path: root/gdb/testsuite/gdb.disasm/am33.exp

# Copyright 1997-1998, 2007-2012 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# This file was written by Jeff Law. (law@cygnus.com)

if ![istarget "mn10300*-*-*"] {
    verbose "Tests ignored for all but mn10300 based targets."
    return
}

global exec_output

set testfile "am33"
set srcfile ${srcdir}/${subdir}/${testfile}.s
set binfile ${objdir}/${subdir}/${testfile}
if  { [gdb_compile "${srcfile}" "${binfile}" object ""] != "" } {
     untested am33.exp
     return -1
}

proc call_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/8i call_tests\n"
    gdb_expect {
	-re "
.*call	.*,.a2,a3,exreg0.,9.*
.*call	.*,.a2,a3,exreg1.,9.*
.*call	.*,.a2,a3,exother.,9.*
.*call	.*,.d2,d3,a2,a3,other,exreg0,exreg1,exother.,9.*
.*call	.*,.a2,a3,exreg0.,9.*
.*call	.*,.a2,a3,exreg1.,9.*
.*call	.*,.a2,a3,exother.,9.*
.*call	.*,.d2,d3,a2,a3,other,exreg0,exreg1,exother.,9.*
.*$gdb_prompt $" { pass "call tests" }
	-re "$gdb_prompt $" { fail "call tests" }
	timeout { fail "(timeout) call tests" }
    }
}

proc movm_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/16i movm_tests\n"
    gdb_expect {
	-re "
.*movm	\\(sp\\),.a2,a3,exreg0.*
.*movm	\\(sp\\),.a2,a3,exreg1.*
.*movm	\\(sp\\),.a2,a3,exother.*
.*movm	\\(sp\\),.d2,d3,a2,a3,other,exreg0,exreg1,exother.*
.*movm	.a2,a3,exreg0.,\\(sp\\).*
.*movm	.a2,a3,exreg1.,\\(sp\\).*
.*movm	.a2,a3,exother.,\\(sp\\).*
.*movm	.d2,d3,a2,a3,other,exreg0,exreg1,exother.,\\(sp\\).*
.*movm	\\(usp\\),.a2,a3,exreg0.*
.*movm	\\(usp\\),.a2,a3,exreg1.*
.*movm	\\(usp\\),.a2,a3,exother.*
.*movm	\\(usp\\),.d2,d3,a2,a3,other,exreg0,exreg1,exother.*
.*movm	.a2,a3,exreg0.,\\(usp\\).*
.*movm	.a2,a3,exreg1.,\\(usp\\).*
.*movm	.a2,a3,exother.,\\(usp\\).*
.*movm	.d2,d3,a2,a3,other,exreg0,exreg1,exother.,\\(usp\\).*
.*$gdb_prompt $" { pass "movm tests" }
	-re "$gdb_prompt $" { fail "movm tests" }
	timeout { fail "(timeout) movm tests" }
    }
}

proc misc_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/11i misc_tests\n"
    gdb_expect {
	-re "
.*syscall	4.*
.*mcst9	d0.*
.*mcst48	d1.*
.*getchx	d0.*
.*getclx	d1.*
.*clr	a1.*
.*sat16	a1,a0.*
.*mcste	r7,r6.*
.*swap	r5,r4.*
.*swaph	r3,r2.*
.*swhw	r1,r0.*
.*$gdb_prompt $" { pass "misc tests" }
	-re "$gdb_prompt $" { fail "misc tests" }
	timeout { fail "(timeout) misc tests" }
    }
}

