Subversion Repositories openrisc_2011-10-31

# Copyright 1997, 2007, 2008, 2009, 2010 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 .

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

if $tracelevel then {

        strace $tracelevel

}

if ![istarget "mn10300*-*-*"] {

    verbose "Tests ignored for all but mn10300 based targets."

    return

}

global exec_output

set prms_id 0

set bug_id 0

set testfile "mn10300"

set srcfile ${srcdir}/${subdir}/${testfile}.s

set binfile ${objdir}/${subdir}/${testfile}

if  { [gdb_compile "${srcfile}" "${binfile}" executable ""] != "" } {

     untested mn10300.exp

     return -1

}

proc add_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/14i add_tests\n"

    gdb_expect {

        -re "

.*add   d1,d2.*

.*add   d2,a3.*

.*add   a3,a2.*

.*add   a2,d1.*

.*add   16,d1.*

.*add   256,d2.*

.*add   131071,d3.*

.*add   16,a1.*

.*add   256,a2.*

.*add   131071,a3.*

.*add   16,sp.*

.*add   256,sp.*

.*add   131071,sp.*

.*addc  d1,d2.*

.*$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]+ .*

.*bne   0x\[0-9a-f]+ .*

.*bgt   0x\[0-9a-f]+ .*

.*bge   0x\[0-9a-f]+ .*

.*ble   0x\[0-9a-f]+ .*

.*blt   0x\[0-9a-f]+ .*

.*bhi   0x\[0-9a-f]+ .*

.*bcc   0x\[0-9a-f]+ .*

.*bls   0x\[0-9a-f]+ .*

.*bcs   0x\[0-9a-f]+ .*

.*bvc   0x\[0-9a-f]+ .*

.*bvs   0x\[0-9a-f]+ .*

.*bnc   0x\[0-9a-f]+ .*

.*bns   0x\[0-9a-f]+ .*

.*bra   0x\[0-9a-f]+ .*

.*$gdb_prompt $" { pass "bCC tests" }

        -re "$gdb_prompt $" { fail "bCC tests" }

        timeout { fail "(timeout) bCC tests" }

    }

}

proc bit_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/11i bit_tests\n"

    gdb_expect {

        -re "

.*btst  64,d1.*

.*btst  8192,d2.*

.*btst  131071,d3.*

.*btst  64,\\(8,a1\\).*

.*btst  64,\\(0x1ffff\\).*

.*bset  d1,\\(a2\\).*

.*bset  64,\\(8,a1\\).*

.*bset  64,\\(0x1ffff\\).*

.*bclr  d1,\\(a2\\).*

.*bclr  64,\\(8,a1\\).*

.*bclr  64,\\(0x1ffff\\).*

.*$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/10i 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   16,a3.*

.*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.*

.*extb  d2.*

.*extbu d3.*

.*exth  d2.*

.*exthu d1.*

.*$gdb_prompt $" { pass "extend tests" }

        -re "$gdb_prompt $" { fail "extend tests" }

        timeout { fail "(timeout) extend tests" }

    }

}

proc extended_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/13i extended_tests\n"

    gdb_expect {

        -re "

.*putx  d1.*

.*getx  d2.*

.*mulq  d1,d2.*

.*mulq  16,d2.*

.*mulq  256,d3.*

.*mulq  131071,d3.*

.*mulqu d1,d2.*

.*mulqu 16,d2.*

.*mulqu 256,d3.*

.*mulqu 131071,d3.*

.*sat16 d2,d3.*

.*sat24 d3,d2.*

.*bsch  d1,d2.*

.*$gdb_prompt $" { pass "extended tests" }

        -re "$gdb_prompt $" { fail "extended tests" }

        timeout { fail "(timeout) extended tests" }

    }

}

proc logical_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/14i logical_tests\n"

    gdb_expect {

        -re "

.*and   d1,d2.*

.*and   127,d2.*

.*and   32767,d3.*

.*and   131071,d3.*

.*and   32767,psw.*

.*or    d1,d2.*

.*or    127,d2.*

.*or    32767,d3.*

.*or    131071,d3.*

.*or    32767,psw.*

.*xor   d1,d2.*

.*xor   32767,d3.*

.*xor   131071,d3.*

.*not   d3.*

.*$gdb_prompt $" { pass "logical tests" }

        -re "$gdb_prompt $" { fail "logical tests" }

        timeout { fail "(timeout) logical tests" }

    }

}

