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

Subversion Repositories openrisc_2011-10-31

Compare Revisions

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

Rev 132 → Rev 156

/fastcall.s
0,0 → 1,?rev2len?
@fastcall_label@0:
/assign.s
0,0 → 1,9
.global x
x = zzz
x = x+1
.long x
 
.global y
y = 1
y = y+zzz
.long y
/struct.s
0,0 → 1,10
.globl w1
.globl w2
.globl w3
.long 0
.struct 0
w1: .short 0
w2: .short 0
w3: .short 0
.text
.long 0
/forward.d
0,0 → 1,8
#objdump: -s -j .data
#name: forward references
 
.*: .*
 
Contents of section .data:
0000 01020304 ff0203fc 01020304 ff0203fc ................
#pass
/eval.s
0,0 → 1,48
.equ zero, 0
.equ one, 1
.equ two, 2
 
 
.data
 
.if two > one
.byte one
.else
.byte two
.endif
 
.if one == one
.byte one
.else
.byte two
.endif
 
.if one < two
.byte one
.else
.byte two
.endif
 
.if one <> two
.byte one
.else
.byte two
.endif
 
.if one != two
.byte one
.else
.byte two
.endif
 
.if one <= two
.byte one
.else
.byte two
.endif
 
.if two >= one
.byte one
.else
.byte two
.endif
/itbl-test.c
0,0 → 1,127
/* itbl-test.c
 
Copyright (C) 1997, 2007 Free Software Foundation, Inc.
 
This file is part of GAS, the GNU Assembler.
 
GAS 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, or (at your option)
any later version.
 
GAS 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 GAS; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA. */
 
/* Stand-alone test for instruction specification table support.
Run using "itbl-test <itbl> <asm.s>"
where <itbl> is the name of the instruction table,
and <asm.s> is the name of the assembler fie. */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "itbl-ops.h"
 
static int test_reg (e_processor processor, e_type type, char *name,
unsigned long val);
 
int
main (int argc, char **argv)
{
unsigned int insn;
FILE *fas;
int aline = 0;
char s[81], *name;
 
if (argc < 3)
{
printf ("usage: %s itbl asm.s\n", argv[0]);
exit (0);
}
if (itbl_parse (argv[1]) != 0)
{
printf ("failed to parse itbl\n");
exit (0);
}
 
fas = fopen (argv[2], "r");
if (fas == 0)
{
printf ("failed to open asm file %s\n", argv[2]);
exit (0);
}
while (fgets (s, 80, fas))
{
char *p;
aline++;
 
if (p = strchr (s, ';'), p) /* strip comments */
*p = 0;
if (p = strchr (s, '#'), p) /* strip comments */
*p = 0;
p = s + strlen (s) - 1;
while (p >= s && (*p == ' ' || *p == '\t' || *p == '\n')) /* strip trailing spaces */
p--;
*(p + 1) = 0;
p = s;
while (*p && (*p == ' ' || *p == '\t' || *p == '\n')) /* strip leading spaces */
p++;
if (!*p)
continue;
 
name = itbl_get_field (&p);
insn = itbl_assemble (name, p);
if (insn == 0)
printf ("line %d: Invalid instruction (%s)\n", aline, s);
else
{
char buf[128];
printf ("line %d: insn(%s) = 0x%x)\n", aline, s, insn);
if (!itbl_disassemble (buf, insn))
printf ("line %d: Can't disassemble instruction "
"(0x%x)\n", aline, insn);
else
printf ("line %d: disasm(0x%x) = %s)\n", aline, insn, buf);
}
}
 
test_reg (1, e_dreg, "d1", 1);
test_reg (3, e_creg, "c2", 22);
test_reg (3, e_dreg, "d3", 3);
 
return 0;
}
 
static int
test_reg (e_processor processor, e_type type, char *name,
unsigned long val)
{
char *n;
unsigned long v;
 
n = itbl_get_name (processor, type, val);
if (!n || strcmp (n, name))
printf ("Error - reg name not found for proessor=%d, type=%d, val=%d\n",
processor, type, val);
else
printf ("name=%s found for processor=%d, type=%d, val=%d\n",
n, processor, type, val);
 
/* We require that names be unique amoung processors and types. */
if (! itbl_get_reg_val (name, &v)
|| v != val)
printf ("Error - reg val not found for processor=%d, type=%d, name=%s\n",
processor, type, name);
else
printf ("val=0x%x found for processor=%d, type=%d, name=%s\n",
v, processor, type, name);
return 0;
}
/test-example.c
0,0 → 1,103
/* Copyright (C) 2000, 2003, 2007 Free Software Foundation
Contributed by Alexandre Oliva <aoliva@cygnus.com>
 
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. */
 
/* Generator of tests for insns introduced in AM33 2.0.
See the following file for usage and documentation. */
#include "../all/test-gen.c"
 
/* Define any char*[]s you may need here. */
char *named_regs[] = { "a", "b", "c", "d" };
 
/* Define helper macros to generate register accesses here. */
#define namedregs(shift) \
reg_r (named_regs, shift, 0x3, mk_get_bits (2u))
#define numberedregs(shift) \
reg_p ("f", shift, mk_get_bits (2u))
 
/* Define helper functions here. */
int
jmp_cond (func_arg * arg, insn_data * data)
#define jmp_cond(shift) { jmp_cond, { i1: shift } }
{
static const char conds[4][2] = { "z", "n", "g", "l" };
unsigned val = get_bits (2u);
 
data->as_in = data->dis_out = strdup (conds[val]);
data->bits = val << arg->i1;
 
/* Do not forget to return 0, otherwise the insn will be skipped. */
return 0;
}
 
