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

# Copyright 1997 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

# Please email any bugs, comments, and/or additions to this file to:
# bug-gdb@prep.ai.mit.edu

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

if $tracelevel then {
	strace $tracelevel
}

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

global exec_output
set prms_id 0
set bug_id 0

set testfile "mn10200"
set srcfile ${srcdir}/${subdir}/${testfile}.s
set binfile ${objdir}/${subdir}/${testfile}
if  { [gdb_compile "${srcfile}" "${binfile}" executable ""] != "" } {
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}

proc add_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/12i add_tests\n"
    gdb_expect {
	-re "
.*add	d1,d2.*
.*add	d2,a3.*
.*add	a2,d1.*
.*add	a3,a2.*
.*add	16,d1.*
.*add	256,d2.*
.*add	131071,d3.*
.*add	16,a1.*
.*add	256,a2.*
.*add	131071,a3.*
.*addc	d1,d2.*
.*addnf	16,a2.*
.*$gdb_prompt $" { pass "add tests" }
	-re "$gdb_prompt $" { fail "add tests" }
	timeout { fail "(timeout) add tests" }
    }
}

proc bcc_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/15i bCC_tests\n"
    gdb_expect {
	-re "
.*beq	0x\[0-9a-f]+ <bCC_tests>.*
.*bne	0x\[0-9a-f]+ <bCC_tests>.*
.*bgt	0x\[0-9a-f]+ <bCC_tests>.*
.*bge	0x\[0-9a-f]+ <bCC_tests>.*
.*ble	0x\[0-9a-f]+ <bCC_tests>.*
.*blt	0x\[0-9a-f]+ <bCC_tests>.*
.*bhi	0x\[0-9a-f]+ <bCC_tests>.*
.*bcc	0x\[0-9a-f]+ <bCC_tests>.*
.*bls	0x\[0-9a-f]+ <bCC_tests>.*
.*bcs	0x\[0-9a-f]+ <bCC_tests>.*
.*bvc	0x\[0-9a-f]+ <bCC_tests>.*
.*bvs	0x\[0-9a-f]+ <bCC_tests>.*
.*bnc	0x\[0-9a-f]+ <bCC_tests>.*
.*bns	0x\[0-9a-f]+ <bCC_tests>.*
.*bra	0x\[0-9a-f]+ <bCC_tests>.*
.*$gdb_prompt $" { pass "bCC tests" }
	-re "$gdb_prompt $" { fail "bCC tests" }
	timeout { fail "(timeout) bCC tests" }
    }
}

proc bccx_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/14i bCCx_tests\n"
    gdb_expect {
	-re "
.*beqx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bnex	0x\[0-9a-f]+ <bCCx_tests>.*
.*bgtx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bgex	0x\[0-9a-f]+ <bCCx_tests>.*
.*blex	0x\[0-9a-f]+ <bCCx_tests>.*
.*bltx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bhix	0x\[0-9a-f]+ <bCCx_tests>.*
.*bccx	0x\[0-9a-f]+ <bCCx_tests>.*
.*blsx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bcsx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bvcx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bvsx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bncx	0x\[0-9a-f]+ <bCCx_tests>.*
.*bnsx	0x\[0-9a-f]+ <bCCx_tests>.*
.*$gdb_prompt $" { pass "bCCx tests" }
	-re "$gdb_prompt $" { fail "bCCx tests" }
	timeout { fail "(timeout) bCCx tests" }
    }
}

proc bit_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/4 bit_tests\n"
    gdb_expect {
	-re "
.*btst	64,d1.*
.*btst	8192,d2.*
.*bset	d1,\\(a2\\).*
.*bclr	d1,\\(a2\\).*
.*$gdb_prompt $" { pass "bit tests" }
	-re "$gdb_prompt $" { fail "bit tests" }
	timeout { fail "(timeout) bit tests" }
    }
}

proc cmp_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/9i cmp_tests\n"
    gdb_expect {
	-re "
.*cmp	d1,d2.*
.*cmp	d2,a3.*
.*cmp	a3,d3.*
.*cmp	a3,a2.*
.*cmp	16,d3.*
.*cmp	256,d2.*
.*cmp	131071,d1.*
.*cmp	256,a2.*
.*cmp	131071,a1.*
.*$gdb_prompt $" { pass "cmp tests" }
	-re "$gdb_prompt $" { fail "cmp tests" }
	timeout { fail "(timeout) cmp tests" }
    }
}