proc mov_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/45i mov_tests\n"
    gdb_expect {
	-re "
.*mov	r0,r1.*
.*mov	sp,r1.*
.*mov	r1,xr2.*
.*mov	\\(r1\\),r2.*
.*mov	r3,\\(r4\\).*
.*mov	\\(sp\\),r5.*
.*mov	r6,\\(sp\\).*
.*mov	16,r1.*
.*mov	16,xr1.*
.*mov	\\(16,r1\\),r2.*
.*mov	r2,\\(16,r1\\).*
.*mov	\\(16,sp\\),r2.*
.*mov	r2,\\(16,sp\\).*
.*mov	2096895,r2.*
.*mov	2096895,xr2.*
.*mov	\\(2096895,r1\\),r2.*
.*mov	r2,\\(2096895,r1\\).*
.*mov	\\(2096895,sp\\),r2.*
.*mov	r2,\\(2096895,sp\\).*
.*mov	\\(0x1ffeff\\),r2.*
.*mov	r2,\\(0x1ffeff\\).*
.*mov	2147417596,r2.*
.*mov	2147417596,xr2.*
.*mov	\\(2147417596,r1\\),r2.*
.*mov	r2,\\(2147417596,r1\\).*
.*mov	\\(2147417596,sp\\),r2.*
.*mov	r2,\\(2147417596,sp\\).*
.*mov	\\(0x7ffefdfc\\),r2.*
.*mov	r2,\\(0x7ffefdfc\\).*
.*movu	16,r1.*
.*movu	2096895,r2.*
.*movu	2147417596,r2.*
.*mov	usp,a0.*
.*mov	ssp,a1.*
.*mov	msp,a2.*
.*mov	pc,a3.*
.*mov	a0,usp.*
.*mov	a1,ssp.*
.*mov	a2,msp.*
.*mov	epsw,d0.*
.*mov	d1,epsw.*
.*mov	a0,r1.*
.*mov	d2,r3.*
.*mov	r5,a1.*
.*mov	r7,d3.*
.*$gdb_prompt $" { pass "mov tests" }
	-re "$gdb_prompt $" { fail "mov tests" }
	timeout { fail "(timeout) mov tests" }
    }
}

proc ext_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/5i ext_tests\n"
    gdb_expect {
	-re "
.*ext	r2.*
.*extb	r3,r4.*
.*extbu	r4,r5.*
.*exth	r6,r7.*
.*exthu	r7,a0.*
.*$gdb_prompt $" { pass "ext tests" }
	-re "$gdb_prompt $" { fail "ext tests" }
	timeout { fail "(timeout) ext tests" }
    }
}

proc add_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/11i add_tests\n"
    gdb_expect {
	-re "
.*add	a2,a3.*
.*add	16,r1.*
.*add	2096895,r2.*
.*add	2147417596,r2.*
.*add	r1,r2,r3.*
.*addc	d0,d1.*
.*addc	16,r1.*
.*addc	2096895,r2.*
.*addc	2147417596,r2.*
.*inc	d1.*
.*inc4	d0.*
.*$gdb_prompt $" { pass "add tests" }
	-re "$gdb_prompt $" { fail "add tests" }
	timeout { fail "(timeout) add tests" }
    }
}

proc sub_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/8i sub_tests\n"
    gdb_expect {
	-re "
.*sub	d2,d3.*
.*sub	16,r1.*
.*sub	2096895,r2.*
.*sub	2147417596,r2.*
.*subc	d3,d2.*
.*subc	16,r1.*
.*subc	2096895,r2.*
.*subc	2147417596,r2.*
.*$gdb_prompt $" { pass "sub tests" }
	-re "$gdb_prompt $" { fail "sub tests" }
	timeout { fail "(timeout) sub tests" }
    }
}

proc cmp_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/4i cmp_tests\n"
    gdb_expect {
	-re "
.*cmp	a3,a2.*
.*cmp	16,r1.*
.*cmp	2096895,r2.*
.*cmp	2147417596,r2.*
.*$gdb_prompt $" { pass "cmp tests" }
	-re "$gdb_prompt $" { fail "cmp tests" }
	timeout { fail "(timeout) cmp tests" }
    }
}

proc logical_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/15i logical_tests\n"
    gdb_expect {
	-re "
.*and	r0,r1.*
.*or	r2,r3.*
.*xor	r4,r5.*
.*not	r6.*
.*and	16,r1.*
.*or	16,r1.*
.*xor	16,r1.*
.*and	2096895,r2.*
.*or	2096895,r2.*
.*xor	2096895,r2.*
.*and	2147417596,r2.*
.*or	2147417596,r2.*
.*xor	2147417596,r2.*
.*and	131072,epsw.*
.*or	65535,epsw.*
.*$gdb_prompt $" { pass "logical tests" }
	-re "$gdb_prompt $" { fail "logical tests" }
	timeout { fail "(timeout) logical tests" }
    }
}

