OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/gnu-src/binutils-2.18.50/gas/testsuite/gas/hppa
    from Rev 38 to Rev 156
    ↔ Reverse comparison
  •

Rev 38 → Rev 156

/basic/branch2.s
0,0 → 1,32
.LEVEL 2.0
.code
.align 4
; More branching instructions than you ever knew what to do with.
; PA 2.0 versions and new syntax.
 
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
 
bb_tests:
bb,< %r4,%sar,bb_tests
bb,>= %r4,%sar,bb_tests
bb,<,n %r4,%cr11,bb_tests
bb,>=,n %r4,%cr11,bb_tests
bb,*< %r4,%sar,bb_tests
bb,*>= %r4,%sar,bb_tests
bb,*<,n %r4,%cr11,bb_tests
bb,*>=,n %r4,%cr11,bb_tests
bb,*< %r4,5,bb_tests
bb,*>= %r4,5,bb_tests
bb,*<,n %r4,5,bb_tests
bb,*>=,n %r4,5,bb_tests
branch_stack:
clrbts
popbts 1
popbts 499
pushnom
pushbts %r4
 
/basic/fp_misc.s
0,0 → 1,9
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
fpu_misc_tests:
ftest
/basic/fmemLRbug.s
0,0 → 1,76
.code
.export f
f:
.proc
.callinfo frame=0,no_calls
.entry
 
fstws %fr6R,0(%r26)
fstws %fr6L,4(%r26)
fstws %fr6,8(%r26)
 
fstds %fr6R,0(%r26)
fstds %fr6L,4(%r26)
fstds %fr6,8(%r26)
 
fldws 0(%r26),%fr6R
fldws 4(%r26),%fr6L
fldws 8(%r26),%fr6
 
fldds 0(%r26),%fr6R
fldds 4(%r26),%fr6L
fldds 8(%r26),%fr6
 
fstws %fr6R,0(%sr0,%r26)
fstws %fr6L,4(%sr0,%r26)
fstws %fr6,8(%sr0,%r26)
 
fstds %fr6R,0(%sr0,%r26)
fstds %fr6L,4(%sr0,%r26)
fstds %fr6,8(%sr0,%r26)
 
fldws 0(%sr0,%r26),%fr6R
fldws 4(%sr0,%r26),%fr6L
fldws 8(%sr0,%r26),%fr6
 
fldds 0(%sr0,%r26),%fr6R
fldds 4(%sr0,%r26),%fr6L
fldds 8(%sr0,%r26),%fr6
 
fstwx %fr6R,%r25(%r26)
fstwx %fr6L,%r25(%r26)
fstwx %fr6,%r25(%r26)
 
fstdx %fr6R,%r25(%r26)
fstdx %fr6L,%r25(%r26)
fstdx %fr6,%r25(%r26)
 
fldwx %r25(%r26),%fr6R
fldwx %r25(%r26),%fr6L
fldwx %r25(%r26),%fr6
 
flddx %r25(%r26),%fr6R
flddx %r25(%r26),%fr6L
flddx %r25(%r26),%fr6
 
fstwx %fr6R,%r25(%sr0,%r26)
fstwx %fr6L,%r25(%sr0,%r26)
fstwx %fr6,%r25(%sr0,%r26)
 
fstdx %fr6R,%r25(%sr0,%r26)
fstdx %fr6L,%r25(%sr0,%r26)
fstdx %fr6,%r25(%sr0,%r26)
 
fldwx %r25(%sr0,%r26),%fr6R
fldwx %r25(%sr0,%r26),%fr6L
fldwx %r25(%sr0,%r26),%fr6
 
flddx %r25(%sr0,%r26),%fr6R
flddx %r25(%sr0,%r26),%fr6L
flddx %r25(%sr0,%r26),%fr6
 
bv %r0(%r2)
nop
 
.exit
.procend
/basic/special.s
0,0 → 1,7
.level 1.1
.code
.align 4
gfw %r4(%sr0,%r5)
gfw,m %r4(%sr0,%r5)
gfr %r4(%sr0,%r5)
gfr,m %r4(%sr0,%r5)
/basic/purge.s
0,0 → 1,26
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
pdtlb %r4(%sr0,%r5)
pdtlb,m %r4(%sr0,%r5)
pitlb %r4(%sr4,%r5)
pitlb,m %r4(%sr4,%r5)
pdtlbe %r4(%sr0,%r5)
pdtlbe,m %r4(%sr0,%r5)
pitlbe %r4(%sr4,%r5)
pitlbe,m %r4(%sr4,%r5)
pdc %r4(%sr0,%r5)
pdc,m %r4(%sr0,%r5)
fdc %r4(%sr0,%r5)
fdc,m %r4(%sr0,%r5)
fic %r4(%sr4,%r5)
fic,m %r4(%sr4,%r5)
fdce %r4(%sr0,%r5)
fdce,m %r4(%sr0,%r5)
fice %r4(%sr4,%r5)
fice,m %r4(%sr4,%r5)
 
/basic/fp_comp.s
0,0 → 1,73
.level 1.1
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
fcpy,sgl %fr5,%fr10
fcpy,dbl %fr5,%fr10
fcpy,quad %fr5,%fr10
fcpy,sgl %fr20,%fr24
fcpy,dbl %fr20,%fr24
 
fabs,sgl %fr5,%fr10
fabs,dbl %fr5,%fr10
fabs,quad %fr5,%fr10
fabs,sgl %fr20,%fr24
fabs,dbl %fr20,%fr24
 
fsqrt,sgl %fr5,%fr10
fsqrt,dbl %fr5,%fr10
fsqrt,quad %fr5,%fr10
fsqrt,sgl %fr20,%fr24
fsqrt,dbl %fr20,%fr24
 
frnd,sgl %fr5,%fr10
frnd,dbl %fr5,%fr10
frnd,quad %fr5,%fr10
frnd,sgl %fr20,%fr24
frnd,dbl %fr20,%fr24
fadd,sgl %fr4,%fr8,%fr12
fadd,dbl %fr4,%fr8,%fr12
fadd,quad %fr4,%fr8,%fr12
fadd,sgl %fr20,%fr24,%fr28
fadd,dbl %fr20,%fr24,%fr28
fadd,quad %fr20,%fr24,%fr28
 
fsub,sgl %fr4,%fr8,%fr12
fsub,dbl %fr4,%fr8,%fr12
fsub,quad %fr4,%fr8,%fr12
fsub,sgl %fr20,%fr24,%fr28
fsub,dbl %fr20,%fr24,%fr28
fsub,quad %fr20,%fr24,%fr28
 
fmpy,sgl %fr4,%fr8,%fr12
fmpy,dbl %fr4,%fr8,%fr12
fmpy,quad %fr4,%fr8,%fr12
fmpy,sgl %fr20,%fr24,%fr28
fmpy,dbl %fr20,%fr24,%fr28
fmpy,quad %fr20,%fr24,%fr28
 
fdiv,sgl %fr4,%fr8,%fr12
fdiv,dbl %fr4,%fr8,%fr12
fdiv,quad %fr4,%fr8,%fr12
fdiv,sgl %fr20,%fr24,%fr28
fdiv,dbl %fr20,%fr24,%fr28
fdiv,quad %fr20,%fr24,%fr28
 
frem,sgl %fr4,%fr8,%fr12
frem,dbl %fr4,%fr8,%fr12
frem,quad %fr4,%fr8,%fr12
frem,sgl %fr20,%fr24,%fr28
frem,dbl %fr20,%fr24,%fr28
frem,quad %fr20,%fr24,%fr28
 
fmpyadd,sgl %fr16,%fr17,%fr18,%fr19,%fr20
fmpyadd,dbl %fr16,%fr17,%fr18,%fr19,%fr20
fmpysub,sgl %fr16,%fr17,%fr18,%fr19,%fr20
fmpysub,dbl %fr16,%fr17,%fr18,%fr19,%fr20
 
xmpyu %fr4,%fr5,%fr6
/basic/imem.s
0,0 → 1,84
.code
.align 4
.EXPORT integer_memory_tests,CODE
.EXPORT integer_indexing_load,CODE
.EXPORT integer_load_short_memory,CODE
.EXPORT integer_store_short_memory,CODE
.EXPORT main,CODE
.EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR
; Basic integer memory tests which also test the various
; addressing modes and completers.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
;
integer_memory_tests:
ldw 0(%sr0,%r4),%r26
ldh 0(%sr0,%r4),%r26
ldb 0(%sr0,%r4),%r26
stw %r26,0(%sr0,%r4)
sth %r26,0(%sr0,%r4)
stb %r26,0(%sr0,%r4)
 
; Should make sure pre/post modes are recognized correctly.
ldwm 0(%sr0,%r4),%r26
stwm %r26,0(%sr0,%r4)
 
integer_indexing_load:
ldwx %r5(%sr0,%r4),%r26
ldwx,s %r5(%sr0,%r4),%r26
ldwx,m %r5(%sr0,%r4),%r26
ldwx,sm %r5(%sr0,%r4),%r26
ldhx %r5(%sr0,%r4),%r26
ldhx,s %r5(%sr0,%r4),%r26
ldhx,m %r5(%sr0,%r4),%r26
ldhx,sm %r5(%sr0,%r4),%r26
ldbx %r5(%sr0,%r4),%r26
ldbx,s %r5(%sr0,%r4),%r26
ldbx,m %r5(%sr0,%r4),%r26
ldbx,sm %r5(%sr0,%r4),%r26
ldwax %r5(%r4),%r26
ldwax,s %r5(%r4),%r26
ldwax,m %r5(%r4),%r26
ldwax,sm %r5(%r4),%r26
ldcwx %r5(%sr0,%r4),%r26
ldcwx,s %r5(%sr0,%r4),%r26
ldcwx,m %r5(%sr0,%r4),%r26
ldcwx,sm %r5(%sr0,%r4),%r26
 
integer_load_short_memory:
ldws 0(%sr0,%r4),%r26
ldws,mb 0(%sr0,%r4),%r26
ldws,ma 0(%sr0,%r4),%r26
ldhs 0(%sr0,%r4),%r26
ldhs,mb 0(%sr0,%r4),%r26
ldhs,ma 0(%sr0,%r4),%r26
ldbs 0(%sr0,%r4),%r26
ldbs,mb 0(%sr0,%r4),%r26
ldbs,ma 0(%sr0,%r4),%r26
ldwas 0(%r4),%r26
ldwas,mb 0(%r4),%r26
ldwas,ma 0(%r4),%r26
ldcws 0(%sr0,%r4),%r26
ldcws,mb 0(%sr0,%r4),%r26
ldcws,ma 0(%sr0,%r4),%r26
 
integer_store_short_memory:
stws %r26,0(%sr0,%r4)
stws,mb %r26,0(%sr0,%r4)
stws,ma %r26,0(%sr0,%r4)
sths %r26,0(%sr0,%r4)
sths,mb %r26,0(%sr0,%r4)
sths,ma %r26,0(%sr0,%r4)
stbs %r26,0(%sr0,%r4)
stbs,mb %r26,0(%sr0,%r4)
stbs,ma %r26,0(%sr0,%r4)
stwas %r26,0(%r4)
stwas,mb %r26,0(%r4)
stwas,ma %r26,0(%r4)
stbys %r26,0(%sr0,%r4)
stbys,b %r26,0(%sr0,%r4)
stbys,e %r26,0(%sr0,%r4)
stbys,b,m %r26,0(%sr0,%r4)
stbys,e,m %r26,0(%sr0,%r4)
/basic/add.s
0,0 → 1,160
.level 1.1
.code
.align 4
; Basic add/sh?add instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
add %r4,%r5,%r6
add,= %r4,%r5,%r6
add,< %r4,%r5,%r6
add,<= %r4,%r5,%r6
add,nuv %r4,%r5,%r6
add,znv %r4,%r5,%r6
add,sv %r4,%r5,%r6
add,od %r4,%r5,%r6
add,tr %r4,%r5,%r6
add,<> %r4,%r5,%r6
add,>= %r4,%r5,%r6
add,> %r4,%r5,%r6
add,uv %r4,%r5,%r6
add,vnz %r4,%r5,%r6
add,nsv %r4,%r5,%r6
add,ev %r4,%r5,%r6
 
addl %r4,%r5,%r6
addl,= %r4,%r5,%r6
addl,< %r4,%r5,%r6
addl,<= %r4,%r5,%r6
addl,nuv %r4,%r5,%r6
addl,znv %r4,%r5,%r6
addl,sv %r4,%r5,%r6
addl,od %r4,%r5,%r6
addl,tr %r4,%r5,%r6
addl,<> %r4,%r5,%r6
addl,>= %r4,%r5,%r6
addl,> %r4,%r5,%r6
addl,uv %r4,%r5,%r6
addl,vnz %r4,%r5,%r6
addl,nsv %r4,%r5,%r6
addl,ev %r4,%r5,%r6
 
addo %r4,%r5,%r6
addo,= %r4,%r5,%r6
addo,< %r4,%r5,%r6
addo,<= %r4,%r5,%r6
addo,nuv %r4,%r5,%r6
addo,znv %r4,%r5,%r6
addo,sv %r4,%r5,%r6
addo,od %r4,%r5,%r6
addo,tr %r4,%r5,%r6
addo,<> %r4,%r5,%r6
addo,>= %r4,%r5,%r6
addo,> %r4,%r5,%r6
addo,uv %r4,%r5,%r6
addo,vnz %r4,%r5,%r6
addo,nsv %r4,%r5,%r6
addo,ev %r4,%r5,%r6
 
addc %r4,%r5,%r6
addc,= %r4,%r5,%r6
addc,< %r4,%r5,%r6
addc,<= %r4,%r5,%r6
addc,nuv %r4,%r5,%r6
addc,znv %r4,%r5,%r6
addc,sv %r4,%r5,%r6
addc,od %r4,%r5,%r6
addc,tr %r4,%r5,%r6
addc,<> %r4,%r5,%r6
addc,>= %r4,%r5,%r6
addc,> %r4,%r5,%r6
addc,uv %r4,%r5,%r6
addc,vnz %r4,%r5,%r6
addc,nsv %r4,%r5,%r6
addc,ev %r4,%r5,%r6
 
addco %r4,%r5,%r6
addco,= %r4,%r5,%r6
addco,< %r4,%r5,%r6
addco,<= %r4,%r5,%r6
addco,nuv %r4,%r5,%r6
addco,znv %r4,%r5,%r6
addco,sv %r4,%r5,%r6
addco,od %r4,%r5,%r6
addco,tr %r4,%r5,%r6
addco,<> %r4,%r5,%r6
addco,>= %r4,%r5,%r6
addco,> %r4,%r5,%r6
addco,uv %r4,%r5,%r6
addco,vnz %r4,%r5,%r6
addco,nsv %r4,%r5,%r6
addco,ev %r4,%r5,%r6
 
add,l %r4,%r5,%r6
add,l,= %r4,%r5,%r6
add,l,< %r4,%r5,%r6
add,l,<= %r4,%r5,%r6
add,l,nuv %r4,%r5,%r6
add,l,znv %r4,%r5,%r6
add,l,sv %r4,%r5,%r6
add,l,od %r4,%r5,%r6
add,l,tr %r4,%r5,%r6
add,l,<> %r4,%r5,%r6
add,l,>= %r4,%r5,%r6
add,l,> %r4,%r5,%r6
add,l,uv %r4,%r5,%r6
add,l,vnz %r4,%r5,%r6
add,l,nsv %r4,%r5,%r6
add,l,ev %r4,%r5,%r6
 
add,tsv %r4,%r5,%r6
add,tsv,= %r4,%r5,%r6
add,tsv,< %r4,%r5,%r6
add,tsv,<= %r4,%r5,%r6
add,tsv,nuv %r4,%r5,%r6
add,tsv,znv %r4,%r5,%r6
add,tsv,sv %r4,%r5,%r6
add,tsv,od %r4,%r5,%r6
add,tsv,tr %r4,%r5,%r6
add,tsv,<> %r4,%r5,%r6
add,tsv,>= %r4,%r5,%r6
add,tsv,> %r4,%r5,%r6
add,tsv,uv %r4,%r5,%r6
add,tsv,vnz %r4,%r5,%r6
add,tsv,nsv %r4,%r5,%r6
add,tsv,ev %r4,%r5,%r6
 
add,c %r4,%r5,%r6
add,c,= %r4,%r5,%r6
add,c,< %r4,%r5,%r6
add,c,<= %r4,%r5,%r6
add,c,nuv %r4,%r5,%r6
add,c,znv %r4,%r5,%r6
add,c,sv %r4,%r5,%r6
add,c,od %r4,%r5,%r6
add,c,tr %r4,%r5,%r6
add,c,<> %r4,%r5,%r6
add,c,>= %r4,%r5,%r6
add,c,> %r4,%r5,%r6
add,c,uv %r4,%r5,%r6
add,c,vnz %r4,%r5,%r6
add,c,nsv %r4,%r5,%r6
add,c,ev %r4,%r5,%r6
 
add,c,tsv %r4,%r5,%r6
add,c,tsv,= %r4,%r5,%r6
add,c,tsv,< %r4,%r5,%r6
add,c,tsv,<= %r4,%r5,%r6
add,c,tsv,nuv %r4,%r5,%r6
add,c,tsv,znv %r4,%r5,%r6
add,c,tsv,sv %r4,%r5,%r6
add,c,tsv,od %r4,%r5,%r6
add,tsv,c,tr %r4,%r5,%r6
add,tsv,c,<> %r4,%r5,%r6
add,tsv,c,>= %r4,%r5,%r6
add,tsv,c,> %r4,%r5,%r6
add,tsv,c,uv %r4,%r5,%r6
add,tsv,c,vnz %r4,%r5,%r6
add,tsv,c,nsv %r4,%r5,%r6
add,tsv,c,ev %r4,%r5,%r6
/basic/sub.s
0,0 → 1,194
.level 1.1
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
sub %r4,%r5,%r6
sub,= %r4,%r5,%r6
sub,< %r4,%r5,%r6
sub,<= %r4,%r5,%r6
sub,<< %r4,%r5,%r6
sub,<<= %r4,%r5,%r6
sub,sv %r4,%r5,%r6
sub,od %r4,%r5,%r6
sub,tr %r4,%r5,%r6
sub,<> %r4,%r5,%r6
sub,>= %r4,%r5,%r6
sub,> %r4,%r5,%r6
sub,>>= %r4,%r5,%r6
sub,>> %r4,%r5,%r6
sub,nsv %r4,%r5,%r6
sub,ev %r4,%r5,%r6
 
subo %r4,%r5,%r6
subo,= %r4,%r5,%r6
subo,< %r4,%r5,%r6
subo,<= %r4,%r5,%r6
subo,<< %r4,%r5,%r6
subo,<<= %r4,%r5,%r6
subo,sv %r4,%r5,%r6
subo,od %r4,%r5,%r6
subo,tr %r4,%r5,%r6
subo,<> %r4,%r5,%r6
subo,>= %r4,%r5,%r6
subo,> %r4,%r5,%r6
subo,>>= %r4,%r5,%r6
subo,>> %r4,%r5,%r6
subo,nsv %r4,%r5,%r6
subo,ev %r4,%r5,%r6
 
subb %r4,%r5,%r6
subb,= %r4,%r5,%r6
subb,< %r4,%r5,%r6
subb,<= %r4,%r5,%r6
subb,<< %r4,%r5,%r6
subb,<<= %r4,%r5,%r6
subb,sv %r4,%r5,%r6
subb,od %r4,%r5,%r6
subb,tr %r4,%r5,%r6
subb,<> %r4,%r5,%r6
subb,>= %r4,%r5,%r6
subb,> %r4,%r5,%r6
subb,>>= %r4,%r5,%r6
subb,>> %r4,%r5,%r6
subb,nsv %r4,%r5,%r6
subb,ev %r4,%r5,%r6
 
subbo %r4,%r5,%r6
subbo,= %r4,%r5,%r6
subbo,< %r4,%r5,%r6
subbo,<= %r4,%r5,%r6
subbo,<< %r4,%r5,%r6
subbo,<<= %r4,%r5,%r6
subbo,sv %r4,%r5,%r6
subbo,od %r4,%r5,%r6
subbo,tr %r4,%r5,%r6
subbo,<> %r4,%r5,%r6
subbo,>= %r4,%r5,%r6
subbo,> %r4,%r5,%r6
subbo,>>= %r4,%r5,%r6
subbo,>> %r4,%r5,%r6
subbo,nsv %r4,%r5,%r6
subbo,ev %r4,%r5,%r6
 
subt %r4,%r5,%r6
subt,= %r4,%r5,%r6
subt,< %r4,%r5,%r6
subt,<= %r4,%r5,%r6
subt,<< %r4,%r5,%r6
subt,<<= %r4,%r5,%r6
subt,sv %r4,%r5,%r6
subt,od %r4,%r5,%r6
subt,tr %r4,%r5,%r6
subt,<> %r4,%r5,%r6
subt,>= %r4,%r5,%r6
subt,> %r4,%r5,%r6
subt,>>= %r4,%r5,%r6
subt,>> %r4,%r5,%r6
subt,nsv %r4,%r5,%r6
subt,ev %r4,%r5,%r6
 
subto %r4,%r5,%r6
subto,= %r4,%r5,%r6
subto,< %r4,%r5,%r6
subto,<= %r4,%r5,%r6
subto,<< %r4,%r5,%r6
subto,<<= %r4,%r5,%r6
subto,sv %r4,%r5,%r6
subto,od %r4,%r5,%r6
subto,tr %r4,%r5,%r6
subto,<> %r4,%r5,%r6
subto,>= %r4,%r5,%r6
subto,> %r4,%r5,%r6
subto,>>= %r4,%r5,%r6
subto,>> %r4,%r5,%r6
subto,nsv %r4,%r5,%r6
subto,ev %r4,%r5,%r6
 
sub,tsv %r4,%r5,%r6
sub,tsv,= %r4,%r5,%r6
sub,tsv,< %r4,%r5,%r6
sub,tsv,<= %r4,%r5,%r6
sub,tsv,<< %r4,%r5,%r6
sub,tsv,<<= %r4,%r5,%r6
sub,tsv,sv %r4,%r5,%r6
sub,tsv,od %r4,%r5,%r6
sub,tsv,tr %r4,%r5,%r6
sub,tsv,<> %r4,%r5,%r6
sub,tsv,>= %r4,%r5,%r6
sub,tsv,> %r4,%r5,%r6
sub,tsv,>>= %r4,%r5,%r6
sub,tsv,>> %r4,%r5,%r6
sub,tsv,nsv %r4,%r5,%r6
sub,tsv,ev %r4,%r5,%r6
 
sub,b %r4,%r5,%r6
sub,b,= %r4,%r5,%r6
sub,b,< %r4,%r5,%r6
sub,b,<= %r4,%r5,%r6
sub,b,<< %r4,%r5,%r6
sub,b,<<= %r4,%r5,%r6
sub,b,sv %r4,%r5,%r6
sub,b,od %r4,%r5,%r6
sub,b,tr %r4,%r5,%r6
sub,b,<> %r4,%r5,%r6
sub,b,>= %r4,%r5,%r6
sub,b,> %r4,%r5,%r6
sub,b,>>= %r4,%r5,%r6
sub,b,>> %r4,%r5,%r6
sub,b,nsv %r4,%r5,%r6
sub,b,ev %r4,%r5,%r6
 
sub,b,tsv %r4,%r5,%r6
sub,b,tsv,= %r4,%r5,%r6
sub,b,tsv,< %r4,%r5,%r6
sub,b,tsv,<= %r4,%r5,%r6
sub,b,tsv,<< %r4,%r5,%r6
sub,b,tsv,<<= %r4,%r5,%r6
sub,b,tsv,sv %r4,%r5,%r6
sub,b,tsv,od %r4,%r5,%r6
sub,tsv,b,tr %r4,%r5,%r6
sub,tsv,b,<> %r4,%r5,%r6
sub,tsv,b,>= %r4,%r5,%r6
sub,tsv,b,> %r4,%r5,%r6
sub,tsv,b,>>= %r4,%r5,%r6
sub,tsv,b,>> %r4,%r5,%r6
sub,tsv,b,nsv %r4,%r5,%r6
sub,tsv,b,ev %r4,%r5,%r6
 
sub,tc %r4,%r5,%r6
sub,tc,= %r4,%r5,%r6
sub,tc,< %r4,%r5,%r6
sub,tc,<= %r4,%r5,%r6
sub,tc,<< %r4,%r5,%r6
sub,tc,<<= %r4,%r5,%r6
sub,tc,sv %r4,%r5,%r6
sub,tc,od %r4,%r5,%r6
sub,tc,tr %r4,%r5,%r6
sub,tc,<> %r4,%r5,%r6
sub,tc,>= %r4,%r5,%r6
sub,tc,> %r4,%r5,%r6
sub,tc,>>= %r4,%r5,%r6
sub,tc,>> %r4,%r5,%r6
sub,tc,nsv %r4,%r5,%r6
sub,tc,ev %r4,%r5,%r6
 
sub,tc,tsv %r4,%r5,%r6
sub,tc,tsv,= %r4,%r5,%r6
sub,tc,tsv,< %r4,%r5,%r6
sub,tc,tsv,<= %r4,%r5,%r6
sub,tc,tsv,<< %r4,%r5,%r6
sub,tc,tsv,<<= %r4,%r5,%r6
sub,tc,tsv,sv %r4,%r5,%r6
sub,tc,tsv,od %r4,%r5,%r6
sub,tsv,tc,tr %r4,%r5,%r6
sub,tsv,tc,<> %r4,%r5,%r6
sub,tsv,tc,>= %r4,%r5,%r6
sub,tsv,tc,> %r4,%r5,%r6
sub,tsv,tc,>>= %r4,%r5,%r6
sub,tsv,tc,>> %r4,%r5,%r6
sub,tsv,tc,nsv %r4,%r5,%r6
sub,tsv,tc,ev %r4,%r5,%r6
/basic/perf.s
0,0 → 1,10
.LEVEL 2.0
.code
.align 4
; PA2.0 performance monitor instruction tests
 
 
pmenb
pmdis
pmdis,n
 
/basic/extract2.s
0,0 → 1,42
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
extrw,u %r4,5,10,%r6
extrw,u,= %r4,5,10,%r6
extrw,u,< %r4,5,10,%r6
extrw,u,od %r4,5,10,%r6
extrw,u,tr %r4,5,10,%r6
extrw,u,<> %r4,5,10,%r6
extrw,u,>= %r4,5,10,%r6
extrw,u,ev %r4,5,10,%r6
 
extrw,s %r4,5,10,%r6
extrw,s,= %r4,5,10,%r6
extrw,s,< %r4,5,10,%r6
extrw,s,od %r4,5,10,%r6
extrw,tr %r4,5,10,%r6
extrw,<> %r4,5,10,%r6
extrw,>= %r4,5,10,%r6
extrw,ev %r4,5,10,%r6
 
extrw,u %r4,%sar,5,%r6
extrw,u,= %r4,%sar,5,%r6
extrw,u,< %r4,%sar,5,%r6
extrw,u,od %r4,%sar,5,%r6
extrw,u,tr %r4,%sar,5,%r6
extrw,u,<> %r4,%sar,5,%r6
extrw,u,>= %r4,%sar,5,%r6
extrw,u,ev %r4,%sar,5,%r6
extrw,s %r4,%sar,5,%r6
extrw,s,= %r4,%sar,5,%r6
extrw,s,< %r4,%sar,5,%r6
extrw,s,od %r4,%sar,5,%r6
extrw,tr %r4,%sar,5,%r6
extrw,<> %r4,%sar,5,%r6
extrw,>= %r4,%sar,5,%r6
extrw,ev %r4,%sar,5,%r6
/basic/extract3.s
0,0 → 1,43
.LEVEL 2.0
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
extrd,u,* %r4,10,5,%r6
extrd,u,*= %r4,10,5,%r6
extrd,u,*< %r4,10,5,%r6
extrd,u,*od %r4,10,5,%r6
extrd,u,*tr %r4,10,5,%r6
extrd,u,*<> %r4,10,5,%r6
extrd,u,*>= %r4,10,5,%r6
extrd,u,*ev %r4,10,5,%r6
 
extrd,s,* %r4,10,5,%r6
extrd,s,*= %r4,10,5,%r6
extrd,s,*< %r4,10,5,%r6
extrd,s,*od %r4,10,5,%r6
extrd,*tr %r4,10,5,%r6
extrd,*<> %r4,10,5,%r6
extrd,*>= %r4,10,5,%r6
extrd,*ev %r4,10,5,%r6
 
extrd,u,* %r4,%sar,5,%r6
extrd,u,*= %r4,%sar,5,%r6
extrd,u,*< %r4,%sar,5,%r6
extrd,u,*od %r4,%sar,5,%r6
extrd,u,*tr %r4,%sar,5,%r6
extrd,u,*<> %r4,%sar,5,%r6
extrd,u,*>= %r4,%sar,5,%r6
extrd,u,*ev %r4,%sar,5,%r6
extrd,s,* %r4,%sar,5,%r6
extrd,s,*= %r4,%sar,5,%r6
extrd,s,*< %r4,%sar,5,%r6
extrd,s,*od %r4,%sar,5,%r6
extrd,*tr %r4,%sar,5,%r6
extrd,*<> %r4,%sar,5,%r6
extrd,*>= %r4,%sar,5,%r6
extrd,*ev %r4,%sar,5,%r6
/basic/branch.s
0,0 → 1,219
.level 1.1
.code
.align 4
; More branching instructions than you ever knew what to do with.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
branch_tests:
bl branch_tests,%r2
bl,n branch_tests,%r2
b branch_tests
b,n branch_tests
gate branch_tests,%r2
gate,n branch_tests,%r2
blr %r4,%r2
blr,n %r4,%r2
blr %r4,%r0
blr,n %r4,%r0
bv %r0(%r2)
bv,n %r0(%r2)
be 0x1234(%sr1,%r2)
be,n 0x1234(%sr1,%r2)
ble 0x1234(%sr1,%r2)
ble,n 0x1234(%sr1,%r2)
 
movb_tests:
movb %r4,%r26,movb_tests
movb,= %r4,%r26,movb_tests
movb,< %r4,%r26,movb_tests
movb,od %r4,%r26,movb_tests
movb,tr %r4,%r26,movb_tests
movb,<> %r4,%r26,movb_tests
movb,>= %r4,%r26,movb_tests
movb,ev %r4,%r26,movb_tests
movb_nullified_tests:
movb,n %r4,%r26,movb_tests
movb,=,n %r4,%r26,movb_tests
movb,<,n %r4,%r26,movb_tests
movb,od,n %r4,%r26,movb_tests
movb,tr,n %r4,%r26,movb_tests
movb,<>,n %r4,%r26,movb_tests
movb,>=,n %r4,%r26,movb_tests
movb,ev,n %r4,%r26,movb_tests
 
movib_tests:
movib 5,%r26,movib_tests
movib,= 5,%r26,movib_tests
movib,< 5,%r26,movib_tests
movib,od 5,%r26,movib_tests
movib,tr 5,%r26,movib_tests
movib,<> 5,%r26,movib_tests
movib,>= 5,%r26,movib_tests
movib,ev 5,%r26,movib_tests
movib_nullified_tests:
movib,n 5,%r26,movib_tests
movib,=,n 5,%r26,movib_tests
movib,<,n 5,%r26,movib_tests
movib,od,n 5,%r26,movib_tests
movib,tr,n 5,%r26,movib_tests
movib,<>,n 5,%r26,movib_tests
movib,>=,n 5,%r26,movib_tests
movib,ev,n 5,%r26,movib_tests
 
comb_tests:
comb %r0,%r4,comb_tests
comb,= %r0,%r4,comb_tests
comb,< %r0,%r4,comb_tests
comb,<= %r0,%r4,comb_tests
comb,<< %r0,%r4,comb_tests
comb,<<= %r0,%r4,comb_tests
comb,sv %r0,%r4,comb_tests
comb,od %r0,%r4,comb_tests
comb,tr %r0,%r4,comb_tests
comb,<> %r0,%r4,comb_tests
comb,>= %r0,%r4,comb_tests
comb,> %r0,%r4,comb_tests
comb,>>= %r0,%r4,comb_tests
comb,>> %r0,%r4,comb_tests
comb,nsv %r0,%r4,comb_tests
comb,ev %r0,%r4,comb_tests
comb_nullified_tests:
comb,n %r0,%r4,comb_tests
comb,=,n %r0,%r4,comb_tests
comb,<,n %r0,%r4,comb_tests
comb,<=,n %r0,%r4,comb_tests
comb,<<,n %r0,%r4,comb_tests
comb,<<=,n %r0,%r4,comb_tests
comb,sv,n %r0,%r4,comb_tests
comb,od,n %r0,%r4,comb_tests
comb,tr,n %r0,%r4,comb_tests
comb,<>,n %r0,%r4,comb_tests
comb,>=,n %r0,%r4,comb_tests
comb,>,n %r0,%r4,comb_tests
comb,>>=,n %r0,%r4,comb_tests
comb,>>,n %r0,%r4,comb_tests
comb,nsv,n %r0,%r4,comb_tests
comb,ev,n %r0,%r4,comb_tests
 
comib_tests:
comib 0,%r4,comib_tests
comib,< 0,%r4,comib_tests
comib,<= 0,%r4,comib_tests
comib,<< 0,%r4,comib_tests
comib,<<= 0,%r4,comib_tests
comib,sv 0,%r4,comib_tests
comib,od 0,%r4,comib_tests
comib,tr 0,%r4,comib_tests
comib,<> 0,%r4,comib_tests
comib,>= 0,%r4,comib_tests
comib,> 0,%r4,comib_tests
comib,>>= 0,%r4,comib_tests
comib,>> 0,%r4,comib_tests
comib,nsv 0,%r4,comib_tests
comib,ev 0,%r4,comb_tests
 
comib_nullified_tests:
comib,n 0,%r4,comib_tests
comib,=,n 0,%r4,comib_tests
comib,<,n 0,%r4,comib_tests
comib,<=,n 0,%r4,comib_tests
comib,<<,n 0,%r4,comib_tests
comib,<<=,n 0,%r4,comib_tests
comib,sv,n 0,%r4,comib_tests
comib,od,n 0,%r4,comib_tests
comib,tr,n 0,%r4,comib_tests
comib,<>,n 0,%r4,comib_tests
comib,>=,n 0,%r4,comib_tests
comib,>,n 0,%r4,comib_tests
comib,>>=,n 0,%r4,comib_tests
comib,>>,n 0,%r4,comib_tests
comib,nsv,n 0,%r4,comib_tests
comib,ev,n 0,%r4,comib_tests
 
 
 
addb_tests:
addb %r1,%r4,addb_tests
addb,= %r1,%r4,addb_tests
addb,< %r1,%r4,addb_tests
addb,<= %r1,%r4,addb_tests
addb,nuv %r1,%r4,addb_tests
addb,znv %r1,%r4,addb_tests
addb,sv %r1,%r4,addb_tests
addb,od %r1,%r4,addb_tests
addb,tr %r1,%r4,addb_tests
addb,<> %r1,%r4,addb_tests
addb,>= %r1,%r4,addb_tests
addb,> %r1,%r4,addb_tests
addb,uv %r1,%r4,addb_tests
addb,vnz %r1,%r4,addb_tests
addb,nsv %r1,%r4,addb_tests
addb,ev %r1,%r4,addb_tests
addb_nullified_tests:
addb,n %r1,%r4,addb_tests
addb,=,n %r1,%r4,addb_tests
addb,<,n %r1,%r4,addb_tests
addb,<=,n %r1,%r4,addb_tests
addb,nuv,n %r1,%r4,addb_tests
addb,znv,n %r1,%r4,addb_tests
addb,sv,n %r1,%r4,addb_tests
addb,od,n %r1,%r4,addb_tests
addb,tr,n %r1,%r4,addb_tests
addb,<>,n %r1,%r4,addb_tests
addb,>=,n %r1,%r4,addb_tests
addb,>,n %r1,%r4,addb_tests
addb,uv,n %r1,%r4,addb_tests
addb,vnz,n %r1,%r4,addb_tests
addb,nsv,n %r1,%r4,addb_tests
addb,ev,n %r1,%r4,addb_tests
 
addib_tests:
addib -1,%r4,addib_tests
addib,= -1,%r4,addib_tests
addib,< -1,%r4,addib_tests
addib,<= -1,%r4,addib_tests
addib,nuv -1,%r4,addib_tests
addib,znv -1,%r4,addib_tests
addib,sv -1,%r4,addib_tests
addib,od -1,%r4,addib_tests
addib,tr -1,%r4,addib_tests
addib,<> -1,%r4,addib_tests
addib,>= -1,%r4,addib_tests
addib,> -1,%r4,addib_tests
addib,uv -1,%r4,addib_tests
addib,vnz -1,%r4,addib_tests
addib,nsv -1,%r4,addib_tests
addib,ev -1,%r4,comb_tests
 
addib_nullified_tests:
addib,n -1,%r4,addib_tests
addib,=,n -1,%r4,addib_tests
addib,<,n -1,%r4,addib_tests
addib,<=,n -1,%r4,addib_tests
addib,nuv,n -1,%r4,addib_tests
addib,znv,n -1,%r4,addib_tests
addib,sv,n -1,%r4,addib_tests
addib,od,n -1,%r4,addib_tests
addib,tr,n -1,%r4,addib_tests
addib,<>,n -1,%r4,addib_tests
addib,>=,n -1,%r4,addib_tests
addib,>,n -1,%r4,addib_tests
addib,uv,n -1,%r4,addib_tests
addib,vnz,n -1,%r4,addib_tests
addib,nsv,n -1,%r4,addib_tests
addib,ev,n -1,%r4,addib_tests
 
 
; Needs to check lots of stuff (like corner bit cases)
bb_tests:
bvb,< %r4,bb_tests
bvb,>= %r4,bb_tests
bvb,<,n %r4,bb_tests
bvb,>=,n %r4,bb_tests
bb,< %r4,5,bb_tests
bb,>= %r4,5,bb_tests
bb,<,n %r4,5,bb_tests
bb,>=,n %r4,5,bb_tests
/basic/addi.s
0,0 → 1,125
.code
.align 4
; Basic add immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
addi 123,%r5,%r6
addi,= 123,%r5,%r6
addi,< 123,%r5,%r6
addi,<= 123,%r5,%r6
addi,nuv 123,%r5,%r6
addi,znv 123,%r5,%r6
addi,sv 123,%r5,%r6
addi,od 123,%r5,%r6
addi,tr 123,%r5,%r6
addi,<> 123,%r5,%r6
addi,>= 123,%r5,%r6
addi,> 123,%r5,%r6
addi,uv 123,%r5,%r6
addi,vnz 123,%r5,%r6
addi,nsv 123,%r5,%r6
addi,ev 123,%r5,%r6
 
addio 123,%r5,%r6
addio,= 123,%r5,%r6
addio,< 123,%r5,%r6
addio,<= 123,%r5,%r6
addio,nuv 123,%r5,%r6
addio,znv 123,%r5,%r6
addio,sv 123,%r5,%r6
addio,od 123,%r5,%r6
addio,tr 123,%r5,%r6
addio,<> 123,%r5,%r6
addio,>= 123,%r5,%r6
addio,> 123,%r5,%r6
addio,uv 123,%r5,%r6
addio,vnz 123,%r5,%r6
addio,nsv 123,%r5,%r6
addio,ev 123,%r5,%r6
 
addit 123,%r5,%r6
addit,= 123,%r5,%r6
addit,< 123,%r5,%r6
addit,<= 123,%r5,%r6
addit,nuv 123,%r5,%r6
addit,znv 123,%r5,%r6
addit,sv 123,%r5,%r6
addit,od 123,%r5,%r6
addit,tr 123,%r5,%r6
addit,<> 123,%r5,%r6
addit,>= 123,%r5,%r6
addit,> 123,%r5,%r6
addit,uv 123,%r5,%r6
addit,vnz 123,%r5,%r6
addit,nsv 123,%r5,%r6
addit,ev 123,%r5,%r6
 
addito 123,%r5,%r6
addito,= 123,%r5,%r6
addito,< 123,%r5,%r6
addito,<= 123,%r5,%r6
addito,nuv 123,%r5,%r6
addito,znv 123,%r5,%r6
addito,sv 123,%r5,%r6
addito,od 123,%r5,%r6
addito,tr 123,%r5,%r6
addito,<> 123,%r5,%r6
addito,>= 123,%r5,%r6
addito,> 123,%r5,%r6
addito,uv 123,%r5,%r6
addito,vnz 123,%r5,%r6
addito,nsv 123,%r5,%r6
addito,ev 123,%r5,%r6
 
addi,tsv 123,%r5,%r6
addi,tsv,= 123,%r5,%r6
addi,tsv,< 123,%r5,%r6
addi,tsv,<= 123,%r5,%r6
addi,tsv,nuv 123,%r5,%r6
addi,tsv,znv 123,%r5,%r6
addi,tsv,sv 123,%r5,%r6
addi,tsv,od 123,%r5,%r6
addi,tsv,tr 123,%r5,%r6
addi,tsv,<> 123,%r5,%r6
addi,tsv,>= 123,%r5,%r6
addi,tsv,> 123,%r5,%r6
addi,tsv,uv 123,%r5,%r6
addi,tsv,vnz 123,%r5,%r6
addi,tsv,nsv 123,%r5,%r6
addi,tsv,ev 123,%r5,%r6
 
addi,tc 123,%r5,%r6
addi,tc,= 123,%r5,%r6
addi,tc,< 123,%r5,%r6
addi,tc,<= 123,%r5,%r6
addi,tc,nuv 123,%r5,%r6
addi,tc,znv 123,%r5,%r6
addi,tc,sv 123,%r5,%r6
addi,tc,od 123,%r5,%r6
addi,tc,tr 123,%r5,%r6
addi,tc,<> 123,%r5,%r6
addi,tc,>= 123,%r5,%r6
addi,tc,> 123,%r5,%r6
addi,tc,uv 123,%r5,%r6
addi,tc,vnz 123,%r5,%r6
addi,tc,nsv 123,%r5,%r6
addi,tc,ev 123,%r5,%r6
 
addi,tc,tsv 123,%r5,%r6
addi,tc,tsv,= 123,%r5,%r6
addi,tc,tsv,< 123,%r5,%r6
addi,tc,tsv,<= 123,%r5,%r6
addi,tc,tsv,nuv 123,%r5,%r6
addi,tc,tsv,znv 123,%r5,%r6
addi,tc,tsv,sv 123,%r5,%r6
addi,tc,tsv,od 123,%r5,%r6
addi,tsv,tc,tr 123,%r5,%r6
addi,tsv,tc,<> 123,%r5,%r6
addi,tsv,tc,>= 123,%r5,%r6
addi,tsv,tc,> 123,%r5,%r6
addi,tsv,tc,uv 123,%r5,%r6
addi,tsv,tc,vnz 123,%r5,%r6
addi,tsv,tc,nsv 123,%r5,%r6
addi,tsv,tc,ev 123,%r5,%r6
/basic/unit2.s
0,0 → 1,47
.LEVEL 2.0
.code
.align 4
; PA2.0 unit instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
 
uxor,* %r4,%r5,%r6
uxor,*sbz %r4,%r5,%r6
uxor,*shz %r4,%r5,%r6
uxor,*sdc %r4,%r5,%r6
uxor,*sbc %r4,%r5,%r6
uxor,*shc %r4,%r5,%r6
uxor,*tr %r4,%r5,%r6
uxor,*nbz %r4,%r5,%r6
uxor,*nhz %r4,%r5,%r6
uxor,*ndc %r4,%r5,%r6
uxor,*nbc %r4,%r5,%r6
uxor,*nhc %r4,%r5,%r6
 
uaddcm,* %r4,%r5,%r6
uaddcm,*sbz %r4,%r5,%r6
uaddcm,*shz %r4,%r5,%r6
uaddcm,*sdc %r4,%r5,%r6
uaddcm,*sbc %r4,%r5,%r6
uaddcm,*shc %r4,%r5,%r6
uaddcm,*tr %r4,%r5,%r6
uaddcm,*nbz %r4,%r5,%r6
uaddcm,*nhz %r4,%r5,%r6
uaddcm,*ndc %r4,%r5,%r6
uaddcm,*nbc %r4,%r5,%r6
uaddcm,*nhc %r4,%r5,%r6
 
uaddcm,tc,* %r4,%r5,%r6
uaddcm,tc,*sbz %r4,%r5,%r6
uaddcm,tc,*shz %r4,%r5,%r6
uaddcm,tc,*sdc %r4,%r5,%r6
uaddcm,tc,*sbc %r4,%r5,%r6
uaddcm,tc,*shc %r4,%r5,%r6
uaddcm,tc,*tr %r4,%r5,%r6
uaddcm,tc,*nbz %r4,%r5,%r6
uaddcm,tc,*nhz %r4,%r5,%r6
uaddcm,tc,*ndc %r4,%r5,%r6
uaddcm,tc,*nbc %r4,%r5,%r6
uaddcm,tc,*nhc %r4,%r5,%r6
/basic/coprmem.s
0,0 → 1,46
.code
.align 4
; Basic copr memory tests which also test the various
; addressing modes and completers.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
;
copr_indexing_load:
 
cldwx,4 %r5(%sr0,%r4),%r26
cldwx,4,s %r5(%sr0,%r4),%r26
cldwx,4,m %r5(%sr0,%r4),%r26
cldwx,4,sm %r5(%sr0,%r4),%r26
clddx,4 %r5(%sr0,%r4),%r26
clddx,4,s %r5(%sr0,%r4),%r26
clddx,4,m %r5(%sr0,%r4),%r26
clddx,4,sm %r5(%sr0,%r4),%r26
 
copr_indexing_store:
cstwx,4 %r26,%r5(%sr0,%r4)
cstwx,4,s %r26,%r5(%sr0,%r4)
cstwx,4,m %r26,%r5(%sr0,%r4)
cstwx,4,sm %r26,%r5(%sr0,%r4)
cstdx,4 %r26,%r5(%sr0,%r4)
cstdx,4,s %r26,%r5(%sr0,%r4)
cstdx,4,m %r26,%r5(%sr0,%r4)
cstdx,4,sm %r26,%r5(%sr0,%r4)
 
copr_short_memory:
cldws,4 0(%sr0,%r4),%r26
cldws,4,mb 0(%sr0,%r4),%r26
cldws,4,ma 0(%sr0,%r4),%r26
cldds,4 0(%sr0,%r4),%r26
cldds,4,mb 0(%sr0,%r4),%r26
cldds,4,ma 0(%sr0,%r4),%r26
cstws,4 %r26,0(%sr0,%r4)
cstws,4,mb %r26,0(%sr0,%r4)
cstws,4,ma %r26,0(%sr0,%r4)
cstds,4 %r26,0(%sr0,%r4)
cstds,4,mb %r26,0(%sr0,%r4)
cstds,4,ma %r26,0(%sr0,%r4)
 
; gas fucks this up thinks it gets the expression 4 modulo 5
; cldwx,4 %r5(0,%r4),%r%r26
/basic/sh1add.s
0,0 → 1,58
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
sh1add %r4,%r5,%r6
sh1add,= %r4,%r5,%r6
sh1add,< %r4,%r5,%r6
sh1add,<= %r4,%r5,%r6
sh1add,nuv %r4,%r5,%r6
sh1add,znv %r4,%r5,%r6
sh1add,sv %r4,%r5,%r6
sh1add,od %r4,%r5,%r6
sh1add,tr %r4,%r5,%r6
sh1add,<> %r4,%r5,%r6
sh1add,>= %r4,%r5,%r6
sh1add,> %r4,%r5,%r6
sh1add,uv %r4,%r5,%r6
sh1add,vnz %r4,%r5,%r6
sh1add,nsv %r4,%r5,%r6
sh1add,ev %r4,%r5,%r6
 
sh1addl %r4,%r5,%r6
sh1addl,= %r4,%r5,%r6
sh1addl,< %r4,%r5,%r6
sh1addl,<= %r4,%r5,%r6
sh1addl,nuv %r4,%r5,%r6
sh1addl,znv %r4,%r5,%r6
sh1addl,sv %r4,%r5,%r6
sh1addl,od %r4,%r5,%r6
sh1addl,tr %r4,%r5,%r6
sh1addl,<> %r4,%r5,%r6
sh1addl,>= %r4,%r5,%r6
sh1addl,> %r4,%r5,%r6
sh1addl,uv %r4,%r5,%r6
sh1addl,vnz %r4,%r5,%r6
sh1addl,nsv %r4,%r5,%r6
sh1addl,ev %r4,%r5,%r6
 
sh1addo %r4,%r5,%r6
sh1addo,= %r4,%r5,%r6
sh1addo,< %r4,%r5,%r6
sh1addo,<= %r4,%r5,%r6
sh1addo,nuv %r4,%r5,%r6
sh1addo,znv %r4,%r5,%r6
sh1addo,sv %r4,%r5,%r6
sh1addo,od %r4,%r5,%r6
sh1addo,tr %r4,%r5,%r6
sh1addo,<> %r4,%r5,%r6
sh1addo,>= %r4,%r5,%r6
sh1addo,> %r4,%r5,%r6
sh1addo,uv %r4,%r5,%r6
sh1addo,vnz %r4,%r5,%r6
sh1addo,nsv %r4,%r5,%r6
sh1addo,ev %r4,%r5,%r6
 
/basic/purge2.s
0,0 → 1,12
.level 2.0
.code
.align 4
; PA2.0 purge instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
pdtlb,l %r4(%sr0,%r5)
pdtlb,l,m %r4(%sr0,%r5)
pitlb,l %r4(%sr4,%r5)
pitlb,l,m %r4(%sr4,%r5)
/basic/sh3add.s
0,0 → 1,58
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
sh3add %r4,%r5,%r6
sh3add,= %r4,%r5,%r6
sh3add,< %r4,%r5,%r6
sh3add,<= %r4,%r5,%r6
sh3add,nuv %r4,%r5,%r6
sh3add,znv %r4,%r5,%r6
sh3add,sv %r4,%r5,%r6
sh3add,od %r4,%r5,%r6
sh3add,tr %r4,%r5,%r6
sh3add,<> %r4,%r5,%r6
sh3add,>= %r4,%r5,%r6
sh3add,> %r4,%r5,%r6
sh3add,uv %r4,%r5,%r6
sh3add,vnz %r4,%r5,%r6
sh3add,nsv %r4,%r5,%r6
sh3add,ev %r4,%r5,%r6
 
sh3addl %r4,%r5,%r6
sh3addl,= %r4,%r5,%r6
sh3addl,< %r4,%r5,%r6
sh3addl,<= %r4,%r5,%r6
sh3addl,nuv %r4,%r5,%r6
sh3addl,znv %r4,%r5,%r6
sh3addl,sv %r4,%r5,%r6
sh3addl,od %r4,%r5,%r6
sh3addl,tr %r4,%r5,%r6
sh3addl,<> %r4,%r5,%r6
sh3addl,>= %r4,%r5,%r6
sh3addl,> %r4,%r5,%r6
sh3addl,uv %r4,%r5,%r6
sh3addl,vnz %r4,%r5,%r6
sh3addl,nsv %r4,%r5,%r6
sh3addl,ev %r4,%r5,%r6
 
sh3addo %r4,%r5,%r6
sh3addo,= %r4,%r5,%r6
sh3addo,< %r4,%r5,%r6
sh3addo,<= %r4,%r5,%r6
sh3addo,nuv %r4,%r5,%r6
sh3addo,znv %r4,%r5,%r6
sh3addo,sv %r4,%r5,%r6
sh3addo,od %r4,%r5,%r6
sh3addo,tr %r4,%r5,%r6
sh3addo,<> %r4,%r5,%r6
sh3addo,>= %r4,%r5,%r6
sh3addo,> %r4,%r5,%r6
sh3addo,uv %r4,%r5,%r6
sh3addo,vnz %r4,%r5,%r6
sh3addo,nsv %r4,%r5,%r6
sh3addo,ev %r4,%r5,%r6
 
/basic/dcor2.s
0,0 → 1,34
.LEVEL 2.0
.code
.align 4
; PA2.0 decimal correction instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
dcor,* %r4,%r5
dcor,*sbz %r4,%r5
dcor,*shz %r4,%r5
dcor,*sdc %r4,%r5
dcor,*sbc %r4,%r5
dcor,*shc %r4,%r5
dcor,*tr %r4,%r5
dcor,*nbz %r4,%r5
dcor,*nhz %r4,%r5
dcor,*ndc %r4,%r5
dcor,*nbc %r4,%r5
dcor,*nhc %r4,%r5
 
dcor,i,* %r4,%r5
dcor,i,*sbz %r4,%r5
dcor,i,*shz %r4,%r5
dcor,i,*sdc %r4,%r5
dcor,i,*sbc %r4,%r5
dcor,i,*shc %r4,%r5
dcor,i,*tr %r4,%r5
dcor,i,*nbz %r4,%r5
dcor,i,*nhz %r4,%r5
dcor,i,*ndc %r4,%r5
dcor,i,*nbc %r4,%r5
dcor,i,*nhc %r4,%r5
 
/basic/weird.s
0,0 → 1,870
.stabs "weird.c",0x64,0,0,Label0
Label0:
.stabs "inttype:t1=bu4;0;32;",0x80,0,0,0
 
 
.stabs "sym32: !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.stabs "type32:t32= !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
 
.stabs "attr104:G404=@h !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr105:G405=@i !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "var0:G300=@a8;1",0x20,0,0, 0
.export var0
.data
.align 4
var0:
.long 42
 
.stabs "sym33:! !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym35:# !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym36:$ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym37:% !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym38:& !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym39:' !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym40:( !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym41:) !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym42:* !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym43:+ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym44:, !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym45:- !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.export attr122
.data
.align 4
attr122:
.long 42
.export attr123
.data
.align 4
attr123:
.long 42
.export attr124
.data
.align 4
attr124:
.long 42
 
.stabs "sym46:. !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym47:/ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym48:0 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym49:1 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym50:2 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.stabs "attr96:G396=@` !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr97:G397=@a !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr98:G398=@b !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr99:G399=@c !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "sym51:3 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym52:4 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym53:5 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym54:6 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym55:7 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym56:8 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym57:9 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym58:: !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym59:; !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym60:< !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym61:= !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym62:> !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym63:? !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym64:@ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym65:A !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym66:B !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym67:C !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym68:D !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym69:E !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym70:F !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym71:G !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym72:H !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym73:I !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym74:J !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym75:K !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym76:L !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym77:M !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym78:N !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym79:O !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym80:P !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym81:Q !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym82:R !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym83:S !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym84:T !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym85:U !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym86:V !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym87:W !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym88:X !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym89:Y !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym90:Z !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym91:[ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.stabs "sym93:] !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym94:^ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym95:_ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym96:` !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym97:a !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym98:b !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym99:c !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym100:d !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym101:e !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym102:f !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym103:g !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym104:h !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym105:i !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym106:j !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym107:k !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym108:l !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym109:m !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym110:n !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym111:o !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym112:p !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym113:q !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym114:r !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym115:s !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym116:t !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym117:u !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym118:v !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym119:w !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym120:x !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym121:y !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym122:z !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym123:{ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym124:| !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym125:} !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "sym126:~ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.stabs "type33:t33=! !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type35:t35=# !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type36:t36=$ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type37:t37=% !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type38:t38=& !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type39:t39=' !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type40:t40=( !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type41:t41=) !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type42:t42=* !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type43:t43=+ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type44:t44=, !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type45:t45=- !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type46:t46=. !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type47:t47=/ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type48:t48=0 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type49:t49=1 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type50:t50=2 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type51:t51=3 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type52:t52=4 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type53:t53=5 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type54:t54=6 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type55:t55=7 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type56:t56=8 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type57:t57=9 !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type58:t58=: !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type59:t59=; !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type60:t60=< !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type61:t61== !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type62:t62=> !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type63:t63=? !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type64:t64=@ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type65:t65=A !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type66:t66=B !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type67:t67=C !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.export attr66
.data
.align 4
attr66:
.long 42
.export attr67
.data
.align 4
attr67:
.long 42
.export attr68
.data
.align 4
attr68:
.long 42
.export attr69
.data
.align 4
attr69:
.long 42
 
.stabs "type68:t68=D !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type69:t69=E !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type70:t70=F !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type71:t71=G !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type72:t72=H !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type73:t73=I !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type74:t74=J !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type75:t75=K !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type76:t76=L !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type77:t77=M !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type78:t78=N !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type79:t79=O !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type80:t80=P !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type81:t81=Q !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type82:t82=R !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type83:t83=S !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type84:t84=T !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type85:t85=U !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type86:t86=V !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type87:t87=W !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.stabs "attr69:G369=@E !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr70:G370=@F !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr71:G371=@G !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "type88:t88=X !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type89:t89=Y !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type90:t90=Z !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type91:t91=[ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.stabs "type93:t93=] !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type94:t94=^ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type95:t95=_ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type96:t96=` !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type97:t97=a !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type98:t98=b !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type99:t99=c !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type100:t100=d !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type101:t101=e !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type102:t102=f !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type103:t103=g !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type104:t104=h !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type105:t105=i !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type106:t106=j !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type107:t107=k !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type108:t108=l !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type109:t109=m !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type110:t110=n !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type111:t111=o !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type112:t112=p !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type113:t113=q !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type114:t114=r !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type115:t115=s !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type116:t116=t !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type117:t117=u !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type118:t118=v !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type119:t119=w !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type120:t120=x !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type121:t121=y !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type122:t122=z !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type123:t123={ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type124:t124=| !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type125:t125=} !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type126:t126=~ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
 
.stabs "attr32:G332=@ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr33:G333=@! !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr35:G334=@# !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "primary:G200=ered:0,green:1,blue:2,;", 0x20,0,0, 0
 
.stabs "attr36:G335=@$ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.export primary
.data
.align 4
primary:
.long 42
 
.stabs "attr37:G337=@% !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "const69:c=e1,69", 0x80,0,0, 0
 
.stabs "const70:c=e190=bs2;0;16;,70", 0x80,0,0, 0
 
.stabs "attr38:G338=@& !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "bad_neg0type:t201=s8field0:1,0,32;field2:-534,32,64;field3:-1,96,32;;", 0x80,0,0, 0
 
.stabs "bad_neg0:G201", 0x20,0,0, 0
 
.export bad_neg0
.data
.align 4
bad_neg0:
.long 42
.long 43, 44, 45
 
.stabs "attr39:G339=@' !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr41:G341=@) !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr42:G342=@* !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr43:G343=@+ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr44:G344=@, !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr46:G346=@. !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr47:G347=@/ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr58:G358=@: !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "attr59:G359=@;@ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "attr60:G360=@< !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr61:G361=@= !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr62:G362=@> !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr63:G363=@? !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr64:G364=@@ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr65:G365=@A !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr66:G366=@B !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr67:G367=@C !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr68:G368=@D !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr72:G372=@H !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr73:G373=@I !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr74:G374=@J !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr75:G375=@K !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr76:G376=@L !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr77:G377=@M !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr78:G378=@N !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr79:G379=@O !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr80:G380=@P !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr81:G381=@Q !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr82:G382=@R !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr83:G383=@S !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr84:G384=@T !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr85:G385=@U !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr86:G386=@V !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr87:G387=@W !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr88:G388=@X !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr89:G389=@Y !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr90:G390=@Z !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr91:G391=@[ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.stabs "attr93:G393=@] !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
 
.export _common0
.data
.align 4
_common0:
.long 42
.long 24
.long 22
.export common0
.data
.align 4
common0:
.long 42
.long 24
.long 22
.stabs "common0",0xe2,0,0,0
.stabs "common0var0:S1", 0x20,0,0, 0
.stabs "common0var1:S1", 0x20,0,0, 4
.stabs "common0var2:S1", 0x20,0,0, 8
.stabs "common0",0xe4,0,0,0
 
.stabs "attr94:G394=@^ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr95:G395=@_ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr100:G400=@d !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr101:G401=@e !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr102:G402=@f !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr103:G403=@g !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr106:G406=@j !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr107:G407=@k !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr108:G408=@l !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr109:G409=@m !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr110:G410=@n !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr111:G411=@o !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr112:G412=@p !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr113:G413=@q !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr114:G414=@r !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr115:G415=@s !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr116:G416=@t !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr117:G417=@u !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr118:G418=@v !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr119:G419=@w !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr120:G420=@x !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr121:G421=@y !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr122:G422=@z !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr123:G423=@{ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr124:G424=@| !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr125:G425=@} !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
.stabs "attr126:G426=@~ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
 
.export attr32
.data
.align 4
attr32:
.long 42
.export attr33
.data
.align 4
attr33:
.long 42
.export attr35
.data
.align 4
attr35:
.long 42
.export attr36
.data
.align 4
attr36:
.long 42
.export attr37
.data
.align 4
attr37:
.long 42
.export attr38
.data
.align 4
attr38:
.long 42
.export attr39
.data
.align 4
attr39:
.long 42
.export attr41
.data
.align 4
attr41:
.long 42
.export attr42
.data
.align 4
attr42:
.long 42
.export attr43
.data
.align 4
attr43:
.long 42
.export attr44
.data
.align 4
attr44:
.long 42
.export attr46
.data
.align 4
attr46:
.long 42
.export attr47
.data
.align 4
attr47:
.long 42
.export attr58
.data
.align 4
attr58:
.long 42
.export attr59
.data
.align 4
attr59:
.long 42
.export attr60
.data
.align 4
attr60:
.long 42
.export attr61
.data
.align 4
attr61:
.long 42
.export attr62
.data
.align 4
attr62:
.long 42
.export attr63
.data
.align 4
attr63:
.long 42
.export attr64
.data
.align 4
attr64:
.long 42
.export attr65
.data
.align 4
attr65:
.long 42
.export attr70
.data
.align 4
attr70:
.long 42
.export attr71
.data
.align 4
attr71:
.long 42
.export attr72
.data
.align 4
attr72:
.long 42
.export attr73
.data
.align 4
attr73:
.long 42
.export attr74
.data
.align 4
attr74:
.long 42
.export attr75
.data
.align 4
attr75:
.long 42
.export attr76
.data
.align 4
attr76:
.long 42
.export attr77
.data
.align 4
attr77:
.long 42
.export attr78
.data
.align 4
attr78:
.long 42
.export attr79
.data
.align 4
attr79:
.long 42
.export attr80
.data
.align 4
attr80:
.long 42
.export attr81
.data
.align 4
attr81:
.long 42
.export attr82
.data
.align 4
attr82:
.long 42
.export attr83
.data
.align 4
attr83:
.long 42
.export attr84
.data
.align 4
attr84:
.long 42
 
.stabs "float72type:t202=R87;9;", 0x80,0,0, 0
 
.stabs "int256var:G203=bu32;0;256;", 0x20,0,0, 0
.export int256var
.data
.align 4
int256var:
.long 42
.long 0x2b, 0x2c, 0x2d, 0x2d, 0x2c, 0x2b, 0x2a
 
 
.stabs "consth:c=e1,4294967296", 0x80,0,0, 0
 
.stabs "consth2:c=e1,-734723985732642758928475678987234563284937456", 0x80,0,0, 0
 
.stabs "bad_neg0const:c=S201,128,128,11222211343434345656565677888877", 0x80,0,0, 0
 
.stabs "bad_type0:t(-3,7)", 0x80,0,0, 0
.stabs "bad_type1:t(42,6)", 0x80,0,0, 0
 
.stabs "array_index0:t205=r1;0;5;", 0x80,0,0, 0
.stabs "array0:G206=a205;1", 0x20,0,0, 0
.export array0
.data
.align 4
array0:
.long 42
.long 43, 44, 45, 46, 47
 
.stabs "array_index1:t207=", 0x80,0,0, 0
.stabs "array1:G208=aeai1_red:0,ai1_green:1,ai1_blue:2,;;1", 0x20,0,0, 0
.export array1
.data
.align 4
array1:
.long 42
.long 43, 44
 
.stabs "inttype_one:t209=1", 0x80,0,0, 0
.stabs "inttype_two:t210=1", 0x80,0,0, 0
.stabs "one_var:G209", 0x20,0,0, 0
.export one_var
.data
.align 4
one_var:
.long 42
.stabs "two_var:G210", 0x20,0,0, 0
.export two_var
.data
.align 4
two_var:
.long 42
 
.stabs "intp:t211=*1", 0x80,0,0, 0
.stabs "pointer_to_int_var:G212=*1", 0x80,0,0, 0
.stabs "intp_var:G211", 0x20,0,0, 0
.export intp_var
.data
.align 4
intp_var:
.long 42
 
.stabs "unrecog_const:c=xjksdflskd33,4;473;", 0x80,0,0, 0
 
.export attr85
.data
.align 4
attr85:
.long 42
.export attr86
.data
.align 4
attr86:
.long 42
.export attr87
.data
.align 4
attr87:
.long 42
.export attr88
.data
.align 4
attr88:
.long 42
.export attr89
.data
.align 4
attr89:
.long 42
.export attr90
.data
.align 4
attr90:
.long 42
.export attr91
.data
.align 4
attr91:
.long 42
.export attr92
.data
.align 4
attr92:
.long 42
.export attr93
.data
.align 4
attr93:
.long 42
.export attr94
.data
.align 4
attr94:
.long 42
.export attr95
.data
.align 4
attr95:
.long 42
.export attr96
.data
.align 4
attr96:
.long 42
.export attr97
.data
.align 4
attr97:
.long 42
.export attr98
.data
.align 4
attr98:
.long 42
.export attr99
.data
.align 4
attr99:
.long 42
.export attr100
.data
.align 4
attr100:
.long 42
.export attr101
.data
.align 4
attr101:
.long 42
.export attr102
.data
.align 4
attr102:
.long 42
.export attr103
.data
.align 4
attr103:
.long 42
.export attr104
.data
.align 4
attr104:
.long 42
.export attr105
.data
.align 4
attr105:
.long 42
.export attr106
.data
.align 4
attr106:
.long 42
.export attr107
.data
.align 4
attr107:
.long 42
.export attr108
.data
.align 4
attr108:
.long 42
.export attr109
.data
.align 4
attr109:
.long 42
.export attr110
.data
.align 4
attr110:
.long 42
.export attr111
.data
.align 4
attr111:
.long 42
.export attr112
.data
.align 4
attr112:
.long 42
.export attr113
.data
.align 4
attr113:
.long 42
.export attr114
.data
.align 4
attr114:
.long 42
.export attr115
.data
.align 4
attr115:
.long 42
.export attr116
.data
.align 4
attr116:
.long 42
.export attr117
.data
.align 4
attr117:
.long 42
.export attr118
.data
.align 4
attr118:
.long 42
.export attr119
.data
.align 4
attr119:
.long 42
.export attr120
.data
.align 4
attr120:
.long 42
.export attr121
.data
.align 4
attr121:
.long 42
.export attr125
.data
.align 4
attr125:
.long 42
.export attr126
.data
.align 4
attr126:
.long 42
 
.stabs "var1:G301=@s32;1",0x20,0,0, 0
.export var1
.data
.align 4
var1:
.long 42
.stabs "var2:G302=@p42;1",0x20,0,0, 0
.export var2
.data
.align 4
var2:
.long 42
.stabs "var3:G303=@P;1",0x20,0,0, 0
.export var3
.data
.align 4
var3:
.long 42
 
 
 
 
 
 
 
 
 
 
 
 
.stabs "v_comb:G448=s24!2,020,445=s12!1,120,444=s4x:1,0,32;;;$vb444:446=*444,0;a:/01,32,32;;;0264,447=s12!1,120,444;$vb444:446,0;b:/01,32,32;;;comb:/01,128,32;;", 0x20,0,0, 0
 
.export v_comb
.align 1
v_comb:
.long v_comb_shared
.long 43
.long v_comb_shared
.long 44
.long 45
v_comb_shared:
.long 42
 
.stabs "sym92:\\ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "type92:t92=\\ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~",0x80,0,0,0
.stabs "attr92:G392=@\\ !#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~;1",0x20,0,0, 0
/basic/add2.s
0,0 → 1,92
.LEVEL 2.0
.code
.align 4
; Basic add/sh?add instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
add,* %r4,%r5,%r6
add,*= %r4,%r5,%r6
add,*< %r4,%r5,%r6
add,*<= %r4,%r5,%r6
add,*nuv %r4,%r5,%r6
add,*znv %r4,%r5,%r6
add,*sv %r4,%r5,%r6
add,*od %r4,%r5,%r6
add,*tr %r4,%r5,%r6
add,*<> %r4,%r5,%r6
add,*>= %r4,%r5,%r6
add,*> %r4,%r5,%r6
add,*uv %r4,%r5,%r6
add,*vnz %r4,%r5,%r6
add,*nsv %r4,%r5,%r6
add,*ev %r4,%r5,%r6
 
add,l,* %r4,%r5,%r6
add,l,*= %r4,%r5,%r6
add,l,*< %r4,%r5,%r6
add,l,*<= %r4,%r5,%r6
add,l,*nuv %r4,%r5,%r6
add,l,*znv %r4,%r5,%r6
add,l,*sv %r4,%r5,%r6
add,l,*od %r4,%r5,%r6
add,l,*tr %r4,%r5,%r6
add,l,*<> %r4,%r5,%r6
add,l,*>= %r4,%r5,%r6
add,l,*> %r4,%r5,%r6
add,l,*uv %r4,%r5,%r6
add,l,*vnz %r4,%r5,%r6
add,l,*nsv %r4,%r5,%r6
add,l,*ev %r4,%r5,%r6
 
add,tsv,* %r4,%r5,%r6
add,tsv,*= %r4,%r5,%r6
add,tsv,*< %r4,%r5,%r6
add,tsv,*<= %r4,%r5,%r6
add,tsv,*nuv %r4,%r5,%r6
add,tsv,*znv %r4,%r5,%r6
add,tsv,*sv %r4,%r5,%r6
add,tsv,*od %r4,%r5,%r6
add,tsv,*tr %r4,%r5,%r6
add,tsv,*<> %r4,%r5,%r6
add,tsv,*>= %r4,%r5,%r6
add,tsv,*> %r4,%r5,%r6
add,tsv,*uv %r4,%r5,%r6
add,tsv,*vnz %r4,%r5,%r6
add,tsv,*nsv %r4,%r5,%r6
add,tsv,*ev %r4,%r5,%r6
 
add,dc,* %r4,%r5,%r6
add,dc,*= %r4,%r5,%r6
add,dc,*< %r4,%r5,%r6
add,dc,*<= %r4,%r5,%r6
add,dc,*nuv %r4,%r5,%r6
add,dc,*znv %r4,%r5,%r6
add,dc,*sv %r4,%r5,%r6
add,dc,*od %r4,%r5,%r6
add,dc,*tr %r4,%r5,%r6
add,dc,*<> %r4,%r5,%r6
add,dc,*>= %r4,%r5,%r6
add,dc,*> %r4,%r5,%r6
add,dc,*uv %r4,%r5,%r6
add,dc,*vnz %r4,%r5,%r6
add,dc,*nsv %r4,%r5,%r6
add,dc,*ev %r4,%r5,%r6
 
add,dc,tsv,* %r4,%r5,%r6
add,dc,tsv,*= %r4,%r5,%r6
add,dc,tsv,*< %r4,%r5,%r6
add,dc,tsv,*<= %r4,%r5,%r6
add,dc,tsv,*nuv %r4,%r5,%r6
add,dc,tsv,*znv %r4,%r5,%r6
add,dc,tsv,*sv %r4,%r5,%r6
add,dc,tsv,*od %r4,%r5,%r6
add,tsv,dc,*tr %r4,%r5,%r6
add,tsv,dc,*<> %r4,%r5,%r6
add,tsv,dc,*>= %r4,%r5,%r6
add,tsv,dc,*> %r4,%r5,%r6
add,tsv,dc,*uv %r4,%r5,%r6
add,tsv,dc,*vnz %r4,%r5,%r6
add,tsv,dc,*nsv %r4,%r5,%r6
add,tsv,dc,*ev %r4,%r5,%r6
/basic/fp_fcmp.s
0,0 → 1,105
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
fcmp,sgl,false? %fr4,%fr5
fcmp,sgl,false %fr4,%fr5
fcmp,sgl,? %fr4,%fr5
fcmp,sgl,!<=> %fr4,%fr5
fcmp,sgl,= %fr4,%fr5
fcmp,sgl,=T %fr4,%fr5
fcmp,sgl,?= %fr4,%fr5
fcmp,sgl,!<> %fr4,%fr5
fcmp,sgl,!?>= %fr4,%fr5
fcmp,sgl,< %fr4,%fr5
fcmp,sgl,?< %fr4,%fr5
fcmp,sgl,!>= %fr4,%fr5
fcmp,sgl,!?> %fr4,%fr5
fcmp,sgl,<= %fr4,%fr5
fcmp,sgl,?<= %fr4,%fr5
fcmp,sgl,!> %fr4,%fr5
fcmp,sgl,!?<= %fr4,%fr5
fcmp,sgl,> %fr4,%fr5
fcmp,sgl,?> %fr4,%fr5
fcmp,sgl,!<= %fr4,%fr5
fcmp,sgl,!?< %fr4,%fr5
fcmp,sgl,>= %fr4,%fr5
fcmp,sgl,?>= %fr4,%fr5
fcmp,sgl,!< %fr4,%fr5
fcmp,sgl,!?= %fr4,%fr5
fcmp,sgl,<> %fr4,%fr5
fcmp,sgl,!= %fr4,%fr5
fcmp,sgl,!=T %fr4,%fr5
fcmp,sgl,!? %fr4,%fr5
fcmp,sgl,<=> %fr4,%fr5
fcmp,sgl,true? %fr4,%fr5
fcmp,sgl,true %fr4,%fr5
 
fcmp,dbl,false? %fr4,%fr5
fcmp,dbl,false %fr4,%fr5
fcmp,dbl,? %fr4,%fr5
fcmp,dbl,!<=> %fr4,%fr5
fcmp,dbl,= %fr4,%fr5
fcmp,dbl,=T %fr4,%fr5
fcmp,dbl,?= %fr4,%fr5
fcmp,dbl,!<> %fr4,%fr5
fcmp,dbl,!?>= %fr4,%fr5
fcmp,dbl,< %fr4,%fr5
fcmp,dbl,?< %fr4,%fr5
fcmp,dbl,!>= %fr4,%fr5
fcmp,dbl,!?> %fr4,%fr5
fcmp,dbl,<= %fr4,%fr5
fcmp,dbl,?<= %fr4,%fr5
fcmp,dbl,!> %fr4,%fr5
fcmp,dbl,!?<= %fr4,%fr5
fcmp,dbl,> %fr4,%fr5
fcmp,dbl,?> %fr4,%fr5
fcmp,dbl,!<= %fr4,%fr5
fcmp,dbl,!?< %fr4,%fr5
fcmp,dbl,>= %fr4,%fr5
fcmp,dbl,?>= %fr4,%fr5
fcmp,dbl,!< %fr4,%fr5
fcmp,dbl,!?= %fr4,%fr5
fcmp,dbl,<> %fr4,%fr5
fcmp,dbl,!= %fr4,%fr5
fcmp,dbl,!=T %fr4,%fr5
fcmp,dbl,!? %fr4,%fr5
fcmp,dbl,<=> %fr4,%fr5
fcmp,dbl,true? %fr4,%fr5
fcmp,dbl,true %fr4,%fr5
 
fcmp,quad,false? %fr4,%fr5
fcmp,quad,false %fr4,%fr5
fcmp,quad,? %fr4,%fr5
fcmp,quad,!<=> %fr4,%fr5
fcmp,quad,= %fr4,%fr5
fcmp,quad,=T %fr4,%fr5
fcmp,quad,?= %fr4,%fr5
fcmp,quad,!<> %fr4,%fr5
fcmp,quad,!?>= %fr4,%fr5
fcmp,quad,< %fr4,%fr5
fcmp,quad,?< %fr4,%fr5
fcmp,quad,!>= %fr4,%fr5
fcmp,quad,!?> %fr4,%fr5
fcmp,quad,<= %fr4,%fr5
fcmp,quad,?<= %fr4,%fr5
fcmp,quad,!> %fr4,%fr5
fcmp,quad,!?<= %fr4,%fr5
fcmp,quad,> %fr4,%fr5
fcmp,quad,?> %fr4,%fr5
fcmp,quad,!<= %fr4,%fr5
fcmp,quad,!?< %fr4,%fr5
fcmp,quad,>= %fr4,%fr5
fcmp,quad,?>= %fr4,%fr5
fcmp,quad,!< %fr4,%fr5
fcmp,quad,!?= %fr4,%fr5
fcmp,quad,<> %fr4,%fr5
fcmp,quad,!= %fr4,%fr5
fcmp,quad,!=T %fr4,%fr5
fcmp,quad,!? %fr4,%fr5
fcmp,quad,<=> %fr4,%fr5
fcmp,quad,true? %fr4,%fr5
fcmp,quad,true %fr4,%fr5
/basic/logical.s
0,0 → 1,52
.level 1.1
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
or %r4,%r5,%r6
or,= %r4,%r5,%r6
or,< %r4,%r5,%r6
or,<= %r4,%r5,%r6
or,od %r4,%r5,%r6
or,tr %r4,%r5,%r6
or,<> %r4,%r5,%r6
or,>= %r4,%r5,%r6
or,> %r4,%r5,%r6
or,ev %r4,%r5,%r6
 
xor %r4,%r5,%r6
xor,= %r4,%r5,%r6
xor,< %r4,%r5,%r6
xor,<= %r4,%r5,%r6
xor,od %r4,%r5,%r6
xor,tr %r4,%r5,%r6
xor,<> %r4,%r5,%r6
xor,>= %r4,%r5,%r6
xor,> %r4,%r5,%r6
xor,ev %r4,%r5,%r6
 
and %r4,%r5,%r6
and,= %r4,%r5,%r6
and,< %r4,%r5,%r6
and,<= %r4,%r5,%r6
and,od %r4,%r5,%r6
and,tr %r4,%r5,%r6
and,<> %r4,%r5,%r6
and,>= %r4,%r5,%r6
and,> %r4,%r5,%r6
and,ev %r4,%r5,%r6
 
andcm %r4,%r5,%r6
andcm,= %r4,%r5,%r6
andcm,< %r4,%r5,%r6
andcm,<= %r4,%r5,%r6
andcm,od %r4,%r5,%r6
andcm,tr %r4,%r5,%r6
andcm,<> %r4,%r5,%r6
andcm,>= %r4,%r5,%r6
andcm,> %r4,%r5,%r6
andcm,ev %r4,%r5,%r6
 
/basic/unit.s
0,0 → 1,60
.level 1.1
.code
.align 4
; Basic unit instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
 
uxor %r4,%r5,%r6
uxor,sbz %r4,%r5,%r6
uxor,shz %r4,%r5,%r6
uxor,sdc %r4,%r5,%r6
uxor,sbc %r4,%r5,%r6
uxor,shc %r4,%r5,%r6
uxor,tr %r4,%r5,%r6
uxor,nbz %r4,%r5,%r6
uxor,nhz %r4,%r5,%r6
uxor,ndc %r4,%r5,%r6
uxor,nbc %r4,%r5,%r6
uxor,nhc %r4,%r5,%r6
 
uaddcm %r4,%r5,%r6
uaddcm,sbz %r4,%r5,%r6
uaddcm,shz %r4,%r5,%r6
uaddcm,sdc %r4,%r5,%r6
uaddcm,sbc %r4,%r5,%r6
uaddcm,shc %r4,%r5,%r6
uaddcm,tr %r4,%r5,%r6
uaddcm,nbz %r4,%r5,%r6
uaddcm,nhz %r4,%r5,%r6
uaddcm,ndc %r4,%r5,%r6
uaddcm,nbc %r4,%r5,%r6
uaddcm,nhc %r4,%r5,%r6
 
uaddcmt %r4,%r5,%r6
uaddcmt,sbz %r4,%r5,%r6
uaddcmt,shz %r4,%r5,%r6
uaddcmt,sdc %r4,%r5,%r6
uaddcmt,sbc %r4,%r5,%r6
uaddcmt,shc %r4,%r5,%r6
uaddcmt,tr %r4,%r5,%r6
uaddcmt,nbz %r4,%r5,%r6
uaddcmt,nhz %r4,%r5,%r6
uaddcmt,ndc %r4,%r5,%r6
uaddcmt,nbc %r4,%r5,%r6
uaddcmt,nhc %r4,%r5,%r6
 
uaddcm,tc %r4,%r5,%r6
uaddcm,tc,sbz %r4,%r5,%r6
uaddcm,tc,shz %r4,%r5,%r6
uaddcm,tc,sdc %r4,%r5,%r6
uaddcm,tc,sbc %r4,%r5,%r6
uaddcm,tc,shc %r4,%r5,%r6
uaddcm,tc,tr %r4,%r5,%r6
uaddcm,tc,nbz %r4,%r5,%r6
uaddcm,tc,nhz %r4,%r5,%r6
uaddcm,tc,ndc %r4,%r5,%r6
uaddcm,tc,nbc %r4,%r5,%r6
uaddcm,tc,nhc %r4,%r5,%r6
/basic/comclr.s
0,0 → 1,41
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
comclr %r4,%r5,%r6
comclr,= %r4,%r5,%r6
comclr,< %r4,%r5,%r6
comclr,<= %r4,%r5,%r6
comclr,<< %r4,%r5,%r6
comclr,<<= %r4,%r5,%r6
comclr,sv %r4,%r5,%r6
comclr,od %r4,%r5,%r6
comclr,tr %r4,%r5,%r6
comclr,<> %r4,%r5,%r6
comclr,>= %r4,%r5,%r6
comclr,> %r4,%r5,%r6
comclr,>>= %r4,%r5,%r6
comclr,>> %r4,%r5,%r6
comclr,nsv %r4,%r5,%r6
comclr,ev %r4,%r5,%r6
 
comiclr 123,%r5,%r6
comiclr,= 123,%r5,%r6
comiclr,< 123,%r5,%r6
comiclr,<= 123,%r5,%r6
comiclr,<< 123,%r5,%r6
comiclr,<<= 123,%r5,%r6
comiclr,sv 123,%r5,%r6
comiclr,od 123,%r5,%r6
comiclr,tr 123,%r5,%r6
comiclr,<> 123,%r5,%r6
comiclr,>= 123,%r5,%r6
comiclr,> 123,%r5,%r6
comiclr,>>= 123,%r5,%r6
comiclr,>> 123,%r5,%r6
comiclr,nsv 123,%r5,%r6
comiclr,ev 123,%r5,%r6
 
/basic/media.s
0,0 → 1,38
.LEVEL 2.0
.code
.align 4
; PA2.0 multimedia (halfword) instruction tests
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
 
hadd %r7,%r11,%r12
hadd,ss %r7,%r11,%r12
hadd,us %r7,%r11,%r12
 
havg %r7,%r11,%r12
hshl %r7,13,%r11
hshladd %r7,1,%r11,%r12
hshladd %r7,2,%r11,%r12
hshladd %r7,3,%r11,%r12
hshr %r7,13,%r11
hshr,s %r7,13,%r11
hshr,u %r7,13,%r11
hshradd %r7,1,%r11,%r12
hshradd %r7,2,%r11,%r12
hshradd %r7,3,%r11,%r12
 
hsub %r14,%r22,%r9
hsub,ss %r14,%r22,%r9
hsub,us %r14,%r22,%r9
 
mixh,l %r14,%r22,%r9
mixh,r %r14,%r22,%r9
mixw,l %r14,%r22,%r9
mixw,r %r14,%r22,%r9
 
permh,0321 %r22,%r9
permh,2222 %r22,%r9
permh,3030 %r22,%r9
 
/basic/spop.s
0,0 → 1,25
.code
.align 4
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
spop_tests:
spop0,4,5
spop0,4,115
spop0,4,5,n
spop0,4,115,n
spop1,4,5 %r5
spop1,4,115 %r5
spop1,4,5,n %r5
spop1,4,115,n %r5
spop2,4,5 %r5
spop2,4,115 %r5
spop2,4,5,n %r5
spop2,4,115,n %r5
spop3,4,5 %r5,%r6
spop3,4,115 %r5,%r6
spop3,4,5,n %r5,%r6
spop3,4,115,n %r5,%r6
 
; Gas fucks this up... Thinks it has the expression 5 mod r5.
; spop1,4,5 %r5
/basic/shladd2.s
0,0 → 1,161
.LEVEL 2.0
.code
.align 4
; PA2.0 shladd instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
shladd,* %r4,1,%r5,%r6
shladd,*= %r4,1,%r5,%r6
shladd,*< %r4,1,%r5,%r6
shladd,*<= %r4,1,%r5,%r6
shladd,*nuv %r4,1,%r5,%r6
shladd,*znv %r4,1,%r5,%r6
shladd,*sv %r4,1,%r5,%r6
shladd,*od %r4,1,%r5,%r6
shladd,*tr %r4,1,%r5,%r6
shladd,*<> %r4,1,%r5,%r6
shladd,*>= %r4,1,%r5,%r6
shladd,*> %r4,1,%r5,%r6
shladd,*uv %r4,1,%r5,%r6
shladd,*vnz %r4,1,%r5,%r6
shladd,*nsv %r4,1,%r5,%r6
shladd,*ev %r4,1,%r5,%r6
 
shladd,l,* %r4,1,%r5,%r6
shladd,l,*= %r4,1,%r5,%r6
shladd,l,*< %r4,1,%r5,%r6
shladd,l,*<= %r4,1,%r5,%r6
shladd,l,*nuv %r4,1,%r5,%r6
shladd,l,*znv %r4,1,%r5,%r6
shladd,l,*sv %r4,1,%r5,%r6
shladd,l,*od %r4,1,%r5,%r6
shladd,l,*tr %r4,1,%r5,%r6
shladd,l,*<> %r4,1,%r5,%r6
shladd,l,*>= %r4,1,%r5,%r6
shladd,l,*> %r4,1,%r5,%r6
shladd,l,*uv %r4,1,%r5,%r6
shladd,l,*vnz %r4,1,%r5,%r6
shladd,l,*nsv %r4,1,%r5,%r6
shladd,l,*ev %r4,1,%r5,%r6
 
shladd,tsv,* %r4,1,%r5,%r6
shladd,tsv,*= %r4,1,%r5,%r6
shladd,tsv,*< %r4,1,%r5,%r6
shladd,tsv,*<= %r4,1,%r5,%r6
shladd,tsv,*nuv %r4,1,%r5,%r6
shladd,tsv,*znv %r4,1,%r5,%r6
shladd,tsv,*sv %r4,1,%r5,%r6
shladd,tsv,*od %r4,1,%r5,%r6
shladd,tsv,*tr %r4,1,%r5,%r6
shladd,tsv,*<> %r4,1,%r5,%r6
shladd,tsv,*>= %r4,1,%r5,%r6
shladd,tsv,*> %r4,1,%r5,%r6
shladd,tsv,*uv %r4,1,%r5,%r6
shladd,tsv,*vnz %r4,1,%r5,%r6
shladd,tsv,*nsv %r4,1,%r5,%r6
shladd,tsv,*ev %r4,1,%r5,%r6
 
shladd,* %r4,2,%r5,%r6
shladd,*= %r4,2,%r5,%r6
shladd,*< %r4,2,%r5,%r6
shladd,*<= %r4,2,%r5,%r6
shladd,*nuv %r4,2,%r5,%r6
shladd,*znv %r4,2,%r5,%r6
shladd,*sv %r4,2,%r5,%r6
shladd,*od %r4,2,%r5,%r6
shladd,*tr %r4,2,%r5,%r6
shladd,*<> %r4,2,%r5,%r6
shladd,*>= %r4,2,%r5,%r6
shladd,*> %r4,2,%r5,%r6
shladd,*uv %r4,2,%r5,%r6
shladd,*vnz %r4,2,%r5,%r6
shladd,*nsv %r4,2,%r5,%r6
shladd,*ev %r4,2,%r5,%r6
 
shladd,l,* %r4,2,%r5,%r6
shladd,l,*= %r4,2,%r5,%r6
shladd,l,*< %r4,2,%r5,%r6
shladd,l,*<= %r4,2,%r5,%r6
shladd,l,*nuv %r4,2,%r5,%r6
shladd,l,*znv %r4,2,%r5,%r6
shladd,l,*sv %r4,2,%r5,%r6
shladd,l,*od %r4,2,%r5,%r6
shladd,l,*tr %r4,2,%r5,%r6
shladd,l,*<> %r4,2,%r5,%r6
shladd,l,*>= %r4,2,%r5,%r6
shladd,l,*> %r4,2,%r5,%r6
shladd,l,*uv %r4,2,%r5,%r6
shladd,l,*vnz %r4,2,%r5,%r6
shladd,l,*nsv %r4,2,%r5,%r6
shladd,l,*ev %r4,2,%r5,%r6
 
shladd,tsv,* %r4,2,%r5,%r6
shladd,tsv,*= %r4,2,%r5,%r6
shladd,tsv,*< %r4,2,%r5,%r6
shladd,tsv,*<= %r4,2,%r5,%r6
shladd,tsv,*nuv %r4,2,%r5,%r6
shladd,tsv,*znv %r4,2,%r5,%r6
shladd,tsv,*sv %r4,2,%r5,%r6
shladd,tsv,*od %r4,2,%r5,%r6
shladd,tsv,*tr %r4,2,%r5,%r6
shladd,tsv,*<> %r4,2,%r5,%r6
shladd,tsv,*>= %r4,2,%r5,%r6
shladd,tsv,*> %r4,2,%r5,%r6
shladd,tsv,*uv %r4,2,%r5,%r6
shladd,tsv,*vnz %r4,2,%r5,%r6
shladd,tsv,*nsv %r4,2,%r5,%r6
shladd,tsv,*ev %r4,2,%r5,%r6
 
shladd,* %r4,3,%r5,%r6
shladd,*= %r4,3,%r5,%r6
shladd,*< %r4,3,%r5,%r6
shladd,*<= %r4,3,%r5,%r6
shladd,*nuv %r4,3,%r5,%r6
shladd,*znv %r4,3,%r5,%r6
shladd,*sv %r4,3,%r5,%r6
shladd,*od %r4,3,%r5,%r6
shladd,*tr %r4,3,%r5,%r6
shladd,*<> %r4,3,%r5,%r6
shladd,*>= %r4,3,%r5,%r6
shladd,*> %r4,3,%r5,%r6
shladd,*uv %r4,3,%r5,%r6
shladd,*vnz %r4,3,%r5,%r6
shladd,*nsv %r4,3,%r5,%r6
shladd,*ev %r4,3,%r5,%r6
 
shladd,l,* %r4,3,%r5,%r6
shladd,l,*= %r4,3,%r5,%r6
shladd,l,*< %r4,3,%r5,%r6
shladd,l,*<= %r4,3,%r5,%r6
shladd,l,*nuv %r4,3,%r5,%r6
shladd,l,*znv %r4,3,%r5,%r6
shladd,l,*sv %r4,3,%r5,%r6
shladd,l,*od %r4,3,%r5,%r6
shladd,l,*tr %r4,3,%r5,%r6
shladd,l,*<> %r4,3,%r5,%r6
shladd,l,*>= %r4,3,%r5,%r6
shladd,l,*> %r4,3,%r5,%r6
shladd,l,*uv %r4,3,%r5,%r6
shladd,l,*vnz %r4,3,%r5,%r6
shladd,l,*nsv %r4,3,%r5,%r6
shladd,l,*ev %r4,3,%r5,%r6
 
shladd,tsv,* %r4,3,%r5,%r6
shladd,tsv,*= %r4,3,%r5,%r6
shladd,tsv,*< %r4,3,%r5,%r6
shladd,tsv,*<= %r4,3,%r5,%r6
shladd,tsv,*nuv %r4,3,%r5,%r6
shladd,tsv,*znv %r4,3,%r5,%r6
shladd,tsv,*sv %r4,3,%r5,%r6
shladd,tsv,*od %r4,3,%r5,%r6
shladd,tsv,*tr %r4,3,%r5,%r6
shladd,tsv,*<> %r4,3,%r5,%r6
shladd,tsv,*>= %r4,3,%r5,%r6
shladd,tsv,*> %r4,3,%r5,%r6
shladd,tsv,*uv %r4,3,%r5,%r6
shladd,tsv,*vnz %r4,3,%r5,%r6
shladd,tsv,*nsv %r4,3,%r5,%r6
shladd,tsv,*ev %r4,3,%r5,%r6
 
/basic/system.s
0,0 → 1,36
.level 1.1
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
break 5,12
rfi
rfir
ssm 5,%r4
rsm 5,%r4
mtsm %r4
ldsid (%sr0,%r5),%r4
mtsp %r4,%sr0
mtctl %r4,%cr10
mfsp %sr0,%r4
mfctl %cr10,%r4
sync
syncdma
diag 1234
 
prober (%sr0,%r5),%r6,%r7
proberi (%sr0,%r5),1,%r7
probew (%sr0,%r5),%r6,%r7
probewi (%sr0,%r5),1,%r7
lpa %r4(%sr0,%r5),%r6
lpa,m %r4(%sr0,%r5),%r6
lci %r4(%sr0,%r5),%r6
 
idtlba %r4,(%sr0,%r5)
iitlba %r4,(%sr4,%r5)
idtlbp %r4,(%sr0,%r5)
iitlbp %r4,(%sr4,%r5)
/basic/fmem.s
0,0 → 1,43
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
fldwx %r4(%sr0,%r5),%fr6
fldwx,s %r4(%sr0,%r5),%fr6
fldwx,m %r4(%sr0,%r5),%fr6
fldwx,sm %r4(%sr0,%r5),%fr6
flddx %r4(%sr0,%r5),%fr6
flddx,s %r4(%sr0,%r5),%fr6
flddx,m %r4(%sr0,%r5),%fr6
flddx,sm %r4(%sr0,%r5),%fr6
fstwx %fr6,%r4(%sr0,%r5)
fstwx,s %fr6,%r4(%sr0,%r5)
fstwx,m %fr6,%r4(%sr0,%r5)
fstwx,sm %fr6,%r4(%sr0,%r5)
fstdx %fr6,%r4(%sr0,%r5)
fstdx,s %fr6,%r4(%sr0,%r5)
fstdx,m %fr6,%r4(%sr0,%r5)
fstdx,sm %fr6,%r4(%sr0,%r5)
fstqx %fr6,%r4(%sr0,%r5)
fstqx,s %fr6,%r4(%sr0,%r5)
fstqx,m %fr6,%r4(%sr0,%r5)
fstqx,sm %fr6,%r4(%sr0,%r5)
 
fldws 0(%sr0,%r5),%fr6
fldws,mb 0(%sr0,%r5),%fr6
fldws,ma 0(%sr0,%r5),%fr6
fldds 0(%sr0,%r5),%fr6
fldds,mb 0(%sr0,%r5),%fr6
fldds,ma 0(%sr0,%r5),%fr6
fstws %fr6,0(%sr0,%r5)
fstws,mb %fr6,0(%sr0,%r5)
fstws,ma %fr6,0(%sr0,%r5)
fstds %fr6,0(%sr0,%r5)
fstds,mb %fr6,0(%sr0,%r5)
fstds,ma %fr6,0(%sr0,%r5)
fstqs %fr6,0(%sr0,%r5)
fstqs,mb %fr6,0(%sr0,%r5)
fstqs,ma %fr6,0(%sr0,%r5)
/basic/dcor.s
0,0 → 1,47
.level 1.1
.code
.align 4
; decimal correction instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
dcor %r4,%r5
dcor,sbz %r4,%r5
dcor,shz %r4,%r5
dcor,sdc %r4,%r5
dcor,sbc %r4,%r5
dcor,shc %r4,%r5
dcor,tr %r4,%r5
dcor,nbz %r4,%r5
dcor,nhz %r4,%r5
dcor,ndc %r4,%r5
dcor,nbc %r4,%r5
dcor,nhc %r4,%r5
 
idcor %r4,%r5
idcor,sbz %r4,%r5
idcor,shz %r4,%r5
idcor,sdc %r4,%r5
idcor,sbc %r4,%r5
idcor,shc %r4,%r5
idcor,tr %r4,%r5
idcor,nbz %r4,%r5
idcor,nhz %r4,%r5
idcor,ndc %r4,%r5
idcor,nbc %r4,%r5
idcor,nhc %r4,%r5
 
dcor,i %r4,%r5
dcor,i,sbz %r4,%r5
dcor,i,shz %r4,%r5
dcor,i,sdc %r4,%r5
dcor,i,sbc %r4,%r5
dcor,i,shc %r4,%r5
dcor,i,tr %r4,%r5
dcor,i,nbz %r4,%r5
dcor,i,nhz %r4,%r5
dcor,i,ndc %r4,%r5
dcor,i,nbc %r4,%r5
dcor,i,nhc %r4,%r5
 
/basic/deposit2.s
0,0 → 1,78
.code
.align 4
; Deposit instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
depw,z %r4,5,10,%r6
depw,z,= %r4,5,10,%r6
depw,z,< %r4,5,10,%r6
depw,z,od %r4,5,10,%r6
depw,z,tr %r4,5,10,%r6
depw,z,<> %r4,5,10,%r6
depw,z,>= %r4,5,10,%r6
depw,z,ev %r4,5,10,%r6
 
depw %r4,5,10,%r6
depw,= %r4,5,10,%r6
depw,< %r4,5,10,%r6
depw,od %r4,5,10,%r6
depw,tr %r4,5,10,%r6
depw,<> %r4,5,10,%r6
depw,>= %r4,5,10,%r6
depw,ev %r4,5,10,%r6
 
depw,z %r4,%sar,5,%r6
depw,z,= %r4,%sar,5,%r6
depw,z,< %r4,%sar,5,%r6
depw,z,od %r4,%sar,5,%r6
depw,z,tr %r4,%sar,5,%r6
depw,z,<> %r4,%sar,5,%r6
depw,z,>= %r4,%sar,5,%r6
depw,z,ev %r4,%sar,5,%r6
 
depw %r4,%sar,5,%r6
depw,= %r4,%sar,5,%r6
depw,< %r4,%sar,5,%r6
depw,od %r4,%sar,5,%r6
depw,tr %r4,%sar,5,%r6
depw,<> %r4,%sar,5,%r6
depw,>= %r4,%sar,5,%r6
depw,ev %r4,%sar,5,%r6
 
depwi -1,%sar,5,%r6
depwi,= -1,%sar,5,%r6
depwi,< -1,%sar,5,%r6
depwi,od -1,%sar,5,%r6
depwi,tr -1,%sar,5,%r6
depwi,<> -1,%sar,5,%r6
depwi,>= -1,%sar,5,%r6
depwi,ev -1,%sar,5,%r6
 
depwi,z -1,%sar,5,%r6
depwi,z,= -1,%sar,5,%r6
depwi,z,< -1,%sar,5,%r6
depwi,z,od -1,%sar,5,%r6
depwi,z,tr -1,%sar,5,%r6
depwi,z,<> -1,%sar,5,%r6
depwi,z,>= -1,%sar,5,%r6
depwi,z,ev -1,%sar,5,%r6
 
depwi -1,4,10,%r6
depwi,= -1,4,10,%r6
depwi,< -1,4,10,%r6
depwi,od -1,4,10,%r6
depwi,tr -1,4,10,%r6
depwi,<> -1,4,10,%r6
depwi,>= -1,4,10,%r6
depwi,ev -1,4,10,%r6
 
depwi,z -1,4,10,%r6
depwi,z,= -1,4,10,%r6
depwi,z,< -1,4,10,%r6
depwi,z,od -1,4,10,%r6
depwi,z,tr -1,4,10,%r6
depwi,z,<> -1,4,10,%r6
depwi,z,>= -1,4,10,%r6
depwi,z,ev -1,4,10,%r6
/basic/fp_conv.s
0,0 → 1,83
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
fcnvff,sgl,sgl %fr5,%fr10
fcnvff,sgl,dbl %fr5,%fr10
fcnvff,sgl,quad %fr5,%fr10
fcnvff,dbl,sgl %fr5,%fr10
fcnvff,dbl,dbl %fr5,%fr10
fcnvff,dbl,quad %fr5,%fr10
fcnvff,quad,sgl %fr5,%fr10
fcnvff,quad,dbl %fr5,%fr10
fcnvff,quad,quad %fr5,%fr10
fcnvff,sgl,sgl %fr20,%fr24
fcnvff,sgl,dbl %fr20,%fr24
fcnvff,sgl,quad %fr20,%fr24
fcnvff,dbl,sgl %fr20,%fr24
fcnvff,dbl,dbl %fr20,%fr24
fcnvff,dbl,quad %fr20,%fr24
fcnvff,quad,sgl %fr20,%fr24
fcnvff,quad,dbl %fr20,%fr24
fcnvff,quad,quad %fr20,%fr24
 
fcnvxf,sgl,sgl %fr5,%fr10
fcnvxf,sgl,dbl %fr5,%fr10
fcnvxf,sgl,quad %fr5,%fr10
fcnvxf,dbl,sgl %fr5,%fr10
fcnvxf,dbl,dbl %fr5,%fr10
fcnvxf,dbl,quad %fr5,%fr10
fcnvxf,quad,sgl %fr5,%fr10
fcnvxf,quad,dbl %fr5,%fr10
fcnvxf,quad,quad %fr5,%fr10
fcnvxf,sgl,sgl %fr20,%fr24
fcnvxf,sgl,dbl %fr20,%fr24
fcnvxf,sgl,quad %fr20,%fr24
fcnvxf,dbl,sgl %fr20,%fr24
fcnvxf,dbl,dbl %fr20,%fr24
fcnvxf,dbl,quad %fr20,%fr24
fcnvxf,quad,sgl %fr20,%fr24
fcnvxf,quad,dbl %fr20,%fr24
fcnvxf,quad,quad %fr20,%fr24
 
fcnvfx,sgl,sgl %fr5,%fr10
fcnvfx,sgl,dbl %fr5,%fr10
fcnvfx,sgl,quad %fr5,%fr10
fcnvfx,dbl,sgl %fr5,%fr10
fcnvfx,dbl,dbl %fr5,%fr10
fcnvfx,dbl,quad %fr5,%fr10
fcnvfx,quad,sgl %fr5,%fr10
fcnvfx,quad,dbl %fr5,%fr10
fcnvfx,quad,quad %fr5,%fr10
fcnvfx,sgl,sgl %fr20,%fr24
fcnvfx,sgl,dbl %fr20,%fr24
fcnvfx,sgl,quad %fr20,%fr24
fcnvfx,dbl,sgl %fr20,%fr24
fcnvfx,dbl,dbl %fr20,%fr24
fcnvfx,dbl,quad %fr20,%fr24
fcnvfx,quad,sgl %fr20,%fr24
fcnvfx,quad,dbl %fr20,%fr24
fcnvfx,quad,quad %fr20,%fr24
 
fcnvfxt,sgl,sgl %fr5,%fr10
fcnvfxt,sgl,dbl %fr5,%fr10
fcnvfxt,sgl,quad %fr5,%fr10
fcnvfxt,dbl,sgl %fr5,%fr10
fcnvfxt,dbl,dbl %fr5,%fr10
fcnvfxt,dbl,quad %fr5,%fr10
fcnvfxt,quad,sgl %fr5,%fr10
fcnvfxt,quad,dbl %fr5,%fr10
fcnvfxt,quad,quad %fr5,%fr10
fcnvfxt,sgl,sgl %fr20,%fr24
fcnvfxt,sgl,dbl %fr20,%fr24
fcnvfxt,sgl,quad %fr20,%fr24
fcnvfxt,dbl,sgl %fr20,%fr24
fcnvfxt,dbl,dbl %fr20,%fr24
fcnvfxt,dbl,quad %fr20,%fr24
fcnvfxt,quad,sgl %fr20,%fr24
fcnvfxt,quad,dbl %fr20,%fr24
fcnvfxt,quad,quad %fr20,%fr24
 
/basic/deposit3.s
0,0 → 1,79
.LEVEL 2.0
.code
.align 4
; PA 2.0 Deposit instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
depd,z,* %r4,10,5,%r6
depd,z,*= %r4,10,5,%r6
depd,z,*< %r4,10,5,%r6
depd,z,*od %r4,10,5,%r6
depd,z,*tr %r4,10,5,%r6
depd,z,*<> %r4,10,5,%r6
depd,z,*>= %r4,10,5,%r6
depd,z,*ev %r4,10,5,%r6
 
depd,* %r4,10,5,%r6
depd,*= %r4,10,5,%r6
depd,*< %r4,10,5,%r6
depd,*od %r4,10,5,%r6
depd,*tr %r4,10,5,%r6
depd,*<> %r4,10,5,%r6
depd,*>= %r4,10,5,%r6
depd,*ev %r4,10,5,%r6
 
depd,z,* %r4,%sar,5,%r6
depd,z,*= %r4,%sar,5,%r6
depd,z,*< %r4,%sar,5,%r6
depd,z,*od %r4,%sar,5,%r6
depd,z,*tr %r4,%sar,5,%r6
depd,z,*<> %r4,%sar,5,%r6
depd,z,*>= %r4,%sar,5,%r6
depd,z,*ev %r4,%sar,5,%r6
 
depd,* %r4,%sar,5,%r6
depd,*= %r4,%sar,5,%r6
depd,*< %r4,%sar,5,%r6
depd,*od %r4,%sar,5,%r6
depd,*tr %r4,%sar,5,%r6
depd,*<> %r4,%sar,5,%r6
depd,*>= %r4,%sar,5,%r6
depd,*ev %r4,%sar,5,%r6
 
depdi,* -1,%sar,5,%r6
depdi,*= -1,%sar,5,%r6
depdi,*< -1,%sar,5,%r6
depdi,*od -1,%sar,5,%r6
depdi,*tr -1,%sar,5,%r6
depdi,*<> -1,%sar,5,%r6
depdi,*>= -1,%sar,5,%r6
depdi,*ev -1,%sar,5,%r6
 
depdi,z,* -1,%sar,5,%r6
depdi,z,*= -1,%sar,5,%r6
depdi,z,*< -1,%sar,5,%r6
depdi,z,*od -1,%sar,5,%r6
depdi,z,*tr -1,%sar,5,%r6
depdi,z,*<> -1,%sar,5,%r6
depdi,z,*>= -1,%sar,5,%r6
depdi,z,*ev -1,%sar,5,%r6
 
depdi,* -1,10,4,%r6
depdi,*= -1,10,4,%r6
depdi,*< -1,10,4,%r6
depdi,*od -1,10,4,%r6
depdi,*tr -1,10,4,%r6
depdi,*<> -1,10,4,%r6
depdi,*>= -1,10,4,%r6
depdi,*ev -1,10,4,%r6
 
depdi,z,* -1,10,4,%r6
depdi,z,*= -1,10,4,%r6
depdi,z,*< -1,10,4,%r6
depdi,z,*od -1,10,4,%r6
depdi,z,*tr -1,10,4,%r6
depdi,z,*<> -1,10,4,%r6
depdi,z,*>= -1,10,4,%r6
depdi,z,*ev -1,10,4,%r6
/basic/immed.s
0,0 → 1,12
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
immediate_tests:
ldo 5(%r26),%r26
ldil L%0xdeadbeef,%r26
addil L%0xdeadbeef,%r5
 
/basic/shift2.s
0,0 → 1,24
.code
.align 4
; PA 2.0 format shift right instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
shrpw %r4,%r5,%sar,%r6
shrpw,= %r4,%r5,%sar,%r6
shrpw,< %r4,%r5,%sar,%r6
shrpw,od %r4,%r5,%sar,%r6
shrpw,tr %r4,%r5,%cr11,%r6
shrpw,<> %r4,%r5,%cr11,%r6
shrpw,>= %r4,%r5,%cr11,%r6
shrpw,ev %r4,%r5,%cr11,%r6
 
shrpw %r4,%r5,5,%r6
shrpw,= %r4,%r5,5,%r6
shrpw,< %r4,%r5,5,%r6
shrpw,od %r4,%r5,5,%r6
shrpw,tr %r4,%r5,5,%r6
shrpw,<> %r4,%r5,5,%r6
shrpw,>= %r4,%r5,5,%r6
shrpw,ev %r4,%r5,5,%r6
/basic/shladd.s
0,0 → 1,161
.level 1.1
.code
.align 4
; Basic shladd instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
shladd %r4,1,%r5,%r6
shladd,= %r4,1,%r5,%r6
shladd,< %r4,1,%r5,%r6
shladd,<= %r4,1,%r5,%r6
shladd,nuv %r4,1,%r5,%r6
shladd,znv %r4,1,%r5,%r6
shladd,sv %r4,1,%r5,%r6
shladd,od %r4,1,%r5,%r6
shladd,tr %r4,1,%r5,%r6
shladd,<> %r4,1,%r5,%r6
shladd,>= %r4,1,%r5,%r6
shladd,> %r4,1,%r5,%r6
shladd,uv %r4,1,%r5,%r6
shladd,vnz %r4,1,%r5,%r6
shladd,nsv %r4,1,%r5,%r6
shladd,ev %r4,1,%r5,%r6
 
shladd,l %r4,1,%r5,%r6
shladd,l,= %r4,1,%r5,%r6
shladd,l,< %r4,1,%r5,%r6
shladd,l,<= %r4,1,%r5,%r6
shladd,l,nuv %r4,1,%r5,%r6
shladd,l,znv %r4,1,%r5,%r6
shladd,l,sv %r4,1,%r5,%r6
shladd,l,od %r4,1,%r5,%r6
shladd,l,tr %r4,1,%r5,%r6
shladd,l,<> %r4,1,%r5,%r6
shladd,l,>= %r4,1,%r5,%r6
shladd,l,> %r4,1,%r5,%r6
shladd,l,uv %r4,1,%r5,%r6
shladd,l,vnz %r4,1,%r5,%r6
shladd,l,nsv %r4,1,%r5,%r6
shladd,l,ev %r4,1,%r5,%r6
 
shladd,tsv %r4,1,%r5,%r6
shladd,tsv,= %r4,1,%r5,%r6
shladd,tsv,< %r4,1,%r5,%r6
shladd,tsv,<= %r4,1,%r5,%r6
shladd,tsv,nuv %r4,1,%r5,%r6
shladd,tsv,znv %r4,1,%r5,%r6
shladd,tsv,sv %r4,1,%r5,%r6
shladd,tsv,od %r4,1,%r5,%r6
shladd,tsv,tr %r4,1,%r5,%r6
shladd,tsv,<> %r4,1,%r5,%r6
shladd,tsv,>= %r4,1,%r5,%r6
shladd,tsv,> %r4,1,%r5,%r6
shladd,tsv,uv %r4,1,%r5,%r6
shladd,tsv,vnz %r4,1,%r5,%r6
shladd,tsv,nsv %r4,1,%r5,%r6
shladd,tsv,ev %r4,1,%r5,%r6
 
shladd %r4,2,%r5,%r6
shladd,= %r4,2,%r5,%r6
shladd,< %r4,2,%r5,%r6
shladd,<= %r4,2,%r5,%r6
shladd,nuv %r4,2,%r5,%r6
shladd,znv %r4,2,%r5,%r6
shladd,sv %r4,2,%r5,%r6
shladd,od %r4,2,%r5,%r6
shladd,tr %r4,2,%r5,%r6
shladd,<> %r4,2,%r5,%r6
shladd,>= %r4,2,%r5,%r6
shladd,> %r4,2,%r5,%r6
shladd,uv %r4,2,%r5,%r6
shladd,vnz %r4,2,%r5,%r6
shladd,nsv %r4,2,%r5,%r6
shladd,ev %r4,2,%r5,%r6
 
shladd,l %r4,2,%r5,%r6
shladd,l,= %r4,2,%r5,%r6
shladd,l,< %r4,2,%r5,%r6
shladd,l,<= %r4,2,%r5,%r6
shladd,l,nuv %r4,2,%r5,%r6
shladd,l,znv %r4,2,%r5,%r6
shladd,l,sv %r4,2,%r5,%r6
shladd,l,od %r4,2,%r5,%r6
shladd,l,tr %r4,2,%r5,%r6
shladd,l,<> %r4,2,%r5,%r6
shladd,l,>= %r4,2,%r5,%r6
shladd,l,> %r4,2,%r5,%r6
shladd,l,uv %r4,2,%r5,%r6
shladd,l,vnz %r4,2,%r5,%r6
shladd,l,nsv %r4,2,%r5,%r6
shladd,l,ev %r4,2,%r5,%r6
 
shladd,tsv %r4,2,%r5,%r6
shladd,tsv,= %r4,2,%r5,%r6
shladd,tsv,< %r4,2,%r5,%r6
shladd,tsv,<= %r4,2,%r5,%r6
shladd,tsv,nuv %r4,2,%r5,%r6
shladd,tsv,znv %r4,2,%r5,%r6
shladd,tsv,sv %r4,2,%r5,%r6
shladd,tsv,od %r4,2,%r5,%r6
shladd,tsv,tr %r4,2,%r5,%r6
shladd,tsv,<> %r4,2,%r5,%r6
shladd,tsv,>= %r4,2,%r5,%r6
shladd,tsv,> %r4,2,%r5,%r6
shladd,tsv,uv %r4,2,%r5,%r6
shladd,tsv,vnz %r4,2,%r5,%r6
shladd,tsv,nsv %r4,2,%r5,%r6
shladd,tsv,ev %r4,2,%r5,%r6
 
shladd %r4,3,%r5,%r6
shladd,= %r4,3,%r5,%r6
shladd,< %r4,3,%r5,%r6
shladd,<= %r4,3,%r5,%r6
shladd,nuv %r4,3,%r5,%r6
shladd,znv %r4,3,%r5,%r6
shladd,sv %r4,3,%r5,%r6
shladd,od %r4,3,%r5,%r6
shladd,tr %r4,3,%r5,%r6
shladd,<> %r4,3,%r5,%r6
shladd,>= %r4,3,%r5,%r6
shladd,> %r4,3,%r5,%r6
shladd,uv %r4,3,%r5,%r6
shladd,vnz %r4,3,%r5,%r6
shladd,nsv %r4,3,%r5,%r6
shladd,ev %r4,3,%r5,%r6
 
shladd,l %r4,3,%r5,%r6
shladd,l,= %r4,3,%r5,%r6
shladd,l,< %r4,3,%r5,%r6
shladd,l,<= %r4,3,%r5,%r6
shladd,l,nuv %r4,3,%r5,%r6
shladd,l,znv %r4,3,%r5,%r6
shladd,l,sv %r4,3,%r5,%r6
shladd,l,od %r4,3,%r5,%r6
shladd,l,tr %r4,3,%r5,%r6
shladd,l,<> %r4,3,%r5,%r6
shladd,l,>= %r4,3,%r5,%r6
shladd,l,> %r4,3,%r5,%r6
shladd,l,uv %r4,3,%r5,%r6
shladd,l,vnz %r4,3,%r5,%r6
shladd,l,nsv %r4,3,%r5,%r6
shladd,l,ev %r4,3,%r5,%r6
 
shladd,tsv %r4,3,%r5,%r6
shladd,tsv,= %r4,3,%r5,%r6
shladd,tsv,< %r4,3,%r5,%r6
shladd,tsv,<= %r4,3,%r5,%r6
shladd,tsv,nuv %r4,3,%r5,%r6
shladd,tsv,znv %r4,3,%r5,%r6
shladd,tsv,sv %r4,3,%r5,%r6
shladd,tsv,od %r4,3,%r5,%r6
shladd,tsv,tr %r4,3,%r5,%r6
shladd,tsv,<> %r4,3,%r5,%r6
shladd,tsv,>= %r4,3,%r5,%r6
shladd,tsv,> %r4,3,%r5,%r6
shladd,tsv,uv %r4,3,%r5,%r6
shladd,tsv,vnz %r4,3,%r5,%r6
shladd,tsv,nsv %r4,3,%r5,%r6
shladd,tsv,ev %r4,3,%r5,%r6
 
/basic/shift3.s
0,0 → 1,26
.LEVEL 2.0
.code
.align 4
; PA 2.0 shift right instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
shrpd,* %r4,%r5,%sar,%r6
shrpd,*= %r4,%r5,%sar,%r6
shrpd,*< %r4,%r5,%sar,%r6
shrpd,*od %r4,%r5,%sar,%r6
shrpd,*tr %r4,%r5,%cr11,%r6
shrpd,*<> %r4,%r5,%cr11,%r6
shrpd,*>= %r4,%r5,%cr11,%r6
shrpd,*ev %r4,%r5,%cr11,%r6
 
shrpd,* %r4,%r5,5,%r6
shrpd,*= %r4,%r5,5,%r6
shrpd,*< %r4,%r5,5,%r6
shrpd,*od %r4,%r5,5,%r6
shrpd,*tr %r4,%r5,5,%r6
shrpd,*<> %r4,%r5,5,%r6
shrpd,*>= %r4,%r5,5,%r6
shrpd,*ev %r4,%r5,5,%r6
 
/basic/subi.s
0,0 → 1,57
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
subi 123,%r5,%r6
subi,= 123,%r5,%r6
subi,< 123,%r5,%r6
subi,<= 123,%r5,%r6
subi,<< 123,%r5,%r6
subi,<<= 123,%r5,%r6
subi,sv 123,%r5,%r6
subi,od 123,%r5,%r6
subi,tr 123,%r5,%r6
subi,<> 123,%r5,%r6
subi,>= 123,%r5,%r6
subi,> 123,%r5,%r6
subi,>>= 123,%r5,%r6
subi,>> 123,%r5,%r6
subi,nsv 123,%r5,%r6
subi,ev 123,%r5,%r6
 
subio 123,%r5,%r6
subio,= 123,%r5,%r6
subio,< 123,%r5,%r6
subio,<= 123,%r5,%r6
subio,<< 123,%r5,%r6
subio,<<= 123,%r5,%r6
subio,sv 123,%r5,%r6
subio,od 123,%r5,%r6
subio,tr 123,%r5,%r6
subio,<> 123,%r5,%r6
subio,>= 123,%r5,%r6
subio,> 123,%r5,%r6
subio,>>= 123,%r5,%r6
subio,>> 123,%r5,%r6
subio,nsv 123,%r5,%r6
subio,ev 123,%r5,%r6
 
subi,tsv 123,%r5,%r6
subi,tsv,= 123,%r5,%r6
subi,tsv,< 123,%r5,%r6
subi,tsv,<= 123,%r5,%r6
subi,tsv,<< 123,%r5,%r6
subi,tsv,<<= 123,%r5,%r6
subi,tsv,sv 123,%r5,%r6
subi,tsv,od 123,%r5,%r6
subi,tsv,tr 123,%r5,%r6
subi,tsv,<> 123,%r5,%r6
subi,tsv,>= 123,%r5,%r6
subi,tsv,> 123,%r5,%r6
subi,tsv,>>= 123,%r5,%r6
subi,tsv,>> 123,%r5,%r6
subi,tsv,nsv 123,%r5,%r6
subi,tsv,ev 123,%r5,%r6
/basic/copr.s
0,0 → 1,10
.code
.align 4
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
copr_tests:
copr,4,5
copr,4,115
copr,4,5,n
copr,4,115,n
/basic/fp_comp2.s
0,0 → 1,30
.LEVEL 2.0
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
fmpyfadd,sgl %fr5R,%fr10L,%fr13R,%fr14L
fmpyfadd,dbl %fr5,%fr10,%fr13,%fr14
fmpyfadd,sgl %fr18R,%fr27L,%fr6R,%fr21L
fmpyfadd,dbl %fr18,%fr27,%fr6,%fr21
 
fmpynfadd,sgl %fr5R,%fr10L,%fr13R,%fr14L
fmpynfadd,dbl %fr5,%fr10,%fr13,%fr14
fmpynfadd,sgl %fr18R,%fr27L,%fr6R,%fr21L
fmpynfadd,dbl %fr18,%fr27,%fr6,%fr21
 
fneg,sgl %fr5,%fr10R
fneg,dbl %fr5,%fr10
fneg,quad %fr5,%fr10
fneg,sgl %fr20R,%fr24L
fneg,dbl %fr20,%fr24
 
fnegabs,sgl %fr5,%fr10R
fnegabs,dbl %fr5,%fr10
fnegabs,quad %fr5,%fr10
fnegabs,sgl %fr20R,%fr24L
fnegabs,dbl %fr20,%fr24
 
/basic/sh2add.s
0,0 → 1,58
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
sh2add %r4,%r5,%r6
sh2add,= %r4,%r5,%r6
sh2add,< %r4,%r5,%r6
sh2add,<= %r4,%r5,%r6
sh2add,nuv %r4,%r5,%r6
sh2add,znv %r4,%r5,%r6
sh2add,sv %r4,%r5,%r6
sh2add,od %r4,%r5,%r6
sh2add,tr %r4,%r5,%r6
sh2add,<> %r4,%r5,%r6
sh2add,>= %r4,%r5,%r6
sh2add,> %r4,%r5,%r6
sh2add,uv %r4,%r5,%r6
sh2add,vnz %r4,%r5,%r6
sh2add,nsv %r4,%r5,%r6
sh2add,ev %r4,%r5,%r6
 
sh2addl %r4,%r5,%r6
sh2addl,= %r4,%r5,%r6
sh2addl,< %r4,%r5,%r6
sh2addl,<= %r4,%r5,%r6
sh2addl,nuv %r4,%r5,%r6
sh2addl,znv %r4,%r5,%r6
sh2addl,sv %r4,%r5,%r6
sh2addl,od %r4,%r5,%r6
sh2addl,tr %r4,%r5,%r6
sh2addl,<> %r4,%r5,%r6
sh2addl,>= %r4,%r5,%r6
sh2addl,> %r4,%r5,%r6
sh2addl,uv %r4,%r5,%r6
sh2addl,vnz %r4,%r5,%r6
sh2addl,nsv %r4,%r5,%r6
sh2addl,ev %r4,%r5,%r6
 
sh2addo %r4,%r5,%r6
sh2addo,= %r4,%r5,%r6
sh2addo,< %r4,%r5,%r6
sh2addo,<= %r4,%r5,%r6
sh2addo,nuv %r4,%r5,%r6
sh2addo,znv %r4,%r5,%r6
sh2addo,sv %r4,%r5,%r6
sh2addo,od %r4,%r5,%r6
sh2addo,tr %r4,%r5,%r6
sh2addo,<> %r4,%r5,%r6
sh2addo,>= %r4,%r5,%r6
sh2addo,> %r4,%r5,%r6
sh2addo,uv %r4,%r5,%r6
sh2addo,vnz %r4,%r5,%r6
sh2addo,nsv %r4,%r5,%r6
sh2addo,ev %r4,%r5,%r6
 
/basic/ds.s
0,0 → 1,23
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
ds %r4,%r5,%r6
ds,= %r4,%r5,%r6
ds,< %r4,%r5,%r6
ds,<= %r4,%r5,%r6
ds,<< %r4,%r5,%r6
ds,<<= %r4,%r5,%r6
ds,sv %r4,%r5,%r6
ds,od %r4,%r5,%r6
ds,tr %r4,%r5,%r6
ds,<> %r4,%r5,%r6
ds,>= %r4,%r5,%r6
ds,> %r4,%r5,%r6
ds,>>= %r4,%r5,%r6
ds,>> %r4,%r5,%r6
ds,nsv %r4,%r5,%r6
ds,ev %r4,%r5,%r6
/basic/system2.s
0,0 → 1,19
.LEVEL 2.0
.code
.align 4
; PA2.0 system instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
rfi
rfi,r
ssm 923,%r4
rsm 923,%r4
mfctl,w %cr11,%r4
 
probe,r (%sr0,%r5),%r6,%r7
probei,r (%sr0,%r5),1,%r7
probe,w (%sr0,%r5),%r6,%r7
probei,w (%sr0,%r5),1,%r7
/basic/deposit.s
0,0 → 1,79
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
zdep %r4,5,10,%r6
zdep,= %r4,5,10,%r6
zdep,< %r4,5,10,%r6
zdep,od %r4,5,10,%r6
zdep,tr %r4,5,10,%r6
zdep,<> %r4,5,10,%r6
zdep,>= %r4,5,10,%r6
zdep,ev %r4,5,10,%r6
 
dep %r4,5,10,%r6
dep,= %r4,5,10,%r6
dep,< %r4,5,10,%r6
dep,od %r4,5,10,%r6
dep,tr %r4,5,10,%r6
dep,<> %r4,5,10,%r6
dep,>= %r4,5,10,%r6
dep,ev %r4,5,10,%r6
 
zvdep %r4,5,%r6
zvdep,= %r4,5,%r6
zvdep,< %r4,5,%r6
zvdep,od %r4,5,%r6
zvdep,tr %r4,5,%r6
zvdep,<> %r4,5,%r6
zvdep,>= %r4,5,%r6
zvdep,ev %r4,5,%r6
 
vdep %r4,5,%r6
vdep,= %r4,5,%r6
vdep,< %r4,5,%r6
vdep,od %r4,5,%r6
vdep,tr %r4,5,%r6
vdep,<> %r4,5,%r6
vdep,>= %r4,5,%r6
vdep,ev %r4,5,%r6
 
vdepi -1,5,%r6
vdepi,= -1,5,%r6
vdepi,< -1,5,%r6
vdepi,od -1,5,%r6
vdepi,tr -1,5,%r6
vdepi,<> -1,5,%r6
vdepi,>= -1,5,%r6
vdepi,ev -1,5,%r6
 
zvdepi -1,5,%r6
zvdepi,= -1,5,%r6
zvdepi,< -1,5,%r6
zvdepi,od -1,5,%r6
zvdepi,tr -1,5,%r6
zvdepi,<> -1,5,%r6
zvdepi,>= -1,5,%r6
zvdepi,ev -1,5,%r6
 
depi -1,4,10,%r6
depi,= -1,4,10,%r6
depi,< -1,4,10,%r6
depi,od -1,4,10,%r6
depi,tr -1,4,10,%r6
depi,<> -1,4,10,%r6
depi,>= -1,4,10,%r6
depi,ev -1,4,10,%r6
 
zdepi -1,4,10,%r6
zdepi,= -1,4,10,%r6
zdepi,< -1,4,10,%r6
zdepi,od -1,4,10,%r6
zdepi,tr -1,4,10,%r6
zdepi,<> -1,4,10,%r6
zdepi,>= -1,4,10,%r6
zdepi,ev -1,4,10,%r6
 
/basic/extract.s
0,0 → 1,42
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
extru %r4,5,10,%r6
extru,= %r4,5,10,%r6
extru,< %r4,5,10,%r6
extru,od %r4,5,10,%r6
extru,tr %r4,5,10,%r6
extru,<> %r4,5,10,%r6
extru,>= %r4,5,10,%r6
extru,ev %r4,5,10,%r6
 
extrs %r4,5,10,%r6
extrs,= %r4,5,10,%r6
extrs,< %r4,5,10,%r6
extrs,od %r4,5,10,%r6
extrs,tr %r4,5,10,%r6
extrs,<> %r4,5,10,%r6
extrs,>= %r4,5,10,%r6
extrs,ev %r4,5,10,%r6
 
vextru %r4,5,%r6
vextru,= %r4,5,%r6
vextru,< %r4,5,%r6
vextru,od %r4,5,%r6
vextru,tr %r4,5,%r6
vextru,<> %r4,5,%r6
vextru,>= %r4,5,%r6
vextru,ev %r4,5,%r6
 
vextrs %r4,5,%r6
vextrs,= %r4,5,%r6
vextrs,< %r4,5,%r6
vextrs,od %r4,5,%r6
vextrs,tr %r4,5,%r6
vextrs,<> %r4,5,%r6
vextrs,>= %r4,5,%r6
vextrs,ev %r4,5,%r6
/basic/basic.exp
0,0 → 1,3863
# Copyright (C) 1993, 1996, 1997, 1999, 2002, 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 the Center for Software Science at the Univeristy of Utah
# and by Cygnus Support.
 
proc do_imem {} {
set testname "imem.s: integer memory loads and stores"
set x 0
 
gas_start "imem.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 489A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0000 0C80109A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 449A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 0C80105A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 409A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 0C80101A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 689A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 0C9A1280\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 649A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 0C9A1240\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 609A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 0C9A1200\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 4C9A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 6C9A0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 0C85009A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 0C85209A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 0C8500BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 0C8520BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 0C85005A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 0C85205A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 0C85007A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 0C85207A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 0C85001A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 0C85201A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 0C85003A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 0C85203A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 0C85019A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 0C85219A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 0C8501BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 0C8521BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 0C8501DA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 0C8521DA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 0C8501FA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 0C8521FA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 0C80109A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 0C8030BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 0C8010BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 0C80105A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 0C80307A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 0C80107A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 0C80101A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 0C80303A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 0C80103A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 0C80119A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 0C8031BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 0C8011BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 0C8011DA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 0C8031FA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 0C8011FA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 0C9A1280\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 0C9A32A0\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 0C9A12A0\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 0C9A1240\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 0C9A3260\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 0C9A1260\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 0C9A1200\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 0C9A3220\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 0C9A1220\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 0C9A1380\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 0C9A33A0\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 0C9A13A0\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 0C9A1300\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 0C9A1300\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 0C9A3300\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 0C9A1320\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 0C9A3320\[^\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==60] then { pass $testname } else { fail $testname }
}
 
proc do_immed {} {
set testname "immed.s: immediate tests"
set x 0
 
gas_start "immed.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 375A000A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 234DFBD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 28ADFBD5\[^\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_branch {} {
set testname "branch.s: branch tests"
set x 0
 
gas_start "branch.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 E85F1FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E85F1FEF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 E81F1FE5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c E81F1FDF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 E85F3FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 E85F3FCF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 E8444000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c E8444002\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 E8044000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 E8044002\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 E840C000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c E840C002\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 E040446C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 E040446E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 E440446C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c E440446E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 CB441FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 CB443FED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 CB445FE5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c CB447FDD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 CB449FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 CB44BFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 CB44DFC5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c CB44FFBD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 CB441FB7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 CB443FAF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 CB445FA7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c CB447F9F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 CB449F97\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 CB44BF8F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 CB44DF87\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c CB44FF7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 CF4A1FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 CF4A3FED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 CF4A5FE5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c CF4A7FDD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 CF4A9FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 CF4ABFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 CF4ADFC5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c CF4AFFBD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 CF4A1FB7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 CF4A3FAF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 CF4A5FA7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac CF4A7F9F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 CF4A9F97\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 CF4ABF8F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 CF4ADF87\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc CF4AFF7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 80801FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 80803FED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 80805FE5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 80807FDD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 80809FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 8080BFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 8080DFC5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 8080FFBD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 88801FB5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 88803FAD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 88805FA5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 88807F9D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 88809F95\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 8880BF8D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 8880DF85\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 8880FF7D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 80801F77\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 80803F6F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 80805F67\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 80807F5F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 80809F57\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 8080BF4F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 8080DF47\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 8080FF3F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 88801F37\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 88803F2F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 88805F27\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 88807F1F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 88809F17\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 8880BF0F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 8880DF07\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 8880FEFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 84801FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 84805FED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 84807FE5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c 84809FDD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 8480BFD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 8480DFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 8480FFC5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c 8C801FBD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 8C803FB5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 8C805FAD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 8C807FA5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c 8C809F9D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 8C80BF95\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 8C80DF8D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 8C80FE85\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c 84801F7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0180 84803F77\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0184 84805F6F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0188 84807F67\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 018c 84809F5F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0190 8480BF57\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0194 8480DF4F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0198 8480FF47\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 019c 8C801F3F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a0 8C803F37\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a4 8C805F2F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a8 8C807F27\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ac 8C809F1F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b0 8C80BF17\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b4 8C80DF0F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b8 8C80FF07\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01bc A0811FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c0 A0813FED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c4 A0815FE5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c8 A0817FDD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01cc A0819FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d0 A081BFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d4 A081DFC5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d8 A081FFBD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01dc A8811FB5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e0 A8813FAD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e4 A8815FA5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e8 A8817F9D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ec A8819F95\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f0 A881BF8D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f4 A881DF85\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f8 A881FF7D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01fc A0811F77\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0200 A0813F6F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0204 A0815F67\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0208 A0817F5F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 020c A0819F57\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0210 A081BF4F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0214 A081DF47\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0218 A081FF3F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 021c A8811F37\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0220 A8813F2F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0224 A8815F27\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0228 A8817F1F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 022c A8819F17\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0230 A881BF0F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0234 A881DF07\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0238 A881FEFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 023c A49F1FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0240 A49F3FED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0244 A49F5FE5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0248 A49F7FDD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 024c A49F9FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0250 A49FBFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0254 A49FDFC5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0258 A49FFFBD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 025c AC9F1FB5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0260 AC9F3FAD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0264 AC9F5FA5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0268 AC9F7F9D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 026c AC9F9F95\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0270 AC9FBF8D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0274 AC9FDF85\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0278 AC9FFC85\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 027c A49F1F77\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0280 A49F3F6F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0284 A49F5F67\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0288 A49F7F5F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 028c A49F9F57\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0290 A49FBF4F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0294 A49FDF47\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0298 A49FFF3F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 029c AC9F1F37\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02a0 AC9F3F2F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02a4 AC9F5F27\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02a8 AC9F7F1F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02ac AC9F9F17\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02b0 AC9FBF0F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02b4 AC9FDF07\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02b8 AC9FFEFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02bc C0045FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02c0 C004DFED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02c4 C0045FE7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02c8 C004DFDF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02cc C4A45FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02d0 C4A4DFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02d4 C4A45FC7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02d8 C4A4DFBF\[^\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==183] then { pass $testname } else { fail $testname }
}
 
proc do_branch2 {} {
set testname "branch2.s: branch tests"
set x 0
 
gas_start "branch2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 C0045FF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 C004DFED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 C0045FE7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c C004DFDF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 C0047FD5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 C004FFCD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 C0047FC7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c C004FFBF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 C4A47FB5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 C4A4FFAD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 C4A47FA7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c C4A4FF9F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 E8004005\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 E800400D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 E8004F9D\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c E8004001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 E8044001\[^\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==17] then { pass $testname } else { fail $testname }
}
 
proc do_add {} {
set testname "add.s: add tests"
set x 0
 
gas_start "add.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4AE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4CE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4EE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4BE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4DE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4FE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 08A40706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 08A42706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 08A44706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 08A46706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 08A48706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 08A4A706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 08A4C706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 08A4E706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 08A41706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 08A43706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 08A45706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 08A47706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 08A49706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 08A4B706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 08A4D706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 08A4F706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 08A40F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 08A42F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 08A44F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 08A46F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 08A48F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 08A4AF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 08A4CF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 08A4EF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 08A41F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 08A43F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 08A45F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 08A47F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 08A49F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 08A4BF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 08A4DF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 08A4FF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 08A40A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 08A42A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 08A44A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c 08A46A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 08A48A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 08A4AA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 08A4CA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c 08A4EA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 08A41A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 08A43A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 08A45A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c 08A47A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 08A49A06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 08A4BA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 08A4DA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c 08A4FA06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0180 08A40E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0184 08A42E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0188 08A44E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 018c 08A46E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0190 08A48E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0194 08A4AE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0198 08A4CE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 019c 08A4EE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a0 08A41E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a4 08A43E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a8 08A45E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ac 08A47E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b0 08A49E06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b4 08A4BE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b8 08A4DE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01bc 08A4FE06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c0 08A40706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c4 08A42706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c8 08A44706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01cc 08A46706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d0 08A48706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d4 08A4A706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d8 08A4C706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01dc 08A4E706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e0 08A41706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e4 08A43706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e8 08A45706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ec 08A47706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f0 08A49706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f4 08A4B706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f8 08A4D706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01fc 08A4F706\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0200 08A40F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0204 08A42F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0208 08A44F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 020c 08A46F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0210 08A48F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0214 08A4AF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0218 08A4CF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 021c 08A4EF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0220 08A41F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0224 08A43F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0228 08A45F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 022c 08A47F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0230 08A49F06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0234 08A4BF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0238 08A4DF06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 023c 08A4FF06\[^\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==144] then { pass $testname } else { fail $testname }
}
 
proc do_add2 {} {
set testname "add2.s: add2 tests"
set x 0
 
gas_start "add2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F626\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AA26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CA26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EA26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49A26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BA26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DA26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FA26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4AE26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4CE26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4EE26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49E26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4BE26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4DE26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4FE26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 08A40726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 08A42726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 08A44726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 08A46726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 08A48726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 08A4A726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 08A4C726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 08A4E726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 08A41726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 08A43726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 08A45726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 08A47726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 08A49726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 08A4B726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 08A4D726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 08A4F726\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 08A40F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 08A42F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 08A44F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 08A46F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 08A48F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 08A4AF26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 08A4CF26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 08A4EF26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 08A41F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 08A43F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 08A45F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 08A47F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 08A49F26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 08A4BF26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 08A4DF26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 08A4FF26\[^\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==80] then { pass $testname } else { fail $testname }
}
 
proc do_sh1add {} {
set testname "sh1add.s: sh1add tests"
set x 0
 
gas_start "sh1add.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4AE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4CE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4EE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4BE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4DE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4FE46\[^\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==48] then { pass $testname } else { fail $testname }
}
 
proc do_sh2add {} {
set testname "sh2add.s: sh2add tests"
set x 0
 
gas_start "sh2add.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4AE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4CE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4EE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4BE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4DE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4FE86\[^\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==48] then { pass $testname } else { fail $testname }
}
 
proc do_sh3add {} {
set testname "sh3add.s: sh3add tests"
set x 0
 
gas_start "sh3add.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A406C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A426C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A446C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A466C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A486C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A416C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A436C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A456C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A476C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A496C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4AEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4CEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4EEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4BEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4DEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4FEC6\[^\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==48] then { pass $testname } else { fail $testname }
}
 
proc do_shladd {} {
set testname "shladd.s: shladd tests"
set x 0
 
gas_start "shladd.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F646\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49A46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FA46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4AE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4CE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4EE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49E46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4BE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4DE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4FE46\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 08A40686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 08A42686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 08A44686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 08A46686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 08A48686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 08A4A686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 08A4C686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 08A4E686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 08A41686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 08A43686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 08A45686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 08A47686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 08A49686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 08A4B686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 08A4D686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 08A4F686\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 08A40A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 08A42A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 08A44A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 08A46A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 08A48A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 08A4AA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 08A4CA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 08A4EA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 08A41A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 08A43A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 08A45A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 08A47A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 08A49A86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 08A4BA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 08A4DA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 08A4FA86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 08A40E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 08A42E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 08A44E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c 08A46E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 08A48E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 08A4AE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 08A4CE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c 08A4EE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 08A41E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 08A43E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 08A45E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c 08A47E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 08A49E86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 08A4BE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 08A4DE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c 08A4FE86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0180 08A406C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0184 08A426C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0188 08A446C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 018c 08A466C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0190 08A486C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0194 08A4A6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0198 08A4C6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 019c 08A4E6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a0 08A416C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a4 08A436C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a8 08A456C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ac 08A476C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b0 08A496C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b4 08A4B6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b8 08A4D6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01bc 08A4F6C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c0 08A40AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c4 08A42AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c8 08A44AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01cc 08A46AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d0 08A48AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d4 08A4AAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d8 08A4CAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01dc 08A4EAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e0 08A41AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e4 08A43AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e8 08A45AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ec 08A47AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f0 08A49AC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f4 08A4BAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f8 08A4DAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01fc 08A4FAC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0200 08A40EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0204 08A42EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0208 08A44EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 020c 08A46EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0210 08A48EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0214 08A4AEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0218 08A4CEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 021c 08A4EEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0220 08A41EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0224 08A43EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0228 08A45EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 022c 08A47EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0230 08A49EC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0234 08A4BEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0238 08A4DEC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 023c 08A4FEC6\[^\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==144] then { pass $testname } else { fail $testname }
}
 
proc do_shladd2 {} {
set testname "shladd2.s: shladd2 tests"
set x 0
 
gas_start "shladd2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F666\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AA66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CA66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EA66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49A66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BA66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DA66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FA66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4AE66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4CE66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4EE66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49E66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4BE66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4DE66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4FE66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 08A406A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 08A426A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 08A446A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 08A466A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 08A486A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 08A4A6A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 08A4C6A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 08A4E6A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 08A416A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 08A436A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 08A456A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 08A476A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 08A496A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 08A4B6A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 08A4D6A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 08A4F6A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 08A40AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 08A42AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 08A44AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 08A46AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 08A48AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 08A4AAA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 08A4CAA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 08A4EAA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 08A41AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 08A43AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 08A45AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 08A47AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 08A49AA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 08A4BAA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 08A4DAA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 08A4FAA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 08A40EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 08A42EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 08A44EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c 08A46EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 08A48EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 08A4AEA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 08A4CEA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c 08A4EEA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 08A41EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 08A43EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 08A45EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c 08A47EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 08A49EA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 08A4BEA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 08A4DEA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c 08A4FEA6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0180 08A406E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0184 08A426E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0188 08A446E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 018c 08A466E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0190 08A486E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0194 08A4A6E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0198 08A4C6E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 019c 08A4E6E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a0 08A416E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a4 08A436E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a8 08A456E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ac 08A476E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b0 08A496E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b4 08A4B6E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b8 08A4D6E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01bc 08A4F6E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c0 08A40AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c4 08A42AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c8 08A44AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01cc 08A46AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d0 08A48AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d4 08A4AAE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d8 08A4CAE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01dc 08A4EAE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e0 08A41AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e4 08A43AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e8 08A45AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ec 08A47AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f0 08A49AE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f4 08A4BAE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f8 08A4DAE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01fc 08A4FAE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0200 08A40EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0204 08A42EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0208 08A44EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 020c 08A46EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0210 08A48EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0214 08A4AEE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0218 08A4CEE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 021c 08A4EEE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0220 08A41EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0224 08A43EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0228 08A45EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 022c 08A47EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0230 08A49EE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0234 08A4BEE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0238 08A4DEE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 023c 08A4FEE6\[^\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==144] then { pass $testname } else { fail $testname }
}
 
proc do_sub {} {
set testname "sub.s: sub tests"
set x 0
 
gas_start "sub.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F406\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4A506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4C506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4E506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4B506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4D506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4F506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 08A40D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 08A42D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 08A44D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 08A46D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 08A48D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 08A4AD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 08A4CD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 08A4ED06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 08A41D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 08A43D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 08A45D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 08A47D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 08A49D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 08A4BD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 08A4DD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 08A4FD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 08A404C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 08A424C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 08A444C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 08A464C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 08A484C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 08A4A4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 08A4C4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 08A4E4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 08A414C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 08A434C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 08A454C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 08A474C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 08A494C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 08A4B4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 08A4D4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 08A4F4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 08A40CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 08A42CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 08A44CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c 08A46CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 08A48CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 08A4ACC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 08A4CCC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c 08A4ECC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 08A41CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 08A43CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 08A45CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c 08A47CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 08A49CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 08A4BCC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 08A4DCC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c 08A4FCC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0180 08A40C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0184 08A42C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0188 08A44C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 018c 08A46C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0190 08A48C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0194 08A4AC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0198 08A4CC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 019c 08A4EC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a0 08A41C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a4 08A43C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a8 08A45C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ac 08A47C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b0 08A49C06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b4 08A4BC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b8 08A4DC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01bc 08A4FC06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c0 08A40506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c4 08A42506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01c8 08A44506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01cc 08A46506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d0 08A48506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d4 08A4A506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01d8 08A4C506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01dc 08A4E506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e0 08A41506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e4 08A43506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01e8 08A45506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ec 08A47506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f0 08A49506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f4 08A4B506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01f8 08A4D506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01fc 08A4F506\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0200 08A40D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0204 08A42D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0208 08A44D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 020c 08A46D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0210 08A48D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0214 08A4AD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0218 08A4CD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 021c 08A4ED06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0220 08A41D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0224 08A43D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0228 08A45D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 022c 08A47D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0230 08A49D06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0234 08A4BD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0238 08A4DD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 023c 08A4FD06\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0240 08A404C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0244 08A424C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0248 08A444C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 024c 08A464C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0250 08A484C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0254 08A4A4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0258 08A4C4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 025c 08A4E4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0260 08A414C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0264 08A434C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0268 08A454C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 026c 08A474C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0270 08A494C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0274 08A4B4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0278 08A4D4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 027c 08A4F4C6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0280 08A40CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0284 08A42CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0288 08A44CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 028c 08A46CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0290 08A48CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0294 08A4ACC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0298 08A4CCC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 029c 08A4ECC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02a0 08A41CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02a4 08A43CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02a8 08A45CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02ac 08A47CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02b0 08A49CC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02b4 08A4BCC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02b8 08A4DCC6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 02bc 08A4FCC6\[^\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==176] then { pass $testname } else { fail $testname }
}
 
proc do_sub2 {} {
set testname "sub2.s: sub2 tests"
set x 0
 
gas_start "sub2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F426\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A40C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A42C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A44C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A46C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A48C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A4AC26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4CC26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4EC26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A41C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A43C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A45C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A47C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A49C26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4BC26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A4DC26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A4FC26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A40526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A42526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A44526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A46526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A48526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A4A526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A4C526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4E526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A41526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A43526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A45526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A47526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A49526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A4B526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4D526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4F526\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 08A40D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 08A42D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 08A44D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 08A46D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 08A48D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 08A4AD26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 08A4CD26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 08A4ED26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 08A41D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 08A43D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 08A45D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 08A47D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 08A49D26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 08A4BD26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 08A4DD26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 08A4FD26\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 08A404E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 08A424E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 08A444E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 08A464E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 08A484E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 08A4A4E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 08A4C4E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 08A4E4E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 08A414E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 08A434E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 08A454E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 08A474E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 08A494E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 08A4B4E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 08A4D4E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 08A4F4E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 08A40CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 08A42CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 08A44CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c 08A46CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 08A48CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 08A4ACE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 08A4CCE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c 08A4ECE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 08A41CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 08A43CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 08A45CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c 08A47CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 08A49CE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 08A4BCE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 08A4DCE6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c 08A4FCE6\[^\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==96] then { pass $testname } else { fail $testname }
}
 
proc do_ds {} {
set testname "ds.s: ds tests"
set x 0
 
gas_start "ds.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D446\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F446\[^\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==16] then { pass $testname } else { fail $testname }
}
 
proc do_comclr {} {
set testname "comclr.s: comclr tests"
set x 0
 
gas_start "comclr.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A48886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4A886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A4C886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A4E886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A41886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A43886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A45886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A47886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A49886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A4B886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4D886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A4F886\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 90A600F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 90A620F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 90A640F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 90A660F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 90A680F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 90A6A0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 90A6C0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 90A6E0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 90A610F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 90A630F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 90A650F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 90A670F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 90A690F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 90A6B0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 90A6D0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 90A6F0F6\[^\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==32] then { pass $testname } else { fail $testname }
}
 
proc do_logical {} {
set testname "logical.s: logical tests"
set x 0
 
gas_start "logical.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A42246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A44246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A46246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A4E246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A41246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A43246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A45246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A47246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A4F246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A40286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A42286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A44286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A46286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A4E286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A41286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A43286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A45286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A47286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A4F286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A40206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A42206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A44206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A46206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A4E206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A41206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A43206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A45206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A47206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4F206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A40006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A42006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A44006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A46006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A4E006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A41006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A43006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A45006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A47006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A4F006\[^\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==40] then { pass $testname } else { fail $testname }
}
 
proc do_unit {} {
set testname "unit.s: unit tests"
set x 0
 
gas_start "unit.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A40386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A44386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A46386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A48386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A4C386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4E386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A41386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A45386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A47386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A49386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A4D386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A4F386\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A40986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A44986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A46986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A48986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A4C986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A4E986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A41986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A45986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A47986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A49986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4D986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4F986\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A409C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A449C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A469C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A489C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A4C9C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4E9C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A419C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A459C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A479C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A499C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A4D9C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A4F9C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 08A409C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 08A449C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 08A469C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 08A489C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 08A4C9C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 08A4E9C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 08A419C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 08A459C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 08A479C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 08A499C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 08A4D9C6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 08A4F9C6\[^\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==48] then { pass $testname } else { fail $testname }
}
 
proc do_unit2 {} {
set testname "unit2.s: unit2 tests"
set x 0
 
gas_start "unit2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08A403A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08A443A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08A463A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08A483A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 08A4C3A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 08A4E3A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08A413A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08A453A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08A473A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08A493A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 08A4D3A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 08A4F3A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08A409A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08A449A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08A469A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08A489A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 08A4C9A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 08A4E9A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08A419A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08A459A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08A479A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08A499A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 08A4D9A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 08A4F9A6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08A409E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08A449E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08A469E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08A489E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 08A4C9E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 08A4E9E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08A419E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08A459E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08A479E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08A499E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 08A4D9E6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 08A4F9E6\[^\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==36] then { pass $testname } else { fail $testname }
}
 
proc do_dcor {} {
set testname "dcor.s: dcor tests"
set x 0
 
gas_start "dcor.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08800B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08804B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08806B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08808B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 0880CB85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 0880EB85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08801B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08805B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08807B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08809B85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 0880DB85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 0880FB85\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08800BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08804BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08806BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08808BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 0880CBC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 0880EBC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08801BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08805BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08807BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08809BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 0880DBC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 0880FBC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 08800BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 08804BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 08806BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 08808BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 0880CBC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 0880EBC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 08801BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 08805BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 08807BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 08809BC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 0880DBC5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 0880FBC5\[^\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==36] then { pass $testname } else { fail $testname }
}
 
proc do_dcor2 {} {
set testname "dcor2.s: dcor2 tests"
set x 0
 
gas_start "dcor2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 08800BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 08804BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08806BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 08808BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 0880CBA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 0880EBA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 08801BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 08805BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 08807BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 08809BA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 0880DBA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 0880FBA5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 08800BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 08804BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 08806BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 08808BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 0880CBE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 0880EBE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 08801BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 08805BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 08807BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 08809BE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 0880DBE5\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 0880FBE5\[^\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==24] then { pass $testname } else { fail $testname }
}
 
proc do_addi {} {
set testname "addi.s: addi tests"
set x 0
 
gas_start "addi.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 B4A600F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 B4A620F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 B4A640F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c B4A660F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 B4A680F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 B4A6A0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 B4A6C0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c B4A6E0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 B4A610F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 B4A630F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 B4A650F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c B4A670F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 B4A690F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 B4A6B0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 B4A6D0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c B4A6F0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 B4A608F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 B4A628F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 B4A648F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c B4A668F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 B4A688F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 B4A6A8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 B4A6C8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c B4A6E8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 B4A618F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 B4A638F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 B4A658F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c B4A678F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 B4A698F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 B4A6B8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 B4A6D8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c B4A6F8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 B0A600F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 B0A620F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 B0A640F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c B0A660F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 B0A680F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 B0A6A0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 B0A6C0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c B0A6E0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 B0A610F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 B0A630F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 B0A650F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac B0A670F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 B0A690F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 B0A6B0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 B0A6D0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc B0A6F0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 B0A608F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 B0A628F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 B0A648F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc B0A668F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 B0A688F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 B0A6A8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 B0A6C8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc B0A6E8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 B0A618F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 B0A638F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 B0A658F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec B0A678F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 B0A698F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 B0A6B8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 B0A6D8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc B0A6F8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 B4A608F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 B4A628F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 B4A648F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c B4A668F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 B4A688F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 B4A6A8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 B4A6C8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c B4A6E8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 B4A618F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 B4A638F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 B4A658F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c B4A678F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 B4A698F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 B4A6B8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 B4A6D8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c B4A6F8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 B0A600F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 B0A620F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 B0A640F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c B0A660F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 B0A680F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 B0A6A0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 B0A6C0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c B0A6E0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 B0A610F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 B0A630F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 B0A650F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c B0A670F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 B0A690F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 B0A6B0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 B0A6D0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c B0A6F0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0180 B0A608F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0184 B0A628F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0188 B0A648F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 018c B0A668F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0190 B0A688F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0194 B0A6A8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0198 B0A6C8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 019c B0A6E8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a0 B0A618F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a4 B0A638F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01a8 B0A658F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01ac B0A678F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b0 B0A698F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b4 B0A6B8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01b8 B0A6D8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 01bc B0A6F8F6\[^\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==112] then { pass $testname } else { fail $testname }
}
 
proc do_subi {} {
set testname "subi.s: subi tests"
set x 0
 
gas_start "subi.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 94A600F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 94A620F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 94A640F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 94A660F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 94A680F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 94A6A0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 94A6C0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 94A6E0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 94A610F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 94A630F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 94A650F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 94A670F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 94A690F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 94A6B0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 94A6D0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 94A6F0F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 94A608F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 94A628F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 94A648F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 94A668F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 94A688F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 94A6A8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 94A6C8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 94A6E8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 94A618F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 94A638F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 94A658F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 94A678F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 94A698F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 94A6B8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 94A6D8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 94A6F8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 94A608F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 94A628F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 94A648F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 94A668F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 94A688F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 94A6A8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 94A6C8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 94A6E8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 94A618F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 94A638F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 94A658F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 94A678F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 94A698F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 94A6B8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 94A6D8F6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 94A6F8F6\[^\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==48] then { pass $testname } else { fail $testname }
}
 
proc do_shift {} {
set testname "shift.s: shift tests"
set x 0
 
gas_start "shift.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D0A40006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D0A42006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D0A44006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D0A46006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D0A48006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D0A4A006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D0A4C006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D0A4E006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D0A40B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D0A42B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D0A44B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D0A46B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D0A48B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D0A4AB46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D0A4CB46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D0A4EB46\[^\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==16] then { pass $testname } else { fail $testname }
}
 
proc do_shift2 {} {
set testname "shift2.s: shift tests"
set x 0
 
gas_start "shift2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D0A40006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D0A42006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D0A44006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D0A46006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D0A48006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D0A4A006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D0A4C006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D0A4E006\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D0A40B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D0A42B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D0A44B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D0A46B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D0A48B46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D0A4AB46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D0A4CB46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D0A4EB46\[^\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==16] then { pass $testname } else { fail $testname }
}
 
proc do_shift3 {} {
set testname "shift3.s: shift3 tests"
set x 0
 
gas_start "shift3.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D0A40206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D0A42206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D0A44206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D0A46206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D0A48206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D0A4A206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D0A4C206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D0A4E206\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D0A40F46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D0A42F46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D0A44F46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D0A46F46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D0A48F46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D0A4AF46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D0A4CF46\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D0A4EF46\[^\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==16] then { pass $testname } else { fail $testname }
}
 
proc do_extract {} {
set testname "extract.s: extract tests"
set x 0
 
gas_start "extract.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D08618B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D08638B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D08658B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D08678B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D08698B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D086B8B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D086D8B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D086F8B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D0861CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D0863CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D0865CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D0867CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D0869CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D086BCB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D086DCB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D086FCB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 D086101B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 D086301B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 D086501B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c D086701B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 D086901B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 D086B01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 D086D01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c D086F01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 D086141B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 D086341B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 D086541B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c D086741B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 D086941B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 D086B41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 D086D41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c D086F41B\[^\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==32] then { pass $testname } else { fail $testname }
}
 
proc do_extract2 {} {
set testname "extract2.s: extract2 tests"
set x 0
 
gas_start "extract2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D08618B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D08638B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D08658B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D08678B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D08698B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D086B8B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D086D8B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D086F8B6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D0861CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D0863CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D0865CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D0867CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D0869CB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D086BCB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D086DCB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D086FCB6\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 D086101B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 D086301B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 D086501B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c D086701B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 D086901B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 D086B01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 D086D01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c D086F01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 D086141B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 D086341B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 D086541B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c D086741B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 D086941B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 D086B41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 D086D41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c D086F41B\[^\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==32] then { pass $testname } else { fail $testname }
}
 
proc do_extract3 {} {
set testname "extract3.s: extract3 tests"
set x 0
 
gas_start "extract3.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D886015B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D886215B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D886415B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D886615B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D886815B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D886A15B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D886C15B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D886E15B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D886055B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D886255B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D886455B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D886655B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D886855B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D886A55B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D886C55B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D886E55B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 D086121B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 D086321B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 D086521B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c D086721B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 D086921B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 D086B21B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 D086D21B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c D086F21B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 D086161B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 D086361B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 D086561B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c D086761B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 D086961B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 D086B61B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 D086D61B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c D086F61B\[^\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==32] then { pass $testname } else { fail $testname }
}
 
proc do_deposit {} {
set testname "deposit.s: deposit tests"
set x 0
 
gas_start "deposit.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D4C40B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D4C42B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D4C44B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D4C46B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D4C48B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D4C4AB56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D4C4CB56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D4C4EB56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D4C40F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D4C42F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D4C44F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D4C46F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D4C48F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D4C4AF56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D4C4CF56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D4C4EF56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 D4C4001B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 D4C4201B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 D4C4401B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c D4C4601B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 D4C4801B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 D4C4A01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 D4C4C01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c D4C4E01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 D4C4041B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 D4C4241B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 D4C4441B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c D4C4641B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 D4C4841B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 D4C4A41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 D4C4C41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c D4C4E41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 D4DF141B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 D4DF341B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 D4DF541B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c D4DF741B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 D4DF941B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 D4DFB41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 D4DFD41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c D4DFF41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 D4DF101B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 D4DF301B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 D4DF501B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac D4DF701B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 D4DF901B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 D4DFB01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 D4DFD01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc D4DFF01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 D4DF1F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 D4DF3F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 D4DF5F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc D4DF7F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 D4DF9F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 D4DFBF76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 D4DFDF76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc D4DFFF76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 D4DF1B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 D4DF3B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 D4DF5B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec D4DF7B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 D4DF9B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 D4DFBB76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 D4DFDB76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc D4DFFB76\[^\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==64] then { pass $testname } else { fail $testname }
}
 
proc do_deposit2 {} {
set testname "deposit2.s: deposit2 tests"
set x 0
 
gas_start "deposit2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 D4C40B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D4C42B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D4C44B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c D4C46B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 D4C48B56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 D4C4AB56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 D4C4CB56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c D4C4EB56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 D4C40F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 D4C42F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 D4C44F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c D4C46F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 D4C48F56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 D4C4AF56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 D4C4CF56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c D4C4EF56\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 D4C4001B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 D4C4201B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 D4C4401B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c D4C4601B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 D4C4801B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 D4C4A01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 D4C4C01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c D4C4E01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 D4C4041B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 D4C4241B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 D4C4441B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c D4C4641B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 D4C4841B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 D4C4A41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 D4C4C41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c D4C4E41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 D4DF141B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 D4DF341B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 D4DF541B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c D4DF741B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 D4DF941B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 D4DFB41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 D4DFD41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c D4DFF41B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 D4DF101B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 D4DF301B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 D4DF501B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac D4DF701B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 D4DF901B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 D4DFB01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 D4DFD01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc D4DFF01B\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 D4DF1F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 D4DF3F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 D4DF5F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc D4DF7F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 D4DF9F76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 D4DFBF76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 D4DFDF76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc D4DFFF76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 D4DF1B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 D4DF3B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 D4DF5B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec D4DF7B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 D4DF9B76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 D4DFBB76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 D4DFDB76\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc D4DFFB76\[^\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==64] then { pass $testname } else { fail $testname }
}
 
proc do_deposit3 {} {
set testname "deposit3.s: deposit3 tests"
set x 0
 
gas_start "deposit3.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 F0C40ABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 F0C42ABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 F0C44ABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c F0C46ABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 F0C48ABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 F0C4AABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 F0C4CABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c F0C4EABB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 F0C40EBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 F0C42EBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 F0C44EBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c F0C46EBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 F0C48EBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 F0C4AEBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 F0C4CEBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c F0C4EEBB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 D4C4021B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 D4C4221B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 D4C4421B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c D4C4621B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 D4C4821B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 D4C4A21B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 D4C4C21B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c D4C4E21B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 D4C4061B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 D4C4261B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 D4C4461B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c D4C4661B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 D4C4861B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 D4C4A61B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 D4C4C61B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c D4C4E61B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 D4DF161B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 D4DF361B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 D4DF561B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c D4DF761B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 D4DF961B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 D4DFB61B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 D4DFD61B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c D4DFF61B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 D4DF121B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 D4DF321B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 D4DF521B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac D4DF721B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 D4DF921B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 D4DFB21B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 D4DFD21B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc D4DFF21B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 F4DF0EBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 F4DF2EBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 F4DF4EBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc F4DF6EBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 F4DF8EBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 F4DFAEBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 F4DFCEBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc F4DFEEBC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 F4DF0ABC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 F4DF2ABC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 F4DF4ABC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec F4DF6ABC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 F4DF8ABC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 F4DFAABC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 F4DFCABC\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc F4DFEABC\[^\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==64] then { pass $testname } else { fail $testname }
}
 
proc do_system {} {
set testname "system.s: system tests"
set x 0
 
gas_start "system.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 00018005\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 00000C00\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 00000CA0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 00050D64\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 00050E64\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 00041860\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 00A010A4\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 00041820\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 01441840\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 000004A4\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 014008A4\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 00000400\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 00100400\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 140004D2\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 04A61187\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 04A13187\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 04A611C7\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 04A131C7\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 04A41346\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 04A41366\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 04A41306\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 04A41040\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 04A42040\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 04A41000\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 04A42000\[^\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==25] then { pass $testname } else { fail $testname }
}
 
proc do_system2 {} {
set testname "system2.s: system2 tests"
set x 0
 
gas_start "system2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 00000C00\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 00000CA0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 039B0D64\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 039B0E64\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 016048A4\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 04A61187\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 04A13187\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 04A611C7\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 04A131C7\[^\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_purge {} {
set testname "purge.s: purge tests"
set x 0
 
gas_start "purge.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 04A41200\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 04A41220\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 04A42200\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 04A42220\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 04A41240\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 04A41260\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 04A42240\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 04A42260\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 04A41380\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 04A413A0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 04A41280\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 04A412A0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 04A42280\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 04A422A0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 04A412C0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 04A412E0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 04A422C0\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 04A422E0\[^\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==18] then { pass $testname } else { fail $testname }
}
 
proc do_purge2 {} {
set testname "purge2.s: purge2 tests"
set x 0
 
gas_start "purge2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 04A41600\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 04A41620\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 04A42600\[^\n]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 04A42620\[^\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_fp_misc {} {
set testname "fp_misc.s: fp_misc tests"
set x 0
 
gas_start "fp_misc.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 30002420\[^\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==1] then { pass $testname } else { fail $testname }
}
 
proc do_fmem {} {
set testname "fmem.s: fmem tests"
set x 0
 
gas_start "fmem.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 24A40006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 24A42006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 24A40026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 24A42026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 2CA40006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 2CA42006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 2CA40026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 2CA42026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 24A40206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 24A42206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 24A40226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 24A42226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 2CA40206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 2CA42206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 2CA40226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 2CA42226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 3CA40206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 3CA42206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 3CA40226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 3CA42226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 24A01006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 24A03026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 24A01026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 2CA01006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 2CA03026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 2CA01026\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 24A01206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 24A03226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 24A01226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 2CA01206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 2CA03226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 2CA01226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 3CA01206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 3CA03226\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 3CA01226\[^\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==35] then { pass $testname } else { fail $testname }
}
 
proc do_fp_comp {} {
set testname "fp_comp.s: fp_comp tests"
set x 0
 
gas_start "fp_comp.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 30A0400A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 30A0480A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 30A0580A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 32804018\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 32804818\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 30A0600A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 30A0680A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 30A0780A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 32806018\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 32806818\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 30A0800A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 30A0880A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 30A0980A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 32808018\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 32808818\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 30A0A00A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 30A0A80A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 30A0B80A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 3280A018\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 3280A818\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 3088060C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 30880E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 30881E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 3298061C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 32980E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 32981E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 3088260C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 30882E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 30883E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 3298261C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 32982E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 32983E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 3088460C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 30884E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 30885E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 3298461C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 32984E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 32985E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 3088660C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 30886E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 30887E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 3298661C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 32986E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 32987E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 3088860C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 30888E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 30889E0C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 3298861C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 32988E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 32989E1C\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 180120E2\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 1A11A4D2\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 980120E2\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 9A11A4D2\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 38854706\[^\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==55] then { pass $testname } else { fail $testname }
}
 
proc do_fp_comp2 {} {
set testname "fp_comp2.s: fp_comp2 tests"
set x 0
 
gas_start "fp_comp2.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 B8AA638E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 B8AA6A0E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 BA5B2595\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c BA5B2C15\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 B8AA63AE\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 B8AA6A2E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 BA5B25B5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c BA5B2C35\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 38A0C04A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 30A0C80A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 30A0D80A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 3A80C098\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 3280C818\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 38A0E04A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 30A0E80A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 30A0F80A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 3A80E098\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 3280E818\[^\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==18] then { pass $testname } else { fail $testname }
}
 
proc do_fp_conv {} {
set testname "fp_conv.s: fp_conv tests"
set x 0
 
gas_start "fp_conv.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 30A0020A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 30A0220A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 30A0620A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 30A00A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 30A02A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 30A06A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 30A01A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 30A03A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 30A07A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 32800218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 32802218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 32806218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 32800A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 32802A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 32806A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 32801A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 32803A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 32807A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 30A0820A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 30A0A20A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 30A0E20A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 30A08A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 30A0AA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 30A0EA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 30A09A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 30A0BA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 30A0FA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 32808218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 3280A218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 3280E218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 32808A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 3280AA18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 3280EA18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 32809A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 3280BA18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 3280FA18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 30A1020A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 30A1220A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 30A1620A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 30A10A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 30A12A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 30A16A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 30A11A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 30A13A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 30A17A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 32810218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 32812218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 32816218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 32810A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 32812A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 32816A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 32811A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 32813A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 32817A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 30A1820A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 30A1A20A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 30A1E20A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 30A18A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 30A1AA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 30A1EA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 30A19A0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 30A1BA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 30A1FA0A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 32818218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 3281A218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 3281E218\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 32818A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 3281AA18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 3281EA18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 32819A18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 3281BA18\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 3281FA18\[^\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==72] then { pass $testname } else { fail $testname }
}
 
proc do_fp_fcmp {} {
set testname "fp_fcmp.s: fp_fcmp tests"
set x 0
 
gas_start "fp_fcmp.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 30850400\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 30850401\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 30850402\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 30850403\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 30850404\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 30850405\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 30850406\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 30850407\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 30850408\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 30850409\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 3085040A\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 3085040B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 3085040C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 3085040D\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 3085040E\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 3085040F\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 30850410\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 30850411\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 30850412\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 30850413\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 30850414\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 30850415\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 30850416\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 30850417\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 30850418\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 30850419\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 3085041A\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 3085041B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 3085041C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 3085041D\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 3085041E\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 3085041F\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 30850C00\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 30850C01\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 30850C02\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 30850C03\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 30850C04\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 30850C05\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 30850C06\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 30850C07\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 30850C08\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 30850C09\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 30850C0A\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 30850C0B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 30850C0C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 30850C0D\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 30850C0E\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 30850C0F\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 30850C10\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 30850C11\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c8 30850C12\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00cc 30850C13\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d0 30850C14\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d4 30850C15\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00d8 30850C16\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00dc 30850C17\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e0 30850C18\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e4 30850C19\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00e8 30850C1A\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ec 30850C1B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f0 30850C1C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f4 30850C1D\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00f8 30850C1E\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 00fc 30850C1F\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0100 30851C00\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0104 30851C01\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0108 30851C02\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 010c 30851C03\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0110 30851C04\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0114 30851C05\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0118 30851C06\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 011c 30851C07\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0120 30851C08\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0124 30851C09\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0128 30851C0A\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 012c 30851C0B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0130 30851C0C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0134 30851C0D\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0138 30851C0E\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 013c 30851C0F\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0140 30851C10\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0144 30851C11\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0148 30851C12\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 014c 30851C13\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0150 30851C14\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0154 30851C15\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0158 30851C16\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 015c 30851C17\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0160 30851C18\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0164 30851C19\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0168 30851C1A\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 016c 30851C1B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0170 30851C1C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0174 30851C1D\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0178 30851C1E\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 017c 30851C1F\[^\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==96] then { pass $testname } else { fail $testname }
}
 
proc do_media {} {
set testname "media.s: media tests"
set x 0
 
gas_start "media.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 096703CC\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 0967034C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 0967030C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 096702CC\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 F8078B4B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 0967074C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 0967078C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 096707CC\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 F8E0CF4B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 F8E0CF4B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 F8E0CB4B\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 0967054C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 0967058C\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 096705CC\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 0ACE01C9\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 0ACE0149\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 0ACE0109\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 FACE8409\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 FACEC409\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c FACE8009\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 FACEC009\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 FAD60E49\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 FAD64A89\[^\n\]*\n" {set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c FAD66309\[^\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==24] then { pass $testname } else { fail $testname }
}
 
proc do_special {} {
set testname "special.s: special tests"
set x 0
 
gas_start "special.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 04A41680\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 04A416A0\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 04A41A80\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 04A41AA0\[^\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_perf {} {
set testname "perf.s: perf tests"
set x 0
 
gas_start "perf.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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).
 
# The third one is questionable. HP as doesn't generate what the book
# says. It outputs the nullify flag at 30 instead.
 
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 30000680\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 30000280\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 300002A0\[^\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_spop {} {
set testname "spop.s: spop tests"
set x 0
 
# This tickles a bug in the expression parser.
gas_start "spop.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 10000105\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 10001913\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 10000125\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 10001933\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 10002B05\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 10039B05\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 10002B25\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 10039B25\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 10A00505\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 10A01D13\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 10A00525\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 10A01D33\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 10C50705\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 10C51F13\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 10C50725\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 10C51F33\[^\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==16] then { pass $testname } else { fail $testname }
}
 
proc do_copr {} {
set testname "copr.s: copr tests"
set x 0
 
gas_start "copr.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 30000105\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 30000713\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 30000125\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 30000733\[^\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_coprmem {} {
set testname "coprmem.s: copr memory tests"
set x 0
 
gas_start "coprmem.s" "-al"
 
# Check the assembled instruction against a table built by the HP assembler
# Any differences should be checked by hand -- with the number of problems
# I've seen in the HP assembler I don't completely trust it.
#
# 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 2485011A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 2485211A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 2485013A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 2485213A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 2C85011A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 2C85211A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 2C85013A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 2C85213A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 2485031A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 2485231A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 2485033A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 2485233A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 2C85031A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 2C85231A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 2C85033A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 2C85233A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 2480111A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 2480313A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 2480113A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 2C80111A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 2C80313A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 2C80113A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 2480131A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 2480333A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 2480133A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 2C80131A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 2C80333A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 2C80133A\[^\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==28] then { pass $testname } else { fail $testname }
}
 
proc do_fmem_LR_tests {} {
set testname "fmemLRbug.s: LR register selection on fp mem instructions"
set x 0
 
gas_start "fmemLRbug.s" "-al"
 
# Make sure we correctly handle field selectors.
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 27401246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 27481206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 27501206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 2F401206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 2F481206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 2F501206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 27401046\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 27481006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 27501006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 2F401006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 2F481006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c 2F501006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 27401246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 27481206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 27501206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c 2F401206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 2F481206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 2F501206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 27401046\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c 27481006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 27501006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 2F401006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0058 2F481006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 005c 2F501006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0060 27590246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0064 27590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0068 27590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 006c 2F590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0070 2F590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0074 2F590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0078 27590046\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 007c 27590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0080 27590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0084 2F590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0088 2F590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 008c 2F590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0090 27590246\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0094 27590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0098 27590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 009c 2F590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a0 2F590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a4 2F590206\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00a8 27590046\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00ac 27590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b0 27590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b4 2F590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00b8 2F590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00bc 2F590006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c0 E840C000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 00c4 08000240\[^\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==50] then { pass $testname } else { fail $testname }
}
 
if [istarget hppa*-*-*] then {
# Test the basic instruction parser.
do_imem
do_immed
do_branch
do_add
do_add2
do_sh1add
do_sh2add
do_sh3add
do_shladd
do_shladd2
do_sub
do_sub2
do_ds
do_comclr
do_logical
do_unit
do_unit2
do_dcor
do_dcor2
do_addi
do_subi
do_shift
do_shift2
do_shift3
do_extract
do_extract2
do_extract3
do_deposit
do_deposit2
do_deposit3
do_system
do_system2
do_purge
do_purge2
do_fp_misc
do_fmem
do_fp_comp
do_fp_conv
do_fp_fcmp
do_special
do_perf
do_spop
do_copr
do_coprmem
 
# The "weird.s" file from the gdb testsuite. Simply verify it
# assembles.
gas_test "weird.s" "" "" "stabs parsing"
 
# Test that we correctly assemble some FP memory tests which
# L/R register selects. (Regression test for a bug Tege found).
do_fmem_LR_tests
 
# PA2.0 tests
do_fp_comp2
do_branch2
do_media
}
/basic/sub2.s
0,0 → 1,109
.LEVEL 2.0
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
sub,* %r4,%r5,%r6
sub,*= %r4,%r5,%r6
sub,*< %r4,%r5,%r6
sub,*<= %r4,%r5,%r6
sub,*<< %r4,%r5,%r6
sub,*<<= %r4,%r5,%r6
sub,*sv %r4,%r5,%r6
sub,*od %r4,%r5,%r6
sub,*tr %r4,%r5,%r6
sub,*<> %r4,%r5,%r6
sub,*>= %r4,%r5,%r6
sub,*> %r4,%r5,%r6
sub,*>>= %r4,%r5,%r6
sub,*>> %r4,%r5,%r6
sub,*nsv %r4,%r5,%r6
sub,*ev %r4,%r5,%r6
 
sub,tsv,* %r4,%r5,%r6
sub,tsv,*= %r4,%r5,%r6
sub,tsv,*< %r4,%r5,%r6
sub,tsv,*<= %r4,%r5,%r6
sub,tsv,*<< %r4,%r5,%r6
sub,tsv,*<<= %r4,%r5,%r6
sub,tsv,*sv %r4,%r5,%r6
sub,tsv,*od %r4,%r5,%r6
sub,tsv,*tr %r4,%r5,%r6
sub,tsv,*<> %r4,%r5,%r6
sub,tsv,*>= %r4,%r5,%r6
sub,tsv,*> %r4,%r5,%r6
sub,tsv,*>>= %r4,%r5,%r6
sub,tsv,*>> %r4,%r5,%r6
sub,tsv,*nsv %r4,%r5,%r6
sub,tsv,*ev %r4,%r5,%r6
 
sub,db,* %r4,%r5,%r6
sub,db,*= %r4,%r5,%r6
sub,db,*< %r4,%r5,%r6
sub,db,*<= %r4,%r5,%r6
sub,db,*<< %r4,%r5,%r6
sub,db,*<<= %r4,%r5,%r6
sub,db,*sv %r4,%r5,%r6
sub,db,*od %r4,%r5,%r6
sub,db,*tr %r4,%r5,%r6
sub,db,*<> %r4,%r5,%r6
sub,db,*>= %r4,%r5,%r6
sub,db,*> %r4,%r5,%r6
sub,db,*>>= %r4,%r5,%r6
sub,db,*>> %r4,%r5,%r6
sub,db,*nsv %r4,%r5,%r6
sub,db,*ev %r4,%r5,%r6
 
sub,db,tsv,* %r4,%r5,%r6
sub,db,tsv,*= %r4,%r5,%r6
sub,db,tsv,*< %r4,%r5,%r6
sub,db,tsv,*<= %r4,%r5,%r6
sub,db,tsv,*<< %r4,%r5,%r6
sub,db,tsv,*<<= %r4,%r5,%r6
sub,db,tsv,*sv %r4,%r5,%r6
sub,db,tsv,*od %r4,%r5,%r6
sub,tsv,db,*tr %r4,%r5,%r6
sub,tsv,db,*<> %r4,%r5,%r6
sub,tsv,db,*>= %r4,%r5,%r6
sub,tsv,db,*> %r4,%r5,%r6
sub,tsv,db,*>>= %r4,%r5,%r6
sub,tsv,db,*>> %r4,%r5,%r6
sub,tsv,db,*nsv %r4,%r5,%r6
sub,tsv,db,*ev %r4,%r5,%r6
 
sub,tc,* %r4,%r5,%r6
sub,tc,*= %r4,%r5,%r6
sub,tc,*< %r4,%r5,%r6
sub,tc,*<= %r4,%r5,%r6
sub,tc,*<< %r4,%r5,%r6
sub,tc,*<<= %r4,%r5,%r6
sub,tc,*sv %r4,%r5,%r6
sub,tc,*od %r4,%r5,%r6
sub,tc,*tr %r4,%r5,%r6
sub,tc,*<> %r4,%r5,%r6
sub,tc,*>= %r4,%r5,%r6
sub,tc,*> %r4,%r5,%r6
sub,tc,*>>= %r4,%r5,%r6
sub,tc,*>> %r4,%r5,%r6
sub,tc,*nsv %r4,%r5,%r6
sub,tc,*ev %r4,%r5,%r6
 
sub,tc,tsv,* %r4,%r5,%r6
sub,tc,tsv,*= %r4,%r5,%r6
sub,tc,tsv,*< %r4,%r5,%r6
sub,tc,tsv,*<= %r4,%r5,%r6
sub,tc,tsv,*<< %r4,%r5,%r6
sub,tc,tsv,*<<= %r4,%r5,%r6
sub,tc,tsv,*sv %r4,%r5,%r6
sub,tc,tsv,*od %r4,%r5,%r6
sub,tsv,tc,*tr %r4,%r5,%r6
sub,tsv,tc,*<> %r4,%r5,%r6
sub,tsv,tc,*>= %r4,%r5,%r6
sub,tsv,tc,*> %r4,%r5,%r6
sub,tsv,tc,*>>= %r4,%r5,%r6
sub,tsv,tc,*>> %r4,%r5,%r6
sub,tsv,tc,*nsv %r4,%r5,%r6
sub,tsv,tc,*ev %r4,%r5,%r6
/basic/shift.s
0,0 → 1,25
.code
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
vshd %r4,%r5,%r6
vshd,= %r4,%r5,%r6
vshd,< %r4,%r5,%r6
vshd,od %r4,%r5,%r6
vshd,tr %r4,%r5,%r6
vshd,<> %r4,%r5,%r6
vshd,>= %r4,%r5,%r6
vshd,ev %r4,%r5,%r6
 
shd %r4,%r5,5,%r6
shd,= %r4,%r5,5,%r6
shd,< %r4,%r5,5,%r6
shd,od %r4,%r5,5,%r6
shd,tr %r4,%r5,5,%r6
shd,<> %r4,%r5,5,%r6
shd,>= %r4,%r5,5,%r6
shd,ev %r4,%r5,5,%r6
 
/unsorted/align4.s
0,0 → 1,4
.space $TEXT$
.subspa $YABBA$
.subspa $MILLICODE$
.align 64
/unsorted/globalbug.s
0,0 → 1,16
 
.space $PRIVATE$
.subspa $GLOBAL$
.export $global$
$global$
.space $TEXT$
.subspa $CODE$
 
.proc
.callinfo
ivaaddr
nop
nop
addil L%ivaaddr-$global$,%dp
ldo R%ivaaddr-$global$(%r1),%r19
.procend
/unsorted/ss_align.s
0,0 → 1,12
.SPACE $PRIVATE$
.SUBSPA $DATA$,QUAD=1,ALIGN=64,ACCESS=31
.SPACE $TEXT$
.SUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=44
.SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
; gcc_compiled.:
.SPACE $PRIVATE$
.SUBSPA $DATA$
sym1: .WORD 2
 
/unsorted/brlenbug.s
0,0 → 1,3488
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
; gcc_compiled.:
.data
 
.align 4
done___2
.word 0
.IMPORT memset,CODE
.EXPORT re_syntax_options,DATA
.align 4
re_syntax_options
.word 0
 
.align 4
re_error_msg
.word 0
.word L$C0000
.word L$C0001
.word L$C0002
.word L$C0003
.word L$C0004
.word L$C0005
.word L$C0006
.word L$C0007
.word L$C0008
.word L$C0009
.word L$C0010
.word L$C0011
.word L$C0012
.word L$C0013
.word L$C0014
.word L$C0015
.code
 
.align 4
L$C0015
.STRING "Unmatched ) or \\)\x00"
.align 4
L$C0014
.STRING "Regular expression too big\x00"
.align 4
L$C0013
.STRING "Premature end of regular expression\x00"
.align 4
L$C0012
.STRING "Invalid preceding regular expression\x00"
.align 4
L$C0011
.STRING "Memory exhausted\x00"
.align 4
L$C0010
.STRING "Invalid range end\x00"
.align 4
L$C0009
.STRING "Invalid content of \\{\\}\x00"
.align 4
L$C0008
.STRING "Unmatched \\{\x00"
.align 4
L$C0007
.STRING "Unmatched ( or \\(\x00"
.align 4
L$C0006
.STRING "Unmatched [ or [^\x00"
.align 4
L$C0005
.STRING "Invalid back reference\x00"
.align 4
L$C0004
.STRING "Trailing backslash\x00"
.align 4
L$C0003
.STRING "Invalid character class name\x00"
.align 4
L$C0002
.STRING "Invalid collation character\x00"
.align 4
L$C0001
.STRING "Invalid regular expression\x00"
.align 4
L$C0000
.STRING "No match\x00"
.EXPORT re_max_failures,DATA
.data
 
.align 4
re_max_failures
.word 2000
.IMPORT malloc,CODE
.IMPORT realloc,CODE
.IMPORT free,CODE
.IMPORT strcmp,CODE
.code
 
.align 4
L$C0016
.STRING "alnum\x00"
.align 4
L$C0017
.STRING "alpha\x00"
.align 4
L$C0018
.STRING "blank\x00"
.align 4
L$C0019
.STRING "cntrl\x00"
.align 4
L$C0020
.STRING "digit\x00"
.align 4
L$C0021
.STRING "graph\x00"
.align 4
L$C0022
.STRING "lower\x00"
.align 4
L$C0023
.STRING "print\x00"
.align 4
L$C0024
.STRING "punct\x00"
.align 4
L$C0025
.STRING "space\x00"
.align 4
L$C0026
.STRING "upper\x00"
.align 4
L$C0027
.STRING "xdigit\x00"
.IMPORT __alnum,DATA
.IMPORT __ctype2,DATA
.IMPORT __ctype,DATA
.IMPORT at_begline_loc_p,CODE
.IMPORT at_endline_loc_p,CODE
.IMPORT store_op1,CODE
.IMPORT insert_op1,CODE
.IMPORT store_op2,CODE
.IMPORT insert_op2,CODE
.IMPORT compile_range,CODE
.IMPORT group_in_compile_stack,CODE
.code
 
.align 4
regex_compile
.PROC
.CALLINFO FRAME=320,CALLS,SAVE_RP,ENTRY_GR=18
.ENTRY
stw %r2,-20(%r30) ;# 8989 reload_outsi+2/6
ldo 320(%r30),%r30 ;# 8991 addsi3/2
stw %r18,-168(%r30) ;# 8993 reload_outsi+2/6
stw %r17,-164(%r30) ;# 8995 reload_outsi+2/6
stw %r16,-160(%r30) ;# 8997 reload_outsi+2/6
stw %r15,-156(%r30) ;# 8999 reload_outsi+2/6
stw %r14,-152(%r30) ;# 9001 reload_outsi+2/6
stw %r13,-148(%r30) ;# 9003 reload_outsi+2/6
stw %r12,-144(%r30) ;# 9005 reload_outsi+2/6
stw %r11,-140(%r30) ;# 9007 reload_outsi+2/6
stw %r10,-136(%r30) ;# 9009 reload_outsi+2/6
stw %r9,-132(%r30) ;# 9011 reload_outsi+2/6
stw %r8,-128(%r30) ;# 9013 reload_outsi+2/6
stw %r7,-124(%r30) ;# 9015 reload_outsi+2/6
stw %r6,-120(%r30) ;# 9017 reload_outsi+2/6
stw %r5,-116(%r30) ;# 9019 reload_outsi+2/6
stw %r4,-112(%r30) ;# 9021 reload_outsi+2/6
stw %r3,-108(%r30) ;# 9023 reload_outsi+2/6
stw %r26,-276(%r30) ;# 4 reload_outsi+2/6
ldi 0,%r9 ;# 25 reload_outsi+2/2
ldi 0,%r8 ;# 28 reload_outsi+2/2
stw %r0,-260(%r30) ;# 34 reload_outsi+2/6
ldi 0,%r10 ;# 31 reload_outsi+2/2
ldi 640,%r26 ;# 37 reload_outsi+2/2
ldw -276(%r30),%r1 ;# 8774 reload_outsi+2/5
copy %r24,%r15 ;# 8 reload_outsi+2/1
stw %r1,-296(%r30) ;# 2325 reload_outsi+2/6
copy %r23,%r5 ;# 10 reload_outsi+2/1
addl %r1,%r25,%r16 ;# 19 addsi3/1
.CALL ARGW0=GR
bl malloc,%r2 ;# 39 call_value_internal_symref
ldw 20(%r5),%r14 ;# 22 reload_outsi+2/5
comib,<> 0,%r28,L$0021 ;# 48 bleu+1
stw %r28,-312(%r30) ;# 43 reload_outsi+2/6
L$0953
bl L$0867,%r0 ;# 53 jump
ldi 12,%r28 ;# 51 reload_outsi+2/2
L$0021
ldi 32,%r19 ;# 58 reload_outsi+2/2
stw %r19,-308(%r30) ;# 59 reload_outsi+2/6
stw %r0,-304(%r30) ;# 62 reload_outsi+2/6
stw %r15,12(%r5) ;# 65 reload_outsi+2/6
stw %r0,8(%r5) ;# 85 reload_outsi+2/6
stw %r0,24(%r5) ;# 88 reload_outsi+2/6
addil LR'done___2-$global$,%r27 ;# 92 pic2_lo_sum+1
ldw 28(%r5),%r19 ;# 68 reload_outsi+2/5
ldw RR'done___2-$global$(%r1),%r20 ;# 94 reload_outsi+2/5
depi 0,3,1,%r19 ;# 69 andsi3/2
depi 0,6,2,%r19 ;# 80 andsi3/2
comib,<> 0,%r20,L$0022 ;# 95 bleu+1
stw %r19,28(%r5) ;# 82 reload_outsi+2/6
addil LR're_syntax_table-$global$,%r27 ;# 99 pic2_lo_sum+1
ldo RR're_syntax_table-$global$(%r1),%r4 ;# 100 movhi-2
copy %r4,%r26 ;# 101 reload_outsi+2/1
ldi 0,%r25 ;# 102 reload_outsi+2/2
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2 ;# 104 call_value_internal_symref
ldi 256,%r24 ;# 103 reload_outsi+2/2
ldi 1,%r20 ;# 8732 movqi+1/2
ldo 97(%r4),%r19 ;# 8736 addsi3/2
ldo 122(%r4),%r4 ;# 8738 addsi3/2
stbs,ma %r20,1(%r19) ;# 115 movqi+1/6
L$1155
comb,>=,n %r4,%r19,L$1155 ;# 121 bleu+1
stbs,ma %r20,1(%r19) ;# 115 movqi+1/6
ldi 1,%r21 ;# 8717 movqi+1/2
addil LR're_syntax_table-$global$,%r27 ;# 8712 pic2_lo_sum+1
ldo RR're_syntax_table-$global$(%r1),%r19 ;# 8715 movhi-2
ldo 65(%r19),%r20 ;# 8721 addsi3/2
ldo 90(%r19),%r19 ;# 8723 addsi3/2
stbs,ma %r21,1(%r20) ;# 138 movqi+1/6
L$1156
comb,>=,n %r19,%r20,L$1156 ;# 144 bleu+1
stbs,ma %r21,1(%r20) ;# 138 movqi+1/6
ldi 48,%r20 ;# 151 reload_outsi+2/2
ldi 57,%r22 ;# 7976 reload_outsi+2/2
ldi 1,%r21 ;# 8707 movqi+1/2
addil LR're_syntax_table-$global$+48,%r27 ;# 8705 pic2_lo_sum+1
ldo RR're_syntax_table-$global$+48(%r1),%r19 ;# 8711 movhi-2
L$0037
ldo 1(%r20),%r20 ;# 164 addsi3/2
comb,>= %r22,%r20,L$0037 ;# 167 bleu+1
stbs,ma %r21,1(%r19) ;# 161 movqi+1/6
addil LR're_syntax_table-$global$,%r27 ;# 174 pic2_lo_sum+1
ldo RR're_syntax_table-$global$(%r1),%r19 ;# 175 movhi-2
ldi 1,%r20 ;# 176 movqi+1/2
stb %r20,95(%r19) ;# 177 movqi+1/6
addil LR'done___2-$global$,%r27 ;# 178 pic2_lo_sum+1
ldi 1,%r19 ;# 180 reload_outsi+2/2
stw %r19,RR'done___2-$global$(%r1) ;# 181 reload_outsi+2/6
L$0022
ldw 4(%r5),%r19 ;# 187 reload_outsi+2/5
comib,<>,n 0,%r19,L$0039 ;# 189 bleu+1
ldw 0(%r5),%r26 ;# 193 reload_outsi+2/5
comib,=,n 0,%r26,L$0040 ;# 195 bleu+1
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 205 call_value_internal_symref
ldi 32,%r25 ;# 203 reload_outsi+2/2
bl L$1157,%r0 ;# 211 jump
stw %r28,0(%r5) ;# 223 reload_outsi+2/6
L$0040
.CALL ARGW0=GR
bl malloc,%r2 ;# 219 call_value_internal_symref
ldi 32,%r26 ;# 217 reload_outsi+2/2
stw %r28,0(%r5) ;# 223 reload_outsi+2/6
L$1157
ldw 0(%r5),%r19 ;# 228 reload_outsi+2/5
comib,<> 0,%r19,L$0042 ;# 230 bleu+1
ldi 32,%r19 ;# 243 reload_outsi+2/2
.CALL ARGW0=GR
bl free,%r2 ;# 234 call_internal_symref
ldw -312(%r30),%r26 ;# 232 reload_outsi+2/5
bl L$0867,%r0 ;# 238 jump
ldi 12,%r28 ;# 51 reload_outsi+2/2
L$0042
stw %r19,4(%r5) ;# 244 reload_outsi+2/6
L$0039
ldw 0(%r5),%r6 ;# 249 reload_outsi+2/5
ldw -296(%r30),%r19 ;# 7981 reload_outsi+2/5
comclr,<> %r16,%r19,%r0 ;# 7982 bleu+1
bl L$0044,%r0
copy %r6,%r12 ;# 253 reload_outsi+2/1
ldw -296(%r30),%r19 ;# 2334 reload_outsi+2/5
L$1178
ldbs,ma 1(%r19),%r7 ;# 277 zero_extendqisi2/2
comib,= 0,%r14,L$0047 ;# 282 bleu+1
stw %r19,-296(%r30) ;# 2337 reload_outsi+2/6
addl %r14,%r7,%r19 ;# 283 addsi3/1
ldb 0(%r19),%r7 ;# 286 zero_extendqisi2/2
L$0047
ldo -10(%r7),%r19 ;# 7895 addsi3/2
addi,uv -115,%r19,%r0 ;# 7896 casesi0
blr,n %r19,%r0
b,n L$0076
L$0863
bl L$0376,%r0
nop ;# 9092 switch_jump
L$0954
bl L$0076,%r0
nop ;# 9095 switch_jump
L$0955
bl L$0076,%r0
nop ;# 9098 switch_jump
L$0956
bl L$0076,%r0
nop ;# 9101 switch_jump
L$0957
bl L$0076,%r0
nop ;# 9104 switch_jump
L$0958
bl L$0076,%r0
nop ;# 9107 switch_jump
L$0959
bl L$0076,%r0
nop ;# 9110 switch_jump
L$0960
bl L$0076,%r0
nop ;# 9113 switch_jump
L$0961
bl L$0076,%r0
nop ;# 9116 switch_jump
L$0962
bl L$0076,%r0
nop ;# 9119 switch_jump
L$0963
bl L$0076,%r0
nop ;# 9122 switch_jump
L$0964
bl L$0076,%r0
nop ;# 9125 switch_jump
L$0965
bl L$0076,%r0
nop ;# 9128 switch_jump
L$0966
bl L$0076,%r0
nop ;# 9131 switch_jump
L$0967
bl L$0076,%r0
nop ;# 9134 switch_jump
L$0968
bl L$0076,%r0
nop ;# 9137 switch_jump
L$0969
bl L$0076,%r0
nop ;# 9140 switch_jump
L$0970
bl L$0076,%r0
nop ;# 9143 switch_jump
L$0971
bl L$0076,%r0
nop ;# 9146 switch_jump
L$0972
bl L$0076,%r0
nop ;# 9149 switch_jump
L$0973
bl L$0076,%r0
nop ;# 9152 switch_jump
L$0974
bl L$0076,%r0
nop ;# 9155 switch_jump
L$0975
bl L$0076,%r0
nop ;# 9158 switch_jump
L$0976
bl L$0076,%r0
nop ;# 9161 switch_jump
L$0977
bl L$0076,%r0
nop ;# 9164 switch_jump
L$0978
bl L$0076,%r0
nop ;# 9167 switch_jump
L$0979
bl L$0077,%r0 ;# 9170 switch_jump
ldw -296(%r30),%r26 ;# 2349 reload_outsi+2/5
L$0980
bl L$0076,%r0
nop ;# 9173 switch_jump
L$0981
bl L$0076,%r0
nop ;# 9176 switch_jump
L$0982
bl L$0076,%r0
nop ;# 9179 switch_jump
L$0983
bl L$0368,%r0
nop ;# 9182 switch_jump
L$0984
bl L$0372,%r0
nop ;# 9185 switch_jump
L$0985
bl L$0104,%r0
nop ;# 9188 switch_jump
L$0986
bl L$1158,%r0 ;# 9191 switch_jump
ldi 1026,%r19 ;# 662 reload_outsi+2/2
L$0987
bl L$0076,%r0
nop ;# 9194 switch_jump
L$0988
bl L$0076,%r0
nop ;# 9197 switch_jump
L$0989
bl L$0196,%r0 ;# 9200 switch_jump
ldw 0(%r5),%r4 ;# 8027 reload_outsi+2/5
L$0990
bl L$0076,%r0
nop ;# 9203 switch_jump
L$0991
bl L$0076,%r0
nop ;# 9206 switch_jump
L$0992
bl L$0076,%r0
nop ;# 9209 switch_jump
L$0993
bl L$0076,%r0
nop ;# 9212 switch_jump
L$0994
bl L$0076,%r0
nop ;# 9215 switch_jump
L$0995
bl L$0076,%r0
nop ;# 9218 switch_jump
L$0996
bl L$0076,%r0
nop ;# 9221 switch_jump
L$0997
bl L$0076,%r0
nop ;# 9224 switch_jump
L$0998
bl L$0076,%r0
nop ;# 9227 switch_jump
L$0999
bl L$0076,%r0
nop ;# 9230 switch_jump
L$1000
bl L$0076,%r0
nop ;# 9233 switch_jump
L$1001
bl L$0076,%r0
nop ;# 9236 switch_jump
L$1002
bl L$0076,%r0
nop ;# 9239 switch_jump
L$1003
bl L$0076,%r0
nop ;# 9242 switch_jump
L$1004
bl L$0076,%r0
nop ;# 9245 switch_jump
L$1005
bl L$0076,%r0
nop ;# 9248 switch_jump
L$1006
bl L$0101,%r0 ;# 9251 switch_jump
ldi 1026,%r19 ;# 662 reload_outsi+2/2
L$1007
bl L$0076,%r0
nop ;# 9254 switch_jump
L$1008
bl L$0076,%r0
nop ;# 9257 switch_jump
L$1009
bl L$0076,%r0
nop ;# 9260 switch_jump
L$1010
bl L$0076,%r0
nop ;# 9263 switch_jump
L$1011
bl L$0076,%r0
nop ;# 9266 switch_jump
L$1012
bl L$0076,%r0
nop ;# 9269 switch_jump
L$1013
bl L$0076,%r0
nop ;# 9272 switch_jump
L$1014
bl L$0076,%r0
nop ;# 9275 switch_jump
L$1015
bl L$0076,%r0
nop ;# 9278 switch_jump
L$1016
bl L$0076,%r0
nop ;# 9281 switch_jump
L$1017
bl L$0076,%r0
nop ;# 9284 switch_jump
L$1018
bl L$0076,%r0
nop ;# 9287 switch_jump
L$1019
bl L$0076,%r0
nop ;# 9290 switch_jump
L$1020
bl L$0076,%r0
nop ;# 9293 switch_jump
L$1021
bl L$0076,%r0
nop ;# 9296 switch_jump
L$1022
bl L$0076,%r0
nop ;# 9299 switch_jump
L$1023
bl L$0076,%r0
nop ;# 9302 switch_jump
L$1024
bl L$0076,%r0
nop ;# 9305 switch_jump
L$1025
bl L$0076,%r0
nop ;# 9308 switch_jump
L$1026
bl L$0076,%r0
nop ;# 9311 switch_jump
L$1027
bl L$0076,%r0
nop ;# 9314 switch_jump
L$1028
bl L$0076,%r0
nop ;# 9317 switch_jump
L$1029
bl L$0076,%r0
nop ;# 9320 switch_jump
L$1030
bl L$0076,%r0
nop ;# 9323 switch_jump
L$1031
bl L$0076,%r0
nop ;# 9326 switch_jump
L$1032
bl L$0076,%r0
nop ;# 9329 switch_jump
L$1033
bl L$0076,%r0
nop ;# 9332 switch_jump
L$1034
bl L$0216,%r0 ;# 9335 switch_jump
ldw -296(%r30),%r19 ;# 2418 reload_outsi+2/5
L$1035
bl L$0387,%r0 ;# 9338 switch_jump
ldw -296(%r30),%r19 ;# 3797 reload_outsi+2/5
L$1036
bl L$0076,%r0
nop ;# 9341 switch_jump
L$1037
bl L$0053,%r0 ;# 9344 switch_jump
ldw -276(%r30),%r1 ;# 8777 reload_outsi+2/5
L$1038
bl L$0076,%r0
nop ;# 9347 switch_jump
L$1039
bl L$0076,%r0
nop ;# 9350 switch_jump
L$1040
bl L$0076,%r0
nop ;# 9353 switch_jump
L$1041
bl L$0076,%r0
nop ;# 9356 switch_jump
L$1042
bl L$0076,%r0
nop ;# 9359 switch_jump
L$1043
bl L$0076,%r0
nop ;# 9362 switch_jump
L$1044
bl L$0076,%r0
nop ;# 9365 switch_jump
L$1045
bl L$0076,%r0
nop ;# 9368 switch_jump
L$1046
bl L$0076,%r0
nop ;# 9371 switch_jump
L$1047
bl L$0076,%r0
nop ;# 9374 switch_jump
L$1048
bl L$0076,%r0
nop ;# 9377 switch_jump
L$1049
bl L$0076,%r0
nop ;# 9380 switch_jump
L$1050
bl L$0076,%r0
nop ;# 9383 switch_jump
L$1051
bl L$0076,%r0
nop ;# 9386 switch_jump
L$1052
bl L$0076,%r0
nop ;# 9389 switch_jump
L$1053
bl L$0076,%r0
nop ;# 9392 switch_jump
L$1054
bl L$0076,%r0
nop ;# 9395 switch_jump
L$1055
bl L$0076,%r0
nop ;# 9398 switch_jump
L$1056
bl L$0076,%r0
nop ;# 9401 switch_jump
L$1057
bl L$0076,%r0
nop ;# 9404 switch_jump
L$1058
bl L$0076,%r0
nop ;# 9407 switch_jump
L$1059
bl L$0076,%r0
nop ;# 9410 switch_jump
L$1060
bl L$0076,%r0
nop ;# 9413 switch_jump
L$1061
bl L$0076,%r0
nop ;# 9416 switch_jump
L$1062
bl L$0076,%r0
nop ;# 9419 switch_jump
L$1063
bl L$0076,%r0
nop ;# 9422 switch_jump
L$1064
bl L$0076,%r0
nop ;# 9425 switch_jump
L$1065
bl L$0076,%r0
nop ;# 9428 switch_jump
L$1066
bl L$0383,%r0 ;# 9431 switch_jump
ldi 4608,%r20 ;# 3778 reload_outsi+2/2
L$1067
bl L$0380,%r0
nop ;# 9434 switch_jump
L$1068
bl,n L$0076,%r0 ;# 7899 jump
L$0053
ldw -296(%r30),%r25 ;# 2343 reload_outsi+2/5
ldo 1(%r1),%r19 ;# 306 addsi3/2
comb,=,n %r19,%r25,L$0055 ;# 308 bleu+1
bb,< %r15,28,L$0055 ;# 313 bleu+3
ldw -276(%r30),%r26 ;# 315 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl at_begline_loc_p,%r2 ;# 321 call_value_internal_symref
copy %r15,%r24 ;# 319 reload_outsi+2/1
extrs %r28,31,8,%r28 ;# 324 extendqisi2
comiclr,<> 0,%r28,%r0 ;# 326 bleu+1
bl,n L$0076,%r0
L$0055
ldw 0(%r5),%r4 ;# 7986 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 7989 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 7987 subsi3/1
ldo 1(%r19),%r19 ;# 7988 addsi3/2
comb,>>=,n %r20,%r19,L$0060 ;# 7990 bleu+1
ldil L'65536,%r3 ;# 8701 reload_outsi+2/3
L$0061
comclr,<> %r3,%r20,%r0 ;# 357 bleu+1
bl L$0944,%r0
zdep %r20,30,31,%r19 ;# 367 ashlsi3+1
comb,>>= %r3,%r19,L$0066 ;# 375 bleu+1
stw %r19,4(%r5) ;# 369 reload_outsi+2/6
stw %r3,4(%r5) ;# 378 reload_outsi+2/6
L$0066
ldw 0(%r5),%r26 ;# 385 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 389 call_value_internal_symref
ldw 4(%r5),%r25 ;# 387 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 397 bleu+1
stw %r28,0(%r5) ;# 393 reload_outsi+2/6
comb,= %r28,%r4,L$0059 ;# 407 bleu+1
sub %r6,%r4,%r19 ;# 409 subsi3/1
addl %r28,%r19,%r6 ;# 412 addsi3/1
sub %r12,%r4,%r19 ;# 413 subsi3/1
comib,= 0,%r10,L$0069 ;# 418 bleu+1
addl %r28,%r19,%r12 ;# 416 addsi3/1
sub %r10,%r4,%r19 ;# 419 subsi3/1
addl %r28,%r19,%r10 ;# 422 addsi3/1
L$0069
comib,= 0,%r8,L$0070 ;# 425 bleu+1
sub %r8,%r4,%r19 ;# 426 subsi3/1
addl %r28,%r19,%r8 ;# 429 addsi3/1
L$0070
comib,= 0,%r9,L$0059 ;# 432 bleu+1
sub %r9,%r4,%r19 ;# 433 subsi3/1
addl %r28,%r19,%r9 ;# 436 addsi3/1
L$0059
ldw 0(%r5),%r4 ;# 337 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 341 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 338 subsi3/1
ldo 1(%r19),%r19 ;# 339 addsi3/2
comb,<< %r20,%r19,L$0061
nop ;# 343 bleu+1
L$0060
ldi 8,%r19 ;# 458 movqi+1/2
bl L$0043,%r0 ;# 479 jump
stbs,ma %r19,1(%r6) ;# 459 movqi+1/6
L$0077
comb,=,n %r16,%r26,L$0079 ;# 485 bleu+1
bb,< %r15,28,L$0079 ;# 490 bleu+3
copy %r16,%r25 ;# 494 reload_outsi+2/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl at_endline_loc_p,%r2 ;# 498 call_value_internal_symref
copy %r15,%r24 ;# 496 reload_outsi+2/1
extrs %r28,31,8,%r28 ;# 501 extendqisi2
comiclr,<> 0,%r28,%r0 ;# 503 bleu+1
bl,n L$0076,%r0
L$0079
ldw 0(%r5),%r4 ;# 7994 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 7997 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 7995 subsi3/1
ldo 1(%r19),%r19 ;# 7996 addsi3/2
comb,>>=,n %r20,%r19,L$0084 ;# 7998 bleu+1
ldil L'65536,%r3 ;# 8699 reload_outsi+2/3
L$0085
comclr,<> %r3,%r20,%r0 ;# 534 bleu+1
bl L$0944,%r0
zdep %r20,30,31,%r19 ;# 544 ashlsi3+1
comb,>>= %r3,%r19,L$0090 ;# 552 bleu+1
stw %r19,4(%r5) ;# 546 reload_outsi+2/6
stw %r3,4(%r5) ;# 555 reload_outsi+2/6
L$0090
ldw 0(%r5),%r26 ;# 562 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 566 call_value_internal_symref
ldw 4(%r5),%r25 ;# 564 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 574 bleu+1
stw %r28,0(%r5) ;# 570 reload_outsi+2/6
comb,= %r28,%r4,L$0083 ;# 584 bleu+1
sub %r6,%r4,%r19 ;# 586 subsi3/1
addl %r28,%r19,%r6 ;# 589 addsi3/1
sub %r12,%r4,%r19 ;# 590 subsi3/1
comib,= 0,%r10,L$0093 ;# 595 bleu+1
addl %r28,%r19,%r12 ;# 593 addsi3/1
sub %r10,%r4,%r19 ;# 596 subsi3/1
addl %r28,%r19,%r10 ;# 599 addsi3/1
L$0093
comib,= 0,%r8,L$0094 ;# 602 bleu+1
sub %r8,%r4,%r19 ;# 603 subsi3/1
addl %r28,%r19,%r8 ;# 606 addsi3/1
L$0094
comib,= 0,%r9,L$0083 ;# 609 bleu+1
sub %r9,%r4,%r19 ;# 610 subsi3/1
addl %r28,%r19,%r9 ;# 613 addsi3/1
L$0083
ldw 0(%r5),%r4 ;# 514 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 518 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 515 subsi3/1
ldo 1(%r19),%r19 ;# 516 addsi3/2
comb,<< %r20,%r19,L$0085
nop ;# 520 bleu+1
L$0084
ldi 9,%r19 ;# 635 movqi+1/2
bl L$0043,%r0 ;# 656 jump
stbs,ma %r19,1(%r6) ;# 636 movqi+1/6
L$0877
bl L$0110,%r0 ;# 897 jump
stw %r21,-296(%r30) ;# 2391 reload_outsi+2/6
L$0101
L$1158
and %r15,%r19,%r19 ;# 663 andsi3/1
comiclr,= 0,%r19,%r0 ;# 665 bleu+1
bl,n L$0076,%r0
L$0104
comib,<> 0,%r8,L$0105 ;# 674 bleu+1
ldi 0,%r13 ;# 711 reload_outsi+2/2
extrs,>= %r15,26,1,%r0 ;# 681 bleu+3
extrs,< %r15,27,1,%r0 ;# 700 movsi-4
nop
bl,n L$0076,%r0
L$0105
ldi 0,%r11 ;# 714 reload_outsi+2/2
ldi 0,%r22 ;# 716 reload_outsi+2/2
ldi 43,%r24 ;# 8688 reload_outsi+2/2
ldi 63,%r23 ;# 8690 reload_outsi+2/2
ldi 42,%r28 ;# 8692 reload_outsi+2/2
ldi 2,%r19 ;# 8694 reload_outsi+2/2
and %r15,%r19,%r25 ;# 8695 andsi3/1
ldi 92,%r26 ;# 8697 reload_outsi+2/2
L$0109
comb,= %r24,%r7,L$0112 ;# 727 bleu+1
copy %r11,%r19 ;# 8780 reload_outsi+2/1
depi -1,31,1,%r19 ;# 729 iorsi3+1/2
bl L$0113,%r0 ;# 731 jump
extrs %r19,31,8,%r19 ;# 730 extendqisi2
L$0112
extrs %r11,31,8,%r19 ;# 734 extendqisi2
L$0113
L$1159
comb,= %r23,%r7,L$0114 ;# 744 bleu+1
copy %r19,%r11 ;# 737 reload_outsi+2/1
copy %r22,%r19 ;# 8783 reload_outsi+2/1
depi -1,31,1,%r19 ;# 746 iorsi3+1/2
bl L$0115,%r0 ;# 748 jump
extrs %r19,31,8,%r19 ;# 747 extendqisi2
L$0114
extrs %r22,31,8,%r19 ;# 751 extendqisi2
L$0115
ldw -296(%r30),%r21 ;# 2355 reload_outsi+2/5
comb,= %r16,%r21,L$0110 ;# 757 bleu+1
copy %r19,%r22 ;# 754 reload_outsi+2/1
copy %r21,%r20 ;# 8743 reload_outsi+2/1
ldbs,ma 1(%r20),%r7 ;# 776 zero_extendqisi2/2
comib,= 0,%r14,L$0118 ;# 781 bleu+1
stw %r20,-296(%r30) ;# 2364 reload_outsi+2/6
addl %r14,%r7,%r19 ;# 782 addsi3/1
ldb 0(%r19),%r7 ;# 785 zero_extendqisi2/2
L$0118
comb,= %r28,%r7,L$0109
nop ;# 802 bleu+1
comib,<>,n 0,%r25,L$0869 ;# 807 bleu+1
comb,= %r24,%r7,L$1159 ;# 811 bleu+1
extrs %r11,31,8,%r19 ;# 734 extendqisi2
comb,= %r23,%r7,L$0109 ;# 815 bleu+1
ldw -296(%r30),%r19 ;# 2400 reload_outsi+2/5
bl,n L$1160,%r0 ;# 827 jump
L$0869
comb,<> %r26,%r7,L$0126 ;# 831 bleu+1
ldw -296(%r30),%r19 ;# 2400 reload_outsi+2/5
comclr,<> %r16,%r20,%r0 ;# 835 bleu+1
bl L$0903,%r0
ldo 1(%r20),%r19 ;# 863 addsi3/2
ldb 1(%r21),%r3 ;# 860 zero_extendqisi2/2
comib,= 0,%r14,L$0129 ;# 865 bleu+1
stw %r19,-296(%r30) ;# 2379 reload_outsi+2/6
addl %r14,%r3,%r19 ;# 866 addsi3/1
ldb 0(%r19),%r3 ;# 869 zero_extendqisi2/2
L$0129
comb,= %r24,%r3,L$0109 ;# 886 bleu+1
copy %r3,%r7 ;# 903 reload_outsi+2/1
comb,<> %r23,%r3,L$0877
nop ;# 890 bleu+1
bl,n L$0109,%r0 ;# 905 jump
L$0126
L$1160
ldo -1(%r19),%r19 ;# 910 addsi3/2
stw %r19,-296(%r30) ;# 2397 reload_outsi+2/6
L$0110
comiclr,<> 0,%r8,%r0 ;# 927 bleu+1
bl L$1161,%r0
ldw -296(%r30),%r19 ;# 2328 reload_outsi+2/5
comib,=,n 0,%r22,L$0137 ;# 934 bleu+1
ldw 0(%r5),%r3 ;# 8002 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8005 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8003 subsi3/1
ldo 3(%r19),%r19 ;# 8004 addsi3/2
comb,>>=,n %r20,%r19,L$0139 ;# 8006 bleu+1
ldil L'65536,%r4 ;# 8686 reload_outsi+2/3
L$0140
comclr,<> %r4,%r20,%r0 ;# 961 bleu+1
bl L$0944,%r0
zdep %r20,30,31,%r19 ;# 971 ashlsi3+1
comb,>>= %r4,%r19,L$0145 ;# 979 bleu+1
stw %r19,4(%r5) ;# 973 reload_outsi+2/6
stw %r4,4(%r5) ;# 982 reload_outsi+2/6
L$0145
ldw 0(%r5),%r26 ;# 989 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 993 call_value_internal_symref
ldw 4(%r5),%r25 ;# 991 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 1001 bleu+1
stw %r28,0(%r5) ;# 997 reload_outsi+2/6
comb,= %r28,%r3,L$0138 ;# 1011 bleu+1
sub %r6,%r3,%r19 ;# 1013 subsi3/1
addl %r28,%r19,%r6 ;# 1016 addsi3/1
sub %r12,%r3,%r19 ;# 1017 subsi3/1
comib,= 0,%r10,L$0148 ;# 1022 bleu+1
addl %r28,%r19,%r12 ;# 1020 addsi3/1
sub %r10,%r3,%r19 ;# 1023 subsi3/1
addl %r28,%r19,%r10 ;# 1026 addsi3/1
L$0148
comib,= 0,%r8,L$0149 ;# 1029 bleu+1
sub %r8,%r3,%r19 ;# 1030 subsi3/1
addl %r28,%r19,%r8 ;# 1033 addsi3/1
L$0149
comib,= 0,%r9,L$0138 ;# 1036 bleu+1
sub %r9,%r3,%r19 ;# 1037 subsi3/1
addl %r28,%r19,%r9 ;# 1040 addsi3/1
L$0138
ldw 0(%r5),%r3 ;# 941 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 945 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 942 subsi3/1
ldo 3(%r19),%r19 ;# 943 addsi3/2
comb,<< %r20,%r19,L$0140
nop ;# 947 bleu+1
L$0139
comib,= 0,%r14,L$0154 ;# 1063 bleu+1
ldw -296(%r30),%r19 ;# 2403 reload_outsi+2/5
ldb -2(%r19),%r19 ;# 1066 zero_extendqisi2/2
addl %r14,%r19,%r19 ;# 1067 addsi3/1
bl L$0947,%r0 ;# 1071 jump
ldb 0(%r19),%r19 ;# 1069 movqi+1/5
L$0154
ldb -2(%r19),%r19 ;# 1075 movqi+1/5
L$0947
comib,= 0,%r14,L$0156 ;# 1079 bleu+1
extrs %r19,31,8,%r20 ;# 1076 extendqisi2
ldb 46(%r14),%r19 ;# 1081 movqi+1/5
extrs %r19,31,8,%r19 ;# 1082 extendqisi2
comb,= %r19,%r20,L$0157 ;# 1084 bleu+1
ldi 17,%r26 ;# 1159 reload_outsi+2/2
bl,n L$1162,%r0 ;# 1085 jump
L$0156
ldi 46,%r19 ;# 1089 reload_outsi+2/2
comb,<> %r19,%r20,L$1162 ;# 1091 bleu+1
ldi 17,%r26 ;# 1159 reload_outsi+2/2
L$0157
comib,= 0,%r11,L$0153 ;# 1096 bleu+1
ldw -296(%r30),%r19 ;# 2409 reload_outsi+2/5
comb,<<= %r16,%r19,L$1162 ;# 1098 bleu+1
ldi 17,%r26 ;# 1159 reload_outsi+2/2
comib,=,n 0,%r14,L$0158 ;# 1100 bleu+1
ldb 0(%r19),%r19 ;# 1103 zero_extendqisi2/2
addl %r14,%r19,%r19 ;# 1104 addsi3/1
L$0158
ldb 0(%r19),%r19 ;# 1112 movqi+1/5
comib,= 0,%r14,L$0160 ;# 1116 bleu+1
extrs %r19,31,8,%r20 ;# 1113 extendqisi2
ldb 10(%r14),%r19 ;# 1118 movqi+1/5
extrs %r19,31,8,%r19 ;# 1119 extendqisi2
comb,= %r19,%r20,L$0161 ;# 1121 bleu+1
ldi 17,%r26 ;# 1159 reload_outsi+2/2
bl,n L$1162,%r0 ;# 1122 jump
L$0160
comib,<> 10,%r20,L$1162 ;# 1126 bleu+1
ldi 17,%r26 ;# 1159 reload_outsi+2/2
L$0161
bb,< %r15,25,L$1162 ;# 1134 bleu+3
ldi 17,%r26 ;# 1159 reload_outsi+2/2
ldi 12,%r26 ;# 1140 reload_outsi+2/2
copy %r6,%r25 ;# 1142 reload_outsi+2/1
sub %r8,%r6,%r24 ;# 1137 subsi3/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl store_op1,%r2 ;# 1146 call_internal_symref
ldo -3(%r24),%r24 ;# 1144 addsi3/2
bl L$0162,%r0 ;# 1151 jump
ldi 1,%r13 ;# 1149 reload_outsi+2/2
L$0153
ldi 17,%r26 ;# 1159 reload_outsi+2/2
L$1162
copy %r6,%r25 ;# 1161 reload_outsi+2/1
sub %r8,%r6,%r24 ;# 1156 subsi3/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl store_op1,%r2 ;# 1165 call_internal_symref
ldo -6(%r24),%r24 ;# 1163 addsi3/2
L$0162
ldo 3(%r6),%r6 ;# 1168 addsi3/2
L$0137
ldw 0(%r5),%r3 ;# 8010 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8013 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8011 subsi3/1
ldo 3(%r19),%r19 ;# 8012 addsi3/2
comb,>>=,n %r20,%r19,L$0164 ;# 8014 bleu+1
ldil L'65536,%r4 ;# 8684 reload_outsi+2/3
L$0165
comclr,<> %r4,%r20,%r0 ;# 1195 bleu+1
bl L$0944,%r0
zdep %r20,30,31,%r19 ;# 1205 ashlsi3+1
comb,>>= %r4,%r19,L$0170 ;# 1213 bleu+1
stw %r19,4(%r5) ;# 1207 reload_outsi+2/6
stw %r4,4(%r5) ;# 1216 reload_outsi+2/6
L$0170
ldw 0(%r5),%r26 ;# 1223 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 1227 call_value_internal_symref
ldw 4(%r5),%r25 ;# 1225 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 1235 bleu+1
stw %r28,0(%r5) ;# 1231 reload_outsi+2/6
comb,= %r28,%r3,L$0163 ;# 1245 bleu+1
sub %r6,%r3,%r19 ;# 1247 subsi3/1
addl %r28,%r19,%r6 ;# 1250 addsi3/1
sub %r12,%r3,%r19 ;# 1251 subsi3/1
comib,= 0,%r10,L$0173 ;# 1256 bleu+1
addl %r28,%r19,%r12 ;# 1254 addsi3/1
sub %r10,%r3,%r19 ;# 1257 subsi3/1
addl %r28,%r19,%r10 ;# 1260 addsi3/1
L$0173
comib,= 0,%r8,L$0174 ;# 1263 bleu+1
sub %r8,%r3,%r19 ;# 1264 subsi3/1
addl %r28,%r19,%r8 ;# 1267 addsi3/1
L$0174
comib,= 0,%r9,L$0163 ;# 1270 bleu+1
sub %r9,%r3,%r19 ;# 1271 subsi3/1
addl %r28,%r19,%r9 ;# 1274 addsi3/1
L$0163
ldw 0(%r5),%r3 ;# 1175 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 1179 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 1176 subsi3/1
ldo 3(%r19),%r19 ;# 1177 addsi3/2
comb,<< %r20,%r19,L$0165
nop ;# 1181 bleu+1
L$0164
ldi 14,%r26 ;# 8786 reload_outsi+2/2
comiclr,= 0,%r13,%r0 ;# 1310 beq-1/2
ldi 15,%r26
copy %r8,%r25 ;# 1312 reload_outsi+2/1
sub %r6,%r8,%r24 ;# 1314 subsi3/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl insert_op1,%r2 ;# 1318 call_internal_symref
copy %r6,%r23 ;# 1316 reload_outsi+2/1
ldi 0,%r9 ;# 1321 reload_outsi+2/2
comib,<> 0,%r11,L$0043 ;# 1326 bleu+1
ldo 3(%r6),%r6 ;# 1323 addsi3/2
ldw 0(%r5),%r3 ;# 8019 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8022 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8020 subsi3/1
ldo 3(%r19),%r19 ;# 8021 addsi3/2
comb,>>=,n %r20,%r19,L$0182 ;# 8023 bleu+1
ldil L'65536,%r4 ;# 8682 reload_outsi+2/3
L$0183
comb,= %r4,%r20,L$0944 ;# 1352 bleu+1
zdep %r20,30,31,%r19 ;# 1362 ashlsi3+1
comb,>>= %r4,%r19,L$0188 ;# 1370 bleu+1
stw %r19,4(%r5) ;# 1364 reload_outsi+2/6
stw %r4,4(%r5) ;# 1373 reload_outsi+2/6
L$0188
ldw 0(%r5),%r26 ;# 1380 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 1384 call_value_internal_symref
ldw 4(%r5),%r25 ;# 1382 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 1392 bleu+1
stw %r28,0(%r5) ;# 1388 reload_outsi+2/6
comb,= %r28,%r3,L$0181 ;# 1402 bleu+1
sub %r6,%r3,%r19 ;# 1404 subsi3/1
addl %r28,%r19,%r6 ;# 1407 addsi3/1
sub %r12,%r3,%r19 ;# 1408 subsi3/1
comib,= 0,%r10,L$0191 ;# 1413 bleu+1
addl %r28,%r19,%r12 ;# 1411 addsi3/1
sub %r10,%r3,%r19 ;# 1414 subsi3/1
addl %r28,%r19,%r10 ;# 1417 addsi3/1
L$0191
comib,= 0,%r8,L$0192 ;# 1420 bleu+1
sub %r8,%r3,%r19 ;# 1421 subsi3/1
addl %r28,%r19,%r8 ;# 1424 addsi3/1
L$0192
comib,= 0,%r9,L$0181 ;# 1427 bleu+1
sub %r9,%r3,%r19 ;# 1428 subsi3/1
addl %r28,%r19,%r9 ;# 1431 addsi3/1
L$0181
ldw 0(%r5),%r3 ;# 1332 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 1336 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 1333 subsi3/1
ldo 3(%r19),%r19 ;# 1334 addsi3/2
comb,<< %r20,%r19,L$0183
nop ;# 1338 bleu+1
L$0182
ldi 18,%r26 ;# 1454 reload_outsi+2/2
copy %r8,%r25 ;# 1456 reload_outsi+2/1
ldi 3,%r24 ;# 1458 reload_outsi+2/2
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl insert_op1,%r2 ;# 1462 call_internal_symref
copy %r6,%r23 ;# 1460 reload_outsi+2/1
bl L$0043,%r0 ;# 1470 jump
ldo 3(%r6),%r6 ;# 1464 addsi3/2
L$0196
ldw 4(%r5),%r20 ;# 8030 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8028 subsi3/1
ldo 1(%r19),%r19 ;# 8029 addsi3/2
comb,>>= %r20,%r19,L$0201 ;# 8031 bleu+1
copy %r6,%r8 ;# 1475 reload_outsi+2/1
ldil L'65536,%r3 ;# 8680 reload_outsi+2/3
L$0202
comb,= %r3,%r20,L$0944 ;# 1503 bleu+1
zdep %r20,30,31,%r19 ;# 1513 ashlsi3+1
comb,>>= %r3,%r19,L$0207 ;# 1521 bleu+1
stw %r19,4(%r5) ;# 1515 reload_outsi+2/6
stw %r3,4(%r5) ;# 1524 reload_outsi+2/6
L$0207
ldw 0(%r5),%r26 ;# 1531 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 1535 call_value_internal_symref
ldw 4(%r5),%r25 ;# 1533 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 1543 bleu+1
stw %r28,0(%r5) ;# 1539 reload_outsi+2/6
comb,= %r28,%r4,L$0200 ;# 1553 bleu+1
sub %r6,%r4,%r19 ;# 1555 subsi3/1
addl %r28,%r19,%r6 ;# 1558 addsi3/1
sub %r12,%r4,%r19 ;# 1559 subsi3/1
comib,= 0,%r10,L$0210 ;# 1564 bleu+1
addl %r28,%r19,%r12 ;# 1562 addsi3/1
sub %r10,%r4,%r19 ;# 1565 subsi3/1
addl %r28,%r19,%r10 ;# 1568 addsi3/1
L$0210
comib,= 0,%r8,L$0211 ;# 1571 bleu+1
sub %r8,%r4,%r19 ;# 1572 subsi3/1
addl %r28,%r19,%r8 ;# 1575 addsi3/1
L$0211
comib,= 0,%r9,L$0200 ;# 1578 bleu+1
sub %r9,%r4,%r19 ;# 1579 subsi3/1
addl %r28,%r19,%r9 ;# 1582 addsi3/1
L$0200
ldw 0(%r5),%r4 ;# 1483 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 1487 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 1484 subsi3/1
ldo 1(%r19),%r19 ;# 1485 addsi3/2
comb,<< %r20,%r19,L$0202
nop ;# 1489 bleu+1
L$0201
ldi 2,%r19 ;# 1604 movqi+1/2
bl L$0043,%r0 ;# 1617 jump
stbs,ma %r19,1(%r6) ;# 1605 movqi+1/6
L$0216
comb,= %r16,%r19,L$0902 ;# 1626 bleu+1
ldi 0,%r13 ;# 1623 reload_outsi+2/2
ldw 0(%r5),%r3 ;# 8035 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8038 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8036 subsi3/1
ldo 34(%r19),%r19 ;# 8037 addsi3/2
comb,>>= %r20,%r19,L$0219 ;# 8039 bleu+1
ldil L'65536,%r4 ;# 8678 reload_outsi+2/3
L$0220
comb,= %r4,%r20,L$0944 ;# 1661 bleu+1
zdep %r20,30,31,%r19 ;# 1671 ashlsi3+1
comb,>>= %r4,%r19,L$0225 ;# 1679 bleu+1
stw %r19,4(%r5) ;# 1673 reload_outsi+2/6
stw %r4,4(%r5) ;# 1682 reload_outsi+2/6
L$0225
ldw 0(%r5),%r26 ;# 1689 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 1693 call_value_internal_symref
ldw 4(%r5),%r25 ;# 1691 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 1701 bleu+1
stw %r28,0(%r5) ;# 1697 reload_outsi+2/6
comb,= %r28,%r3,L$0218 ;# 1711 bleu+1
sub %r6,%r3,%r19 ;# 1713 subsi3/1
addl %r28,%r19,%r6 ;# 1716 addsi3/1
sub %r12,%r3,%r19 ;# 1717 subsi3/1
comib,= 0,%r10,L$0228 ;# 1722 bleu+1
addl %r28,%r19,%r12 ;# 1720 addsi3/1
sub %r10,%r3,%r19 ;# 1723 subsi3/1
addl %r28,%r19,%r10 ;# 1726 addsi3/1
L$0228
comib,= 0,%r8,L$0229 ;# 1729 bleu+1
sub %r8,%r3,%r19 ;# 1730 subsi3/1
addl %r28,%r19,%r8 ;# 1733 addsi3/1
L$0229
comib,= 0,%r9,L$0218 ;# 1736 bleu+1
sub %r9,%r3,%r19 ;# 1737 subsi3/1
addl %r28,%r19,%r9 ;# 1740 addsi3/1
L$0218
ldw 0(%r5),%r3 ;# 1641 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 1645 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 1642 subsi3/1
ldo 34(%r19),%r19 ;# 1643 addsi3/2
comb,<< %r20,%r19,L$0220
nop ;# 1647 bleu+1
L$0219
ldw 0(%r5),%r4 ;# 8043 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8046 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8044 subsi3/1
ldo 1(%r19),%r19 ;# 8045 addsi3/2
comb,>>= %r20,%r19,L$0237 ;# 8047 bleu+1
copy %r6,%r8 ;# 1763 reload_outsi+2/1
ldil L'65536,%r3 ;# 8676 reload_outsi+2/3
L$0238
comb,= %r3,%r20,L$0944 ;# 1791 bleu+1
zdep %r20,30,31,%r19 ;# 1801 ashlsi3+1
comb,>>= %r3,%r19,L$0243 ;# 1809 bleu+1
stw %r19,4(%r5) ;# 1803 reload_outsi+2/6
stw %r3,4(%r5) ;# 1812 reload_outsi+2/6
L$0243
ldw 0(%r5),%r26 ;# 1819 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 1823 call_value_internal_symref
ldw 4(%r5),%r25 ;# 1821 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 1831 bleu+1
stw %r28,0(%r5) ;# 1827 reload_outsi+2/6
comb,= %r28,%r4,L$0236 ;# 1841 bleu+1
sub %r6,%r4,%r19 ;# 1843 subsi3/1
addl %r28,%r19,%r6 ;# 1846 addsi3/1
sub %r12,%r4,%r19 ;# 1847 subsi3/1
comib,= 0,%r10,L$0246 ;# 1852 bleu+1
addl %r28,%r19,%r12 ;# 1850 addsi3/1
sub %r10,%r4,%r19 ;# 1853 subsi3/1
addl %r28,%r19,%r10 ;# 1856 addsi3/1
L$0246
comib,= 0,%r8,L$0247 ;# 1859 bleu+1
sub %r8,%r4,%r19 ;# 1860 subsi3/1
addl %r28,%r19,%r8 ;# 1863 addsi3/1
L$0247
comib,= 0,%r9,L$0236 ;# 1866 bleu+1
sub %r9,%r4,%r19 ;# 1867 subsi3/1
addl %r28,%r19,%r9 ;# 1870 addsi3/1
L$0236
ldw 0(%r5),%r4 ;# 1771 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 1775 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 1772 subsi3/1
ldo 1(%r19),%r19 ;# 1773 addsi3/2
comb,<< %r20,%r19,L$0238
nop ;# 1777 bleu+1
L$0237
copy %r6,%r22 ;# 1909 reload_outsi+2/1
ldo 1(%r6),%r6 ;# 1891 addsi3/2
ldw -296(%r30),%r19 ;# 2421 reload_outsi+2/5
ldb 0(%r19),%r19 ;# 1893 movqi+1/5
ldi 94,%r21 ;# 1896 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 1894 extendqisi2
comb,<> %r21,%r19,L$0251 ;# 1898 bleu+1
ldi 3,%r20 ;# 8051 movqi+1/2
ldi 4,%r20 ;# 1900 movqi+1/2
L$0251
stb %r20,0(%r22) ;# 1911 movqi+1/6
ldw -296(%r30),%r20 ;# 2424 reload_outsi+2/5
ldb 0(%r20),%r19 ;# 1923 movqi+1/5
extrs %r19,31,8,%r19 ;# 1924 extendqisi2
comb,<> %r21,%r19,L$0254 ;# 1928 bleu+1
ldo 1(%r20),%r19 ;# 1930 addsi3/2
stw %r19,-296(%r30) ;# 2427 reload_outsi+2/6
L$0254
ldw 0(%r5),%r4 ;# 8052 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8055 reload_outsi+2/5
ldw -296(%r30),%r1 ;# 2433 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8053 subsi3/1
ldo 1(%r19),%r19 ;# 8054 addsi3/2
comb,>>= %r20,%r19,L$0259 ;# 8056 bleu+1
stw %r1,-268(%r30) ;# 8789 reload_outsi+2/6
ldil L'65536,%r3 ;# 8674 reload_outsi+2/3
L$0260
comb,= %r3,%r20,L$0944 ;# 1962 bleu+1
zdep %r20,30,31,%r19 ;# 1972 ashlsi3+1
comb,>>= %r3,%r19,L$0265 ;# 1980 bleu+1
stw %r19,4(%r5) ;# 1974 reload_outsi+2/6
stw %r3,4(%r5) ;# 1983 reload_outsi+2/6
L$0265
ldw 0(%r5),%r26 ;# 1990 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 1994 call_value_internal_symref
ldw 4(%r5),%r25 ;# 1992 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 2002 bleu+1
stw %r28,0(%r5) ;# 1998 reload_outsi+2/6
comb,= %r28,%r4,L$0258 ;# 2012 bleu+1
sub %r6,%r4,%r19 ;# 2014 subsi3/1
addl %r28,%r19,%r6 ;# 2017 addsi3/1
sub %r12,%r4,%r19 ;# 2018 subsi3/1
comib,= 0,%r10,L$0268 ;# 2023 bleu+1
addl %r28,%r19,%r12 ;# 2021 addsi3/1
sub %r10,%r4,%r19 ;# 2024 subsi3/1
addl %r28,%r19,%r10 ;# 2027 addsi3/1
L$0268
comib,= 0,%r8,L$0269 ;# 2030 bleu+1
sub %r8,%r4,%r19 ;# 2031 subsi3/1
addl %r28,%r19,%r8 ;# 2034 addsi3/1
L$0269
comib,= 0,%r9,L$0258 ;# 2037 bleu+1
sub %r9,%r4,%r19 ;# 2038 subsi3/1
addl %r28,%r19,%r9 ;# 2041 addsi3/1
L$0258
ldw 0(%r5),%r4 ;# 1942 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 1946 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 1943 subsi3/1
ldo 1(%r19),%r19 ;# 1944 addsi3/2
comb,<< %r20,%r19,L$0260
nop ;# 1948 bleu+1
L$0259
ldi 32,%r19 ;# 2063 movqi+1/2
stbs,ma %r19,1(%r6) ;# 2064 movqi+1/6
copy %r6,%r26 ;# 2077 reload_outsi+2/1
ldi 0,%r25 ;# 2079 reload_outsi+2/2
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2 ;# 2083 call_value_internal_symref
ldi 32,%r24 ;# 2081 reload_outsi+2/2
ldb -2(%r6),%r19 ;# 2087 zero_extendqisi2/2
comib,<> 4,%r19,L$0274 ;# 2089 bleu+1
ldi 93,%r17 ;# 8622 reload_outsi+2/2
bb,>=,n %r15,23,L$0274 ;# 2094 movsi-4
ldb 1(%r6),%r19 ;# 2097 movqi+1/5
depi -1,29,1,%r19 ;# 2099 iorsi3+1/2
stb %r19,1(%r6) ;# 2101 movqi+1/6
L$0274
ldi 4,%r18 ;# 8628 reload_outsi+2/2
and %r15,%r18,%r1 ;# 8629 andsi3/1
stw %r1,-252(%r30) ;# 8792 reload_outsi+2/6
ldo -288(%r30),%r11 ;# 8632 addsi3/2
L$0275
ldw -296(%r30),%r20 ;# 2436 reload_outsi+2/5
L$1165
comb,= %r16,%r20,L$0902 ;# 2109 bleu+1
copy %r20,%r21 ;# 8745 reload_outsi+2/1
ldbs,ma 1(%r21),%r7 ;# 2134 zero_extendqisi2/2
comib,= 0,%r14,L$0280 ;# 2139 bleu+1
stw %r21,-296(%r30) ;# 2445 reload_outsi+2/6
addl %r14,%r7,%r19 ;# 2140 addsi3/1
ldb 0(%r19),%r7 ;# 2143 zero_extendqisi2/2
L$0280
bb,>= %r15,31,L$0285 ;# 2159 movsi-4
ldi 92,%r19 ;# 2161 reload_outsi+2/2
comb,<>,n %r19,%r7,L$0285 ;# 2163 bleu+1
comb,= %r16,%r21,L$0903 ;# 2167 bleu+1
ldo 1(%r21),%r19 ;# 2195 addsi3/2
ldb 1(%r20),%r3 ;# 2192 zero_extendqisi2/2
comib,= 0,%r14,L$0288 ;# 2197 bleu+1
stw %r19,-296(%r30) ;# 2460 reload_outsi+2/6
addl %r14,%r3,%r19 ;# 2198 addsi3/1
ldb 0(%r19),%r3 ;# 2201 zero_extendqisi2/2
L$0288
extru %r3,28,29,%r19 ;# 2216 lshrsi3/2
addl %r6,%r19,%r19 ;# 2219 addsi3/1
bl L$0948,%r0 ;# 2235 jump
extru %r3,31,3,%r20 ;# 2222 andsi3/1
L$0285
comb,<>,n %r17,%r7,L$0293 ;# 2243 bleu+1
ldw -268(%r30),%r1 ;# 8798 reload_outsi+2/5
ldw -296(%r30),%r20 ;# 2466 reload_outsi+2/5
ldo 1(%r1),%r19 ;# 2244 addsi3/2
comb,<>,n %r19,%r20,L$0276 ;# 2246 bleu+1
L$0293
comib,= 0,%r13,L$0294 ;# 2253 bleu+1
ldi 45,%r1 ;# 8801 reload_outsi+2/2
comb,<> %r1,%r7,L$1163 ;# 2257 bleu+1
ldw -296(%r30),%r20 ;# 2524 reload_outsi+2/5
ldw -296(%r30),%r19 ;# 2469 reload_outsi+2/5
ldb 0(%r19),%r19 ;# 2259 movqi+1/5
extrs %r19,31,8,%r19 ;# 2260 extendqisi2
comb,<>,n %r17,%r19,L$0895 ;# 2264 bleu+1
L$0294
ldi 45,%r1 ;# 8804 reload_outsi+2/2
comb,<> %r1,%r7,L$1163 ;# 2280 bleu+1
ldw -296(%r30),%r20 ;# 2524 reload_outsi+2/5
ldw -276(%r30),%r1 ;# 8807 reload_outsi+2/5
ldo -2(%r20),%r19 ;# 2281 addsi3/2
comb,>>,n %r1,%r19,L$1179 ;# 2283 bleu+1
ldb -2(%r20),%r19 ;# 2285 movqi+1/5
ldi 91,%r1 ;# 8810 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 2286 extendqisi2
comb,= %r1,%r19,L$1163 ;# 2290 bleu+1
ldw -276(%r30),%r1 ;# 8813 reload_outsi+2/5
L$1179
ldo -3(%r20),%r19 ;# 2294 addsi3/2
comb,>>,n %r1,%r19,L$0297 ;# 2296 bleu+1
ldb -3(%r20),%r19 ;# 2298 movqi+1/5
ldi 91,%r1 ;# 8816 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 2299 extendqisi2
comb,<> %r1,%r19,L$1164 ;# 2303 bleu+1
ldw -296(%r30),%r19 ;# 2487 reload_outsi+2/5
ldb -2(%r20),%r19 ;# 2305 movqi+1/5
ldi 94,%r20 ;# 2308 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 2306 extendqisi2
comb,= %r20,%r19,L$1163 ;# 2310 bleu+1
ldw -296(%r30),%r20 ;# 2524 reload_outsi+2/5
L$0297
ldw -296(%r30),%r19 ;# 2487 reload_outsi+2/5
L$1164
ldb 0(%r19),%r19 ;# 2315 movqi+1/5
extrs %r19,31,8,%r19 ;# 2316 extendqisi2
comb,<> %r17,%r19,L$0302 ;# 2320 bleu+1
ldw -296(%r30),%r20 ;# 2524 reload_outsi+2/5
L$1163
ldb 0(%r20),%r19 ;# 2526 movqi+1/5
ldi 45,%r1 ;# 8819 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 2527 extendqisi2
comb,<>,n %r1,%r19,L$0300 ;# 2531 bleu+1
ldb 1(%r20),%r19 ;# 2535 movqi+1/5
extrs %r19,31,8,%r19 ;# 2536 extendqisi2
comb,=,n %r17,%r19,L$0300 ;# 2540 bleu+1
comb,= %r16,%r20,L$0922 ;# 2550 bleu+1
ldo 1(%r20),%r19 ;# 2559 addsi3/2
stw %r19,-296(%r30) ;# 2561 reload_outsi+2/6
L$0302
stw %r6,-52(%r30) ;# 2588 reload_outsi+2/6
ldo -296(%r30),%r26 ;# 2590 addsi3/2
copy %r16,%r25 ;# 2592 reload_outsi+2/1
copy %r14,%r24 ;# 2594 reload_outsi+2/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl compile_range,%r2 ;# 2598 call_value_internal_symref
copy %r15,%r23 ;# 2596 reload_outsi+2/1
movb,= %r28,%r4,L$1165 ;# 2603 decrement_and_branch_until_zero+2/1
ldw -296(%r30),%r20 ;# 2436 reload_outsi+2/5
.CALL ARGW0=GR
bl free,%r2 ;# 2607 call_internal_symref
ldw -312(%r30),%r26 ;# 2605 reload_outsi+2/5
bl L$0867,%r0 ;# 2611 jump
copy %r4,%r28 ;# 2609 reload_outsi+2/1
L$0300
ldw -252(%r30),%r1 ;# 8822 reload_outsi+2/5
comib,= 0,%r1,L$0309 ;# 2624 bleu+1
ldi 91,%r1 ;# 8825 reload_outsi+2/2
comb,<> %r1,%r7,L$1166 ;# 2628 bleu+1
ldi 0,%r13 ;# 3624 reload_outsi+2/2
ldw -296(%r30),%r20 ;# 2630 reload_outsi+2/5
ldb 0(%r20),%r19 ;# 2632 movqi+1/5
ldi 58,%r1 ;# 8828 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 2633 extendqisi2
comb,<>,n %r1,%r19,L$1166 ;# 2637 bleu+1
comb,= %r16,%r20,L$0922 ;# 2647 bleu+1
ldo 1(%r20),%r19 ;# 2656 addsi3/2
stw %r19,-296(%r30) ;# 2658 reload_outsi+2/6
comb,= %r16,%r19,L$0902 ;# 2689 bleu+1
ldi 0,%r3 ;# 2684 reload_outsi+2/2
L$0317
ldw -296(%r30),%r19 ;# 2709 reload_outsi+2/5
comb,= %r16,%r19,L$0922 ;# 2711 bleu+1
ldo 1(%r19),%r20 ;# 2720 addsi3/2
stw %r20,-296(%r30) ;# 2722 reload_outsi+2/6
comib,= 0,%r14,L$0321 ;# 2729 bleu+1
ldb 0(%r19),%r7 ;# 2725 zero_extendqisi2/2
addl %r14,%r7,%r19 ;# 2730 addsi3/1
ldb 0(%r19),%r7 ;# 2733 zero_extendqisi2/2
L$0321
ldi 58,%r1 ;# 8831 reload_outsi+2/2
comb,= %r1,%r7,L$1167 ;# 2750 bleu+1
addl %r11,%r3,%r19 ;# 2789 addsi3/1
comb,=,n %r17,%r7,L$1167 ;# 2754 bleu+1
comb,=,n %r16,%r20,L$1167 ;# 2758 bleu+1
comib,= 6,%r3,L$1167 ;# 2760 bleu+1
copy %r3,%r20 ;# 2770 reload_outsi+2/1
ldo 1(%r20),%r19 ;# 2771 addsi3/2
extru %r19,31,8,%r3 ;# 2772 zero_extendqisi2/1
addl %r11,%r20,%r20 ;# 2776 addsi3/1
bl L$0317,%r0 ;# 2783 jump
stb %r7,0(%r20) ;# 2778 movqi+1/6
L$1167
comb,<> %r1,%r7,L$0328 ;# 2796 bleu+1
stb %r0,0(%r19) ;# 2791 movqi+1/6
ldw -296(%r30),%r19 ;# 2798 reload_outsi+2/5
ldb 0(%r19),%r19 ;# 2800 movqi+1/5
extrs %r19,31,8,%r19 ;# 2801 extendqisi2
comb,<> %r17,%r19,L$1168 ;# 2805 bleu+1
ldi 255,%r19 ;# 8069 reload_outsi+2/2
copy %r11,%r26 ;# 2813 reload_outsi+2/1
ldil LR'L$C0016,%r1 ;# 8835 add_high_const+3
ldo RR'L$C0016(%r1),%r1 ;# 8836 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2817 call_value_internal_symref
copy %r1,%r25 ;# 2815 reload_outsi+2/1
copy %r11,%r26 ;# 2829 reload_outsi+2/1
ldil LR'L$C0017,%r1 ;# 8837 add_high_const+3
ldo RR'L$C0017(%r1),%r1 ;# 8838 movhi-2
copy %r1,%r25 ;# 2831 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2821 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2833 call_value_internal_symref
stw %r28,-244(%r30) ;# 8841 reload_outsi+2/6
copy %r11,%r26 ;# 2845 reload_outsi+2/1
ldil LR'L$C0018,%r1 ;# 8842 add_high_const+3
ldo RR'L$C0018(%r1),%r1 ;# 8843 movhi-2
copy %r1,%r25 ;# 2847 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2837 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2849 call_value_internal_symref
stw %r28,-236(%r30) ;# 8846 reload_outsi+2/6
copy %r11,%r26 ;# 2861 reload_outsi+2/1
ldil LR'L$C0019,%r1 ;# 8847 add_high_const+3
ldo RR'L$C0019(%r1),%r1 ;# 8848 movhi-2
copy %r1,%r25 ;# 2863 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2853 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2865 call_value_internal_symref
stw %r28,-228(%r30) ;# 8851 reload_outsi+2/6
copy %r11,%r26 ;# 2877 reload_outsi+2/1
ldil LR'L$C0020,%r1 ;# 8852 add_high_const+3
ldo RR'L$C0020(%r1),%r1 ;# 8853 movhi-2
copy %r1,%r25 ;# 2879 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2869 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2881 call_value_internal_symref
stw %r28,-220(%r30) ;# 8856 reload_outsi+2/6
copy %r11,%r26 ;# 2893 reload_outsi+2/1
ldil LR'L$C0021,%r1 ;# 8857 add_high_const+3
ldo RR'L$C0021(%r1),%r1 ;# 8858 movhi-2
copy %r1,%r25 ;# 2895 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2885 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2897 call_value_internal_symref
stw %r28,-212(%r30) ;# 8861 reload_outsi+2/6
copy %r11,%r26 ;# 2909 reload_outsi+2/1
ldil LR'L$C0022,%r1 ;# 8862 add_high_const+3
ldo RR'L$C0022(%r1),%r1 ;# 8863 movhi-2
copy %r1,%r25 ;# 2911 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2901 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2913 call_value_internal_symref
stw %r28,-204(%r30) ;# 8866 reload_outsi+2/6
copy %r11,%r26 ;# 2925 reload_outsi+2/1
ldil LR'L$C0023,%r1 ;# 8867 add_high_const+3
ldo RR'L$C0023(%r1),%r1 ;# 8868 movhi-2
copy %r1,%r25 ;# 2927 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2917 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2929 call_value_internal_symref
stw %r28,-196(%r30) ;# 8871 reload_outsi+2/6
copy %r11,%r26 ;# 2941 reload_outsi+2/1
ldil LR'L$C0024,%r1 ;# 8872 add_high_const+3
ldo RR'L$C0024(%r1),%r1 ;# 8873 movhi-2
copy %r1,%r25 ;# 2943 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2933 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2945 call_value_internal_symref
stw %r28,-188(%r30) ;# 8876 reload_outsi+2/6
copy %r11,%r26 ;# 2957 reload_outsi+2/1
ldil LR'L$C0025,%r1 ;# 8877 add_high_const+3
ldo RR'L$C0025(%r1),%r1 ;# 8878 movhi-2
copy %r1,%r25 ;# 2959 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2949 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2961 call_value_internal_symref
stw %r28,-180(%r30) ;# 8881 reload_outsi+2/6
copy %r11,%r26 ;# 2973 reload_outsi+2/1
ldil LR'L$C0026,%r19 ;# 2970 add_high_const+3
ldo RR'L$C0026(%r19),%r3 ;# 2971 movhi-2
copy %r3,%r25 ;# 2975 reload_outsi+2/1
comiclr,<> 0,%r28,%r28 ;# 2965 scc
ldi 1,%r28
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2977 call_value_internal_symref
stw %r28,-172(%r30) ;# 8884 reload_outsi+2/6
copy %r11,%r26 ;# 2989 reload_outsi+2/1
ldil LR'L$C0027,%r19 ;# 2986 add_high_const+3
ldo RR'L$C0027(%r19),%r4 ;# 2987 movhi-2
comiclr,<> 0,%r28,%r13 ;# 2981 scc
ldi 1,%r13
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 2993 call_value_internal_symref
copy %r4,%r25 ;# 2991 reload_outsi+2/1
copy %r11,%r26 ;# 3005 reload_outsi+2/1
ldil LR'L$C0017,%r1 ;# 8885 add_high_const+3
ldo RR'L$C0017(%r1),%r1 ;# 8886 movhi-2
comiclr,<> 0,%r28,%r7 ;# 2997 scc
ldi 1,%r7
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3009 call_value_internal_symref
copy %r1,%r25 ;# 3007 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3013 bleu+1
copy %r11,%r26 ;# 3018 reload_outsi+2/1
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3022 call_value_internal_symref
copy %r3,%r25 ;# 3020 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3026 bleu+1
copy %r11,%r26 ;# 3031 reload_outsi+2/1
ldil LR'L$C0022,%r1 ;# 8887 add_high_const+3
ldo RR'L$C0022(%r1),%r1 ;# 8888 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3035 call_value_internal_symref
copy %r1,%r25 ;# 3033 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3039 bleu+1
copy %r11,%r26 ;# 3044 reload_outsi+2/1
ldil LR'L$C0020,%r1 ;# 8889 add_high_const+3
ldo RR'L$C0020(%r1),%r1 ;# 8890 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3048 call_value_internal_symref
copy %r1,%r25 ;# 3046 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3052 bleu+1
copy %r11,%r26 ;# 3057 reload_outsi+2/1
ldil LR'L$C0016,%r1 ;# 8891 add_high_const+3
ldo RR'L$C0016(%r1),%r1 ;# 8892 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3061 call_value_internal_symref
copy %r1,%r25 ;# 3059 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3065 bleu+1
copy %r11,%r26 ;# 3070 reload_outsi+2/1
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3074 call_value_internal_symref
copy %r4,%r25 ;# 3072 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3078 bleu+1
copy %r11,%r26 ;# 3083 reload_outsi+2/1
ldil LR'L$C0025,%r1 ;# 8893 add_high_const+3
ldo RR'L$C0025(%r1),%r1 ;# 8894 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3087 call_value_internal_symref
copy %r1,%r25 ;# 3085 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3091 bleu+1
copy %r11,%r26 ;# 3096 reload_outsi+2/1
ldil LR'L$C0023,%r1 ;# 8895 add_high_const+3
ldo RR'L$C0023(%r1),%r1 ;# 8896 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3100 call_value_internal_symref
copy %r1,%r25 ;# 3098 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3104 bleu+1
copy %r11,%r26 ;# 3109 reload_outsi+2/1
ldil LR'L$C0024,%r1 ;# 8897 add_high_const+3
ldo RR'L$C0024(%r1),%r1 ;# 8898 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3113 call_value_internal_symref
copy %r1,%r25 ;# 3111 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3117 bleu+1
copy %r11,%r26 ;# 3122 reload_outsi+2/1
ldil LR'L$C0021,%r1 ;# 8899 add_high_const+3
ldo RR'L$C0021(%r1),%r1 ;# 8900 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3126 call_value_internal_symref
copy %r1,%r25 ;# 3124 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3130 bleu+1
copy %r11,%r26 ;# 3135 reload_outsi+2/1
ldil LR'L$C0019,%r1 ;# 8901 add_high_const+3
ldo RR'L$C0019(%r1),%r1 ;# 8902 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3139 call_value_internal_symref
copy %r1,%r25 ;# 3137 reload_outsi+2/1
comib,= 0,%r28,L$0329 ;# 3143 bleu+1
copy %r11,%r26 ;# 3148 reload_outsi+2/1
ldil LR'L$C0018,%r1 ;# 8903 add_high_const+3
ldo RR'L$C0018(%r1),%r1 ;# 8904 movhi-2
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2 ;# 3152 call_value_internal_symref
copy %r1,%r25 ;# 3150 reload_outsi+2/1
comib,<>,n 0,%r28,L$0900 ;# 3156 bleu+1
L$0329
ldw -296(%r30),%r19 ;# 3173 reload_outsi+2/5
comb,= %r16,%r19,L$0922 ;# 3175 bleu+1
ldo 1(%r19),%r19 ;# 3184 addsi3/2
comb,= %r16,%r19,L$0902 ;# 3214 bleu+1
stw %r19,-296(%r30) ;# 3186 reload_outsi+2/6
ldi 0,%r22 ;# 3227 reload_outsi+2/2
addil LR'__alnum-$global$,%r27 ;# 8596 pic2_lo_sum+1
copy %r1,%r2 ;# 8907 reload_outsi+2/1
addil LR'__ctype2-$global$,%r27 ;# 8598 pic2_lo_sum+1
copy %r1,%r23 ;# 8910 reload_outsi+2/1
addil LR'__ctype-$global$,%r27 ;# 8600 pic2_lo_sum+1
copy %r1,%r4 ;# 8913 reload_outsi+2/1
ldi 32,%r25 ;# 8605 reload_outsi+2/2
ldi 2,%r24 ;# 8607 reload_outsi+2/2
ldi 16,%r31 ;# 8609 reload_outsi+2/2
ldi 8,%r29 ;# 8611 reload_outsi+2/2
ldi 128,%r28 ;# 8613 reload_outsi+2/2
ldi 255,%r26 ;# 8615 reload_outsi+2/2
ldw -244(%r30),%r1 ;# 8916 reload_outsi+2/5
L$1173
comib,=,n 0,%r1,L$0343 ;# 3240 bleu+1
stw %r22,RR'__alnum-$global$(%r2) ;# 3244 reload_outsi+2/6
ldw RR'__ctype2-$global$(%r23),%r19 ;# 3248 reload_outsi+2/5
ldw RR'__ctype-$global$(%r4),%r21 ;# 3260 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3253 addsi3/1
addl %r21,%r22,%r21 ;# 3265 addsi3/1
ldb 0(%r19),%r20 ;# 3255 movqi+1/5
ldb 0(%r21),%r19 ;# 3267 movqi+1/5
extru %r20,31,1,%r20 ;# 3256 andsi3/1
and %r19,%r18,%r19 ;# 3270 andsi3/1
or %r20,%r19,%r20 ;# 3278 xordi3-1
comib,<> 0,%r20,L$1169 ;# 3280 bleu+1
extru %r22,31,8,%r19 ;# 3330 zero_extendqisi2/1
L$0343
ldw -236(%r30),%r1 ;# 8919 reload_outsi+2/5
comib,= 0,%r1,L$0344 ;# 3285 bleu+1
ldw RR'__ctype2-$global$(%r23),%r19 ;# 3289 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3290 addsi3/1
ldb 0(%r19),%r19 ;# 3292 movqi+1/5
bb,< %r19,31,L$1169 ;# 3296 bleu+3
extru %r22,31,8,%r19 ;# 3330 zero_extendqisi2/1
L$0344
ldw -228(%r30),%r1 ;# 8922 reload_outsi+2/5
comib,=,n 0,%r1,L$0345 ;# 3301 bleu+1
comb,= %r25,%r22,L$1169 ;# 3305 bleu+1
extru %r22,31,8,%r19 ;# 3330 zero_extendqisi2/1
comib,= 9,%r22,L$1170 ;# 3307 bleu+1
extru %r19,28,29,%r21 ;# 3332 lshrsi3/2
L$0345
ldw -220(%r30),%r1 ;# 8925 reload_outsi+2/5
comib,= 0,%r1,L$0341 ;# 3312 bleu+1
ldw RR'__ctype-$global$(%r4),%r19 ;# 3316 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3317 addsi3/1
ldb 0(%r19),%r19 ;# 3319 movqi+1/5
and %r19,%r25,%r19 ;# 3322 andsi3/1
comib,= 0,%r19,L$0341 ;# 3325 bleu+1
extru %r22,31,8,%r19 ;# 3330 zero_extendqisi2/1
L$1169
extru %r19,28,29,%r21 ;# 3332 lshrsi3/2
L$1170
addl %r6,%r21,%r21 ;# 3335 addsi3/1
extru %r19,31,3,%r19 ;# 3339 andsi3/1
subi 31,%r19,%r19 ;# 3340 subsi3/2
ldb 0(%r21),%r20 ;# 3343 movqi+1/5
mtsar %r19 ;# 8928 reload_outsi+2/7
vdepi -1,1,%r20 ;# 3348 vdepi_ior
stb %r20,0(%r21) ;# 3350 movqi+1/6
L$0341
ldw -212(%r30),%r1 ;# 8931 reload_outsi+2/5
comib,= 0,%r1,L$0348 ;# 3354 bleu+1
ldw RR'__ctype-$global$(%r4),%r19 ;# 3358 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3359 addsi3/1
ldb 0(%r19),%r19 ;# 3361 movqi+1/5
and %r19,%r18,%r19 ;# 3364 andsi3/1
comib,<> 0,%r19,L$1171 ;# 3367 bleu+1
extru %r22,31,8,%r19 ;# 3426 zero_extendqisi2/1
L$0348
ldw -204(%r30),%r1 ;# 8934 reload_outsi+2/5
comib,= 0,%r1,L$0349 ;# 3372 bleu+1
ldw RR'__ctype2-$global$(%r23),%r19 ;# 3376 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3377 addsi3/1
ldb 0(%r19),%r19 ;# 3379 movqi+1/5
and %r19,%r24,%r19 ;# 3382 andsi3/1
comib,<> 0,%r19,L$1171 ;# 3385 bleu+1
extru %r22,31,8,%r19 ;# 3426 zero_extendqisi2/1
L$0349
ldw -196(%r30),%r1 ;# 8937 reload_outsi+2/5
comib,= 0,%r1,L$0350 ;# 3390 bleu+1
ldw RR'__ctype-$global$(%r4),%r19 ;# 3394 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3395 addsi3/1
ldb 0(%r19),%r19 ;# 3397 movqi+1/5
and %r19,%r24,%r19 ;# 3400 andsi3/1
comib,<> 0,%r19,L$1171 ;# 3403 bleu+1
extru %r22,31,8,%r19 ;# 3426 zero_extendqisi2/1
L$0350
ldw -188(%r30),%r1 ;# 8940 reload_outsi+2/5
comib,= 0,%r1,L$0346 ;# 3408 bleu+1
ldw RR'__ctype2-$global$(%r23),%r19 ;# 3412 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3413 addsi3/1
ldb 0(%r19),%r19 ;# 3415 movqi+1/5
and %r19,%r18,%r19 ;# 3418 andsi3/1
comib,= 0,%r19,L$0346 ;# 3421 bleu+1
extru %r22,31,8,%r19 ;# 3426 zero_extendqisi2/1
L$1171
extru %r19,28,29,%r21 ;# 3428 lshrsi3/2
addl %r6,%r21,%r21 ;# 3431 addsi3/1
extru %r19,31,3,%r19 ;# 3435 andsi3/1
subi 31,%r19,%r19 ;# 3436 subsi3/2
ldb 0(%r21),%r20 ;# 3439 movqi+1/5
mtsar %r19 ;# 8943 reload_outsi+2/7
vdepi -1,1,%r20 ;# 3444 vdepi_ior
stb %r20,0(%r21) ;# 3446 movqi+1/6
L$0346
ldw -180(%r30),%r1 ;# 8946 reload_outsi+2/5
comib,= 0,%r1,L$0353 ;# 3450 bleu+1
ldw RR'__ctype-$global$(%r4),%r19 ;# 3454 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3455 addsi3/1
ldb 0(%r19),%r19 ;# 3457 movqi+1/5
and %r19,%r31,%r19 ;# 3460 andsi3/1
comib,<> 0,%r19,L$1172 ;# 3463 bleu+1
extru %r22,31,8,%r19 ;# 3520 zero_extendqisi2/1
L$0353
ldw -172(%r30),%r1 ;# 8949 reload_outsi+2/5
comib,= 0,%r1,L$0354 ;# 3468 bleu+1
ldw RR'__ctype-$global$(%r4),%r19 ;# 3472 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3473 addsi3/1
ldb 0(%r19),%r19 ;# 3475 movqi+1/5
and %r19,%r29,%r19 ;# 3478 andsi3/1
comib,<> 0,%r19,L$1172 ;# 3481 bleu+1
extru %r22,31,8,%r19 ;# 3520 zero_extendqisi2/1
L$0354
comib,= 0,%r13,L$0355 ;# 3486 bleu+1
ldw RR'__ctype-$global$(%r4),%r19 ;# 3490 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3491 addsi3/1
ldb 0(%r19),%r19 ;# 3493 movqi+1/5
bb,< %r19,31,L$1172 ;# 3497 bleu+3
extru %r22,31,8,%r19 ;# 3520 zero_extendqisi2/1
L$0355
comib,= 0,%r7,L$0339 ;# 3502 bleu+1
ldw RR'__ctype-$global$(%r4),%r19 ;# 3506 reload_outsi+2/5
addl %r19,%r22,%r19 ;# 3507 addsi3/1
ldb 0(%r19),%r19 ;# 3509 movqi+1/5
and %r19,%r28,%r19 ;# 3512 andsi3/1
comib,= 0,%r19,L$0339 ;# 3515 bleu+1
extru %r22,31,8,%r19 ;# 3520 zero_extendqisi2/1
L$1172
extru %r19,28,29,%r21 ;# 3522 lshrsi3/2
addl %r6,%r21,%r21 ;# 3525 addsi3/1
extru %r19,31,3,%r19 ;# 3529 andsi3/1
subi 31,%r19,%r19 ;# 3530 subsi3/2
ldb 0(%r21),%r20 ;# 3533 movqi+1/5
mtsar %r19 ;# 8952 reload_outsi+2/7
vdepi -1,1,%r20 ;# 3538 vdepi_ior
stb %r20,0(%r21) ;# 3540 movqi+1/6
L$0339
ldo 1(%r22),%r22 ;# 3546 addsi3/2
comb,>=,n %r26,%r22,L$1173 ;# 3233 bleu+1
ldw -244(%r30),%r1 ;# 8916 reload_outsi+2/5
bl L$0275,%r0 ;# 3559 jump
ldi 1,%r13 ;# 3556 reload_outsi+2/2
L$0328
ldi 255,%r19 ;# 8069 reload_outsi+2/2
L$1168
comb,= %r19,%r3,L$0359 ;# 8070 bleu+1
copy %r19,%r21 ;# 8595 reload_outsi+2/1
L$0360
ldo -1(%r3),%r20 ;# 3571 addsi3/2
ldw -296(%r30),%r19 ;# 3583 reload_outsi+2/5
extru %r20,31,8,%r3 ;# 3572 zero_extendqisi2/1
ldo -1(%r19),%r19 ;# 3584 addsi3/2
comb,<> %r21,%r3,L$0360 ;# 3577 bleu+1
stw %r19,-296(%r30) ;# 3588 reload_outsi+2/6
L$0359
ldb 11(%r6),%r19 ;# 3599 movqi+1/5
depi -1,28,1,%r19 ;# 3601 iorsi3+1/2
stb %r19,11(%r6) ;# 3603 movqi+1/6
ldb 7(%r6),%r19 ;# 3606 movqi+1/5
ldi 0,%r13 ;# 3613 reload_outsi+2/2
depi -1,29,1,%r19 ;# 3608 iorsi3+1/2
bl L$0275,%r0 ;# 3618 jump
stb %r19,7(%r6) ;# 3610 movqi+1/6
L$0309
ldi 0,%r13 ;# 3624 reload_outsi+2/2
L$1166
extru %r7,21+8-1,8,%r19 ;# 3627 extzv
addl %r6,%r19,%r19 ;# 3630 addsi3/1
extru %r7,31,3,%r20 ;# 3633 andsi3/1
L$0948
subi 31,%r20,%r20 ;# 3634 subsi3/2
ldb 0(%r19),%r21 ;# 3637 movqi+1/5
mtsar %r20 ;# 8955 reload_outsi+2/7
vdepi -1,1,%r21 ;# 3642 vdepi_ior
bl L$0275,%r0 ;# 3653 jump
stb %r21,0(%r19) ;# 3644 movqi+1/6
L$0276
ldb -1(%r6),%r20 ;# 8074 movqi+1/5
extru %r20,31,8,%r19 ;# 8075 zero_extendqisi2/1
comib,= 0,%r19,L$0364 ;# 8076 bleu+1
addl %r19,%r6,%r19 ;# 8079 addsi3/1
ldb -1(%r19),%r19 ;# 8082 zero_extendqisi2/2
comib,<> 0,%r19,L$0364 ;# 8083 bleu+1
ldo -1(%r20),%r19 ;# 8242 addsi3/2
bl L$1183,%r0 ;# 8253 jump
stb %r19,-1(%r6) ;# 3688 movqi+1/6
L$0365
ldo -1(%r19),%r19 ;# 3686 addsi3/2
stb %r19,-1(%r6) ;# 3688 movqi+1/6
L$1183
extru %r19,31,8,%r19 ;# 3662 zero_extendqisi2/1
comib,= 0,%r19,L$0364 ;# 3664 bleu+1
addl %r19,%r6,%r19 ;# 3668 addsi3/1
ldb -1(%r19),%r19 ;# 3672 zero_extendqisi2/2
comib,=,n 0,%r19,L$0365 ;# 3674 bleu+1
ldb -1(%r6),%r19 ;# 3683 movqi+1/5
L$0364
ldb -1(%r6),%r19 ;# 3700 zero_extendqisi2/2
bl L$0043,%r0 ;# 3705 jump
addl %r6,%r19,%r6 ;# 3701 addsi3/1
L$0368
bb,>=,n %r15,18,L$0076 ;# 3713 movsi-4
bl L$1181,%r0 ;# 3721 jump
ldw 24(%r5),%r19 ;# 3861 reload_outsi+2/5
L$0372
bb,>=,n %r15,18,L$0076 ;# 3730 movsi-4
bl,n L$0374,%r0 ;# 3738 jump
L$0376
bb,>=,n %r15,20,L$0076 ;# 3747 movsi-4
bl,n L$0378,%r0 ;# 3755 jump
L$0380
bb,>=,n %r15,16,L$0076 ;# 3764 movsi-4
bl,n L$0378,%r0 ;# 3772 jump
L$0383
and %r15,%r20,%r19 ;# 3779 andsi3/1
comb,= %r20,%r19,L$1174 ;# 3783 bleu+1
ldi -1,%r4 ;# 5074 reload_outsi+2/2
bl,n L$0076,%r0 ;# 3791 jump
L$0387
comb,=,n %r16,%r19,L$0903 ;# 3799 bleu+1
ldb 0(%r19),%r7 ;# 3831 zero_extendqisi2/2
ldo 1(%r19),%r19 ;# 3826 addsi3/2
stw %r19,-296(%r30) ;# 3828 reload_outsi+2/6
ldo -39(%r7),%r19 ;# 7446 addsi3/2
addi,uv -86,%r19,%r0 ;# 7447 casesi0
blr,n %r19,%r0
b,n L$0397
L$0817
bl L$0759,%r0 ;# 9437 switch_jump
ldw 0(%r5),%r4 ;# 8204 reload_outsi+2/5
L$1069
bl L$0395,%r0
nop ;# 9440 switch_jump
L$1070
bl L$0422,%r0
nop ;# 9443 switch_jump
L$1071
bl L$0397,%r0
nop ;# 9446 switch_jump
L$1072
bl L$0811,%r0
nop ;# 9449 switch_jump
L$1073
bl L$0397,%r0
nop ;# 9452 switch_jump
L$1074
bl L$0397,%r0
nop ;# 9455 switch_jump
L$1075
bl L$0397,%r0
nop ;# 9458 switch_jump
L$1076
bl L$0397,%r0
nop ;# 9461 switch_jump
L$1077
bl L$0397,%r0
nop ;# 9464 switch_jump
L$1078
bl L$0787,%r0
nop ;# 9467 switch_jump
L$1079
bl L$0787,%r0
nop ;# 9470 switch_jump
L$1080
bl L$0787,%r0
nop ;# 9473 switch_jump
L$1081
bl L$0787,%r0
nop ;# 9476 switch_jump
L$1082
bl L$0787,%r0
nop ;# 9479 switch_jump
L$1083
bl L$0787,%r0
nop ;# 9482 switch_jump
L$1084
bl L$0787,%r0
nop ;# 9485 switch_jump
L$1085
bl L$0787,%r0
nop ;# 9488 switch_jump
L$1086
bl L$0787,%r0
nop ;# 9491 switch_jump
L$1087
bl L$0397,%r0
nop ;# 9494 switch_jump
L$1088
bl L$0397,%r0
nop ;# 9497 switch_jump
L$1089
bl L$0659,%r0 ;# 9500 switch_jump
ldw 0(%r5),%r4 ;# 8164 reload_outsi+2/5
L$1090
bl L$0397,%r0
nop ;# 9503 switch_jump
L$1091
bl L$0679,%r0 ;# 9506 switch_jump
ldw 0(%r5),%r4 ;# 8172 reload_outsi+2/5
L$1092
bl L$0811,%r0
nop ;# 9509 switch_jump
L$1093
bl L$0397,%r0
nop ;# 9512 switch_jump
L$1094
bl L$0397,%r0
nop ;# 9515 switch_jump
L$1095
bl L$0719,%r0 ;# 9518 switch_jump
ldw 0(%r5),%r4 ;# 8188 reload_outsi+2/5
L$1096
bl L$0397,%r0
nop ;# 9521 switch_jump
L$1097
bl L$0397,%r0
nop ;# 9524 switch_jump
L$1098
bl L$0397,%r0
nop ;# 9527 switch_jump
L$1099
bl L$0397,%r0
nop ;# 9530 switch_jump
L$1100
bl L$0397,%r0
nop ;# 9533 switch_jump
L$1101
bl L$0397,%r0
nop ;# 9536 switch_jump
L$1102
bl L$0397,%r0
nop ;# 9539 switch_jump
L$1103
bl L$0397,%r0
nop ;# 9542 switch_jump
L$1104
bl L$0397,%r0
nop ;# 9545 switch_jump
L$1105
bl L$0397,%r0
nop ;# 9548 switch_jump
L$1106
bl L$0397,%r0
nop ;# 9551 switch_jump
L$1107
bl L$0397,%r0
nop ;# 9554 switch_jump
L$1108
bl L$0397,%r0
nop ;# 9557 switch_jump
L$1109
bl L$0397,%r0
nop ;# 9560 switch_jump
L$1110
bl L$0397,%r0
nop ;# 9563 switch_jump
L$1111
bl L$0397,%r0
nop ;# 9566 switch_jump
L$1112
bl L$0397,%r0
nop ;# 9569 switch_jump
L$1113
bl L$0397,%r0
nop ;# 9572 switch_jump
L$1114
bl L$0397,%r0
nop ;# 9575 switch_jump
L$1115
bl L$0397,%r0
nop ;# 9578 switch_jump
L$1116
bl L$0639,%r0 ;# 9581 switch_jump
ldw 0(%r5),%r4 ;# 8156 reload_outsi+2/5
L$1117
bl L$0397,%r0
nop ;# 9584 switch_jump
L$1118
bl L$0397,%r0
nop ;# 9587 switch_jump
L$1119
bl L$0397,%r0
nop ;# 9590 switch_jump
L$1120
bl L$0397,%r0
nop ;# 9593 switch_jump
L$1121
bl L$0397,%r0
nop ;# 9596 switch_jump
L$1122
bl L$0397,%r0
nop ;# 9599 switch_jump
L$1123
bl L$0397,%r0
nop ;# 9602 switch_jump
L$1124
bl L$0397,%r0
nop ;# 9605 switch_jump
L$1125
bl L$0739,%r0 ;# 9608 switch_jump
ldw 0(%r5),%r4 ;# 8196 reload_outsi+2/5
L$1126
bl L$0397,%r0
nop ;# 9611 switch_jump
L$1127
bl L$0699,%r0 ;# 9614 switch_jump
ldw 0(%r5),%r4 ;# 8180 reload_outsi+2/5
L$1128
bl L$0397,%r0
nop ;# 9617 switch_jump
L$1129
bl L$0397,%r0
nop ;# 9620 switch_jump
L$1130
bl L$0397,%r0
nop ;# 9623 switch_jump
L$1131
bl L$0397,%r0
nop ;# 9626 switch_jump
L$1132
bl L$0397,%r0
nop ;# 9629 switch_jump
L$1133
bl L$0397,%r0
nop ;# 9632 switch_jump
L$1134
bl L$0397,%r0
nop ;# 9635 switch_jump
L$1135
bl L$0397,%r0
nop ;# 9638 switch_jump
L$1136
bl L$0397,%r0
nop ;# 9641 switch_jump
L$1137
bl L$0397,%r0
nop ;# 9644 switch_jump
L$1138
bl L$0397,%r0
nop ;# 9647 switch_jump
L$1139
bl L$0397,%r0
nop ;# 9650 switch_jump
L$1140
bl L$0397,%r0
nop ;# 9653 switch_jump
L$1141
bl L$0397,%r0
nop ;# 9656 switch_jump
L$1142
bl L$0397,%r0
nop ;# 9659 switch_jump
L$1143
bl L$0397,%r0
nop ;# 9662 switch_jump
L$1144
bl L$0397,%r0
nop ;# 9665 switch_jump
L$1145
bl L$0397,%r0
nop ;# 9668 switch_jump
L$1146
bl L$0397,%r0
nop ;# 9671 switch_jump
L$1147
bl L$0397,%r0
nop ;# 9674 switch_jump
L$1148
bl L$0619,%r0 ;# 9677 switch_jump
ldw 0(%r5),%r4 ;# 8148 reload_outsi+2/5
L$1149
bl L$0397,%r0
nop ;# 9680 switch_jump
L$1150
bl L$0397,%r0
nop ;# 9683 switch_jump
L$1151
bl L$0397,%r0
nop ;# 9686 switch_jump
L$1152
bl L$0506,%r0
nop ;# 9689 switch_jump
L$1153
bl L$0472,%r0 ;# 9692 switch_jump
ldil L'33792,%r19 ;# 4724 add_high_const+3
L$1154
bl,n L$0397,%r0 ;# 7450 jump
L$0395
bb,<,n %r15,18,L$0397 ;# 3853 bleu+3
ldw 24(%r5),%r19 ;# 3861 reload_outsi+2/5
L$1181
ldo 1(%r19),%r19 ;# 3862 addsi3/2
stw %r19,24(%r5) ;# 3866 reload_outsi+2/6
ldw -304(%r30),%r20 ;# 3871 reload_outsi+2/5
ldw -260(%r30),%r1 ;# 8958 reload_outsi+2/5
ldw -308(%r30),%r19 ;# 3873 reload_outsi+2/5
ldo 1(%r1),%r1 ;# 3868 addsi3/2
comb,<> %r19,%r20,L$0398 ;# 3875 bleu+1
stw %r1,-260(%r30) ;# 8961 reload_outsi+2/6
zdep %r20,28,29,%r25 ;# 3885 ashlsi3+1
sh1addl %r20,%r25,%r25 ;# 3886 ashlsi3-2
ldw -312(%r30),%r26 ;# 3890 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 3894 call_value_internal_symref
zdep %r25,29,30,%r25 ;# 3892 ashlsi3+1
comib,= 0,%r28,L$0953 ;# 3903 bleu+1
stw %r28,-312(%r30) ;# 3898 reload_outsi+2/6
ldw -308(%r30),%r19 ;# 3912 reload_outsi+2/5
zdep %r19,30,31,%r19 ;# 3914 ashlsi3+1
stw %r19,-308(%r30) ;# 3916 reload_outsi+2/6
L$0398
ldw -304(%r30),%r20 ;# 3921 reload_outsi+2/5
ldw -312(%r30),%r21 ;# 3923 reload_outsi+2/5
ldw 0(%r5),%r19 ;# 3933 reload_outsi+2/5
sh2addl %r20,%r20,%r20 ;# 3928 ashlsi3-2
sh2addl %r20,%r21,%r21 ;# 3931 ashlsi3-2
sub %r12,%r19,%r19 ;# 3934 subsi3/1
stw %r19,0(%r21) ;# 3936 reload_outsi+2/6
ldw -304(%r30),%r19 ;# 3939 reload_outsi+2/5
ldw -312(%r30),%r20 ;# 3941 reload_outsi+2/5
sh2addl %r19,%r19,%r19 ;# 3946 ashlsi3-2
comib,= 0,%r10,L$0400 ;# 3951 bleu+1
sh2addl %r19,%r20,%r20 ;# 3949 ashlsi3-2
ldw 0(%r5),%r19 ;# 3953 reload_outsi+2/5
sub %r10,%r19,%r19 ;# 3954 subsi3/1
ldo 1(%r19),%r19 ;# 3955 addsi3/2
bl L$0401,%r0 ;# 3958 jump
stw %r19,4(%r20) ;# 3957 reload_outsi+2/6
L$0400
stw %r0,4(%r20) ;# 3962 reload_outsi+2/6
L$0401
ldw -304(%r30),%r20 ;# 3966 reload_outsi+2/5
ldw -312(%r30),%r21 ;# 3968 reload_outsi+2/5
ldw 0(%r5),%r19 ;# 3978 reload_outsi+2/5
sh2addl %r20,%r20,%r20 ;# 3973 ashlsi3-2
sh2addl %r20,%r21,%r21 ;# 3976 ashlsi3-2
sub %r6,%r19,%r19 ;# 3979 subsi3/1
stw %r19,12(%r21) ;# 3981 reload_outsi+2/6
ldw -304(%r30),%r19 ;# 3984 reload_outsi+2/5
ldw -312(%r30),%r20 ;# 3986 reload_outsi+2/5
ldw -260(%r30),%r1 ;# 8964 reload_outsi+2/5
sh2addl %r19,%r19,%r19 ;# 3991 ashlsi3-2
sh2addl %r19,%r20,%r20 ;# 3994 ashlsi3-2
ldi 255,%r19 ;# 3999 reload_outsi+2/2
comb,<< %r19,%r1,L$0402 ;# 4001 bleu+1
stw %r1,16(%r20) ;# 3996 reload_outsi+2/6
ldw -304(%r30),%r20 ;# 4005 reload_outsi+2/5
ldw -312(%r30),%r21 ;# 4007 reload_outsi+2/5
ldw 0(%r5),%r19 ;# 4017 reload_outsi+2/5
sh2addl %r20,%r20,%r20 ;# 4012 ashlsi3-2
sh2addl %r20,%r21,%r21 ;# 4015 ashlsi3-2
sub %r6,%r19,%r19 ;# 4018 subsi3/1
ldo 2(%r19),%r19 ;# 4019 addsi3/2
stw %r19,8(%r21) ;# 4021 reload_outsi+2/6
ldw 0(%r5),%r4 ;# 8087 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8090 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8088 subsi3/1
ldo 3(%r19),%r19 ;# 8089 addsi3/2
comb,>>=,n %r20,%r19,L$0407 ;# 8091 bleu+1
ldil L'65536,%r3 ;# 8593 reload_outsi+2/3
L$0408
comb,= %r3,%r20,L$0944 ;# 4049 bleu+1
zdep %r20,30,31,%r19 ;# 4059 ashlsi3+1
comb,>>= %r3,%r19,L$0413 ;# 4067 bleu+1
stw %r19,4(%r5) ;# 4061 reload_outsi+2/6
stw %r3,4(%r5) ;# 4070 reload_outsi+2/6
L$0413
ldw 0(%r5),%r26 ;# 4077 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 4081 call_value_internal_symref
ldw 4(%r5),%r25 ;# 4079 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 4089 bleu+1
stw %r28,0(%r5) ;# 4085 reload_outsi+2/6
comb,= %r28,%r4,L$0406 ;# 4099 bleu+1
sub %r6,%r4,%r19 ;# 4101 subsi3/1
comib,= 0,%r10,L$0416 ;# 4110 bleu+1
addl %r28,%r19,%r6 ;# 4104 addsi3/1
sub %r10,%r4,%r19 ;# 4111 subsi3/1
addl %r28,%r19,%r10 ;# 4114 addsi3/1
L$0416
comib,= 0,%r8,L$0417 ;# 4117 bleu+1
sub %r8,%r4,%r19 ;# 4118 subsi3/1
addl %r28,%r19,%r8 ;# 4121 addsi3/1
L$0417
comib,= 0,%r9,L$0406 ;# 4124 bleu+1
sub %r9,%r4,%r19 ;# 4125 subsi3/1
addl %r28,%r19,%r9 ;# 4128 addsi3/1
L$0406
ldw 0(%r5),%r4 ;# 4029 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 4033 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 4030 subsi3/1
ldo 3(%r19),%r19 ;# 4031 addsi3/2
comb,<< %r20,%r19,L$0408
nop ;# 4035 bleu+1
L$0407
ldi 5,%r19 ;# 4150 movqi+1/2
stbs,ma %r19,1(%r6) ;# 4151 movqi+1/6
ldb -257(%r30),%r1 ;# 4156 movqi+1/5
stbs,ma %r1,1(%r6) ;# 8968 movqi+1/6
stbs,ma %r0,1(%r6) ;# 4159 movqi+1/6
L$0402
ldi 0,%r10 ;# 4182 reload_outsi+2/2
ldi 0,%r8 ;# 4185 reload_outsi+2/2
copy %r6,%r12 ;# 4188 reload_outsi+2/1
ldw -304(%r30),%r19 ;# 4174 reload_outsi+2/5
ldi 0,%r9 ;# 4191 reload_outsi+2/2
ldo 1(%r19),%r19 ;# 4175 addsi3/2
bl L$0043,%r0 ;# 4193 jump
stw %r19,-304(%r30) ;# 4179 reload_outsi+2/6
L$0422
bb,< %r15,18,L$0397 ;# 4201 bleu+3
ldw -304(%r30),%r19 ;# 4207 reload_outsi+2/5
comib,<>,n 0,%r19,L$0374 ;# 4209 bleu+1
bb,>=,n %r15,14,L$0950 ;# 4215 movsi-4
bl,n L$0397,%r0 ;# 4230 jump
L$0374
comib,=,n 0,%r10,L$0427 ;# 4237 bleu+1
ldw 0(%r5),%r4 ;# 8095 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8098 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8096 subsi3/1
ldo 1(%r19),%r19 ;# 8097 addsi3/2
comb,>>=,n %r20,%r19,L$0432 ;# 8099 bleu+1
ldil L'65536,%r3 ;# 8591 reload_outsi+2/3
L$0433
comb,= %r3,%r20,L$0944 ;# 4266 bleu+1
zdep %r20,30,31,%r19 ;# 4276 ashlsi3+1
comb,>>= %r3,%r19,L$0438 ;# 4284 bleu+1
stw %r19,4(%r5) ;# 4278 reload_outsi+2/6
stw %r3,4(%r5) ;# 4287 reload_outsi+2/6
L$0438
ldw 0(%r5),%r26 ;# 4294 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 4298 call_value_internal_symref
ldw 4(%r5),%r25 ;# 4296 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 4306 bleu+1
stw %r28,0(%r5) ;# 4302 reload_outsi+2/6
comb,= %r28,%r4,L$0431 ;# 4316 bleu+1
sub %r6,%r4,%r19 ;# 4318 subsi3/1
addl %r28,%r19,%r6 ;# 4321 addsi3/1
sub %r12,%r4,%r19 ;# 4322 subsi3/1
comib,= 0,%r10,L$0441 ;# 4327 bleu+1
addl %r28,%r19,%r12 ;# 4325 addsi3/1
sub %r10,%r4,%r19 ;# 4328 subsi3/1
addl %r28,%r19,%r10 ;# 4331 addsi3/1
L$0441
comib,= 0,%r8,L$0442 ;# 4334 bleu+1
sub %r8,%r4,%r19 ;# 4335 subsi3/1
addl %r28,%r19,%r8 ;# 4338 addsi3/1
L$0442
comib,= 0,%r9,L$0431 ;# 4341 bleu+1
sub %r9,%r4,%r19 ;# 4342 subsi3/1
addl %r28,%r19,%r9 ;# 4345 addsi3/1
L$0431
ldw 0(%r5),%r4 ;# 4246 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 4250 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 4247 subsi3/1
ldo 1(%r19),%r19 ;# 4248 addsi3/2
comb,<< %r20,%r19,L$0433
nop ;# 4252 bleu+1
L$0432
ldi 19,%r19 ;# 4367 movqi+1/2
stbs,ma %r19,1(%r6) ;# 4368 movqi+1/6
uaddcm %r6,%r10,%r24 ;# 4381 adddi3+1
ldi 13,%r26 ;# 4384 reload_outsi+2/2
copy %r10,%r25 ;# 4386 reload_outsi+2/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl store_op1,%r2 ;# 4390 call_internal_symref
ldo -3(%r24),%r24 ;# 4388 addsi3/2
L$0427
ldw -304(%r30),%r19 ;# 4395 reload_outsi+2/5
comib,<>,n 0,%r19,L$0447 ;# 4397 bleu+1
bb,<,n %r15,14,L$0076 ;# 4403 bleu+3
L$0950
.CALL ARGW0=GR
bl free,%r2 ;# 4414 call_internal_symref
ldw -312(%r30),%r26 ;# 4412 reload_outsi+2/5
bl L$0867,%r0 ;# 4418 jump
ldi 16,%r28 ;# 4416 reload_outsi+2/2
L$0447
ldo -1(%r19),%r19 ;# 4427 addsi3/2
stw %r19,-304(%r30) ;# 4431 reload_outsi+2/6
ldw -312(%r30),%r20 ;# 4436 reload_outsi+2/5
sh2addl %r19,%r19,%r19 ;# 4441 ashlsi3-2
sh2addl %r19,%r20,%r20 ;# 4444 ashlsi3-2
ldw 0(%r5),%r21 ;# 4446 reload_outsi+2/5
ldw 0(%r20),%r19 ;# 4448 reload_outsi+2/5
ldw 4(%r20),%r20 ;# 4464 reload_outsi+2/5
comib,= 0,%r20,L$0450 ;# 4466 bleu+1
addl %r21,%r19,%r12 ;# 4449 addsi3/1
addl %r21,%r20,%r19 ;# 4483 addsi3/1
bl L$0451,%r0 ;# 4485 jump
ldo -1(%r19),%r10 ;# 4484 addsi3/2
L$0450
ldi 0,%r10 ;# 4489 reload_outsi+2/2
L$0451
ldw -304(%r30),%r19 ;# 4493 reload_outsi+2/5
ldw -312(%r30),%r20 ;# 4495 reload_outsi+2/5
ldw 0(%r5),%r21 ;# 4505 reload_outsi+2/5
sh2addl %r19,%r19,%r19 ;# 4500 ashlsi3-2
sh2addl %r19,%r20,%r20 ;# 4503 ashlsi3-2
ldw 12(%r20),%r19 ;# 4507 reload_outsi+2/5
ldw 16(%r20),%r7 ;# 4523 reload_outsi+2/5
addl %r21,%r19,%r8 ;# 4508 addsi3/1
ldi 255,%r19 ;# 4529 reload_outsi+2/2
comb,<< %r19,%r7,L$0043 ;# 4531 bleu+1
ldi 0,%r9 ;# 4526 reload_outsi+2/2
ldw 8(%r20),%r19 ;# 4550 reload_outsi+2/5
ldw -260(%r30),%r1 ;# 8971 reload_outsi+2/5
addl %r21,%r19,%r19 ;# 4551 addsi3/1
sub %r1,%r7,%r20 ;# 4557 subsi3/1
stb %r20,0(%r19) ;# 4559 movqi+1/6
ldw 0(%r5),%r4 ;# 8103 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8106 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8104 subsi3/1
ldo 3(%r19),%r19 ;# 8105 addsi3/2
comb,>>=,n %r20,%r19,L$0457 ;# 8107 bleu+1
ldil L'65536,%r3 ;# 8589 reload_outsi+2/3
L$0458
comb,= %r3,%r20,L$0944 ;# 4587 bleu+1
zdep %r20,30,31,%r19 ;# 4597 ashlsi3+1
comb,>>= %r3,%r19,L$0463 ;# 4605 bleu+1
stw %r19,4(%r5) ;# 4599 reload_outsi+2/6
stw %r3,4(%r5) ;# 4608 reload_outsi+2/6
L$0463
ldw 0(%r5),%r26 ;# 4615 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 4619 call_value_internal_symref
ldw 4(%r5),%r25 ;# 4617 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 4627 bleu+1
stw %r28,0(%r5) ;# 4623 reload_outsi+2/6
comb,= %r28,%r4,L$0456 ;# 4637 bleu+1
sub %r6,%r4,%r19 ;# 4639 subsi3/1
addl %r28,%r19,%r6 ;# 4642 addsi3/1
sub %r12,%r4,%r19 ;# 4643 subsi3/1
comib,= 0,%r10,L$0466 ;# 4648 bleu+1
addl %r28,%r19,%r12 ;# 4646 addsi3/1
sub %r10,%r4,%r19 ;# 4649 subsi3/1
addl %r28,%r19,%r10 ;# 4652 addsi3/1
L$0466
comib,= 0,%r8,L$0467 ;# 4655 bleu+1
sub %r8,%r4,%r19 ;# 4656 subsi3/1
addl %r28,%r19,%r8 ;# 4659 addsi3/1
L$0467
comib,= 0,%r9,L$0456 ;# 4662 bleu+1
sub %r9,%r4,%r19 ;# 4663 subsi3/1
addl %r28,%r19,%r9 ;# 4666 addsi3/1
L$0456
ldw 0(%r5),%r4 ;# 4567 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 4571 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 4568 subsi3/1
ldo 3(%r19),%r19 ;# 4569 addsi3/2
comb,<< %r20,%r19,L$0458
nop ;# 4573 bleu+1
L$0457
ldi 6,%r19 ;# 4688 movqi+1/2
stbs,ma %r19,1(%r6) ;# 4689 movqi+1/6
stbs,ma %r7,1(%r6) ;# 4694 movqi+1/6
ldw -260(%r30),%r1 ;# 8974 reload_outsi+2/5
sub %r1,%r7,%r19 ;# 4700 subsi3/1
bl L$0043,%r0 ;# 4720 jump
stbs,ma %r19,1(%r6) ;# 4702 movqi+1/6
L$0472
ldo R'33792(%r19),%r19 ;# 4725 movhi-2
and %r15,%r19,%r19 ;# 4726 andsi3/1
comib,<>,n 0,%r19,L$0397 ;# 4728 bleu+1
L$0378
bb,<,n %r15,21,L$0076 ;# 4739 bleu+3
ldw 0(%r5),%r3 ;# 8111 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8114 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8112 subsi3/1
ldo 3(%r19),%r19 ;# 8113 addsi3/2
comb,>>=,n %r20,%r19,L$0476 ;# 8115 bleu+1
ldil L'65536,%r4 ;# 8587 reload_outsi+2/3
L$0477
comb,= %r4,%r20,L$0944 ;# 4768 bleu+1
zdep %r20,30,31,%r19 ;# 4778 ashlsi3+1
comb,>>= %r4,%r19,L$0482 ;# 4786 bleu+1
stw %r19,4(%r5) ;# 4780 reload_outsi+2/6
stw %r4,4(%r5) ;# 4789 reload_outsi+2/6
L$0482
ldw 0(%r5),%r26 ;# 4796 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 4800 call_value_internal_symref
ldw 4(%r5),%r25 ;# 4798 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 4808 bleu+1
stw %r28,0(%r5) ;# 4804 reload_outsi+2/6
comb,= %r28,%r3,L$0475 ;# 4818 bleu+1
sub %r6,%r3,%r19 ;# 4820 subsi3/1
addl %r28,%r19,%r6 ;# 4823 addsi3/1
sub %r12,%r3,%r19 ;# 4824 subsi3/1
comib,= 0,%r10,L$0485 ;# 4829 bleu+1
addl %r28,%r19,%r12 ;# 4827 addsi3/1
sub %r10,%r3,%r19 ;# 4830 subsi3/1
addl %r28,%r19,%r10 ;# 4833 addsi3/1
L$0485
comib,= 0,%r8,L$0486 ;# 4836 bleu+1
sub %r8,%r3,%r19 ;# 4837 subsi3/1
addl %r28,%r19,%r8 ;# 4840 addsi3/1
L$0486
comib,= 0,%r9,L$0475 ;# 4843 bleu+1
sub %r9,%r3,%r19 ;# 4844 subsi3/1
addl %r28,%r19,%r9 ;# 4847 addsi3/1
L$0475
ldw 0(%r5),%r3 ;# 4748 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 4752 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 4749 subsi3/1
ldo 3(%r19),%r19 ;# 4750 addsi3/2
comb,<< %r20,%r19,L$0477
nop ;# 4754 bleu+1
L$0476
ldi 14,%r26 ;# 4873 reload_outsi+2/2
copy %r12,%r25 ;# 4875 reload_outsi+2/1
sub %r6,%r25,%r24 ;# 4870 subsi3/1
ldo 3(%r24),%r24 ;# 4877 addsi3/2
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl insert_op1,%r2 ;# 4881 call_internal_symref
copy %r6,%r23 ;# 4879 reload_outsi+2/1
ldi 0,%r9 ;# 4884 reload_outsi+2/2
comib,= 0,%r10,L$0490 ;# 4889 bleu+1
ldo 3(%r6),%r6 ;# 4886 addsi3/2
ldi 13,%r26 ;# 4894 reload_outsi+2/2
copy %r10,%r25 ;# 4896 reload_outsi+2/1
sub %r6,%r25,%r24 ;# 4891 subsi3/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl store_op1,%r2 ;# 4900 call_internal_symref
ldo -3(%r24),%r24 ;# 4898 addsi3/2
L$0490
ldw 0(%r5),%r3 ;# 8119 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8122 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8120 subsi3/1
ldo 3(%r19),%r19 ;# 8121 addsi3/2
comb,>>= %r20,%r19,L$0492 ;# 8123 bleu+1
copy %r6,%r10 ;# 4904 reload_outsi+2/1
ldil L'65536,%r4 ;# 8585 reload_outsi+2/3
L$0493
comb,= %r4,%r20,L$0944 ;# 4929 bleu+1
zdep %r20,30,31,%r19 ;# 4939 ashlsi3+1
comb,>>= %r4,%r19,L$0498 ;# 4947 bleu+1
stw %r19,4(%r5) ;# 4941 reload_outsi+2/6
stw %r4,4(%r5) ;# 4950 reload_outsi+2/6
L$0498
ldw 0(%r5),%r26 ;# 4957 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 4961 call_value_internal_symref
ldw 4(%r5),%r25 ;# 4959 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 4969 bleu+1
stw %r28,0(%r5) ;# 4965 reload_outsi+2/6
comb,= %r28,%r3,L$0491 ;# 4979 bleu+1
sub %r6,%r3,%r19 ;# 4981 subsi3/1
comib,= 0,%r10,L$0501 ;# 4990 bleu+1
addl %r28,%r19,%r6 ;# 4984 addsi3/1
sub %r10,%r3,%r19 ;# 4991 subsi3/1
addl %r28,%r19,%r10 ;# 4994 addsi3/1
L$0501
comib,= 0,%r8,L$0502 ;# 4997 bleu+1
sub %r8,%r3,%r19 ;# 4998 subsi3/1
addl %r28,%r19,%r8 ;# 5001 addsi3/1
L$0502
comib,= 0,%r9,L$0491 ;# 5004 bleu+1
sub %r9,%r3,%r19 ;# 5005 subsi3/1
addl %r28,%r19,%r9 ;# 5008 addsi3/1
L$0491
ldw 0(%r5),%r3 ;# 4909 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 4913 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 4910 subsi3/1
ldo 3(%r19),%r19 ;# 4911 addsi3/2
comb,<< %r20,%r19,L$0493
nop ;# 4915 bleu+1
L$0492
ldo 3(%r6),%r6 ;# 5030 addsi3/2
ldi 0,%r8 ;# 5033 reload_outsi+2/2
bl L$0043,%r0 ;# 5038 jump
copy %r6,%r12 ;# 5036 reload_outsi+2/1
L$0506
bb,>= %r15,22,L$0397 ;# 5046 movsi-4
ldi 4608,%r20 ;# 5048 reload_outsi+2/2
and %r15,%r20,%r19 ;# 5049 andsi3/1
comb,= %r20,%r19,L$0397 ;# 5053 bleu+1
ldw -296(%r30),%r20 ;# 5055 reload_outsi+2/5
ldw -276(%r30),%r1 ;# 8977 reload_outsi+2/5
ldo -2(%r20),%r19 ;# 5056 addsi3/2
comb,<> %r1,%r19,L$1175 ;# 5058 bleu+1
ldi -1,%r4 ;# 5074 reload_outsi+2/2
comb,=,n %r16,%r20,L$0397 ;# 5062 bleu+1
L$1174
ldw -296(%r30),%r20 ;# 5079 reload_outsi+2/5
L$1175
copy %r4,%r11 ;# 5076 reload_outsi+2/1
comb,<> %r16,%r20,L$0517 ;# 5085 bleu+1
ldo -1(%r20),%r23 ;# 5080 addsi3/2
bb,>=,n %r15,19,L$0915 ;# 5092 movsi-4
bl L$1182,%r0 ;# 5107 jump
stw %r23,-296(%r30) ;# 5968 reload_outsi+2/6
L$0517
ldo 1(%r20),%r19 ;# 5134 addsi3/2
stw %r19,-296(%r30) ;# 5136 reload_outsi+2/6
comib,= 0,%r14,L$0515 ;# 5143 bleu+1
ldb 0(%r20),%r7 ;# 5139 zero_extendqisi2/2
addl %r14,%r7,%r19 ;# 5144 addsi3/1
ldb 0(%r19),%r7 ;# 5147 zero_extendqisi2/2
L$0515
addil LR'__ctype-$global$,%r27 ;# 8257 pic2_lo_sum+1
ldw RR'__ctype-$global$(%r1),%r21 ;# 8259 reload_outsi+2/5
addl %r21,%r7,%r19 ;# 8260 addsi3/1
ldb 0(%r19),%r19 ;# 8261 movqi+1/5
bb,>= %r19,29,L$0513 ;# 8265 movsi-4
ldi 4,%r20 ;# 8263 reload_outsi+2/2
copy %r20,%r22 ;# 8583 reload_outsi+2/1
L$0522
comiclr,< -1,%r11,%r0 ;# 8128 movsicc+1/1
ldi 0,%r11
sh2addl %r11,%r11,%r19 ;# 5188 ashlsi3-2
sh1addl %r19,%r7,%r19 ;# 5191 ashlsi3-2
ldw -296(%r30),%r20 ;# 5194 reload_outsi+2/5
comb,= %r16,%r20,L$0513 ;# 5196 bleu+1
ldo -48(%r19),%r11 ;# 5192 addsi3/2
ldo 1(%r20),%r19 ;# 5215 addsi3/2
stw %r19,-296(%r30) ;# 5217 reload_outsi+2/6
comib,= 0,%r14,L$0520 ;# 5224 bleu+1
ldb 0(%r20),%r7 ;# 5220 zero_extendqisi2/2
addl %r14,%r7,%r19 ;# 5225 addsi3/1
ldb 0(%r19),%r7 ;# 5228 zero_extendqisi2/2
L$0520
addl %r21,%r7,%r19 ;# 5166 addsi3/1
ldb 0(%r19),%r19 ;# 5168 movqi+1/5
and %r19,%r22,%r19 ;# 5172 andsi3/1
comib,<> 0,%r19,L$0522
nop ;# 5174 bleu+1
L$0513
ldi 44,%r19 ;# 5252 reload_outsi+2/2
comb,<> %r19,%r7,L$0532 ;# 5254 bleu+1
ldw -296(%r30),%r20 ;# 5259 reload_outsi+2/5
comb,= %r16,%r20,L$0533 ;# 5261 bleu+1
ldo 1(%r20),%r19 ;# 5278 addsi3/2
stw %r19,-296(%r30) ;# 5280 reload_outsi+2/6
comib,= 0,%r14,L$0535 ;# 5287 bleu+1
ldb 0(%r20),%r7 ;# 5283 zero_extendqisi2/2
addl %r14,%r7,%r19 ;# 5288 addsi3/1
ldb 0(%r19),%r7 ;# 5291 zero_extendqisi2/2
L$0535
addil LR'__ctype-$global$,%r27 ;# 8269 pic2_lo_sum+1
ldw RR'__ctype-$global$(%r1),%r21 ;# 8271 reload_outsi+2/5
addl %r21,%r7,%r19 ;# 8272 addsi3/1
ldb 0(%r19),%r19 ;# 8273 movqi+1/5
bb,>= %r19,29,L$0533 ;# 8277 movsi-4
ldi 4,%r20 ;# 8275 reload_outsi+2/2
copy %r20,%r22 ;# 8578 reload_outsi+2/1
L$0542
comiclr,< -1,%r4,%r0 ;# 8132 movsicc+1/1
ldi 0,%r4
sh2addl %r4,%r4,%r19 ;# 5332 ashlsi3-2
sh1addl %r19,%r7,%r19 ;# 5335 ashlsi3-2
ldw -296(%r30),%r20 ;# 5338 reload_outsi+2/5
comb,= %r16,%r20,L$0533 ;# 5340 bleu+1
ldo -48(%r19),%r4 ;# 5336 addsi3/2
ldo 1(%r20),%r19 ;# 5359 addsi3/2
stw %r19,-296(%r30) ;# 5361 reload_outsi+2/6
comib,= 0,%r14,L$0540 ;# 5368 bleu+1
ldb 0(%r20),%r7 ;# 5364 zero_extendqisi2/2
addl %r14,%r7,%r19 ;# 5369 addsi3/1
ldb 0(%r19),%r7 ;# 5372 zero_extendqisi2/2
L$0540
addl %r21,%r7,%r19 ;# 5310 addsi3/1
ldb 0(%r19),%r19 ;# 5312 movqi+1/5
and %r19,%r22,%r19 ;# 5316 andsi3/1
comib,<> 0,%r19,L$0542
nop ;# 5318 bleu+1
L$0533
comiclr,< -1,%r4,%r0 ;# 8136 beq-1/4
zdepi -1,31,15,%r4
bl,n L$0553,%r0 ;# 5401 jump
L$0532
copy %r11,%r4 ;# 5406 reload_outsi+2/1
L$0553
comib,> 0,%r11,L$0951 ;# 5410 bleu+1
zdepi -1,31,15,%r19 ;# 5412 reload_outsi+2/4
comb,<,n %r19,%r4,L$0951 ;# 5414 bleu+1
comb,<,n %r4,%r11,L$0951 ;# 5416 bleu+1
bb,< %r15,19,L$1176 ;# 5451 bleu+3
ldi 125,%r19 ;# 5514 reload_outsi+2/2
ldi 92,%r19 ;# 5455 reload_outsi+2/2
comb,<> %r19,%r7,L$0915 ;# 5457 bleu+1
ldw -296(%r30),%r20 ;# 5473 reload_outsi+2/5
comb,= %r16,%r20,L$0922 ;# 5475 bleu+1
ldo 1(%r20),%r19 ;# 5484 addsi3/2
stw %r19,-296(%r30) ;# 5486 reload_outsi+2/6
comib,= 0,%r14,L$0558 ;# 5493 bleu+1
ldb 0(%r20),%r7 ;# 5489 zero_extendqisi2/2
addl %r14,%r7,%r19 ;# 5494 addsi3/1
ldb 0(%r19),%r7 ;# 5497 zero_extendqisi2/2
L$0558
ldi 125,%r19 ;# 5514 reload_outsi+2/2
L$1176
comb,=,n %r19,%r7,L$0566 ;# 5516 bleu+1
L$0951
bb,<,n %r15,19,L$0511 ;# 5523 bleu+3
.CALL ARGW0=GR
bl free,%r2 ;# 5534 call_internal_symref
ldw -312(%r30),%r26 ;# 5532 reload_outsi+2/5
bl L$0867,%r0 ;# 5538 jump
ldi 10,%r28 ;# 5536 reload_outsi+2/2
L$0566
comib,<>,n 0,%r8,L$0569 ;# 5545 bleu+1
bb,<,n %r15,26,L$0917 ;# 5552 bleu+3
bb,>=,n %r15,27,L$0511 ;# 5571 movsi-4
copy %r6,%r8 ;# 5574 reload_outsi+2/1
L$0569
comib,<> 0,%r4,L$0574 ;# 5587 bleu+1
ldi 10,%r13 ;# 8980 reload_outsi+2/2
ldw 0(%r5),%r3 ;# 8139 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8142 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8140 subsi3/1
ldo 3(%r19),%r19 ;# 8141 addsi3/2
comb,>>=,n %r20,%r19,L$0576 ;# 8143 bleu+1
ldil L'65536,%r4 ;# 8573 reload_outsi+2/3
L$0577
comb,= %r4,%r20,L$0944 ;# 5613 bleu+1
zdep %r20,30,31,%r19 ;# 5623 ashlsi3+1
comb,>>= %r4,%r19,L$0582 ;# 5631 bleu+1
stw %r19,4(%r5) ;# 5625 reload_outsi+2/6
stw %r4,4(%r5) ;# 5634 reload_outsi+2/6
L$0582
ldw 0(%r5),%r26 ;# 5641 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 5645 call_value_internal_symref
ldw 4(%r5),%r25 ;# 5643 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 5653 bleu+1
stw %r28,0(%r5) ;# 5649 reload_outsi+2/6
comb,= %r28,%r3,L$0575 ;# 5663 bleu+1
sub %r6,%r3,%r19 ;# 5665 subsi3/1
addl %r28,%r19,%r6 ;# 5668 addsi3/1
sub %r12,%r3,%r19 ;# 5669 subsi3/1
comib,= 0,%r10,L$0585 ;# 5674 bleu+1
addl %r28,%r19,%r12 ;# 5672 addsi3/1
sub %r10,%r3,%r19 ;# 5675 subsi3/1
addl %r28,%r19,%r10 ;# 5678 addsi3/1
L$0585
comib,= 0,%r8,L$0586 ;# 5681 bleu+1
sub %r8,%r3,%r19 ;# 5682 subsi3/1
addl %r28,%r19,%r8 ;# 5685 addsi3/1
L$0586
comib,= 0,%r9,L$0575 ;# 5688 bleu+1
sub %r9,%r3,%r19 ;# 5689 subsi3/1
addl %r28,%r19,%r9 ;# 5692 addsi3/1
L$0575
ldw 0(%r5),%r3 ;# 5593 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 5597 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 5594 subsi3/1
ldo 3(%r19),%r19 ;# 5595 addsi3/2
comb,<< %r20,%r19,L$0577
nop ;# 5599 bleu+1
L$0576
ldi 12,%r26 ;# 5718 reload_outsi+2/2
copy %r8,%r25 ;# 5720 reload_outsi+2/1
sub %r6,%r8,%r24 ;# 5722 subsi3/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl insert_op1,%r2 ;# 5726 call_internal_symref
copy %r6,%r23 ;# 5724 reload_outsi+2/1
bl L$0590,%r0 ;# 5730 jump
ldo 3(%r6),%r6 ;# 5728 addsi3/2
L$0574
comiclr,> 2,%r4,%r0 ;# 8282 beq-1/2
ldi 20,%r13
ldw 0(%r5),%r3 ;# 8285 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8288 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 8286 subsi3/1
addl %r19,%r13,%r19 ;# 8287 addsi3/1
comb,>>=,n %r20,%r19,L$0868 ;# 8289 bleu+1
ldil L'65536,%r7 ;# 8571 reload_outsi+2/3
L$0595
comb,= %r7,%r20,L$0944 ;# 5769 bleu+1
zdep %r20,30,31,%r19 ;# 5779 ashlsi3+1
comb,>>= %r7,%r19,L$0600 ;# 5787 bleu+1
stw %r19,4(%r5) ;# 5781 reload_outsi+2/6
stw %r7,4(%r5) ;# 5790 reload_outsi+2/6
L$0600
ldw 0(%r5),%r26 ;# 5797 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 5801 call_value_internal_symref
ldw 4(%r5),%r25 ;# 5799 reload_outsi+2/5
comib,= 0,%r28,L$0953 ;# 5809 bleu+1
stw %r28,0(%r5) ;# 5805 reload_outsi+2/6
comb,= %r28,%r3,L$0593 ;# 5819 bleu+1
sub %r6,%r3,%r19 ;# 5821 subsi3/1
addl %r28,%r19,%r6 ;# 5824 addsi3/1
sub %r12,%r3,%r19 ;# 5825 subsi3/1
comib,= 0,%r10,L$0603 ;# 5830 bleu+1
addl %r28,%r19,%r12 ;# 5828 addsi3/1
sub %r10,%r3,%r19 ;# 5831 subsi3/1
addl %r28,%r19,%r10 ;# 5834 addsi3/1
L$0603
comib,= 0,%r8,L$0604 ;# 5837 bleu+1
sub %r8,%r3,%r19 ;# 5838 subsi3/1
addl %r28,%r19,%r8 ;# 5841 addsi3/1
L$0604
comib,= 0,%r9,L$0593 ;# 5844 bleu+1
sub %r9,%r3,%r19 ;# 5845 subsi3/1
addl %r28,%r19,%r9 ;# 5848 addsi3/1
L$0593
ldw 0(%r5),%r3 ;# 5749 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 5753 reload_outsi+2/5
sub %r6,%r3,%r19 ;# 5750 subsi3/1
addl %r19,%r13,%r19 ;# 5751 addsi3/1
comb,<< %r20,%r19,L$0595
nop ;# 5755 bleu+1
L$0868
comib,>= 1,%r4,L$0608 ;# 5872 bleu+1
ldo 5(%r6),%r19 ;# 5870 addsi3/2
sub %r19,%r8,%r19 ;# 5874 subsi3/1
bl L$0609,%r0 ;# 5876 jump
ldo 2(%r19),%r24 ;# 5875 addsi3/2
L$0608
sub %r19,%r8,%r19 ;# 5879 subsi3/1
ldo -3(%r19),%r24 ;# 5880 addsi3/2
L$0609
ldi 20,%r26 ;# 5885 reload_outsi+2/2
copy %r8,%r25 ;# 5887 reload_outsi+2/1
copy %r11,%r23 ;# 5891 reload_outsi+2/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl insert_op2,%r2 ;# 5893 call_internal_symref
stw %r6,-52(%r30) ;# 5883 reload_outsi+2/6
ldo 5(%r6),%r6 ;# 5895 addsi3/2
ldi 22,%r26 ;# 5900 reload_outsi+2/2
copy %r8,%r25 ;# 5902 reload_outsi+2/1
ldi 5,%r24 ;# 5904 reload_outsi+2/2
copy %r11,%r23 ;# 5906 reload_outsi+2/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl insert_op2,%r2 ;# 5908 call_internal_symref
stw %r6,-52(%r30) ;# 5898 reload_outsi+2/6
comib,>= 1,%r4,L$0590 ;# 5913 bleu+1
ldo 5(%r6),%r6 ;# 5910 addsi3/2
ldi 21,%r26 ;# 5921 reload_outsi+2/2
copy %r6,%r25 ;# 5923 reload_outsi+2/1
sub %r8,%r6,%r24 ;# 5917 subsi3/1
ldo 2(%r24),%r24 ;# 5925 addsi3/2
ldo -1(%r4),%r4 ;# 5919 addsi3/2
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl store_op2,%r2 ;# 5929 call_internal_symref
copy %r4,%r23 ;# 5927 reload_outsi+2/1
ldo 5(%r6),%r6 ;# 5931 addsi3/2
stw %r6,-52(%r30) ;# 5936 reload_outsi+2/6
ldi 22,%r26 ;# 5938 reload_outsi+2/2
copy %r8,%r25 ;# 5940 reload_outsi+2/1
sub %r6,%r8,%r24 ;# 5942 subsi3/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl insert_op2,%r2 ;# 5946 call_internal_symref
copy %r4,%r23 ;# 5944 reload_outsi+2/1
ldo 5(%r6),%r6 ;# 5948 addsi3/2
L$0590
bl L$0043,%r0 ;# 5963 jump
ldi 0,%r9 ;# 5956 reload_outsi+2/2
L$0511
stw %r23,-296(%r30) ;# 5968 reload_outsi+2/6
L$1182
ldw -296(%r30),%r20 ;# 5977 reload_outsi+2/5
comb,= %r16,%r20,L$0922 ;# 5979 bleu+1
ldo 1(%r20),%r21 ;# 5988 addsi3/2
ldb 0(%r20),%r20 ;# 5992 movqi+1/5
stw %r21,-296(%r30) ;# 5990 reload_outsi+2/6
comib,= 0,%r14,L$0612 ;# 5997 bleu+1
extru %r20,31,8,%r7 ;# 5993 zero_extendqisi2/1
addl %r14,%r7,%r19 ;# 5998 addsi3/1
ldb 0(%r19),%r7 ;# 6001 zero_extendqisi2/2
L$0612
bb,< %r15,19,L$0076 ;# 6019 bleu+3
ldw -276(%r30),%r1 ;# 8983 reload_outsi+2/5
comb,>>= %r1,%r21,L$0076 ;# 6025 bleu+1
extrs %r20,31,8,%r20 ;# 6030 extendqisi2
ldi 92,%r19 ;# 6032 reload_outsi+2/2
comb,=,n %r19,%r20,L$0397 ;# 6034 bleu+1
bl,n L$0076,%r0 ;# 6042 jump
L$0619
ldw 4(%r5),%r20 ;# 8151 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8149 subsi3/1
ldo 1(%r19),%r19 ;# 8150 addsi3/2
comb,>>= %r20,%r19,L$0624 ;# 8152 bleu+1
copy %r6,%r8 ;# 6047 reload_outsi+2/1
ldil L'65536,%r3 ;# 8569 reload_outsi+2/3
L$0625
comb,= %r3,%r20,L$0944 ;# 6075 bleu+1
zdep %r20,30,31,%r19 ;# 6085 ashlsi3+1
comb,>>= %r3,%r19,L$0630 ;# 6093 bleu+1
stw %r19,4(%r5) ;# 6087 reload_outsi+2/6
stw %r3,4(%r5) ;# 6096 reload_outsi+2/6
L$0630
ldw 0(%r5),%r26 ;# 6103 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 6107 call_value_internal_symref
ldw 4(%r5),%r25 ;# 6105 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 6115 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 6111 reload_outsi+2/6
comb,= %r28,%r4,L$0623 ;# 6125 bleu+1
sub %r6,%r4,%r19 ;# 6127 subsi3/1
addl %r28,%r19,%r6 ;# 6130 addsi3/1
sub %r12,%r4,%r19 ;# 6131 subsi3/1
comib,= 0,%r10,L$0633 ;# 6136 bleu+1
addl %r28,%r19,%r12 ;# 6134 addsi3/1
sub %r10,%r4,%r19 ;# 6137 subsi3/1
addl %r28,%r19,%r10 ;# 6140 addsi3/1
L$0633
comib,= 0,%r8,L$0634 ;# 6143 bleu+1
sub %r8,%r4,%r19 ;# 6144 subsi3/1
addl %r28,%r19,%r8 ;# 6147 addsi3/1
L$0634
comib,= 0,%r9,L$0623 ;# 6150 bleu+1
sub %r9,%r4,%r19 ;# 6151 subsi3/1
addl %r28,%r19,%r9 ;# 6154 addsi3/1
L$0623
ldw 0(%r5),%r4 ;# 6055 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 6059 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 6056 subsi3/1
ldo 1(%r19),%r19 ;# 6057 addsi3/2
comb,<< %r20,%r19,L$0625
nop ;# 6061 bleu+1
L$0624
ldi 23,%r19 ;# 6176 movqi+1/2
bl L$0043,%r0 ;# 6189 jump
stbs,ma %r19,1(%r6) ;# 6177 movqi+1/6
L$0639
ldw 4(%r5),%r20 ;# 8159 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8157 subsi3/1
ldo 1(%r19),%r19 ;# 8158 addsi3/2
comb,>>= %r20,%r19,L$0644 ;# 8160 bleu+1
copy %r6,%r8 ;# 6194 reload_outsi+2/1
ldil L'65536,%r3 ;# 8567 reload_outsi+2/3
L$0645
comb,= %r3,%r20,L$0944 ;# 6222 bleu+1
zdep %r20,30,31,%r19 ;# 6232 ashlsi3+1
comb,>>= %r3,%r19,L$0650 ;# 6240 bleu+1
stw %r19,4(%r5) ;# 6234 reload_outsi+2/6
stw %r3,4(%r5) ;# 6243 reload_outsi+2/6
L$0650
ldw 0(%r5),%r26 ;# 6250 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 6254 call_value_internal_symref
ldw 4(%r5),%r25 ;# 6252 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 6262 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 6258 reload_outsi+2/6
comb,= %r28,%r4,L$0643 ;# 6272 bleu+1
sub %r6,%r4,%r19 ;# 6274 subsi3/1
addl %r28,%r19,%r6 ;# 6277 addsi3/1
sub %r12,%r4,%r19 ;# 6278 subsi3/1
comib,= 0,%r10,L$0653 ;# 6283 bleu+1
addl %r28,%r19,%r12 ;# 6281 addsi3/1
sub %r10,%r4,%r19 ;# 6284 subsi3/1
addl %r28,%r19,%r10 ;# 6287 addsi3/1
L$0653
comib,= 0,%r8,L$0654 ;# 6290 bleu+1
sub %r8,%r4,%r19 ;# 6291 subsi3/1
addl %r28,%r19,%r8 ;# 6294 addsi3/1
L$0654
comib,= 0,%r9,L$0643 ;# 6297 bleu+1
sub %r9,%r4,%r19 ;# 6298 subsi3/1
addl %r28,%r19,%r9 ;# 6301 addsi3/1
L$0643
ldw 0(%r5),%r4 ;# 6202 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 6206 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 6203 subsi3/1
ldo 1(%r19),%r19 ;# 6204 addsi3/2
comb,<< %r20,%r19,L$0645
nop ;# 6208 bleu+1
L$0644
ldi 24,%r19 ;# 6323 movqi+1/2
bl L$0043,%r0 ;# 6336 jump
stbs,ma %r19,1(%r6) ;# 6324 movqi+1/6
L$0659
ldw 4(%r5),%r20 ;# 8167 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8165 subsi3/1
ldo 1(%r19),%r19 ;# 8166 addsi3/2
comb,>>=,n %r20,%r19,L$0664 ;# 8168 bleu+1
ldil L'65536,%r3 ;# 8565 reload_outsi+2/3
L$0665
comb,= %r3,%r20,L$0944 ;# 6366 bleu+1
zdep %r20,30,31,%r19 ;# 6376 ashlsi3+1
comb,>>= %r3,%r19,L$0670 ;# 6384 bleu+1
stw %r19,4(%r5) ;# 6378 reload_outsi+2/6
stw %r3,4(%r5) ;# 6387 reload_outsi+2/6
L$0670
ldw 0(%r5),%r26 ;# 6394 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 6398 call_value_internal_symref
ldw 4(%r5),%r25 ;# 6396 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 6406 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 6402 reload_outsi+2/6
comb,= %r28,%r4,L$0663 ;# 6416 bleu+1
sub %r6,%r4,%r19 ;# 6418 subsi3/1
addl %r28,%r19,%r6 ;# 6421 addsi3/1
sub %r12,%r4,%r19 ;# 6422 subsi3/1
comib,= 0,%r10,L$0673 ;# 6427 bleu+1
addl %r28,%r19,%r12 ;# 6425 addsi3/1
sub %r10,%r4,%r19 ;# 6428 subsi3/1
addl %r28,%r19,%r10 ;# 6431 addsi3/1
L$0673
comib,= 0,%r8,L$0674 ;# 6434 bleu+1
sub %r8,%r4,%r19 ;# 6435 subsi3/1
addl %r28,%r19,%r8 ;# 6438 addsi3/1
L$0674
comib,= 0,%r9,L$0663 ;# 6441 bleu+1
sub %r9,%r4,%r19 ;# 6442 subsi3/1
addl %r28,%r19,%r9 ;# 6445 addsi3/1
L$0663
ldw 0(%r5),%r4 ;# 6346 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 6350 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 6347 subsi3/1
ldo 1(%r19),%r19 ;# 6348 addsi3/2
comb,<< %r20,%r19,L$0665
nop ;# 6352 bleu+1
L$0664
ldi 25,%r19 ;# 6467 movqi+1/2
bl L$0043,%r0 ;# 6480 jump
stbs,ma %r19,1(%r6) ;# 6468 movqi+1/6
L$0679
ldw 4(%r5),%r20 ;# 8175 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8173 subsi3/1
ldo 1(%r19),%r19 ;# 8174 addsi3/2
comb,>>=,n %r20,%r19,L$0684 ;# 8176 bleu+1
ldil L'65536,%r3 ;# 8563 reload_outsi+2/3
L$0685
comb,= %r3,%r20,L$0944 ;# 6510 bleu+1
zdep %r20,30,31,%r19 ;# 6520 ashlsi3+1
comb,>>= %r3,%r19,L$0690 ;# 6528 bleu+1
stw %r19,4(%r5) ;# 6522 reload_outsi+2/6
stw %r3,4(%r5) ;# 6531 reload_outsi+2/6
L$0690
ldw 0(%r5),%r26 ;# 6538 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 6542 call_value_internal_symref
ldw 4(%r5),%r25 ;# 6540 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 6550 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 6546 reload_outsi+2/6
comb,= %r28,%r4,L$0683 ;# 6560 bleu+1
sub %r6,%r4,%r19 ;# 6562 subsi3/1
addl %r28,%r19,%r6 ;# 6565 addsi3/1
sub %r12,%r4,%r19 ;# 6566 subsi3/1
comib,= 0,%r10,L$0693 ;# 6571 bleu+1
addl %r28,%r19,%r12 ;# 6569 addsi3/1
sub %r10,%r4,%r19 ;# 6572 subsi3/1
addl %r28,%r19,%r10 ;# 6575 addsi3/1
L$0693
comib,= 0,%r8,L$0694 ;# 6578 bleu+1
sub %r8,%r4,%r19 ;# 6579 subsi3/1
addl %r28,%r19,%r8 ;# 6582 addsi3/1
L$0694
comib,= 0,%r9,L$0683 ;# 6585 bleu+1
sub %r9,%r4,%r19 ;# 6586 subsi3/1
addl %r28,%r19,%r9 ;# 6589 addsi3/1
L$0683
ldw 0(%r5),%r4 ;# 6490 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 6494 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 6491 subsi3/1
ldo 1(%r19),%r19 ;# 6492 addsi3/2
comb,<< %r20,%r19,L$0685
nop ;# 6496 bleu+1
L$0684
ldi 26,%r19 ;# 6611 movqi+1/2
bl L$0043,%r0 ;# 6624 jump
stbs,ma %r19,1(%r6) ;# 6612 movqi+1/6
L$0699
ldw 4(%r5),%r20 ;# 8183 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8181 subsi3/1
ldo 1(%r19),%r19 ;# 8182 addsi3/2
comb,>>=,n %r20,%r19,L$0704 ;# 8184 bleu+1
ldil L'65536,%r3 ;# 8561 reload_outsi+2/3
L$0705
comb,= %r3,%r20,L$0944 ;# 6654 bleu+1
zdep %r20,30,31,%r19 ;# 6664 ashlsi3+1
comb,>>= %r3,%r19,L$0710 ;# 6672 bleu+1
stw %r19,4(%r5) ;# 6666 reload_outsi+2/6
stw %r3,4(%r5) ;# 6675 reload_outsi+2/6
L$0710
ldw 0(%r5),%r26 ;# 6682 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 6686 call_value_internal_symref
ldw 4(%r5),%r25 ;# 6684 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 6694 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 6690 reload_outsi+2/6
comb,= %r28,%r4,L$0703 ;# 6704 bleu+1
sub %r6,%r4,%r19 ;# 6706 subsi3/1
addl %r28,%r19,%r6 ;# 6709 addsi3/1
sub %r12,%r4,%r19 ;# 6710 subsi3/1
comib,= 0,%r10,L$0713 ;# 6715 bleu+1
addl %r28,%r19,%r12 ;# 6713 addsi3/1
sub %r10,%r4,%r19 ;# 6716 subsi3/1
addl %r28,%r19,%r10 ;# 6719 addsi3/1
L$0713
comib,= 0,%r8,L$0714 ;# 6722 bleu+1
sub %r8,%r4,%r19 ;# 6723 subsi3/1
addl %r28,%r19,%r8 ;# 6726 addsi3/1
L$0714
comib,= 0,%r9,L$0703 ;# 6729 bleu+1
sub %r9,%r4,%r19 ;# 6730 subsi3/1
addl %r28,%r19,%r9 ;# 6733 addsi3/1
L$0703
ldw 0(%r5),%r4 ;# 6634 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 6638 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 6635 subsi3/1
ldo 1(%r19),%r19 ;# 6636 addsi3/2
comb,<< %r20,%r19,L$0705
nop ;# 6640 bleu+1
L$0704
ldi 27,%r19 ;# 6755 movqi+1/2
bl L$0043,%r0 ;# 6768 jump
stbs,ma %r19,1(%r6) ;# 6756 movqi+1/6
L$0719
ldw 4(%r5),%r20 ;# 8191 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8189 subsi3/1
ldo 1(%r19),%r19 ;# 8190 addsi3/2
comb,>>=,n %r20,%r19,L$0724 ;# 8192 bleu+1
ldil L'65536,%r3 ;# 8559 reload_outsi+2/3
L$0725
comb,= %r3,%r20,L$0944 ;# 6798 bleu+1
zdep %r20,30,31,%r19 ;# 6808 ashlsi3+1
comb,>>= %r3,%r19,L$0730 ;# 6816 bleu+1
stw %r19,4(%r5) ;# 6810 reload_outsi+2/6
stw %r3,4(%r5) ;# 6819 reload_outsi+2/6
L$0730
ldw 0(%r5),%r26 ;# 6826 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 6830 call_value_internal_symref
ldw 4(%r5),%r25 ;# 6828 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 6838 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 6834 reload_outsi+2/6
comb,= %r28,%r4,L$0723 ;# 6848 bleu+1
sub %r6,%r4,%r19 ;# 6850 subsi3/1
addl %r28,%r19,%r6 ;# 6853 addsi3/1
sub %r12,%r4,%r19 ;# 6854 subsi3/1
comib,= 0,%r10,L$0733 ;# 6859 bleu+1
addl %r28,%r19,%r12 ;# 6857 addsi3/1
sub %r10,%r4,%r19 ;# 6860 subsi3/1
addl %r28,%r19,%r10 ;# 6863 addsi3/1
L$0733
comib,= 0,%r8,L$0734 ;# 6866 bleu+1
sub %r8,%r4,%r19 ;# 6867 subsi3/1
addl %r28,%r19,%r8 ;# 6870 addsi3/1
L$0734
comib,= 0,%r9,L$0723 ;# 6873 bleu+1
sub %r9,%r4,%r19 ;# 6874 subsi3/1
addl %r28,%r19,%r9 ;# 6877 addsi3/1
L$0723
ldw 0(%r5),%r4 ;# 6778 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 6782 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 6779 subsi3/1
ldo 1(%r19),%r19 ;# 6780 addsi3/2
comb,<< %r20,%r19,L$0725
nop ;# 6784 bleu+1
L$0724
ldi 28,%r19 ;# 6899 movqi+1/2
bl L$0043,%r0 ;# 6912 jump
stbs,ma %r19,1(%r6) ;# 6900 movqi+1/6
L$0739
ldw 4(%r5),%r20 ;# 8199 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8197 subsi3/1
ldo 1(%r19),%r19 ;# 8198 addsi3/2
comb,>>=,n %r20,%r19,L$0744 ;# 8200 bleu+1
ldil L'65536,%r3 ;# 8557 reload_outsi+2/3
L$0745
comb,= %r3,%r20,L$0944 ;# 6942 bleu+1
zdep %r20,30,31,%r19 ;# 6952 ashlsi3+1
comb,>>= %r3,%r19,L$0750 ;# 6960 bleu+1
stw %r19,4(%r5) ;# 6954 reload_outsi+2/6
stw %r3,4(%r5) ;# 6963 reload_outsi+2/6
L$0750
ldw 0(%r5),%r26 ;# 6970 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 6974 call_value_internal_symref
ldw 4(%r5),%r25 ;# 6972 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 6982 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 6978 reload_outsi+2/6
comb,= %r28,%r4,L$0743 ;# 6992 bleu+1
sub %r6,%r4,%r19 ;# 6994 subsi3/1
addl %r28,%r19,%r6 ;# 6997 addsi3/1
sub %r12,%r4,%r19 ;# 6998 subsi3/1
comib,= 0,%r10,L$0753 ;# 7003 bleu+1
addl %r28,%r19,%r12 ;# 7001 addsi3/1
sub %r10,%r4,%r19 ;# 7004 subsi3/1
addl %r28,%r19,%r10 ;# 7007 addsi3/1
L$0753
comib,= 0,%r8,L$0754 ;# 7010 bleu+1
sub %r8,%r4,%r19 ;# 7011 subsi3/1
addl %r28,%r19,%r8 ;# 7014 addsi3/1
L$0754
comib,= 0,%r9,L$0743 ;# 7017 bleu+1
sub %r9,%r4,%r19 ;# 7018 subsi3/1
addl %r28,%r19,%r9 ;# 7021 addsi3/1
L$0743
ldw 0(%r5),%r4 ;# 6922 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 6926 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 6923 subsi3/1
ldo 1(%r19),%r19 ;# 6924 addsi3/2
comb,<< %r20,%r19,L$0745
nop ;# 6928 bleu+1
L$0744
ldi 10,%r19 ;# 7043 movqi+1/2
bl L$0043,%r0 ;# 7056 jump
stbs,ma %r19,1(%r6) ;# 7044 movqi+1/6
L$0759
ldw 4(%r5),%r20 ;# 8207 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8205 subsi3/1
ldo 1(%r19),%r19 ;# 8206 addsi3/2
comb,>>=,n %r20,%r19,L$0764 ;# 8208 bleu+1
ldil L'65536,%r3 ;# 8555 reload_outsi+2/3
L$0765
comb,= %r3,%r20,L$0944 ;# 7086 bleu+1
zdep %r20,30,31,%r19 ;# 7096 ashlsi3+1
comb,>>= %r3,%r19,L$0770 ;# 7104 bleu+1
stw %r19,4(%r5) ;# 7098 reload_outsi+2/6
stw %r3,4(%r5) ;# 7107 reload_outsi+2/6
L$0770
ldw 0(%r5),%r26 ;# 7114 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 7118 call_value_internal_symref
ldw 4(%r5),%r25 ;# 7116 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 7126 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 7122 reload_outsi+2/6
comb,= %r28,%r4,L$0763 ;# 7136 bleu+1
sub %r6,%r4,%r19 ;# 7138 subsi3/1
addl %r28,%r19,%r6 ;# 7141 addsi3/1
sub %r12,%r4,%r19 ;# 7142 subsi3/1
comib,= 0,%r10,L$0773 ;# 7147 bleu+1
addl %r28,%r19,%r12 ;# 7145 addsi3/1
sub %r10,%r4,%r19 ;# 7148 subsi3/1
addl %r28,%r19,%r10 ;# 7151 addsi3/1
L$0773
comib,= 0,%r8,L$0774 ;# 7154 bleu+1
sub %r8,%r4,%r19 ;# 7155 subsi3/1
addl %r28,%r19,%r8 ;# 7158 addsi3/1
L$0774
comib,= 0,%r9,L$0763 ;# 7161 bleu+1
sub %r9,%r4,%r19 ;# 7162 subsi3/1
addl %r28,%r19,%r9 ;# 7165 addsi3/1
L$0763
ldw 0(%r5),%r4 ;# 7066 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 7070 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 7067 subsi3/1
ldo 1(%r19),%r19 ;# 7068 addsi3/2
comb,<< %r20,%r19,L$0765
nop ;# 7072 bleu+1
L$0764
ldi 11,%r19 ;# 7187 movqi+1/2
bl L$0043,%r0 ;# 7200 jump
stbs,ma %r19,1(%r6) ;# 7188 movqi+1/6
L$0787
bb,< %r15,17,L$0076 ;# 7216 bleu+3
ldo -48(%r7),%r19 ;# 7224 addsi3/2
ldw -260(%r30),%r1 ;# 8986 reload_outsi+2/5
extru %r19,31,8,%r3 ;# 7225 zero_extendqisi2/1
comb,<< %r1,%r3,L$0939 ;# 7230 bleu+1
ldo -312(%r30),%r26 ;# 7244 addsi3/2
.CALL ARGW0=GR,ARGW1=GR
bl group_in_compile_stack,%r2 ;# 7248 call_value_internal_symref
copy %r3,%r25 ;# 7246 reload_outsi+2/1
extrs %r28,31,8,%r28 ;# 7251 extendqisi2
comib,<>,n 0,%r28,L$0076 ;# 7253 bleu+1
ldw 0(%r5),%r4 ;# 8212 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8215 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8213 subsi3/1
ldo 2(%r19),%r19 ;# 8214 addsi3/2
comb,>>= %r20,%r19,L$0795 ;# 8216 bleu+1
copy %r6,%r8 ;# 7260 reload_outsi+2/1
ldil L'65536,%r7 ;# 8553 reload_outsi+2/3
L$0796
comb,= %r7,%r20,L$0944 ;# 7288 bleu+1
zdep %r20,30,31,%r19 ;# 7298 ashlsi3+1
comb,>>= %r7,%r19,L$0801 ;# 7306 bleu+1
stw %r19,4(%r5) ;# 7300 reload_outsi+2/6
stw %r7,4(%r5) ;# 7309 reload_outsi+2/6
L$0801
ldw 0(%r5),%r26 ;# 7316 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 7320 call_value_internal_symref
ldw 4(%r5),%r25 ;# 7318 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 7328 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 7324 reload_outsi+2/6
comb,= %r28,%r4,L$0794 ;# 7338 bleu+1
sub %r6,%r4,%r19 ;# 7340 subsi3/1
addl %r28,%r19,%r6 ;# 7343 addsi3/1
sub %r12,%r4,%r19 ;# 7344 subsi3/1
comib,= 0,%r10,L$0804 ;# 7349 bleu+1
addl %r28,%r19,%r12 ;# 7347 addsi3/1
sub %r10,%r4,%r19 ;# 7350 subsi3/1
addl %r28,%r19,%r10 ;# 7353 addsi3/1
L$0804
comib,= 0,%r8,L$0805 ;# 7356 bleu+1
sub %r8,%r4,%r19 ;# 7357 subsi3/1
addl %r28,%r19,%r8 ;# 7360 addsi3/1
L$0805
comib,= 0,%r9,L$0794 ;# 7363 bleu+1
sub %r9,%r4,%r19 ;# 7364 subsi3/1
addl %r28,%r19,%r9 ;# 7367 addsi3/1
L$0794
ldw 0(%r5),%r4 ;# 7268 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 7272 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 7269 subsi3/1
ldo 2(%r19),%r19 ;# 7270 addsi3/2
comb,<< %r20,%r19,L$0796
nop ;# 7274 bleu+1
L$0795
ldi 7,%r19 ;# 7389 movqi+1/2
stbs,ma %r19,1(%r6) ;# 7390 movqi+1/6
bl L$0043,%r0 ;# 7405 jump
stbs,ma %r3,1(%r6) ;# 7393 movqi+1/6
L$0811
bb,< %r15,30,L$0104
nop ;# 7414 bleu+3
L$0397
comib,= 0,%r14,L$0815 ;# 7429 bleu+1
addl %r14,%r7,%r19 ;# 7430 addsi3/1
bl L$0816,%r0 ;# 7434 jump
ldb 0(%r19),%r19 ;# 7433 zero_extendqisi2/2
L$0815
copy %r7,%r19 ;# 7438 reload_outsi+2/1
L$0816
copy %r19,%r7 ;# 7441 reload_outsi+2/1
L$0076
comib,=,n 0,%r9,L$0820 ;# 7460 bleu+1
ldb 0(%r9),%r20 ;# 7463 zero_extendqisi2/2
addl %r9,%r20,%r19 ;# 7464 addsi3/1
ldo 1(%r19),%r19 ;# 7465 addsi3/2
comb,<> %r6,%r19,L$0820 ;# 7467 bleu+1
ldi 255,%r19 ;# 7472 reload_outsi+2/2
comb,= %r19,%r20,L$0820 ;# 7474 bleu+1
ldw -296(%r30),%r21 ;# 7476 reload_outsi+2/5
ldb 0(%r21),%r19 ;# 7478 movqi+1/5
extrs %r19,31,8,%r20 ;# 7479 extendqisi2
ldi 42,%r19 ;# 7481 reload_outsi+2/2
comb,= %r19,%r20,L$0820 ;# 7483 bleu+1
ldi 94,%r19 ;# 7490 reload_outsi+2/2
comb,=,n %r19,%r20,L$0820 ;# 7492 bleu+1
bb,>= %r15,30,L$0821 ;# 7497 movsi-4
ldi 92,%r19 ;# 7504 reload_outsi+2/2
comb,<>,n %r19,%r20,L$0822 ;# 7506 bleu+1
ldb 1(%r21),%r19 ;# 7510 movqi+1/5
extrs %r19,31,8,%r20 ;# 7511 extendqisi2
L$0821
ldi 43,%r19 ;# 7534 reload_outsi+2/2
comb,= %r19,%r20,L$0820 ;# 7536 bleu+1
ldi 63,%r19 ;# 7543 reload_outsi+2/2
comb,=,n %r19,%r20,L$0820 ;# 7545 bleu+1
L$0822
bb,>=,n %r15,22,L$0819 ;# 7553 movsi-4
bb,>= %r15,19,L$0823 ;# 7558 movsi-4
ldw -296(%r30),%r19 ;# 7560 reload_outsi+2/5
ldb 0(%r19),%r19 ;# 7562 movqi+1/5
ldi 123,%r20 ;# 7565 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 7563 extendqisi2
comb,=,n %r20,%r19,L$0820 ;# 7567 bleu+1
ldw 0(%r5),%r4 ;# 8228 reload_outsi+2/5
bl,n L$1177,%r0 ;# 7568 jump
L$0823
ldw -296(%r30),%r21 ;# 7572 reload_outsi+2/5
ldb 0(%r21),%r19 ;# 7574 movqi+1/5
ldi 92,%r20 ;# 7577 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 7575 extendqisi2
comb,<>,n %r20,%r19,L$0819 ;# 7579 bleu+1
ldb 1(%r21),%r19 ;# 7583 movqi+1/5
ldi 123,%r20 ;# 7586 reload_outsi+2/2
extrs %r19,31,8,%r19 ;# 7584 extendqisi2
comb,<>,n %r20,%r19,L$0819 ;# 7588 bleu+1
L$0820
ldw 0(%r5),%r4 ;# 8220 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 8223 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8221 subsi3/1
ldo 2(%r19),%r19 ;# 8222 addsi3/2
comb,>>= %r20,%r19,L$0829 ;# 8224 bleu+1
copy %r6,%r8 ;# 7596 reload_outsi+2/1
ldil L'65536,%r3 ;# 8551 reload_outsi+2/3
L$0830
comb,= %r3,%r20,L$0944 ;# 7624 bleu+1
zdep %r20,30,31,%r19 ;# 7634 ashlsi3+1
comb,>>= %r3,%r19,L$0835 ;# 7642 bleu+1
stw %r19,4(%r5) ;# 7636 reload_outsi+2/6
stw %r3,4(%r5) ;# 7645 reload_outsi+2/6
L$0835
ldw 0(%r5),%r26 ;# 7652 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 7656 call_value_internal_symref
ldw 4(%r5),%r25 ;# 7654 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 7664 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 7660 reload_outsi+2/6
comb,= %r28,%r4,L$0828 ;# 7674 bleu+1
sub %r6,%r4,%r19 ;# 7676 subsi3/1
addl %r28,%r19,%r6 ;# 7679 addsi3/1
sub %r12,%r4,%r19 ;# 7680 subsi3/1
comib,= 0,%r10,L$0838 ;# 7685 bleu+1
addl %r28,%r19,%r12 ;# 7683 addsi3/1
sub %r10,%r4,%r19 ;# 7686 subsi3/1
addl %r28,%r19,%r10 ;# 7689 addsi3/1
L$0838
comib,= 0,%r8,L$0839 ;# 7692 bleu+1
sub %r8,%r4,%r19 ;# 7693 subsi3/1
addl %r28,%r19,%r8 ;# 7696 addsi3/1
L$0839
comib,= 0,%r9,L$0828 ;# 7699 bleu+1
sub %r9,%r4,%r19 ;# 7700 subsi3/1
addl %r28,%r19,%r9 ;# 7703 addsi3/1
L$0828
ldw 0(%r5),%r4 ;# 7604 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 7608 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 7605 subsi3/1
ldo 2(%r19),%r19 ;# 7606 addsi3/2
comb,<< %r20,%r19,L$0830
nop ;# 7610 bleu+1
L$0829
ldi 1,%r19 ;# 7725 movqi+1/2
stbs,ma %r19,1(%r6) ;# 7726 movqi+1/6
stbs,ma %r0,1(%r6) ;# 7729 movqi+1/6
ldo -1(%r6),%r9 ;# 7741 addsi3/2
L$0819
ldw 0(%r5),%r4 ;# 8228 reload_outsi+2/5
L$1177
ldw 4(%r5),%r20 ;# 8231 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 8229 subsi3/1
ldo 1(%r19),%r19 ;# 8230 addsi3/2
comb,>>=,n %r20,%r19,L$0848 ;# 8232 bleu+1
ldil L'65536,%r3 ;# 8549 reload_outsi+2/3
L$0849
comb,= %r3,%r20,L$0944 ;# 7771 bleu+1
zdep %r20,30,31,%r19 ;# 7781 ashlsi3+1
comb,>>= %r3,%r19,L$0854 ;# 7789 bleu+1
stw %r19,4(%r5) ;# 7783 reload_outsi+2/6
stw %r3,4(%r5) ;# 7792 reload_outsi+2/6
L$0854
ldw 0(%r5),%r26 ;# 7799 reload_outsi+2/5
.CALL ARGW0=GR,ARGW1=GR
bl realloc,%r2 ;# 7803 call_value_internal_symref
ldw 4(%r5),%r25 ;# 7801 reload_outsi+2/5
comiclr,<> 0,%r28,%r0 ;# 7811 bleu+1
bl L$0953,%r0
stw %r28,0(%r5) ;# 7807 reload_outsi+2/6
comb,= %r28,%r4,L$0847 ;# 7821 bleu+1
sub %r6,%r4,%r19 ;# 7823 subsi3/1
addl %r28,%r19,%r6 ;# 7826 addsi3/1
sub %r12,%r4,%r19 ;# 7827 subsi3/1
comib,= 0,%r10,L$0857 ;# 7832 bleu+1
addl %r28,%r19,%r12 ;# 7830 addsi3/1
sub %r10,%r4,%r19 ;# 7833 subsi3/1
addl %r28,%r19,%r10 ;# 7836 addsi3/1
L$0857
comib,= 0,%r8,L$0858 ;# 7839 bleu+1
sub %r8,%r4,%r19 ;# 7840 subsi3/1
addl %r28,%r19,%r8 ;# 7843 addsi3/1
L$0858
comib,= 0,%r9,L$0847 ;# 7846 bleu+1
sub %r9,%r4,%r19 ;# 7847 subsi3/1
addl %r28,%r19,%r9 ;# 7850 addsi3/1
L$0847
ldw 0(%r5),%r4 ;# 7751 reload_outsi+2/5
ldw 4(%r5),%r20 ;# 7755 reload_outsi+2/5
sub %r6,%r4,%r19 ;# 7752 subsi3/1
ldo 1(%r19),%r19 ;# 7753 addsi3/2
comb,<< %r20,%r19,L$0849
nop ;# 7757 bleu+1
L$0848
stbs,ma %r7,1(%r6) ;# 7872 movqi+1/6
ldb 0(%r9),%r19 ;# 7885 movqi+1/5
ldo 1(%r19),%r19 ;# 7888 addsi3/2
stb %r19,0(%r9) ;# 7890 movqi+1/6
L$0043
ldw -296(%r30),%r19 ;# 2328 reload_outsi+2/5
L$1161
comclr,= %r16,%r19,%r0 ;# 258 bleu+1
bl L$1178,%r0
ldw -296(%r30),%r19 ;# 2334 reload_outsi+2/5
L$0044
comib,= 0,%r10,L$0865 ;# 7913 bleu+1
ldi 13,%r26 ;# 7918 reload_outsi+2/2
copy %r10,%r25 ;# 7920 reload_outsi+2/1
sub %r6,%r25,%r24 ;# 7915 subsi3/1
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl store_op1,%r2 ;# 7924 call_internal_symref
ldo -3(%r24),%r24 ;# 7922 addsi3/2
L$0865
ldw -304(%r30),%r19 ;# 7928 reload_outsi+2/5
comib,<>,n 0,%r19,L$0866 ;# 7930 bleu+1
.CALL ARGW0=GR
bl free,%r2 ;# 7946 call_internal_symref
ldw -312(%r30),%r26 ;# 7944 reload_outsi+2/5
ldw 0(%r5),%r19 ;# 7949 reload_outsi+2/5
ldi 0,%r28 ;# 7955 reload_outsi+2/2
sub %r6,%r19,%r19 ;# 7950 subsi3/1
bl L$0867,%r0 ;# 7957 jump
stw %r19,8(%r5) ;# 7952 reload_outsi+2/6
L$0895
.CALL ARGW0=GR
bl free,%r2 ;# 2269 call_internal_symref
ldw -312(%r30),%r26 ;# 2267 reload_outsi+2/5
bl L$0867,%r0 ;# 2273 jump
ldi 11,%r28 ;# 2271 reload_outsi+2/2
L$0900
.CALL ARGW0=GR
bl free,%r2 ;# 3161 call_internal_symref
ldw -312(%r30),%r26 ;# 3159 reload_outsi+2/5
bl L$0867,%r0 ;# 3165 jump
ldi 4,%r28 ;# 3163 reload_outsi+2/2
L$0902
.CALL ARGW0=GR
bl free,%r2 ;# 3218 call_internal_symref
ldw -312(%r30),%r26 ;# 3216 reload_outsi+2/5
bl L$0867,%r0 ;# 3222 jump
ldi 7,%r28 ;# 3220 reload_outsi+2/2
L$0903
.CALL ARGW0=GR
bl free,%r2 ;# 3803 call_internal_symref
ldw -312(%r30),%r26 ;# 3801 reload_outsi+2/5
bl L$0867,%r0 ;# 3807 jump
ldi 5,%r28 ;# 3805 reload_outsi+2/2
L$0915
.CALL ARGW0=GR
bl free,%r2 ;# 5461 call_internal_symref
ldw -312(%r30),%r26 ;# 5459 reload_outsi+2/5
bl L$0867,%r0 ;# 5465 jump
ldi 9,%r28 ;# 5463 reload_outsi+2/2
L$0917
.CALL ARGW0=GR
bl free,%r2 ;# 5557 call_internal_symref
ldw -312(%r30),%r26 ;# 5555 reload_outsi+2/5
bl L$0867,%r0 ;# 5561 jump
ldi 13,%r28 ;# 5559 reload_outsi+2/2
L$0922
bl L$0867,%r0 ;# 5983 jump
ldi 14,%r28 ;# 5981 reload_outsi+2/2
L$0939
.CALL ARGW0=GR
bl free,%r2 ;# 7235 call_internal_symref
ldw -312(%r30),%r26 ;# 7233 reload_outsi+2/5
bl L$0867,%r0 ;# 7239 jump
ldi 6,%r28 ;# 7237 reload_outsi+2/2
L$0944
bl L$0867,%r0 ;# 7775 jump
ldi 15,%r28 ;# 7773 reload_outsi+2/2
L$0866
.CALL ARGW0=GR
bl free,%r2 ;# 7935 call_internal_symref
ldw -312(%r30),%r26 ;# 7933 reload_outsi+2/5
ldi 8,%r28 ;# 7937 reload_outsi+2/2
L$0867
ldw -340(%r30),%r2 ;# 9026 reload_outsi+2/5
ldw -168(%r30),%r18 ;# 9028 reload_outsi+2/5
ldw -164(%r30),%r17 ;# 9030 reload_outsi+2/5
ldw -160(%r30),%r16 ;# 9032 reload_outsi+2/5
ldw -156(%r30),%r15 ;# 9034 reload_outsi+2/5
ldw -152(%r30),%r14 ;# 9036 reload_outsi+2/5
ldw -148(%r30),%r13 ;# 9038 reload_outsi+2/5
ldw -144(%r30),%r12 ;# 9040 reload_outsi+2/5
ldw -140(%r30),%r11 ;# 9042 reload_outsi+2/5
ldw -136(%r30),%r10 ;# 9044 reload_outsi+2/5
ldw -132(%r30),%r9 ;# 9046 reload_outsi+2/5
ldw -128(%r30),%r8 ;# 9048 reload_outsi+2/5
ldw -124(%r30),%r7 ;# 9050 reload_outsi+2/5
ldw -120(%r30),%r6 ;# 9052 reload_outsi+2/5
ldw -116(%r30),%r5 ;# 9054 reload_outsi+2/5
ldw -112(%r30),%r4 ;# 9056 reload_outsi+2/5
ldw -108(%r30),%r3 ;# 9058 reload_outsi+2/5
bv %r0(%r2) ;# 9061 return_internal
ldo -320(%r30),%r30 ;# 9060 addsi3/2
.EXIT
.PROCEND
.data
 
.align 1
re_syntax_table
.block 256
/unsorted/common.s
0,0 → 1,8
.code
text_symbol:
.long 1
.long external_symbol
.data
data_symbol:
.long 2
common_symbol: .comm 4
/unsorted/importbug.s
0,0 → 1,34
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
; gcc_compiled.:
.EXPORT foo,DATA
.data
 
.align 4
foo:
.word 0
.IMPORT __main,CODE
 
.code
.align 4
.EXPORT main,CODE
.EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR
main:
.PROC
.CALLINFO FRAME=64,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=3
.ENTRY
.import foo
stw %r2,-20(0,%r30)
copy %r3,%r1
copy %r30,%r3
stwm %r1,64(%r30)
.CALL
bl __main,%r2
nop
L$0001:
ldw -20(%r3),%r2
ldo 64(%r3),%r30
ldwm -64(%r30),%r3
bv,n %r0(%r2)
.EXIT
.PROCEND
/unsorted/locallabel.s
0,0 → 1,7
.code
 
.align 4
 
Label:
L$01234:
 
/unsorted/labeldiffs.s
0,0 → 1,39
; Should check to make sure something useful gets put on those .word
; statements.
.code
 
.align 8
.export icode,data
icode:
.proc
.callinfo frame=0,no_calls
.entry
bv,n %r0(%r2)
.exit
nop
.procend
 
;
; FIRST, argv array of pointers to args, 1st is same as path.
;
.align 8
ic_argv:
.word ic_argv1-icode ; second, pointer to 1st argument
.word ic_path-icode ; first, pointer to init path
.word 0 ; fourth, NULL argv terminator (pad)
.word 0 ; third, NULL argv terminator
 
ic_path:
.blockz 4096 ; must be multiple of 4 bytes
.word 0 ; in case full string is used
.word 0 ; this will be the string terminator
 
ic_argv1:
.blockz 4096 ; must be multiple of 4 bytes
.word 0 ; in case full string is used
.word 0 ; this will be the string terminator
 
.export szicode,data
szicode:
.word szicode-icode
.word 0 ; must have at least one filler at end
/unsorted/align3.s
0,0 → 1,20
.SPACE $PRIVATE$
.SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31
.SPACE $TEXT$
.SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
 
.blockz 4
 
main:
.SPACE $PRIVATE$
.SUBSPA $DATA$
 
.SPACE $TEXT$
.SUBSPA $CODE$
 
.PROC
.CALLINFO FRAME=0
.ENTRY
nop
.EXIT
.PROCEND
/unsorted/fragbug.s
0,0 → 1,2
.code
nop
/unsorted/unsorted.exp
0,0 → 1,265
# Copyright (C) 1993, 1997, 1999, 2000, 2002, 2004, 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 the Center for Software Science at the University of Utah
# and by Cygnus Support.
 
proc do_subspace_align_test {} {
set testname "ss_align.s: Test subspace alignment (part 2)"
set x 0
 
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
if [gas_test_old "ss_align.s" "" "subspace alignment (part 1)"] then {
objdump_start_no_subdir "a.out" "-h"
 
# Check the headers for the correct alignment value for the
# the $DATA$ subspace (som).
while 1 {
expect {
-re "DATA\[^\n\]* 2..6\[^\n\]*\n" { set 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==1] then { pass $testname } else { fail $testname }
}
}
 
proc do_local_label_test {} {
set testname "locallabel.s: Elimination of local labels (part 2)"
set x 0
 
if [gas_test_old "locallabel.s" "" "Elimination of local labels (part1)"] {
objdump_start_no_subdir "a.out" "-t"
 
while 1 {
expect {
-re "^00000000\[^\n\]*Label\[^\n\]*\n" { set x 1 }
-re "^00000000\[^\n\]*L\$01234\[^\n\]*\n" { set x 0 }
-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==1] then { pass $testname } else { fail $testname }
}
}
 
proc do_frchain_test {} {
set testname "fragbug.s: Test bug in frag chaining (part 2)"
set x 0
 
if [gas_test_old "fragbug.s" "" "Test bug in frag chaining (part1)"] {
objdump_start_no_subdir "a.out" "--prefix-addresses -d"
 
while 1 {
expect {
-re "^0x00000000\[^\n\]*nop\[^\n\]*\n" { set x 1 }
-re "^0x00000004\[^\n\]*nop\[^\n\]*\n" { set x 0 }
-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==1] then { pass $testname } else { fail $testname }
}
}
 
proc do_align3_test {} {
set testname "align3.s: Test for alignment bug when switching subspaces (part2)"
set x 0
 
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
if [gas_test_old "align3.s" "" "Test for alignment bug when switching subspaces (part1)"] {
objdump_start_no_subdir "a.out" "--prefix-addresses -d"
 
while 1 {
expect {
-re "\[^\n\]* <main> nop\[^\n\]*\n" { set x 1 }
-re "\[^\n\]* <.*end_main> nop\[^\n\]*\n" { set x 1 }
-re "\[^\n\]* <main+.*> nop\[^\n\]*\n" { set x 0 }
-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==1] then { pass $testname } else { fail $testname }
}
}
 
proc do_align4_test {} {
set testname "align4.s: More subspace alignment tests (part2)"
set x 0
 
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
if [gas_test_old "align4.s" "" "More subspace alignment tests (part1)"] {
objdump_start_no_subdir "a.out" "-h"
 
while 1 {
expect {
-re "\[^\n\]*MILLICODE\[^\n\]*2..6\[^\n\]*\n"
{ set x [expr $x+1] }
-re "\[^\n\]*YABBA\[^\n\]*2..3\[^\n\]*\n"
{ set x [expr $x+1] }
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==2] then { pass $testname } else { fail $testname }
}
}
 
proc do_import_test {} {
set testname "importbug.s: Test for bug in .import directive (part2)"
set x 0
 
if [gas_test_old "importbug.s" "" "Test for bug in .import directive (part1)"] {
objdump_start_no_subdir "a.out" "--syms"
 
while 1 {
expect {
-re "\[^\n\]*.DATA..foo\[^\n\]*\n" { set x 1 }
-re "\[^\n\]*.data.*foo\[^\n\]*\n" { set 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==1] then { pass $testname } else { fail $testname }
}
}
 
proc do_common_test {} {
# linux has a different .comm syntax
if [istarget hppa*-*-linux*] then {
return
}
 
set testname "common.s: Test for bug in .comm handling (part2)"
set x 0
 
if [gas_test_old "common.s" "" "Test for bug in .comm handling (part1)"] {
objdump_start_no_subdir "a.out" "--syms"
 
while 1 {
expect {
-re "\[^\n\]*.COM.*common_symbol\[^\n\]*\n" { set 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==1] then { pass $testname } else { fail $testname }
}
}
 
if [istarget hppa*-*-*] then {
# Make sure subspace alignment requests from the subspace directives
# are honored
do_subspace_align_test
 
# Make sure the correct labels end up in the symbol table
do_local_label_test
 
# GAS-1.36 choked on this file.
gas_test "labeldiffs.s" "" "" "Difference of labels"
 
# Test a recent bug where frag chaining wasn't working correctly.
do_frchain_test
 
# Test bug where switching between subspaces creates bogus alignments
do_align3_test
 
# Test bug where switching between subspaces creates bogus alignments
do_align4_test
 
# Test a problem where $global$ is defined, then used within the
# same source file.
setup_xfail hppa*-*-*
gas_test "globalbug.s" "" "" "Use \$global\$ in file which defines it"
 
# Test that importing a defined symbol doesn't screw up the symbol's
# space/subspace.
do_import_test
 
# Test for a buglet in the handling of common symbols
do_common_test
 
# Test for an off-by-2 bug in range check for conditional branches
# The labels in brlenbug.s lack colons and are not linux compatible.
if {! [istarget *-*-linux*]} then {
gas_test_error "brlenbug.s" "" "Check for error(s) in branch length"
}
}
/reloc/selectorbug.s
0,0 → 1,18
; gcc_compiled.:
.EXPORT intVec_error_handler,DATA
.data
 
intVec_error_handler:
.word P%default_intVec_error_handler__FPCc
 
.code
.align 4
.EXPORT foo,CODE
.EXPORT foo,ENTRY,PRIV_LEV=3
foo:
.PROC
.CALLINFO FRAME=0
.ENTRY
.stabd 68,0,41
.EXIT
.PROCEND
/reloc/funcrelocbug.s
0,0 → 1,173
.code
.align 4
.EXPORT g,CODE
.EXPORT g,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,RTNVAL=GR
g:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=3
.ENTRY
stw %r2,-20(%r30)
copy %r3,%r1
copy %r30,%r3
stwm %r1,128(%r30)
stw %r26,-36(%r3)
stw %r25,-40(%r3)
stw %r24,-44(%r3)
ldw -36(%r3),%r26
ldw -40(%r3),%r25
ldw -44(%r3),%r19
copy %r19,%r22
.CALL ARGW0=GR
bl $$dyncall,%r31
copy %r31,%r2
copy %r28,%r19
comiclr,<> 0,%r19,%r0
bl,n L$0002,%r0
ldw -36(%r3),%r28
bl,n L$0001,%r0
bl,n L$0003,%r0
L$0002:
ldw -40(%r3),%r28
bl,n L$0001,%r0
L$0003:
L$0001:
ldw -20(%r3),%r2
ldo 64(%r3),%r30
ldwm -64(%r30),%r3
bv,n %r0(%r2)
.EXIT
.PROCEND
.align 4
f2___4:
.PROC
.CALLINFO FRAME=64,NO_CALLS,SAVE_SP,ENTRY_GR=3
.ENTRY
copy %r3,%r1
copy %r30,%r3
stwm %r1,64(%r30)
stw %r29,8(%r3)
stw %r26,-36(%r3)
stw %r25,-40(%r3)
ldw -36(%r3),%r19
ldw -40(%r3),%r20
comclr,>= %r20,%r19,%r19
ldi 1,%r19
copy %r19,%r28
bl,n L$0005,%r0
L$0005:
ldo 64(%r3),%r30
ldwm -64(%r30),%r3
bv,n %r0(%r2)
.EXIT
.PROCEND
.IMPORT abort,CODE
.data
 
.align 4
L$TRAMP0000:
ldw 36(%r22),%r21
bb,>=,n %r21,30,.+16
depi 0,31,2,%r21
ldw 4(%r21),%r19
ldw 0(%r21),%r21
ldsid (%r21),%r1
mtsp %r1,%sr0
be 0(%sr0,%r21)
ldw 40(%r22),%r29
.word 0
.word 0
.code
 
.align 4
.EXPORT f,CODE
.EXPORT f,ENTRY,PRIV_LEV=3,RTNVAL=GR
f:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=3
.ENTRY
stw %r2,-20(%r30)
copy %r3,%r1
copy %r30,%r3
stwm %r1,192(%r30)
ldo 16(%r3),%r19
addil L'L$TRAMP0000-$global$,%r27
ldo R'L$TRAMP0000-$global$(%r1),%r22
ldo 40(%r0),%r20
ldws,ma 4(%r22),%r21
addib,>= -4,%r20,.-4
stws,ma %r21,4(%r19)
ldil L'f2___4,%r20
ldo R'f2___4(%r20),%r19
stw %r19,52(%r3)
ldo 8(%r3),%r19
stw %r19,56(%r3)
ldo 16(%r3),%r19
ldo 48(%r3),%r20
fdc %r0(%r19)
fdc %r0(%r20)
sync
ldo 32(%r19),%r22
mfsp %sr0,%r21
ldsid (%r19),%r20
mtsp %r20,%sr0
fic %r0(%sr0,%r19)
fic %r0(%sr0,%r22)
sync
mtsp %r21,%sr0
nop
nop
nop
nop
nop
nop
ldo 16(%r3),%r19
ldi 1,%r26
ldi 2,%r25
copy %r19,%r24
.CALL ARGW0=NO,ARGW1=NO,ARGW2=NO,ARGW3=NO
bl g,%r2
nop
copy %r28,%r19
comiclr,<> 2,%r19,%r0
bl,n L$0006,%r0
.CALL ARGW0=NO,ARGW1=NO,ARGW2=NO,ARGW3=NO
bl abort,%r2
nop
L$0006:
L$0004:
ldw -20(%r3),%r2
ldo 64(%r3),%r30
ldwm -64(%r30),%r3
bv,n %r0(%r2)
.EXIT
.PROCEND
.IMPORT __main,CODE
.IMPORT exit,CODE
.align 4
.EXPORT main,CODE
.EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR
main:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=3
.ENTRY
stw %r2,-20(%r30)
copy %r3,%r1
copy %r30,%r3
stwm %r1,128(%r30)
.CALL ARGW0=NO,ARGW1=NO,ARGW2=NO,ARGW3=NO
bl __main,%r2
nop
.CALL ARGW0=NO,ARGW1=NO,ARGW2=NO,ARGW3=NO
bl f,%r2
nop
copy %r0,%r26
.CALL ARGW0=NO,ARGW1=NO,ARGW2=NO,ARGW3=NO
bl exit,%r2
nop
L$0007:
ldw -20(%r3),%r2
ldo 64(%r3),%r30
ldwm -64(%r30),%r3
bv,n %r0(%r2)
.EXIT
.PROCEND
/reloc/r_no_reloc.s
0,0 → 1,34
.COPYRIGHT "MetaWare Incorporated, 1992"
.VERSION "hc2.6a -O1 t3.c\n"
 
.data
.ALIGN 8
$L00DATA:
.ALIGN 8
.EXPORT s
s:
.WORD 0x0
.BLOCKZ 786425
.BLOCKZ 7
 
.code
L$001.3:
g: .PROC
.CALLINFO FRAME=0,NO_CALLS
.ENTRY
;ldo 120(%r0),%r28 --> to delay slot
bv %r0(%r2)
.EXIT
ldo 120(%r0),%r28
.PROCEND
 
 
.data
.ALIGN 4
.EXPORT l
l:
.WORD P'g
.IMPORT common,DATA ; common section, size=0
.IMPORT $global$,DATA
.EXPORT g,ENTRY,PRIV_LEV=3,RTNVAL=GR
.END
/reloc/blebug2.s
0,0 → 1,5
.code
.align 4
 
ldil L%0xc0001004,%r1
ble R%0xc0001004(%sr7,%r1)
/reloc/applybug.s
0,0 → 1,118
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
; gcc_compiled.:
.data
 
.align 4
tab___2:
.word L$0002
.word L$0003
.word L$0004
.code
 
.align 4
.EXPORT execute,CODE
.EXPORT execute,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
execute:
.PROC
.CALLINFO FRAME=0,NO_CALLS
.ENTRY
addil L'buf-$global$,%r27
ldo R'buf-$global$(%r1),%r20
ldil L'L$0002,%r19
movb,<> %r26,%r26,L$0002
ldo R'L$0002(%r19),%r22
copy %r0,%r21
addil L'tab___2-$global$,%r27
ldo R'tab___2-$global$(%r1),%r23
addil L'optab-$global$,%r27
ldo R'optab-$global$(%r1),%r20
L$0009:
sh2add %r21,%r23,%r19
ldh 2(%r19),%r19
ldo 1(%r21),%r21
sub %r19,%r22,%r19
comib,>= 2,%r21,L$0009
sths,ma %r19,2(%r20)
bv,n %r0(%r2)
L$0002:
ldi 120,%r19
stbs,ma %r19,1(%r20)
ldhs,ma 2(%r26),%r19
add %r22,%r19,%r19
bv,n %r0(%r19)
L$0003:
ldi 121,%r19
stbs,ma %r19,1(%r20)
ldhs,ma 2(%r26),%r19
add %r22,%r19,%r19
bv,n %r0(%r19)
L$0004:
ldi 122,%r19
stb %r19,0(%r20)
bv %r0(%r2)
stbs,mb %r0,1(%r20)
.EXIT
.PROCEND
.IMPORT __main,CODE
.IMPORT strcmp,CODE
 
.align 4
L$C0000:
.STRING "xyxyz\x00"
.IMPORT abort,CODE
.IMPORT exit,CODE
.code
 
.align 4
.EXPORT main,CODE
.EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR
main:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
.CALL
bl __main,%r2
ldo 128(%r30),%r30
.CALL ARGW0=GR
bl execute,%r2
copy %r0,%r26
addil L'optab-$global$,%r27
copy %r1,%r19
ldo R'optab-$global$(%r19),%r21
ldh 2(%r21),%r20
ldh R'optab-$global$(%r19),%r19
addil L'p-$global$,%r27
copy %r1,%r22
sth %r20,R'p-$global$(%r22)
ldo R'p-$global$(%r22),%r26
sth %r20,4(%r26)
sth %r19,2(%r26)
ldh 4(%r21),%r19
.CALL ARGW0=GR
bl execute,%r2
sth %r19,6(%r26)
addil L'buf-$global$,%r27
copy %r1,%r19
ldo R'buf-$global$(%r19),%r26
ldil L'L$C0000,%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2
ldo R'L$C0000(%r25),%r25
comib,=,n 0,%r28,L$0011
.CALL
bl abort,%r2
nop
L$0011:
.CALL ARGW0=GR
bl exit,%r2
copy %r0,%r26
nop
.EXIT
.PROCEND
.data
 
optab: .comm 10
buf: .comm 10
p: .comm 10
/reloc/blebug3.s
0,0 → 1,5
.code
.align 4
.import yabba,code
 
ble R%yabba(%sr4,%r0)
/reloc/fixupbug.s
0,0 → 1,9
.code
b,n $$foo
nop
nop
 
.SPACE $TEXT$
.SUBSPA $MILLICODE$
$$foo:
nop
/reloc/reduce2.s
0,0 → 1,80
.SPACE $PRIVATE$
.SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31
.SUBSPA $BSS$,QUAD=1,ALIGN=8,ACCESS=31,ZERO,SORT=82
.SPACE $TEXT$
.SUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=44
.SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
; gcc_compiled.:
.SPACE $TEXT$
.SUBSPA $LIT$
 
.align 8
L$P0000
.word 0x12345678
.word 0x0
 
.align 8
L$C0000
.word 0x3ff00000
.word 0x0
.SPACE $TEXT$
.SUBSPA $CODE$
 
.align 4
.EXPORT g,ENTRY,PRIV_LEV=3,RTNVAL=FR
g
.PROC
.CALLINFO FRAME=0,NO_CALLS
.ENTRY
stw %r19,-32(%r30)
ldw T'L$C0000(%r19),%r20
bv %r0(%r2)
fldds 0(%r20),%fr4
.EXIT
.PROCEND
.IMPORT abort,CODE
.IMPORT exit,CODE
.SPACE $TEXT$
.SUBSPA $LIT$
 
.align 8
L$C0001
.word 0x3ff00000
.word 0x0
.SPACE $TEXT$
.SUBSPA $CODE$
 
.align 4
.EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR
main
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP,ENTRY_GR=3
.ENTRY
stw %r2,-20(%r30)
ldo 128(%r30),%r30
stw %r19,-32(%r30)
stw %r4,-128(%r30)
 
copy %r19,%r4
.CALL
bl g,%r2
copy %r4,%r19
copy %r4,%r19
ldw T'L$C0001(%r19),%r20
fldds 0(%r20),%fr8
fcmp,dbl,= %fr4,%fr8
ftest
add,tr %r0,%r0,%r0
b,n L$0003
.CALL
bl abort,%r2
nop
L$0003
.CALL ARGW0=GR
bl exit,%r2
ldi 0,%r26
nop
.EXIT
.PROCEND
/reloc/reduce3.s
0,0 → 1,38
.data
.align 8
blah:
; .double 0e+00
.word 0 ; = 0x0
.word 0 ; = 0x0
.EXPORT foo,DATA
.align 8
foo:
; .double 0e+00
.word 0 ; = 0x0
.word 0 ; = 0x0
.EXPORT yabba,DATA
.align 4
yabba:
.word 1
.code
 
.align 4
.EXPORT bar,CODE
.EXPORT bar,ENTRY,PRIV_LEV=3,RTNVAL=GR
bar:
.PROC
.CALLINFO FRAME=64,NO_CALLS,SAVE_SP,ENTRY_GR=3
.ENTRY
copy %r3,%r1
copy %r30,%r3
stwm %r1,64(%r30)
addil L'yabba-$global$,%r27
ldo R'yabba-$global$(%r1),%r19
ldi 2,%r20
stw %r20,0(%r19)
L$0001:
ldo 64(%r3),%r30
ldwm -64(%r30),%r3
bv,n %r0(%r2)
.EXIT
.PROCEND
/reloc/longcall.s
0,0 → 1,28
.code
.align 4
.EXPORT foo,CODE
.EXPORT foo,ENTRY,PRIV_LEV=3,RTNVAL=GR
foo:
.PROC
.CALLINFO FRAME=64,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
.CALL
bl bar,%r2
ldo 64(%r30),%r30
.blockz 262144
ldw -84(%r30),%r2
bv %r0(%r2)
ldo -64(%r30),%r30
.EXIT
.PROCEND
.align 4
.EXPORT bar,CODE
.EXPORT bar,ENTRY,PRIV_LEV=3,RTNVAL=GR
bar:
.PROC
.CALLINFO FRAME=0,NO_CALLS
.ENTRY
bv,n %r0(%r2)
.EXIT
.PROCEND
/reloc/roundmode.s
0,0 → 1,15
.code
 
.align 4
.IMPORT foo,data
 
; Switch in/out of different rounding modes.
; Also make sure we "optimize" away useless rounding mode relocations
addil LR'foo-0x12345,%r27
ldo RR'foo-0x12345(%r1),%r1
addil L'foo-0x12345,%r27
ldo R'foo-0x12345(%r1),%r1
addil LR'foo-0x12345,%r27
ldo RR'foo-0x12345(%r1),%r1
addil LR'foo-0x12345,%r27
ldo RR'foo-0x12345(%r1),%r1
/reloc/plabelbug.s
0,0 → 1,37
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
; gcc_compiled.:
.IMPORT abort,CODE
.EXPORT f,DATA
.data
.align 4
f:
.word P%abort
.word P%abort
.IMPORT __main,CODE
.IMPORT printf,CODE
.code
.align 4
LC$0000:
.STRING "frob\x0a\x00"
.align 4
.EXPORT main,CODE
.EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR
main:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
ldo 128(%r30),%r30
.CALL
bl __main,%r2
nop
ldil L'LC$0000,%r26
.CALL ARGW0=GR
bl printf,%r2
ldo R'LC$0000(%r26),%r26
ldw -148(%r30),%r2
bv %r0(%r2)
ldo -128(%r30),%r30
.EXIT
.PROCEND
/reloc/reloc.exp
0,0 → 1,716
# Copyright 1993, 1996, 1997, 2002, 2004, 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 the Center for Software Science at the University of Utah
# and by Cygnus Support.
 
proc do_ble_relocation_test {} {
set testname "blebug.s: Test for proper relocation for BLE (part 2)"
set x 0
 
if [gas_test_old "blebug.s" "" "Proper relocation for BLE (part 1)"] then {
objdump_start_no_subdir "a.out" "-r"
 
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
# At one time both versions of the assembler would incorrectly use
# a PC-relative relocation for a BLE instruction.
while 1 {
expect {
-re "^0+\[^\n\]*DIR21L\[^\n\]*\n" { set x 1 }
-re "^0+4\[^\n\]*DIR17R\[^\n\]*\n" { set x 1 }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
} else {
# At one time both versions of the assembler would incorrectly use
# a PC-relative relocation for a BLE instruction.
while 1 {
expect {
-re "^0+4\[^\n\]*ABS_CALL\[^\n\]*\n" { set 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==1] then { pass $testname } else { fail $testname }
}
 
proc do_relocation_reduction_tests {} {
set testname "reduce.s: Test relocation reductions (part 2)"
set x 0
 
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
if [gas_test_old "reduce.s" "" "Relocation reductions (part1)"] then {
objdump_start_no_subdir "a.out" "-r"
 
# Check to make sure relocations involving procedure labels
# are not reduced to a relocation involving some other symbol.
# Doing so makes generating parameter relocation stubs impossible.
while 1 {
expect {
-re "^0+4\[^\n\]*PLABEL\[^\n\]*foo\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+14\[^\n\]*PCREL\[^\n\]*foo\[^\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==2] then { pass $testname } else { fail $testname }
 
set testname "reduce2.s: More relocation reduction tests (part 2)"
set x 0
 
if [gas_test_old "reduce2.s" "" "More relocation reductions (part1)"] then {
objdump_start_no_subdir "a.out" "-r"
 
# Check to make sure DLT relative relocs are not reduced to sym+addend
# Doing so doesn't work as one might expect
while 1 {
expect {
-re "^0+4\[^\n\]*DLT\[^\n\]*L.C0000\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+1c\[^\n\]*DLT\[^\n\]*L.C0000\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+30\[^\n\]*DLT\[^\n\]*L.C0001\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+48\[^\n\]*DLT\[^\n\]*L.C0001\[^\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==2] then { pass $testname } else { fail $testname }
 
set testname "reduce3.s: Test even more relocation reductions (part 2)"
set x 0
 
if [gas_test_old "reduce3.s" "" "Even more relocation reductions (part1)"] then {
objdump_start_no_subdir "a.out" "-r"
 
# Check to make sure relocations involving procedure labels
# are not reduced to a relocation involving some other symbol.
# Doing so makes generating parameter relocation stubs impossible.
while 1 {
expect {
-re "^0+c\[^\n\]*yabba\[^\n\+\]*\n"
{ set x [expr $x+1] }
-re "^0+c\[^\n\]*yabba\+\[^\n\]*\n"
{ set x 0; break }
-re "^0+10\[^\n\]*yabba\[^\n\+\]*\n"
{ set x [expr $x+1] }
-re "^0+10\[^\n\]*yabba\+\[^\n\]*\n"
{ set x 0; break }
-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==2] then { pass $testname } else { fail $testname }
}
 
proc do_ble_mode_selector_test {} {
set testname "blebug2.s: blebug2"
set x 0
 
gas_start "blebug2.s" "-al"
 
# GAS uses too many bits on the BLE instruction.
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 20202801\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E420E008\[^\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==2] then { pass $testname } else { fail $testname }
}
 
proc do_ble_relocation_test {} {
set testname "blebug3.s: blebug3"
set x 0
 
gas_start "blebug3.s" "-al"
 
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 E4002000\[^\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==1] then { pass $testname } else { fail $testname }
}
 
proc do_plabel_relocation_test {} {
set testname "plabelbug.s: Old gas-1.36 plabel bug (part 2)"
set x 0
 
if [gas_test_old "plabelbug.s" "" "Old gas-1.36 plabel bug (part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Check that we make PLABEL relocation entries when they're needed.
while 1 {
expect {
-re "^0+\[^\n\]*PLABEL\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+4\[^\n\]*PLABEL\[^\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==2] then { pass $testname } else { fail $testname }
}
}
 
proc do_selector_scope_test {} {
set testname "selectorbug.s: Test scope of field selector"
set x 0
 
if [istarget hppa*64*-*-*] then {
return
}
 
if [gas_test_old "selectorbug.s" "" "Test scope of field selector (part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Check to make sure the relocation entry after the plabel is correct.
# If an old field selector was incorrectly "carried" over, then
# this test will fail.
if {[istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
while 1 {
expect {
-re "^0+14\[^\n\]*DIR32\[^\n\]*\n"
{ set x 1 }
-re "^0+14\[^\n\]*PLABEL\[^\n\]*foo\[^\n\]*\n"
{ set x 0 }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
} else {
while 1 {
expect {
-re "^0+14\[^\n\]*DATA_ONE\[^\n\]*\n"
{ set x 1 }
-re "^0+14\[^\n\]*PLABEL\[^\n\]*foo\[^\n\]*\n"
{ set x 0 }
-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==1] then { pass $testname } else { fail $testname }
}
}
 
proc do_local_label_as_operand_test {} {
set testname "labelopbug.s: Test local label as operand (non-branching)"
set x 0
 
if [gas_test_old "labelopbug.s" "" "Local label as operand (part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Check to make sure we handle difference of local labels as an operand
# to a non-branching instruction correctly. On hppa elf targets, the
# R_PARISC_DIR21 and R_PARISC_DIR14R relocations are done with LR and
# RR selectors, respectively. As a result, we can't reduce these to
# section offsets without risking incorrect rounding. So, we just
# check to see if the label hasn't been reduced.
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
while 1 {
expect {
-re "^0+2c\[^\n\]*L.0002\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+30\[^\n\]*L.0002\[^\n\]*\n"
{ set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
} else {
while 1 {
expect {
-re "^0+2c\[^\n\]*0x0+24\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+30\[^\n\]*0x0+24\[^\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==2] then { pass $testname } else { fail $testname }
}
}
 
proc do_exit_relocation_test {} {
set testname "exitbug.s: Test for bogus R_EXIT relocation (part 2)"
set x 0
 
# Elf (osf) does not use ENTRY/EXIT relocations.
# I guess we could look at the unwind subspaces it builds...
# Until then, make sure it still assembles.
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
gas_test_old "exitbug.s" "" "Test for bogus R_EXIT relocation (part 1)"
return
}
 
if [gas_test_old "exitbug.s" "" "Test for bogus R_EXIT relocation (part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Note that a match here is really a FAILURE!
while 1 {
expect {
-re "^0+\[^\n\]*R_EXIT\[^\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==0] then { pass $testname } else { fail $testname }
}
}
 
proc do_cross_space_fixup_test_1 {} {
set testname "fixupbug.s: Test cross space jump/call fixup bug (part 2)"
set x 0
 
# ELF doesn't really handle extra sections too well...
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
if [gas_test_old "fixupbug.s" "" "Test cross space jump/call fixup bug (part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Make sure GAS generated a fixup/relocation for the cross-space
# branch/call
while 1 {
expect {
-re "^0+\[^\n\]*PCREL_CALL\[^\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==1] then { pass $testname } else { fail $testname }
}
}
 
proc do_cross_space_fixup_test_2 {} {
set testname "fixupbug.s: Test cross space jump/call fixup bug (part 3)"
set x 0
 
# ELF doesn't really handle extra sections too well...
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
gas_start "fixupbug.s" "-al"
 
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 E8000002\[^\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==1] then { pass $testname } else { fail $testname }
}
 
proc do_round_mode_test {} {
set testname "roundmode.s: Test switching of rounding modes (part 2)"
set x 0
 
if [gas_test_old "roundmode.s" "" "Test switch of rounding modes(part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Make sure GAS generated correct relocations to switch rounding modes.
# Also make sure (for SOM) that redundant rounding mode relocations
# were eliminated.
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
while 1 {
expect {
-re "^0+\[^\n\]*DIR21L\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+4\[^\n\]*DIR14R\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+8\[^\n\]*DIR21L\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+c\[^\n\]*DIR14R\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+10\[^\n\]*DIR21L\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+14\[^\n\]*DIR14R\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+18\[^\n\]*DIR21L\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+1c\[^\n\]*DIR14R\[^\n\]*\n"
{ set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
} else {
while 1 {
expect {
-re "^0+\[^\n\]*R_R_MODE\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+4\[^\n\]*R_R_MODE\[^\n\]*\n"
{ fail $testname }
-re "^0+8\[^\n\]*R_N_MODE\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+c\[^\n\]*R_N_MODE\[^\n\]*\n"
{ fail $testname }
-re "^0+10\[^\n\]*R_R_MODE\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+14\[^\n\]*R_R_MODE\[^\n\]*\n"
{ fail $testname }
-re "^0+1c\[^\n\]*R_R_MODE\[^\n\]*\n"
{ fail $testname }
-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 {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
if [expr $x==8] then { pass $testname } else { fail $testname }
} else {
if [expr $x==3] then { pass $testname } else { fail $testname }
}
}
}
 
proc do_function_reloc_bug {} {
set testname "funcrelocbug.s: Test for reloc bug in non-plabel function reference (part 2)"
set x 0
 
if [gas_test_old "funcrelocbug.s" "" "Test for reloc bug in non-plabel function reference (part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Make sure GAS generated a correct relocation for the reference.
# branch/call
while 1 {
expect {
-re "^0+cc\[^\n\]*f2___4\[^\n+\]*\n"
{ set x [expr $x+1] }
-re "^0+d0\[^\n\]*f2___4\[^\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==2] then { pass $testname } else { fail $testname }
 
set testname "funcrelocbug.s: Test for reloc bug in non-plabel function reference (part3)"
set x 0
 
objdump_start_no_subdir "a.out" "--prefix-addresses -d"
# Make sure we didn't put anything in the instruction itself!
while 1 {
expect {
-re "^0+cc\[^\n\]*ldil L%0,r20\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0+d0\[^\n\]*ldo 0\[\(\]+r20\[\)\]+,r19\[^\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==2] then { pass $testname } else { fail $testname }
}
 
}
 
proc do_r_no_reloc {} {
set testname "r_no_reloc.s: Test for reloc bug in 4-byte R_NO_RELCOATION fixups (part 2)"
set x 0
 
if [gas_test_old "r_no_reloc.s" "" "Test for reloc bug in 4-byte R_NO_RELOCATION fixups (part 1)"] {
objdump_start_no_subdir "a.out" "-r"
 
# Make sure GAS generated a correct relocation for the reference.
while 1 {
expect {
-re "^0+c0004\[^\n\]*PLABEL\[^\n]*g\[^\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==1] then { pass $testname } else { fail $testname }
 
}
}
 
proc do_pic_relocation_test {} {
set testname "picreloc.s: Test for proper PIC relocation (part 2)"
set x 0
 
# ELF doesn't really handle extra sections too well...
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
gas_start "picreloc.s" "-al"
 
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 00000004\[^\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==1] then { pass $testname } else { fail $testname }
}
 
proc do_apply_test {} {
set testname "applybug.s: Test for proper fixup application (part 2)"
set x 0
 
# ELF doesn't really handle extra sections too well...
if {[istarget hppa*64*-*-*]
|| [istarget hppa*-*-*elf*] || [istarget hppa*-*-linux*]} then {
return
}
 
gas_start "applybug.s" "-al"
 
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 00000044\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 00000058\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 0000006C\[^\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 }
}
 
if [istarget hppa*-*-*] then {
# Make sure we put the right relocation entry on a BLE instruction.
do_ble_relocation_test
 
# Make sure relocation reductions are not too agressive about
# adjusting relocations against some symbols.
do_relocation_reduction_tests
 
# Check that mode selectors on a ble instruction actually work.
do_ble_mode_selector_test
 
# Check that we take the -8 adjustment into account when zeroing
# out the displacement field in a ble instruction with a reloc
do_ble_relocation_test
 
# 1.36 simply didn't generate all the plabels it should have. Make
# sure gas-2 does.
do_plabel_relocation_test
 
# Make sure a field selector only effects the current instruction
# or assembler directive.
do_selector_scope_test
 
# This should really generate a relocation. It would make life much
# easier on the optimizing linker. Until then just make sure the
# difference is computed correctly.
do_local_label_as_operand_test
 
# GAS2 incorrectly generated R_EXIT relocations when .exit directives
# were not in the source code.
do_exit_relocation_test
 
# GAS2 incorrectly thought it could apply a fixup for a pc-relative
# branch/call which crossed different subspaces.
# Also check that the assembled instruction is correct
do_cross_space_fixup_test_1
do_cross_space_fixup_test_2
 
# Make sure we switch rounding modes correctly
do_round_mode_test
 
# Test for a bug found when a function was used in a non-branching
# instruction *without* a plabel (for portable runtime model)
do_function_reloc_bug
 
# Test for an off-by-one bug in the handling of 4-byte R_NO_RELOCATION
# fixups.
do_r_no_reloc
 
# Test a relocation problem which shows up when building shared
# libraries in SOM
do_pic_relocation_test
 
# Test a problem with md_apply_fix that was introduced when fixing
# the pic relocation test.
do_apply_test
 
# Make sure gas doesn't resolve long-calls which are to be fixed
# by the linker
gas_test "longcall.s" "" "" "Avoid resolving long-calls"
}
/reloc/blebug.s
0,0 → 1,7
.code
.align 4
.IMPORT $$dyncall,MILLICODE ; Code for dynamic function calls.
 
_sigtramp:
ldil L%$$dyncall,%r2 ; whose address is in r22.
ble R%$$dyncall(%sr4,%r2)
/reloc/picreloc.s
0,0 → 1,9
 
.data
bogo
.ALIGN 8
.WORD bogo+4 ; = 0x4
.STRING "\x00\x00\x00{\x00\x00\x01\xC8\x00\x00\x03\x15"
.data
.EXPORT bogo
.END
/reloc/reduce.s
0,0 → 1,37
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
; gcc_compiled.:
 
.code
.align 4
.PARAM foo,ARGW0=FR
foo:
.PROC
.CALLINFO FRAME=0,NO_CALLS
.ENTRY
bv,n %r0(%r2)
.EXIT
.PROCEND
 
.align 4
LC$0000:
.word P%foo
 
.align 4
.EXPORT bar,CODE
.EXPORT bar,ENTRY,PRIV_LEV=3,RTNVAL=GR
bar:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
ldil L'LC$0000,%r19
ldw R'LC$0000(%r19),%r26
stw %r2,-20(%r30)
.CALL ARGW0=GR
bl foo,%r2
ldo 128(%r30),%r30
ldw -148(%r30),%r2
bv %r0(%r2)
ldo -128(%r30),%r30
.EXIT
.PROCEND
/reloc/exitbug.s
0,0 → 1,8
.code
.align 4
.EXPORT foo,CODE
.EXPORT foo,ENTRY,PRIV_LEV=3
foo:
.PROC
.CALLINFO FRAME=0
.PROCEND
/reloc/labelopbug.s
0,0 → 1,26
.code
.align 4
s:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r30,12(%r4)
ldil L'L$0007,%r19
ldo R'L$0007(%r19),%r19
comib,>= 0,%r26,L$0002
stw %r19,8(%r4)
L$0003:
L$0002:
b L$0001
ldo 1(%r0),%r28
L$0007:
ldil L'L$0002,%r19
ldo R'L$0002(%r19),%r19
comb,= %r29,%r19,L$0002
ldo -8(%r4),%r4
.EXIT
.PROCEND
/parse/appbug.s
0,0 → 1,26
# 1 "crt0.s"
/parse/exportbug.s
0,0 → 1,5
.code
.align 4
.EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR
 
 
/parse/xmpyubug.s
0,0 → 1,8
.code
.align 4
; No format selector for xmpyu!
xmpyu,sgl %fr4,%fr5,%fr6
xmpyu,dbl %fr4,%fr5,%fr6
xmpyu,quad %fr4,%fr5,%fr6
 
 
/parse/fixup7bug.s
0,0 → 1,6167
.IMPORT $global$,DATA
.IMPORT $$dyncall,MILLICODE
.code
.align 4
.EXPORT alloc_type,CODE
.EXPORT alloc_type,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
alloc_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r7,32(%r4)
stw %r6,36(%r4)
stw %r5,40(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0002,%r0
nop
ldo 52(%r0),%r26
.CALL ARGW0=GR
bl xmalloc,%r2
nop
copy %r28,%r7
bl,n L$0003,%r0
L$0002:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo 120(%r19),%r20
stw %r20,8(%r4)
ldw 8(%r4),%r19
stw %r19,12(%r4)
ldo 52(%r0),%r19
stw %r19,16(%r4)
ldw 12(%r4),%r19
ldw 12(%r4),%r20
ldw 16(%r19),%r19
ldw 12(%r20),%r20
sub %r19,%r20,%r19
ldw 16(%r4),%r20
comclr,< %r19,%r20,%r0
bl L$0004,%r0
nop
ldw 12(%r4),%r26
ldw 16(%r4),%r25
.CALL ARGW0=GR,ARGW1=GR
bl _obstack_newchunk,%r2
nop
copy %r0,%r19
bl,n L$0005,%r0
L$0004:
copy %r0,%r19
L$0005:
ldw 12(%r4),%r19
ldw 12(%r4),%r20
ldw 12(%r20),%r21
ldw 16(%r4),%r22
add %r21,%r22,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 8(%r4),%r19
stw %r19,20(%r4)
ldw 20(%r4),%r19
ldw 8(%r19),%r20
stw %r20,24(%r4)
ldw 20(%r4),%r19
ldw 12(%r19),%r20
ldw 24(%r4),%r19
comclr,= %r20,%r19,%r0
bl L$0006,%r0
nop
ldw 20(%r4),%r19
ldw 40(%r19),%r20
copy %r20,%r21
depi -1,1,1,%r21
stw %r21,40(%r19)
L$0006:
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 20(%r4),%r21
ldw 12(%r20),%r20
ldw 24(%r21),%r21
add %r20,%r21,%r20
ldw 20(%r4),%r21
ldw 24(%r21),%r22
uaddcm %r0,%r22,%r21
and %r20,%r21,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 12(%r19),%r19
ldw 4(%r20),%r20
sub %r19,%r20,%r19
ldw 20(%r4),%r20
ldw 20(%r4),%r21
ldw 16(%r20),%r20
ldw 4(%r21),%r21
sub %r20,%r21,%r20
comclr,> %r19,%r20,%r0
bl L$0007,%r0
nop
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 16(%r20),%r21
stw %r21,12(%r19)
copy %r21,%r19
bl,n L$0008,%r0
L$0007:
copy %r0,%r19
L$0008:
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 12(%r20),%r21
stw %r21,8(%r19)
ldw 24(%r4),%r7
L$0003:
copy %r7,%r26
copy %r0,%r25
ldo 52(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2
nop
stw %r0,0(%r7)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,12(%r7)
ldo -1(%r0),%r19
stw %r19,44(%r7)
copy %r7,%r28
bl,n L$0001,%r0
L$0001:
ldw 32(%r4),%r7
ldw 36(%r4),%r6
ldw 40(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT make_pointer_type,CODE
.EXPORT make_pointer_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
make_pointer_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r9,16(%r4)
stw %r8,20(%r4)
stw %r7,24(%r4)
stw %r6,28(%r4)
stw %r5,32(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 20(%r19),%r9
comiclr,<> 0,%r9,%r0
bl L$0010,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0011,%r0
nop
copy %r9,%r28
bl,n L$0009,%r0
bl,n L$0012,%r0
L$0011:
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0013,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,0(%r19)
copy %r9,%r28
bl,n L$0009,%r0
L$0013:
L$0012:
L$0010:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0015,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0014,%r0
nop
bl,n L$0015,%r0
L$0015:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
copy %r28,%r9
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0016,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,0(%r19)
L$0016:
bl,n L$0017,%r0
L$0014:
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r9
ldw 12(%r9),%r19
stw %r19,8(%r4)
copy %r9,%r26
copy %r0,%r25
ldo 52(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2
nop
ldw 8(%r4),%r19
stw %r19,12(%r9)
L$0017:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,16(%r9)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,20(%r19)
ldo 4(%r0),%r19
stw %r19,8(%r9)
ldo 1(%r0),%r19
stw %r19,0(%r9)
ldh 32(%r9),%r19
copy %r19,%r20
depi -1,31,1,%r20
sth %r20,32(%r9)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 20(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0018,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,20(%r19)
L$0018:
copy %r9,%r28
bl,n L$0009,%r0
L$0009:
ldw 16(%r4),%r9
ldw 20(%r4),%r8
ldw 24(%r4),%r7
ldw 28(%r4),%r6
ldw 32(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT lookup_pointer_type,CODE
.EXPORT lookup_pointer_type,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
lookup_pointer_type:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,8(%r4)
stw %r5,12(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
copy %r0,%r25
.CALL ARGW0=GR,ARGW1=GR
bl make_pointer_type,%r2
nop
bl,n L$0019,%r0
L$0019:
ldw 8(%r4),%r6
ldw 12(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT make_reference_type,CODE
.EXPORT make_reference_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
make_reference_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r9,16(%r4)
stw %r8,20(%r4)
stw %r7,24(%r4)
stw %r6,28(%r4)
stw %r5,32(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 24(%r19),%r9
comiclr,<> 0,%r9,%r0
bl L$0021,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0022,%r0
nop
copy %r9,%r28
bl,n L$0020,%r0
bl,n L$0023,%r0
L$0022:
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0024,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,0(%r19)
copy %r9,%r28
bl,n L$0020,%r0
L$0024:
L$0023:
L$0021:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0026,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0025,%r0
nop
bl,n L$0026,%r0
L$0026:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
copy %r28,%r9
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0027,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,0(%r19)
L$0027:
bl,n L$0028,%r0
L$0025:
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r9
ldw 12(%r9),%r19
stw %r19,8(%r4)
copy %r9,%r26
copy %r0,%r25
ldo 52(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2
nop
ldw 8(%r4),%r19
stw %r19,12(%r9)
L$0028:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,16(%r9)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,24(%r19)
ldo 4(%r0),%r19
stw %r19,8(%r9)
ldo 16(%r0),%r19
stw %r19,0(%r9)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 24(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0029,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,24(%r19)
L$0029:
copy %r9,%r28
bl,n L$0020,%r0
L$0020:
ldw 16(%r4),%r9
ldw 20(%r4),%r8
ldw 24(%r4),%r7
ldw 28(%r4),%r6
ldw 32(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT lookup_reference_type,CODE
.EXPORT lookup_reference_type,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
lookup_reference_type:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,8(%r4)
stw %r5,12(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
copy %r0,%r25
.CALL ARGW0=GR,ARGW1=GR
bl make_reference_type,%r2
nop
bl,n L$0030,%r0
L$0030:
ldw 8(%r4),%r6
ldw 12(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT make_function_type,CODE
.EXPORT make_function_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
make_function_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r9,16(%r4)
stw %r8,20(%r4)
stw %r7,24(%r4)
stw %r6,28(%r4)
stw %r5,32(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 28(%r19),%r9
comiclr,<> 0,%r9,%r0
bl L$0032,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0033,%r0
nop
copy %r9,%r28
bl,n L$0031,%r0
bl,n L$0034,%r0
L$0033:
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0035,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,0(%r19)
copy %r9,%r28
bl,n L$0031,%r0
L$0035:
L$0034:
L$0032:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0037,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0036,%r0
nop
bl,n L$0037,%r0
L$0037:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
copy %r28,%r9
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0038,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,0(%r19)
L$0038:
bl,n L$0039,%r0
L$0036:
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r9
ldw 12(%r9),%r19
stw %r19,8(%r4)
copy %r9,%r26
copy %r0,%r25
ldo 52(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2
nop
ldw 8(%r4),%r19
stw %r19,12(%r9)
L$0039:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,16(%r9)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,28(%r19)
ldo 1(%r0),%r19
stw %r19,8(%r9)
ldo 6(%r0),%r19
stw %r19,0(%r9)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 28(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0040,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
stw %r9,28(%r19)
L$0040:
copy %r9,%r28
bl,n L$0031,%r0
L$0031:
ldw 16(%r4),%r9
ldw 20(%r4),%r8
ldw 24(%r4),%r7
ldw 28(%r4),%r6
ldw 32(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT lookup_function_type,CODE
.EXPORT lookup_function_type,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
lookup_function_type:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,8(%r4)
stw %r5,12(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
copy %r0,%r25
.CALL ARGW0=GR,ARGW1=GR
bl make_function_type,%r2
nop
bl,n L$0041,%r0
L$0041:
ldw 8(%r4),%r6
ldw 12(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT smash_to_member_type,CODE
.align 4
.EXPORT lookup_member_type,CODE
.EXPORT lookup_member_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
lookup_member_type:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r8,8(%r4)
stw %r7,12(%r4)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo 24(%r4),%r1
fstds,ma %fr12,8(%r1)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
stw %r28,-16(%r30)
fldws -16(%r30),%fr12
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
fstws %fr12,-16(%r30)
ldw -16(%r30),%r26
ldw 0(%r19),%r25
ldw 0(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl smash_to_member_type,%r2
nop
fstws %fr12,-16(%r30)
ldw -16(%r30),%r28
bl,n L$0042,%r0
L$0042:
ldw 8(%r4),%r8
ldw 12(%r4),%r7
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 24(%r4),%r1
fldds,ma 8(%r1),%fr12
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT allocate_stub_method,CODE
.EXPORT allocate_stub_method,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
allocate_stub_method:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
stw %r28,8(%r4)
ldw 8(%r4),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,16(%r19)
ldw 8(%r4),%r19
ldo 4(%r0),%r20
sth %r20,32(%r19)
ldw 8(%r4),%r19
ldo 15(%r0),%r20
stw %r20,0(%r19)
ldw 8(%r4),%r19
ldo 1(%r0),%r20
stw %r20,8(%r19)
ldw 8(%r4),%r28
bl,n L$0043,%r0
L$0043:
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT builtin_type_int,DATA
.align 4
.EXPORT create_array_type,CODE
.EXPORT create_array_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
create_array_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r10,56(%r4)
stw %r9,60(%r4)
stw %r8,64(%r4)
stw %r7,68(%r4)
stw %r6,72(%r4)
stw %r5,76(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
stw %r28,8(%r4)
ldw 8(%r4),%r19
ldo 2(%r0),%r20
stw %r20,0(%r19)
ldw 8(%r4),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,16(%r19)
ldw 8(%r4),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r23
add %r23,%r21,%r22
ldw 0(%r22),%r21
ldw 0(%r20),%r20
ldw 8(%r21),%r21
stw %r20,-16(%r30)
fldws -16(%r30),%fr5
stw %r21,-16(%r30)
fldws -16(%r30),%fr5R
xmpyu %fr5,%fr5R,%fr4
fstws %fr4R,-16(%r30)
ldw -16(%r30),%r24
stw %r24,8(%r19)
ldw 8(%r4),%r19
ldo 1(%r0),%r20
sth %r20,34(%r19)
ldw 8(%r4),%r9
ldw 8(%r4),%r19
ldw 12(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0050,%r0
nop
ldw 8(%r4),%r19
ldw 12(%r19),%r20
ldo 120(%r20),%r19
stw %r19,16(%r4)
ldw 16(%r4),%r19
stw %r19,20(%r4)
ldo 16(%r0),%r19
stw %r19,24(%r4)
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 16(%r19),%r19
ldw 12(%r20),%r20
sub %r19,%r20,%r19
ldw 24(%r4),%r20
comclr,< %r19,%r20,%r0
bl L$0045,%r0
nop
ldw 20(%r4),%r26
ldw 24(%r4),%r25
.CALL ARGW0=GR,ARGW1=GR
bl _obstack_newchunk,%r2
nop
copy %r0,%r19
bl,n L$0046,%r0
L$0045:
copy %r0,%r19
L$0046:
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 12(%r20),%r21
ldw 24(%r4),%r22
add %r21,%r22,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 16(%r4),%r19
stw %r19,28(%r4)
ldw 28(%r4),%r19
ldw 8(%r19),%r20
stw %r20,32(%r4)
ldw 28(%r4),%r19
ldw 12(%r19),%r20
ldw 32(%r4),%r19
comclr,= %r20,%r19,%r0
bl L$0047,%r0
nop
ldw 28(%r4),%r19
ldw 40(%r19),%r20
copy %r20,%r21
depi -1,1,1,%r21
stw %r21,40(%r19)
L$0047:
ldw 28(%r4),%r19
ldw 28(%r4),%r20
ldw 28(%r4),%r21
ldw 12(%r20),%r20
ldw 24(%r21),%r21
add %r20,%r21,%r20
ldw 28(%r4),%r21
ldw 24(%r21),%r22
uaddcm %r0,%r22,%r21
and %r20,%r21,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 28(%r4),%r19
ldw 28(%r4),%r20
ldw 12(%r19),%r19
ldw 4(%r20),%r20
sub %r19,%r20,%r19
ldw 28(%r4),%r20
ldw 28(%r4),%r21
ldw 16(%r20),%r20
ldw 4(%r21),%r21
sub %r20,%r21,%r20
comclr,> %r19,%r20,%r0
bl L$0048,%r0
nop
ldw 28(%r4),%r19
ldw 28(%r4),%r20
ldw 16(%r20),%r21
stw %r21,12(%r19)
copy %r21,%r19
bl,n L$0049,%r0
L$0048:
copy %r0,%r19
L$0049:
ldw 28(%r4),%r19
ldw 28(%r4),%r20
ldw 12(%r20),%r21
stw %r21,8(%r19)
ldw 32(%r4),%r10
bl,n L$0051,%r0
L$0050:
ldo 16(%r0),%r26
.CALL ARGW0=GR
bl xmalloc,%r2
nop
copy %r28,%r10
L$0051:
stw %r10,36(%r9)
ldw 8(%r4),%r19
ldw 12(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
stw %r28,12(%r4)
ldw 12(%r4),%r19
ldo 11(%r0),%r20
stw %r20,0(%r19)
ldw 12(%r4),%r19
addil L'builtin_type_int-$global$,%r27
ldw R'builtin_type_int-$global$(%r1),%r20
stw %r20,16(%r19)
ldw 12(%r4),%r19
ldo 4(%r0),%r20
stw %r20,8(%r19)
ldw 12(%r4),%r19
ldo 2(%r0),%r20
sth %r20,34(%r19)
ldw 12(%r4),%r9
ldw 12(%r4),%r19
ldw 12(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0057,%r0
nop
ldw 12(%r4),%r19
ldw 12(%r19),%r20
ldo 120(%r20),%r19
stw %r19,36(%r4)
ldw 36(%r4),%r19
stw %r19,40(%r4)
ldo 32(%r0),%r19
stw %r19,44(%r4)
ldw 40(%r4),%r19
ldw 40(%r4),%r20
ldw 16(%r19),%r19
ldw 12(%r20),%r20
sub %r19,%r20,%r19
ldw 44(%r4),%r20
comclr,< %r19,%r20,%r0
bl L$0052,%r0
nop
ldw 40(%r4),%r26
ldw 44(%r4),%r25
.CALL ARGW0=GR,ARGW1=GR
bl _obstack_newchunk,%r2
nop
copy %r0,%r19
bl,n L$0053,%r0
L$0052:
copy %r0,%r19
L$0053:
ldw 40(%r4),%r19
ldw 40(%r4),%r20
ldw 12(%r20),%r21
ldw 44(%r4),%r22
add %r21,%r22,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 36(%r4),%r19
stw %r19,48(%r4)
ldw 48(%r4),%r19
ldw 8(%r19),%r20
stw %r20,52(%r4)
ldw 48(%r4),%r19
ldw 12(%r19),%r20
ldw 52(%r4),%r19
comclr,= %r20,%r19,%r0
bl L$0054,%r0
nop
ldw 48(%r4),%r19
ldw 40(%r19),%r20
copy %r20,%r21
depi -1,1,1,%r21
stw %r21,40(%r19)
L$0054:
ldw 48(%r4),%r19
ldw 48(%r4),%r20
ldw 48(%r4),%r21
ldw 12(%r20),%r20
ldw 24(%r21),%r21
add %r20,%r21,%r20
ldw 48(%r4),%r21
ldw 24(%r21),%r22
uaddcm %r0,%r22,%r21
and %r20,%r21,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 48(%r4),%r19
ldw 48(%r4),%r20
ldw 12(%r19),%r19
ldw 4(%r20),%r20
sub %r19,%r20,%r19
ldw 48(%r4),%r20
ldw 48(%r4),%r21
ldw 16(%r20),%r20
ldw 4(%r21),%r21
sub %r20,%r21,%r20
comclr,> %r19,%r20,%r0
bl L$0055,%r0
nop
ldw 48(%r4),%r19
ldw 48(%r4),%r20
ldw 16(%r20),%r21
stw %r21,12(%r19)
copy %r21,%r19
bl,n L$0056,%r0
L$0055:
copy %r0,%r19
L$0056:
ldw 48(%r4),%r19
ldw 48(%r4),%r20
ldw 12(%r20),%r21
stw %r21,8(%r19)
ldw 52(%r4),%r10
bl,n L$0058,%r0
L$0057:
ldo 32(%r0),%r26
.CALL ARGW0=GR
bl xmalloc,%r2
nop
copy %r28,%r10
L$0058:
stw %r10,36(%r9)
ldw 12(%r4),%r19
ldw 36(%r19),%r20
stw %r0,0(%r20)
ldw 12(%r4),%r19
ldo 16(%r0),%r20
ldw 36(%r19),%r21
add %r20,%r21,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldo -1(%r20),%r21
stw %r21,0(%r19)
ldw 12(%r4),%r20
ldw 36(%r20),%r19
addil L'builtin_type_int-$global$,%r27
ldw R'builtin_type_int-$global$(%r1),%r20
stw %r20,8(%r19)
ldw 12(%r4),%r19
ldo 16(%r0),%r20
ldw 36(%r19),%r21
add %r20,%r21,%r19
addil L'builtin_type_int-$global$,%r27
ldw R'builtin_type_int-$global$(%r1),%r20
stw %r20,8(%r19)
ldw 8(%r4),%r19
ldw 36(%r19),%r20
ldw 12(%r4),%r19
stw %r19,8(%r20)
ldw 8(%r4),%r19
ldo -1(%r0),%r20
stw %r20,44(%r19)
ldw 8(%r4),%r28
bl,n L$0044,%r0
L$0044:
ldw 56(%r4),%r10
ldw 60(%r4),%r9
ldw 64(%r4),%r8
ldw 68(%r4),%r7
ldw 72(%r4),%r6
ldw 76(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT smash_to_member_type,CODE
.EXPORT smash_to_member_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR
smash_to_member_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r10,16(%r4)
stw %r9,20(%r4)
stw %r8,24(%r4)
stw %r7,28(%r4)
stw %r6,32(%r4)
stw %r5,36(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -12(%r0),%r9
ldo -32(%r4),%r19
add %r19,%r9,%r10
stw %r24,0(%r10)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r20
stw %r20,8(%r4)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
copy %r0,%r25
ldo 52(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
stw %r20,12(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -12(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,16(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,40(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo 1(%r0),%r20
stw %r20,8(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo 14(%r0),%r20
stw %r20,0(%r19)
L$0059:
ldw 16(%r4),%r10
ldw 20(%r4),%r9
ldw 24(%r4),%r8
ldw 28(%r4),%r7
ldw 32(%r4),%r6
ldw 36(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT smash_to_method_type,CODE
.EXPORT smash_to_method_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
smash_to_method_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r12,16(%r4)
stw %r11,20(%r4)
stw %r10,24(%r4)
stw %r9,28(%r4)
stw %r8,32(%r4)
stw %r7,36(%r4)
stw %r6,40(%r4)
stw %r5,44(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -12(%r0),%r9
ldo -32(%r4),%r19
add %r19,%r9,%r10
stw %r24,0(%r10)
ldo -16(%r0),%r11
ldo -32(%r4),%r19
add %r19,%r11,%r12
stw %r23,0(%r12)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r20
stw %r20,8(%r4)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
copy %r0,%r25
ldo 52(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
stw %r20,12(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -12(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,16(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,40(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -16(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,48(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo 1(%r0),%r20
stw %r20,8(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo 15(%r0),%r20
stw %r20,0(%r19)
L$0060:
ldw 16(%r4),%r12
ldw 20(%r4),%r11
ldw 24(%r4),%r10
ldw 28(%r4),%r9
ldw 32(%r4),%r8
ldw 36(%r4),%r7
ldw 40(%r4),%r6
ldw 44(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT strncmp,CODE
.align 4
LC$0000:
.STRING "struct \x00"
.align 4
LC$0001:
.STRING "union \x00"
.align 4
LC$0002:
.STRING "enum \x00"
.align 4
.EXPORT type_name_no_tag,CODE
.EXPORT type_name_no_tag,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
type_name_no_tag:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,8(%r4)
stw %r5,12(%r4)
copy %r26,%r5
ldw 4(%r5),%r6
comiclr,<> 0,%r6,%r0
bl L$0062,%r0
nop
ldw 0(%r5),%r19
comiclr,<> 4,%r19,%r0
bl L$0066,%r0
nop
comiclr,>= 4,%r19,%r0
bl L$0072,%r0
nop
comiclr,<> 3,%r19,%r0
bl L$0064,%r0
nop
bl,n L$0070,%r0
L$0072:
comiclr,<> 5,%r19,%r0
bl L$0068,%r0
nop
bl,n L$0070,%r0
L$0064:
copy %r6,%r26
ldil L'LC$0000,%r25
ldo R'LC$0000(%r25),%r25
ldo 7(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl strncmp,%r2
nop
copy %r28,%r19
comiclr,= 0,%r19,%r0
bl L$0065,%r0
nop
ldo 7(%r6),%r6
L$0065:
bl,n L$0063,%r0
L$0066:
copy %r6,%r26
ldil L'LC$0001,%r25
ldo R'LC$0001(%r25),%r25
ldo 6(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl strncmp,%r2
nop
copy %r28,%r19
comiclr,= 0,%r19,%r0
bl L$0067,%r0
nop
ldo 6(%r6),%r6
L$0067:
bl,n L$0063,%r0
L$0068:
copy %r6,%r26
ldil L'LC$0002,%r25
ldo R'LC$0002(%r25),%r25
ldo 5(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl strncmp,%r2
nop
copy %r28,%r19
comiclr,= 0,%r19,%r0
bl L$0069,%r0
nop
ldo 5(%r6),%r6
L$0069:
bl,n L$0063,%r0
L$0070:
bl,n L$0063,%r0
L$0063:
L$0062:
copy %r6,%r28
bl,n L$0061,%r0
L$0061:
ldw 8(%r4),%r6
ldw 12(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT current_language,DATA
.IMPORT strcmp,CODE
.align 4
.EXPORT lookup_primitive_typename,CODE
.EXPORT lookup_primitive_typename,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
lookup_primitive_typename:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
addil L'current_language-$global$,%r27
ldw R'current_language-$global$(%r1),%r19
ldw 8(%r19),%r20
stw %r20,8(%r4)
L$0074:
ldw 8(%r4),%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0075,%r0
nop
ldw 8(%r4),%r19
ldw 0(%r19),%r20
ldw 0(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 4(%r19),%r26
ldw 0(%r20),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2
nop
copy %r28,%r19
comiclr,= 0,%r19,%r0
bl L$0077,%r0
nop
ldw 8(%r4),%r19
ldw 0(%r19),%r20
ldw 0(%r20),%r28
bl,n L$0073,%r0
L$0077:
L$0076:
ldw 8(%r4),%r19
ldo 4(%r19),%r20
stw %r20,8(%r4)
bl,n L$0074,%r0
L$0075:
copy %r0,%r28
bl,n L$0073,%r0
L$0073:
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT lookup_symbol,CODE
.IMPORT error,CODE
.align 4
LC$0003:
.STRING "No type named %s.\x00"
.align 4
.EXPORT lookup_typename,CODE
.EXPORT lookup_typename,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,RTNVAL=GR
lookup_typename:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r12,8(%r4)
stw %r11,12(%r4)
stw %r10,16(%r4)
stw %r9,20(%r4)
stw %r8,24(%r4)
stw %r7,28(%r4)
stw %r6,32(%r4)
stw %r5,36(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -12(%r0),%r9
ldo -32(%r4),%r19
add %r19,%r9,%r10
stw %r24,0(%r10)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
stw %r0,-52(%r30)
ldw 0(%r19),%r26
ldw 0(%r20),%r25
ldo 1(%r0),%r24
copy %r0,%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl lookup_symbol,%r2
nop
copy %r28,%r11
comiclr,<> 0,%r11,%r0
bl L$0080,%r0
nop
ldw 8(%r11),%r19
comiclr,= 8,%r19,%r0
bl L$0080,%r0
nop
bl,n L$0079,%r0
L$0080:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl lookup_primitive_typename,%r2
nop
copy %r28,%r12
comiclr,<> 0,%r12,%r0
bl L$0081,%r0
nop
copy %r12,%r28
bl,n L$0078,%r0
bl,n L$0082,%r0
L$0081:
comiclr,= 0,%r12,%r0
bl L$0083,%r0
nop
ldo -12(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0083,%r0
nop
copy %r0,%r28
bl,n L$0078,%r0
bl,n L$0084,%r0
L$0083:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0003,%r26
ldo R'LC$0003(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0084:
L$0082:
L$0079:
ldw 12(%r11),%r28
bl,n L$0078,%r0
L$0078:
ldw 8(%r4),%r12
ldw 12(%r4),%r11
ldw 16(%r4),%r10
ldw 20(%r4),%r9
ldw 24(%r4),%r8
ldw 28(%r4),%r7
ldw 32(%r4),%r6
ldw 36(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT alloca,CODE
.IMPORT strlen,CODE
.IMPORT strcpy,CODE
.align 4
LC$0004:
.STRING "unsigned \x00"
.align 4
.EXPORT lookup_unsigned_typename,CODE
.EXPORT lookup_unsigned_typename,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
lookup_unsigned_typename:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl strlen,%r2
nop
copy %r28,%r19
ldo 10(%r19),%r20
ldo 7(%r20),%r21
copy %r21,%r19
ldo 63(%r19),%r20
extru %r20,25,26,%r19
zdep %r19,25,26,%r20
ldo -96(%r30),%r19
add %r30,%r20,%r30
ldo 7(%r19),%r20
extru %r20,28,29,%r19
zdep %r19,28,29,%r20
stw %r20,8(%r4)
ldw 8(%r4),%r26
ldil L'LC$0004,%r25
ldo R'LC$0004(%r25),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcpy,%r2
nop
ldw 8(%r4),%r20
ldo 9(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
copy %r19,%r26
ldw 0(%r20),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcpy,%r2
nop
ldw 8(%r4),%r26
copy %r0,%r25
copy %r0,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl lookup_typename,%r2
nop
bl,n L$0085,%r0
L$0085:
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
LC$0005:
.STRING "signed \x00"
.align 4
.EXPORT lookup_signed_typename,CODE
.EXPORT lookup_signed_typename,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
lookup_signed_typename:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl strlen,%r2
nop
copy %r28,%r19
ldo 8(%r19),%r20
ldo 7(%r20),%r21
copy %r21,%r19
ldo 63(%r19),%r20
extru %r20,25,26,%r19
zdep %r19,25,26,%r20
ldo -96(%r30),%r19
add %r30,%r20,%r30
ldo 7(%r19),%r20
extru %r20,28,29,%r19
zdep %r19,28,29,%r20
stw %r20,12(%r4)
ldw 12(%r4),%r26
ldil L'LC$0005,%r25
ldo R'LC$0005(%r25),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcpy,%r2
nop
ldw 12(%r4),%r20
ldo 7(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
copy %r19,%r26
ldw 0(%r20),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcpy,%r2
nop
ldw 12(%r4),%r26
copy %r0,%r25
ldo 1(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl lookup_typename,%r2
nop
stw %r28,8(%r4)
ldw 8(%r4),%r19
comiclr,<> 0,%r19,%r0
bl L$0087,%r0
nop
ldw 8(%r4),%r28
bl,n L$0086,%r0
L$0087:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
copy %r0,%r25
copy %r0,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl lookup_typename,%r2
nop
bl,n L$0086,%r0
L$0086:
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
LC$0006:
.STRING "No struct type named %s.\x00"
.align 4
LC$0007:
.STRING "This context has class, union or enum %s, not a struct.\x00"
.align 4
.EXPORT lookup_struct,CODE
.EXPORT lookup_struct,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
lookup_struct:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r9,8(%r4)
stw %r8,12(%r4)
stw %r7,16(%r4)
stw %r6,20(%r4)
stw %r5,24(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
stw %r0,-52(%r30)
ldw 0(%r19),%r26
ldw 0(%r20),%r25
ldo 2(%r0),%r24
copy %r0,%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl lookup_symbol,%r2
nop
copy %r28,%r9
comiclr,= 0,%r9,%r0
bl L$0089,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0006,%r26
ldo R'LC$0006(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0089:
ldw 12(%r9),%r19
ldw 0(%r19),%r20
comiclr,<> 3,%r20,%r0
bl L$0090,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0007,%r26
ldo R'LC$0007(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0090:
ldw 12(%r9),%r28
bl,n L$0088,%r0
L$0088:
ldw 8(%r4),%r9
ldw 12(%r4),%r8
ldw 16(%r4),%r7
ldw 20(%r4),%r6
ldw 24(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
LC$0008:
.STRING "No union type named %s.\x00"
.align 4
LC$0009:
.STRING "This context has class, struct or enum %s, not a union.\x00"
.align 4
.EXPORT lookup_union,CODE
.EXPORT lookup_union,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
lookup_union:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r9,8(%r4)
stw %r8,12(%r4)
stw %r7,16(%r4)
stw %r6,20(%r4)
stw %r5,24(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
stw %r0,-52(%r30)
ldw 0(%r19),%r26
ldw 0(%r20),%r25
ldo 2(%r0),%r24
copy %r0,%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl lookup_symbol,%r2
nop
copy %r28,%r9
comiclr,= 0,%r9,%r0
bl L$0092,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0008,%r26
ldo R'LC$0008(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0092:
ldw 12(%r9),%r19
ldw 0(%r19),%r20
comiclr,<> 4,%r20,%r0
bl L$0093,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0009,%r26
ldo R'LC$0009(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0093:
ldw 12(%r9),%r28
bl,n L$0091,%r0
L$0091:
ldw 8(%r4),%r9
ldw 12(%r4),%r8
ldw 16(%r4),%r7
ldw 20(%r4),%r6
ldw 24(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
LC$0010:
.STRING "No enum type named %s.\x00"
.align 4
LC$0011:
.STRING "This context has class, struct or union %s, not an enum.\x00"
.align 4
.EXPORT lookup_enum,CODE
.EXPORT lookup_enum,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
lookup_enum:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r9,8(%r4)
stw %r8,12(%r4)
stw %r7,16(%r4)
stw %r6,20(%r4)
stw %r5,24(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
stw %r0,-52(%r30)
ldw 0(%r19),%r26
ldw 0(%r20),%r25
ldo 2(%r0),%r24
copy %r0,%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl lookup_symbol,%r2
nop
copy %r28,%r9
comiclr,= 0,%r9,%r0
bl L$0095,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0010,%r26
ldo R'LC$0010(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0095:
ldw 12(%r9),%r19
ldw 0(%r19),%r20
comiclr,<> 5,%r20,%r0
bl L$0096,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0011,%r26
ldo R'LC$0011(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0096:
ldw 12(%r9),%r28
bl,n L$0094,%r0
L$0094:
ldw 8(%r4),%r9
ldw 12(%r4),%r8
ldw 16(%r4),%r7
ldw 20(%r4),%r6
ldw 24(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT strcat,CODE
.align 4
LC$0012:
.STRING "<\x00"
.align 4
LC$0013:
.STRING " >\x00"
.align 4
LC$0014:
.STRING "No template type named %s.\x00"
.align 4
.EXPORT lookup_template_type,CODE
.EXPORT lookup_template_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,RTNVAL=GR
lookup_template_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r11,16(%r4)
stw %r10,20(%r4)
stw %r9,24(%r4)
stw %r8,28(%r4)
stw %r7,32(%r4)
stw %r6,36(%r4)
stw %r5,40(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -12(%r0),%r9
ldo -32(%r4),%r19
add %r19,%r9,%r10
stw %r24,0(%r10)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl strlen,%r2
nop
copy %r28,%r11
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 4(%r19),%r26
.CALL ARGW0=GR
bl strlen,%r2
nop
copy %r28,%r19
add %r11,%r19,%r20
ldo 4(%r20),%r19
ldo 7(%r19),%r20
copy %r20,%r19
ldo 63(%r19),%r20
extru %r20,25,26,%r19
zdep %r19,25,26,%r20
ldo -96(%r30),%r19
add %r30,%r20,%r30
ldo 7(%r19),%r20
extru %r20,28,29,%r19
zdep %r19,28,29,%r20
stw %r20,12(%r4)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 12(%r4),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcpy,%r2
nop
ldw 12(%r4),%r26
ldil L'LC$0012,%r25
ldo R'LC$0012(%r25),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcat,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r4),%r26
ldw 4(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcat,%r2
nop
ldw 12(%r4),%r26
ldil L'LC$0013,%r25
ldo R'LC$0013(%r25),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcat,%r2
nop
ldo -12(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
stw %r0,-52(%r30)
ldw 12(%r4),%r26
ldw 0(%r19),%r25
ldo 1(%r0),%r24
copy %r0,%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl lookup_symbol,%r2
nop
stw %r28,8(%r4)
ldw 8(%r4),%r19
comiclr,= 0,%r19,%r0
bl L$0098,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0014,%r26
ldo R'LC$0014(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0098:
ldw 8(%r4),%r19
ldw 12(%r19),%r20
ldw 0(%r20),%r19
comiclr,<> 3,%r19,%r0
bl L$0099,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0007,%r26
ldo R'LC$0007(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0099:
ldw 8(%r4),%r19
ldw 12(%r19),%r28
bl,n L$0097,%r0
L$0097:
ldw 16(%r4),%r11
ldw 20(%r4),%r10
ldw 24(%r4),%r9
ldw 28(%r4),%r8
ldw 32(%r4),%r7
ldw 36(%r4),%r6
ldw 40(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT current_target,DATA
.IMPORT fflush,CODE
.IMPORT __iob,DATA
.IMPORT fprintf,CODE
.align 4
LC$0015:
.STRING "Type \x00"
.IMPORT type_print,CODE
.align 4
LC$0016:
.STRING "\x00"
.align 4
LC$0017:
.STRING " is not a structure or union type.\x00"
.IMPORT check_stub_type,CODE
.align 4
LC$0018:
.STRING " has no component named \x00"
.IMPORT fputs_filtered,CODE
.align 4
LC$0019:
.STRING ".\x00"
.align 4
.EXPORT lookup_struct_elt_type,CODE
.EXPORT lookup_struct_elt_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,RTNVAL=GR
lookup_struct_elt_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r11,24(%r4)
stw %r10,28(%r4)
stw %r9,32(%r4)
stw %r8,36(%r4)
stw %r7,40(%r4)
stw %r6,44(%r4)
stw %r5,48(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -12(%r0),%r9
ldo -32(%r4),%r19
add %r19,%r9,%r10
stw %r24,0(%r10)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,<> 1,%r20,%r0
bl L$0102,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
ldo 16(%r0),%r19
comclr,<> %r20,%r19,%r0
bl L$0102,%r0
nop
bl,n L$0101,%r0
L$0102:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 16(%r20),%r21
stw %r21,0(%r19)
L$0101:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,<> 3,%r20,%r0
bl L$0103,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,<> 4,%r20,%r0
bl L$0103,%r0
nop
addil L'current_target-$global$,%r27
ldw R'current_target-$global$(%r1),%r19
ldw 76(%r19),%r11
copy %r11,%r22
.CALL ARGW0=GR
bl $$dyncall,%r31
copy %r31,%r2
addil L'__iob-$global$+16,%r27
ldo R'__iob-$global$+16(%r1),%r26
.CALL ARGW0=GR
bl fflush,%r2
nop
addil L'__iob-$global$+32,%r27
ldo R'__iob-$global$+32(%r1),%r26
ldil L'LC$0015,%r25
ldo R'LC$0015(%r25),%r25
.CALL ARGW0=GR,ARGW1=GR
bl fprintf,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
ldil L'LC$0016,%r25
ldo R'LC$0016(%r25),%r25
addil L'__iob-$global$+32,%r27
ldo R'__iob-$global$+32(%r1),%r24
ldo -1(%r0),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl type_print,%r2
nop
ldil L'LC$0017,%r26
ldo R'LC$0017(%r26),%r26
.CALL ARGW0=GR
bl error,%r2
nop
L$0103:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl check_stub_type,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldh 34(%r19),%r20
extrs %r20,31,16,%r19
ldo -1(%r19),%r20
stw %r20,8(%r4)
L$0104:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldh 0(%r20),%r21
extrs %r21,31,16,%r19
ldw 8(%r4),%r20
comclr,>= %r20,%r19,%r0
bl L$0105,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
zdep %r20,27,28,%r21
ldw 36(%r19),%r20
add %r21,%r20,%r19
ldw 12(%r19),%r20
stw %r20,12(%r4)
ldw 12(%r4),%r19
comiclr,<> 0,%r19,%r0
bl L$0107,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 12(%r4),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strcmp,%r2
nop
copy %r28,%r19
comiclr,= 0,%r19,%r0
bl L$0107,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
zdep %r20,27,28,%r21
ldw 36(%r19),%r20
add %r21,%r20,%r19
ldw 8(%r19),%r28
bl,n L$0100,%r0
L$0107:
L$0106:
ldw 8(%r4),%r19
ldo -1(%r19),%r20
stw %r20,8(%r4)
bl,n L$0104,%r0
L$0105:
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldh 0(%r20),%r21
extrs %r21,31,16,%r19
ldo -1(%r19),%r20
stw %r20,8(%r4)
L$0108:
ldw 8(%r4),%r19
comiclr,<= 0,%r19,%r0
bl L$0109,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
zdep %r20,27,28,%r21
ldw 36(%r19),%r20
add %r21,%r20,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 8(%r19),%r26
ldw 0(%r20),%r25
copy %r0,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl lookup_struct_elt_type,%r2
nop
stw %r28,16(%r4)
ldw 16(%r4),%r19
comiclr,<> 0,%r19,%r0
bl L$0111,%r0
nop
ldw 16(%r4),%r28
bl,n L$0100,%r0
L$0111:
L$0110:
ldw 8(%r4),%r19
ldo -1(%r19),%r20
stw %r20,8(%r4)
bl,n L$0108,%r0
L$0109:
ldo -12(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0112,%r0
nop
copy %r0,%r28
bl,n L$0100,%r0
L$0112:
addil L'current_target-$global$,%r27
ldw R'current_target-$global$(%r1),%r19
ldw 76(%r19),%r11
copy %r11,%r22
.CALL ARGW0=GR
bl $$dyncall,%r31
copy %r31,%r2
addil L'__iob-$global$+16,%r27
ldo R'__iob-$global$+16(%r1),%r26
.CALL ARGW0=GR
bl fflush,%r2
nop
addil L'__iob-$global$+32,%r27
ldo R'__iob-$global$+32(%r1),%r26
ldil L'LC$0015,%r25
ldo R'LC$0015(%r25),%r25
.CALL ARGW0=GR,ARGW1=GR
bl fprintf,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
ldil L'LC$0016,%r25
ldo R'LC$0016(%r25),%r25
addil L'__iob-$global$+32,%r27
ldo R'__iob-$global$+32(%r1),%r24
ldo -1(%r0),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl type_print,%r2
nop
addil L'__iob-$global$+32,%r27
ldo R'__iob-$global$+32(%r1),%r26
ldil L'LC$0018,%r25
ldo R'LC$0018(%r25),%r25
.CALL ARGW0=GR,ARGW1=GR
bl fprintf,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
addil L'__iob-$global$+32,%r27
ldo R'__iob-$global$+32(%r1),%r25
.CALL ARGW0=GR,ARGW1=GR
bl fputs_filtered,%r2
nop
ldil L'LC$0019,%r26
ldo R'LC$0019(%r26),%r26
.CALL ARGW0=GR
bl error,%r2
nop
ldo -1(%r0),%r28
bl,n L$0100,%r0
L$0100:
ldw 24(%r4),%r11
ldw 28(%r4),%r10
ldw 32(%r4),%r9
ldw 36(%r4),%r8
ldw 40(%r4),%r7
ldw 44(%r4),%r6
ldw 48(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT fill_in_vptr_fieldno,CODE
.EXPORT fill_in_vptr_fieldno,ENTRY,PRIV_LEV=3,ARGW0=GR
fill_in_vptr_fieldno:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 44(%r19),%r20
comiclr,> 0,%r20,%r0
bl L$0114,%r0
nop
ldo 1(%r0),%r19
stw %r19,8(%r4)
L$0115:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldh 0(%r20),%r21
extrs %r21,31,16,%r19
ldw 8(%r4),%r20
comclr,< %r20,%r19,%r0
bl L$0116,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
zdep %r20,27,28,%r21
ldw 36(%r19),%r20
add %r21,%r20,%r19
ldw 8(%r19),%r26
.CALL ARGW0=GR
bl fill_in_vptr_fieldno,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
zdep %r20,27,28,%r21
ldw 36(%r19),%r20
add %r21,%r20,%r19
ldw 8(%r19),%r20
ldw 44(%r20),%r19
comiclr,<= 0,%r19,%r0
bl L$0118,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 8(%r4),%r21
zdep %r21,27,28,%r22
ldw 36(%r20),%r21
add %r22,%r21,%r20
ldw 8(%r20),%r21
ldw 44(%r21),%r20
stw %r20,44(%r19)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 8(%r4),%r21
zdep %r21,27,28,%r22
ldw 36(%r20),%r21
add %r22,%r21,%r20
ldw 8(%r20),%r21
ldw 40(%r21),%r20
stw %r20,40(%r19)
bl,n L$0116,%r0
L$0118:
L$0117:
ldw 8(%r4),%r19
ldo 1(%r19),%r20
stw %r20,8(%r4)
bl,n L$0115,%r0
L$0116:
L$0114:
L$0113:
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.EXPORT stub_noname_complaint,DATA
.align 4
LC$0020:
.STRING "stub type has NULL name\x00"
.data
 
.align 4
stub_noname_complaint:
.word LC$0020
.word 0
.word 0
.IMPORT complain,CODE
.IMPORT memcpy,CODE
.code
 
.align 4
.EXPORT check_stub_type,CODE
.EXPORT check_stub_type,ENTRY,PRIV_LEV=3,ARGW0=GR
check_stub_type:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldh 32(%r19),%r20
ldo 4(%r0),%r21
and %r20,%r21,%r19
extrs %r19,31,16,%r20
comiclr,<> 0,%r20,%r0
bl L$0120,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl type_name_no_tag,%r2
nop
stw %r28,8(%r4)
ldw 8(%r4),%r19
comiclr,= 0,%r19,%r0
bl L$0121,%r0
nop
addil L'stub_noname_complaint-$global$,%r27
ldo R'stub_noname_complaint-$global$(%r1),%r26
copy %r0,%r25
.CALL ARGW0=GR,ARGW1=GR
bl complain,%r2
nop
bl,n L$0119,%r0
L$0121:
stw %r0,-52(%r30)
ldw 8(%r4),%r26
copy %r0,%r25
ldo 2(%r0),%r24
copy %r0,%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl lookup_symbol,%r2
nop
stw %r28,12(%r4)
ldw 12(%r4),%r19
comiclr,<> 0,%r19,%r0
bl L$0122,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 12(%r4),%r20
ldw 0(%r19),%r26
ldw 12(%r20),%r25
ldo 52(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memcpy,%r2
nop
L$0122:
L$0120:
L$0119:
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT gdb_mangle_name,CODE
.IMPORT cplus_demangle,CODE
.align 4
LC$0021:
.STRING "Internal: Cannot demangle mangled name `%s'.\x00"
.IMPORT strchr,CODE
.IMPORT parse_and_eval_type,CODE
.IMPORT builtin_type_void,DATA
.IMPORT free,CODE
.align 4
.EXPORT check_stub_method,CODE
.EXPORT check_stub_method,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR
check_stub_method:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r11,64(%r4)
stw %r10,68(%r4)
stw %r9,72(%r4)
stw %r8,76(%r4)
stw %r7,80(%r4)
stw %r6,84(%r4)
stw %r5,88(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -12(%r0),%r9
ldo -32(%r4),%r19
add %r19,%r9,%r10
stw %r24,0(%r10)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldo -12(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r19),%r26
ldw 0(%r20),%r25
ldw 0(%r21),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl gdb_mangle_name,%r2
nop
stw %r28,12(%r4)
ldw 12(%r4),%r26
ldo 3(%r0),%r25
.CALL ARGW0=GR,ARGW1=GR
bl cplus_demangle,%r2
nop
stw %r28,16(%r4)
stw %r0,28(%r4)
ldo 1(%r0),%r19
stw %r19,32(%r4)
ldw 16(%r4),%r19
comiclr,= 0,%r19,%r0
bl L$0124,%r0
nop
ldil L'LC$0021,%r26
ldo R'LC$0021(%r26),%r26
ldw 12(%r4),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
L$0124:
ldw 16(%r4),%r26
ldo 40(%r0),%r25
.CALL ARGW0=GR,ARGW1=GR
bl strchr,%r2
nop
copy %r28,%r19
ldo 1(%r19),%r20
stw %r20,20(%r4)
ldw 20(%r4),%r19
stw %r19,24(%r4)
L$0125:
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
comiclr,<> 0,%r19,%r0
bl L$0126,%r0
nop
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 40(%r0),%r20
comclr,= %r19,%r20,%r0
bl L$0127,%r0
nop
ldw 28(%r4),%r19
ldo 1(%r19),%r20
stw %r20,28(%r4)
bl,n L$0128,%r0
L$0127:
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 41(%r0),%r20
comclr,= %r19,%r20,%r0
bl L$0129,%r0
nop
ldw 28(%r4),%r19
ldo -1(%r19),%r20
stw %r20,28(%r4)
bl,n L$0130,%r0
L$0129:
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 44(%r0),%r20
comclr,= %r19,%r20,%r0
bl L$0131,%r0
nop
ldw 28(%r4),%r19
comiclr,= 0,%r19,%r0
bl L$0131,%r0
nop
ldw 32(%r4),%r19
ldo 1(%r19),%r20
stw %r20,32(%r4)
L$0131:
L$0130:
L$0128:
ldw 24(%r4),%r19
ldo 1(%r19),%r20
stw %r20,24(%r4)
bl,n L$0125,%r0
L$0126:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0137,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r20
ldo 120(%r20),%r19
stw %r19,44(%r4)
ldw 44(%r4),%r19
stw %r19,48(%r4)
ldw 32(%r4),%r20
ldo 2(%r20),%r19
zdep %r19,29,30,%r20
stw %r20,52(%r4)
ldw 48(%r4),%r19
ldw 48(%r4),%r20
ldw 16(%r19),%r19
ldw 12(%r20),%r20
sub %r19,%r20,%r19
ldw 52(%r4),%r20
comclr,< %r19,%r20,%r0
bl L$0132,%r0
nop
ldw 48(%r4),%r26
ldw 52(%r4),%r25
.CALL ARGW0=GR,ARGW1=GR
bl _obstack_newchunk,%r2
nop
copy %r0,%r19
bl,n L$0133,%r0
L$0132:
copy %r0,%r19
L$0133:
ldw 48(%r4),%r19
ldw 48(%r4),%r20
ldw 12(%r20),%r21
ldw 52(%r4),%r22
add %r21,%r22,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 44(%r4),%r19
stw %r19,56(%r4)
ldw 56(%r4),%r19
ldw 8(%r19),%r20
stw %r20,60(%r4)
ldw 56(%r4),%r19
ldw 12(%r19),%r20
ldw 60(%r4),%r19
comclr,= %r20,%r19,%r0
bl L$0134,%r0
nop
ldw 56(%r4),%r19
ldw 40(%r19),%r20
copy %r20,%r21
depi -1,1,1,%r21
stw %r21,40(%r19)
L$0134:
ldw 56(%r4),%r19
ldw 56(%r4),%r20
ldw 56(%r4),%r21
ldw 12(%r20),%r20
ldw 24(%r21),%r21
add %r20,%r21,%r20
ldw 56(%r4),%r21
ldw 24(%r21),%r22
uaddcm %r0,%r22,%r21
and %r20,%r21,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 56(%r4),%r19
ldw 56(%r4),%r20
ldw 12(%r19),%r19
ldw 4(%r20),%r20
sub %r19,%r20,%r19
ldw 56(%r4),%r20
ldw 56(%r4),%r21
ldw 16(%r20),%r20
ldw 4(%r21),%r21
sub %r20,%r21,%r20
comclr,> %r19,%r20,%r0
bl L$0135,%r0
nop
ldw 56(%r4),%r19
ldw 56(%r4),%r20
ldw 16(%r20),%r21
stw %r21,12(%r19)
copy %r21,%r19
bl,n L$0136,%r0
L$0135:
copy %r0,%r19
L$0136:
ldw 56(%r4),%r19
ldw 56(%r4),%r20
ldw 12(%r20),%r21
stw %r21,8(%r19)
ldw 60(%r4),%r11
bl,n L$0138,%r0
L$0137:
ldw 32(%r4),%r20
ldo 2(%r20),%r19
zdep %r19,29,30,%r20
copy %r20,%r26
.CALL ARGW0=GR
bl xmalloc,%r2
nop
copy %r28,%r11
L$0138:
stw %r11,36(%r4)
ldw 20(%r4),%r19
stw %r19,24(%r4)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl lookup_pointer_type,%r2
nop
copy %r28,%r19
ldw 36(%r4),%r20
stw %r19,0(%r20)
ldo 1(%r0),%r19
stw %r19,32(%r4)
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 41(%r0),%r20
comclr,<> %r19,%r20,%r0
bl L$0139,%r0
nop
stw %r0,28(%r4)
L$0140:
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
comiclr,<> 0,%r19,%r0
bl L$0141,%r0
nop
ldw 28(%r4),%r19
comiclr,>= 0,%r19,%r0
bl L$0142,%r0
nop
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 44(%r0),%r20
comclr,<> %r19,%r20,%r0
bl L$0143,%r0
nop
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 41(%r0),%r20
comclr,<> %r19,%r20,%r0
bl L$0143,%r0
nop
bl,n L$0142,%r0
L$0143:
ldw 24(%r4),%r19
ldw 20(%r4),%r20
sub %r19,%r20,%r19
ldw 20(%r4),%r26
copy %r19,%r25
.CALL ARGW0=GR,ARGW1=GR
bl parse_and_eval_type,%r2
nop
copy %r28,%r19
ldw 32(%r4),%r20
zdep %r20,29,30,%r21
ldw 36(%r4),%r22
add %r21,%r22,%r20
stw %r19,0(%r20)
ldw 32(%r4),%r19
ldo 1(%r19),%r20
stw %r20,32(%r4)
ldw 24(%r4),%r19
ldo 1(%r19),%r20
stw %r20,20(%r4)
L$0142:
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 40(%r0),%r20
comclr,= %r19,%r20,%r0
bl L$0144,%r0
nop
ldw 28(%r4),%r19
ldo 1(%r19),%r20
stw %r20,28(%r4)
bl,n L$0145,%r0
L$0144:
ldw 24(%r4),%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 41(%r0),%r20
comclr,= %r19,%r20,%r0
bl L$0146,%r0
nop
ldw 28(%r4),%r19
ldo -1(%r19),%r20
stw %r20,28(%r4)
L$0146:
L$0145:
ldw 24(%r4),%r19
ldo 1(%r19),%r20
stw %r20,24(%r4)
bl,n L$0140,%r0
L$0141:
L$0139:
ldo -2(%r0),%r19
ldw 24(%r4),%r20
add %r19,%r20,%r19
ldb 0(%r19),%r20
extrs %r20,31,8,%r19
ldo 46(%r0),%r20
comclr,<> %r19,%r20,%r0
bl L$0147,%r0
nop
ldw 32(%r4),%r19
zdep %r19,29,30,%r20
ldw 36(%r4),%r21
add %r20,%r21,%r19
addil L'builtin_type_void-$global$,%r27
ldw R'builtin_type_void-$global$(%r1),%r20
stw %r20,0(%r19)
bl,n L$0148,%r0
L$0147:
ldw 32(%r4),%r19
zdep %r19,29,30,%r20
ldw 36(%r4),%r21
add %r20,%r21,%r19
stw %r0,0(%r19)
L$0148:
ldw 16(%r4),%r26
.CALL ARGW0=GR
bl free,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 48(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
zdep %r21,30,31,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 20(%r19),%r21
add %r20,%r21,%r19
ldw 8(%r19),%r20
stw %r20,8(%r4)
ldo -12(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
zdep %r20,29,30,%r19
add %r19,%r20,%r19
zdep %r19,29,30,%r19
ldw 8(%r4),%r20
add %r19,%r20,%r19
ldw 12(%r4),%r20
stw %r20,0(%r19)
ldo -12(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
zdep %r20,29,30,%r19
add %r19,%r20,%r19
zdep %r19,29,30,%r19
ldw 8(%r4),%r20
add %r19,%r20,%r19
ldw 4(%r19),%r20
stw %r20,40(%r4)
ldw 40(%r4),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
stw %r21,40(%r19)
ldw 40(%r4),%r19
ldw 36(%r4),%r20
stw %r20,48(%r19)
ldw 40(%r4),%r19
ldw 40(%r4),%r20
ldh 32(%r20),%r21
copy %r21,%r20
depi 0,29,1,%r20
sth %r20,32(%r19)
ldo -12(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
zdep %r20,29,30,%r19
add %r19,%r20,%r19
zdep %r19,29,30,%r19
ldw 8(%r4),%r20
add %r19,%r20,%r19
ldw 16(%r19),%r20
copy %r20,%r21
depi 0,4,1,%r21
stw %r21,16(%r19)
L$0123:
ldw 64(%r4),%r11
ldw 68(%r4),%r10
ldw 72(%r4),%r9
ldw 76(%r4),%r8
ldw 80(%r4),%r7
ldw 84(%r4),%r6
ldw 88(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT allocate_cplus_struct_type,CODE
.EXPORT allocate_cplus_struct_type,ENTRY,PRIV_LEV=3,ARGW0=GR
allocate_cplus_struct_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r8,32(%r4)
stw %r7,36(%r4)
stw %r6,40(%r4)
stw %r5,44(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 48(%r20),%r19
comclr,= %r19,%r20,%r0
bl L$0150,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r7
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0156,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 12(%r19),%r20
ldo 120(%r20),%r19
stw %r19,8(%r4)
ldw 8(%r4),%r19
stw %r19,12(%r4)
ldo 24(%r0),%r19
stw %r19,16(%r4)
ldw 12(%r4),%r19
ldw 12(%r4),%r20
ldw 16(%r19),%r19
ldw 12(%r20),%r20
sub %r19,%r20,%r19
ldw 16(%r4),%r20
comclr,< %r19,%r20,%r0
bl L$0151,%r0
nop
ldw 12(%r4),%r26
ldw 16(%r4),%r25
.CALL ARGW0=GR,ARGW1=GR
bl _obstack_newchunk,%r2
nop
copy %r0,%r19
bl,n L$0152,%r0
L$0151:
copy %r0,%r19
L$0152:
ldw 12(%r4),%r19
ldw 12(%r4),%r20
ldw 12(%r20),%r21
ldw 16(%r4),%r22
add %r21,%r22,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 8(%r4),%r19
stw %r19,20(%r4)
ldw 20(%r4),%r19
ldw 8(%r19),%r20
stw %r20,24(%r4)
ldw 20(%r4),%r19
ldw 12(%r19),%r20
ldw 24(%r4),%r19
comclr,= %r20,%r19,%r0
bl L$0153,%r0
nop
ldw 20(%r4),%r19
ldw 40(%r19),%r20
copy %r20,%r21
depi -1,1,1,%r21
stw %r21,40(%r19)
L$0153:
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 20(%r4),%r21
ldw 12(%r20),%r20
ldw 24(%r21),%r21
add %r20,%r21,%r20
ldw 20(%r4),%r21
ldw 24(%r21),%r22
uaddcm %r0,%r22,%r21
and %r20,%r21,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 12(%r19),%r19
ldw 4(%r20),%r20
sub %r19,%r20,%r19
ldw 20(%r4),%r20
ldw 20(%r4),%r21
ldw 16(%r20),%r20
ldw 4(%r21),%r21
sub %r20,%r21,%r20
comclr,> %r19,%r20,%r0
bl L$0154,%r0
nop
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 16(%r20),%r21
stw %r21,12(%r19)
copy %r21,%r19
bl,n L$0155,%r0
L$0154:
copy %r0,%r19
L$0155:
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 12(%r20),%r21
stw %r21,8(%r19)
ldw 24(%r4),%r8
bl,n L$0157,%r0
L$0156:
ldo 24(%r0),%r26
.CALL ARGW0=GR
bl xmalloc,%r2
nop
copy %r28,%r8
L$0157:
stw %r8,48(%r7)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
copy %r20,%r21
ldws,ma 4(%r22),%r19
ldws,ma 4(%r22),%r20
stws,ma %r19,4(%r21)
ldws,ma 4(%r22),%r19
stws,ma %r20,4(%r21)
ldws,ma 4(%r22),%r20
stws,ma %r19,4(%r21)
ldws,ma 4(%r22),%r19
stws,ma %r20,4(%r21)
ldws,ma 4(%r22),%r20
stws,ma %r19,4(%r21)
stw %r20,0(%r21)
L$0150:
L$0149:
ldw 32(%r4),%r8
ldw 36(%r4),%r7
ldw 40(%r4),%r6
ldw 44(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT obsavestring,CODE
.align 4
.EXPORT init_type,CODE
.EXPORT init_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR,RTNVAL=GR
init_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r14,8(%r4)
stw %r13,12(%r4)
stw %r12,16(%r4)
stw %r11,20(%r4)
stw %r10,24(%r4)
stw %r9,28(%r4)
stw %r8,32(%r4)
stw %r7,36(%r4)
stw %r6,40(%r4)
stw %r5,44(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -12(%r0),%r9
ldo -32(%r4),%r19
add %r19,%r9,%r10
stw %r24,0(%r10)
ldo -16(%r0),%r11
ldo -32(%r4),%r19
add %r19,%r11,%r12
stw %r23,0(%r12)
ldo -20(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl alloc_type,%r2
nop
copy %r28,%r13
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,0(%r13)
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,8(%r13)
ldo -12(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldh 32(%r13),%r20
ldh 2(%r19),%r19
or %r20,%r19,%r20
sth %r20,32(%r13)
ldo -16(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0159,%r0
nop
ldo -20(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0159,%r0
nop
ldo -16(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r14
ldo -16(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r26
.CALL ARGW0=GR
bl strlen,%r2
nop
copy %r28,%r19
ldo -20(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldo 120(%r21),%r20
ldw 0(%r14),%r26
copy %r19,%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl obsavestring,%r2
nop
copy %r28,%r19
stw %r19,4(%r13)
bl,n L$0160,%r0
L$0159:
ldo -16(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,4(%r13)
L$0160:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 3,%r20,%r0
bl L$0162,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 4,%r20,%r0
bl L$0162,%r0
nop
bl,n L$0161,%r0
L$0162:
stw %r19,48(%r13)
L$0161:
copy %r13,%r28
bl,n L$0158,%r0
L$0158:
ldw 8(%r4),%r14
ldw 12(%r4),%r13
ldw 16(%r4),%r12
ldw 20(%r4),%r11
ldw 24(%r4),%r10
ldw 28(%r4),%r9
ldw 32(%r4),%r8
ldw 36(%r4),%r7
ldw 40(%r4),%r6
ldw 44(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
LC$0022:
.STRING "internal error - invalid fundamental type id %d\x00"
.align 4
LC$0023:
.STRING "internal error: unhandled type id %d\x00"
.align 4
LC$0024:
.STRING "void\x00"
.align 4
LC$0025:
.STRING "boolean\x00"
.align 4
LC$0026:
.STRING "string\x00"
.align 4
LC$0027:
.STRING "char\x00"
.align 4
LC$0028:
.STRING "signed char\x00"
.align 4
LC$0029:
.STRING "unsigned char\x00"
.align 4
LC$0030:
.STRING "short\x00"
.align 4
LC$0031:
.STRING "unsigned short\x00"
.align 4
LC$0032:
.STRING "int\x00"
.align 4
LC$0033:
.STRING "unsigned int\x00"
.align 4
LC$0034:
.STRING "fixed decimal\x00"
.align 4
LC$0035:
.STRING "long\x00"
.align 4
LC$0036:
.STRING "unsigned long\x00"
.align 4
LC$0037:
.STRING "long long\x00"
.align 4
LC$0038:
.STRING "signed long long\x00"
.align 4
LC$0039:
.STRING "unsigned long long\x00"
.align 4
LC$0040:
.STRING "float\x00"
.align 4
LC$0041:
.STRING "double\x00"
.align 4
LC$0042:
.STRING "floating decimal\x00"
.align 4
LC$0043:
.STRING "long double\x00"
.align 4
LC$0044:
.STRING "complex\x00"
.align 4
LC$0045:
.STRING "double complex\x00"
.align 4
LC$0046:
.STRING "long double complex\x00"
.align 4
.EXPORT lookup_fundamental_type,CODE
.EXPORT lookup_fundamental_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,RTNVAL=GR
lookup_fundamental_type:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r12,32(%r4)
stw %r11,36(%r4)
stw %r10,40(%r4)
stw %r9,44(%r4)
stw %r8,48(%r4)
stw %r7,52(%r4)
stw %r6,56(%r4)
stw %r5,60(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
copy %r0,%r9
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<= 0,%r20,%r0
bl L$0165,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 25(%r0),%r19
comclr,<= %r20,%r19,%r0
bl L$0165,%r0
nop
bl,n L$0164,%r0
L$0165:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0022,%r26
ldo R'LC$0022(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
bl,n L$0166,%r0
L$0164:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 196(%r19),%r20
comiclr,= 0,%r20,%r0
bl L$0167,%r0
nop
ldo 104(%r0),%r11
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r12
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo 120(%r19),%r20
stw %r20,8(%r4)
ldw 8(%r4),%r19
stw %r19,12(%r4)
stw %r11,16(%r4)
ldw 12(%r4),%r19
ldw 12(%r4),%r20
ldw 16(%r19),%r19
ldw 12(%r20),%r20
sub %r19,%r20,%r19
ldw 16(%r4),%r20
comclr,< %r19,%r20,%r0
bl L$0168,%r0
nop
ldw 12(%r4),%r26
ldw 16(%r4),%r25
.CALL ARGW0=GR,ARGW1=GR
bl _obstack_newchunk,%r2
nop
copy %r0,%r19
bl,n L$0169,%r0
L$0168:
copy %r0,%r19
L$0169:
ldw 12(%r4),%r19
ldw 12(%r4),%r20
ldw 12(%r20),%r21
ldw 16(%r4),%r22
add %r21,%r22,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 8(%r4),%r19
stw %r19,20(%r4)
ldw 20(%r4),%r19
ldw 8(%r19),%r20
stw %r20,24(%r4)
ldw 20(%r4),%r19
ldw 12(%r19),%r20
ldw 24(%r4),%r19
comclr,= %r20,%r19,%r0
bl L$0170,%r0
nop
ldw 20(%r4),%r19
ldw 40(%r19),%r20
copy %r20,%r21
depi -1,1,1,%r21
stw %r21,40(%r19)
L$0170:
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 20(%r4),%r21
ldw 12(%r20),%r20
ldw 24(%r21),%r21
add %r20,%r21,%r20
ldw 20(%r4),%r21
ldw 24(%r21),%r22
uaddcm %r0,%r22,%r21
and %r20,%r21,%r20
copy %r20,%r21
stw %r21,12(%r19)
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 12(%r19),%r19
ldw 4(%r20),%r20
sub %r19,%r20,%r19
ldw 20(%r4),%r20
ldw 20(%r4),%r21
ldw 16(%r20),%r20
ldw 4(%r21),%r21
sub %r20,%r21,%r20
comclr,> %r19,%r20,%r0
bl L$0171,%r0
nop
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 16(%r20),%r21
stw %r21,12(%r19)
copy %r21,%r19
bl,n L$0172,%r0
L$0171:
copy %r0,%r19
L$0172:
ldw 20(%r4),%r19
ldw 20(%r4),%r20
ldw 12(%r20),%r21
stw %r21,8(%r19)
ldw 24(%r4),%r19
stw %r19,196(%r12)
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 196(%r19),%r26
copy %r0,%r25
copy %r11,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl memset,%r2
nop
L$0167:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
zdep %r21,29,30,%r20
ldw 196(%r19),%r19
add %r20,%r19,%r10
ldw 0(%r10),%r9
comiclr,= 0,%r9,%r0
bl L$0173,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
addi,uv -26,%r20,%r0
blr,n %r20,%r0
b,n L$0175
L$0202:
b L$0176
nop
b L$0177
nop
b L$0179
nop
b L$0180
nop
b L$0181
nop
b L$0182
nop
b L$0183
nop
b L$0184
nop
b L$0185
nop
b L$0186
nop
b L$0187
nop
b L$0189
nop
b L$0190
nop
b L$0191
nop
b L$0192
nop
b L$0193
nop
b L$0194
nop
b L$0195
nop
b L$0196
nop
b L$0198
nop
b L$0199
nop
b L$0200
nop
b L$0201
nop
b L$0178
nop
b L$0188
nop
b L$0197
nop
L$0175:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldil L'LC$0023,%r26
ldo R'LC$0023(%r26),%r26
ldw 0(%r19),%r25
.CALL ARGW0=GR,ARGW1=GR
bl error,%r2
nop
bl,n L$0174,%r0
L$0176:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 9(%r0),%r26
ldo 1(%r0),%r25
copy %r0,%r24
ldil L'LC$0024,%r23
ldo R'LC$0024(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0177:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
ldo 1(%r0),%r24
ldil L'LC$0025,%r23
ldo R'LC$0025(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0178:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 12(%r0),%r26
ldo 1(%r0),%r25
copy %r0,%r24
ldil L'LC$0026,%r23
ldo R'LC$0026(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0179:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 1(%r0),%r25
copy %r0,%r24
ldil L'LC$0027,%r23
ldo R'LC$0027(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0180:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 1(%r0),%r25
ldo 2(%r0),%r24
ldil L'LC$0028,%r23
ldo R'LC$0028(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0181:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 1(%r0),%r25
ldo 1(%r0),%r24
ldil L'LC$0029,%r23
ldo R'LC$0029(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0182:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 2(%r0),%r25
copy %r0,%r24
ldil L'LC$0030,%r23
ldo R'LC$0030(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0183:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 2(%r0),%r25
ldo 2(%r0),%r24
ldil L'LC$0030,%r23
ldo R'LC$0030(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0184:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 2(%r0),%r25
ldo 1(%r0),%r24
ldil L'LC$0031,%r23
ldo R'LC$0031(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0185:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
copy %r0,%r24
ldil L'LC$0032,%r23
ldo R'LC$0032(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0186:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
ldo 2(%r0),%r24
ldil L'LC$0032,%r23
ldo R'LC$0032(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0187:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
ldo 1(%r0),%r24
ldil L'LC$0033,%r23
ldo R'LC$0033(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0188:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
copy %r0,%r24
ldil L'LC$0034,%r23
ldo R'LC$0034(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0189:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
copy %r0,%r24
ldil L'LC$0035,%r23
ldo R'LC$0035(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0190:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
ldo 2(%r0),%r24
ldil L'LC$0035,%r23
ldo R'LC$0035(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0191:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 4(%r0),%r25
ldo 1(%r0),%r24
ldil L'LC$0036,%r23
ldo R'LC$0036(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0192:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 8(%r0),%r25
copy %r0,%r24
ldil L'LC$0037,%r23
ldo R'LC$0037(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0193:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 8(%r0),%r25
ldo 2(%r0),%r24
ldil L'LC$0038,%r23
ldo R'LC$0038(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0194:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 7(%r0),%r26
ldo 8(%r0),%r25
ldo 1(%r0),%r24
ldil L'LC$0039,%r23
ldo R'LC$0039(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0195:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 8(%r0),%r26
ldo 4(%r0),%r25
copy %r0,%r24
ldil L'LC$0040,%r23
ldo R'LC$0040(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0196:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 8(%r0),%r26
ldo 8(%r0),%r25
copy %r0,%r24
ldil L'LC$0041,%r23
ldo R'LC$0041(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0197:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 8(%r0),%r26
ldo 8(%r0),%r25
copy %r0,%r24
ldil L'LC$0042,%r23
ldo R'LC$0042(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0198:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 8(%r0),%r26
ldo 16(%r0),%r25
copy %r0,%r24
ldil L'LC$0043,%r23
ldo R'LC$0043(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0199:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 8(%r0),%r26
ldo 8(%r0),%r25
copy %r0,%r24
ldil L'LC$0044,%r23
ldo R'LC$0044(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0200:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 8(%r0),%r26
ldo 16(%r0),%r25
copy %r0,%r24
ldil L'LC$0045,%r23
ldo R'LC$0045(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0201:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
stw %r20,-52(%r30)
ldo 8(%r0),%r26
ldo 16(%r0),%r25
copy %r0,%r24
ldil L'LC$0046,%r23
ldo R'LC$0046(%r23),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl init_type,%r2
nop
copy %r28,%r9
bl,n L$0174,%r0
L$0174:
stw %r9,0(%r10)
L$0173:
L$0166:
copy %r9,%r28
bl,n L$0163,%r0
L$0163:
ldw 32(%r4),%r12
ldw 36(%r4),%r11
ldw 40(%r4),%r10
ldw 44(%r4),%r9
ldw 48(%r4),%r8
ldw 52(%r4),%r7
ldw 56(%r4),%r6
ldw 60(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT puts_filtered,CODE
.align 4
LC$0047:
.STRING " \x00"
.IMPORT printf_filtered,CODE
.align 4
LC$0048:
.STRING "1\x00"
.align 4
LC$0049:
.STRING "0\x00"
.align 4
print_bit_vector:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r8,16(%r4)
stw %r7,20(%r4)
stw %r6,24(%r4)
stw %r5,28(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
stw %r0,8(%r4)
L$0204:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 8(%r4),%r20
ldw 0(%r19),%r19
comclr,< %r20,%r19,%r0
bl L$0205,%r0
nop
ldw 8(%r4),%r19
ldw 8(%r4),%r20
comiclr,> 0,%r19,%r0
bl L$0208,%r0
nop
ldo 7(%r19),%r19
L$0208:
extrs %r19,28,29,%r19
zdep %r19,28,29,%r21
sub %r20,%r21,%r19
comiclr,= 0,%r19,%r0
bl L$0207,%r0
nop
ldil L'LC$0047,%r26
ldo R'LC$0047(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
L$0207:
ldw 8(%r4),%r20
extrs %r20,28,29,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
add %r19,%r21,%r20
ldb 0(%r20),%r19
ldw 8(%r4),%r20
extru %r20,31,3,%r21
subi,>>= 31,%r21,%r20
copy %r0,%r20
mtsar %r20
vextrs %r19,32,%r19
extru %r19,31,1,%r20
comiclr,<> 0,%r20,%r0
bl L$0209,%r0
nop
ldil L'LC$0048,%r26
ldo R'LC$0048(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0210,%r0
L$0209:
ldil L'LC$0049,%r26
ldo R'LC$0049(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
L$0210:
L$0206:
ldw 8(%r4),%r19
ldo 1(%r19),%r20
stw %r20,8(%r4)
bl,n L$0204,%r0
L$0205:
L$0203:
ldw 16(%r4),%r8
ldw 20(%r4),%r7
ldw 24(%r4),%r6
ldw 28(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT recursive_dump_type,CODE
.align 4
print_arg_types:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r8,8(%r4)
stw %r7,12(%r4)
stw %r6,16(%r4)
stw %r5,20(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0212,%r0
nop
L$0213:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0214,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldo 2(%r21),%r20
ldw 0(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl recursive_dump_type,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 4(%r20),%r21
stw %r21,0(%r19)
ldw 0(%r20),%r19
ldw 0(%r19),%r20
comiclr,= 9,%r20,%r0
bl L$0215,%r0
nop
bl,n L$0214,%r0
L$0215:
bl,n L$0213,%r0
L$0214:
L$0212:
L$0211:
ldw 8(%r4),%r8
ldw 12(%r4),%r7
ldw 16(%r4),%r6
ldw 20(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT printfi_filtered,CODE
.align 4
LC$0050:
.STRING "fn_fieldlists 0x%x\x0a\x00"
.align 4
LC$0051:
.STRING "[%d] name '%s' (0x%x) length %d\x0a\x00"
.align 4
LC$0052:
.STRING "[%d] physname '%s' (0x%x)\x0a\x00"
.align 4
LC$0053:
.STRING "type 0x%x\x0a\x00"
.align 4
LC$0054:
.STRING "args 0x%x\x0a\x00"
.align 4
LC$0055:
.STRING "fcontext 0x%x\x0a\x00"
.align 4
LC$0056:
.STRING "is_const %d\x0a\x00"
.align 4
LC$0057:
.STRING "is_volatile %d\x0a\x00"
.align 4
LC$0058:
.STRING "is_private %d\x0a\x00"
.align 4
LC$0059:
.STRING "is_protected %d\x0a\x00"
.align 4
LC$0060:
.STRING "is_stub %d\x0a\x00"
.align 4
LC$0061:
.STRING "voffset %u\x0a\x00"
.align 4
dump_fn_fieldlists:
.PROC
.CALLINFO FRAME=192,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,192(%r30)
stw %r8,24(%r4)
stw %r7,28(%r4)
stw %r6,32(%r4)
stw %r5,36(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldw 48(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0050,%r25
ldo R'LC$0050(%r25),%r25
ldw 20(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
stw %r0,8(%r4)
L$0217:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldh 2(%r20),%r21
extrs %r21,31,16,%r19
ldw 8(%r4),%r20
comclr,< %r20,%r19,%r0
bl L$0218,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 48(%r20),%r19
ldw 8(%r4),%r21
zdep %r21,30,31,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 20(%r19),%r21
add %r20,%r21,%r19
ldw 8(%r19),%r20
stw %r20,16(%r4)
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 2(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldw 48(%r21),%r20
ldw 8(%r4),%r22
zdep %r22,30,31,%r21
add %r21,%r22,%r21
zdep %r21,29,30,%r21
ldw 20(%r20),%r22
add %r21,%r22,%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
ldw 48(%r22),%r21
ldw 8(%r4),%r23
zdep %r23,30,31,%r22
add %r22,%r23,%r22
zdep %r22,29,30,%r22
ldw 20(%r21),%r23
add %r22,%r23,%r21
ldw 0(%r21),%r22
stw %r22,-52(%r30)
ldo -4(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
ldw 48(%r22),%r21
ldw 8(%r4),%r23
zdep %r23,30,31,%r22
add %r22,%r23,%r22
zdep %r22,29,30,%r22
ldw 20(%r21),%r23
add %r22,%r23,%r21
ldw 4(%r21),%r22
stw %r22,-56(%r30)
copy %r19,%r26
ldil L'LC$0051,%r25
ldo R'LC$0051(%r25),%r25
ldw 8(%r4),%r24
ldw 0(%r20),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
stw %r0,12(%r4)
L$0220:
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 48(%r20),%r19
ldw 8(%r4),%r21
zdep %r21,30,31,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 20(%r19),%r21
add %r20,%r21,%r19
ldw 12(%r4),%r20
ldw 4(%r19),%r19
comclr,< %r20,%r19,%r0
bl L$0221,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 4(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
ldw 12(%r4),%r22
zdep %r22,29,30,%r21
add %r21,%r22,%r21
zdep %r21,29,30,%r21
ldw 16(%r4),%r22
add %r21,%r22,%r21
ldw 0(%r21),%r22
stw %r22,-52(%r30)
copy %r19,%r26
ldil L'LC$0052,%r25
ldo R'LC$0052(%r25),%r25
ldw 12(%r4),%r24
ldw 0(%r20),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
copy %r19,%r26
ldil L'LC$0053,%r25
ldo R'LC$0053(%r25),%r25
ldw 4(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldw 12(%r4),%r20
zdep %r20,29,30,%r19
add %r19,%r20,%r19
zdep %r19,29,30,%r19
ldw 16(%r4),%r20
add %r19,%r20,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldo 10(%r21),%r20
ldw 4(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl recursive_dump_type,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r22
add %r20,%r22,%r21
ldw 4(%r21),%r20
copy %r19,%r26
ldil L'LC$0054,%r25
ldo R'LC$0054(%r25),%r25
ldw 48(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldw 12(%r4),%r20
zdep %r20,29,30,%r19
add %r19,%r20,%r19
zdep %r19,29,30,%r19
ldw 16(%r4),%r21
add %r19,%r21,%r20
ldw 4(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 48(%r19),%r26
ldw 0(%r20),%r25
.CALL ARGW0=GR,ARGW1=GR
bl print_arg_types,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
copy %r19,%r26
ldil L'LC$0055,%r25
ldo R'LC$0055(%r25),%r25
ldw 12(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
ldw 16(%r20),%r21
extru %r21,0+1-1,1,%r20
copy %r19,%r26
ldil L'LC$0056,%r25
ldo R'LC$0056(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
ldw 16(%r20),%r21
extru %r21,1+1-1,1,%r20
copy %r19,%r26
ldil L'LC$0057,%r25
ldo R'LC$0057(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
ldw 16(%r20),%r21
extru %r21,2+1-1,1,%r20
copy %r19,%r26
ldil L'LC$0058,%r25
ldo R'LC$0058(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
ldw 16(%r20),%r21
extru %r21,3+1-1,1,%r20
copy %r19,%r26
ldil L'LC$0059,%r25
ldo R'LC$0059(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
ldw 16(%r20),%r21
extru %r21,4+1-1,1,%r20
copy %r19,%r26
ldil L'LC$0060,%r25
ldo R'LC$0060(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 8(%r20),%r19
ldw 12(%r4),%r21
zdep %r21,29,30,%r20
add %r20,%r21,%r20
zdep %r20,29,30,%r20
ldw 16(%r4),%r21
add %r20,%r21,%r20
ldw 16(%r20),%r21
extru %r21,8+24-1,24,%r22
ldo -2(%r22),%r20
copy %r19,%r26
ldil L'LC$0061,%r25
ldo R'LC$0061(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
L$0222:
ldw 12(%r4),%r19
ldo 1(%r19),%r20
stw %r20,12(%r4)
bl,n L$0220,%r0
L$0221:
L$0219:
ldw 8(%r4),%r19
ldo 1(%r19),%r20
stw %r20,8(%r4)
bl,n L$0217,%r0
L$0218:
L$0216:
ldw 24(%r4),%r8
ldw 28(%r4),%r7
ldw 32(%r4),%r6
ldw 36(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
LC$0062:
.STRING "n_baseclasses %d\x0a\x00"
.align 4
LC$0063:
.STRING "nfn_fields %d\x0a\x00"
.align 4
LC$0064:
.STRING "nfn_fields_total %d\x0a\x00"
.align 4
LC$0065:
.STRING "virtual_field_bits (%d bits at *0x%x)\x00"
.align 4
LC$0066:
.STRING "\x0a\x00"
.align 4
LC$0067:
.STRING "private_field_bits (%d bits at *0x%x)\x00"
.align 4
LC$0068:
.STRING "protected_field_bits (%d bits at *0x%x)\x00"
.align 4
print_cplus_stuff:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r8,16(%r4)
stw %r7,20(%r4)
stw %r6,24(%r4)
stw %r5,28(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 48(%r20),%r21
ldh 0(%r21),%r22
extrs %r22,31,16,%r20
ldw 0(%r19),%r26
ldil L'LC$0062,%r25
ldo R'LC$0062(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 48(%r20),%r21
ldh 2(%r21),%r22
extrs %r22,31,16,%r20
ldw 0(%r19),%r26
ldil L'LC$0063,%r25
ldo R'LC$0063(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldw 48(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0064,%r25
ldo R'LC$0064(%r25),%r25
ldw 4(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldh 0(%r20),%r21
extrs %r21,31,16,%r19
comiclr,< 0,%r19,%r0
bl L$0224,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 48(%r20),%r21
ldh 0(%r21),%r22
extrs %r22,31,16,%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
ldw 48(%r22),%r21
ldw 0(%r19),%r26
ldil L'LC$0065,%r25
ldo R'LC$0065(%r25),%r25
copy %r20,%r24
ldw 8(%r21),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 48(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 48(%r20),%r21
ldh 0(%r21),%r22
extrs %r22,31,16,%r20
ldw 8(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl print_bit_vector,%r2
nop
ldil L'LC$0066,%r26
ldo R'LC$0066(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
L$0224:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldh 34(%r19),%r20
extrs %r20,31,16,%r19
comiclr,< 0,%r19,%r0
bl L$0225,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldw 12(%r20),%r19
comiclr,<> 0,%r19,%r0
bl L$0226,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldh 34(%r20),%r21
extrs %r21,31,16,%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
ldw 48(%r22),%r21
ldw 0(%r19),%r26
ldil L'LC$0067,%r25
ldo R'LC$0067(%r25),%r25
copy %r20,%r24
ldw 12(%r21),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 48(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldh 34(%r20),%r21
extrs %r21,31,16,%r20
ldw 12(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl print_bit_vector,%r2
nop
ldil L'LC$0066,%r26
ldo R'LC$0066(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
L$0226:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldw 16(%r20),%r19
comiclr,<> 0,%r19,%r0
bl L$0227,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldh 34(%r20),%r21
extrs %r21,31,16,%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
ldw 48(%r22),%r21
ldw 0(%r19),%r26
ldil L'LC$0068,%r25
ldo R'LC$0068(%r25),%r25
copy %r20,%r24
ldw 16(%r21),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 48(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldh 34(%r20),%r21
extrs %r21,31,16,%r20
ldw 16(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl print_bit_vector,%r2
nop
ldil L'LC$0066,%r26
ldo R'LC$0066(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
L$0227:
L$0225:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
ldh 2(%r20),%r21
extrs %r21,31,16,%r19
comiclr,< 0,%r19,%r0
bl L$0228,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r19),%r26
ldw 0(%r20),%r25
.CALL ARGW0=GR,ARGW1=GR
bl dump_fn_fieldlists,%r2
nop
L$0228:
L$0223:
ldw 16(%r4),%r8
ldw 20(%r4),%r7
ldw 24(%r4),%r6
ldw 28(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
LC$0069:
.STRING "type node 0x%x\x0a\x00"
.align 4
LC$0070:
.STRING "name '%s' (0x%x)\x0a\x00"
.align 4
LC$0071:
.STRING "<NULL>\x00"
.align 4
LC$0072:
.STRING "code 0x%x \x00"
.align 4
LC$0073:
.STRING "(TYPE_CODE_UNDEF)\x00"
.align 4
LC$0074:
.STRING "(TYPE_CODE_PTR)\x00"
.align 4
LC$0075:
.STRING "(TYPE_CODE_ARRAY)\x00"
.align 4
LC$0076:
.STRING "(TYPE_CODE_STRUCT)\x00"
.align 4
LC$0077:
.STRING "(TYPE_CODE_UNION)\x00"
.align 4
LC$0078:
.STRING "(TYPE_CODE_ENUM)\x00"
.align 4
LC$0079:
.STRING "(TYPE_CODE_FUNC)\x00"
.align 4
LC$0080:
.STRING "(TYPE_CODE_INT)\x00"
.align 4
LC$0081:
.STRING "(TYPE_CODE_FLT)\x00"
.align 4
LC$0082:
.STRING "(TYPE_CODE_VOID)\x00"
.align 4
LC$0083:
.STRING "(TYPE_CODE_SET)\x00"
.align 4
LC$0084:
.STRING "(TYPE_CODE_RANGE)\x00"
.align 4
LC$0085:
.STRING "(TYPE_CODE_PASCAL_ARRAY)\x00"
.align 4
LC$0086:
.STRING "(TYPE_CODE_ERROR)\x00"
.align 4
LC$0087:
.STRING "(TYPE_CODE_MEMBER)\x00"
.align 4
LC$0088:
.STRING "(TYPE_CODE_METHOD)\x00"
.align 4
LC$0089:
.STRING "(TYPE_CODE_REF)\x00"
.align 4
LC$0090:
.STRING "(TYPE_CODE_CHAR)\x00"
.align 4
LC$0091:
.STRING "(TYPE_CODE_BOOL)\x00"
.align 4
LC$0092:
.STRING "(UNKNOWN TYPE CODE)\x00"
.align 4
LC$0093:
.STRING "length %d\x0a\x00"
.align 4
LC$0094:
.STRING "objfile 0x%x\x0a\x00"
.align 4
LC$0095:
.STRING "target_type 0x%x\x0a\x00"
.align 4
LC$0096:
.STRING "pointer_type 0x%x\x0a\x00"
.align 4
LC$0097:
.STRING "reference_type 0x%x\x0a\x00"
.align 4
LC$0098:
.STRING "function_type 0x%x\x0a\x00"
.align 4
LC$0099:
.STRING "flags 0x%x\x00"
.align 4
LC$0100:
.STRING " TYPE_FLAG_UNSIGNED\x00"
.align 4
LC$0101:
.STRING " TYPE_FLAG_SIGNED\x00"
.align 4
LC$0102:
.STRING " TYPE_FLAG_STUB\x00"
.align 4
LC$0103:
.STRING "nfields %d 0x%x\x0a\x00"
.align 4
LC$0104:
.STRING "[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\x0a\x00"
.align 4
LC$0105:
.STRING "vptr_basetype 0x%x\x0a\x00"
.align 4
LC$0106:
.STRING "vptr_fieldno %d\x0a\x00"
.align 4
LC$0107:
.STRING "arg_types 0x%x\x0a\x00"
.align 4
LC$0108:
.STRING "cplus_stuff 0x%x\x0a\x00"
.align 4
LC$0109:
.STRING "type_specific 0x%x\x00"
.align 4
LC$0110:
.STRING " (unknown data form)\x00"
.align 4
.EXPORT recursive_dump_type,CODE
.EXPORT recursive_dump_type,ENTRY,PRIV_LEV=3,ARGW0=GR,ARGW1=GR
recursive_dump_type:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r8,16(%r4)
stw %r7,20(%r4)
stw %r6,24(%r4)
stw %r5,28(%r4)
ldo -4(%r0),%r5
ldo -32(%r4),%r19
add %r19,%r5,%r6
stw %r26,0(%r6)
ldo -8(%r0),%r7
ldo -32(%r4),%r19
add %r19,%r7,%r8
stw %r25,0(%r8)
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r19),%r26
ldil L'LC$0069,%r25
ldo R'LC$0069(%r25),%r25
ldw 0(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
ldw 4(%r22),%r21
ldo -4(%r0),%r22
ldo -32(%r4),%r24
add %r24,%r22,%r23
ldw 0(%r23),%r22
ldw 4(%r22),%r23
comiclr,= 0,%r23,%r0
bl L$0230,%r0
nop
ldil L'LC$0071,%r21
ldo R'LC$0071(%r21),%r21
L$0230:
ldw 0(%r19),%r26
ldil L'LC$0070,%r25
ldo R'LC$0070(%r25),%r25
ldw 4(%r20),%r24
copy %r21,%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0072,%r25
ldo R'LC$0072(%r25),%r25
ldw 0(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 0(%r19),%r20
addi,uv -19,%r20,%r0
blr,n %r20,%r0
b,n L$0251
L$0252:
b L$0232
nop
b L$0233
nop
b L$0234
nop
b L$0235
nop
b L$0236
nop
b L$0237
nop
b L$0238
nop
b L$0239
nop
b L$0240
nop
b L$0241
nop
b L$0242
nop
b L$0243
nop
b L$0244
nop
b L$0245
nop
b L$0246
nop
b L$0247
nop
b L$0248
nop
b L$0249
nop
b L$0250
nop
L$0232:
ldil L'LC$0073,%r26
ldo R'LC$0073(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0233:
ldil L'LC$0074,%r26
ldo R'LC$0074(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0234:
ldil L'LC$0075,%r26
ldo R'LC$0075(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0235:
ldil L'LC$0076,%r26
ldo R'LC$0076(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0236:
ldil L'LC$0077,%r26
ldo R'LC$0077(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0237:
ldil L'LC$0078,%r26
ldo R'LC$0078(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0238:
ldil L'LC$0079,%r26
ldo R'LC$0079(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0239:
ldil L'LC$0080,%r26
ldo R'LC$0080(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0240:
ldil L'LC$0081,%r26
ldo R'LC$0081(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0241:
ldil L'LC$0082,%r26
ldo R'LC$0082(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0242:
ldil L'LC$0083,%r26
ldo R'LC$0083(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0243:
ldil L'LC$0084,%r26
ldo R'LC$0084(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0244:
ldil L'LC$0085,%r26
ldo R'LC$0085(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0245:
ldil L'LC$0086,%r26
ldo R'LC$0086(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0246:
ldil L'LC$0087,%r26
ldo R'LC$0087(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0247:
ldil L'LC$0088,%r26
ldo R'LC$0088(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0248:
ldil L'LC$0089,%r26
ldo R'LC$0089(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0249:
ldil L'LC$0090,%r26
ldo R'LC$0090(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0250:
ldil L'LC$0091,%r26
ldo R'LC$0091(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0251:
ldil L'LC$0092,%r26
ldo R'LC$0092(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0231,%r0
L$0231:
ldil L'LC$0066,%r26
ldo R'LC$0066(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0093,%r25
ldo R'LC$0093(%r25),%r25
ldw 8(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0094,%r25
ldo R'LC$0094(%r25),%r25
ldw 12(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0095,%r25
ldo R'LC$0095(%r25),%r25
ldw 16(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 16(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0253,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldo 2(%r21),%r20
ldw 16(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl recursive_dump_type,%r2
nop
L$0253:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0096,%r25
ldo R'LC$0096(%r25),%r25
ldw 20(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0097,%r25
ldo R'LC$0097(%r25),%r25
ldw 24(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0098,%r25
ldo R'LC$0098(%r25),%r25
ldw 28(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldh 32(%r20),%r21
extrs %r21,31,16,%r20
ldw 0(%r19),%r26
ldil L'LC$0099,%r25
ldo R'LC$0099(%r25),%r25
copy %r20,%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldh 32(%r19),%r20
extru %r20,31,1,%r19
extrs %r19,31,16,%r20
comiclr,<> 0,%r20,%r0
bl L$0254,%r0
nop
ldil L'LC$0100,%r26
ldo R'LC$0100(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
L$0254:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldh 32(%r19),%r20
ldo 2(%r0),%r21
and %r20,%r21,%r19
extrs %r19,31,16,%r20
comiclr,<> 0,%r20,%r0
bl L$0255,%r0
nop
ldil L'LC$0101,%r26
ldo R'LC$0101(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
L$0255:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldh 32(%r19),%r20
ldo 4(%r0),%r21
and %r20,%r21,%r19
extrs %r19,31,16,%r20
comiclr,<> 0,%r20,%r0
bl L$0256,%r0
nop
ldil L'LC$0102,%r26
ldo R'LC$0102(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
L$0256:
ldil L'LC$0066,%r26
ldo R'LC$0066(%r26),%r26
.CALL ARGW0=GR
bl puts_filtered,%r2
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldh 34(%r20),%r21
extrs %r21,31,16,%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r23
add %r23,%r21,%r22
ldw 0(%r22),%r21
ldw 0(%r19),%r26
ldil L'LC$0103,%r25
ldo R'LC$0103(%r25),%r25
copy %r20,%r24
ldw 36(%r21),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
stw %r0,8(%r4)
L$0257:
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldh 34(%r19),%r20
extrs %r20,31,16,%r19
ldw 8(%r4),%r20
comclr,< %r20,%r19,%r0
bl L$0258,%r0
nop
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldo 2(%r20),%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 8(%r4),%r21
zdep %r21,27,28,%r22
ldw 36(%r20),%r21
add %r22,%r21,%r20
ldo -4(%r0),%r21
ldo -32(%r4),%r23
add %r23,%r21,%r22
ldw 0(%r22),%r21
ldw 8(%r4),%r22
zdep %r22,27,28,%r23
ldw 36(%r21),%r22
add %r23,%r22,%r21
ldw 4(%r21),%r22
stw %r22,-52(%r30)
ldo -4(%r0),%r21
ldo -32(%r4),%r23
add %r23,%r21,%r22
ldw 0(%r22),%r21
ldw 8(%r4),%r22
zdep %r22,27,28,%r23
ldw 36(%r21),%r22
add %r23,%r22,%r21
ldw 8(%r21),%r22
stw %r22,-56(%r30)
ldo -4(%r0),%r21
ldo -32(%r4),%r23
add %r23,%r21,%r22
ldw 0(%r22),%r21
ldw 8(%r4),%r22
zdep %r22,27,28,%r23
ldw 36(%r21),%r22
add %r23,%r22,%r21
ldw 12(%r21),%r22
stw %r22,-60(%r30)
ldo -4(%r0),%r21
ldo -32(%r4),%r23
add %r23,%r21,%r22
ldw 0(%r22),%r21
ldw 8(%r4),%r22
zdep %r22,27,28,%r23
ldw 36(%r21),%r22
add %r23,%r22,%r21
ldw 12(%r21),%r22
stw %r22,-64(%r30)
ldo -4(%r0),%r21
ldo -32(%r4),%r23
add %r23,%r21,%r22
ldw 0(%r22),%r21
ldw 8(%r4),%r22
zdep %r22,27,28,%r23
ldw 36(%r21),%r22
add %r23,%r22,%r21
ldw 12(%r21),%r22
comiclr,= 0,%r22,%r0
bl L$0260,%r0
nop
ldil L'LC$0071,%r21
ldo R'LC$0071(%r21),%r21
stw %r21,-64(%r30)
L$0260:
copy %r19,%r26
ldil L'LC$0104,%r25
ldo R'LC$0104(%r25),%r25
ldw 8(%r4),%r24
ldw 0(%r20),%r23
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
zdep %r20,27,28,%r21
ldw 36(%r19),%r20
add %r21,%r20,%r19
ldw 8(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0261,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 8(%r4),%r20
zdep %r20,27,28,%r21
ldw 36(%r19),%r20
add %r21,%r20,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldo 4(%r21),%r20
ldw 8(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl recursive_dump_type,%r2
nop
L$0261:
L$0259:
ldw 8(%r4),%r19
ldo 1(%r19),%r20
stw %r20,8(%r4)
bl,n L$0257,%r0
L$0258:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0105,%r25
ldo R'LC$0105(%r25),%r25
ldw 40(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 40(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0262,%r0
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r20),%r21
ldo 2(%r21),%r20
ldw 40(%r19),%r26
copy %r20,%r25
.CALL ARGW0=GR,ARGW1=GR
bl recursive_dump_type,%r2
nop
L$0262:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0106,%r25
ldo R'LC$0106(%r25),%r25
ldw 44(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldw 0(%r19),%r20
ldw 0(%r20),%r19
comiclr,<> 6,%r19,%r0
bl L$0265,%r0
nop
comiclr,>= 6,%r19,%r0
bl L$0270,%r0
nop
comiclr,<> 3,%r19,%r0
bl L$0266,%r0
nop
bl,n L$0267,%r0
L$0270:
comiclr,<> 15,%r19,%r0
bl L$0264,%r0
nop
bl,n L$0267,%r0
L$0264:
L$0265:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0107,%r25
ldo R'LC$0107(%r25),%r25
ldw 48(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 48(%r19),%r26
ldw 0(%r20),%r25
.CALL ARGW0=GR,ARGW1=GR
bl print_arg_types,%r2
nop
bl,n L$0263,%r0
L$0266:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0108,%r25
ldo R'LC$0108(%r25),%r25
ldw 48(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -8(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldw 0(%r19),%r26
ldw 0(%r20),%r25
.CALL ARGW0=GR,ARGW1=GR
bl print_cplus_stuff,%r2
nop
bl,n L$0263,%r0
L$0267:
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -4(%r0),%r20
ldo -32(%r4),%r22
add %r22,%r20,%r21
ldw 0(%r21),%r20
ldw 0(%r19),%r26
ldil L'LC$0109,%r25
ldo R'LC$0109(%r25),%r25
ldw 48(%r20),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl printfi_filtered,%r2
nop
ldo -4(%r0),%r19
ldo -32(%r4),%r21
add %r21,%r19,%r20
ldw 0(%r20),%r19
ldw 48(%r19),%r20
comiclr,<> 0,%r20,%r0
bl L$0268,%r0
nop
ldil L'LC$0110,%r26
ldo R'LC$0110(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
L$0268:
ldil L'LC$0066,%r26
ldo R'LC$0066(%r26),%r26
.CALL ARGW0=GR
bl printf_filtered,%r2
nop
bl,n L$0263,%r0
L$0263:
L$0229:
ldw 16(%r4),%r8
ldw 20(%r4),%r7
ldw 24(%r4),%r6
ldw 28(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
/parse/versionbug.s
0,0 → 1,4
.code
 
.VERSION "abc123"
 
/parse/ssbug.s
0,0 → 1,10
.SPACE $PRIVATE$
.SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31
.SUBSPA $BSS$,QUAD=1,ALIGN=8,ACCESS=31,ZERO,SORT=82
.SUBSPA $SHORTBSS$,QUAD=1,ALIGN=8,ACCESS=31,ZERO,SORT=80
.SPACE $TEXT$
.SUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=44
.SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
 
 
 
/parse/callinfobug.s
0,0 → 1,7
.code
.align 4
.export divu,millicode
.proc
.callinfo millicode
divu:
.procend
/parse/stdreg.s
0,0 → 1,18
.code
.align 4
.export foo
foo:
.proc
.callinfo no_calls
.entry
ldi 15,%sp
ldi 15,%rp
ldi 15,%dp
ldi 15,%ret0
ldi 15,%ret1
ldi 15,%arg0
ldi 15,%arg1
ldi 15,%arg2
ldi 15,%arg3
.exit
.procend
/parse/spacebug.s
0,0 → 1,3
start: .long 0, 1, 2, 3, 4, 5, 6, 7
.space 0x20 - (. - start)
foo: .long 42
/parse/regpopbug.s
0,0 → 1,9
.code
 
r0: .reg %r0
shift: .reg %sar
fpreg10: .reg %fr10
shift2: .reg shift
 
; Make sure we didn't botch .equ...
yabba: .equ r0 + shift
/parse/space.s
0,0 → 1,24
.code
.align 4
.export $$mulI, millicode
.proc
.callinfo millicode
$$mulI:
.procend
 
.code
 
.align 4
.PARAM foo, RTNVAL=GR
foo:
.PROC
.CALLINFO FRAME=128, NO_CALLS, ENTRY_GR=3, ENTRY_FR=12
.ENTRY
bv,n %r0(%r2)
.EXIT
.PROCEND
 
.align 4
.import yabba, code
 
ble R%yabba(%sr4, %r0)
/parse/badfmpyadd.s
0,0 → 1,21
.code
.align 4
.EXPORT foobar,ENTRY,PRIV_LEV=3,ARGW0=FR,ARGW1=FU,ARGW2=FR,ARGW3=FU,RTNVAL=FR
foobar
.PROC
.CALLINFO FRAME=0,NO_CALLS
.ENTRY
ldo -64(%r30),%r20
addil LR'x-$global$,%r27
fldds 8(%r20),%fr4
fldds 0(%r20),%fr22
ldo RR'x-$global$(%r1),%r19
fmpysub,sgl %fr5L,%fr7L,%fr5L,%fr22L,%fr4L
bv %r0(%r2)
fstds %fr5,0(%r19)
.EXIT
.PROCEND
.bss
 
x .comm 8
y .comm 8
/parse/defbug.s
0,0 → 1,9
.code
.align 4
.import _seterrno
.export vfork ! .label vfork ! .proc! .callinfo no_calls! .entry ! .label __vfork ! mtsp %r0,%sr0! ldil L%0xc0000004,%r1! ble R%0xc0000004(%sr0,%r1)! ldi 66 ,%r22 ! b,n yyy! b,n __vfork ! b _seterrno! copy %r28,%r26! .label yyy
add,= %r0,%r29,%r0
copy %r0,%r28
bv,n (%r2)
.exit
.procend
/parse/stringer.s
0,0 → 1,11
.data
 
 
; GAS used to mis-parse the embedded quotes
.STRING "#include \"awk.def\"\x0a\x00"
 
; Octal escapes used to consume > 3 chars which led to this
; string being screwed in a big way.
.STRING "\0110x123"
 
 
/parse/lselbug.s
0,0 → 1,10
.code
 
.align 4
; In gas-1.36 the ldil instruction using parenthesis generated
; garbage bits while the one without parens worked fine.
ldil L%(0x00040000 | 0x00000008 | 0x00000002),%r21
ldo L%(0x00040000 | 0x00000008 | 0x00000002) (%r21),%r21
ldil L%0x00040000 | 0x00000008 | 0x00000002,%r21
ldo L%0x00040000 | 0x00000008 | 0x00000002 (%r21),%r21
 
/parse/linesepbug.s
0,0 → 1,12
.code
 
.align 4
; Basic immediate instruction tests.
;
; We could/should test some of the corner cases for register and
; immediate fields. We should also check the assorted field
; selectors to make sure they're handled correctly.
 
foo:
.WORD 0 !.IMPORT $bar$,DATA
 
/parse/entrybug.s
0,0 → 1,12
.code
 
.align 4
.PARAM foo,RTNVAL=GR
foo:
.PROC
.CALLINFO FRAME=128,NO_CALLS,ENTRY_GR=1,ENTRY_FR=11
.ENTRY
bv,n %r0(%r2)
.EXIT
.PROCEND
 
/parse/undefbug.s
0,0 → 1,6
.code
 
.align 4
bl somewhere,%r2
nop
 
/parse/global.s
0,0 → 1,7
.code
.IMPORT foo,data
 
.align 4
; Official gas code will not accept sym-$global$.
addil L%foo-$global$,%r27
 
/parse/procbug.s
0,0 → 1,15
.code
.align 4
.export divu,entry
.proc
.callinfo
divu: stws,ma %r4,4(%r5) ; save registers on stack
.procend
 
.export divu2,entry
.proc
.callinfo
.entry
divu2: stws,ma %r4,4(%r5) ; save registers on stack
.exit
.procend
/parse/nosubspace.s
0,0 → 1,21
.SPACE $TEXT$
 
.align 4
.EXPORT mpn_add_n
.EXPORT mpn_add_n,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR,RTNVAL=GR
mpn_add_n:
.PROC
.CALLINFO FRAME=0,NO_CALLS
.ENTRY
 
add %r0,%r0,%r0 ; reset cy
Loop:
ldws,ma 4(0,%r25),%r20
ldws,ma 4(0,%r24),%r19
 
addc %r19,%r20,%r19
addib,<> -1,%r23,Loop
stws,ma %r19,4(0,%r26)
 
bv 0(2)
addc %r0,%r0,%r28
/parse/calldatabug.s
0,0 → 1,178
.code
.align 4
LC$0000:
.STRING "%d %lf %d\x0a\x00"
.align 4
.EXPORT error__3AAAiidi
.EXPORT error__3AAAiidi,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=FR,ARGW4=FU,RTNVAL=GR
error__3AAAiidi:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r9,8(%r4)
stw %r8,12(%r4)
stw %r7,16(%r4)
stw %r6,20(%r4)
stw %r5,24(%r4)
copy %r26,%r5
ldo -8(%r0),%r6
ldo -32(%r4),%r19
add %r19,%r6,%r7
stw %r25,0(%r7)
ldo -12(%r0),%r8
ldo -32(%r4),%r19
add %r19,%r8,%r9
stw %r24,0(%r9)
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -24(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldo -28(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
stw %r22,-52(%r30)
ldil L'LC$0000,%r26
ldo R'LC$0000(%r26),%r26
ldw 0(%r19),%r25
fldds 0(%r20),%fr7
.CALL ARGW0=GR,ARGW1=GR,ARGW2=FR,ARGW3=FU
bl printf,%r2
nop
bl,n L$0002,%r0
bl,n L$0001,%r0
L$0002:
L$0001:
ldw 8(%r4),%r9
ldw 12(%r4),%r8
ldw 16(%r4),%r7
ldw 20(%r4),%r6
ldw 24(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.align 4
.EXPORT ok__3AAAidi
.EXPORT ok__3AAAidi,PRIV_LEV=3,ARGW0=GR,ARGW1=GR,ARGW2=FR,ARGW3=FU,RTNVAL=GR
ok__3AAAidi:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
stw %r9,8(%r4)
stw %r8,12(%r4)
stw %r7,16(%r4)
stw %r6,20(%r4)
stw %r5,24(%r4)
copy %r26,%r5
ldo -8(%r0),%r6
ldo -32(%r4),%r19
add %r19,%r6,%r7
stw %r25,0(%r7)
ldo -16(%r0),%r8
ldo -32(%r4),%r19
add %r19,%r8,%r9
fstds %fr7,0(%r9)
ldo -8(%r0),%r19
ldo -32(%r4),%r20
add %r20,%r19,%r19
ldo -16(%r0),%r20
ldo -32(%r4),%r21
add %r21,%r20,%r20
ldo -20(%r0),%r21
ldo -32(%r4),%r22
add %r22,%r21,%r21
ldw 0(%r21),%r22
stw %r22,-52(%r30)
ldil L'LC$0000,%r26
ldo R'LC$0000(%r26),%r26
ldw 0(%r19),%r25
fldds 0(%r20),%fr7
.CALL ARGW0=GR,ARGW1=GR,ARGW2=FR,ARGW3=FU
bl printf,%r2
nop
bl,n L$0004,%r0
bl,n L$0003,%r0
L$0004:
L$0003:
ldw 8(%r4),%r9
ldw 12(%r4),%r8
ldw 16(%r4),%r7
ldw 20(%r4),%r6
ldw 24(%r4),%r5
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
.IMPORT __main,CODE
.align 8
LC$0001:
; .double 5.50000000000000000000e+00
.word 1075183616 ; = 0x40160000
.word 0 ; = 0x0
.align 4
.EXPORT main
.EXPORT main,PRIV_LEV=3,RTNVAL=GR
main:
.PROC
.CALLINFO FRAME=128,CALLS,SAVE_RP
.ENTRY
stw %r2,-20(%r30)
copy %r4,%r1
copy %r30,%r4
stwm %r1,128(%r30)
.CALL
bl __main,%r2
nop
ldo -24(%r0),%r19
ldo -32(%r30),%r20
add %r20,%r19,%r19
ldil L'LC$0001,%r20
ldo R'LC$0001(%r20),%r21
ldw 0(%r21),%r22
ldw 4(%r21),%r23
stw %r22,0(%r19)
stw %r23,4(%r19)
ldo 3(%r0),%r19
stw %r19,-60(%r30)
ldo 8(%r4),%r26
ldo 1(%r0),%r25
ldo 4(%r0),%r24
.CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
bl error__3AAAiidi,%r2
nop
ldo 3(%r0),%r19
stw %r19,-52(%r30)
ldo 8(%r4),%r26
ldo 1(%r0),%r25
ldil L'LC$0001,%r19
ldo R'LC$0001(%r19),%r20
fldds 0(%r20),%fr7
.CALL ARGW0=GR,ARGW1=GR,ARGW2=FR,ARGW3=FU
bl ok__3AAAidi,%r2
nop
copy %r0,%r28
bl,n L$0005,%r0
bl,n L$0005,%r0
L$0005:
ldo 8(%r4),%r30
ldw -28(%r30),%r2
bv %r0(%r2)
ldwm -8(%r30),%r4
.EXIT
.PROCEND
 
/parse/parse.exp
0,0 → 1,230
# Copyright (C) 1993, 1996, 1997, 1999, 2000, 2001, 2002, 2003, 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 the Center for Software Science at the University of Utah
# and by Cygnus Support.
 
proc do_string_tests {} {
set testname "stringer.s: Test embedded quotes and octal escapes in strings"
set x 0
 
gas_start "stringer.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 23696E63\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 6C756465\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 6B2E6465\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 66220A00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 09307831\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 3233\[^\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==6] then { pass $testname } else { fail $testname }
}
 
proc do_lsel_test {} {
set testname "lselbugs.s: lselbug"
set x 0
 
gas_start "lselbug.s" "-al"
 
# Make sure we correctly handle field selectors.
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 22A04000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 36B50100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 22A04000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 36B50100\[^\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_valid_align_tests {} {
set testname "align1.s: valid alignment tests"
set x 0
 
gas_start "align1.s" "-al"
 
# Make sure we correctly handle field selectors.
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 08000240\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 08000240\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 1000 08000240\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0000\[^\n\]*BLOCK\[^\n\]*1024\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^ +\[0-9\]+ 0400\[^\n\]*BLOCK\[^\n\]*1024\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^ +\[0-9\]+ 0800\[^\n\]*BLOCK\[^\n\]*4\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^ +\[0-9\]+ 0804\[^\n\]*ALIGN\[^\n\]*8\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^ +\[0-9\]+ 0808\[^\n\]*BLOCK\[^\n\]*30\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^ +\[0-9\]+ 0826\[^\n\]*ALIGN\[^\n\]*4\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^ +\[0-9\]+ 0828\[^\n\]*BLOCK\[^\n\]*4\[^\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==10] then { pass $testname } else { fail $testname }
}
 
if [istarget hppa*-*-*] then {
if { ![istarget hppa*-*-linux*]
&& ![istarget hppa*-*-netbsd*] } {
# GAS-2.0 does not always parse ! as a line separator when it should.
setup_xfail hppa*-*-*
}
gas_test "linesepbug.s" "" "" "line separator bug"
 
# Make sure GAS accepts syntax for accessing static data.
gas_test "global.s" "" "" "check for sym-\$global\$ acceptance"
 
# GAS-2.0 (and 1.36 for that matter) can not handle a .proc which
# has no label before it.
gas_test "procbug.s" "" "" "Label following .proc"
 
# One is required to explicitly IMPORT any non-local symbol used
# in an assembly file. Make sure we give an error if we use
# an undefined symbol.
setup_xfail hppa*-*-*
gas_test_error "undefbug.s" "" "Check for error when using undefined symbol"
 
# This file has code and assembler directives before switching into any
# space/subspace pair. This should report an error for SOM (it is not
# an error for ELF. The file also has mismatched entry/exit and
# proc/procend pairs which are errors for both SOM and ELF.
gas_test_error "nosubspace.s" "" "Check for error(s) in input file "
 
# This file should return errors for both the ENTRY_GR and ENTRY_FR
# directives (they are out-of-range)
gas_test_error "entrybug.s" "" "Check for error on entry_gr and entry_fr"
 
# Make sure embedded quotes and octal escapes in strings work
do_string_tests
 
# Make sure we do not die on a .version directive
gas_test "versionbug.s" "" "" ".version directive"
 
# Make sure we give an error on a bogus .space directive.
# recent version of gas2 went into infinite loops printing
# errors on this test.
gas_test_error "spacebug.s" "" "Check for error on bogus .space directive"
 
# GAS should give an error for this test.
gas_test_error "calldatabug.s" "" "Check for invalid aguments on .call"
 
# Old versions of gas incorrectly gave errors on some valid .EXPORT lines
gas_test "exportbug.s" "" "" "syntax check for an old .EXPORT bug"
 
# Old versions of gas choked on this file for some reason
gas_test "fixup7bug.s" "" "" "check for old \"fixup7\" gas bug"
 
# Test an L% selector parsing bug which existed in gas-1.36
do_lsel_test
 
# First check how some valid alignments are handled.
do_valid_align_tests
 
# Now check to make sure an invalid argument is flagged as an error.
gas_test_error "align2.s" "" "Check for error on bogus argument to .align"
 
# GAS can't handle upper bound for a PA .block[z] directive
setup_xfail hppa*-*-*
gas_test "block1.s" "" "" "Check min/max values for .block"
 
# Now check for an invalid argument
gas_test_error "block2.s" "" "Check for error on bogus argument to .block"
 
# GAS-1.36 choked on this file.
# FIXME. Should check relocations made for this test!
gas_test "exprbug.s" "" "" "Check for sym1-sym2 acceptance"
 
# Bad things happen in the PA ELF backend (others too?) if a non-default
# section is created...
setup_xfail "hppa*-*-*elf*" "hppa*-*-linux*" "hppa*64*-*-*"
gas_test "ssbug.s" "" "" "Check for acceptance of non-default subspaces"
 
# To be compatable with certain "features" of the HP compiler
# non-existant registers should default to %r0.
gas_test "defbug.s" "" "" "Missing register should default to %%r0"
 
# Make sure GAS understands a reasonable set of standard predefined
# registers. eg %rp, %dp, %sp, etc.
gas_test "stdreg.s" "" "" "Test standard predefined registers"
 
# Make sure GAS will accept a label without a colon.
setup_xfail "hppa*-*-linux*"
gas_test "labelbug.s" "" "" "Test label without colon"
 
# Make sure we grok # line directives.
gas_test "appbug.s" "" "" "Test acceptance of #line directives"
 
# Make sure we give errors if a floating point format is specified
# for an xmpyu instruction (integer multiple)
gas_test_error "xmpyubug.s" "" "Check for error on bogus argument to xmpyu"
 
# Make sure gas handles various kinds of .reg pseudo-ops
gas_test "regpopbug.s" "" "" "Test for bugs in .reg pseudo-op"
 
# Check some bugs that have appeared in parsing .callinfo directives
gas_test "callinfobug.s" "" "" "Test for bugs in .callinfo directive"
 
# Check for bogus registers in single precision fmpyadd/fmpysub
# instructions
gas_test_error "badfmpyadd.s" "" "Check for error on bad fmpyadd insn"
 
# Make sure we grok spaces in directives.
gas_test "space.s" "" "" "Test acceptance of spaces in directives"
}
 
/parse/block1.s
0,0 → 1,11
.data
 
 
foo:
.block
bar:
.block 0x3fffffff
com:
 
 
 
/parse/align1.s
0,0 → 1,31
.code
.align 1
.align 8
nop
; "8" assumed if no alignment given.
.align
nop
.align 4096
nop
 
 
.data
 
.ALIGN 8
$L00BSS:
home_buff:
.BLOCK 1024
.ALIGN 8
current_buff:
.BLOCK 1024
.ALIGN 4
lock_file:
.BLOCK 4
.ALIGN 8
L332.name:
.BLOCK 30
.ALIGN 4
L352.last_case_wa:
.BLOCK 4
 
 
/parse/exprbug.s
0,0 → 1,38
.code
 
.align 8
.export icode,data
icode:
.proc
.callinfo frame=0,no_calls
.entry
bv,n %r0(%r2)
.exit
nop
.procend
 
;
; FIRST, argv array of pointers to args, 1st is same as path.
;
.align 8
ic_argv:
.word ic_argv1-icode ; second, pointer to 1st argument
.word ic_path-icode ; first, pointer to init path
.word 0 ; fourth, NULL argv terminator (pad)
.word 0 ; third, NULL argv terminator
 
ic_path:
.blockz 4096 ; must be multiple of 4 bytes
.word 0 ; in case full string is used
.word 0 ; this will be the string terminator
 
ic_argv1:
.blockz 4096 ; must be multiple of 4 bytes
.word 0 ; in case full string is used
.word 0 ; this will be the string terminator
 
.export szicode,data
szicode:
.word szicode-icode
.word 0 ; must have at least one filler at end
 
/parse/block2.s
0,0 → 1,6
.data
foo:
.block -1
 
 
 
/parse/align2.s
0,0 → 1,6
.code
.align 3
 
 
 
/parse/labelbug.s
0,0 → 1,27
.code
 
.align 4
; A comment. This should not be interpreted as a label, but both of the
; following statements should.
label_without_colon
label_with_colon:
 
; A problem tege found...
; Input scrubbing in gas makes life a real nightmare for assemblers
; in which the *position* within a line determines how to interpret
; a stream a characters. These test one particular case where gas
; had the tendency to delete the whitespace between the opcode and
; operands if a label without a colon began a line, and the operands
; started with a non-numeric character.
L$1 add %r2,%r2,%r2
L$2: add %r2,%r2,%r2
L$3
add %r2,%r2,%r2
 
L$4 add %r2,%r2,%r2
L$5: add %r2,%r2,%r2
L$6
add %r2,%r2,%r2
 
; An instruction or pseudo-op may begin anywhere after column 0.
b,n label_without_colon
/README
0,0 → 1,34
Notes on how the HPPA testsuite is organized:
 
basic.parse -- this directory contains the basic instruction parsing
tests and a simple .stab parsing test. This would be where you'd
add code to make sure new instructions are parsed correctly, new
completers (such as cache hits) are parsed correctly, etc.
 
It's also a reasonable place to make sure parsing of the various
assembler directives is handled correctly. If you're going to add
such code, try to be reasonably complete. Add test code for each
basic directive and test all (or a noteworthy) subset of arguments.
 
It should only be necessary to have an assembler to run these tests;
calling objdump_start or something similar should not be done from
this directory.
 
 
more.parse -- this is where you should put additional parsing tests, such
as tests to check mode selector parsing, string parsing, expression parsing,
etc. It's also a reasonable place to put parsing tests which are not complete
enough (whatever that means) for basic.parse.
 
It should only be necessary to have an assembler to run these tests;
calling objdump_start or something similar should not be done from
this directory.
 
 
reloc -- this is where you tests which examine relocations produced
by GAS belong. To run these tests you must have a functioning objdump.
 
 
unsorted -- this is where everything else goes. As groups of related tests
end up in this directory, they should be broken out into a new class of
tests.

powered by: WebSVN 2.1.0

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