OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /open8_urisc/trunk/gnu/binutils
    from Rev 137 to Rev 138
    ↔ Reverse comparison
  •

Rev 137 → Rev 138

/gas/testsuite/gas/v850/mem.s
0,0 → 1,16
 
.text
.global memory
memory:
ld.b 5[r5],r6
ld.h 4[r5],r6
ld.w 4[r5],r6
sld.b 64[ep],r6
sld.h 128[ep],r6
sld.w 128[ep],r6
st.b r5,5[r6]
st.h r5,4[r6]
st.w r5,4[r6]
sst.b r6,64[ep]
sst.h r6,128[ep]
sst.w r6,128[ep]
/gas/testsuite/gas/v850/bit.s
0,0 → 1,8
 
.text
.global bit
bit:
clr1 5,16[r6]
not1 5,16[r6]
set1 5,16[r6]
tst1 5,16[r6]
/gas/testsuite/gas/v850/fepsw.s
0,0 → 1,2
.text
ldsr r17,fepsw
/gas/testsuite/gas/v850/compare.s
0,0 → 1,28
 
.text
.global compare
compare:
cmp r5,r6
cmp 5,r6
setf v,r5
setf nv,r5
setf c,r5
setf l,r5
setf nc,r5
setf nl,r5
setf z,r5
setf nz,r5
setf nh,r5
setf h,r5
setf s,r5
setf n,r5
setf ns,r5
setf p,r5
setf t,r5
setf sa,r5
setf lt,r5
setf ge,r5
setf le,r5
setf gt,r5
tst r5,r6
/gas/testsuite/gas/v850/v850e1.s
0,0 → 1,39
.text
.align 0
bsh r1, r2
bsw r3, r4
callt 5
clr1 r7, [r8]
cmov nz, 22, r2, r3
cmov nz, r1, r2, r3
ctret
dbret
dbtrap
dispose 7, {r24}
dispose 7, {r25 - r27}, r5
div r1, r2, r3
divh r4, r5, r6
divhu r7, r8, r9
divu r10, r11, r12
hsw r13, r14
ld.bu 13 [r1], r2
ld.hu 16 [r3], r4
mov 0x12345678, r1
mul 5, r2, r3
mul r1, r2, r3
mulu r4, r5, r6
mulu 35, r5, r6
not1 r9, [r10]
prepare {r24}, 20
prepare {r25 - r27}, 20, sp
set1 r9, [r1]
sasf nz, r8
sld.bu 0 [ep], r4
sld.hu 14 [ep], r5
sxb r1
sxh r2
tst1 r0, [r31]
zxb r3
zxh r4
st.w lp, 156[sp]
/gas/testsuite/gas/v850/split-lo16.d
0,0 → 1,18
#objdump: -dr
#name: V850E split LO16 tests
#as: -mv850e
#...
00000000 <.*>:
0: 40 0e 00 00 movhi 0, r0, r1
2: R_V850_HI16_S foo
4: 01 16 00 00 addi 0, r1, r2
6: R_V850_LO16 foo
8: 01 17 00 00 ld\.b 0\[r1\], r2
a: R_V850_LO16 foo
c: 81 17 01 00 ld\.bu 0\[r1\], r2
c: R_V850_LO16_SPLIT_OFFSET foo
10: a1 17 45 23 ld\.bu 9029\[r1\], r2
14: 81 17 57 34 ld\.bu 13398\[r1\], r2
18: 20 57 01 00 ld.w 0\[r0\], r10
1c: 20 57 79 56 ld.w 22136\[r0\], r10
#pass
/gas/testsuite/gas/v850/misc.s
0,0 → 1,13
 
.text
.global misc
misc:
di
ei
halt
nop
reti
trap 0
trap 31
ldsr r7,psw
stsr psw,r7
/gas/testsuite/gas/v850/hilo.s
0,0 → 1,5
 
.text
movea lo(0xdeadbeef),r0,r1
movhi hi(0xdeadbeef),r1,r1
movhi hi0(0xdeadbeef),r1,r1
/gas/testsuite/gas/v850/range.s
0,0 → 1,2
.text
ld.b 0xff62[r0],r0
/gas/testsuite/gas/v850/branch.s
0,0 → 1,24
 
.text
.global bcc
bcc:
bgt bcc
bge bcc
blt bcc
ble bcc
bh bcc
bnl bcc
bl bcc
bnh bcc
be bcc
bne bcc
bv bcc
bnv bcc
bn bcc
bp bcc
bc bcc
bnc bcc
bz bcc
bnz bcc
br bcc
bsa bcc
/gas/testsuite/gas/v850/jumps.s
0,0 → 1,8
 
.text
.global jumps
jumps:
jarl jumps,r5
jmp [r5]
jr jumps
/gas/testsuite/gas/v850/reloc.s
0,0 → 1,7
.text
movea lo(foo),r0,r1
movhi hi(foo),r1,r1
movhi hi0(foo),r1,r1
movea zdaoff(_foo),r0,r1
movhi tdaoff(_foo),ep,r1
movhi sdaoff(_foo),gp,r1
/gas/testsuite/gas/v850/move.s
0,0 → 1,8
 