proc extend_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/5i extend_tests\n"
    gdb_expect {
	-re "
.*ext	d1.*
.*extx	d2.*
.*extxu	d3.*
.*extxb	d2.*
.*extxbu	d1.*
.*$gdb_prompt $" { pass "extend tests" }
	-re "$gdb_prompt $" { fail "extend tests" }
	timeout { fail "(timeout) extend tests" }
    }
}

proc logical_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/11i logical_tests\n"
    gdb_expect {
	-re "
.*and	d1,d2.*
.*and	127,d2.*
.*and	32767,d3.*
.*and	32767,psw.*
.*or	d1,d2.*
.*or	127,d2.*
.*or	32767,d3.*
.*or	32767,psw.*
.*xor	d1,d2.*
.*xor	32767,d3.*
.*not	d3.*
.*$gdb_prompt $" { pass "logical tests" }
	-re "$gdb_prompt $" { fail "logical tests" }
	timeout { fail "(timeout) logical tests" }
    }
}

proc mov_tests_1 { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/12i mov_tests_1\n"
    gdb_expect {
	-re "
.*mov	d1,a2.*
.*mov	a2,d1.*
.*mov	d1,d2.*
.*mov	a2,a1.*
.*mov	psw,d3.*
.*mov	d2,psw.*
.*mov	mdr,d1.*
.*mov	d2,mdr.*
.*mov	\\(a2\\),d1.*
.*mov	\\(8,a2\\),d1.*
.*mov	\\(256,a2\\),d1.*
.*mov	\\(131071,a2\\),d1.*
.*$gdb_prompt $" { pass "mov1 tests" }
	-re "$gdb_prompt $" { fail "mov1 tests" }
	timeout { fail "(timeout) mov1 tests" }
    }
}

proc mov_tests_2 { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/9 mov_tests_2\n"
    gdb_expect {
	-re "
.*mov	\\(d1,a1\\),d2.*
.*mov	\\(0x8000.*\\),d1.*
.*mov	\\(0x1ffff.*\\),d1.*
.*mov	\\(8,a2\\),a1.*
.*mov	\\(256,a2\\),a1.*
.*mov	\\(131071,a2\\),a1.*
.*mov	\\(d1,a1\\),a2.*
.*mov	\\(0x8000.*\\),a1.*
.*mov	\\(0x1ffff.*\\),a1.*
.*$gdb_prompt $" { pass "mov2 tests" }
	-re "$gdb_prompt $" { fail "mov2 tests" }
	timeout { fail "(timeout) mov2 tests" }
    }
}

proc mov_tests_3 { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/10 mov_tests_3\n"
    gdb_expect {
	-re "
.*mov	d1,\\(a2\\).*
.*mov	d1,\\(32,a2\\).*
.*mov	d1,\\(256,a2\\).*
.*mov	d1,\\(131071,a2\\).*
.*mov	d1,\\(d2,a2\\).*
.*mov	d1,\\(0x80.*\\).*
.*mov	d1,\\(0x1ffff.*\\).*
.*mov	a1,\\(32,a2\\).*
.*mov	a1,\\(256,a2\\).*
.*mov	a1,\\(131071,a2\\).*
.*$gdb_prompt $" { pass "mov3 tests" }
	-re "$gdb_prompt $" { fail "mov3 tests" }
	timeout { fail "(timeout) mov3 tests" }
    }
}

proc mov_tests_4 { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/8 mov_tests_4\n"
    gdb_expect {
	-re "
.*mov	a1,\\(d2,a2\\).*
.*mov	a1,\\(0x80.*\\).*
.*mov	a1,\\(0x1ffff.*\\).*
.*mov	8,d1.*
.*mov	256,d1.*
.*mov	131071,d1.*
.*mov	256,a1.*
.*mov	131071,a1.*
.*$gdb_prompt $" { pass "mov4 tests" }
	-re "$gdb_prompt $" { fail "mov4 tests" }
	timeout { fail "(timeout) mov4 tests" }
    }
}

