repo_id
stringlengths 5
115
| size
int64 590
5.01M
| file_path
stringlengths 4
212
| content
stringlengths 590
5.01M
|
|---|---|---|---|
stsp/binutils-ia16
| 1,081
|
gas/testsuite/gas/mips/jalr4.s
|
.abicalls
.text
.align 2
.globl foo
.ent foo
foo:
.reloc 1f, R_MIPS_JALR, bar0
1: jalr $25
.reloc 1f, R_MIPS_JALR, bar0
1: jalr $0, $25
.reloc 1f, R_MIPS_JALR, bar0
1: jr $25
.reloc 1f, R_MIPS_JALR, bar1
1: jalr $25
.reloc 1f, R_MIPS_JALR, bar1
1: jalr $0, $25
.reloc 1f, R_MIPS_JALR, bar1
1: jr $25
.reloc 1f, R_MIPS_JALR, bar2
1: jalr $25
.reloc 1f, R_MIPS_JALR, bar2
1: jalr $0, $25
.reloc 1f, R_MIPS_JALR, bar2
1: jr $25
.end foo
# Force some (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 4, 0
.space 16
.align 2
.globl bar0
.ent bar0
bar0:
.insn
.end bar0
# Force some (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 4, 0
.space 16
.align 2
.globl bar1
.ent bar1
.space 2
bar1:
.insn
.end bar1
# Force some (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 4, 0
.space 16
.set mips64r2
.set mips16
.align 2
.globl bar2
.ent bar2
.byte 0
bar2:
.insn
.end bar2
.set nomips16
.set mips0
# Force some (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 4, 0
.space 16
|
stsp/binutils-ia16
| 2,193
|
gas/testsuite/gas/mips/elf-rel-got-n64.s
|
# MIPS ELF GOT reloc n64
.data
.align 3
sp1:
.space 60
.globl dg1
dg1:
dl1:
.space 60
.text
.globl fn
.ent fn
.type fn,@function
fn:
.Lfn:
dla $5,dg1+0
dla $5,dg1+12
dla $5,dg1+123456
dla $5,dg1+0($17)
dla $5,dg1+12($17)
dla $5,dg1+123456($17)
ld $5,dg1+0
ld $5,dg1+12
ld $5,dg1+0($17)
ld $5,dg1+12($17)
ld $5,dg1+34($5)
sd $5,dg1+56($5)
ulw $5,dg1+0
ulw $5,dg1+12
ulw $5,dg1+0($17)
ulw $5,dg1+12($17)
ulw $5,dg1+34($5)
usw $5,dg1+56($5)
dla $5,dl1+0
dla $5,dl1+12
dla $5,dl1+123456
dla $5,dl1+0($17)
dla $5,dl1+12($17)
dla $5,dl1+123456($17)
ld $5,dl1+0
ld $5,dl1+12
ld $5,dl1+0($17)
ld $5,dl1+12($17)
ld $5,dl1+34($5)
sd $5,dl1+56($5)
ulw $5,dl1+0
ulw $5,dl1+12
ulw $5,dl1+0($17)
ulw $5,dl1+12($17)
ulw $5,dl1+34($5)
usw $5,dl1+56($5)
dla $5,fn
dla $5,.Lfn
dla $25,fn
dla $25,.Lfn
jal fn
jal .Lfn
dla $5,dg2+0
dla $5,dg2+12
dla $5,dg2+123456
dla $5,dg2+0($17)
dla $5,dg2+12($17)
dla $5,dg2+123456($17)
ld $5,dg2+0
ld $5,dg2+12
ld $5,dg2+0($17)
ld $5,dg2+12($17)
ld $5,dg2+34($5)
sd $5,dg2+56($5)
ulw $5,dg2+0
ulw $5,dg2+12
ulw $5,dg2+0($17)
ulw $5,dg2+12($17)
ulw $5,dg2+34($5)
usw $5,dg2+56($5)
dla $5,dl2+0
dla $5,dl2+12
dla $5,dl2+123456
dla $5,dl2+0($17)
dla $5,dl2+12($17)
dla $5,dl2+123456($17)
ld $5,dl2+0
ld $5,dl2+12
ld $5,dl2+0($17)
ld $5,dl2+12($17)
ld $5,dl2+34($5)
sd $5,dl2+56($5)
ulw $5,dl2+0
ulw $5,dl2+12
ulw $5,dl2+0($17)
ulw $5,dl2+12($17)
ulw $5,dl2+34($5)
usw $5,dl2+56($5)
dla $5,fn2
dla $5,.Lfn2
dla $25,fn2
dla $25,.Lfn2
jal fn2
jal .Lfn2
# Check that filling delay slots doesn't break our relocations.
dla $5,dg1
b .Lfn
ld $5,dg2
b .Lfn2
dla $5,dl1
b .Lfn
dla $5,dl2+12
b .Lfn2
dla $5,dl1+123456
b .Lfn
ld $5,dl2
b .Lfn2
ld $5,dl1+12
b .Lfn
ld $5,dl2+34($5)
b .Lfn2
# Force at least 8 (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 2
.space 8
.end fn
.globl fn2
.ent fn2
.type fn2,@function
fn2:
.Lfn2:
.end fn2
.globl __start
__start:
# Force at least 8 (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 2
.space 8
.data
.align 3
sp2:
.space 60
.globl dg2
dg2:
dl2:
.space 60
|
stsp/binutils-ia16
| 1,768
|
gas/testsuite/gas/mips/ldstla-32-1.s
|
.text
ld $2, 0xfffffffeffffffff($4)
ld $2, 0xfffffffe00000000($4)
ld $2, 0xabcdef0123456789($4)
ld $2, 0x0123456789abcdef($4)
ld $2, 0x00000001ffffffff($4)
ld $2, 0x0000000100000000($4)
ld $2, 0xfffffffeffffffff
ld $2, 0xfffffffe00000000
ld $2, 0xabcdef0123456789
ld $2, 0x0123456789abcdef
ld $2, 0x00000001ffffffff
ld $2, 0x0000000100000000
sd $2, 0xfffffffeffffffff($4)
sd $2, 0xfffffffe00000000($4)
sd $2, 0xabcdef0123456789($4)
sd $2, 0x0123456789abcdef($4)
sd $2, 0x00000001ffffffff($4)
sd $2, 0x0000000100000000($4)
sd $2, 0xfffffffeffffffff
sd $2, 0xfffffffe00000000
sd $2, 0xabcdef0123456789
sd $2, 0x0123456789abcdef
sd $2, 0x00000001ffffffff
sd $2, 0x0000000100000000
lw $2, 0xfffffffeffffffff($4)
lw $2, 0xfffffffe00000000($4)
lw $2, 0xabcdef0123456789($4)
lw $2, 0x0123456789abcdef($4)
lw $2, 0x00000001ffffffff($4)
lw $2, 0x0000000100000000($4)
lw $2, 0xfffffffeffffffff
lw $2, 0xfffffffe00000000
lw $2, 0xabcdef0123456789
lw $2, 0x0123456789abcdef
lw $2, 0x00000001ffffffff
lw $2, 0x0000000100000000
sw $2, 0xfffffffeffffffff($4)
sw $2, 0xfffffffe00000000($4)
sw $2, 0xabcdef0123456789($4)
sw $2, 0x0123456789abcdef($4)
sw $2, 0x00000001ffffffff($4)
sw $2, 0x0000000100000000($4)
sw $2, 0xfffffffeffffffff
sw $2, 0xfffffffe00000000
sw $2, 0xabcdef0123456789
sw $2, 0x0123456789abcdef
sw $2, 0x00000001ffffffff
sw $2, 0x0000000100000000
la $2, 0xfffffffeffffffff($4)
la $2, 0xfffffffe00000000($4)
la $2, 0xabcdef0123456789($4)
la $2, 0x0123456789abcdef($4)
la $2, 0x00000001ffffffff($4)
la $2, 0x0000000100000000($4)
la $2, 0xfffffffeffffffff
la $2, 0xfffffffe00000000
la $2, 0xabcdef0123456789
la $2, 0x0123456789abcdef
la $2, 0x00000001ffffffff
la $2, 0x0000000100000000
.space 8
|
stsp/binutils-ia16
| 1,849
|
gas/testsuite/gas/mips/ush.s
|
# Source file used to test the ush macro.
.data
data_label:
.extern big_external_data_label,1000
.extern small_external_data_label,1
.comm big_external_common,1000
.comm small_external_common,1
.lcomm big_local_common,1000
.lcomm small_local_common,1
.text
ush $4,0
ush $4,1
ush $4,0x8000
ush $4,-0x8000
ush $4,0x10000
ush $4,0x1a5a5
ush $4,0($5)
ush $4,1($5)
ush $4,data_label
ush $4,big_external_data_label
ush $4,small_external_data_label
ush $4,big_external_common
ush $4,small_external_common
ush $4,big_local_common
ush $4,small_local_common
ush $4,data_label+1
ush $4,big_external_data_label+1
ush $4,small_external_data_label+1
ush $4,big_external_common+1
ush $4,small_external_common+1
ush $4,big_local_common+1
ush $4,small_local_common+1
ush $4,data_label+0x8000
ush $4,big_external_data_label+0x8000
ush $4,small_external_data_label+0x8000
ush $4,big_external_common+0x8000
ush $4,small_external_common+0x8000
ush $4,big_local_common+0x8000
ush $4,small_local_common+0x8000
ush $4,data_label-0x8000
ush $4,big_external_data_label-0x8000
ush $4,small_external_data_label-0x8000
ush $4,big_external_common-0x8000
ush $4,small_external_common-0x8000
ush $4,big_local_common-0x8000
ush $4,small_local_common-0x8000
ush $4,data_label+0x10000
ush $4,big_external_data_label+0x10000
ush $4,small_external_data_label+0x10000
ush $4,big_external_common+0x10000
ush $4,small_external_common+0x10000
ush $4,big_local_common+0x10000
ush $4,small_local_common+0x10000
ush $4,data_label+0x1a5a5
ush $4,big_external_data_label+0x1a5a5
ush $4,small_external_data_label+0x1a5a5
ush $4,big_external_common+0x1a5a5
ush $4,small_external_common+0x1a5a5
ush $4,big_local_common+0x1a5a5
ush $4,small_local_common+0x1a5a5
# Round to a 16 byte boundary, for ease in testing multiple targets.
nop
|
stsp/binutils-ia16
| 1,161
|
gas/testsuite/gas/mips/compact-eh-5.s
|
.gnu_attribute 4, 1
.abicalls
.hidden DW.ref.__gnu_compact_pr2
.weak DW.ref.__gnu_compact_pr2
.section .data.DW.ref.__gnu_compact_pr2,"awG",@progbits,DW.ref.__gnu_compact_pr2,comdat
.align 2
.type DW.ref.__gnu_compact_pr2, @object
.size DW.ref.__gnu_compact_pr2, 4
DW.ref.__gnu_compact_pr2:
.word __gnu_compact_pr2
.text
.align 2
.globl _Z3fooi
.cfi_sections .eh_frame_entry
$LFB0 = .
.cfi_startproc
.cfi_personality 0x1b, DW.ref.__gnu_compact_pr2
.cfi_lsda 0x1b,$LLSDA0
.set nomips16
.set nomicromips
.ent _Z3fooi
.type _Z3fooi, @function
_Z3fooi:
$LEHB0 = .
nop
$LEHE0 = .
nop
$LEHB1 = .
nop
$LEHE1 = .
nop
$LEHB2 = .
$L3:
nop
$LEHE2 = .
.end _Z3fooi
.size _Z3fooi, .-_Z3fooi
.cfi_fde_data 0x4,0x40
.cfi_endproc
.globl __gnu_compact_pr2
.cfi_inline_lsda 2
$LLSDA0:
.byte 0x2
.uleb128 $LLSDACSE0-$LLSDACSB0
$LLSDACSB0:
.uleb128 ($LEHB0-$LFB0)|1
.uleb128 ($LEHE0-$LEHB0)
.sleb128 -1
.uleb128 ($LEHB1-$LEHE0)|1
.uleb128 ($LEHE1-$LEHB1)
.sleb128 ($L3-($LEHE1))
.sleb128 (0<<2)|0
.uleb128 ($LEHB2-$LEHE1)|1
.uleb128 ($LEHE2-$LEHB2)
.sleb128 -1
$LLSDACSE0:
|
stsp/binutils-ia16
| 1,355
|
gas/testsuite/gas/mips/unaligned-branch-mips16-1.s
|
.text
.set noreorder
.space 0x1000
.align 4
.set mips16
.ent foo
foo:
not $2, $3
b bar0
not $2, $3
b bar1
not $2, $3
b bar2
not $2, $3
b bar3
not $2, $3
b bar4
not $2, $3
b bar4 + 1
not $2, $3
b bar4 + 2
not $2, $3
b bar4 + 3
not $2, $3
b bar4 + 4
not $2, $3
b bar16
not $2, $3
b bar17
not $2, $3
b bar18
not $2, $3
b bar18 + 1
not $2, $3
b bar18 + 2
not $2, $3
b bar18 + 3
not $2, $3
b bar18 + 4
not $2, $3
bnez $2, bar0
not $2, $3
bnez $2, bar1
not $2, $3
bnez $2, bar2
not $2, $3
bnez $2, bar3
not $2, $3
bnez $2, bar4
not $2, $3
bnez $2, bar4 + 1
not $2, $3
bnez $2, bar4 + 2
not $2, $3
bnez $2, bar4 + 3
not $2, $3
bnez $2, bar4 + 4
not $2, $3
bnez $2, bar16
not $2, $3
bnez $2, bar17
not $2, $3
bnez $2, bar18
not $2, $3
bnez $2, bar18 + 1
not $2, $3
bnez $2, bar18 + 2
not $2, $3
bnez $2, bar18 + 3
not $2, $3
bnez $2, bar18 + 4
not $2, $3
jr $ra
not $2, $3
.end foo
# Force some (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 4, 0
.space 16
.macro obj n:req
.type bar\@, @object
bar\@ :
.byte 0
.size bar\@, . - bar\@
.if \n - 1
obj \n - 1
.endif
.endm
.macro fun n:req
.type bar\@, @function
bar\@ :
.insn
.hword 0
.size bar\@, . - bar\@
.if \n - 1
fun \n - 1
.endif
.endm
.align 4
obj 16
fun 8
|
stsp/binutils-ia16
| 1,510
|
gas/testsuite/gas/mips/dli.s
|
# Source file used to test the dli macro.
foo:
dli $4,0
dli $4,1
dli $4,-1
dli $4,0x8000
dli $4,-0x8000
dli $4,0x10000
dli $4,0x1a5a5
dli $4,0x80001234
dli $4,0xffffffff
dli $4,0x00000000ffffffff
dli $4,0xffffffffffffffff
dli $4,0x000fffffffffffff
dli $4,0xffffffff80001234
dli $4,0xffff800012345678
dli $4,0x8000123456780000
dli $4,0xffffffffffff8765
dli $4,0xffffffffffff4321
dli $4,0xfffffffffffffff0
dli $4,0xffffffffffffff00
dli $4,0xfffffffffffff000
dli $4,0xffffffffffff0000
dli $4,0xfffffffffff00000
dli $4,0xffffffffff000000
dli $4,0xfffffffff0000000
dli $4,0xffffffff00000000
dli $4,0xfffffff000000000
dli $4,0xffffff0000000000
dli $4,0xfffff00000000000
dli $4,0xffff000000000000
dli $4,0xfff0000000000000
dli $4,0xff00000000000000
dli $4,0xf000000000000000
dli $4,0x0fffffffffffffff
dli $4,0x00ffffffffffffff
dli $4,0x000fffffffffffff
dli $4,0x0000ffffffffffff
dli $4,0x00000fffffffffff
dli $4,0x000000ffffffffff
dli $4,0x0000000fffffffff
dli $4,0x00000000ffffffff
dli $4,0x000000000fffffff
dli $4,0x0000000000ffffff
dli $4,0x00000000000fffff
dli $4,0x000000000000ffff
dli $4,0x0000000000000fff
dli $4,0x00000000000000ff
dli $4,0x000000000000000f
dli $4,0x000000000003fffc
dli $4,0x00003fffc0000000
dli $4,0x0003fffc00000000
dli $4,0x003fffc000000000
dli $4,0x003fffffffc00000
dli $4,0x003ffffffffc0000
dli $4,0x003fffffffffc000
dli $4,0x003ffc03ffffc000
# Round to a 16 byte boundary, for ease in testing multiple targets.
.p2align 4
|
stsp/binutils-ia16
| 2,158
|
gas/testsuite/gas/mips/unaligned-jump-micromips-2.s
|
.text
.set noreorder
.space 0x1000
.align 4
.set micromips
.ent foo
foo:
not $2, $3
jalx bar0
not $2, $3
jal bar0
not $2, $3
jals bar0
not $2, $3
j bar0
not $2, $3
jalx bar1
not $2, $3
jal bar1
not $2, $3
jals bar1
not $2, $3
j bar1
not $2, $3
jalx bar2
not $2, $3
jal bar2
not $2, $3
jals bar2
not $2, $3
j bar2
not $2, $3
jalx bar3
not $2, $3
jal bar3
not $2, $3
jals bar3
not $2, $3
j bar3
not $2, $3
jalx bar4
not $2, $3
jal bar4
not $2, $3
jals bar4
not $2, $3
j bar4
not $2, $3
jalx bar4 + 1
not $2, $3
jal bar4 + 1
not $2, $3
jals bar4 + 1
not $2, $3
j bar4 + 1
not $2, $3
jalx bar4 + 2
not $2, $3
jal bar4 + 2
not $2, $3
jals bar4 + 2
not $2, $3
j bar4 + 2
not $2, $3
jalx bar4 + 3
not $2, $3
jal bar4 + 3
not $2, $3
jals bar4 + 3
not $2, $3
j bar4 + 3
not $2, $3
jalx bar4 + 4
not $2, $3
jal bar4 + 4
not $2, $3
jals bar4 + 4
not $2, $3
j bar4 + 4
not $2, $3
jalx bar16
not $2, $3
jal bar16
not $2, $3
jals bar16
not $2, $3
j bar16
not $2, $3
jalx bar17
not $2, $3
jal bar17
not $2, $3
jals bar17
not $2, $3
j bar17
not $2, $3
jalx bar18
not $2, $3
jal bar18
not $2, $3
jals bar18
not $2, $3
j bar18
not $2, $3
jalx bar18 + 1
not $2, $3
jal bar18 + 1
not $2, $3
jals bar18 + 1
not $2, $3
j bar18 + 1
not $2, $3
jalx bar18 + 2
not $2, $3
jal bar18 + 2
not $2, $3
jals bar18 + 2
not $2, $3
j bar18 + 2
not $2, $3
jalx bar18 + 3
not $2, $3
jal bar18 + 3
not $2, $3
jals bar18 + 3
not $2, $3
j bar18 + 3
not $2, $3
jalx bar18 + 4
not $2, $3
jal bar18 + 4
not $2, $3
jals bar18 + 4
not $2, $3
j bar18 + 4
not $2, $3
jalr $0, $ra
not $2, $3
.end foo
# Force some (non-delay-slot) zero bytes, to make 'objdump' print ...
.align 4, 0
.space 16
.macro obj n:req
.globl bar\@
.type bar\@, @object
bar\@ :
.byte 0
.size bar\@, . - bar\@
.if \n - 1
obj \n - 1
.endif
.endm
.macro fun n:req
.globl bar\@
.type bar\@, @function
bar\@ :
.insn
.hword 0
.size bar\@, . - bar\@
.if \n - 1
fun \n - 1
.endif
.endm
.align 4
obj 16
fun 8
|
stsp/binutils-ia16
| 4,686
|
gas/testsuite/gas/mips/mips64r2-ill.s
|
# source file to test illegal mips64r2 instructions
.set noreorder
.set noat
.text
text_label:
# dext macro position/size checks
# constraint: 0 <= pos < 64
dext $4, $5, -1, 1 # error (position)
dext $4, $5, 0, 1
dext $4, $5, 63, 1
dext $4, $5, 64, 1 # error (position)
# constraint: 0 < size <= 64
dext $4, $5, 0, 0 # error (size)
dext $4, $5, 0, 1
dext $4, $5, 0, 64
dext $4, $5, 0, 65 # error (size)
# constraint: 0 < (pos+size) <= 64
dext $4, $5, 0, 1
dext $4, $5, 0, 2
dext $4, $5, 0, 63
dext $4, $5, 0, 64
dext $4, $5, 1, 1
dext $4, $5, 1, 2
dext $4, $5, 1, 63
dext $4, $5, 1, 64 # error (size)
dext $4, $5, 63, 1
dext $4, $5, 63, 2 # error (size)
dext $4, $5, 63, 63 # error (size)
dext $4, $5, 63, 64 # error (size)
# dextm instruction position/size checks
# constraint: 0 <= pos < 32
dextm $4, $5, -1, 33 # error (position)
dextm $4, $5, 0, 33
dextm $4, $5, 31, 33
dextm $4, $5, 32, 33 # error (position)
# constraint: 32 < size <= 64
dextm $4, $5, 0, 32 # error (size)
dextm $4, $5, 0, 33
dextm $4, $5, 0, 64
dextm $4, $5, 0, 65 # error (size)
# constraint: 32 < (pos+size) <= 64
dextm $4, $5, 0, 33
dextm $4, $5, 0, 34
dextm $4, $5, 0, 63
dextm $4, $5, 0, 64
dextm $4, $5, 1, 33
dextm $4, $5, 1, 34
dextm $4, $5, 1, 63
dextm $4, $5, 1, 64 # error (size)
dextm $4, $5, 31, 33
dextm $4, $5, 31, 34 # error (size)
dextm $4, $5, 31, 63 # error (size)
dextm $4, $5, 31, 64 # error (size)
# dextu instruction position/size checks
# constraint: 32 <= pos < 64
dextu $4, $5, 31, 1 # error (position)
dextu $4, $5, 32, 1
dextu $4, $5, 63, 1
dextu $4, $5, 64, 1 # error (position)
# constraint: 0 < size <= 32
dextu $4, $5, 32, 0 # error (size)
dextu $4, $5, 32, 1
dextu $4, $5, 32, 32
dextu $4, $5, 32, 33 # error (size)
# constraint: 32 < (pos+size) <= 64
dextu $4, $5, 32, 1
dextu $4, $5, 32, 2
dextu $4, $5, 32, 31
dextu $4, $5, 32, 32
dextu $4, $5, 33, 1
dextu $4, $5, 33, 2
dextu $4, $5, 33, 31
dextu $4, $5, 33, 32 # error (size)
dextu $4, $5, 63, 1
dextu $4, $5, 63, 2 # error (size)
dextu $4, $5, 63, 31 # error (size)
dextu $4, $5, 63, 32 # error (size)
# dins macro position/size checks
# constraint: 0 <= pos < 64
dins $4, $5, -1, 1 # error (position)
dins $4, $5, 0, 1
dins $4, $5, 63, 1
dins $4, $5, 64, 1 # error (position)
# constraint: 0 < size <= 64
dins $4, $5, 0, 0 # error (size)
dins $4, $5, 0, 1
dins $4, $5, 0, 64
dins $4, $5, 0, 65 # error (size)
# constraint: 0 < (pos+size) <= 64
dins $4, $5, 0, 1
dins $4, $5, 0, 2
dins $4, $5, 0, 63
dins $4, $5, 0, 64
dins $4, $5, 1, 1
dins $4, $5, 1, 2
dins $4, $5, 1, 63
dins $4, $5, 1, 64 # error (size)
dins $4, $5, 63, 1
dins $4, $5, 63, 2 # error (size)
dins $4, $5, 63, 63 # error (size)
dins $4, $5, 63, 64 # error (size)
# dinsm instruction position/size checks
# constraint: 0 <= pos < 32
dinsm $4, $5, -1, 33 # error (position)
dinsm $4, $5, 0, 33
dinsm $4, $5, 31, 33
dinsm $4, $5, 32, 33 # error (position)
# constraint: 2 <= size <= 64
dinsm $4, $5, 31, 1 # error (size)
dinsm $4, $5, 31, 2
dinsm $4, $5, 0, 64
dinsm $4, $5, 0, 65 # error (size)
# constraint: 32 < (pos+size) <= 64
dinsm $4, $5, 0, 2 # error (size)
dinsm $4, $5, 0, 3 # error (size)
dinsm $4, $5, 0, 63
dinsm $4, $5, 0, 64
dinsm $4, $5, 1, 2 # error (size)
dinsm $4, $5, 1, 3 # error (size)
dinsm $4, $5, 1, 63
dinsm $4, $5, 1, 64 # error (size)
dinsm $4, $5, 30, 2 # error (size)
dinsm $4, $5, 30, 3
dinsm $4, $5, 30, 63 # error (size)
dinsm $4, $5, 30, 64 # error (size)
dinsm $4, $5, 31, 2
dinsm $4, $5, 31, 3
dinsm $4, $5, 31, 63 # error (size)
dinsm $4, $5, 31, 64 # error (size)
# dinsu instruction position/size checks
# constraint: 32 <= pos < 64
dinsu $4, $5, 31, 1 # error (position)
dinsu $4, $5, 32, 1
dinsu $4, $5, 63, 1
dinsu $4, $5, 64, 1 # error (position)
# constraint: 1 <= size <= 32
dinsu $4, $5, 32, 0 # error (size)
dinsu $4, $5, 32, 1
dinsu $4, $5, 32, 32
dinsu $4, $5, 32, 33 # error (size)
# constraint: 32 < (pos+size) <= 64
dinsu $4, $5, 32, 1
dinsu $4, $5, 32, 2
dinsu $4, $5, 32, 31
dinsu $4, $5, 32, 32
dinsu $4, $5, 33, 1
dinsu $4, $5, 33, 2
dinsu $4, $5, 33, 31
dinsu $4, $5, 33, 32 # error (size)
dinsu $4, $5, 62, 1
dinsu $4, $5, 62, 2
dinsu $4, $5, 62, 31 # error (size)
dinsu $4, $5, 62, 32 # error (size)
dinsu $4, $5, 63, 1
dinsu $4, $5, 63, 2 # error (size)
dinsu $4, $5, 63, 31 # error (size)
dinsu $4, $5, 63, 32 # error (size)
# Force at least 8 (non-delay-slot) zero bytes, to make 'objdump' print ...
.space 8
|
stsp/binutils-ia16
| 1,966
|
gas/testsuite/gas/mips/loongson-2f-mmi.s
|
.text
.set noreorder
simd_insns:
packsshb $f0, $f1, $f2
packsswh $f3, $f4, $f5
packushb $f6, $f7, $f8
paddb $f9, $f10, $f11
paddh $f12, $f13, $f14
paddw $f15, $f16, $f17
paddd $f18, $f19, $f20
paddsb $f21, $f22, $f23
paddsh $f24, $f25, $f26
paddusb $f27, $f28, $f29
paddush $f0, $f1, $f2
pandn $f3, $f4, $f5
pavgb $f6, $f7, $f8
pavgh $f9, $f10, $f11
pcmpeqb $f12, $f13, $f14
pcmpeqh $f15, $f16, $f17
pcmpeqw $f18, $f19, $f20
pcmpgtb $f21, $f22, $f23
pcmpgth $f24, $f25, $f26
pcmpgtw $f27, $f28, $f29
pextrh $f0, $f1, $f2
pinsrh_0 $f3, $f4, $f5
pinsrh_1 $f6, $f7, $f8
pinsrh_2 $f9, $f10, $f11
pinsrh_3 $f12, $f13, $f14
pmaddhw $f15, $f16, $f17
pmaxsh $f18, $f19, $f20
pmaxub $f21, $f22, $f23
pminsh $f24, $f25, $f26
pminub $f27, $f28, $f29
pmovmskb $f0, $f1
pmulhuh $f2, $f3, $f4
pmulhh $f5, $f6, $f7
pmullh $f8, $f9, $f10
pmuluw $f11, $f12, $f13
pasubub $f14, $f15, $f16
biadd $f17, $f18
pshufh $f19, $f20, $f21
psllh $f22, $f23, $f24
psllw $f25, $f26, $f27
psrah $f28, $f29, $f30
psraw $f0, $f1, $f2
psrlh $f3, $f4, $f5
psrlw $f6, $f7, $f8
psubb $f9, $f10, $f11
psubh $f12, $f13, $f14
psubw $f15, $f16, $f17
psubd $f18, $f19, $f20
psubsb $f21, $f22, $f23
psubsh $f24, $f25, $f26
psubusb $f27, $f28, $f29
psubush $f0, $f1, $f2
punpckhbh $f3, $f4, $f5
punpckhhw $f6, $f7, $f8
punpckhwd $f9, $f10, $f11
punpcklbh $f12, $f13, $f14
punpcklhw $f15, $f16, $f17
punpcklwd $f18, $f19, $f20
fixed_point_insns:
add $f0, $f1, $f2
addu $f3, $f4, $f5
dadd $f6, $f7, $f8
sub $f9, $f10, $f11
subu $f12, $f13, $f14
dsub $f15, $f16, $f17
or $f18, $f19, $f20
sll $f21, $f22, $f23
dsll $f24, $f25, $f26
xor $f27, $f28, $f29
nor $f0, $f1, $f2
and $f3, $f4, $f5
srl $f6, $f7, $f8
dsrl $f9, $f10, $f11
sra $f12, $f13, $f14
dsra $f15, $f16, $f17
sequ $f18, $f19
sltu $f20, $f21
sleu $f22, $f23
seq $f24, $f25
slt $f26, $f27
sle $f28, $f29
|
stsp/binutils-ia16
| 2,124
|
gas/testsuite/gas/mips/vr5400.s
|
.text
stuff:
.ent stuff
/* Integer instructions. */
mul $4,$5,$6
mulu $4,$5,$6
mulhi $4,$5,$6
mulhiu $4,$5,$6
muls $4,$5,$6
mulsu $4,$5,$6
mulshi $4,$5,$6
mulshiu $4,$5,$6
macc $4,$5,$6
maccu $4,$5,$6
macchi $4,$5,$6
macchiu $4,$5,$6
msac $4,$5,$6
msacu $4,$5,$6
msachi $4,$5,$6
msachiu $4,$5,$6
ror $4,$5,25
rorv $4,$5,$6
dror $4,$5,25
dror $4,$5,57 /* Should expand to dror32 $4,$5,25. */
dror32 $4,$5,25
drorv $4,$5,$6
/* Debug instructions. */
dbreak
dret
mfdr $3,$3
mtdr $3,$3
/* Coprocessor 0 instructions, minus standard ISA 3 ones.
That leaves just the performance monitoring registers. */
mfpc $4,1
mfps $4,1
mtpc $4,1
mtps $4,1
/* Multimedia instructions. */
.macro nsel2 op
/* Test each form of each vector opcode. */
\op $f0,$f2
\op $f4,$f6[2]
\op $f6,15
.if 0 /* Which is right?? */
/* Test negative numbers in immediate-value slot. */
\op $f4,-3
.else
/* Test that it's recognized as an unsigned field. */
\op $f4,31
.endif
.endm
.macro nsel3 op
/* Test each form of each vector opcode. */
\op $f0,$f2,$f4
\op $f2,$f4,$f6[2]
\op $f6,$f4,15
.if 0 /* Which is right?? */
/* Test negative numbers in immediate-value slot. */
\op $f4,$f6,-3
.else
/* Test that it's recognized as an unsigned field. */
\op $f4,$f6,31
.endif
.endm
nsel3 add.ob
nsel3 and.ob
nsel2 c.eq.ob
nsel2 c.le.ob
nsel2 c.lt.ob
nsel3 max.ob
nsel3 min.ob
nsel3 mul.ob
nsel2 mula.ob
nsel2 mull.ob
nsel2 muls.ob
nsel2 mulsl.ob
nsel3 nor.ob
nsel3 or.ob
nsel3 pickf.ob
nsel3 pickt.ob
nsel3 sub.ob
nsel3 xor.ob
/* ALNI, SHFL: Vector only. */
alni.ob $f0,$f2,$f4,5
shfl.mixh.ob $f0,$f2,$f4
shfl.mixl.ob $f0,$f2,$f4
shfl.pach.ob $f0,$f2,$f4
shfl.pacl.ob $f0,$f2,$f4
/* SLL,SRL: Scalar or immediate. */
sll.ob $f2,$f4,$f6[3]
sll.ob $f4,$f6,14
srl.ob $f2,$f4,$f6[3]
srl.ob $f4,$f6,14
/* RZU: Immediate, must be 0, 8, or 16. */
rzu.ob $f2,13
/* No selector. */
rach.ob $f2
racl.ob $f2
racm.ob $f2
wach.ob $f2
wacl.ob $f2,$f4
ror $4,$5,$6
rol $4,$5,15
dror $4,$5,$6
drol $4,$5,31
drol $4,$5,62
.space 8
.end stuff
|
stsp/binutils-ia16
| 3,027
|
gas/testsuite/gas/mips/ldstla-32.s
|
.text
ld $2, 0xffffffffffffffff($4)
ld $2, 0xffffffffabcdef01($4)
ld $2, 0xffffffff80000000($4)
ld $2, 0xffffffff7fffffff($4)
ld $2, 0xffffffff01234567($4)
ld $2, 0xffffffff00000000($4)
ld $2, 0xffffffff($4)
ld $2, 0xabcdef01($4)
ld $2, 0x80000000($4)
ld $2, 0x7fffffff($4)
ld $2, 0x01234567($4)
ld $2, 0x00000000($4)
ld $2, 0xffffffffffffffff
ld $2, 0xffffffffabcdef01
ld $2, 0xffffffff80000000
ld $2, 0xffffffff7fffffff
ld $2, 0xffffffff01234567
ld $2, 0xffffffff00000000
ld $2, 0xffffffff
ld $2, 0xabcdef01
ld $2, 0x80000000
ld $2, 0x7fffffff
ld $2, 0x01234567
ld $2, 0x00000000
sd $2, 0xffffffffffffffff($4)
sd $2, 0xffffffffabcdef01($4)
sd $2, 0xffffffff80000000($4)
sd $2, 0xffffffff7fffffff($4)
sd $2, 0xffffffff01234567($4)
sd $2, 0xffffffff00000000($4)
sd $2, 0xffffffff($4)
sd $2, 0xabcdef01($4)
sd $2, 0x80000000($4)
sd $2, 0x7fffffff($4)
sd $2, 0x01234567($4)
sd $2, 0x00000000($4)
sd $2, 0xffffffffffffffff
sd $2, 0xffffffffabcdef01
sd $2, 0xffffffff80000000
sd $2, 0xffffffff7fffffff
sd $2, 0xffffffff01234567
sd $2, 0xffffffff00000000
sd $2, 0xffffffff
sd $2, 0xabcdef01
sd $2, 0x80000000
sd $2, 0x7fffffff
sd $2, 0x01234567
sd $2, 0x00000000
lw $2, 0xffffffffffffffff($4)
lw $2, 0xffffffffabcdef01($4)
lw $2, 0xffffffff80000000($4)
lw $2, 0xffffffff7fffffff($4)
lw $2, 0xffffffff01234567($4)
lw $2, 0xffffffff00000000($4)
lw $2, 0xffffffff($4)
lw $2, 0xabcdef01($4)
lw $2, 0x80000000($4)
lw $2, 0x7fffffff($4)
lw $2, 0x01234567($4)
lw $2, 0x00000000($4)
lw $2, 0xffffffffffffffff
lw $2, 0xffffffffabcdef01
lw $2, 0xffffffff80000000
lw $2, 0xffffffff7fffffff
lw $2, 0xffffffff01234567
lw $2, 0xffffffff00000000
lw $2, 0xffffffff
lw $2, 0xabcdef01
lw $2, 0x80000000
lw $2, 0x7fffffff
lw $2, 0x01234567
lw $2, 0x00000000
sw $2, 0xffffffffffffffff($4)
sw $2, 0xffffffffabcdef01($4)
sw $2, 0xffffffff80000000($4)
sw $2, 0xffffffff7fffffff($4)
sw $2, 0xffffffff01234567($4)
sw $2, 0xffffffff00000000($4)
sw $2, 0xffffffff($4)
sw $2, 0xabcdef01($4)
sw $2, 0x80000000($4)
sw $2, 0x7fffffff($4)
sw $2, 0x01234567($4)
sw $2, 0x00000000($4)
sw $2, 0xffffffffffffffff
sw $2, 0xffffffffabcdef01
sw $2, 0xffffffff80000000
sw $2, 0xffffffff7fffffff
sw $2, 0xffffffff01234567
sw $2, 0xffffffff00000000
sw $2, 0xffffffff
sw $2, 0xabcdef01
sw $2, 0x80000000
sw $2, 0x7fffffff
sw $2, 0x01234567
sw $2, 0x00000000
la $2, 0xffffffffffffffff($4)
la $2, 0xffffffffabcdef01($4)
la $2, 0xffffffff80000000($4)
la $2, 0xffffffff7fffffff($4)
la $2, 0xffffffff01234567($4)
la $2, 0xffffffff00000000($4)
la $2, 0xffffffff($4)
la $2, 0xabcdef01($4)
la $2, 0x80000000($4)
la $2, 0x7fffffff($4)
la $2, 0x01234567($4)
la $2, 0x00000000($4)
la $2, 0xffffffffffffffff
la $2, 0xffffffffabcdef01
la $2, 0xffffffff80000000
la $2, 0xffffffff7fffffff
la $2, 0xffffffff01234567
la $2, 0xffffffff00000000
la $2, 0xffffffff
la $2, 0xabcdef01
la $2, 0x80000000
la $2, 0x7fffffff
la $2, 0x01234567
la $2, 0x00000000
.space 8
|
stsp/binutils-ia16
| 2,845
|
gas/testsuite/gas/pdp11/opcode.s
|
# Opcode test for PDP-11.
# Copyright (C) 2002-2022 Free Software Foundation, Inc.
#
# This file 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.
foo: .word 0
bar: .word foo
start: halt
start2: wait
rti
bpt
iot
reset
rtt
mfpt
jmp (r1)+
rts r2
spl 3
nop
clc
clv
clz
cln
ccc
sec
sev
sez
sen
scc
swab pc
1: br 1b
bne 1b
beq 1b
bge 1b
blt 1b
bgt 1b
ble 1b
jsr pc,@(sp)+
clr -(sp)
com r0
inc r1
dec r2
neg r3
adc r4
sbc r5
tst (sp)+
ror r5
rol r4
asr @10(r4)
asl 4(r5)
mark 2
mfpi sp
mtpi @$402
sxt r3
csm 2(r4)
tstset (r3)
wrtlck 2(r4)
mov r0,r1
cmp (r0),(r4)
bit (r0)+,-(r3)
bic foo,@bar
bis @(r1)+,@-(r5)
add 4(r3),@6(r3)
mul $10,r2
div 1b,r4
ash $3,r4
ashc $7,r2
xor r3,10(sp)
fadd r2
fsub r1
fmul r4
fdiv r0
l2dr r1
movc
movrc
movtc
locc
skpc
scanc
spanc
cmpc
matc
addn
subn
cmpn
cvtnl
cvtpn
cvtnp
ashn
cvtln
l3dr r5
addp
subp
cmpp
cvtpl
mulp
divp
ashp
cvtlp
movci
movrci
movtci
locci
skpci
scanci
spanci
cmpci
matci
addni
subni
cmpni
cvtnli
cvtpni
cvtnpi
ashni
cvtlni
addpi
subpi
cmppi
cvtpli
mulpi
divpi
ashpi
cvtlpi
med
2: xfc 42
sob r0,2b
bpl 2b
bmi 2b
bhi 2b
blos 2b
bvc 2b
bvs 2b
bcc 2b
bcs 2b
emt 69
sys 42
clrb (r3)
comb @-(r5)
incb @(sp)+
decb r3
negb foo
adcb @bar
sbcb -(r2)
tstb (r4)+
rorb r1
rolb r2
asrb r3
aslb r4
mtps $0340
mfpd sp
mtpd (r0)
mfps -(sp)
movb $17,foo
cmpb r1,(r2)
bitb $0117,r5
bicb $1,bar
bisb $2,@bar
sub r0,r5
cfcc
setf
seti
ldub
setd
setl
ldfps $1
stfps -(sp)
stst (r2)
clrf ac3
tstf ac1
absf ac2
negf ac0
mulf $0f0.25,ac1
modf ac5,ac0
addf foo,ac2
ldf @bar,ac1
subf ac4,ac3
cmpf ac5,ac2
stf ac1,-(sp)
divf $0f20.0,ac0
stexp ac2,r5
stcfi ac3,r0
stcff ac3,ac5
ldexp r0,ac2
ldcif r2,ac3
ldcff ac5,ac2
# aliases for some of these opcodes:
l2d r1
3: l3d r4
bhis 3b
blo 3b
trap 99
clrd ac3
tstd ac2
absd ac1
negd ac0
muld ac5,ac2
modd ac4,ac0
addd ac4,ac3
ldd bar,ac0
subd foo,ac2
cmpd ac5,ac2
std ac1,(r2)
divd (sp)+,ac3
stcfl ac2,r5
stcdi ac3,r0
stcdl ac2,r4
stcfd ac2,ac5
stcdf ac1,ac4
ldcid r0,ac1
ldclf r4,ac2
ldcld $01234567,ac3
ldcfd ac5,ac2
ldcdf ac4,ac0
|
stsp/binutils-ia16
| 1,771
|
gas/testsuite/gas/m68hc11/9s12x-mov.s
|
# Test for correct generation of 9s12x specific moves
.sect .text
;;
;; Test all s12x extended forms of movb, movw
;; page 273 et seq in S12XCPUV2
;;
v1=4
v2=68
v3=88
v4=0x89
v5=0xfe
v6=0x80
a1=0x1234
a2=0x3456
a3=0x8123
a4=0xc567
a5=0x2987
a6=0x1009
;movb
movb #v1, a1
movb #v2, 0,x
movb #v3, -254,y
movb #v4, a1,sp
movb #v5, [d,x]
movb #v6, [a2,sp]
movb a1, a2
movb a2, 1,x
movb a3, 255,y
movb a4, a1,sp
movb a5, [d,y]
movb a6, [a3,sp]
movb 1,x+, a1
movb 2,-x, 15,x
movb 7,sp+, 253,y
movb 6,-sp, a2,sp
movb -15,y, [d,x]
movb 13,sp, [a5,sp]
movb [d,x], a1
movb [d,y], 14,x
movb [d,sp], 253,y
movb [d,pc], a2,sp
movb [d,x], [d,x]
movb [d,y], [a5,sp]
movb [a1,x], a2
movb [a2,y], 13,x
movb [a3,sp], 251,y
movb [a4,pc], a3,sp
movb [a5,x], [d,pc]
movb [a6,y], [a5,sp]
;movw
movw #a1, a1
movw #a2, 0,x
movw #a3, -254,y
movw #a4, a1,sp
movw #a5, [d,x]
movw #a6, [a2,sp]
movw a1, a2
movw a2, 1,x
movw a3, 255,y
movw a4, a1,sp
movw a5, [d,y]
movw a6, [a3,sp]
movw 1,x+, a1
movw 2,-x, 15,x
movw 7,sp+, 253,y
movw 6,-sp, a2,sp
movw -15,y, [d,x]
movw 13,sp, [a5,sp]
movw [d,x], a1
movw [d,y], 14,x
movw [d,sp], 253,y
movw [d,pc], a2,sp
movw [d,x], [d,x]
movw [d,y], [a5,sp]
movw [a1,x], a2
movw [a2,y], 13,x
movw [a3,sp], 251,y
movw [a4,pc], a3,sp
movw [a5,x], [d,pc]
movw [a6,y], [a5,sp]
|
stsp/binutils-ia16
| 1,541
|
gas/testsuite/gas/m68hc11/insns9s12xg.s
|
# XGATE instruction set and all modes
.sect .text
val1 = 0x1234
val2 = 0x5432
u08_1 = 0x32
u08_2 = 0xa5
label1:
adc r1,r2,r3
label2:
add r4,r6,r1
label3:
add r7,#val1 ;splits out to addh, addl
addl r4,#u08_2
addh r4,#u08_1
and r7,r6,r5
and r2,#val2
andl r1, #u08_2
andh r1, #u08_1
asr r2,#3
asr r3,r4
bcc label1
bcs label2
beq label3
bfext r1,r2,r3
bffo r4,r5
bfins r6,r7,r1
bfinsi r2,r4,r6
bfinsx r3,r5,r7
bge label1
bgt label2
bhi label3
bhs label1
bith r2,#0x55
bitl r3,#0xaa
ble label2
blo label3
bls label1
blt label2
bmi label3
bne label1
bpl label2
bra label3
brk
bvc label1
bvs label2
cmp r1,r2
cmp r3,#val1
cmpl r4,#u08_1
com r4,r5
com r6
cpc r7,r5
cpch r6,#u08_2
csem #2
csem r1
csl r2,#1
csl r3,r4
csr r5,#4
csr r6,r7
jal r1
ldb r2,(r3,#4)
ldb r3,(r0,r2)
ldb r4,(r5,r6+)
ldb r5,(r6,-r7)
ldh r6,#0x35
ldl r7,#0x46
ldw r1,(r2,#29)
ldw r2,(r3,r0)
ldw r3,(r4,r5+)
ldw r4,(r5,-r6)
ldw r6,#0x1234
lsl r7,#2
lsl r2,r1
lsr r5,#3
lsl r6,r3
mov r7,r6
neg r2,r3
neg r4
nop
or r2,r3,r4
or r5,#0x1256
orh r6,#0x08
orl r4,#0xf0
par r1 ; comma on datasheet a typo?
rol r2,#5
rol r3,r4
ror r3,#6
ror r5,r4
rts
sbc r7,r1,r2
sex r1
sif
sif r2
ssem #5
ssem r3
stb r2,(r4,#15)
stb r3,(r5,r6)
stb r0,(r7,r1+)
stb r1,(r2,-r3)
stw r7,(r6,#30)
stw r6,(r5,r0)
stw r5,(r4,r3+)
stw r4,(r3,-r2)
sub r7,r6,r5
sub r4,#val1
subh r5,#0x44
subl r4,#0x55
tfr r2,ccr
tfr ccr,r3
tfr r5,pc
tst r2
xnor r4,r6,r2
xnor r3,#val2
xnorh r2,#0x32
xnorl r1,#0x54
|
stsp/binutils-ia16
| 1,724
|
gas/testsuite/gas/m68hc11/opers12.s
|
#
# Try to verify all operand modes for 68HC12
#
sect .text
globl start
start:
anda [12,x] ; Indexed indirect
ldaa #10
ldx L1
L1: ldy ,x
addd 1,y ; Offset from register
subd -1,y
eora 15,y
eora -16,y
eorb 16,y
eorb -17,y
oraa 128,sp
orab -128,sp
orab 255,x
orab -256,x
anda 256,x
andb -257,x
anda [12,x] ; Indexed indirect (16-bit offset)
ldaa [257,y]
ldab [32767,sp]
ldd [32768,pc]
ldd L1,pc
std a,x ; Two-reg index
ldx b,x
stx d,y
addd 1,+x ; Pre-Auto inc
addd 2,+x
addd 8,+x
addd 1,sp+ ; Post-Auto inc
addd 2,sp+
addd 8,sp+
subd 1,-y ; Pre-Auto dec
subd 2,-y
subd 8,-y
addd 1,y- ; Post-Auto dec
addd 2,y-
addd 8,y-
std [d,x] ; Indexed indirect with two reg index
std [d,y]
std [d,sp]
std [d,pc]
beq L1
lbeq start
lbcc L2
;;
;; Move insn with various operands
;;
movb start, 1,x
movw 1,x, start
movb start, 1,+x
movb start, 1,-x
movb #23, 1,-sp
movb L1, L2
movb L1, a,x
movw L1, b,x
movw L1, d,x
movw d,x, a,x
movw b,sp, d,pc
movw b,sp, L1
movw b,sp, 1,x
movw d,x, a,y
trap #0x30
trap #0x39
trap #0x40
trap #0x80
trap #255
L2:
movw 1,x,2,x
movw -1,-1
movw -1,1,x
movw #-1,1,x
movw 3,8
movw #3,3
movw #3,1,x
movw 3,1,x
movw 3,+2,x
movw 4,-2,x
rts
;;
;; Post-index byte with relocation
;;
post_indexed_pb:
t1:
leas abort,x
t2:
leax t2-t1,y
leax toto,x
leas toto+titi,sp
leay titi,x
leas bb,y
leas min5b,pc
leas max5b,pc
leas min9b,pc
leas max9b,pc
;;
;; Disassembler bug with movb
;;
movb #23,0x2345
movb #40,12,sp
movb #39,3,+sp
movb #20,14,sp
movw #0x3210,0x3456
movw #0x4040,12,sp
movw #0x3900,3,+sp
movw #0x2000,14,sp
# movb #111,start
titi = 10
toto = 100
min5b= -16
max5b= 15
min9b= -256
max9b= 255
bb = 10240
|
stsp/binutils-ia16
| 3,160
|
gas/testsuite/gas/m68hc11/indexed12.s
|
;;
;; This file verifies the 68HC12 indexed addressing modes
;; with a 5, 9 and 16-bit offset.
;;
.sect .text
.globl _main
_main:
nop
;;; Global check (1st)
ldab L1-_main,x ; Offset/const of these 2 insns must be
ldaa #L1-_main ; identical (likewise for 2nd global check)
;;; Test gas relax with difference of symbols (same section)
ldaa L2-L1,x ; -> ldaa 2,x (5-bit offset), text seg
adda L1-L2,y ; -> adda -2,y (5-bit offset), text seg
orab L7-L6,sp ; -> orab 8,sp (5-bit offset), text seg
anda L8-L7,sp ; -> anda 15,sp (5-bit offset), text seg
eora L7-L8,sp ; -> eora -15,sp (5-bit offset), text seg
eorb L7-L9,sp ; -> eorb -16,sp (5-bit offset), text seg
andb L9-L7,sp ; -> andb 16,sp (9-bit offset), text seg
staa L7-L10,x ; -> staa -17,x (9-bit offset), text seg
stab L11-L10,y ; -> stab 128,y (9-bit offset), text seg
stab L10-L11,y ; -> stab -128,y (9-bit offset), text seg
stab L11-L10+1,y ; -> stab 129,y (9-bit offset), text seg
stab L10-L11-1,y ; -> stab -129,y (9-bit offset), text seg
stab L11-1-L10,y ; -> stab 127,y (9-bit offset), text seg
stab L10-1-L11,y ; -> stab -129,y (9-bit offset), text seg
tst L12-L10,x ; -> tst 255,x (9-bit offset), text seg
tst L10-L12,x ; -> tst -255,x (9-bit offset), text seg
tst L12-L10+1,x ; -> tst 256,x (16-bit offset), text seg
mina L13-L10,x ; -> mina 256,x (16-bit offset)
mina L10-L13,x ; -> mina -256,x (9-bit offset)
maxa L14-L10,x ; -> maxa 257,x (16-bit offset)
maxa L10-L14,x ; -> maxa -257,x (16-bit offset)
;;; Test gas relax with difference of symbols (different section)
ldaa D2-D1,x ; -> ldaa 2,x (5-bit offset), data seg
adda D1-D2,y ; -> adda -2,y (5-bit offset), data seg
orab D7-D6,sp ; -> orab 8,sp (5-bit offset), data seg
anda D8-D7,sp ; -> anda 15,sp (5-bit offset), data seg
eora D7-D8,sp ; -> eora -15,sp (5-bit offset), data seg
eorb D7-D9,sp ; -> eorb -16,sp (5-bit offset), data seg
andb D9-D7,sp ; -> andb 16,sp (9-bit offset), data seg
staa D7-D10,x ; -> staa -17,x (9-bit offset), data seg
stab D11-D10,y ; -> stab 128,y (9-bit offset), data seg
stab D10-D11,y ; -> stab -128,y (9-bit offset), data seg
stab D11-D10+1,y ; -> stab 129,y (9-bit offset), data seg
stab D10-D11+1,y ; -> stab -127,y (9-bit offset), data seg
stab D11-1-D10,y ; -> stab 127,y (9-bit offset), data seg
stab D10-1-D11,y ; -> stab -129,y (9-bit offset), data seg
tst D12-D10,x ; -> tst 255,x (9-bit offset), data seg
tst D10-D12,x ; -> tst -255,x (9-bit offset), data seg
tst D12-D10+1,x ; -> tst 256,x (16-bit offset), data seg
mina D13-D10,x ; -> mina 256,x (16-bit offset)
mina D10-D13,x ; -> mina -256,x (9-bit offset)
maxa D14-D10,x ; -> maxa 257,x (16-bit offset)
maxa D10-D14,x ; -> maxa -257,x (16-bit offset)
;;; Global check (2nd)
ldab L1-_main,x
ldaa #L1-_main
;;; Indexed addressing with external symbol
ldab _external+128,x
bra L2
L1:
.dc.w 0xaabb
L2:
L6:
.ds.b 8, 0xa7
L7:
.ds.b 15, 0xa7
L8:
nop
L9:
nop
L10:
.skip 128
L11:
.skip 127
L12:
nop
L13:
nop
L14:
rts
.sect .data
D1:
.dc.w 0xaabb
D2:
D6:
.ds.b 8, 0xa7
D7:
.ds.b 15, 0xa7
D8:
nop
D9:
nop
D10:
.skip 128
D11:
.skip 127
D12:
nop
D13:
nop
D14:
|
stsp/binutils-ia16
| 1,261
|
gas/testsuite/gas/m68hc11/insns9s12x.s
|
# Test for correct generation of 9s12x specific insns.
.sect .text
addx #0x5678
addy 2,x+
aded 0,x
adex 2,-y
adey [d,x]
andx #0x9988
andy 0x55aa
aslw 0x2004
aslx
asly
asrw 0x3000,y
asrx
asry
bitx [0x3456,sp]
bity [d,sp]
btas 0x2345, #0x04
clrw 0x2008,y
clrx
clry
comw 0,x
comx
comy
cped #0xfdeb
cpes 0xfedc
cpex 2,sp
cpey 2,sp+
decw 0,x
decx
decy
eorx 0x34
eory 0x1234
; exg in own test
gldaa 0x5678
gldab 0,x
gldd 2,y+
glds 0,y
gldx [d,y]
gldy [d,x]
gstaa 0x5001
gstab 0x5189
gstd 0x5000,x
gsts 0x7008
gstx 0x6001,y
gsty [d,x]
incw [0x100,sp]
incx
incy
lslw 0x3005
lslx
lsly
lsrw 0x3890
lsrx
lsry
; mov in own test
negw 2,-y
negx
negy
orx #0x9876
ory 0x9876
pshcw
pulcw
rolw 0x5544
rolx
roly
rorw 0,x
rorx
rory
sbed 2,y
sbex 0x3458
sbey 0x8543
;sex with exg
subx [d,y]
suby [d,x]
sys
;tfr with exg
tstw 3,x
tstx
tsty
|
stsp/binutils-ia16
| 4,821
|
gas/testsuite/gas/m68hc11/malis.s
|
;;
;; This file verifies the compliance with the Motorola specification:
;;
;; MOTOROLA STANDARDS
;; Document #1001, Version 1.0
;; SPECIFICATION FOR Motorola 8- and 16-Bit ASSEMBLY LANGUAGE INPUT STANDARD
;; 26, October 1999
;;
;; Available at:
;;
;; http://www.mcu.motsps.com/dev_tools/hc12/eabi/m8-16alis.pdf
;;
;; Lines starting with '#' represent instructions that fail in GAS.
;;
;;
;; Section 8.2 INPUTS
;; Validated within the whole file
;; Section 8.2.1 Character Set
;; TBD
;; Section 8.2.2 Assembly Language Statement
;; Validated within the whole file
;; Section 8.2.3 Comments
; Motorola comment
;; This file is full of comments
;; Section 8.2.5 Location Counter
section .text
_start:
L0: * ; L0 set to 0 (relative to text)
ldaa 1,x
L1: equ * ; L1 set to 2 (relative to text)
;; Section 8.2.6 Sections
section .data
section .text
section empty
section .text
;; Section 8.2.7 Expressions
L2: equ 23 ; Absolute = 0x17
L3: equ L0-23 ; Simple relocatable
;; Section 8.2.7.1 Primary Expression
L4: equ 45 ; Numeric = 0x2d
L5: equ L0 ; Symbolic
;; Section 8.2.7.2 Absolute Expression
L_txt: ldaa #44
L_txt2:
L6: equ -L4 ; unary expr 0xffffffd3
L7: equ L6+1000 ; binary expr 0x03bb
L8: equ L6-12 ; 0xffffffc7
L9: equ L_txt2-L_txt ; reloc - reloc 2 = sizeof(ldaa #44)
;; Section 8.2.7.3 Simple Relocatable Expressions
L10: equ _start ; symbol 0 + text
L11: equ L10+23 ; reloc+abs 0x17 + text
L12: equ L11-4 ; reloc-abs 0x13 + text
L13: equ L12+L9 ; reloc+abs 0x15 + text
;; Section 8.2.8 Symbols
section .text
Text_Symbol:
ldx #Data_Symbol
section .data
Data_Symbol:
;; Section 8.2.8.1 Labels
L_label_shall_be_significant_to_at_least_32_chars:
dc.b 1
L_label_lower: ; Labels are case sensitive
dc.b 2
L_Label_Lower:
dc.b 3
;; Section 8.2.9 Constants
;
; Section 8.2.9.1 Decimal Constants
section .text
L_constant:
ldaa #123 ; -> ldaa #0x7b
ldaa #-23 ; -> ldaa #0xe9
;; Section 8.2.9.2 Binary Constants
ldab #%10001010 ; -> ldab #0x8A
ldab #%0111 ; -> ldab #0x07
;; Section 8.2.9.3 Octal Constants
ldaa #@74 ; -> ldaa 0x3c
ldaa #@377 ; -> ldaa 0xff
;; Section 8.2.9.4 Hexadecimal Constants
ldaa #$ae ; -> ldaa 0xae
ldaa #$B2 ; -> ldaa 0xb2
;; Section 8.2.9.5 String Constants
section .data
# ascii '"Single quote string"'
ascii "'Double quote string'"
;; Section 8.2.9.6 Floating Point Constants
;; No specification
L_float: float 3.241592e-2
;; Section 8.2.10 Operators
section .text
L_operator:
ldx #(((1<<3)&(1<<3)|2)<<4)+(4*4-1)
ldx #(L2>=23)&1-(L2<=23)&1+(L2==23)&1 ; -> ldx #1
ldx #(L2>23)&1-(L2<23)&1+(L2==23)&1 ; -> ldx #0
ldx #1-1+1-1+1-1
ldab #~L4 ; -> ldab #0xd2
# ldab #<_start ; force to 8-bit
# ldx #>_start ; force to 16-bit
# ldab #page(_start) ; 68HC12 page number of symbol
;; Section 8.2.11 Instructions
;; Defined by other tests
;; Section 8.2.12 Assembler Directives
;;
;; Section 8.2.12.1 Conditional Directives
;;
# The specification says we are allowed to have spaces in expressions.
# This does not work with GAS in mri mode, the instruction 'if L2 < 24'
# is in fact treated as 'if L2'.
L_if:
if L2<24 ; true
ldx #1 ; -> ldx #1
else
ldx #2
endif
if L2<23||L2>23||L2==22+1 ; true
if L2<23 ; false
ldaa #0
endif
if L2>23 ; false
ldaa #1
endif
if L2 == 23 ; true
ldaa #L2+8 ; -> ldaa #31
endif
if L2+2<23+2 ; false
if L2+4>23+4
ldaa #1
elseif L2==23
ldaa #2
else
ldaa #3
endif
elseif L2==23 ; true
ldaa #4 ; -> ldaa #4
else
ldaa #5
endif
endif
ifdef L1 ; true
ldx #23 ; -> ldx #0x17
endif
ifndef L_undef ; true
ldx #4 ; -> ldx #4
endif
;; Section 8.2.12.2 Define Constant -dc
section .data
L_const_data:
dc.b (1<<3)|2 ; 0x0a
dc.w (1<<9)+2 ; 0x02 0x02
dc.l $12345678
dc.b 10
dc.l (1<<9)*(3<<12)
# dc.b "Hello"
# dc.w "World"
# dc.l "!!!"
;; Section 8.2.12.3 Define Constant Block -dcb
dcb.b 3,2
dcb.w 2,$55AA
dcb.l 2,$12345678
dcb.b 10,2
dcb.w 5,$55AA
dcb.l 2,$12345678
# dcb.b 4, 12 ; Fails in GAS due to space
;; Section 8.2.12.4 Define Storage - ds
ds.b 4
ds.w 2
ds.l 1
ds 2
;; Section 8.2.12.5 Equate Symbol Value - equ
L_equ1: equ (1<<8)+3
L_equ2: equ L_equ1*3
L_equ3: equ L_equ2-L_equ1
;; Section 8.2.12.6 Include File - include
# include 'malis-include.s'
# include "malis-include.s"
include malis-include.s
include malis-include.s
;; Section 8.2.12.7 Origin - org
section .text
# org $100
ldaa #23
# org $200
staa 24
# org $0
rts
;; Section 8.2.12.8 Define Section - section
section .text
ldaa 23
section .data
dc.b 23
;; Section 8.2.12.9 Set Value of Symbol - set
s1: set 3
s1: set 4
s2: set s1+2
s3: set s2+4
;; Section 8.2.12.10 External Symbol Definition - xdef
xdef s1
xdef s2
xdef entry
;; Section 8.2.12.11 External Symbol Reference - xref
section .text
xref printf
xrefb write
entry:
rts
|
stsp/binutils-ia16
| 1,477
|
gas/testsuite/gas/m68hc11/branchs12.s
|
#
# Try to verify all branchs for 68HC12
# Ensures that PC-relative relocations are correct.
#
sect .text
globl start
start:
L0:
;; Branchs to defined symbols, positive offset < 128
bgt L1
bge L1
ble L1
blt L1
bhi L1
bhs L1
bcc L1
beq L1
bls L1
blo L1
bcs L1
bmi L1
bvs L1
bra L1
bvc L1
bne L1
bpl L1
brn L1
;; Branchs to defined symbols, negative offset > -128
bgt L0
bge L0
ble L0
blt L0
bhi L0
bhs L0
bcc L0
beq L0
bls L0
blo L0
bcs L0
bmi L0
bvs L0
bra L0
bvc L0
bne L0
bpl L0
brn L0
L1:
;; Branchs to defined symbols, positive offset > -128
lbgt L2
lbge L2
lble L2
lblt L2
lbhi L2
lbhs L2
lbcc L2
lbeq L2
lbls L2
lblo L2
lbcs L2
lbmi L2
lbvs L2
lbra L2
lbvc L2
lbne L2
lbpl L2
lbrn L2
;; Branchs to undefined symbols, translated into lbcc
bgt undefined
bge undefined
ble undefined
blt undefined
bhi undefined
bhs undefined
bcc undefined
beq undefined
bls undefined
blo undefined
bcs undefined
bmi undefined
bvs undefined
bra undefined
bvc undefined
bne undefined
bpl undefined
brn undefined
;; Far branchs to undefined symbols
lbgt undefined+16
lbge undefined+16
lble undefined+16
lblt undefined+16
lbhi undefined+16
lbhs undefined+16
lbcc undefined+16
lbeq undefined+16
lbls undefined+16
lblo undefined+16
lbcs undefined+16
lbmi undefined+16
lbvs undefined+16
lbra undefined+16
lbvc undefined+16
lbne undefined+16
lbpl undefined+16
lbrn undefined+16
.skip 200
L2:
rts
|
stsp/binutils-ia16
| 2,258
|
gas/testsuite/gas/m68hc11/9s12x-exg-sex-tfr.s
|
# Test for correct generation of 9s12x specific insns.
.sect .text
;;
;; Test all s12x extended forms of exg,tfr,sex where supported
;;
;; presently tmp register and h/l forms not supported in gas
;exg
;; none of shaded area is actually supported
exg a,a
exg b,a
; exg ccrh,a
; exg tmp3h,a
exg d,a
; exg xh,a
; exg yh,a
; exg sph,a
exg a,b
exg b,b
; exg ccrl,b
; exg tmp3l,b
exg d,b
; exg xl,b
; exg yl,b
; exg spl,b
; exg a,ccrh
; exg b,ccrl
exg ccr,ccr
; exg tmp3,ccr
exg d,ccr
exg x,ccr
exg y,ccr
exg sp,ccr
; exg a,tmp2h
; exg b,tmp2l
; exg ccr,tmp2
; exg tmp3,tmp2
; exg d,tmp1
; exg x,tmp2
; exg y,tmp2
; exg sp,tmp2
exg a,d
exg b,d
exg ccr,d
; exg tmp1,d
exg d,d
exg x,d
exg y,d
exg sp,d
; exg a,xh
; exg b,xl
exg ccr,x
; exg tmp3,x
exg d,x
exg x,x
exg y,x
exg sp,x
; exg a,yh
; exg b,yl
exg ccr,y
; exg tmp3,y
exg d,y
exg x,y
exg y,y
exg sp,y
; exg a,sph
; exg b,spl
exg ccr,sp
; exg tmp3,sp
exg d,sp
exg x,sp
exg y,sp
exg sp,sp
;sex
sex a,d
sex b,d
sex d,x ; new
sex d,y ; new
;tfr
tfr a,a
tfr b,a
; tfr tmp3h,a
tfr d,a
; tfr xh,a
; tfr yh,a
; tfr sph,a
tfr a,b
tfr b,b
; tfr ccrl,b
; tfr tmp3l,b
tfr d,b
; tfr xl,b
; tfr yl,b
; tfr spl,b
; tfr a,ccrh
; tfr b,ccrl
; tfr ccrw,ccrw
; tfr tmp3,ccrw
; tfr d,ccrw
; tfr x,ccrw
; tfr y,ccrw
; tfr sp,ccrw
; tfr a,tmp2h
; tfr b,tmp2l
; tfr ccrw,tmp
; tfr tmp3,tmp2
; tfr d,tmp1
; tfr x,tmp2
; tfr y,tmp2
; tfr sp,tmp2
;sex
;sex
; tfr ccrw,d
; tfr tmp1,d
tfr d,d
tfr x,d
tfr y,d
tfr sp,d
; tfr a,xh
; tfr b,xl
; tfr ccrw,x
; tfr tmp3,x
;sex
tfr x,x
tfr y,x
tfr sp,x
; tfr a,yh
; tfr b,yl
; tfr ccrw,y
; tfr tmp3,y
;sex
tfr x,y
tfr y,y
tfr sp,y
; tfr a,sph
; tfr b,spl
; tfr ccrw,xp
; tfr tmp3,sp
tfr d,sp
tfr x,sp
tfr y,sp
tfr sp,sp
|
stsp/binutils-ia16
| 5,500
|
gas/testsuite/gas/m68hc11/movb.s
|
dog2=15
dog3=-16
dog4=7
dog5=-8
;; idx - idx
ldaa #0
movb 15,x,dog2,x
movb 15,x,cat2,x
movb 15,x,15,x
ldaa #1
movb dog2,x,15,x
movb cat2,x,15,x
movb 15,x,15,x
ldaa #2
movb 15,x,dog3,x
movb 15,x,cat3,x
movb 15,x,-16,x
ldaa #3
movb dog3,x,15,x
movb cat3,x,15,x
movb -16,x,15,x
ldaa #4
movw 15,x,dog2,x
movw 15,x,cat2,x
movw 15,x,15,x
ldaa #5
movw dog2,x,15,x
movw cat2,x,15,x
movw 15,x,15,x
ldaa #6
movw 15,x,dog3,x
movw 15,x,cat3,x
movw 15,x,-16,x
ldaa #7
movw dog3,x,15,x
movw cat3,x,15,x
movw -16,x,15,x
ldaa #8
movb 15,y,dog2,y
movb 15,y,cat2,y
movb 15,y,15,y
ldaa #9
movb dog2,y,15,y
movb cat2,y,15,y
movb 15,y,15,y
ldaa #10
movb 15,y,dog3,y
movb 15,y,cat3,y
movb 15,y,-16,y
ldaa #11
movb dog3,y,15,y
movb cat3,y,15,y
movb -16,y,15,y
ldaa #12
movw 15,y,dog2,y
movw 15,y,cat2,y
movw 15,y,15,y
ldaa #13
movw dog2,y,15,y
movw cat2,y,15,y
movw 15,y,15,y
ldaa #14
movw 15,y,dog3,y
movw 15,y,cat3,y
movw 15,y,-16,y
ldaa #15
movw dog3,y,15,y
movw cat3,y,15,y
movw -16,y,15,y
ldaa #16
movb 15,y,dog2,pc
movb 15,y,cat2,pc
movb 15,y,15,pc
ldaa #17
movb dog2,y,15,pc
movb cat2,y,15,pc
movb 15,y,15,pc
ldaa #18
movb 15,y,dog3,pc
movb 15,y,cat3,pc
movb 15,y,-16,pc
ldaa #19
movb dog3,y,15,pc
movb cat3,y,15,pc
movb -16,y,15,pc
ldaa #20
movw 15,y,dog2,pc
movw 15,y,cat2,pc
movw 15,y,15,pc
ldaa #21
movw dog2,y,15,pc
movw cat2,y,15,pc
movw 15,y,15,pc
ldaa #22
movw 15,y,dog3,pc
movw 15,y,cat3,pc
movw 15,y,-16,pc
ldaa #23
movw dog3,y,15,pc
movw cat3,y,15,pc
movw -16,y,15,pc
ldaa #24
movb 15,sp,dog2,pc
movb 15,sp,cat2,pc
movb 15,sp,15,pc
ldaa #25
movb dog2,sp,15,pc
movb cat2,sp,15,pc
movb 15,sp,15,pc
ldaa #26
movb 15,sp,dog3,pc
movb 15,sp,cat3,pc
movb 15,sp,-16,pc
ldaa #27
movb dog3,sp,15,pc
movb cat3,sp,15,pc
movb -16,sp,15,pc
ldaa #28
movw 15,sp,dog2,pc
movw 15,sp,cat2,pc
movw 15,sp,15,pc
ldaa #29
movw dog2,sp,15,pc
movw cat2,sp,15,pc
movw 15,sp,15,pc
ldaa #30
movw 15,sp,dog3,pc
movw 15,sp,cat3,pc
movw 15,sp,-16,pc
ldaa #31
movw dog3,sp,15,pc
movw cat3,sp,15,pc
movw -16,sp,15,pc
ldaa #32
;; ext - idx
;; idx - ext
movb 0x1000,dog2,x
movb 0x1000,cat2,x
movb 0x1000,15,x
ldaa #33
movb dog2,x,0x1000
movb cat2,x,0x1000
movb 15,x,0x1000
ldaa #34
movb 0x1000,dog3,x
movb 0x1000,cat3,x
movb 0x1000,-16,x
ldaa #35
movb dog3,x,0x1000
movb cat3,x,0x1000
movb -16,x,0x1000
ldaa #36
movw 0x1002,dog2,x
movw 0x1002,cat2,x
movw 0x1002,15,x
ldaa #37
movw dog2,x,0x1002
movw cat2,x,0x1002
movw 15,x,0x1002
ldaa #38
movw 0x1002,dog3,x
movw 0x1002,cat3,x
movw 0x1002,-16,x
ldaa #39
movw dog3,x,0x1002
movw cat3,x,0x1002
movw -16,x,0x1002
ldaa #40
movb 0x1000,dog2,y
movb 0x1000,cat2,y
movb 0x1000,15,y
ldaa #41
movb dog2,y,0x1000
movb cat2,y,0x1000
movb 15,y,0x1000
ldaa #42
movb 0x1000,dog3,y
movb 0x1000,cat3,y
movb 0x1000,-16,y
ldaa #43
movb dog3,y,0x1000
movb cat3,y,0x1000
movb -16,y,0x1000
ldaa #44
movw 0x1002,dog2,y
movw 0x1002,cat2,y
movw 0x1002,15,y
ldaa #45
movw dog2,y,0x1002
movw cat2,y,0x1002
movw 15,y,0x1002
ldaa #46
movw 0x1002,dog3,y
movw 0x1002,cat3,y
movw 0x1002,-16,y
ldaa #47
movw dog3,y,0x1002
movw cat3,y,0x1002
movw -16,y,0x1002
ldaa #48
movb 0x1000,dog2,pc
movb 0x1000,cat2,pc
movb 0x1000,15,pc
ldaa #49
movb dog2,pc,0x1000
movb cat2,pc,0x1000
movb 15,pc,0x1000
ldaa #50
movb 0x1000,dog3,pc
movb 0x1000,cat3,pc
movb 0x1000,-16,pc
ldaa #51
movb dog3,pc,0x1000
movb cat3,pc,0x1000
movb -16,pc,0x1000
ldaa #52
movw 0x1002,dog2,pc
movw 0x1002,cat2,pc
movw 0x1002,15,pc
ldaa #53
movw dog2,pc,0x1002
movw cat2,pc,0x1002
movw 15,pc,0x1002
ldaa #54
movw 0x1002,dog3,pc
movw 0x1002,cat3,pc
movw 0x1002,-16,pc
ldaa #55
movw dog3,pc,0x1002
movw cat3,pc,0x1002
movw -16,pc,0x1002
ldaa #56
movb 0x1000,dog2,sp
movb 0x1000,cat2,sp
movb 0x1000,15,sp
ldaa #57
movb dog2,sp,0x1000
movb cat2,sp,0x1000
movb 15,sp,0x1000
ldaa #58
movb 0x1000,dog3,sp
movb 0x1000,cat3,sp
movb 0x1000,-16,sp
ldaa #59
movb dog3,sp,0x1000
movb cat3,sp,0x1000
movb -16,sp,0x1000
ldaa #60
movw 0x1002,dog2,sp
movw 0x1002,cat2,sp
movw 0x1002,15,sp
ldaa #61
movw dog2,sp,0x1002
movw cat2,sp,0x1002
movw 15,sp,0x1002
ldaa #62
movw 0x1002,dog3,sp
movw 0x1002,cat3,sp
movw 0x1002,-16,sp
ldaa #63
movw dog3,sp,0x1002
movw cat3,sp,0x1002
movw -16,sp,0x1002
ldaa #64
;; imm - idx
movb #0xaa,dog4,x
movb #0xaa,cat4,x
movb #0xaa,7,x
ldaa #65
movb #0xaa,dog5,x
movb #0xaa,cat5,x
movb #0xaa,-8,x
ldaa #66
movw #0x44,dog4,x
movw #0x44,cat4,x
movw #0x44,7,x
ldaa #67
movw #0x44,dog5,x
movw #0x44,cat5,x
movw #0x44,-8,x
ldaa #68
movb #0xaa,dog4,y
movb #0xaa,cat4,y
movb #0xaa,7,y
ldaa #69
movb #0xaa,dog5,y
movb #0xaa,cat5,y
movb #0xaa,-8,y
ldaa #70
movw #0x44,dog4,y
movw #0x44,cat4,y
movw #0x44,7,y
ldaa #71
movw #0x44,dog5,y
movw #0x44,cat5,y
movw #0x44,-8,y
ldaa #72
movb #0xaa,dog4,pc
movb #0xaa,cat4,pc
movb #0xaa,7,pc
ldaa #73
movb #0xaa,dog5,pc
movb #0xaa,cat5,pc
movb #0xaa,-8,pc
ldaa #74
movw #0x44,dog4,pc
movw #0x44,cat4,pc
movw #0x44,7,pc
ldaa #75
movw #0x44,dog5,pc
movw #0x44,cat5,pc
movw #0x44,-8,pc
ldaa #76
movb #0xaa,dog4,sp
movb #0xaa,cat4,sp
movb #0xaa,7,sp
ldaa #77
movb #0xaa,dog5,sp
movb #0xaa,cat5,sp
movb #0xaa,-8,sp
ldaa #78
movw #0x44,dog4,sp
movw #0x44,cat4,sp
movw #0x44,7,sp
ldaa #79
movw #0x44,dog5,sp
movw #0x44,cat5,sp
movw #0x44,-8,sp
ldaa #80
cat2=15
cat3=-16
cat4=7
cat5=-8
|
stsp/binutils-ia16
| 1,070
|
gas/testsuite/gas/m68hc11/insns12.s
|
# Test for correct generation of 68HC12 specific insns.
.sect .text
;; Test the call insns
call_test:
call _foo ; 24-bit reloc
call _foo,1 ; 16-bit reloc, immediate page specification
call _foo,%page(foo_page) ; 16-bit reloc and 8-bit page reloc
call 0,x,3 ; 8-bit page reloc
call 4,y,12
call 7,sp,13
call 12,x,%page(foo_page) ; 8-bit page reloc
call 4,y,%page(foo_page)
call 7,sp,%page(foo_page)
call [d,x] ; No reloc
ldab [32767,sp]
call [2048,sp] ; No reloc
call [_foo,x] ; 16-bit reloc
rtc
;; Test special insn
special_test:
emacs _foo ; Wonderful, Emacs as a single instruction!
;; Min instruction
maxa 0,x
maxa 819,y
maxa [d,x]
maxa [_foo,x]
maxm 0,x
maxm 819,y
maxm [d,x]
maxm [_foo,x]
emaxd 0,x
emaxd 819,y
emaxd [d,x]
emaxd [_foo,x]
emaxm 0,x
emaxm 819,y
emaxm [d,x]
emaxm [_foo,x]
;; Min instruction
mina 0,x
mina 819,y
mina [d,x]
mina [_foo,x]
minm 0,x
minm 819,y
minm [d,x]
minm [_foo,x]
emind 0,x
emind 819,y
emind [d,x]
emind [_foo,x]
;; Mul
emul
emuls
etbl 3,x
etbl 4,pc
;;
rev
revw
wav
;;
|
stsp/binutils-ia16
| 5,227
|
gas/testsuite/gas/m68hc11/all_insns.s
|
# Example of M68hc11 instructions
.sect .text
_start:
L0: aba
L1: abx
L2: aby
L3: adca #103
L4: adca *Z198
L5: adca 105,X
L6: adca symbol115
L7: adca 81,X
L8: adcb #255
L9: adcb *Z74
L10: adcb 236,X
L11: adcb symbol41
L12: adcb 205,X
L13: adda #186
L14: adda *Z171
L15: adda 242,X
L16: adda symbol251
L17: adda 227,X
L18: addb #70
L19: addb *Z124
L20: addb 194,X
L21: addb symbol84
L22: addb 248,X
L23: addd #8987
L24: addd *Z232
L25: addd 231,X
L26: addd symbol141
L27: addd 118,X
L28: anda #90
L29: anda *Z46
L30: anda 99,X
L31: anda symbol51
L32: anda 159,X
L33: andb #201
L34: andb *Z154
L35: andb 102,X
L36: andb symbol50
L37: andb 13,X
L38: asl 183,X
L39: asl symbol49
L40: asl 88,X
L41: asla
L42: aslb
L43: asld
L44: asr 163,X
L45: asr symbol90
L46: asr 37,X
L47: asra
L48: asrb
L49: bcc L93
L50: bclr *Z5 #$17
L51: bclr 88,X #$e9
L52: bclr 94,X #$d4
L53: bcs L171
L54: beq L178
L55: bge L205
L56: bgt L198
L57: bhi L155
L58: bhs L180
L59: bita #84
L60: bita *Z17
L61: bita 14,X
L62: bita symbol130
L63: bita 116,X
L64: bitb #65
L65: bitb *Z33
L66: bitb 61,X
L67: bitb symbol220
L68: bitb 135,X
L69: ble L112
L70: blo L233
L71: bls L62
L72: blt L161
L73: bmi L65
L74: bne L225
L75: bpl L252
L76: bra L103
L77: brclr *Z62 #$01 .+126
L78: brclr 151,X #$ea .+92
L79: brclr 107,X #$96 .+15
L80: brn L56
L81: brset *Z92 #$2a .+108
L82: brset 176,X #$3b .+123
L83: brset 50,X #$af .+60
L84: bset *Z84 #$ec
L85: bset 24,X #$db
L86: bset 92,X #$02
L87: bsr L26
L88: bvc L254
L89: bvs L67
L90: cba
L91: clc
L92: cli
L93: clr 251,X
L94: clr symbol250
L95: clr 170,X
L96: clra
L97: clrb
L98: clv
L99: cmpa #58
L100: cmpa *Z251
L101: cmpa 41,X
L102: cmpa symbol209
L103: cmpa 230,X
L104: cmpb #5
L105: cmpb *Z60
L106: cmpb 124,X
L107: cmpb symbol148
L108: cmpb 117,X
L109: cmpd #4056
L110: cmpd *Z190
L111: cmpd 97,X
L112: cmpd symbol137
L113: cmpd 249,X
L114: cmpx #44892
L115: cmpx *Z187
L116: cmpx 168,X
L117: cmpx symbol153
L118: cmpx 15,X
L119: cmpy #16533
L120: cmpy *Z177
L121: cmpy 235,X
L122: cmpy symbol241
L123: cmpy 179,X
L124: com 5,X
L125: com symbol239
L126: com 247,X
L127: coma
L128: comb
L129: cpd #48896
L130: cpd *Z233
L131: cpd 161,X
L132: cpd symbol58
L133: cpd 229,X
L134: cpx #36810
L135: cpx *Z11
L136: cpx 203,X
L137: cpx symbol208
L138: cpx 72,X
L139: cpy #583
L140: cpy *Z100
L141: cpy 189,X
L142: cpy symbol31
L143: cpy 35,X
L144: daa
L145: dec 30,X
L146: dec symbol168
L147: dec 28,X
L148: deca
L149: decb
L150: des
L151: dex
L152: dey
L153: eora #123
L154: eora *Z100
L155: eora 197,X
L156: eora symbol20
L157: eora 115,X
L158: eorb #90
L159: eorb *Z197
L160: eorb 94,X
L161: eorb symbol75
L162: eorb 121,X
L163: fdiv
L164: idiv
L165: inc 99,X
L166: inc symbol59
L167: inc 112,X
L168: inca
L169: incb
L170: ins
L171: inx
L172: iny
L173: jmp 100,X
L174: jmp symbol36
L175: jmp 17,X
L176: jsr *Z158
L177: jsr 9,X
L178: jsr symbol220
L179: jsr 170,X
L180: ldaa #212
L181: ldaa *Z172
L182: ldaa 242,X
L183: ldaa symbol27
L184: ldaa 16,X
L185: ldab #175
L186: ldab *Z59
L187: ldab 51,X
L188: ldab symbol205
L189: ldab 227,X
L190: ldd #50512
L191: ldd *Z72
L192: ldd 71,X
L193: ldd symbol21
L194: ldd 92,X
L195: lds #20411
L196: lds *Z111
L197: lds 34,X
L198: lds symbol25
L199: lds 186,X
L200: ldx #22427
L201: ldx *Z125
L202: ldx 245,X
L203: ldx symbol11
L204: ldx 225,X
L205: ldy #44058
L206: ldy *Z28
L207: ldy 127,X
L208: ldy symbol35
L209: ldy 248,X
L210: lsl 41,X
L211: lsl symbol248
L212: lsl 164,X
L213: lsla
L214: lslb
L215: lsld
L216: lsr 27,X
L217: lsr symbol19
L218: lsr 181,X
L219: lsra
L220: lsrb
L221: lsrd
L222: mul
L223: neg 202,X
L224: neg symbol78
L225: neg 232,X
L226: nega
L227: negb
L228: nop
L229: oraa #152
L230: oraa *Z50
L231: oraa 56,X
L232: oraa symbol224
L233: oraa 121,X
L234: orab #77
L235: orab *Z61
L236: orab 52,X
L237: orab symbol188
L238: orab 95,X
L239: psha
L240: pshb
L241: pshx
L242: pshy
L243: pula
L244: pulb
L245: pulx
L246: puly
L247: rol 78,X
L248: rol symbol119
L249: rol 250,X
L250: rola
L251: rolb
L252: ror 203,X
L253: ror symbol108
L254: ror 5,X
L255: rora
L256: rorb
L257: rti
L258: rts
L259: sba
L260: sbca #172
L261: sbca *Z134
L262: sbca 33,X
L263: sbca symbol43
L264: sbca 170,X
L265: sbcb #26
L266: sbcb *Z85
L267: sbcb 162,X
L268: sbcb symbol190
L269: sbcb 112,X
L270: sec
L271: sei
L272: sev
L273: staa *Z181
L274: staa 115,X
L275: staa symbol59
L276: staa 4,X
L277: stab *Z92
L278: stab 211,X
L279: stab symbol54
L280: stab 148,X
L281: std *Z179
L282: std 175,X
L283: std symbol226
L284: std 240,X
L285: stop
L286: sts *Z228
L287: sts 158,X
L288: sts symbol79
L289: sts 50,X
L290: stx *Z21
L291: stx 73,X
L292: stx symbol253
L293: stx 130,X
L294: sty *Z78
L295: sty 169,X
L296: sty symbol8
L297: sty 112,X
L298: suba #212
L299: suba *Z178
L300: suba 138,X
L301: suba symbol41
L302: suba 84,X
L303: subb #72
L304: subb *Z154
L305: subb 10,X
L306: subb symbol188
L307: subb 213,X
L308: subd #61710
L309: subd *Z24
L310: subd 168,X
L311: subd symbol68
L312: subd 172,X
L313: swi
L314: tab
L315: tap
L316: tba
L317: test
L318: tpa
L319: tst 91,X
L320: tst symbol243
L321: tst 142,X
L322: tsta
L323: tstb
L324: tsx
L325: tsy
L326: txs
L327: tys
L328: wai
L329: xgdx
L330: xgdy
|
stsp/binutils-ia16
| 18,592
|
gas/testsuite/gas/arm/thumb2_bad_reg.s
|
.syntax unified
.text
.align 2
.thumb
.thumb_func
test:
@ ADC (immediate)
adc r13, r0, #1
adc r15, r0, #1
adc r0, r13, #1
adc r0, r15, #1
@ ADC (register)
adc.w r13, r0, r1
adc.w r15, r0, r1
adc.w r0, r13, r1
adc.w r0, r15, r1
adc.w r0, r1, r13
adc.w r0, r1, r15
@ ADD (immediate)
add.w r13, r0, #1
add.w r15, r0, #1
add.w r0, r13, #1 @ ADD (SP plus immediate)
add.w r0, r15, #1 @ Converted implicitly to ADDW
addw r13, r0, #1
addw r15, r0, #1
addw r0, r13, #1 @ ADD (SP plus immediate)
addw r0, r15, #1 @ ADR
@ ADD (register)
add.w r13, r0, r1
add.w r15, r0, r1
adds.w r15, r0, r1
add.w r0, r13, r1 @ ADD (SP plus register)
add.w r0, r15, r1
add.w r0, r1, r13
add.w r0, r1, r15
@ ADD (SP plus immediate)
add.w r0, r13, #1 @ OK
add.w r15, r13, #1
adds.w r15, r13, #1
addw r15, r13, #1
@ ADD (SP plus register)
add.w r15, r13, r0
add.w r0, r13, r13
add.w r0, r13, r15
@ ADR
adr.w r13, test
adr.w r15, test
@ AND (immediate)
and r13, r0, #1
and r15, r0, #1
and r0, r13, #1
and r0, r15, #1
@ AND (register)
and.w r13, r0, r1
and.w r15, r0, r1
and.w r0, r13, r1
and.w r0, r15, r1
and.w r0, r1, r13
and.w r0, r1, r15
@ ASR (immediate)
asr r13, r0, #1
asr r15, r0, #1
asr r0, r13, #1
asr r0, r15, #1
@ ASR (register)
asr.w r13, r0, r1
asr.w r15, r0, r1
asr.w r0, r13, r1
asr.w r0, r15, r1
asr.w r0, r1, r13
asr.w r0, r1, r15
@ BFC
bfc r13, #1, #1
bfc r15, #1, #1
@ BFI
bfi r13, r0, #1, #1
bfi r15, r0, #1, #1
bfi r0, r13, #1, #1
bfi r0, r15, #1, #1
@ BIC (immediate)
bic r13, r0, #1
bic r15, r0, #1
bic r0, r13, #1
bic r0, r15, #1
@ BIC (register)
bic.w r13, r0, r1
bic.w r15, r0, r1
bic.w r0, r13, r1
bic.w r0, r15, r1
bic.w r0, r1, r13
bic.w r0, r1, r15
@ BLX (register)
blx r13 @ OK
blx r15
@ BXJ
bxj r13
bxj r15
@ CLZ
clz r13, r0
clz r15, r0
clz r0, r13
clz r0, r15
@ CMN (immediate)
cmn r13, #1 @ OK
cmn r15, #1
@ CMN (register)
cmn.w r13, r0 @ OK
cmn.w r15, r0
cmn.w r0, r13
cmn.w r0, r15
@ CMP (immediate)
cmp.w r13, #1 @ OK
cmp.w r15, #1
@ CMP (register)
cmp r13, r0 @ OK
cmp r15, r0
cmp r0, r13 @ Deprecated
cmp r0, r15
cmp.n r0, r13 @ Deprecated
cmp.n r0, r15
cmp.w r13, r0 @ OK
cmp.w r15, r0
cmp.w r0, r13
cmp.w r0, r15
@ EOR (immediate)
eor r13, r0, #1
eor r15, r0, #1
eor r0, r13, #1
eor r0, r15, #1
@ EOR (register)
eor.w r13, r0, r1
eor.w r15, r0, r1
eor.w r0, r13, r1
eor.w r0, r15, r1
eor.w r0, r1, r13
eor.w r0, r1, r15
@ LSL (immediate)
lsl r13, r0, #1
lsl r15, r0, #1
lsl r0, r13, #1
lsl r0, r15, #1
@ LSL (register)
lsl.w r13, r0, r1
lsl.w r15, r0, r1
lsl.w r0, r13, r1
lsl.w r0, r15, r1
lsl.w r0, r1, r13
lsl.w r0, r1, r15
@ LSR (immediate)
lsr r13, r0, #1
lsr r15, r0, #1
lsr r0, r13, #1
lsr r0, r15, #1
@ LSR (register)
lsr.w r13, r0, r1
lsr.w r15, r0, r1
lsr.w r0, r13, r1
lsr.w r0, r15, r1
lsr.w r0, r1, r13
lsr.w r0, r1, r15
@ MCR
mcr p0, #1, r13, cr0, cr0
mcr p0, #1, r15, cr0, cr0 @ OK
@ MCRR
mcrr p0, #1, r13, r0, cr0
mcrr p0, #1, r15, r0, cr0
mcrr p0, #1, r0, r13, cr0
mcrr p0, #1, r0, r15, cr0
@ MLA
mla r13, r0, r0, r0
mla r15, r0, r0, r0
mla r0, r13, r0, r0
mla r0, r15, r0, r0
mla r0, r0, r13, r0
mla r0, r0, r15, r0
mla r0, r0, r0, r13
mla r0, r0, r0, r15
@ MLS
mls r13, r0, r0, r0
mls r15, r0, r0, r0
mls r0, r13, r0, r0
mls r0, r15, r0, r0
mls r0, r0, r13, r0
mls r0, r0, r15, r0
mls r0, r0, r0, r13
mls r0, r0, r0, r15
@ MOV (immediate)
mov.w r13, #1
mov.w r15, #1
@ MOV (register)
mov r13, r0 @ OK
mov r15, r0 @ OK
mov.w r0, r13 @ OK
mov.w r0, r15
mov.w r15, r0
mov.w r13, r0 @ OK
movs.w r0, r13
movs.w r0, r15
movs.w r13, r0
movs.w r15, r0
mov.w r13, r13
mov.w r15, r13
mov.w r13, r15
mov.w r15, r15
mov r13, r13 @ Deprecated
mov r15, r13 @ Deprecated
mov r13, r15 @ Deprecated
mov r15, r15 @ Deprecated
movs r13, r13
movs r15, r13
movs r13, r15
movs r15, r15
@ MOVT
movt r13, #1
movt r15, #1
@ MRC
mrc p0, #1, r13, cr0, cr0
mrc p0, #1, r15, cr0, cr0 @ OK
@ MRCC
mrrc p0, #1, r13, r0, cr0
mrrc p0, #1, r15, r0, cr0
mrrc p0, #1, r0, r13, cr0
mrrc p0, #1, r0, r15, cr0
@ MRS
mrs r13, cpsr
mrs r15, cpsr
@ MSR (register)
msr cpsr, r13
msr cpsr, r15
@ MUL
mul r13, r0, r0
mul r15, r0, r0
mul r0, r13, r0
mul r0, r15, r0
mul r0, r0, r13
mul r0, r0, r15
@ MVN (immediate)
mvn r13, #1
mvn r15, #1
@ MVN (register)
mvn.w r13, r0
mvn.w r15, r0
mvn.w r0, r13
mvn.w r0, r15
@ ORN (immediate)
orn r13, r0, #1
orn r15, r0, #1
orn r0, r13, #1
orn r0, r15, #1
@ ORN (register)
orn r13, r0, r0
orn r15, r0, r0
orn r0, r13, r0
orn r0, r15, r0
orn r0, r0, r13
orn r0, r0, r15
@ ORR (immediate)
orr r13, r0, #1
orr r15, r0, #1
orr r0, r13, #1
orr r0, r15, #1
@ ORR (register)
orr r13, r0, r0
orr r15, r0, r0
orr r0, r13, r0
orr r0, r15, r0
orr r0, r0, r13
orr r0, r0, r15
@ PKH
pkhbt r13, r0, r0
pkhbt r15, r0, r0
pkhbt r0, r13, r0
pkhbt r0, r15, r0
pkhbt r0, r0, r13
pkhbt r0, r0, r15
@ PLD (register)
pld [r0, r13]
pld [r0, r15]
pld [r13, r0] @ OK
pld [r15, r0]
@ PLI (register)
pli [r0, r13]
pli [r0, r15]
pli [r13, r0] @ OK
pli [r15, r0]
@ QADD
qadd r13, r0, r0
qadd r15, r0, r0
qadd r0, r13, r0
qadd r0, r15, r0
qadd r0, r0, r13
qadd r0, r0, r15
@ QADD16
qadd16 r13, r0, r0
qadd16 r15, r0, r0
qadd16 r0, r13, r0
qadd16 r0, r15, r0
qadd16 r0, r0, r13
qadd16 r0, r0, r15
@ QADD8
qadd8 r13, r0, r0
qadd8 r15, r0, r0
qadd8 r0, r13, r0
qadd8 r0, r15, r0
qadd8 r0, r0, r13
qadd8 r0, r0, r15
@ QASX
qasx r13, r0, r0
qasx r15, r0, r0
qasx r0, r13, r0
qasx r0, r15, r0
qasx r0, r0, r13
qasx r0, r0, r15
@ QDADD
qdadd r13, r0, r0
qdadd r15, r0, r0
qdadd r0, r13, r0
qdadd r0, r15, r0
qdadd r0, r0, r13
qdadd r0, r0, r15
@ QDSUB
qdsub r13, r0, r0
qdsub r15, r0, r0
qdsub r0, r13, r0
qdsub r0, r15, r0
qdsub r0, r0, r13
qdsub r0, r0, r15
@ QSAX
qsax r13, r0, r0
qsax r15, r0, r0
qsax r0, r13, r0
qsax r0, r15, r0
qsax r0, r0, r13
qsax r0, r0, r15
@ QSUB
qsub r13, r0, r0
qsub r15, r0, r0
qsub r0, r13, r0
qsub r0, r15, r0
qsub r0, r0, r13
qsub r0, r0, r15
@ QSUB16
qsub16 r13, r0, r0
qsub16 r15, r0, r0
qsub16 r0, r13, r0
qsub16 r0, r15, r0
qsub16 r0, r0, r13
qsub16 r0, r0, r15
@ QSUB8
qsub8 r13, r0, r0
qsub8 r15, r0, r0
qsub8 r0, r13, r0
qsub8 r0, r15, r0
qsub8 r0, r0, r13
qsub8 r0, r0, r15
@ RBIT
rbit r13, r0
rbit r15, r0
rbit r0, r13
rbit r0, r15
@ REV
rev.w r13, r0
rev.w r15, r0
rev.w r0, r13
rev.w r0, r15
@ REV16
rev16.w r13, r0
rev16.w r15, r0
rev16.w r0, r13
rev16.w r0, r15
@ REVSH
revsh.w r13, r0
revsh.w r15, r0
revsh.w r0, r13
revsh.w r0, r15
@ RFE
rfedb r15
rfeia r15
@ ROR (immediate)
ror r13, r0, #1
ror r15, r0, #1
ror r0, r13, #1
ror r0, r15, #1
@ ROR (register)
ror.w r13, r0, r1
ror.w r15, r0, r1
ror.w r0, r13, r1
ror.w r0, r15, r1
ror.w r0, r1, r13
ror.w r0, r1, r15
@ RRX
rrx r13, r0
rrx r15, r0
rrx r0, r13
rrx r0, r15
@ RSB (immediate)
rsb.w r13, r0, #1
rsb.w r15, r0, #1
rsb.w r0, r13, #1
rsb.w r0, r15, #1
@ RSB (register)
rsb r13, r0, r1
rsb r15, r0, r1
rsb r0, r13, r1
rsb r0, r15, r1
rsb r0, r1, r13
rsb r0, r1, r15
@ SADD16
sadd16 r13, r0, r0
sadd16 r15, r0, r0
sadd16 r0, r13, r0
sadd16 r0, r15, r0
sadd16 r0, r0, r13
sadd16 r0, r0, r15
@ SADD8
sadd8 r13, r0, r0
sadd8 r15, r0, r0
sadd8 r0, r13, r0
sadd8 r0, r15, r0
sadd8 r0, r0, r13
sadd8 r0, r0, r15
@ SASX
sasx r13, r0, r0
sasx r15, r0, r0
sasx r0, r13, r0
sasx r0, r15, r0
sasx r0, r0, r13
sasx r0, r0, r15
@ SBC (immediate)
sbc r13, r0, #1
sbc r15, r0, #1
sbc r0, r13, #1
sbc r0, r15, #1
@ SBC (register)
sbc r13, r0, r1
sbc r15, r0, r1
sbc r0, r13, r1
sbc r0, r15, r1
sbc r0, r1, r13
sbc r0, r1, r15
@ SBFX (immediate)
sbfx r13, r0, #1, #1
sbfx r15, r0, #1, #1
sbfx r0, r13, #1, #1
sbfx r0, r15, #1, #1
@ SDIV (register)
sdiv r13, r0, r1
sdiv r15, r0, r1
sdiv r0, r13, r1
sdiv r0, r15, r1
sdiv r0, r1, r13
sdiv r0, r1, r15
@ SEL (register)
sel r13, r0, r1
sel r15, r0, r1
sel r0, r13, r1
sel r0, r15, r1
sel r0, r1, r13
sel r0, r1, r15
@ SHADD16
shadd16 r13, r0, r0
shadd16 r15, r0, r0
shadd16 r0, r13, r0
shadd16 r0, r15, r0
shadd16 r0, r0, r13
shadd16 r0, r0, r15
@ SHADD8
shadd8 r13, r0, r0
shadd8 r15, r0, r0
shadd8 r0, r13, r0
shadd8 r0, r15, r0
shadd8 r0, r0, r13
shadd8 r0, r0, r15
@ SHASX
shasx r13, r0, r0
shasx r15, r0, r0
shasx r0, r13, r0
shasx r0, r15, r0
shasx r0, r0, r13
shasx r0, r0, r15
@ SHSAX
shsax r13, r0, r0
shsax r15, r0, r0
shsax r0, r13, r0
shsax r0, r15, r0
shsax r0, r0, r13
shsax r0, r0, r15
@ SHSUB16
shsub16 r13, r0, r0
shsub16 r15, r0, r0
shsub16 r0, r13, r0
shsub16 r0, r15, r0
shsub16 r0, r0, r13
shsub16 r0, r0, r15
@ SHSUB8
shsub8 r13, r0, r0
shsub8 r15, r0, r0
shsub8 r0, r13, r0
shsub8 r0, r15, r0
shsub8 r0, r0, r13
shsub8 r0, r0, r15
@ SMLABB
smlabb r13, r0, r0, r0
smlabb r15, r0, r0, r0
smlabb r0, r13, r0, r0
smlabb r0, r15, r0, r0
smlabb r0, r0, r13, r0
smlabb r0, r0, r15, r0
smlabb r0, r0, r0, r13
smlabb r0, r0, r0, r15
@ SMLAD
smlad r13, r0, r0, r0
smlad r15, r0, r0, r0
smlad r0, r13, r0, r0
smlad r0, r15, r0, r0
smlad r0, r0, r13, r0
smlad r0, r0, r15, r0
smlad r0, r0, r0, r13
smlad r0, r0, r0, r15
@ SMLAL
smlal r13, r0, r0, r0
smlal r15, r0, r0, r0
smlal r0, r13, r0, r0
smlal r0, r15, r0, r0
smlal r0, r0, r13, r0
smlal r0, r0, r15, r0
smlal r0, r0, r0, r13
smlal r0, r0, r0, r15
@ SMLALBB
smlalbb r13, r0, r0, r0
smlalbb r15, r0, r0, r0
smlalbb r0, r13, r0, r0
smlalbb r0, r15, r0, r0
smlalbb r0, r0, r13, r0
smlalbb r0, r0, r15, r0
smlalbb r0, r0, r0, r13
smlalbb r0, r0, r0, r15
@ SMLALD
smlald r13, r0, r0, r0
smlald r15, r0, r0, r0
smlald r0, r13, r0, r0
smlald r0, r15, r0, r0
smlald r0, r0, r13, r0
smlald r0, r0, r15, r0
smlald r0, r0, r0, r13
smlald r0, r0, r0, r15
@ SMLAWB
smlawb r13, r0, r0, r0
smlawb r15, r0, r0, r0
smlawb r0, r13, r0, r0
smlawb r0, r15, r0, r0
smlawb r0, r0, r13, r0
smlawb r0, r0, r15, r0
smlawb r0, r0, r0, r13
smlawb r0, r0, r0, r15
@ SMLSD
smlsd r13, r0, r0, r0
smlsd r15, r0, r0, r0
smlsd r0, r13, r0, r0
smlsd r0, r15, r0, r0
smlsd r0, r0, r13, r0
smlsd r0, r0, r15, r0
smlsd r0, r0, r0, r13
smlsd r0, r0, r0, r15
@ SMLSLD
smlsld r13, r0, r0, r0
smlsld r15, r0, r0, r0
smlsld r0, r13, r0, r0
smlsld r0, r15, r0, r0
smlsld r0, r0, r13, r0
smlsld r0, r0, r15, r0
smlsld r0, r0, r0, r13
smlsld r0, r0, r0, r15
@ SMMLA
smmla r13, r0, r0, r0
smmla r15, r0, r0, r0
smmla r0, r13, r0, r0
smmla r0, r15, r0, r0
smmla r0, r0, r13, r0
smmla r0, r0, r15, r0
smmla r0, r0, r0, r13
smmla r0, r0, r0, r15
@ SMMLS
smmls r13, r0, r0, r0
smmls r15, r0, r0, r0
smmls r0, r13, r0, r0
smmls r0, r15, r0, r0
smmls r0, r0, r13, r0
smmls r0, r0, r15, r0
smmls r0, r0, r0, r13
smmls r0, r0, r0, r15
@ SMMUL
smmul r13, r0, r0
smmul r15, r0, r0
smmul r0, r13, r0
smmul r0, r15, r0
smmul r0, r0, r13
smmul r0, r0, r15
@ SMUAD
smuad r13, r0, r0
smuad r15, r0, r0
smuad r0, r13, r0
smuad r0, r15, r0
smuad r0, r0, r13
smuad r0, r0, r15
@ SMULBB
smulbb r13, r0, r0
smulbb r15, r0, r0
smulbb r0, r13, r0
smulbb r0, r15, r0
smulbb r0, r0, r13
smulbb r0, r0, r15
@ SMULL
smull r13, r0, r0, r0
smull r15, r0, r0, r0
smull r0, r13, r0, r0
smull r0, r15, r0, r0
smull r0, r0, r13, r0
smull r0, r0, r15, r0
smull r0, r0, r0, r13
smull r0, r0, r0, r15
@ SMULWB
smulwb r13, r0, r0
smulwb r15, r0, r0
smulwb r0, r13, r0
smulwb r0, r15, r0
smulwb r0, r0, r13
smulwb r0, r0, r15
@ SMUSD
smusd r13, r0, r0
smusd r15, r0, r0
smusd r0, r13, r0
smusd r0, r15, r0
smusd r0, r0, r13
smusd r0, r0, r15
@ SSAT
ssat r13, #1, r0
ssat r15, #1, r0
ssat r0, #1, r13
ssat r0, #1, r15
ssat r1, #1, r3,asr #32
@ SSAT16
ssat16 r13, #1, r0
ssat16 r15, #1, r0
ssat16 r0, #1, r13
ssat16 r0, #1, r15
@ SSAX
ssax r13, r0, r1
ssax r15, r0, r1
ssax r0, r13, r1
ssax r0, r15, r1
ssax r0, r1, r13
ssax r0, r1, r15
@ SSUB16
ssub16 r13, r0, r1
ssub16 r15, r0, r1
ssub16 r0, r13, r1
ssub16 r0, r15, r1
ssub16 r0, r1, r13
ssub16 r0, r1, r15
@ SSUB8
ssub8 r13, r0, r1
ssub8 r15, r0, r1
ssub8 r0, r13, r1
ssub8 r0, r15, r1
ssub8 r0, r1, r13
ssub8 r0, r1, r15
@ SUB (immediate)
sub.w r13, r0, #1
sub.w r15, r0, #1
sub.w r0, r13, #1 @ SUB (SP minus immediate)
sub.w r0, r15, #1 @ ADR
subw r13, r0, #1
subw r15, r0, #1
subw r0, r13, #1 @ SUB (SP minus immediate)
subw r0, r15, #1 @ ADR
@ SUB (register)
sub.w r13, r0, r1
sub.w r15, r0, r1
sub.w r0, r13, r1 @ SUB (SP minus register)
sub.w r0, r15, r1
sub.w r0, r1, r13
sub.w r0, r1, r15
@ SUB (SP minus immediate)
sub.w r0, r13, #1 @ OK
sub.w r15, r13, #1
subs.w r15, r13, #1
subw r15, r13, #1
@ SUB (SP minus register)
sub.w r13, r13, r0 @ OK
sub.w r15, r13, r0
sub.w r0, r13, r13
sub.w r0, r13, r15
@ SXTAB
sxtab r13, r0, r1
sxtab r15, r0, r1
sxtab r0, r13, r1
sxtab r0, r15, r1
sxtab r0, r1, r13
sxtab r0, r1, r15
@ SXTAB16
sxtab16 r13, r0, r1
sxtab16 r15, r0, r1
sxtab16 r0, r13, r1
sxtab16 r0, r15, r1
sxtab16 r0, r1, r13
sxtab16 r0, r1, r15
@ SXTAH
sxtah r13, r0, r1
sxtah r15, r0, r1
sxtah r0, r13, r1
sxtah r0, r15, r1
sxtah r0, r1, r13
sxtah r0, r1, r15
@ SXTB
sxtb r13, r0
sxtb r15, r0
sxtb r0, r13
sxtb r0, r15
@ SXTB16
sxtb16 r13, r0
sxtb16 r15, r0
sxtb16 r0, r13
sxtb16 r0, r15
@ SXTH
sxth r13, r0
sxth r15, r0
sxth r0, r13
sxth r0, r15
@ TBB
tbb [r13, r0]
tbb [r15, r0] @ OK
tbb [r0, r13]
tbb [r0, r15]
@ TBH
tbh [r13, r0]
tbh [r15, r0] @ OK
tbh [r0, r13]
tbh [r0, r15]
@ TEQ (immediate)
teq r13, #1
teq r15, #1
@ TEQ (register)
teq r13, r0
teq r15, r0
teq r0, r13
teq r0, r15
@ TST (immediate)
tst r13, #1
tst r15, #1
@ TST (register)
tst.w r13, r0
tst.w r15, r0
tst.w r0, r13
tst.w r0, r15
@ UADD16
uadd16 r13, r0, r0
uadd16 r15, r0, r0
uadd16 r0, r13, r0
uadd16 r0, r15, r0
uadd16 r0, r0, r13
uadd16 r0, r0, r15
@ UADD8
uadd8 r13, r0, r0
uadd8 r15, r0, r0
uadd8 r0, r13, r0
uadd8 r0, r15, r0
uadd8 r0, r0, r13
uadd8 r0, r0, r15
@ UASX
uasx r13, r0, r0
uasx r15, r0, r0
uasx r0, r13, r0
uasx r0, r15, r0
uasx r0, r0, r13
uasx r0, r0, r15
@ UBFX (immediate)
ubfx r13, r0, #1, #1
ubfx r15, r0, #1, #1
ubfx r0, r13, #1, #1
ubfx r0, r15, #1, #1
@ UDIV (register)
udiv r13, r0, r1
udiv r15, r0, r1
udiv r0, r13, r1
udiv r0, r15, r1
udiv r0, r1, r13
udiv r0, r1, r15
@ UHADD16
uhadd16 r13, r0, r0
uhadd16 r15, r0, r0
uhadd16 r0, r13, r0
uhadd16 r0, r15, r0
uhadd16 r0, r0, r13
uhadd16 r0, r0, r15
@ UHADD8
uhadd8 r13, r0, r0
uhadd8 r15, r0, r0
uhadd8 r0, r13, r0
uhadd8 r0, r15, r0
uhadd8 r0, r0, r13
uhadd8 r0, r0, r15
@ UHASX
uhasx r13, r0, r0
uhasx r15, r0, r0
uhasx r0, r13, r0
uhasx r0, r15, r0
uhasx r0, r0, r13
uhasx r0, r0, r15
@ UHSAX
uhsax r13, r0, r0
uhsax r15, r0, r0
uhsax r0, r13, r0
uhsax r0, r15, r0
uhsax r0, r0, r13
uhsax r0, r0, r15
@ UHSUB16
uhsub16 r13, r0, r0
uhsub16 r15, r0, r0
uhsub16 r0, r13, r0
uhsub16 r0, r15, r0
uhsub16 r0, r0, r13
uhsub16 r0, r0, r15
@ UHSUB8
uhsub8 r13, r0, r0
uhsub8 r15, r0, r0
uhsub8 r0, r13, r0
uhsub8 r0, r15, r0
uhsub8 r0, r0, r13
uhsub8 r0, r0, r15
@ UMAAL
umaal r13, r0, r0, r0
umaal r15, r0, r0, r0
umaal r0, r13, r0, r0
umaal r0, r15, r0, r0
umaal r0, r0, r13, r0
umaal r0, r0, r15, r0
umaal r0, r0, r0, r13
umaal r0, r0, r0, r15
@ UMLAL
umlal r13, r0, r0, r0
umlal r15, r0, r0, r0
umlal r0, r13, r0, r0
umlal r0, r15, r0, r0
umlal r0, r0, r13, r0
umlal r0, r0, r15, r0
umlal r0, r0, r0, r13
umlal r0, r0, r0, r15
@ UMULL
umull r13, r0, r0, r0
umull r15, r0, r0, r0
umull r0, r13, r0, r0
umull r0, r15, r0, r0
umull r0, r0, r13, r0
umull r0, r0, r15, r0
umull r0, r0, r0, r13
umull r0, r0, r0, r15
@ UQADD16
uqadd16 r13, r0, r0
uqadd16 r15, r0, r0
uqadd16 r0, r13, r0
uqadd16 r0, r15, r0
uqadd16 r0, r0, r13
uqadd16 r0, r0, r15
@ UQADD8
uqadd8 r13, r0, r0
uqadd8 r15, r0, r0
uqadd8 r0, r13, r0
uqadd8 r0, r15, r0
uqadd8 r0, r0, r13
uqadd8 r0, r0, r15
@ UQASX
uqasx r13, r0, r0
uqasx r15, r0, r0
uqasx r0, r13, r0
uqasx r0, r15, r0
uqasx r0, r0, r13
uqasx r0, r0, r15
@ UQSAX
uqsax r13, r0, r0
uqsax r15, r0, r0
uqsax r0, r13, r0
uqsax r0, r15, r0
uqsax r0, r0, r13
uqsax r0, r0, r15
@ UQSUB16
uqsub16 r13, r0, r0
uqsub16 r15, r0, r0
uqsub16 r0, r13, r0
uqsub16 r0, r15, r0
uqsub16 r0, r0, r13
uqsub16 r0, r0, r15
@ UQSUB8
uqsub8 r13, r0, r0
uqsub8 r15, r0, r0
uqsub8 r0, r13, r0
uqsub8 r0, r15, r0
uqsub8 r0, r0, r13
uqsub8 r0, r0, r15
@ USAD8
usad8 r13, r0, r0
usad8 r15, r0, r0
usad8 r0, r13, r0
usad8 r0, r15, r0
usad8 r0, r0, r13
usad8 r0, r0, r15
@ USADA8
usada8 r13, r0, r0, r0
usada8 r15, r0, r0, r0
usada8 r0, r13, r0, r0
usada8 r0, r15, r0, r0
usada8 r0, r0, r13, r0
usada8 r0, r0, r15, r0
usada8 r0, r0, r0, r13
usada8 r0, r0, r0, r15
@ USAT
usat r13, #1, r0
usat r15, #1, r0
usat r0, #1, r13
usat r0, #1, r15
usat r1, #1, r3,asr #32
@ USAT16
usat16 r13, #1, r0
usat16 r15, #1, r0
usat16 r0, #1, r13
usat16 r0, #1, r15
@ USAX
usax r13, r0, r1
usax r15, r0, r1
usax r0, r13, r1
usax r0, r15, r1
usax r0, r1, r13
usax r0, r1, r15
@ USUB16
usub16 r13, r0, r1
usub16 r15, r0, r1
usub16 r0, r13, r1
usub16 r0, r15, r1
usub16 r0, r1, r13
usub16 r0, r1, r15
@ USUB8
usub8 r13, r0, r1
usub8 r15, r0, r1
usub8 r0, r13, r1
usub8 r0, r15, r1
usub8 r0, r1, r13
usub8 r0, r1, r15
@ UXTAB
uxtab r13, r0, r1
uxtab r15, r0, r1
uxtab r0, r13, r1
uxtab r0, r15, r1
uxtab r0, r1, r13
uxtab r0, r1, r15
@ UXTAB16
uxtab16 r13, r0, r1
uxtab16 r15, r0, r1
uxtab16 r0, r13, r1
uxtab16 r0, r15, r1
uxtab16 r0, r1, r13
uxtab16 r0, r1, r15
@ UXTAH
uxtah r13, r0, r1
uxtah r15, r0, r1
uxtah r0, r13, r1
uxtah r0, r15, r1
uxtah r0, r1, r13
uxtah r0, r1, r15
@ UXTB
uxtb r13, r0
uxtb r15, r0
uxtb r0, r13
uxtb r0, r15
@ UXTB16
uxtb16 r13, r0
uxtb16 r15, r0
uxtb16 r0, r13
uxtb16 r0, r15
@ UXTH
uxth r13, r0
uxth r15, r0
uxth r0, r13
uxth r0, r15
|
stsp/binutils-ia16
| 5,939
|
gas/testsuite/gas/arm/cde-scalar.s
|
.syntax unified
# Extra tests everywhere:
# Ensure that setting the register to something in r[1-12] works.
# cx1{a} Has arguments in the following form
# 111a111000iiiiiidddd0pppi0iiiiii
#
# Variants to test:
# - Base (everything we can set to zero)
# - immediates that set each set of `i` to ones in turn.
# (imm = op1:op2:op3 , which is each group of `i` from left to write
# concatenated)
# - Each register 9 (0b1001), APSR_nzcv, or all zeros
# - Coprocessor num set to 7
# - Everything again with the `a` version (to double check parsing).
# - Accumulator versions without optional argument (to check parsing)
#
# IT blocks:
# Non-accumulator versions are UNPREDICTABLE in IT blocks.
# Accumulator versions are allowed in IT blocks.
# cx1{a} extra tests.
# Arm conditional
cx1 p0, r0, #0
cx1 p0, r0, #8064
cx1 p0, r0, #64
cx1 p0, r0, #63
cx1 p7, r0, #0
cx1 p0, APSR_nzcv, #0
cx1 p0, r9, #0
cx1a p0, r0, #0
cx1a p0, r0, #8064
cx1a p0, r0, #64
cx1a p0, r0, #63
cx1a p7, r0, #0
cx1a p0, APSR_nzcv, #0
cx1a p0, r9, #0
it ne
cx1ane p0, r0, #0
# cx1d{a} encoding of following form:
# 111a111000iiiiiidddd0pppi1iiiiii
#
# Variants to test:
# - Base (everything we can set to zero)
# - immediates that set each set of `i` to ones in turn.
# (imm = op1:op2:op3 , which is each group of `i` from left to write
# concatenated)
# - Destination register 10 (0b1010) or all zeros
# - Coprocessor num set to 7
# - Everything again with the `a` version (to double check parsing).
# - Accumulator versions without optional argument (to check parsing)
cx1d p0, r0, r1, #0
cx1d p0, r0, r1, #8064
cx1d p0, r0, r1, #64
cx1d p0, r0, r1, #63
cx1d p7, r0, r1, #0
cx1d p0, r10, r11, #0
cx1da p0, r0, r1, #0
cx1da p0, r0, r1, #8064
cx1da p0, r0, r1, #64
cx1da p0, r0, r1, #63
cx1da p7, r0, r1, #0
cx1da p0, r10, r11, #0
it ne
cx1dane p0, r0, r1, #0
# cx2{a} Has arguments of the following form:
# 111a111001iinnnndddd0pppi0iiiiii
#
# Variants to test:
# - Base (everything we can set to zero)
# - immediates that set each set of `i` to ones in turn.
# (imm = op1:op2:op3 , which is each group of `i` from left to write
# concatenated)
# - Each register 9 (0b1001), APSR_nzcv, or all zeros
# - Coprocessor num set to 7
# - Everything again with the `a` version (to double check parsing).
# - Accumulator versions without optional argument (to check parsing)
cx2 p0, r0, r0, #0
cx2 p0, r0, r0, #384
cx2 p0, r0, r0, #64
cx2 p0, r0, r0, #63
cx2 p7, r0, r0, #0
cx2 p0, APSR_nzcv, r0, #0
cx2 p0, r9, r0, #0
cx2 p0, r0, APSR_nzcv, #0
cx2 p0, r0, r9, #0
cx2a p0, r0, r0, #0
cx2a p0, r0, r0, #384
cx2a p0, r0, r0, #64
cx2a p0, r0, r0, #63
cx2a p7, r0, r0, #0
cx2a p0, APSR_nzcv, r0, #0
cx2a p0, r9, r0, #0
cx2a p0, r0, APSR_nzcv, #0
cx2a p0, r0, r9, #0
it ne
cx2ane p0, r0, r0, #0
# cx2d{a} encoding has following form:
# 111a111001iinnnndddd0pppi1iiiiii
#
# - Base (everything we can set to zero)
# - immediates that set each set of `i` to ones in turn.
# (imm = op1:op2:op3 , which is each group of `i` from left to write
# concatenated)
# - Destination register 10 (0b1010) or all zeros
# - Coprocessor num set to 7
# - Everything again with the `a` version (to double check parsing).
# - Accumulator versions without optional argument (to check parsing)
cx2d p0, r0, r1, r0, #0
cx2d p0, r0, r1, r0, #384
cx2d p0, r0, r1, r0, #64
cx2d p0, r0, r1, r0, #63
cx2d p7, r0, r1, r0, #0
cx2d p0, r10, r11, r0, #0
cx2d p0, r0, r1, APSR_nzcv, #0
cx2d p0, r0, r1, r9, #0
cx2da p0, r0, r1, r0, #0
cx2da p0, r0, r1, r0, #384
cx2da p0, r0, r1, r0, #64
cx2da p0, r0, r1, r0, #63
cx2da p7, r0, r1, r0, #0
cx2da p0, r10, r11, r0, #0
cx2da p0, r0, r1, APSR_nzcv, #0
cx2da p0, r0, r1, r9, #0
# cx3{a} Has arguments in the following form:
# 111a11101iiinnnnmmmm0pppi0iidddd
#
# Variants to test:
# - immediates that set each set of `i` to ones in turn.
# (imm = op1:op2:op3 , which is each group of `i` from left to write
# - Base (everything we can set to zero)
# - immediates that set each set of `i` to ones in turn.
# (imm = op1:op2:op3 , which is each group of `i` from left to write
# concatenated)
# - Each register 9 (0b1001), APSR_nzcv, or all zeros
# - Coprocessor num set to 7
# - Everything again with the `a` version (to double check parsing).
# - Accumulator versions without optional argument (to check parsing)
cx3 p0, r0, r0, r0, #0
cx3 p0, r0, r0, r0, #56
cx3 p0, r0, r0, r0, #4
cx3 p0, r0, r0, r0, #3
cx3 p7, r0, r0, r0, #0
cx3 p0, APSR_nzcv, r0, r0, #0
cx3 p0, r9, r0, r0, #0
cx3 p0, r0, APSR_nzcv, r0, #0
cx3 p0, r0, r9, r0, #0
cx3 p0, r0, r0, APSR_nzcv, #0
cx3 p0, r0, r0, r9, #0
cx3a p0, r0, r0, r0, #0
cx3a p0, r0, r0, r0, #56
cx3a p0, r0, r0, r0, #4
cx3a p0, r0, r0, r0, #3
cx3a p7, r0, r0, r0, #0
cx3a p0, APSR_nzcv, r0, r0, #0
cx3a p0, r9, r0, r0, #0
cx3a p0, r0, APSR_nzcv, r0, #0
cx3a p0, r0, r9, r0, #0
cx3a p0, r0, r0, APSR_nzcv, #0
cx3a p0, r0, r0, r9, #0
it ne
cx3ane p0, r0, r0, r0, #0
# cx3d{a} encoding has following form:
# 111a11101iiinnnnmmmm0pppi1iidddd
#
# Variants to test:
# - Toggle 'a'
# - immediates that set each set of `i` to ones in turn.
# (imm = op1:op2:op3 , which is each group of `i` from left to write
# concatenated)
# - Destination register 10 (0b1010) or all zeros
# - Source register 9 (0b1001), APSR_nzcv, or all zeros
# No longer allows APSR_nzcv in destination register
cx3d p0, r0, r1, r0, r0, #0
cx3d p0, r0, r1, r0, r0, #56
cx3d p0, r0, r1, r0, r0, #4
cx3d p0, r0, r1, r0, r0, #3
cx3d p7, r0, r1, r0, r0, #0
cx3d p0, r10, r11, r0, r0, #0
cx3d p0, r0, r1, APSR_nzcv, r0, #0
cx3d p0, r0, r1, r9, r0, #0
cx3d p0, r0, r1, r0, APSR_nzcv, #0
cx3d p0, r0, r1, r0, r9, #0
cx3da p0, r0, r1, r0, r0, #0
cx3da p0, r0, r1, r0, r0, #56
cx3da p0, r0, r1, r0, r0, #4
cx3da p0, r0, r1, r0, r0, #3
cx3da p7, r0, r1, r0, r0, #0
cx3da p0, r10, r11, r0, r0, #0
cx3da p0, r0, r1, APSR_nzcv, r0, #0
cx3da p0, r0, r1, r9, r0, #0
cx3da p0, r0, r1, r0, APSR_nzcv, #0
cx3da p0, r0, r1, r0, r9, #0
|
stsp/binutils-ia16
| 1,314
|
gas/testsuite/gas/arm/group-reloc-ldrs-encoding-bad.s
|
@ Tests that are meant to fail during encoding of LDRS group relocations.
.text
.macro ldrtest2 load sym offset
\load r0, [r0, #:pc_g1:(\sym \offset)]
\load r0, [r0, #:pc_g2:(\sym \offset)]
\load r0, [r0, #:sb_g0:(\sym \offset)]
\load r0, [r0, #:sb_g1:(\sym \offset)]
\load r0, [r0, #:sb_g2:(\sym \offset)]
.endm
.macro ldrtest load store sym offset
ldrtest2 \load \sym \offset
\store r0, [r0, #:pc_g1:(\sym \offset)]
\store r0, [r0, #:pc_g2:(\sym \offset)]
\store r0, [r0, #:sb_g0:(\sym \offset)]
\store r0, [r0, #:sb_g1:(\sym \offset)]
\store r0, [r0, #:sb_g2:(\sym \offset)]
.endm
@ LDRD/STRD/LDRH/STRH/LDRSH/LDRSB only have 8 bits available for the
@ magnitude of the addend. So these should all (just) fail.
ldrtest ldrd strd f "+ 256"
ldrtest ldrh strh f "+ 256"
ldrtest2 ldrsh f "+ 256"
ldrtest2 ldrsb f "+ 256"
ldrtest ldrd strd f "- 256"
ldrtest ldrh strh f "- 256"
ldrtest2 ldrsh f "- 256"
ldrtest2 ldrsb f "- 256"
@ The same as the above, but for a local symbol.
ldrtest ldrd strd localsym "+ 256"
ldrtest ldrh strh localsym "+ 256"
ldrtest2 ldrsh localsym "+ 256"
ldrtest2 ldrsb localsym "+ 256"
ldrtest ldrd strd localsym "- 256"
ldrtest ldrh strh localsym "- 256"
ldrtest2 ldrsh localsym "- 256"
ldrtest2 ldrsb localsym "- 256"
localsym:
mov r0, #0
|
stsp/binutils-ia16
| 3,072
|
gas/testsuite/gas/arm/mve-vmov-2.s
|
.syntax unified
.thumb
.irp op0, s0, s1, s2, s4, s8, s16, s30, s31
.irp op1, r0, r1, r2, r4, r7, r8, r10, r12, r14
vmov \op0, \op1
vmov \op1, \op0
.endr
.endr
.macro vmov_rr, op0, op1
.irp op2, d0, d1, d2, d4, d8, d15
vmov \op0, \op1, \op2
vmov \op2, \op0, \op1
.endr
vmov \op0, \op1, s0, s1
vmov \op0, \op1, s1, s2
vmov \op0, \op1, s2, s3
vmov \op0, \op1, s4, s5
vmov \op0, \op1, s8, s9
vmov \op0, \op1, s16, s17
vmov \op0, \op1, s30, s31
vmov s0, s1, \op0, \op1
vmov s1, s2, \op0, \op1
vmov s2, s3, \op0, \op1
vmov s4, s5, \op0, \op1
vmov s8, s9, \op0, \op1
vmov s16, s17, \op0, \op1
vmov s30, s31, \op0, \op1
.endm
.irp op0, r1, r2, r4, r7, r8, r10, r12, r14
vmov_rr r0, \op0
.endr
.irp op0, r0, r2, r4, r7, r8, r10, r12, r14
vmov_rr r1, \op0
.endr
.irp op0, r0, r1, r4, r7, r8, r10, r12, r14
vmov_rr r2, \op0
.endr
.irp op0, r0, r1, r2, r7, r8, r10, r12, r14
vmov_rr r4, \op0
.endr
.irp op0, r0, r1, r2, r4, r8, r10, r12, r14
vmov_rr r7, \op0
.endr
.irp op0, r0, r1, r2, r4, r7, r10, r12, r14
vmov_rr r8, \op0
.endr
.irp op0, r0, r1, r2, r4, r7, r8, r12, r14
vmov_rr r10, \op0
.endr
.irp op0, r0, r1, r2, r4, r7, r8, r10, r14
vmov_rr r12, \op0
.endr
.irp op0, r0, r1, r2, r4, r7, r8, r10, r12
vmov_rr r14, \op0
.endr
.macro vmov_qidx_r size, idx
.irp op1, q0, q1, q2, q4, q7
.irp op2, r0, r1, r2, r4, r7, r8, r10, r12, r14
vmov\size \op1[\idx], \op2
.endr
.endr
.endm
.irp idx, 0, 1, 2, 4, 8, 15, 13, 6
vmov_qidx_r .8, \idx
.endr
.irp idx, 0, 1, 2, 4, 7
vmov_qidx_r .16, \idx
.endr
.irp idx, 0, 1, 2, 3
vmov_qidx_r .32, \idx
.endr
.macro vmov_r_qidx size, idx
.irp op1, r0, r1, r2, r4, r7, r8, r10, r12, r14
.irp op2, q0, q1, q2, q4, q7
vmov\size \op1, \op2[\idx]
.endr
.endr
.endm
.irp data, .u8, .s8
.irp idx, 0, 1, 2, 4, 8, 15, 13, 6
vmov_r_qidx \data, \idx
.endr
.endr
.irp data, .u16, .s16
.irp idx, 0, 1, 2, 4, 7
vmov_r_qidx \data, \idx
.endr
.endr
.irp idx, 0, 1, 2, 3
vmov_r_qidx .32, \idx
.endr
vmov.i32 q0, #0
vmov.i32 q0, #255 @ 0x000000FF 000000FF
vmov.i32 q0, #65280 @ 0x0000FF00 0000FF00
vmov.i32 q0, #4278190080 @ 0xFF000000 FF000000
vmov.i32 q0, #16711680 @ 0x00FF0000 00FF0000
vmov.i16 q0, #0
vmov.i16 q0, #255 @ 0x00FF 00FF 00FF 00FF
vmov.i16 q0, #65280 @ 0xFF00 FF00 FF00 FF00
vmov.i8 q0, #0
vmov.i8 q0, #255 @ 0xFF FF FF FF FF FF FF FF
vmov.i64 q0, #18374686479671623680 @ 0xFF00000000000000
vmov.i64 q0, #71776119061217280 @ 0x00FF000000000000
vmov.i64 q0, #280375465082880 @ 0x0000FF0000000000
vmov.i64 q0, #1095216660480 @ 0x000000FF00000000
vmov.i64 q0, #4278190080 @ 0x00000000FF000000
vmov.i64 q0, #16711680 @ 0x00000000000FF0000
vmov.i64 q0, #65280 @ 0x0000000000000FF00
vmov.i64 q0, #255 @ 0x000000000000000FF
.irp op0, s0, s1, s2, s4, s8, s16, s30, s31
.irp op1, r0, r1, r2, r4, r7, r8, r10, r12, r14
vmov.f16 \op0, \op1
vmov.f16 \op1, \op0
.endr
.endr
vmov.f32 q0, #0.0
vmov.f32 q0, #-31.0 @ 0xC1F80000 C1F80000
vmov.f32 q0, #-31.0 @ 0xC1F80000 C1F80000
vmov.f32 q0, #-1.9375 @ 0xBFF80000 BFF80000
vmov.f32 q0, #1.0 @ 0x3F800000 3F800000
vmov.f16 s0, #2.0
vmov.f32 s0, #2.5
|
stsp/binutils-ia16
| 7,483
|
gas/testsuite/gas/arm/neon-const.s
|
@ test floating-point constant parsing.
.arm
.text
.syntax unified
vmov.f32 q0, 0.0
vmov.f32 q0, 2.0
vmov.f32 q0, 4.0
vmov.f32 q0, 8.0
vmov.f32 q0, 16.0
vmov.f32 q0, 0.125
vmov.f32 q0, 0.25
vmov.f32 q0, 0.5
vmov.f32 q0, 1.0
vmov.f32 q0, 2.125
vmov.f32 q0, 4.25
vmov.f32 q0, 8.5
vmov.f32 q0, 17.0
vmov.f32 q0, 0.1328125
vmov.f32 q0, 0.265625
vmov.f32 q0, 0.53125
vmov.f32 q0, 1.0625
vmov.f32 q0, 2.25
vmov.f32 q0, 4.5
vmov.f32 q0, 9.0
vmov.f32 q0, 18.0
vmov.f32 q0, 0.140625
vmov.f32 q0, 0.28125
vmov.f32 q0, 0.5625
vmov.f32 q0, 1.125
vmov.f32 q0, 2.375
vmov.f32 q0, 4.75
vmov.f32 q0, 9.5
vmov.f32 q0, 19.0
vmov.f32 q0, 0.1484375
vmov.f32 q0, 0.296875
vmov.f32 q0, 0.59375
vmov.f32 q0, 1.1875
vmov.f32 q0, 2.5
vmov.f32 q0, 5.0
vmov.f32 q0, 10.0
vmov.f32 q0, 20.0
vmov.f32 q0, 0.15625
vmov.f32 q0, 0.3125
vmov.f32 q0, 0.625
vmov.f32 q0, 1.25
vmov.f32 q0, 2.625
vmov.f32 q0, 5.25
vmov.f32 q0, 10.5
vmov.f32 q0, 21.0
vmov.f32 q0, 0.1640625
vmov.f32 q0, 0.328125
vmov.f32 q0, 0.65625
vmov.f32 q0, 1.3125
vmov.f32 q0, 2.75
vmov.f32 q0, 5.5
vmov.f32 q0, 11.0
vmov.f32 q0, 22.0
vmov.f32 q0, 0.171875
vmov.f32 q0, 0.34375
vmov.f32 q0, 0.6875
vmov.f32 q0, 1.375
vmov.f32 q0, 2.875
vmov.f32 q0, 5.75
vmov.f32 q0, 11.5
vmov.f32 q0, 23.0
vmov.f32 q0, 0.1796875
vmov.f32 q0, 0.359375
vmov.f32 q0, 0.71875
vmov.f32 q0, 1.4375
vmov.f32 q0, 3.0
vmov.f32 q0, 6.0
vmov.f32 q0, 12.0
vmov.f32 q0, 24.0
vmov.f32 q0, 0.1875
vmov.f32 q0, 0.375
vmov.f32 q0, 0.75
vmov.f32 q0, 1.5
vmov.f32 q0, 3.125
vmov.f32 q0, 6.25
vmov.f32 q0, 12.5
vmov.f32 q0, 25.0
vmov.f32 q0, 0.1953125
vmov.f32 q0, 0.390625
vmov.f32 q0, 0.78125
vmov.f32 q0, 1.5625
vmov.f32 q0, 3.25
vmov.f32 q0, 6.5
vmov.f32 q0, 13.0
vmov.f32 q0, 26.0
vmov.f32 q0, 0.203125
vmov.f32 q0, 0.40625
vmov.f32 q0, 0.8125
vmov.f32 q0, 1.625
vmov.f32 q0, 3.375
vmov.f32 q0, 6.75
vmov.f32 q0, 13.5
vmov.f32 q0, 27.0
vmov.f32 q0, 0.2109375
vmov.f32 q0, 0.421875
vmov.f32 q0, 0.84375
vmov.f32 q0, 1.6875
vmov.f32 q0, 3.5
vmov.f32 q0, 7.0
vmov.f32 q0, 14.0
vmov.f32 q0, 28.0
vmov.f32 q0, 0.21875
vmov.f32 q0, 0.4375
vmov.f32 q0, 0.875
vmov.f32 q0, 1.75
vmov.f32 q0, 3.625
vmov.f32 q0, 7.25
vmov.f32 q0, 14.5
vmov.f32 q0, 29.0
vmov.f32 q0, 0.2265625
vmov.f32 q0, 0.453125
vmov.f32 q0, 0.90625
vmov.f32 q0, 1.8125
vmov.f32 q0, 3.75
vmov.f32 q0, 7.5
vmov.f32 q0, 15.0
vmov.f32 q0, 30.0
vmov.f32 q0, 0.234375
vmov.f32 q0, 0.46875
vmov.f32 q0, 0.9375
vmov.f32 q0, 1.875
vmov.f32 q0, 3.875
vmov.f32 q0, 7.75
vmov.f32 q0, 15.5
vmov.f32 q0, 31.0
vmov.f32 q0, 0.2421875
vmov.f32 q0, 0.484375
vmov.f32 q0, 0.96875
vmov.f32 q0, 1.9375
vmov.f32 q0, -0.0
vmov.f32 q0, -2.0
vmov.f32 q0, -4.0
vmov.f32 q0, -8.0
vmov.f32 q0, -16.0
vmov.f32 q0, -0.125
vmov.f32 q0, -0.25
vmov.f32 q0, -0.5
vmov.f32 q0, -1.0
vmov.f32 q0, -2.125
vmov.f32 q0, -4.25
vmov.f32 q0, -8.5
vmov.f32 q0, -17.0
vmov.f32 q0, -0.1328125
vmov.f32 q0, -0.265625
vmov.f32 q0, -0.53125
vmov.f32 q0, -1.0625
vmov.f32 q0, -2.25
vmov.f32 q0, -4.5
vmov.f32 q0, -9.0
vmov.f32 q0, -18.0
vmov.f32 q0, -0.140625
vmov.f32 q0, -0.28125
vmov.f32 q0, -0.5625
vmov.f32 q0, -1.125
vmov.f32 q0, -2.375
vmov.f32 q0, -4.75
vmov.f32 q0, -9.5
vmov.f32 q0, -19.0
vmov.f32 q0, -0.1484375
vmov.f32 q0, -0.296875
vmov.f32 q0, -0.59375
vmov.f32 q0, -1.1875
vmov.f32 q0, -2.5
vmov.f32 q0, -5.0
vmov.f32 q0, -10.0
vmov.f32 q0, -20.0
vmov.f32 q0, -0.15625
vmov.f32 q0, -0.3125
vmov.f32 q0, -0.625
vmov.f32 q0, -1.25
vmov.f32 q0, -2.625
vmov.f32 q0, -5.25
vmov.f32 q0, -10.5
vmov.f32 q0, -21.0
vmov.f32 q0, -0.1640625
vmov.f32 q0, -0.328125
vmov.f32 q0, -0.65625
vmov.f32 q0, -1.3125
vmov.f32 q0, -2.75
vmov.f32 q0, -5.5
vmov.f32 q0, -11.0
vmov.f32 q0, -22.0
vmov.f32 q0, -0.171875
vmov.f32 q0, -0.34375
vmov.f32 q0, -0.6875
vmov.f32 q0, -1.375
vmov.f32 q0, -2.875
vmov.f32 q0, -5.75
vmov.f32 q0, -11.5
vmov.f32 q0, -23.0
vmov.f32 q0, -0.1796875
vmov.f32 q0, -0.359375
vmov.f32 q0, -0.71875
vmov.f32 q0, -1.4375
vmov.f32 q0, -3.0
vmov.f32 q0, -6.0
vmov.f32 q0, -12.0
vmov.f32 q0, -24.0
vmov.f32 q0, -0.1875
vmov.f32 q0, -0.375
vmov.f32 q0, -0.75
vmov.f32 q0, -1.5
vmov.f32 q0, -3.125
vmov.f32 q0, -6.25
vmov.f32 q0, -12.5
vmov.f32 q0, -25.0
vmov.f32 q0, -0.1953125
vmov.f32 q0, -0.390625
vmov.f32 q0, -0.78125
vmov.f32 q0, -1.5625
vmov.f32 q0, -3.25
vmov.f32 q0, -6.5
vmov.f32 q0, -13.0
vmov.f32 q0, -26.0
vmov.f32 q0, -0.203125
vmov.f32 q0, -0.40625
vmov.f32 q0, -0.8125
vmov.f32 q0, -1.625
vmov.f32 q0, -3.375
vmov.f32 q0, -6.75
vmov.f32 q0, -13.5
vmov.f32 q0, -27.0
vmov.f32 q0, -0.2109375
vmov.f32 q0, -0.421875
vmov.f32 q0, -0.84375
vmov.f32 q0, -1.6875
vmov.f32 q0, -3.5
vmov.f32 q0, -7.0
vmov.f32 q0, -14.0
vmov.f32 q0, -28.0
vmov.f32 q0, -0.21875
vmov.f32 q0, -0.4375
vmov.f32 q0, -0.875
vmov.f32 q0, -1.75
vmov.f32 q0, -3.625
vmov.f32 q0, -7.25
vmov.f32 q0, -14.5
vmov.f32 q0, -29.0
vmov.f32 q0, -0.2265625
vmov.f32 q0, -0.453125
vmov.f32 q0, -0.90625
vmov.f32 q0, -1.8125
vmov.f32 q0, -3.75
vmov.f32 q0, -7.5
vmov.f32 q0, -15.0
vmov.f32 q0, -30.0
vmov.f32 q0, -0.234375
vmov.f32 q0, -0.46875
vmov.f32 q0, -0.9375
vmov.f32 q0, -1.875
vmov.f32 q0, -3.875
vmov.f32 q0, -7.75
vmov.f32 q0, -15.5
vmov.f32 q0, -31.0
vmov.f32 q0, -0.2421875
vmov.f32 q0, -0.484375
vmov.f32 q0, -0.96875
vmov.f32 q0, -1.9375
vmov.i64 d9, #0xffffffffffffffff
|
stsp/binutils-ia16
| 3,646
|
gas/testsuite/gas/arm/inst.s
|
@ Test file for ARM/GAS -- basic instructions
.text
.align
mov r0, #0
mov r1, r2
mov r3, r4, lsl #3
mov r5, r6, lsr r7
mov r8, r9, asr r10
mov r11, r12, asl r13
mov r14, r15, rrx
moval a2, a3
moveq a3, a4
movne v1, v2
movlt v3, v4
movge v5, v6
movle v7, v8
movgt ip, sp
movcc r1, r2
movcs r1, r3
movmi r3, r6
movpl wr, sb
movvs r1, r8
movvc SB, r1, lsr #31
movhi r8, pc
movls PC, lr
movhs r9, r8
movul r1, r3
movs r0, r8
movuls r0, WR
add r0, r1, #10
add r2, r3, r4
add r5, r6, r7, asl #5
add r1, r2, r3, lsl r1
and r0, r1, #10
and r2, r3, r4
and r5, r6, r7, asl #5
and r1, r2, r3, lsl r1
eor r0, r1, #10
eor r2, r3, r4
eor r5, r6, r7, asl #5
eor r1, r2, r3, lsl r1
sub r0, r1, #10
sub r2, r3, r4
sub r5, r6, r7, asl #5
sub r1, r2, r3, lsl r1
adc r0, r1, #10
adc r2, r3, r4
adc r5, r6, r7, asl #5
adc r1, r2, r3, lsl r1
sbc r0, r1, #10
sbc r2, r3, r4
sbc r5, r6, r7, asl #5
sbc r1, r2, r3, lsl r1
rsb r0, r1, #10
rsb r2, r3, r4
rsb r5, r6, r7, asl #5
rsb r1, r2, r3, lsl r1
rsc r0, r1, #10
rsc r2, r3, r4
rsc r5, r6, r7, asl #5
rsc r1, r2, r3, lsl r1
orr r0, r1, #10
orr r2, r3, r4
orr r5, r6, r7, asl #5
orr r1, r2, r3, lsl r1
bic r0, r1, #10
bic r2, r3, r4
bic r5, r6, r7, asl #5
bic r1, r2, r3, lsl r1
mvn r0, #10
mvn r2, r4
mvn r5, r7, asl #5
mvn r1, r3, lsl r1
tst r0, #10
tst r2, r4
tst r5, r7, asl #5
tst r1, r3, lsl r1
teq r0, #10
teq r2, r4
teq r5, r7, asl #5
teq r1, r3, lsl r1
cmp r0, #10
cmp r2, r4
cmp r5, r7, asl #5
cmp r1, r3, lsl r1
cmn r0, #10
cmn r2, r4
cmn r5, r7, asl #5
cmn r1, r3, lsl r1
teqp r0, #10
teqp r2, r4
teqp r5, r7, asl #5
teqp r1, r3, lsl r1
cmnp r0, #10
cmnp r2, r4
cmnp r5, r7, asl #5
cmnp r1, r3, lsl r1
cmpp r0, #10
cmpp r2, r4
cmpp r5, r7, asl #5
cmpp r1, r3, lsl r1
tstp r0, #10
tstp r2, r4
tstp r5, r7, asl #5
tstp r1, r3, lsl r1
mul r0, r1, r2
muls r1, r2, r3
mulne r0, r1, r0
mullss r9, r8, r7
mla r1, r9, sl, fp
mlas r3, r4, r9, IP
mlalt r9, r8, r7, SP
mlages r4, r1, r3, LR
ldr r0, [r1]
ldr r1, [r1, r2]
ldr r2, [r3, r4]!
ldr r2, [r2, #32]
ldr r2, [r3, r4, lsr #8]
ldreq r4, [r5, r4, asl #9]!
ldrne r4, [r5], #6
ldrt r1, [r2], r3
ldr r2, [r4], r5, lsr #8
foo:
ldr r0, foo
ldrb r3, [r4]
ldrnebt r5, [r8]
str r0, [r1]
str r1, [r1, r2]
str r3, [r4, r3]!
str r2, [r2, #32]
str r2, [r3, r4, lsr #8]
streq r4, [r5, r4, asl #9]!
strne r4, [r5], #6
str r1, [r2], r3
strt r2, [r4], r5, lsr #8
str r1, bar
bar:
stralb r1, [r7]
strbt r2, [r0]
ldmia r0, {r1}
ldmeqib r2, {r3, r4, r5}
ldmalda r3, {r0-r15}^
ldmdb FP!, {r0-r8, SL}
ldmed r1, {r0, r1, r2}|0xf0
ldmfd r2, {r3, r4}+{r5, r6, r7, r8}
ldmea r3, 3
ldmfa r4, {r8, r9}^
stmia r0, {r1}
stmeqib r2, {r3, r4, r5}
stmalda r3, {r0-r15}^
stmdb r11!, {r0-r8, r10}
stmed r1, {r0, r1, r2}
stmfd r2, {r3, r4}
stmea r3, 3
stmfa r4, {r8, r9}^
swi 0x123456
swihs 0x33
bl _wombat
blpl hohum
b _wibble
ble testerfunc
mov r1, r2, lsl #2
mov r1, r2, lsl #0
mov r1, r2, lsl #31
mov r1, r2, lsl r3
mov r1, r2, lsr #2
mov r1, r2, lsr #31
mov r1, r2, lsr #32
mov r1, r2, lsr r3
mov r1, r2, asr #2
mov r1, r2, asr #31
mov r1, r2, asr #32
mov r1, r2, asr r3
mov r1, r2, ror #2
mov r1, r2, ror #31
mov r1, r2, ror r3
mov r1, r2, rrx
mov r1, r2, LSL #2
mov r1, r2, LSL #0
mov r1, r2, LSL #31
mov r1, r2, LSL r3
mov r1, r2, LSR #2
mov r1, r2, LSR #31
mov r1, r2, LSR #32
mov r1, r2, LSR r3
mov r1, r2, ASR #2
mov r1, r2, ASR #31
mov r1, r2, ASR #32
mov r1, r2, ASR r3
mov r1, r2, ROR #2
mov r1, r2, ROR #31
mov r1, r2, ROR r3
mov r1, r2, RRX
ldralt r1, [r2], r3
|
stsp/binutils-ia16
| 2,872
|
gas/testsuite/gas/arm/iwmmxt2.s
|
.text
.global iwmmxt2
iwmmxt2:
waddhc wr4, wr5, wr6
waddwc wr7, wr8, wr9
wmadduxgt wr4, wr5, wr6
wmadduneq wr7, wr8, wr9
wmaddsxne wr4, wr5, wr6
wmaddsnge wr7, wr8, wr9
wmulumr wr1, wr2, wr3
wmulsmr wr1, wr2, wr3
torvscbgt r15
torvschne r15
torvscweq r15
wabsb wr1, wr2
wabsh wr3, wr4
wabsw wr5, wr6
wabsbgt wr1, wr2
wabsdiffb wr1, wr2, wr3
wabsdiffh wr4, wr5, wr6
wabsdiffw wr7, wr8, wr9
wabsdiffbgt wr1, wr2, wr3
waddbhusm wr1, wr2, wr3
waddbhusl wr4, wr5, wr6
waddbhusmgt wr1, wr2, wr3
waddbhuslgt wr4, wr5, wr6
waddsubhx wr1, wr2, wr3
waddsubhxlt wr4, wr5, wr6
waddsubhxeq wr1, wr2, wr3
waddsubhxgt wr4, wr5, wr6
wavg4 wr1, wr2, wr3
wavg4gt wr4, wr5, wr6
wavg4r wr1, wr2, wr3
wavg4rgt wr4, wr5, wr6
wldrd wr1, [r1], -r2
wldrd wr2, [r1], -r2,lsl #3
wldrd wr3, [r1], +r2
wldrd wr4, [r1], +r2,lsl #4
wldrd wr5, [r1, -r2]
wldrd wr6, [r1, -r2,lsl #3]
wldrd wr7, [r1, +r2]
wldrd wr8, [r1, +r2,lsl #4]
wldrd wr9, [r1, -r2]!
wldrd wr10, [r1, -r2,lsl #3]!
wldrd wr11, [r1, +r2]!
wldrd wr12, [r1, +r2,lsl #4]!
wmerge wr1, wr2, wr3, #4
wmergegt wr1, wr2, wr3, #4
wmiatteq wr1, wr2, wr3
wmiatbgt wr1, wr2, wr3
wmiabtne wr1, wr2, wr3
wmiabbgt wr1, wr2, wr3
wmiattneq wr1, wr2, wr3
wmiatbnne wr1, wr2, wr3
wmiabtngt wr1, wr2, wr3
wmiabbneq wr1, wr2, wr3
wmiawtteq wr1, wr2, wr3
wmiawtbgt wr1, wr2, wr3
wmiawbtne wr1, wr2, wr3
wmiawbbgt wr1, wr2, wr3
wmiawttnne wr1, wr2, wr3
wmiawtbngt wr1, wr2, wr3
wmiawbtneq wr1, wr2, wr3
wmiawbbnne wr1, wr2, wr3
wmulwumeq wr1, wr2, wr3
wmulwumrgt wr1, wr2, wr3
wmulwsmne wr1, wr2, wr3
wmulwsmreq wr1, wr2, wr3
wmulwlgt wr1, wr2, wr3
wmulwlge wr1, wr2, wr3
wqmiattne wr1, wr2, wr3
wqmiattneq wr1, wr2, wr3
wqmiatbgt wr1, wr2, wr3
wqmiatbnge wr1, wr2, wr3
wqmiabtne wr1, wr2, wr3
wqmiabtneq wr1, wr2, wr3
wqmiabbgt wr1, wr2, wr3
wqmiabbnne wr1, wr2, wr3
wqmulmgt wr1, wr2, wr3
wqmulmreq wr1, wr2, wr3
wqmulwmgt wr1, wr2, wr3
wqmulwmreq wr1, wr2, wr3
wstrd wr1, [r1], -r2
wstrd wr2, [r1], -r2,lsl #3
wstrd wr3, [r1], +r2
wstrd wr4, [r1], +r2,lsl #4
wstrd wr5, [r1, -r2]
wstrd wr6, [r1, -r2,lsl #3]
wstrd wr7, [r1, +r2]
wstrd wr8, [r1, +r2,lsl #4]
wstrd wr9, [r1, -r2]!
wstrd wr10, [r1, -r2,lsl #3]!
wstrd wr11, [r1, +r2]!
wstrd wr12, [r1, +r2,lsl #4]!
wsubaddhxgt wr1, wr2, wr3
wrorh wr1, wr2, #0
wrorw wr1, wr2, #0
wrord wr1, wr2, #0
wrorh wr1, wr2, #21
wrorw wr1, wr2, #13
wrord wr1, wr2, #14
wsllh wr1, wr2, #0
wsllw wr1, wr2, #0
wslld wr1, wr2, #0
wsllh wr2, wr9, #11
wsllw wr3, wr5, #13
wslld wr3, wr8, #15
wsrah wr1, wr2, #0
wsraw wr1, wr2, #0
wsrad wr1, wr2, #0
wsrah wr2, wr9, #12
wsraw wr3, wr5, #14
wsrad wr3, wr8, #16
wsrlh wr1, wr2, #0
wsrlw wr1, wr2, #0
wsrld wr1, wr2, #0
wsrlh wr2, wr9, #12
wsrlw wr3, wr5, #14
wsrld wr3, wr8, #16
|
stsp/binutils-ia16
| 1,159
|
gas/testsuite/gas/arm/mve-vaddsub.s
|
.syntax unified
.thumb
.macro all_qqq op
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
.irp op3, q0, q1, q2, q4, q7
\op \op1, \op2, \op3
.endr
.endr
.endr
.endm
.macro all_qqr op
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
.irp op3, r0, r1, r2, r4, r7, r8, r10, r12, r14
\op \op1, \op2, \op3
.endr
.endr
.endr
.endm
all_qqq vadd.i8
all_qqq vadd.i16
all_qqq vadd.i32
all_qqq vadd.f16
all_qqq vadd.f32
vpstt
vaddt.i8 q0, q1, q2
vaddt.i16 q1, q2, q4
vpstee
vaddt.i32 q2, q4, q5
vadde.f16 q0, q4, q6
vadde.f32 q4, q5, q7
all_qqq vsub.i8
all_qqq vsub.i16
all_qqq vsub.i32
all_qqq vsub.f16
all_qqq vsub.f32
vpste
vsubt.i8 q0, q1, q2
vsube.i16 q1, q2, q4
vpstte
vsubt.i32 q2, q7, q5
vsubt.f16 q1, q4, q6
vsube.f32 q4, q5, q7
all_qqr vadd.i8
all_qqr vadd.i16
all_qqr vadd.i32
all_qqr vadd.f16
all_qqr vadd.f32
vpstt
vaddt.i8 q0, q1, r10
vaddt.i16 q1, q2, r12
vpstee
vaddt.i32 q2, q4, r5
vadde.f16 q5, q4, r6
vadde.f32 q4, q5, r7
all_qqr vsub.i8
all_qqr vsub.i16
all_qqr vsub.i32
all_qqr vsub.f16
all_qqr vsub.f32
vpste
vsubt.i8 q0, q1, r10
vsube.i16 q1, q2, r11
vpstte
vsubt.i32 q2, q0, r5
vsubt.f16 q1, q4, r6
vsube.f32 q4, q5, r7
|
stsp/binutils-ia16
| 2,348
|
gas/testsuite/gas/arm/armv8-2-fp16-scalar-bad.s
|
.macro f16_sss_arithmetic reg0, reg1, reg2
.irp op, vdiv, vfma, vfms, vfnma, vfnms, vmla, vmls, vmul, vnmla, vnmls, vnmul, vsub
.irp cond, eq.f16, ne.f16, ge.f16, lt.f16, gt.f16, le.f16
\op\cond s\reg0, s\reg1, s\reg2
.endr
.endr
.endm
.macro f16_ss_arithmetic reg0, reg1
.irp op, vabs, vadd, vsqrt, vneg
.irp cond, eq.f16, ne.f16, ge.f16, lt.f16, gt.f16, le.f16
\op\cond s\reg0, s\reg1
.endr
.endr
.endm
.macro f16_si_cmp reg0, imm
.irp op, vcmp, vcmpe
.irp cond, eq.f16, ne.f16, ge.f16, lt.f16, gt.f16, le.f16
\op\cond s\reg0, \imm
.endr
.endr
.endm
.macro f16_ss_cmp reg0, reg1
.irp op, vcmp, vcmpe
.irp cond, eq.f16, ne.f16, ge.f16, lt.f16, gt.f16, le.f16
\op\cond s\reg0, s\reg1
.endr
.endr
.endm
.macro f16_ss_cvt reg0, reg1
.irp cond, eq, ne, ge, lt, gt, le
.irp mode, .s32.f16, .u32.f16, .f16.s32, .f16.u32
vcvt\cond\mode s\reg0, s\reg1
.endr
.endr
.endm
.macro f16_ssi_cvt_imm32 reg0, reg1, imm
.irp cond, eq, ne, ge, lt, gt, le
.irp mode, .s32.f16, .u32.f16, .f16.s32, .f16.u32
vcvt\cond\mode s\reg0, s\reg1, \imm
.endr
.endr
.endm
.macro f16_ss_cvt_r reg0, reg1
.irp cond, eq, ne, ge, lt, gt, le
.irp mode, .s32.f16, .u32.f16
vcvtr\cond\mode s\reg0, s\reg1
.endr
.endr
.endm
.macro f16_ss_vrint reg0, reg1
.irp op, vrintr, vrintx, vrintz
.irp cond, eq.f16, ne.f16, ge.f16, lt.f16, gt.f16, le.f16
\op\cond s\reg0, s\reg1
.endr
.endr
.endm
.macro f16_ss_mov reg0, reg1
.irp op, vins, vmovx
.irp cond, eq.f16, ne.f16, ge.f16, lt.f16, gt.f16, le.f16
\op\cond s\reg0, s\reg1
.endr
.endr
.endm
.macro t_f16_ss_mov reg0, reg1
.irp op, vins, vmovx
.irp cond, eq, ne, ge, lt, gt, le
.irp mode, .f16
it \cond
\op\cond\mode s\reg0, s\reg1
.endr
.endr
.endr
.endm
.text
@ invalied immediate range
vldr.16 s6, [pc, #-511]
vldr.16 s6, [pc, #111]
vldr.16 s3, [pc, #511]
@ invalid immediate range
vcvt.s32.f16 s11, s11, #33
vcvt.u32.f16 s11, s11, #0
vcvt.f16.s32 s12, s12, #34
vcvt.f16.u32 s12, s12, #-1
@ armv8.2 fp16 scalar instruction cannot be conditional
f16_sss_arithmetic 0, 1, 2
f16_ss_arithmetic 0, 1
f16_si_cmp 2, #0.0
f16_ss_cmp 0, 1
f16_ss_cvt 1, 8
f16_ssi_cvt_imm32 2, 2, #29
f16_ss_cvt_r 0, 10
f16_ss_vrint 3, 11
f16_ss_mov 0, 1
.syntax unified
.thumb
t_f16_ss_mov 0, 1
|
stsp/binutils-ia16
| 1,091
|
gas/testsuite/gas/arm/armv1.s
|
.global entry
.text
entry:
and r0, r0, r0
ands r0, r0, r0
eor r0, r0, r0
eors r0, r0, r0
sub r0, r0, r0
subs r0, r0, r0
rsb r0, r0, r0
rsbs r0, r0, r0
add r0, r0, r0
adds r0, r0, r0
adc r0, r0, r0
adcs r0, r0, r0
sbc r0, r0, r0
sbcs r0, r0, r0
rsc r0, r0, r0
rscs r0, r0, r0
orr r0, r0, r0
orrs r0, r0, r0
bic r0, r0, r0
bics r0, r0, r0
tst r0, r0
tsts r0, r0
tstp r0, r0
teq r0, r0
teqs r0, r0
teqp r0, r0
cmp r0, r0
cmps r0, r0
cmpp r0, r0
cmn r0, r0
cmns r0, r0
cmnp r0, r0
mov r0, r0
movs r0, r0
mvn r0, r0
mvns r0, r0
swi #0
ldr r0, [r0, #-0]
ldrb r0, [r0, #-0]
ldrt r0, [r1]
ldrbt r0, [r1]
str r0, [r0, #-0]
strb r0, [r0, #-0]
strt r0, [r1]
strbt r0, [r1]
stmia r0, {r0}
stmib r0, {r0}
stmda r0, {r0}
stmdb r0, {r0}
stmfd r0, {r0}
stmfa r0, {r0}
stmea r0, {r0}
stmed r0, {r0}
ldmia r0, {r0}
ldmib r0, {r0}
ldmda r0, {r0}
ldmdb r0, {r0}
ldmfd r0, {r0}
ldmfa r0, {r0}
ldmea r0, {r0}
ldmed r0, {r0}
# Add three nop instructions to ensure that the
# output is 32-byte aligned as required for arm-aout.
nop
nop
nop
|
stsp/binutils-ia16
| 1,326
|
gas/testsuite/gas/arm/armv7e-m+fpv5-d16.s
|
.syntax unified
.text
.arch armv7e-m
.fpu fpv5-d16
.thumb
vseleq.f32 s0, s0, s0
vselvs.f32 s1, s1, s1
vselge.f32 s30, s30, s30
vselgt.f32 s31, s31, s31
vseleq.f64 d0, d0, d0
vselvs.f64 d8, d8, d8
vselge.f64 d15, d15, d15
vselgt.f64 d10, d10, d10
vmaxnm.f32 s0, s0, s0
vmaxnm.f32 s1, s1, s1
vmaxnm.f32 s30, s30, s30
vmaxnm.f32 s31, s31, s31
vmaxnm.f64 d0, d0, d0
vmaxnm.f64 d8, d8, d8
vmaxnm.f64 d15, d15, d15
vmaxnm.f64 d10, d10, d10
vminnm.f32 s0, s0, s0
vminnm.f32 s1, s1, s1
vminnm.f32 s30, s30, s30
vminnm.f32 s31, s31, s31
vminnm.f64 d0, d0, d0
vminnm.f64 d8, d8, d8
vminnm.f64 d15, d15, d15
vminnm.f64 d10, d10, d10
vcvta.s32.f32 s0, s0
vcvtn.s32.f32 s1, s1
vcvtp.u32.f32 s30, s30
vcvtm.u32.f32 s31, s31
vcvta.s32.f64 s0, d0
vcvtn.s32.f64 s1, d8
vcvtp.u32.f64 s30, d15
vcvtm.u32.f64 s31, d10
vrintz.f32 s0, s0
vrintx.f32 s1, s1
vrintr.f32 s30, s30
vrinta.f32 s0, s0
vrintn.f32 s1, s1
vrintp.f32 s30, s30
vrintm.f32 s31, s31
vrintz.f64 d0, d0
vrintx.f64 d1, d1
vrintr.f64 d10, d10
vrinta.f64 d0, d0
vrintn.f64 d1, d1
vrintp.f64 d10, d10
vrintm.f64 d10, d10
vcvtt.f16.f64 s0, d0
vcvtb.f16.f64 s1, d8
vcvtt.f16.f64 s30, d15
vcvtb.f16.f64 s31, d10
vcvtt.f64.f16 d0, s0
vcvtb.f64.f16 d8, s1
vcvtt.f64.f16 d15, s30
vcvtb.f64.f16 d10, s31
|
stsp/binutils-ia16
| 1,079
|
gas/testsuite/gas/arm/neon-addressing-bad.s
|
.syntax unified
VLD1.8 {d0}, 1f
1:
VLD1.8 {D0}, R0
VLD1.8 {Q1}, R0
VLD1.8 {D0}, [PC]
VLD1.8 {D0}, [PC, #0]
VST1.8 {D0}, R0
VST1.8 {Q1}, R0
VST1.8 {D0}, [PC]
VST1.8 {D0}, [PC, #0]
VST1.8 {D0[]}, [R0]
VST2.8 {D0[], D2[]}, [R0]
VST3.16 {D0[], D1[], D2[]}, [R0]
VST4.32 {D0[], D1[], D2[], D3[]}, [R0]
VLD1.8 {Q0}, [R0, #8]
VLD1.8 {Q0}, [R0, #8]!
VLD1.8 {Q0}, [R0, R1]
VLD1.8 {Q0}, [R0, R1]!
.thumb
VLD1.8 {d0}, 2f
2:
VLD1.8 {D0}, R0
VLD1.8 {Q1}, R0
VLD1.8 {D0}, [PC]
VLD1.8 {D0}, [PC, #0]
VST1.8 {D0}, R0
VST1.8 {Q1}, R0
VST1.8 {D0}, [PC]
VST1.8 {D0}, [PC, #0]
VSHL.I8 d0, d0, #7
VSHL.I8 d0, d0, #8
VSHL.I16 d0, d0, #15
VSHL.I16 d0, d0, #16
VSHL.I32 d0, d0, #31
VSHL.I32 d0, d0, #32
VSHL.I64 d0, d0, #63
VSHL.I64 d0, d0, #64
VQSHL.S8 d0, d0, #7
VQSHL.S8 d0, d0, #8
VQSHL.S16 d0, d0, #15
VQSHL.S16 d0, d0, #16
VQSHL.S32 d0, d0, #31
VQSHL.S32 d0, d0, #32
VQSHL.S64 d0, d0, #63
VQSHL.S64 d0, d0, #64
VQSHLU.S8 d0, d0, #7
VQSHLU.S8 d0, d0, #8
VQSHLU.S16 d0, d0, #15
VQSHLU.S16 d0, d0, #16
VQSHLU.S32 d0, d0, #31
VQSHLU.S32 d0, d0, #32
VQSHLU.S64 d0, d0, #63
VQSHLU.S64 d0, d0, #64
|
stsp/binutils-ia16
| 1,725
|
gas/testsuite/gas/arm/mve-vqdmladh.s
|
.syntax unified
.thumb
.irp data, s8, s16
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
.irp op3, q0, q1, q2, q4, q7
vqdmladh.\data \op1, \op2, \op3
vqdmladhx.\data \op1, \op2, \op3
vqrdmladh.\data \op1, \op2, \op3
vqrdmladhx.\data \op1, \op2, \op3
.endr
.endr
.endr
.endr
.irp op2, q1, q2, q4, q7
.irp op3, q1, q2, q4, q7
vqdmladh.s32 q0, \op2, \op3
vqdmladhx.s32 q0, \op2, \op3
vqrdmladh.s32 q0, \op2, \op3
vqrdmladhx.s32 q0, \op2, \op3
.endr
.endr
.irp op2, q0, q2, q4, q7
.irp op3, q0, q2, q4, q7
vqdmladh.s32 q1, \op2, \op3
vqdmladhx.s32 q1, \op2, \op3
vqrdmladh.s32 q1, \op2, \op3
vqrdmladhx.s32 q1, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q4, q7
.irp op3, q0, q1, q4, q7
vqdmladh.s32 q2, \op2, \op3
vqdmladhx.s32 q2, \op2, \op3
vqrdmladh.s32 q2, \op2, \op3
vqrdmladhx.s32 q2, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q4, q7
.irp op3, q0, q1, q4, q7
vqdmladh.s32 q2, \op2, \op3
vqdmladhx.s32 q2, \op2, \op3
vqrdmladh.s32 q2, \op2, \op3
vqrdmladhx.s32 q2, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q2, q7
.irp op3, q0, q1, q2, q7
vqdmladh.s32 q4, \op2, \op3
vqdmladhx.s32 q4, \op2, \op3
vqrdmladh.s32 q4, \op2, \op3
vqrdmladhx.s32 q4, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q2, q4
.irp op3, q0, q1, q2, q4
vqdmladh.s32 q7, \op2, \op3
vqdmladhx.s32 q7, \op2, \op3
vqrdmladh.s32 q7, \op2, \op3
vqrdmladhx.s32 q7, \op2, \op3
.endr
.endr
vpstete
vqdmladht.s8 q0, q1, q2
vqdmladhe.s8 q0, q1, q2
vqdmladhxt.s16 q0, q1, q2
vqdmladhxe.s16 q0, q1, q2
vpstete
vqrdmladht.s32 q0, q1, q2
vqrdmladhe.s32 q0, q1, q2
vqrdmladhxt.s16 q0, q1, q2
vqrdmladhxe.s16 q0, q1, q2
vqdmladh.s32 q0, q0, q0
vqrdmladh.s32 q0, q0, q0
vqdmladh.s32 q0, q0, q1
vqrdmladh.s32 q1, q1, q2
vqdmladh.s32 q2, q3, q2
vqrdmladh.s32 q3, q4, q3
|
stsp/binutils-ia16
| 1,392
|
gas/testsuite/gas/arm/bundle.s
|
.syntax unified
.bundle_align_mode 4
# We use these macros to test each pattern at every offset from
# bundle alignment, i.e. [0,16) by 2 or 4.
.macro offset_insn insn_name, offset, size
.p2align 4
\insn_name\()_offset_\offset\():
.rept \offset / \size
bkpt
.endr
\insn_name
.endm
.macro test_offsets_arm insn_name
.arm
offset_insn \insn_name, 0, 4
offset_insn \insn_name, 4, 4
offset_insn \insn_name, 8, 4
offset_insn \insn_name, 12, 4
.endm
.macro test_offsets_thumb insn_name
.thumb
offset_insn \insn_name, 0, 2
offset_insn \insn_name, 2, 2
offset_insn \insn_name, 4, 2
offset_insn \insn_name, 6, 2
offset_insn \insn_name, 8, 2
offset_insn \insn_name, 10, 2
offset_insn \insn_name, 12, 2
offset_insn \insn_name, 14, 2
.endm
.macro test_arm
add r0, r1
.endm
.macro test_thumb_2
adds r0, r1
.endm
.macro test_thumb_4
adds r8, r9
.endm
test_offsets_arm test_arm
test_offsets_thumb test_thumb_2
test_offsets_thumb test_thumb_4
# There are many relaxation cases for Thumb instructions.
# But we use as representative the simple branch cases.
.macro test_thumb_b_2
b 0f
bkpt 1
0: bkpt 2
.endm
.macro test_thumb_b_4
b far_target
.endm
test_offsets_thumb test_thumb_b_2
test_offsets_thumb test_thumb_b_4
# This is to set up a branch target surely too far for a short branch.
pad_for_far_target:
.rept 1025
bkpt 1
.endr
far_target:
bkpt 2
.p2align 4
bkpt
|
stsp/binutils-ia16
| 2,628
|
gas/testsuite/gas/arm/thumb.s
|
.text
.code 16
.foo:
lsl r2, r1, #3
lsr r3, r4, #31
wibble/data:
asr r7, r0, #5
lsl r1, r2, #0
lsr r3, r4, #0
asr r4, r5, #0
lsr r6, r7, #32
asr r0, r1, #32
add r1, r2, r3
add r2, r4, #2
sub r3, r5, r7
sub r2, r4, #7
mov r4, #255
cmp r3, #250
add r6, #123
sub r5, #128
and r3, r5
eor r4, r6
lsl r1, r0
lsr r2, r3
asr r4, r6
adc r5, r7
sbc r0, r4
ror r1, r4
tst r2, r5
neg r1, r1
cmp r2, r3
cmn r1, r4
orr r0, r3
mul r4, r5
bic r5, r7
mvn r5, r5
add r1, r13
add r12, r2
add r9, r9
cmp r1, r14
cmp r8, r0
cmp r12, r14
mov r0, r9
mov r9, r4
mov r8, r8
bx r7
bx r8
.align 0
bx pc
ldr r3, [pc, #128]
ldr r4, bar
str r0, [r1, r2]
strb r1, [r2, r4]
ldr r5, [r6, r7]
ldrb r2, [r4, r5]
.align 0
bar:
strh r1, [r2, r3]
ldrh r3, [r4, r0]
ldsb r1, [r6, r7]
ldsh r2, [r0, r5]
str r3, [r3, #124]
ldr r1, [r4, #124]
ldr r5, [r5]
strb r1, [r5, #31]
strb r1, [r4, #5]
strb r2, [r6]
strh r4, [r5, #62]
ldrh r5, [r0, #4]
ldrh r3, [r2]
str r3, [r13, #1020]
ldr r1, [r13, #44]
ldr r2, [r13]
add r7, r15, #1020
add r4, r13, #512
add r13, #268
add r13, #-104
sub r13, #268
sub r13, #-108
push {r0, r1, r2, r4}
push {r0, r3-r7, lr}
pop {r3, r4, r7}
pop {r0-r7, r15}
stmia r3!, {r0, r1, r4-r7}
ldmia r0!, {r1-r7}
beq bar
bne bar
bcs bar
bcc bar
bmi bar
bpl bar
bvs bar
bvc bar
bhi bar
bls bar
bge bar
bgt bar
blt bar
bgt bar
ble bar
bhi bar
blo bar
bul bar
bal bar
close:
lsl r4, r5, #near - close
near:
add r2, r3, #near - close
add sp, sp, #127 << 2
sub sp, sp, #127 << 2
add r0, sp, #255 << 2
add r0, pc, #255 << 2
add sp, sp, #bar - .foo
sub sp, sp, #bar - .foo
add r0, sp, #bar - .foo
add r0, pc, #bar - .foo
add r1, #bar - .foo
mov r6, #bar - .foo
cmp r7, #bar - .foo
nop
nop
.arm
.localbar:
b .localbar
b .back
bl .localbar
bl .back
bx r0
swi 0x123456
.thumb
@ The following will be disassembled incorrectly if we do not
@ have a Thumb symbol defined before the first Thumb instruction:
morethumb:
adr r0, forwardonly
b .foo
b .back
bl .foo
bl .back
bx r0
swi 0xff
.align 0
forwardonly:
beq .back
bne .back
bcs .back
bcc .back
bmi .back
bpl .back
bvs .back
bvc .back
bhi .back
bls .back
bge .back
bgt .back
blt .back
bgt .back
ble .back
bhi .back
blo .back
bul .back
.back:
bl .local
.space (1 << 11) @ leave space to force long offsets
.local:
bl .back
ldr r0, .target
ldr r0, .target
ldr r0, [pc, #4]
ldr r0, [pc, #4]
.target:
baz:
mov r0, r1
nop
adr r0, pr18541
adr r0, pr18541
adr r0, pr18541
nop
.align
.global pr18541
pr18541:
.long 0
|
stsp/binutils-ia16
| 4,160
|
gas/testsuite/gas/arm/mve-vmov-3.s
|
vmov r0, r1, q1[2], q1[0]
vmov r0, r1, q2[2], q2[0]
vmov r0, r1, q3[2], q3[0]
vmov r0, r1, q4[2], q4[0]
vmov r0, r1, q5[2], q5[0]
vmov r0, r1, q6[2], q6[0]
vmov r0, r1, q7[2], q7[0]
vmov r1, r0, q0[2], q0[0]
vmov r2, r0, q0[2], q0[0]
vmov r3, r0, q0[2], q0[0]
vmov r4, r0, q0[2], q0[0]
vmov r5, r0, q0[2], q0[0]
vmov r6, r0, q0[2], q0[0]
vmov r7, r0, q0[2], q0[0]
vmov r8, r0, q0[2], q0[0]
vmov r9, r0, q0[2], q0[0]
vmov sl, r0, q0[2], q0[0]
vmov fp, r0, q0[2], q0[0]
vmov ip, r0, q0[2], q0[0]
vmov lr, r0, q0[2], q0[0]
vmov r0, r1, q0[2], q0[0]
vmov r0, r2, q0[2], q0[0]
vmov r0, r3, q0[2], q0[0]
vmov r0, r4, q0[2], q0[0]
vmov r0, r5, q0[2], q0[0]
vmov r0, r6, q0[2], q0[0]
vmov r0, r7, q0[2], q0[0]
vmov r0, r8, q0[2], q0[0]
vmov r0, r9, q0[2], q0[0]
vmov r0, sl, q0[2], q0[0]
vmov r0, fp, q0[2], q0[0]
vmov r0, ip, q0[2], q0[0]
vmov r0, lr, q0[2], q0[0]
vmov r0, r1, q1[3], q1[1]
vmov r0, r1, q2[3], q2[1]
vmov r0, r1, q3[3], q3[1]
vmov r0, r1, q4[3], q4[1]
vmov r0, r1, q5[3], q5[1]
vmov r0, r1, q6[3], q6[1]
vmov r0, r1, q7[3], q7[1]
vmov r1, r0, q0[3], q0[1]
vmov r2, r0, q0[3], q0[1]
vmov r3, r0, q0[3], q0[1]
vmov r4, r0, q0[3], q0[1]
vmov r5, r0, q0[3], q0[1]
vmov r6, r0, q0[3], q0[1]
vmov r7, r0, q0[3], q0[1]
vmov r8, r0, q0[3], q0[1]
vmov r9, r0, q0[3], q0[1]
vmov sl, r0, q0[3], q0[1]
vmov fp, r0, q0[3], q0[1]
vmov ip, r0, q0[3], q0[1]
vmov lr, r0, q0[3], q0[1]
vmov r0, r1, q0[3], q0[1]
vmov r0, r2, q0[3], q0[1]
vmov r0, r3, q0[3], q0[1]
vmov r0, r4, q0[3], q0[1]
vmov r0, r5, q0[3], q0[1]
vmov r0, r6, q0[3], q0[1]
vmov r0, r7, q0[3], q0[1]
vmov r0, r8, q0[3], q0[1]
vmov r0, r9, q0[3], q0[1]
vmov r0, sl, q0[3], q0[1]
vmov r0, fp, q0[3], q0[1]
vmov r0, ip, q0[3], q0[1]
vmov r0, lr, q0[3], q0[1]
vmov q1[2], q1[0], r0, r1
vmov q2[2], q2[0], r0, r1
vmov q3[2], q3[0], r0, r1
vmov q4[2], q4[0], r0, r1
vmov q5[2], q5[0], r0, r1
vmov q6[2], q6[0], r0, r1
vmov q7[2], q7[0], r0, r1
vmov q0[2], q0[0], r0, r0
vmov q0[2], q0[0], r1, r0
vmov q0[2], q0[0], r2, r0
vmov q0[2], q0[0], r3, r0
vmov q0[2], q0[0], r4, r0
vmov q0[2], q0[0], r5, r0
vmov q0[2], q0[0], r6, r0
vmov q0[2], q0[0], r7, r0
vmov q0[2], q0[0], r8, r0
vmov q0[2], q0[0], r9, r0
vmov q0[2], q0[0], sl, r0
vmov q0[2], q0[0], fp, r0
vmov q0[2], q0[0], ip, r0
vmov q0[2], q0[0], lr, r0
vmov q0[2], q0[0], r0, r1
vmov q0[2], q0[0], r0, r2
vmov q0[2], q0[0], r0, r3
vmov q0[2], q0[0], r0, r4
vmov q0[2], q0[0], r0, r5
vmov q0[2], q0[0], r0, r6
vmov q0[2], q0[0], r0, r7
vmov q0[2], q0[0], r0, r8
vmov q0[2], q0[0], r0, r9
vmov q0[2], q0[0], r0, sl
vmov q0[2], q0[0], r0, fp
vmov q0[2], q0[0], r0, ip
vmov q0[2], q0[0], r0, lr
vmov q0[2], q0[0], r1, r1
vmov q0[2], q0[0], r2, r2
vmov q0[2], q0[0], r3, r3
vmov q0[2], q0[0], r4, r4
vmov q0[2], q0[0], r5, r5
vmov q0[2], q0[0], r6, r6
vmov q0[2], q0[0], r7, r7
vmov q0[2], q0[0], r8, r8
vmov q0[2], q0[0], r9, r9
vmov q0[2], q0[0], sl, sl
vmov q0[2], q0[0], fp, fp
vmov q0[2], q0[0], ip, ip
vmov q0[2], q0[0], lr, lr
vmov q1[3], q1[1], r0, r1
vmov q2[3], q2[1], r0, r1
vmov q3[3], q3[1], r0, r1
vmov q4[3], q4[1], r0, r1
vmov q5[3], q5[1], r0, r1
vmov q6[3], q6[1], r0, r1
vmov q7[3], q7[1], r0, r1
vmov q0[3], q0[1], r0, r0
vmov q0[3], q0[1], r1, r0
vmov q0[3], q0[1], r2, r0
vmov q0[3], q0[1], r3, r0
vmov q0[3], q0[1], r4, r0
vmov q0[3], q0[1], r5, r0
vmov q0[3], q0[1], r6, r0
vmov q0[3], q0[1], r7, r0
vmov q0[3], q0[1], r8, r0
vmov q0[3], q0[1], r9, r0
vmov q0[3], q0[1], sl, r0
vmov q0[3], q0[1], fp, r0
vmov q0[3], q0[1], ip, r0
vmov q0[3], q0[1], lr, r0
vmov q0[3], q0[1], r0, r1
vmov q0[3], q0[1], r0, r2
vmov q0[3], q0[1], r0, r3
vmov q0[3], q0[1], r0, r4
vmov q0[3], q0[1], r0, r5
vmov q0[3], q0[1], r0, r6
vmov q0[3], q0[1], r0, r7
vmov q0[3], q0[1], r0, r8
vmov q0[3], q0[1], r0, r9
vmov q0[3], q0[1], r0, sl
vmov q0[3], q0[1], r0, fp
vmov q0[3], q0[1], r0, ip
vmov q0[3], q0[1], r0, lr
vmov q0[3], q0[1], r1, r1
vmov q0[3], q0[1], r2, r2
vmov q0[3], q0[1], r3, r3
vmov q0[3], q0[1], r4, r4
vmov q0[3], q0[1], r5, r5
vmov q0[3], q0[1], r6, r6
vmov q0[3], q0[1], r7, r7
vmov q0[3], q0[1], r8, r8
vmov q0[3], q0[1], r9, r9
vmov q0[3], q0[1], sl, sl
vmov q0[3], q0[1], fp, fp
vmov q0[3], q0[1], ip, ip
vmov q0[3], q0[1], lr, lr
|
stsp/binutils-ia16
| 1,723
|
gas/testsuite/gas/arm/mve-vqdmlsdh.s
|
.syntax unified
.thumb
.irp data, s8, s16
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
.irp op3, q0, q1, q2, q4, q7
vqdmlsdh.\data \op1, \op2, \op3
vqdmlsdhx.\data \op1, \op2, \op3
vqrdmlsdh.\data \op1, \op2, \op3
vqrdmlsdhx.\data \op1, \op2, \op3
.endr
.endr
.endr
.endr
.irp op2, q1, q2, q4, q7
.irp op3, q1, q2, q4, q7
vqdmlsdh.s32 q0, \op2, \op3
vqdmlsdhx.s32 q0, \op2, \op3
vqrdmlsdh.s32 q0, \op2, \op3
vqrdmlsdhx.s32 q0, \op2, \op3
.endr
.endr
.irp op2, q0, q2, q4, q7
.irp op3, q0, q2, q4, q7
vqdmlsdh.s32 q1, \op2, \op3
vqdmlsdhx.s32 q1, \op2, \op3
vqrdmlsdh.s32 q1, \op2, \op3
vqrdmlsdhx.s32 q1, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q4, q7
.irp op3, q0, q1, q4, q7
vqdmlsdh.s32 q2, \op2, \op3
vqdmlsdhx.s32 q2, \op2, \op3
vqrdmlsdh.s32 q2, \op2, \op3
vqrdmlsdhx.s32 q2, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q4, q7
.irp op3, q0, q1, q4, q7
vqdmlsdh.s32 q2, \op2, \op3
vqdmlsdhx.s32 q2, \op2, \op3
vqrdmlsdh.s32 q2, \op2, \op3
vqrdmlsdhx.s32 q2, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q2, q7
.irp op3, q0, q1, q2, q7
vqdmlsdh.s32 q4, \op2, \op3
vqdmlsdhx.s32 q4, \op2, \op3
vqrdmlsdh.s32 q4, \op2, \op3
vqrdmlsdhx.s32 q4, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q2, q4
.irp op3, q0, q1, q2, q4
vqdmlsdh.s32 q7, \op2, \op3
vqdmlsdhx.s32 q7, \op2, \op3
vqrdmlsdh.s32 q7, \op2, \op3
vqrdmlsdhx.s32 q7, \op2, \op3
.endr
.endr
vpstete
vqdmlsdht.s8 q0, q1, q2
vqdmlsdhe.s8 q0, q1, q2
vqdmlsdhxt.s16 q0, q1, q2
vqdmlsdhxe.s16 q0, q1, q2
vpstete
vqrdmlsdht.s32 q0, q1, q2
vqrdmlsdhe.s32 q0, q1, q2
vqrdmlsdhxt.s16 q0, q1, q2
vqrdmlsdhxe.s16 q0, q1, q2
vqdmlsdh.s32 q0, q0, q0
vqrdmlsdh.s32 q0, q0, q0
vqdmlsdh.s32 q1, q1, q2
vqrdmlsdh.s32 q2, q2, q3
vqdmlsdh.s32 q3, q4, q3
vqrdmlsdh.s32 q4, q5, q4
|
stsp/binutils-ia16
| 1,225
|
gas/testsuite/gas/arm/bundle-lock.s
|
.syntax unified
.bundle_align_mode 4
# We use these macros to test each pattern at every offset from
# bundle alignment, i.e. [0,16) by 2 or 4.
size_arm = 4
size_thumb = 2
.macro offset_sequence which, size, offset
.p2align 4
\which\()_sequence_\size\()_offset_\offset\():
.rept \offset / size_\which
bkpt
.endr
test_sequence \size
.endm
.macro test_offsets_arm size
.arm
offset_sequence arm, \size, 0
offset_sequence arm, \size, 4
offset_sequence arm, \size, 8
offset_sequence arm, \size, 12
.endm
.macro test_offsets_thumb size
.thumb
offset_sequence thumb, \size, 0
offset_sequence thumb, \size, 2
offset_sequence thumb, \size, 4
offset_sequence thumb, \size, 6
offset_sequence thumb, \size, 8
offset_sequence thumb, \size, 10
offset_sequence thumb, \size, 12
offset_sequence thumb, \size, 14
.endm
.macro test_sequence size
.bundle_lock
adds r0, r1
.rept \size - 1
subs r0, r1
.endr
.bundle_unlock
.endm
test_offsets_arm 1
test_offsets_arm 2
test_offsets_arm 3
test_offsets_arm 4
test_offsets_thumb 1
test_offsets_thumb 2
test_offsets_thumb 3
test_offsets_thumb 4
test_offsets_thumb 5
test_offsets_thumb 6
test_offsets_thumb 7
test_offsets_thumb 8
.arm
.p2align 4
bkpt
|
stsp/binutils-ia16
| 1,482
|
gas/testsuite/gas/arm/branch-reloc.s
|
@ Check that non-local branches with and without mode switching
@ produce the right relocations with appropriate in-place addends.
.syntax unified
.text
.arm
.global arm_glob_sym1
.global arm_glob_sym2
.global thumb_glob_sym1
.global thumb_glob_sym2
nop
.type arm_glob_sym1, %function
arm_glob_sym1:
bl thumb_glob_sym1
bl thumb_glob_sym2
bl thumb_sym1
bl arm_glob_sym1
bl arm_glob_sym2
bl arm_sym1
blx thumb_glob_sym1
blx thumb_glob_sym2
blx thumb_sym1
blx arm_glob_sym1
blx arm_glob_sym2
blx arm_sym1
nop
bx lr
.type arm_sym1, %function
arm_sym1:
nop
bx lr
.thumb
.thumb_func
.type thumb_sym1, %function
thumb_sym1:
bx lr
.type thumb_glob_sym1, %function
.thumb_func
.thumb
thumb_glob_sym1:
bx lr
.section foo,"ax"
@ Add some space to avoid confusing objdump output: as we are
@ producing a relocatable file, objdump may match an address to
@ the wrong symbol (as symbols in different sections may have the same
@ address in the object file).
.space 0x100
.type thumb_glob_sym2, %function
.thumb_func
.thumb
thumb_glob_sym2:
bl arm_glob_sym1
bl arm_glob_sym2
bl arm_sym2
bl thumb_glob_sym1
bl thumb_glob_sym2
bl thumb_sym2
blx arm_glob_sym1
blx arm_glob_sym2
blx arm_sym2
blx thumb_glob_sym1
blx thumb_glob_sym2
blx thumb_sym2
nop
bx lr
.type thumb_sym2, %function
thumb_sym2:
nop
bx lr
.arm
.type arm_sym2, %function
arm_sym2:
bx lr
.global arm_glob_sym2
.type arm_glob_sym2, %function
arm_glob_sym2:
bx lr
|
stsp/binutils-ia16
| 5,726
|
gas/testsuite/gas/arm/vfp1xD_t2.s
|
@ VFP Instructions for v1xD variants (Single precision only)
@ Same as vfp1xD.s, but for Thumb-2
.syntax unified
.thumb
.text
.global F
F:
@ First we test the basic syntax and bit patterns of the opcodes.
@ Most of these tests deliberately use s0/r0 to avoid setting
@ any more bits than necessary.
@ Comparison operations
fmstat
fcmpes s0, s0
fcmpezs s0
fcmps s0, s0
fcmpzs s0
@ Monadic data operations
fabss s0, s0
fcpys s0, s0
fnegs s0, s0
fsqrts s0, s0
@ Dyadic data operations
fadds s0, s0, s0
fdivs s0, s0, s0
fmacs s0, s0, s0
fmscs s0, s0, s0
fmuls s0, s0, s0
fnmacs s0, s0, s0
fnmscs s0, s0, s0
fnmuls s0, s0, s0
fsubs s0, s0, s0
@ Load/store operations
flds s0, [r0]
fsts s0, [r0]
@ Load/store multiple operations
fldmias r0, {s0}
fldmfds r0, {s0}
fldmias r0!, {s0}
fldmfds r0!, {s0}
fldmdbs r0!, {s0}
fldmeas r0!, {s0}
fldmiax r0, {d0}
fldmfdx r0, {d0}
fldmiax r0!, {d0}
fldmfdx r0!, {d0}
fldmdbx r0!, {d0}
fldmeax r0!, {d0}
fstmias r0, {s0}
fstmeas r0, {s0}
fstmias r0!, {s0}
fstmeas r0!, {s0}
fstmdbs r0!, {s0}
fstmfds r0!, {s0}
fstmiax r0, {d0}
fstmeax r0, {d0}
fstmiax r0!, {d0}
fstmeax r0!, {d0}
fstmdbx r0!, {d0}
fstmfdx r0!, {d0}
@ Conversion operations
fsitos s0, s0
fuitos s0, s0
ftosis s0, s0
ftosizs s0, s0
ftouis s0, s0
ftouizs s0, s0
@ ARM from VFP operations
fmrs r0, s0
fmrx r0, fpsid
fmrx r0, fpscr
fmrx r0, fpexc
@ VFP From ARM operations
fmsr s0, r0
fmxr fpsid, r0
fmxr fpscr, r0
fmxr fpexc, r0
@ Now we test that the register fields are updated correctly for
@ each class of instruction.
@ Single register operations (compare-zero):
fcmpzs s1
fcmpzs s2
fcmpzs s31
@ Two register comparison operations:
fcmps s0, s1
fcmps s0, s2
fcmps s0, s31
fcmps s1, s0
fcmps s2, s0
fcmps s31, s0
fcmps s21, s12
@ Two register data operations (monadic)
fnegs s0, s1
fnegs s0, s2
fnegs s0, s31
fnegs s1, s0
fnegs s2, s0
fnegs s31, s0
fnegs s12, s21
@ Three register data operations (dyadic)
fadds s0, s0, s1
fadds s0, s0, s2
fadds s0, s0, s31
fadds s0, s1, s0
fadds s0, s2, s0
fadds s0, s31, s0
fadds s1, s0, s0
fadds s2, s0, s0
fadds s31, s0, s0
fadds s12, s21, s5
@ Conversion operations
fsitos s0, s1
fsitos s0, s2
fsitos s0, s31
fsitos s1, s0
fsitos s2, s0
fsitos s31, s0
ftosis s0, s1
ftosis s0, s2
ftosis s0, s31
ftosis s1, s0
ftosis s2, s0
ftosis s31, s0
@ Move to VFP from ARM
fmsr s0, r1
fmsr s0, r7
fmsr s0, r14
fmsr s1, r0
fmsr s2, r0
fmsr s31, r0
fmsr s21, r7
fmxr fpsid, r1
fmxr fpsid, r14
@ Move to ARM from VFP
fmrs r0, s1
fmrs r0, s2
fmrs r0, s31
fmrs r1, s0
fmrs r7, s0
fmrs r14, s0
fmrs r9, s11
fmrx r1, fpsid
fmrx r14, fpsid
@ Load/store operations
flds s0, [r1]
flds s0, [r14]
flds s0, [r0, #0]
flds s0, [r0, #1020]
flds s0, [r0, #-1020]
flds s1, [r0]
flds s2, [r0]
flds s31, [r0]
fsts s21, [r12, #804]
@ Load/store multiple operations
fldmias r0, {s1}
fldmias r0, {s2}
fldmias r0, {s31}
fldmias r0, {s0-s1}
fldmias r0, {s0-s2}
fldmias r0, {s0-s31}
fldmias r0, {s1-s31}
fldmias r0, {s2-s31}
fldmias r0, {s30-s31}
fldmias r1, {s0}
fldmias r14, {s0}
fstmiax r0, {d1}
fstmiax r0, {d2}
fstmiax r0, {d15}
fstmiax r0, {d0-d1}
fstmiax r0, {d0-d2}
fstmiax r0, {d0-d15}
fstmiax r0, {d1-d15}
fstmiax r0, {d2-d15}
fstmiax r0, {d14-d15}
fstmiax r1, {d0}
fstmiax r14, {d0}
@ Check that we assemble all the register names correctly
fcmpzs s0
fcmpzs s1
fcmpzs s2
fcmpzs s3
fcmpzs s4
fcmpzs s5
fcmpzs s6
fcmpzs s7
fcmpzs s8
fcmpzs s9
fcmpzs s10
fcmpzs s11
fcmpzs s12
fcmpzs s13
fcmpzs s14
fcmpzs s15
fcmpzs s16
fcmpzs s17
fcmpzs s18
fcmpzs s19
fcmpzs s20
fcmpzs s21
fcmpzs s22
fcmpzs s23
fcmpzs s24
fcmpzs s25
fcmpzs s26
fcmpzs s27
fcmpzs s28
fcmpzs s29
fcmpzs s30
fcmpzs s31
@ Now we check the placement of the conditional execution substring.
@ On VFP this is always at the end of the instruction.
@ We use different register numbers here to check for correct
@ disassembly
@ Comparison operations
itttt eq
fmstateq
fcmpeseq s3, s7
fcmpezseq s5
fcmpseq s1, s2
itttt eq
fcmpzseq s1
@ Monadic data operations
fabsseq s1, s3
fcpyseq s31, s19
fnegseq s20, s8
itttt eq
fsqrtseq s5, s7
@ Dyadic data operations
faddseq s6, s5, s4
fdivseq s3, s2, s1
fmacseq s31, s30, s29
itttt eq
fmscseq s28, s27, s26
fmulseq s25, s24, s23
fnmacseq s22, s21, s20
fnmscseq s19, s18, s17
itttt eq
fnmulseq s16, s15, s14
fsubseq s13, s12, s11
@ Load/store operations
fldseq s10, [r8]
fstseq s9, [r7]
@ Load/store multiple operations
itttt eq
fldmiaseq r1, {s8}
fldmfdseq r2, {s7}
fldmiaseq r3!, {s6}
fldmfdseq r4!, {s5}
itttt eq
fldmdbseq r5!, {s4}
fldmeaseq r6!, {s3}
fldmiaxeq r7, {d1}
fldmfdxeq r8, {d2}
itttt eq
fldmiaxeq r9!, {d3}
fldmfdxeq r10!, {d4}
fldmdbxeq r11!, {d5}
fldmeaxeq r12!, {d6}
itttt eq
fstmiaseq r13, {s2}
fstmeaseq r14, {s1}
fstmiaseq r1!, {s31}
fstmeaseq r2!, {s30}
itttt eq
fstmdbseq r3!, {s29}
fstmfdseq r4!, {s28}
fstmiaxeq r5, {d7}
fstmeaxeq r6, {d8}
itttt eq
fstmiaxeq r7!, {d9}
fstmeaxeq r8!, {d10}
fstmdbxeq r9!, {d11}
fstmfdxeq r10!, {d12}
@ Conversion operations
itttt eq
fsitoseq s27, s6
ftosiseq s25, s5
ftosizseq s23, s4
ftouiseq s21, s3
itttt eq
ftouizseq s19, s2
fuitoseq s17, s1
@ ARM from VFP operations
fmrseq r11, s3
fmrxeq r9, fpsid
@ VFP From ARM operations
itt eq
fmsreq s3, r9
fmxreq fpsid, r8
@ Implementation specific system registers
fmrx r0, fpinst
fmrx r0, fpinst2
fmrx r0, mvfr0
fmrx r0, mvfr1
fmrx r0, c12
fmxr fpinst, r0
fmxr fpinst2, r0
fmxr mvfr0, r0
fmxr mvfr1, r0
fmxr c12, r0
nop
nop
nop
nop
nop
nop
|
stsp/binutils-ia16
| 2,779
|
gas/testsuite/gas/arm/vldconst.s
|
@ Test file for ARM/GAS -- vldr reg, =... expressions.
.fpu neon
.text
.align
foo:
# test both low and high index of the
# Advanced SIMD and Floating-point reg.
.macro vlxr regtype const
.irp regindex, 0, 14, 28, 31
vldr \regtype\regindex, \const
.endr
.endm
.macro vlxreq regtype const
.irp regindex, 0, 14, 28, 31
vldreq \regtype\regindex, \const
.endr
.endm
.macro vlxrmi regtype const
.irp regindex, 0, 14, 28, 31
vldrmi \regtype\regindex, \const
.endr
.endm
vlxr s "=0"
vlxr s "=0xff000000"
vlxr s "=-1"
vlxr s "=0x0fff0000"
.pool
vlxr s "=0"
vlxr s "=0x00ff0000"
vlxr s "=0xff00ffff"
vlxr s "=0x00fff000"
.pool
vlxreq s "=0"
vlxreq s "=0x0000ff00"
vlxreq s "=0xffff00ff"
vlxreq s "=0x000fff00"
.pool
vlxrmi s "=0"
vlxrmi s "=0x000000ff"
vlxrmi s "=0xffffff00"
vlxrmi s "=0x0000fff0"
.pool
vlxr d "=0"
vlxr d "=0xca000000"
vlxr d "=-1"
vlxr d "=0x0fff0000"
.pool
vlxr d "=0"
vlxr d "=0x00ff0000"
vlxr d "=0xff0000ff"
vlxr d "=0x00fff000"
.pool
vlxreq d "=0"
vlxreq d "=0x0000ff00"
vlxreq d "=0xffff00ff"
vlxreq d "=0x000fff00"
.pool
vlxrmi d "=0"
vlxrmi d "=0x000000ff"
vlxrmi d "=0xffffff00"
vlxrmi d "=0x0000ffff"
.pool
vlxr d "=0"
vlxr d "=0xff00000000000000"
vlxr d "=-1"
vlxr d "=0x0fff000000000000"
.pool
vlxr d "=0"
vlxr d "=0x00ff00000000000"
vlxr d "=0xff00ffff0000000"
vlxr d "=0x00fff0000000000"
.pool
vlxreq d "=0"
vlxreq d "=0x0000ff0000000000"
vlxreq d "=0xffff00ff00000000"
vlxreq d "=0x000fff0000000000"
.pool
vlxrmi d "=0"
vlxrmi d "=0x000000ff00000000"
vlxrmi d "=0xffffff0000000000"
vlxrmi d "=0x0000fff000000000"
.pool
# pool should be aligned to 8-byte.
.p2align 3
vldr d1, =0x0000fff000000000
.pool
# no error when code is align already.
.p2align 3
add r0, r1, #0
vldr d1, =0x0000fff000000000
.pool
.p2align 3
vldr d1, =0x0000fff000000000
vldr s2, =0xff000000
# padding A
vldr d3, =0x0000fff000000001
# reuse padding slot A
vldr s4, =0xff000001
# reuse d3
vldr d5, =0x0000fff000000001
# new 8-byte entry
vldr d6, =0x0000fff000000002
# new 8-byte entry
vldr d7, =0x0000fff000000003
# new 4-byte entry
vldr s8, =0xff000002
# padding B
vldr d9, =0x0000fff000000004
# reuse padding slot B
vldr s10, =0xff000003
# new 8-byte entry
vldr d11, =0x0000fff000000005
# new 4 entry
vldr s12, =0xff000004
# new 4 entry
vldr s13, =0xff000005
# reuse value of s4 in pool
vldr s14, =0xff000001
# reuse high part of d1 in pool
vldr s15, =0x0000fff0
# 8-byte entry reuse two 4-byte entries.
# this reuse should only happen for
# little-endian
# d16 reuse s12, s13
vldr d16, =0xff000005ff000004
# d17 should not reuse high part of d11 and s12.
# because the it's align 8-byte aligned.
vldr d17, =0xff0000040000fff0
.pool
|
stsp/binutils-ia16
| 3,155
|
gas/testsuite/gas/arm/mve-vldr-bad-3.s
|
.macro cond mnem
.irp cond, eq, ne, gt, ge, lt, le
it \cond
\mnem\().u32 q0, [r0]
.endr
.endm
.syntax unified
.thumb
vldrb.8 q0, [r0, #128]
vldrb.8 q0, [r0, #-128]
vldrb.u16 q0, [r0, #128]
vldrb.u16 q0, [r0, #-128]
vldrb.u32 q0, [r0, #128]
vldrb.u32 q0, [r0, #-128]
vldrb.8 q0, [r0, #128]!
vldrb.8 q0, [r0, #-128]!
vldrb.u16 q0, [r0, #128]!
vldrb.u16 q0, [r0, #-128]!
vldrb.u32 q0, [r0, #128]!
vldrb.u32 q0, [r0, #-128]!
vldrb.8 q0, [r0], #128
vldrb.8 q0, [r0], #-128
vldrb.u16 q0, [r0], #128
vldrb.u16 q0, [r0], #-128
vldrb.u32 q0, [r0], #128
vldrb.u32 q0, [r0], #-128
vldrb.u16 q0, [r10, #2]
vldrb.u16 q0, [r10, #2]!
vldrb.u16 q0, [r10], #2
vldrb.8 q0, [sp, #2]!
vldrb.8 q0, [sp], #2
vldrb.8 q0, [pc, #2]
cond vldrb
vldrb.16 q0, [r0]
vldrb.f16 q0, [r0]
vldrb.p16 q0, [r0]
vldrb.32 q0, [r0]
vldrb.f32 q0, [r0]
vldrh.16 q0, [r0, #1]
vldrh.16 q0, [r0, #17]
vldrh.16 q0, [r0, #-17]
vldrh.16 q0, [r0, #256]
vldrh.16 q0, [r0, #-256]
vldrh.u32 q0, [r0, #1]
vldrh.u32 q0, [r0, #17]
vldrh.u32 q0, [r0, #-17]
vldrh.u32 q0, [r0, #256]
vldrh.u32 q0, [r0, #-256]
vldrh.16 q0, [r0, #1]!
vldrh.16 q0, [r0, #17]!
vldrh.16 q0, [r0, #-17]!
vldrh.16 q0, [r0, #256]!
vldrh.16 q0, [r0, #-256]!
vldrh.s32 q0, [r0, #1]!
vldrh.s32 q0, [r0, #17]!
vldrh.s32 q0, [r0, #-17]!
vldrh.s32 q0, [r0, #256]!
vldrh.s32 q0, [r0, #-256]!
vldrh.16 q0, [r0], #1
vldrh.16 q0, [r0], #17
vldrh.16 q0, [r0], #-17
vldrh.16 q0, [r0], #256
vldrh.16 q0, [r0], #-256
vldrh.u32 q0, [r0], #1
vldrh.u32 q0, [r0], #17
vldrh.u32 q0, [r0], #-17
vldrh.u32 q0, [r0], #256
vldrh.u32 q0, [r0], #-256
vldrh.u32 q0, [r10, #4]
vldrh.16 q0, [sp, #2]!
vldrh.16 q0, [sp], #2
vldrh.16 q0, [pc, #2]
cond vldrh
vldrh.8 q0, [r0]
vldrh.u8 q0, [r0]
vldrh.s8 q0, [r0]
vldrh.p8 q0, [r0]
vldrh.32 q0, [r0]
vldrh.f32 q0, [r0]
vldrw.32 q0, [r0, #3]
vldrw.32 q0, [r0, #-3]
vldrw.32 q0, [r0, #514]
vldrw.32 q0, [r0, #-258]
vldrw.32 q0, [r0, #258]
vldrw.32 q0, [r0, #516]
vldrw.32 q0, [r0, #-516]
vldrw.32 q0, [r0, #3]!
vldrw.32 q0, [r0, #-3]!
vldrw.32 q0, [r0, #514]!
vldrw.32 q0, [r0, #-258]!
vldrw.32 q0, [r0, #258]!
vldrw.32 q0, [r0, #516]!
vldrw.32 q0, [r0, #-516]!
vldrw.32 q0, [r0], #3
vldrw.32 q0, [r0], #-3
vldrw.32 q0, [r0], #514
vldrw.32 q0, [r0], #-258
vldrw.32 q0, [r0], #258
vldrw.32 q0, [r0], #516
vldrw.32 q0, [r0], #-516
vldrw.32 q0, [sp, #4]!
vldrw.32 q0, [pc, #4]
cond vldrw
vldrw.8 q0, [r0]
vldrw.u8 q0, [r0]
vldrw.s8 q0, [r0]
vldrw.p8 q0, [r0]
vldrw.16 q0, [r0]
vldrw.u16 q0, [r0]
vldrw.s16 q0, [r0]
vldrw.f16 q0, [r0]
vldrw.p16 q0, [r0]
it eq
vldrbeq.8 q0, [r0]
vldrbeq.8 q0, [r0]
vpst
vldrbeq.8 q0, [r0]
vldrbt.8 q0, [r0]
vpst
vldrb.8 q0, [r0]
it eq
vldrheq.16 q0, [r0]
vldrheq.16 q0, [r0]
vpst
vldrheq.16 q0, [r0]
vldrht.16 q0, [r0]
vpst
vldrh.16 q0, [r0]
it eq
vldrweq.32 q0, [r0]
vldrweq.32 q0, [r0]
vpst
vldrweq.32 q0, [r0]
vldrwt.32 q0, [r0]
vpst
vldrw.32 q0, [r0]
.irp op1, 16, 32, 64, f16, f32, f64, p16, p32, p64, s8
vldrb.\op1 q0, [r2, q3]
.endr
.irp op1, 8, 32, 64, f32, f64, p32, p64, s16
vldrh.\op1 q0, [r2, q3, uxtw #1]
.endr
.irp op1, 8, 16, 64, f16, f64, p16, p64, s32
vldrw.\op1 q0, [r2, q3, uxtw #2]
.endr
.irp op1, 8, 16, 32, f16, f32, p16, p32, s64
vldrd.\op1 q0, [r2, q3, uxtw #3]
.endr
|
stsp/binutils-ia16
| 1,822
|
gas/testsuite/gas/arm/thumb2_ldmstm.s
|
.syntax unified
.thumb
ldmstm:
ldmia sp!, {r0}
ldmia sp!, {r8}
ldmia r1, {r9}
ldmia r2!, {ip}
ldmdb sp!, {r2}
ldmdb sp!, {r8}
ldmdb r6, {r4}
ldmdb r6, {r8}
ldmdb r2!, {r4}
ldmdb r2!, {ip}
stmia sp!, {r3}
stmia sp!, {r9}
stmia r3, {ip}
stmia r4!, {ip}
stmdb sp!, {r3}
stmdb sp!, {r9}
stmdb r7, {r5}
stmdb r6, {ip}
stmdb r6!, {fp}
stmdb r5!, {r8}
@ Valid Thumb-2 encodings of LDM/LDMIA/LDMFD as specified by section
@ A8.6.53 of the ARM ARM
ldmia r0!, {r1-r3} @ Encoding T1
ldmia r0, {r0-r3} @ Encoding T1
ldmia r0!, {r1} @ Encoding T1
ldmia r0, {r8-r11} @ Encoding T2
ldmia.w r0!, {r1-r3} @ Encoding T2
ldmia r0!, {r8-r11} @ Encoding T2
ldmia r0!, {r12, r14} @ Encoding T2
ldmia r0!, {r12, pc} @ Encoding T2
it eq
ldmiaeq r0!, {r12, pc} @ Encoding T2
@ Valid Thumb-2 encodings of STM/STMIA/STMEA as specified by section
@ A8.6.189 of the ARMARM.
stmia r0!, {r0-r3} @ Encoding T1, Allowed as r0 is lowest reg
stmia r0!, {r4-r7} @ Encoding T1
stmia.w r0!, {r4-r7} @ Encoding T2
stmia r0!, {r8-r11} @ Encoding T2
stmia r0, {r0-r3} @ Encoding T2
stmia r0, {r8-r11} @ Encoding T2
@ The following are technically UNPREDICTABLE if we assemble them
@ as written, but gas translates (stm|ldm) rn(!), {rd} into an
@ equivalent, and well-defined, (ldr, str) rd, [rn], (#4).
ldmia.w r0!, {r1} @ ldr.w r1, [r0], #4
ldmia.w r0, {r1} @ ldr.w r1, [r0]
ldmia r8!, {r9} @ ldr.w r9, [r8], #4
ldmia r8, {r9} @ ldr.w r9, [r8]
stmia.w r0!, {r1} @ str.w r1, [r0], #4
stmia r0, {r1} @ T1 str r1, [r0]
ldmia r1, {r2} @ T1 ldr r2, [r1]
ldmia r0, {r7} @ T1 ldr r7, [r0]
stmia sp, {r7} @ T1 str r7, [sp]
stmia sp, {r0} @ T1 str r0, [sp]
ldmia sp, {r7} @ T1 ldr r7, [sp]
ldmia sp, {r0} @ T1 ldr r0, [sp]
stmia r8!, {r9} @ str.w r9, [r8], #4
stmia r8, {r9} @ str.w r9, [r8]
|
stsp/binutils-ia16
| 1,694
|
gas/testsuite/gas/arm/attr-names.s
|
.eabi_attribute Tag_CPU_raw_name, "random-cpu"
.eabi_attribute Tag_CPU_name, "cpu"
.eabi_attribute Tag_CPU_arch, 1
.eabi_attribute Tag_CPU_arch_profile, 'S'
.eabi_attribute Tag_ARM_ISA_use, 1
.eabi_attribute Tag_THUMB_ISA_use, 1
.eabi_attribute Tag_FP_arch, 1
.eabi_attribute Tag_VFP_arch, 1
.eabi_attribute Tag_WMMX_arch, 1
.eabi_attribute Tag_Advanced_SIMD_arch, 1
.eabi_attribute Tag_PCS_config, 1
.eabi_attribute Tag_ABI_PCS_R9_use, 1
.eabi_attribute Tag_ABI_PCS_RW_data, 1
.eabi_attribute Tag_ABI_PCS_RO_data, 1
.eabi_attribute Tag_ABI_PCS_GOT_use, 1
.eabi_attribute Tag_ABI_PCS_wchar_t, 2
.eabi_attribute Tag_ABI_FP_rounding, 1
.eabi_attribute Tag_ABI_FP_denormal, 1
.eabi_attribute Tag_ABI_FP_exceptions, 1
.eabi_attribute Tag_ABI_FP_user_exceptions, 1
.eabi_attribute Tag_ABI_FP_number_model, 1
.eabi_attribute Tag_ABI_align_needed, 1
.eabi_attribute Tag_ABI_align8_needed, 1
.eabi_attribute Tag_ABI_align_preserved, 1
.eabi_attribute Tag_ABI_align8_preserved, 1
.eabi_attribute Tag_ABI_enum_size, 1
.eabi_attribute Tag_ABI_HardFP_use, 1
.eabi_attribute Tag_ABI_VFP_args, 1
.eabi_attribute Tag_ABI_WMMX_args, 1
.eabi_attribute Tag_ABI_optimization_goals, 1
.eabi_attribute Tag_ABI_FP_optimization_goals, 1
.eabi_attribute Tag_compatibility, 1, "gnu"
.eabi_attribute Tag_CPU_unaligned_access, 1
.eabi_attribute Tag_FP_HP_extension, 1
.eabi_attribute Tag_VFP_HP_extension, 1
.eabi_attribute Tag_ABI_FP_16bit_format, 1
.eabi_attribute Tag_MPextension_use, 1
.eabi_attribute Tag_DIV_use, 1
.eabi_attribute Tag_nodefaults, 0
.eabi_attribute Tag_also_compatible_with, "\06\013"
.eabi_attribute Tag_conformance, "2.08"
.eabi_attribute Tag_T2EE_use, 1
.eabi_attribute Tag_Virtualization_use, 3
|
stsp/binutils-ia16
| 1,173
|
gas/testsuite/gas/arm/thumb2_ldmstm_bad.s
|
.syntax unified
.thumb
ldmstm_bad:
@ UNPREDICTABLE Thumb-2 encodings of LDM/LDMIA/LDMFD as specified
@ by section A8.6.53 of the ARMARM.
ldmia r15, {r0-r3} @ Encoding T2, UNPREDICTABLE
ldmia r15!, {r0-r3} @ Encoding T2, UNPREDICTABLE
ldmia r1, {r14, r15} @ Encoding T2, UNPREDICTABLE
ldmia r0!, {r0-r3} @ Encoding T2, UNPREDICTABLE
itt eq
ldmiaeq r0, {r12, r15} @ Encoding T2, UNPREDICTABLE
ldmiaeq r0!, {r0, r1} @ Encoding T2, UNPREDICTABLE
@ UNPREDICTABLE Thumb-2 encodings of STM/STMIA/STMEA as specified
@ by section A8.6.189 of the ARMARM.
stmia.w r0!, {r0-r3} @ Encoding T2, UNPREDICTABLE
stmia r1!, {r0-r3} @ Encoding T1, r1 is UNKNOWN
stmia r15!, {r0-r3} @ Encoding T2, UNPREDICTABLE
stmia r15, {r0-r3} @ Encoding T2, UNPREDICTABLE
stmia r8!, {r0-r11} @ Encoding T2, UNPREDICTABLE
@ The following are technically UNDEFINED, but gas converts them to
@ an equivalent, and well-defined instruction automatically.
@stmia.w r0!, {r1} @ str.w r1, [r0], #4
@stmia r8!, {r9} @ str.w r9, [r8], #4
@stmia r8, {r9} @ str.w r9, [r8]
@ldmia.w r0!, {r1} @ ldr.w r1, [r0], #4
@ldmia r8!, {r9} @ ldr.w r9, [r8], #4
@ldmia r8, {r9} @ ldr.w r9, [r8]
|
stsp/binutils-ia16
| 1,520
|
gas/testsuite/gas/arm/arm-it-auto.s
|
.syntax unified
.arch armv7
.thumb
main:
@These branches are to see the labels in the generated file
bl .L888
bl .L111
bl .L777
@No IT block here:
bne .L4
@The following groups should be an IT block each.
@it ne
addne.n pc, r0
@it ne
tbbne [r0, r1]
@it eq
tbheq [r1, r0]
@The following group should be left as is:
itet eq
.L111: moveq r0, #2
movne r0, #3
moveq r0, #4
@Same, reverted condition:
itet ne
movne r0, #2
moveq r0, #3
movne r0, #4
@Two groups shall be generated, due to the label:
movne r0, #1
@ second group, the label should be at the IT insn
.L777: moveq r0, #2
ldrne pc, [r1]
@it ne
blne .L4
@it lt
bllt .L9
@itett ne
.L888: movne r0, #45
moveq r0, #5
movne r0, #6
addne.n pc, r0
@iteet eq
moveq r0, #7
movne r0, #8
movne r0, #3
moveq r0, #4
@itete eq
moveq r0, #5
movne r0, #6
moveq r0, #7
movne r0, #8
@ite eq - this group finishes due to the mov.n pc, rn
moveq r0, #5
movne r0, #6
mov.n pc, r0
@itete eq
moveq r0, #7
movne r0, #8
moveq r0, #5
movne r0, #6
@this shall not generate an IT block
add.n pc, r0
@ite eq - testing condition change (eq -> gt)
moveq r0, #7
movne r0, #8
@ite gt (group shall finish due to another condition change)
movgt r0, #9
movle r0, #10
@it eq
moveq r0, #11
@it le
movle r0, #12
@it ne
movne r0, #13
bl f
.L4:
pop {r4, pc}
.L9:
bl f
@Only the movlt shall be enclosed in the IT block
movlt r0, #0
muls r0, r0, r1
@Same here:
movlt r0, #0
muls r0, r0, r1
|
stsp/binutils-ia16
| 1,334
|
gas/testsuite/gas/arm/mve-vmlsldav-bad.s
|
.macro cond, op
.irp cond, eq, ne, gt, ge, lt, le
it \cond
\op\().s16 r0, r1, q1, q2
.endr
.endm
.syntax unified
.thumb
vmlsldav.s16 r0, sp, q1, q2
vmlsldav.u16 r0, r1, q1, q2
cond vmlsldav
cond vmlsldava
cond vmlsldavx
cond vmlsldavax
vmlsldav.s64 r0, r1, q1, q2
vmlsldav.f32 r0, r1, q1, q2
vmlsldav.s8 r0, r1, q1, q2
vmlsldav.s16 r0, q1, q2
vmlsldava.s64 r0, r1, q1, q2
vmlsldava.f32 r0, r1, q1, q2
vmlsldava.s8 r0, r1, q1, q2
vmlsldava.s16 r0, q1, q2
vmlsldavx.s64 r0, r1, q1, q2
vmlsldavx.f32 r0, r1, q1, q2
vmlsldavx.s8 r0, r1, q1, q2
vmlsldavx.s16 r0, q1, q2
vmlsldavax.s64 r0, r1, q1, q2
vmlsldavax.f32 r0, r1, q1, q2
vmlsldavax.s8 r0, r1, q1, q2
vmlsldavax.s16 r0, q1, q2
it eq
vmlsldaveq.s16 r0, r1, q1, q2
vmlsldaveq.s16 r0, r1, q1, q2
vmlsldaveq.s16 r0, r1, q1, q2
vmlsldavt.s16 r0, r1, q1, q2
vpst
vmlsldav.s16 r0, r1, q1, q2
it eq
vmlsldavaeq.s16 r0, r1, q1, q2
vmlsldavaeq.s16 r0, r1, q1, q2
vmlsldavaeq.s16 r0, r1, q1, q2
vmlsldavat.s16 r0, r1, q1, q2
vpst
vmlsldava.s16 r0, r1, q1, q2
it eq
vmlsldavxeq.s16 r0, r1, q1, q2
vmlsldavxeq.s16 r0, r1, q1, q2
vmlsldavxeq.s16 r0, r1, q1, q2
vmlsldavxt.s16 r0, r1, q1, q2
vpst
vmlsldavx.s16 r0, r1, q1, q2
it eq
vmlsldavaxeq.s16 r0, r1, q1, q2
vmlsldavaxeq.s16 r0, r1, q1, q2
vmlsldavaxeq.s16 r0, r1, q1, q2
vmlsldavaxt.s16 r0, r1, q1, q2
vpst
vmlsldavax.s16 r0, r1, q1, q2
|
stsp/binutils-ia16
| 1,206
|
gas/testsuite/gas/arm/archv6t2.s
|
.text
x:
bfi r0, r0, #0, #1
bfine r0, r0, #0, #1
bfi r9, r0, #0, #1
bfi r0, r9, #0, #1
bfi r0, r0, #0, #18
bfi r0, r0, #17, #1
bfi r0, #0, #0, #1
bfc r0, #0, #1
bfcne r0, #0, #1
bfc r9, #0, #1
bfc r0, #0, #18
bfc r0, #17, #1
sbfx r0, r0, #0, #1
sbfxne r0, r0, #0, #1
ubfx r0, r0, #0, #1
sbfx r9, r0, #0, #1
sbfx r0, r9, #0, #1
sbfx r0, r0, #17, #1
sbfx r0, r0, #0, #18
rbit r0, r0
rbitne r0, r0
rbit r9, r0
rbit r0, r9
mls r0, r0, r0, r0
mlsne r0, r0, r0, r0
mls r9, r0, r0, r0
mls r0, r9, r0, r0
mls r0, r0, r9, r0
mls r0, r0, r0, r9
movw r0, #0
movt r0, #0
movwne r0, #0
movw r9, #0
movw r0, #0x0999
movw r0, #0x9000
@ for these, we must avoid write-back warnings
ldrht r0, [r9]
ldrsht r0, [r9]
ldrsbt r0, [r9]
strht r0, [r9]
ldrneht r0, [r9]
ldrht r9, [r0], r9
ldrht r9, [r0], -r9
ldrht r9, [r0], #0x99
ldrht r9, [r0], #-0x99
ldrneht r9, [r0], r9
ldrneht r9, [r0], -r9
ldrneht r9, [r0], #0x99
ldrneht r9, [r0], #-0x99
strht r0, [r1], -r2
strneht r0, [r1], -r2
strht r0, [r1], r2
strneht r0, [r1], r2
strht r0, [r1], #2
strht r0, [r1], #-2
strneht r0, [r1], #2
strneht r0, [r1], #-2
@ mov accept A2 encoding as well.
mov r9, #0x0999
|
stsp/binutils-ia16
| 1,394
|
gas/testsuite/gas/arm/mve-vqrshrn-bad.s
|
.macro cond op
.irp cond, eq, ne, gt, ge, lt, le
it \cond
\op\().s16 q0, q0, #1
.endr
.endm
.syntax unified
.thumb
vqrshrnt.s8 q0, q1, #1
vqrshrnt.s64 q0, q1, #1
vqrshrnt.s16 q0, q1, #0
vqrshrnt.s16 q0, q1, #9
vqrshrnt.s32 q0, q1, #0
vqrshrnt.s32 q0, q1, #17
vqrshrnb.s8 q0, q1, #1
vqrshrnb.s64 q0, q1, #1
vqrshrnb.s16 q0, q1, #0
vqrshrnb.s16 q0, q1, #9
vqrshrnb.s32 q0, q1, #0
vqrshrnb.s32 q0, q1, #17
vqrshrunt.s8 q0, q1, #1
vqrshrunt.s64 q0, q1, #1
vqrshrunt.s16 q0, q1, #0
vqrshrunt.s16 q0, q1, #9
vqrshrunt.s32 q0, q1, #0
vqrshrunt.s32 q0, q1, #17
vqrshrunt.u16 q0, q1, #1
vqrshrunb.s8 q0, q1, #1
vqrshrunb.s64 q0, q1, #1
vqrshrunb.s16 q0, q1, #0
vqrshrunb.s16 q0, q1, #9
vqrshrunb.s32 q0, q1, #0
vqrshrunb.s32 q0, q1, #17
vqrshrunb.u16 q0, q1, #1
cond vqrshrnt
cond vqrshrnb
cond vqrshrunt
cond vqrshrunb
it eq
vqrshrnteq.s16 q0, q1, #1
vqrshrnteq.s16 q0, q1, #1
vpst
vqrshrnteq.s16 q0, q1, #1
vqrshrntt.s16 q0, q1, #1
vpst
vqrshrnt.s16 q0, q1, #1
it eq
vqrshrnbeq.s16 q0, q1, #1
vqrshrnbeq.s16 q0, q1, #1
vpst
vqrshrnbeq.s16 q0, q1, #1
vqrshrnbt.s16 q0, q1, #1
vpst
vqrshrnb.s16 q0, q1, #1
it eq
vqrshrunteq.s16 q0, q1, #1
vqrshrunteq.s16 q0, q1, #1
vpst
vqrshrunteq.s16 q0, q1, #1
vqrshruntt.s16 q0, q1, #1
vpst
vqrshrunt.s16 q0, q1, #1
it eq
vqrshrunbeq.s16 q0, q1, #1
vqrshrunbeq.s16 q0, q1, #1
vpst
vqrshrunbeq.s16 q0, q1, #1
vqrshrunbt.s16 q0, q1, #1
vpst
vqrshrunb.s16 q0, q1, #1
|
stsp/binutils-ia16
| 1,038
|
gas/testsuite/gas/arm/archv8m.s
|
.thumb
.syntax unified
T:
blx r4
blx r9
bx r4
bx r9
tt r0, r1
tt r8, r9
ttt r0, r1
ttt r8, r9
movw r0, #0xF123
@ mov accept all immediate formats, including T3. It's also the suggested
@ assembly to use.
mov r8, #0xF123
@ .w means wide, specifies that the assembler must select a 32-bit encoding for
@ the instruction if it is possible, it should accept both T2 (Thumb modified
@ immediate) and T3 (UINT16) encoding. See the section "Standard assembler
@ syntax fields" on latest ARM-ARM.
mov.w r8, #0xF123
movw r8, #0xF123
movt r0, #0xF123
movt r8, #0xF123
cbz r4, .L1
cbnz r4, .L1
b.w .L1
sdiv r0, r1, r2
sdiv r8, r9, r10
udiv r0, r1, r2
udiv r8, r9, r10
.L1:
add r0, r1
clrex
ldrex r0, [r1, #0x4]
ldrexb r0, [r1]
ldrexh r0, [r1]
strex r0, r1, [r2, #0x4]
strexb r0, r1, [r2]
strexh r0, r1, [r2]
lda r0, [r1]
ldab r0, [r1]
ldah r0, [r1]
stl r0, [r1]
stlb r0, [r1]
stlh r0, [r1]
ldaex r0, [r1]
ldaexb r0, [r1]
ldaexh r0, [r1]
stlex r0, r1, [r2]
stlexb r0, r1, [r2]
stlexh r0, r1, [r2]
|
stsp/binutils-ia16
| 1,055
|
gas/testsuite/gas/arm/arch7.s
|
# ARMV7 instructions
.text
.arch armv7r
label1:
pli [r6, r8]
pli [r9, r7]
pli [r0, r1, lsl #2]
pli [r5]
pli [r5, #4095]
pli [r5, #-4095]
dbg #0
dbg #15
dmb
dmb sy
dsb
dsb sy
dsb un
dsb st
dsb unst
isb
isb sy
.thumb
.thumb_func
label2:
pli [r6, r8]
pli [r9, r7]
pli [r0, r1, lsl #2]
pli [r5]
pli [r5, #4095]
pli [r5, #-255]
pli [pc, #4095]
pli [pc, #-4095]
dbg #0
dbg #15
dmb
dmb sy
dsb
dsb sy
dsb un
dsb st
dsb unst
isb
isb sy
sdiv r6, r9, r12
sdiv r9, r6, r3
udiv r9, r6, r3
udiv r6, r9, r12
.arch armv7m
mrs r0, apsr
mrs r0, iapsr
mrs r0, eapsr
mrs r0, psr
mrs r0, ipsr
mrs r0, epsr
mrs r0, iepsr
mrs r0, msp
mrs r0, psp
mrs r0, primask
mrs r0, basepri
mrs r0, basepri_max
mrs r0, faultmask
mrs r0, control
msr apsr_nzcvq, r0
msr iapsr_nzcvq, r0
msr eapsr_nzcvq, r0
msr psr_nzcvq, r0
msr ipsr, r0
msr epsr, r0
msr iepsr, r0
msr msp, r0
msr psp, r0
msr primask, r0
msr basepri, r0
msr BASEPRI_MAX, r0
msr faultmask, r0
msr control, r0
mrs r0, xpsr
msr xpsr_nzcvq, r0
svc 0
|
stsp/binutils-ia16
| 1,687
|
gas/testsuite/gas/arm/armv8-ar+simd.s
|
.syntax unified
.arch_extension simd
.arm
vmaxnm.f32 d0, d0, d0
vmaxnm.f32 d16, d16, d16
vmaxnm.f32 d15, d15, d15
vmaxnm.f32 d31, d31, d31
vmaxnm.f32 q0, q0, q0
vmaxnm.f32 q8, q8, q8
vmaxnm.f32 q7, q7, q7
vmaxnm.f32 q15, q15, q15
vminnm.f32 d0, d0, d0
vminnm.f32 d16, d16, d16
vminnm.f32 d15, d15, d15
vminnm.f32 d31, d31, d31
vminnm.f32 q0, q0, q0
vminnm.f32 q8, q8, q8
vminnm.f32 q7, q7, q7
vminnm.f32 q15, q15, q15
vcvta.s32.f32 d0, d0
vcvtn.s32.f32 d16, d16
vcvtp.u32.f32 d15, d15
vcvtm.u32.f32 d31, d31
vcvta.s32.f32 q0, q0
vcvtn.s32.f32 q8, q8
vcvtp.u32.f32 q7, q7
vcvtm.u32.f32 q15, q15
vrinta.f32 d0, d0
vrintn.f32 d16, d16
vrintm.f32 d15, d15
vrintp.f32 d31, d31
vrintx.f32 d0, d31
vrintz.f32 d16, d15
vrinta.f32 q0, q0
vrintn.f32 q8, q8
vrintm.f32 q7, q7
vrintp.f32 q15, q15
vrintx.f32 q0, q15
vrintz.f32 q8, q7
.thumb
vmaxnm.f32 d0, d0, d0
vmaxnm.f32 d16, d16, d16
vmaxnm.f32 d15, d15, d15
vmaxnm.f32 d31, d31, d31
vmaxnm.f32 q0, q0, q0
vmaxnm.f32 q8, q8, q8
vmaxnm.f32 q7, q7, q7
vmaxnm.f32 q15, q15, q15
vminnm.f32 d0, d0, d0
vminnm.f32 d16, d16, d16
vminnm.f32 d15, d15, d15
vminnm.f32 d31, d31, d31
vminnm.f32 q0, q0, q0
vminnm.f32 q8, q8, q8
vminnm.f32 q7, q7, q7
vminnm.f32 q15, q15, q15
vcvta.s32.f32 d0, d0
vcvtn.s32.f32 d16, d16
vcvtp.u32.f32 d15, d15
vcvtm.u32.f32 d31, d31
vcvta.s32.f32 q0, q0
vcvtn.s32.f32 q8, q8
vcvtp.u32.f32 q7, q7
vcvtm.u32.f32 q15, q15
vrinta.f32 d0, d0
vrintn.f32 d16, d16
vrintm.f32 d15, d15
vrintp.f32 d31, d31
vrintx.f32 d0, d31
vrintz.f32 d16, d15
vrinta.f32 q0, q0
vrintn.f32 q8, q8
vrintm.f32 q7, q7
vrintp.f32 q15, q15
vrintx.f32 q0, q15
vrintz.f32 q8, q7
|
stsp/binutils-ia16
| 6,275
|
gas/testsuite/gas/arm/sp-pc-validations-bad.s
|
.syntax unified
@ Loads, ARM ================================================================
.arm
@ LDR (immediate, ARM)
@ LDR (literal)
@No unpredictable or undefined combinations.
@ LDR (register)
ldr r0,[r1,pc, LSL #2] @ Unpredictable
ldr r0,[r1,pc, LSL #2]! @ ditto
ldr r0,[r1],pc, LSL #2 @ ditto
ldr r0,[pc,r1, LSL #2]! @ ditto
ldr r0,[pc],r1, LSL #2 @ ditto
@ LDRB (immediate, ARM)
ldrb pc,[r0,#4] @ Unpredictable
ldrb pc,[r0],#4 @ ditto
ldrb pc,[r0,#4]! @ ditto
@ LDRB (literal)
ldrb pc, label @ Unpredictable
ldrb pc,[pc,#-0] @ ditto
@ LDRB (register)
ldrb pc,[r0,r1, LSL #2] @ Unpredictable
ldrb pc,[r0,r1, LSL #2]! @ ditto
ldrb pc,[r0],r1, LSL #2 @ ditto
ldrb r0,[r1,pc, LSL #2] @ ditto
ldrb r0,[r1,pc, LSL #2]! @ ditto
ldrb r0,[r1],pc, LSL #2 @ ditto
ldrb r0,[pc,r1, LSL #2]! @ ditto
ldrb r0,[pc],r1, LSL #2 @ ditto
@ LDRBT
ldrbt pc,[r0],#4 @ Unpredictable
ldrbt r0,[pc],#4 @ ditto
ldrbt pc,[r0],r1, LSL #4 @ ditto
ldrbt r0,[pc],r1, LSL #4 @ ditto
ldrbt r0,[r1],pc, LSL #4 @ ditto
@ LDRD (immediate)
ldrd r0,pc,[r1,#4] @ Unpredictable
ldrd r0,pc,[r1],#4 @ ditto
ldrd r0,pc,[r1,#4]! @ ditto
@ LDRD (literal)
ldrd r0,pc, label @ Unpredictable
ldrd r0,pc,[PC,#-0] @ ditto
@ LDRD (register)
ldrd r0,pc,[r1,r2] @ Unpredictable
ldrd r0,pc,[r1,r2]! @ ditto
ldrd r0,pc,[r1],r2 @ ditto
ldrd r0,r1,[r2,pc] @ ditto
ldrd r0,r1,[r2,pc]! @ ditto
ldrd r0,r1,[r2],pc @ ditto
ldrd r0,r1,[pc,r2]! @ ditto
ldrd r0,r1,[pc],r2 @ ditto
@ LDREX
ldrex pc,[r0] @ Unpredictable
ldrex r0,[pc] @ ditto
@ LDREXB
ldrexb pc,[r0] @ Unpredictable
ldrexb r0,[pc] @ ditto
@ LDREXD
ldrexd r0,r1,[pc] @ Unpredictable
@ LDREXH
ldrexh pc,[r0] @ Unpredictable
ldrexh r0,[pc] @ ditto
@ LDRH (immediate, ARM)
ldrh pc,[r0,#4] @ Unpredictable
ldrh pc,[r0],#4 @ ditto
ldrh pc,[r0,#4]! @ ditto
@ LDRH (literal)
ldrh pc, label @ Unpredictable
ldrh pc,[pc,#-0] @ ditto
@ LDRH (register)
ldrh pc,[r0,r1] @ Unpredictable
ldrh pc,[r0,r1]! @ ditto
ldrh pc,[r0],r1 @ ditto
ldrh r0,[r1,pc] @ ditto
ldrh r0,[r1,pc]! @ ditto
ldrh r0,[r1],pc @ ditto
ldrh r0,[pc,r1]! @ ditto
ldrh r0,[pc],r1 @ ditto
@ LDRHT
ldrht pc, [r0], #4 @ Unpredictable
ldrht r0, [pc], #4 @ ditto
ldrht pc, [r0], r1 @ ditto
ldrht r0, [pc], r1 @ ditto
ldrht r0, [r1], pc @ ditto
@ LDRSB (immediate)
ldrsb pc,[r0,#4] @ Unpredictable
ldrsb pc,[r0],#4 @ ditto
ldrsb pc,[r0,#4]! @ ditto
@ LDRSB (literal)
ldrsb pc, label @ Unpredictable
ldrsb pc,[pc,#-0] @ ditto
@ LDRSB (register)
ldrsb pc,[r0,r1] @ Unpredictable
ldrsb pc,[r0,r1]! @ ditto
ldrsb pc,[r0],r1 @ ditto
ldrsb r0,[r1,pc] @ ditto
ldrsb r0,[r1,pc]! @ ditto
ldrsb r0,[r1],pc @ ditto
ldrsb r0,[pc,r1]! @ ditto
ldrsb r0,[pc],r1 @ ditto
@ LDRSBT
ldrsbt pc, [r0], #4 @ Unpredictable
ldrsbt r0, [pc], #4 @ ditto
ldrsbt pc, [r0], r1 @ ditto
ldrsbt r0, [pc], r1 @ ditto
ldrsbt r0, [r1], pc @ ditto
@ LDRSH (immediate)
ldrsh pc,[r0,#4] @ Unpredictable
ldrsh pc,[r0],#4 @ ditto
ldrsh pc,[r0,#4]! @ ditto
@ LDRSH (literal)
ldrsh pc, label @ Unpredictable
ldrsh pc,[pc,#-0] @ ditto
@ LDRSH (register)
ldrsh pc,[r0,r1] @ Unpredictable
ldrsh pc,[r0,r1]! @ ditto
ldrsh pc,[r0],r1 @ ditto
ldrsh r0,[r1,pc] @ ditto
ldrsh r0,[r1,pc]! @ ditto
ldrsh r0,[r1],pc @ ditto
ldrsh r0,[pc,r1]! @ ditto
ldrsh r0,[pc],r1 @ ditto
@ LDRSHT
ldrsht pc, [r0], #4 @ Unpredictable
ldrsht r0, [pc], #4 @ ditto
ldrsht pc, [r0], r1 @ ditto
ldrsht r0, [pc], r1 @ ditto
ldrsht r0, [r1], pc @ ditto
@ LDRT
ldrt pc, [r0], #4 @ Unpredictable
ldrt r0, [pc], #4 @ ditto
ldrt pc,[r0],r1, LSL #4 @ ditto
ldrt r0,[pc],r1, LSL #4 @ ditto
ldrt r0,[r1],pc, LSL #4 @ ditto
@ Stores, ARM ================================================================
@ STR (immediate, ARM)
str r0,[pc],#4 @ Unpredictable
str r0,[pc,#4]! @ ditto
@ STR (register)
str r0,[r1,pc, LSL #4] @ Unpredictable
str r0,[r1,pc, LSL #4]! @ ditto
str r0,[r1],pc, LSL #4 @ ditto
@ STRB (immediate, ARM)
strb pc,[r0,#4] @ Unpredictable
strb pc,[r0],#4 @ ditto
strb pc,[r0,#4]! @ ditto
strb r0,[pc],#4 @ ditto
strb r0,[pc,#4]! @ ditto
@ STRB (register)
strb pc,[r0,r1, LSL #4] @ Unpredictable
strb pc,[r0,r1, LSL #4]! @ ditto
strb pc,[r0],r1, LSL #4 @ ditto
strb r1,[r0,pc, LSL #4] @ ditto
strb r1,[r0,pc, LSL #4]! @ ditto
strb r1,[r0],pc, LSL #4 @ ditto
strb r0,[pc,r1, LSL #4]! @ ditto
strb r0,[pc],r1, LSL #4 @ ditto
@ STRBT
strbt pc,[r0],#4 @ Unpredictable
strbt r0,[pc],#4 @ ditto
strbt pc,[r0],r1, LSL #4 @ ditto
strbt r0,[pc],r1, LSL #4 @ ditto
strbt r0,[r1],pc, LSL #4 @ ditto
@ STRD (immediate)
strd r0,pc,[r1,#4] @ ditto
strd r0,pc,[r1],#4 @ ditto
strd r0,pc,[r1,#4]! @ ditto
strd r0,r1,[pc],#4 @ ditto
strd r0,r1,[pc,#4]! @ ditto
@STRD (register)
strd r0,pc,[r1,r2] @ Unpredictable
strd r0,pc,[r1,r2]! @ ditto
strd r0,pc,[r1],r2 @ ditto
strd r0,r1,[r2,pc] @ ditto
strd r0,r1,[r2,pc]! @ ditto
strd r0,r1,[r2],pc @ ditto
strd r0,r1,[pc,r2]! @ ditto
strd r0,r1,[pc],r2 @ ditto
@ STREX
strex pc,r0,[r1] @ Unpredictable
strex r0,pc,[r1] @ ditto
strex r0,r1,[pc] @ ditto
@ STREXB
strexb pc,r0,[r1] @ Unpredictable
strexb r0,pc,[r1] @ ditto
strexb r0,r1,[pc] @ ditto
@ STREXD
strexd pc,r0,r1,[r2] @ Unpredictable
strexd r0,r1,r2,[pc] @ ditto
@ STREXH
strexh pc,r0,[r1] @ Unpredictable
strexh r0,pc,[r1] @ ditto
strexh r0,r1,[pc] @ ditto
@ STRH (immediate, ARM)
strh pc,[r0,#4] @ Unpredictable
strh pc,[r0],#4 @ ditto
strh pc,[r0,#4]! @ ditto
strh r0,[pc],#4 @ ditto
strh r0,[pc,#4]! @ ditto
@ STRH (register)
strh pc,[r0,r1] @ Unpredictable
strh pc,[r0,r1]! @ ditto
strh pc,[r0],r1 @ ditto
strh r0,[r1,pc] @ ditto
strh r0,[r1,pc]! @ ditto
strh r0,[r1],pc @ ditto
strh r0,[pc,r1]! @ ditto
strh r0,[pc],r1 @ ditto
@ STRHT
strht pc, [r0], #4 @ Unpredictable
strht r0, [pc], #4 @ ditto
strht pc, [r0], r1 @ ditto
strht r0, [pc], r1 @ ditto
strht r0, [r1], pc @ ditto
@ STRT
strt r0, [pc], #4 @ Unpredictable
strt r0, [pc],r1, LSL #4 @ ditto
strt r0, [r1],pc, LSL #4 @ ditto
@ ============================================================================
.label:
ldr r0, [r1]
|
stsp/binutils-ia16
| 1,892
|
gas/testsuite/gas/arm/neon-omit.s
|
@ test omitted optional arguments
.text
.arm
.syntax unified
vabd.u8 q1,q3
vhadd.s32 q14, q3
vrhadd.s32 q1,q2
vhsub.s32 q5,q7
vshl.u16 q3,q4
vqshl.u32 q5,q6
vand.64 q7,q8
veor.64 q7,q8
vceq.i16 q5,#0
vceq.i16 q5,q5
vclt.s16 q5,#0
vabs.s16 q5,q6
vneg.s16 d7,d8
vabs.f d7,d8
vneg.f q9,q10
vpmax.s32 d1,d3
vpmin.s32 d5,d7
vpmax.f32 d1,d3
vpmin.f32 d5,d7
vqdmulh.s16 q1,q3
vqrdmulh.s32 d5,d7
vqdmulh.s16 q1,d5[3]
vqadd.s16 q1,q3
vqadd.s32 d5,d7
vmla.i32 q1,q2
vpadd.i16 d3,d4
vmls.s32 q3,q4
vacge.f q1,q2
vacgt.f q3,q4
vacle.f q5,q6
vaclt.f q7,q8
vcge.u32 q7,q8
vcgt.u32 q7,q8
vcle.u32 q7,q8
vclt.u32 q7,q8
vaddw.u32 q1,d2
vsubw.s32 q3,d4
vtst.i32 q2,q3
vrecps.f d1,d2
vshr.s16 q1,#4
vrshr.s8 q2,#5
vsra.u16 q3,#6
vrsra.u16 q4,#6
vsli.16 q2,#5
vqshlu.s64 d15,#63
vext.8 d5,d6,#3
@ Also test three-argument forms without omitted arguments
vabd.u8 q1,q2,q3
vhadd.s32 q14,q9,q3
vrhadd.s32 q1,q5,q2
vhsub.s32 q5,q8,q7
vshl.u16 q3,q4,q5
vqshl.u32 q5,q6,q1
vand.64 q7,q8,q6
veor.64 q7,q8,q6
vceq.i16 q5,q3,#0
vceq.i16 q5,q3,q5
vclt.s16 q5,q3,#0
vpmax.s32 d1,d3,d16
vpmin.s32 d5,d7,d20
vpmax.f32 d1,d3,d7
vpmin.f32 d5,d12,d7
vqdmulh.s16 q1,q3,q8
vqrdmulh.s32 d5,d7,d9
vqdmulh.s16 q1,q6,d5[3]
vqadd.s16 q1,q11,q3
vqadd.s32 d5,d7,d31
vmla.i32 q1,q2,q9
vpadd.i16 d3,d26,d4
vmls.s32 q3,q4,q5
vacge.f q1,q4,q2
vacgt.f q3,q1,q4
vacle.f q5,q9,q6
vaclt.f q7,q1,q8
vcge.u32 q7,q8,q3
vcgt.u32 q7,q8,q3
vcle.u32 q7,q8,q3
vclt.u32 q7,q8,q3
vaddw.u32 q1,q5,d2
vsubw.s32 q3,q1,d4
vtst.i32 q2,q11,q3
vrecps.f d1,d30,d2
vshr.s16 q1,q13,#4
vrshr.s8 q2,q9,#5
vsra.u16 q3,q1,#6
vrsra.u16 q15,q4,#6
vsli.16 q2,q3,#5
vqshlu.s64 d15,d23,#63
vext.8 d5,d18,d6,#3
@ Also test VMOV with omitted suffix:
vmov d0[0], r0
vmov r0, d0[0]
@ PR 11136 - this used to crash the assembler.
vmul.f32 q0,q1,q2
|
stsp/binutils-ia16
| 1,295
|
gas/testsuite/gas/arm/fpv5-d16.s
|
.syntax unified
.text
.thumb
vseleq.f32 s0, s0, s0
vselvs.f32 s1, s1, s1
vselge.f32 s30, s30, s30
vselgt.f32 s31, s31, s31
vseleq.f64 d0, d0, d0
vselvs.f64 d8, d8, d8
vselge.f64 d15, d15, d15
vselgt.f64 d10, d10, d10
vmaxnm.f32 s0, s0, s0
vmaxnm.f32 s1, s1, s1
vmaxnm.f32 s30, s30, s30
vmaxnm.f32 s31, s31, s31
vmaxnm.f64 d0, d0, d0
vmaxnm.f64 d8, d8, d8
vmaxnm.f64 d15, d15, d15
vmaxnm.f64 d10, d10, d10
vminnm.f32 s0, s0, s0
vminnm.f32 s1, s1, s1
vminnm.f32 s30, s30, s30
vminnm.f32 s31, s31, s31
vminnm.f64 d0, d0, d0
vminnm.f64 d8, d8, d8
vminnm.f64 d15, d15, d15
vminnm.f64 d10, d10, d10
vcvta.s32.f32 s0, s0
vcvtn.s32.f32 s1, s1
vcvtp.u32.f32 s30, s30
vcvtm.u32.f32 s31, s31
vcvta.s32.f64 s0, d0
vcvtn.s32.f64 s1, d8
vcvtp.u32.f64 s30, d15
vcvtm.u32.f64 s31, d10
vrintz.f32 s0, s0
vrintx.f32 s1, s1
vrintr.f32 s30, s30
vrinta.f32 s0, s0
vrintn.f32 s1, s1
vrintp.f32 s30, s30
vrintm.f32 s31, s31
vrintz.f64 d0, d0
vrintx.f64 d1, d1
vrintr.f64 d10, d10
vrinta.f64 d0, d0
vrintn.f64 d1, d1
vrintp.f64 d10, d10
vrintm.f64 d10, d10
vcvtt.f16.f64 s0, d0
vcvtb.f16.f64 s1, d8
vcvtt.f16.f64 s30, d15
vcvtb.f16.f64 s31, d10
vcvtt.f64.f16 d0, s0
vcvtb.f64.f16 d8, s1
vcvtt.f64.f16 d15, s30
vcvtb.f64.f16 d10, s31
|
stsp/binutils-ia16
| 4,202
|
gas/testsuite/gas/arm/msr-imm.s
|
@ Check MSR and MRS instruction operand syntax.
@ Also check for MSR/MRS acceptance in ARM/THUMB modes.
.section .text
.syntax unified
@ Write to Special Register from Immediate
@ Write to application status register
msr APSR_nzcvq,#0xc0000004
msr APSR_g,#0xc0000004
msr APSR_nzcvq,#0xc0000004
msr APSR_nzcvqg,#0xc0000004
@ Write to CPSR flags
msr CPSR,#0xc0000004
msr CPSR_s,#0xc0000004
msr CPSR_f,#0xc0000004
msr CPSR_c,#0xc0000004
msr CPSR_x,#0xc0000004
@ Write to CPSR flag combos
msr CPSR_fs, #0xc0000004
msr CPSR_fx, #0xc0000004
msr CPSR_fc, #0xc0000004
msr CPSR_sf, #0xc0000004
msr CPSR_sx, #0xc0000004
msr CPSR_sc, #0xc0000004
msr CPSR_xf, #0xc0000004
msr CPSR_xs, #0xc0000004
msr CPSR_xc, #0xc0000004
msr CPSR_cf, #0xc0000004
msr CPSR_cs, #0xc0000004
msr CPSR_cx, #0xc0000004
msr CPSR_fsx, #0xc0000004
msr CPSR_fsc, #0xc0000004
msr CPSR_fxs, #0xc0000004
msr CPSR_fxc, #0xc0000004
msr CPSR_fcs, #0xc0000004
msr CPSR_fcx, #0xc0000004
msr CPSR_sfx, #0xc0000004
msr CPSR_sfc, #0xc0000004
msr CPSR_sxf, #0xc0000004
msr CPSR_sxc, #0xc0000004
msr CPSR_scf, #0xc0000004
msr CPSR_scx, #0xc0000004
msr CPSR_xfs, #0xc0000004
msr CPSR_xfc, #0xc0000004
msr CPSR_xsf, #0xc0000004
msr CPSR_xsc, #0xc0000004
msr CPSR_xcf, #0xc0000004
msr CPSR_xcs, #0xc0000004
msr CPSR_cfs, #0xc0000004
msr CPSR_cfx, #0xc0000004
msr CPSR_csf, #0xc0000004
msr CPSR_csx, #0xc0000004
msr CPSR_cxf, #0xc0000004
msr CPSR_cxs, #0xc0000004
msr CPSR_fsxc, #0xc0000004
msr CPSR_fscx, #0xc0000004
msr CPSR_fxsc, #0xc0000004
msr CPSR_fxcs, #0xc0000004
msr CPSR_fcsx, #0xc0000004
msr CPSR_fcxs, #0xc0000004
msr CPSR_sfxc, #0xc0000004
msr CPSR_sfcx, #0xc0000004
msr CPSR_sxfc, #0xc0000004
msr CPSR_sxcf, #0xc0000004
msr CPSR_scfx, #0xc0000004
msr CPSR_scxf, #0xc0000004
msr CPSR_xfsc, #0xc0000004
msr CPSR_xfcs, #0xc0000004
msr CPSR_xsfc, #0xc0000004
msr CPSR_xscf, #0xc0000004
msr CPSR_xcfs, #0xc0000004
msr CPSR_xcsf, #0xc0000004
msr CPSR_cfsx, #0xc0000004
msr CPSR_cfxs, #0xc0000004
msr CPSR_csfx, #0xc0000004
msr CPSR_csxf, #0xc0000004
msr CPSR_cxfs, #0xc0000004
msr CPSR_cxsf, #0xc0000004
@ Write to Saved status register
@ Write to SPSR flags
msr SPSR, #0xc0000004
msr SPSR_s, #0xc0000004
msr SPSR_f, #0xc0000004
msr SPSR_c, #0xc0000004
msr SPSR_x, #0xc0000004
@Write to SPSR flag combos
msr SPSR_fs, #0xc0000004
msr SPSR_fx, #0xc0000004
msr SPSR_fc, #0xc0000004
msr SPSR_sf, #0xc0000004
msr SPSR_sx, #0xc0000004
msr SPSR_sc, #0xc0000004
msr SPSR_xf, #0xc0000004
msr SPSR_xs, #0xc0000004
msr SPSR_xc, #0xc0000004
msr SPSR_cf, #0xc0000004
msr SPSR_cs, #0xc0000004
msr SPSR_cx, #0xc0000004
msr SPSR_fsx, #0xc0000004
msr SPSR_fsc, #0xc0000004
msr SPSR_fxs, #0xc0000004
msr SPSR_fxc, #0xc0000004
msr SPSR_fcs, #0xc0000004
msr SPSR_fcx, #0xc0000004
msr SPSR_sfx, #0xc0000004
msr SPSR_sfc, #0xc0000004
msr SPSR_sxf, #0xc0000004
msr SPSR_sxc, #0xc0000004
msr SPSR_scf, #0xc0000004
msr SPSR_scx, #0xc0000004
msr SPSR_xfs, #0xc0000004
msr SPSR_xfc, #0xc0000004
msr SPSR_xsf, #0xc0000004
msr SPSR_xsc, #0xc0000004
msr SPSR_xcf, #0xc0000004
msr SPSR_xcs, #0xc0000004
msr SPSR_cfs, #0xc0000004
msr SPSR_cfx, #0xc0000004
msr SPSR_csf, #0xc0000004
msr SPSR_csx, #0xc0000004
msr SPSR_cxf, #0xc0000004
msr SPSR_cxs, #0xc0000004
msr SPSR_fsxc, #0xc0000004
msr SPSR_fscx, #0xc0000004
msr SPSR_fxsc, #0xc0000004
msr SPSR_fxcs, #0xc0000004
msr SPSR_fcsx, #0xc0000004
msr SPSR_fcxs, #0xc0000004
msr SPSR_sfxc, #0xc0000004
msr SPSR_sfcx, #0xc0000004
msr SPSR_sxfc, #0xc0000004
msr SPSR_sxcf, #0xc0000004
msr SPSR_scfx, #0xc0000004
msr SPSR_scxf, #0xc0000004
msr SPSR_xfsc, #0xc0000004
msr SPSR_xfcs, #0xc0000004
msr SPSR_xsfc, #0xc0000004
msr SPSR_xscf, #0xc0000004
msr SPSR_xcfs, #0xc0000004
msr SPSR_xcsf, #0xc0000004
msr SPSR_cfsx, #0xc0000004
msr SPSR_cfxs, #0xc0000004
msr SPSR_csfx, #0xc0000004
msr SPSR_csxf, #0xc0000004
msr SPSR_cxfs, #0xc0000004
msr SPSR_cxsf, #0xc0000004
|
stsp/binutils-ia16
| 2,846
|
gas/testsuite/gas/arm/mve-vstr-bad-3.s
|
.macro cond mnem
.irp cond, eq, ne, gt, ge, lt, le
it \cond
\mnem\().32 q0, [r0]
.endr
.endm
.syntax unified
.thumb
vstrb.8 q0, [r0, #128]
vstrb.8 q0, [r0, #-128]
vstrb.16 q0, [r0, #128]
vstrb.16 q0, [r0, #-128]
vstrb.32 q0, [r0, #128]
vstrb.32 q0, [r0, #-128]
vstrb.8 q0, [r0, #128]!
vstrb.8 q0, [r0, #-128]!
vstrb.16 q0, [r0, #128]!
vstrb.16 q0, [r0, #-128]!
vstrb.32 q0, [r0, #128]!
vstrb.32 q0, [r0, #-128]!
vstrb.8 q0, [r0], #128
vstrb.8 q0, [r0], #-128
vstrb.16 q0, [r0], #128
vstrb.16 q0, [r0], #-128
vstrb.32 q0, [r0], #128
vstrb.32 q0, [r0], #-128
vstrb.16 q0, [r10, #2]
vstrb.16 q0, [r10, #2]!
vstrb.16 q0, [r10], #2
vstrb.8 q0, [sp, #2]!
vstrb.8 q0, [sp], #2
vstrb.8 q0, [pc, #2]
cond vstrb
vstrb.u16 q0, [r0]
vstrb.s16 q0, [r0]
vstrb.f16 q0, [r0]
vstrb.p16 q0, [r0]
vstrb.u32 q0, [r0]
vstrb.s32 q0, [r0]
vstrb.f32 q0, [r0]
vstrh.16 q0, [r0, #1]
vstrh.16 q0, [r0, #17]
vstrh.16 q0, [r0, #-17]
vstrh.16 q0, [r0, #256]
vstrh.16 q0, [r0, #-256]
vstrh.32 q0, [r0, #1]
vstrh.32 q0, [r0, #17]
vstrh.32 q0, [r0, #-17]
vstrh.32 q0, [r0, #256]
vstrh.32 q0, [r0, #-256]
vstrh.16 q0, [r0, #1]!
vstrh.16 q0, [r0, #17]!
vstrh.16 q0, [r0, #-17]!
vstrh.16 q0, [r0, #256]!
vstrh.16 q0, [r0, #-256]!
vstrh.32 q0, [r0, #1]!
vstrh.32 q0, [r0, #17]!
vstrh.32 q0, [r0, #-17]!
vstrh.32 q0, [r0, #256]!
vstrh.32 q0, [r0, #-256]!
vstrh.16 q0, [r0], #1
vstrh.16 q0, [r0], #17
vstrh.16 q0, [r0], #-17
vstrh.16 q0, [r0], #256
vstrh.16 q0, [r0], #-256
vstrh.32 q0, [r0], #1
vstrh.32 q0, [r0], #17
vstrh.32 q0, [r0], #-17
vstrh.32 q0, [r0], #256
vstrh.32 q0, [r0], #-256
vstrh.32 q0, [r10, #4]
vstrh.16 q0, [sp, #2]!
vstrh.16 q0, [sp], #2
vstrh.16 q0, [pc, #2]
cond vstrh
vstrh.8 q0, [r0]
vstrh.u8 q0, [r0]
vstrh.s8 q0, [r0]
vstrh.p8 q0, [r0]
vstrh.u32 q0, [r0]
vstrh.s32 q0, [r0]
vstrh.f32 q0, [r0]
vstrw.32 q0, [r0, #3]
vstrw.32 q0, [r0, #-3]
vstrw.32 q0, [r0, #514]
vstrw.32 q0, [r0, #-258]
vstrw.32 q0, [r0, #258]
vstrw.32 q0, [r0, #516]
vstrw.32 q0, [r0, #-516]
vstrw.32 q0, [r0, #3]!
vstrw.32 q0, [r0, #-3]!
vstrw.32 q0, [r0, #514]!
vstrw.32 q0, [r0, #-258]!
vstrw.32 q0, [r0, #258]!
vstrw.32 q0, [r0, #516]!
vstrw.32 q0, [r0, #-516]!
vstrw.32 q0, [r0], #3
vstrw.32 q0, [r0], #-3
vstrw.32 q0, [r0], #514
vstrw.32 q0, [r0], #-258
vstrw.32 q0, [r0], #258
vstrw.32 q0, [r0], #516
vstrw.32 q0, [r0], #-516
vstrw.32 q0, [sp, #4]!
vstrw.32 q0, [pc, #4]
cond vstrw
vstrw.8 q0, [r0]
vstrw.u8 q0, [r0]
vstrw.s8 q0, [r0]
vstrw.p8 q0, [r0]
vstrw.16 q0, [r0]
vstrw.u16 q0, [r0]
vstrw.s16 q0, [r0]
vstrw.f16 q0, [r0]
vstrw.p16 q0, [r0]
it eq
vstrbeq.8 q0, [r0]
vstrbeq.8 q0, [r0]
vpst
vstrbeq.8 q0, [r0]
vstrbt.8 q0, [r0]
vpst
vstrb.8 q0, [r0]
it eq
vstrheq.16 q0, [r0]
vstrheq.16 q0, [r0]
vpst
vstrheq.16 q0, [r0]
vstrht.16 q0, [r0]
vpst
vstrh.16 q0, [r0]
it eq
vstrweq.32 q0, [r0]
vstrweq.32 q0, [r0]
vpst
vstrweq.32 q0, [r0]
vstrwt.32 q0, [r0]
vpst
vstrw.32 q0, [r0]
|
stsp/binutils-ia16
| 2,081
|
gas/testsuite/gas/arm/float.s
|
.text
.align 0
l:
mvfe f0, f1
mvfeqe f3, f5
mvfeqd f4, #1.0
mvfs f4, f7
mvfsp f0, f1
mvfdm f3, f4
mvfez f7, f7
adfe f0, f1, #2.0
adfeqe f1, f2, #0.5
adfsm f3, f4, f5
sufd f0, f0, #2.0
sufs f1, f2, #10.0
sufneez f3, f4, f5
rsfs f1, f1, #0.0
rsfdp f3, f0, #5.0
rsfled f7, f6, f0
mufd f0, f0, f0
mufez f1, f2, #3.0
mufals f0, f0, #4.0
dvfd f0, f0, #1.0000
dvfez f0, f1, #10e0
dvfmism f3, f4, f5
rdfe f0, f1, #1.0e1
rdfs f3, f7, #0f1
rdfccdp f4, f4, f3
powd f0, f2, f3
pows f1, f3, #0e1e1
powcsez f4, f7, #1
rpws f7, f6, f7
rpweqd f0, f1, f2
rpwem f2, f2, f3
rmfd f1, f2, #3
rmfvss f3, f4, f4
rmfep f4, f7, f0
fmls f0, f1, f2
fmleqs f1, f3, f5
fmlplsz f4, f6, f0
fdvs f1, f3, #10
fdvsp f0, f1, f2
fdvhssm f4, f4, f4
frds f1, f1, #1.0
frdgts f2, f1, f0
frdgtsz f4, f4, f5
pold f0, f1, f2
polsz f4, f6, #3.0
poleqe f5, f6, f7
mnfs f0, f1
mnfd f0, #3.0
mnfez f0, #4.0
mnfeqez f0, f5
mnfsp f0, f4
mnfdm f1, f7
absd f0, f1
abssp f1, #3.0
abseqe f4, f5
rnds f1, f2
rndd f3, f4
rndeqez f6, #4.0
sqts f5, f5
sqtdp f6, f6
sqtplez f7, f6
logs f0, #10
loge f0, #0f10
lognedz f0, f1
lgne f1, f2
lgndz f1, f3
lgnvcs f3, f4
exps f1, f3
expem f3, #10.0
exppld f6, f7
sind f0, f1
sinsm f1, f2
singte f4, #5
cosd f1, f3
cosem f4, f5
cosnedp f6, f1
tane f1, f5
tansz f4, f7
tangedz f1, #4.0
asne f4, f5
asnsp f6, #5e-1
asnmidz f5, f5
acss f5, f6
acsd f6, f0
acshsem f1, #0.05e1
atne f0, f5
atnsz f1, #5
atnltd f3, f2
urde f5, f4
nrme f6, f5
nrmpldz f7, f5
fltsp f0, r8
flte f1, r0
flteqdz f5, r7
fix r0, f1
fixz r1, f7
fixcsm r5, f5
wfc r0
wfs r1
rfseq r2
rfc r4
cmf f0, #1
cmf f1, f2
cmfeq f0, f1
cnf f0, #3
cnf f1, #0.5
cnfvs f3, f4
cmfe f0, f1
cmfeeq f1, f2
cmfeqe f3, #5.0
cnfe f1, f3
cnfeeq f3, f4
cnfeqe f4, f7
cnfale f4, #5.0
lfm f0, 4, [r0]
lfm f0, 4, [r0, #0]
lfm f1, 4, [r1, #64]
sfm f2, 4, [r14, #1020]!
sfmeq f7, 3, [r8], #-1020
lfmfd f6, 2, [r15]
sfmea f7, 1, [r8]!
lfmeqea f5, 4, [r6]
sfmnefd f4, 3, [r2]
sfmnefd f4, 3, [r2]!
|
stsp/binutils-ia16
| 13,220
|
gas/testsuite/gas/arm/thumb32.s
|
.text
.thumb
.syntax unified
encode_thumb32_immediate:
orr r0, r1, #0x00000000
orr r0, r1, #0x000000a5
orr r0, r1, #0x00a500a5
orr r0, r1, #0xa500a500
orr r0, r1, #0xa5a5a5a5
orr r0, r1, #0xa5 << 31
orr r0, r1, #0xa5 << 30
orr r0, r1, #0xa5 << 29
orr r0, r1, #0xa5 << 28
orr r0, r1, #0xa5 << 27
orr r0, r1, #0xa5 << 26
orr r0, r1, #0xa5 << 25
orr r0, r1, #0xa5 << 24
orr r0, r1, #0xa5 << 23
orr r0, r1, #0xa5 << 22
orr r0, r1, #0xa5 << 21
orr r0, r1, #0xa5 << 20
orr r0, r1, #0xa5 << 19
orr r0, r1, #0xa5 << 18
orr r0, r1, #0xa5 << 17
orr r0, r1, #0xa5 << 16
orr r0, r1, #0xa5 << 15
orr r0, r1, #0xa5 << 14
orr r0, r1, #0xa5 << 13
orr r0, r1, #0xa5 << 12
orr r0, r1, #0xa5 << 11
orr r0, r1, #0xa5 << 10
orr r0, r1, #0xa5 << 9
orr r0, r1, #0xa5 << 8
orr r0, r1, #0xa5 << 7
orr r0, r1, #0xa5 << 6
orr r0, r1, #0xa5 << 5
orr r0, r1, #0xa5 << 4
orr r0, r1, #0xa5 << 3
orr r0, r1, #0xa5 << 2
orr r0, r1, #0xa5 << 1
add_sub:
@ Should be format 1, Some have equivalent format 2 encodings
adds r0, r0, #0
adds r5, r0, #0
adds r0, r5, #0
adds r0, r2, #5
adds r0, #129 @ format 2
adds r0, r0, #129
adds r5, #126
adds r0, r0, r0 @ format 3
adds r5, r0, r0
adds r0, r5, r0
adds r0, r0, r5
adds r1, r2, r3
add r8, r0 @ format 4
add r0, r8
add r0, r8, r0
add r0, r0, r8
add r8, r0, r0 @ ... not this one
add r1, r0
add r0, r1
add r0, pc, #0 @ format 5
add r5, pc, #0
add r0, pc, #516
add r0, sp, #0 @ format 6
add r5, sp, #0
add r0, sp, #516
add sp, #0 @ format 7
add sp, sp, #0
add sp, #260
add.w r0, r0, #0 @ T32 format 1
adds.w r0, r0, #0
add.w r9, r0, #0
add.w r0, r9, #0
add.w r0, r0, #129
adds r5, r3, #0x10000
add r0, sp, #1
add r9, sp, #0
add.w sp, sp, #4
add.w r0, r0, r0 @ T32 format 2
adds.w r0, r0, r0
add.w r9, r0, r0
add.w r0, r9, r0
add.w r0, r0, r9
add.w r8, r9, r10
add.w r8, r9, r10, lsl #17
add.w r8, r8, r10, lsr #32
add.w r8, r8, r10, lsr #17
add.w r8, r9, r10, asr #32
add.w r8, r9, r10, asr #17
add.w r8, r9, r10, rrx
add.w r8, r9, r10, ror #17
subs r0, r0, #0 @ format 1
subs r5, r0, #0
subs r0, r5, #0
subs r0, r2, #5
subs r0, r0, #129
subs r5, #8
subs r0, r0, r0 @ format 3
subs r5, r0, r0
subs r0, r5, r0
subs r0, r0, r5
sub sp, #260 @ format 4
sub sp, sp, #260
subs r8, r0 @ T32 format 2
subs r0, r8
subs r0, #260 @ T32 format 1
subs.w r1, r2, #4
subs r5, r3, #0x10000
sub r1, sp, #4
sub r9, sp, #0
sub.w sp, sp, #4
arit3:
.macro arit3 op ops opw opsw
\ops r0, r0
\ops r5, r0
\ops r0, r5
\ops r0, r0, r5
\ops r0, r5, r0
\op r0, r5, r0
\op r0, r1, r2
\op r9, r0, r0
\op r0, r9, r0
\op r0, r0, r9
\opsw r0, r0, r0
\opw r0, r1, r2, asr #17
\opw r0, r1, #129
.endm
arit3 adc adcs adc.w adcs.w
arit3 and ands and.w ands.w
arit3 bic bics bic.w bics.w
arit3 eor eors eor.w eors.w
arit3 orr orrs orr.w orrs.w
arit3 rsb rsbs rsb.w rsbs.w
arit3 sbc sbcs sbc.w sbcs.w
arit3 orn orns orn orns
.purgem arit3
bfc_bfi_bfx:
bfc r0, #0, #1
bfc r9, #0, #1
bfi r9, #0, #0, #1
bfc r0, #21, #1
bfc r0, #0, #18
bfi r0, r0, #0, #1
bfi r9, r0, #0, #1
bfi r0, r9, #0, #1
bfi r0, r0, #21, #1
bfi r0, r0, #0, #18
sbfx r0, r0, #0, #1
ubfx r9, r0, #0, #1
sbfx r0, r9, #0, #1
ubfx r0, r0, #21, #1
sbfx r0, r0, #0, #18
.globl branches
branches:
.macro bra op
\op 1b
\op 1f
.endm
1:
bra beq.n
bra bne.n
bra bcs.n
bra bhs.n
bra bcc.n
bra bul.n
bra blo.n
bra bmi.n
bra bpl.n
bra bvs.n
bra bvc.n
bra bhi.n
bra bls.n
bra bvc.n
bra bhi.n
bra bls.n
bra bge.n
bra blt.n
bra bgt.n
bra ble.n
bra bal.n
bra b.n
@ bl, blx have no short form.
.balign 4
1:
bra beq.w
bra bne.w
bra bcs.w
bra bhs.w
bra bcc.w
bra bul.w
bra blo.w
bra bmi.w
bra bpl.w
bra bvs.w
bra bvc.w
bra bhi.w
bra bls.w
bra bvc.w
bra bhi.w
bra bls.w
bra bge.w
bra blt.w
bra bgt.w
bra ble.w
bra b.w
bra bl
bra blx
.balign 4
1:
bx r9
blx r0
blx r9
bxj r0
bxj r9
.purgem bra
clz:
clz r0, r0
clz r9, r0
clz r0, r9
cps:
cpsie f
cpsid i
cpsie a
cpsid.w f
cpsie.w i
cpsid.w a
cpsie i, #0
cpsid i, #17
cps #0
cps #17
cpy:
cpy r0, r0
cpy r9, r0
cpy r0, r9
cpy.w r0, r0
cpy.w r9, r0
cpy.w r0, r9
czb:
cbnz r0, 2f
cbz r5, 1f
nop_hint:
nop
1: yield
2: wfe
wfi
sev
nop.w
yield.w
wfe.w
wfi.w
sev.w
nop {9}
nop {129}
it:
.macro nop1 cond ncond a
.ifc \a,t
nop\cond
.else
nop\ncond
.endif
.endm
.macro it0 cond m=
it\m \cond
nop\cond
.endm
.macro it1 cond ncond a m=
it0 \cond \a\m
nop1 \cond \ncond \a
.endm
.macro it2 cond ncond a b m=
it1 \cond \ncond \a \b\m
nop1 \cond \ncond \b
.endm
.macro it3 cond ncond a b c
it2 \cond \ncond \a \b \c
nop1 \cond \ncond \c
.endm
it0 eq
it0 ne
it0 cs
it0 hs
it0 cc
it0 ul
it0 lo
it0 mi
it0 pl
it0 vs
it0 vc
it0 hi
it0 ge
it0 lt
it0 gt
it0 le
it0 al
it1 eq ne t
it1 eq ne e
it2 eq ne t t
it2 eq ne e t
it2 eq ne t e
it2 eq ne e e
it3 eq ne t t t
it3 eq ne e t t
it3 eq ne t e t
it3 eq ne t t e
it3 eq ne t e e
it3 eq ne e t e
it3 eq ne e e t
it3 eq ne e e e
it1 ne eq t
it1 ne eq e
it2 ne eq t t
it2 ne eq e t
it2 ne eq t e
it2 ne eq e e
it3 ne eq t t t
it3 ne eq e t t
it3 ne eq t e t
it3 ne eq t t e
it3 ne eq t e e
it3 ne eq e t e
it3 ne eq e e t
it3 ne eq e e e
ldst:
1:
pld [r5]
pld [r5, #0x330]
pld [r5, #-0x30]
pld [r5], #0x30
pld [r5], #-0x30
pld [r5, #0x30]!
pld [r5, #-0x30]!
pld [r5, r4]
pld [r9, ip]
pld 1f
pld 1b
1:
nop
here:
ldrd r2, r3, [r5]
ldrd r2, [r5, #0x30]
ldrd r2, [r5, #-0x30]
ldrd r4, r5, here
strd r2, r3, [r5]
strd r2, [r5, #0x30]
strd r2, [r5, #-0x30]
ldrbt r1, [r5]
ldrbt r1, [r5, #0x30]
ldrsbt r1, [r5]
ldrsbt r1, [r5, #0x30]
ldrht r1, [r5]
ldrht r1, [r5, #0x30]
ldrsht r1, [r5]
ldrsht r1, [r5, #0x30]
ldrt r1, [r5]
ldrt r1, [r5, #0x30]
ldxstx:
ldrexb r1, [r4]
ldrexh r1, [r4]
ldrex r1, [r4]
ldrexd r1, r2, [r4]
strexb r1, r2, [r4]
strexh r1, r2, [r4]
strex r1, r2, [r4]
strexd r1, r2, r3, [r4]
strexd r1, r3, r3, [r4]
ldrex r1, [r4,#516]
strex r1, r2, [r4,#516]
ldmstm:
ldmia r0!, {r1,r2,r3}
ldmia r2, {r0,r1,r2}
ldmia.w r2, {r0,r1,r2}
ldmia r9, {r0,r1,r2}
ldmia r0, {r7,r8,r10}
ldmia r0!, {r7,r8,r10}
stmia r0!, {r1,r2,r3}
stmia r2!, {r0,r1,r3}
stmia.w r2!, {r0,r1,r3}
stmia r9, {r0,r1,r2}
stmia r0, {r7,r8,r10}
stmia r0!, {r7,r8,r10}
ldmdb r0, {r7,r8,r10}
stmdb r0, {r7,r8,r10}
mlas:
mla r0, r0, r0, r0
mls r0, r0, r0, r0
mla r9, r0, r0, r0
mla r0, r9, r0, r0
mla r0, r0, r9, r0
mla r0, r0, r0, r9
tst_teq_cmp_cmn_mov_mvn:
.macro mt op ops opw opsw
\ops r0, r0
\op r0, r0
\ops r5, r0
\op r0, r5
\op r0, r5, asr #17
\opw r0, r0
\ops r9, r0
\opsw r0, r9
\opw r0, #129
\opw r5, #129
.endm
mt tst tsts tst.w tsts.w
mt teq teqs teq.w teqs.w
mt cmp cmps cmp.w cmps.w
mt cmn cmns cmn.w cmns.w
mt mov movs mov.w movs.w
mt mvn mvns mvn.w mvns.w
.purgem mt
mov16:
movw r0, #0
movt r0, #0
movw r9, #0
movw r0, #0x9000
movw r0, #0x0800
movw r0, #0x0500
movw r0, #0x0081
movw r0, #0xffff
mrs_msr:
mrs r0, CPSR
mrs r0, SPSR
mrs r9, CPSR_all
mrs r9, SPSR_all
msr CPSR_c, r0
msr SPSR_c, r0
msr CPSR_c, r9
msr CPSR_x, r0
msr CPSR_s, r0
msr CPSR_f, r0
mul:
mul r0, r0, r0
mul r0, r9, r0
mul r0, r0, r9
mul r0, r0
mul r9, r0
muls r5, r0
muls r5, r0, r5
muls r0, r5
mull:
smull r0, r1, r0, r0
umull r0, r1, r0, r0
smlal r0, r1, r0, r0
umlal r0, r1, r0, r0
smull r9, r0, r0, r0
smull r0, r9, r0, r0
smull r0, r1, r9, r0
smull r0, r1, r0, r9
neg:
negs r0, r0
negs r0, r5
negs r5, r0
negs.w r0, r0
negs.w r5, r0
negs.w r0, r5
neg r0, r9
neg r9, r0
negs r0, r9
negs r9, r0
pkh:
pkhbt r0, r0, r0
pkhbt r9, r0, r0
pkhbt r0, r9, r0
pkhbt r0, r0, r9
pkhbt r0, r0, r0, lsl #0x14
pkhbt r0, r0, r0, lsl #3
pkhtb r1, r2, r3
pkhtb r1, r2, r3, asr #0x11
push_pop:
push {r0}
pop {r0}
push {r1,lr}
pop {r1,pc}
push {r8,r9,r10,r11,r12}
pop {r8,r9,r10,r11,r12}
qadd:
qadd r1, r2, r3
qadd16 r1, r2, r3
qadd8 r1, r2, r3
qasx r1, r2, r3
qaddsubx r1, r2, r3
qdadd r1, r2, r3
qdsub r1, r2, r3
qsub r1, r2, r3
qsub16 r1, r2, r3
qsub8 r1, r2, r3
qsax r1, r2, r3
qsubaddx r1, r2, r3
sadd16 r1, r2, r3
sadd8 r1, r2, r3
sasx r1, r2, r3
saddsubx r1, r2, r3
ssub16 r1, r2, r3
ssub8 r1, r2, r3
ssax r1, r2, r3
ssubaddx r1, r2, r3
shadd16 r1, r2, r3
shadd8 r1, r2, r3
shasx r1, r2, r3
shaddsubx r1, r2, r3
shsub16 r1, r2, r3
shsub8 r1, r2, r3
shsax r1, r2, r3
shsubaddx r1, r2, r3
uadd16 r1, r2, r3
uadd8 r1, r2, r3
uasx r1, r2, r3
uaddsubx r1, r2, r3
usub16 r1, r2, r3
usub8 r1, r2, r3
usax r1, r2, r3
usubaddx r1, r2, r3
uhadd16 r1, r2, r3
uhadd8 r1, r2, r3
uhasx r1, r2, r3
uhaddsubx r1, r2, r3
uhsub16 r1, r2, r3
uhsub8 r1, r2, r3
uhsax r1, r2, r3
uhsubaddx r1, r2, r3
uqadd16 r1, r2, r3
uqadd8 r1, r2, r3
uqasx r1, r2, r3
uqaddsubx r1, r2, r3
uqsub16 r1, r2, r3
uqsub8 r1, r2, r3
uqsax r1, r2, r3
uqsubaddx r1, r2, r3
sel r1, r2, r3
rbit_rev:
.macro rx op opw
\op r0, r0
\opw r0, r0
\op r0, r5
\op r5, r0
\op r0, r9
\op r9, r0
.endm
rx rev rev.w
rx rev16 rev16.w
rx revsh revsh.w
rx rbit rbit.w
.purgem rx
shift:
.macro sh op ops opw opsw
\ops r0, #17 @ 16-bit format 1
\ops r0, r0, #14
\ops r5, r0, #17
\ops r0, r5, #14
\ops r0, r0 @ 16-bit format 2
\ops r0, r5
\ops r0, r0, r5
\op r9, #17 @ 32-bit format 1
\op r9, r9, #14
\ops r0, r9, #17
\op r9, r0, #14
\opw r0, r0, r0 @ 32-bit format 2
\op r9, r9
\ops r9, r0
\op r0, r9
\op r0, r5
\ops r0, r1, r2
.endm
sh lsl lsls lsl.w lsls.w
sh lsr lsrs lsr.w lsrs.w
sh asr asrs asr.w asrs.w
sh ror rors ror.w rors.w
.purgem sh
rrx:
rrx r1, r2
rrxs r3, r4
.arch armv7-a
.arch_extension sec
smc:
smc #0
smc #0xd
smla:
smlabb r0, r0, r0, r0
smlabb r9, r0, r0, r0
smlabb r0, r9, r0, r0
smlabb r0, r0, r9, r0
smlabb r0, r0, r0, r9
smlatb r0, r0, r0, r0
smlabt r0, r0, r0, r0
smlatt r0, r0, r0, r0
smlawb r0, r0, r0, r0
smlawt r0, r0, r0, r0
smlad r0, r0, r0, r0
smladx r0, r0, r0, r0
smlsd r0, r0, r0, r0
smlsdx r0, r0, r0, r0
smmla r0, r0, r0, r0
smmlar r0, r0, r0, r0
smmls r0, r0, r0, r0
smmlsr r0, r0, r0, r0
usada8 r0, r0, r0, r0
smlal:
smlalbb r0, r0, r0, r0
smlalbb r9, r0, r0, r0
smlalbb r0, r9, r0, r0
smlalbb r0, r0, r9, r0
smlalbb r0, r0, r0, r9
smlaltb r0, r0, r0, r0
smlalbt r0, r0, r0, r0
smlaltt r0, r0, r0, r0
smlald r0, r0, r0, r0
smlaldx r0, r0, r0, r0
smlsld r0, r0, r0, r0
smlsldx r0, r0, r0, r0
umaal r0, r0, r0, r0
smul:
smulbb r0, r0, r0
smulbb r9, r0, r0
smulbb r0, r9, r0
smulbb r0, r0, r9
smultb r0, r0, r0
smulbt r0, r0, r0
smultt r0, r0, r0
smulwb r0, r0, r0
smulwt r0, r0, r0
smmul r0, r0, r0
smmulr r0, r0, r0
smuad r0, r0, r0
smuadx r0, r0, r0
smusd r0, r0, r0
smusdx r0, r0, r0
usad8 r0, r0, r0
sat:
ssat r0, #1, r0
ssat r0, #1, r0, lsl #0
ssat r0, #1, r0, asr #0
ssat r9, #1, r0
ssat r0, #18, r0
ssat r0, #1, r9
ssat r0, #1, r0, lsl #0x1c
ssat r0, #1, r0, asr #0x03
ssat16 r0, #1, r0
ssat16 r9, #1, r0
ssat16 r0, #10, r0
ssat16 r0, #1, r9
usat r0, #0, r0
usat r0, #0, r0, lsl #0
usat r0, #0, r0, asr #0
usat r9, #0, r0
usat r0, #17, r0
usat r0, #0, r9
usat r0, #0, r0, lsl #0x1c
usat r0, #0, r0, asr #0x03
usat16 r0, #0, r0
usat16 r9, #0, r0
usat16 r0, #9, r0
usat16 r0, #0, r9
xt:
sxtb r0, r0
sxtb r0, r0, ror #0
sxtb r5, r0
sxtb r0, r5
sxtb.w r1, r2
sxtb r1, r2, ror #8
sxtb r1, r2, ror #16
sxtb r1, r2, ror #24
sxtb16 r1, r2
sxtb16 r8, r9
sxth r1, r2
sxth r8, r9
uxtb r1, r2
uxtb r8, r9
uxtb16 r1, r2
uxtb16 r8, r9
uxth r1, r2
uxth r8, r9
xta:
sxtab r0, r0, r0
sxtab r0, r0, r0, ror #0
sxtab r9, r0, r0, ror #8
sxtab r0, r9, r0, ror #16
sxtab r0, r0, r9, ror #24
sxtab16 r1, r2, r3
sxtah r1, r2, r3
uxtab r1, r2, r3
uxtab16 r1, r2, r3
uxtah r1, r2, r3
.macro ldpcimm op
\op r1, [pc, #0x2aa]
\op r1, [pc, #0x155]
\op r1, [pc, #-0x2aa]
\op r1, [pc, #-0x155]
.endm
ldpcimm ldrb
ldpcimm ldrsb
ldpcimm ldrh
ldpcimm ldrsh
ldpcimm ldr
addw r9, r0, #0
addw r6, pc, #0xfff
subw r6, r9, #0xa85
subw r6, r9, #0x57a
tbb [pc, r6]
tbb [r0, r9]
tbh [pc, r7, lsl #1]
tbh [r0, r8, lsl #1]
push {r8}
pop {r8}
ldmdb r0!, {r7,r8,r10}
stmdb r0!, {r7,r8,r10}
ldm r0!, {r1, r2}
stm r0!, {r1, r2}
ldm r0, {r8, r9}
stm r0, {r8, r9}
itttt eq
ldmeq r0!, {r1, r2}
stmeq r0!, {r1, r2}
ldmeq r0, {r8, r9}
stmeq r0, {r8, r9}
nop
srs:
srsia sp, #16
srsdb sp, #16
srsia sp!, #21
srsia sp!, #10
movs pc, lr
subs pc, lr, #0
subs pc, lr, #4
subs pc, lr, #255
ldrd r2, r4, [r9, #48]!
ldrd r2, r4, [r9, #-48]!
strd r2, r4, [r9, #48]!
strd r2, r4, [r9, #-48]!
ldrd r2, r4, [r9], #48
ldrd r2, r4, [r9], #-48
strd r2, r4, [r9], #48
strd r2, r4, [r9], #-48
.macro ldaddr op
ldr\op r1, [r5, #0x301]
ldr\op r1, [r5, #0x30]!
ldr\op r1, [r5, #-0x30]!
ldr\op r1, [r5], #0x30
ldr\op r1, [r5], #-0x30
ldr\op r1, [r5, r9]
.endm
ldaddr
ldaddr b
ldaddr sb
ldaddr h
ldaddr sh
.macro movshift op s="s"
movs r1, r4, \op #2
movs r3, r9, \op #2
movs r1, r2, \op r3
movs r1, r1, \op r3
movs r1, r1, \op r9
mov r1, r2, \op r3
mov r1, r1, \op r3
.endm
movshift lsl
movshift lsr
movshift asr
movshift ror
nop
|
stsp/binutils-ia16
| 1,830
|
gas/testsuite/gas/arm/thumb2_vpool.s
|
.text
.fpu neon
.thumb
.syntax unified
.thumb_func
thumb2_ldr:
.macro vlxr regtype const
.irp regindex, 0, 14, 28, 31
vldr \regtype\regindex, \const
.endr
.endm
# Thumb-2 support vldr literal pool also.
vlxr s "=0"
vlxr s "=0xff000000"
vlxr s "=-1"
vlxr s "=0x0fff0000"
.pool
vlxr s "=0"
vlxr s "=0x00ff0000"
vlxr s "=0xff00ffff"
vlxr s "=0x00fff000"
.pool
vlxr d "=0"
vlxr d "=0xca000000"
vlxr d "=-1"
vlxr d "=0x0fff0000"
.pool
vlxr d "=0"
vlxr d "=0x00ff0000"
vlxr d "=0xff0000ff"
vlxr d "=0x00fff000"
.pool
vlxr d "=0"
vlxr d "=0xff00000000000000"
vlxr d "=-1"
vlxr d "=0x0fff000000000000"
.pool
vlxr d "=0"
vlxr d "=0x00ff00000000000"
vlxr d "=0xff00ffff0000000"
vlxr d "=0xff00ffff0000000"
.pool
# pool should be aligned to 8-byte.
.p2align 3
vldr d1, =0x0000fff000000000
.pool
# no error when code is align already.
.p2align 3
add r0, r1, #0
vldr d1, =0x0000fff000000000
.pool
.p2align 3
vldr d1, =0x0000fff000000000
vldr s2, =0xff000000
# padding A
vldr d3, =0x0000fff000000001
# reuse padding slot A
vldr s4, =0xff000001
# reuse d3
vldr d5, =0x0000fff000000001
# new 8-byte entry
vldr d6, =0x0000fff000000002
# new 8-byte entry
vldr d7, =0x0000fff000000003
# new 4-byte entry
vldr s8, =0xff000002
# padding B
vldr d9, =0x0000fff000000004
# reuse padding slot B
vldr s10, =0xff000003
# new 8-byte entry
vldr d11, =0x0000fff000000005
# new 4 entry
vldr s12, =0xff000004
# new 4 entry
vldr s13, =0xff000005
# reuse value of s4 in pool
vldr s14, =0xff000001
# reuse high part of d1 in pool
vldr s15, =0x0000fff0
# 8-byte entry reuse two 4-byte entries.
# d16 reuse s12, s13
vldr d16, =0xff000005ff000004
# d17 should not reuse high part of d11 and s12.
# because the it's align 8-byte aligned.
vldr d17, =0xff0000040000fff0
.pool
|
stsp/binutils-ia16
| 12,605
|
gas/testsuite/gas/arm/maverick.s
|
.text
.align
load_store:
cfldrseq mvf5, [sp, #1020]
cfldrsmi mvf14, [r11, #292]
cfldrsvc mvf2, [r12, #-956]
cfldrslt mvf0, [sl, #-1020]
cfldrscc mvf12, [r1, #-156]
cfldrs mvf13, [r9, #416]!
cfldrscs mvf9, [r0, #-1020]!
cfldrsls mvf4, [r1, #-156]!
cfldrsle mvf7, [r9, #416]!
cfldrsvs mvf11, [r0, #-1020]!
cfldrscc mvf12, [r1], #-156
cfldrs mvf13, [r9], #416
cfldrscs mvf9, [r0], #-1020
cfldrsls mvf4, [r1], #-156
cfldrsle mvf7, [r9], #416
cfldrdvs mvd11, [r0, #-1020]
cfldrdcc mvd12, [r1, #-156]
cfldrd mvd13, [r9, #416]
cfldrdcs mvd9, [r0, #-1020]
cfldrdls mvd4, [r1, #-156]
cfldrdle mvd7, [r9, #416]!
cfldrdvs mvd11, [r0, #-1020]!
cfldrdcc mvd12, [r1, #-156]!
cfldrd mvd13, [r9, #416]!
cfldrdcs mvd9, [r0, #-1020]!
cfldrdls mvd4, [r1], #-156
cfldrdle mvd7, [r9], #416
cfldrdvs mvd11, [r0], #-1020
cfldrdcc mvd12, [r1], #-156
cfldrd mvd13, [r9], #416
cfldr32cs mvfx9, [r0, #-1020]
cfldr32ls mvfx4, [r1, #-156]
cfldr32le mvfx7, [r9, #416]
cfldr32vs mvfx11, [r0, #-1020]
cfldr32cc mvfx12, [r1, #-156]
cfldr32 mvfx13, [r9, #416]!
cfldr32cs mvfx9, [r0, #-1020]!
cfldr32ls mvfx4, [r1, #-156]!
cfldr32le mvfx7, [r9, #416]!
cfldr32vs mvfx11, [r0, #-1020]!
cfldr32cc mvfx12, [r1], #-156
cfldr32 mvfx13, [r9], #416
cfldr32cs mvfx9, [r0], #-1020
cfldr32ls mvfx4, [r1], #-156
cfldr32le mvfx7, [r9], #416
cfldr64vs mvdx11, [r0, #-1020]
cfldr64cc mvdx12, [r1, #-156]
cfldr64 mvdx13, [r9, #416]
cfldr64cs mvdx9, [r0, #-1020]
cfldr64ls mvdx4, [r1, #-156]
cfldr64le mvdx7, [r9, #416]!
cfldr64vs mvdx11, [r0, #-1020]!
cfldr64cc mvdx12, [r1, #-156]!
cfldr64 mvdx13, [r9, #416]!
cfldr64cs mvdx9, [r0, #-1020]!
cfldr64ls mvdx4, [r1], #-156
cfldr64le mvdx7, [r9], #416
cfldr64vs mvdx11, [r0], #-1020
cfldr64cc mvdx12, [r1], #-156
cfldr64 mvdx13, [r9], #416
cfstrscs mvf9, [r0, #-1020]
cfstrsls mvf4, [r1, #-156]
cfstrsle mvf7, [r9, #416]
cfstrsvs mvf11, [r0, #-1020]
cfstrscc mvf12, [r1, #-156]
cfstrs mvf13, [r9, #416]!
cfstrscs mvf9, [r0, #-1020]!
cfstrsls mvf4, [r1, #-156]!
cfstrsle mvf7, [r9, #416]!
cfstrsvs mvf11, [r0, #-1020]!
cfstrscc mvf12, [r1], #-156
cfstrs mvf13, [r9], #416
cfstrscs mvf9, [r0], #-1020
cfstrsls mvf4, [r1], #-156
cfstrsle mvf7, [r9], #416
cfstrdvs mvd11, [r0, #-1020]
cfstrdcc mvd12, [r1, #-156]
cfstrd mvd13, [r9, #416]
cfstrdcs mvd9, [r0, #-1020]
cfstrdls mvd4, [r1, #-156]
cfstrdle mvd7, [r9, #416]!
cfstrdvs mvd11, [r0, #-1020]!
cfstrdcc mvd12, [r1, #-156]!
cfstrd mvd13, [r9, #416]!
cfstrdcs mvd9, [r0, #-1020]!
cfstrdls mvd4, [r1], #-156
cfstrdle mvd7, [r9], #416
cfstrdvs mvd11, [r0], #-1020
cfstrdcc mvd12, [r1], #-156
cfstrd mvd13, [r9], #416
cfstr32cs mvfx9, [r0, #-1020]
cfstr32ls mvfx4, [r1, #-156]
cfstr32le mvfx7, [r9, #416]
cfstr32vs mvfx11, [r0, #-1020]
cfstr32cc mvfx12, [r1, #-156]
cfstr32 mvfx13, [r9, #416]!
cfstr32cs mvfx9, [r0, #-1020]!
cfstr32ls mvfx4, [r1, #-156]!
cfstr32le mvfx7, [r9, #416]!
cfstr32vs mvfx11, [r0, #-1020]!
cfstr32cc mvfx12, [r1], #-156
cfstr32 mvfx13, [r9], #416
cfstr32cs mvfx9, [r0], #-1020
cfstr32ls mvfx4, [r1], #-156
cfstr32le mvfx7, [r9], #416
cfstr64vs mvdx11, [r0, #-1020]
cfstr64cc mvdx12, [r1, #-156]
cfstr64 mvdx13, [r9, #416]
cfstr64cs mvdx9, [r0, #-1020]
cfstr64ls mvdx4, [r1, #-156]
cfstr64le mvdx7, [r9, #416]!
cfstr64vs mvdx11, [r0, #-1020]!
cfstr64cc mvdx12, [r1, #-156]!
cfstr64 mvdx13, [r9, #416]!
cfstr64cs mvdx9, [r0, #-1020]!
cfstr64ls mvdx4, [r1], #-156
cfstr64le mvdx7, [r9], #416
cfstr64vs mvdx11, [r0], #-1020
cfstr64cc mvdx12, [r1], #-156
cfstr64 mvdx13, [r9], #416
move:
cfmvsrcs mvf9, r0
cfmvsrpl mvf15, r7
cfmvsrls mvf4, r1
cfmvsrcc mvf8, r2
cfmvsrvc mvf2, r12
cfmvrsgt r9, mvf11
cfmvrseq sl, mvf5
cfmvrsal r4, mvf12
cfmvrsge fp, mvf8
cfmvrs r5, mvf6
cfmvdlrlt mvd4, r9
cfmvdlrls mvd0, r10
cfmvdlr mvd10, r4
cfmvdlrmi mvd14, r11
cfmvdlrhi mvd13, r5
cfmvrdlcs r12, mvd12
cfmvrdlvs r3, mvd0
cfmvrdlvc r13, mvd14
cfmvrdlcc r14, mvd10
cfmvrdlne r8, mvd15
cfmvdhrle mvd6, ip
cfmvdhrmi mvd2, r3
cfmvdhreq mvd5, sp
cfmvdhrge mvd9, lr
cfmvdhral mvd3, r8
cfmvrdhle r5, mvd2
cfmvrdhne r6, mvd6
cfmvrdhlt r0, mvd7
cfmvrdhpl r7, mvd3
cfmvrdhgt r1, mvd1
cfmv64lrhi mvdx15, r5
cfmv64lrvs mvdx11, r6
cfmv64lrcs mvdx9, r0
cfmv64lrpl mvdx15, r7
cfmv64lrls mvdx4, r1
cfmvr64lcc r8, mvdx13
cfmvr64lvc pc, mvdx1
cfmvr64lgt r9, mvdx11
cfmvr64leq sl, mvdx5
cfmvr64lal r4, mvdx12
cfmv64hrge mvdx1, r8
cfmv64hr mvdx13, r15
cfmv64hrlt mvdx4, r9
cfmv64hrls mvdx0, r10
cfmv64hr mvdx10, r4
cfmvr64hmi r1, mvdx3
cfmvr64hhi r2, mvdx7
cfmvr64hcs r12, mvdx12
cfmvr64hvs r3, mvdx0
cfmvr64hvc r13, mvdx14
cfmval32cc mvax0, mvfx10
cfmval32ne mvax1, mvfx15
cfmval32le mvax0, mvfx11
cfmval32mi mvax0, mvfx9
cfmval32eq mvax1, mvfx15
cfmv32alge mvfx9, mvax0
cfmv32alal mvfx3, mvax1
cfmv32alle mvfx7, mvax0
cfmv32alne mvfx12, mvax0
cfmv32allt mvfx0, mvax1
cfmvam32pl mvax2, mvfx3
cfmvam32gt mvax1, mvfx1
cfmvam32hi mvax3, mvfx13
cfmvam32vs mvax3, mvfx4
cfmvam32cs mvax1, mvfx0
cfmv32ampl mvfx15, mvax2
cfmv32amls mvfx4, mvax1
cfmv32amcc mvfx8, mvax3
cfmv32amvc mvfx2, mvax3
cfmv32amgt mvfx6, mvax1
cfmvah32eq mvax1, mvfx5
cfmvah32al mvax2, mvfx12
cfmvah32ge mvax3, mvfx8
cfmvah32 mvax2, mvfx6
cfmvah32lt mvax2, mvfx2
cfmv32ahls mvfx0, mvax1
cfmv32ah mvfx10, mvax2
cfmv32ahmi mvfx14, mvax3
cfmv32ahhi mvfx13, mvax2
cfmv32ahcs mvfx1, mvax2
cfmva32vs mvax1, mvfx0
cfmva32vc mvax3, mvfx14
cfmva32cc mvax0, mvfx10
cfmva32ne mvax1, mvfx15
cfmva32le mvax0, mvfx11
cfmv32ami mvfx2, mvax1
cfmv32aeq mvfx5, mvax3
cfmv32age mvfx9, mvax0
cfmv32aal mvfx3, mvax1
cfmv32ale mvfx7, mvax0
cfmva64ne mvax2, mvdx6
cfmva64lt mvax0, mvdx7
cfmva64pl mvax2, mvdx3
cfmva64gt mvax1, mvdx1
cfmva64hi mvax3, mvdx13
cfmv64avs mvdx11, mvax2
cfmv64acs mvdx9, mvax0
cfmv64apl mvdx15, mvax2
cfmv64als mvdx4, mvax1
cfmv64acc mvdx8, mvax3
cfmvsc32vc dspsc, mvdx1
cfmvsc32gt dspsc, mvdx11
cfmvsc32eq dspsc, mvdx5
cfmvsc32al dspsc, mvdx12
cfmvsc32ge dspsc, mvdx8
cfmv32sc mvdx13, dspsc
cfmv32sclt mvdx4, dspsc
cfmv32scls mvdx0, dspsc
cfmv32sc mvdx10, dspsc
cfmv32scmi mvdx14, dspsc
cfcpyshi mvf13, mvf7
cfcpyscs mvf1, mvf12
cfcpysvs mvf11, mvf0
cfcpysvc mvf5, mvf14
cfcpyscc mvf12, mvf10
cfcpydne mvd8, mvd15
cfcpydle mvd6, mvd11
cfcpydmi mvd2, mvd9
cfcpydeq mvd5, mvd15
cfcpydge mvd9, mvd4
conv:
cfcvtsdal mvd3, mvf8
cfcvtsdle mvd7, mvf2
cfcvtsdne mvd12, mvf6
cfcvtsdlt mvd0, mvf7
cfcvtsdpl mvd14, mvf3
cfcvtdsgt mvf10, mvd1
cfcvtdshi mvf15, mvd13
cfcvtdsvs mvf11, mvd4
cfcvtdscs mvf9, mvd0
cfcvtdspl mvf15, mvd10
cfcvt32sls mvf4, mvfx14
cfcvt32scc mvf8, mvfx13
cfcvt32svc mvf2, mvfx1
cfcvt32sgt mvf6, mvfx11
cfcvt32seq mvf7, mvfx5
cfcvt32dal mvd3, mvfx12
cfcvt32dge mvd1, mvfx8
cfcvt32d mvd13, mvfx6
cfcvt32dlt mvd4, mvfx2
cfcvt32dls mvd0, mvfx5
cfcvt64s mvf10, mvdx9
cfcvt64smi mvf14, mvdx3
cfcvt64shi mvf13, mvdx7
cfcvt64scs mvf1, mvdx12
cfcvt64svs mvf11, mvdx0
cfcvt64dvc mvd5, mvdx14
cfcvt64dcc mvd12, mvdx10
cfcvt64dne mvd8, mvdx15
cfcvt64dle mvd6, mvdx11
cfcvt64dmi mvd2, mvdx9
cfcvts32eq mvfx5, mvf15
cfcvts32ge mvfx9, mvf4
cfcvts32al mvfx3, mvf8
cfcvts32le mvfx7, mvf2
cfcvts32ne mvfx12, mvf6
cfcvtd32lt mvfx0, mvd7
cfcvtd32pl mvfx14, mvd3
cfcvtd32gt mvfx10, mvd1
cfcvtd32hi mvfx15, mvd13
cfcvtd32vs mvfx11, mvd4
cftruncs32cs mvfx9, mvf0
cftruncs32pl mvfx15, mvf10
cftruncs32ls mvfx4, mvf14
cftruncs32cc mvfx8, mvf13
cftruncs32vc mvfx2, mvf1
cftruncd32gt mvfx6, mvd11
cftruncd32eq mvfx7, mvd5
cftruncd32al mvfx3, mvd12
cftruncd32ge mvfx1, mvd8
cftruncd32 mvfx13, mvd6
shift:
cfrshl32lt mvfx4, mvfx2, r3
cfrshl32pl mvfx15, mvfx10, r4
cfrshl32al mvfx3, mvfx8, r2
cfrshl32cs mvfx1, mvfx12, r9
cfrshl32eq mvfx7, mvfx5, r7
cfrshl64gt mvdx10, mvdx1, r8
cfrshl64le mvdx6, mvdx11, r6
cfrshl64ls mvdx0, mvdx5, sp
cfrshl64ls mvdx4, mvdx14, r11
cfrshl64le mvdx7, mvdx2, r12
cfsh32vs mvfx11, mvfx0, #-1
cfsh32al mvfx3, mvfx12, #24
cfsh32hi mvfx15, mvfx13, #33
cfsh32mi mvfx2, mvfx9, #0
cfsh32 mvfx10, mvfx9, #32
cfsh64cc mvdx8, mvdx13, #-31
cfsh64ne mvdx12, mvdx6, #1
cfsh64vc mvdx5, mvdx14, #-32
cfsh64ge mvdx1, mvdx8, #-27
cfsh64vs mvdx11, mvdx4, #-5
comp:
cfcmpseq r10, mvf15, mvf10
cfcmpsmi r1, mvf3, mvf8
cfcmpsvc pc, mvf1, mvf12
cfcmpslt r0, mvf7, mvf5
cfcmpscc r14, mvf10, mvf1
cfcmpd r5, mvd6, mvd11
cfcmpdcs r3, mvd0, mvd5
cfcmpdge r4, mvd4, mvd14
cfcmpdhi r2, mvd7, mvd2
cfcmpdgt r9, mvd11, mvd0
cfcmp32pl r7, mvfx3, mvfx12
cfcmp32ne r8, mvfx15, mvfx13
cfcmp32lt r6, mvfx2, mvfx9
cfcmp32pl sp, mvfx10, mvfx9
cfcmp32al r11, mvfx8, mvfx13
cfcmp64cs r12, mvdx12, mvdx6
cfcmp64eq sl, mvdx5, mvdx14
cfcmp64gt r1, mvdx1, mvdx8
cfcmp64le r15, mvdx11, mvdx4
cfcmp64ls r0, mvdx5, mvdx15
fp_arith:
cfabssls mvf4, mvf14
cfabsscc mvf8, mvf13
cfabssvc mvf2, mvf1
cfabssgt mvf6, mvf11
cfabsseq mvf7, mvf5
cfabsdal mvd3, mvd12
cfabsdge mvd1, mvd8
cfabsd mvd13, mvd6
cfabsdlt mvd4, mvd2
cfabsdls mvd0, mvd5
cfnegs mvf10, mvf9
cfnegsmi mvf14, mvf3
cfnegshi mvf13, mvf7
cfnegscs mvf1, mvf12
cfnegsvs mvf11, mvf0
cfnegdvc mvd5, mvd14
cfnegdcc mvd12, mvd10
cfnegdne mvd8, mvd15
cfnegdle mvd6, mvd11
cfnegdmi mvd2, mvd9
cfaddseq mvf5, mvf15, mvf10
cfaddsmi mvf14, mvf3, mvf8
cfaddsvc mvf2, mvf1, mvf12
cfaddslt mvf0, mvf7, mvf5
cfaddscc mvf12, mvf10, mvf1
cfaddd mvd13, mvd6, mvd11
cfadddcs mvd9, mvd0, mvd5
cfadddge mvd9, mvd4, mvd14
cfadddhi mvd13, mvd7, mvd2
cfadddgt mvd6, mvd11, mvd0
cfsubspl mvf14, mvf3, mvf12
cfsubsne mvf8, mvf15, mvf13
cfsubslt mvf4, mvf2, mvf9
cfsubspl mvf15, mvf10, mvf9
cfsubsal mvf3, mvf8, mvf13
cfsubdcs mvd1, mvd12, mvd6
cfsubdeq mvd7, mvd5, mvd14
cfsubdgt mvd10, mvd1, mvd8
cfsubdle mvd6, mvd11, mvd4
cfsubdls mvd0, mvd5, mvd15
cfmulsls mvf4, mvf14, mvf3
cfmulsle mvf7, mvf2, mvf1
cfmulsvs mvf11, mvf0, mvf7
cfmulsal mvf3, mvf12, mvf10
cfmulshi mvf15, mvf13, mvf6
cfmuldmi mvd2, mvd9, mvd0
cfmuld mvd10, mvd9, mvd4
cfmuldcc mvd8, mvd13, mvd7
cfmuldne mvd12, mvd6, mvd11
cfmuldvc mvd5, mvd14, mvd3
int_arith:
cfabs32ge mvfx1, mvfx8
cfabs32 mvfx13, mvfx6
cfabs32lt mvfx4, mvfx2
cfabs32ls mvfx0, mvfx5
cfabs32 mvfx10, mvfx9
cfabs64mi mvdx14, mvdx3
cfabs64hi mvdx13, mvdx7
cfabs64cs mvdx1, mvdx12
cfabs64vs mvdx11, mvdx0
cfabs64vc mvdx5, mvdx14
cfneg32cc mvfx12, mvfx10
cfneg32ne mvfx8, mvfx15
cfneg32le mvfx6, mvfx11
cfneg32mi mvfx2, mvfx9
cfneg32eq mvfx5, mvfx15
cfneg64ge mvdx9, mvdx4
cfneg64al mvdx3, mvdx8
cfneg64le mvdx7, mvdx2
cfneg64ne mvdx12, mvdx6
cfneg64lt mvdx0, mvdx7
cfadd32pl mvfx14, mvfx3, mvfx12
cfadd32ne mvfx8, mvfx15, mvfx13
cfadd32lt mvfx4, mvfx2, mvfx9
cfadd32pl mvfx15, mvfx10, mvfx9
cfadd32al mvfx3, mvfx8, mvfx13
cfadd64cs mvdx1, mvdx12, mvdx6
cfadd64eq mvdx7, mvdx5, mvdx14
cfadd64gt mvdx10, mvdx1, mvdx8
cfadd64le mvdx6, mvdx11, mvdx4
cfadd64ls mvdx0, mvdx5, mvdx15
cfsub32ls mvfx4, mvfx14, mvfx3
cfsub32le mvfx7, mvfx2, mvfx1
cfsub32vs mvfx11, mvfx0, mvfx7
cfsub32al mvfx3, mvfx12, mvfx10
cfsub32hi mvfx15, mvfx13, mvfx6
cfsub64mi mvdx2, mvdx9, mvdx0
cfsub64 mvdx10, mvdx9, mvdx4
cfsub64cc mvdx8, mvdx13, mvdx7
cfsub64ne mvdx12, mvdx6, mvdx11
cfsub64vc mvdx5, mvdx14, mvdx3
cfmul32ge mvfx1, mvfx8, mvfx15
cfmul32vs mvfx11, mvfx4, mvfx2
cfmul32eq mvfx5, mvfx15, mvfx10
cfmul32mi mvfx14, mvfx3, mvfx8
cfmul32vc mvfx2, mvfx1, mvfx12
cfmul64lt mvdx0, mvdx7, mvdx5
cfmul64cc mvdx12, mvdx10, mvdx1
cfmul64 mvdx13, mvdx6, mvdx11
cfmul64cs mvdx9, mvdx0, mvdx5
cfmul64ge mvdx9, mvdx4, mvdx14
cfmac32hi mvfx13, mvfx7, mvfx2
cfmac32gt mvfx6, mvfx11, mvfx0
cfmac32pl mvfx14, mvfx3, mvfx12
cfmac32ne mvfx8, mvfx15, mvfx13
cfmac32lt mvfx4, mvfx2, mvfx9
cfmsc32pl mvfx15, mvfx10, mvfx9
cfmsc32al mvfx3, mvfx8, mvfx13
cfmsc32cs mvfx1, mvfx12, mvfx6
cfmsc32eq mvfx7, mvfx5, mvfx14
cfmsc32gt mvfx10, mvfx1, mvfx8
acc_arith:
cfmadd32le mvax0, mvfx11, mvfx4, mvfx2
cfmadd32ls mvax0, mvfx5, mvfx15, mvfx10
cfmadd32ls mvax0, mvfx14, mvfx3, mvfx8
cfmadd32le mvax2, mvfx2, mvfx1, mvfx12
cfmadd32vs mvax1, mvfx0, mvfx7, mvfx5
cfmsub32al mvax2, mvfx12, mvfx10, mvfx1
cfmsub32hi mvax3, mvfx13, mvfx6, mvfx11
cfmsub32mi mvax0, mvfx9, mvfx0, mvfx5
cfmsub32 mvax2, mvfx9, mvfx4, mvfx14
cfmsub32cc mvax1, mvfx13, mvfx7, mvfx2
cfmadda32ne mvax2, mvax0, mvfx11, mvfx0
cfmadda32vc mvax3, mvax2, mvfx3, mvfx12
cfmadda32ge mvax3, mvax1, mvfx15, mvfx13
cfmadda32vs mvax3, mvax2, mvfx2, mvfx9
cfmadda32eq mvax1, mvax3, mvfx10, mvfx9
cfmsuba32mi mvax1, mvax3, mvfx8, mvfx13
cfmsuba32vc mvax0, mvax3, mvfx12, mvfx6
cfmsuba32lt mvax0, mvax1, mvfx5, mvfx14
cfmsuba32cc mvax0, mvax1, mvfx1, mvfx8
cfmsuba32 mvax2, mvax0, mvfx11, mvfx4
|
stsp/binutils-ia16
| 11,472
|
gas/testsuite/gas/arm/cde-warnings.s
|
.syntax unified
# cx1{a}
# Immediate out of range.
# Each register out of range.
# r13 => constrained unpredictable
# itblock => constrained unpredictable
# Error given when using coprocessor number not enabled on command line.
# Too many arguments
# Too little arguments
# r15 instead of APSR_nzcv
cx1 p0, r0, #8192
cx1a p0, r0, #8192
cx1 p0, r0, #-1
cx1a p0, r0, #-1
cx1 p8, r0, #0
cx1a p8, r0, #0
cx1 p0, r16, #0
cx1a p0, r16, #0
cx1 p0, r13, #0
cx1a p0, r13, #0
itttt ne
cx1 p0, r0, #0
cx1ne p0, r0, #0
cx1a p0, r0, #0
cx1aeq p0, r0, #0
cx1 p1, r0, #0
cx1a p1, r0, #0
cx1 p0, r0, r0, #0
cx1a p0, r0, r0, #0
cx1 p0, #0
cx1a p0, #0
cx1 p0, r15, #0
cx1a p0, r15, #0
# cx1d{a}
# Immediate out of range.
# Each register out of range.
# APSR_nzcv disallowed as destination register.
# rd<odd> => constrained unpredictable
# r< N > 10 > => constrained unpredictable
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Disallow non-incrementing values in destination.
# Too many arguments
# Too little arguments
cx1d p0, r0, r1, #8192
cx1da p0, r0, r1, #8192
cx1d p0, r0, r1, #-1
cx1da p0, r0, r1, #-1
cx1d p8, r0, r1, #0
cx1da p8, r0, r1, #0
cx1d p0, r16, r17, #0
cx1da p0, r16, r17, #0
cx1d p0, APSR_nzcv, r15, #0
cx1da p0, APSR_nzcv, r15, #0
cx1d p0, r9, r10, #0
cx1da p0, r9, r10, #0
cx1d p0, r13, r14, #0
cx1da p0, r13, r14, #0
itttt ne
cx1d p0, r0, r1, #0
cx1da p0, r0, r1, #0
cx1dne p0, r0, r1, #0
cx1daeq p0, r0, r1, #0
cx1d p1, r0, r1, #0
cx1da p1, r0, r1, #0
cx1d p0, r0, r2, #0
cx1da p0, r0, r2, #0
cx1d p0, r0, r1, r0, #0
cx1da p0, r0, r1, r0, #0
cx1d p0, r0, #0
cx1da p0, r0, #0
# cx2{a}
# Immediate out of range.
# Each register out of range.
# rd13 => constrained unpredictable
# rn13 => constrained unpredictable
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Too many arguments
# Too little arguments.
# r15 instead of APSR_nzcv
cx2 p0, r0, r0, #512
cx2a p0, r0, r0, #512
cx2 p0, r0, r0, #-1
cx2a p0, r0, r0, #-1
cx2 p8, r0, r0, #0
cx2a p8, r0, r0, #0
cx2 p0, r16, r0, #0
cx2a p0, r16, r0, #0
cx2 p0, r0, r16, #0
cx2a p0, r0, r16, #0
cx2 p0, r13, r0, #0
cx2a p0, r13, r0, #0
cx2 p0, r0, r13, #0
cx2a p0, r0, r13, #0
itttt ne
cx2 p0, r0, r0, #0
cx2a p0, r0, r0, #0
cx2ne p0, r0, r0, #0
cx2aeq p0, r0, r0, #0
cx2 p1, r0, r0, #0
cx2a p1, r0, r0, #0
cx2 p0, r0, r0, r0, #0
cx2a p0, r0, r0, r0, #0
cx2 p0, r0, #0
cx2a p0, r0, #0
cx2 p0, r0, r15, #0
cx2a p0, r0, r15, #0
cx2 p0, r15, r0, #0
cx2a p0, r15, r0, #0
# cx2d{a}
# Immediate out of range.
# Each register out of range.
# APSR_nzcv disallowed as destination register.
# rd<odd> => constrained unpredictable
# rd< N > 10 > => constrained unpredictable
# rn13 => constrained unpredictable
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Disallow non-incrementing values in destination.
# Too many arguments
# Too little arguments
cx2d p0, r0, r1, r0, #512
cx2da p0, r0, r1, r0, #512
cx2d p0, r0, r1, r0, #-1
cx2da p0, r0, r1, r0, #-1
cx2d p8, r0, r1, r0, #0
cx2da p8, r0, r1, r0, #0
cx2d p0, r16, r17, r0, #0
cx2da p0, r16, r17, r0, #0
cx2d p0, r0, r1, r16, #0
cx2da p0, r0, r1, r16, #0
cx2d p0, APSR_nzcv, r15, r0, #0
cx2da p0, APSR_nzcv, r15, r0, #0
cx2d p0, r9, r10, r0, #0
cx2da p0, r9, r10, r0, #0
cx2d p0, r12, r13, r0, #0
cx2da p0, r12, r13, r0, #0
cx2d p0, r0, r1, r13, #0
cx2da p0, r0, r1, r13, #0
cx2d p0, r0, r1, r15, #0
cx2da p0, r0, r1, r15, #0
itttt ne
cx2d p0, r0, r1, r0, #0
cx2da p0, r0, r1, r0, #0
cx2dne p0, r0, r1, r0, #0
cx2daeq p0, r0, r1, r0, #0
cx2d p1, r0, r1, r0, #0
cx2da p1, r0, r1, r0, #0
cx2d p0, r0, r2, r0, #0
cx2da p0, r0, r2, r0, #0
cx2d p0, r0, r1, r0, r0, #0
cx2da p0, r0, r1, r0, r0, #0
cx2d p0, r0, r0, #0
cx2da p0, r0, r0, #0
# cx2{a}
# Immediate out of range.
# Each register out of range.
# rd13 => constrained unpredictable
# rn13 => constrained unpredictable
# rm13 => constrained unpredictable
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Too many arguments
# Too little arguments.
# r15 instead of APSR_nzcv
cx3 p0, r0, r0, r0, #64
cx3a p0, r0, r0, r0, #64
cx3 p0, r0, r0, r0, #-1
cx3a p0, r0, r0, r0, #-1
cx3 p8, r0, r0, r0, #0
cx3a p8, r0, r0, r0, #0
cx3 p0, r16, r0, r0, #0
cx3a p0, r16, r0, r0, #0
cx3 p0, r0, r16, r0, #0
cx3a p0, r0, r16, r0, #0
cx3 p0, r0, r0, r16, #0
cx3a p0, r0, r0, r16, #0
cx3 p0, r13, r0, r0, #0
cx3a p0, r13, r0, r0, #0
cx3 p0, r0, r13, r0, #0
cx3a p0, r0, r13, r0, #0
cx3 p0, r0, r0, r13, #0
cx3a p0, r0, r0, r13, #0
itttt ne
cx3 p0, r0, r0, r0, #0
cx3a p0, r0, r0, r0, #0
cx3ne p0, r0, r0, r0, #0
cx3aeq p0, r0, r0, r0, #0
cx3 p1, r0, r0, r0, #0
cx3a p1, r0, r0, r0, #0
cx3 p0, r0, r0, r0, r0, #0
cx3a p0, r0, r0, r0, r0, #0
cx3 p0, r0, r0, #0
cx3a p0, r0, r0, #0
cx3 p0, r15, r0, r0, #0
cx3a p0, r15, r0, r0, #0
cx3 p0, r0, r15, r0, #0
cx3a p0, r0, r15, r0, #0
cx3 p0, r0, r0, r15, #0
cx3a p0, r0, r0, r15, #0
# cx3d{a}
# Immediate out of range.
# Each register out of range.
# APSR_nzcv disallowed as destination register.
# rd<odd> => constrained unpredictable
# rd< N > 10 > => constrained unpredictable
# rn13 => constrained unpredictable
# rm13 => constrained unpredictable
# rn15 disallowed (pattern matches APSR_nzcv)
# rm15 disallowed (pattern matches APSR_nzcv)
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Disallow non-incrementing values in destination.
# Too many arguments
# Too little arguments
cx3d p0, r0, r1, r0, r0, #64
cx3da p0, r0, r1, r0, r0, #64
cx3d p0, r0, r1, r0, r0, #-1
cx3da p0, r0, r1, r0, r0, #-1
cx3d p8, r0, r1, r0, r0, #0
cx3da p8, r0, r1, r0, r0, #0
cx3d p0, r16, r17, r0, r0, #0
cx3da p0, r16, r17, r0, r0, #0
cx3d p0, r0, r1, r16, r0, #0
cx3da p0, r0, r1, r16, r0, #0
cx3d p0, r0, r1, r0, r16, #0
cx3da p0, r0, r1, r0, r16, #0
cx3d p0, APSR_nzcv, r15, r0, r0, #0
cx3da p0, APSR_nzcv, r15, r0, r0, #0
cx3d p0, r9, r10, r0, r0, #0
cx3da p0, r9, r10, r0, r0, #0
cx3d p0, r12, r13, r0, r0, #0
cx3da p0, r12, r13, r0, r0, #0
cx3d p0, r0, r1, r13, r0, #0
cx3da p0, r0, r1, r13, r0, #0
cx3d p0, r0, r1, r0, r13, #0
cx3da p0, r0, r1, r0, r13, #0
cx3d p0, r0, r1, r15, r0, #0
cx3da p0, r0, r1, r15, r0, #0
cx3d p0, r0, r1, r0, r15, #0
cx3da p0, r0, r1, r0, r15, #0
itttt ne
cx3d p0, r0, r1, r0, r0, #0
cx3da p0, r0, r1, r0, r0, #0
cx3dne p0, r0, r1, r0, r0, #0
cx3daeq p0, r0, r1, r0, r0, #0
cx3d p1, r0, r1, r0, r0, #0
cx3da p1, r0, r1, r0, r0, #0
cx3d p0, r0, r2, r0, r0, #0
cx3da p0, r0, r2, r0, r0, #0
cx3d p0, r0, r1, r0, r0, r0, #0
cx3da p0, r0, r1, r0, r0, r0, #0
cx3d p0, r0, r0, r0, #0
cx3da p0, r0, r0, r0, #0
# vcx1{a}
# Immediate out of range.
# Each register out of range.
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Too many arguments
# Too little arguments
vcx1 p0, q0, #4096
vcx1a p0, q0, #4096
vcx1 p0, q0, #-1
vcx1a p0, q0, #-1
vcx1 p8, q0, #0
vcx1a p8, q0, #0
vcx1 p0, q8, #0
vcx1a p0, q8, #0
itttt ne
vcx1 p0, q0, #0
vcx1ne p0, q0, #0
vcx1a p0, q0, #0
vcx1ane p0, q0, #0
vcx1 p1, q0, #0
vcx1a p1, q0, #0
vcx1 p0, q0, q0, #0
vcx1a p0, q0, q0, #0
vcx1 p0, #0
vcx1a p0, #0
vcx1 p0, d0, #2048
vcx1a p0, d0, #2048
vcx1 p0, d0, #-1
vcx1a p0, d0, #-1
vcx1 p8, d0, #0
vcx1a p8, d0, #0
vcx1 p0, d16, #0
vcx1a p0, d16, #0
itttt ne
vcx1 p0, d0, #0
vcx1ne p0, d0, #0
vcx1a p0, d0, #0
vcx1ane p0, d0, #0
vcx1 p1, d0, #0
vcx1a p1, d0, #0
vcx1 p0, d0, d0, #0
vcx1a p0, d0, d0, #0
vcx1 p0, #0
vcx1a p0, #0
vcx1 p0, s0, #2048
vcx1a p0, s0, #2048
vcx1 p0, s0, #-1
vcx1a p0, s0, #-1
vcx1 p8, s0, #0
vcx1a p8, s0, #0
vcx1 p0, s32, #0
vcx1a p0, s32, #0
itttt ne
vcx1 p0, s0, #0
vcx1ne p0, s0, #0
vcx1a p0, s0, #0
vcx1ane p0, s0, #0
vcx1 p1, s0, #0
vcx1a p1, s0, #0
vcx1 p0, s0, s0, #0
vcx1a p0, s0, s0, #0
vcx1 p0, #0
vcx1a p0, #0
# vcx2{a}
# Immediate out of range.
# Each register out of range.
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Too many arguments
# Too little arguments
vcx2 p0, q0, q0, #128
vcx2a p0, q0, q0, #128
vcx2 p0, q0, q0, #-1
vcx2a p0, q0, q0, #-1
vcx2 p8, q0, q0, #0
vcx2a p8, q0, q0, #0
vcx2 p0, q8, q0, #0
vcx2a p0, q8, q0, #0
vcx2 p0, q0, q8, #0
vcx2a p0, q0, q8, #0
itttt ne
vcx2 p0, q0, q0, #0
vcx2ne p0, q0, q0, #0
vcx2a p0, q0, q0, #0
vcx2ane p0, q0, q0, #0
vcx2 p1, q0, q0, #0
vcx2a p1, q0, q0, #0
vcx2 p0, q0, q0, q0, #0
vcx2a p0, q0, q0, q0, #0
vcx2 p0, q0, #0
vcx2a p0, q0, #0
vcx2 p0, d0, d0, #64
vcx2a p0, d0, d0, #64
vcx2 p0, d0, d0, #-1
vcx2a p0, d0, d0, #-1
vcx2 p8, d0, d0, #0
vcx2a p8, d0, d0, #0
vcx2 p0, d16, d0, #0
vcx2a p0, d16, d0, #0
vcx2 p0, d0, d16, #0
vcx2a p0, d0, d16, #0
itttt ne
vcx2 p0, d0, d0, #0
vcx2ne p0, d0, d0, #0
vcx2a p0, d0, d0, #0
vcx2ane p0, d0, d0, #0
vcx2 p1, d0, d0, #0
vcx2a p1, d0, d0, #0
vcx2 p0, d0, d0, d0, #0
vcx2a p0, d0, d0, d0, #0
vcx2 p0, d0, #0
vcx2a p0, d0, #0
vcx2 p0, s0, s0, #64
vcx2a p0, s0, s0, #64
vcx2 p0, s0, s0, #-1
vcx2a p0, s0, s0, #-1
vcx2 p8, s0, s0, #0
vcx2a p8, s0, s0, #0
vcx2 p0, s32, s0, #0
vcx2a p0, s32, s0, #0
vcx2 p0, s0, s32, #0
vcx2a p0, s0, s32, #0
itttt ne
vcx2 p0, s0, s0, #0
vcx2ne p0, s0, s0, #0
vcx2a p0, s0, s0, #0
vcx2ane p0, s0, s0, #0
vcx2 p1, s0, s0, #0
vcx2a p1, s0, s0, #0
vcx2 p0, s0, s0, s0, #0
vcx2a p0, s0, s0, s0, #0
vcx2 p0, s0, #0
vcx2a p0, s0, #0
# vcx3{a}
# Immediate out of range.
# Each register out of range.
# IT block => constrained unpredictable
#
# Error given when using coprocessor number not enabled on command line.
# Too many arguments
# Too little arguments
vcx3 p0, q0, q0, q0, #16
vcx3a p0, q0, q0, q0, #16
vcx3 p0, q0, q0, q0, #-1
vcx3a p0, q0, q0, q0, #-1
vcx3 p8, q0, q0, q0, #0
vcx3a p8, q0, q0, q0, #0
vcx3 p0, q8, q0, q0, #0
vcx3a p0, q8, q0, q0, #0
vcx3 p0, q8, q0, q0, #0
vcx3a p0, q0, q8, q0, #0
vcx3 p0, q0, q0, q8, #0
vcx3a p0, q0, q0, q8, #0
itttt ne
vcx3 p0, q0, q0, q0, #0
vcx3ne p0, q0, q0, q0, #0
vcx3a p0, q0, q0, q0, #0
vcx3ane p0, q0, q0, q0, #0
vcx3 p1, q0, q0, q0, #0
vcx3a p1, q0, q0, q0, #0
vcx3 p0, q0, q0, q0, q0, #0
vcx3a p0, q0, q0, q0, q0, #0
vcx3 p0, q0, q0, #0
vcx3a p0, q0, q0, #0
vcx3 p0, d0, d0, d0, #8
vcx3a p0, d0, d0, d0, #8
vcx3 p0, d0, d0, d0, #-1
vcx3a p0, d0, d0, d0, #-1
vcx3 p8, d0, d0, d0, #0
vcx3a p8, d0, d0, d0, #0
vcx3 p0, d16, d0, d0, #0
vcx3a p0, d16, d0, d0, #0
vcx3 p0, d0, d16, d0, #0
vcx3a p0, d0, d16, d0, #0
vcx3 p0, d0, d0, d16, #0
vcx3a p0, d0, d0, d16, #0
itttt ne
vcx3 p0, d0, d0, d0, #0
vcx3ne p0, d0, d0, d0, #0
vcx3a p0, d0, d0, d0, #0
vcx3ane p0, d0, d0, d0, #0
vcx3 p1, d0, d0, d0, #0
vcx3a p1, d0, d0, d0, #0
vcx3 p0, d0, d0, d0, d0, #0
vcx3a p0, d0, d0, d0, d0, #0
vcx3 p0, d0, d0, #0
vcx3a p0, d0, d0, #0
vcx3 p0, s0, s0, s0, #8
vcx3a p0, s0, s0, s0, #8
vcx3 p0, s0, s0, s0, #-1
vcx3a p0, s0, s0, s0, #-1
vcx3 p8, s0, s0, s0, #0
vcx3a p8, s0, s0, s0, #0
vcx3 p0, s32, s0, s0, #0
vcx3a p0, s32, s0, s0, #0
vcx3 p0, s0, s32, s0, #0
vcx3a p0, s0, s32, s0, #0
vcx3 p0, s0, s0, s32, #0
vcx3a p0, s0, s0, s32, #0
itttt ne
vcx3 p0, s0, s0, s0, #0
vcx3ne p0, s0, s0, s0, #0
vcx3a p0, s0, s0, s0, #0
vcx3ane p0, s0, s0, s0, #0
vcx3 p1, s0, s0, s0, #0
vcx3a p1, s0, s0, s0, #0
vcx3 p0, s0, s0, s0, s0, #0
vcx3a p0, s0, s0, s0, s0, #0
vcx3 p0, s0, s0, #0
vcx3a p0, s0, s0, #0
|
stsp/binutils-ia16
| 3,870
|
gas/testsuite/gas/arm/mve-vrmlaldavh-bad.s
|
.macro cond op
.irp cond, eq, ne, gt, ge, lt, le
it \cond
\op\().s32 r0, r1, q2, q3
.endr
.endm
.syntax unified
.thumb
vrmlaldavh.s16 r0, r1, q2, q3
vrmlaldavh.i32 r0, r1, q2, q3
vrmlaldavha.s16 r0, r1, q2, q3
vrmlaldavha.i32 r0, r1, q2, q3
vrmlalvh.s16 r0, r1, q2, q3
vrmlalvh.i32 r0, r1, q2, q3
vrmlalvha.s16 r0, r1, q2, q3
vrmlalvha.i32 r0, r1, q2, q3
vrmlaldavhx.u32 r0, r1, q2, q3
vrmlaldavhax.u32 r0, r1, q2, q3
vrmlaldavhx.i32 r0, r1, q2, q3
vrmlaldavhax.i32 r0, r1, q2, q3
vrmlsldavh.s16 r0, r1, q2, q3
vrmlsldavh.u32 r0, r1, q2, q3
vrmlsldavha.s16 r0, r1, q2, q3
vrmlsldavha.u32 r0, r1, q2, q3
vrmlsldavhx.s16 r0, r1, q2, q3
vrmlsldavhx.u32 r0, r1, q2, q3
vrmlsldavhax.s16 r0, r1, q2, q3
vrmlsldavhax.u32 r0, r1, q2, q3
vrmlaldavh.s32 r1, r1, q2, q3
vrmlaldavh.s32 r0, r0, q2, q3
vrmlaldavh.s32 r0, sp, q2, q3
vrmlaldavh.s32 r0, pc, q2, q3
vrmlaldavha.s32 r1, r1, q2, q3
vrmlaldavha.s32 r0, r0, q2, q3
vrmlaldavha.s32 r0, sp, q2, q3
vrmlaldavha.s32 r0, pc, q2, q3
vrmlaldavhx.s32 r1, r1, q2, q3
vrmlaldavhx.s32 r0, r0, q2, q3
vrmlaldavhx.s32 r0, sp, q2, q3
vrmlaldavhx.s32 r0, pc, q2, q3
vrmlaldavhax.s32 r1, r1, q2, q3
vrmlaldavhax.s32 r0, r0, q2, q3
vrmlaldavhax.s32 r0, sp, q2, q3
vrmlaldavhax.s32 r0, pc, q2, q3
vrmlalvh.s32 r1, r1, q2, q3
vrmlalvh.s32 r0, r0, q2, q3
vrmlalvh.s32 r0, sp, q2, q3
vrmlalvh.s32 r0, pc, q2, q3
vrmlalvha.s32 r1, r1, q2, q3
vrmlalvha.s32 r0, r0, q2, q3
vrmlalvha.s32 r0, sp, q2, q3
vrmlalvha.s32 r0, pc, q2, q3
vrmlsldavh.s32 r1, r1, q2, q3
vrmlsldavh.s32 r0, r0, q2, q3
vrmlsldavh.s32 r0, sp, q2, q3
vrmlsldavh.s32 r0, pc, q2, q3
vrmlsldavha.s32 r1, r1, q2, q3
vrmlsldavha.s32 r0, r0, q2, q3
vrmlsldavha.s32 r0, sp, q2, q3
vrmlsldavha.s32 r0, pc, q2, q3
vrmlsldavhx.s32 r1, r1, q2, q3
vrmlsldavhx.s32 r0, r0, q2, q3
vrmlsldavhx.s32 r0, sp, q2, q3
vrmlsldavhx.s32 r0, pc, q2, q3
vrmlsldavhax.s32 r1, r1, q2, q3
vrmlsldavhax.s32 r0, r0, q2, q3
vrmlsldavhax.s32 r0, sp, q2, q3
vrmlsldavhax.s32 r0, pc, q2, q3
cond vrmlaldavh
cond vrmlaldavha
cond vrmlaldavhx
cond vrmlaldavhax
cond vrmlalvh
cond vrmlalvha
cond vrmlsldavh
cond vrmlsldavha
cond vrmlsldavhx
cond vrmlsldavhax
it eq
vrmlaldavheq.s32 r0, r1, q2, q3
vrmlaldavheq.s32 r0, r1, q2, q3
vpst
vrmlaldavheq.s32 r0, r1, q2, q3
vrmlaldavht.s32 r0, r1, q2, q3
vpst
vrmlaldavh.s32 r0, r1, q2, q3
it eq
vrmlaldavhaeq.s32 r0, r1, q2, q3
vrmlaldavhaeq.s32 r0, r1, q2, q3
vpst
vrmlaldavhaeq.s32 r0, r1, q2, q3
vrmlaldavhat.s32 r0, r1, q2, q3
vpst
vrmlaldavha.s32 r0, r1, q2, q3
it eq
vrmlaldavhxeq.s32 r0, r1, q2, q3
vrmlaldavhxeq.s32 r0, r1, q2, q3
vpst
vrmlaldavhxeq.s32 r0, r1, q2, q3
vrmlaldavhxt.s32 r0, r1, q2, q3
vpst
vrmlaldavhx.s32 r0, r1, q2, q3
it eq
vrmlaldavhaxeq.s32 r0, r1, q2, q3
vrmlaldavhaxeq.s32 r0, r1, q2, q3
vpst
vrmlaldavhaxeq.s32 r0, r1, q2, q3
vrmlaldavhaxt.s32 r0, r1, q2, q3
vpst
vrmlaldavhax.s32 r0, r1, q2, q3
it eq
vrmlalvheq.s32 r0, r1, q2, q3
vrmlalvheq.s32 r0, r1, q2, q3
vpst
vrmlalvheq.s32 r0, r1, q2, q3
vrmlalvht.s32 r0, r1, q2, q3
vpst
vrmlalvh.s32 r0, r1, q2, q3
it eq
vrmlalvhaeq.s32 r0, r1, q2, q3
vrmlalvhaeq.s32 r0, r1, q2, q3
vpst
vrmlalvhaeq.s32 r0, r1, q2, q3
vrmlalvhat.s32 r0, r1, q2, q3
vpst
vrmlalvha.s32 r0, r1, q2, q3
it eq
vrmlsldavheq.s32 r0, r1, q2, q3
vrmlsldavheq.s32 r0, r1, q2, q3
vpst
vrmlsldavheq.s32 r0, r1, q2, q3
vrmlsldavht.s32 r0, r1, q2, q3
vpst
vrmlsldavh.s32 r0, r1, q2, q3
it eq
vrmlsldavhaeq.s32 r0, r1, q2, q3
vrmlsldavhaeq.s32 r0, r1, q2, q3
vpst
vrmlsldavhaeq.s32 r0, r1, q2, q3
vrmlsldavhat.s32 r0, r1, q2, q3
vpst
vrmlsldavha.s32 r0, r1, q2, q3
it eq
vrmlsldavhxeq.s32 r0, r1, q2, q3
vrmlsldavhxeq.s32 r0, r1, q2, q3
vpst
vrmlsldavhxeq.s32 r0, r1, q2, q3
vrmlsldavhxt.s32 r0, r1, q2, q3
vpst
vrmlsldavhx.s32 r0, r1, q2, q3
it eq
vrmlsldavhaxeq.s32 r0, r1, q2, q3
vrmlsldavhaxeq.s32 r0, r1, q2, q3
vpst
vrmlsldavhaxeq.s32 r0, r1, q2, q3
vrmlsldavhaxt.s32 r0, r1, q2, q3
vpst
vrmlsldavhax.s32 r0, r1, q2, q3
|
stsp/binutils-ia16
| 1,311
|
gas/testsuite/gas/arm/armv8_3-a-simd.s
|
.text
A1:
.arm
vcadd.f32 q1,q2,q3,#90
vcadd.f32 q1,q2,q3,#270
vcadd.f16 d21,d22,d23,#90
vcadd.f16 q1,q2,q3,#90
vcadd.f32 d21,d22,d23,#90
vcmla.f32 q1,q2,q3,#0
vcmla.f32 q1,q2,q3,#90
vcmla.f32 q1,q2,q3,#180
vcmla.f32 q1,q2,q3,#270
vcmla.f16 d21,d22,d23,#90
vcmla.f16 q1,q2,q3,#90
vcmla.f32 d21,d22,d23,#90
vcmla.f16 d21,d22,d3[0],#90
vcmla.f16 d21,d22,d3[1],#90
vcmla.f16 q1,q2,d3[0],#90
vcmla.f16 q1,q2,d3[1],#90
vcmla.f32 d21,d22,d23[0],#90
vcmla.f32 q1,q2,d23[0],#90
vcmla.f16 q1,q2,d3[1],#0
vcmla.f16 q1,q2,d3[1],#180
vcmla.f16 q1,q2,d3[1],#270
vcmla.f32 q1,q2,d3[0],#0
vcmla.f32 q1,q2,d3[0],#180
vcmla.f32 q1,q2,d3[0],#270
T1:
.thumb
vcadd.f32 q1,q2,q3,#90
vcadd.f32 q1,q2,q3,#270
vcadd.f16 d21,d22,d23,#90
vcadd.f16 q1,q2,q3,#90
vcadd.f32 d21,d22,d23,#90
vcmla.f32 q1,q2,q3,#0
vcmla.f32 q1,q2,q3,#90
vcmla.f32 q1,q2,q3,#180
vcmla.f32 q1,q2,q3,#270
vcmla.f16 d21,d22,d23,#90
vcmla.f16 q1,q2,q3,#90
vcmla.f32 d21,d22,d23,#90
vcmla.f16 d21,d22,d3[0],#90
vcmla.f16 d21,d22,d3[1],#90
vcmla.f16 q1,q2,d3[0],#90
vcmla.f16 q1,q2,d3[1],#90
vcmla.f32 d21,d22,d23[0],#90
vcmla.f32 q1,q2,d23[0],#90
vcmla.f16 q1,q2,d3[1],#0
vcmla.f16 q1,q2,d3[1],#180
vcmla.f16 q1,q2,d3[1],#270
vcmla.f32 q1,q2,d3[0],#0
vcmla.f32 q1,q2,d3[0],#180
vcmla.f32 q1,q2,d3[0],#270
|
stsp/binutils-ia16
| 1,561
|
gas/testsuite/gas/arm/archv8m-cmse-msr.s
|
T:
## MRS ##
# MSP
mrs r0, MSP
mrs r0, MSP_NS
mrs r0, msp
mrs r0, msp_ns
# PSP
mrs r1, PSP
mrs r1, PSP_NS
mrs r1, psp
mrs r1, psp_ns
# MSPLIM
mrs r2, MSPLIM
mrs r2, MSPLIM_NS
mrs r2, msplim
mrs r2, msplim_ns
# PSPLIM
mrs r3, PSPLIM
mrs r3, PSPLIM_NS
mrs r3, psplim
mrs r3, psplim_ns
# PRIMASK
mrs r4, PRIMASK
mrs r4, PRIMASK_NS
mrs r4, primask
mrs r4, primask_ns
# BASEPRI
mrs r5, BASEPRI
mrs r5, BASEPRI_NS
mrs r5, basepri
mrs r5, basepri_ns
# FAULTMASK
mrs r6, FAULTMASK
mrs r6, FAULTMASK_NS
mrs r6, faultmask
mrs r6, faultmask_ns
# CONTROL
mrs r7, CONTROL
mrs r7, CONTROL_NS
mrs r7, control
mrs r7, control_ns
# SP_NS
mrs r8, SP_NS
mrs r8, sp_ns
## MSR ##
# MSP
msr MSP, r0
msr MSP_NS, r0
msr msp, r0
msr msp_ns, r0
# PSP
msr PSP, r1
msr PSP_NS, r1
msr psp, r1
msr psp_ns, r1
# MSPLIM
msr MSPLIM, r2
msr MSPLIM_NS, r2
msr msplim, r2
msr msplim_ns, r2
# PSPLIM
msr PSPLIM, r3
msr PSPLIM_NS, r3
msr psplim, r3
msr psplim_ns, r3
# PRIMASK
msr PRIMASK, r4
msr PRIMASK_NS, r4
msr primask, r4
msr primask_ns, r4
# BASEPRI
msr BASEPRI, r5
msr BASEPRI_NS, r5
msr basepri, r5
msr basepri_ns, r5
# FAULTMASK
msr FAULTMASK, r6
msr FAULTMASK_NS, r6
msr faultmask, r6
msr faultmask_ns, r6
# CONTROL
msr CONTROL, r7
msr CONTROL_NS, r7
msr control, r7
msr control_ns, r7
# SP_NS
msr SP_NS, r8
msr sp_ns, r8
|
stsp/binutils-ia16
| 2,689
|
gas/testsuite/gas/arm/mve-vstrldr-3.s
|
.syntax unified
.thumb
.macro n_vstr_w_vldr op, imm
.irp op1, q0, q1, q2, q4, q7
.irp op2, r0, r1, r2, r4, r7
\op \op1, [\op2, #\imm]
\op \op1, [\op2, #-\imm]
\op \op1, [\op2, #\imm]!
\op \op1, [\op2, #-\imm]!
\op \op1, [\op2], #\imm
\op \op1, [\op2], #-\imm
.endr
.endr
.endm
.irp mnem, vstrb.16, vstrb.32
.irp imm, 0, 1, 2, 4, 8, 16, 32, 64, 127, 120, 15
n_vstr_w_vldr \mnem, \imm
.endr
.endr
.irp imm, 0, 2, 4, 8, 16, 32, 64, 128, 254, 240, 30
n_vstr_w_vldr vstrh.32, \imm
.endr
.macro wb_same_size_vstr_vldr op, imm
.irp op1, q0, q1, q2, q4, q7
.irp op2, r0, r1, r2, r4, r7, r8, r10, r12, r14
\op \op1, [\op2, #\imm]!
\op \op1, [\op2, #-\imm]!
\op \op1, [\op2], #\imm
\op \op1, [\op2], #-\imm
.endr
.endr
.endm
.macro no_wb_same_size_vstr_vldr op, imm
.irp op1, q0, q1, q2, q4, q7
.irp op2, r0, r1, r2, r4, r7, r8, r10, r12, r13, r14
\op \op1, [\op2, #\imm]
\op \op1, [\op2, #-\imm]
.endr
.endr
.endm
.irp mnem, vstrb.8, vstrb.s8, vstrb.u8
.irp imm, 0, 1, 2, 4, 8, 16, 32, 64, 127, 120, 15
wb_same_size_vstr_vldr \mnem, \imm
no_wb_same_size_vstr_vldr \mnem, \imm
.endr
.endr
.irp mnem, vstrh.16, vstrh.s16, vstrh.u16, vstrh.f16
.irp imm, 0, 2, 4, 8, 16, 32, 64, 128, 254, 240, 30
wb_same_size_vstr_vldr \mnem, \imm
no_wb_same_size_vstr_vldr \mnem, \imm
.endr
.endr
.irp mnem, vstrw.32, vstrw.s32, vstrw.u32, vstrw.f32
.irp imm, 0, 4, 8, 16, 32, 64, 128, 256, 508, 480, 60
wb_same_size_vstr_vldr \mnem, \imm
no_wb_same_size_vstr_vldr \mnem, \imm
.endr
.endr
vpstet
vstrbt.u8 q0, [r12, #1]
vstrbe.16 q3, [r2, #-127]
vstrbt.32 q3, [r3, #-93]!
vpstete
vstrht.f16 q5, [r4], #254
vstrhe.32 q5, [r0, #126]
vstrwt.32 q3, [r5, #508]
vstrwe.u32 q5, [r8], #244
.irp mnem, vldrb.s16, vldrb.u16, vldrb.s32, vldrb.u32
.irp imm, 0, 1, 2, 4, 8, 16, 32, 64, 127, 120, 15
n_vstr_w_vldr \mnem, \imm
.endr
.endr
.irp mnem, vldrh.s32, vldrh.u32
.irp imm, 0, 2, 4, 8, 16, 32, 64, 128, 254, 240, 30
n_vstr_w_vldr \mnem, \imm
.endr
.endr
.irp mnem, vldrb.8, vldrb.s8, vldrb.u8
.irp imm, 0, 1, 2, 4, 8, 16, 32, 64, 127, 120, 15
wb_same_size_vstr_vldr \mnem, \imm
no_wb_same_size_vstr_vldr \mnem, \imm
.endr
.endr
.irp mnem, vldrh.16, vldrh.s16, vldrh.u16, vldrh.f16
.irp imm, 0, 2, 4, 8, 16, 32, 64, 128, 254, 240, 30
wb_same_size_vstr_vldr \mnem, \imm
no_wb_same_size_vstr_vldr \mnem, \imm
.endr
.endr
.irp mnem, vldrw.32, vldrw.s32, vldrw.u32, vldrw.f32
.irp imm, 0, 4, 8, 16, 32, 64, 128, 256, 508, 480, 60
wb_same_size_vstr_vldr \mnem, \imm
no_wb_same_size_vstr_vldr \mnem, \imm
.endr
.endr
vpstet
vldrbt.u8 q0, [r12, #1]
vldrbe.u16 q3, [r2, #-127]
vldrbt.u32 q3, [r3, #-93]!
vpstete
vldrht.f16 q5, [r4], #254
vldrhe.s32 q5, [r0, #126]
vldrwt.32 q3, [r5, #508]
vldrwe.u32 q5, [r8], #244
|
stsp/binutils-ia16
| 1,052
|
gas/testsuite/gas/arm/mve-vcvt-bad-4.s
|
.macro cond
.irp round, a, n, p, m
.irp cond, eq, ne, gt, ge, lt, le
.irp size, .s16.f16, .u16.f16, .s32.f32, .u32.f32
it \cond
vcvt\round\size q0, q1
.endr
.endr
.endr
.endm
.syntax unified
.thumb
cond
vcvta.s64.f64 q0, q1
vcvta.u64.f64 q0, q1
vcvta.f64.s64 q0, q1
vcvta.f64.u64 q0, q1
vcvtn.s64.f64 q0, q1
vcvtn.u64.f64 q0, q1
vcvtn.f64.s64 q0, q1
vcvtn.f64.u64 q0, q1
vcvtp.s64.f64 q0, q1
vcvtp.u64.f64 q0, q1
vcvtp.f64.s64 q0, q1
vcvtp.f64.u64 q0, q1
vcvtm.s64.f64 q0, q1
vcvtm.u64.f64 q0, q1
vcvtm.f64.s64 q0, q1
vcvtm.f64.u64 q0, q1
it eq
vcvtaeq.s32.f32 q0, q1
vcvtaeq.s32.f32 q0, q1
vpst
vcvtaeq.s32.f32 q0, q1
vcvtat.s32.f32 q0, q1
vpst
vcvta.s32.f32 q0, q1
it eq
vcvtneq.s32.f32 q0, q1
vcvtneq.s32.f32 q0, q1
vpst
vcvtneq.s32.f32 q0, q1
vcvtnt.s32.f32 q0, q1
vpst
vcvtn.s32.f32 q0, q1
it eq
vcvtpeq.s32.f32 q0, q1
vcvtpeq.s32.f32 q0, q1
vpst
vcvtpeq.s32.f32 q0, q1
vcvtpt.s32.f32 q0, q1
vpst
vcvtp.s32.f32 q0, q1
it eq
vcvtmeq.s32.f32 q0, q1
vcvtmeq.s32.f32 q0, q1
vpst
vcvtmeq.s32.f32 q0, q1
vcvtmt.s32.f32 q0, q1
vpst
vcvtm.s32.f32 q0, q1
|
stsp/binutils-ia16
| 13,442
|
gas/testsuite/gas/arm/neon-cov.s
|
@ Neon tests. Basic bitfield tests, using zero for as many registers/fields as
@ possible, but without causing instructions to be badly-formed.
.arm
.syntax unified
.text
.macro regs3_1 op opq vtype
\op\vtype q0,q0,q0
\opq\vtype q0,q0,q0
\op\vtype d0,d0,d0
.endm
.macro dregs3_1 op vtype
\op\vtype d0,d0,d0
.endm
.macro regn3_1 op operand2 vtype
\op\vtype d0,q0,\operand2
.endm
.macro regl3_1 op operand2 vtype
\op\vtype q0,d0,\operand2
.endm
.macro regw3_1 op operand2 vtype
\op\vtype q0,q0,\operand2
.endm
.macro regs2_1 op opq vtype
\op\vtype q0,q0
\opq\vtype q0,q0
\op\vtype d0,d0
.endm
.macro regs3_su_32 op opq
regs3_1 \op \opq .s8
regs3_1 \op \opq .s16
regs3_1 \op \opq .s32
regs3_1 \op \opq .u8
regs3_1 \op \opq .u16
regs3_1 \op \opq .u32
.endm
regs3_su_32 vaba vabaq
regs3_su_32 vhadd vhaddq
regs3_su_32 vrhadd vrhaddq
regs3_su_32 vhsub vhsubq
.macro regs3_su_64 op opq
regs3_1 \op \opq .s8
regs3_1 \op \opq .s16
regs3_1 \op \opq .s32
regs3_1 \op \opq .s64
regs3_1 \op \opq .u8
regs3_1 \op \opq .u16
regs3_1 \op \opq .u32
regs3_1 \op \opq .u64
.endm
regs3_su_64 vqadd vqaddq
regs3_su_64 vqsub vqsubq
regs3_su_64 vrshl vrshlq
regs3_su_64 vqrshl vqrshlq
regs3_su_64 vshl vshlq
regs3_su_64 vqshl vqshlq
.macro regs2i_1 op opq imm vtype
\op\vtype q0,q0,\imm
\opq\vtype q0,q0,\imm
\op\vtype d0,d0,\imm
.endm
.macro regs2i_su_64 op opq imm
regs2i_1 \op \opq \imm .s8
regs2i_1 \op \opq \imm .s16
regs2i_1 \op \opq \imm .s32
regs2i_1 \op \opq \imm .s64
regs2i_1 \op \opq \imm .u8
regs2i_1 \op \opq \imm .u16
regs2i_1 \op \opq \imm .u32
regs2i_1 \op \opq \imm .u64
.endm
.macro regs2i_i_64 op opq imm
regs2i_1 \op \opq \imm .i8
regs2i_1 \op \opq \imm .i16
regs2i_1 \op \opq \imm .i32
regs2i_1 \op \opq \imm .s32
regs2i_1 \op \opq \imm .u32
regs2i_1 \op \opq \imm .i64
.endm
regs2i_i_64 vshl vshlq 0
regs2i_su_64 vqshl vqshlq 0
.macro regs3_ntyp op opq
regs3_1 \op \opq .8
.endm
regs3_ntyp vand vandq
regs3_ntyp vbic vbicq
regs3_ntyp vorr vorrq
regs3_ntyp vorn vornq
regs3_ntyp veor veorq
.macro logic_imm_1 op opq imm vtype
\op\vtype q0,\imm
\opq\vtype q0,\imm
\op\vtype d0,\imm
.endm
.macro logic_imm op opq
logic_imm_1 \op \opq 0x000000a5000000a5 .i64
logic_imm_1 \op \opq 0x0000a5000000a500 .i64
logic_imm_1 \op \opq 0x00a5000000a50000 .i64
logic_imm_1 \op \opq 0xa5000000a5000000 .i64
logic_imm_1 \op \opq 0x00a500a500a500a5 .i64
logic_imm_1 \op \opq 0xa500a500a500a500 .i64
logic_imm_1 \op \opq 0x000000ff .i32
logic_imm_1 \op \opq 0x000000ff .s32
logic_imm_1 \op \opq 0x000000ff .u32
logic_imm_1 \op \opq 0x0000ff00 .i32
logic_imm_1 \op \opq 0x00ff0000 .i32
logic_imm_1 \op \opq 0xff000000 .i32
logic_imm_1 \op \opq 0x00a500a5 .i32
logic_imm_1 \op \opq 0xa500a500 .i32
logic_imm_1 \op \opq 0x00ff .i16
logic_imm_1 \op \opq 0xff00 .i16
logic_imm_1 \op \opq 0x00 .i8
.endm
logic_imm vbic vbicq
logic_imm vorr vorrq
.macro logic_inv_imm op opq
logic_imm_1 \op \opq 0xffffff5affffff5a .i64
logic_imm_1 \op \opq 0xffff5affffff5aff .i64
logic_imm_1 \op \opq 0xff5affffff5affff .i64
logic_imm_1 \op \opq 0x5affffff5affffff .i64
logic_imm_1 \op \opq 0xff5aff5aff5aff5a .i64
logic_imm_1 \op \opq 0x5aff5aff5aff5aff .i64
logic_imm_1 \op \opq 0xffffff00 .i32
logic_imm_1 \op \opq 0xffffff00 .s32
logic_imm_1 \op \opq 0xffffff00 .u32
logic_imm_1 \op \opq 0xffff00ff .i32
logic_imm_1 \op \opq 0xff00ffff .i32
logic_imm_1 \op \opq 0x00ffffff .i32
logic_imm_1 \op \opq 0xff5aff5a .i32
logic_imm_1 \op \opq 0x5aff5aff .i32
logic_imm_1 \op \opq 0xff00 .i16
logic_imm_1 \op \opq 0x00ff .i16
logic_imm_1 \op \opq 0xff .i8
.endm
logic_inv_imm vand vandq
logic_inv_imm vorn vornq
regs3_ntyp vbsl vbslq
regs3_ntyp vbit vbitq
regs3_ntyp vbif vbifq
.macro regs3_suf_32 op opq
regs3_1 \op \opq .s8
regs3_1 \op \opq .s16
regs3_1 \op \opq .s32
regs3_1 \op \opq .u8
regs3_1 \op \opq .u16
regs3_1 \op \opq .u32
regs3_1 \op \opq .f32
.endm
.macro regs3_if_32 op opq
regs3_1 \op \opq .i8
regs3_1 \op \opq .i16
regs3_1 \op \opq .i32
regs3_1 \op \opq .s32
regs3_1 \op \opq .u32
regs3_1 \op \opq .f32
.endm
regs3_suf_32 vabd vabdq
regs3_suf_32 vmax vmaxq
regs3_suf_32 vmin vminq
regs3_suf_32 vcge vcgeq
regs3_suf_32 vcgt vcgtq
regs3_suf_32 vcle vcleq
regs3_suf_32 vclt vcltq
regs3_if_32 vceq vceqq
.macro regs2i_sf_0 op opq
regs2i_1 \op \opq 0 .s8
regs2i_1 \op \opq 0 .s16
regs2i_1 \op \opq 0 .s32
regs2i_1 \op \opq 0 .f32
.endm
regs2i_sf_0 vcge vcgeq
regs2i_sf_0 vcgt vcgtq
regs2i_sf_0 vcle vcleq
regs2i_sf_0 vclt vcltq
.macro regs2i_if_0 op opq
regs2i_1 \op \opq 0 .i8
regs2i_1 \op \opq 0 .i16
regs2i_1 \op \opq 0 .i32
regs2i_1 \op \opq 0 .s32
regs2i_1 \op \opq 0 .u32
regs2i_1 \op \opq 0 .f32
.endm
regs2i_if_0 vceq vceqq
.macro dregs3_suf_32 op
dregs3_1 \op .s8
dregs3_1 \op .s16
dregs3_1 \op .s32
dregs3_1 \op .u8
dregs3_1 \op .u16
dregs3_1 \op .u32
dregs3_1 \op .f32
.endm
dregs3_suf_32 vpmax
dregs3_suf_32 vpmin
.macro sregs3_1 op opq vtype
\op\vtype q0,q0,q0
\opq\vtype q0,q0,q0
\op\vtype d0,d0,d0
.endm
.macro sclr21_1 op opq vtype
\op\vtype q0,q0,d0[0]
\opq\vtype q0,q0,d0[0]
\op\vtype d0,d0,d0[0]
.endm
.macro mul_incl_scalar op opq
regs3_1 \op \opq .i8
regs3_1 \op \opq .i16
regs3_1 \op \opq .i32
regs3_1 \op \opq .s32
regs3_1 \op \opq .u32
regs3_1 \op \opq .f32
sclr21_1 \op \opq .i16
sclr21_1 \op \opq .i32
sclr21_1 \op \opq .s32
sclr21_1 \op \opq .u32
sclr21_1 \op \opq .f32
.endm
mul_incl_scalar vmla vmlaq
mul_incl_scalar vmls vmlsq
.macro dregs3_if_32 op
dregs3_1 \op .i8
dregs3_1 \op .i16
dregs3_1 \op .i32
dregs3_1 \op .s32
dregs3_1 \op .u32
dregs3_1 \op .f32
.endm
dregs3_if_32 vpadd
.macro regs3_if_64 op opq
regs3_1 \op \opq .i8
regs3_1 \op \opq .i16
regs3_1 \op \opq .i32
regs3_1 \op \opq .s32
regs3_1 \op \opq .u32
regs3_1 \op \opq .i64
regs3_1 \op \opq .f32
.endm
regs3_if_64 vadd vaddq
regs3_if_64 vsub vsubq
.macro regs3_sz_32 op opq
regs3_1 \op \opq .8
regs3_1 \op \opq .16
regs3_1 \op \opq .32
.endm
regs3_sz_32 vtst vtstq
.macro regs3_ifp_32 op opq
regs3_1 \op \opq .i8
regs3_1 \op \opq .i16
regs3_1 \op \opq .i32
regs3_1 \op \opq .s32
regs3_1 \op \opq .u32
regs3_1 \op \opq .f32
regs3_1 \op \opq .p8
.endm
regs3_ifp_32 vmul vmulq
.macro dqmulhs op opq
regs3_1 \op \opq .s16
regs3_1 \op \opq .s32
sclr21_1 \op \opq .s16
sclr21_1 \op \opq .s32
.endm
dqmulhs vqdmulh vqdmulhq
dqmulhs vqrdmulh vqrdmulhq
regs3_1 vacge vacgeq .f32
regs3_1 vacgt vacgtq .f32
regs3_1 vacle vacleq .f32
regs3_1 vaclt vacltq .f32
regs3_1 vrecps vrecpsq .f32
regs3_1 vrsqrts vrsqrtsq .f32
.macro regs2_sf_32 op opq
regs2_1 \op \opq .s8
regs2_1 \op \opq .s16
regs2_1 \op \opq .s32
regs2_1 \op \opq .f32
.endm
regs2_sf_32 vabs vabsq
regs2_sf_32 vneg vnegq
.macro rshift_imm op opq
regs2i_1 \op \opq 7 .s8
regs2i_1 \op \opq 15 .s16
regs2i_1 \op \opq 31 .s32
regs2i_1 \op \opq 63 .s64
regs2i_1 \op \opq 7 .u8
regs2i_1 \op \opq 15 .u16
regs2i_1 \op \opq 31 .u32
regs2i_1 \op \opq 63 .u64
.endm
rshift_imm vshr vshrq
rshift_imm vrshr vrshrq
rshift_imm vsra vsraq
rshift_imm vrsra vrsraq
regs2i_1 vsli vsliq 0 .8
regs2i_1 vsli vsliq 0 .16
regs2i_1 vsli vsliq 0 .32
regs2i_1 vsli vsliq 0 .64
regs2i_1 vsri vsriq 7 .8
regs2i_1 vsri vsriq 15 .16
regs2i_1 vsri vsriq 31 .32
regs2i_1 vsri vsriq 63 .64
regs2i_1 vqshlu vqshluq 0 .s8
regs2i_1 vqshlu vqshluq 0 .s16
regs2i_1 vqshlu vqshluq 0 .s32
regs2i_1 vqshlu vqshluq 0 .s64
.macro qrshift_imm op
regn3_1 \op 7 .s16
regn3_1 \op 15 .s32
regn3_1 \op 31 .s64
regn3_1 \op 7 .u16
regn3_1 \op 15 .u32
regn3_1 \op 31 .u64
.endm
.macro qrshiftu_imm op
regn3_1 \op 7 .s16
regn3_1 \op 15 .s32
regn3_1 \op 31 .s64
.endm
.macro qrshifti_imm op
regn3_1 \op 7 .i16
regn3_1 \op 15 .i32
regn3_1 \op 15 .s32
regn3_1 \op 15 .u32
regn3_1 \op 31 .i64
.endm
qrshift_imm vqshrn
qrshift_imm vqrshrn
qrshiftu_imm vqshrun
qrshiftu_imm vqrshrun
qrshifti_imm vshrn
qrshifti_imm vrshrn
regl3_1 vshll 1 .s8
regl3_1 vshll 1 .s16
regl3_1 vshll 1 .s32
regl3_1 vshll 1 .u8
regl3_1 vshll 1 .u16
regl3_1 vshll 1 .u32
regl3_1 vshll 8 .i8
regl3_1 vshll 16 .i16
regl3_1 vshll 32 .i32
regl3_1 vshll 32 .s32
regl3_1 vshll 32 .u32
.macro convert op opr arg="" t1=".s32.f32" t2=".u32.f32" t3=".f32.s32" t4=".f32.u32"
\op\t1 \opr,\opr\arg
\op\t2 \opr,\opr\arg
\op\t3 \opr,\opr\arg
\op\t4 \opr,\opr\arg
.endm
convert vcvt q0
convert vcvtq q0
convert vcvt d0
convert vcvt q0 ",1"
convert vcvtq q0 ",1"
convert vcvt d0 ",1"
vmov q0,q0
vmov d0,d0
vmov.8 d0[0],r0
vmov.16 d0[0],r0
vmov.32 d0[0],r0
vmov d0,r0,r0
vmov.s8 r0,d0[0]
vmov.s16 r0,d0[0]
vmov.u8 r0,d0[0]
vmov.u16 r0,d0[0]
vmov.32 r0,d0[0]
vmov r0,r1,d0
.macro mov_imm op imm vtype
\op\vtype q0,\imm
\op\vtype d0,\imm
.endm
mov_imm vmov 0x00000077 .i32
mov_imm vmov 0x00000077 .s32
mov_imm vmov 0x00000077 .u32
mov_imm vmvn 0x00000077 .i32
mov_imm vmvn 0x00000077 .s32
mov_imm vmvn 0x00000077 .u32
mov_imm vmov 0x00007700 .i32
mov_imm vmvn 0x00007700 .i32
mov_imm vmov 0x00770000 .i32
mov_imm vmvn 0x00770000 .i32
mov_imm vmov 0x77000000 .i32
mov_imm vmvn 0x77000000 .i32
mov_imm vmov 0x0077 .i16
mov_imm vmvn 0x0077 .i16
mov_imm vmov 0x7700 .i16
mov_imm vmvn 0x7700 .i16
mov_imm vmov 0x000077ff .i32
mov_imm vmvn 0x000077ff .i32
mov_imm vmov 0x0077ffff .i32
mov_imm vmvn 0x0077ffff .i32
mov_imm vmov 0x77 .i8
mov_imm vmov 0xff0000ff000000ff .i64
mov_imm vmov 4.25 .f32
mov_imm vmov 0xa5a5 .i16
mov_imm vmvn 0xa5a5 .i16
mov_imm vmov 0xa5a5a5a5 .i32
mov_imm vmvn 0xa5a5a5a5 .i32
mov_imm vmov 0x00a500a5 .i32
mov_imm vmov 0xa500a500 .i32
mov_imm vmov 0xa5a5a5a5a5a5a5a5 .i64
mov_imm vmvn 0xa5a5a5a5a5a5a5a5 .i64
mov_imm vmov 0x00a500a500a500a5 .i64
mov_imm vmov 0xa500a500a500a500 .i64
mov_imm vmov 0x000000a5000000a5 .i64
mov_imm vmov 0x0000a5000000a500 .i64
mov_imm vmov 0x00a5000000a50000 .i64
mov_imm vmov 0xa5000000a5000000 .i64
mov_imm vmov 0x0000a5ff0000a5ff .i64
mov_imm vmov 0x00a5ffff00a5ffff .i64
mov_imm vmov 0xa5ffffffa5ffffff .i64
vmvn q0,q0
vmvnq q0,q0
vmvn d0,d0
.macro long_ops op
regl3_1 \op d0 .s8
regl3_1 \op d0 .s16
regl3_1 \op d0 .s32
regl3_1 \op d0 .u8
regl3_1 \op d0 .u16
regl3_1 \op d0 .u32
.endm
long_ops vabal
long_ops vabdl
long_ops vaddl
long_ops vsubl
.macro long_mac op
regl3_1 \op d0 .s8
regl3_1 \op d0 .s16
regl3_1 \op d0 .s32
regl3_1 \op d0 .u8
regl3_1 \op d0 .u16
regl3_1 \op d0 .u32
regl3_1 \op "d0[0]" .s16
regl3_1 \op "d0[0]" .s32
regl3_1 \op "d0[0]" .u16
regl3_1 \op "d0[0]" .u32
.endm
long_mac vmlal
long_mac vmlsl
.macro wide_ops op
regw3_1 \op d0 .s8
regw3_1 \op d0 .s16
regw3_1 \op d0 .s32
regw3_1 \op d0 .u8
regw3_1 \op d0 .u16
regw3_1 \op d0 .u32
.endm
wide_ops vaddw
wide_ops vsubw
.macro narr_ops op
regn3_1 \op q0 .i16
regn3_1 \op q0 .i32
regn3_1 \op q0 .s32
regn3_1 \op q0 .u32
regn3_1 \op q0 .i64
.endm
narr_ops vaddhn
narr_ops vraddhn
narr_ops vsubhn
narr_ops vrsubhn
.macro long_dmac op
regl3_1 \op d0 .s16
regl3_1 \op d0 .s32
regl3_1 \op "d0[0]" .s16
regl3_1 \op "d0[0]" .s32
.endm
long_dmac vqdmlal
long_dmac vqdmlsl
long_dmac vqdmull
regl3_1 vmull d0 .s8
regl3_1 vmull d0 .s16
regl3_1 vmull d0 .s32
regl3_1 vmull d0 .u8
regl3_1 vmull d0 .u16
regl3_1 vmull d0 .u32
regl3_1 vmull d0 .p8
regl3_1 vmull "d0[0]" .s16
regl3_1 vmull "d0[0]" .s32
regl3_1 vmull "d0[0]" .u16
regl3_1 vmull "d0[0]" .u32
vext.8 q0,q0,q0,0
vextq.8 q0,q0,q0,0
vext.8 d0,d0,d0,0
vext.8 q0,q0,q0,8
.macro revs op opq vtype
\op\vtype q0,q0
\opq\vtype q0,q0
\op\vtype d0,d0
.endm
revs vrev64 vrev64q .8
revs vrev64 vrev64q .16
revs vrev64 vrev64q .32
revs vrev32 vrev32q .8
revs vrev32 vrev32q .16
revs vrev16 vrev16q .8
.macro dups op opq vtype
\op\vtype q0,r0
\opq\vtype q0,r0
\op\vtype d0,r0
\op\vtype q0,d0[0]
\opq\vtype q0,d0[0]
\op\vtype d0,d0[0]
.endm
dups vdup vdupq .8
dups vdup vdupq .16
dups vdup vdupq .32
.macro binop_3typ op op1 op2 t1 t2 t3
\op\t1 \op1,\op2
\op\t2 \op1,\op2
\op\t3 \op1,\op2
.endm
binop_3typ vmovl q0 d0 .s8 .s16 .s32
binop_3typ vmovl q0 d0 .u8 .u16 .u32
binop_3typ vmovn d0 q0 .i16 .i32 .i64
vmovn.s32 d0, q0
vmovn.u32 d0, q0
binop_3typ vqmovn d0 q0 .s16 .s32 .s64
binop_3typ vqmovn d0 q0 .u16 .u32 .u64
binop_3typ vqmovun d0 q0 .s16 .s32 .s64
.macro binops op opq vtype="" rhs="0"
\op\vtype q0,q\rhs
\opq\vtype q0,q\rhs
\op\vtype d0,d\rhs
.endm
.macro regs2_sz_32 op opq
binops \op \opq .8 1
binops \op \opq .16 1
binops \op \opq .32 1
.endm
regs2_sz_32 vzip vzipq
regs2_sz_32 vuzp vuzpq
.macro regs2_s_32 op opq
binops \op \opq .s8
binops \op \opq .s16
binops \op \opq .s32
.endm
regs2_s_32 vqabs vqabsq
regs2_s_32 vqneg vqnegq
.macro regs2_su_32 op opq
regs2_s_32 \op \opq
binops \op \opq .u8
binops \op \opq .u16
binops \op \opq .u32
.endm
regs2_su_32 vpadal vpadalq
regs2_su_32 vpaddl vpaddlq
binops vrecpe vrecpeq .u32
binops vrecpe vrecpeq .f32
binops vrsqrte vrsqrteq .u32
binops vrsqrte vrsqrteq .f32
regs2_s_32 vcls vclsq
.macro regs2_i_32 op opq
binops \op \opq .i8
binops \op \opq .i16
binops \op \opq .i32
binops \op \opq .s32
binops \op \opq .u32
.endm
regs2_i_32 vclz vclzq
binops vcnt vcntq .8
binops vswp vswpq "" 1
regs2_sz_32 vtrn vtrnq
vtbl.8 d0,{d0},d0
vtbx.8 d0,{d0},d0
|
stsp/binutils-ia16
| 2,802
|
gas/testsuite/gas/arm/fpa-dyadic.s
|
.text
.globl F
F:
adfs f0, f0, f0
adfsp f0, f0, f0
adfsm f0, f0, f0
adfsz f0, f0, f0
adfd f0, f0, f0
adfdp f0, f0, f0
adfdm f0, f0, f0
adfdz f0, f0, f0
adfe f0, f0, f0
adfep f0, f0, f0
adfem f0, f0, f0
adfez f0, f0, f0
sufs f0, f0, f0
sufsp f0, f0, f0
sufsm f0, f0, f0
sufsz f0, f0, f0
sufd f0, f0, f0
sufdp f0, f0, f0
sufdm f0, f0, f0
sufdz f0, f0, f0
sufe f0, f0, f0
sufep f0, f0, f0
sufem f0, f0, f0
sufez f0, f0, f0
rsfs f0, f0, f0
rsfsp f0, f0, f0
rsfsm f0, f0, f0
rsfsz f0, f0, f0
rsfd f0, f0, f0
rsfdp f0, f0, f0
rsfdm f0, f0, f0
rsfdz f0, f0, f0
rsfe f0, f0, f0
rsfep f0, f0, f0
rsfem f0, f0, f0
rsfez f0, f0, f0
mufs f0, f0, f0
mufsp f0, f0, f0
mufsm f0, f0, f0
mufsz f0, f0, f0
mufd f0, f0, f0
mufdp f0, f0, f0
mufdm f0, f0, f0
mufdz f0, f0, f0
mufe f0, f0, f0
mufep f0, f0, f0
mufem f0, f0, f0
mufez f0, f0, f0
dvfs f0, f0, f0
dvfsp f0, f0, f0
dvfsm f0, f0, f0
dvfsz f0, f0, f0
dvfd f0, f0, f0
dvfdp f0, f0, f0
dvfdm f0, f0, f0
dvfdz f0, f0, f0
dvfe f0, f0, f0
dvfep f0, f0, f0
dvfem f0, f0, f0
dvfez f0, f0, f0
rdfs f0, f0, f0
rdfsp f0, f0, f0
rdfsm f0, f0, f0
rdfsz f0, f0, f0
rdfd f0, f0, f0
rdfdp f0, f0, f0
rdfdm f0, f0, f0
rdfdz f0, f0, f0
rdfe f0, f0, f0
rdfep f0, f0, f0
rdfem f0, f0, f0
rdfez f0, f0, f0
pows f0, f0, f0
powsp f0, f0, f0
powsm f0, f0, f0
powsz f0, f0, f0
powd f0, f0, f0
powdp f0, f0, f0
powdm f0, f0, f0
powdz f0, f0, f0
powe f0, f0, f0
powep f0, f0, f0
powem f0, f0, f0
powez f0, f0, f0
rpws f0, f0, f0
rpwsp f0, f0, f0
rpwsm f0, f0, f0
rpwsz f0, f0, f0
rpwd f0, f0, f0
rpwdp f0, f0, f0
rpwdm f0, f0, f0
rpwdz f0, f0, f0
rpwe f0, f0, f0
rpwep f0, f0, f0
rpwem f0, f0, f0
rpwez f0, f0, f0
rmfs f0, f0, f0
rmfsp f0, f0, f0
rmfsm f0, f0, f0
rmfsz f0, f0, f0
rmfd f0, f0, f0
rmfdp f0, f0, f0
rmfdm f0, f0, f0
rmfdz f0, f0, f0
rmfe f0, f0, f0
rmfep f0, f0, f0
rmfem f0, f0, f0
rmfez f0, f0, f0
fmls f0, f0, f0
fmlsp f0, f0, f0
fmlsm f0, f0, f0
fmlsz f0, f0, f0
fmld f0, f0, f0
fmldp f0, f0, f0
fmldm f0, f0, f0
fmldz f0, f0, f0
fmle f0, f0, f0
fmlep f0, f0, f0
fmlem f0, f0, f0
fmlez f0, f0, f0
fdvs f0, f0, f0
fdvsp f0, f0, f0
fdvsm f0, f0, f0
fdvsz f0, f0, f0
fdvd f0, f0, f0
fdvdp f0, f0, f0
fdvdm f0, f0, f0
fdvdz f0, f0, f0
fdve f0, f0, f0
fdvep f0, f0, f0
fdvem f0, f0, f0
fdvez f0, f0, f0
frds f0, f0, f0
frdsp f0, f0, f0
frdsm f0, f0, f0
frdsz f0, f0, f0
frdd f0, f0, f0
frddp f0, f0, f0
frddm f0, f0, f0
frddz f0, f0, f0
frde f0, f0, f0
frdep f0, f0, f0
frdem f0, f0, f0
frdez f0, f0, f0
pols f0, f0, f0
polsp f0, f0, f0
polsm f0, f0, f0
polsz f0, f0, f0
pold f0, f0, f0
poldp f0, f0, f0
poldm f0, f0, f0
poldz f0, f0, f0
pole f0, f0, f0
polep f0, f0, f0
polem f0, f0, f0
polez f0, f0, f0
|
stsp/binutils-ia16
| 3,936
|
gas/testsuite/gas/arm/iwmmxt.s
|
.text
.global iwmmxt
iwmmxt:
tandcb r15
TANDCHLE r15
TANDCWge r15
TBCSTBlt wr0, r1
tbcsth wr1, r2
TBCSTWGT wr2, r3
textrcb r15, #7
textrcheq r15, #2
TEXTRCW r15, #0
TEXTRMUB r14, wr3, #6
textrmsbne r13, wr4, #5
textrmUH r12, wr5, #2
textrmSh r11, wr6, #0
TEXTRMUWcs r10, wr7, #1
textrmswhs r9, wr8, #0
TINSRB wr9, r8, #4
tinsrhcc wr10, r7, #0
tinsrw wr11, r6, #1
tmcrul wcid, r5
TMCRR wr12, r6, r7
tmialo wr13, r5, r4
tmiaphMI wr14, r3, r2
TMIAbb wr15, r0, r1
TMIAbTpl wr13, r2, r3
tmiaBtvs wr1, r4, r5
tmiaTTvc wr2, r6, r7
tmovmskB r8, wr3
TMOVMSKHhi r9, wr4
tmovmskwls r10, wr5
tmrc r11, wcon
TMRRCge r12, r13, wr6
torcb r15
torchlt r15
TORCW r15
waccb wr7, wr8
WACCHlt wr9, wr10
WACCWGT wr11, wr12
waddble wr13, wr14, wr15
waddBUS wr0, wr2, wr4
waddbssal wr6, wr8, wr10
waddH wr12, wr14, wr15
WADDHUSLE wr13, wr12, wr11
WADDHSSeq wr10, wr9, wr8
WADDWne wr7, wr6, wr5
waddwus wr4, wr3, wr2
waddwsscs wr1, wr0, wr15
waligni wr3, wr5, wr7, #5
WALIGNR0hs wr9, wr11, wr13
walignr1 wr7, wr6, wr5
walignr2cc wr2, wr4, wr8
WALIGNR3ul wr5, wr9, wr1
wand wr3, wr8, wr1
wandn wr3, wr2, wr6
wavg2b wr7, wr8, wr9
wavg2hle wr10, wr11, wr12
wavg2brge wr13, wr14, wr15
wavg2hr wr0, wr1, wr12
wcmpeqb wr13, wr4, wr5
wcmpeqheq wr4, wr7, wr0
wcmpeqWlt wr6, wr9, wr8
wcmpgtUbul wr1, wr2, wr3
wcmpgtsb wr4, wr5, wr6
wcmpgtuhcc wr7, wr8, wr9
wcmpgtsh wr10, wr11, wr13
wcmpgtuw wr2, wr4, wr3
wcmpgtswhi wr5, wr6, wr3
wldrb wr1, [r0, #36]
wldrheq wr2, [r1, #24]!
wldrwne wr3, [r2], #16
wldrdvs wr4, [r3, #-332]
wldrw wcssf, [r1, #20]!
wmacu wr4, wr7, wr9
wmacscs wr8, wr10, wr14
wmacuzal wr15, wr12, wr11
wmacsz wr3, wr8, wr10
wmaddu wr12, wr11, wr7
wmaddsgt wr5, wr3, wr15
wmaxubhs wr3, wr4, wr5
wmaxsb wr3, wr4, wr5
wmaxuhpl wr3, wr4, wr5
wmaxshmi wr3, wr4, wr5
wmaxuwge wr3, wr4, wr5
wmaxswle wr3, wr4, wr5
wminubul wr4, wr12, wr10
wminsb wr4, wr12, wr10
wminuhvc wr4, wr12, wr10
wminsh wr4, wr12, wr10
wminuw wr4, wr12, wr10
wminswcc wr4, wr12, wr10
wmoveq wr3, wr4
wmulum wr2, wr1, wr8
wmulsm wr2, wr1, wr8
wmulul wr2, wr1, wr8
wmulslle wr2, wr1, wr8
woreq wr11, wr8, wr14
wpackhuseq wr0, wr1, wr3
wpackwus wr0, wr1, wr3
wpackdusal wr0, wr1, wr3
wpackhsshi wr0, wr1, wr3
wpackwss wr0, wr1, wr3
wpackdsseq wr0, wr1, wr3
wrorh wr4, wr5, wr6
wrorwmi wr4, wr5, wr6
wrord wr4, wr5, wr6
wrorhg wr9, wr10, wcgr0
wrorwgge wr9, wr10, wcgr1
wrordg wr9, wr10, wcgr2
wsadb wr2, wr0, wr10
wsadhal wr2, wr0, wr10
wsadbz wr2, wr0, wr10
wsadhzle wr2, wr0, wr10
wshufheq wr4, wr9, #251
wsllh wr2, wr9, wr4
wsllw wr2, wr9, wr4
wslldeq wr2, wr9, wr4
wsllhgeq wr2, wr9, wcgr3
wsllwgvc wr2, wr9, wcgr2
wslldg wr2, wr9, wcgr1
wsrah wr1, wr5, wr7
wsraw wr1, wr5, wr7
wsradeq wr1, wr5, wr7
wsrahg wr1, wr5, wcgr3
wsrawgmi wr1, wr5, wcgr0
wsradg wr1, wr5, wcgr1
wsrlh wr1, wr5, wr7
wsrlw wr1, wr5, wr7
wsrldeq wr1, wr5, wr7
wsrlhg wr1, wr5, wcgr3
wsrlwgmi wr1, wr5, wcgr0
wsrldg wr1, wr5, wcgr1
wstrb wr1, [r1, #0xFF]
wstrh wr1, [r1, #-0xFF]!
wstrw wr1, [r1], #4
wstrd wr1, [r1, #0x3FC]
wstrw wcasf, [r1], #300
wsubbusul wr1, wr3, wr14
wsubhus wr1, wr3, wr14
wsubwusul wr1, wr3, wr14
wsubbssul wr1, wr3, wr14
wsubhssul wr1, wr3, wr14
wsubwss wr1, wr3, wr14
wunpckehub wr3, wr6
wunpckehuhmi wr3, wr6
wunpckehuw wr3, wr6
wunpckehsb wr3, wr6
wunpckehsh wr3, wr6
wunpckehsweq wr3, wr6
wunpckihb wr5, wr12, wr10
wunpckihhhi wr5, wr12, wr10
wunpckihw wr5, wr12, wr10
wunpckelub wr3, wr5
wunpckeluhne wr3, wr5
wunpckeluw wr3, wr5
wunpckelsbgt wr3, wr5
wunpckelsh wr3, wr5
wunpckelsw wr3, wr5
wunpckilb wr4, wr5, wr10
wunpckilh wr4, wr5, wr10
wunpckilweq wr4, wr5, wr10
wxorne wr3, wr4, wr5
wzeroge wr7
tmcr wcgr0, r0
tmrc r1, wcgr2
@ a.out-required section size padding
nop
|
stsp/binutils-ia16
| 4,601
|
gas/testsuite/gas/arm/vfp1_t2.s
|
@ VFP Instructions for D variants (Double precision)
@ Same as vfp1.s, but for Thumb-2
.syntax unified
.thumb
.text
.global F
F:
@ First we test the basic syntax and bit patterns of the opcodes.
@ Most of these tests deliberately use d0/r0 to avoid setting
@ any more bits than necessary.
@ Comparison operations
fcmped d0, d0
fcmpezd d0
fcmpd d0, d0
fcmpzd d0
@ Monadic data operations
fabsd d0, d0
fcpyd d0, d0
fnegd d0, d0
fsqrtd d0, d0
@ Dyadic data operations
faddd d0, d0, d0
fdivd d0, d0, d0
fmacd d0, d0, d0
fmscd d0, d0, d0
fmuld d0, d0, d0
fnmacd d0, d0, d0
fnmscd d0, d0, d0
fnmuld d0, d0, d0
fsubd d0, d0, d0
@ Load/store operations
fldd d0, [r0]
fstd d0, [r0]
@ Load/store multiple operations
fldmiad r0, {d0}
fldmfdd r0, {d0}
fldmiad r0!, {d0}
fldmfdd r0!, {d0}
fldmdbd r0!, {d0}
fldmead r0!, {d0}
fstmiad r0, {d0}
fstmead r0, {d0}
fstmiad r0!, {d0}
fstmead r0!, {d0}
fstmdbd r0!, {d0}
fstmfdd r0!, {d0}
@ Conversion operations
fsitod d0, s0
fuitod d0, s0
ftosid s0, d0
ftosizd s0, d0
ftouid s0, d0
ftouizd s0, d0
fcvtds d0, s0
fcvtsd s0, d0
@ ARM from VFP operations
fmrdh r0, d0
fmrdl r0, d0
@ VFP From ARM operations
fmdhr d0, r0
fmdlr d0, r0
@ Now we test that the register fields are updated correctly for
@ each class of instruction.
@ Single register operations (compare-zero):
fcmpzd d1
fcmpzd d2
fcmpzd d15
@ Two register comparison operations:
fcmpd d0, d1
fcmpd d0, d2
fcmpd d0, d15
fcmpd d1, d0
fcmpd d2, d0
fcmpd d15, d0
fcmpd d5, d12
@ Two register data operations (monadic)
fnegd d0, d1
fnegd d0, d2
fnegd d0, d15
fnegd d1, d0
fnegd d2, d0
fnegd d15, d0
fnegd d12, d5
@ Three register data operations (dyadic)
faddd d0, d0, d1
faddd d0, d0, d2
faddd d0, d0, d15
faddd d0, d1, d0
faddd d0, d2, d0
faddd d0, d15, d0
faddd d1, d0, d0
faddd d2, d0, d0
faddd d15, d0, d0
faddd d12, d9, d5
@ Conversion operations
fcvtds d0, s1
fcvtds d0, s2
fcvtds d0, s31
fcvtds d1, s0
fcvtds d2, s0
fcvtds d15, s0
fcvtsd s1, d0
fcvtsd s2, d0
fcvtsd s31, d0
fcvtsd s0, d1
fcvtsd s0, d2
fcvtsd s0, d15
@ Move to VFP from ARM
fmrdh r1, d0
fmrdh r14, d0
fmrdh r0, d1
fmrdh r0, d2
fmrdh r0, d15
fmrdl r1, d0
fmrdl r14, d0
fmrdl r0, d1
fmrdl r0, d2
fmrdl r0, d15
@ Move to ARM from VFP
fmdhr d0, r1
fmdhr d0, r14
fmdhr d1, r0
fmdhr d2, r0
fmdhr d15, r0
fmdlr d0, r1
fmdlr d0, r14
fmdlr d1, r0
fmdlr d2, r0
fmdlr d15, r0
@ Load/store operations
fldd d0, [r1]
fldd d0, [r14]
fldd d0, [r0, #0]
fldd d0, [r0, #1020]
fldd d0, [r0, #-1020]
fldd d1, [r0]
fldd d2, [r0]
fldd d15, [r0]
fstd d12, [r12, #804]
@ Load/store multiple operations
fldmiad r0, {d1}
fldmiad r0, {d2}
fldmiad r0, {d15}
fldmiad r0, {d0-d1}
fldmiad r0, {d0-d2}
fldmiad r0, {d0-d15}
fldmiad r0, {d1-d15}
fldmiad r0, {d2-d15}
fldmiad r0, {d14-d15}
fldmiad r1, {d0}
fldmiad r14, {d0}
@ Check that we assemble all the register names correctly
fcmpzd d0
fcmpzd d1
fcmpzd d2
fcmpzd d3
fcmpzd d4
fcmpzd d5
fcmpzd d6
fcmpzd d7
fcmpzd d8
fcmpzd d9
fcmpzd d10
fcmpzd d11
fcmpzd d12
fcmpzd d13
fcmpzd d14
fcmpzd d15
@ Now we check the placement of the conditional execution substring.
@ On VFP this is always at the end of the instruction.
@ Comparison operations
itttt eq
fcmpedeq d1, d15
fcmpezdeq d2
fcmpdeq d3, d14
fcmpzdeq d4
@ Monadic data operations
itttt eq
fabsdeq d5, d13
fcpydeq d6, d12
fnegdeq d7, d11
fsqrtdeq d8, d10
@ Dyadic data operations
itttt eq
fadddeq d9, d1, d15
fdivdeq d2, d3, d14
fmacdeq d4, d13, d12
fmscdeq d5, d6, d11
itttt eq
fmuldeq d7, d10, d9
fnmacdeq d8, d9, d10
fnmscdeq d7, d6, d11
fnmuldeq d5, d4, d12
ittt eq
fsubdeq d3, d13, d14
@ Load/store operations
flddeq d2, [r5]
fstdeq d1, [r12]
@ Load/store multiple operations
itttt eq
fldmiadeq r1, {d1}
fldmfddeq r2, {d2}
fldmiadeq r3!, {d3}
fldmfddeq r4!, {d4}
itttt eq
fldmdbdeq r5!, {d5}
fldmeadeq r6!, {d6}
fstmiadeq r7, {d15}
fstmeadeq r8, {d14}
itttt eq
fstmiadeq r9!, {d13}
fstmeadeq r10!, {d12}
fstmdbdeq r11!, {d11}
fstmfddeq r12!, {d10}
@ Conversion operations
itttt eq
fsitodeq d15, s1
fuitodeq d1, s31
ftosideq s1, d15
ftosizdeq s31, d2
itttt eq
ftouideq s15, d2
ftouizdeq s11, d3
fcvtdseq d1, s10
fcvtsdeq s11, d1
@ ARM from VFP operations
itttt eq
fmrdheq r8, d1
fmrdleq r7, d15
@ VFP From ARM operations
fmdhreq d1, r15
fmdlreq d15, r1
# Add three nop instructions to ensure that the
# output is 32-byte aligned as required for arm-aout.
nop
nop
nop
|
stsp/binutils-ia16
| 1,129
|
gas/testsuite/gas/arm/neon-psyn.s
|
.arm
.syntax unified
fish .qn q2
cow .dn d2[1]
chips .dn d2
banana .dn d3
vmul fish.s16, fish.s16, fish.s16
vmul banana, banana, cow.s32
vmul d3.s32, d3.s32, d2.s32
vadd d2.s32, d3.s32
vmull fish.u32, chips.u16, chips.u16[1]
X .dn D0.S16
Y .dn D1.S16
Z .dn Y[2]
VMLA X, Y, Z
VMLA X, Y, Y[2]
foo .dn d5
bar .dn d7
foos .dn foo[1]
vadd foo, foo, foo.u32
vmov foo, bar
vmov d2.s16[1], r1
vmov d5.s32[1], r1
vmov foo, r2, r3
vmov r4, foos.s8
vmov r5, r6, foo
baa .qn q5
moo .dn d6
sheep .dn d7
chicken .dn d8
vabal baa, moo.u16, sheep.u16
vcvt q1.s32, q2.f32
vcvt d4.f, d5.u32, #5
vdup bar, foos.32
vtbl d1, {baa}, d4.8
el1 .dn d4.16[1]
el2 .dn d6.16[1]
el3 .dn d8.16[1]
el4 .dn d10.16[1]
vld2 {moo.32[1], sheep.32[1]}, [r10]
vld4 {el1, el2, el3, el4}, [r10]
vld3 {moo.16[], sheep.16[], chicken.16[]}, [r10]
vmov r0,d0.s16[0]
el5 .qn q3.16
el6 .qn q4.16
vld4 {el5,el6}, [r10]
vld3 {d2.s16[1], d4.s16[1], d6.s16[1]}, [r10]
chicken8 .dn chicken.8
vtbl d7.8, {d4, d5}, chicken8
vbsl q1.8, q2.16, q3.8
vcge d2.32, d3.f, d4.f
vcge d2.16, d3.s16, #0
dupme .dn d2.s16
vdup dupme, r3
|
stsp/binutils-ia16
| 1,190
|
gas/testsuite/gas/arm/cde.s
|
.syntax unified
.include "cde-scalar.s"
# vcx1{a} encoding has the following form
# 111a110i0d10iiiidddd0pppi1iiiiii (vector form)
# 111a110s0d10iiiidddd0pppi0iiiiii (S/D register form)
#
# Variants to test:
# - immediates that set each set of `i` to ones in turn.
# - each register set to something non-zero
# (where each block of register sets is set to all-ones if possible)
# - coprocessor set to 7
# vcx2{a} encoding has the following form
# 111a110i0d11iiiidddd0pppi1mimmmm (vector form)
# 111a110s0d11iiiidddd0pppi0mimmmm (S/D register form)
#
# Variants to test:
# - immediates that set each set of `i` to ones in turn.
# - each register set to something non-zero
# (where each block of register sets is set to all-ones if possible)
# - coprocessor set to 7
# vcx3{a} encoding has the following form
# 111a110i1diinnnndddd0pppn1mimmmm (vector form)
# 111a110s1diinnnndddd0pppn0mimmmm (S/D register form)
#
# Variants to test:
# - immediates that set each set of `i` to ones in turn.
# - each register set to something non-zero
# (where each block of register sets is set to all-ones if possible)
# - coprocessor set to 7
.include "cde-mve.s"
.include "cde-mve-or-neon.s"
|
stsp/binutils-ia16
| 1,983
|
gas/testsuite/gas/arm/neon-ldst-es.s
|
@ test element and structure loads and stores.
.text
.arm
.syntax unified
vst2.8 {d2,d3},[r6,:128]
vld3.8 {d1,d2,d3},[r7]!
vst3.16 {d1,d3,d5},[r9:64],r3
vld4.32 {d2,d3,d4,d5},[r10]
vst4.16 {d1,d3,d5,d7},[r10]
vld1.16 {d1[],d2[]},[r10]
vld1.16 {d1[]},[r10,:16]
vld2.32 {d1[],d3[]},[r10:64]
vld3.s8 {d3[],d4[],d5[]},[r10],r12
vld4.16 {d10[],d12[],d14[],d16[]},[r9]!
vld4.16 {d10[],d11[],d12[],d13[]},[r9,:64]
vld4.32 {d10[],d11[],d12[],d13[]},[r9,:64]
vld4.32 {d10[],d11[],d12[],d13[]},[r9,:128]
vld1.8 {d3[7]},[r5]!
vst1.16 {d5[3]},[r5,:16]
vld2.16 {d3[3],d4[3]},[r5,:32]!
vst3.32 {d8[1],d9[1],d10[1]},[r5],r3
vld1.8 {d8[2]},[r7]
vld1.16 {d8[2]},[r7]
vld1.16 {d8[2]},[r7:16]
vld1.32 {d8[1]},[r7]
vld1.32 {d8[1]},[r7:32]
vld2.8 {d8[1],d9[1]},[r7]
vld2.8 {d8[1],d9[1]},[r7:16]
vld2.16 {d8[1],d9[1]},[r7]
vld2.16 {d8[1],d9[1]},[r7:32]
vld2.16 {d8[1],d10[1]},[r7]
vld2.16 {d8[1],d10[1]},[r7:32]
vld2.32 {d8[1],d9[1]},[r7]
vld2.32 {d8[1],d9[1]},[r7:64]
vld2.32 {d8[1],d10[1]},[r7]
vld2.32 {d8[1],d10[1]},[r7:64]
vld3.8 {d8[1],d9[1],d10[1]},[r7]
vld3.16 {d8[1],d9[1],d10[1]},[r7]
vld3.16 {d8[1],d10[1],d12[1]},[r7]
vld3.32 {d8[1],d9[1],d10[1]},[r7]
vld3.32 {d8[1],d10[1],d12[1]},[r7]
vld4.8 {d8[2],d9[2],d10[2],d11[2]},[r7]
vld4.8 {d8[2],d9[2],d10[2],d11[2]},[r7:32]
vld4.16 {d8[1],d10[1],d12[1],d14[1]},[r7]
vld4.16 {d8[1],d9[1],d10[1],d11[1]},[r7:64]
vld4.32 {d8[1],d10[1],d12[1],d14[1]},[r7]
vld4.32 {d8[1],d10[1],d12[1],d14[1]},[r7:64]
vld4.32 {d8[1],d10[1],d12[1],d14[1]},[r7:128]
vtbl.8 d3,{d4},d5
vtbl.8 d3,{q1-q2},d5
vtbl.8 d3,{q15},d5
vld2.32 {q1},[r7]
vld4.32 {q1-q2},[r7]
vld4.32 {q14-q15},[r7]
@ PR 14987 and 14887: Allow for whitespace in the instruction.
vld1.32 { d1 [ ] } , [ r2 ] , r3
vld1.64 {d0}, [r0]
vld1.64 {d0-d3}, [r0]
|
stsp/binutils-ia16
| 1,028
|
gas/testsuite/gas/arm/req.s
|
.text
.global test_dot_req_and_unreq
test_dot_req_and_unreq:
# Check that builtin register alias 'r0' works.
add r0, r0, r0
# Create an alias for r0.
foo .req r0
# Check that it works.
add foo, foo, foo
# Now remove the alias.
.unreq foo
# And make sure that it no longer works.
add foo, foo, foo
# Attempt to remove the builtin alias for r0.
.unreq r0
# That is ignored, so this should still work.
add r0, r0, r0
# Now attempt to re-alias foo. There used to be a bug whereby the
# first creation of an alias called foo would also create an alias
# called FOO, but the .unreq of foo would not delete FOO. Thus a
# second attempt at aliasing foo (to something different than
# before) would fail because the assembler would complain that FOO
# already existed.
foo .req r1
add foo, foo, foo
# Check that the upper case alias was also recreated.
add FOO, FOO, FOO
# Check that a second attempt to alias foo, using a mixed case
# version of the name, will fail.
Foo .req r2
|
stsp/binutils-ia16
| 2,306
|
gas/testsuite/gas/arm/armv7-a+virt.s
|
.text
.syntax unified
.arm
foo:
hvc 0x0000
hvc 0xffff
eret
mrs r1, R8_usr
mrs r1, R9_usr
mrs r1, R10_usr
mrs r1, R11_usr
mrs r1, R12_usr
mrs r1, SP_usr
mrs r1, LR_usr
mrs r1, R8_fiq
mrs r1, R9_fiq
mrs r1, R10_fiq
mrs r1, R11_fiq
mrs r1, R12_fiq
mrs r1, SP_fiq
mrs r1, LR_fiq
mrs r1, SPSR_fiq
mrs r1, SP_irq
mrs r1, LR_irq
mrs r1, SPSR_irq
mrs r1, SP_svc
mrs r1, LR_svc
mrs r1, SPSR_svc
mrs r1, SP_abt
mrs r1, LR_abt
mrs r1, SPSR_abt
mrs r1, SP_und
mrs r1, LR_und
mrs r1, SPSR_und
mrs r1, SP_mon
mrs r1, LR_mon
mrs r1, SPSR_mon
mrs r1, SP_hyp
mrs r1, ELR_hyp
mrs r1, SPSR_hyp
msr R8_usr, r1
msr R9_usr, r1
msr R10_usr, r1
msr R11_usr, r1
msr R12_usr, r1
msr SP_usr, r1
msr LR_usr, r1
msr R8_fiq, r1
msr R9_fiq, r1
msr R10_fiq, r1
msr R11_fiq, r1
msr R12_fiq, r1
msr SP_fiq, r1
msr LR_fiq, r1
msr SPSR_fiq, r1
msr SP_irq, r1
msr LR_irq, r1
msr SPSR_irq, r1
msr SP_svc, r1
msr LR_svc, r1
msr SPSR_svc, r1
msr SP_abt, r1
msr LR_abt, r1
msr SPSR_abt, r1
msr SP_und, r1
msr LR_und, r1
msr SPSR_und, r1
msr SP_mon, r1
msr LR_mon, r1
msr SPSR_mon, r1
msr SP_hyp, r1
msr ELR_hyp, r1
msr SPSR_hyp, r1
.thumb
bar:
hvc 0x0000
hvc 0xffff
eret
mrs r1, R8_usr
mrs r1, R9_usr
mrs r1, R10_usr
mrs r1, R11_usr
mrs r1, R12_usr
mrs r1, SP_usr
mrs r1, LR_usr
mrs r1, R8_fiq
mrs r1, R9_fiq
mrs r1, R10_fiq
mrs r1, R11_fiq
mrs r1, R12_fiq
mrs r1, SP_fiq
mrs r1, LR_fiq
mrs r1, SPSR_fiq
mrs r1, SP_irq
mrs r1, LR_irq
mrs r1, SPSR_irq
mrs r1, SP_svc
mrs r1, LR_svc
mrs r1, SPSR_svc
mrs r1, SP_abt
mrs r1, LR_abt
mrs r1, SPSR_abt
mrs r1, SP_und
mrs r1, LR_und
mrs r1, SPSR_und
mrs r1, SP_mon
mrs r1, LR_mon
mrs r1, SPSR_mon
mrs r1, SP_hyp
mrs r1, ELR_hyp
mrs r1, SPSR_hyp
msr R8_usr, r1
msr R9_usr, r1
msr R10_usr, r1
msr R11_usr, r1
msr R12_usr, r1
msr SP_usr, r1
msr LR_usr, r1
msr R8_fiq, r1
msr R9_fiq, r1
msr R10_fiq, r1
msr R11_fiq, r1
msr R12_fiq, r1
msr SP_fiq, r1
msr LR_fiq, r1
msr SPSR_fiq, r1
msr SP_irq, r1
msr LR_irq, r1
msr SPSR_irq, r1
msr SP_svc, r1
msr LR_svc, r1
msr SPSR_svc, r1
msr SP_abt, r1
msr LR_abt, r1
msr SPSR_abt, r1
msr SP_und, r1
msr LR_und, r1
msr SPSR_und, r1
msr SP_mon, r1
msr LR_mon, r1
msr SPSR_mon, r1
msr SP_hyp, r1
msr ELR_hyp, r1
msr SPSR_hyp, r1
|
stsp/binutils-ia16
| 1,276
|
gas/testsuite/gas/arm/group-reloc-ldrs.s
|
@ Tests for LDRS group relocations.
.text
.macro ldrtest2 load sym offset
\load r0, [r0, #:pc_g1:(\sym \offset)]
\load r0, [r0, #:pc_g2:(\sym \offset)]
\load r0, [r0, #:sb_g0:(\sym \offset)]
\load r0, [r0, #:sb_g1:(\sym \offset)]
\load r0, [r0, #:sb_g2:(\sym \offset)]
.endm
.macro ldrtest load store sym offset
ldrtest2 \load \sym \offset
\store r0, [r0, #:pc_g1:(\sym \offset)]
\store r0, [r0, #:pc_g2:(\sym \offset)]
\store r0, [r0, #:sb_g0:(\sym \offset)]
\store r0, [r0, #:sb_g1:(\sym \offset)]
\store r0, [r0, #:sb_g2:(\sym \offset)]
.endm
@ LDRD/STRD/LDRH/STRH/LDRSH/LDRSB only have 8 bits available for the
@ magnitude of the addend. So these should all (just) work.
ldrtest ldrd strd f "+ 255"
ldrtest ldrh strh f "+ 255"
ldrtest2 ldrsh f "+ 255"
ldrtest2 ldrsb f "+ 255"
ldrtest ldrd strd f "- 255"
ldrtest ldrh strh f "- 255"
ldrtest2 ldrsh f "- 255"
ldrtest2 ldrsb f "- 255"
@ The same as the above, but for a local symbol.
ldrtest ldrd strd localsym "+ 255"
ldrtest ldrh strh localsym "+ 255"
ldrtest2 ldrsh localsym "+ 255"
ldrtest2 ldrsb localsym "+ 255"
ldrtest ldrd strd localsym "- 255"
ldrtest ldrh strh localsym "- 255"
ldrtest2 ldrsh localsym "- 255"
ldrtest2 ldrsb localsym "- 255"
localsym:
mov r0, #0
|
stsp/binutils-ia16
| 1,135
|
gas/testsuite/gas/arm/group-reloc-ldc-parsing-bad.s
|
@ Tests for LDC group relocations that are meant to fail during parsing.
.macro ldctest insn reg
\insn 0, \reg, [r0, #:pc_g0_nc:(sym)]
\insn 0, \reg, [r0, #:pc_g1_nc:(sym)]
\insn 0, \reg, [r0, #:sb_g0_nc:(sym)]
\insn 0, \reg, [r0, #:sb_g1_nc:(sym)]
\insn 0, \reg, [r0, #:foo:(sym)]
.endm
.macro ldctest2 insn reg
\insn \reg, [r0, #:pc_g0_nc:(sym)]
\insn \reg, [r0, #:pc_g1_nc:(sym)]
\insn \reg, [r0, #:sb_g0_nc:(sym)]
\insn \reg, [r0, #:sb_g1_nc:(sym)]
\insn \reg, [r0, #:foo:(sym)]
.endm
ldctest ldc c0
ldctest ldcl c0
ldctest ldc2 c0
ldctest ldc2l c0
ldctest stc c0
ldctest stcl c0
ldctest stc2 c0
ldctest stc2l c0
.fpu fpa
ldctest2 ldfs f0
ldctest2 stfs f0
ldctest2 ldfd f0
ldctest2 stfd f0
ldctest2 ldfe f0
ldctest2 stfe f0
ldctest2 ldfp f0
ldctest2 stfp f0
.fpu vfp
ldctest2 flds s0
ldctest2 fsts s0
ldctest2 fldd d0
ldctest2 fstd d0
ldctest2 vldr d0 FIXME
ldctest2 vstr d0
.cpu ep9312
ldctest2 cfldrs mvf0
ldctest2 cfstrs mvf0
ldctest2 cfldrd mvd0
ldctest2 cfstrd mvd0
ldctest2 cfldr32 mvfx0
ldctest2 cfstr32 mvfx0
ldctest2 cfldr64 mvdx0
ldctest2 cfstr64 mvdx0
|
stsp/binutils-ia16
| 1,115
|
gas/testsuite/gas/arm/mve-vqdmull.s
|
.syntax unified
.thumb
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
.irp op3, r0, r1, r2, r4, r7, r8, r10, r12, r14
vqdmullt.s16 \op1, \op2, \op3
vqdmullb.s16 \op1, \op2, \op3
.endr
.endr
.endr
.irp op2, q1, q2, q4, q7
.irp op3, r0, r2, r4, r7, r8, r10, r12, r14
vqdmullt.s32 q0, \op2, \op3
vqdmullb.s32 q0, \op2, \op3
.endr
.endr
.irp op2, q0, q2, q4, q7
.irp op3, r0, r2, r4, r7, r8, r10, r12, r14
vqdmullt.s32 q1, \op2, \op3
vqdmullb.s32 q1, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q4, q7
.irp op3, r0, r2, r4, r7, r8, r10, r12, r14
vqdmullt.s32 q2, \op2, \op3
vqdmullb.s32 q2, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q2, q7
.irp op3, r0, r2, r4, r7, r8, r10, r12, r14
vqdmullt.s32 q4, \op2, \op3
vqdmullb.s32 q4, \op2, \op3
.endr
.endr
.irp op2, q0, q1, q2, q4
.irp op3, r0, r2, r4, r7, r8, r10, r12, r14
vqdmullt.s32 q7, \op2, \op3
vqdmullb.s32 q7, \op2, \op3
.endr
.endr
vpstete
vqdmulltt.s16 q0, q1, q2
vqdmullte.s32 q0, q1, q2
vqdmullbt.s16 q0, q1, q2
vqdmullbe.s32 q0, q1, q2
vpstete
vqdmulltt.s16 q7, q7, lr
vqdmullte.s32 q7, q6, r0
vqdmullbt.s16 q0, q1, r2
vqdmullbe.s32 q5, q7, r14
|
stsp/binutils-ia16
| 1,975
|
gas/testsuite/gas/arm/armv8-ar-bad.s
|
.syntax unified
.text
// SWP
.arm
swp r0, r1, [r2]
// deprecated MCRs
mcr p15, 0, r0, c7, c5, 4
mcr p15, 0, r1, c7, c10, 4
mcr p15, 0, r2, c7, c10, 5
mrc p14, 6, r1, c0, c0, 0
mrc p14, 6, r0, c1, c0, 0
// deprecated SETEND
setend be
.thumb
setend le
// HLT A32
.arm
hlt 0x10000
hltne 0x1
// HLT T32
.thumb
hlt 64
it ne
hltne 0
// STL A32
.arm
stlb pc, [r0]
stlb r0, [pc]
stlh pc, [r0]
stlh r0, [pc]
stl pc, [r0]
stl r0, [pc]
stlexb r1, pc, [r0]
stlexb r1, r0, [pc]
stlexb pc, r0, [r1]
stlexb r0, r0, [r1]
stlexb r0, r1, [r0]
stlexh r1, pc, [r0]
stlexh r1, r0, [pc]
stlexh pc, r0, [r1]
stlexh r0, r0, [r1]
stlexh r0, r1, [r0]
stlex r1, pc, [r0]
stlex r1, r0, [pc]
stlex pc, r0, [r1]
stlex r0, r0, [r1]
stlex r0, r1, [r0]
stlexd r1, lr, [r0]
stlexd r1, r0, [pc]
stlexd pc, r0, [r1]
stlexd r0, r0, [r1]
stlexd r0, r2, [r0]
stlexd r0, r1, [r2]
// STL T32
.thumb
stlb pc, [r0]
stlb r0, [pc]
stlh pc, [r0]
stlh r0, [pc]
stl pc, [r0]
stl r0, [pc]
stlexb r1, pc, [r0]
stlexb r1, r0, [pc]
stlexb pc, r0, [r1]
stlexb r0, r0, [r1]
stlexb r0, r1, [r0]
stlexh r1, pc, [r0]
stlexh r1, r0, [pc]
stlexh pc, r0, [r1]
stlexh r0, r0, [r1]
stlexh r0, r1, [r0]
stlex r1, pc, [r0]
stlex r1, r0, [pc]
stlex pc, r0, [r1]
stlex r0, r0, [r1]
stlex r0, r1, [r0]
stlexd r1, lr, [r0]
stlexd r1, r0, [pc]
stlexd pc, r0, [r1]
stlexd r0, r0, [r1]
stlexd r0, r2, [r0]
stlexd r0, r1, [r2]
// LDA A32
.arm
ldab pc, [r0]
ldab r0, [pc]
ldah pc, [r0]
ldah r0, [pc]
lda pc, [r0]
lda r0, [pc]
ldaexb pc, [r0]
ldaexb r0, [pc]
ldaexh pc, [r0]
ldaexh r0, [pc]
ldaex pc, [r0]
ldaex r0, [pc]
ldaexd lr, [r0]
ldaexd r0, [pc]
ldaexd r1, [r2]
// LDA T32
.thumb
ldab pc, [r0]
ldab r0, [pc]
ldah pc, [r0]
ldah r0, [pc]
lda pc, [r0]
lda r0, [pc]
ldaexb pc, [r0]
ldaexb r0, [pc]
ldaexh pc, [r0]
ldaexh r0, [pc]
ldaex pc, [r0]
ldaex r0, [pc]
ldaexd r0, pc, [r0]
ldaexd pc, r0, [r0]
ldaexd r1, r0, [pc]
|
stsp/binutils-ia16
| 1,112
|
gas/testsuite/gas/arm/group-reloc-ldr.s
|
@ Tests for LDR group relocations.
.text
.macro ldrtest load store sym offset
\load r0, [r0, #:pc_g0:(\sym \offset)]
\load r0, [r0, #:pc_g1:(\sym \offset)]
\load r0, [r0, #:pc_g2:(\sym \offset)]
\load r0, [r0, #:sb_g0:(\sym \offset)]
\load r0, [r0, #:sb_g1:(\sym \offset)]
\load r0, [r0, #:sb_g2:(\sym \offset)]
\store r0, [r0, #:pc_g0:(\sym \offset)]
\store r0, [r0, #:pc_g1:(\sym \offset)]
\store r0, [r0, #:pc_g2:(\sym \offset)]
\store r0, [r0, #:sb_g0:(\sym \offset)]
\store r0, [r0, #:sb_g1:(\sym \offset)]
\store r0, [r0, #:sb_g2:(\sym \offset)]
.endm
@ LDR/STR/LDRB/STRB only have 12 bits available for the magnitude of the addend.
@ So these should all (just) work.
ldrtest ldr str f "+ 4095"
ldrtest ldrb strb f "+ 4095"
ldrtest ldr str f "- 4095"
ldrtest ldrb strb f "- 4095"
@ The same as the above, but for a local symbol. These should not be
@ resolved by the assembler but instead left to the linker.
ldrtest ldr str localsym "+ 4095"
ldrtest ldrb strb localsym "+ 4095"
ldrtest ldr str localsym "- 4095"
ldrtest ldrb strb localsym "- 4095"
localsym:
mov r0, #0
|
stsp/binutils-ia16
| 1,699
|
gas/testsuite/gas/arm/bfloat16-neon.s
|
.syntax unified
// Check argument encoding by having different arguments.
// We use 20 and 11 since their binary encoding is 10100 and 01011
// respectively which ensures that we distinguish between the D/M/N bit
// encoding the first or last bit of the argument.
// q registers are encoded as double their actual number.
vdot.bf16 d0, d20, d11
vdot d11.bf16, d0.bf16, d20.bf16
.macro conversion_type_specifier_check insn, dest, source
\insn\().bf16.f32 \dest, \source
\insn \dest\().bf16, \source\().f32
\insn \dest\().bf16, \source\().f32
.endm
conversion_type_specifier_check vcvtt,s0,s0
conversion_type_specifier_check vcvtb,s0,s0
conversion_type_specifier_check vcvt,d0,q0
// Here we follow the same encoding sequence as above.
// Since the 'M' bit encodes the index and the last register is encoded in 4
// bits that argument has a different number.
vdot.bf16 d11, d0, d4[1]
vdot d0.bf16, d20.bf16, d11.bf16[0]
// vmmla only works on q registers.
// These registers are encoded as double the number given in the mnemonic.
// Hence we choose different numbers to ensure a similar bit pattern as above.
// 10 & 5 produce the bit patterns 10100 & 01010
vmmla.bf16 q10, q5, q0
vmmla q5.bf16, q0.bf16, q10.bf16
vfmat.bf16 q10, q11, q0
vfmat.bf16 q10, q11, d0[3]
vfmat.bf16 q10, q11, d0[0]
vfmab.bf16 q10, q11, q0
vfmab.bf16 q10, q11, d0[3]
vfmab.bf16 q10, q11, d0[0]
// vcvt
// - no condition allowed in arm
// - no condition allowed in thumb outside IT block
// - Condition *allowed* in thumb in IT block
// - different encoding between thumb and arm
vcvt.bf16.f32 d20, q5
vcvt.bf16.f32 d11, q10
// Only works for thumb mode.
.ifdef COMPILING_FOR_THUMB
it ne
vcvtne.bf16.f32 d0, q0
.endif
|
stsp/binutils-ia16
| 2,786
|
gas/testsuite/gas/arm/bfloat16-bad.s
|
.syntax unified
// Test warnings about type specifier being incorrect.
vdot.b16 d0, d0, d0
vmmla q0.b16, q0, q0
vdot.bf32 d0, d0, d0[1]
vdot d0.bf32, d0, d0
vdot d0.bf32, d0.bf16, d0.bf16
// Test conditions are not allowed in ARM.
vdotne d0, d0, d0
vdotne d0, d0, d0[1]
vmmlane q0, q0, q0
vfmatne.bf16 q0, d0, d0
vfmatne.bf16 q0, d0, d0[0]
vfmabne.bf16 q0, d0, d0
vfmabne.bf16 q0, d0, d0[0]
vcvtne.bf16.f32 d0, q0
// d register out of range
vdot d32, d0, d0
vdot d0, d32, d0
vdot d0, d0, d32
vdot d32, d0, d0[0]
vdot d0, d32, d0[0]
vdot d0, d0, d16[0]
vcvtne.bf16.f32 d32, q0
// q register out of range
vdot q16, q0, q0
vdot q0, q16, q0
vdot q0, q0, q16
vdot q16, q0, d0[0]
vdot q0, q16, d0[0]
vmmla q16, q0, q0
vmmla q0, q16, q0
vmmla q0, q0, q16
vfmab.bf16 q16, d0, d0
vfmab.bf16 q16, d0, d0[0]
vfmab.bf16 q0, q32, d0
vfmab.bf16 q0, q32, d0[0]
vfmab.bf16 q0, q0, d8[0]
vfmat.bf16 q16, d0, d0
vfmat.bf16 q16, d0, d0[0]
vfmat.bf16 q0, q32, d0
vfmat.bf16 q0, q32, d0[0]
vfmat.bf16 q0, q0, d8[0]
vcvt.bf16.f32 d0, q16
// Incorrect set of arguments
vdot q0, q0, d5
vdot q0, d5, q0
vdot d5, q0, q0
vdot q0, d5, q0[0]
vdot d5, q0, q0[0]
vmmla q0, q0, d5
vmmla q0, d5, q0
vmmla d5, q0, q0
vfmab.bf16 d0, q0, d0
vfmab.bf16 d0, q0, d0[0]
vfmat.bf16 d0, q0, d0
vfmat.bf16 d0, q0, d0[0]
vcvt.bf16.f32 q0, d0
// vdot index out of range
vdot q0, q0, d0[2]
// vfma<bt> index out of range
vfmab.bf16 q0, d0, d0[4]
vfmat.bf16 q0, d0, d0[4]
// Non neon encodings (this file gets assembled more than once but with
// different flags, providing different error messages each time).
// Type specifier warnings
.macro conversion_type_specifier_check insn, dest, source
\insn\().b16.f32 \dest, \source
\insn\().bf32.f32 \dest, \source
\insn \dest\().b16, \source\().f32
\insn \dest\().bf32, \source\().f32
\insn \dest\().f32, \source\().bf16
.endm
conversion_type_specifier_check vcvtb, s0, s0
conversion_type_specifier_check vcvtt, s0, s0
conversion_type_specifier_check vcvt, d0, q0
// Conditions allowed (and checked in the "Valid" source file).
// Incorrect set of operands & registers out of range
.macro bad_args insn
\insn\().bf16.f32 s0, s0, #0
\insn\().bf16.f32 s0, s0, #1
\insn\().bf16.f32 d0, s0
\insn\().bf16.f32 s0
\insn\().bf16.f32 s0, s0, s0, s0
\insn\().bf16.f32 s0, s0, s0
\insn\().bf16.f32 s0, s32
\insn\().bf16.f32 s32, s32
.endm
bad_args vcvtt
bad_args vcvtb
// Allowed in thumb mode but not allowed in arm mode.
it ne
vcvtne.bf16.f32 d0, q0
// Ensure these instructions are not allowed to have a conditional suffix.
ittt ne
vdotne.bf16 d0, d20, d11
vdotne.bf16 d0, d20, d11[1]
vmmlane.bf16 q0, q0, q0
// Ensure we are warned these instructions are UNPREDICTABLE in an IT block in
// thumb.
ittt ne
vdot.bf16 d0, d20, d11
vdot.bf16 d0, d20, d11[1]
vmmla.bf16 q0, q0, q0
|
stsp/binutils-ia16
| 1,317
|
gas/testsuite/gas/arm/ldr-t.s
|
.syntax unified
.arch armv7-a
.thumb
.global foo
foo:
.align 4
@ldr-immediate
@!wback && (n == t)
ldr r1, [r1, #5]
@wback && !(n == t)
ldr r1, [r2, #5]!
@!(rt == r15) && rn == r15
@ && bits<0..1> (immediate) != 00
ldr r1, [r15, #5]
@rt == r15 && !(rn == r15)
@ && bits<0..1> (immediate) != 00
ldr r15, [r1, #5]
@rt == r15 && rn == r15
@ && bits<0..1> (immediate) == 00
ldr r15, [r15, #4]
@inITBlock && !(rt == 15) && !lastInITBlock
ittt ge
ldrge r1, [r15, #4]
nopge
nopge
@inITBlock && rt == 15 && lastInITBlock
it ge
ldrge r15, [r15, #4]
@ldr-literal
@inITBlock && !(rt == 15) && !lastInITBlock
ittt ge
ldrge r1, .-0xab4
nopge
nopge
@inITBlock && (rt == 15) && lastInITBlock
it ge
ldrge r15, .-0xab4
@!(rt == r15) && bits<0..1> (immediate) != 00
ldr r1, .-0xab7
@rt == r15 && bits<0..1> (immediate) == 00
ldr r15, .-0xab4
@ldr-register
@inITBlock && !(rt == 15) && !lastInITBlock
ittt ge
ldrge r1, [r2, r1]
nopge
nopge
@inITBlock && (rt == 15) && lastInITBlock
it ge
ldrge r15, [r2, r1]
@!(rm == 13 || rm == 15)
ldr r1, [r2, r3]
@str-immediate
@!(rt == 15 || rn == 15)
str r1, [r2, #10]
@!wback && (n == t)
str r1, [r1, #10]
@wback && !(n == t)
str r1, [r2, #10]!
@str-register
@!(rt == 15 || rm == 13 || rm == 15)
str r1, [r2, r3]
|
stsp/binutils-ia16
| 2,618
|
gas/testsuite/gas/arm/archv8m_1m-cmse-main.s
|
.thumb
.syntax unified
T:
clrm {r0, r2} @ Accepts list without APSR
clrm {APSR} @ Accepts APSR alone
clrm {r3, APSR} @ Accepts core register and APSR together
clrmeq {r4} @ Accepts conditional execution
vscclrm {VPR} @ Accepts list with only VPR
vscclrm {s30, VPR} @ Accept single-precision VFP register and VPR together
vscclrm {d14, VPR} @ Likewise for double-precision VFP register
vscclrm {s1-s4, VPR} @ Accept range of single-precision VFP registers
@ and VPR together
vscclrm {d1-d4, VPR} @ Likewise for double-precision VFP registers
vscclrm {s0-s31, VPR} @ Accept all single-precision VFP registers and VPR
@ together
vscclrm {d0-d15, VPR} @ Likewise for double-precision VFP registers
vscclrmne {s3, VPR} @ Accepts conditional execution
vldr FPSCR, [r2] @ Accepts offset variant without immediate
vldr FPSCR, [r2, #8] @ Likewise but with immediate without sign
vldr FPSCR, [r2, #+8] @ Likewise but with positive sign
vldr FPSCR, [r2, #-8] @ Likewise but with negative sign
vldr FPSCR, [r2, #8]! @ Accepts pre-index variant with immediate without sign
vldr FPSCR, [r2, #+8]! @ Likewise but with positive sign
vldr FPSCR, [r2, #-8]! @ Likewise but with negative sign
vldr FPSCR, [r2], #8 @ Accepts post-index variant with immediate without sign
vldr FPSCR, [r2], #+8 @ Likewise but with positive sign
vldr FPSCR, [r2], #-8 @ Likewise but with negative sign
vldr FPSCR_nzcvqc, [r3] @ Accepts FPSCR_nzcvqc system register
vldr VPR, [r3] @ Accepts VPR system register
vldr P0, [r3] @ Accepts P0 system register
vldr FPCXTNS, [r3] @ Accepts FPCXTNS system register
vldr FPCXTS, [r3] @ Accepts FPCXTS system register
vldrge FPCXTS, [r3] @ Accepts conditional execution
vstr FPSCR, [r2] @ Accepts offset variant without immediate
vstr FPSCR, [r2, #8] @ Likewise but with immediate without sign
vstr FPSCR, [r2, #+8] @ Likewise but with positive sign
vstr FPSCR, [r2, #-8] @ Likewise but with negative sign
vstr FPSCR, [r2, #8]! @ Accepts pre-index variant with immediate without sign
vstr FPSCR, [r2, #+8]! @ Likewise but with positive sign
vstr FPSCR, [r2, #-8]! @ Likewise but with negative sign
vstr FPSCR, [r2], #8 @ Accepts post-index variant with immediate without sign
vstr FPSCR, [r2], #+8 @ Likewise but with positive sign
vstr FPSCR, [r2], #-8 @ Likewise but with negative sign
vstr FPSCR_nzcvqc, [r3] @ Accepts FPSCR_nzcvqc system register
vstr VPR, [r3] @ Accepts VPR system register
vstr P0, [r3] @ Accepts P0 system register
vstr FPCXTNS, [r3] @ Accepts FPCXTNS system register
vstr FPCXTS, [r3] @ Accepts FPCXTS system register
vstrge FPCXTS, [r3] @ Accepts conditional execution
|
stsp/binutils-ia16
| 1,166
|
gas/testsuite/gas/arm/vfpv3-32drs.s
|
.arm
.syntax unified
fcpyd d3,d22
fcpyd d22,d3
fcvtds d22,s22
fcvtsd s22,d22
fmdhr d21,r4
fmdlr d27,r5
fmrdh r6,d23
fmrdl r7,d25
fsitod d22,s22
fuitod d21,s21
ftosid s20,d20
ftosizd s20,d20
ftouid s19,d19
ftouizd s19,d19
fldd d19,[r10,#4]
fstd d21,[r10,#4]
fldmiad r10!,{d5,d6}
fldmiad r10!,{d18,d19,d20}
fldmiax r10!,{d5,d6}
fldmiax r10!,{d18,d19,d20}
fldmdbx r10!,{d18,d19}
fstmiad r9,{d20,d21,d22,d23,d24}
fabsd d3,d5
fabsd d12,d18
fabsd d18,d19
fnegd d3,d5
fnegd d12,d18
fnegd d18,d19
fsqrtd d3,d5
fsqrtd d12,d18
fsqrtd d18,d19
faddd d3,d5,d6
faddd d12,d18,d4
faddd d18,d19,d20
fsubd d3,d5,d6
fsubd d12,d18,d4
fsubd d18,d19,d20
fmuld d3,d5,d6
fmuld d12,d18,d4
fmuld d18,d19,d20
fdivd d3,d5,d6
fdivd d12,d18,d4
fdivd d18,d19,d20
fmacd d3,d5,d6
fmacd d12,d18,d4
fmacd d18,d19,d20
fmscd d3,d5,d6
fmscd d12,d18,d4
fmscd d18,d19,d20
fnmuld d3,d5,d6
fnmuld d12,d18,d4
fnmuld d18,d19,d20
fnmacd d3,d5,d6
fnmacd d12,d18,d4
fnmacd d18,d19,d20
fnmscd d3,d5,d6
fnmscd d12,d18,d4
fnmscd d18,d19,d20
fcmpd d3,d18
fcmpd d18,d3
fcmpzd d19
fcmped d3,d18
fcmped d18,d3
fcmpezd d19
fmdrr d31,r3,r4
fmrrd r5,r6,d30
|
stsp/binutils-ia16
| 2,975
|
gas/testsuite/gas/arm/vfp-neon-syntax-inc.s
|
@ VFP with Neon-style syntax
.syntax unified
.arch armv7-a
.include "itblock.s"
func:
.macro testvmov cond="" f32=".f32" f64=".f64"
itblock 4 \cond
vmov\cond\f32 s0,s1
vmov\cond\f64 d0,d1
vmov\cond\f32 s0,#0.25
vmov\cond\f64 d0,#1.0
itblock 4 \cond
vmov\cond r0,s1
vmov\cond s0,r1
vmov\cond r0,r1,s2,s3
vmov\cond s0,s1,r2,r4
.endm
@ Test VFP vmov variants. These can all be conditional.
testvmov
testvmov eq
.macro monadic op cond="" f32=".f32" f64=".f64"
itblock 2 \cond
\op\cond\f32 s0,s1
\op\cond\f64 d0,d1
.endm
.macro monadic_c op
monadic \op
monadic \op eq
.endm
.macro dyadic op cond="" f32=".f32" f64=".f64"
itblock 2 \cond
\op\cond\f32 s0,s1,s2
\op\cond\f64 d0,d1,d2
.endm
.macro dyadic_c op
dyadic \op
dyadic \op eq
.endm
.macro dyadicz op cond="" f32=".f32" f64=".f64"
itblock 2 \cond
\op\cond\f32 s0,#0
\op\cond\f64 d0,#0
.endm
.macro dyadicz_c op
dyadicz \op
dyadicz \op eq
.endm
monadic_c vsqrt
monadic_c vabs
monadic_c vneg
monadic_c vcmp
monadic_c vcmpe
dyadic_c vnmul
dyadic_c vnmla
dyadic_c vnmls
dyadic_c vmul
dyadic_c vmla
dyadic_c vmls
dyadic_c vadd
dyadic_c vsub
dyadic_c vdiv
dyadicz_c vcmp
dyadicz_c vcmpe
.macro cvtz cond="" s32=".s32" u32=".u32" f32=".f32" f64=".f64"
itblock 4 \cond
vcvtz\cond\s32\f32 s0,s1
vcvtz\cond\u32\f32 s0,s1
vcvtz\cond\s32\f64 s0,d1
vcvtz\cond\u32\f64 s0,d1
.endm
cvtz
cvtz eq
.macro cvt cond="" s32=".s32" u32=".u32" f32=".f32" f64=".f64"
itblock 4 \cond
vcvt\cond\s32\f32 s0,s1
vcvt\cond\u32\f32 s0,s1
vcvt\cond\f32\s32 s0,s1
vcvt\cond\f32\u32 s0,s1
itblock 4 \cond
vcvt\cond\f32\f64 s0,d1
vcvt\cond\f64\f32 d0,s1
vcvt\cond\s32\f64 s0,d1
vcvt\cond\u32\f64 s0,d1
itblock 2 \cond
vcvt\cond\f64\s32 d0,s1
vcvt\cond\f64\u32 d0,s1
.endm
cvt
cvt eq
.macro cvti cond="" s32=".s32" u32=".u32" f32=".f32" f64=".f64" s16=".s16" u16=".u16"
itblock 4 \cond
vcvt\cond\s32\f32 s0,s0,#1
vcvt\cond\u32\f32 s0,s0,#1
vcvt\cond\f32\s32 s0,s0,#1
vcvt\cond\f32\u32 s0,s0,#1
itblock 4 \cond
vcvt\cond\s32\f64 d0,d0,#1
vcvt\cond\u32\f64 d0,d0,#1
vcvt\cond\f64\s32 d0,d0,#1
vcvt\cond\f64\u32 d0,d0,#1
itblock 4 \cond
vcvt\cond\f32\s16 s0,s0,#1
vcvt\cond\f32\u16 s0,s0,#1
vcvt\cond\f64\s16 d0,d0,#1
vcvt\cond\f64\u16 d0,d0,#1
itblock 4 \cond
vcvt\cond\s16\f32 s0,s0,#1
vcvt\cond\u16\f32 s0,s0,#1
vcvt\cond\s16\f64 d0,d0,#1
vcvt\cond\u16\f64 d0,d0,#1
.endm
cvti
cvti eq
.macro multi op cond="" n="" ia="ia" db="db"
itblock 4 \cond
\op\n\cond r0,{s3-s6}
\op\ia\cond r0,{s3-s6}
\op\ia\cond r0!,{s3-s6}
\op\db\cond r0!,{s3-s6}
itblock 4 \cond
\op\n\cond r0,{d3-d6}
\op\ia\cond r0,{d3-d6}
\op\ia\cond r0!,{d3-d6}
\op\db\cond r0!,{d3-d6}
.endm
multi vldm
multi vldm eq
multi vstm
multi vstm eq
.macro single op cond=""
itblock 2 \cond
\op\cond s0,[r0,#4]
\op\cond d0,[r0,#4]
.endm
single vldr
single vldr eq
single vstr
single vstr eq
|
stsp/binutils-ia16
| 1,917
|
gas/testsuite/gas/arm/mve-vstrldr-2.s
|
.syntax unified
.thumb
.macro all_vstr op, imm
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
\op \op1, [\op2, #\imm]
\op \op1, [\op2, #-\imm]
\op \op1, [\op2, #\imm]!
\op \op1, [\op2, #-\imm]!
.endr
.endr
.endm
.irp data, .32, .u32, .s32, .f32
.irp imm, 0, 4, 8, 16, 32, 64, 128, 256, 508, 340, 168, 60, 480
all_vstr vstrw\data, \imm
.endr
.endr
.irp data, .64, .u64, .s64
.irp imm, 0, 8, 16, 32, 64, 128, 256, 512, 1016, 680, 336, 960, 120
all_vstr vstrd\data, \imm
.endr
.endr
vpstete
vstrwt.32 q0, [q1, #4]
vstrwe.u32 q1, [q0, #-4]
vstrwt.s32 q2, [q2]
vstrwe.f32 q3, [q4, #-508]
vpstet
vstrdt.64 q4, [q5, #512]
vstrde.u64 q5, [q6, #1016]
vstrdt.s64 q6, [q7, #-1016]
.macro all_vldr_qq op, op1, op2, imm
\op \op1, [\op2, #\imm]
\op \op1, [\op2, #-\imm]
\op \op1, [\op2, #\imm]!
\op \op1, [\op2, #-\imm]!
.endm
.macro all_vldr_q0 op, imm
.irp op2, q1, q2, q4, q7
all_vldr_qq \op, q0, \op2, \imm
.endr
.endm
.macro all_vldr_q1 op, imm
.irp op2, q0, q2, q4, q7
all_vldr_qq \op, q1, \op2, \imm
.endr
.endm
.macro all_vldr_q2 op, imm
.irp op2, q0, q1, q4, q7
all_vldr_qq \op, q2, \op2, \imm
.endr
.endm
.macro all_vldr_q4 op, imm
.irp op2, q0, q1, q2, q7
all_vldr_qq \op, q4, \op2, \imm
.endr
.endm
.macro all_vldr_q7 op, imm
.irp op2, q0, q1, q2, q4
all_vldr_qq \op, q7, \op2, \imm
.endr
.endm
.macro all_vldr op, imm
all_vldr_q0 \op, \imm
all_vldr_q1 \op, \imm
all_vldr_q2 \op, \imm
all_vldr_q4 \op, \imm
all_vldr_q7 \op, \imm
.endm
.irp data, .32, .u32, .s32, .f32
.irp imm, 0, 4, 8, 16, 32, 64, 128, 256, 508, 340, 168, 60, 480
all_vldr vldrw\data, \imm
.endr
.endr
.irp data, .64, .u64, .s64
.irp imm, 0, 8, 16, 32, 64, 128, 256, 512, 1016, 680, 336, 960, 120
all_vldr vldrd\data, \imm
.endr
.endr
vpstete
vldrwt.32 q0, [q1, #4]
vldrwe.u32 q1, [q0, #-4]
vldrwt.s32 q2, [q3]
vldrwe.f32 q3, [q4, #-508]
vpstet
vldrdt.64 q4, [q5, #512]
vldrde.u64 q5, [q6, #1016]
vldrdt.s64 q6, [q7, #-1016]
|
stsp/binutils-ia16
| 3,847
|
gas/testsuite/gas/arm/unpredictable.s
|
.text
.global upredictable
unpredictable:
.word 0x004f00b1 @ strheq r0, [pc], #-1
.word 0x005fffff @ ldrsheq pc, [pc], #-255
.word 0x007fffff @ ldrsheq pc, [pc, #-255]!
.word 0x00cf00b0 @ strheq r0, [pc], #0
.word 0x00df00b0 @ ldrheq r0, [pc], #0
.word 0x00dfffff @ ldrsheq pc, [pc], #255
.word 0x00ffffff @ ldrsheq pc, [pc, #255]
.word 0x0000f0b0 @ strheq pc, [r0], -r0
.word 0x000ff0be @ strheq pc, [pc], -lr
.word 0xe16fff10 @ clz pc, r0
.word 0xe16f0f1f @ clz r0, r15
.word 0xe99f0001 @ ldmib r15, { r0 }
.word 0xe9910000 @ ldmib r1, { }
.word 0xe89f0002 @ ldmia pc, { r1 }
.word 0xe93f0004 @ ldmdb r15!, { r2 }
.word 0xe83f0008 @ ldmda pc!, { r3 }
.word 0xe7d0f001 @ ldrb pc, [r0, r1]
.word 0xe6f0f001 @ ldrbt pc, [r0], r1
.word 0xe190f0b1 @ ldrh pc, [r0, r1]
.word 0xe190f0d1 @ ldrsb pc, [r0, r1]
.word 0xe010f0d0 @ ldrsb pc, [r0], -r0
.word 0xe190f0f1 @ ldrsh pc, [r0, r1]
.word 0xe6b0f001 @ ldrt pc, [r0], r1
.word 0xe020f291 @ mla r0, r1, r2, pc
.word 0xe0202f91 @ mla r0, r1, pc, r2
.word 0xe020219f @ mla r0, pc, r1, r2
.word 0xe02f2190 @ mla pc, r0, r1, r2
.word 0xe10ff000 @ mrs pc, cpsr
.word 0xe0000f91 @ mul r0, r1, pc
.word 0xe001009f @ mul r0, pc, r1
.word 0xe00f0091 @ mul pc, r1, r0
.word 0xe0e21f93 @ smlal r1, r2, r3, pc
.word 0xe0e2149f @ smlal r1, r2, pc, r4
.word 0xe0ef1493 @ smlal r1, pc, r3, r4
.word 0xe0e2f493 @ smlal pc, r2, r3, r4
.word 0xe0e11493 @ smlal r1, r1, r3, r4
.word 0xe0c21f93 @ smull r1, r2, r3, pc
.word 0xe0c2149f @ smull r1, r2, pc, r4
.word 0xe0cf1493 @ smull r1, pc, r3, r4
.word 0xe0c2f493 @ smull pc, r2, r3, r4
.word 0xe0c11493 @ smull r1, r1, r3, r4
.word 0xe98f0004 @ stmib r15, { r2 }
.word 0xe88f0008 @ stmia r15, { r3 }
.word 0xe92f0010 @ stmdb r15!, { r4 }
.word 0xe82f0020 @ stmda r15!, { r5 }
.word 0xe180f0b1 @ strh pc, [r0, r1]
.word 0xe103f092 @ swp r15, r2, [r3]
.word 0xe103109f @ swp r1, r15, [r3]
.word 0xe10f1092 @ swp r1, r2, [r15]
.word 0xe1031093 @ swp r1, r3, [r3]
.word 0xe1033092 @ swp r3, r2, [r3]
.word 0xe143f092 @ swpb r15, r2, [r3]
.word 0xe143109f @ swpb r1, r15, [r3]
.word 0xe14f1092 @ swpb r1, r2, [r15]
.word 0xe1431093 @ swpb r1, r3, [r3]
.word 0xe1433092 @ swpb r3, r2, [r3]
.word 0xe0a21f93 @ umlal r1, r2, r3, r15
.word 0xe0a2149f @ umlal r1, r2, r15, r4
.word 0xe0af1493 @ umlal r1, r15, r3, r4
.word 0xe0a2f493 @ umlal r15, r2, r3, r4
.word 0xe0a11493 @ umlal r1, r1, r3, r4
.word 0xe0821f93 @ umull r1, r2, r3, r15
.word 0xe082149f @ umull r1, r2, r15, r4
.word 0xe08f1493 @ umull r1, r15, r3, r4
.word 0xe082f493 @ umull r15, r2, r3, r4
.word 0xe0811493 @ umull r1, r1, r3, r4
nop @ Marker to indicated end of unpredictable insns.
|
stsp/binutils-ia16
| 1,341
|
gas/testsuite/gas/arm/mve-vmullbt.s
|
.syntax unified
.thumb
.macro helper_q0 op
.irp op2, q1, q2, q4, q7
.irp op3, q1, q2, q4, q7
\op q0, \op2, \op3
.endr
.endr
.endm
.macro helper_q1 op
.irp op2, q0, q2, q4, q7
.irp op3, q0, q2, q4, q7
\op q1, \op2, \op3
.endr
.endr
.endm
.macro helper_q2 op
.irp op2, q0, q1, q4, q7
.irp op3, q0, q1, q4, q7
\op q2, \op2, \op3
.endr
.endr
.endm
.macro helper_q4 op
.irp op2, q0, q1, q2, q7
.irp op3, q0, q1, q2, q7
\op q4, \op2, \op3
.endr
.endr
.endm
.macro helper_q7 op
.irp op2, q0, q1, q2, q4
.irp op3, q0, q1, q2, q4
\op q7, \op2, \op3
.endr
.endr
.endm
.macro all_qqq op
helper_q0 \op
helper_q1 \op
helper_q2 \op
helper_q4 \op
helper_q7 \op
.endm
.irp data, s8, u8, s16, u16, p8, p16
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
.irp op3, q0, q1, q2, q4, q7
vmullb.\data \op1, \op2, \op3
vmullt.\data \op1, \op2, \op3
.endr
.endr
.endr
.endr
all_qqq vmullb.s32
all_qqq vmullb.u32
all_qqq vmullt.s32
all_qqq vmullt.u32
vpstete
vmullbt.s8 q0, q1, q2
vmullbe.s16 q1, q0, q3
vmullbt.s32 q2, q3, q4
vmullbe.u8 q3, q2, q1
vpstete
vmullbt.u16 q4, q5, q7
vmullbe.u32 q5, q4, q6
vmullbt.p8 q6, q7, q5
vmullbe.p16 q7, q6, q0
vpstete
vmulltt.s8 q0, q1, q2
vmullte.s16 q1, q0, q3
vmulltt.s32 q2, q3, q4
vmullte.u8 q3, q2, q1
vpstete
vmulltt.u16 q4, q5, q7
vmullte.u32 q5, q4, q6
vmulltt.p8 q6, q7, q5
vmullte.p16 q7, q6, q0
|
stsp/binutils-ia16
| 1,917
|
gas/testsuite/gas/arm/armv8-2-fp16-scalar.s
|
.macro f16_sss_arithmetic reg0, reg1, reg2
.irp op, vdiv.f16, vfma.f16, vfms.f16, vfnma.f16, vfnms.f16, vmaxnm.f16, vminnm.f16, vmla.f16, vmls.f16, vmul.f16, vnmla.f16, vnmls.f16, vnmul.f16, vsub.f16
\op s\reg0, s\reg1, s\reg2
.endr
.endm
.macro f16_ss_arithmetic reg0, reg1
.irp op, vabs.f16, vadd.f16, vsqrt.f16, vneg.f16
\op s\reg0, s\reg1
.endr
.endm
.macro f16_si_cmp reg0, imm
.irp op, vcmp.f16, vcmpe.f16
\op s\reg0, \imm
.endr
.endm
.macro f16_ss_cmp reg0, reg1
.irp op, vcmp.f16, vcmpe.f16
\op s\reg0, s\reg1
.endr
.endm
.macro f16_sss_vsel reg0, reg1, reg2
.irp op, vseleq.f16 vselge.f16, vselvs.f16
\op s\reg0, s\reg1, s\reg2
.endr
.endm
.macro f16_ss_cvt reg0, reg1
.irp op, vcvt.s32.f16, vcvt.u32.f16, vcvt.f16.s32, vcvt.f16.u32
\op s\reg0, s\reg1
.endr
.endm
.macro f16_ssi_cvt_imm32 reg0, reg1, imm
.irp op, vcvt.f16.s32, vcvt.f16.u32, vcvt.s32.f16, vcvt.u32.f16
\op s\reg0, s\reg1, \imm
.endr
.endm
.macro f16_ss_cvt_amnpr reg0, reg1
.irp op, vcvta.s32.f16, vcvta.u32.f16, vcvtm.s32.f16, vcvtm.u32.f16, vcvtn.s32.f16, vcvtn.u32.f16, vcvtp.s32.f16, vcvtp.u32.f16, vcvtr.u32.f16, vcvtr.s32.f16
\op s\reg0, s\reg1
.endr
.endm
.macro f16_ss_vrint reg0, reg1
.irp op, vrinta.f16, vrintm.f16, vrintn.f16, vrintp.f16, vrintr.f16, vrintx.f16, vrintz.f16
\op s\reg0, s\reg1
.endr
.endm
.macro f16_ss_mov reg0, reg1
.irp op, vins.f16, vmovx.f16
\op s\reg0, s\reg1
.endr
.endm
.text
vmov.f16 s0, r1
vmov.f16 r0, s1
vmov.f16 s0, #2.0
label:
.word 0xffe
vldr.16 s3, label
vldr.16 s6, [pc, #-4]
vldr.16 s3, [pc, #4]
vldr.16 s1, [r0, #4]
vldr.16 s2, [r0, #-4]
vstr.16 s6 , [r0, #4]
vstr.16 s11 , [r0, #-4]
f16_sss_arithmetic 5, 13, 24
f16_ss_arithmetic 5, 12
f16_si_cmp 2, #0.0
f16_ss_cmp 5, 13
f16_sss_vsel 5, 13, 23
f16_ss_cvt 3, 8
f16_ssi_cvt_imm32 7, 7, #29
f16_ss_cvt_amnpr 5, 10
f16_ss_vrint 3, 11
f16_ss_mov 5, 9
|
stsp/binutils-ia16
| 1,265
|
gas/testsuite/gas/arm/neon-cond-bad-inc.s
|
# Check for illegal conditional Neon instructions in ARM mode. The instructions
# which overlap with VFP are the tricky cases, so test those.
.include "itblock.s"
.syntax unified
.arch armv7-a
.fpu neon
.text
func:
itblock 4 eq
vmoveq q0,q1
vmoveq d0,d1
vmoveq.i32 q0,#0
vmoveq.i32 d0,#0
@ Following four *can* be conditional.
itblock 4 eq
vmoveq.32 d0[1], r2
vmoveq d0,r1,r2
vmoveq.32 r2,d1[0]
vmoveq r0,r1,d2
.macro dyadic_eq op eq="eq" f32=".f32"
itblock 2 eq
\op\eq\f32 d0,d1,d2
\op\eq\f32 q0,q1,q2
.endm
dyadic_eq vmul
dyadic_eq vmla
dyadic_eq vmls
dyadic_eq vadd
dyadic_eq vsub
itblock 2 eq
vcvteq.f16.f32 d1, q1
vcvteq.f32.f16 q1, d1
.macro monadic_eq op eq="eq" f32=".f32"
itblock 2 eq
\op\eq\f32 d0,d1
\op\eq\f32 q0,q1
.endm
monadic_eq vabs
monadic_eq vneg
.macro cvt to from dot="."
itblock 2 eq
vcvteq\dot\to\dot\from d0,d1
vcvteq\dot\to\dot\from q0,q1
.endm
cvt s32 f32
cvt u32 f32
cvt f32 s32
cvt f32 u32
itblock 4 eq
vdupeq.32 d0,r1
vdupeq.32 q0,r1
vdupeq.32 d0,d1[0]
vdupeq.32 q0,d1[1]
|
stsp/binutils-ia16
| 1,202
|
gas/testsuite/gas/arm/vfma1.s
|
.eabi_attribute Tag_Advanced_SIMD_arch, 2
.eabi_attribute Tag_VFP_arch, 6
@VMLA
.inst 0xee000a00 @ VFP vmla.f32 s0,s0,s0
.inst 0xee000b00 @ VFP vmla.f64 d0,d0,d0
.inst 0xf2000d10 @ NEON vmla.f32 d0,d0,d0
.inst 0xf2000d50 @ NEON vmla.f32 q0,q0,q0
@VFMA new
.inst 0xeea00a00 @ VFP vfma.f32 s0,s0,s0
.inst 0xeea00b00 @ VFP vfma.f64 d0,d0,d0
.inst 0xf2000c10 @ NEON vfma.f32 d0,d0,d0
.inst 0xf2000c50 @ NEON vfma.f32 q0,q0,q0
@VMLS
.inst 0xee000a40 @ VFP vmls.F32 s0,s0,s0
.inst 0xee000b40 @ VFP vmls.F64 d0,d0,d0
.inst 0xf2200d10 @ NEON vmls.F32 d0,d0,d0
.inst 0xf2200d50 @ NEON vmls.F32 q0,q0,q0
@VFMS new
.inst 0xeea00a40 @ VFP vfms.F32 s0,s0,s0
.inst 0xeea00b40 @ VFP vfms.F64 d0,d0,d0
.inst 0xf2200c10 @ NEON vfms.F32 d0,d0,d0
.inst 0xf2200c50 @ NEON vfms.F32 q0,q0,q0
@VNMLA
.inst 0xee100a40 @ VFP vnmla.F32 s0,s0,s0
.inst 0xee100b40 @ VFP vnmla.F64 d0,d0,d0
@VFNMA new
.inst 0xee900a40 @ VFP vfnma.F32 s0,s0,s0
.inst 0xee900b40 @ VFP vfnma.F64 d0,d0,d0
@VNMLS
.inst 0xee100a00 @ VFP vnmls.F32 s0,s0,s0
.inst 0xee100b00 @ VFP vnmls.F64 d0,d0,d0
@VFNMS new
.inst 0xee900a00 @ VFP vfnms.F32 s0,s0,s0
.inst 0xee900b00 @ VFP vfnms.F64 d0,d0,d0
|
stsp/binutils-ia16
| 1,461
|
gas/testsuite/gas/arm/mve-vcadd.s
|
.syntax unified
.thumb
.irp data, i8, i16, f16
.irp op1, q0, q1, q2, q4, q7
.irp op2, q0, q1, q2, q4, q7
.irp op3, q0, q1, q2, q4, q7
.irp op4, #90, #270
vcadd.\data \op1, \op2, \op3, \op4
.endr
.endr
.endr
.endr
.endr
.macro vcadd_q0 data, op2, op4
.irp op3, q1, q2, q4, q7
vcadd.\data q0, \op2, \op3, \op4
.endr
.endm
.macro vcadd_q1 data, op2, op4
.irp op3, q0, q2, q4, q7
vcadd.\data q1, \op2, \op3, \op4
.endr
.endm
.macro vcadd_q2 data, op2, op4
.irp op3, q0, q1, q4, q7
vcadd.\data q2, \op2, \op3, \op4
.endr
.endm
.macro vcadd_q3 data, op2, op4
.irp op3, q0, q1, q2, q4, q7
vcadd.\data q3, \op2, \op3, \op4
.endr
.endm
.macro vcadd_q4 data, op2, op4
.irp op3, q0, q1, q2, q3, q7
vcadd.\data q4, \op2, \op3, \op4
.endr
.endm
.macro vcadd_q6 data, op2, op4
.irp op3, q0, q1, q2, q4, q7
vcadd.\data q6, \op2, \op3, \op4
.endr
.endm
.macro vcadd_q7 data, op2, op4
.irp op3, q0, q1, q2, q4, q5
vcadd.\data q7, \op2, \op3, \op4
.endr
.endm
.irp data, i32, f32
.irp op2, q0, q1, q2, q4, q7
.irp op4, #90, #270
vcadd_q0 \data, \op2, \op4
vcadd_q1 \data, \op2, \op4
vcadd_q2 \data, \op2, \op4
vcadd_q3 \data, \op2, \op4
vcadd_q4 \data, \op2, \op4
vcadd_q6 \data, \op2, \op4
vcadd_q7 \data, \op2, \op4
.endr
.endr
.endr
vpstete
vcaddt.i8 q0, q1, q2, #90
vcadde.i8 q7, q7, q7, #270
vcaddt.i16 q0, q1, q2, #90
vcadde.i16 q0, q1, q2, #270
vpstete
vcaddt.i32 q0, q1, q2, #90
vcadde.i32 q0, q1, q2, #270
vcaddt.f16 q0, q1, q2, #90
vcadde.f32 q0, q1, q2, #270
|
stsp/binutils-ia16
| 1,872
|
gas/testsuite/gas/arm/sp-pc-usage-t.s
|
.arch armv7-r
.syntax unified
.text
.thumb
.global foo
foo:
.align 4
@ Section A6.1.3 "Use of 0b1101 as a register specifier".
@ R13 as the source or destination register of a mov instruction.
@ only register to register transfers without shifts are supported,
@ with no flag setting
mov sp,r0
mov r0,sp
@ Using the following instructions to adjust r13 up or down by a
@ multiple of 4:
add sp,sp,#0
addw sp,sp,#0
sub sp,sp,#0
subw sp,sp,#0
add sp,sp,r0
add sp,sp,r0,lsl #1
sub sp,sp,r0
sub sp,sp,r0,lsl #1
@ R13 as a base register <Rn> of any load/store instruction.
ldr r0, [sp]
ldr r0, [pc]
ldr pc, [r0]
ldr sp, [r0]
ldr pc, [pc]
ldr sp, [sp]
ldr pc, [sp]
ldr sp, [pc]
str r0, [sp]
str sp, [r0]
str sp, [sp]
@ R13 as the first operand <Rn> in any add{s}, cmn, cmp, or sub{s} instruction.
add r0, sp, r0
adds r0, sp, r0
add r0, sp, r0, lsl #1
adds r0, sp, r0, lsl #1
cmn sp, #0
cmn sp, r0
cmn sp, r0, lsl #1
cmp sp, #0
cmp sp, r0
cmp sp, r0, lsl #1
sub sp, #0
subs sp, #0
sub r0, sp, #0
subs r0, sp, #0
@ ADD (sp plus immediate).
add sp, #4
add r0, sp, #4
adds sp, #4
adds r0, sp, #4
addw r0, sp, #4
add sp, sp, #4
adds sp, sp, #4
addw sp, sp, #4
@ ADD (sp plus register).
add sp, r0
add r0, sp, r0
add r0, sp, r0, lsl #1
adds sp, r0
adds r0, sp, r0
adds r0, sp, r0, lsl #1
add sp, sp, r0
add sp, sp, r0, lsl #1
adds sp, sp, r0
adds sp, sp, r0, lsl #1
add sp, sp, sp
@ SUB (sp minus immediate).
sub r0, sp , #0
subs r0, sp , #0
subw r0, sp , #0
sub sp, sp , #0
subs sp, sp , #0
subw sp, sp , #0
@ SUB (sp minus register).
sub sp, #0
subs sp, #0
sub r0, sp, r0, lsl #1
subs r0, sp, r0, lsl #1
sub sp, sp, r0, lsl #1
subs sp, sp, r0, lsl #1
@ PC-related insns (equivalent to adr).
add r0, pc, #4
sub r0, pc, #4
adds r0, pc, #4
subs r0, pc, #4
addw r0, pc, #4
subw r0, pc, #4
@ nops to pad the section out to an alignment boundary.
nop
nop
nop
|
stsp/binutils-ia16
| 2,844
|
gas/testsuite/gas/arm/arch7em.s
|
# Instructions included in v7E-M architecture over v7-M.
.text
.thumb
.syntax unified
pkh:
pkhbt r0, r0, r0
pkhbt r9, r0, r0
pkhbt r0, r9, r0
pkhbt r0, r0, r9
pkhbt r0, r0, r0, lsl #0x14
pkhbt r0, r0, r0, lsl #3
pkhtb r1, r2, r3
pkhtb r1, r2, r3, asr #0x11
qadd:
qadd r1, r2, r3
qadd16 r1, r2, r3
qadd8 r1, r2, r3
qasx r1, r2, r3
qaddsubx r1, r2, r3
qdadd r1, r2, r3
qdsub r1, r2, r3
qsub r1, r2, r3
qsub16 r1, r2, r3
qsub8 r1, r2, r3
qsax r1, r2, r3
qsubaddx r1, r2, r3
sadd16 r1, r2, r3
sadd8 r1, r2, r3
sasx r1, r2, r3
saddsubx r1, r2, r3
ssub16 r1, r2, r3
ssub8 r1, r2, r3
ssax r1, r2, r3
ssubaddx r1, r2, r3
shadd16 r1, r2, r3
shadd8 r1, r2, r3
shasx r1, r2, r3
shaddsubx r1, r2, r3
shsub16 r1, r2, r3
shsub8 r1, r2, r3
shsax r1, r2, r3
shsubaddx r1, r2, r3
uadd16 r1, r2, r3
uadd8 r1, r2, r3
uasx r1, r2, r3
uaddsubx r1, r2, r3
usub16 r1, r2, r3
usub8 r1, r2, r3
usax r1, r2, r3
usubaddx r1, r2, r3
uhadd16 r1, r2, r3
uhadd8 r1, r2, r3
uhasx r1, r2, r3
uhaddsubx r1, r2, r3
uhsub16 r1, r2, r3
uhsub8 r1, r2, r3
uhsax r1, r2, r3
uhsubaddx r1, r2, r3
uqadd16 r1, r2, r3
uqadd8 r1, r2, r3
uqasx r1, r2, r3
uqaddsubx r1, r2, r3
uqsub16 r1, r2, r3
uqsub8 r1, r2, r3
uqsax r1, r2, r3
uqsubaddx r1, r2, r3
sel r1, r2, r3
smla:
smlabb r0, r0, r0, r0
smlabb r9, r0, r0, r0
smlabb r0, r9, r0, r0
smlabb r0, r0, r9, r0
smlabb r0, r0, r0, r9
smlatb r0, r0, r0, r0
smlabt r0, r0, r0, r0
smlatt r0, r0, r0, r0
smlawb r0, r0, r0, r0
smlawt r0, r0, r0, r0
smlad r0, r0, r0, r0
smladx r0, r0, r0, r0
smlsd r0, r0, r0, r0
smlsdx r0, r0, r0, r0
smmla r0, r0, r0, r0
smmlar r0, r0, r0, r0
smmls r0, r0, r0, r0
smmlsr r0, r0, r0, r0
usada8 r0, r0, r0, r0
smlal:
smlalbb r0, r0, r0, r0
smlalbb r9, r0, r0, r0
smlalbb r0, r9, r0, r0
smlalbb r0, r0, r9, r0
smlalbb r0, r0, r0, r9
smlaltb r0, r0, r0, r0
smlalbt r0, r0, r0, r0
smlaltt r0, r0, r0, r0
smlald r0, r0, r0, r0
smlaldx r0, r0, r0, r0
smlsld r0, r0, r0, r0
smlsldx r0, r0, r0, r0
umaal r0, r0, r0, r0
smul:
smulbb r0, r0, r0
smulbb r9, r0, r0
smulbb r0, r9, r0
smulbb r0, r0, r9
smultb r0, r0, r0
smulbt r0, r0, r0
smultt r0, r0, r0
smulwb r0, r0, r0
smulwt r0, r0, r0
smmul r0, r0, r0
smmulr r0, r0, r0
smuad r0, r0, r0
smuadx r0, r0, r0
smusd r0, r0, r0
smusdx r0, r0, r0
usad8 r0, r0, r0
sat:
ssat16 r0, #1, r0
ssat16 r9, #1, r0
ssat16 r0, #10, r0
ssat16 r0, #1, r9
usat16 r0, #0, r0
usat16 r9, #0, r0
usat16 r0, #9, r0
usat16 r0, #0, r9
xt:
sxtb16 r1, r2
sxtb16 r8, r9
uxtb16 r1, r2
uxtb16 r8, r9
xta:
sxtab r0, r0, r0
sxtab r0, r0, r0, ror #0
sxtab r9, r0, r0, ror #8
sxtab r0, r9, r0, ror #16
sxtab r0, r0, r9, ror #24
sxtab16 r1, r2, r3
sxtah r1, r2, r3
uxtab r1, r2, r3
uxtab16 r1, r2, r3
uxtah r1, r2, r3
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.