| |
| # 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 |