proc movb_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/12 movb_tests\n"
    gdb_expect {
	-re "
.*movb	\\(8,a2\\),d1.*
.*movb	\\(256,a2\\),d1.*
.*movb	\\(131071,a2\\),d1.*
.*movb	\\(d2,a2\\),d3.*
.*movb	\\(0x1ffff.*\\),d2.*
.*movb	d1,\\(a2\\).*
.*movb	d1,\\(8,a2\\).*
.*movb	d1,\\(256,a2\\).*
.*movb	d1,\\(131071,a2\\).*
.*movb	d1,\\(d2,a2\\).*
.*movb	d1,\\(0x100.*\\).*
.*movb	d1,\\(0x1ffff.*\\).*
.*$gdb_prompt $" { pass "movb tests" }
	-re "$gdb_prompt $" { fail "movb tests" }
	timeout { fail "(timeout) movb tests" }
    }
}

proc movbu_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/7 movbu_tests\n"
    gdb_expect {
	-re "
.*movbu	\\(a2\\),d1.*
.*movbu	\\(8,a2\\),d1.*
.*movbu	\\(256,a2\\),d1.*
.*movbu	\\(131071,a2\\),d1.*
.*movbu	\\(d1,a1\\),d2.*
.*movbu	\\(0x8000.*\\),d1.*
.*movbu	\\(0x1ffff.*\\),d1.*
.*$gdb_prompt $" { pass "movbu tests" }
	-re "$gdb_prompt $" { fail "movbu tests" }
	timeout { fail "(timeout) movbu tests" }
    }
}

proc movx_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/6 movx_tests\n"
    gdb_expect {
	-re "
.*movx	\\(8,a2\\),d1.*
.*movx	\\(256,a2\\),d1.*
.*movx	\\(131071,a2\\),d1.*
.*movx	d1,\\(8,a2\\).*
.*movx	d1,\\(256,a2\\).*
.*movx	d1,\\(131071,a2\\).*
.*$gdb_prompt $" { pass "movx tests" }
	-re "$gdb_prompt $" { fail "movx tests" }
	timeout { fail "(timeout) movx tests" }
    }
}

proc muldiv_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/3 muldiv_tests\n"
    gdb_expect {
	-re "
.*mul	d1,d2.*
.*mulu	d2,d3.*
.*divu	d3,d2.*
.*$gdb_prompt $" { pass "muldiv tests" }
	-re "$gdb_prompt $" { fail "muldiv tests" }
	timeout { fail "(timeout) muldiv tests" }
    }
}

proc misc_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/9 misc_tests\n"
    gdb_expect {
	-re "
.*jmp	0x\[0-9a-f]+ <main>.*
.*jmp	0x\[0-9a-f]+ <start>.*
.*jmp	\\(a2\\).*
.*jsr	0x\[0-9a-f]+ <main>.*
.*jsr	0x\[0-9a-f]+ <start>.*
.*jsr	\\(a2\\).*
.*rts.*
.*rti.*
.*nop.*
.*$gdb_prompt $" { pass "misc tests" }
	-re "$gdb_prompt $" { fail "misc tests" }
	timeout { fail "(timeout) misc tests" }
    }
}

proc shift_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/4i shift_tests\n"
    gdb_expect {
	-re "
.*asr	d2.*
.*lsr	d3.*
.*ror	d1.*
.*rol	d2.*
.*$gdb_prompt $" { pass "shift tests" }
	-re "$gdb_prompt $" { fail "shift tests" }
	timeout { fail "(timeout) shift tests" }
    }
}

proc sub_tests { } {
    global gdb_prompt
    global hex
    global decimal

    send_gdb "x/9i sub_tests\n"
    gdb_expect {
	-re "
.*sub	d1,d2.*
.*sub	d2,a3.*
.*sub	a3,d3.*
.*sub	a3,a2.*
.*sub	32767,d2.*
.*sub	131071,d2.*
.*sub	32767,a2.*
.*sub	131071,a2.*
.*subc	d1,d2.*
.*$gdb_prompt $" { pass "sub tests" }
	-re "$gdb_prompt $" { fail "sub tests" }
	timeout { fail "(timeout) sub tests" }
    }
}

# Start with a fresh gdb.

gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load $binfile

add_tests
bcc_tests
bccx_tests
bit_tests
cmp_tests
extend_tests
logical_tests
mov_tests_1
mov_tests_2
mov_tests_3
mov_tests_4
movb_tests
movbu_tests
movx_tests
muldiv_tests
misc_tests
shift_tests
sub_tests