proc shift_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/15i shift_tests\n"
    gdb_expect {
	-re "
.*asr	r7,a0.*
.*lsr	a1,a2.*
.*asl	a3,d0.*
.*asl2	d1.*
.*ror	d2.*
.*rol	d3.*
.*asr	16,r1.*
.*lsr	16,r1.*
.*asl	16,r1.*
.*asr	2096895,r2.*
.*lsr	2096895,r2.*
.*asl	2096895,r2.*
.*asr	2147417596,r2.*
.*lsr	2147417596,r2.*
.*asl	2147417596,r2.*
.*$gdb_prompt $" { pass "shift tests" }
	-re "$gdb_prompt $" { fail "shift tests" }
	timeout { fail "(timeout) shift tests" }
    }
}

proc muldiv_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/16i muldiv_tests\n"
    gdb_expect {
	-re "
.*mul	r1,r2.*
.*mulu	r3,r4.*
.*mul	16,r1.*
.*mulu	16,r1.*
.*mul	2096895,r2.*
.*mulu	2096895,r2.*
.*mul	2147417596,r2.*
.*mulu	2147417596,r2.*
.*div	r5,r6.*
.*divu	r7,a0.*
.*dmulh	d1,d0.*
.*dmulhu	a3,a2.*
.*dmulh	2147417596,r2.*
.*dmulhu	2147417596,r2.*
.*mul	r1,r2,r3,r4.*
.*mulu	r1,r2,r3,r4.*
.*$gdb_prompt $" { pass "muldiv tests" }
	-re "$gdb_prompt $" { fail "muldiv tests" }
	timeout { fail "(timeout) muldiv tests" }
    }
}

proc movbu_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/20i movbu_tests\n"
    gdb_expect {
	-re "
.*movbu	\\(r5\\),r6.*
.*movbu	r7,\\(a0\\).*
.*movbu	\\(sp\\),r7.*
.*movbu	a0,\\(sp\\).*
.*movbu	\\(16,r1\\),r2.*
.*movbu	r2,\\(16,r1\\).*
.*movbu	\\(16,sp\\),r2.*
.*movbu	r2,\\(16,sp\\).*
.*movbu	\\(2096895,r1\\),r2.*
.*movbu	r2,\\(2096895,r1\\).*
.*movbu	\\(2096895,sp\\),r2.*
.*movbu	r2,\\(2096895,sp\\).*
.*movbu	\\(0x1ffeff\\),r2.*
.*movbu	r2,\\(0x1ffeff\\).*
.*movbu	\\(2147417596,r1\\),r2.*
.*movbu	r2,\\(2147417596,r1\\).*
.*movbu	\\(2147417596,sp\\),r2.*
.*movbu	r2,\\(2147417596,sp\\).*
.*movbu	\\(0x7ffefdfc\\),r2.*
.*movbu	r2,\\(0x7ffefdfc\\).*
.*$gdb_prompt $" { pass "movbu tests" }
	-re "$gdb_prompt $" { fail "movbu tests" }
	timeout { fail "(timeout) movbu tests" }
    }
}

proc movhu_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/20i movhu_tests\n"
    gdb_expect {
	-re "
.*movhu	\\(a1\\),a2.*
.*movhu	a3,\\(d0\\).*
.*movhu	\\(sp\\),a1.*
.*movhu	a2,\\(sp\\).*
.*movhu	\\(16,r1\\),r2.*
.*movhu	r2,\\(16,r1\\).*
.*movhu	\\(16,sp\\),r2.*
.*movhu	r2,\\(16,sp\\).*
.*movhu	\\(2096895,r1\\),r2.*
.*movhu	r2,\\(2096895,r1\\).*
.*movhu	\\(2096895,sp\\),r2.*
.*movhu	r2,\\(2096895,sp\\).*
.*movhu	\\(0x1ffeff\\),r2.*
.*movhu	r2,\\(0x1ffeff\\).*
.*movhu	\\(2147417596,r1\\),r2.*
.*movhu	r2,\\(2147417596,r1\\).*
.*movhu	\\(2147417596,sp\\),r2.*
.*movhu	r2,\\(2147417596,sp\\).*
.*movhu	\\(0x7ffefdfc\\),r2.*
.*movhu	r2,\\(0x7ffefdfc\\).*
.*$gdb_prompt $" { pass "movhu tests" }
	-re "$gdb_prompt $" { fail "movhu tests" }
	timeout { fail "(timeout) movhu tests" }
    }
}