proc loop_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/12i loop_tests\n"

    gdb_expect {

        -re "

.*leq.*

.*lne.*

.*lgt.*

.*lge.*

.*lle.*

.*llt.*

.*lhi.*

.*lcc.*

.*lls.*

.*lcs.*

.*lra.*

.*setlb.*

.*$gdb_prompt $" { pass "loop tests" }

        -re "$gdb_prompt $" { fail "loop tests" }

        timeout { fail "(timeout) loop tests" }

    }

}

proc mov_tests_1 { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/16i mov_tests_1\n"

    gdb_expect {

        -re "

.*mov   d1,d2.*

.*mov   d1,a2.*

.*mov   a2,d1.*

.*mov   a2,a1.*

.*mov   sp,a2.*

.*mov   a1,sp.*

.*mov   d2,psw.*

.*mov   mdr,d1.*

.*mov   d2,mdr.*

.*mov   \\(a2\\),d1.*

.*mov   \\(8,a2\\),d1.*

.*mov   \\(256,a2\\),d1.*

.*mov   \\(131071,a2\\),d1.*

.*mov   \\(8,sp\\),d1.*

.*mov   \\(256,sp\\),d1.*

.*mov   psw,d3.*

.*$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/15i mov_tests_2\n"

    gdb_expect {

        -re "

.*mov   \\(131071,sp\\),d1.*

.*mov   \\(d1,a1\\),d2.*

.*mov   \\(0x8000.*\\),d1.*

.*mov   \\(0x1ffff.*\\),d1.*

.*mov   \\(a2\\),a1.*

.*mov   \\(8,a2\\),a1.*

.*mov   \\(256,a2\\),a1.*

.*mov   \\(131071,a2\\),a1.*

.*mov   \\(8,sp\\),a1.*

.*mov   \\(256,sp\\),a1.*

.*mov   \\(131071,sp\\),a1.*

.*mov   \\(d1,a1\\),a2.*

.*mov   \\(0x8000.*\\),a1.*

.*mov   \\(0x1ffff.*\\),a1.*

.*mov   \\(32,a1\\),sp.*

.*$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/15i mov_tests_3\n"

    gdb_expect {

        -re "

.*mov   d1,\\(a2\\).*

.*mov   d1,\\(32,a2\\).*

.*mov   d1,\\(256,a2\\).*

.*mov   d1,\\(131071,a2\\).*

.*mov   d1,\\(32,sp\\).*

.*mov   d1,\\(32768,sp\\).*

.*mov   d1,\\(131071,sp\\).*

.*mov   d1,\\(d2,a2\\).*

.*mov   d1,\\(0x80.*\\).*

.*mov   d1,\\(0x1ffff.*\\).*

.*mov   a1,\\(a2\\).*

.*mov   a1,\\(32,a2\\).*

.*mov   a1,\\(256,a2\\).*

.*mov   a1,\\(131071,a2\\).*

.*mov   a1,\\(32,sp\\).*

.*$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/12i mov_tests_4\n"

    gdb_expect {

        -re "

.*mov   a1,\\(32768,sp\\).*

.*mov   a1,\\(131071,sp\\).*

.*mov   a1,\\(d2,a2\\).*

.*mov   a1,\\(0x80.*\\).*

.*mov   a1,\\(0x1ffff.*\\).*

.*mov   sp,\\(32,a1\\).*

.*mov   8,d1.*

.*mov   256,d1.*

.*mov   131071,d1.*

.*mov   8,a1.*

.*mov   256,a1.*

.*mov   131071,a1.*

.*$gdb_prompt $" { pass "mov4 tests" }

        -re "$gdb_prompt $" { fail "mov4 tests" }

        timeout { fail "(timeout) mov4 tests" }

    }

}

proc movbu_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/20i movbu_tests\n"

    gdb_expect {

        -re "

.*movbu \\(a2\\),d1.*

.*movbu \\(8,a2\\),d1.*

.*movbu \\(256,a2\\),d1.*

.*movbu \\(131071,a2\\),d1.*

.*movbu \\(8,sp\\),d1.*

.*movbu \\(256,sp\\),d1.*

.*movbu \\(131071,sp\\),d1.*

.*movbu \\(d1,a1\\),d2.*

.*movbu \\(0x8000.*\\),d1.*

.*movbu \\(0x1ffff.*\\),d1.*

.*movbu d1,\\(a2\\).*

.*movbu d1,\\(32,a2\\).*

.*movbu d1,\\(256,a2\\).*

.*movbu d1,\\(131071,a2\\).*

.*movbu d1,\\(32,sp\\).*

.*movbu d1,\\(32768,sp\\).*

.*movbu d1,\\(131071,sp\\).*

.*movbu d1,\\(d2,a2\\).*

.*movbu d1,\\(0x80.*\\).*

.*movbu d1,\\(0x1ffff.*\\).*

.*$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 \\(a2\\),d1.*

.*movhu \\(8,a2\\),d1.*

.*movhu \\(256,a2\\),d1.*

.*movhu \\(131071,a2\\),d1.*

.*movhu \\(8,sp\\),d1.*

.*movhu \\(256,sp\\),d1.*

.*movhu \\(131071,sp\\),d1.*

.*movhu \\(d1,a1\\),d2.*

.*movhu \\(0x8000.*\\),d1.*

.*movhu \\(0x1ffff.*\\),d1.*

.*movhu d1,\\(a2\\).*

.*movhu d1,\\(32,a2\\).*

.*movhu d1,\\(256,a2\\).*

.*movhu d1,\\(131071,a2\\).*

.*movhu d1,\\(32,sp\\).*

.*movhu d1,\\(32768,sp\\).*

.*movhu d1,\\(131071,sp\\).*

.*movhu d1,\\(d2,a2\\).*

.*movhu d1,\\(0x80.*\\).*

.*movhu d1,\\(0x1ffff.*\\).*

.*$gdb_prompt $" { pass "movhu tests" }

        -re "$gdb_prompt $" { fail "movhu tests" }

        timeout { fail "(timeout) movhu tests" }

    }

}

proc movm_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/4i movm_tests\n"

    gdb_expect {

        -re "

.*movm  \\(sp\\),.a2,a3..*

.*movm  \\(sp\\),.d2,d3,a2,a3,other..*

.*movm  .a2,a3.,\\(sp\\).*

.*movm  .d2,d3,a2,a3,other.,\\(sp\\).*

.*$gdb_prompt $" { pass "movm tests" }

        -re "$gdb_prompt $" { fail "movm tests" }

        timeout { fail "(timeout) movm tests" }

    }

}

proc muldiv_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/4i muldiv_tests\n"

    gdb_expect {

        -re "

.*mul   d1,d2.*

.*mulu  d2,d3.*

.*div   d3,d3.*

.*divu  d3,d2.*

.*$gdb_prompt $" { pass "muldiv tests" }

        -re "$gdb_prompt $" { fail "muldiv tests" }

        timeout { fail "(timeout) muldiv tests" }

    }

}