.text
.global move
move:
mov r5,r6
mov 5,r6
movea 7,r5,r6
movhi 7,r5,r6
/gas/testsuite/gas/v850/arith.s
0,0 → 1,24
 
.text
.global arith_opcodes
arith_opcodes:
add r5,r6
add 5,r6
addi 7,r5,r6
divh r5,r6
mulh r5,r6
mulh 5,r6
mulhi 7,r5,r6
sar r5,r6
sar 31,r6
satadd r5,r6
satadd 5,r6
satsub r5,r6
satsubi 7,r5,r6
satsubr r5,r6
shl r5,r6
shl 31,r6
shr r5,r6
shr 31,r6
sub r5,r6
subr r5,r6
/gas/testsuite/gas/v850/v850e1.d
0,0 → 1,45
#objdump: -dr --prefix-addresses --show-raw-insn
#name: V850E1 instruction tests
#as: -mv850e1
 
# Test the new instructions in the V850E1 processor
 
.*: +file format .*v850.*
 
Disassembly of section .text:
0x0+00 e0 0f 42 13 [ ]*bsh r1, r2
0x0+04 e0 1f 40 23 [ ]*bsw sp, gp
0x0+08 05 02 [ ]*callt 5
0x0+0a e8 3f e4 00 [ ]*clr1 r7, r8
0x0+0e f6 17 14 1b [ ]*cmov nz, -10, r2, sp
0x0+12 e1 17 34 1b [ ]*cmov nz, r1, r2, sp
0x0+16 e0 07 44 01 [ ]*ctret
0x0+1a e0 07 46 01 [ ]*dbret
0x0+1e 40 f8 [ ]*dbtrap
0x0+20 4e 06 00 80 [ ]*dispose 7, {r24}, r0
0x0+24 4e 06 05 70 [ ]*dispose 7, {r25 - r27}, r5
0x0+28 e1 17 c0 1a [ ]*div r1, r2, sp
0x0+2c e4 2f 80 32 [ ]*divh gp, r5, r6
0x0+30 e7 47 82 4a [ ]*divhu r7, r8, r9
0x0+34 ea 5f c2 62 [ ]*divu r10, r11, r12
0x0+38 e0 6f 44 73 [ ]*hsw r13, r14
0x0+3c a1 17 0d 00 [ ]*ld.bu 13\[r1\], r2
0x0+40 e3 27 11 00 [ ]*ld.hu 16\[sp\], gp
0x0+44 21 06 78 56 34 12 [ ]*mov 0x12345678, r1
0x0+4a e5 17 40 1a [ ]*mul 5, r2, sp
0x0+4e e1 17 20 1a [ ]*mul r1, r2, sp
0x0+52 e4 2f 22 32 [ ]*mulu gp, r5, r6
0x0+56 e3 2f 46 32 [ ]*mulu 35, r5, r6
0x0+5a ea 4f e2 00 [ ]*not1 r9, r10
0x0+5e a8 07 01 80 [ ]*prepare {r24}, 20
0x0+62 a8 07 03 70 [ ]*prepare {r25 - r27}, 20, sp
0x0+66 e1 4f e0 00 [ ]*set1 r9, r1
0x0+6a ea 47 00 02 [ ]*sasf nz, r8
0x0+6e 60 20 [ ]*sld.bu 0\[ep\], gp
0x0+70 77 28 [ ]*sld.hu 14\[ep\], r5
0x0+72 a1 00 [ ]*sxb r1
0x0+74 e2 00 [ ]*sxh r2
0x0+76 ff 07 e6 00 [ ]*tst1 r0, lp
0x0+7a 83 00 [ ]*zxb sp
0x0+7c c4 00 [ ]*zxh gp
0x0+7e 63 ff 9d 00[ ]*st.w lp, 156\[sp\]
/gas/testsuite/gas/v850/logical.s
0,0 → 1,11
 
.text
.global logicals
logicals:
and r5,r6
andi 7,r5,r6
not r5,r6
or r5,r6
ori 7,r5,r6
xor r5,r6
xori 7,r5,r6
/gas/testsuite/gas/v850/split-lo16.s
0,0 → 1,10
movhi hi(foo),r0,r1
addi lo(foo),r1,r2
ld.b lo(foo),r1,r2
ld.bu lo(foo),r1,r2
 
ld.bu lo(0x12345),r1,r2
ld.bu lo(0x123456),r1,r2
 
ld.w lo(0)[r0], r10
ld.w lo(0x12345678)[r0], r10
/gas/testsuite/gas/v850/basic.exp
0,0 → 1,441
# Copyright (C) 1996, 2002, 2003, 2004, 2005, 2007
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
 
# Please email any bugs, comments, and/or additions to this file to:
# dejagnu@gnu.org
 
# Written by Cygnus Support.
 