proc mac_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/28i mac_tests\n"
    gdb_expect {
	-re "
.*mac	r1,r2.*
.*macu	r3,r4.*
.*macb	r5,r6.*
.*macbu	r7,a0.*
.*mach	a1,a2.*
.*machu	a3,d0.*
.*dmach	d1,d2.*
.*dmachu	d3,d2.*
.*mac	16,r1.*
.*macu	16,r1.*
.*macb	16,r1.*
.*macbu	16,r1.*
.*mach	16,r1.*
.*machu	16,r1.*
.*mac	2096895,r2.*
.*macu	2096895,r2.*
.*macb	2096895,r2.*
.*macbu	2096895,r2.*
.*mach	2096895,r2.*
.*machu	2096895,r2.*
.*mac	2147417596,r2.*
.*macu	2147417596,r2.*
.*macb	2147417596,r2.*
.*macbu	2147417596,r2.*
.*mach	2147417596,r2.*
.*machu	2147417596,r2.*
.*dmach	2147417596,r2.*
.*dmachu	2147417596,r2.*
.*$gdb_prompt $" { pass "mac tests" }
	-re "$gdb_prompt $" { fail "mac tests" }
	timeout { fail "(timeout) mac tests" }
    }
}

proc bit_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/4i bit_tests\n"
    gdb_expect {
	-re "
.*bsch	r1,r2.*
.*btst	16,r1.*
.*btst	2096895,r2.*
.*btst	2147417596,r2.*
.*$gdb_prompt $" { pass "bit tests" }
	-re "$gdb_prompt $" { fail "bit tests" }
	timeout { fail "(timeout) bit tests" }
    }
}

proc dsp_add_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/28i dsp_add_tests\n"
    gdb_expect {
	-re "
.*add_add	r4,r1,r2,r3.*
.*add_add	r4,r1,2,r3.*
.*add_sub	r4,r1,r2,r3.*
.*add_sub	r4,r1,2,r3.*
.*add_cmp	r4,r1,r2,r3.*
.*add_cmp	r4,r1,2,r3.*
.*add_mov	r4,r1,r2,r3.*
.*add_mov	r4,r1,2,r3.*
.*add_asr	r4,r1,r2,r3.*
.*add_asr	r4,r1,2,r3.*
.*add_lsr	r4,r1,r2,r3.*
.*add_lsr	r4,r1,2,r3.*
.*add_asl	r4,r1,r2,r3.*
.*add_asl	r4,r1,2,r3.*
.*add_add	4,r1,r2,r3.*
.*add_add	4,r1,2,r3.*
.*add_sub	4,r1,r2,r3.*
.*add_sub	4,r1,2,r3.*
.*add_cmp	4,r1,r2,r3.*
.*add_cmp	4,r1,2,r3.*
.*add_mov	4,r1,r2,r3.*
.*add_mov	4,r1,2,r3.*
.*add_asr	4,r1,r2,r3.*
.*add_asr	4,r1,2,r3.*
.*add_lsr	4,r1,r2,r3.*
.*add_lsr	4,r1,2,r3.*
.*add_asl	4,r1,r2,r3.*
.*add_asl	4,r1,2,r3.*
.*$gdb_prompt $" { pass "dsp_add tests" }
	-re "$gdb_prompt $" { fail "dsp_add tests" }
	timeout { fail "(timeout) dsp_add tests" }
    }
}