proc other_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/19i other_tests\n"

    gdb_expect {

        -re "

.*clr   d2.*

.*inc   d1.*

.*inc   a2.*

.*inc4  a3.*

.*jmp   \\(a2\\).*

.*jmp   0x\[0-9a-f]+ 
.*

.*jmp   0x\[0-9a-f]+ .*

.*call  0x\[0-9a-f]+ 
,.a2,a3.,9.*

.*call  0x\[0-9a-f]+ ,.a2,a3.,32.*

.*calls \\(a2\\).*

.*calls 0x\[0-9a-f]+ 
.*

.*calls 0x\[0-9a-f]+ .*

.*ret   .a2,a3.,7.*

.*retf  .a2,a3.,5.*

.*rets.*

.*rti.*

.*trap.*

.*nop.*

.*rtm.*

.*$gdb_prompt $" { pass "other tests" }

        -re "$gdb_prompt $" { fail "other tests" }

        timeout { fail "(timeout) other tests" }

    }

}

proc shift_tests { } {

    global gdb_prompt

    global hex

    global decimal

    send_gdb "x/9i shift_tests\n"

    gdb_expect {

        -re "

.*asr   d1,d2.*

.*asr   4,d2.*

.*lsr   d2,d3.*

.*lsr   4,d3.*

.*asl   d3,d2.*

.*asl   4,d2.*

.*asl2  d2.*

.*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/7i sub_tests\n"

    gdb_expect {

        -re "

.*sub   d1,d2.*

.*sub   d2,a3.*

.*sub   a3,d3.*

.*sub   a3,a2.*

.*sub   131071,d2.*

.*sub   131071,a1.*

.*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

bit_tests

cmp_tests

extend_tests

extended_tests

logical_tests

loop_tests

mov_tests_1

mov_tests_2

mov_tests_3

mov_tests_4

movbu_tests

movhu_tests

movm_tests

muldiv_tests

other_tests

shift_tests

sub_tests