proc do_arith {} {
set testname "arith.s: Arithmetic operations"
set x 0
 
gas_start "arith.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
# -re "^ +\[0-9\]+ 0000 489A0000\[^\n\]*\n" { set x [expr $x+1] }
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 C531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 4532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 05360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 4530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a E530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c E532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e E5360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 E537A000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 BF32\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 C530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a 2532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c A530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e 65360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 8530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 E537C000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 DF32\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002a E5378000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002e 9F32\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 A531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0032 8531\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==20] then { pass $testname } else { fail $testname }
}
 
proc do_bit {} {
set testname "bit.s: bit operations"
set x 0
 
gas_start "bit.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 C6AF1000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 C66F1000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 C62F1000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c C6EF1000\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==4] then { pass $testname } else { fail $testname }
}
 
proc do_branch {} {
set testname "branch.s: branch operations"
set x 0
 
gas_start "branch.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 8F05\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 FEFD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E6FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 D7FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 CBFD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a B9FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c A1FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e 93FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 82FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 FAF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 E0F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 D8F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 C4F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a BCF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c A1F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e 99F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 82F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 FAED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 E5ED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0026 DDED\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==20] then { pass $testname } else { fail $testname }
}
 
proc do_compare {} {
set testname "compare.s: compare operations"
set x 0
 
gas_start "compare.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 E531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 6532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E02F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 E82F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c E12F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 E12F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 E92F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 E92F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c E22F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 EA2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 E32F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 EB2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c E42F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 E42F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 EC2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 EC2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c E52F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 ED2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 E62F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 EE2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c E72F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 EF2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 6531\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==23] then { pass $testname } else { fail $testname }
}
 
proc do_jumps {} {
set testname "jumps.s: jumps operations"
set x 0
 
gas_start "jumps.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 802F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 6500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 BF07FAFF\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==3] then { pass $testname } else { fail $testname }
}
 
proc do_logical {} {
set testname "logical.s: logical operations"
set x 0
 
gas_start "logical.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 4531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 C5360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 2530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 0531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a 85360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e 2531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 A5360700\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==7] then { pass $testname } else { fail $testname }
}
 
proc do_mem {} {
set testname "mem.s: memory operations"
set x 0
 
gas_start "mem.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 05370500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 25370400\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 25370500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 4033\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e 4034\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 4035\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 462F0500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 662F0400\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a 662F0500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e C033\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 C034\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 4135\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==12] then { pass $testname } else { fail $testname }
}
 
proc do_misc {} {
set testname "misc.s: misc operations"
set x 0
 
gas_start "misc.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 E0076001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E0876001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 E0072001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e E0074001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 E0070001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 FF070001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a E72F2000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e E53F4000\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==9] then { pass $testname } else { fail $testname }
}
 
proc do_move {} {
set testname "move.s: move operations"
set x 0
 
gas_start "move.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 0530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 0532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 25360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 45360700\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==4] then { pass $testname } else { fail $testname }
}
 
proc do_hilo {} {
set testname "hilo.s: hilo tests"
set x 0
 
gas_start "hilo.s" "-al"
 
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 200EEFBE\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 410EAEDE\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 410EADDE\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==3] then { pass $testname } else { fail $testname }
}
 
 
proc do_simple_reloc_tests {} {
set testname "reloc.s: Test for proper relocations (part 2)"
set x 0
 
if [gas_test_old "reloc.s" "" "Test for proper relocation (part 1)"] then {
objdump_start_no_subdir "a.out" "-r"
 
while 1 {
expect {
-re "^00000002\[^\n\]*R_V850_LO16\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^00000006\[^\n\]*R_V850_HI16_S\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0000000a\[^\n\]*R_V850_HI16\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0000000e\[^\n\]*R_V850_ZDA_16_16_OFFSET\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^00000012\[^\n\]*R_V850_TDA_16_16_OFFSET\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^00000016\[^\n\]*R_V850_SDA_16_16_OFFSET\[^\n\]*\n"
{ set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
}
 
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
objdump_finish
 
# Did we find what we were looking for? If not, flunk it.
if [expr $x==6] then { pass $testname } else { fail $testname }
}
 
if [istarget v850*-*-*] then {
# Test the basic instruction parser.
do_arith
do_bit
do_branch
do_compare
do_jumps
do_logical
do_mem
do_misc
do_move
 
# Make sure we handle lo() hi() and hi0() correctly.
do_hilo
 
# Check for proper relocs on lo, hi, hi0, zdaoff, tdaoff and sdaoff
# expressions
do_simple_reloc_tests
 
gas_test "hilo2.s" "" "" "hi/lo regression test"
gas_test "fepsw.s" "" "" "eqsw regression test"
 
gas_test_error "range.s" "-mwarn-signed-overflow" "Check for range error on byte load/store"
run_dump_test "v850e1"
run_dump_test "split-lo16"
}
/gas/testsuite/gas/v850/hilo2.s
0,0 → 1,4
.text
.org 0x10000
movea hi(blah),r0,r1
blah:

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.