proc dsp_cmp_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/24i dsp_cmp_tests\n"
    gdb_expect {
	-re "
.*cmp_add	r4,r1,r2,r3.*
.*cmp_add	r4,r1,2,r3.*
.*cmp_sub	r4,r1,r2,r3.*
.*cmp_sub	r4,r1,2,r3.*
.*cmp_mov	r4,r1,r2,r3.*
.*cmp_mov	r4,r1,2,r3.*
.*cmp_asr	r4,r1,r2,r3.*
.*cmp_asr	r4,r1,2,r3.*
.*cmp_lsr	r4,r1,r2,r3.*
.*cmp_lsr	r4,r1,2,r3.*
.*cmp_asl	r4,r1,r2,r3.*
.*cmp_asl	r4,r1,2,r3.*
.*cmp_add	4,r1,r2,r3.*
.*cmp_add	4,r1,2,r3.*
.*cmp_sub	4,r1,r2,r3.*
.*cmp_sub	4,r1,2,r3.*
.*cmp_mov	4,r1,r2,r3.*
.*cmp_mov	4,r1,2,r3.*
.*cmp_asr	4,r1,r2,r3.*
.*cmp_asr	4,r1,2,r3.*
.*cmp_lsr	4,r1,r2,r3.*
.*cmp_lsr	4,r1,2,r3.*
.*cmp_asl	4,r1,r2,r3.*
.*cmp_asl	4,r1,2,r3.*
.*$gdb_prompt $" { pass "dsp_cmp tests" }
	-re "$gdb_prompt $" { fail "dsp_cmp tests" }
	timeout { fail "(timeout) dsp_cmp tests" }
    }
}

proc dsp_sub_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/28i dsp_sub_tests\n"
    gdb_expect {
	-re "
.*sub_add	r4,r1,r2,r3.*
.*sub_add	r4,r1,2,r3.*
.*sub_sub	r4,r1,r2,r3.*
.*sub_sub	r4,r1,2,r3.*
.*sub_cmp	r4,r1,r2,r3.*
.*sub_cmp	r4,r1,2,r3.*
.*sub_mov	r4,r1,r2,r3.*
.*sub_mov	r4,r1,2,r3.*
.*sub_asr	r4,r1,r2,r3.*
.*sub_asr	r4,r1,2,r3.*
.*sub_lsr	r4,r1,r2,r3.*
.*sub_lsr	r4,r1,2,r3.*
.*sub_asl	r4,r1,r2,r3.*
.*sub_asl	r4,r1,2,r3.*
.*sub_add	4,r1,r2,r3.*
.*sub_add	4,r1,2,r3.*
.*sub_sub	4,r1,r2,r3.*
.*sub_sub	4,r1,2,r3.*
.*sub_cmp	4,r1,r2,r3.*
.*sub_cmp	4,r1,2,r3.*
.*sub_mov	4,r1,r2,r3.*
.*sub_mov	4,r1,2,r3.*
.*sub_asr	4,r1,r2,r3.*
.*sub_asr	4,r1,2,r3.*
.*sub_lsr	4,r1,r2,r3.*
.*sub_lsr	4,r1,2,r3.*
.*sub_asl	4,r1,r2,r3.*
.*sub_asl	4,r1,2,r3.*
.*$gdb_prompt $" { pass "dsp_sub tests" }
	-re "$gdb_prompt $" { fail "dsp_sub tests" }
	timeout { fail "(timeout) dsp_sub tests" }
    }
}

proc dsp_mov_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/28i dsp_mov_tests\n"
    gdb_expect {
	-re "
.*mov_add	r4,r1,r2,r3.*
.*mov_add	r4,r1,2,r3.*
.*mov_sub	r4,r1,r2,r3.*
.*mov_sub	r4,r1,2,r3.*
.*mov_cmp	r4,r1,r2,r3.*
.*mov_cmp	r4,r1,2,r3.*
.*mov_mov	r4,r1,r2,r3.*
.*mov_mov	r4,r1,2,r3.*
.*mov_asr	r4,r1,r2,r3.*
.*mov_asr	r4,r1,2,r3.*
.*mov_lsr	r4,r1,r2,r3.*
.*mov_lsr	r4,r1,2,r3.*
.*mov_asl	r4,r1,r2,r3.*
.*mov_asl	r4,r1,2,r3.*
.*mov_add	4,r1,r2,r3.*
.*mov_add	4,r1,2,r3.*
.*mov_sub	4,r1,r2,r3.*
.*mov_sub	4,r1,2,r3.*
.*mov_cmp	4,r1,r2,r3.*
.*mov_cmp	4,r1,2,r3.*
.*mov_mov	4,r1,r2,r3.*
.*mov_mov	4,r1,2,r3.*
.*mov_asr	4,r1,r2,r3.*
.*mov_asr	4,r1,2,r3.*
.*mov_lsr	4,r1,r2,r3.*
.*mov_lsr	4,r1,2,r3.*
.*mov_asl	4,r1,r2,r3.*
.*mov_asl	4,r1,2,r3.*
.*$gdb_prompt $" { pass "dsp_mov tests" }
	-re "$gdb_prompt $" { fail "dsp_mov tests" }
	timeout { fail "(timeout) dsp_mov tests" }
    }
}