/* Define convenience wrappers to define_insn. */
#define cond_jmp_insn(insname, word, funcs...) \
define_insn (insname, \
insn_size_bits (insname, 1, word), \
jmp_cond (4), \
tab, \
## funcs)
 
/* Define insns. */
cond_jmp_insn (j, 0x40, numberedregs(2), comma, namedregs (0));
 
/* Define an insn group. */
func *jmp_insns[] =
{
insn (j),
0
};
 
/* Define the set of all groups. */
group_t
groups[] =
{
{ "jumps", jmp_insns },
{ 0 }
};
 
int
main (int argc, char *argv[])
{
FILE *as_in = stdout, *dis_out = stderr;
 
/* Check whether we're filtering insns. */
if (argc > 1)
skip_list = argv + 1;
 
/* Output assembler header. */
fputs ("\t.text\n"
"\t.align\n",
as_in);
/* Output comments for the testsuite-driver and the initial
disassembler output. */
fputs ("#objdump: -dr --prefix-address --show-raw-insn\n"
"#name: Foo Digital Processor\n"
"#as: -mfood\n"
"\n"
"# Test the instructions of FooD\n"
"\n"
".*: +file format.*food.*\n"
"\n"
"Disassembly of section .text:\n",
dis_out);
 
/* Now emit all (selected) insns. */
output_groups (groups, as_in, dis_out);
 
exit (0);
}
/redef3.d
0,0 → 1,15
#objdump: -rsj .data
#name: .equ redefinitions (3)
 
.*: .*
 
RELOCATION RECORDS FOR .*
.*
0+00.*(here|\.data)
0+08.*xtrn
0+10.*sym
#...
Contents of section \.data:
0000 00000000 11111111 00000000 22222222[ ]+................[ ]*
0010 00000000 .*
#pass
/quad.s
0,0 → 1,12
.data
.quad 0x76543210
.quad 0x80000000
.quad 0x87654321
.quad 0xffffffff
.quad -0x76543210
.quad -0x80000000
.quad -0x87654321
.quad -0xffffffff
 
.quad 0x123456789abcdef
.quad -0x123456789abcdef
/weakref1g.d
0,0 → 1,18
#nm: --defined-only --extern-only
#name: weakref tests, global syms
#source: weakref1.s
# see weakref1.d for comments on the not-targets
# ecoff (OSF/alpha) lacks .weak support
# pdp11 lacks .long
#not-target: alpha*-*-osf* *-*-ecoff pdp11-*-aout
 
# the rest of this file is generated with the following script:
# # script begin
# echo \#...
# sed -n 's,^[ ]*\.global \(g.*\),.* T \1,p' weakref1.s | uniq
# echo \#pass
# # script output:
#...
.* T gd6
.* T gd7
#pass
/comment.s
0,0 → 1,3
# This test file is to see whether comments get written into listings
# correctly. The file has no real contents.
/* C comments too! */
/forward.s
0,0 → 1,44
.equiv two, 2*one
.equiv minus_one, -one
.equ one, 1
.equiv three, 3*one
.eqv four, 4*one
 
.data
 
.if two > one
.byte one
.byte two
.endif
.if four > one
.byte three
.byte four
.endif
 
.equ one, -1
.byte one
.byte two
.if four < one
.byte three
.byte four
.endif
 
.equ one, -minus_one
.byte one
.byte two
.if four > one
.byte three
.byte four
.endif
 
.equ one, minus_one
.byte one
.byte two
 
.if four < one
.byte three
.byte four
.endif
/gas.exp
0,0 → 1,336
#
# These tests should be valid on all targets.
#
 
# I think currently all targets fail this one when listings are enabled.
gas_test "p2425.s" "" "" "pcrel values in assignment"
 
# p1480.s uses a ".space" directive which for most assemblers means
# "allocate some space". On the PA it means "switch into this space".
#
# Therefore this test (as it is currently written) is completely bogus
# for any PA target. Do not bother trying to run it and just claim
# it fails.
#
# The C54x uses ".space" to allocate bits, and requires absolute expressions;
# The ".space" directive is taken care of in the C54x-specific tests, so fail
# here
#
# The test also doesn't work on mep targets, since they use RELC, and it
# will avoid simplifying the expression since it conservatively assumes
# ugly expressions can be saved until link-time.
if { [istarget hppa*-*-*] || [istarget *c54x*-*-*] || [istarget mep*-*-*]} then {
setup_xfail *-*-*
fail "simplifiable double subtraction"
} else {
gas_test "p1480.s" "" "-a>" "simplifiable double subtraction"
}
 
# No floating point support in assembly code for CRIS and Z80.
if { ![istarget cris-*-*] && ![istarget crisv32-*-*]
&& ![istarget z80-*-*] } then {
gas_test "float.s" "" "" "simple FP constants"
}
 
# This test is meaningless for the PA; the difference of two undefined
# symbols is something that is (and must be) supported on the PA.
#
# The MN10300 port supports link time relaxation which in turn allows
# for link time resolution of the differneces of two symbols which are
# undefined at assembly time. Hence this test will not pass for the
# MN10300.
if { ![istarget hppa*-*-*] && ![istarget mn10300-*-*] && ![istarget am3*-*-*] } then {
gas_test_error "diff1.s" "" "difference of two undefined symbols"
}
 
gas_test_error "equiv1.s" "" ".equiv for symbol already set to another one"
gas_test_error "equiv2.s" "" ".equiv for symbol already set to an expression"
 
# .equ works differently on some targets.
case $target_triplet in {
{ hppa*-*-* } { }
{ *c54x*-*-* } { }
default {
gas_test "equ-ok.s" "" "" ".equ for symbol already set"
gas_test_error "equ-bad.s" "" ".equ for symbol already set through .eqv"
}
}
 
gas_test "eqv-ok.s" "" "" ".eqv support"
gas_test_error "eqv-bad.s" "" ".eqv for symbol already set"
 
gas_test "assign-ok.s" "" "" "== assignment support"
gas_test_error "assign-bad.s" "" "== assignment for symbol already set"
 
# .equ works differently on some targets.
# linkrelax-ing prevents most forward references from working.
case $target_triplet in {
{ cr16*-*-* } { }
{ crx*-*-* } { }
{ h8300*-*-* } { }
{ hppa*-*-* } { }
{ mn10\[23\]00*-*-* } { }
{ *c54x*-*-* } { }
default {
# Some targets don't manage to resolve BFD_RELOC_8 for constants.
setup_xfail "alpha*-*-*" "avr-*-*" "*c30*-*-*" "*c4x*-*-*" \
"d\[13\]0v*-*-*" "i860-*-*" "mips*-*-*" "msp430-*-*" \
"pdp11-*-*" "sparc*-*-*" "xtensa*-*-*"
run_dump_test forward
}
}
 
# .set works differently on some targets.
case $target_triplet in {
{ alpha*-*-* } { }
{ mips*-*-* } { }
{ *c54x*-*-* } { }
{ z80-*-* } { }
default {
setup_xfail "*c30*-*-*" "*c4x*-*-*" "pdp11-*-*"
run_dump_test redef
# The next two tests can fail if the target does not convert fixups
# against ordinary symbols into relocations against section symbols.
# This is usually revealed by the error message:
# symbol `sym' required but not present
setup_xfail "*c30*-*-*" "*c4x*-*-*" "*arm*-*-*aout*" "*arm*-*-*coff" \
"*arm*-*-pe" "crx*-*-*" "h8300*-*-*" "m68hc*-*-*" "maxq-*-*" \
"mn10300-*-*" "pdp11-*-*" "vax*-*-*" "z8k-*-*" "cr16-*-*"
run_dump_test redef2
setup_xfail "*-*-aix*" "*-*-coff" "*-*-cygwin" "*-*-mingw*" "*-*-pe*" \
"bfin-*-*" "*c4x*-*-*" "crx*-*-*" "h8300*-*-*" "hppa*-*-hpux*" \
"m68hc*-*-*" "maxq-*-*" "mn10300-*-*" "or32-*-*" "pdp11-*-*" \
"vax*-*-*" "z8k-*-*" "cr16-*-*"
run_dump_test redef3
setup_xfail "*c4x*-*-*"
gas_test_error "redef4.s" "" ".set for symbol already used as label"
setup_xfail "*c4x*-*-*"
gas_test_error "redef5.s" "" ".set for symbol already defined through .comm"
}
}
 
proc do_comment {} {
set testname "comment.s: comments in listings"
set x1 0
set x2 0
set x3 0
set white {[ \t]*}
gas_start "comment.s" "-al"
while 1 {
# Apparently CRLF is received when using ptys for subprocesses; hence the
# \r\n for line 3.
expect {
-re "^ +1\[ \t\]+# This\[^\n\]*\n" { set x1 1 }
-re "^ +2\[ \t\]+# correctly\[^\n\]*\n" { set x2 1 }
-re "^ +3\[ \t\]+/. C comments too. ./\r?\r?\n" { set x3 1 }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
gas_finish
if [all_ones $x1 $x2 $x3] then { pass $testname } else { fail $testname }
}
 
do_comment
 
# This test checks the output of the -ag switch. It must detect at least
# the name of the input file, output file, and options passed.
proc general_info_section {} {
set testname "general info section in listings"
set x1 0
set x2 0
set x3 0
set white {[ \t]*}
gas_start "comment.s" "-agn"
while 1 {
expect {
-re "^ \[^\n\]*\t: \-agn\[^\n\]*\n" { set x1 1 }
-re "^ \[^\n\]*\t: \[^\n\]*comment\.s\[^\n\]*\n" { set x2 1 }
-re "^ \[^\n\]*\t: a\.out\[^\n\]*\n" { set x3 1 }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
gas_finish
if [all_ones $x1 $x2 $x3] then { pass $testname } else { fail $testname }
}
 
general_info_section
 
#
# Test x930509a -- correct assembly of differences involving forward
# references.
#
 
proc do_930509a {} {
set testname "difference between forward references"
set x 0
gas_start "x930509.s" "-al"
while 1 {
# We need to accomodate both byte orders here.
# If ".long" means an 8-byte value on some target someday, this test will have
# to be fixed.
expect {
-re "^ +1 .... 00 ?00 ?00 ?00" { fail $testname; set x 1 }
-re "^ +1 .... 04 ?00 ?00 ?00" { pass $testname; set x 1 }
-re "^ +1 .... 00 ?00 ?00 ?04" { pass $testname; set x 1 }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
gas_finish
if !$x then { fail $testname }
}
 
# This test is meaningless for the PA and CR16/CRX: the difference of two
# symbols cannot be resolved by the assembler.
# C54x assembler (for compatibility) does not allow differences between
# forward references.
# C30 counts a four byte offset as a difference of one.
if { ![istarget hppa*-*-*] &&
![istarget cr16*-*-*] &&
![istarget crx*-*-*] &&
![istarget *c30*-*-*] &&
![istarget *c4x*-*-*] &&
![istarget *c54x*-*-*] } then {
# the vax fails because VMS can apparently actually handle this
# case in relocs, so gas doesn't handle it itself.
setup_xfail "h8300*-*-elf*" "mn10200*-*-*" "mn10300*-*-*" "vax*-*-vms*"
do_930509a
}
 
# ".struct" and ".align" have different meanings on c54x
# These directives are done in the c54x-specific tests instead
case $target_triplet in {
{ hppa*-*-* } { }
{ *c4x*-*-* } { }
{ *c54x*-*-* } { }
default {
run_dump_test struct
run_dump_test align
run_dump_test align2
}
}
 
# '<' and '>' appear to have special meanings on the excluded targets
case $target_triplet in {
{ frv-*-* } { }
{ hppa*-*-* } { }
{ m32r-*-* } { }
{ mmix-*-* } { }
{ *c4x*-*-* } { }
{ *c54x*-*-* } { }
{ bfin-*-* } { }
default {
run_dump_test altmacro
# The second test is valid only when '!' is not a comment
# character (it is allowed to be a line comment character).
if [string match "" [lindex [gas_run excl.s "-o /dev/null" ""] 0]] {
run_dump_test altmac2
# Similarly this test does not work when ! is a line seperator.
run_dump_test eval
}
}
}
 
# This test is for any COFF target.
# We omit the ARM toolchains because they define locals to
# start with '.', which eliminates .eos, .text etc from the output.
# Omit c54x, since .tag and .def mean something different on that target
if { ([istarget *-*-coff*] && ![istarget *arm*-*-coff] && ![istarget thumb*-*-coff] && ![istarget xscale-*-coff] && ![istarget *c4x*-*-coff] && ![istarget *c54x*-*-coff]) \
||([istarget *-*-pe*] && ![istarget arm*-*-pe*] && ![istarget thumb*-*-pe*]) \
|| [istarget i*86-*-aix*] \
|| [istarget i*86-*-sco*] \
|| [istarget i*86-*-isc*] \
|| [istarget i*86-*-go32*] \
|| [istarget i*86-*-cygwin*] \
|| [istarget x86_64-*-mingw*] \
|| [istarget i*86-*-*nt] \
|| [istarget i*86-*-interix*] \
|| ([istarget i960-*-vxworks5.*] && ![istarget i960-*-vxworks5.0*]) } {
run_dump_test cofftag
}
 
# Test omitting conditionals from listings.
proc test_cond {} {
global comp_output
global srcdir
global subdir
 
set testname "conditional listings"
gas_run cond.s "-alc" ">dump.out"
if ![string match "" $comp_output] {
send_log "$comp_output\n"
fail $testname
} else {
if { [regexp_diff dump.out $srcdir/$subdir/cond.l] } {
fail $testname
} else {
pass $testname
}
}
}
 
# This test is not suitable for the PA for various reasons
# not limited to the fact that it depends on specific section
# names appearing in the output file.
# again, p2align doesn't work on c54x target
case $target_triplet in {
{ hppa*-*-* } { }
{ *c4x*-*-* } { }
{ *c54x*-*-* } { }
default {
test_cond
remote_download host "$srcdir/$subdir/incbin.dat"
run_dump_test incbin
}
}
 
if { ([istarget "i*86-*-*pe*"] && ![istarget "i*86-*-openbsd*"]) \
|| [istarget "i*86-*-cygwin*"] \
|| [istarget "i*86-*-mingw32*"] } {
gas_test "fastcall.s" "" "" "fastcall labels"
}
 
run_dump_test assign
run_dump_test sleb128
 
# .byte is 32 bits on tic4x, and .p2align isn't supported on tic54x
# .space is different on hppa*-hpux.
if { ![istarget "tic4x*-*-*"] && ![istarget "tic54x*-*-*"] && ![istarget "hppa*-*-hpux*"] } {
run_dump_test relax
}
 
# .quad is 16 bytes on i960.
if { ![istarget "i960-*-*"] } {
run_dump_test quad
}
 
 
# .set works differently on some targets.
case $target_triplet in {
{ alpha*-*-* } { }
{ mips*-*-* } { }
{ *c54x*-*-* } { }
{ z80-*-* } { }
default {
run_dump_test weakref1
run_dump_test weakref1g
run_dump_test weakref1l
run_dump_test weakref1u
run_dump_test weakref1w
}
}
gas_test_error "weakref2.s" "" "e: would close weakref loop: e => a => b => c => d => e"
gas_test_error "weakref3.s" "" "a: would close weakref loop: a => b => c => d => e => a"
gas_test_error "weakref4.s" "" "is already defined"
 
run_dump_test string
 
load_lib gas-dg.exp
dg-init
dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/err-*.s $srcdir/$subdir/warn-*.s]] "" ""
dg-finish
/test-gen.c
0,0 → 1,744
#ifndef TEST_GEN_C
#define TEST_GEN_C 1
 
/* Copyright (C) 2000, 2003, 2007 Free Software Foundation
Contributed by Alexandre Oliva <aoliva@cygnus.com>
 
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. */
 
/* This is a source file with infra-structure to test generators for
assemblers and disassemblers.
 
The strategy to generate testcases is as follows. We'll output to
two streams: one will get the assembly source, and the other will
get regexps that match the expected binary patterns.
 
To generate each instruction, the functions of a func[] are called,
each with the corresponding func_arg. Each function should set
members of insn_data, to decide what it's going to output to the
assembly source, the corresponding output for the disassembler
tester, and the bits to be set in the instruction word. The
strings to be output must have been allocated with strdup() or
malloc(), so that they can be freed. A function may also modify
insn_size. More details in test-gen.c
 
Because this would have generated too many tests, we have chosen to
define ``random'' sequences of numbers/registers, and simply
generate each instruction a couple of times, which should get us
enough coverage.
 
In general, test generators should be compiled/run as follows:
% gcc test.c -o test
% ./test > test.s 2 > test.d
 
Please note that this file contains a couple of GCC-isms, such as
macro varargs (also available in C99, but with a difference syntax)
and labeled elements in initializers (so that insn definitions are
simpler and safer).
 
It is assumed that the test generator #includes this file after
defining any of the preprocessor macros documented below. The test
generator is supposed to define instructions, at least one group of
instructions, optionally, a sequence of groups.
 
It should also define a main() function that outputs the initial
lines of the assembler input and of the test control file, that
also contains the disassembler output. The main() funcion may
optionally set skip_list too, before calling output_groups() or
output_insns(). */
 
/* Define to 1 to avoid repeating instructions and to use a simpler
register/constant generation mechanism. This makes it much easier
to verify that the generated bit patterns are correct. */
#ifndef SIMPLIFY_OUTPUT
#define SIMPLIFY_OUTPUT 0
#endif
 
/* Define to 0 to avoid generating disassembler tests. */
#ifndef DISASSEMBLER_TEST
#define DISASSEMBLER_TEST 1
#endif
 
/* Define to the number of times to repeat the generation of each
insn. It's best to use prime numbers, to improve randomization. */
#ifndef INSN_REPEAT
#define INSN_REPEAT 5
#endif
 
/* Define in order to get randomization_counter printed, as a comment,
in the disassembler output, after each insn is emitted. */
#ifndef OUTPUT_RANDOMIZATION_COUNTER
#define OUTPUT_RANDOMIZATION_COUNTER 0
#endif
 
/* Other configuration macros are DEFINED_WORD and DEFINED_FUNC_ARG,
see below. */
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
/* It is expected that the main program defines the type `word' before
includeing this. */
#ifndef DEFINED_WORD
typedef unsigned long long word;
#endif
 
/* This struct is used as the output area for each function. It
should store in as_in a pointer to the string to be output to the
assembler; in dis_out, the string to be expected in return from the
disassembler, and in bits the bits of the instruction word that are
enabled by the assembly fragment. */
typedef struct
{
char * as_in;
char * dis_out;
word bits;
} insn_data;
 
#ifndef DEFINED_FUNC_ARG
/* This is the struct that feeds information to each function. You're
free to extend it, by `typedef'ing it before including this file,
and defining DEFINED_FUNC_ARG. You may even reorder the fields,
but do not remove any of the existing fields. */
typedef struct
{
int i1;
int i2;
int i3;
void * p1;
void * p2;
word w;
} func_arg;
#endif
 
/* This is the struct whose arrays define insns. Each func in the
array will be called, in sequence, being given a pointer to the
associated arg and a pointer to a zero-initialized output area,
that it may fill in. */
typedef struct
{
int (* func) (func_arg *, insn_data *);
func_arg arg;
} func;
 
/* Use this to group insns under a name. */
typedef struct
{
const char * name;
func ** insns;
} group_t;
 
/* This is the size of each instruction. Use `insn_size_bits' instead
of `insn_bits' in an insn defition to modify it. */
int insn_size = 4;
 
/* The offset of the next insn, as expected in the disassembler
output. */
int current_offset = 0;
 
/* The offset and name of the last label to be emitted. */
int last_label_offset = 0;
const char * last_label_name = 0;
 
/* This variable may be initialized in main() to `argv+1', if
`argc>1', so that tests are emitted only for instructions that
match exactly one of the given command-line arguments. If it is
NULL, tests for all instructions are emitted. It must be a
NULL-terminated array of pointers to strings (just like
`argv+1'). */
char ** skip_list = 0;
 
/* This is a counter used to walk the various arrays of ``random''
operand generation. In simplified output mode, it is zeroed after
each insn, otherwise it just keeps growing. */
unsigned randomization_counter = 0;
 
/* Use `define_insn' to create an array of funcs to define an insn,
then `insn' to refer to that insn when defining an insn group. */
#define define_insn(insname, funcs...) \
func i_ ## insname[] = { funcs, { 0 } }
#define insn(insname) (i_ ## insname)
 
/* Use these to output a comma followed by an optional space, a single
space, a plus sign, left and right square brackets and parentheses,
all of them properly quoted. */
#define comma literal_q (", ", ", ?")
#define space literal (" ")
#define tab literal ("\t")
#define plus literal_q ("+", "\\+")
#define lsqbkt literal_q ("[", "\\[")
#define rsqbkt literal_q ("]", "\\]")
#define lparen literal_q ("(", "\\(")
#define rparen literal_q (")", "\\)")
 
/* Use this as a placeholder when you define a macro that expects an
argument, but you don't have anything to output there. */
int
nothing (func_arg *arg, insn_data *data)
#define nothing { nothing }
{
return 0;
}
 
/* This is to be used in the argument list of define_insn, causing a
string to be copied into both the assembly and the expected
disassembler output. It is assumed not to modify the binary
encoding of the insn. */
int
literal (func_arg *arg, insn_data *data)
#define literal(s) { literal, { p1: (s) } }
{
data->as_in = data->dis_out = strdup ((char *) arg->p1);
return 0;
}
 
/* The characters `[', `]', `\\' and `^' must be quoted in the
disassembler-output matcher. If a literal string contains any of
these characters, use literal_q instead of literal, and specify the
unquoted version (for as input) as the first argument, and the
quoted version (for expected disassembler output) as the second
one. */
int
literal_q (func_arg *arg, insn_data *data)
#define literal_q(s,q) { literal_q, { p1: (s), p2: (q) } }
{
data->as_in = strdup ((char *) arg->p1);
data->dis_out = strdup ((char *) arg->p2);
return 0;
}
 
/* Given an insn name, check whether it should be skipped or not,
depending on skip_list. Return non-zero if the insn is to be
skipped. */
int
skip_insn (char *name)
{
char **test;
 
if (! skip_list)
return 0;
 
for (test = skip_list; * test; ++ test)
if (strcmp (name, * test) == 0)
return 0;
 
return 1;
}
 
/* Use this to emit the actual insn name, with its opcode, in
architectures with fixed-length instructions. */
int
insn_bits (func_arg *arg, insn_data *data)
#define insn_bits(name,bits) \
{ insn_bits, { p1: # name, w: bits } }
{
if (skip_insn ((char *) arg->p1))
return 1;
data->as_in = data->dis_out = strdup ((char *) arg->p1);
data->bits = arg->w;
return 0;
}
 
/* Use this to emit the insn name and its opcode in architectures
without a variable instruction length. */
int
insn_size_bits (func_arg *arg, insn_data *data)
#define insn_size_bits(name,size,bits) \
{ insn_size_bits, { p1: # name, i1: size, w: bits } }
{
if (skip_insn ((char *) arg->p1))
return 1;
data->as_in = data->dis_out = strdup ((char *) arg->p1);
data->bits = arg->w;
insn_size = arg->i1;
return 0;
}
 
/* Use this to advance the random generator by one, in case it is
generating repetitive patterns. It is usually good to arrange that
each insn consumes a prime number of ``random'' numbers, or, at
least, that it does not consume an exact power of two ``random''
numbers. */
int
tick_random (func_arg *arg, insn_data *data)
#define tick_random { tick_random }
{
++ randomization_counter;
return 0;
}
 
/* Select the next ``random'' number from the array V of size S, and
advance the counter. */
#define get_bits_from_size(V,S) \
((V)[randomization_counter ++ % (S)])
 
/* Utility macros. `_get_bits_var', used in some macros below, assume
the names of the arrays used to define the ``random'' orders start
with `random_order_'. */
#define _get_bits_var(N) (random_order_ ## N)
#define _get_bits_size(V) (sizeof (V) / sizeof * (V))
 
/* Use this within a `func_arg' to select one of the arrays below (or
any other array that starts with random_order_N. */
#define mk_get_bits(N) \
p2: _get_bits_var (N), i3: _get_bits_size (_get_bits_var (N))
 
/* Simplified versions of get_bits_from_size for when you have access
to the array, so that its size can be implicitly calculated. */
#define get_bits_from(V) get_bits_from_size ((V),_get_bits_size ((V)))
#define get_bits(N) get_bits_from (_get_bits_var (N))
 
 
/* Use `2u' to generate 2-bit unsigned values. Good for selecting
registers randomly from a set of 4 registers. */
unsigned random_order_2u[] =
{
/* This sequence was generated by hand so that no digit appers more
than once in any horizontal or vertical line. */
0, 1, 3, 2,
2, 0, 1, 3,
1, 3, 2, 0,
3, 2, 0, 1
};
 
/* Use `3u' to generate 3-bit unsigned values. Good for selecting
registers randomly from a set of 8 registers. */
unsigned random_order_3u[] =
{
/* This sequence was generated by:
f(k) = 3k mod 8
except that the middle pairs were swapped. */
0, 6, 3, 1, 4, 2, 7, 5,
/* This sequence was generated by:
f(k) = 5k mod 8
except that the middle pairs were swapped. */
0, 2, 5, 7, 4, 6, 1, 3,
};
 
/* Use `4u' to generate 4-bit unsigned values. Good for selecting
registers randomly from a set of 16 registers. */
unsigned random_order_4u[] =
{
/* This sequence was generated by:
f(k) = 5k mod 16
except that the middle pairs were swapped. */
0, 5, 15, 10, 9, 4, 14, 3,
8, 13, 7, 2, 1, 12, 6, 11,
/* This sequence was generated by:
f(k) = 7k mod 16
except that the middle pairs were swapped. */
0, 7, 5, 14, 3, 12, 10, 1,
8, 15, 13, 6, 11, 4, 2, 9,
};
 
/* Use `5u' to generate 5-bit unsigned values. Good for selecting
registers randomly from a set of 32 registers. */
unsigned random_order_5u[] =
{
/* This sequence was generated by:
f(k) = (13k) mod 32
except that the middle pairs were swapped. */
0, 26, 13, 7, 20, 14, 1, 27,
8, 2, 21, 15, 28, 22, 9, 3,
16, 10, 29, 23, 4, 30, 17, 11,
24, 18, 5, 31, 12, 6, 25, 19
};
 
/* Use `7s' to generate 7-bit signed values. Good for selecting
``interesting'' constants from -64 to +63. */
int random_order_7s[] =
{
/* Sequence generated by hand, to explore limit values and a few
intermediate values selected by chance. Keep the number of
intermediate values low, to ensure that the limit values are
generated often enough. */
0, -1, -64, 63, -32, 32, 24, -20,
9, -27, -31, 33, 40, -2, -5, 1
};
 
/* Use `8s' to generate 8-bit signed values. Good for selecting
``interesting'' constants from -128 to +127. */
int random_order_8s[] =
{
/* Sequence generated by hand, to explore limit values and a few
intermediate values selected by chance. Keep the number of
intermediate values low, to ensure that the limit values are
generated often enough. */
0, -1, -128, 127, -32, 32, 24, -20,
73, -27, -95, 33, 104, -2, -69, 1
};
 
/* Use `9s' to generate 9-bit signed values. Good for selecting
``interesting'' constants from -256 to +255. */
int random_order_9s[] =
{
/* Sequence generated by hand, to explore limit values and a few
intermediate values selected by chance. Keep the number of
intermediate values low, to ensure that the limit values are
generated often enough. */
0, -1, -256, 255, -64, 64, 72, -40,
73, -137, -158, 37, 104, -240, -69, 1
};
 
/* Use `16s' to generate 16-bit signed values. Good for selecting
``interesting'' constants from -32768 to +32767. */
int random_order_16s[] =
{
/* Sequence generated by hand, to explore limit values and a few
intermediate values selected by chance. Keep the number of
intermediate values low, to ensure that the limit values are
generated often enough. */
-32768,
32767,
(-1 << 15) | (64 << 8) | 32,
(64 << 8) | 32,
0x1234,
(-1 << 15) | 0x8765,
0x0180,
(-1 << 15) | 0x8001
};
 
/* Use `24s' to generate 24-bit signed values. Good for selecting
``interesting'' constants from -2^23 to 2^23-1. */
int random_order_24s[] =
{
/* Sequence generated by hand, to explore limit values and a few
intermediate values selected by chance. Keep the number of
intermediate values low, to ensure that the limit values are
generated often enough. */
-1 << 23,
1 << 23 -1,
(-1 << 23) | (((64 << 8) | 32) << 8) | 16,
(((64 << 8) | 32) << 8) | 16,
0x123456,
(-1 << 23) | 0x876543,
0x01ff80,
(-1 << 23) | 0x80ff01
};
 
/* Use `32s' to generate 32-bit signed values. Good for selecting
``interesting'' constants from -2^31 to 2^31-1. */
int random_order_32s[] =
{
/* Sequence generated by hand, to explore limit values and a few
intermediate values selected by chance. Keep the number of
intermediate values low, to ensure that the limit values are
generated often enough. */
-1 << 31,
1 << 31 - 1,
(-1 << 31) | (((((64 << 8) | 32) << 8) | 16) << 8) | 8,
(((((64 << 8) | 32) << 8) | 16) << 8) | 8,
0x12345678,
(-1 << 31) | 0x87654321,
0x01ffff80,
(-1 << 31) | 0x80ffff01
};
 
/* This function computes the number of digits needed to represent a
given number. */
unsigned long
ulen (unsigned long i, unsigned base)
{
int count = 0;
 
if (i == 0)
return 1;
for (; i > 0; ++ count)
i /= base;
return count;
}
 
/* Use this to generate a signed constant of the given size, shifted
by the given amount, with the specified endianness. */
int
signed_constant (func_arg * arg, insn_data * data)
#define signed_constant(bits, shift, revert) \
{ signed_constant, { i1: shift, i2: bits * (revert ? -1 : 1), \
mk_get_bits (bits ## s) } }
{
long val = get_bits_from_size ((unsigned *) arg->p2, arg->i3);
int len = (val >= 0 ? ulen (val, 10) : (1 + ulen (-val, 10)));
int nbits = (arg->i2 >= 0 ? arg->i2 : -arg->i2);
word bits = ((word) val) & (((((word) 1) << (nbits - 1)) << 1) - 1);
 
data->as_in = data->dis_out = malloc (len + 1);
sprintf (data->as_in, "%ld", val);
if (arg->i2 < 0)
{
word rbits = 0;
 
do
{
rbits <<= 8;
rbits |= bits & 0xff;
bits >>= 8;
nbits -= 8;
}
while (nbits > 0);
 
bits = rbits;
}
data->bits = bits << arg->i1;
 
return 0;
}
 
/* Use this to generate a unsigned constant of the given size, shifted
by the given amount, with the specified endianness. */
int
unsigned_constant (func_arg * arg, insn_data * data)
#define unsigned_constant(bits, shift, revert) \
{ unsigned_constant, { i1: shift, i2: bits * (revert ? -1 : 1), \
mk_get_bits (bits ## s) } }
{
int nbits = (arg->i2 >= 0 ? arg->i2 : -arg->i2);
unsigned long val =
get_bits_from_size ((unsigned *) arg->p2, arg->i3)
& (((((word) 1) << (nbits - 1)) << 1) - 1);
int len = ulen (val, 10);
word bits = val;
 
data->as_in = data->dis_out = malloc (len + 1);
sprintf (data->as_in, "%lu", val);
if (arg->i2 < 0)
{
word rbits = 0;
 
do
{
rbits <<= 8;
rbits |= bits & 0xff;
bits >>= 8;
nbits -= 8;
}
while (nbits > 0);
 
bits = rbits;
}
data->bits = bits << arg->i1;
 
return 0;
}
 
/* Use this to generate an absolute address of the given size, shifted
by the given amount, with the specified endianness. */
int
absolute_address (func_arg *arg, insn_data *data)
#define absolute_address (bits, shift, revert) \
{ absolute_address, { i1: shift, i2: bits * (revert ? -1 : 1), \
mk_get_bits (bits ## s) } }
{
int nbits = (arg->i2 >= 0 ? arg->i2 : -arg->i2);
unsigned long val =
get_bits_from_size ((unsigned *) arg->p2, arg->i3)
& (((((word) 1) << (nbits - 1)) << 1) - 1);
word bits = val;
 
data->as_in = malloc (ulen (val, 10) + 1);
sprintf (data->as_in, "%lu", val);
data->dis_out = malloc (nbits / 4 + 11);
sprintf (data->dis_out, "0*%0*lx <[^>]*>", nbits / 4, val);
if (arg->i2 < 0)
{
word rbits = 0;
 
do
{
rbits <<= 8;
rbits |= bits & 0xff;
bits >>= 8;
nbits -= 8;
}
while (nbits > 0);
 
bits = rbits;
}
data->bits = bits << arg->i1;
 
return 0;
}
 
/* Use this to generate a register name that starts with a given
prefix, and is followed by a number generated by `gen' (see
mk_get_bits below). The register number is shifted `shift' bits
left before being stored in the binary insn. */
int
reg_p (func_arg *arg, insn_data *data)
#define reg_p(prefix,shift,gen) \
{ reg_p, { i1: (shift), p1: (prefix), gen } }
{
unsigned reg = get_bits_from_size ((unsigned *) arg->p2, arg->i3);
char *regname = (char *) arg->p1;
 
data->as_in = data->dis_out = malloc (strlen (regname) + ulen (reg, 10) + 1);
sprintf (data->as_in, "%s%u", regname, reg);
data->bits = reg;
data->bits <<= arg->i1;
return 0;
}
 
/* Use this to generate a register name taken from an array. The
index into the array `names' is to be produced by `gen', but `mask'
may be used to filter out some of the bits before choosing the
disassembler output and the bits for the binary insn, shifted left
by `shift'. For example, if registers have canonical names, but
can also be referred to by aliases, the array can be n times larger
than the actual number of registers, and the mask is then used to
pick the canonical name for the disassembler output, and to
eliminate the extra bits from the binary output. */
int
reg_r (func_arg *arg, insn_data *data)
#define reg_r(names,shift,mask,gen) \
{ reg_r, { i1: (shift), i2: (mask), p1: (names), gen } }
{
unsigned reg = get_bits_from_size ((unsigned *) arg->p2, arg->i3);
data->as_in = strdup (((const char **) arg->p1)[reg]);
reg &= arg->i2;
data->dis_out = strdup (((const char **) arg->p1)[reg]);
data->bits = reg;
data->bits <<= arg->i1;
return 0;
}
 
/* Given a NULL-terminated array of insns-definitions (pointers to
arrays of funcs), output test code for the insns to as_in (assembly
input) and dis_out (expected disassembler output). */
void
output_insns (func **insn, FILE *as_in, FILE *dis_out)
{
for (; *insn; ++insn)
{
insn_data *data;
func *parts = *insn;
int part_count = 0, r;
 
/* Figure out how many funcs have to be called. */
while (parts[part_count].func)
++part_count;
 
/* Allocate storage for the output area of each func. */
data = (insn_data*) malloc (part_count * sizeof (insn_data));
 
#if SIMPLIFY_OUTPUT
randomization_counter = 0;
#else
/* Repeat each insn several times. */
for (r = 0; r < INSN_REPEAT; ++r)
#endif
{
unsigned saved_rc = randomization_counter;
int part;
word bits = 0;
 
for (part = 0; part < part_count; ++part)
{
/* Zero-initialize the storage. */
data[part].as_in = data[part].dis_out = 0;
data[part].bits = 0;
/* If a func returns non-zero, skip this line. */
if (parts[part].func (&parts[part].arg, &data[part]))
goto skip;
/* Otherwise, get its output bit pattern into the total
bit pattern. */
bits |= data[part].bits;
}
if (as_in)
{
/* Output the whole assembly line. */
fputc ('\t', as_in);
for (part = 0; part < part_count; ++part)
if (data[part].as_in)
fputs (data[part].as_in, as_in);
fputc ('\n', as_in);
}
 
if (dis_out)
{
/* Output the disassembler expected output line,
starting with the offset and the insn binary pattern,
just like objdump outputs. Because objdump sometimes
inserts spaces between each byte in the insn binary
pattern, make the space optional. */
fprintf (dis_out, "0*%x <", current_offset);
if (last_label_name)
if (current_offset == last_label_offset)
fputs (last_label_name, dis_out);
else
fprintf (dis_out, "%s\\+0x%x", last_label_name,
current_offset - last_label_offset);
else
fputs ("[^>]*", dis_out);
fputs ("> ", dis_out);
for (part = insn_size; part-- > 0; )
fprintf (dis_out, "%02x ?", (int)(bits >> (part * 8)) & 0xff);
fputs (" *\t", dis_out);
#if DISASSEMBLER_TEST
for (part = 0; part < part_count; ++part)
if (data[part].dis_out)
fputs (data[part].dis_out, dis_out);
#else
/* If we're not testing the DISASSEMBLER, just match
anything. */
fputs (".*", dis_out);
#endif
fputc ('\n', dis_out);
#if OUTPUT_RANDOMIZATION_COUNTER
fprintf (dis_out, "# %i\n", randomization_counter);
#endif
}
 
/* Account for the insn_size bytes we've just output. */
current_offset += insn_size;
 
/* Release the memory that each func may have allocated. */
for (; part-- > 0;)
{
skip:
if (data[part].as_in)
free (data[part].as_in);
if (data[part].dis_out
&& data[part].dis_out != data[part].as_in)
free (data[part].dis_out);
}
 
/* There's nothing random here, don't repeat this insn. */
if (randomization_counter == saved_rc)
break;
}
 
free (data);
}
}
 
/* For each group, output an asm label and the insns of the group. */
void
output_groups (group_t group[], FILE *as_in, FILE *dis_out)
{
for (; group->name; ++group)
{
fprintf (as_in, "%s:\n", group->name);
fprintf (dis_out, "# %s:\n", group->name);
last_label_offset = current_offset;
last_label_name = group->name;
output_insns (group->insns, as_in, dis_out);
}
}
 
#endif
/incbin.dat
0,0 → 1,744
88888888 122333 SOMEMOREDATADATA
/redef3.s
0,0 → 1,12
.data
here:
.set sym, here
.long sym
.set sym, 0x11111111
.long sym
.set sym, xtrn
.long sym
.set sym, 0x22222222
.long sym
.comm sym, 1
.long sym
/redef5.s
0,0 → 1,2
.comm sym, 1
.set sym, 0
/weakref1u.d
0,0 → 1,49
#nm: --undefined-only
#name: weakref tests, strong undefined syms
#source: weakref1.s
# aout turns undefined into *ABS* symbols.
# see weakref1.d for comments on the other not-targets
#not-target: *-*-*aout ns32k-*-netbsd alpha*-*-osf* *-*-ecoff
 
# the rest of this file is generated with the following script:
# # script begin
# sed -n 's:^[ ]*\.weakref .*, \(u.*\)$:.* U \1:p' weakref1.s | uniq | while read line; do echo "#..."; echo "$line"; done
# echo \#pass
# # script output:
#...
.* U ua2
#...
.* U ua3
#...
.* U ua4
#...
.* U ub2
#...
.* U ub3
#...
.* U ub4
#...
.* U uc2
#...
.* U uc3
#...
.* U uc4
#...
.* U uc5
#...
.* U uc6
#...
.* U uc7
#...
.* U uc8
#...
.* U uc9
#...
.* U ud5
#...
.* U uh8
#...
.* U uh9
#...
.* U um5
#pass
/cond.l
0,0 → 1,71
# This should match the output of gas -alc cond.s.
 
.*cond.s.*
 
 
1[ ]+.if 0
8[ ]+.else
9[ ]+.if 1
10[ ]+.endc
11 0000 0[02] ?00 ?00 ?0[02][ ]+.long[ ]+2
12[ ]+.if 0
14[ ]+.else
15 0004 0[04] ?00 ?00 ?0[04][ ]+.long[ ]+4
16[ ]+.endc
17[ ]+.endc
18[ ]+
19[ ]+.if 0
21[ ]+.elseif 1
22[ ]+.if 0
24[ ]+.elseif 1
25 0008 0[07] ?00 ?00 ?0[07][ ]+.long[ ]+7
26[ ]+.endif
27[ ]+.elseif 1
29[ ]+.else
31[ ]+.endif
[ ]*[1-9][0-9]*[ ]+
[ ]*[1-9][0-9]*[ ]+\.comm[ ]+c,[ ]*1[ ]*
[ ]*[1-9][0-9]*[ ]+\.ifndef[ ]+c[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+x[ ]*<>[ ]*x[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]+\.equiv[ ]+y,[ ]*x[ ]*
[ ]*[1-9][0-9]*[ ]+\.ifndef[ ]+y[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+x[ ]*<>[ ]*y[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]+\.equiv[ ]+z,[ ]*x[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+y[ ]*<>[ ]*z[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]*
[ ]*[1-9][0-9]*[ ]+\.equiv[ ]+a,[ ]*y[ ]*\+[ ]*1[ ]*
[ ]*[1-9][0-9]*[ ]+\.equiv[ ]+b,[ ]*z[ ]*-[ ]*1[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+a[ ]*==[ ]*x[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+a[ ]*-[ ]*1[ ]*<>[ ]*x[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+a[ ]*<>[ ]*b[ ]*\+[ ]*2[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+a[ ]*-[ ]*b[ ]*<>[ ]*2[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]*
[ ]*[1-9][0-9]*[ ]+\.equiv[ ]+x,[ ]*0[ ]*
[ ]*[1-9][0-9]*[ ]+\.if[ ]+y[ ]*
[ ]*[1-9][0-9]*[ ]+\.elseif[ ]+y[ ]*
[ ]*[1-9][0-9]*[ ]+\.endif[ ]*
[ ]*[1-9][0-9]*[ ]+
[ ]*[1-9][0-9]*[ ]+\.macro[ ]+m[ ]+x,[ ]*y[ ]*
#...
[ ]*[1-9][0-9]*[ ]+\.endm[ ]*
[ ]*[1-9][0-9]*[ ]+[0-9a-f]+[048c] FF ?FF ?FF ?FF[ ]+m[ ]+,[ ]*
[ ]*[1-9][0-9]*[ ]+FF ?FF ?FF ?FF[ ]*
[ ]*[1-9][0-9]*[ ]+[0-9a-f]+[048c] FF ?FF ?FF ?FF[ ]+m[ ]+,[ ]*10[ ]*
[ ]*[1-9][0-9]*[ ]+0[0A] ?00 ?00 ?0[0A][ ]*
[ ]*[1-9][0-9]*[ ]+[0-9a-f]+[048c] 0[0B] ?00 ?00 ?0[0B][ ]+m[ ]+11,[ ]*
[ ]*[1-9][0-9]*[ ]+FF ?FF ?FF ?FF[ ]*
[ ]*[1-9][0-9]*[ ]+[0-9a-f]+[048c] 0[0C] ?00 ?00 ?0[0C][ ]+m[ ]+12,[ ]*13[ ]*
[ ]*[1-9][0-9]*[ ]+0[0D] ?00 ?00 ?0[0D][ ]*
[ ]*[1-9][0-9]*[ ]+
[ ]*[1-9][0-9]*[ ]+.*\.p2align 5,0
#pass
/weakref1w.d
0,0 → 1,56
#nm: --undefined-only
#name: weakref tests, weak undefined syms
#source: weakref1.s
# see weakref1.d for comments on the not-targets
#not-target: alpha*-*-osf* *-*-ecoff pdp11-*-aout
 
# the rest of this file is generated with the following script:
# # script begin
# sed -n 's:^[ ]*\.weakref .*, \(w.*\)$:.* w \1:p' weakref1.s | uniq | while read line; do echo "#..."; echo "$line"; done
# echo \#pass
# # script output:
#...
.* w wa1
#...
.* w wb1
#...
.* w wc1
#...
.* w wh2
#...
.* w wh3
#...
.* w wh4
#...
.* w wh5
#...
.* w wh6
#...
.* w wh7
#...
.* w wm6
#...
.* w wm7
#...
.* w wm8
#...
.* w ww1
#...
.* w ww10
#...
.* w ww2
#...
.* w ww3
#...
.* w ww4
#...
.* w ww5
#...
.* w ww6
#...
.* w ww7
#...
.* w ww8
#...
.* w ww9
#pass
/equ-bad.s
0,0 → 1,2
.equ x, 1
.eqv x, 2
/altmacro.d
0,0 → 1,11
#as: --alternate
#objdump: -s -j .data
#name: alternate macro syntax
 
# Test the alternate macro syntax.
 
.*: .*
 
Contents of section .data:
0000 01020912 61626331 32332121 3c3e2721 .*
0010 3c3e27.*
/cond.s
0,0 → 1,92
.if 0
.if 1
.endc
.long 0
.if 0
.long 1
.endc
.else
.if 1
.endc
.long 2
.if 0
.long 3
.else
.long 4
.endc
.endc
 
.if 0
.long 5
.elseif 1
.if 0
.long 6
.elseif 1
.long 7
.endif
.elseif 1
.long 8
.else
.long 9
.endif
 
.comm c, 1
.ifndef c
.err
.endif
 
.if x <> x
.err
.endif
.equiv y, x
.ifndef y
.err
.endif
.if x <> y
.err
.endif
.equiv z, x
.if y <> z
.err
.endif
 
.equiv a, y + 1
.equiv b, z - 1
.if a == x
.err
.endif
.if a - 1 <> x
.err
.endif
.if a <> b + 2
.err
.endif
.if a - b <> 2
.err
.endif
 
.equiv x, 0
.if y
.err
.elseif y
.err
.endif
 
.macro m x, y
.ifb \x
.long -1
.else
.long \x
.endif
.ifnb \y
.long \y
.else
.long -1
.endif
.endm
m ,
m , 10
m 11,
m 12, 13
 
.p2align 5,0
/weakref1.d
0,0 → 1,96
#objdump: -r
#name: weakref tests, relocations
# ecoff (OSF/alpha) lacks .weak support
# pdp11 lacks .long
# the following must be present in all weakref1*.d
#not-target: alpha*-*-osf* *-*-ecoff pdp11-*-aout
 
#...
RELOCATION RECORDS FOR \[(\.text|\$CODE\$)\]:
OFFSET +TYPE +VALUE *
# the rest of this file is generated with the following script:
# # script begin
# echo \#...
# sed -n 's:^[ ]*\.long \(W\|\)\(.*[^a-z]\)[a-z]*\(\| - .*\)$:\2:p' weakref1.s | sed -e 's,^[lg].*,(&|\\.text)(\\+0x[0-9a-f]+)?,' | sed 's,^,[0-9a-f]+ [^ ]* +,'
# # script output:
#...
[0-9a-f]+ [^ ]* +wa1
[0-9a-f]+ [^ ]* +ua2
[0-9a-f]+ [^ ]* +ua3
[0-9a-f]+ [^ ]* +ua3
[0-9a-f]+ [^ ]* +ua4
[0-9a-f]+ [^ ]* +ua4
[0-9a-f]+ [^ ]* +wb1
[0-9a-f]+ [^ ]* +ub2
[0-9a-f]+ [^ ]* +ub3
[0-9a-f]+ [^ ]* +ub3
[0-9a-f]+ [^ ]* +ub4
[0-9a-f]+ [^ ]* +ub4
[0-9a-f]+ [^ ]* +wc1
[0-9a-f]+ [^ ]* +wc1
[0-9a-f]+ [^ ]* +uc2
[0-9a-f]+ [^ ]* +uc2
[0-9a-f]+ [^ ]* +uc3
[0-9a-f]+ [^ ]* +uc3
[0-9a-f]+ [^ ]* +uc3
[0-9a-f]+ [^ ]* +uc3
[0-9a-f]+ [^ ]* +uc4
[0-9a-f]+ [^ ]* +uc4
[0-9a-f]+ [^ ]* +uc4
[0-9a-f]+ [^ ]* +uc4
[0-9a-f]+ [^ ]* +uc5
[0-9a-f]+ [^ ]* +uc5
[0-9a-f]+ [^ ]* +uc5
[0-9a-f]+ [^ ]* +uc5
[0-9a-f]+ [^ ]* +uc6
[0-9a-f]+ [^ ]* +uc6
[0-9a-f]+ [^ ]* +uc6
[0-9a-f]+ [^ ]* +uc6
[0-9a-f]+ [^ ]* +uc7
[0-9a-f]+ [^ ]* +uc7
[0-9a-f]+ [^ ]* +uc8
[0-9a-f]+ [^ ]* +uc8
[0-9a-f]+ [^ ]* +uc9
[0-9a-f]+ [^ ]* +uc9
[0-9a-f]+ [^ ]* +uc9
[0-9a-f]+ [^ ]* +ww1
[0-9a-f]+ [^ ]* +ww2
[0-9a-f]+ [^ ]* +ww3
[0-9a-f]+ [^ ]* +ww3
[0-9a-f]+ [^ ]* +ww4
[0-9a-f]+ [^ ]* +ww4
[0-9a-f]+ [^ ]* +ww5
[0-9a-f]+ [^ ]* +ww5
[0-9a-f]+ [^ ]* +ww6
[0-9a-f]+ [^ ]* +ww7
[0-9a-f]+ [^ ]* +ww8
[0-9a-f]+ [^ ]* +ww8
[0-9a-f]+ [^ ]* +ww9
[0-9a-f]+ [^ ]* +ww9
[0-9a-f]+ [^ ]* +ww10
[0-9a-f]+ [^ ]* +ww10
[0-9a-f]+ [^ ]* +um5
[0-9a-f]+ [^ ]* +wm6
[0-9a-f]+ [^ ]* +wm7
[0-9a-f]+ [^ ]* +wm8
[0-9a-f]+ [^ ]* +wh2
[0-9a-f]+ [^ ]* +wh3
[0-9a-f]+ [^ ]* +wh4
[0-9a-f]+ [^ ]* +wh5
[0-9a-f]+ [^ ]* +wh6
[0-9a-f]+ [^ ]* +wh7
[0-9a-f]+ [^ ]* +uh8
[0-9a-f]+ [^ ]* +uh8
[0-9a-f]+ [^ ]* +uh9
[0-9a-f]+ [^ ]* +uh9
[0-9a-f]+ [^ ]* +(ld1|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(ld2|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(ld3|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(ld4|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +ud5
[0-9a-f]+ [^ ]* +(gd6|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(gd7|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(ld8|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(ld8|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(ld9|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
[0-9a-f]+ [^ ]* +(ld9|\.text|\$CODE\$)(\+0x[0-9a-f]+)?
/err-1.s
0,0 → 1,7
;# Test .error directive.
;# { dg-do assemble }
.error "an error message" ;# { dg-error "Error: an error message" }
.error an error message ;# { dg-error "Error: .error argument must be a string" }
.error ;# { dg-error "Error: .error directive invoked in source file" }
.error ".error directive invoked in source file" ;# { dg-error "Error: .error directive invoked in source file" }
.error "" ;# { dg-error "Error: " }
/cofftag.d
0,0 → 1,25
#objdump: -t
#name: cofftag
 
.*: file format .*
 
SYMBOL TABLE:
\[ 0\]\(sec -2\)\(fl 0x00\)\(ty 0\)\(scl 103\) \(nx 1\) 0x0+0000 foo.c
File
\[ 2\]\(sec 1\)\(fl 0x00\)\(ty 0\)\(scl 6\) \(nx 0\) 0x0+0000 gcc2_compiled.
\[ 3\]\(sec 1\)\(fl 0x00\)\(ty 0\)\(scl 6\) \(nx 0\) 0x0+0000 ___gnu_compiled_c
\[ 4\]\(sec -2\)\(fl 0x00\)\(ty a\)\(scl 15\) \(nx 1\) 0x0+0000 _token
AUX lnno 0 size 0x4 tagndx 0 endndx 10
\[ 6\]\(sec -(1|2)\)\(fl 0x00\)\(ty b\)\(scl 16\) \(nx 0\) 0x0+0000 _operator
\[ 7\]\(sec -(1|2)\)\(fl 0x00\)\(ty b\)\(scl 16\) \(nx 0\) 0x0+0001 _flags
\[ 8\]\(sec -(1|2)\)\(fl 0x00\)\(ty 0\)\(scl 102\) \(nx 1\) 0x0+0004 .eos
AUX lnno 0 size 0x4 tagndx 4
\[ 10\]\(sec 1\)\(fl 0x00\)\(ty 0\)\(scl 3\) \(nx 1\) 0x[0-9a-f]+ .text
AUX scnlen 0x[0-9a-f]+ nreloc 0 nlnno 0
\[ 12\]\(sec 2\)\(fl 0x00\)\(ty 0\)\(scl 3\) \(nx 1\) 0x[0-9a-f]+ .data
AUX scnlen 0x[0-9a-f]+ nreloc 0 nlnno 0
\[ 14\]\(sec 3\)\(fl 0x00\)\(ty 0\)\(scl 3\) \(nx 1\) 0x[0-9a-f]+ .bss
AUX scnlen 0x[0-9a-f]+ nreloc 0 nlnno 0
\[ 16\]\(sec 2\)\(fl 0x00\)\(ty 2\)\(scl 2\) \(nx 0\) 0x0+0000 _token
\[ 17\]\(sec 2\)\(fl 0x00\)\(ty a\)\(scl 2\) \(nx 1\) 0x[0-9a-f]+ _what
AUX lnno 0 size 0x4 tagndx 4
/altmacro.s
0,0 → 1,35
.macro m1 v1, v2
LOCAL l1, l2
label&v1:
l1: .byte v1
label&v2:
l2: .byte v2
.endm
 
.macro m2 v1, v2
m1 %(v1), %(v2-v1)
.endm
 
.macro m3 str
.ascii &str
.endm
 
.data
 
m2 1, 3
m2 9, 27
 
m3 "abc"
m3 <"1", "23">
 
.noaltmacro
 
.macro m4 str
.ascii "&str"
.endm
 
m4 "!!<>'"
 
.altmacro
 
m3 "!!<>'"
/altmac2.d
0,0 → 1,10
#as: --alternate
#objdump: -s -j .data
#name: alternate macro syntax (escape)
 
# Test the alternate macro syntax.
 
.*: .*
 
Contents of section .data:
0000 3e3c21.*
/weakref1.s
0,0 → 1,232
.text
l:
/* a# test references after weakref. */
.weakref Wwa1, wa1
.long Wwa1
 
.weakref Wua2, ua2
.long ua2
 
.weakref Wua3, ua3
.long Wua3
.long ua3
 
.weakref Wua4, ua4
.long ua4
.long Wua4
 
.weakref Wna5, na5
 
/* b# test references before weakref. */
.long Wwb1
.weakref Wwb1, wb1
 
.long ub2
.weakref Wub2, ub2
 
.long Wub3
.long ub3
.weakref Wub3, ub3
 
.long ub4
.long Wub4
.weakref Wub4, ub4
 
/* c# test combinations of references before and after weakref. */
.long Wwc1
.weakref Wwc1, wc1
.long Wwc1
 
.long uc2
.weakref Wuc2, uc2
.long uc2
 
.long Wuc3
.long uc3
.weakref Wuc3, uc3
.long Wuc3
.long uc3
 
.long uc4
.long Wuc4
.weakref Wuc4, uc4
.long uc4
.long Wuc4
 
.long Wuc5
.long uc5
.weakref Wuc5, uc5
.long uc5
.long Wuc5
 
.long uc6
.long Wuc6
.weakref Wuc6, uc6
.long uc6
.long Wuc6
 
.long uc7
.weakref Wuc7, uc7
.long Wuc7
 
.long Wuc8
.weakref Wuc8, uc8
.long uc8
 
.long Wuc9
.weakref Wuc9, uc9
.long Wuc9
.long uc9
 
/* w# test that explicitly weak target don't lose the weak status */
.weakref Www1, ww1
.weak ww1
.long ww1
 
.weak ww2
.weakref Www2, ww2
.long ww2
 
.weak ww3
.long ww3
.weakref Www3, ww3
.long ww3
 
.long ww4
.weakref Www4, ww4
.weak ww4
.long ww4
 
.long ww5
.weakref Www5, ww5
.long ww5
.weak ww5
 
.weakref Www6, ww6
.weak ww6
.long Www6
 
.weak ww7
.weakref Www7, ww7
.long Www7
 
.weak ww8
.long Www8
.weakref Www8, ww8
.long Www8
 
.long Www9
.weakref Www9, ww9
.weak ww9
.long Www9
 
.long Www10
.weakref Www10, ww10
.long Www10
.weak ww10
 
/* m# test multiple weakrefs */
.weakref Wnm4a, nm4
.weakref Wnm4b, nm4
 
.weakref Wum5a, um5
.weakref Wum5b, um5
.long um5
 
.weakref Wwm6a, wm6
.weakref Wwm6b, wm6
.long Wwm6a
 
.weakref Wwm7a, wm7
.weakref Wwm7b, wm7
.long Wwm7b
 
.weakref Wwm8a, wm8
.long Wwm8b
.weakref Wwm8b, wm8
 
/* h# test weakref chain */
.weakref Wnh1a, nh1
.weakref Wnh1b, Wnh1a
.weakref Wnh1c, Wnh1b
 
.weakref Wwh2a, wh2
.weakref Wwh2b, Wwh2a
.long Wwh2b
 
.weakref Wwh3a, wh3
.weakref Wwh3b, Wwh3a
.long Wwh3a
 
.weakref Wwh4b, Wwh4a
.weakref Wwh4a, wh4
.long Wwh4b
 
.long Wwh5b
.weakref Wwh5a, wh5
.weakref Wwh5b, Wwh5a
 
.long Wwh6b
.weakref Wwh6b, Wwh6a
.weakref Wwh6a, wh6
 
.weakref Wwh7b, Wwh7a
.long Wwh7b
.weakref Wwh7a, wh7
 
.long Wuh8c
.weakref Wuh8a, uh8
.weakref Wuh8b, Wuh8a
.weakref Wuh8c, Wuh8b
.long uh8
 
.long Wuh9c
.weakref Wuh9c, Wuh9b
.weakref Wuh9b, Wuh9a
.weakref Wuh9a, uh9
.long uh9
 
/* d# target symbol definitions */
.weakref Wld1, ld1
.long Wld1
ld1 = l
 
.weakref Wld2, ld2
.long Wld2
ld2:
 
ld3:
.weakref Wld3, ld3
.long Wld3
 
ld4:
.long Wld4
.weakref Wld4, ld4
 
.global ud5
.weakref Wud5, ud5
.long Wud5
 
.global gd6
.weakref Wgd6, gd6
.long Wgd6
gd6:
 
.weakref Wgd7, gd7
.long Wgd7
.global gd7
gd7:
 
.long Wld8c
.weakref Wld8a, ld8
.weakref Wld8b, Wld8a
.weakref Wld8c, Wld8b
.long ld8
ld8:
 
.long Wld9c
.weakref Wld9c, Wld9b
.weakref Wld9b, Wld9a
.weakref Wld9a, ld9
.long ld9
ld9:
/warn-1.s
0,0 → 1,7
;# Test .warning directive.
;# { dg-do assemble }
.warning "a warning message" ;# { dg-warning "Warning: a warning message" }
.warning a warning message ;# { dg-error "Error: .warning argument must be a string" }
.warning ;# { dg-warning "Warning: .warning directive invoked in source file" }
.warning ".warning directive invoked in source file" ;# { dg-warning "Warning: .warning directive invoked in source file" }
.warning "" ;# { dg-warning "Warning: " }
/weakref3.s
0,0 → 1,5
.weakref e,a
.weakref d,e
.weakref c,d
.weakref b,c
.weakref a,b
/cofftag.s
0,0 → 1,60
/* This file was compiled from this C source:
char token =0;
enum token {
operator,
flags
};
enum token what= operator;
 
Type numbers have been converted to decimal to make this test pass on
ports having NUMBERS_WITH_SUFFIX.
*/
 
.file "foo.c"
gcc2_compiled.:
___gnu_compiled_c:
.globl _token
.data
_token:
.byte 0
.text
.def _token
.scl 15
.type 10
.size 4
.endef
.def _operator
.val 0
.scl 16
.type 11
.endef
.def _flags
.val 1
.scl 16
.type 11
.endef
.def .eos
.val 4
.scl 102
.tag _token
.size 4
.endef
.globl _what
.data
.p2align 2
_what:
.long 0
.text
.def _token
.val _token
.scl 2
.type 2
.endef
.def _what
.val _what
.scl 2
.tag _token
.size 4
.type 10
.endef
/equiv2.s
0,0 → 1,6
;# Re-definition of an already .equiv-ed symbol (to an expression).
;# The assembler should reject this.
.equiv x, y-z
.equiv y, 1
.equiv z, 1
.equiv x, 1
/align.d
0,0 → 1,12
#objdump: -s -j .text
#name: align
 
# Test the alignment pseudo-op.
 
.*: .*
 
Contents of section .text:
0000 ff00ff01 ff020202 ffff0303 04040404 ................
0010 ffffffff 05050505 ff090a0a 0a0a0a0a ................
0020 ff00ff01 ff020202 ffff0303 04040404 ................
0030 ffffffff 05050505 ff090a0a 0a0a0a0a ................
/p1480.s
0,0 → 1,3
start: .long 0, 1, 2, 3, 4, 5, 6, 7
.space 0x80 - (. - start)
foo: .long 42
/altmac2.s
0,0 → 1,7
.macro m1 str
.ascii "&str"
.endm
 
.data
 
m1 <!>!<!!>
/string.d
0,0 → 1,11
#objdump : -s -j .data -j "\$DATA\$"
#name : .strings tests
 
.*: .*
 
Contents of section (\.data|\$DATA\$):
0000 7374726e 65773800 00000000 00000000 strnew8.*
00.. (73007400 72003100 36000000 00000000|00730074 00720031 00360000 00000000).*
00.. (33000000 32000000 00000000 00000000|00000033 00000032 00000000 00000000).*
00.. (36000000 00000000 34000000 00000000|00000000 00000036 00000000 00000034).*
#pass
/redef2.d
0,0 → 1,15
#objdump: -rs -j .data -j "\$DATA\$"
#name: .equ redefinitions (2)
 
.*: .*
 
RELOCATION RECORDS FOR .*
.*
0+00.*(here|\.data|\$DATA\$)
0+08.*xtrn
0+10.*(sym|(\.data|\$DATA\$)(\+0x0+10)?)
#...
Contents of section (\.data|\$DATA\$):
0000 00000000 11111111 00000000 22222222[ ]+................[ ]*
0010 [01]00000[01]0 .*
#pass
/diff1.s
0,0 → 1,5
# Difference of two undefined symbols.
# The assembler should reject this.
.text
.globl _foo
_foo: .long _a - _b
/itbl
0,0 → 1,20
 
; Test case for assembler option "itbl".
; Run as "as --itbl itbl itbl.s"
; or with stand-alone test case "itbl-test itbl itbl.s".
; The "p<n>" represent processors of a multi-processor system.
 
p1 dreg d1 1 ; data register "d1" for COP1 has value 1
p1 creg c3 3 ; ctrl register "c3" for COP1 has value 3
p3 insn fie 0x1e:24-20 ; function "fill" for COP3 has value 31
p3 dreg d3 3 ; data register "d3" for COP3 has value 3
p3 creg c2 22 ; control register "c2" for COP3 has value 22
p3 insn fee 0x1e:24-20,dreg:17-13,creg:12-8,immed:7-0
 
p3 dreg d3 3 ; data register "d3" for COP3 has value 3
p3 creg c2 22 ; control register "c2" for COP3 has value 22
p3 insn fum 0x01e00001 dreg:17-13 creg:12-8
p3 insn foh 0xf:24-21 dreg:20-16 immed:15-0
 
p3 insn pig 0x1:24-21*[0x100|0x2], dreg:20-16, immed:15-0*0x10000
 
/align.s
0,0 → 1,61
/* Test the alignment pseudo-ops. */
.text
 
.byte 0xff
.p2align 1,0
 
.byte 0xff
.p2align 1,1
 
.byte 0xff
.p2align 2,2
 
.byte 0xff
.byte 0xff
.p2alignw 2,0x0303
 
.p2align 3,4
.byte 0xff
.byte 0xff
.byte 0xff
.byte 0xff
.p2alignl 3,0x05050505
 
.p2align 1,6
.p2align 1,7
 
.byte 0xff
.p2align 3,8,5
.byte 9
.p2align 3,0xa
 
.byte 0xff
.balign 2,0
 
.byte 0xff
.balign 2,1
 
.byte 0xff
.balign 4,2
 
.byte 0xff
.byte 0xff
.balignw 4,0x0303
 
.balign 8,4
.byte 0xff
.byte 0xff
.byte 0xff
.byte 0xff
.balignl 8,0x05050505
 
.balign 2,6
.balign 2,7
 
.byte 0xff
.balign 8,8,5
.byte 9
.balign 8,0xa
 
.p2align 5
.balign 32
/excl.s
0,0 → 1,61
.equ a,!0
/assign-ok.s
0,0 → 1,3
xxx = 1
xxx = 2
yyy == 3
/align2.d
0,0 → 1,9
#objdump: -s -j .text
#name: align2
 
# Test the section alignment.
 
.*: .*
 
Contents of section .text:
0000 ff[ 0-9a-f]*[ ]+.*
/equ-ok.s
0,0 → 1,2
.equ x, 1
.equ x, 2
/sleb128.d
0,0 → 1,57
#objdump : -s -j .data -j "\$DATA\$"
#name : .sleb128 tests
 
.*: .*
 
Contents of section (\.data|\$DATA\$):
#
# 0x76543210 : 000_0111 0110_010 1_0100_00 11_0010_0 001_0000
# 0x80000000 : 000_1000 0000_000 0_0000_00 00_0000_0 000_0000
# 0x87654321 : 000_1000 0111_011 0_0101_01 00_0011_0 010_0001
# 0xffffffff : ..................................... 111_1111
#
0000 90e4d0b2 07808080 8008a186 95bb08ff .*
#
# 0xffffffff : 000_1111 1111_111 1_1111_11 11_1111_1 ........
# -0x76543210 : 111_1000 1001_101 0_1011_11 00_1101_1 111_0000
# -0x80000000 : 111_1000 0000_000 0_0000_00 00_0000_0 000_0000
# -0x87654321 : ........................... 11_1100_1 101_1111
#
00.. ffffff0f f09bafcd 78808080 8078dff9 .*
#
# -0x87654321 : 111_0111 1000_100 1_1010_10 ..................
# -0xffffffff : 111_0000 0000_000 0_0000_00 00_0000_0 000_0001
# 789abcdef : 111_1000 1001_101 0_1011_11 00_1101_1 110_1111
# 0x123456 : ........ 0010_001 1_0100_01 01_0110_0
#
00.. eac47781 80808070 ef9bafcd f8acd191 .*
#
# 0x123456 : 000_0001 ............................
# 789abcdef : 000_0111 0110_010 1_0100_00 11_0010_0 001_0001
# -0x123456 : 111_1110 1101_110 0_1011_10 01_1001_1
# fffffffff : 000_0000 0000_000 0_0000_00 00_0000_0 000_0001
# -0x7ff : ......... 00_0000_0
#
00.. 0191e4d0 b287d3ae ee7e8180 80808080 .*
#
# -0x7ff : 1_1000_00 .........
# 000000000 : 000_0000 0000_000 0_0000_00 00_0000_0 000_0000
# -0x800 : 1_1000_00 00_0000_0
# fffffffff : 000_0000 0000_000 0_0000_00 00_0000_0 000_0001
# -0x7ffffff : .................. 0000_000 0_0000_00 00_0000_0
#
00.. 60808080 80808060 81808080 80808080 .*
#
# -0x7ffffff : 11_1111_1 000_0000 ............................
# 000000000 : 000_0000 0000_000 0_0000_00 00_0000_0 000_0000
# -0x8000000 : 11_1111_1 000_0000 0000_000 0_0000_00 00_0000_0
# -0x100000000 : ........ 0000_000 0_0000_00 00_0000_0 000_0000
#
00.. 807f8080 80808080 8080807f 80808080 .*
#
# -0x100000000 : 111_0000 .....................................
# 000000000 : 000_0000 0000_000 0_0000_00 00_0000_0 000_0000
# -0x1000 : 1_0000_00 00_0000_0
#
00.. 70808080 80808040 00000000 00000000 .*
#pass
/weakref1l.d
0,0 → 1,27
#nm: --defined-only
#name: weakref tests, local syms
#source: weakref1.s
# aix drops local symbols
# see weakref1.d for comments on the other not-targets
#not-target: *-*-aix* alpha*-*-osf* *-*-ecoff pdp11-*-aout
 
# the rest of this file is generated with the following script:
# # script begin
# sed -n 's,^\(l[^ ]*\)[ ]*:.*,.* t \1,p;s:^[ ]*\.set[ ][ ]*\(l[^ ]*\)[ ]*,.*:.* t \1:p' weakref1.s | uniq | while read line; do echo "#..."; echo "$line"; done
# echo \#pass
# # script output:
#...
.* t l
#...
.* t ld1
#...
.* t ld2
#...
.* t ld3
#...
.* t ld4
#...
.* t ld8
#...
.* t ld9
#pass
/float.s
0,0 → 1,4
.text
foo: .single 0r1.2345e+06
.single 0f3.14159
.double 0r2.718282
/redef.d
0,0 → 1,8
#objdump: -s -j .data -j "\$DATA\$"
#name: .equ redefinitions
 
.*: .*
 
Contents of section (\.data|\$DATA\$):
0000 00000000 0[04]00000[04] 0[08]00000[08] 0[0c]00000[0c][ ]+................[ ]*
#pass
/string.s
0,0 → 1,11
.data
.string8 "strnew8"
 
.balign 16
.string16 "str16"
 
.balign 16
.string32 "32"
 
.balign 16
.string64 "64"
/redef2.s
0,0 → 1,12
.data
here:
.set sym, here
.long sym
.set sym, 0x11111111
.long sym
.set sym, xtrn
.long sym
.set sym, 0x22222222
.long sym
sym:
.long sym
/assign-bad.s
0,0 → 1,2
yyy == 3
yyy == 4
/redef4.s
0,0 → 1,3
.data
sym:
.set sym, 0
/align2.s
0,0 → 1,2
.p2align 4,0
.byte 0xff
/p2425.s
0,0 → 1,6
.text
.globl _frobnitz
_frobnitz:
.long 1, 2, 3, 4, 5, 6, 7, GRUMP, 42
GRUMP=.-_frobnitz
HALFGRUMP=GRUMP/2
/eqv-bad.s
0,0 → 1,2
.eqv x, 1
.eqv x, 2
/sleb128.s
0,0 → 1,22
.data
.sleb128 0x76543210
.sleb128 0x80000000
.sleb128 0x87654321
.sleb128 0xffffffff
.sleb128 -0x76543210
.sleb128 -0x80000000
.sleb128 -0x87654321
.sleb128 -0xffffffff
 
.sleb128 0x123456789abcdef
.sleb128 -0x123456789abcdef
 
.sleb128 -0x7fffffffffff
.sleb128 -0x800000000000
.sleb128 -0x7fffffffffffffff
.sleb128 -0x8000000000000000
 
.sleb128 -0x100000000
.sleb128 -0x1000000000000
 
.fill 32
/incbin.d
0,0 → 1,13
#as: -I$srcdir/$subdir
#objdump: -s -j .text
#name: incbin
 
# Test the incbin pseudo-op
 
.*: .*
 
Contents of section .text:
0000 38383838 38383838 0c313232 3333330c 88888888.122333.
0010 534f4d45 4d4f5245 44415441 44415441 SOMEMOREDATADATA
0020 38383838 38383838 0c313232 3333330c 88888888.122333.
0030 534f4d45 4d4f5245 44415441 44415441 SOMEMOREDATADATA
/redef.s
0,0 → 1,11
.data
_start:
.set x, .-_start
.long x
.balign 4
.set x, .-_start
.long x
.set x, .-_start
.long x
.set x, .-_start
.long x
/itbl.s
0,0 → 1,13
 
; Test case for assembler option "itbl".
; Run as "as --itbl itbl itbl.s"
; or with stand-alone test case "itbl-test itbl itbl.s".
 
; Assemble processor instructions as defined in "itbl".
 
fee $d3,$c2,0x1 ; 0x4ff07601
fie ; 0x4ff00000
foh $2,0x100
fum $d3,$c2 ; 0x4ff07601
pig $2,0x100
 
/relax.d
0,0 → 1,13
#objdump : -s -j .data -j "\$DATA\$"
#name : relax .uleb128
 
.*: .*
 
Contents of section .*
0000 01020381 01000000 00000000 00000000.*
#...
0080 00000004 ffff0500 06078380 01000000.*
#...
4080 00000000 00000000 00000008 ffffffff.*
4090 09090909 09090909 09090909 09090909.*
#pass
/x930509.s
0,0 → 1,3
.long L2-L1
L1: .long 0x1234
L2: .long 0x5678
/eqv-ok.s
0,0 → 1,3
.eqv x, 1
/incbin.s
0,0 → 1,5
.text
.incbin "incbin.dat"
.incbin "incbin.dat",0,8
.incbin "incbin.dat",8,8
.incbin "incbin.dat",16,16
/struct.d
0,0 → 1,8
#nm: --extern-only
#name: struct
 
# Test the .struct pseudo-op.
 
0+00 A w1
0+02 A w2
0+04 A w3
/assign.d
0,0 → 1,6
#objdump : -r
#name : assignment tests
 
#...
.*zzz.*
.*zzz.*
/weakref2.s
0,0 → 1,5
.weakref a,b
.weakref b,c
.weakref c,d
.weakref d,e
.weakref e,a
/eval.d
0,0 → 1,8
#objdump: -s -j .data
#name: evaluation of simple expressions
 
.*: .*
 
Contents of section .data:
0000 01010101 010101.. ........ ........ ................
#pass
/weakref4.s
0,0 → 1,45
/* m# test multiple weakrefs */
.weakref Wnm1, nm1
.weakref Wnm1, nm1
 
.weakref Wum2, um2
.weakref Wum2, um2
.long um2
 
.weakref Wwm3, wm3
.weakref Wwm3, wm3
.long Wwm3
 
/* r# weakref redefinitions, to and from */
.weakref lr1, nr1
.long lr1
.set lr1, l
.long lr1
 
.long lr2
.weakref lr2, nr2
.set lr2, l
.long lr2
 
.set Wwr3, l
.long Wwr3
.weakref Wwr3, wr3
.long Wwr3
 
.set Wwr4, l
.weakref Wwr4, wr4
.long Wwr4
 
.set Wwr5, l
.long Wwr5
.weakref Wwr5, wr5
 
.weakref lr6, ur6
.long lr6
.set lr6, l
.long ur6
 
.weakref lr7, nr7
.long lr7
lr7:
.long lr7
/equiv1.s
0,0 → 1,5
;# Re-definition of an already .equiv-ed symbol (to another symbol).
;# The assembler should reject this.
.equiv x, y
.equiv y, 1
.equiv x, 0
/relax.s
0,0 → 1,20
.data
.byte 1, 2, 3
.uleb128 L2 - L1
L1:
.space 128 - 2
.byte 4
.p2align 1, 0xff
L2:
.byte 5
 
.p2align 2
.byte 6, 7
.uleb128 L4 - L3
L3:
.space 128*128 - 2
.byte 8
.p2align 2, 0xff
L4:
.byte 9
.p2align 4, 9
/quad.d
0,0 → 1,12
#objdump : -s -j .data -j "\$DATA\$"
#name : .quad tests
 
.*: .*
 
Contents of section (\.data|\$DATA\$):
0000 (00000000 76543210 00000000 80000000|10325476 00000000 00000080 00000000|00000000 54761032 00000000 00800000|32107654 00000000 00008000 00000000) .*
00.. (00000000 87654321 00000000 ffffffff|21436587 00000000 ffffffff 00000000|00000000 65872143 00000000 ffffffff|43218765 00000000 ffffffff 00000000) .*
00.. (ffffffff 89abcdf0 ffffffff 80000000|f0cdab89 ffffffff 00000080 ffffffff|ffffffff ab89f0cd ffffffff 00800000|cdf089ab ffffffff 00008000 ffffffff) .*
00.. (ffffffff 789abcdf ffffffff 00000001|dfbc9a78 ffffffff 01000000 ffffffff|ffffffff 9a78dfbc ffffffff 00000100|bcdf789a ffffffff 00010000 ffffffff) .*
00.. (01234567 89abcdef fedcba98 76543211|efcdab89 67452301 11325476 98badcfe|23016745 ab89efcd dcfe98ba 54761132|cdef89ab 45670123 32117654 ba98fedc) .*
#pass

powered by: WebSVN 2.1.0

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