proc dsp_logical_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/42i dsp_logical_tests\n"
    gdb_expect {
	-re "
.*and_add	r4,r1,r2,r3.*
.*and_add	r4,r1,2,r3.*
.*and_sub	r4,r1,r2,r3.*
.*and_sub	r4,r1,2,r3.*
.*and_cmp	r4,r1,r2,r3.*
.*and_cmp	r4,r1,2,r3.*
.*and_mov	r4,r1,r2,r3.*
.*and_mov	r4,r1,2,r3.*
.*and_asr	r4,r1,r2,r3.*
.*and_asr	r4,r1,2,r3.*
.*and_lsr	r4,r1,r2,r3.*
.*and_lsr	r4,r1,2,r3.*
.*and_asl	r4,r1,r2,r3.*
.*and_asl	r4,r1,2,r3.*
.*xor_add	r4,r1,r2,r3.*
.*xor_add	r4,r1,2,r3.*
.*xor_sub	r4,r1,r2,r3.*
.*xor_sub	r4,r1,2,r3.*
.*xor_cmp	r4,r1,r2,r3.*
.*xor_cmp	r4,r1,2,r3.*
.*xor_mov	r4,r1,r2,r3.*
.*xor_mov	r4,r1,2,r3.*
.*xor_asr	r4,r1,r2,r3.*
.*xor_asr	r4,r1,2,r3.*
.*xor_lsr	r4,r1,r2,r3.*
.*xor_lsr	r4,r1,2,r3.*
.*xor_asl	r4,r1,r2,r3.*
.*xor_asl	r4,r1,2,r3.*
.*or_add	r4,r1,r2,r3.*
.*or_add	r4,r1,2,r3.*
.*or_sub	r4,r1,r2,r3.*
.*or_sub	r4,r1,2,r3.*
.*or_cmp	r4,r1,r2,r3.*
.*or_cmp	r4,r1,2,r3.*
.*or_mov	r4,r1,r2,r3.*
.*or_mov	r4,r1,2,r3.*
.*or_asr	r4,r1,r2,r3.*
.*or_asr	r4,r1,2,r3.*
.*or_lsr	r4,r1,r2,r3.*
.*or_lsr	r4,r1,2,r3.*
.*or_asl	r4,r1,r2,r3.*
.*or_asl	r4,r1,2,r3.*
.*$gdb_prompt $" { pass "dsp_logical tests" }
	-re "$gdb_prompt $" { fail "dsp_logical tests" }
	timeout { fail "(timeout) dsp_logical tests" }
    }
}

proc dsp_misc_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/42i dsp_misc_tests\n"
    gdb_expect {
	-re "
.*dmach_add	r4,r1,r2,r3.*
.*dmach_add	r4,r1,2,r3.*
.*dmach_sub	r4,r1,r2,r3.*
.*dmach_sub	r4,r1,2,r3.*
.*dmach_cmp	r4,r1,r2,r3.*
.*dmach_cmp	r4,r1,2,r3.*
.*dmach_mov	r4,r1,r2,r3.*
.*dmach_mov	r4,r1,2,r3.*
.*dmach_asr	r4,r1,r2,r3.*
.*dmach_asr	r4,r1,2,r3.*
.*dmach_lsr	r4,r1,r2,r3.*
.*dmach_lsr	r4,r1,2,r3.*
.*dmach_asl	r4,r1,r2,r3.*
.*dmach_asl	r4,r1,2,r3.*
.*swhw_add	r4,r1,r2,r3.*
.*swhw_add	r4,r1,2,r3.*
.*swhw_sub	r4,r1,r2,r3.*
.*swhw_sub	r4,r1,2,r3.*
.*swhw_cmp	r4,r1,r2,r3.*
.*swhw_cmp	r4,r1,2,r3.*
.*swhw_mov	r4,r1,r2,r3.*
.*swhw_mov	r4,r1,2,r3.*
.*swhw_asr	r4,r1,r2,r3.*
.*swhw_asr	r4,r1,2,r3.*
.*swhw_lsr	r4,r1,r2,r3.*
.*swhw_lsr	r4,r1,2,r3.*
.*swhw_asl	r4,r1,r2,r3.*
.*swhw_asl	r4,r1,2,r3.*
.*sat16_add	r4,r1,r2,r3.*
.*sat16_add	r4,r1,2,r3.*
.*sat16_sub	r4,r1,r2,r3.*
.*sat16_sub	r4,r1,2,r3.*
.*sat16_cmp	r4,r1,r2,r3.*
.*sat16_cmp	r4,r1,2,r3.*
.*sat16_mov	r4,r1,r2,r3.*
.*sat16_mov	r4,r1,2,r3.*
.*sat16_asr	r4,r1,r2,r3.*
.*sat16_asr	r4,r1,2,r3.*
.*sat16_lsr	r4,r1,r2,r3.*
.*sat16_lsr	r4,r1,2,r3.*
.*sat16_asl	r4,r1,r2,r3.*
.*sat16_asl	r4,r1,2,r3.*
.*$gdb_prompt $" { pass "dsp_misc tests" }
	-re "$gdb_prompt $" { fail "dsp_misc tests" }
	timeout { fail "(timeout) dsp_misc tests" }
    }
}

proc autoincrement_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/16i autoincrement_tests\n"
    gdb_expect {
	-re "
.*mov	\\(r1\\+\\),r2.*
.*mov	r3,\\(r4\\+\\).*
.*movhu	\\(r6\\+\\),r7.*
.*movhu	a0,\\(a1\\+\\).*
.*mov	\\(r1\\+,64\\),r2.*
.*mov	r1,\\(r2\\+,64\\).*
.*movhu	\\(r1\\+,64\\),r2.*
.*movhu	r1,\\(r2\\+,64\\).*
.*mov	\\(r1\\+,131055\\),r2.*
.*mov	r1,\\(r2\\+,131055\\).*
.*movhu	\\(r1\\+,131055\\),r2.*
.*movhu	r1,\\(r2\\+,131055\\).*
.*mov	\\(r1\\+,2147417596\\),r2.*
.*mov	r1,\\(r2\\+,2147417596\\).*
.*movhu	\\(r1\\+,2147417596\\),r2.*
.*movhu	r1,\\(r2\\+,2147417596\\).*
.*$gdb_prompt $" { pass "autoincrement tests" }
	-re "$gdb_prompt $" { fail "autoincrement tests" }
	timeout { fail "(timeout) autoincrement tests" }
    }
}

proc dsp_autoincrement_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/11i dsp_autoincrement_tests\n"
    gdb_expect {
	-re "
.*mov_llt	\\(r1\\+,4\\),r2.*
.*mov_lgt	\\(r1\\+,4\\),r2.*
.*mov_lge	\\(r1\\+,4\\),r2.*
.*mov_lle	\\(r1\\+,4\\),r2.*
.*mov_lcs	\\(r1\\+,4\\),r2.*
.*mov_lhi	\\(r1\\+,4\\),r2.*
.*mov_lcc	\\(r1\\+,4\\),r2.*
.*mov_lls	\\(r1\\+,4\\),r2.*
.*mov_leq	\\(r1\\+,4\\),r2.*
.*mov_lne	\\(r1\\+,4\\),r2.*
.*mov_lra	\\(r1\\+,4\\),r2.*
.*$gdb_prompt $" { pass "autoincrement tests" }
	-re "$gdb_prompt $" { fail "autoincrement tests" }
	timeout { fail "(timeout) autoincrement tests" }
    }
}

# Start with a fresh gdb.

gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load $binfile

call_tests
movm_tests
misc_tests
mov_tests
ext_tests
add_tests
sub_tests
cmp_tests
logical_tests
shift_tests
muldiv_tests
movbu_tests
movhu_tests
mac_tests
bit_tests
dsp_add_tests
dsp_cmp_tests
dsp_sub_tests
dsp_mov_tests
dsp_logical_tests
autoincrement_tests
dsp_autoincrement_tests