diff options
| author | Phil Blundell <philb@gnu.org> | 2000-05-29 14:08:54 +0000 |
|---|---|---|
| committer | Phil Blundell <philb@gnu.org> | 2000-05-29 14:08:54 +0000 |
| commit | 8beeaa5b890a8618851dce324739b63684d195c9 (patch) | |
| tree | 6a88d497718a677a12df256472a20b0a0c4e61a2 | |
| parent | b01819b086ca34b6921cedd12151ff37ba0eca77 (diff) | |
| download | binutils-gdb-8beeaa5b890a8618851dce324739b63684d195c9.tar.gz | |
Add generated files.
82 files changed, 67595 insertions, 1 deletions
diff --git a/Makefile.in b/Makefile.in index beab8be4fb1..9a45e4fc518 100644 --- a/Makefile.in +++ b/Makefile.in @@ -711,7 +711,6 @@ INSTALL_MODULES = \ install-shellutils \ install-sim \ install-tar \ - install-texinfo \ install-textutils \ install-tgas \ install-time \ diff --git a/bfd/doc/aoutx.texi b/bfd/doc/aoutx.texi new file mode 100644 index 00000000000..d97e96aeb79 --- /dev/null +++ b/bfd/doc/aoutx.texi @@ -0,0 +1,211 @@ +@section a.out backends + + +@strong{Description}@* +BFD supports a number of different flavours of a.out format, +though the major differences are only the sizes of the +structures on disk, and the shape of the relocation +information. + +The support is split into a basic support file @file{aoutx.h} +and other files which derive functions from the base. One +derivation file is @file{aoutf1.h} (for a.out flavour 1), and +adds to the basic a.out functions support for sun3, sun4, 386 +and 29k a.out files, to create a target jump vector for a +specific target. + +This information is further split out into more specific files +for each machine, including @file{sunos.c} for sun3 and sun4, +@file{newsos3.c} for the Sony NEWS, and @file{demo64.c} for a +demonstration of a 64 bit a.out format. + +The base file @file{aoutx.h} defines general mechanisms for +reading and writing records to and from disk and various +other methods which BFD requires. It is included by +@file{aout32.c} and @file{aout64.c} to form the names +@code{aout_32_swap_exec_header_in}, @code{aout_64_swap_exec_header_in}, etc. + +As an example, this is what goes on to make the back end for a +sun4, from @file{aout32.c}: + +@example + #define ARCH_SIZE 32 + #include "aoutx.h" +@end example + +Which exports names: + +@example + ... + aout_32_canonicalize_reloc + aout_32_find_nearest_line + aout_32_get_lineno + aout_32_get_reloc_upper_bound + ... +@end example + +from @file{sunos.c}: + +@example + #define TARGET_NAME "a.out-sunos-big" + #define VECNAME sunos_big_vec + #include "aoutf1.h" +@end example + +requires all the names from @file{aout32.c}, and produces the jump vector + +@example + sunos_big_vec +@end example + +The file @file{host-aout.c} is a special case. It is for a large set +of hosts that use ``more or less standard'' a.out files, and +for which cross-debugging is not interesting. It uses the +standard 32-bit a.out support routines, but determines the +file offsets and addresses of the text, data, and BSS +sections, the machine architecture and machine type, and the +entry point address, in a host-dependent manner. Once these +values have been determined, generic code is used to handle +the object file. + +When porting it to run on a new system, you must supply: + +@example + HOST_PAGE_SIZE + HOST_SEGMENT_SIZE + HOST_MACHINE_ARCH (optional) + HOST_MACHINE_MACHINE (optional) + HOST_TEXT_START_ADDR + HOST_STACK_END_ADDR +@end example + +in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These +values, plus the structures and macros defined in @file{a.out.h} on +your host system, will produce a BFD target that will access +ordinary a.out files on your host. To configure a new machine +to use @file{host-aout.c}, specify: + +@example + TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec + TDEPFILES= host-aout.o trad-core.o +@end example + +in the @file{config/@var{XXX}.mt} file, and modify @file{configure.in} +to use the +@file{@var{XXX}.mt} file (by setting "@code{bfd_target=XXX}") when your +configuration is selected. + +@subsection Relocations + + +@strong{Description}@* +The file @file{aoutx.h} provides for both the @emph{standard} +and @emph{extended} forms of a.out relocation records. + +The standard records contain only an +address, a symbol index, and a type field. The extended records +(used on 29ks and sparcs) also have a full integer for an +addend. + +@subsection Internal entry points + + +@strong{Description}@* +@file{aoutx.h} exports several routines for accessing the +contents of an a.out file, which are gathered and exported in +turn by various format specific files (eg sunos.c). + +@findex aout_@var{size}_swap_exec_header_in +@subsubsection @code{aout_@var{size}_swap_exec_header_in} +@strong{Synopsis} +@example +void aout_@var{size}_swap_exec_header_in, + (bfd *abfd, + struct external_exec *raw_bytes, + struct internal_exec *execp); +@end example +@strong{Description}@* +Swap the information in an executable header @var{raw_bytes} taken +from a raw byte stream memory image into the internal exec header +structure @var{execp}. + +@findex aout_@var{size}_swap_exec_header_out +@subsubsection @code{aout_@var{size}_swap_exec_header_out} +@strong{Synopsis} +@example +void aout_@var{size}_swap_exec_header_out + (bfd *abfd, + struct internal_exec *execp, + struct external_exec *raw_bytes); +@end example +@strong{Description}@* +Swap the information in an internal exec header structure +@var{execp} into the buffer @var{raw_bytes} ready for writing to disk. + +@findex aout_@var{size}_some_aout_object_p +@subsubsection @code{aout_@var{size}_some_aout_object_p} +@strong{Synopsis} +@example +const bfd_target *aout_@var{size}_some_aout_object_p + (bfd *abfd, + const bfd_target *(*callback_to_real_object_p)()); +@end example +@strong{Description}@* +Some a.out variant thinks that the file open in @var{abfd} +checking is an a.out file. Do some more checking, and set up +for access if it really is. Call back to the calling +environment's "finish up" function just before returning, to +handle any last-minute setup. + +@findex aout_@var{size}_mkobject +@subsubsection @code{aout_@var{size}_mkobject} +@strong{Synopsis} +@example +boolean aout_@var{size}_mkobject, (bfd *abfd); +@end example +@strong{Description}@* +Initialize BFD @var{abfd} for use with a.out files. + +@findex aout_@var{size}_machine_type +@subsubsection @code{aout_@var{size}_machine_type} +@strong{Synopsis} +@example +enum machine_type aout_@var{size}_machine_type + (enum bfd_architecture arch, + unsigned long machine)); +@end example +@strong{Description}@* +Keep track of machine architecture and machine type for +a.out's. Return the @code{machine_type} for a particular +architecture and machine, or @code{M_UNKNOWN} if that exact architecture +and machine can't be represented in a.out format. + +If the architecture is understood, machine type 0 (default) +is always understood. + +@findex aout_@var{size}_set_arch_mach +@subsubsection @code{aout_@var{size}_set_arch_mach} +@strong{Synopsis} +@example +boolean aout_@var{size}_set_arch_mach, + (bfd *, + enum bfd_architecture arch, + unsigned long machine)); +@end example +@strong{Description}@* +Set the architecture and the machine of the BFD @var{abfd} to the +values @var{arch} and @var{machine}. Verify that @var{abfd}'s format +can support the architecture required. + +@findex aout_@var{size}_new_section_hook +@subsubsection @code{aout_@var{size}_new_section_hook} +@strong{Synopsis} +@example +boolean aout_@var{size}_new_section_hook, + (bfd *abfd, + asection *newsect)); +@end example +@strong{Description}@* +Called by the BFD in response to a @code{bfd_make_section} +request. + diff --git a/bfd/doc/archive.texi b/bfd/doc/archive.texi new file mode 100644 index 00000000000..7e91a1690c8 --- /dev/null +++ b/bfd/doc/archive.texi @@ -0,0 +1,95 @@ +@section Archives + + +@strong{Description}@* +An archive (or library) is just another BFD. It has a symbol +table, although there's not much a user program will do with it. + +The big difference between an archive BFD and an ordinary BFD +is that the archive doesn't have sections. Instead it has a +chain of BFDs that are considered its contents. These BFDs can +be manipulated like any other. The BFDs contained in an +archive opened for reading will all be opened for reading. You +may put either input or output BFDs into an archive opened for +output; they will be handled correctly when the archive is closed. + +Use @code{bfd_openr_next_archived_file} to step through +the contents of an archive opened for input. You don't +have to read the entire archive if you don't want +to! Read it until you find what you want. + +Archive contents of output BFDs are chained through the +@code{next} pointer in a BFD. The first one is findable through +the @code{archive_head} slot of the archive. Set it with +@code{bfd_set_archive_head} (q.v.). A given BFD may be in only one +open output archive at a time. + +As expected, the BFD archive code is more general than the +archive code of any given environment. BFD archives may +contain files of different formats (e.g., a.out and coff) and +even different architectures. You may even place archives +recursively into archives! + +This can cause unexpected confusion, since some archive +formats are more expressive than others. For instance, Intel +COFF archives can preserve long filenames; SunOS a.out archives +cannot. If you move a file from the first to the second +format and back again, the filename may be truncated. +Likewise, different a.out environments have different +conventions as to how they truncate filenames, whether they +preserve directory names in filenames, etc. When +interoperating with native tools, be sure your files are +homogeneous. + +Beware: most of these formats do not react well to the +presence of spaces in filenames. We do the best we can, but +can't always handle this case due to restrictions in the format of +archives. Many Unix utilities are braindead in regards to +spaces and such in filenames anyway, so this shouldn't be much +of a restriction. + +Archives are supported in BFD in @code{archive.c}. + +@findex bfd_get_next_mapent +@subsubsection @code{bfd_get_next_mapent} +@strong{Synopsis} +@example +symindex bfd_get_next_mapent(bfd *abfd, symindex previous, carsym **sym); +@end example +@strong{Description}@* +Step through archive @var{abfd}'s symbol table (if it +has one). Successively update @var{sym} with the next symbol's +information, returning that symbol's (internal) index into the +symbol table. + +Supply @code{BFD_NO_MORE_SYMBOLS} as the @var{previous} entry to get +the first one; returns @code{BFD_NO_MORE_SYMBOLS} when you've already +got the last one. + +A @code{carsym} is a canonical archive symbol. The only +user-visible element is its name, a null-terminated string. + +@findex bfd_set_archive_head +@subsubsection @code{bfd_set_archive_head} +@strong{Synopsis} +@example +boolean bfd_set_archive_head(bfd *output, bfd *new_head); +@end example +@strong{Description}@* +Set the head of the chain of +BFDs contained in the archive @var{output} to @var{new_head}. + +@findex bfd_openr_next_archived_file +@subsubsection @code{bfd_openr_next_archived_file} +@strong{Synopsis} +@example +bfd *bfd_openr_next_archived_file(bfd *archive, bfd *previous); +@end example +@strong{Description}@* +Provided a BFD, @var{archive}, containing an archive and NULL, open +an input BFD on the first contained element and returns that. +Subsequent calls should pass +the archive and the previous return value to return a created +BFD to the next contained element. NULL is returned when there +are no more. + diff --git a/bfd/doc/archures.texi b/bfd/doc/archures.texi new file mode 100644 index 00000000000..6ee20e971cf --- /dev/null +++ b/bfd/doc/archures.texi @@ -0,0 +1,409 @@ +@section Architectures +BFD keeps one atom in a BFD describing the +architecture of the data attached to the BFD: a pointer to a +@code{bfd_arch_info_type}. + +Pointers to structures can be requested independently of a BFD +so that an architecture's information can be interrogated +without access to an open BFD. + +The architecture information is provided by each architecture package. +The set of default architectures is selected by the macro +@code{SELECT_ARCHITECTURES}. This is normally set up in the +@file{config/@var{target}.mt} file of your choice. If the name is not +defined, then all the architectures supported are included. + +When BFD starts up, all the architectures are called with an +initialize method. It is up to the architecture back end to +insert as many items into the list of architectures as it wants to; +generally this would be one for each machine and one for the +default case (an item with a machine field of 0). + +BFD's idea of an architecture is implemented in @file{archures.c}. + +@subsection bfd_architecture + + +@strong{Description}@* +This enum gives the object file's CPU architecture, in a +global sense---i.e., what processor family does it belong to? +Another field indicates which processor within +the family is in use. The machine gives a number which +distinguishes different versions of the architecture, +containing, for example, 2 and 3 for Intel i960 KA and i960 KB, +and 68020 and 68030 for Motorola 68020 and 68030. +@example +enum bfd_architecture +@{ + bfd_arch_unknown, /* File arch not known */ + bfd_arch_obscure, /* Arch known, not one of these */ + bfd_arch_m68k, /* Motorola 68xxx */ +#define bfd_mach_m68000 1 +#define bfd_mach_m68008 2 +#define bfd_mach_m68010 3 +#define bfd_mach_m68020 4 +#define bfd_mach_m68030 5 +#define bfd_mach_m68040 6 +#define bfd_mach_m68060 7 +#define bfd_mach_cpu32 8 + bfd_arch_vax, /* DEC Vax */ + bfd_arch_i960, /* Intel 960 */ + /* The order of the following is important. + lower number indicates a machine type that + only accepts a subset of the instructions + available to machines with higher numbers. + The exception is the "ca", which is + incompatible with all other machines except + "core". */ + +#define bfd_mach_i960_core 1 +#define bfd_mach_i960_ka_sa 2 +#define bfd_mach_i960_kb_sb 3 +#define bfd_mach_i960_mc 4 +#define bfd_mach_i960_xa 5 +#define bfd_mach_i960_ca 6 +#define bfd_mach_i960_jx 7 +#define bfd_mach_i960_hx 8 + + bfd_arch_a29k, /* AMD 29000 */ + bfd_arch_sparc, /* SPARC */ +#define bfd_mach_sparc 1 + /* The difference between v8plus and v9 is that v9 is a true 64 bit env. */ +#define bfd_mach_sparc_sparclet 2 +#define bfd_mach_sparc_sparclite 3 +#define bfd_mach_sparc_v8plus 4 +#define bfd_mach_sparc_v8plusa 5 /* with ultrasparc add'ns */ +#define bfd_mach_sparc_sparclite_le 6 +#define bfd_mach_sparc_v9 7 +#define bfd_mach_sparc_v9a 8 /* with ultrasparc add'ns */ + /* Nonzero if MACH has the v9 instruction set. */ +#define bfd_mach_sparc_v9_p(mach) \ + ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a) + bfd_arch_mips, /* MIPS Rxxxx */ +#define bfd_mach_mips3000 3000 +#define bfd_mach_mips3900 3900 +#define bfd_mach_mips4000 4000 +#define bfd_mach_mips4010 4010 +#define bfd_mach_mips4100 4100 +#define bfd_mach_mips4111 4111 +#define bfd_mach_mips4300 4300 +#define bfd_mach_mips4400 4400 +#define bfd_mach_mips4600 4600 +#define bfd_mach_mips4650 4650 +#define bfd_mach_mips5000 5000 +#define bfd_mach_mips6000 6000 +#define bfd_mach_mips8000 8000 +#define bfd_mach_mips10000 10000 +#define bfd_mach_mips16 16 + bfd_arch_i386, /* Intel 386 */ +#define bfd_mach_i386_i386 0 +#define bfd_mach_i386_i8086 1 +#define bfd_mach_i386_i386_intel_syntax 2 + bfd_arch_we32k, /* AT&T WE32xxx */ + bfd_arch_tahoe, /* CCI/Harris Tahoe */ + bfd_arch_i860, /* Intel 860 */ + bfd_arch_i370, /* IBM 360/370 Mainframes */ + bfd_arch_romp, /* IBM ROMP PC/RT */ + bfd_arch_alliant, /* Alliant */ + bfd_arch_convex, /* Convex */ + bfd_arch_m88k, /* Motorola 88xxx */ + bfd_arch_pyramid, /* Pyramid Technology */ + bfd_arch_h8300, /* Hitachi H8/300 */ +#define bfd_mach_h8300 1 +#define bfd_mach_h8300h 2 +#define bfd_mach_h8300s 3 + bfd_arch_powerpc, /* PowerPC */ + bfd_arch_rs6000, /* IBM RS/6000 */ + bfd_arch_hppa, /* HP PA RISC */ + bfd_arch_d10v, /* Mitsubishi D10V */ +#define bfd_mach_d10v 0 +#define bfd_mach_d10v_ts2 2 +#define bfd_mach_d10v_ts3 3 + bfd_arch_d30v, /* Mitsubishi D30V */ + bfd_arch_z8k, /* Zilog Z8000 */ +#define bfd_mach_z8001 1 +#define bfd_mach_z8002 2 + bfd_arch_h8500, /* Hitachi H8/500 */ + bfd_arch_sh, /* Hitachi SH */ +#define bfd_mach_sh 0 +#define bfd_mach_sh2 0x20 +#define bfd_mach_sh_dsp 0x2d +#define bfd_mach_sh3 0x30 +#define bfd_mach_sh3_dsp 0x3d +#define bfd_mach_sh3e 0x3e +#define bfd_mach_sh4 0x40 + bfd_arch_alpha, /* Dec Alpha */ +#define bfd_mach_alpha_ev4 0x10 +#define bfd_mach_alpha_ev5 0x20 +#define bfd_mach_alpha_ev6 0x30 + bfd_arch_arm, /* Advanced Risc Machines ARM */ +#define bfd_mach_arm_2 1 +#define bfd_mach_arm_2a 2 +#define bfd_mach_arm_3 3 +#define bfd_mach_arm_3M 4 +#define bfd_mach_arm_4 5 +#define bfd_mach_arm_4T 6 +#define bfd_mach_arm_5 7 +#define bfd_mach_arm_5T 8 + bfd_arch_ns32k, /* National Semiconductors ns32000 */ + bfd_arch_w65, /* WDC 65816 */ + bfd_arch_tic30, /* Texas Instruments TMS320C30 */ + bfd_arch_tic80, /* TI TMS320c80 (MVP) */ + bfd_arch_v850, /* NEC V850 */ +#define bfd_mach_v850 0 +#define bfd_mach_v850e 'E' +#define bfd_mach_v850ea 'A' + bfd_arch_arc, /* Argonaut RISC Core */ +#define bfd_mach_arc_base 0 + bfd_arch_m32r, /* Mitsubishi M32R/D */ +#define bfd_mach_m32r 0 /* backwards compatibility */ +#define bfd_mach_m32rx 'x' + bfd_arch_mn10200, /* Matsushita MN10200 */ + bfd_arch_mn10300, /* Matsushita MN10300 */ +#define bfd_mach_mn10300 300 +#define bfd_mach_am33 330 + bfd_arch_fr30, +#define bfd_mach_fr30 0x46523330 + bfd_arch_mcore, + bfd_arch_pj, + bfd_arch_avr, /* Atmel AVR microcontrollers */ +#define bfd_mach_avr1 1 +#define bfd_mach_avr2 2 +#define bfd_mach_avr3 3 +#define bfd_mach_avr4 4 + bfd_arch_last + @}; +@end example + +@subsection bfd_arch_info + + +@strong{Description}@* +This structure contains information on architectures for use +within BFD. +@example + +typedef struct bfd_arch_info +@{ + int bits_per_word; + int bits_per_address; + int bits_per_byte; + enum bfd_architecture arch; + unsigned long mach; + const char *arch_name; + const char *printable_name; + unsigned int section_align_power; + /* true if this is the default machine for the architecture */ + boolean the_default; + const struct bfd_arch_info * (*compatible) + PARAMS ((const struct bfd_arch_info *a, + const struct bfd_arch_info *b)); + + boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *)); + + const struct bfd_arch_info *next; +@} bfd_arch_info_type; +@end example + +@findex bfd_printable_name +@subsubsection @code{bfd_printable_name} +@strong{Synopsis} +@example +const char *bfd_printable_name(bfd *abfd); +@end example +@strong{Description}@* +Return a printable string representing the architecture and machine +from the pointer to the architecture info structure. + +@findex bfd_scan_arch +@subsubsection @code{bfd_scan_arch} +@strong{Synopsis} +@example +const bfd_arch_info_type *bfd_scan_arch(const char *string); +@end example +@strong{Description}@* +Figure out if BFD supports any cpu which could be described with +the name @var{string}. Return a pointer to an @code{arch_info} +structure if a machine is found, otherwise NULL. + +@findex bfd_arch_list +@subsubsection @code{bfd_arch_list} +@strong{Synopsis} +@example +const char **bfd_arch_list(void); +@end example +@strong{Description}@* +Return a freshly malloced NULL-terminated vector of the names +of all the valid BFD architectures. Do not modify the names. + +@findex bfd_arch_get_compatible +@subsubsection @code{bfd_arch_get_compatible} +@strong{Synopsis} +@example +const bfd_arch_info_type *bfd_arch_get_compatible( + const bfd *abfd, + const bfd *bbfd); +@end example +@strong{Description}@* +Determine whether two BFDs' +architectures and machine types are compatible. Calculates +the lowest common denominator between the two architectures +and machine types implied by the BFDs and returns a pointer to +an @code{arch_info} structure describing the compatible machine. + +@findex bfd_default_arch_struct +@subsubsection @code{bfd_default_arch_struct} +@strong{Description}@* +The @code{bfd_default_arch_struct} is an item of +@code{bfd_arch_info_type} which has been initialized to a fairly +generic state. A BFD starts life by pointing to this +structure, until the correct back end has determined the real +architecture of the file. +@example +extern const bfd_arch_info_type bfd_default_arch_struct; +@end example + +@findex bfd_set_arch_info +@subsubsection @code{bfd_set_arch_info} +@strong{Synopsis} +@example +void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg); +@end example +@strong{Description}@* +Set the architecture info of @var{abfd} to @var{arg}. + +@findex bfd_default_set_arch_mach +@subsubsection @code{bfd_default_set_arch_mach} +@strong{Synopsis} +@example +boolean bfd_default_set_arch_mach(bfd *abfd, + enum bfd_architecture arch, + unsigned long mach); +@end example +@strong{Description}@* +Set the architecture and machine type in BFD @var{abfd} +to @var{arch} and @var{mach}. Find the correct +pointer to a structure and insert it into the @code{arch_info} +pointer. + +@findex bfd_get_arch +@subsubsection @code{bfd_get_arch} +@strong{Synopsis} +@example +enum bfd_architecture bfd_get_arch(bfd *abfd); +@end example +@strong{Description}@* +Return the enumerated type which describes the BFD @var{abfd}'s +architecture. + +@findex bfd_get_mach +@subsubsection @code{bfd_get_mach} +@strong{Synopsis} +@example +unsigned long bfd_get_mach(bfd *abfd); +@end example +@strong{Description}@* +Return the long type which describes the BFD @var{abfd}'s +machine. + +@findex bfd_arch_bits_per_byte +@subsubsection @code{bfd_arch_bits_per_byte} +@strong{Synopsis} +@example +unsigned int bfd_arch_bits_per_byte(bfd *abfd); +@end example +@strong{Description}@* +Return the number of bits in one of the BFD @var{abfd}'s +architecture's bytes. + +@findex bfd_arch_bits_per_address +@subsubsection @code{bfd_arch_bits_per_address} +@strong{Synopsis} +@example +unsigned int bfd_arch_bits_per_address(bfd *abfd); +@end example +@strong{Description}@* +Return the number of bits in one of the BFD @var{abfd}'s +architecture's addresses. + +@findex bfd_default_compatible +@subsubsection @code{bfd_default_compatible} +@strong{Synopsis} +@example +const bfd_arch_info_type *bfd_default_compatible + (const bfd_arch_info_type *a, + const bfd_arch_info_type *b); +@end example +@strong{Description}@* +The default function for testing for compatibility. + +@findex bfd_default_scan +@subsubsection @code{bfd_default_scan} +@strong{Synopsis} +@example +boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string); +@end example +@strong{Description}@* +The default function for working out whether this is an +architecture hit and a machine hit. + +@findex bfd_get_arch_info +@subsubsection @code{bfd_get_arch_info} +@strong{Synopsis} +@example +const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd); +@end example +@strong{Description}@* +Return the architecture info struct in @var{abfd}. + +@findex bfd_lookup_arch +@subsubsection @code{bfd_lookup_arch} +@strong{Synopsis} +@example +const bfd_arch_info_type *bfd_lookup_arch + (enum bfd_architecture + arch, + unsigned long machine); +@end example +@strong{Description}@* +Look for the architecure info structure which matches the +arguments @var{arch} and @var{machine}. A machine of 0 matches the +machine/architecture structure which marks itself as the +default. + +@findex bfd_printable_arch_mach +@subsubsection @code{bfd_printable_arch_mach} +@strong{Synopsis} +@example +const char *bfd_printable_arch_mach + (enum bfd_architecture arch, unsigned long machine); +@end example +@strong{Description}@* +Return a printable string representing the architecture and +machine type. + +This routine is depreciated. + +@findex bfd_octets_per_byte +@subsubsection @code{bfd_octets_per_byte} +@strong{Synopsis} +@example +unsigned int bfd_octets_per_byte(bfd *abfd); +@end example +@strong{Description}@* +Return the number of octets (8-bit quantities) per target byte +(minimum addressable unit). In most cases, this will be one, but some +DSP targets have 16, 32, or even 48 bits per byte. + +@findex bfd_arch_mach_octets_per_byte +@subsubsection @code{bfd_arch_mach_octets_per_byte} +@strong{Synopsis} +@example +unsigned int bfd_arch_mach_octets_per_byte(enum bfd_architecture arch, + unsigned long machine); +@end example +@strong{Description}@* +See bfd_octets_per_byte. +This routine is provided for those cases where a bfd * is not +available + diff --git a/bfd/doc/bfd.info b/bfd/doc/bfd.info new file mode 100644 index 00000000000..58f549be00e --- /dev/null +++ b/bfd/doc/bfd.info @@ -0,0 +1,95 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +Indirect: +bfd.info-1: 916 +bfd.info-2: 37727 +bfd.info-3: 81566 +bfd.info-4: 126215 +bfd.info-5: 175891 +bfd.info-6: 205826 +bfd.info-7: 233431 + +Tag Table: +(Indirect) +Node: Top916 +Node: Overview1181 +Node: History2231 +Node: How It Works3172 +Node: What BFD Version 2 Can Do4710 +Node: BFD information loss6024 +Node: Canonical format8547 +Node: BFD front end12908 +Node: Memory Usage31825 +Node: Initialization33048 +Node: Sections33425 +Node: Section Input33903 +Node: Section Output35259 +Node: typedef asection37727 +Node: section prototypes53227 +Node: Symbols59441 +Node: Reading Symbols61031 +Node: Writing Symbols62205 +Node: Mini Symbols63895 +Node: typedef asymbol64860 +Node: symbol handling functions70089 +Node: Archives74418 +Node: Formats78036 +Node: Relocations80846 +Node: typedef arelent81566 +Node: howto manager97725 +Node: Core Files123231 +Node: Targets124252 +Node: bfd_target126215 +Node: Architectures145125 +Node: Opening and Closing158434 +Node: Internal162831 +Node: File Caching168829 +Node: Linker Functions171607 +Node: Creating a Linker Hash Table173273 +Node: Adding Symbols to the Hash Table175001 +Node: Differing file formats175891 +Node: Adding symbols from an object file177624 +Node: Adding symbols from an archive179760 +Node: Performing the Final Link182159 +Node: Information provided by the linker183390 +Node: Relocating the section contents184526 +Node: Writing the symbol table186263 +Node: Hash Tables188857 +Node: Creating and Freeing a Hash Table190048 +Node: Looking Up or Entering a String191205 +Node: Traversing a Hash Table192447 +Node: Deriving a New Hash Table Type193225 +Node: Define the Derived Structures194280 +Node: Write the Derived Creation Routine195346 +Node: Write Other Derived Routines198045 +Node: BFD back ends199345 +Node: What to Put Where199564 +Node: aout199702 +Node: coff205826 +Node: elf232598 +Node: Index233431 + +End Tag Table diff --git a/bfd/doc/bfd.info-1 b/bfd/doc/bfd.info-1 new file mode 100644 index 00000000000..deef94c6815 --- /dev/null +++ b/bfd/doc/bfd.info-1 @@ -0,0 +1,1017 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: bfd.info, Node: Top, Next: Overview, Prev: (dir), Up: (dir) + + This file documents the binary file descriptor library libbfd. + +* Menu: + +* Overview:: Overview of BFD +* BFD front end:: BFD front end +* BFD back ends:: BFD back ends +* Index:: Index + + +File: bfd.info, Node: Overview, Next: BFD front end, Prev: Top, Up: Top + +Introduction +************ + + BFD is a package which allows applications to use the same routines +to operate on object files whatever the object file format. A new +object file format can be supported simply by creating a new BFD back +end and adding it to the library. + + BFD is split into two parts: the front end, and the back ends (one +for each object file format). + * The front end of BFD provides the interface to the user. It manages + memory and various canonical data structures. The front end also + decides which back end to use and when to call back end routines. + + * The back ends provide BFD its view of the real world. Each back + end provides a set of calls which the BFD front end can use to + maintain its canonical form. The back ends also may keep around + information for their own use, for greater efficiency. + +* Menu: + +* History:: History +* How It Works:: How It Works +* What BFD Version 2 Can Do:: What BFD Version 2 Can Do + + +File: bfd.info, Node: History, Next: How It Works, Prev: Overview, Up: Overview + +History +======= + + One spur behind BFD was the desire, on the part of the GNU 960 team +at Intel Oregon, for interoperability of applications on their COFF and +b.out file formats. Cygnus was providing GNU support for the team, and +was contracted to provide the required functionality. + + The name came from a conversation David Wallace was having with +Richard Stallman about the library: RMS said that it would be quite +hard--David said "BFD". Stallman was right, but the name stuck. + + At the same time, Ready Systems wanted much the same thing, but for +different object file formats: IEEE-695, Oasys, Srecords, a.out and 68k +coff. + + BFD was first implemented by members of Cygnus Support; Steve +Chamberlain (`sac@cygnus.com'), John Gilmore (`gnu@cygnus.com'), K. +Richard Pixley (`rich@cygnus.com') and David Henkel-Wallace +(`gumby@cygnus.com'). + + +File: bfd.info, Node: How It Works, Next: What BFD Version 2 Can Do, Prev: History, Up: Overview + +How To Use BFD +============== + + To use the library, include `bfd.h' and link with `libbfd.a'. + + BFD provides a common interface to the parts of an object file for a +calling application. + + When an application sucessfully opens a target file (object, +archive, or whatever), a pointer to an internal structure is returned. +This pointer points to a structure called `bfd', described in `bfd.h'. +Our convention is to call this pointer a BFD, and instances of it +within code `abfd'. All operations on the target object file are +applied as methods to the BFD. The mapping is defined within `bfd.h' +in a set of macros, all beginning with `bfd_' to reduce namespace +pollution. + + For example, this sequence does what you would probably expect: +return the number of sections in an object file attached to a BFD +`abfd'. + + #include "bfd.h" + + unsigned int number_of_sections(abfd) + bfd *abfd; + { + return bfd_count_sections(abfd); + } + + The abstraction used within BFD is that an object file has: + + * a header, + + * a number of sections containing raw data (*note Sections::), + + * a set of relocations (*note Relocations::), and + + * some symbol information (*note Symbols::). + +Also, BFDs opened for archives have the additional attribute of an index +and contain subordinate BFDs. This approach is fine for a.out and coff, +but loses efficiency when applied to formats such as S-records and +IEEE-695. + + +File: bfd.info, Node: What BFD Version 2 Can Do, Prev: How It Works, Up: Overview + +What BFD Version 2 Can Do +========================= + + When an object file is opened, BFD subroutines automatically +determine the format of the input object file. They then build a +descriptor in memory with pointers to routines that will be used to +access elements of the object file's data structures. + + As different information from the the object files is required, BFD +reads from different sections of the file and processes them. For +example, a very common operation for the linker is processing symbol +tables. Each BFD back end provides a routine for converting between +the object file's representation of symbols and an internal canonical +format. When the linker asks for the symbol table of an object file, it +calls through a memory pointer to the routine from the relevant BFD +back end which reads and converts the table into a canonical form. The +linker then operates upon the canonical form. When the link is finished +and the linker writes the output file's symbol table, another BFD back +end routine is called to take the newly created symbol table and +convert it into the chosen output format. + +* Menu: + +* BFD information loss:: Information Loss +* Canonical format:: The BFD canonical object-file format + + +File: bfd.info, Node: BFD information loss, Next: Canonical format, Up: What BFD Version 2 Can Do + +Information Loss +---------------- + + _Information can be lost during output._ The output formats +supported by BFD do not provide identical facilities, and information +which can be described in one form has nowhere to go in another format. +One example of this is alignment information in `b.out'. There is +nowhere in an `a.out' format file to store alignment information on the +contained data, so when a file is linked from `b.out' and an `a.out' +image is produced, alignment information will not propagate to the +output file. (The linker will still use the alignment information +internally, so the link is performed correctly). + + Another example is COFF section names. COFF files may contain an +unlimited number of sections, each one with a textual section name. If +the target of the link is a format which does not have many sections +(e.g., `a.out') or has sections without names (e.g., the Oasys format), +the link cannot be done simply. You can circumvent this problem by +describing the desired input-to-output section mapping with the linker +command language. + + _Information can be lost during canonicalization._ The BFD internal +canonical form of the external formats is not exhaustive; there are +structures in input formats for which there is no direct representation +internally. This means that the BFD back ends cannot maintain all +possible data richness through the transformation between external to +internal and back to external formats. + + This limitation is only a problem when an application reads one +format and writes another. Each BFD back end is responsible for +maintaining as much data as possible, and the internal BFD canonical +form has structures which are opaque to the BFD core, and exported only +to the back ends. When a file is read in one format, the canonical form +is generated for BFD and the application. At the same time, the back +end saves away any information which may otherwise be lost. If the data +is then written back in the same format, the back end routine will be +able to use the canonical form provided by the BFD core as well as the +information it prepared earlier. Since there is a great deal of +commonality between back ends, there is no information lost when +linking or copying big endian COFF to little endian COFF, or `a.out' to +`b.out'. When a mixture of formats is linked, the information is only +lost from the files whose format differs from the destination. + + +File: bfd.info, Node: Canonical format, Prev: BFD information loss, Up: What BFD Version 2 Can Do + +The BFD canonical object-file format +------------------------------------ + + The greatest potential for loss of information occurs when there is +the least overlap between the information provided by the source +format, that stored by the canonical format, and that needed by the +destination format. A brief description of the canonical form may help +you understand which kinds of data you can count on preserving across +conversions. + +_files_ + Information stored on a per-file basis includes target machine + architecture, particular implementation format type, a demand + pageable bit, and a write protected bit. Information like Unix + magic numbers is not stored here--only the magic numbers' meaning, + so a `ZMAGIC' file would have both the demand pageable bit and the + write protected text bit set. The byte order of the target is + stored on a per-file basis, so that big- and little-endian object + files may be used with one another. + +_sections_ + Each section in the input file contains the name of the section, + the section's original address in the object file, size and + alignment information, various flags, and pointers into other BFD + data structures. + +_symbols_ + Each symbol contains a pointer to the information for the object + file which originally defined it, its name, its value, and various + flag bits. When a BFD back end reads in a symbol table, it + relocates all symbols to make them relative to the base of the + section where they were defined. Doing this ensures that each + symbol points to its containing section. Each symbol also has a + varying amount of hidden private data for the BFD back end. Since + the symbol points to the original file, the private data format + for that symbol is accessible. `ld' can operate on a collection + of symbols of wildly different formats without problems. + + Normal global and simple local symbols are maintained on output, + so an output file (no matter its format) will retain symbols + pointing to functions and to global, static, and common variables. + Some symbol information is not worth retaining; in `a.out', type + information is stored in the symbol table as long symbol names. + This information would be useless to most COFF debuggers; the + linker has command line switches to allow users to throw it away. + + There is one word of type information within the symbol, so if the + format supports symbol type information within symbols (for + example, COFF, IEEE, Oasys) and the type is simple enough to fit + within one word (nearly everything but aggregates), the + information will be preserved. + +_relocation level_ + Each canonical BFD relocation record contains a pointer to the + symbol to relocate to, the offset of the data to relocate, the + section the data is in, and a pointer to a relocation type + descriptor. Relocation is performed by passing messages through + the relocation type descriptor and the symbol pointer. Therefore, + relocations can be performed on output data using a relocation + method that is only available in one of the input formats. For + instance, Oasys provides a byte relocation format. A relocation + record requesting this relocation type would point indirectly to a + routine to perform this, so the relocation may be performed on a + byte being written to a 68k COFF file, even though 68k COFF has no + such relocation type. + +_line numbers_ + Object formats can contain, for debugging purposes, some form of + mapping between symbols, source line numbers, and addresses in the + output file. These addresses have to be relocated along with the + symbol information. Each symbol with an associated list of line + number records points to the first record of the list. The head + of a line number list consists of a pointer to the symbol, which + allows finding out the address of the function whose line number + is being described. The rest of the list is made up of pairs: + offsets into the section and line numbers. Any format which can + simply derive this information can pass it successfully between + formats (COFF, IEEE and Oasys). + + +File: bfd.info, Node: BFD front end, Next: BFD back ends, Prev: Overview, Up: Top + +BFD front end +************* + +`typedef bfd' +============= + + A BFD has type `bfd'; objects of this type are the cornerstone of +any application using BFD. Using BFD consists of making references +though the BFD and to data in the BFD. + + Here is the structure that defines the type `bfd'. It contains the +major data about the file and pointers to the rest of the data. + + + struct _bfd + { + /* The filename the application opened the BFD with. */ + CONST char *filename; + + /* A pointer to the target jump table. */ + const struct bfd_target *xvec; + + /* To avoid dragging too many header files into every file that + includes ``bfd.h'', IOSTREAM has been declared as a "char + *", and MTIME as a "long". Their correct types, to which they + are cast when used, are "FILE *" and "time_t". The iostream + is the result of an fopen on the filename. However, if the + BFD_IN_MEMORY flag is set, then iostream is actually a pointer + to a bfd_in_memory struct. */ + PTR iostream; + + /* Is the file descriptor being cached? That is, can it be closed as + needed, and re-opened when accessed later? */ + + boolean cacheable; + + /* Marks whether there was a default target specified when the + BFD was opened. This is used to select which matching algorithm + to use to choose the back end. */ + + boolean target_defaulted; + + /* The caching routines use these to maintain a + least-recently-used list of BFDs */ + + struct _bfd *lru_prev, *lru_next; + + /* When a file is closed by the caching routines, BFD retains + state information on the file here: */ + + file_ptr where; + + /* and here: (``once'' means at least once) */ + + boolean opened_once; + + /* Set if we have a locally maintained mtime value, rather than + getting it from the file each time: */ + + boolean mtime_set; + + /* File modified time, if mtime_set is true: */ + + long mtime; + + /* Reserved for an unimplemented file locking extension.*/ + + int ifd; + + /* The format which belongs to the BFD. (object, core, etc.) */ + + bfd_format format; + + /* The direction the BFD was opened with*/ + + enum bfd_direction {no_direction = 0, + read_direction = 1, + write_direction = 2, + both_direction = 3} direction; + + /* Format_specific flags*/ + + flagword flags; + + /* Currently my_archive is tested before adding origin to + anything. I believe that this can become always an add of + origin, with origin set to 0 for non archive files. */ + + file_ptr origin; + + /* Remember when output has begun, to stop strange things + from happening. */ + boolean output_has_begun; + + /* Pointer to linked list of sections*/ + struct sec *sections; + + /* The number of sections */ + unsigned int section_count; + + /* Stuff only useful for object files: + The start address. */ + bfd_vma start_address; + + /* Used for input and output*/ + unsigned int symcount; + + /* Symbol table for output BFD (with symcount entries) */ + struct symbol_cache_entry **outsymbols; + + /* Pointer to structure which contains architecture information*/ + const struct bfd_arch_info *arch_info; + + /* Stuff only useful for archives:*/ + PTR arelt_data; + struct _bfd *my_archive; /* The containing archive BFD. */ + struct _bfd *next; /* The next BFD in the archive. */ + struct _bfd *archive_head; /* The first BFD in the archive. */ + boolean has_armap; + + /* A chain of BFD structures involved in a link. */ + struct _bfd *link_next; + + /* A field used by _bfd_generic_link_add_archive_symbols. This will + be used only for archive elements. */ + int archive_pass; + + /* Used by the back end to hold private data. */ + + union + { + struct aout_data_struct *aout_data; + struct artdata *aout_ar_data; + struct _oasys_data *oasys_obj_data; + struct _oasys_ar_data *oasys_ar_data; + struct coff_tdata *coff_obj_data; + struct pe_tdata *pe_obj_data; + struct xcoff_tdata *xcoff_obj_data; + struct ecoff_tdata *ecoff_obj_data; + struct ieee_data_struct *ieee_data; + struct ieee_ar_data_struct *ieee_ar_data; + struct srec_data_struct *srec_data; + struct ihex_data_struct *ihex_data; + struct tekhex_data_struct *tekhex_data; + struct elf_obj_tdata *elf_obj_data; + struct nlm_obj_tdata *nlm_obj_data; + struct bout_data_struct *bout_data; + struct sun_core_struct *sun_core_data; + struct sco5_core_struct *sco5_core_data; + struct trad_core_struct *trad_core_data; + struct som_data_struct *som_data; + struct hpux_core_struct *hpux_core_data; + struct hppabsd_core_struct *hppabsd_core_data; + struct sgi_core_struct *sgi_core_data; + struct lynx_core_struct *lynx_core_data; + struct osf_core_struct *osf_core_data; + struct cisco_core_struct *cisco_core_data; + struct versados_data_struct *versados_data; + struct netbsd_core_struct *netbsd_core_data; + PTR any; + } tdata; + + /* Used by the application to hold private data*/ + PTR usrdata; + + /* Where all the allocated stuff under this BFD goes. This is a + struct objalloc *, but we use PTR to avoid requiring the inclusion of + objalloc.h. */ + PTR memory; + }; + +Error reporting +=============== + + Most BFD functions return nonzero on success (check their individual +documentation for precise semantics). On an error, they call +`bfd_set_error' to set an error condition that callers can check by +calling `bfd_get_error'. If that returns `bfd_error_system_call', then +check `errno'. + + The easiest way to report a BFD error to the user is to use +`bfd_perror'. + +Type `bfd_error_type' +--------------------- + + The values returned by `bfd_get_error' are defined by the enumerated +type `bfd_error_type'. + + + typedef enum bfd_error + { + bfd_error_no_error = 0, + bfd_error_system_call, + bfd_error_invalid_target, + bfd_error_wrong_format, + bfd_error_invalid_operation, + bfd_error_no_memory, + bfd_error_no_symbols, + bfd_error_no_armap, + bfd_error_no_more_archived_files, + bfd_error_malformed_archive, + bfd_error_file_not_recognized, + bfd_error_file_ambiguously_recognized, + bfd_error_no_contents, + bfd_error_nonrepresentable_section, + bfd_error_no_debug_section, + bfd_error_bad_value, + bfd_error_file_truncated, + bfd_error_file_too_big, + bfd_error_invalid_error_code + } bfd_error_type; + +`bfd_get_error' +............... + + *Synopsis* + bfd_error_type bfd_get_error (void); + *Description* +Return the current BFD error condition. + +`bfd_set_error' +............... + + *Synopsis* + void bfd_set_error (bfd_error_type error_tag); + *Description* +Set the BFD error condition to be ERROR_TAG. + +`bfd_errmsg' +............ + + *Synopsis* + CONST char *bfd_errmsg (bfd_error_type error_tag); + *Description* +Return a string describing the error ERROR_TAG, or the system error if +ERROR_TAG is `bfd_error_system_call'. + +`bfd_perror' +............ + + *Synopsis* + void bfd_perror (CONST char *message); + *Description* +Print to the standard error stream a string describing the last BFD +error that occurred, or the last system error if the last BFD error was +a system call failure. If MESSAGE is non-NULL and non-empty, the error +string printed is preceded by MESSAGE, a colon, and a space. It is +followed by a newline. + +BFD error handler +----------------- + + Some BFD functions want to print messages describing the problem. +They call a BFD error handler function. This function may be overriden +by the program. + + The BFD error handler acts like printf. + + + typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...)); + +`bfd_set_error_handler' +....................... + + *Synopsis* + bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); + *Description* +Set the BFD error handler function. Returns the previous function. + +`bfd_set_error_program_name' +............................ + + *Synopsis* + void bfd_set_error_program_name (const char *); + *Description* +Set the program name to use when printing a BFD error. This is printed +before the error message followed by a colon and space. The string +must not be changed after it is passed to this function. + +`bfd_get_error_handler' +....................... + + *Synopsis* + bfd_error_handler_type bfd_get_error_handler (void); + *Description* +Return the BFD error handler function. + +Symbols +======= + +`bfd_get_reloc_upper_bound' +........................... + + *Synopsis* + long bfd_get_reloc_upper_bound(bfd *abfd, asection *sect); + *Description* +Return the number of bytes required to store the relocation information +associated with section SECT attached to bfd ABFD. If an error occurs, +return -1. + +`bfd_canonicalize_reloc' +........................ + + *Synopsis* + long bfd_canonicalize_reloc + (bfd *abfd, + asection *sec, + arelent **loc, + asymbol **syms); + *Description* +Call the back end associated with the open BFD ABFD and translate the +external form of the relocation information attached to SEC into the +internal canonical form. Place the table into memory at LOC, which has +been preallocated, usually by a call to `bfd_get_reloc_upper_bound'. +Returns the number of relocs, or -1 on error. + + The SYMS table is also needed for horrible internal magic reasons. + +`bfd_set_reloc' +............... + + *Synopsis* + void bfd_set_reloc + (bfd *abfd, asection *sec, arelent **rel, unsigned int count) + *Description* +Set the relocation pointer and count within section SEC to the values +REL and COUNT. The argument ABFD is ignored. + +`bfd_set_file_flags' +.................... + + *Synopsis* + boolean bfd_set_file_flags(bfd *abfd, flagword flags); + *Description* +Set the flag word in the BFD ABFD to the value FLAGS. + + Possible errors are: + * `bfd_error_wrong_format' - The target bfd was not of object format. + + * `bfd_error_invalid_operation' - The target bfd was open for + reading. + + * `bfd_error_invalid_operation' - The flag word contained a bit + which was not applicable to the type of file. E.g., an attempt + was made to set the `D_PAGED' bit on a BFD format which does not + support demand paging. + +`bfd_set_start_address' +....................... + + *Synopsis* + boolean bfd_set_start_address(bfd *abfd, bfd_vma vma); + *Description* +Make VMA the entry point of output BFD ABFD. + + *Returns* +Returns `true' on success, `false' otherwise. + +`bfd_get_mtime' +............... + + *Synopsis* + long bfd_get_mtime(bfd *abfd); + *Description* +Return the file modification time (as read from the file system, or +from the archive header for archive members). + +`bfd_get_size' +.............. + + *Synopsis* + long bfd_get_size(bfd *abfd); + *Description* +Return the file size (as read from file system) for the file associated +with BFD ABFD. + + The initial motivation for, and use of, this routine is not so we +can get the exact size of the object the BFD applies to, since that +might not be generally possible (archive members for example). It +would be ideal if someone could eventually modify it so that such +results were guaranteed. + + Instead, we want to ask questions like "is this NNN byte sized +object I'm about to try read from file offset YYY reasonable?" As as +example of where we might do this, some object formats use string +tables for which the first `sizeof(long)' bytes of the table contain +the size of the table itself, including the size bytes. If an +application tries to read what it thinks is one of these string tables, +without some way to validate the size, and for some reason the size is +wrong (byte swapping error, wrong location for the string table, etc.), +the only clue is likely to be a read error when it tries to read the +table, or a "virtual memory exhausted" error when it tries to allocate +15 bazillon bytes of space for the 15 bazillon byte table it is about +to read. This function at least allows us to answer the quesion, "is +the size reasonable?". + +`bfd_get_gp_size' +................. + + *Synopsis* + int bfd_get_gp_size(bfd *abfd); + *Description* +Return the maximum size of objects to be optimized using the GP +register under MIPS ECOFF. This is typically set by the `-G' argument +to the compiler, assembler or linker. + +`bfd_set_gp_size' +................. + + *Synopsis* + void bfd_set_gp_size(bfd *abfd, int i); + *Description* +Set the maximum size of objects to be optimized using the GP register +under ECOFF or MIPS ELF. This is typically set by the `-G' argument to +the compiler, assembler or linker. + +`bfd_scan_vma' +.............. + + *Synopsis* + bfd_vma bfd_scan_vma(CONST char *string, CONST char **end, int base); + *Description* +Convert, like `strtoul', a numerical expression STRING into a `bfd_vma' +integer, and return that integer. (Though without as many bells and +whistles as `strtoul'.) The expression is assumed to be unsigned +(i.e., positive). If given a BASE, it is used as the base for +conversion. A base of 0 causes the function to interpret the string in +hex if a leading "0x" or "0X" is found, otherwise in octal if a leading +zero is found, otherwise in decimal. + + Overflow is not detected. + +`bfd_copy_private_bfd_data' +........................... + + *Synopsis* + boolean bfd_copy_private_bfd_data(bfd *ibfd, bfd *obfd); + *Description* +Copy private BFD information from the BFD IBFD to the the BFD OBFD. +Return `true' on success, `false' on error. Possible error returns are: + + * `bfd_error_no_memory' - Not enough memory exists to create private + data for OBFD. + + #define bfd_copy_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ + (ibfd, obfd)) + +`bfd_merge_private_bfd_data' +............................ + + *Synopsis* + boolean bfd_merge_private_bfd_data(bfd *ibfd, bfd *obfd); + *Description* +Merge private BFD information from the BFD IBFD to the the output file +BFD OBFD when linking. Return `true' on success, `false' on error. +Possible error returns are: + + * `bfd_error_no_memory' - Not enough memory exists to create private + data for OBFD. + + #define bfd_merge_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ + (ibfd, obfd)) + +`bfd_set_private_flags' +....................... + + *Synopsis* + boolean bfd_set_private_flags(bfd *abfd, flagword flags); + *Description* +Set private BFD flag information in the BFD ABFD. Return `true' on +success, `false' on error. Possible error returns are: + + * `bfd_error_no_memory' - Not enough memory exists to create private + data for OBFD. + + #define bfd_set_private_flags(abfd, flags) \ + BFD_SEND (abfd, _bfd_set_private_flags, \ + (abfd, flags)) + +`stuff' +....... + + *Description* +Stuff which should be documented: + #define bfd_sizeof_headers(abfd, reloc) \ + BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) + + #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ + BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, sec, syms, off, file, func, line)) + + /* Do these three do anything useful at all, for any back end? */ + #define bfd_debug_info_start(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) + + #define bfd_debug_info_end(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) + + #define bfd_debug_info_accumulate(abfd, section) \ + BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) + + + #define bfd_stat_arch_elt(abfd, stat) \ + BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) + + #define bfd_update_armap_timestamp(abfd) \ + BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) + + #define bfd_set_arch_mach(abfd, arch, mach)\ + BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) + + #define bfd_relax_section(abfd, section, link_info, again) \ + BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) + + #define bfd_gc_sections(abfd, link_info) \ + BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) + + #define bfd_link_hash_table_create(abfd) \ + BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) + + #define bfd_link_add_symbols(abfd, info) \ + BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) + + #define bfd_final_link(abfd, info) \ + BFD_SEND (abfd, _bfd_final_link, (abfd, info)) + + #define bfd_free_cached_info(abfd) \ + BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) + + #define bfd_get_dynamic_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) + + #define bfd_print_private_bfd_data(abfd, file)\ + BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) + + #define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) + + #define bfd_get_dynamic_reloc_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) + + #define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) + + extern bfd_byte *bfd_get_relocated_section_contents + PARAMS ((bfd *, struct bfd_link_info *, + struct bfd_link_order *, bfd_byte *, + boolean, asymbol **)); + +* Menu: + +* Memory Usage:: +* Initialization:: +* Sections:: +* Symbols:: +* Archives:: +* Formats:: +* Relocations:: +* Core Files:: +* Targets:: +* Architectures:: +* Opening and Closing:: +* Internal:: +* File Caching:: +* Linker Functions:: +* Hash Tables:: + + +File: bfd.info, Node: Memory Usage, Next: Initialization, Prev: BFD front end, Up: BFD front end + +Memory usage +============ + + BFD keeps all of its internal structures in obstacks. There is one +obstack per open BFD file, into which the current state is stored. When +a BFD is closed, the obstack is deleted, and so everything which has +been allocated by BFD for the closing file is thrown away. + + BFD does not free anything created by an application, but pointers +into `bfd' structures become invalid on a `bfd_close'; for example, +after a `bfd_close' the vector passed to `bfd_canonicalize_symtab' is +still around, since it has been allocated by the application, but the +data that it pointed to are lost. + + The general rule is to not close a BFD until all operations dependent +upon data from the BFD have been completed, or all the data from within +the file has been copied. To help with the management of memory, there +is a function (`bfd_alloc_size') which returns the number of bytes in +obstacks associated with the supplied BFD. This could be used to select +the greediest open BFD, close it to reclaim the memory, perform some +operation and reopen the BFD again, to get a fresh copy of the data +structures. + + +File: bfd.info, Node: Initialization, Next: Sections, Prev: Memory Usage, Up: BFD front end + +Initialization +============== + + These are the functions that handle initializing a BFD. + +`bfd_init' +.......... + + *Synopsis* + void bfd_init(void); + *Description* +This routine must be called before any other BFD function to initialize +magical internal data structures. + + +File: bfd.info, Node: Sections, Next: Symbols, Prev: Initialization, Up: BFD front end + +Sections +======== + + The raw data contained within a BFD is maintained through the +section abstraction. A single BFD may have any number of sections. It +keeps hold of them by pointing to the first; each one points to the +next in the list. + + Sections are supported in BFD in `section.c'. + +* Menu: + +* Section Input:: +* Section Output:: +* typedef asection:: +* section prototypes:: + + +File: bfd.info, Node: Section Input, Next: Section Output, Prev: Sections, Up: Sections + +Section input +------------- + + When a BFD is opened for reading, the section structures are created +and attached to the BFD. + + Each section has a name which describes the section in the outside +world--for example, `a.out' would contain at least three sections, +called `.text', `.data' and `.bss'. + + Names need not be unique; for example a COFF file may have several +sections named `.data'. + + Sometimes a BFD will contain more than the "natural" number of +sections. A back end may attach other sections containing constructor +data, or an application may add a section (using `bfd_make_section') to +the sections attached to an already open BFD. For example, the linker +creates an extra section `COMMON' for each input file's BFD to hold +information about common storage. + + The raw data is not necessarily read in when the section descriptor +is created. Some targets may leave the data in place until a +`bfd_get_section_contents' call is made. Other back ends may read in +all the data at once. For example, an S-record file has to be read +once to determine the size of the data. An IEEE-695 file doesn't +contain raw data in sections, but data and relocation expressions +intermixed, so the data area has to be parsed to get out the data and +relocations. + + +File: bfd.info, Node: Section Output, Next: typedef asection, Prev: Section Input, Up: Sections + +Section output +-------------- + + To write a new object style BFD, the various sections to be written +have to be created. They are attached to the BFD in the same way as +input sections; data is written to the sections using +`bfd_set_section_contents'. + + Any program that creates or combines sections (e.g., the assembler +and linker) must use the `asection' fields `output_section' and +`output_offset' to indicate the file sections to which each section +must be written. (If the section is being created from scratch, +`output_section' should probably point to the section itself and +`output_offset' should probably be zero.) + + The data to be written comes from input sections attached (via +`output_section' pointers) to the output sections. The output section +structure can be considered a filter for the input section: the output +section determines the vma of the output data and the name, but the +input section determines the offset into the output section of the data +to be written. + + E.g., to create a section "O", starting at 0x100, 0x123 long, +containing two subsections, "A" at offset 0x0 (i.e., at vma 0x100) and +"B" at offset 0x20 (i.e., at vma 0x120) the `asection' structures would +look like: + + section name "A" + output_offset 0x00 + size 0x20 + output_section -----------> section name "O" + | vma 0x100 + section name "B" | size 0x123 + output_offset 0x20 | + size 0x103 | + output_section --------| + +Link orders +----------- + + The data within a section is stored in a "link_order". These are +much like the fixups in `gas'. The link_order abstraction allows a +section to grow and shrink within itself. + + A link_order knows how big it is, and which is the next link_order +and where the raw data for it is; it also points to a list of +relocations which apply to it. + + The link_order is used by the linker to perform relaxing on final +code. The compiler creates code which is as big as necessary to make +it work without relaxing, and the user can select whether to relax. +Sometimes relaxing takes a lot of time. The linker runs around the +relocations to see if any are attached to data which can be shrunk, if +so it does it on a link_order by link_order basis. + diff --git a/bfd/doc/bfd.info-2 b/bfd/doc/bfd.info-2 new file mode 100644 index 00000000000..05c4f8ca3de --- /dev/null +++ b/bfd/doc/bfd.info-2 @@ -0,0 +1,1187 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: bfd.info, Node: typedef asection, Next: section prototypes, Prev: Section Output, Up: Sections + +typedef asection +---------------- + + Here is the section structure: + + + /* This structure is used for a comdat section, as in PE. A comdat + section is associated with a particular symbol. When the linker + sees a comdat section, it keeps only one of the sections with a + given name and associated with a given symbol. */ + + struct bfd_comdat_info + { + /* The name of the symbol associated with a comdat section. */ + const char *name; + + /* The local symbol table index of the symbol associated with a + comdat section. This is only meaningful to the object file format + specific code; it is not an index into the list returned by + bfd_canonicalize_symtab. */ + long symbol; + + /* If this section is being discarded, the linker uses this field + to point to the input section which is being kept. */ + struct sec *sec; + }; + + typedef struct sec + { + /* The name of the section; the name isn't a copy, the pointer is + the same as that passed to bfd_make_section. */ + + CONST char *name; + + /* Which section is it; 0..nth. */ + + int index; + + /* The next section in the list belonging to the BFD, or NULL. */ + + struct sec *next; + + /* The field flags contains attributes of the section. Some + flags are read in from the object file, and some are + synthesized from other information. */ + + flagword flags; + + #define SEC_NO_FLAGS 0x000 + + /* Tells the OS to allocate space for this section when loading. + This is clear for a section containing debug information + only. */ + #define SEC_ALLOC 0x001 + + /* Tells the OS to load the section from the file when loading. + This is clear for a .bss section. */ + #define SEC_LOAD 0x002 + + /* The section contains data still to be relocated, so there is + some relocation information too. */ + #define SEC_RELOC 0x004 + + #if 0 /* Obsolete ? */ + #define SEC_BALIGN 0x008 + #endif + + /* A signal to the OS that the section contains read only + data. */ + #define SEC_READONLY 0x010 + + /* The section contains code only. */ + #define SEC_CODE 0x020 + + /* The section contains data only. */ + #define SEC_DATA 0x040 + + /* The section will reside in ROM. */ + #define SEC_ROM 0x080 + + /* The section contains constructor information. This section + type is used by the linker to create lists of constructors and + destructors used by `g++'. When a back end sees a symbol + which should be used in a constructor list, it creates a new + section for the type of name (e.g., `__CTOR_LIST__'), attaches + the symbol to it, and builds a relocation. To build the lists + of constructors, all the linker has to do is catenate all the + sections called `__CTOR_LIST__' and relocate the data + contained within - exactly the operations it would peform on + standard data. */ + #define SEC_CONSTRUCTOR 0x100 + + /* The section is a constructor, and should be placed at the + end of the text, data, or bss section(?). */ + #define SEC_CONSTRUCTOR_TEXT 0x1100 + #define SEC_CONSTRUCTOR_DATA 0x2100 + #define SEC_CONSTRUCTOR_BSS 0x3100 + + /* The section has contents - a data section could be + `SEC_ALLOC' | `SEC_HAS_CONTENTS'; a debug section could be + `SEC_HAS_CONTENTS' */ + #define SEC_HAS_CONTENTS 0x200 + + /* An instruction to the linker to not output the section + even if it has information which would normally be written. */ + #define SEC_NEVER_LOAD 0x400 + + /* The section is a COFF shared library section. This flag is + only for the linker. If this type of section appears in + the input file, the linker must copy it to the output file + without changing the vma or size. FIXME: Although this + was originally intended to be general, it really is COFF + specific (and the flag was renamed to indicate this). It + might be cleaner to have some more general mechanism to + allow the back end to control what the linker does with + sections. */ + #define SEC_COFF_SHARED_LIBRARY 0x800 + + /* The section contains common symbols (symbols may be defined + multiple times, the value of a symbol is the amount of + space it requires, and the largest symbol value is the one + used). Most targets have exactly one of these (which we + translate to bfd_com_section_ptr), but ECOFF has two. */ + #define SEC_IS_COMMON 0x8000 + + /* The section contains only debugging information. For + example, this is set for ELF .debug and .stab sections. + strip tests this flag to see if a section can be + discarded. */ + #define SEC_DEBUGGING 0x10000 + + /* The contents of this section are held in memory pointed to + by the contents field. This is checked by + bfd_get_section_contents, and the data is retrieved from + memory if appropriate. */ + #define SEC_IN_MEMORY 0x20000 + + /* The contents of this section are to be excluded by the + linker for executable and shared objects unless those + objects are to be further relocated. */ + #define SEC_EXCLUDE 0x40000 + + /* The contents of this section are to be sorted by the + based on the address specified in the associated symbol + table. */ + #define SEC_SORT_ENTRIES 0x80000 + + /* When linking, duplicate sections of the same name should be + discarded, rather than being combined into a single section as + is usually done. This is similar to how common symbols are + handled. See SEC_LINK_DUPLICATES below. */ + #define SEC_LINK_ONCE 0x100000 + + /* If SEC_LINK_ONCE is set, this bitfield describes how the linker + should handle duplicate sections. */ + #define SEC_LINK_DUPLICATES 0x600000 + + /* This value for SEC_LINK_DUPLICATES means that duplicate + sections with the same name should simply be discarded. */ + #define SEC_LINK_DUPLICATES_DISCARD 0x0 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if there are any duplicate sections, although + it should still only link one copy. */ + #define SEC_LINK_DUPLICATES_ONE_ONLY 0x200000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections are a different size. */ + #define SEC_LINK_DUPLICATES_SAME_SIZE 0x400000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections contain different + contents. */ + #define SEC_LINK_DUPLICATES_SAME_CONTENTS 0x600000 + + /* This section was created by the linker as part of dynamic + relocation or other arcane processing. It is skipped when + going through the first-pass output, trusting that someone + else up the line will take care of it later. */ + #define SEC_LINKER_CREATED 0x800000 + + /* This section should not be subject to garbage collection. */ + #define SEC_KEEP 0x1000000 + + /* This section contains "short" data, and should be placed + "near" the GP. */ + #define SEC_SMALL_DATA 0x2000000 + + /* This section contains data which may be shared with other + executables or shared objects. */ + #define SEC_SHARED 0x4000000 + + /* End of section flags. */ + + /* Some internal packed boolean fields. */ + + /* See the vma field. */ + unsigned int user_set_vma : 1; + + /* Whether relocations have been processed. */ + unsigned int reloc_done : 1; + + /* A mark flag used by some of the linker backends. */ + unsigned int linker_mark : 1; + + /* A mark flag used by some linker backends for garbage collection. */ + unsigned int gc_mark : 1; + + /* End of internal packed boolean fields. */ + + /* The virtual memory address of the section - where it will be + at run time. The symbols are relocated against this. The + user_set_vma flag is maintained by bfd; if it's not set, the + backend can assign addresses (for example, in `a.out', where + the default address for `.data' is dependent on the specific + target and various flags). */ + + bfd_vma vma; + + /* The load address of the section - where it would be in a + rom image; really only used for writing section header + information. */ + + bfd_vma lma; + + /* The size of the section in octets, as it will be output. + Contains a value even if the section has no contents (e.g., the + size of `.bss'). This will be filled in after relocation. */ + + bfd_size_type _cooked_size; + + /* The original size on disk of the section, in octets. Normally this + value is the same as the size, but if some relaxing has + been done, then this value will be bigger. */ + + bfd_size_type _raw_size; + + /* If this section is going to be output, then this value is the + offset in *bytes* into the output section of the first byte in the + input section (byte ==> smallest addressable unit on the + target). In most cases, if this was going to start at the + 100th octet (8-bit quantity) in the output section, this value + would be 100. However, if the target byte size is 16 bits + (bfd_octets_per_byte is "2"), this value would be 50. */ + + bfd_vma output_offset; + + /* The output section through which to map on output. */ + + struct sec *output_section; + + /* The alignment requirement of the section, as an exponent of 2 - + e.g., 3 aligns to 2^3 (or 8). */ + + unsigned int alignment_power; + + /* If an input section, a pointer to a vector of relocation + records for the data in this section. */ + + struct reloc_cache_entry *relocation; + + /* If an output section, a pointer to a vector of pointers to + relocation records for the data in this section. */ + + struct reloc_cache_entry **orelocation; + + /* The number of relocation records in one of the above */ + + unsigned reloc_count; + + /* Information below is back end specific - and not always used + or updated. */ + + /* File position of section data */ + + file_ptr filepos; + + /* File position of relocation info */ + + file_ptr rel_filepos; + + /* File position of line data */ + + file_ptr line_filepos; + + /* Pointer to data for applications */ + + PTR userdata; + + /* If the SEC_IN_MEMORY flag is set, this points to the actual + contents. */ + unsigned char *contents; + + /* Attached line number information */ + + alent *lineno; + + /* Number of line number records */ + + unsigned int lineno_count; + + /* Optional information about a COMDAT entry; NULL if not COMDAT */ + + struct bfd_comdat_info *comdat; + + /* When a section is being output, this value changes as more + linenumbers are written out */ + + file_ptr moving_line_filepos; + + /* What the section number is in the target world */ + + int target_index; + + PTR used_by_bfd; + + /* If this is a constructor section then here is a list of the + relocations created to relocate items within it. */ + + struct relent_chain *constructor_chain; + + /* The BFD which owns the section. */ + + bfd *owner; + + /* A symbol which points at this section only */ + struct symbol_cache_entry *symbol; + struct symbol_cache_entry **symbol_ptr_ptr; + + struct bfd_link_order *link_order_head; + struct bfd_link_order *link_order_tail; + } asection ; + + /* These sections are global, and are managed by BFD. The application + and target back end are not permitted to change the values in + these sections. New code should use the section_ptr macros rather + than referring directly to the const sections. The const sections + may eventually vanish. */ + #define BFD_ABS_SECTION_NAME "*ABS*" + #define BFD_UND_SECTION_NAME "*UND*" + #define BFD_COM_SECTION_NAME "*COM*" + #define BFD_IND_SECTION_NAME "*IND*" + + /* the absolute section */ + extern const asection bfd_abs_section; + #define bfd_abs_section_ptr ((asection *) &bfd_abs_section) + #define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) + /* Pointer to the undefined section */ + extern const asection bfd_und_section; + #define bfd_und_section_ptr ((asection *) &bfd_und_section) + #define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) + /* Pointer to the common section */ + extern const asection bfd_com_section; + #define bfd_com_section_ptr ((asection *) &bfd_com_section) + /* Pointer to the indirect section */ + extern const asection bfd_ind_section; + #define bfd_ind_section_ptr ((asection *) &bfd_ind_section) + #define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr) + + extern const struct symbol_cache_entry * const bfd_abs_symbol; + extern const struct symbol_cache_entry * const bfd_com_symbol; + extern const struct symbol_cache_entry * const bfd_und_symbol; + extern const struct symbol_cache_entry * const bfd_ind_symbol; + #define bfd_get_section_size_before_reloc(section) \ + ((section)->reloc_done ? (abort (), (bfd_size_type) 1) \ + : (section)->_raw_size) + #define bfd_get_section_size_after_reloc(section) \ + ((section)->reloc_done ? (section)->_cooked_size \ + : (abort (), (bfd_size_type) 1)) + + +File: bfd.info, Node: section prototypes, Prev: typedef asection, Up: Sections + +Section prototypes +------------------ + + These are the functions exported by the section handling part of BFD. + +`bfd_get_section_by_name' +......................... + + *Synopsis* + asection *bfd_get_section_by_name(bfd *abfd, CONST char *name); + *Description* +Run through ABFD and return the one of the `asection's whose name +matches NAME, otherwise `NULL'. *Note Sections::, for more information. + + This should only be used in special cases; the normal way to process +all sections of a given name is to use `bfd_map_over_sections' and +`strcmp' on the name (or better yet, base it on the section flags or +something else) for each section. + +`bfd_make_section_old_way' +.......................... + + *Synopsis* + asection *bfd_make_section_old_way(bfd *abfd, CONST char *name); + *Description* +Create a new empty section called NAME and attach it to the end of the +chain of sections for the BFD ABFD. An attempt to create a section with +a name which is already in use returns its pointer without changing the +section chain. + + It has the funny name since this is the way it used to be before it +was rewritten.... + + Possible errors are: + * `bfd_error_invalid_operation' - If output has already started for + this BFD. + + * `bfd_error_no_memory' - If memory allocation fails. + +`bfd_make_section_anyway' +......................... + + *Synopsis* + asection *bfd_make_section_anyway(bfd *abfd, CONST char *name); + *Description* +Create a new empty section called NAME and attach it to the end of the +chain of sections for ABFD. Create a new section even if there is +already a section with that name. + + Return `NULL' and set `bfd_error' on error; possible errors are: + * `bfd_error_invalid_operation' - If output has already started for + ABFD. + + * `bfd_error_no_memory' - If memory allocation fails. + +`bfd_make_section' +.................. + + *Synopsis* + asection *bfd_make_section(bfd *, CONST char *name); + *Description* +Like `bfd_make_section_anyway', but return `NULL' (without calling +bfd_set_error ()) without changing the section chain if there is +already a section named NAME. If there is an error, return `NULL' and +set `bfd_error'. + +`bfd_set_section_flags' +....................... + + *Synopsis* + boolean bfd_set_section_flags(bfd *abfd, asection *sec, flagword flags); + *Description* +Set the attributes of the section SEC in the BFD ABFD to the value +FLAGS. Return `true' on success, `false' on error. Possible error +returns are: + + * `bfd_error_invalid_operation' - The section cannot have one or + more of the attributes requested. For example, a .bss section in + `a.out' may not have the `SEC_HAS_CONTENTS' field set. + +`bfd_map_over_sections' +....................... + + *Synopsis* + void bfd_map_over_sections(bfd *abfd, + void (*func)(bfd *abfd, + asection *sect, + PTR obj), + PTR obj); + *Description* +Call the provided function FUNC for each section attached to the BFD +ABFD, passing OBJ as an argument. The function will be called as if by + + func(abfd, the_section, obj); + + This is the prefered method for iterating over sections; an +alternative would be to use a loop: + + section *p; + for (p = abfd->sections; p != NULL; p = p->next) + func(abfd, p, ...) + +`bfd_set_section_size' +...................... + + *Synopsis* + boolean bfd_set_section_size(bfd *abfd, asection *sec, bfd_size_type val); + *Description* +Set SEC to the size VAL. If the operation is ok, then `true' is +returned, else `false'. + + Possible error returns: + * `bfd_error_invalid_operation' - Writing has started to the BFD, so + setting the size is invalid. + +`bfd_set_section_contents' +.......................... + + *Synopsis* + boolean bfd_set_section_contents + (bfd *abfd, + asection *section, + PTR data, + file_ptr offset, + bfd_size_type count); + *Description* +Sets the contents of the section SECTION in BFD ABFD to the data +starting in memory at DATA. The data is written to the output section +starting at offset OFFSET for COUNT octets. + + Normally `true' is returned, else `false'. Possible error returns +are: + * `bfd_error_no_contents' - The output section does not have the + `SEC_HAS_CONTENTS' attribute, so nothing can be written to it. + + * and some more too + This routine is front end to the back end function +`_bfd_set_section_contents'. + +`bfd_get_section_contents' +.......................... + + *Synopsis* + boolean bfd_get_section_contents + (bfd *abfd, asection *section, PTR location, + file_ptr offset, bfd_size_type count); + *Description* +Read data from SECTION in BFD ABFD into memory starting at LOCATION. +The data is read at an offset of OFFSET from the start of the input +section, and is read for COUNT bytes. + + If the contents of a constructor with the `SEC_CONSTRUCTOR' flag set +are requested or if the section does not have the `SEC_HAS_CONTENTS' +flag set, then the LOCATION is filled with zeroes. If no errors occur, +`true' is returned, else `false'. + +`bfd_copy_private_section_data' +............................... + + *Synopsis* + boolean bfd_copy_private_section_data(bfd *ibfd, asection *isec, bfd *obfd, asection *osec); + *Description* +Copy private section information from ISEC in the BFD IBFD to the +section OSEC in the BFD OBFD. Return `true' on success, `false' on +error. Possible error returns are: + + * `bfd_error_no_memory' - Not enough memory exists to create private + data for OSEC. + + #define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ + BFD_SEND (obfd, _bfd_copy_private_section_data, \ + (ibfd, isection, obfd, osection)) + +`_bfd_strip_section_from_output' +................................ + + *Synopsis* + void _bfd_strip_section_from_output + (struct bfd_link_info *info, asection *section); + *Description* +Remove SECTION from the output. If the output section becomes empty, +remove it from the output bfd. INFO may be NULL; if it is not, it is +used to decide whether the output section is empty. + + +File: bfd.info, Node: Symbols, Next: Archives, Prev: Sections, Up: BFD front end + +Symbols +======= + + BFD tries to maintain as much symbol information as it can when it +moves information from file to file. BFD passes information to +applications though the `asymbol' structure. When the application +requests the symbol table, BFD reads the table in the native form and +translates parts of it into the internal format. To maintain more than +the information passed to applications, some targets keep some +information "behind the scenes" in a structure only the particular back +end knows about. For example, the coff back end keeps the original +symbol table structure as well as the canonical structure when a BFD is +read in. On output, the coff back end can reconstruct the output symbol +table so that no information is lost, even information unique to coff +which BFD doesn't know or understand. If a coff symbol table were read, +but were written through an a.out back end, all the coff specific +information would be lost. The symbol table of a BFD is not necessarily +read in until a canonicalize request is made. Then the BFD back end +fills in a table provided by the application with pointers to the +canonical information. To output symbols, the application provides BFD +with a table of pointers to pointers to `asymbol's. This allows +applications like the linker to output a symbol as it was read, since +the "behind the scenes" information will be still available. + +* Menu: + +* Reading Symbols:: +* Writing Symbols:: +* Mini Symbols:: +* typedef asymbol:: +* symbol handling functions:: + + +File: bfd.info, Node: Reading Symbols, Next: Writing Symbols, Prev: Symbols, Up: Symbols + +Reading symbols +--------------- + + There are two stages to reading a symbol table from a BFD: +allocating storage, and the actual reading process. This is an excerpt +from an application which reads the symbol table: + + long storage_needed; + asymbol **symbol_table; + long number_of_symbols; + long i; + + storage_needed = bfd_get_symtab_upper_bound (abfd); + + if (storage_needed < 0) + FAIL + + if (storage_needed == 0) { + return ; + } + symbol_table = (asymbol **) xmalloc (storage_needed); + ... + number_of_symbols = + bfd_canonicalize_symtab (abfd, symbol_table); + + if (number_of_symbols < 0) + FAIL + + for (i = 0; i < number_of_symbols; i++) { + process_symbol (symbol_table[i]); + } + + All storage for the symbols themselves is in an objalloc connected +to the BFD; it is freed when the BFD is closed. + + +File: bfd.info, Node: Writing Symbols, Next: Mini Symbols, Prev: Reading Symbols, Up: Symbols + +Writing symbols +--------------- + + Writing of a symbol table is automatic when a BFD open for writing +is closed. The application attaches a vector of pointers to pointers to +symbols to the BFD being written, and fills in the symbol count. The +close and cleanup code reads through the table provided and performs +all the necessary operations. The BFD output code must always be +provided with an "owned" symbol: one which has come from another BFD, +or one which has been created using `bfd_make_empty_symbol'. Here is an +example showing the creation of a symbol table with only one element: + + #include "bfd.h" + main() + { + bfd *abfd; + asymbol *ptrs[2]; + asymbol *new; + + abfd = bfd_openw("foo","a.out-sunos-big"); + bfd_set_format(abfd, bfd_object); + new = bfd_make_empty_symbol(abfd); + new->name = "dummy_symbol"; + new->section = bfd_make_section_old_way(abfd, ".text"); + new->flags = BSF_GLOBAL; + new->value = 0x12345; + + ptrs[0] = new; + ptrs[1] = (asymbol *)0; + + bfd_set_symtab(abfd, ptrs, 1); + bfd_close(abfd); + } + + ./makesym + nm foo + 00012345 A dummy_symbol + + Many formats cannot represent arbitary symbol information; for +instance, the `a.out' object format does not allow an arbitary number +of sections. A symbol pointing to a section which is not one of +`.text', `.data' or `.bss' cannot be described. + + +File: bfd.info, Node: Mini Symbols, Next: typedef asymbol, Prev: Writing Symbols, Up: Symbols + +Mini Symbols +------------ + + Mini symbols provide read-only access to the symbol table. They use +less memory space, but require more time to access. They can be useful +for tools like nm or objdump, which may have to handle symbol tables of +extremely large executables. + + The `bfd_read_minisymbols' function will read the symbols into +memory in an internal form. It will return a `void *' pointer to a +block of memory, a symbol count, and the size of each symbol. The +pointer is allocated using `malloc', and should be freed by the caller +when it is no longer needed. + + The function `bfd_minisymbol_to_symbol' will take a pointer to a +minisymbol, and a pointer to a structure returned by +`bfd_make_empty_symbol', and return a `asymbol' structure. The return +value may or may not be the same as the value from +`bfd_make_empty_symbol' which was passed in. + + +File: bfd.info, Node: typedef asymbol, Next: symbol handling functions, Prev: Mini Symbols, Up: Symbols + +typedef asymbol +--------------- + + An `asymbol' has the form: + + + typedef struct symbol_cache_entry + { + /* A pointer to the BFD which owns the symbol. This information + is necessary so that a back end can work out what additional + information (invisible to the application writer) is carried + with the symbol. + + This field is *almost* redundant, since you can use section->owner + instead, except that some symbols point to the global sections + bfd_{abs,com,und}_section. This could be fixed by making + these globals be per-bfd (or per-target-flavor). FIXME. */ + + struct _bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */ + + /* The text of the symbol. The name is left alone, and not copied; the + application may not alter it. */ + CONST char *name; + + /* The value of the symbol. This really should be a union of a + numeric value with a pointer, since some flags indicate that + a pointer to another symbol is stored here. */ + symvalue value; + + /* Attributes of a symbol: */ + + #define BSF_NO_FLAGS 0x00 + + /* The symbol has local scope; `static' in `C'. The value + is the offset into the section of the data. */ + #define BSF_LOCAL 0x01 + + /* The symbol has global scope; initialized data in `C'. The + value is the offset into the section of the data. */ + #define BSF_GLOBAL 0x02 + + /* The symbol has global scope and is exported. The value is + the offset into the section of the data. */ + #define BSF_EXPORT BSF_GLOBAL /* no real difference */ + + /* A normal C symbol would be one of: + `BSF_LOCAL', `BSF_FORT_COMM', `BSF_UNDEFINED' or + `BSF_GLOBAL' */ + + /* The symbol is a debugging record. The value has an arbitary + meaning, unless BSF_DEBUGGING_RELOC is also set. */ + #define BSF_DEBUGGING 0x08 + + /* The symbol denotes a function entry point. Used in ELF, + perhaps others someday. */ + #define BSF_FUNCTION 0x10 + + /* Used by the linker. */ + #define BSF_KEEP 0x20 + #define BSF_KEEP_G 0x40 + + /* A weak global symbol, overridable without warnings by + a regular global symbol of the same name. */ + #define BSF_WEAK 0x80 + + /* This symbol was created to point to a section, e.g. ELF's + STT_SECTION symbols. */ + #define BSF_SECTION_SYM 0x100 + + /* The symbol used to be a common symbol, but now it is + allocated. */ + #define BSF_OLD_COMMON 0x200 + + /* The default value for common data. */ + #define BFD_FORT_COMM_DEFAULT_VALUE 0 + + /* In some files the type of a symbol sometimes alters its + location in an output file - ie in coff a `ISFCN' symbol + which is also `C_EXT' symbol appears where it was + declared and not at the end of a section. This bit is set + by the target BFD part to convey this information. */ + + #define BSF_NOT_AT_END 0x400 + + /* Signal that the symbol is the label of constructor section. */ + #define BSF_CONSTRUCTOR 0x800 + + /* Signal that the symbol is a warning symbol. The name is a + warning. The name of the next symbol is the one to warn about; + if a reference is made to a symbol with the same name as the next + symbol, a warning is issued by the linker. */ + #define BSF_WARNING 0x1000 + + /* Signal that the symbol is indirect. This symbol is an indirect + pointer to the symbol with the same name as the next symbol. */ + #define BSF_INDIRECT 0x2000 + + /* BSF_FILE marks symbols that contain a file name. This is used + for ELF STT_FILE symbols. */ + #define BSF_FILE 0x4000 + + /* Symbol is from dynamic linking information. */ + #define BSF_DYNAMIC 0x8000 + + /* The symbol denotes a data object. Used in ELF, and perhaps + others someday. */ + #define BSF_OBJECT 0x10000 + + /* This symbol is a debugging symbol. The value is the offset + into the section of the data. BSF_DEBUGGING should be set + as well. */ + #define BSF_DEBUGGING_RELOC 0x20000 + + flagword flags; + + /* A pointer to the section to which this symbol is + relative. This will always be non NULL, there are special + sections for undefined and absolute symbols. */ + struct sec *section; + + /* Back end special data. */ + union + { + PTR p; + bfd_vma i; + } udata; + + } asymbol; + + +File: bfd.info, Node: symbol handling functions, Prev: typedef asymbol, Up: Symbols + +Symbol handling functions +------------------------- + +`bfd_get_symtab_upper_bound' +............................ + + *Description* +Return the number of bytes required to store a vector of pointers to +`asymbols' for all the symbols in the BFD ABFD, including a terminal +NULL pointer. If there are no symbols in the BFD, then return 0. If an +error occurs, return -1. + #define bfd_get_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) + +`bfd_is_local_label' +.................... + + *Synopsis* + boolean bfd_is_local_label(bfd *abfd, asymbol *sym); + *Description* +Return true if the given symbol SYM in the BFD ABFD is a compiler +generated local label, else return false. + +`bfd_is_local_label_name' +......................... + + *Synopsis* + boolean bfd_is_local_label_name(bfd *abfd, const char *name); + *Description* +Return true if a symbol with the name NAME in the BFD ABFD is a +compiler generated local label, else return false. This just checks +whether the name has the form of a local label. + #define bfd_is_local_label_name(abfd, name) \ + BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) + +`bfd_canonicalize_symtab' +......................... + + *Description* +Read the symbols from the BFD ABFD, and fills in the vector LOCATION +with pointers to the symbols and a trailing NULL. Return the actual +number of symbol pointers, not including the NULL. + #define bfd_canonicalize_symtab(abfd, location) \ + BFD_SEND (abfd, _bfd_canonicalize_symtab,\ + (abfd, location)) + +`bfd_set_symtab' +................ + + *Synopsis* + boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count); + *Description* +Arrange that when the output BFD ABFD is closed, the table LOCATION of +COUNT pointers to symbols will be written. + +`bfd_print_symbol_vandf' +........................ + + *Synopsis* + void bfd_print_symbol_vandf(PTR file, asymbol *symbol); + *Description* +Print the value and flags of the SYMBOL supplied to the stream FILE. + +`bfd_make_empty_symbol' +....................... + + *Description* +Create a new `asymbol' structure for the BFD ABFD and return a pointer +to it. + + This routine is necessary because each back end has private +information surrounding the `asymbol'. Building your own `asymbol' and +pointing to it will not create the private information, and will cause +problems later on. + #define bfd_make_empty_symbol(abfd) \ + BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) + +`bfd_make_debug_symbol' +....................... + + *Description* +Create a new `asymbol' structure for the BFD ABFD, to be used as a +debugging symbol. Further details of its use have yet to be worked out. + #define bfd_make_debug_symbol(abfd,ptr,size) \ + BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) + +`bfd_decode_symclass' +..................... + + *Description* +Return a character corresponding to the symbol class of SYMBOL, or '?' +for an unknown class. + + *Synopsis* + int bfd_decode_symclass(asymbol *symbol); + +`bfd_is_undefined_symclass ' +............................ + + *Description* +Returns non-zero if the class symbol returned by bfd_decode_symclass +represents an undefined symbol. Returns zero otherwise. + + *Synopsis* + boolean bfd_is_undefined_symclass (int symclass); + +`bfd_symbol_info' +................. + + *Description* +Fill in the basic info about symbol that nm needs. Additional info may +be added by the back-ends after calling this function. + + *Synopsis* + void bfd_symbol_info(asymbol *symbol, symbol_info *ret); + +`bfd_copy_private_symbol_data' +.............................. + + *Synopsis* + boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); + *Description* +Copy private symbol information from ISYM in the BFD IBFD to the symbol +OSYM in the BFD OBFD. Return `true' on success, `false' on error. +Possible error returns are: + + * `bfd_error_no_memory' - Not enough memory exists to create private + data for OSEC. + + #define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ + BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ + (ibfd, isymbol, obfd, osymbol)) + + +File: bfd.info, Node: Archives, Next: Formats, Prev: Symbols, Up: BFD front end + +Archives +======== + + *Description* +An archive (or library) is just another BFD. It has a symbol table, +although there's not much a user program will do with it. + + The big difference between an archive BFD and an ordinary BFD is +that the archive doesn't have sections. Instead it has a chain of BFDs +that are considered its contents. These BFDs can be manipulated like +any other. The BFDs contained in an archive opened for reading will +all be opened for reading. You may put either input or output BFDs +into an archive opened for output; they will be handled correctly when +the archive is closed. + + Use `bfd_openr_next_archived_file' to step through the contents of +an archive opened for input. You don't have to read the entire archive +if you don't want to! Read it until you find what you want. + + Archive contents of output BFDs are chained through the `next' +pointer in a BFD. The first one is findable through the `archive_head' +slot of the archive. Set it with `bfd_set_archive_head' (q.v.). A +given BFD may be in only one open output archive at a time. + + As expected, the BFD archive code is more general than the archive +code of any given environment. BFD archives may contain files of +different formats (e.g., a.out and coff) and even different +architectures. You may even place archives recursively into archives! + + This can cause unexpected confusion, since some archive formats are +more expressive than others. For instance, Intel COFF archives can +preserve long filenames; SunOS a.out archives cannot. If you move a +file from the first to the second format and back again, the filename +may be truncated. Likewise, different a.out environments have different +conventions as to how they truncate filenames, whether they preserve +directory names in filenames, etc. When interoperating with native +tools, be sure your files are homogeneous. + + Beware: most of these formats do not react well to the presence of +spaces in filenames. We do the best we can, but can't always handle +this case due to restrictions in the format of archives. Many Unix +utilities are braindead in regards to spaces and such in filenames +anyway, so this shouldn't be much of a restriction. + + Archives are supported in BFD in `archive.c'. + +`bfd_get_next_mapent' +..................... + + *Synopsis* + symindex bfd_get_next_mapent(bfd *abfd, symindex previous, carsym **sym); + *Description* +Step through archive ABFD's symbol table (if it has one). Successively +update SYM with the next symbol's information, returning that symbol's +(internal) index into the symbol table. + + Supply `BFD_NO_MORE_SYMBOLS' as the PREVIOUS entry to get the first +one; returns `BFD_NO_MORE_SYMBOLS' when you've already got the last one. + + A `carsym' is a canonical archive symbol. The only user-visible +element is its name, a null-terminated string. + +`bfd_set_archive_head' +...................... + + *Synopsis* + boolean bfd_set_archive_head(bfd *output, bfd *new_head); + *Description* +Set the head of the chain of BFDs contained in the archive OUTPUT to +NEW_HEAD. + +`bfd_openr_next_archived_file' +.............................. + + *Synopsis* + bfd *bfd_openr_next_archived_file(bfd *archive, bfd *previous); + *Description* +Provided a BFD, ARCHIVE, containing an archive and NULL, open an input +BFD on the first contained element and returns that. Subsequent calls +should pass the archive and the previous return value to return a +created BFD to the next contained element. NULL is returned when there +are no more. + + +File: bfd.info, Node: Formats, Next: Relocations, Prev: Archives, Up: BFD front end + +File formats +============ + + A format is a BFD concept of high level file contents type. The +formats supported by BFD are: + + * `bfd_object' + The BFD may contain data, symbols, relocations and debug info. + + * `bfd_archive' + The BFD contains other BFDs and an optional index. + + * `bfd_core' + The BFD contains the result of an executable core dump. + +`bfd_check_format' +.................. + + *Synopsis* + boolean bfd_check_format(bfd *abfd, bfd_format format); + *Description* +Verify if the file attached to the BFD ABFD is compatible with the +format FORMAT (i.e., one of `bfd_object', `bfd_archive' or `bfd_core'). + + If the BFD has been set to a specific target before the call, only +the named target and format combination is checked. If the target has +not been set, or has been set to `default', then all the known target +backends is interrogated to determine a match. If the default target +matches, it is used. If not, exactly one target must recognize the +file, or an error results. + + The function returns `true' on success, otherwise `false' with one +of the following error codes: + + * `bfd_error_invalid_operation' - if `format' is not one of + `bfd_object', `bfd_archive' or `bfd_core'. + + * `bfd_error_system_call' - if an error occured during a read - even + some file mismatches can cause bfd_error_system_calls. + + * `file_not_recognised' - none of the backends recognised the file + format. + + * `bfd_error_file_ambiguously_recognized' - more than one backend + recognised the file format. + +`bfd_check_format_matches' +.......................... + + *Synopsis* + boolean bfd_check_format_matches(bfd *abfd, bfd_format format, char ***matching); + *Description* +Like `bfd_check_format', except when it returns false with `bfd_errno' +set to `bfd_error_file_ambiguously_recognized'. In that case, if +MATCHING is not NULL, it will be filled in with a NULL-terminated list +of the names of the formats that matched, allocated with `malloc'. +Then the user may choose a format and try again. + + When done with the list that MATCHING points to, the caller should +free it. + +`bfd_set_format' +................ + + *Synopsis* + boolean bfd_set_format(bfd *abfd, bfd_format format); + *Description* +This function sets the file format of the BFD ABFD to the format +FORMAT. If the target set in the BFD does not support the format +requested, the format is invalid, or the BFD is not open for writing, +then an error occurs. + +`bfd_format_string' +................... + + *Synopsis* + CONST char *bfd_format_string(bfd_format format); + *Description* +Return a pointer to a const string `invalid', `object', `archive', +`core', or `unknown', depending upon the value of FORMAT. + + +File: bfd.info, Node: Relocations, Next: Core Files, Prev: Formats, Up: BFD front end + +Relocations +=========== + + BFD maintains relocations in much the same way it maintains symbols: +they are left alone until required, then read in en-masse and +translated into an internal form. A common routine +`bfd_perform_relocation' acts upon the canonical form to do the fixup. + + Relocations are maintained on a per section basis, while symbols are +maintained on a per BFD basis. + + All that a back end has to do to fit the BFD interface is to create +a `struct reloc_cache_entry' for each relocation in a particular +section, and fill in the right bits of the structures. + +* Menu: + +* typedef arelent:: +* howto manager:: + diff --git a/bfd/doc/bfd.info-3 b/bfd/doc/bfd.info-3 new file mode 100644 index 00000000000..ec7f35135b9 --- /dev/null +++ b/bfd/doc/bfd.info-3 @@ -0,0 +1,1297 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: bfd.info, Node: typedef arelent, Next: howto manager, Prev: Relocations, Up: Relocations + +typedef arelent +--------------- + + This is the structure of a relocation entry: + + + typedef enum bfd_reloc_status + { + /* No errors detected */ + bfd_reloc_ok, + + /* The relocation was performed, but there was an overflow. */ + bfd_reloc_overflow, + + /* The address to relocate was not within the section supplied. */ + bfd_reloc_outofrange, + + /* Used by special functions */ + bfd_reloc_continue, + + /* Unsupported relocation size requested. */ + bfd_reloc_notsupported, + + /* Unused */ + bfd_reloc_other, + + /* The symbol to relocate against was undefined. */ + bfd_reloc_undefined, + + /* The relocation was performed, but may not be ok - presently + generated only when linking i960 coff files with i960 b.out + symbols. If this type is returned, the error_message argument + to bfd_perform_relocation will be set. */ + bfd_reloc_dangerous + } + bfd_reloc_status_type; + + + typedef struct reloc_cache_entry + { + /* A pointer into the canonical table of pointers */ + struct symbol_cache_entry **sym_ptr_ptr; + + /* offset in section */ + bfd_size_type address; + + /* addend for relocation value */ + bfd_vma addend; + + /* Pointer to how to perform the required relocation */ + reloc_howto_type *howto; + + } arelent; + *Description* +Here is a description of each of the fields within an `arelent': + + * `sym_ptr_ptr' + The symbol table pointer points to a pointer to the symbol +associated with the relocation request. It is the pointer into the +table returned by the back end's `get_symtab' action. *Note Symbols::. +The symbol is referenced through a pointer to a pointer so that tools +like the linker can fix up all the symbols of the same name by +modifying only one pointer. The relocation routine looks in the symbol +and uses the base of the section the symbol is attached to and the +value of the symbol as the initial relocation offset. If the symbol +pointer is zero, then the section provided is looked up. + + * `address' + The `address' field gives the offset in bytes from the base of the +section data which owns the relocation record to the first byte of +relocatable information. The actual data relocated will be relative to +this point; for example, a relocation type which modifies the bottom +two bytes of a four byte word would not touch the first byte pointed to +in a big endian world. + + * `addend' + The `addend' is a value provided by the back end to be added (!) to +the relocation offset. Its interpretation is dependent upon the howto. +For example, on the 68k the code: + + char foo[]; + main() + { + return foo[0x12345678]; + } + + Could be compiled into: + + linkw fp,#-4 + moveb @#12345678,d0 + extbl d0 + unlk fp + rts + + This could create a reloc pointing to `foo', but leave the offset in +the data, something like: + + RELOCATION RECORDS FOR [.text]: + offset type value + 00000006 32 _foo + + 00000000 4e56 fffc ; linkw fp,#-4 + 00000004 1039 1234 5678 ; moveb @#12345678,d0 + 0000000a 49c0 ; extbl d0 + 0000000c 4e5e ; unlk fp + 0000000e 4e75 ; rts + + Using coff and an 88k, some instructions don't have enough space in +them to represent the full address range, and pointers have to be +loaded in two parts. So you'd get something like: + + or.u r13,r0,hi16(_foo+0x12345678) + ld.b r2,r13,lo16(_foo+0x12345678) + jmp r1 + + This should create two relocs, both pointing to `_foo', and with +0x12340000 in their addend field. The data would consist of: + + RELOCATION RECORDS FOR [.text]: + offset type value + 00000002 HVRT16 _foo+0x12340000 + 00000006 LVRT16 _foo+0x12340000 + + 00000000 5da05678 ; or.u r13,r0,0x5678 + 00000004 1c4d5678 ; ld.b r2,r13,0x5678 + 00000008 f400c001 ; jmp r1 + + The relocation routine digs out the value from the data, adds it to +the addend to get the original offset, and then adds the value of +`_foo'. Note that all 32 bits have to be kept around somewhere, to cope +with carry from bit 15 to bit 16. + + One further example is the sparc and the a.out format. The sparc has +a similar problem to the 88k, in that some instructions don't have room +for an entire offset, but on the sparc the parts are created in odd +sized lumps. The designers of the a.out format chose to not use the +data within the section for storing part of the offset; all the offset +is kept within the reloc. Anything in the data should be ignored. + + save %sp,-112,%sp + sethi %hi(_foo+0x12345678),%g2 + ldsb [%g2+%lo(_foo+0x12345678)],%i0 + ret + restore + + Both relocs contain a pointer to `foo', and the offsets contain junk. + + RELOCATION RECORDS FOR [.text]: + offset type value + 00000004 HI22 _foo+0x12345678 + 00000008 LO10 _foo+0x12345678 + + 00000000 9de3bf90 ; save %sp,-112,%sp + 00000004 05000000 ; sethi %hi(_foo+0),%g2 + 00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0 + 0000000c 81c7e008 ; ret + 00000010 81e80000 ; restore + + * `howto' + The `howto' field can be imagined as a relocation instruction. It is +a pointer to a structure which contains information on what to do with +all of the other information in the reloc record and data section. A +back end would normally have a relocation instruction set and turn +relocations into pointers to the correct structure on input - but it +would be possible to create each howto field on demand. + +`enum complain_overflow' +........................ + + Indicates what sort of overflow checking should be done when +performing a relocation. + + + enum complain_overflow + { + /* Do not complain on overflow. */ + complain_overflow_dont, + + /* Complain if the bitfield overflows, whether it is considered + as signed or unsigned. */ + complain_overflow_bitfield, + + /* Complain if the value overflows when considered as signed + number. */ + complain_overflow_signed, + + /* Complain if the value overflows when considered as an + unsigned number. */ + complain_overflow_unsigned + }; + +`reloc_howto_type' +.................. + + The `reloc_howto_type' is a structure which contains all the +information that libbfd needs to know to tie up a back end's data. + + struct symbol_cache_entry; /* Forward declaration */ + + struct reloc_howto_struct + { + /* The type field has mainly a documentary use - the back end can + do what it wants with it, though normally the back end's + external idea of what a reloc number is stored + in this field. For example, a PC relative word relocation + in a coff environment has the type 023 - because that's + what the outside world calls a R_PCRWORD reloc. */ + unsigned int type; + + /* The value the final relocation is shifted right by. This drops + unwanted data from the relocation. */ + unsigned int rightshift; + + /* The size of the item to be relocated. This is *not* a + power-of-two measure. To get the number of bytes operated + on by a type of relocation, use bfd_get_reloc_size. */ + int size; + + /* The number of bits in the item to be relocated. This is used + when doing overflow checking. */ + unsigned int bitsize; + + /* Notes that the relocation is relative to the location in the + data section of the addend. The relocation function will + subtract from the relocation value the address of the location + being relocated. */ + boolean pc_relative; + + /* The bit position of the reloc value in the destination. + The relocated value is left shifted by this amount. */ + unsigned int bitpos; + + /* What type of overflow error should be checked for when + relocating. */ + enum complain_overflow complain_on_overflow; + + /* If this field is non null, then the supplied function is + called rather than the normal function. This allows really + strange relocation methods to be accomodated (e.g., i960 callj + instructions). */ + bfd_reloc_status_type (*special_function) + PARAMS ((bfd *abfd, + arelent *reloc_entry, + struct symbol_cache_entry *symbol, + PTR data, + asection *input_section, + bfd *output_bfd, + char **error_message)); + + /* The textual name of the relocation type. */ + char *name; + + /* Some formats record a relocation addend in the section contents + rather than with the relocation. For ELF formats this is the + distinction between USE_REL and USE_RELA (though the code checks + for USE_REL == 1/0). The value of this field is TRUE if the + addend is recorded with the section contents; when performing a + partial link (ld -r) the section contents (the data) will be + modified. The value of this field is FALSE if addends are + recorded with the relocation (in arelent.addend); when performing + a partial link the relocation will be modified. + All relocations for all ELF USE_RELA targets should set this field + to FALSE (values of TRUE should be looked on with suspicion). + However, the converse is not true: not all relocations of all ELF + USE_REL targets set this field to TRUE. Why this is so is peculiar + to each particular target. For relocs that aren't used in partial + links (e.g. GOT stuff) it doesn't matter what this is set to. */ + boolean partial_inplace; + + /* The src_mask selects which parts of the read in data + are to be used in the relocation sum. E.g., if this was an 8 bit + byte of data which we read and relocated, this would be + 0x000000ff. When we have relocs which have an addend, such as + sun4 extended relocs, the value in the offset part of a + relocating field is garbage so we never use it. In this case + the mask would be 0x00000000. */ + bfd_vma src_mask; + + /* The dst_mask selects which parts of the instruction are replaced + into the instruction. In most cases src_mask == dst_mask, + except in the above special case, where dst_mask would be + 0x000000ff, and src_mask would be 0x00000000. */ + bfd_vma dst_mask; + + /* When some formats create PC relative instructions, they leave + the value of the pc of the place being relocated in the offset + slot of the instruction, so that a PC relative relocation can + be made just by adding in an ordinary offset (e.g., sun3 a.out). + Some formats leave the displacement part of an instruction + empty (e.g., m88k bcs); this flag signals the fact.*/ + boolean pcrel_offset; + + }; + +`The HOWTO Macro' +................. + + *Description* +The HOWTO define is horrible and will go away. + #define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ + {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC} + + *Description* +And will be replaced with the totally magic way. But for the moment, we +are compatible, so do it this way. + #define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN) + + *Description* +This is used to fill in an empty howto entry in an array. + #define EMPTY_HOWTO(C) \ + HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false) + + *Description* +Helper routine to turn a symbol into a relocation value. + #define HOWTO_PREPARE(relocation, symbol) \ + { \ + if (symbol != (asymbol *)NULL) { \ + if (bfd_is_com_section (symbol->section)) { \ + relocation = 0; \ + } \ + else { \ + relocation = symbol->value; \ + } \ + } \ + } + +`bfd_get_reloc_size' +.................... + + *Synopsis* + unsigned int bfd_get_reloc_size (reloc_howto_type *); + *Description* +For a reloc_howto_type that operates on a fixed number of bytes, this +returns the number of bytes operated on. + +`arelent_chain' +............... + + *Description* +How relocs are tied together in an `asection': + typedef struct relent_chain { + arelent relent; + struct relent_chain *next; + } arelent_chain; + +`bfd_check_overflow' +.................... + + *Synopsis* + bfd_reloc_status_type + bfd_check_overflow + (enum complain_overflow how, + unsigned int bitsize, + unsigned int rightshift, + unsigned int addrsize, + bfd_vma relocation); + *Description* +Perform overflow checking on RELOCATION which has BITSIZE significant +bits and will be shifted right by RIGHTSHIFT bits, on a machine with +addresses containing ADDRSIZE significant bits. The result is either of +`bfd_reloc_ok' or `bfd_reloc_overflow'. + +`bfd_perform_relocation' +........................ + + *Synopsis* + bfd_reloc_status_type + bfd_perform_relocation + (bfd *abfd, + arelent *reloc_entry, + PTR data, + asection *input_section, + bfd *output_bfd, + char **error_message); + *Description* +If OUTPUT_BFD is supplied to this function, the generated image will be +relocatable; the relocations are copied to the output file after they +have been changed to reflect the new state of the world. There are two +ways of reflecting the results of partial linkage in an output file: by +modifying the output data in place, and by modifying the relocation +record. Some native formats (e.g., basic a.out and basic coff) have no +way of specifying an addend in the relocation type, so the addend has +to go in the output data. This is no big deal since in these formats +the output data slot will always be big enough for the addend. Complex +reloc types with addends were invented to solve just this problem. The +ERROR_MESSAGE argument is set to an error message if this return +`bfd_reloc_dangerous'. + +`bfd_install_relocation' +........................ + + *Synopsis* + bfd_reloc_status_type + bfd_install_relocation + (bfd *abfd, + arelent *reloc_entry, + PTR data, bfd_vma data_start, + asection *input_section, + char **error_message); + *Description* +This looks remarkably like `bfd_perform_relocation', except it does not +expect that the section contents have been filled in. I.e., it's +suitable for use when creating, rather than applying a relocation. + + For now, this function should be considered reserved for the +assembler. + + +File: bfd.info, Node: howto manager, Prev: typedef arelent, Up: Relocations + +The howto manager +================= + + When an application wants to create a relocation, but doesn't know +what the target machine might call it, it can find out by using this +bit of code. + +`bfd_reloc_code_type' +..................... + + *Description* +The insides of a reloc code. The idea is that, eventually, there will +be one enumerator for every type of relocation we ever do. Pass one of +these values to `bfd_reloc_type_lookup', and it'll return a howto +pointer. + + This does mean that the application must determine the correct +enumerator value; you can't get a howto pointer from a random set of +attributes. + + Here are the possible values for `enum bfd_reloc_code_real': + + - : BFD_RELOC_64 + - : BFD_RELOC_32 + - : BFD_RELOC_26 + - : BFD_RELOC_24 + - : BFD_RELOC_16 + - : BFD_RELOC_14 + - : BFD_RELOC_8 + Basic absolute relocations of N bits. + + - : BFD_RELOC_64_PCREL + - : BFD_RELOC_32_PCREL + - : BFD_RELOC_24_PCREL + - : BFD_RELOC_16_PCREL + - : BFD_RELOC_12_PCREL + - : BFD_RELOC_8_PCREL + PC-relative relocations. Sometimes these are relative to the + address of the relocation itself; sometimes they are relative to + the start of the section containing the relocation. It depends on + the specific target. + + The 24-bit relocation is used in some Intel 960 configurations. + + - : BFD_RELOC_32_GOT_PCREL + - : BFD_RELOC_16_GOT_PCREL + - : BFD_RELOC_8_GOT_PCREL + - : BFD_RELOC_32_GOTOFF + - : BFD_RELOC_16_GOTOFF + - : BFD_RELOC_LO16_GOTOFF + - : BFD_RELOC_HI16_GOTOFF + - : BFD_RELOC_HI16_S_GOTOFF + - : BFD_RELOC_8_GOTOFF + - : BFD_RELOC_32_PLT_PCREL + - : BFD_RELOC_24_PLT_PCREL + - : BFD_RELOC_16_PLT_PCREL + - : BFD_RELOC_8_PLT_PCREL + - : BFD_RELOC_32_PLTOFF + - : BFD_RELOC_16_PLTOFF + - : BFD_RELOC_LO16_PLTOFF + - : BFD_RELOC_HI16_PLTOFF + - : BFD_RELOC_HI16_S_PLTOFF + - : BFD_RELOC_8_PLTOFF + For ELF. + + - : BFD_RELOC_68K_GLOB_DAT + - : BFD_RELOC_68K_JMP_SLOT + - : BFD_RELOC_68K_RELATIVE + Relocations used by 68K ELF. + + - : BFD_RELOC_32_BASEREL + - : BFD_RELOC_16_BASEREL + - : BFD_RELOC_LO16_BASEREL + - : BFD_RELOC_HI16_BASEREL + - : BFD_RELOC_HI16_S_BASEREL + - : BFD_RELOC_8_BASEREL + - : BFD_RELOC_RVA + Linkage-table relative. + + - : BFD_RELOC_8_FFnn + Absolute 8-bit relocation, but used to form an address like 0xFFnn. + + - : BFD_RELOC_32_PCREL_S2 + - : BFD_RELOC_16_PCREL_S2 + - : BFD_RELOC_23_PCREL_S2 + These PC-relative relocations are stored as word displacements - + i.e., byte displacements shifted right two bits. The 30-bit word + displacement (<<32_PCREL_S2>> - 32 bits, shifted 2) is used on the + SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The + signed 16-bit displacement is used on the MIPS, and the 23-bit + displacement is used on the Alpha. + + - : BFD_RELOC_HI22 + - : BFD_RELOC_LO10 + High 22 bits and low 10 bits of 32-bit value, placed into lower + bits of the target word. These are used on the SPARC. + + - : BFD_RELOC_GPREL16 + - : BFD_RELOC_GPREL32 + For systems that allocate a Global Pointer register, these are + displacements off that register. These relocation types are + handled specially, because the value the register will have is + decided relatively late. + + - : BFD_RELOC_I960_CALLJ + Reloc types used for i960/b.out. + + - : BFD_RELOC_NONE + - : BFD_RELOC_SPARC_WDISP22 + - : BFD_RELOC_SPARC22 + - : BFD_RELOC_SPARC13 + - : BFD_RELOC_SPARC_GOT10 + - : BFD_RELOC_SPARC_GOT13 + - : BFD_RELOC_SPARC_GOT22 + - : BFD_RELOC_SPARC_PC10 + - : BFD_RELOC_SPARC_PC22 + - : BFD_RELOC_SPARC_WPLT30 + - : BFD_RELOC_SPARC_COPY + - : BFD_RELOC_SPARC_GLOB_DAT + - : BFD_RELOC_SPARC_JMP_SLOT + - : BFD_RELOC_SPARC_RELATIVE + - : BFD_RELOC_SPARC_UA32 + SPARC ELF relocations. There is probably some overlap with other + relocation types already defined. + + - : BFD_RELOC_SPARC_BASE13 + - : BFD_RELOC_SPARC_BASE22 + I think these are specific to SPARC a.out (e.g., Sun 4). + + - : BFD_RELOC_SPARC_64 + - : BFD_RELOC_SPARC_10 + - : BFD_RELOC_SPARC_11 + - : BFD_RELOC_SPARC_OLO10 + - : BFD_RELOC_SPARC_HH22 + - : BFD_RELOC_SPARC_HM10 + - : BFD_RELOC_SPARC_LM22 + - : BFD_RELOC_SPARC_PC_HH22 + - : BFD_RELOC_SPARC_PC_HM10 + - : BFD_RELOC_SPARC_PC_LM22 + - : BFD_RELOC_SPARC_WDISP16 + - : BFD_RELOC_SPARC_WDISP19 + - : BFD_RELOC_SPARC_7 + - : BFD_RELOC_SPARC_6 + - : BFD_RELOC_SPARC_5 + - : BFD_RELOC_SPARC_DISP64 + - : BFD_RELOC_SPARC_PLT64 + - : BFD_RELOC_SPARC_HIX22 + - : BFD_RELOC_SPARC_LOX10 + - : BFD_RELOC_SPARC_H44 + - : BFD_RELOC_SPARC_M44 + - : BFD_RELOC_SPARC_L44 + - : BFD_RELOC_SPARC_REGISTER + SPARC64 relocations + + - : BFD_RELOC_SPARC_REV32 + SPARC little endian relocation + + - : BFD_RELOC_ALPHA_GPDISP_HI16 + Alpha ECOFF and ELF relocations. Some of these treat the symbol or + "addend" in some special way. For GPDISP_HI16 ("gpdisp") + relocations, the symbol is ignored when writing; when reading, it + will be the absolute section symbol. The addend is the + displacement in bytes of the "lda" instruction from the "ldah" + instruction (which is at the address of this reloc). + + - : BFD_RELOC_ALPHA_GPDISP_LO16 + For GPDISP_LO16 ("ignore") relocations, the symbol is handled as + with GPDISP_HI16 relocs. The addend is ignored when writing the + relocations out, and is filled in with the file's GP value on + reading, for convenience. + + - : BFD_RELOC_ALPHA_GPDISP + The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 + relocation except that there is no accompanying GPDISP_LO16 + relocation. + + - : BFD_RELOC_ALPHA_LITERAL + - : BFD_RELOC_ALPHA_ELF_LITERAL + - : BFD_RELOC_ALPHA_LITUSE + The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; + the assembler turns it into a LDQ instruction to load the address + of the symbol, and then fills in a register in the real + instruction. + + The LITERAL reloc, at the LDQ instruction, refers to the .lita + section symbol. The addend is ignored when writing, but is filled + in with the file's GP value on reading, for convenience, as with + the GPDISP_LO16 reloc. + + The ELF_LITERAL reloc is somewhere between 16_GOTOFF and + GPDISP_LO16. It should refer to the symbol to be referenced, as + with 16_GOTOFF, but it generates output not based on the position + within the .got section, but relative to the GP value chosen for + the file during the final link stage. + + The LITUSE reloc, on the instruction using the loaded address, + gives information to the linker that it might be able to use to + optimize away some literal section references. The symbol is + ignored (read as the absolute section symbol), and the "addend" + indicates the type of instruction using the register: 1 - "memory" + fmt insn 2 - byte-manipulation (byte offset reg) 3 - jsr (target + of branch) + + The GNU linker currently doesn't do any of this optimizing. + + - : BFD_RELOC_ALPHA_USER_LITERAL + - : BFD_RELOC_ALPHA_USER_LITUSE_BASE + - : BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF + - : BFD_RELOC_ALPHA_USER_LITUSE_JSR + - : BFD_RELOC_ALPHA_USER_GPDISP + - : BFD_RELOC_ALPHA_USER_GPRELHIGH + - : BFD_RELOC_ALPHA_USER_GPRELLOW + The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to + process the explicit !<reloc>!sequence relocations, and are mapped + into the normal relocations at the end of processing. + + - : BFD_RELOC_ALPHA_HINT + The HINT relocation indicates a value that should be filled into + the "hint" field of a jmp/jsr/ret instruction, for possible branch- + prediction logic which may be provided on some processors. + + - : BFD_RELOC_ALPHA_LINKAGE + The LINKAGE relocation outputs a linkage pair in the object file, + which is filled by the linker. + + - : BFD_RELOC_ALPHA_CODEADDR + The CODEADDR relocation outputs a STO_CA in the object file, which + is filled by the linker. + + - : BFD_RELOC_MIPS_JMP + Bits 27..2 of the relocation address shifted right 2 bits; simple + reloc otherwise. + + - : BFD_RELOC_MIPS16_JMP + The MIPS16 jump instruction. + + - : BFD_RELOC_MIPS16_GPREL + MIPS16 GP relative reloc. + + - : BFD_RELOC_HI16 + High 16 bits of 32-bit value; simple reloc. + + - : BFD_RELOC_HI16_S + High 16 bits of 32-bit value but the low 16 bits will be sign + extended and added to form the final result. If the low 16 bits + form a negative number, we need to add one to the high value to + compensate for the borrow when the low bits are added. + + - : BFD_RELOC_LO16 + Low 16 bits. + + - : BFD_RELOC_PCREL_HI16_S + Like BFD_RELOC_HI16_S, but PC relative. + + - : BFD_RELOC_PCREL_LO16 + Like BFD_RELOC_LO16, but PC relative. + + - : BFD_RELOC_MIPS_GPREL + Relocation relative to the global pointer. + + - : BFD_RELOC_MIPS_LITERAL + Relocation against a MIPS literal section. + + - : BFD_RELOC_MIPS_GOT16 + - : BFD_RELOC_MIPS_CALL16 + - : BFD_RELOC_MIPS_GPREL32 + - : BFD_RELOC_MIPS_GOT_HI16 + - : BFD_RELOC_MIPS_GOT_LO16 + - : BFD_RELOC_MIPS_CALL_HI16 + - : BFD_RELOC_MIPS_CALL_LO16 + - : BFD_RELOC_MIPS_SUB + - : BFD_RELOC_MIPS_GOT_PAGE + - : BFD_RELOC_MIPS_GOT_OFST + - : BFD_RELOC_MIPS_GOT_DISP + MIPS ELF relocations. + + - : BFD_RELOC_386_GOT32 + - : BFD_RELOC_386_PLT32 + - : BFD_RELOC_386_COPY + - : BFD_RELOC_386_GLOB_DAT + - : BFD_RELOC_386_JUMP_SLOT + - : BFD_RELOC_386_RELATIVE + - : BFD_RELOC_386_GOTOFF + - : BFD_RELOC_386_GOTPC + i386/elf relocations + + - : BFD_RELOC_NS32K_IMM_8 + - : BFD_RELOC_NS32K_IMM_16 + - : BFD_RELOC_NS32K_IMM_32 + - : BFD_RELOC_NS32K_IMM_8_PCREL + - : BFD_RELOC_NS32K_IMM_16_PCREL + - : BFD_RELOC_NS32K_IMM_32_PCREL + - : BFD_RELOC_NS32K_DISP_8 + - : BFD_RELOC_NS32K_DISP_16 + - : BFD_RELOC_NS32K_DISP_32 + - : BFD_RELOC_NS32K_DISP_8_PCREL + - : BFD_RELOC_NS32K_DISP_16_PCREL + - : BFD_RELOC_NS32K_DISP_32_PCREL + ns32k relocations + + - : BFD_RELOC_PJ_CODE_HI16 + - : BFD_RELOC_PJ_CODE_LO16 + - : BFD_RELOC_PJ_CODE_DIR16 + - : BFD_RELOC_PJ_CODE_DIR32 + - : BFD_RELOC_PJ_CODE_REL16 + - : BFD_RELOC_PJ_CODE_REL32 + Picojava relocs. Not all of these appear in object files. + + - : BFD_RELOC_PPC_B26 + - : BFD_RELOC_PPC_BA26 + - : BFD_RELOC_PPC_TOC16 + - : BFD_RELOC_PPC_B16 + - : BFD_RELOC_PPC_B16_BRTAKEN + - : BFD_RELOC_PPC_B16_BRNTAKEN + - : BFD_RELOC_PPC_BA16 + - : BFD_RELOC_PPC_BA16_BRTAKEN + - : BFD_RELOC_PPC_BA16_BRNTAKEN + - : BFD_RELOC_PPC_COPY + - : BFD_RELOC_PPC_GLOB_DAT + - : BFD_RELOC_PPC_JMP_SLOT + - : BFD_RELOC_PPC_RELATIVE + - : BFD_RELOC_PPC_LOCAL24PC + - : BFD_RELOC_PPC_EMB_NADDR32 + - : BFD_RELOC_PPC_EMB_NADDR16 + - : BFD_RELOC_PPC_EMB_NADDR16_LO + - : BFD_RELOC_PPC_EMB_NADDR16_HI + - : BFD_RELOC_PPC_EMB_NADDR16_HA + - : BFD_RELOC_PPC_EMB_SDAI16 + - : BFD_RELOC_PPC_EMB_SDA2I16 + - : BFD_RELOC_PPC_EMB_SDA2REL + - : BFD_RELOC_PPC_EMB_SDA21 + - : BFD_RELOC_PPC_EMB_MRKREF + - : BFD_RELOC_PPC_EMB_RELSEC16 + - : BFD_RELOC_PPC_EMB_RELST_LO + - : BFD_RELOC_PPC_EMB_RELST_HI + - : BFD_RELOC_PPC_EMB_RELST_HA + - : BFD_RELOC_PPC_EMB_BIT_FLD + - : BFD_RELOC_PPC_EMB_RELSDA + Power(rs6000) and PowerPC relocations. + + - : BFD_RELOC_I370_D12 + IBM 370/390 relocations + + - : BFD_RELOC_CTOR + The type of reloc used to build a contructor table - at the moment + probably a 32 bit wide absolute relocation, but the target can + choose. It generally does map to one of the other relocation + types. + + - : BFD_RELOC_ARM_PCREL_BRANCH + ARM 26 bit pc-relative branch. The lowest two bits must be zero + and are not stored in the instruction. + + - : BFD_RELOC_ARM_IMMEDIATE + - : BFD_RELOC_ARM_ADRL_IMMEDIATE + - : BFD_RELOC_ARM_OFFSET_IMM + - : BFD_RELOC_ARM_SHIFT_IMM + - : BFD_RELOC_ARM_SWI + - : BFD_RELOC_ARM_MULTI + - : BFD_RELOC_ARM_CP_OFF_IMM + - : BFD_RELOC_ARM_ADR_IMM + - : BFD_RELOC_ARM_LDR_IMM + - : BFD_RELOC_ARM_LITERAL + - : BFD_RELOC_ARM_IN_POOL + - : BFD_RELOC_ARM_OFFSET_IMM8 + - : BFD_RELOC_ARM_HWLITERAL + - : BFD_RELOC_ARM_THUMB_ADD + - : BFD_RELOC_ARM_THUMB_IMM + - : BFD_RELOC_ARM_THUMB_SHIFT + - : BFD_RELOC_ARM_THUMB_OFFSET + - : BFD_RELOC_ARM_GOT12 + - : BFD_RELOC_ARM_GOT32 + - : BFD_RELOC_ARM_JUMP_SLOT + - : BFD_RELOC_ARM_COPY + - : BFD_RELOC_ARM_GLOB_DAT + - : BFD_RELOC_ARM_PLT32 + - : BFD_RELOC_ARM_RELATIVE + - : BFD_RELOC_ARM_GOTOFF + - : BFD_RELOC_ARM_GOTPC + These relocs are only used within the ARM assembler. They are not + (at present) written to any object files. + + - : BFD_RELOC_SH_PCDISP8BY2 + - : BFD_RELOC_SH_PCDISP12BY2 + - : BFD_RELOC_SH_IMM4 + - : BFD_RELOC_SH_IMM4BY2 + - : BFD_RELOC_SH_IMM4BY4 + - : BFD_RELOC_SH_IMM8 + - : BFD_RELOC_SH_IMM8BY2 + - : BFD_RELOC_SH_IMM8BY4 + - : BFD_RELOC_SH_PCRELIMM8BY2 + - : BFD_RELOC_SH_PCRELIMM8BY4 + - : BFD_RELOC_SH_SWITCH16 + - : BFD_RELOC_SH_SWITCH32 + - : BFD_RELOC_SH_USES + - : BFD_RELOC_SH_COUNT + - : BFD_RELOC_SH_ALIGN + - : BFD_RELOC_SH_CODE + - : BFD_RELOC_SH_DATA + - : BFD_RELOC_SH_LABEL + Hitachi SH relocs. Not all of these appear in object files. + + - : BFD_RELOC_THUMB_PCREL_BRANCH9 + - : BFD_RELOC_THUMB_PCREL_BRANCH12 + - : BFD_RELOC_THUMB_PCREL_BRANCH23 + Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must + be zero and is not stored in the instruction. + + - : BFD_RELOC_ARC_B22_PCREL + Argonaut RISC Core (ARC) relocs. ARC 22 bit pc-relative branch. + The lowest two bits must be zero and are not stored in the + instruction. The high 20 bits are installed in bits 26 through 7 + of the instruction. + + - : BFD_RELOC_ARC_B26 + ARC 26 bit absolute branch. The lowest two bits must be zero and + are not stored in the instruction. The high 24 bits are installed + in bits 23 through 0. + + - : BFD_RELOC_D10V_10_PCREL_R + Mitsubishi D10V relocs. This is a 10-bit reloc with the right 2 + bits assumed to be 0. + + - : BFD_RELOC_D10V_10_PCREL_L + Mitsubishi D10V relocs. This is a 10-bit reloc with the right 2 + bits assumed to be 0. This is the same as the previous reloc + except it is in the left container, i.e., shifted left 15 bits. + + - : BFD_RELOC_D10V_18 + This is an 18-bit reloc with the right 2 bits assumed to be 0. + + - : BFD_RELOC_D10V_18_PCREL + This is an 18-bit reloc with the right 2 bits assumed to be 0. + + - : BFD_RELOC_D30V_6 + Mitsubishi D30V relocs. This is a 6-bit absolute reloc. + + - : BFD_RELOC_D30V_9_PCREL + This is a 6-bit pc-relative reloc with the right 3 bits assumed to + be 0. + + - : BFD_RELOC_D30V_9_PCREL_R + This is a 6-bit pc-relative reloc with the right 3 bits assumed to + be 0. Same as the previous reloc but on the right side of the + container. + + - : BFD_RELOC_D30V_15 + This is a 12-bit absolute reloc with the right 3 bitsassumed to be + 0. + + - : BFD_RELOC_D30V_15_PCREL + This is a 12-bit pc-relative reloc with the right 3 bits assumed + to be 0. + + - : BFD_RELOC_D30V_15_PCREL_R + This is a 12-bit pc-relative reloc with the right 3 bits assumed + to be 0. Same as the previous reloc but on the right side of the + container. + + - : BFD_RELOC_D30V_21 + This is an 18-bit absolute reloc with the right 3 bits assumed to + be 0. + + - : BFD_RELOC_D30V_21_PCREL + This is an 18-bit pc-relative reloc with the right 3 bits assumed + to be 0. + + - : BFD_RELOC_D30V_21_PCREL_R + This is an 18-bit pc-relative reloc with the right 3 bits assumed + to be 0. Same as the previous reloc but on the right side of the + container. + + - : BFD_RELOC_D30V_32 + This is a 32-bit absolute reloc. + + - : BFD_RELOC_D30V_32_PCREL + This is a 32-bit pc-relative reloc. + + - : BFD_RELOC_M32R_24 + Mitsubishi M32R relocs. This is a 24 bit absolute address. + + - : BFD_RELOC_M32R_10_PCREL + This is a 10-bit pc-relative reloc with the right 2 bits assumed + to be 0. + + - : BFD_RELOC_M32R_18_PCREL + This is an 18-bit reloc with the right 2 bits assumed to be 0. + + - : BFD_RELOC_M32R_26_PCREL + This is a 26-bit reloc with the right 2 bits assumed to be 0. + + - : BFD_RELOC_M32R_HI16_ULO + This is a 16-bit reloc containing the high 16 bits of an address + used when the lower 16 bits are treated as unsigned. + + - : BFD_RELOC_M32R_HI16_SLO + This is a 16-bit reloc containing the high 16 bits of an address + used when the lower 16 bits are treated as signed. + + - : BFD_RELOC_M32R_LO16 + This is a 16-bit reloc containing the lower 16 bits of an address. + + - : BFD_RELOC_M32R_SDA16 + This is a 16-bit reloc containing the small data area offset for + use in add3, load, and store instructions. + + - : BFD_RELOC_V850_9_PCREL + This is a 9-bit reloc + + - : BFD_RELOC_V850_22_PCREL + This is a 22-bit reloc + + - : BFD_RELOC_V850_SDA_16_16_OFFSET + This is a 16 bit offset from the short data area pointer. + + - : BFD_RELOC_V850_SDA_15_16_OFFSET + This is a 16 bit offset (of which only 15 bits are used) from the + short data area pointer. + + - : BFD_RELOC_V850_ZDA_16_16_OFFSET + This is a 16 bit offset from the zero data area pointer. + + - : BFD_RELOC_V850_ZDA_15_16_OFFSET + This is a 16 bit offset (of which only 15 bits are used) from the + zero data area pointer. + + - : BFD_RELOC_V850_TDA_6_8_OFFSET + This is an 8 bit offset (of which only 6 bits are used) from the + tiny data area pointer. + + - : BFD_RELOC_V850_TDA_7_8_OFFSET + This is an 8bit offset (of which only 7 bits are used) from the + tiny data area pointer. + + - : BFD_RELOC_V850_TDA_7_7_OFFSET + This is a 7 bit offset from the tiny data area pointer. + + - : BFD_RELOC_V850_TDA_16_16_OFFSET + This is a 16 bit offset from the tiny data area pointer. + + - : BFD_RELOC_V850_TDA_4_5_OFFSET + This is a 5 bit offset (of which only 4 bits are used) from the + tiny data area pointer. + + - : BFD_RELOC_V850_TDA_4_4_OFFSET + This is a 4 bit offset from the tiny data area pointer. + + - : BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET + This is a 16 bit offset from the short data area pointer, with the + bits placed non-contigously in the instruction. + + - : BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET + This is a 16 bit offset from the zero data area pointer, with the + bits placed non-contigously in the instruction. + + - : BFD_RELOC_V850_CALLT_6_7_OFFSET + This is a 6 bit offset from the call table base pointer. + + - : BFD_RELOC_V850_CALLT_16_16_OFFSET + This is a 16 bit offset from the call table base pointer. + + - : BFD_RELOC_MN10300_32_PCREL + This is a 32bit pcrel reloc for the mn10300, offset by two bytes + in the instruction. + + - : BFD_RELOC_MN10300_16_PCREL + This is a 16bit pcrel reloc for the mn10300, offset by two bytes + in the instruction. + + - : BFD_RELOC_TIC30_LDP + This is a 8bit DP reloc for the tms320c30, where the most + significant 8 bits of a 24 bit word are placed into the least + significant 8 bits of the opcode. + + - : BFD_RELOC_FR30_48 + This is a 48 bit reloc for the FR30 that stores 32 bits. + + - : BFD_RELOC_FR30_20 + This is a 32 bit reloc for the FR30 that stores 20 bits split up + into two sections. + + - : BFD_RELOC_FR30_6_IN_4 + This is a 16 bit reloc for the FR30 that stores a 6 bit word + offset in 4 bits. + + - : BFD_RELOC_FR30_8_IN_8 + This is a 16 bit reloc for the FR30 that stores an 8 bit byte + offset into 8 bits. + + - : BFD_RELOC_FR30_9_IN_8 + This is a 16 bit reloc for the FR30 that stores a 9 bit short + offset into 8 bits. + + - : BFD_RELOC_FR30_10_IN_8 + This is a 16 bit reloc for the FR30 that stores a 10 bit word + offset into 8 bits. + + - : BFD_RELOC_FR30_9_PCREL + This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative + short offset into 8 bits. + + - : BFD_RELOC_FR30_12_PCREL + This is a 16 bit reloc for the FR30 that stores a 12 bit pc + relative short offset into 11 bits. + + - : BFD_RELOC_MCORE_PCREL_IMM8BY4 + - : BFD_RELOC_MCORE_PCREL_IMM11BY2 + - : BFD_RELOC_MCORE_PCREL_IMM4BY2 + - : BFD_RELOC_MCORE_PCREL_32 + - : BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2 + - : BFD_RELOC_MCORE_RVA + Motorola Mcore relocations. + + - : BFD_RELOC_AVR_7_PCREL + This is a 16 bit reloc for the AVR that stores 8 bit pc relative + short offset into 7 bits. + + - : BFD_RELOC_AVR_13_PCREL + This is a 16 bit reloc for the AVR that stores 13 bit pc relative + short offset into 12 bits. + + - : BFD_RELOC_AVR_16_PM + This is a 16 bit reloc for the AVR that stores 17 bit value + (usually program memory address) into 16 bits. + + - : BFD_RELOC_AVR_LO8_LDI + This is a 16 bit reloc for the AVR that stores 8 bit value (usually + data memory address) into 8 bit immediate value of LDI insn. + + - : BFD_RELOC_AVR_HI8_LDI + This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 + bit of data memory address) into 8 bit immediate value of LDI insn. + + - : BFD_RELOC_AVR_HH8_LDI + This is a 16 bit reloc for the AVR that stores 8 bit value (most + high 8 bit of program memory address) into 8 bit immediate value + of LDI insn. + + - : BFD_RELOC_AVR_LO8_LDI_NEG + This is a 16 bit reloc for the AVR that stores negated 8 bit value + (usually data memory address) into 8 bit immediate value of SUBI + insn. + + - : BFD_RELOC_AVR_HI8_LDI_NEG + This is a 16 bit reloc for the AVR that stores negated 8 bit value + (high 8 bit of data memory address) into 8 bit immediate value of + SUBI insn. + + - : BFD_RELOC_AVR_HH8_LDI_NEG + This is a 16 bit reloc for the AVR that stores negated 8 bit value + (most high 8 bit of program memory address) into 8 bit immediate + value of LDI or SUBI insn. + + - : BFD_RELOC_AVR_LO8_LDI_PM + This is a 16 bit reloc for the AVR that stores 8 bit value (usually + command address) into 8 bit immediate value of LDI insn. + + - : BFD_RELOC_AVR_HI8_LDI_PM + This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 + bit of command address) into 8 bit immediate value of LDI insn. + + - : BFD_RELOC_AVR_HH8_LDI_PM + This is a 16 bit reloc for the AVR that stores 8 bit value (most + high 8 bit of command address) into 8 bit immediate value of LDI + insn. + + - : BFD_RELOC_AVR_LO8_LDI_PM_NEG + This is a 16 bit reloc for the AVR that stores negated 8 bit value + (usually command address) into 8 bit immediate value of SUBI insn. + + - : BFD_RELOC_AVR_HI8_LDI_PM_NEG + This is a 16 bit reloc for the AVR that stores negated 8 bit value + (high 8 bit of 16 bit command address) into 8 bit immediate value + of SUBI insn. + + - : BFD_RELOC_AVR_HH8_LDI_PM_NEG + This is a 16 bit reloc for the AVR that stores negated 8 bit value + (high 6 bit of 22 bit command address) into 8 bit immediate value + of SUBI insn. + + - : BFD_RELOC_AVR_CALL + This is a 32 bit reloc for the AVR that stores 23 bit value into + 22 bits. + + - : BFD_RELOC_VTABLE_INHERIT + - : BFD_RELOC_VTABLE_ENTRY + These two relocations are used by the linker to determine which of + the entries in a C++ virtual function table are actually used. + When the -gc-sections option is given, the linker will zero out + the entries that are not used, so that the code for those + functions need not be included in the output. + + VTABLE_INHERIT is a zero-space relocation used to describe to the + linker the inheritence tree of a C++ virtual function table. The + relocation's symbol should be the parent class' vtable, and the + relocation should be located at the child vtable. + + VTABLE_ENTRY is a zero-space relocation that describes the use of a + virtual function table entry. The reloc's symbol should refer to + the table of the class mentioned in the code. Off of that base, + an offset describes the entry that is being used. For Rela hosts, + this offset is stored in the reloc's addend. For Rel hosts, we + are forced to put this offset in the reloc's section offset. + + + typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; + +`bfd_reloc_type_lookup' +....................... + + *Synopsis* + reloc_howto_type * + bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code); + *Description* +Return a pointer to a howto structure which, when invoked, will perform +the relocation CODE on data from the architecture noted. + +`bfd_default_reloc_type_lookup' +............................... + + *Synopsis* + reloc_howto_type *bfd_default_reloc_type_lookup + (bfd *abfd, bfd_reloc_code_real_type code); + *Description* +Provides a default relocation lookup routine for any architecture. + +`bfd_get_reloc_code_name' +......................... + + *Synopsis* + const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); + *Description* +Provides a printable name for the supplied relocation code. Useful +mainly for printing error messages. + +`bfd_generic_relax_section' +........................... + + *Synopsis* + boolean bfd_generic_relax_section + (bfd *abfd, + asection *section, + struct bfd_link_info *, + boolean *); + *Description* +Provides default handling for relaxing for back ends which don't do +relaxing - i.e., does nothing. + +`bfd_generic_gc_sections' +......................... + + *Synopsis* + boolean bfd_generic_gc_sections + (bfd *, struct bfd_link_info *); + *Description* +Provides default handling for relaxing for back ends which don't do +section gc - i.e., does nothing. + +`bfd_generic_get_relocated_section_contents' +............................................ + + *Synopsis* + bfd_byte * + bfd_generic_get_relocated_section_contents (bfd *abfd, + struct bfd_link_info *link_info, + struct bfd_link_order *link_order, + bfd_byte *data, + boolean relocateable, + asymbol **symbols); + *Description* +Provides default handling of relocation effort for back ends which +can't be bothered to do it efficiently. + + +File: bfd.info, Node: Core Files, Next: Targets, Prev: Relocations, Up: BFD front end + +Core files +========== + + *Description* +These are functions pertaining to core files. + +`bfd_core_file_failing_command' +............................... + + *Synopsis* + CONST char *bfd_core_file_failing_command(bfd *abfd); + *Description* +Return a read-only string explaining which program was running when it +failed and produced the core file ABFD. + +`bfd_core_file_failing_signal' +.............................. + + *Synopsis* + int bfd_core_file_failing_signal(bfd *abfd); + *Description* +Returns the signal number which caused the core dump which generated +the file the BFD ABFD is attached to. + +`core_file_matches_executable_p' +................................ + + *Synopsis* + boolean core_file_matches_executable_p + (bfd *core_bfd, bfd *exec_bfd); + *Description* +Return `true' if the core file attached to CORE_BFD was generated by a +run of the executable file attached to EXEC_BFD, `false' otherwise. + + +File: bfd.info, Node: Targets, Next: Architectures, Prev: Core Files, Up: BFD front end + +Targets +======= + + *Description* +Each port of BFD to a different machine requries the creation of a +target back end. All the back end provides to the root part of BFD is a +structure containing pointers to functions which perform certain low +level operations on files. BFD translates the applications's requests +through a pointer into calls to the back end routines. + + When a file is opened with `bfd_openr', its format and target are +unknown. BFD uses various mechanisms to determine how to interpret the +file. The operations performed are: + + * Create a BFD by calling the internal routine `_bfd_new_bfd', then + call `bfd_find_target' with the target string supplied to + `bfd_openr' and the new BFD pointer. + + * If a null target string was provided to `bfd_find_target', look up + the environment variable `GNUTARGET' and use that as the target + string. + + * If the target string is still `NULL', or the target string is + `default', then use the first item in the target vector as the + target type, and set `target_defaulted' in the BFD to cause + `bfd_check_format' to loop through all the targets. *Note + bfd_target::. *Note Formats::. + + * Otherwise, inspect the elements in the target vector one by one, + until a match on target name is found. When found, use it. + + * Otherwise return the error `bfd_error_invalid_target' to + `bfd_openr'. + + * `bfd_openr' attempts to open the file using `bfd_open_file', and + returns the BFD. + Once the BFD has been opened and the target selected, the file +format may be determined. This is done by calling `bfd_check_format' on +the BFD with a suggested format. If `target_defaulted' has been set, +each possible target type is tried to see if it recognizes the +specified format. `bfd_check_format' returns `true' when the caller +guesses right. + +* Menu: + +* bfd_target:: + diff --git a/bfd/doc/bfd.info-4 b/bfd/doc/bfd.info-4 new file mode 100644 index 00000000000..d527fb1a139 --- /dev/null +++ b/bfd/doc/bfd.info-4 @@ -0,0 +1,1292 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: bfd.info, Node: bfd_target, Prev: Targets, Up: Targets + +bfd_target +---------- + + *Description* +This structure contains everything that BFD knows about a target. It +includes things like its byte order, name, and which routines to call +to do various operations. + + Every BFD points to a target structure with its `xvec' member. + + The macros below are used to dispatch to functions through the +`bfd_target' vector. They are used in a number of macros further down +in `bfd.h', and are also used when calling various routines by hand +inside the BFD implementation. The ARGLIST argument must be +parenthesized; it contains all the arguments to the called function. + + They make the documentation (more) unpleasant to read, so if someone +wants to fix this and not break the above, please do. + #define BFD_SEND(bfd, message, arglist) \ + ((*((bfd)->xvec->message)) arglist) + + #ifdef DEBUG_BFD_SEND + #undef BFD_SEND + #define BFD_SEND(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + ((*((bfd)->xvec->message)) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) + #endif + For operations which index on the BFD format: + #define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) + + #ifdef DEBUG_BFD_SEND + #undef BFD_SEND_FMT + #define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) + #endif + This is the structure which defines the type of BFD this is. The +`xvec' member of the struct `bfd' itself points here. Each module that +implements access to a different target under BFD, defines one of these. + + FIXME, these names should be rationalised with the names of the +entry points which call them. Too bad we can't have one macro to define +them both! + enum bfd_flavour { + bfd_target_unknown_flavour, + bfd_target_aout_flavour, + bfd_target_coff_flavour, + bfd_target_ecoff_flavour, + bfd_target_elf_flavour, + bfd_target_ieee_flavour, + bfd_target_nlm_flavour, + bfd_target_oasys_flavour, + bfd_target_tekhex_flavour, + bfd_target_srec_flavour, + bfd_target_ihex_flavour, + bfd_target_som_flavour, + bfd_target_os9k_flavour, + bfd_target_versados_flavour, + bfd_target_msdos_flavour, + bfd_target_ovax_flavour, + bfd_target_evax_flavour + }; + + enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN }; + + /* Forward declaration. */ + typedef struct bfd_link_info _bfd_link_info; + + typedef struct bfd_target + { + Identifies the kind of target, e.g., SunOS4, Ultrix, etc. + char *name; + The "flavour" of a back end is a general indication about the +contents of a file. + enum bfd_flavour flavour; + The order of bytes within the data area of a file. + enum bfd_endian byteorder; + The order of bytes within the header parts of a file. + enum bfd_endian header_byteorder; + A mask of all the flags which an executable may have set - from the +set `BFD_NO_FLAGS', `HAS_RELOC', ...`D_PAGED'. + flagword object_flags; + A mask of all the flags which a section may have set - from the set +`SEC_NO_FLAGS', `SEC_ALLOC', ...`SET_NEVER_LOAD'. + flagword section_flags; + The character normally found at the front of a symbol (if any), +perhaps `_'. + char symbol_leading_char; + The pad character for file names within an archive header. + char ar_pad_char; + The maximum number of characters in an archive header. + unsigned short ar_max_namelen; + Entries for byte swapping for data. These are different from the +other entry points, since they don't take a BFD asthe first argument. +Certain other handlers could do the same. + bfd_vma (*bfd_getx64) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *)); + void (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_getx32) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *)); + void (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_getx16) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *)); + void (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *)); + Byte swapping for the headers + bfd_vma (*bfd_h_getx64) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *)); + void (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_h_getx32) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *)); + void (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_h_getx16) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *)); + void (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *)); + Format dependent routines: these are vectors of entry points within +the target vector structure, one for each format to check. + + Check the format of a file being read. Return a `bfd_target *' or +zero. + const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *)); + Set the format of a file being written. + boolean (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *)); + Write cached information into a file being written, at `bfd_close'. + boolean (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *)); + The general target vector. These vectors are initialized using the +BFD_JUMP_TABLE macros. + + /* Generic entry points. */ + #define BFD_JUMP_TABLE_GENERIC(NAME)\ + CAT(NAME,_close_and_cleanup),\ + CAT(NAME,_bfd_free_cached_info),\ + CAT(NAME,_new_section_hook),\ + CAT(NAME,_get_section_contents),\ + CAT(NAME,_get_section_contents_in_window) + + /* Called when the BFD is being closed to do any necessary cleanup. */ + boolean (*_close_and_cleanup) PARAMS ((bfd *)); + /* Ask the BFD to free all cached information. */ + boolean (*_bfd_free_cached_info) PARAMS ((bfd *)); + /* Called when a new section is created. */ + boolean (*_new_section_hook) PARAMS ((bfd *, sec_ptr)); + /* Read the contents of a section. */ + boolean (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR, + file_ptr, bfd_size_type)); + boolean (*_bfd_get_section_contents_in_window) + PARAMS ((bfd *, sec_ptr, bfd_window *, + file_ptr, bfd_size_type)); + + /* Entry points to copy private data. */ + #define BFD_JUMP_TABLE_COPY(NAME)\ + CAT(NAME,_bfd_copy_private_bfd_data),\ + CAT(NAME,_bfd_merge_private_bfd_data),\ + CAT(NAME,_bfd_copy_private_section_data),\ + CAT(NAME,_bfd_copy_private_symbol_data),\ + CAT(NAME,_bfd_set_private_flags),\ + CAT(NAME,_bfd_print_private_bfd_data)\ + /* Called to copy BFD general private data from one object file + to another. */ + boolean (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *)); + /* Called to merge BFD general private data from one object file + to a common output file when linking. */ + boolean (*_bfd_merge_private_bfd_data) PARAMS ((bfd *, bfd *)); + /* Called to copy BFD private section data from one object file + to another. */ + boolean (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr, + bfd *, sec_ptr)); + /* Called to copy BFD private symbol data from one symbol + to another. */ + boolean (*_bfd_copy_private_symbol_data) PARAMS ((bfd *, asymbol *, + bfd *, asymbol *)); + /* Called to set private backend flags */ + boolean (*_bfd_set_private_flags) PARAMS ((bfd *, flagword)); + + /* Called to print private BFD data */ + boolean (*_bfd_print_private_bfd_data) PARAMS ((bfd *, PTR)); + + /* Core file entry points. */ + #define BFD_JUMP_TABLE_CORE(NAME)\ + CAT(NAME,_core_file_failing_command),\ + CAT(NAME,_core_file_failing_signal),\ + CAT(NAME,_core_file_matches_executable_p) + char * (*_core_file_failing_command) PARAMS ((bfd *)); + int (*_core_file_failing_signal) PARAMS ((bfd *)); + boolean (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *)); + + /* Archive entry points. */ + #define BFD_JUMP_TABLE_ARCHIVE(NAME)\ + CAT(NAME,_slurp_armap),\ + CAT(NAME,_slurp_extended_name_table),\ + CAT(NAME,_construct_extended_name_table),\ + CAT(NAME,_truncate_arname),\ + CAT(NAME,_write_armap),\ + CAT(NAME,_read_ar_hdr),\ + CAT(NAME,_openr_next_archived_file),\ + CAT(NAME,_get_elt_at_index),\ + CAT(NAME,_generic_stat_arch_elt),\ + CAT(NAME,_update_armap_timestamp) + boolean (*_bfd_slurp_armap) PARAMS ((bfd *)); + boolean (*_bfd_slurp_extended_name_table) PARAMS ((bfd *)); + boolean (*_bfd_construct_extended_name_table) + PARAMS ((bfd *, char **, bfd_size_type *, const char **)); + void (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *)); + boolean (*write_armap) PARAMS ((bfd *arch, + unsigned int elength, + struct orl *map, + unsigned int orl_count, + int stridx)); + PTR (*_bfd_read_ar_hdr_fn) PARAMS ((bfd *)); + bfd * (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev)); + #define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i)) + bfd * (*_bfd_get_elt_at_index) PARAMS ((bfd *, symindex)); + int (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *)); + boolean (*_bfd_update_armap_timestamp) PARAMS ((bfd *)); + + /* Entry points used for symbols. */ + #define BFD_JUMP_TABLE_SYMBOLS(NAME)\ + CAT(NAME,_get_symtab_upper_bound),\ + CAT(NAME,_get_symtab),\ + CAT(NAME,_make_empty_symbol),\ + CAT(NAME,_print_symbol),\ + CAT(NAME,_get_symbol_info),\ + CAT(NAME,_bfd_is_local_label_name),\ + CAT(NAME,_get_lineno),\ + CAT(NAME,_find_nearest_line),\ + CAT(NAME,_bfd_make_debug_symbol),\ + CAT(NAME,_read_minisymbols),\ + CAT(NAME,_minisymbol_to_symbol) + long (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *)); + long (*_bfd_canonicalize_symtab) PARAMS ((bfd *, + struct symbol_cache_entry **)); + struct symbol_cache_entry * + (*_bfd_make_empty_symbol) PARAMS ((bfd *)); + void (*_bfd_print_symbol) PARAMS ((bfd *, PTR, + struct symbol_cache_entry *, + bfd_print_symbol_type)); + #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e)) + void (*_bfd_get_symbol_info) PARAMS ((bfd *, + struct symbol_cache_entry *, + symbol_info *)); + #define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e)) + boolean (*_bfd_is_local_label_name) PARAMS ((bfd *, const char *)); + + alent * (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *)); + boolean (*_bfd_find_nearest_line) PARAMS ((bfd *abfd, + struct sec *section, struct symbol_cache_entry **symbols, + bfd_vma offset, CONST char **file, CONST char **func, + unsigned int *line)); + /* Back-door to allow format-aware applications to create debug symbols + while using BFD for everything else. Currently used by the assembler + when creating COFF files. */ + asymbol * (*_bfd_make_debug_symbol) PARAMS (( + bfd *abfd, + void *ptr, + unsigned long size)); + #define bfd_read_minisymbols(b, d, m, s) \ + BFD_SEND (b, _read_minisymbols, (b, d, m, s)) + long (*_read_minisymbols) PARAMS ((bfd *, boolean, PTR *, + unsigned int *)); + #define bfd_minisymbol_to_symbol(b, d, m, f) \ + BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f)) + asymbol *(*_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR, + asymbol *)); + + /* Routines for relocs. */ + #define BFD_JUMP_TABLE_RELOCS(NAME)\ + CAT(NAME,_get_reloc_upper_bound),\ + CAT(NAME,_canonicalize_reloc),\ + CAT(NAME,_bfd_reloc_type_lookup) + long (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr)); + long (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **, + struct symbol_cache_entry **)); + /* See documentation on reloc types. */ + reloc_howto_type * + (*reloc_type_lookup) PARAMS ((bfd *abfd, + bfd_reloc_code_real_type code)); + + /* Routines used when writing an object file. */ + #define BFD_JUMP_TABLE_WRITE(NAME)\ + CAT(NAME,_set_arch_mach),\ + CAT(NAME,_set_section_contents) + boolean (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture, + unsigned long)); + boolean (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR, + file_ptr, bfd_size_type)); + + /* Routines used by the linker. */ + #define BFD_JUMP_TABLE_LINK(NAME)\ + CAT(NAME,_sizeof_headers),\ + CAT(NAME,_bfd_get_relocated_section_contents),\ + CAT(NAME,_bfd_relax_section),\ + CAT(NAME,_bfd_link_hash_table_create),\ + CAT(NAME,_bfd_link_add_symbols),\ + CAT(NAME,_bfd_final_link),\ + CAT(NAME,_bfd_link_split_section),\ + CAT(NAME,_bfd_gc_sections) + int (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean)); + bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *, + struct bfd_link_info *, struct bfd_link_order *, + bfd_byte *data, boolean relocateable, + struct symbol_cache_entry **)); + + boolean (*_bfd_relax_section) PARAMS ((bfd *, struct sec *, + struct bfd_link_info *, boolean *again)); + + /* Create a hash table for the linker. Different backends store + different information in this table. */ + struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *)); + + /* Add symbols from this object file into the hash table. */ + boolean (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *)); + + /* Do a link based on the link_order structures attached to each + section of the BFD. */ + boolean (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *)); + + /* Should this section be split up into smaller pieces during linking. */ + boolean (*_bfd_link_split_section) PARAMS ((bfd *, struct sec *)); + + /* Remove sections that are not referenced from the output. */ + boolean (*_bfd_gc_sections) PARAMS ((bfd *, struct bfd_link_info *)); + + /* Routines to handle dynamic symbols and relocs. */ + #define BFD_JUMP_TABLE_DYNAMIC(NAME)\ + CAT(NAME,_get_dynamic_symtab_upper_bound),\ + CAT(NAME,_canonicalize_dynamic_symtab),\ + CAT(NAME,_get_dynamic_reloc_upper_bound),\ + CAT(NAME,_canonicalize_dynamic_reloc) + /* Get the amount of memory required to hold the dynamic symbols. */ + long (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *)); + /* Read in the dynamic symbols. */ + long (*_bfd_canonicalize_dynamic_symtab) + PARAMS ((bfd *, struct symbol_cache_entry **)); + /* Get the amount of memory required to hold the dynamic relocs. */ + long (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *)); + /* Read in the dynamic relocs. */ + long (*_bfd_canonicalize_dynamic_reloc) + PARAMS ((bfd *, arelent **, struct symbol_cache_entry **)); + A pointer to an alternative bfd_target in case the current one is not +satisfactory. This can happen when the target cpu supports both big +and little endian code, and target chosen by the linker has the wrong +endianness. The function open_output() in ld/ldlang.c uses this field +to find an alternative output format that is suitable. + /* Opposite endian version of this target. */ + const struct bfd_target * alternative_target; + Data for use by back-end routines, which isn't generic enough to +belong in this structure. + PTR backend_data; + + } bfd_target; + +`bfd_set_default_target' +........................ + + *Synopsis* + boolean bfd_set_default_target (const char *name); + *Description* +Set the default target vector to use when recognizing a BFD. This +takes the name of the target, which may be a BFD target name or a +configuration triplet. + +`bfd_find_target' +................. + + *Synopsis* + const bfd_target *bfd_find_target(CONST char *target_name, bfd *abfd); + *Description* +Return a pointer to the transfer vector for the object target named +TARGET_NAME. If TARGET_NAME is `NULL', choose the one in the +environment variable `GNUTARGET'; if that is null or not defined, then +choose the first entry in the target list. Passing in the string +"default" or setting the environment variable to "default" will cause +the first entry in the target list to be returned, and +"target_defaulted" will be set in the BFD. This causes +`bfd_check_format' to loop over all the targets to find the one that +matches the file being read. + +`bfd_target_list' +................. + + *Synopsis* + const char **bfd_target_list(void); + *Description* +Return a freshly malloced NULL-terminated vector of the names of all +the valid BFD targets. Do not modify the names. + +`bfd_seach_for_target' +...................... + + *Synopsis* + const bfd_target * bfd_search_for_target (int (* search_func)(const bfd_target *, void *), void *); + *Description* +Return a pointer to the first transfer vector in the list of transfer +vectors maintained by BFD that produces a non-zero result when passed +to the function SEARCH_FUNC. The parameter DATA is passed, unexamined, +to the search function. + + +File: bfd.info, Node: Architectures, Next: Opening and Closing, Prev: Targets, Up: BFD front end + +Architectures +============= + + BFD keeps one atom in a BFD describing the architecture of the data +attached to the BFD: a pointer to a `bfd_arch_info_type'. + + Pointers to structures can be requested independently of a BFD so +that an architecture's information can be interrogated without access +to an open BFD. + + The architecture information is provided by each architecture +package. The set of default architectures is selected by the macro +`SELECT_ARCHITECTURES'. This is normally set up in the +`config/TARGET.mt' file of your choice. If the name is not defined, +then all the architectures supported are included. + + When BFD starts up, all the architectures are called with an +initialize method. It is up to the architecture back end to insert as +many items into the list of architectures as it wants to; generally +this would be one for each machine and one for the default case (an +item with a machine field of 0). + + BFD's idea of an architecture is implemented in `archures.c'. + +bfd_architecture +---------------- + + *Description* +This enum gives the object file's CPU architecture, in a global +sense--i.e., what processor family does it belong to? Another field +indicates which processor within the family is in use. The machine +gives a number which distinguishes different versions of the +architecture, containing, for example, 2 and 3 for Intel i960 KA and +i960 KB, and 68020 and 68030 for Motorola 68020 and 68030. + enum bfd_architecture + { + bfd_arch_unknown, /* File arch not known */ + bfd_arch_obscure, /* Arch known, not one of these */ + bfd_arch_m68k, /* Motorola 68xxx */ + #define bfd_mach_m68000 1 + #define bfd_mach_m68008 2 + #define bfd_mach_m68010 3 + #define bfd_mach_m68020 4 + #define bfd_mach_m68030 5 + #define bfd_mach_m68040 6 + #define bfd_mach_m68060 7 + #define bfd_mach_cpu32 8 + bfd_arch_vax, /* DEC Vax */ + bfd_arch_i960, /* Intel 960 */ + /* The order of the following is important. + lower number indicates a machine type that + only accepts a subset of the instructions + available to machines with higher numbers. + The exception is the "ca", which is + incompatible with all other machines except + "core". */ + + #define bfd_mach_i960_core 1 + #define bfd_mach_i960_ka_sa 2 + #define bfd_mach_i960_kb_sb 3 + #define bfd_mach_i960_mc 4 + #define bfd_mach_i960_xa 5 + #define bfd_mach_i960_ca 6 + #define bfd_mach_i960_jx 7 + #define bfd_mach_i960_hx 8 + + bfd_arch_a29k, /* AMD 29000 */ + bfd_arch_sparc, /* SPARC */ + #define bfd_mach_sparc 1 + /* The difference between v8plus and v9 is that v9 is a true 64 bit env. */ + #define bfd_mach_sparc_sparclet 2 + #define bfd_mach_sparc_sparclite 3 + #define bfd_mach_sparc_v8plus 4 + #define bfd_mach_sparc_v8plusa 5 /* with ultrasparc add'ns */ + #define bfd_mach_sparc_sparclite_le 6 + #define bfd_mach_sparc_v9 7 + #define bfd_mach_sparc_v9a 8 /* with ultrasparc add'ns */ + /* Nonzero if MACH has the v9 instruction set. */ + #define bfd_mach_sparc_v9_p(mach) \ + ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a) + bfd_arch_mips, /* MIPS Rxxxx */ + #define bfd_mach_mips3000 3000 + #define bfd_mach_mips3900 3900 + #define bfd_mach_mips4000 4000 + #define bfd_mach_mips4010 4010 + #define bfd_mach_mips4100 4100 + #define bfd_mach_mips4111 4111 + #define bfd_mach_mips4300 4300 + #define bfd_mach_mips4400 4400 + #define bfd_mach_mips4600 4600 + #define bfd_mach_mips4650 4650 + #define bfd_mach_mips5000 5000 + #define bfd_mach_mips6000 6000 + #define bfd_mach_mips8000 8000 + #define bfd_mach_mips10000 10000 + #define bfd_mach_mips16 16 + bfd_arch_i386, /* Intel 386 */ + #define bfd_mach_i386_i386 0 + #define bfd_mach_i386_i8086 1 + #define bfd_mach_i386_i386_intel_syntax 2 + bfd_arch_we32k, /* AT&T WE32xxx */ + bfd_arch_tahoe, /* CCI/Harris Tahoe */ + bfd_arch_i860, /* Intel 860 */ + bfd_arch_i370, /* IBM 360/370 Mainframes */ + bfd_arch_romp, /* IBM ROMP PC/RT */ + bfd_arch_alliant, /* Alliant */ + bfd_arch_convex, /* Convex */ + bfd_arch_m88k, /* Motorola 88xxx */ + bfd_arch_pyramid, /* Pyramid Technology */ + bfd_arch_h8300, /* Hitachi H8/300 */ + #define bfd_mach_h8300 1 + #define bfd_mach_h8300h 2 + #define bfd_mach_h8300s 3 + bfd_arch_powerpc, /* PowerPC */ + bfd_arch_rs6000, /* IBM RS/6000 */ + bfd_arch_hppa, /* HP PA RISC */ + bfd_arch_d10v, /* Mitsubishi D10V */ + #define bfd_mach_d10v 0 + #define bfd_mach_d10v_ts2 2 + #define bfd_mach_d10v_ts3 3 + bfd_arch_d30v, /* Mitsubishi D30V */ + bfd_arch_z8k, /* Zilog Z8000 */ + #define bfd_mach_z8001 1 + #define bfd_mach_z8002 2 + bfd_arch_h8500, /* Hitachi H8/500 */ + bfd_arch_sh, /* Hitachi SH */ + #define bfd_mach_sh 0 + #define bfd_mach_sh2 0x20 + #define bfd_mach_sh_dsp 0x2d + #define bfd_mach_sh3 0x30 + #define bfd_mach_sh3_dsp 0x3d + #define bfd_mach_sh3e 0x3e + #define bfd_mach_sh4 0x40 + bfd_arch_alpha, /* Dec Alpha */ + #define bfd_mach_alpha_ev4 0x10 + #define bfd_mach_alpha_ev5 0x20 + #define bfd_mach_alpha_ev6 0x30 + bfd_arch_arm, /* Advanced Risc Machines ARM */ + #define bfd_mach_arm_2 1 + #define bfd_mach_arm_2a 2 + #define bfd_mach_arm_3 3 + #define bfd_mach_arm_3M 4 + #define bfd_mach_arm_4 5 + #define bfd_mach_arm_4T 6 + #define bfd_mach_arm_5 7 + #define bfd_mach_arm_5T 8 + bfd_arch_ns32k, /* National Semiconductors ns32000 */ + bfd_arch_w65, /* WDC 65816 */ + bfd_arch_tic30, /* Texas Instruments TMS320C30 */ + bfd_arch_tic80, /* TI TMS320c80 (MVP) */ + bfd_arch_v850, /* NEC V850 */ + #define bfd_mach_v850 0 + #define bfd_mach_v850e 'E' + #define bfd_mach_v850ea 'A' + bfd_arch_arc, /* Argonaut RISC Core */ + #define bfd_mach_arc_base 0 + bfd_arch_m32r, /* Mitsubishi M32R/D */ + #define bfd_mach_m32r 0 /* backwards compatibility */ + #define bfd_mach_m32rx 'x' + bfd_arch_mn10200, /* Matsushita MN10200 */ + bfd_arch_mn10300, /* Matsushita MN10300 */ + #define bfd_mach_mn10300 300 + #define bfd_mach_am33 330 + bfd_arch_fr30, + #define bfd_mach_fr30 0x46523330 + bfd_arch_mcore, + bfd_arch_pj, + bfd_arch_avr, /* Atmel AVR microcontrollers */ + #define bfd_mach_avr1 1 + #define bfd_mach_avr2 2 + #define bfd_mach_avr3 3 + #define bfd_mach_avr4 4 + bfd_arch_last + }; + +bfd_arch_info +------------- + + *Description* +This structure contains information on architectures for use within BFD. + + typedef struct bfd_arch_info + { + int bits_per_word; + int bits_per_address; + int bits_per_byte; + enum bfd_architecture arch; + unsigned long mach; + const char *arch_name; + const char *printable_name; + unsigned int section_align_power; + /* true if this is the default machine for the architecture */ + boolean the_default; + const struct bfd_arch_info * (*compatible) + PARAMS ((const struct bfd_arch_info *a, + const struct bfd_arch_info *b)); + + boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *)); + + const struct bfd_arch_info *next; + } bfd_arch_info_type; + +`bfd_printable_name' +.................... + + *Synopsis* + const char *bfd_printable_name(bfd *abfd); + *Description* +Return a printable string representing the architecture and machine +from the pointer to the architecture info structure. + +`bfd_scan_arch' +............... + + *Synopsis* + const bfd_arch_info_type *bfd_scan_arch(const char *string); + *Description* +Figure out if BFD supports any cpu which could be described with the +name STRING. Return a pointer to an `arch_info' structure if a machine +is found, otherwise NULL. + +`bfd_arch_list' +............... + + *Synopsis* + const char **bfd_arch_list(void); + *Description* +Return a freshly malloced NULL-terminated vector of the names of all +the valid BFD architectures. Do not modify the names. + +`bfd_arch_get_compatible' +......................... + + *Synopsis* + const bfd_arch_info_type *bfd_arch_get_compatible( + const bfd *abfd, + const bfd *bbfd); + *Description* +Determine whether two BFDs' architectures and machine types are +compatible. Calculates the lowest common denominator between the two +architectures and machine types implied by the BFDs and returns a +pointer to an `arch_info' structure describing the compatible machine. + +`bfd_default_arch_struct' +......................... + + *Description* +The `bfd_default_arch_struct' is an item of `bfd_arch_info_type' which +has been initialized to a fairly generic state. A BFD starts life by +pointing to this structure, until the correct back end has determined +the real architecture of the file. + extern const bfd_arch_info_type bfd_default_arch_struct; + +`bfd_set_arch_info' +................... + + *Synopsis* + void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg); + *Description* +Set the architecture info of ABFD to ARG. + +`bfd_default_set_arch_mach' +........................... + + *Synopsis* + boolean bfd_default_set_arch_mach(bfd *abfd, + enum bfd_architecture arch, + unsigned long mach); + *Description* +Set the architecture and machine type in BFD ABFD to ARCH and MACH. +Find the correct pointer to a structure and insert it into the +`arch_info' pointer. + +`bfd_get_arch' +.............. + + *Synopsis* + enum bfd_architecture bfd_get_arch(bfd *abfd); + *Description* +Return the enumerated type which describes the BFD ABFD's architecture. + +`bfd_get_mach' +.............. + + *Synopsis* + unsigned long bfd_get_mach(bfd *abfd); + *Description* +Return the long type which describes the BFD ABFD's machine. + +`bfd_arch_bits_per_byte' +........................ + + *Synopsis* + unsigned int bfd_arch_bits_per_byte(bfd *abfd); + *Description* +Return the number of bits in one of the BFD ABFD's architecture's bytes. + +`bfd_arch_bits_per_address' +........................... + + *Synopsis* + unsigned int bfd_arch_bits_per_address(bfd *abfd); + *Description* +Return the number of bits in one of the BFD ABFD's architecture's +addresses. + +`bfd_default_compatible' +........................ + + *Synopsis* + const bfd_arch_info_type *bfd_default_compatible + (const bfd_arch_info_type *a, + const bfd_arch_info_type *b); + *Description* +The default function for testing for compatibility. + +`bfd_default_scan' +.................. + + *Synopsis* + boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string); + *Description* +The default function for working out whether this is an architecture +hit and a machine hit. + +`bfd_get_arch_info' +................... + + *Synopsis* + const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd); + *Description* +Return the architecture info struct in ABFD. + +`bfd_lookup_arch' +................. + + *Synopsis* + const bfd_arch_info_type *bfd_lookup_arch + (enum bfd_architecture + arch, + unsigned long machine); + *Description* +Look for the architecure info structure which matches the arguments +ARCH and MACHINE. A machine of 0 matches the machine/architecture +structure which marks itself as the default. + +`bfd_printable_arch_mach' +......................... + + *Synopsis* + const char *bfd_printable_arch_mach + (enum bfd_architecture arch, unsigned long machine); + *Description* +Return a printable string representing the architecture and machine +type. + + This routine is depreciated. + +`bfd_octets_per_byte' +..................... + + *Synopsis* + unsigned int bfd_octets_per_byte(bfd *abfd); + *Description* +Return the number of octets (8-bit quantities) per target byte (minimum +addressable unit). In most cases, this will be one, but some DSP +targets have 16, 32, or even 48 bits per byte. + +`bfd_arch_mach_octets_per_byte' +............................... + + *Synopsis* + unsigned int bfd_arch_mach_octets_per_byte(enum bfd_architecture arch, + unsigned long machine); + *Description* +See bfd_octets_per_byte. This routine is provided for those cases +where a bfd * is not available + + +File: bfd.info, Node: Opening and Closing, Next: Internal, Prev: Architectures, Up: BFD front end + +Opening and closing BFDs +======================== + +`bfd_openr' +........... + + *Synopsis* + bfd *bfd_openr(CONST char *filename, CONST char *target); + *Description* +Open the file FILENAME (using `fopen') with the target TARGET. Return +a pointer to the created BFD. + + Calls `bfd_find_target', so TARGET is interpreted as by that +function. + + If `NULL' is returned then an error has occured. Possible errors +are `bfd_error_no_memory', `bfd_error_invalid_target' or `system_call' +error. + +`bfd_fdopenr' +............. + + *Synopsis* + bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd); + *Description* +`bfd_fdopenr' is to `bfd_fopenr' much like `fdopen' is to `fopen'. It +opens a BFD on a file already described by the FD supplied. + + When the file is later `bfd_close'd, the file descriptor will be +closed. + + If the caller desires that this file descriptor be cached by BFD +(opened as needed, closed as needed to free descriptors for other +opens), with the supplied FD used as an initial file descriptor (but +subject to closure at any time), call bfd_set_cacheable(bfd, 1) on the +returned BFD. The default is to assume no cacheing; the file +descriptor will remain open until `bfd_close', and will not be affected +by BFD operations on other files. + + Possible errors are `bfd_error_no_memory', +`bfd_error_invalid_target' and `bfd_error_system_call'. + +`bfd_openstreamr' +................. + + *Synopsis* + bfd *bfd_openstreamr(const char *, const char *, PTR); + *Description* +Open a BFD for read access on an existing stdio stream. When the BFD +is passed to `bfd_close', the stream will be closed. + +`bfd_openw' +........... + + *Synopsis* + bfd *bfd_openw(CONST char *filename, CONST char *target); + *Description* +Create a BFD, associated with file FILENAME, using the file format +TARGET, and return a pointer to it. + + Possible errors are `bfd_error_system_call', `bfd_error_no_memory', +`bfd_error_invalid_target'. + +`bfd_close' +........... + + *Synopsis* + boolean bfd_close(bfd *abfd); + *Description* +Close a BFD. If the BFD was open for writing, then pending operations +are completed and the file written out and closed. If the created file +is executable, then `chmod' is called to mark it as such. + + All memory attached to the BFD is released. + + The file descriptor associated with the BFD is closed (even if it +was passed in to BFD by `bfd_fdopenr'). + + *Returns* +`true' is returned if all is ok, otherwise `false'. + +`bfd_close_all_done' +.................... + + *Synopsis* + boolean bfd_close_all_done(bfd *); + *Description* +Close a BFD. Differs from `bfd_close' since it does not complete any +pending operations. This routine would be used if the application had +just used BFD for swapping and didn't want to use any of the writing +code. + + If the created file is executable, then `chmod' is called to mark it +as such. + + All memory attached to the BFD is released. + + *Returns* +`true' is returned if all is ok, otherwise `false'. + +`bfd_create' +............ + + *Synopsis* + bfd *bfd_create(CONST char *filename, bfd *templ); + *Description* +Create a new BFD in the manner of `bfd_openw', but without opening a +file. The new BFD takes the target from the target used by TEMPLATE. The +format is always set to `bfd_object'. + +`bfd_make_writable' +................... + + *Synopsis* + boolean bfd_make_writable(bfd *abfd); + *Description* +Takes a BFD as created by `bfd_create' and converts it into one like as +returned by `bfd_openw'. It does this by converting the BFD to +BFD_IN_MEMORY. It's assumed that you will call `bfd_make_readable' on +this bfd later. + + *Returns* +`true' is returned if all is ok, otherwise `false'. + +`bfd_make_readable' +................... + + *Synopsis* + boolean bfd_make_readable(bfd *abfd); + *Description* +Takes a BFD as created by `bfd_create' and `bfd_make_writable' and +converts it into one like as returned by `bfd_openr'. It does this by +writing the contents out to the memory buffer, then reversing the +direction. + + *Returns* +`true' is returned if all is ok, otherwise `false'. + +`bfd_alloc' +........... + + *Synopsis* + PTR bfd_alloc (bfd *abfd, size_t wanted); + *Description* +Allocate a block of WANTED bytes of memory attached to `abfd' and +return a pointer to it. + + +File: bfd.info, Node: Internal, Next: File Caching, Prev: Opening and Closing, Up: BFD front end + +Internal functions +================== + + *Description* +These routines are used within BFD. They are not intended for export, +but are documented here for completeness. + +`bfd_write_bigendian_4byte_int' +............................... + + *Synopsis* + void bfd_write_bigendian_4byte_int(bfd *abfd, int i); + *Description* +Write a 4 byte integer I to the output BFD ABFD, in big endian order +regardless of what else is going on. This is useful in archives. + +`bfd_put_size' +.............. + +`bfd_get_size' +.............. + + *Description* +These macros as used for reading and writing raw data in sections; each +access (except for bytes) is vectored through the target format of the +BFD and mangled accordingly. The mangling performs any necessary endian +translations and removes alignment restrictions. Note that types +accepted and returned by these macros are identical so they can be +swapped around in macros--for example, `libaout.h' defines `GET_WORD' +to either `bfd_get_32' or `bfd_get_64'. + + In the put routines, VAL must be a `bfd_vma'. If we are on a system +without prototypes, the caller is responsible for making sure that is +true, with a cast if necessary. We don't cast them in the macro +definitions because that would prevent `lint' or `gcc -Wall' from +detecting sins such as passing a pointer. To detect calling these with +less than a `bfd_vma', use `gcc -Wconversion' on a host with 64 bit +`bfd_vma''s. + + /* Byte swapping macros for user section data. */ + + #define bfd_put_8(abfd, val, ptr) \ + ((void) (*((unsigned char *)(ptr)) = (unsigned char)(val))) + #define bfd_put_signed_8 \ + bfd_put_8 + #define bfd_get_8(abfd, ptr) \ + (*(unsigned char *)(ptr)) + #define bfd_get_signed_8(abfd, ptr) \ + ((*(unsigned char *)(ptr) ^ 0x80) - 0x80) + + #define bfd_put_16(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx16, ((val),(ptr))) + #define bfd_put_signed_16 \ + bfd_put_16 + #define bfd_get_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx16, (ptr)) + #define bfd_get_signed_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) + + #define bfd_put_32(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx32, ((val),(ptr))) + #define bfd_put_signed_32 \ + bfd_put_32 + #define bfd_get_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx32, (ptr)) + #define bfd_get_signed_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx_signed_32, (ptr)) + + #define bfd_put_64(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx64, ((val), (ptr))) + #define bfd_put_signed_64 \ + bfd_put_64 + #define bfd_get_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx64, (ptr)) + #define bfd_get_signed_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx_signed_64, (ptr)) + + #define bfd_get(bits, abfd, ptr) \ + ((bits) == 8 ? bfd_get_8 (abfd, ptr) \ + : (bits) == 16 ? bfd_get_16 (abfd, ptr) \ + : (bits) == 32 ? bfd_get_32 (abfd, ptr) \ + : (bits) == 64 ? bfd_get_64 (abfd, ptr) \ + : (abort (), (bfd_vma) - 1)) + + #define bfd_put(bits, abfd, val, ptr) \ + ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \ + : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \ + : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \ + : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \ + : (abort (), (void) 0)) + +`bfd_h_put_size' +................ + + *Description* +These macros have the same function as their `bfd_get_x' bretheren, +except that they are used for removing information for the header +records of object files. Believe it or not, some object files keep +their header records in big endian order and their data in little +endian order. + + /* Byte swapping macros for file header data. */ + + #define bfd_h_put_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) + #define bfd_h_put_signed_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) + #define bfd_h_get_8(abfd, ptr) \ + bfd_get_8 (abfd, ptr) + #define bfd_h_get_signed_8(abfd, ptr) \ + bfd_get_signed_8 (abfd, ptr) + + #define bfd_h_put_16(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx16,(val,ptr)) + #define bfd_h_put_signed_16 \ + bfd_h_put_16 + #define bfd_h_get_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx16,(ptr)) + #define bfd_h_get_signed_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr)) + + #define bfd_h_put_32(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx32,(val,ptr)) + #define bfd_h_put_signed_32 \ + bfd_h_put_32 + #define bfd_h_get_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx32,(ptr)) + #define bfd_h_get_signed_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr)) + + #define bfd_h_put_64(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx64,(val, ptr)) + #define bfd_h_put_signed_64 \ + bfd_h_put_64 + #define bfd_h_get_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx64,(ptr)) + #define bfd_h_get_signed_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr)) + +`bfd_log2' +.......... + + *Synopsis* + unsigned int bfd_log2(bfd_vma x); + *Description* +Return the log base 2 of the value supplied, rounded up. E.g., an X of +1025 returns 11. + + +File: bfd.info, Node: File Caching, Next: Linker Functions, Prev: Internal, Up: BFD front end + +File caching +============ + + The file caching mechanism is embedded within BFD and allows the +application to open as many BFDs as it wants without regard to the +underlying operating system's file descriptor limit (often as low as 20 +open files). The module in `cache.c' maintains a least recently used +list of `BFD_CACHE_MAX_OPEN' files, and exports the name +`bfd_cache_lookup', which runs around and makes sure that the required +BFD is open. If not, then it chooses a file to close, closes it and +opens the one wanted, returning its file handle. + +`BFD_CACHE_MAX_OPEN macro' +.......................... + + *Description* +The maximum number of files which the cache will keep open at one time. + #define BFD_CACHE_MAX_OPEN 10 + +`bfd_last_cache' +................ + + *Synopsis* + extern bfd *bfd_last_cache; + *Description* +Zero, or a pointer to the topmost BFD on the chain. This is used by +the `bfd_cache_lookup' macro in `libbfd.h' to determine when it can +avoid a function call. + +`bfd_cache_lookup' +.................. + + *Description* +Check to see if the required BFD is the same as the last one looked up. +If so, then it can use the stream in the BFD with impunity, since it +can't have changed since the last lookup; otherwise, it has to perform +the complicated lookup function. + #define bfd_cache_lookup(x) \ + ((x)==bfd_last_cache? \ + (FILE*)(bfd_last_cache->iostream): \ + bfd_cache_lookup_worker(x)) + +`bfd_cache_init' +................ + + *Synopsis* + boolean bfd_cache_init (bfd *abfd); + *Description* +Add a newly opened BFD to the cache. + +`bfd_cache_close' +................. + + *Synopsis* + boolean bfd_cache_close (bfd *abfd); + *Description* +Remove the BFD ABFD from the cache. If the attached file is open, then +close it too. + + *Returns* +`false' is returned if closing the file fails, `true' is returned if +all is well. + +`bfd_open_file' +............... + + *Synopsis* + FILE* bfd_open_file(bfd *abfd); + *Description* +Call the OS to open a file for ABFD. Return the `FILE *' (possibly +`NULL') that results from this operation. Set up the BFD so that +future accesses know the file is open. If the `FILE *' returned is +`NULL', then it won't have been put in the cache, so it won't have to +be removed from it. + +`bfd_cache_lookup_worker' +......................... + + *Synopsis* + FILE *bfd_cache_lookup_worker(bfd *abfd); + *Description* +Called when the macro `bfd_cache_lookup' fails to find a quick answer. +Find a file descriptor for ABFD. If necessary, it open it. If there +are already more than `BFD_CACHE_MAX_OPEN' files open, it tries to +close one first, to avoid running out of file descriptors. + + +File: bfd.info, Node: Linker Functions, Next: Hash Tables, Prev: File Caching, Up: BFD front end + +Linker Functions +================ + + The linker uses three special entry points in the BFD target vector. +It is not necessary to write special routines for these entry points +when creating a new BFD back end, since generic versions are provided. +However, writing them can speed up linking and make it use +significantly less runtime memory. + + The first routine creates a hash table used by the other routines. +The second routine adds the symbols from an object file to the hash +table. The third routine takes all the object files and links them +together to create the output file. These routines are designed so +that the linker proper does not need to know anything about the symbols +in the object files that it is linking. The linker merely arranges the +sections as directed by the linker script and lets BFD handle the +details of symbols and relocs. + + The second routine and third routines are passed a pointer to a +`struct bfd_link_info' structure (defined in `bfdlink.h') which holds +information relevant to the link, including the linker hash table +(which was created by the first routine) and a set of callback +functions to the linker proper. + + The generic linker routines are in `linker.c', and use the header +file `genlink.h'. As of this writing, the only back ends which have +implemented versions of these routines are a.out (in `aoutx.h') and +ECOFF (in `ecoff.c'). The a.out routines are used as examples +throughout this section. + +* Menu: + +* Creating a Linker Hash Table:: +* Adding Symbols to the Hash Table:: +* Performing the Final Link:: + + +File: bfd.info, Node: Creating a Linker Hash Table, Next: Adding Symbols to the Hash Table, Prev: Linker Functions, Up: Linker Functions + +Creating a linker hash table +---------------------------- + + The linker routines must create a hash table, which must be derived +from `struct bfd_link_hash_table' described in `bfdlink.c'. *Note Hash +Tables::, for information on how to create a derived hash table. This +entry point is called using the target vector of the linker output file. + + The `_bfd_link_hash_table_create' entry point must allocate and +initialize an instance of the desired hash table. If the back end does +not require any additional information to be stored with the entries in +the hash table, the entry point may simply create a `struct +bfd_link_hash_table'. Most likely, however, some additional +information will be needed. + + For example, with each entry in the hash table the a.out linker +keeps the index the symbol has in the final output file (this index +number is used so that when doing a relocateable link the symbol index +used in the output file can be quickly filled in when copying over a +reloc). The a.out linker code defines the required structures and +functions for a hash table derived from `struct bfd_link_hash_table'. +The a.out linker hash table is created by the function +`NAME(aout,link_hash_table_create)'; it simply allocates space for the +hash table, initializes it, and returns a pointer to it. + + When writing the linker routines for a new back end, you will +generally not know exactly which fields will be required until you have +finished. You should simply create a new hash table which defines no +additional fields, and then simply add fields as they become necessary. + + +File: bfd.info, Node: Adding Symbols to the Hash Table, Next: Performing the Final Link, Prev: Creating a Linker Hash Table, Up: Linker Functions + +Adding symbols to the hash table +-------------------------------- + + The linker proper will call the `_bfd_link_add_symbols' entry point +for each object file or archive which is to be linked (typically these +are the files named on the command line, but some may also come from +the linker script). The entry point is responsible for examining the +file. For an object file, BFD must add any relevant symbol information +to the hash table. For an archive, BFD must determine which elements +of the archive should be used and adding them to the link. + + The a.out version of this entry point is +`NAME(aout,link_add_symbols)'. + +* Menu: + +* Differing file formats:: +* Adding symbols from an object file:: +* Adding symbols from an archive:: + diff --git a/bfd/doc/bfd.info-5 b/bfd/doc/bfd.info-5 new file mode 100644 index 00000000000..bfb707caeb5 --- /dev/null +++ b/bfd/doc/bfd.info-5 @@ -0,0 +1,736 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: bfd.info, Node: Differing file formats, Next: Adding symbols from an object file, Prev: Adding Symbols to the Hash Table, Up: Adding Symbols to the Hash Table + +Differing file formats +...................... + + Normally all the files involved in a link will be of the same +format, but it is also possible to link together different format +object files, and the back end must support that. The +`_bfd_link_add_symbols' entry point is called via the target vector of +the file to be added. This has an important consequence: the function +may not assume that the hash table is the type created by the +corresponding `_bfd_link_hash_table_create' vector. All the +`_bfd_link_add_symbols' function can assume about the hash table is +that it is derived from `struct bfd_link_hash_table'. + + Sometimes the `_bfd_link_add_symbols' function must store some +information in the hash table entry to be used by the `_bfd_final_link' +function. In such a case the `creator' field of the hash table must be +checked to make sure that the hash table was created by an object file +of the same format. + + The `_bfd_final_link' routine must be prepared to handle a hash +entry without any extra information added by the +`_bfd_link_add_symbols' function. A hash entry without extra +information will also occur when the linker script directs the linker +to create a symbol. Note that, regardless of how a hash table entry is +added, all the fields will be initialized to some sort of null value by +the hash table entry initialization function. + + See `ecoff_link_add_externals' for an example of how to check the +`creator' field before saving information (in this case, the ECOFF +external symbol debugging information) in a hash table entry. + + +File: bfd.info, Node: Adding symbols from an object file, Next: Adding symbols from an archive, Prev: Differing file formats, Up: Adding Symbols to the Hash Table + +Adding symbols from an object file +.................................. + + When the `_bfd_link_add_symbols' routine is passed an object file, +it must add all externally visible symbols in that object file to the +hash table. The actual work of adding the symbol to the hash table is +normally handled by the function `_bfd_generic_link_add_one_symbol'. +The `_bfd_link_add_symbols' routine is responsible for reading all the +symbols from the object file and passing the correct information to +`_bfd_generic_link_add_one_symbol'. + + The `_bfd_link_add_symbols' routine should not use +`bfd_canonicalize_symtab' to read the symbols. The point of providing +this routine is to avoid the overhead of converting the symbols into +generic `asymbol' structures. + + `_bfd_generic_link_add_one_symbol' handles the details of combining +common symbols, warning about multiple definitions, and so forth. It +takes arguments which describe the symbol to add, notably symbol flags, +a section, and an offset. The symbol flags include such things as +`BSF_WEAK' or `BSF_INDIRECT'. The section is a section in the object +file, or something like `bfd_und_section_ptr' for an undefined symbol +or `bfd_com_section_ptr' for a common symbol. + + If the `_bfd_final_link' routine is also going to need to read the +symbol information, the `_bfd_link_add_symbols' routine should save it +somewhere attached to the object file BFD. However, the information +should only be saved if the `keep_memory' field of the `info' argument +is true, so that the `-no-keep-memory' linker switch is effective. + + The a.out function which adds symbols from an object file is +`aout_link_add_object_symbols', and most of the interesting work is in +`aout_link_add_symbols'. The latter saves pointers to the hash tables +entries created by `_bfd_generic_link_add_one_symbol' indexed by symbol +number, so that the `_bfd_final_link' routine does not have to call the +hash table lookup routine to locate the entry. + + +File: bfd.info, Node: Adding symbols from an archive, Prev: Adding symbols from an object file, Up: Adding Symbols to the Hash Table + +Adding symbols from an archive +.............................. + + When the `_bfd_link_add_symbols' routine is passed an archive, it +must look through the symbols defined by the archive and decide which +elements of the archive should be included in the link. For each such +element it must call the `add_archive_element' linker callback, and it +must add the symbols from the object file to the linker hash table. + + In most cases the work of looking through the symbols in the archive +should be done by the `_bfd_generic_link_add_archive_symbols' function. +This function builds a hash table from the archive symbol table and +looks through the list of undefined symbols to see which elements +should be included. `_bfd_generic_link_add_archive_symbols' is passed +a function to call to make the final decision about adding an archive +element to the link and to do the actual work of adding the symbols to +the linker hash table. + + The function passed to `_bfd_generic_link_add_archive_symbols' must +read the symbols of the archive element and decide whether the archive +element should be included in the link. If the element is to be +included, the `add_archive_element' linker callback routine must be +called with the element as an argument, and the elements symbols must +be added to the linker hash table just as though the element had itself +been passed to the `_bfd_link_add_symbols' function. + + When the a.out `_bfd_link_add_symbols' function receives an archive, +it calls `_bfd_generic_link_add_archive_symbols' passing +`aout_link_check_archive_element' as the function argument. +`aout_link_check_archive_element' calls `aout_link_check_ar_symbols'. +If the latter decides to add the element (an element is only added if +it provides a real, non-common, definition for a previously undefined +or common symbol) it calls the `add_archive_element' callback and then +`aout_link_check_archive_element' calls `aout_link_add_symbols' to +actually add the symbols to the linker hash table. + + The ECOFF back end is unusual in that it does not normally call +`_bfd_generic_link_add_archive_symbols', because ECOFF archives already +contain a hash table of symbols. The ECOFF back end searches the +archive itself to avoid the overhead of creating a new hash table. + + +File: bfd.info, Node: Performing the Final Link, Prev: Adding Symbols to the Hash Table, Up: Linker Functions + +Performing the final link +------------------------- + + When all the input files have been processed, the linker calls the +`_bfd_final_link' entry point of the output BFD. This routine is +responsible for producing the final output file, which has several +aspects. It must relocate the contents of the input sections and copy +the data into the output sections. It must build an output symbol +table including any local symbols from the input files and the global +symbols from the hash table. When producing relocateable output, it +must modify the input relocs and write them into the output file. +There may also be object format dependent work to be done. + + The linker will also call the `write_object_contents' entry point +when the BFD is closed. The two entry points must work together in +order to produce the correct output file. + + The details of how this works are inevitably dependent upon the +specific object file format. The a.out `_bfd_final_link' routine is +`NAME(aout,final_link)'. + +* Menu: + +* Information provided by the linker:: +* Relocating the section contents:: +* Writing the symbol table:: + + +File: bfd.info, Node: Information provided by the linker, Next: Relocating the section contents, Prev: Performing the Final Link, Up: Performing the Final Link + +Information provided by the linker +.................................. + + Before the linker calls the `_bfd_final_link' entry point, it sets +up some data structures for the function to use. + + The `input_bfds' field of the `bfd_link_info' structure will point +to a list of all the input files included in the link. These files are +linked through the `link_next' field of the `bfd' structure. + + Each section in the output file will have a list of `link_order' +structures attached to the `link_order_head' field (the `link_order' +structure is defined in `bfdlink.h'). These structures describe how to +create the contents of the output section in terms of the contents of +various input sections, fill constants, and, eventually, other types of +information. They also describe relocs that must be created by the BFD +backend, but do not correspond to any input file; this is used to +support -Ur, which builds constructors while generating a relocateable +object file. + + +File: bfd.info, Node: Relocating the section contents, Next: Writing the symbol table, Prev: Information provided by the linker, Up: Performing the Final Link + +Relocating the section contents +............................... + + The `_bfd_final_link' function should look through the `link_order' +structures attached to each section of the output file. Each +`link_order' structure should either be handled specially, or it should +be passed to the function `_bfd_default_link_order' which will do the +right thing (`_bfd_default_link_order' is defined in `linker.c'). + + For efficiency, a `link_order' of type `bfd_indirect_link_order' +whose associated section belongs to a BFD of the same format as the +output BFD must be handled specially. This type of `link_order' +describes part of an output section in terms of a section belonging to +one of the input files. The `_bfd_final_link' function should read the +contents of the section and any associated relocs, apply the relocs to +the section contents, and write out the modified section contents. If +performing a relocateable link, the relocs themselves must also be +modified and written out. + + The functions `_bfd_relocate_contents' and +`_bfd_final_link_relocate' provide some general support for performing +the actual relocations, notably overflow checking. Their arguments +include information about the symbol the relocation is against and a +`reloc_howto_type' argument which describes the relocation to perform. +These functions are defined in `reloc.c'. + + The a.out function which handles reading, relocating, and writing +section contents is `aout_link_input_section'. The actual relocation +is done in `aout_link_input_section_std' and +`aout_link_input_section_ext'. + + +File: bfd.info, Node: Writing the symbol table, Prev: Relocating the section contents, Up: Performing the Final Link + +Writing the symbol table +........................ + + The `_bfd_final_link' function must gather all the symbols in the +input files and write them out. It must also write out all the symbols +in the global hash table. This must be controlled by the `strip' and +`discard' fields of the `bfd_link_info' structure. + + The local symbols of the input files will not have been entered into +the linker hash table. The `_bfd_final_link' routine must consider +each input file and include the symbols in the output file. It may be +convenient to do this when looking through the `link_order' structures, +or it may be done by stepping through the `input_bfds' list. + + The `_bfd_final_link' routine must also traverse the global hash +table to gather all the externally visible symbols. It is possible +that most of the externally visible symbols may be written out when +considering the symbols of each input file, but it is still necessary +to traverse the hash table since the linker script may have defined +some symbols that are not in any of the input files. + + The `strip' field of the `bfd_link_info' structure controls which +symbols are written out. The possible values are listed in +`bfdlink.h'. If the value is `strip_some', then the `keep_hash' field +of the `bfd_link_info' structure is a hash table of symbols to keep; +each symbol should be looked up in this hash table, and only symbols +which are present should be included in the output file. + + If the `strip' field of the `bfd_link_info' structure permits local +symbols to be written out, the `discard' field is used to further +controls which local symbols are included in the output file. If the +value is `discard_l', then all local symbols which begin with a certain +prefix are discarded; this is controlled by the +`bfd_is_local_label_name' entry point. + + The a.out backend handles symbols by calling +`aout_link_write_symbols' on each input BFD and then traversing the +global hash table with the function `aout_link_write_other_symbol'. It +builds a string table while writing out the symbols, which is written +to the output file at the end of `NAME(aout,final_link)'. + +`bfd_link_split_section' +........................ + + *Synopsis* + boolean bfd_link_split_section(bfd *abfd, asection *sec); + *Description* +Return nonzero if SEC should be split during a reloceatable or final +link. + #define bfd_link_split_section(abfd, sec) \ + BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec)) + + +File: bfd.info, Node: Hash Tables, Prev: Linker Functions, Up: BFD front end + +Hash Tables +=========== + + BFD provides a simple set of hash table functions. Routines are +provided to initialize a hash table, to free a hash table, to look up a +string in a hash table and optionally create an entry for it, and to +traverse a hash table. There is currently no routine to delete an +string from a hash table. + + The basic hash table does not permit any data to be stored with a +string. However, a hash table is designed to present a base class from +which other types of hash tables may be derived. These derived types +may store additional information with the string. Hash tables were +implemented in this way, rather than simply providing a data pointer in +a hash table entry, because they were designed for use by the linker +back ends. The linker may create thousands of hash table entries, and +the overhead of allocating private data and storing and following +pointers becomes noticeable. + + The basic hash table code is in `hash.c'. + +* Menu: + +* Creating and Freeing a Hash Table:: +* Looking Up or Entering a String:: +* Traversing a Hash Table:: +* Deriving a New Hash Table Type:: + + +File: bfd.info, Node: Creating and Freeing a Hash Table, Next: Looking Up or Entering a String, Prev: Hash Tables, Up: Hash Tables + +Creating and freeing a hash table +--------------------------------- + + To create a hash table, create an instance of a `struct +bfd_hash_table' (defined in `bfd.h') and call `bfd_hash_table_init' (if +you know approximately how many entries you will need, the function +`bfd_hash_table_init_n', which takes a SIZE argument, may be used). +`bfd_hash_table_init' returns `false' if some sort of error occurs. + + The function `bfd_hash_table_init' take as an argument a function to +use to create new entries. For a basic hash table, use the function +`bfd_hash_newfunc'. *Note Deriving a New Hash Table Type::, for why +you would want to use a different value for this argument. + + `bfd_hash_table_init' will create an objalloc which will be used to +allocate new entries. You may allocate memory on this objalloc using +`bfd_hash_allocate'. + + Use `bfd_hash_table_free' to free up all the memory that has been +allocated for a hash table. This will not free up the `struct +bfd_hash_table' itself, which you must provide. + + +File: bfd.info, Node: Looking Up or Entering a String, Next: Traversing a Hash Table, Prev: Creating and Freeing a Hash Table, Up: Hash Tables + +Looking up or entering a string +------------------------------- + + The function `bfd_hash_lookup' is used both to look up a string in +the hash table and to create a new entry. + + If the CREATE argument is `false', `bfd_hash_lookup' will look up a +string. If the string is found, it will returns a pointer to a `struct +bfd_hash_entry'. If the string is not found in the table +`bfd_hash_lookup' will return `NULL'. You should not modify any of the +fields in the returns `struct bfd_hash_entry'. + + If the CREATE argument is `true', the string will be entered into +the hash table if it is not already there. Either way a pointer to a +`struct bfd_hash_entry' will be returned, either to the existing +structure or to a newly created one. In this case, a `NULL' return +means that an error occurred. + + If the CREATE argument is `true', and a new entry is created, the +COPY argument is used to decide whether to copy the string onto the +hash table objalloc or not. If COPY is passed as `false', you must be +careful not to deallocate or modify the string as long as the hash table +exists. + + +File: bfd.info, Node: Traversing a Hash Table, Next: Deriving a New Hash Table Type, Prev: Looking Up or Entering a String, Up: Hash Tables + +Traversing a hash table +----------------------- + + The function `bfd_hash_traverse' may be used to traverse a hash +table, calling a function on each element. The traversal is done in a +random order. + + `bfd_hash_traverse' takes as arguments a function and a generic +`void *' pointer. The function is called with a hash table entry (a +`struct bfd_hash_entry *') and the generic pointer passed to +`bfd_hash_traverse'. The function must return a `boolean' value, which +indicates whether to continue traversing the hash table. If the +function returns `false', `bfd_hash_traverse' will stop the traversal +and return immediately. + + +File: bfd.info, Node: Deriving a New Hash Table Type, Prev: Traversing a Hash Table, Up: Hash Tables + +Deriving a new hash table type +------------------------------ + + Many uses of hash tables want to store additional information which +each entry in the hash table. Some also find it convenient to store +additional information with the hash table itself. This may be done +using a derived hash table. + + Since C is not an object oriented language, creating a derived hash +table requires sticking together some boilerplate routines with a few +differences specific to the type of hash table you want to create. + + An example of a derived hash table is the linker hash table. The +structures for this are defined in `bfdlink.h'. The functions are in +`linker.c'. + + You may also derive a hash table from an already derived hash table. +For example, the a.out linker backend code uses a hash table derived +from the linker hash table. + +* Menu: + +* Define the Derived Structures:: +* Write the Derived Creation Routine:: +* Write Other Derived Routines:: + + +File: bfd.info, Node: Define the Derived Structures, Next: Write the Derived Creation Routine, Prev: Deriving a New Hash Table Type, Up: Deriving a New Hash Table Type + +Define the derived structures +............................. + + You must define a structure for an entry in the hash table, and a +structure for the hash table itself. + + The first field in the structure for an entry in the hash table must +be of the type used for an entry in the hash table you are deriving +from. If you are deriving from a basic hash table this is `struct +bfd_hash_entry', which is defined in `bfd.h'. The first field in the +structure for the hash table itself must be of the type of the hash +table you are deriving from itself. If you are deriving from a basic +hash table, this is `struct bfd_hash_table'. + + For example, the linker hash table defines `struct +bfd_link_hash_entry' (in `bfdlink.h'). The first field, `root', is of +type `struct bfd_hash_entry'. Similarly, the first field in `struct +bfd_link_hash_table', `table', is of type `struct bfd_hash_table'. + + +File: bfd.info, Node: Write the Derived Creation Routine, Next: Write Other Derived Routines, Prev: Define the Derived Structures, Up: Deriving a New Hash Table Type + +Write the derived creation routine +.................................. + + You must write a routine which will create and initialize an entry +in the hash table. This routine is passed as the function argument to +`bfd_hash_table_init'. + + In order to permit other hash tables to be derived from the hash +table you are creating, this routine must be written in a standard way. + + The first argument to the creation routine is a pointer to a hash +table entry. This may be `NULL', in which case the routine should +allocate the right amount of space. Otherwise the space has already +been allocated by a hash table type derived from this one. + + After allocating space, the creation routine must call the creation +routine of the hash table type it is derived from, passing in a pointer +to the space it just allocated. This will initialize any fields used +by the base hash table. + + Finally the creation routine must initialize any local fields for +the new hash table type. + + Here is a boilerplate example of a creation routine. FUNCTION_NAME +is the name of the routine. ENTRY_TYPE is the type of an entry in the +hash table you are creating. BASE_NEWFUNC is the name of the creation +routine of the hash table type your hash table is derived from. + + struct bfd_hash_entry * + FUNCTION_NAME (entry, table, string) + struct bfd_hash_entry *entry; + struct bfd_hash_table *table; + const char *string; + { + struct ENTRY_TYPE *ret = (ENTRY_TYPE *) entry; + + /* Allocate the structure if it has not already been allocated by a + derived class. */ + if (ret == (ENTRY_TYPE *) NULL) + { + ret = ((ENTRY_TYPE *) + bfd_hash_allocate (table, sizeof (ENTRY_TYPE))); + if (ret == (ENTRY_TYPE *) NULL) + return NULL; + } + + /* Call the allocation method of the base class. */ + ret = ((ENTRY_TYPE *) + BASE_NEWFUNC ((struct bfd_hash_entry *) ret, table, string)); + + /* Initialize the local fields here. */ + + return (struct bfd_hash_entry *) ret; + } + *Description* +The creation routine for the linker hash table, which is in `linker.c', +looks just like this example. FUNCTION_NAME is +`_bfd_link_hash_newfunc'. ENTRY_TYPE is `struct bfd_link_hash_entry'. +BASE_NEWFUNC is `bfd_hash_newfunc', the creation routine for a basic +hash table. + + `_bfd_link_hash_newfunc' also initializes the local fields in a +linker hash table entry: `type', `written' and `next'. + + +File: bfd.info, Node: Write Other Derived Routines, Prev: Write the Derived Creation Routine, Up: Deriving a New Hash Table Type + +Write other derived routines +............................ + + You will want to write other routines for your new hash table, as +well. + + You will want an initialization routine which calls the +initialization routine of the hash table you are deriving from and +initializes any other local fields. For the linker hash table, this is +`_bfd_link_hash_table_init' in `linker.c'. + + You will want a lookup routine which calls the lookup routine of the +hash table you are deriving from and casts the result. The linker hash +table uses `bfd_link_hash_lookup' in `linker.c' (this actually takes an +additional argument which it uses to decide how to return the looked up +value). + + You may want a traversal routine. This should just call the +traversal routine of the hash table you are deriving from with +appropriate casts. The linker hash table uses `bfd_link_hash_traverse' +in `linker.c'. + + These routines may simply be defined as macros. For example, the +a.out backend linker hash table, which is derived from the linker hash +table, uses macros for the lookup and traversal routines. These are +`aout_link_hash_lookup' and `aout_link_hash_traverse' in aoutx.h. + + +File: bfd.info, Node: BFD back ends, Next: Index, Prev: BFD front end, Up: Top + +BFD back ends +************* + +* Menu: + +* What to Put Where:: +* aout :: a.out backends +* coff :: coff backends +* elf :: elf backends + + +File: bfd.info, Node: What to Put Where, Next: aout, Prev: BFD back ends, Up: BFD back ends + + All of BFD lives in one directory. + + +File: bfd.info, Node: aout, Next: coff, Prev: What to Put Where, Up: BFD back ends + +a.out backends +============== + + *Description* +BFD supports a number of different flavours of a.out format, though the +major differences are only the sizes of the structures on disk, and the +shape of the relocation information. + + The support is split into a basic support file `aoutx.h' and other +files which derive functions from the base. One derivation file is +`aoutf1.h' (for a.out flavour 1), and adds to the basic a.out functions +support for sun3, sun4, 386 and 29k a.out files, to create a target +jump vector for a specific target. + + This information is further split out into more specific files for +each machine, including `sunos.c' for sun3 and sun4, `newsos3.c' for +the Sony NEWS, and `demo64.c' for a demonstration of a 64 bit a.out +format. + + The base file `aoutx.h' defines general mechanisms for reading and +writing records to and from disk and various other methods which BFD +requires. It is included by `aout32.c' and `aout64.c' to form the names +`aout_32_swap_exec_header_in', `aout_64_swap_exec_header_in', etc. + + As an example, this is what goes on to make the back end for a sun4, +from `aout32.c': + + #define ARCH_SIZE 32 + #include "aoutx.h" + + Which exports names: + + ... + aout_32_canonicalize_reloc + aout_32_find_nearest_line + aout_32_get_lineno + aout_32_get_reloc_upper_bound + ... + + from `sunos.c': + + #define TARGET_NAME "a.out-sunos-big" + #define VECNAME sunos_big_vec + #include "aoutf1.h" + + requires all the names from `aout32.c', and produces the jump vector + + sunos_big_vec + + The file `host-aout.c' is a special case. It is for a large set of +hosts that use "more or less standard" a.out files, and for which +cross-debugging is not interesting. It uses the standard 32-bit a.out +support routines, but determines the file offsets and addresses of the +text, data, and BSS sections, the machine architecture and machine +type, and the entry point address, in a host-dependent manner. Once +these values have been determined, generic code is used to handle the +object file. + + When porting it to run on a new system, you must supply: + + HOST_PAGE_SIZE + HOST_SEGMENT_SIZE + HOST_MACHINE_ARCH (optional) + HOST_MACHINE_MACHINE (optional) + HOST_TEXT_START_ADDR + HOST_STACK_END_ADDR + + in the file `../include/sys/h-XXX.h' (for your host). These values, +plus the structures and macros defined in `a.out.h' on your host +system, will produce a BFD target that will access ordinary a.out files +on your host. To configure a new machine to use `host-aout.c', specify: + + TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec + TDEPFILES= host-aout.o trad-core.o + + in the `config/XXX.mt' file, and modify `configure.in' to use the +`XXX.mt' file (by setting "`bfd_target=XXX'") when your configuration +is selected. + +Relocations +----------- + + *Description* +The file `aoutx.h' provides for both the _standard_ and _extended_ +forms of a.out relocation records. + + The standard records contain only an address, a symbol index, and a +type field. The extended records (used on 29ks and sparcs) also have a +full integer for an addend. + +Internal entry points +--------------------- + + *Description* +`aoutx.h' exports several routines for accessing the contents of an +a.out file, which are gathered and exported in turn by various format +specific files (eg sunos.c). + +`aout_SIZE_swap_exec_header_in' +............................... + + *Synopsis* + void aout_SIZE_swap_exec_header_in, + (bfd *abfd, + struct external_exec *raw_bytes, + struct internal_exec *execp); + *Description* +Swap the information in an executable header RAW_BYTES taken from a raw +byte stream memory image into the internal exec header structure EXECP. + +`aout_SIZE_swap_exec_header_out' +................................ + + *Synopsis* + void aout_SIZE_swap_exec_header_out + (bfd *abfd, + struct internal_exec *execp, + struct external_exec *raw_bytes); + *Description* +Swap the information in an internal exec header structure EXECP into +the buffer RAW_BYTES ready for writing to disk. + +`aout_SIZE_some_aout_object_p' +.............................. + + *Synopsis* + const bfd_target *aout_SIZE_some_aout_object_p + (bfd *abfd, + const bfd_target *(*callback_to_real_object_p)()); + *Description* +Some a.out variant thinks that the file open in ABFD checking is an +a.out file. Do some more checking, and set up for access if it really +is. Call back to the calling environment's "finish up" function just +before returning, to handle any last-minute setup. + +`aout_SIZE_mkobject' +.................... + + *Synopsis* + boolean aout_SIZE_mkobject, (bfd *abfd); + *Description* +Initialize BFD ABFD for use with a.out files. + +`aout_SIZE_machine_type' +........................ + + *Synopsis* + enum machine_type aout_SIZE_machine_type + (enum bfd_architecture arch, + unsigned long machine)); + *Description* +Keep track of machine architecture and machine type for a.out's. Return +the `machine_type' for a particular architecture and machine, or +`M_UNKNOWN' if that exact architecture and machine can't be represented +in a.out format. + + If the architecture is understood, machine type 0 (default) is +always understood. + +`aout_SIZE_set_arch_mach' +......................... + + *Synopsis* + boolean aout_SIZE_set_arch_mach, + (bfd *, + enum bfd_architecture arch, + unsigned long machine)); + *Description* +Set the architecture and the machine of the BFD ABFD to the values ARCH +and MACHINE. Verify that ABFD's format can support the architecture +required. + +`aout_SIZE_new_section_hook' +............................ + + *Synopsis* + boolean aout_SIZE_new_section_hook, + (bfd *abfd, + asection *newsect)); + *Description* +Called by the BFD in response to a `bfd_make_section' request. + diff --git a/bfd/doc/bfd.info-6 b/bfd/doc/bfd.info-6 new file mode 100644 index 00000000000..0c59a3dc63d --- /dev/null +++ b/bfd/doc/bfd.info-6 @@ -0,0 +1,683 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: bfd.info, Node: coff, Next: elf, Prev: aout, Up: BFD back ends + +coff backends +============= + + BFD supports a number of different flavours of coff format. The +major differences between formats are the sizes and alignments of +fields in structures on disk, and the occasional extra field. + + Coff in all its varieties is implemented with a few common files and +a number of implementation specific files. For example, The 88k bcs +coff format is implemented in the file `coff-m88k.c'. This file +`#include's `coff/m88k.h' which defines the external structure of the +coff format for the 88k, and `coff/internal.h' which defines the +internal structure. `coff-m88k.c' also defines the relocations used by +the 88k format *Note Relocations::. + + The Intel i960 processor version of coff is implemented in +`coff-i960.c'. This file has the same structure as `coff-m88k.c', +except that it includes `coff/i960.h' rather than `coff-m88k.h'. + +Porting to a new version of coff +-------------------------------- + + The recommended method is to select from the existing +implementations the version of coff which is most like the one you want +to use. For example, we'll say that i386 coff is the one you select, +and that your coff flavour is called foo. Copy `i386coff.c' to +`foocoff.c', copy `../include/coff/i386.h' to `../include/coff/foo.h', +and add the lines to `targets.c' and `Makefile.in' so that your new +back end is used. Alter the shapes of the structures in +`../include/coff/foo.h' so that they match what you need. You will +probably also have to add `#ifdef's to the code in `coff/internal.h' and +`coffcode.h' if your version of coff is too wild. + + You can verify that your new BFD backend works quite simply by +building `objdump' from the `binutils' directory, and making sure that +its version of what's going on and your host system's idea (assuming it +has the pretty standard coff dump utility, usually called `att-dump' or +just `dump') are the same. Then clean up your code, and send what +you've done to Cygnus. Then your stuff will be in the next release, and +you won't have to keep integrating it. + +How the coff backend works +-------------------------- + +File layout +........... + + The Coff backend is split into generic routines that are applicable +to any Coff target and routines that are specific to a particular +target. The target-specific routines are further split into ones which +are basically the same for all Coff targets except that they use the +external symbol format or use different values for certain constants. + + The generic routines are in `coffgen.c'. These routines work for +any Coff target. They use some hooks into the target specific code; +the hooks are in a `bfd_coff_backend_data' structure, one of which +exists for each target. + + The essentially similar target-specific routines are in +`coffcode.h'. This header file includes executable C code. The +various Coff targets first include the appropriate Coff header file, +make any special defines that are needed, and then include `coffcode.h'. + + Some of the Coff targets then also have additional routines in the +target source file itself. + + For example, `coff-i960.c' includes `coff/internal.h' and +`coff/i960.h'. It then defines a few constants, such as `I960', and +includes `coffcode.h'. Since the i960 has complex relocation types, +`coff-i960.c' also includes some code to manipulate the i960 relocs. +This code is not in `coffcode.h' because it would not be used by any +other target. + +Bit twiddling +............. + + Each flavour of coff supported in BFD has its own header file +describing the external layout of the structures. There is also an +internal description of the coff layout, in `coff/internal.h'. A major +function of the coff backend is swapping the bytes and twiddling the +bits to translate the external form of the structures into the normal +internal form. This is all performed in the `bfd_swap'_thing_direction +routines. Some elements are different sizes between different versions +of coff; it is the duty of the coff version specific include file to +override the definitions of various packing routines in `coffcode.h'. +E.g., the size of line number entry in coff is sometimes 16 bits, and +sometimes 32 bits. `#define'ing `PUT_LNSZ_LNNO' and `GET_LNSZ_LNNO' +will select the correct one. No doubt, some day someone will find a +version of coff which has a varying field size not catered to at the +moment. To port BFD, that person will have to add more `#defines'. +Three of the bit twiddling routines are exported to `gdb'; +`coff_swap_aux_in', `coff_swap_sym_in' and `coff_swap_lineno_in'. `GDB' +reads the symbol table on its own, but uses BFD to fix things up. More +of the bit twiddlers are exported for `gas'; `coff_swap_aux_out', +`coff_swap_sym_out', `coff_swap_lineno_out', `coff_swap_reloc_out', +`coff_swap_filehdr_out', `coff_swap_aouthdr_out', +`coff_swap_scnhdr_out'. `Gas' currently keeps track of all the symbol +table and reloc drudgery itself, thereby saving the internal BFD +overhead, but uses BFD to swap things on the way out, making cross +ports much safer. Doing so also allows BFD (and thus the linker) to +use the same header files as `gas', which makes one avenue to disaster +disappear. + +Symbol reading +.............. + + The simple canonical form for symbols used by BFD is not rich enough +to keep all the information available in a coff symbol table. The back +end gets around this problem by keeping the original symbol table +around, "behind the scenes". + + When a symbol table is requested (through a call to +`bfd_canonicalize_symtab'), a request gets through to +`coff_get_normalized_symtab'. This reads the symbol table from the coff +file and swaps all the structures inside into the internal form. It +also fixes up all the pointers in the table (represented in the file by +offsets from the first symbol in the table) into physical pointers to +elements in the new internal table. This involves some work since the +meanings of fields change depending upon context: a field that is a +pointer to another structure in the symbol table at one moment may be +the size in bytes of a structure at the next. Another pass is made +over the table. All symbols which mark file names (`C_FILE' symbols) +are modified so that the internal string points to the value in the +auxent (the real filename) rather than the normal text associated with +the symbol (`".file"'). + + At this time the symbol names are moved around. Coff stores all +symbols less than nine characters long physically within the symbol +table; longer strings are kept at the end of the file in the string +table. This pass moves all strings into memory and replaces them with +pointers to the strings. + + The symbol table is massaged once again, this time to create the +canonical table used by the BFD application. Each symbol is inspected +in turn, and a decision made (using the `sclass' field) about the +various flags to set in the `asymbol'. *Note Symbols::. The generated +canonical table shares strings with the hidden internal symbol table. + + Any linenumbers are read from the coff file too, and attached to the +symbols which own the functions the linenumbers belong to. + +Symbol writing +.............. + + Writing a symbol to a coff file which didn't come from a coff file +will lose any debugging information. The `asymbol' structure remembers +the BFD from which the symbol was taken, and on output the back end +makes sure that the same destination target as source target is present. + + When the symbols have come from a coff file then all the debugging +information is preserved. + + Symbol tables are provided for writing to the back end in a vector +of pointers to pointers. This allows applications like the linker to +accumulate and output large symbol tables without having to do too much +byte copying. + + This function runs through the provided symbol table and patches +each symbol marked as a file place holder (`C_FILE') to point to the +next file place holder in the list. It also marks each `offset' field +in the list with the offset from the first symbol of the current symbol. + + Another function of this procedure is to turn the canonical value +form of BFD into the form used by coff. Internally, BFD expects symbol +values to be offsets from a section base; so a symbol physically at +0x120, but in a section starting at 0x100, would have the value 0x20. +Coff expects symbols to contain their final value, so symbols have +their values changed at this point to reflect their sum with their +owning section. This transformation uses the `output_section' field of +the `asymbol''s `asection' *Note Sections::. + + * `coff_mangle_symbols' + This routine runs though the provided symbol table and uses the +offsets generated by the previous pass and the pointers generated when +the symbol table was read in to create the structured hierachy required +by coff. It changes each pointer to a symbol into the index into the +symbol table of the asymbol. + + * `coff_write_symbols' + This routine runs through the symbol table and patches up the +symbols from their internal form into the coff way, calls the bit +twiddlers, and writes out the table to the file. + +`coff_symbol_type' +.................. + + *Description* +The hidden information for an `asymbol' is described in a +`combined_entry_type': + + + typedef struct coff_ptr_struct + { + + /* Remembers the offset from the first symbol in the file for + this symbol. Generated by coff_renumber_symbols. */ + unsigned int offset; + + /* Should the value of this symbol be renumbered. Used for + XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. */ + unsigned int fix_value : 1; + + /* Should the tag field of this symbol be renumbered. + Created by coff_pointerize_aux. */ + unsigned int fix_tag : 1; + + /* Should the endidx field of this symbol be renumbered. + Created by coff_pointerize_aux. */ + unsigned int fix_end : 1; + + /* Should the x_csect.x_scnlen field be renumbered. + Created by coff_pointerize_aux. */ + unsigned int fix_scnlen : 1; + + /* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the + index into the line number entries. Set by + coff_slurp_symbol_table. */ + unsigned int fix_line : 1; + + /* The container for the symbol structure as read and translated + from the file. */ + + union { + union internal_auxent auxent; + struct internal_syment syment; + } u; + } combined_entry_type; + + + /* Each canonical asymbol really looks like this: */ + + typedef struct coff_symbol_struct + { + /* The actual symbol which the rest of BFD works with */ + asymbol symbol; + + /* A pointer to the hidden information for this symbol */ + combined_entry_type *native; + + /* A pointer to the linenumber information for this symbol */ + struct lineno_cache_entry *lineno; + + /* Have the line numbers been relocated yet ? */ + boolean done_lineno; + } coff_symbol_type; + +`bfd_coff_backend_data' +....................... + + /* COFF symbol classifications. */ + + enum coff_symbol_classification + { + /* Global symbol. */ + COFF_SYMBOL_GLOBAL, + /* Common symbol. */ + COFF_SYMBOL_COMMON, + /* Undefined symbol. */ + COFF_SYMBOL_UNDEFINED, + /* Local symbol. */ + COFF_SYMBOL_LOCAL, + /* PE section symbol. */ + COFF_SYMBOL_PE_SECTION + }; + Special entry points for gdb to swap in coff symbol table parts: + typedef struct + { + void (*_bfd_coff_swap_aux_in) PARAMS (( + bfd *abfd, + PTR ext, + int type, + int class, + int indaux, + int numaux, + PTR in)); + + void (*_bfd_coff_swap_sym_in) PARAMS (( + bfd *abfd , + PTR ext, + PTR in)); + + void (*_bfd_coff_swap_lineno_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + Special entry points for gas to swap out coff parts: + unsigned int (*_bfd_coff_swap_aux_out) PARAMS (( + bfd *abfd, + PTR in, + int type, + int class, + int indaux, + int numaux, + PTR ext)); + + unsigned int (*_bfd_coff_swap_sym_out) PARAMS (( + bfd *abfd, + PTR in, + PTR ext)); + + unsigned int (*_bfd_coff_swap_lineno_out) PARAMS (( + bfd *abfd, + PTR in, + PTR ext)); + + unsigned int (*_bfd_coff_swap_reloc_out) PARAMS (( + bfd *abfd, + PTR src, + PTR dst)); + + unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS (( + bfd *abfd, + PTR in, + PTR out)); + + unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS (( + bfd *abfd, + PTR in, + PTR out)); + + unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS (( + bfd *abfd, + PTR in, + PTR out)); + Special entry points for generic COFF routines to call target +dependent COFF routines: + unsigned int _bfd_filhsz; + unsigned int _bfd_aoutsz; + unsigned int _bfd_scnhsz; + unsigned int _bfd_symesz; + unsigned int _bfd_auxesz; + unsigned int _bfd_relsz; + unsigned int _bfd_linesz; + unsigned int _bfd_filnmlen; + boolean _bfd_coff_long_filenames; + boolean _bfd_coff_long_section_names; + unsigned int _bfd_coff_default_section_alignment_power; + void (*_bfd_coff_swap_filehdr_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + void (*_bfd_coff_swap_aouthdr_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + void (*_bfd_coff_swap_scnhdr_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + void (*_bfd_coff_swap_reloc_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + boolean (*_bfd_coff_bad_format_hook) PARAMS (( + bfd *abfd, + PTR internal_filehdr)); + boolean (*_bfd_coff_set_arch_mach_hook) PARAMS (( + bfd *abfd, + PTR internal_filehdr)); + PTR (*_bfd_coff_mkobject_hook) PARAMS (( + bfd *abfd, + PTR internal_filehdr, + PTR internal_aouthdr)); + flagword (*_bfd_styp_to_sec_flags_hook) PARAMS (( + bfd *abfd, + PTR internal_scnhdr, + const char *name, + asection *section)); + void (*_bfd_set_alignment_hook) PARAMS (( + bfd *abfd, + asection *sec, + PTR internal_scnhdr)); + boolean (*_bfd_coff_slurp_symbol_table) PARAMS (( + bfd *abfd)); + boolean (*_bfd_coff_symname_in_debug) PARAMS (( + bfd *abfd, + struct internal_syment *sym)); + boolean (*_bfd_coff_pointerize_aux_hook) PARAMS (( + bfd *abfd, + combined_entry_type *table_base, + combined_entry_type *symbol, + unsigned int indaux, + combined_entry_type *aux)); + boolean (*_bfd_coff_print_aux) PARAMS (( + bfd *abfd, + FILE *file, + combined_entry_type *table_base, + combined_entry_type *symbol, + combined_entry_type *aux, + unsigned int indaux)); + void (*_bfd_coff_reloc16_extra_cases) PARAMS (( + bfd *abfd, + struct bfd_link_info *link_info, + struct bfd_link_order *link_order, + arelent *reloc, + bfd_byte *data, + unsigned int *src_ptr, + unsigned int *dst_ptr)); + int (*_bfd_coff_reloc16_estimate) PARAMS (( + bfd *abfd, + asection *input_section, + arelent *r, + unsigned int shrink, + struct bfd_link_info *link_info)); + enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS (( + bfd *abfd, + struct internal_syment *)); + boolean (*_bfd_coff_compute_section_file_positions) PARAMS (( + bfd *abfd)); + boolean (*_bfd_coff_start_final_link) PARAMS (( + bfd *output_bfd, + struct bfd_link_info *info)); + boolean (*_bfd_coff_relocate_section) PARAMS (( + bfd *output_bfd, + struct bfd_link_info *info, + bfd *input_bfd, + asection *input_section, + bfd_byte *contents, + struct internal_reloc *relocs, + struct internal_syment *syms, + asection **sections)); + reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS (( + bfd *abfd, + asection *sec, + struct internal_reloc *rel, + struct coff_link_hash_entry *h, + struct internal_syment *sym, + bfd_vma *addendp)); + boolean (*_bfd_coff_adjust_symndx) PARAMS (( + bfd *obfd, + struct bfd_link_info *info, + bfd *ibfd, + asection *sec, + struct internal_reloc *reloc, + boolean *adjustedp)); + boolean (*_bfd_coff_link_add_one_symbol) PARAMS (( + struct bfd_link_info *info, + bfd *abfd, + const char *name, + flagword flags, + asection *section, + bfd_vma value, + const char *string, + boolean copy, + boolean collect, + struct bfd_link_hash_entry **hashp)); + + boolean (*_bfd_coff_link_output_has_begun) PARAMS (( + bfd * abfd, + struct coff_final_link_info * pfinfo)); + boolean (*_bfd_coff_final_link_postscript) PARAMS (( + bfd * abfd, + struct coff_final_link_info * pfinfo)); + + } bfd_coff_backend_data; + + #define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) + + #define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ + ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) + + #define bfd_coff_swap_sym_in(a,e,i) \ + ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) + + #define bfd_coff_swap_lineno_in(a,e,i) \ + ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) + + #define bfd_coff_swap_reloc_out(abfd, i, o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) + + #define bfd_coff_swap_lineno_out(abfd, i, o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) + + #define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ + ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) + + #define bfd_coff_swap_sym_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) + + #define bfd_coff_swap_scnhdr_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) + + #define bfd_coff_swap_filehdr_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) + + #define bfd_coff_swap_aouthdr_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) + + #define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) + #define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) + #define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) + #define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) + #define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) + #define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) + #define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) + #define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) + #define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames) + #define bfd_coff_long_section_names(abfd) \ + (coff_backend_info (abfd)->_bfd_coff_long_section_names) + #define bfd_coff_default_section_alignment_power(abfd) \ + (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) + #define bfd_coff_swap_filehdr_in(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) + + #define bfd_coff_swap_aouthdr_in(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) + + #define bfd_coff_swap_scnhdr_in(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) + + #define bfd_coff_swap_reloc_in(abfd, i, o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) + + #define bfd_coff_bad_format_hook(abfd, filehdr) \ + ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) + + #define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ + ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) + #define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ + ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr)) + + #define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\ + ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ + (abfd, scnhdr, name, section)) + + #define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ + ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) + + #define bfd_coff_slurp_symbol_table(abfd)\ + ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) + + #define bfd_coff_symname_in_debug(abfd, sym)\ + ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) + + #define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ + ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ + (abfd, file, base, symbol, aux, indaux)) + + #define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\ + ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ + (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) + + #define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ + ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ + (abfd, section, reloc, shrink, link_info)) + + #define bfd_coff_classify_symbol(abfd, sym)\ + ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ + (abfd, sym)) + + #define bfd_coff_compute_section_file_positions(abfd)\ + ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ + (abfd)) + + #define bfd_coff_start_final_link(obfd, info)\ + ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ + (obfd, info)) + #define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ + ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ + (obfd, info, ibfd, o, con, rel, isyms, secs)) + #define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ + ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ + (abfd, sec, rel, h, sym, addendp)) + #define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ + ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ + (obfd, info, ibfd, sec, rel, adjustedp)) + #define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\ + ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ + (info, abfd, name, flags, section, value, string, cp, coll, hashp)) + + #define bfd_coff_link_output_has_begun(a,p) \ + ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p)) + #define bfd_coff_final_link_postscript(a,p) \ + ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p)) + +Writing relocations +................... + + To write relocations, the back end steps though the canonical +relocation table and create an `internal_reloc'. The symbol index to +use is removed from the `offset' field in the symbol table supplied. +The address comes directly from the sum of the section base address and +the relocation offset; the type is dug directly from the howto field. +Then the `internal_reloc' is swapped into the shape of an +`external_reloc' and written out to disk. + +Reading linenumbers +................... + + Creating the linenumber table is done by reading in the entire coff +linenumber table, and creating another table for internal use. + + A coff linenumber table is structured so that each function is +marked as having a line number of 0. Each line within the function is +an offset from the first line in the function. The base of the line +number information for the table is stored in the symbol associated +with the function. + + Note: The PE format uses line number 0 for a flag indicating a new +source file. + + The information is copied from the external to the internal table, +and each symbol which marks a function is marked by pointing its... + + How does this work ? + +Reading relocations +................... + + Coff relocations are easily transformed into the internal BFD form +(`arelent'). + + Reading a coff relocation table is done in the following stages: + + * Read the entire coff relocation table into memory. + + * Process each relocation in turn; first swap it from the external + to the internal form. + + * Turn the symbol referenced in the relocation's symbol index into a + pointer into the canonical symbol table. This table is the same + as the one returned by a call to `bfd_canonicalize_symtab'. The + back end will call that routine and save the result if a + canonicalization hasn't been done. + + * The reloc index is turned into a pointer to a howto structure, in + a back end specific way. For instance, the 386 and 960 use the + `r_type' to directly produce an index into a howto table vector; + the 88k subtracts a number from the `r_type' field and creates an + addend field. + + +File: bfd.info, Node: elf, Prev: coff, Up: BFD back ends + +ELF backends +============ + + BFD support for ELF formats is being worked on. Currently, the best +supported back ends are for sparc and i386 (running svr4 or Solaris 2). + + Documentation of the internals of the support code still needs to be +written. The code is changing quickly enough that we haven't bothered +yet. + +`bfd_elf_find_section' +...................... + + *Synopsis* + struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name); + *Description* +Helper functions for GDB to locate the string tables. Since BFD hides +string tables from callers, GDB needs to use an internal hook to find +them. Sun's .stabstr, in particular, isn't even pointed to by the +.stab section, so ordinary mechanisms wouldn't work to find it, even if +we had some. + diff --git a/bfd/doc/bfd.info-7 b/bfd/doc/bfd.info-7 new file mode 100644 index 00000000000..18e8a5d8c89 --- /dev/null +++ b/bfd/doc/bfd.info-7 @@ -0,0 +1,491 @@ +This is bfd.info, produced by makeinfo version 4.0 from bfd.texinfo. + +START-INFO-DIR-ENTRY +* Bfd: (bfd). The Binary File Descriptor library. +END-INFO-DIR-ENTRY + + This file documents the BFD library. + + Copyright (C) 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, subject to the +terms of the GNU General Public License, which includes the provision +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: bfd.info, Node: Index, Prev: BFD back ends, Up: Top + +Index +***** + +* Menu: + +* _bfd_final_link_relocate: Relocating the section contents. +* _bfd_generic_link_add_archive_symbols: Adding symbols from an archive. +* _bfd_generic_link_add_one_symbol: Adding symbols from an object file. +* _bfd_link_add_symbols in target vector: Adding Symbols to the Hash Table. +* _bfd_link_final_link in target vector: Performing the Final Link. +* _bfd_link_hash_table_create in target vector: Creating a Linker Hash Table. +* _bfd_relocate_contents: Relocating the section contents. +* _bfd_strip_section_from_output: section prototypes. +* aout_SIZE_machine_type: aout. +* aout_SIZE_mkobject: aout. +* aout_SIZE_new_section_hook: aout. +* aout_SIZE_set_arch_mach: aout. +* aout_SIZE_some_aout_object_p: aout. +* aout_SIZE_swap_exec_header_in: aout. +* aout_SIZE_swap_exec_header_out: aout. +* arelent_chain: typedef arelent. +* BFD: Overview. +* BFD canonical format: Canonical format. +* bfd_alloc: Opening and Closing. +* bfd_arch_bits_per_address: Architectures. +* bfd_arch_bits_per_byte: Architectures. +* bfd_arch_get_compatible: Architectures. +* bfd_arch_list: Architectures. +* bfd_arch_mach_octets_per_byte: Architectures. +* bfd_cache_close: File Caching. +* bfd_cache_init: File Caching. +* bfd_cache_lookup: File Caching. +* bfd_cache_lookup_worker: File Caching. +* BFD_CACHE_MAX_OPEN macro: File Caching. +* bfd_canonicalize_reloc: BFD front end. +* bfd_canonicalize_symtab: symbol handling functions. +* bfd_check_format: Formats. +* bfd_check_format_matches: Formats. +* bfd_check_overflow: typedef arelent. +* bfd_close: Opening and Closing. +* bfd_close_all_done: Opening and Closing. +* bfd_coff_backend_data: coff. +* bfd_copy_private_bfd_data: BFD front end. +* bfd_copy_private_section_data: section prototypes. +* bfd_copy_private_symbol_data: symbol handling functions. +* bfd_core_file_failing_command: Core Files. +* bfd_core_file_failing_signal: Core Files. +* bfd_create: Opening and Closing. +* bfd_decode_symclass: symbol handling functions. +* bfd_default_arch_struct: Architectures. +* bfd_default_compatible: Architectures. +* bfd_default_reloc_type_lookup: howto manager. +* bfd_default_scan: Architectures. +* bfd_default_set_arch_mach: Architectures. +* bfd_elf_find_section: elf. +* bfd_errmsg: BFD front end. +* bfd_fdopenr: Opening and Closing. +* bfd_find_target: bfd_target. +* bfd_format_string: Formats. +* bfd_generic_gc_sections: howto manager. +* bfd_generic_get_relocated_section_contents: howto manager. +* bfd_generic_relax_section: howto manager. +* bfd_get_arch: Architectures. +* bfd_get_arch_info: Architectures. +* bfd_get_error: BFD front end. +* bfd_get_error_handler: BFD front end. +* bfd_get_gp_size: BFD front end. +* bfd_get_mach: Architectures. +* bfd_get_mtime: BFD front end. +* bfd_get_next_mapent: Archives. +* bfd_get_reloc_code_name: howto manager. +* bfd_get_reloc_size: typedef arelent. +* bfd_get_reloc_upper_bound: BFD front end. +* bfd_get_section_by_name: section prototypes. +* bfd_get_section_contents: section prototypes. +* bfd_get_size <1>: Internal. +* bfd_get_size: BFD front end. +* bfd_get_symtab_upper_bound: symbol handling functions. +* bfd_h_put_size: Internal. +* bfd_hash_allocate: Creating and Freeing a Hash Table. +* bfd_hash_lookup: Looking Up or Entering a String. +* bfd_hash_newfunc: Creating and Freeing a Hash Table. +* bfd_hash_table_free: Creating and Freeing a Hash Table. +* bfd_hash_table_init: Creating and Freeing a Hash Table. +* bfd_hash_table_init_n: Creating and Freeing a Hash Table. +* bfd_hash_traverse: Traversing a Hash Table. +* bfd_init: Initialization. +* bfd_install_relocation: typedef arelent. +* bfd_is_local_label: symbol handling functions. +* bfd_is_local_label_name: symbol handling functions. +* bfd_is_undefined_symclass: symbol handling functions. +* bfd_last_cache: File Caching. +* bfd_link_split_section: Writing the symbol table. +* bfd_log2: Internal. +* bfd_lookup_arch: Architectures. +* bfd_make_debug_symbol: symbol handling functions. +* bfd_make_empty_symbol: symbol handling functions. +* bfd_make_readable: Opening and Closing. +* bfd_make_section: section prototypes. +* bfd_make_section_anyway: section prototypes. +* bfd_make_section_old_way: section prototypes. +* bfd_make_writable: Opening and Closing. +* bfd_map_over_sections: section prototypes. +* bfd_merge_private_bfd_data: BFD front end. +* bfd_octets_per_byte: Architectures. +* bfd_open_file: File Caching. +* bfd_openr: Opening and Closing. +* bfd_openr_next_archived_file: Archives. +* bfd_openstreamr: Opening and Closing. +* bfd_openw: Opening and Closing. +* bfd_perform_relocation: typedef arelent. +* bfd_perror: BFD front end. +* bfd_print_symbol_vandf: symbol handling functions. +* bfd_printable_arch_mach: Architectures. +* bfd_printable_name: Architectures. +* bfd_put_size: Internal. +* BFD_RELOC_12_PCREL: howto manager. +* BFD_RELOC_14: howto manager. +* BFD_RELOC_16: howto manager. +* BFD_RELOC_16_BASEREL: howto manager. +* BFD_RELOC_16_GOT_PCREL: howto manager. +* BFD_RELOC_16_GOTOFF: howto manager. +* BFD_RELOC_16_PCREL: howto manager. +* BFD_RELOC_16_PCREL_S2: howto manager. +* BFD_RELOC_16_PLT_PCREL: howto manager. +* BFD_RELOC_16_PLTOFF: howto manager. +* BFD_RELOC_23_PCREL_S2: howto manager. +* BFD_RELOC_24: howto manager. +* BFD_RELOC_24_PCREL: howto manager. +* BFD_RELOC_24_PLT_PCREL: howto manager. +* BFD_RELOC_26: howto manager. +* BFD_RELOC_32: howto manager. +* BFD_RELOC_32_BASEREL: howto manager. +* BFD_RELOC_32_GOT_PCREL: howto manager. +* BFD_RELOC_32_GOTOFF: howto manager. +* BFD_RELOC_32_PCREL: howto manager. +* BFD_RELOC_32_PCREL_S2: howto manager. +* BFD_RELOC_32_PLT_PCREL: howto manager. +* BFD_RELOC_32_PLTOFF: howto manager. +* BFD_RELOC_386_COPY: howto manager. +* BFD_RELOC_386_GLOB_DAT: howto manager. +* BFD_RELOC_386_GOT32: howto manager. +* BFD_RELOC_386_GOTOFF: howto manager. +* BFD_RELOC_386_GOTPC: howto manager. +* BFD_RELOC_386_JUMP_SLOT: howto manager. +* BFD_RELOC_386_PLT32: howto manager. +* BFD_RELOC_386_RELATIVE: howto manager. +* BFD_RELOC_64: howto manager. +* BFD_RELOC_64_PCREL: howto manager. +* BFD_RELOC_68K_GLOB_DAT: howto manager. +* BFD_RELOC_68K_JMP_SLOT: howto manager. +* BFD_RELOC_68K_RELATIVE: howto manager. +* BFD_RELOC_8: howto manager. +* BFD_RELOC_8_BASEREL: howto manager. +* BFD_RELOC_8_FFnn: howto manager. +* BFD_RELOC_8_GOT_PCREL: howto manager. +* BFD_RELOC_8_GOTOFF: howto manager. +* BFD_RELOC_8_PCREL: howto manager. +* BFD_RELOC_8_PLT_PCREL: howto manager. +* BFD_RELOC_8_PLTOFF: howto manager. +* BFD_RELOC_ALPHA_CODEADDR: howto manager. +* BFD_RELOC_ALPHA_ELF_LITERAL: howto manager. +* BFD_RELOC_ALPHA_GPDISP: howto manager. +* BFD_RELOC_ALPHA_GPDISP_HI16: howto manager. +* BFD_RELOC_ALPHA_GPDISP_LO16: howto manager. +* BFD_RELOC_ALPHA_HINT: howto manager. +* BFD_RELOC_ALPHA_LINKAGE: howto manager. +* BFD_RELOC_ALPHA_LITERAL: howto manager. +* BFD_RELOC_ALPHA_LITUSE: howto manager. +* BFD_RELOC_ALPHA_USER_GPDISP: howto manager. +* BFD_RELOC_ALPHA_USER_GPRELHIGH: howto manager. +* BFD_RELOC_ALPHA_USER_GPRELLOW: howto manager. +* BFD_RELOC_ALPHA_USER_LITERAL: howto manager. +* BFD_RELOC_ALPHA_USER_LITUSE_BASE: howto manager. +* BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF: howto manager. +* BFD_RELOC_ALPHA_USER_LITUSE_JSR: howto manager. +* BFD_RELOC_ARC_B22_PCREL: howto manager. +* BFD_RELOC_ARC_B26: howto manager. +* BFD_RELOC_ARM_ADR_IMM: howto manager. +* BFD_RELOC_ARM_ADRL_IMMEDIATE: howto manager. +* BFD_RELOC_ARM_COPY: howto manager. +* BFD_RELOC_ARM_CP_OFF_IMM: howto manager. +* BFD_RELOC_ARM_GLOB_DAT: howto manager. +* BFD_RELOC_ARM_GOT12: howto manager. +* BFD_RELOC_ARM_GOT32: howto manager. +* BFD_RELOC_ARM_GOTOFF: howto manager. +* BFD_RELOC_ARM_GOTPC: howto manager. +* BFD_RELOC_ARM_HWLITERAL: howto manager. +* BFD_RELOC_ARM_IMMEDIATE: howto manager. +* BFD_RELOC_ARM_IN_POOL: howto manager. +* BFD_RELOC_ARM_JUMP_SLOT: howto manager. +* BFD_RELOC_ARM_LDR_IMM: howto manager. +* BFD_RELOC_ARM_LITERAL: howto manager. +* BFD_RELOC_ARM_MULTI: howto manager. +* BFD_RELOC_ARM_OFFSET_IMM: howto manager. +* BFD_RELOC_ARM_OFFSET_IMM8: howto manager. +* BFD_RELOC_ARM_PCREL_BRANCH: howto manager. +* BFD_RELOC_ARM_PLT32: howto manager. +* BFD_RELOC_ARM_RELATIVE: howto manager. +* BFD_RELOC_ARM_SHIFT_IMM: howto manager. +* BFD_RELOC_ARM_SWI: howto manager. +* BFD_RELOC_ARM_THUMB_ADD: howto manager. +* BFD_RELOC_ARM_THUMB_IMM: howto manager. +* BFD_RELOC_ARM_THUMB_OFFSET: howto manager. +* BFD_RELOC_ARM_THUMB_SHIFT: howto manager. +* BFD_RELOC_AVR_13_PCREL: howto manager. +* BFD_RELOC_AVR_16_PM: howto manager. +* BFD_RELOC_AVR_7_PCREL: howto manager. +* BFD_RELOC_AVR_CALL: howto manager. +* BFD_RELOC_AVR_HH8_LDI: howto manager. +* BFD_RELOC_AVR_HH8_LDI_NEG: howto manager. +* BFD_RELOC_AVR_HH8_LDI_PM: howto manager. +* BFD_RELOC_AVR_HH8_LDI_PM_NEG: howto manager. +* BFD_RELOC_AVR_HI8_LDI: howto manager. +* BFD_RELOC_AVR_HI8_LDI_NEG: howto manager. +* BFD_RELOC_AVR_HI8_LDI_PM: howto manager. +* BFD_RELOC_AVR_HI8_LDI_PM_NEG: howto manager. +* BFD_RELOC_AVR_LO8_LDI: howto manager. +* BFD_RELOC_AVR_LO8_LDI_NEG: howto manager. +* BFD_RELOC_AVR_LO8_LDI_PM: howto manager. +* BFD_RELOC_AVR_LO8_LDI_PM_NEG: howto manager. +* bfd_reloc_code_type: howto manager. +* BFD_RELOC_CTOR: howto manager. +* BFD_RELOC_D10V_10_PCREL_L: howto manager. +* BFD_RELOC_D10V_10_PCREL_R: howto manager. +* BFD_RELOC_D10V_18: howto manager. +* BFD_RELOC_D10V_18_PCREL: howto manager. +* BFD_RELOC_D30V_15: howto manager. +* BFD_RELOC_D30V_15_PCREL: howto manager. +* BFD_RELOC_D30V_15_PCREL_R: howto manager. +* BFD_RELOC_D30V_21: howto manager. +* BFD_RELOC_D30V_21_PCREL: howto manager. +* BFD_RELOC_D30V_21_PCREL_R: howto manager. +* BFD_RELOC_D30V_32: howto manager. +* BFD_RELOC_D30V_32_PCREL: howto manager. +* BFD_RELOC_D30V_6: howto manager. +* BFD_RELOC_D30V_9_PCREL: howto manager. +* BFD_RELOC_D30V_9_PCREL_R: howto manager. +* BFD_RELOC_FR30_10_IN_8: howto manager. +* BFD_RELOC_FR30_12_PCREL: howto manager. +* BFD_RELOC_FR30_20: howto manager. +* BFD_RELOC_FR30_48: howto manager. +* BFD_RELOC_FR30_6_IN_4: howto manager. +* BFD_RELOC_FR30_8_IN_8: howto manager. +* BFD_RELOC_FR30_9_IN_8: howto manager. +* BFD_RELOC_FR30_9_PCREL: howto manager. +* BFD_RELOC_GPREL16: howto manager. +* BFD_RELOC_GPREL32: howto manager. +* BFD_RELOC_HI16: howto manager. +* BFD_RELOC_HI16_BASEREL: howto manager. +* BFD_RELOC_HI16_GOTOFF: howto manager. +* BFD_RELOC_HI16_PLTOFF: howto manager. +* BFD_RELOC_HI16_S: howto manager. +* BFD_RELOC_HI16_S_BASEREL: howto manager. +* BFD_RELOC_HI16_S_GOTOFF: howto manager. +* BFD_RELOC_HI16_S_PLTOFF: howto manager. +* BFD_RELOC_HI22: howto manager. +* BFD_RELOC_I370_D12: howto manager. +* BFD_RELOC_I960_CALLJ: howto manager. +* BFD_RELOC_LO10: howto manager. +* BFD_RELOC_LO16: howto manager. +* BFD_RELOC_LO16_BASEREL: howto manager. +* BFD_RELOC_LO16_GOTOFF: howto manager. +* BFD_RELOC_LO16_PLTOFF: howto manager. +* BFD_RELOC_M32R_10_PCREL: howto manager. +* BFD_RELOC_M32R_18_PCREL: howto manager. +* BFD_RELOC_M32R_24: howto manager. +* BFD_RELOC_M32R_26_PCREL: howto manager. +* BFD_RELOC_M32R_HI16_SLO: howto manager. +* BFD_RELOC_M32R_HI16_ULO: howto manager. +* BFD_RELOC_M32R_LO16: howto manager. +* BFD_RELOC_M32R_SDA16: howto manager. +* BFD_RELOC_MCORE_PCREL_32: howto manager. +* BFD_RELOC_MCORE_PCREL_IMM11BY2: howto manager. +* BFD_RELOC_MCORE_PCREL_IMM4BY2: howto manager. +* BFD_RELOC_MCORE_PCREL_IMM8BY4: howto manager. +* BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: howto manager. +* BFD_RELOC_MCORE_RVA: howto manager. +* BFD_RELOC_MIPS16_GPREL: howto manager. +* BFD_RELOC_MIPS16_JMP: howto manager. +* BFD_RELOC_MIPS_CALL16: howto manager. +* BFD_RELOC_MIPS_CALL_HI16: howto manager. +* BFD_RELOC_MIPS_CALL_LO16: howto manager. +* BFD_RELOC_MIPS_GOT16: howto manager. +* BFD_RELOC_MIPS_GOT_DISP: howto manager. +* BFD_RELOC_MIPS_GOT_HI16: howto manager. +* BFD_RELOC_MIPS_GOT_LO16: howto manager. +* BFD_RELOC_MIPS_GOT_OFST: howto manager. +* BFD_RELOC_MIPS_GOT_PAGE: howto manager. +* BFD_RELOC_MIPS_GPREL: howto manager. +* BFD_RELOC_MIPS_GPREL32: howto manager. +* BFD_RELOC_MIPS_JMP: howto manager. +* BFD_RELOC_MIPS_LITERAL: howto manager. +* BFD_RELOC_MIPS_SUB: howto manager. +* BFD_RELOC_MN10300_16_PCREL: howto manager. +* BFD_RELOC_MN10300_32_PCREL: howto manager. +* BFD_RELOC_NONE: howto manager. +* BFD_RELOC_NS32K_DISP_16: howto manager. +* BFD_RELOC_NS32K_DISP_16_PCREL: howto manager. +* BFD_RELOC_NS32K_DISP_32: howto manager. +* BFD_RELOC_NS32K_DISP_32_PCREL: howto manager. +* BFD_RELOC_NS32K_DISP_8: howto manager. +* BFD_RELOC_NS32K_DISP_8_PCREL: howto manager. +* BFD_RELOC_NS32K_IMM_16: howto manager. +* BFD_RELOC_NS32K_IMM_16_PCREL: howto manager. +* BFD_RELOC_NS32K_IMM_32: howto manager. +* BFD_RELOC_NS32K_IMM_32_PCREL: howto manager. +* BFD_RELOC_NS32K_IMM_8: howto manager. +* BFD_RELOC_NS32K_IMM_8_PCREL: howto manager. +* BFD_RELOC_PCREL_HI16_S: howto manager. +* BFD_RELOC_PCREL_LO16: howto manager. +* BFD_RELOC_PJ_CODE_DIR16: howto manager. +* BFD_RELOC_PJ_CODE_DIR32: howto manager. +* BFD_RELOC_PJ_CODE_HI16: howto manager. +* BFD_RELOC_PJ_CODE_LO16: howto manager. +* BFD_RELOC_PJ_CODE_REL16: howto manager. +* BFD_RELOC_PJ_CODE_REL32: howto manager. +* BFD_RELOC_PPC_B16: howto manager. +* BFD_RELOC_PPC_B16_BRNTAKEN: howto manager. +* BFD_RELOC_PPC_B16_BRTAKEN: howto manager. +* BFD_RELOC_PPC_B26: howto manager. +* BFD_RELOC_PPC_BA16: howto manager. +* BFD_RELOC_PPC_BA16_BRNTAKEN: howto manager. +* BFD_RELOC_PPC_BA16_BRTAKEN: howto manager. +* BFD_RELOC_PPC_BA26: howto manager. +* BFD_RELOC_PPC_COPY: howto manager. +* BFD_RELOC_PPC_EMB_BIT_FLD: howto manager. +* BFD_RELOC_PPC_EMB_MRKREF: howto manager. +* BFD_RELOC_PPC_EMB_NADDR16: howto manager. +* BFD_RELOC_PPC_EMB_NADDR16_HA: howto manager. +* BFD_RELOC_PPC_EMB_NADDR16_HI: howto manager. +* BFD_RELOC_PPC_EMB_NADDR16_LO: howto manager. +* BFD_RELOC_PPC_EMB_NADDR32: howto manager. +* BFD_RELOC_PPC_EMB_RELSDA: howto manager. +* BFD_RELOC_PPC_EMB_RELSEC16: howto manager. +* BFD_RELOC_PPC_EMB_RELST_HA: howto manager. +* BFD_RELOC_PPC_EMB_RELST_HI: howto manager. +* BFD_RELOC_PPC_EMB_RELST_LO: howto manager. +* BFD_RELOC_PPC_EMB_SDA21: howto manager. +* BFD_RELOC_PPC_EMB_SDA2I16: howto manager. +* BFD_RELOC_PPC_EMB_SDA2REL: howto manager. +* BFD_RELOC_PPC_EMB_SDAI16: howto manager. +* BFD_RELOC_PPC_GLOB_DAT: howto manager. +* BFD_RELOC_PPC_JMP_SLOT: howto manager. +* BFD_RELOC_PPC_LOCAL24PC: howto manager. +* BFD_RELOC_PPC_RELATIVE: howto manager. +* BFD_RELOC_PPC_TOC16: howto manager. +* BFD_RELOC_RVA: howto manager. +* BFD_RELOC_SH_ALIGN: howto manager. +* BFD_RELOC_SH_CODE: howto manager. +* BFD_RELOC_SH_COUNT: howto manager. +* BFD_RELOC_SH_DATA: howto manager. +* BFD_RELOC_SH_IMM4: howto manager. +* BFD_RELOC_SH_IMM4BY2: howto manager. +* BFD_RELOC_SH_IMM4BY4: howto manager. +* BFD_RELOC_SH_IMM8: howto manager. +* BFD_RELOC_SH_IMM8BY2: howto manager. +* BFD_RELOC_SH_IMM8BY4: howto manager. +* BFD_RELOC_SH_LABEL: howto manager. +* BFD_RELOC_SH_PCDISP12BY2: howto manager. +* BFD_RELOC_SH_PCDISP8BY2: howto manager. +* BFD_RELOC_SH_PCRELIMM8BY2: howto manager. +* BFD_RELOC_SH_PCRELIMM8BY4: howto manager. +* BFD_RELOC_SH_SWITCH16: howto manager. +* BFD_RELOC_SH_SWITCH32: howto manager. +* BFD_RELOC_SH_USES: howto manager. +* BFD_RELOC_SPARC13: howto manager. +* BFD_RELOC_SPARC22: howto manager. +* BFD_RELOC_SPARC_10: howto manager. +* BFD_RELOC_SPARC_11: howto manager. +* BFD_RELOC_SPARC_5: howto manager. +* BFD_RELOC_SPARC_6: howto manager. +* BFD_RELOC_SPARC_64: howto manager. +* BFD_RELOC_SPARC_7: howto manager. +* BFD_RELOC_SPARC_BASE13: howto manager. +* BFD_RELOC_SPARC_BASE22: howto manager. +* BFD_RELOC_SPARC_COPY: howto manager. +* BFD_RELOC_SPARC_DISP64: howto manager. +* BFD_RELOC_SPARC_GLOB_DAT: howto manager. +* BFD_RELOC_SPARC_GOT10: howto manager. +* BFD_RELOC_SPARC_GOT13: howto manager. +* BFD_RELOC_SPARC_GOT22: howto manager. +* BFD_RELOC_SPARC_H44: howto manager. +* BFD_RELOC_SPARC_HH22: howto manager. +* BFD_RELOC_SPARC_HIX22: howto manager. +* BFD_RELOC_SPARC_HM10: howto manager. +* BFD_RELOC_SPARC_JMP_SLOT: howto manager. +* BFD_RELOC_SPARC_L44: howto manager. +* BFD_RELOC_SPARC_LM22: howto manager. +* BFD_RELOC_SPARC_LOX10: howto manager. +* BFD_RELOC_SPARC_M44: howto manager. +* BFD_RELOC_SPARC_OLO10: howto manager. +* BFD_RELOC_SPARC_PC10: howto manager. +* BFD_RELOC_SPARC_PC22: howto manager. +* BFD_RELOC_SPARC_PC_HH22: howto manager. +* BFD_RELOC_SPARC_PC_HM10: howto manager. +* BFD_RELOC_SPARC_PC_LM22: howto manager. +* BFD_RELOC_SPARC_PLT64: howto manager. +* BFD_RELOC_SPARC_REGISTER: howto manager. +* BFD_RELOC_SPARC_RELATIVE: howto manager. +* BFD_RELOC_SPARC_REV32: howto manager. +* BFD_RELOC_SPARC_UA32: howto manager. +* BFD_RELOC_SPARC_WDISP16: howto manager. +* BFD_RELOC_SPARC_WDISP19: howto manager. +* BFD_RELOC_SPARC_WDISP22: howto manager. +* BFD_RELOC_SPARC_WPLT30: howto manager. +* BFD_RELOC_THUMB_PCREL_BRANCH12: howto manager. +* BFD_RELOC_THUMB_PCREL_BRANCH23: howto manager. +* BFD_RELOC_THUMB_PCREL_BRANCH9: howto manager. +* BFD_RELOC_TIC30_LDP: howto manager. +* bfd_reloc_type_lookup: howto manager. +* BFD_RELOC_V850_22_PCREL: howto manager. +* BFD_RELOC_V850_9_PCREL: howto manager. +* BFD_RELOC_V850_CALLT_16_16_OFFSET: howto manager. +* BFD_RELOC_V850_CALLT_6_7_OFFSET: howto manager. +* BFD_RELOC_V850_SDA_15_16_OFFSET: howto manager. +* BFD_RELOC_V850_SDA_16_16_OFFSET: howto manager. +* BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET: howto manager. +* BFD_RELOC_V850_TDA_16_16_OFFSET: howto manager. +* BFD_RELOC_V850_TDA_4_4_OFFSET: howto manager. +* BFD_RELOC_V850_TDA_4_5_OFFSET: howto manager. +* BFD_RELOC_V850_TDA_6_8_OFFSET: howto manager. +* BFD_RELOC_V850_TDA_7_7_OFFSET: howto manager. +* BFD_RELOC_V850_TDA_7_8_OFFSET: howto manager. +* BFD_RELOC_V850_ZDA_15_16_OFFSET: howto manager. +* BFD_RELOC_V850_ZDA_16_16_OFFSET: howto manager. +* BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET: howto manager. +* BFD_RELOC_VTABLE_ENTRY: howto manager. +* BFD_RELOC_VTABLE_INHERIT: howto manager. +* bfd_scan_arch: Architectures. +* bfd_scan_vma: BFD front end. +* bfd_seach_for_target: bfd_target. +* bfd_set_arch_info: Architectures. +* bfd_set_archive_head: Archives. +* bfd_set_default_target: bfd_target. +* bfd_set_error: BFD front end. +* bfd_set_error_handler: BFD front end. +* bfd_set_error_program_name: BFD front end. +* bfd_set_file_flags: BFD front end. +* bfd_set_format: Formats. +* bfd_set_gp_size: BFD front end. +* bfd_set_private_flags: BFD front end. +* bfd_set_reloc: BFD front end. +* bfd_set_section_contents: section prototypes. +* bfd_set_section_flags: section prototypes. +* bfd_set_section_size: section prototypes. +* bfd_set_start_address: BFD front end. +* bfd_set_symtab: symbol handling functions. +* bfd_symbol_info: symbol handling functions. +* bfd_target_list: bfd_target. +* bfd_write_bigendian_4byte_int: Internal. +* coff_symbol_type: coff. +* core_file_matches_executable_p: Core Files. +* Hash tables: Hash Tables. +* internal object-file format: Canonical format. +* Linker: Linker Functions. +* stuff: BFD front end. +* target vector (_bfd_final_link): Performing the Final Link. +* target vector (_bfd_link_add_symbols): Adding Symbols to the Hash Table. +* target vector (_bfd_link_hash_table_create): Creating a Linker Hash Table. +* The HOWTO Macro: typedef arelent. +* what is it?: Overview. + + diff --git a/bfd/doc/bfdt.texi b/bfd/doc/bfdt.texi new file mode 100644 index 00000000000..98269fb6c6a --- /dev/null +++ b/bfd/doc/bfdt.texi @@ -0,0 +1,601 @@ +@section @code{typedef bfd} +A BFD has type @code{bfd}; objects of this type are the +cornerstone of any application using BFD. Using BFD +consists of making references though the BFD and to data in the BFD. + +Here is the structure that defines the type @code{bfd}. It +contains the major data about the file and pointers +to the rest of the data. + + +@example + +struct _bfd +@{ + /* The filename the application opened the BFD with. */ + CONST char *filename; + + /* A pointer to the target jump table. */ + const struct bfd_target *xvec; + + /* To avoid dragging too many header files into every file that + includes `@code{bfd.h}', IOSTREAM has been declared as a "char + *", and MTIME as a "long". Their correct types, to which they + are cast when used, are "FILE *" and "time_t". The iostream + is the result of an fopen on the filename. However, if the + BFD_IN_MEMORY flag is set, then iostream is actually a pointer + to a bfd_in_memory struct. */ + PTR iostream; + + /* Is the file descriptor being cached? That is, can it be closed as + needed, and re-opened when accessed later? */ + + boolean cacheable; + + /* Marks whether there was a default target specified when the + BFD was opened. This is used to select which matching algorithm + to use to choose the back end. */ + + boolean target_defaulted; + + /* The caching routines use these to maintain a + least-recently-used list of BFDs */ + + struct _bfd *lru_prev, *lru_next; + + /* When a file is closed by the caching routines, BFD retains + state information on the file here: */ + + file_ptr where; + + /* and here: (``once'' means at least once) */ + + boolean opened_once; + + /* Set if we have a locally maintained mtime value, rather than + getting it from the file each time: */ + + boolean mtime_set; + + /* File modified time, if mtime_set is true: */ + + long mtime; + + /* Reserved for an unimplemented file locking extension.*/ + + int ifd; + + /* The format which belongs to the BFD. (object, core, etc.) */ + + bfd_format format; + + /* The direction the BFD was opened with*/ + + enum bfd_direction @{no_direction = 0, + read_direction = 1, + write_direction = 2, + both_direction = 3@} direction; + + /* Format_specific flags*/ + + flagword flags; + + /* Currently my_archive is tested before adding origin to + anything. I believe that this can become always an add of + origin, with origin set to 0 for non archive files. */ + + file_ptr origin; + + /* Remember when output has begun, to stop strange things + from happening. */ + boolean output_has_begun; + + /* Pointer to linked list of sections*/ + struct sec *sections; + + /* The number of sections */ + unsigned int section_count; + + /* Stuff only useful for object files: + The start address. */ + bfd_vma start_address; + + /* Used for input and output*/ + unsigned int symcount; + + /* Symbol table for output BFD (with symcount entries) */ + struct symbol_cache_entry **outsymbols; + + /* Pointer to structure which contains architecture information*/ + const struct bfd_arch_info *arch_info; + + /* Stuff only useful for archives:*/ + PTR arelt_data; + struct _bfd *my_archive; /* The containing archive BFD. */ + struct _bfd *next; /* The next BFD in the archive. */ + struct _bfd *archive_head; /* The first BFD in the archive. */ + boolean has_armap; + + /* A chain of BFD structures involved in a link. */ + struct _bfd *link_next; + + /* A field used by _bfd_generic_link_add_archive_symbols. This will + be used only for archive elements. */ + int archive_pass; + + /* Used by the back end to hold private data. */ + + union + @{ + struct aout_data_struct *aout_data; + struct artdata *aout_ar_data; + struct _oasys_data *oasys_obj_data; + struct _oasys_ar_data *oasys_ar_data; + struct coff_tdata *coff_obj_data; + struct pe_tdata *pe_obj_data; + struct xcoff_tdata *xcoff_obj_data; + struct ecoff_tdata *ecoff_obj_data; + struct ieee_data_struct *ieee_data; + struct ieee_ar_data_struct *ieee_ar_data; + struct srec_data_struct *srec_data; + struct ihex_data_struct *ihex_data; + struct tekhex_data_struct *tekhex_data; + struct elf_obj_tdata *elf_obj_data; + struct nlm_obj_tdata *nlm_obj_data; + struct bout_data_struct *bout_data; + struct sun_core_struct *sun_core_data; + struct sco5_core_struct *sco5_core_data; + struct trad_core_struct *trad_core_data; + struct som_data_struct *som_data; + struct hpux_core_struct *hpux_core_data; + struct hppabsd_core_struct *hppabsd_core_data; + struct sgi_core_struct *sgi_core_data; + struct lynx_core_struct *lynx_core_data; + struct osf_core_struct *osf_core_data; + struct cisco_core_struct *cisco_core_data; + struct versados_data_struct *versados_data; + struct netbsd_core_struct *netbsd_core_data; + PTR any; + @} tdata; + + /* Used by the application to hold private data*/ + PTR usrdata; + + /* Where all the allocated stuff under this BFD goes. This is a + struct objalloc *, but we use PTR to avoid requiring the inclusion of + objalloc.h. */ + PTR memory; +@}; + +@end example +@section Error reporting +Most BFD functions return nonzero on success (check their +individual documentation for precise semantics). On an error, +they call @code{bfd_set_error} to set an error condition that callers +can check by calling @code{bfd_get_error}. +If that returns @code{bfd_error_system_call}, then check +@code{errno}. + +The easiest way to report a BFD error to the user is to +use @code{bfd_perror}. + +@subsection Type @code{bfd_error_type} +The values returned by @code{bfd_get_error} are defined by the +enumerated type @code{bfd_error_type}. + + +@example + +typedef enum bfd_error +@{ + bfd_error_no_error = 0, + bfd_error_system_call, + bfd_error_invalid_target, + bfd_error_wrong_format, + bfd_error_invalid_operation, + bfd_error_no_memory, + bfd_error_no_symbols, + bfd_error_no_armap, + bfd_error_no_more_archived_files, + bfd_error_malformed_archive, + bfd_error_file_not_recognized, + bfd_error_file_ambiguously_recognized, + bfd_error_no_contents, + bfd_error_nonrepresentable_section, + bfd_error_no_debug_section, + bfd_error_bad_value, + bfd_error_file_truncated, + bfd_error_file_too_big, + bfd_error_invalid_error_code +@} bfd_error_type; + +@end example +@findex bfd_get_error +@subsubsection @code{bfd_get_error} +@strong{Synopsis} +@example +bfd_error_type bfd_get_error (void); +@end example +@strong{Description}@* +Return the current BFD error condition. + +@findex bfd_set_error +@subsubsection @code{bfd_set_error} +@strong{Synopsis} +@example +void bfd_set_error (bfd_error_type error_tag); +@end example +@strong{Description}@* +Set the BFD error condition to be @var{error_tag}. + +@findex bfd_errmsg +@subsubsection @code{bfd_errmsg} +@strong{Synopsis} +@example +CONST char *bfd_errmsg (bfd_error_type error_tag); +@end example +@strong{Description}@* +Return a string describing the error @var{error_tag}, or +the system error if @var{error_tag} is @code{bfd_error_system_call}. + +@findex bfd_perror +@subsubsection @code{bfd_perror} +@strong{Synopsis} +@example +void bfd_perror (CONST char *message); +@end example +@strong{Description}@* +Print to the standard error stream a string describing the +last BFD error that occurred, or the last system error if +the last BFD error was a system call failure. If @var{message} +is non-NULL and non-empty, the error string printed is preceded +by @var{message}, a colon, and a space. It is followed by a newline. + +@subsection BFD error handler +Some BFD functions want to print messages describing the +problem. They call a BFD error handler function. This +function may be overriden by the program. + +The BFD error handler acts like printf. + + +@example + +typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...)); + +@end example +@findex bfd_set_error_handler +@subsubsection @code{bfd_set_error_handler} +@strong{Synopsis} +@example +bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); +@end example +@strong{Description}@* +Set the BFD error handler function. Returns the previous +function. + +@findex bfd_set_error_program_name +@subsubsection @code{bfd_set_error_program_name} +@strong{Synopsis} +@example +void bfd_set_error_program_name (const char *); +@end example +@strong{Description}@* +Set the program name to use when printing a BFD error. This +is printed before the error message followed by a colon and +space. The string must not be changed after it is passed to +this function. + +@findex bfd_get_error_handler +@subsubsection @code{bfd_get_error_handler} +@strong{Synopsis} +@example +bfd_error_handler_type bfd_get_error_handler (void); +@end example +@strong{Description}@* +Return the BFD error handler function. + +@section Symbols + + +@findex bfd_get_reloc_upper_bound +@subsubsection @code{bfd_get_reloc_upper_bound} +@strong{Synopsis} +@example +long bfd_get_reloc_upper_bound(bfd *abfd, asection *sect); +@end example +@strong{Description}@* +Return the number of bytes required to store the +relocation information associated with section @var{sect} +attached to bfd @var{abfd}. If an error occurs, return -1. + +@findex bfd_canonicalize_reloc +@subsubsection @code{bfd_canonicalize_reloc} +@strong{Synopsis} +@example +long bfd_canonicalize_reloc + (bfd *abfd, + asection *sec, + arelent **loc, + asymbol **syms); +@end example +@strong{Description}@* +Call the back end associated with the open BFD +@var{abfd} and translate the external form of the relocation +information attached to @var{sec} into the internal canonical +form. Place the table into memory at @var{loc}, which has +been preallocated, usually by a call to +@code{bfd_get_reloc_upper_bound}. Returns the number of relocs, or +-1 on error. + +The @var{syms} table is also needed for horrible internal magic +reasons. + +@findex bfd_set_reloc +@subsubsection @code{bfd_set_reloc} +@strong{Synopsis} +@example +void bfd_set_reloc + (bfd *abfd, asection *sec, arelent **rel, unsigned int count) +@end example +@strong{Description}@* +Set the relocation pointer and count within +section @var{sec} to the values @var{rel} and @var{count}. +The argument @var{abfd} is ignored. + +@findex bfd_set_file_flags +@subsubsection @code{bfd_set_file_flags} +@strong{Synopsis} +@example +boolean bfd_set_file_flags(bfd *abfd, flagword flags); +@end example +@strong{Description}@* +Set the flag word in the BFD @var{abfd} to the value @var{flags}. + +Possible errors are: +@itemize @bullet + +@item +@code{bfd_error_wrong_format} - The target bfd was not of object format. +@item +@code{bfd_error_invalid_operation} - The target bfd was open for reading. +@item +@code{bfd_error_invalid_operation} - +The flag word contained a bit which was not applicable to the +type of file. E.g., an attempt was made to set the @code{D_PAGED} bit +on a BFD format which does not support demand paging. +@end itemize + +@findex bfd_set_start_address +@subsubsection @code{bfd_set_start_address} +@strong{Synopsis} +@example +boolean bfd_set_start_address(bfd *abfd, bfd_vma vma); +@end example +@strong{Description}@* +Make @var{vma} the entry point of output BFD @var{abfd}. + +@strong{Returns}@* +Returns @code{true} on success, @code{false} otherwise. + +@findex bfd_get_mtime +@subsubsection @code{bfd_get_mtime} +@strong{Synopsis} +@example +long bfd_get_mtime(bfd *abfd); +@end example +@strong{Description}@* +Return the file modification time (as read from the file system, or +from the archive header for archive members). + +@findex bfd_get_size +@subsubsection @code{bfd_get_size} +@strong{Synopsis} +@example +long bfd_get_size(bfd *abfd); +@end example +@strong{Description}@* +Return the file size (as read from file system) for the file +associated with BFD @var{abfd}. + +The initial motivation for, and use of, this routine is not +so we can get the exact size of the object the BFD applies to, since +that might not be generally possible (archive members for example). +It would be ideal if someone could eventually modify +it so that such results were guaranteed. + +Instead, we want to ask questions like "is this NNN byte sized +object I'm about to try read from file offset YYY reasonable?" +As as example of where we might do this, some object formats +use string tables for which the first @code{sizeof(long)} bytes of the +table contain the size of the table itself, including the size bytes. +If an application tries to read what it thinks is one of these +string tables, without some way to validate the size, and for +some reason the size is wrong (byte swapping error, wrong location +for the string table, etc.), the only clue is likely to be a read +error when it tries to read the table, or a "virtual memory +exhausted" error when it tries to allocate 15 bazillon bytes +of space for the 15 bazillon byte table it is about to read. +This function at least allows us to answer the quesion, "is the +size reasonable?". + +@findex bfd_get_gp_size +@subsubsection @code{bfd_get_gp_size} +@strong{Synopsis} +@example +int bfd_get_gp_size(bfd *abfd); +@end example +@strong{Description}@* +Return the maximum size of objects to be optimized using the GP +register under MIPS ECOFF. This is typically set by the @code{-G} +argument to the compiler, assembler or linker. + +@findex bfd_set_gp_size +@subsubsection @code{bfd_set_gp_size} +@strong{Synopsis} +@example +void bfd_set_gp_size(bfd *abfd, int i); +@end example +@strong{Description}@* +Set the maximum size of objects to be optimized using the GP +register under ECOFF or MIPS ELF. This is typically set by +the @code{-G} argument to the compiler, assembler or linker. + +@findex bfd_scan_vma +@subsubsection @code{bfd_scan_vma} +@strong{Synopsis} +@example +bfd_vma bfd_scan_vma(CONST char *string, CONST char **end, int base); +@end example +@strong{Description}@* +Convert, like @code{strtoul}, a numerical expression +@var{string} into a @code{bfd_vma} integer, and return that integer. +(Though without as many bells and whistles as @code{strtoul}.) +The expression is assumed to be unsigned (i.e., positive). +If given a @var{base}, it is used as the base for conversion. +A base of 0 causes the function to interpret the string +in hex if a leading "0x" or "0X" is found, otherwise +in octal if a leading zero is found, otherwise in decimal. + +Overflow is not detected. + +@findex bfd_copy_private_bfd_data +@subsubsection @code{bfd_copy_private_bfd_data} +@strong{Synopsis} +@example +boolean bfd_copy_private_bfd_data(bfd *ibfd, bfd *obfd); +@end example +@strong{Description}@* +Copy private BFD information from the BFD @var{ibfd} to the +the BFD @var{obfd}. Return @code{true} on success, @code{false} on error. +Possible error returns are: + +@itemize @bullet + +@item +@code{bfd_error_no_memory} - +Not enough memory exists to create private data for @var{obfd}. +@end itemize +@example +#define bfd_copy_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ + (ibfd, obfd)) +@end example + +@findex bfd_merge_private_bfd_data +@subsubsection @code{bfd_merge_private_bfd_data} +@strong{Synopsis} +@example +boolean bfd_merge_private_bfd_data(bfd *ibfd, bfd *obfd); +@end example +@strong{Description}@* +Merge private BFD information from the BFD @var{ibfd} to the +the output file BFD @var{obfd} when linking. Return @code{true} +on success, @code{false} on error. Possible error returns are: + +@itemize @bullet + +@item +@code{bfd_error_no_memory} - +Not enough memory exists to create private data for @var{obfd}. +@end itemize +@example +#define bfd_merge_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ + (ibfd, obfd)) +@end example + +@findex bfd_set_private_flags +@subsubsection @code{bfd_set_private_flags} +@strong{Synopsis} +@example +boolean bfd_set_private_flags(bfd *abfd, flagword flags); +@end example +@strong{Description}@* +Set private BFD flag information in the BFD @var{abfd}. +Return @code{true} on success, @code{false} on error. Possible error +returns are: + +@itemize @bullet + +@item +@code{bfd_error_no_memory} - +Not enough memory exists to create private data for @var{obfd}. +@end itemize +@example +#define bfd_set_private_flags(abfd, flags) \ + BFD_SEND (abfd, _bfd_set_private_flags, \ + (abfd, flags)) +@end example + +@findex stuff +@subsubsection @code{stuff} +@strong{Description}@* +Stuff which should be documented: +@example +#define bfd_sizeof_headers(abfd, reloc) \ + BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) + +#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ + BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, sec, syms, off, file, func, line)) + + /* Do these three do anything useful at all, for any back end? */ +#define bfd_debug_info_start(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) + +#define bfd_debug_info_end(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) + +#define bfd_debug_info_accumulate(abfd, section) \ + BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) + + +#define bfd_stat_arch_elt(abfd, stat) \ + BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) + +#define bfd_update_armap_timestamp(abfd) \ + BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) + +#define bfd_set_arch_mach(abfd, arch, mach)\ + BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) + +#define bfd_relax_section(abfd, section, link_info, again) \ + BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) + +#define bfd_gc_sections(abfd, link_info) \ + BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) + +#define bfd_link_hash_table_create(abfd) \ + BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) + +#define bfd_link_add_symbols(abfd, info) \ + BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) + +#define bfd_final_link(abfd, info) \ + BFD_SEND (abfd, _bfd_final_link, (abfd, info)) + +#define bfd_free_cached_info(abfd) \ + BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) + +#define bfd_get_dynamic_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) + +#define bfd_print_private_bfd_data(abfd, file)\ + BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) + +#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) + +#define bfd_get_dynamic_reloc_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) + +#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) + +extern bfd_byte *bfd_get_relocated_section_contents + PARAMS ((bfd *, struct bfd_link_info *, + struct bfd_link_order *, bfd_byte *, + boolean, asymbol **)); + +@end example + diff --git a/bfd/doc/cache.texi b/bfd/doc/cache.texi new file mode 100644 index 00000000000..4aafb69ca7a --- /dev/null +++ b/bfd/doc/cache.texi @@ -0,0 +1,95 @@ +@section File caching +The file caching mechanism is embedded within BFD and allows +the application to open as many BFDs as it wants without +regard to the underlying operating system's file descriptor +limit (often as low as 20 open files). The module in +@code{cache.c} maintains a least recently used list of +@code{BFD_CACHE_MAX_OPEN} files, and exports the name +@code{bfd_cache_lookup}, which runs around and makes sure that +the required BFD is open. If not, then it chooses a file to +close, closes it and opens the one wanted, returning its file +handle. + +@findex BFD_CACHE_MAX_OPEN macro +@subsubsection @code{BFD_CACHE_MAX_OPEN macro} +@strong{Description}@* +The maximum number of files which the cache will keep open at +one time. +@example +#define BFD_CACHE_MAX_OPEN 10 +@end example + +@findex bfd_last_cache +@subsubsection @code{bfd_last_cache} +@strong{Synopsis} +@example +extern bfd *bfd_last_cache; +@end example +@strong{Description}@* +Zero, or a pointer to the topmost BFD on the chain. This is +used by the @code{bfd_cache_lookup} macro in @file{libbfd.h} to +determine when it can avoid a function call. + +@findex bfd_cache_lookup +@subsubsection @code{bfd_cache_lookup} +@strong{Description}@* +Check to see if the required BFD is the same as the last one +looked up. If so, then it can use the stream in the BFD with +impunity, since it can't have changed since the last lookup; +otherwise, it has to perform the complicated lookup function. +@example +#define bfd_cache_lookup(x) \ + ((x)==bfd_last_cache? \ + (FILE*)(bfd_last_cache->iostream): \ + bfd_cache_lookup_worker(x)) +@end example + +@findex bfd_cache_init +@subsubsection @code{bfd_cache_init} +@strong{Synopsis} +@example +boolean bfd_cache_init (bfd *abfd); +@end example +@strong{Description}@* +Add a newly opened BFD to the cache. + +@findex bfd_cache_close +@subsubsection @code{bfd_cache_close} +@strong{Synopsis} +@example +boolean bfd_cache_close (bfd *abfd); +@end example +@strong{Description}@* +Remove the BFD @var{abfd} from the cache. If the attached file is open, +then close it too. + +@strong{Returns}@* +@code{false} is returned if closing the file fails, @code{true} is +returned if all is well. + +@findex bfd_open_file +@subsubsection @code{bfd_open_file} +@strong{Synopsis} +@example +FILE* bfd_open_file(bfd *abfd); +@end example +@strong{Description}@* +Call the OS to open a file for @var{abfd}. Return the @code{FILE *} +(possibly @code{NULL}) that results from this operation. Set up the +BFD so that future accesses know the file is open. If the @code{FILE *} +returned is @code{NULL}, then it won't have been put in the +cache, so it won't have to be removed from it. + +@findex bfd_cache_lookup_worker +@subsubsection @code{bfd_cache_lookup_worker} +@strong{Synopsis} +@example +FILE *bfd_cache_lookup_worker(bfd *abfd); +@end example +@strong{Description}@* +Called when the macro @code{bfd_cache_lookup} fails to find a +quick answer. Find a file descriptor for @var{abfd}. If +necessary, it open it. If there are already more than +@code{BFD_CACHE_MAX_OPEN} files open, it tries to close one first, to +avoid running out of file descriptors. + diff --git a/bfd/doc/coffcode.texi b/bfd/doc/coffcode.texi new file mode 100644 index 00000000000..fcb7e757881 --- /dev/null +++ b/bfd/doc/coffcode.texi @@ -0,0 +1,666 @@ +@section coff backends +BFD supports a number of different flavours of coff format. +The major differences between formats are the sizes and +alignments of fields in structures on disk, and the occasional +extra field. + +Coff in all its varieties is implemented with a few common +files and a number of implementation specific files. For +example, The 88k bcs coff format is implemented in the file +@file{coff-m88k.c}. This file @code{#include}s +@file{coff/m88k.h} which defines the external structure of the +coff format for the 88k, and @file{coff/internal.h} which +defines the internal structure. @file{coff-m88k.c} also +defines the relocations used by the 88k format +@xref{Relocations}. + +The Intel i960 processor version of coff is implemented in +@file{coff-i960.c}. This file has the same structure as +@file{coff-m88k.c}, except that it includes @file{coff/i960.h} +rather than @file{coff-m88k.h}. + +@subsection Porting to a new version of coff +The recommended method is to select from the existing +implementations the version of coff which is most like the one +you want to use. For example, we'll say that i386 coff is +the one you select, and that your coff flavour is called foo. +Copy @file{i386coff.c} to @file{foocoff.c}, copy +@file{../include/coff/i386.h} to @file{../include/coff/foo.h}, +and add the lines to @file{targets.c} and @file{Makefile.in} +so that your new back end is used. Alter the shapes of the +structures in @file{../include/coff/foo.h} so that they match +what you need. You will probably also have to add +@code{#ifdef}s to the code in @file{coff/internal.h} and +@file{coffcode.h} if your version of coff is too wild. + +You can verify that your new BFD backend works quite simply by +building @file{objdump} from the @file{binutils} directory, +and making sure that its version of what's going on and your +host system's idea (assuming it has the pretty standard coff +dump utility, usually called @code{att-dump} or just +@code{dump}) are the same. Then clean up your code, and send +what you've done to Cygnus. Then your stuff will be in the +next release, and you won't have to keep integrating it. + +@subsection How the coff backend works + + +@subsubsection File layout +The Coff backend is split into generic routines that are +applicable to any Coff target and routines that are specific +to a particular target. The target-specific routines are +further split into ones which are basically the same for all +Coff targets except that they use the external symbol format +or use different values for certain constants. + +The generic routines are in @file{coffgen.c}. These routines +work for any Coff target. They use some hooks into the target +specific code; the hooks are in a @code{bfd_coff_backend_data} +structure, one of which exists for each target. + +The essentially similar target-specific routines are in +@file{coffcode.h}. This header file includes executable C code. +The various Coff targets first include the appropriate Coff +header file, make any special defines that are needed, and +then include @file{coffcode.h}. + +Some of the Coff targets then also have additional routines in +the target source file itself. + +For example, @file{coff-i960.c} includes +@file{coff/internal.h} and @file{coff/i960.h}. It then +defines a few constants, such as @code{I960}, and includes +@file{coffcode.h}. Since the i960 has complex relocation +types, @file{coff-i960.c} also includes some code to +manipulate the i960 relocs. This code is not in +@file{coffcode.h} because it would not be used by any other +target. + +@subsubsection Bit twiddling +Each flavour of coff supported in BFD has its own header file +describing the external layout of the structures. There is also +an internal description of the coff layout, in +@file{coff/internal.h}. A major function of the +coff backend is swapping the bytes and twiddling the bits to +translate the external form of the structures into the normal +internal form. This is all performed in the +@code{bfd_swap}_@i{thing}_@i{direction} routines. Some +elements are different sizes between different versions of +coff; it is the duty of the coff version specific include file +to override the definitions of various packing routines in +@file{coffcode.h}. E.g., the size of line number entry in coff is +sometimes 16 bits, and sometimes 32 bits. @code{#define}ing +@code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the +correct one. No doubt, some day someone will find a version of +coff which has a varying field size not catered to at the +moment. To port BFD, that person will have to add more @code{#defines}. +Three of the bit twiddling routines are exported to +@code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in} +and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol +table on its own, but uses BFD to fix things up. More of the +bit twiddlers are exported for @code{gas}; +@code{coff_swap_aux_out}, @code{coff_swap_sym_out}, +@code{coff_swap_lineno_out}, @code{coff_swap_reloc_out}, +@code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out}, +@code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track +of all the symbol table and reloc drudgery itself, thereby +saving the internal BFD overhead, but uses BFD to swap things +on the way out, making cross ports much safer. Doing so also +allows BFD (and thus the linker) to use the same header files +as @code{gas}, which makes one avenue to disaster disappear. + +@subsubsection Symbol reading +The simple canonical form for symbols used by BFD is not rich +enough to keep all the information available in a coff symbol +table. The back end gets around this problem by keeping the original +symbol table around, "behind the scenes". + +When a symbol table is requested (through a call to +@code{bfd_canonicalize_symtab}), a request gets through to +@code{coff_get_normalized_symtab}. This reads the symbol table from +the coff file and swaps all the structures inside into the +internal form. It also fixes up all the pointers in the table +(represented in the file by offsets from the first symbol in +the table) into physical pointers to elements in the new +internal table. This involves some work since the meanings of +fields change depending upon context: a field that is a +pointer to another structure in the symbol table at one moment +may be the size in bytes of a structure at the next. Another +pass is made over the table. All symbols which mark file names +(@code{C_FILE} symbols) are modified so that the internal +string points to the value in the auxent (the real filename) +rather than the normal text associated with the symbol +(@code{".file"}). + +At this time the symbol names are moved around. Coff stores +all symbols less than nine characters long physically +within the symbol table; longer strings are kept at the end of +the file in the string table. This pass moves all strings +into memory and replaces them with pointers to the strings. + +The symbol table is massaged once again, this time to create +the canonical table used by the BFD application. Each symbol +is inspected in turn, and a decision made (using the +@code{sclass} field) about the various flags to set in the +@code{asymbol}. @xref{Symbols}. The generated canonical table +shares strings with the hidden internal symbol table. + +Any linenumbers are read from the coff file too, and attached +to the symbols which own the functions the linenumbers belong to. + +@subsubsection Symbol writing +Writing a symbol to a coff file which didn't come from a coff +file will lose any debugging information. The @code{asymbol} +structure remembers the BFD from which the symbol was taken, and on +output the back end makes sure that the same destination target as +source target is present. + +When the symbols have come from a coff file then all the +debugging information is preserved. + +Symbol tables are provided for writing to the back end in a +vector of pointers to pointers. This allows applications like +the linker to accumulate and output large symbol tables +without having to do too much byte copying. + +This function runs through the provided symbol table and +patches each symbol marked as a file place holder +(@code{C_FILE}) to point to the next file place holder in the +list. It also marks each @code{offset} field in the list with +the offset from the first symbol of the current symbol. + +Another function of this procedure is to turn the canonical +value form of BFD into the form used by coff. Internally, BFD +expects symbol values to be offsets from a section base; so a +symbol physically at 0x120, but in a section starting at +0x100, would have the value 0x20. Coff expects symbols to +contain their final value, so symbols have their values +changed at this point to reflect their sum with their owning +section. This transformation uses the +@code{output_section} field of the @code{asymbol}'s +@code{asection} @xref{Sections}. + +@itemize @bullet + +@item +@code{coff_mangle_symbols} +@end itemize +This routine runs though the provided symbol table and uses +the offsets generated by the previous pass and the pointers +generated when the symbol table was read in to create the +structured hierachy required by coff. It changes each pointer +to a symbol into the index into the symbol table of the asymbol. + +@itemize @bullet + +@item +@code{coff_write_symbols} +@end itemize +This routine runs through the symbol table and patches up the +symbols from their internal form into the coff way, calls the +bit twiddlers, and writes out the table to the file. + +@findex coff_symbol_type +@subsubsection @code{coff_symbol_type} +@strong{Description}@* +The hidden information for an @code{asymbol} is described in a +@code{combined_entry_type}: + + +@example + +typedef struct coff_ptr_struct +@{ + + /* Remembers the offset from the first symbol in the file for + this symbol. Generated by coff_renumber_symbols. */ +unsigned int offset; + + /* Should the value of this symbol be renumbered. Used for + XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. */ +unsigned int fix_value : 1; + + /* Should the tag field of this symbol be renumbered. + Created by coff_pointerize_aux. */ +unsigned int fix_tag : 1; + + /* Should the endidx field of this symbol be renumbered. + Created by coff_pointerize_aux. */ +unsigned int fix_end : 1; + + /* Should the x_csect.x_scnlen field be renumbered. + Created by coff_pointerize_aux. */ +unsigned int fix_scnlen : 1; + + /* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the + index into the line number entries. Set by + coff_slurp_symbol_table. */ +unsigned int fix_line : 1; + + /* The container for the symbol structure as read and translated + from the file. */ + +union @{ + union internal_auxent auxent; + struct internal_syment syment; + @} u; +@} combined_entry_type; + + +/* Each canonical asymbol really looks like this: */ + +typedef struct coff_symbol_struct +@{ + /* The actual symbol which the rest of BFD works with */ +asymbol symbol; + + /* A pointer to the hidden information for this symbol */ +combined_entry_type *native; + + /* A pointer to the linenumber information for this symbol */ +struct lineno_cache_entry *lineno; + + /* Have the line numbers been relocated yet ? */ +boolean done_lineno; +@} coff_symbol_type; +@end example +@findex bfd_coff_backend_data +@subsubsection @code{bfd_coff_backend_data} + +@example +/* COFF symbol classifications. */ + +enum coff_symbol_classification +@{ + /* Global symbol. */ + COFF_SYMBOL_GLOBAL, + /* Common symbol. */ + COFF_SYMBOL_COMMON, + /* Undefined symbol. */ + COFF_SYMBOL_UNDEFINED, + /* Local symbol. */ + COFF_SYMBOL_LOCAL, + /* PE section symbol. */ + COFF_SYMBOL_PE_SECTION +@}; + +@end example +Special entry points for gdb to swap in coff symbol table parts: +@example +typedef struct +@{ + void (*_bfd_coff_swap_aux_in) PARAMS (( + bfd *abfd, + PTR ext, + int type, + int class, + int indaux, + int numaux, + PTR in)); + + void (*_bfd_coff_swap_sym_in) PARAMS (( + bfd *abfd , + PTR ext, + PTR in)); + + void (*_bfd_coff_swap_lineno_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + +@end example +Special entry points for gas to swap out coff parts: +@example + unsigned int (*_bfd_coff_swap_aux_out) PARAMS (( + bfd *abfd, + PTR in, + int type, + int class, + int indaux, + int numaux, + PTR ext)); + + unsigned int (*_bfd_coff_swap_sym_out) PARAMS (( + bfd *abfd, + PTR in, + PTR ext)); + + unsigned int (*_bfd_coff_swap_lineno_out) PARAMS (( + bfd *abfd, + PTR in, + PTR ext)); + + unsigned int (*_bfd_coff_swap_reloc_out) PARAMS (( + bfd *abfd, + PTR src, + PTR dst)); + + unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS (( + bfd *abfd, + PTR in, + PTR out)); + + unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS (( + bfd *abfd, + PTR in, + PTR out)); + + unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS (( + bfd *abfd, + PTR in, + PTR out)); + +@end example +Special entry points for generic COFF routines to call target +dependent COFF routines: +@example + unsigned int _bfd_filhsz; + unsigned int _bfd_aoutsz; + unsigned int _bfd_scnhsz; + unsigned int _bfd_symesz; + unsigned int _bfd_auxesz; + unsigned int _bfd_relsz; + unsigned int _bfd_linesz; + unsigned int _bfd_filnmlen; + boolean _bfd_coff_long_filenames; + boolean _bfd_coff_long_section_names; + unsigned int _bfd_coff_default_section_alignment_power; + void (*_bfd_coff_swap_filehdr_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + void (*_bfd_coff_swap_aouthdr_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + void (*_bfd_coff_swap_scnhdr_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + void (*_bfd_coff_swap_reloc_in) PARAMS (( + bfd *abfd, + PTR ext, + PTR in)); + boolean (*_bfd_coff_bad_format_hook) PARAMS (( + bfd *abfd, + PTR internal_filehdr)); + boolean (*_bfd_coff_set_arch_mach_hook) PARAMS (( + bfd *abfd, + PTR internal_filehdr)); + PTR (*_bfd_coff_mkobject_hook) PARAMS (( + bfd *abfd, + PTR internal_filehdr, + PTR internal_aouthdr)); + flagword (*_bfd_styp_to_sec_flags_hook) PARAMS (( + bfd *abfd, + PTR internal_scnhdr, + const char *name, + asection *section)); + void (*_bfd_set_alignment_hook) PARAMS (( + bfd *abfd, + asection *sec, + PTR internal_scnhdr)); + boolean (*_bfd_coff_slurp_symbol_table) PARAMS (( + bfd *abfd)); + boolean (*_bfd_coff_symname_in_debug) PARAMS (( + bfd *abfd, + struct internal_syment *sym)); + boolean (*_bfd_coff_pointerize_aux_hook) PARAMS (( + bfd *abfd, + combined_entry_type *table_base, + combined_entry_type *symbol, + unsigned int indaux, + combined_entry_type *aux)); + boolean (*_bfd_coff_print_aux) PARAMS (( + bfd *abfd, + FILE *file, + combined_entry_type *table_base, + combined_entry_type *symbol, + combined_entry_type *aux, + unsigned int indaux)); + void (*_bfd_coff_reloc16_extra_cases) PARAMS (( + bfd *abfd, + struct bfd_link_info *link_info, + struct bfd_link_order *link_order, + arelent *reloc, + bfd_byte *data, + unsigned int *src_ptr, + unsigned int *dst_ptr)); + int (*_bfd_coff_reloc16_estimate) PARAMS (( + bfd *abfd, + asection *input_section, + arelent *r, + unsigned int shrink, + struct bfd_link_info *link_info)); + enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS (( + bfd *abfd, + struct internal_syment *)); + boolean (*_bfd_coff_compute_section_file_positions) PARAMS (( + bfd *abfd)); + boolean (*_bfd_coff_start_final_link) PARAMS (( + bfd *output_bfd, + struct bfd_link_info *info)); + boolean (*_bfd_coff_relocate_section) PARAMS (( + bfd *output_bfd, + struct bfd_link_info *info, + bfd *input_bfd, + asection *input_section, + bfd_byte *contents, + struct internal_reloc *relocs, + struct internal_syment *syms, + asection **sections)); + reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS (( + bfd *abfd, + asection *sec, + struct internal_reloc *rel, + struct coff_link_hash_entry *h, + struct internal_syment *sym, + bfd_vma *addendp)); + boolean (*_bfd_coff_adjust_symndx) PARAMS (( + bfd *obfd, + struct bfd_link_info *info, + bfd *ibfd, + asection *sec, + struct internal_reloc *reloc, + boolean *adjustedp)); + boolean (*_bfd_coff_link_add_one_symbol) PARAMS (( + struct bfd_link_info *info, + bfd *abfd, + const char *name, + flagword flags, + asection *section, + bfd_vma value, + const char *string, + boolean copy, + boolean collect, + struct bfd_link_hash_entry **hashp)); + + boolean (*_bfd_coff_link_output_has_begun) PARAMS (( + bfd * abfd, + struct coff_final_link_info * pfinfo)); + boolean (*_bfd_coff_final_link_postscript) PARAMS (( + bfd * abfd, + struct coff_final_link_info * pfinfo)); + +@} bfd_coff_backend_data; + +#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) + +#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ + ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) + +#define bfd_coff_swap_sym_in(a,e,i) \ + ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) + +#define bfd_coff_swap_lineno_in(a,e,i) \ + ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) + +#define bfd_coff_swap_reloc_out(abfd, i, o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) + +#define bfd_coff_swap_lineno_out(abfd, i, o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) + +#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ + ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) + +#define bfd_coff_swap_sym_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) + +#define bfd_coff_swap_scnhdr_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) + +#define bfd_coff_swap_filehdr_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) + +#define bfd_coff_swap_aouthdr_out(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) + +#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) +#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) +#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) +#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) +#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) +#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) +#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) +#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) +#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames) +#define bfd_coff_long_section_names(abfd) \ + (coff_backend_info (abfd)->_bfd_coff_long_section_names) +#define bfd_coff_default_section_alignment_power(abfd) \ + (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) +#define bfd_coff_swap_filehdr_in(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) + +#define bfd_coff_swap_aouthdr_in(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) + +#define bfd_coff_swap_scnhdr_in(abfd, i,o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) + +#define bfd_coff_swap_reloc_in(abfd, i, o) \ + ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) + +#define bfd_coff_bad_format_hook(abfd, filehdr) \ + ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) + +#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ + ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) +#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ + ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr)) + +#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\ + ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ + (abfd, scnhdr, name, section)) + +#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ + ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) + +#define bfd_coff_slurp_symbol_table(abfd)\ + ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) + +#define bfd_coff_symname_in_debug(abfd, sym)\ + ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) + +#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ + ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ + (abfd, file, base, symbol, aux, indaux)) + +#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\ + ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ + (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) + +#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ + ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ + (abfd, section, reloc, shrink, link_info)) + +#define bfd_coff_classify_symbol(abfd, sym)\ + ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ + (abfd, sym)) + +#define bfd_coff_compute_section_file_positions(abfd)\ + ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ + (abfd)) + +#define bfd_coff_start_final_link(obfd, info)\ + ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ + (obfd, info)) +#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ + ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ + (obfd, info, ibfd, o, con, rel, isyms, secs)) +#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ + ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ + (abfd, sec, rel, h, sym, addendp)) +#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ + ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ + (obfd, info, ibfd, sec, rel, adjustedp)) +#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\ + ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ + (info, abfd, name, flags, section, value, string, cp, coll, hashp)) + +#define bfd_coff_link_output_has_begun(a,p) \ + ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p)) +#define bfd_coff_final_link_postscript(a,p) \ + ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p)) + +@end example +@subsubsection Writing relocations +To write relocations, the back end steps though the +canonical relocation table and create an +@code{internal_reloc}. The symbol index to use is removed from +the @code{offset} field in the symbol table supplied. The +address comes directly from the sum of the section base +address and the relocation offset; the type is dug directly +from the howto field. Then the @code{internal_reloc} is +swapped into the shape of an @code{external_reloc} and written +out to disk. + +@subsubsection Reading linenumbers +Creating the linenumber table is done by reading in the entire +coff linenumber table, and creating another table for internal use. + +A coff linenumber table is structured so that each function +is marked as having a line number of 0. Each line within the +function is an offset from the first line in the function. The +base of the line number information for the table is stored in +the symbol associated with the function. + +Note: The PE format uses line number 0 for a flag indicating a +new source file. + +The information is copied from the external to the internal +table, and each symbol which marks a function is marked by +pointing its... + +How does this work ? + +@subsubsection Reading relocations +Coff relocations are easily transformed into the internal BFD form +(@code{arelent}). + +Reading a coff relocation table is done in the following stages: + +@itemize @bullet + +@item +Read the entire coff relocation table into memory. + +@item +Process each relocation in turn; first swap it from the +external to the internal form. + +@item +Turn the symbol referenced in the relocation's symbol index +into a pointer into the canonical symbol table. +This table is the same as the one returned by a call to +@code{bfd_canonicalize_symtab}. The back end will call that +routine and save the result if a canonicalization hasn't been done. + +@item +The reloc index is turned into a pointer to a howto +structure, in a back end specific way. For instance, the 386 +and 960 use the @code{r_type} to directly produce an index +into a howto table vector; the 88k subtracts a number from the +@code{r_type} field and creates an addend field. +@end itemize + diff --git a/bfd/doc/core.texi b/bfd/doc/core.texi new file mode 100644 index 00000000000..55e369ab2ac --- /dev/null +++ b/bfd/doc/core.texi @@ -0,0 +1,38 @@ +@section Core files + + +@strong{Description}@* +These are functions pertaining to core files. + +@findex bfd_core_file_failing_command +@subsubsection @code{bfd_core_file_failing_command} +@strong{Synopsis} +@example +CONST char *bfd_core_file_failing_command(bfd *abfd); +@end example +@strong{Description}@* +Return a read-only string explaining which program was running +when it failed and produced the core file @var{abfd}. + +@findex bfd_core_file_failing_signal +@subsubsection @code{bfd_core_file_failing_signal} +@strong{Synopsis} +@example +int bfd_core_file_failing_signal(bfd *abfd); +@end example +@strong{Description}@* +Returns the signal number which caused the core dump which +generated the file the BFD @var{abfd} is attached to. + +@findex core_file_matches_executable_p +@subsubsection @code{core_file_matches_executable_p} +@strong{Synopsis} +@example +boolean core_file_matches_executable_p + (bfd *core_bfd, bfd *exec_bfd); +@end example +@strong{Description}@* +Return @code{true} if the core file attached to @var{core_bfd} +was generated by a run of the executable file attached to +@var{exec_bfd}, @code{false} otherwise. + diff --git a/bfd/doc/elf.texi b/bfd/doc/elf.texi new file mode 100644 index 00000000000..4f9434cf69d --- /dev/null +++ b/bfd/doc/elf.texi @@ -0,0 +1,22 @@ +@section ELF backends +BFD support for ELF formats is being worked on. +Currently, the best supported back ends are for sparc and i386 +(running svr4 or Solaris 2). + +Documentation of the internals of the support code still needs +to be written. The code is changing quickly enough that we +haven't bothered yet. + +@findex bfd_elf_find_section +@subsubsection @code{bfd_elf_find_section} +@strong{Synopsis} +@example +struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name); +@end example +@strong{Description}@* +Helper functions for GDB to locate the string tables. +Since BFD hides string tables from callers, GDB needs to use an +internal hook to find them. Sun's .stabstr, in particular, +isn't even pointed to by the .stab section, so ordinary +mechanisms wouldn't work to find it, even if we had some. + diff --git a/bfd/doc/elfcode.texi b/bfd/doc/elfcode.texi new file mode 100644 index 00000000000..e69de29bb2d --- /dev/null +++ b/bfd/doc/elfcode.texi diff --git a/bfd/doc/format.texi b/bfd/doc/format.texi new file mode 100644 index 00000000000..3281c36eac8 --- /dev/null +++ b/bfd/doc/format.texi @@ -0,0 +1,108 @@ +@section File formats +A format is a BFD concept of high level file contents type. The +formats supported by BFD are: + +@itemize @bullet + +@item +@code{bfd_object} +@end itemize +The BFD may contain data, symbols, relocations and debug info. + +@itemize @bullet + +@item +@code{bfd_archive} +@end itemize +The BFD contains other BFDs and an optional index. + +@itemize @bullet + +@item +@code{bfd_core} +@end itemize +The BFD contains the result of an executable core dump. + +@findex bfd_check_format +@subsubsection @code{bfd_check_format} +@strong{Synopsis} +@example +boolean bfd_check_format(bfd *abfd, bfd_format format); +@end example +@strong{Description}@* +Verify if the file attached to the BFD @var{abfd} is compatible +with the format @var{format} (i.e., one of @code{bfd_object}, +@code{bfd_archive} or @code{bfd_core}). + +If the BFD has been set to a specific target before the +call, only the named target and format combination is +checked. If the target has not been set, or has been set to +@code{default}, then all the known target backends is +interrogated to determine a match. If the default target +matches, it is used. If not, exactly one target must recognize +the file, or an error results. + +The function returns @code{true} on success, otherwise @code{false} +with one of the following error codes: + +@itemize @bullet + +@item +@code{bfd_error_invalid_operation} - +if @code{format} is not one of @code{bfd_object}, @code{bfd_archive} or +@code{bfd_core}. + +@item +@code{bfd_error_system_call} - +if an error occured during a read - even some file mismatches +can cause bfd_error_system_calls. + +@item +@code{file_not_recognised} - +none of the backends recognised the file format. + +@item +@code{bfd_error_file_ambiguously_recognized} - +more than one backend recognised the file format. +@end itemize + +@findex bfd_check_format_matches +@subsubsection @code{bfd_check_format_matches} +@strong{Synopsis} +@example +boolean bfd_check_format_matches(bfd *abfd, bfd_format format, char ***matching); +@end example +@strong{Description}@* +Like @code{bfd_check_format}, except when it returns false with +@code{bfd_errno} set to @code{bfd_error_file_ambiguously_recognized}. In that +case, if @var{matching} is not NULL, it will be filled in with +a NULL-terminated list of the names of the formats that matched, +allocated with @code{malloc}. +Then the user may choose a format and try again. + +When done with the list that @var{matching} points to, the caller +should free it. + +@findex bfd_set_format +@subsubsection @code{bfd_set_format} +@strong{Synopsis} +@example +boolean bfd_set_format(bfd *abfd, bfd_format format); +@end example +@strong{Description}@* +This function sets the file format of the BFD @var{abfd} to the +format @var{format}. If the target set in the BFD does not +support the format requested, the format is invalid, or the BFD +is not open for writing, then an error occurs. + +@findex bfd_format_string +@subsubsection @code{bfd_format_string} +@strong{Synopsis} +@example +CONST char *bfd_format_string(bfd_format format); +@end example +@strong{Description}@* +Return a pointer to a const string +@code{invalid}, @code{object}, @code{archive}, @code{core}, or @code{unknown}, +depending upon the value of @var{format}. + diff --git a/bfd/doc/hash.texi b/bfd/doc/hash.texi new file mode 100644 index 00000000000..7ddc900cd2e --- /dev/null +++ b/bfd/doc/hash.texi @@ -0,0 +1,245 @@ +@section Hash Tables +@cindex Hash tables +BFD provides a simple set of hash table functions. Routines +are provided to initialize a hash table, to free a hash table, +to look up a string in a hash table and optionally create an +entry for it, and to traverse a hash table. There is +currently no routine to delete an string from a hash table. + +The basic hash table does not permit any data to be stored +with a string. However, a hash table is designed to present a +base class from which other types of hash tables may be +derived. These derived types may store additional information +with the string. Hash tables were implemented in this way, +rather than simply providing a data pointer in a hash table +entry, because they were designed for use by the linker back +ends. The linker may create thousands of hash table entries, +and the overhead of allocating private data and storing and +following pointers becomes noticeable. + +The basic hash table code is in @code{hash.c}. + +@menu +* Creating and Freeing a Hash Table:: +* Looking Up or Entering a String:: +* Traversing a Hash Table:: +* Deriving a New Hash Table Type:: +@end menu + +@node Creating and Freeing a Hash Table, Looking Up or Entering a String, Hash Tables, Hash Tables +@subsection Creating and freeing a hash table +@findex bfd_hash_table_init +@findex bfd_hash_table_init_n +To create a hash table, create an instance of a @code{struct +bfd_hash_table} (defined in @code{bfd.h}) and call +@code{bfd_hash_table_init} (if you know approximately how many +entries you will need, the function @code{bfd_hash_table_init_n}, +which takes a @var{size} argument, may be used). +@code{bfd_hash_table_init} returns @code{false} if some sort of +error occurs. + +@findex bfd_hash_newfunc +The function @code{bfd_hash_table_init} take as an argument a +function to use to create new entries. For a basic hash +table, use the function @code{bfd_hash_newfunc}. @xref{Deriving +a New Hash Table Type}, for why you would want to use a +different value for this argument. + +@findex bfd_hash_allocate +@code{bfd_hash_table_init} will create an objalloc which will be +used to allocate new entries. You may allocate memory on this +objalloc using @code{bfd_hash_allocate}. + +@findex bfd_hash_table_free +Use @code{bfd_hash_table_free} to free up all the memory that has +been allocated for a hash table. This will not free up the +@code{struct bfd_hash_table} itself, which you must provide. + +@node Looking Up or Entering a String, Traversing a Hash Table, Creating and Freeing a Hash Table, Hash Tables +@subsection Looking up or entering a string +@findex bfd_hash_lookup +The function @code{bfd_hash_lookup} is used both to look up a +string in the hash table and to create a new entry. + +If the @var{create} argument is @code{false}, @code{bfd_hash_lookup} +will look up a string. If the string is found, it will +returns a pointer to a @code{struct bfd_hash_entry}. If the +string is not found in the table @code{bfd_hash_lookup} will +return @code{NULL}. You should not modify any of the fields in +the returns @code{struct bfd_hash_entry}. + +If the @var{create} argument is @code{true}, the string will be +entered into the hash table if it is not already there. +Either way a pointer to a @code{struct bfd_hash_entry} will be +returned, either to the existing structure or to a newly +created one. In this case, a @code{NULL} return means that an +error occurred. + +If the @var{create} argument is @code{true}, and a new entry is +created, the @var{copy} argument is used to decide whether to +copy the string onto the hash table objalloc or not. If +@var{copy} is passed as @code{false}, you must be careful not to +deallocate or modify the string as long as the hash table +exists. + +@node Traversing a Hash Table, Deriving a New Hash Table Type, Looking Up or Entering a String, Hash Tables +@subsection Traversing a hash table +@findex bfd_hash_traverse +The function @code{bfd_hash_traverse} may be used to traverse a +hash table, calling a function on each element. The traversal +is done in a random order. + +@code{bfd_hash_traverse} takes as arguments a function and a +generic @code{void *} pointer. The function is called with a +hash table entry (a @code{struct bfd_hash_entry *}) and the +generic pointer passed to @code{bfd_hash_traverse}. The function +must return a @code{boolean} value, which indicates whether to +continue traversing the hash table. If the function returns +@code{false}, @code{bfd_hash_traverse} will stop the traversal and +return immediately. + +@node Deriving a New Hash Table Type, , Traversing a Hash Table, Hash Tables +@subsection Deriving a new hash table type +Many uses of hash tables want to store additional information +which each entry in the hash table. Some also find it +convenient to store additional information with the hash table +itself. This may be done using a derived hash table. + +Since C is not an object oriented language, creating a derived +hash table requires sticking together some boilerplate +routines with a few differences specific to the type of hash +table you want to create. + +An example of a derived hash table is the linker hash table. +The structures for this are defined in @code{bfdlink.h}. The +functions are in @code{linker.c}. + +You may also derive a hash table from an already derived hash +table. For example, the a.out linker backend code uses a hash +table derived from the linker hash table. + +@menu +* Define the Derived Structures:: +* Write the Derived Creation Routine:: +* Write Other Derived Routines:: +@end menu + +@node Define the Derived Structures, Write the Derived Creation Routine, Deriving a New Hash Table Type, Deriving a New Hash Table Type +@subsubsection Define the derived structures +You must define a structure for an entry in the hash table, +and a structure for the hash table itself. + +The first field in the structure for an entry in the hash +table must be of the type used for an entry in the hash table +you are deriving from. If you are deriving from a basic hash +table this is @code{struct bfd_hash_entry}, which is defined in +@code{bfd.h}. The first field in the structure for the hash +table itself must be of the type of the hash table you are +deriving from itself. If you are deriving from a basic hash +table, this is @code{struct bfd_hash_table}. + +For example, the linker hash table defines @code{struct +bfd_link_hash_entry} (in @code{bfdlink.h}). The first field, +@code{root}, is of type @code{struct bfd_hash_entry}. Similarly, +the first field in @code{struct bfd_link_hash_table}, @code{table}, +is of type @code{struct bfd_hash_table}. + +@node Write the Derived Creation Routine, Write Other Derived Routines, Define the Derived Structures, Deriving a New Hash Table Type +@subsubsection Write the derived creation routine +You must write a routine which will create and initialize an +entry in the hash table. This routine is passed as the +function argument to @code{bfd_hash_table_init}. + +In order to permit other hash tables to be derived from the +hash table you are creating, this routine must be written in a +standard way. + +The first argument to the creation routine is a pointer to a +hash table entry. This may be @code{NULL}, in which case the +routine should allocate the right amount of space. Otherwise +the space has already been allocated by a hash table type +derived from this one. + +After allocating space, the creation routine must call the +creation routine of the hash table type it is derived from, +passing in a pointer to the space it just allocated. This +will initialize any fields used by the base hash table. + +Finally the creation routine must initialize any local fields +for the new hash table type. + +Here is a boilerplate example of a creation routine. +@var{function_name} is the name of the routine. +@var{entry_type} is the type of an entry in the hash table you +are creating. @var{base_newfunc} is the name of the creation +routine of the hash table type your hash table is derived +from. + + +@example +struct bfd_hash_entry * +@var{function_name} (entry, table, string) + struct bfd_hash_entry *entry; + struct bfd_hash_table *table; + const char *string; +@{ + struct @var{entry_type} *ret = (@var{entry_type} *) entry; + + /* Allocate the structure if it has not already been allocated by a + derived class. */ + if (ret == (@var{entry_type} *) NULL) + @{ + ret = ((@var{entry_type} *) + bfd_hash_allocate (table, sizeof (@var{entry_type}))); + if (ret == (@var{entry_type} *) NULL) + return NULL; + @} + + /* Call the allocation method of the base class. */ + ret = ((@var{entry_type} *) + @var{base_newfunc} ((struct bfd_hash_entry *) ret, table, string)); + + /* Initialize the local fields here. */ + + return (struct bfd_hash_entry *) ret; +@} +@end example +@strong{Description}@* +The creation routine for the linker hash table, which is in +@code{linker.c}, looks just like this example. +@var{function_name} is @code{_bfd_link_hash_newfunc}. +@var{entry_type} is @code{struct bfd_link_hash_entry}. +@var{base_newfunc} is @code{bfd_hash_newfunc}, the creation +routine for a basic hash table. + +@code{_bfd_link_hash_newfunc} also initializes the local fields +in a linker hash table entry: @code{type}, @code{written} and +@code{next}. + +@node Write Other Derived Routines, , Write the Derived Creation Routine, Deriving a New Hash Table Type +@subsubsection Write other derived routines +You will want to write other routines for your new hash table, +as well. + +You will want an initialization routine which calls the +initialization routine of the hash table you are deriving from +and initializes any other local fields. For the linker hash +table, this is @code{_bfd_link_hash_table_init} in @code{linker.c}. + +You will want a lookup routine which calls the lookup routine +of the hash table you are deriving from and casts the result. +The linker hash table uses @code{bfd_link_hash_lookup} in +@code{linker.c} (this actually takes an additional argument which +it uses to decide how to return the looked up value). + +You may want a traversal routine. This should just call the +traversal routine of the hash table you are deriving from with +appropriate casts. The linker hash table uses +@code{bfd_link_hash_traverse} in @code{linker.c}. + +These routines may simply be defined as macros. For example, +the a.out backend linker hash table, which is derived from the +linker hash table, uses macros for the lookup and traversal +routines. These are @code{aout_link_hash_lookup} and +@code{aout_link_hash_traverse} in aoutx.h. + diff --git a/bfd/doc/init.texi b/bfd/doc/init.texi new file mode 100644 index 00000000000..e561a7720f7 --- /dev/null +++ b/bfd/doc/init.texi @@ -0,0 +1,13 @@ +@section Initialization +These are the functions that handle initializing a BFD. + +@findex bfd_init +@subsubsection @code{bfd_init} +@strong{Synopsis} +@example +void bfd_init(void); +@end example +@strong{Description}@* +This routine must be called before any other BFD function to +initialize magical internal data structures. + diff --git a/bfd/doc/libbfd.texi b/bfd/doc/libbfd.texi new file mode 100644 index 00000000000..d202dc208db --- /dev/null +++ b/bfd/doc/libbfd.texi @@ -0,0 +1,156 @@ +@section Internal functions + + +@strong{Description}@* +These routines are used within BFD. +They are not intended for export, but are documented here for +completeness. + +@findex bfd_write_bigendian_4byte_int +@subsubsection @code{bfd_write_bigendian_4byte_int} +@strong{Synopsis} +@example +void bfd_write_bigendian_4byte_int(bfd *abfd, int i); +@end example +@strong{Description}@* +Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big +endian order regardless of what else is going on. This is useful in +archives. + +@findex bfd_put_size +@subsubsection @code{bfd_put_size} +@findex bfd_get_size +@subsubsection @code{bfd_get_size} +@strong{Description}@* +These macros as used for reading and writing raw data in +sections; each access (except for bytes) is vectored through +the target format of the BFD and mangled accordingly. The +mangling performs any necessary endian translations and +removes alignment restrictions. Note that types accepted and +returned by these macros are identical so they can be swapped +around in macros---for example, @file{libaout.h} defines @code{GET_WORD} +to either @code{bfd_get_32} or @code{bfd_get_64}. + +In the put routines, @var{val} must be a @code{bfd_vma}. If we are on a +system without prototypes, the caller is responsible for making +sure that is true, with a cast if necessary. We don't cast +them in the macro definitions because that would prevent @code{lint} +or @code{gcc -Wall} from detecting sins such as passing a pointer. +To detect calling these with less than a @code{bfd_vma}, use +@code{gcc -Wconversion} on a host with 64 bit @code{bfd_vma}'s. +@example + + /* Byte swapping macros for user section data. */ + +#define bfd_put_8(abfd, val, ptr) \ + ((void) (*((unsigned char *)(ptr)) = (unsigned char)(val))) +#define bfd_put_signed_8 \ + bfd_put_8 +#define bfd_get_8(abfd, ptr) \ + (*(unsigned char *)(ptr)) +#define bfd_get_signed_8(abfd, ptr) \ + ((*(unsigned char *)(ptr) ^ 0x80) - 0x80) + +#define bfd_put_16(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx16, ((val),(ptr))) +#define bfd_put_signed_16 \ + bfd_put_16 +#define bfd_get_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx16, (ptr)) +#define bfd_get_signed_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) + +#define bfd_put_32(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx32, ((val),(ptr))) +#define bfd_put_signed_32 \ + bfd_put_32 +#define bfd_get_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx32, (ptr)) +#define bfd_get_signed_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx_signed_32, (ptr)) + +#define bfd_put_64(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx64, ((val), (ptr))) +#define bfd_put_signed_64 \ + bfd_put_64 +#define bfd_get_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx64, (ptr)) +#define bfd_get_signed_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx_signed_64, (ptr)) + +#define bfd_get(bits, abfd, ptr) \ + ((bits) == 8 ? bfd_get_8 (abfd, ptr) \ + : (bits) == 16 ? bfd_get_16 (abfd, ptr) \ + : (bits) == 32 ? bfd_get_32 (abfd, ptr) \ + : (bits) == 64 ? bfd_get_64 (abfd, ptr) \ + : (abort (), (bfd_vma) - 1)) + +#define bfd_put(bits, abfd, val, ptr) \ + ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \ + : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \ + : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \ + : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \ + : (abort (), (void) 0)) + +@end example + +@findex bfd_h_put_size +@subsubsection @code{bfd_h_put_size} +@strong{Description}@* +These macros have the same function as their @code{bfd_get_x} +bretheren, except that they are used for removing information +for the header records of object files. Believe it or not, +some object files keep their header records in big endian +order and their data in little endian order. +@example + + /* Byte swapping macros for file header data. */ + +#define bfd_h_put_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) +#define bfd_h_put_signed_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) +#define bfd_h_get_8(abfd, ptr) \ + bfd_get_8 (abfd, ptr) +#define bfd_h_get_signed_8(abfd, ptr) \ + bfd_get_signed_8 (abfd, ptr) + +#define bfd_h_put_16(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx16,(val,ptr)) +#define bfd_h_put_signed_16 \ + bfd_h_put_16 +#define bfd_h_get_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx16,(ptr)) +#define bfd_h_get_signed_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr)) + +#define bfd_h_put_32(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx32,(val,ptr)) +#define bfd_h_put_signed_32 \ + bfd_h_put_32 +#define bfd_h_get_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx32,(ptr)) +#define bfd_h_get_signed_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr)) + +#define bfd_h_put_64(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx64,(val, ptr)) +#define bfd_h_put_signed_64 \ + bfd_h_put_64 +#define bfd_h_get_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx64,(ptr)) +#define bfd_h_get_signed_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr)) + +@end example + +@findex bfd_log2 +@subsubsection @code{bfd_log2} +@strong{Synopsis} +@example +unsigned int bfd_log2(bfd_vma x); +@end example +@strong{Description}@* +Return the log base 2 of the value supplied, rounded up. E.g., an +@var{x} of 1025 returns 11. + diff --git a/bfd/doc/linker.texi b/bfd/doc/linker.texi new file mode 100644 index 00000000000..b61815643f7 --- /dev/null +++ b/bfd/doc/linker.texi @@ -0,0 +1,365 @@ +@section Linker Functions +@cindex Linker +The linker uses three special entry points in the BFD target +vector. It is not necessary to write special routines for +these entry points when creating a new BFD back end, since +generic versions are provided. However, writing them can +speed up linking and make it use significantly less runtime +memory. + +The first routine creates a hash table used by the other +routines. The second routine adds the symbols from an object +file to the hash table. The third routine takes all the +object files and links them together to create the output +file. These routines are designed so that the linker proper +does not need to know anything about the symbols in the object +files that it is linking. The linker merely arranges the +sections as directed by the linker script and lets BFD handle +the details of symbols and relocs. + +The second routine and third routines are passed a pointer to +a @code{struct bfd_link_info} structure (defined in +@code{bfdlink.h}) which holds information relevant to the link, +including the linker hash table (which was created by the +first routine) and a set of callback functions to the linker +proper. + +The generic linker routines are in @code{linker.c}, and use the +header file @code{genlink.h}. As of this writing, the only back +ends which have implemented versions of these routines are +a.out (in @code{aoutx.h}) and ECOFF (in @code{ecoff.c}). The a.out +routines are used as examples throughout this section. + +@menu +* Creating a Linker Hash Table:: +* Adding Symbols to the Hash Table:: +* Performing the Final Link:: +@end menu + +@node Creating a Linker Hash Table, Adding Symbols to the Hash Table, Linker Functions, Linker Functions +@subsection Creating a linker hash table +@cindex _bfd_link_hash_table_create in target vector +@cindex target vector (_bfd_link_hash_table_create) +The linker routines must create a hash table, which must be +derived from @code{struct bfd_link_hash_table} described in +@code{bfdlink.c}. @xref{Hash Tables}, for information on how to +create a derived hash table. This entry point is called using +the target vector of the linker output file. + +The @code{_bfd_link_hash_table_create} entry point must allocate +and initialize an instance of the desired hash table. If the +back end does not require any additional information to be +stored with the entries in the hash table, the entry point may +simply create a @code{struct bfd_link_hash_table}. Most likely, +however, some additional information will be needed. + +For example, with each entry in the hash table the a.out +linker keeps the index the symbol has in the final output file +(this index number is used so that when doing a relocateable +link the symbol index used in the output file can be quickly +filled in when copying over a reloc). The a.out linker code +defines the required structures and functions for a hash table +derived from @code{struct bfd_link_hash_table}. The a.out linker +hash table is created by the function +@code{NAME(aout,link_hash_table_create)}; it simply allocates +space for the hash table, initializes it, and returns a +pointer to it. + +When writing the linker routines for a new back end, you will +generally not know exactly which fields will be required until +you have finished. You should simply create a new hash table +which defines no additional fields, and then simply add fields +as they become necessary. + +@node Adding Symbols to the Hash Table, Performing the Final Link, Creating a Linker Hash Table, Linker Functions +@subsection Adding symbols to the hash table +@cindex _bfd_link_add_symbols in target vector +@cindex target vector (_bfd_link_add_symbols) +The linker proper will call the @code{_bfd_link_add_symbols} +entry point for each object file or archive which is to be +linked (typically these are the files named on the command +line, but some may also come from the linker script). The +entry point is responsible for examining the file. For an +object file, BFD must add any relevant symbol information to +the hash table. For an archive, BFD must determine which +elements of the archive should be used and adding them to the +link. + +The a.out version of this entry point is +@code{NAME(aout,link_add_symbols)}. + +@menu +* Differing file formats:: +* Adding symbols from an object file:: +* Adding symbols from an archive:: +@end menu + +@node Differing file formats, Adding symbols from an object file, Adding Symbols to the Hash Table, Adding Symbols to the Hash Table +@subsubsection Differing file formats +Normally all the files involved in a link will be of the same +format, but it is also possible to link together different +format object files, and the back end must support that. The +@code{_bfd_link_add_symbols} entry point is called via the target +vector of the file to be added. This has an important +consequence: the function may not assume that the hash table +is the type created by the corresponding +@code{_bfd_link_hash_table_create} vector. All the +@code{_bfd_link_add_symbols} function can assume about the hash +table is that it is derived from @code{struct +bfd_link_hash_table}. + +Sometimes the @code{_bfd_link_add_symbols} function must store +some information in the hash table entry to be used by the +@code{_bfd_final_link} function. In such a case the @code{creator} +field of the hash table must be checked to make sure that the +hash table was created by an object file of the same format. + +The @code{_bfd_final_link} routine must be prepared to handle a +hash entry without any extra information added by the +@code{_bfd_link_add_symbols} function. A hash entry without +extra information will also occur when the linker script +directs the linker to create a symbol. Note that, regardless +of how a hash table entry is added, all the fields will be +initialized to some sort of null value by the hash table entry +initialization function. + +See @code{ecoff_link_add_externals} for an example of how to +check the @code{creator} field before saving information (in this +case, the ECOFF external symbol debugging information) in a +hash table entry. + +@node Adding symbols from an object file, Adding symbols from an archive, Differing file formats, Adding Symbols to the Hash Table +@subsubsection Adding symbols from an object file +When the @code{_bfd_link_add_symbols} routine is passed an object +file, it must add all externally visible symbols in that +object file to the hash table. The actual work of adding the +symbol to the hash table is normally handled by the function +@code{_bfd_generic_link_add_one_symbol}. The +@code{_bfd_link_add_symbols} routine is responsible for reading +all the symbols from the object file and passing the correct +information to @code{_bfd_generic_link_add_one_symbol}. + +The @code{_bfd_link_add_symbols} routine should not use +@code{bfd_canonicalize_symtab} to read the symbols. The point of +providing this routine is to avoid the overhead of converting +the symbols into generic @code{asymbol} structures. + +@findex _bfd_generic_link_add_one_symbol +@code{_bfd_generic_link_add_one_symbol} handles the details of +combining common symbols, warning about multiple definitions, +and so forth. It takes arguments which describe the symbol to +add, notably symbol flags, a section, and an offset. The +symbol flags include such things as @code{BSF_WEAK} or +@code{BSF_INDIRECT}. The section is a section in the object +file, or something like @code{bfd_und_section_ptr} for an undefined +symbol or @code{bfd_com_section_ptr} for a common symbol. + +If the @code{_bfd_final_link} routine is also going to need to +read the symbol information, the @code{_bfd_link_add_symbols} +routine should save it somewhere attached to the object file +BFD. However, the information should only be saved if the +@code{keep_memory} field of the @code{info} argument is true, so +that the @code{-no-keep-memory} linker switch is effective. + +The a.out function which adds symbols from an object file is +@code{aout_link_add_object_symbols}, and most of the interesting +work is in @code{aout_link_add_symbols}. The latter saves +pointers to the hash tables entries created by +@code{_bfd_generic_link_add_one_symbol} indexed by symbol number, +so that the @code{_bfd_final_link} routine does not have to call +the hash table lookup routine to locate the entry. + +@node Adding symbols from an archive, , Adding symbols from an object file, Adding Symbols to the Hash Table +@subsubsection Adding symbols from an archive +When the @code{_bfd_link_add_symbols} routine is passed an +archive, it must look through the symbols defined by the +archive and decide which elements of the archive should be +included in the link. For each such element it must call the +@code{add_archive_element} linker callback, and it must add the +symbols from the object file to the linker hash table. + +@findex _bfd_generic_link_add_archive_symbols +In most cases the work of looking through the symbols in the +archive should be done by the +@code{_bfd_generic_link_add_archive_symbols} function. This +function builds a hash table from the archive symbol table and +looks through the list of undefined symbols to see which +elements should be included. +@code{_bfd_generic_link_add_archive_symbols} is passed a function +to call to make the final decision about adding an archive +element to the link and to do the actual work of adding the +symbols to the linker hash table. + +The function passed to +@code{_bfd_generic_link_add_archive_symbols} must read the +symbols of the archive element and decide whether the archive +element should be included in the link. If the element is to +be included, the @code{add_archive_element} linker callback +routine must be called with the element as an argument, and +the elements symbols must be added to the linker hash table +just as though the element had itself been passed to the +@code{_bfd_link_add_symbols} function. + +When the a.out @code{_bfd_link_add_symbols} function receives an +archive, it calls @code{_bfd_generic_link_add_archive_symbols} +passing @code{aout_link_check_archive_element} as the function +argument. @code{aout_link_check_archive_element} calls +@code{aout_link_check_ar_symbols}. If the latter decides to add +the element (an element is only added if it provides a real, +non-common, definition for a previously undefined or common +symbol) it calls the @code{add_archive_element} callback and then +@code{aout_link_check_archive_element} calls +@code{aout_link_add_symbols} to actually add the symbols to the +linker hash table. + +The ECOFF back end is unusual in that it does not normally +call @code{_bfd_generic_link_add_archive_symbols}, because ECOFF +archives already contain a hash table of symbols. The ECOFF +back end searches the archive itself to avoid the overhead of +creating a new hash table. + +@node Performing the Final Link, , Adding Symbols to the Hash Table, Linker Functions +@subsection Performing the final link +@cindex _bfd_link_final_link in target vector +@cindex target vector (_bfd_final_link) +When all the input files have been processed, the linker calls +the @code{_bfd_final_link} entry point of the output BFD. This +routine is responsible for producing the final output file, +which has several aspects. It must relocate the contents of +the input sections and copy the data into the output sections. +It must build an output symbol table including any local +symbols from the input files and the global symbols from the +hash table. When producing relocateable output, it must +modify the input relocs and write them into the output file. +There may also be object format dependent work to be done. + +The linker will also call the @code{write_object_contents} entry +point when the BFD is closed. The two entry points must work +together in order to produce the correct output file. + +The details of how this works are inevitably dependent upon +the specific object file format. The a.out +@code{_bfd_final_link} routine is @code{NAME(aout,final_link)}. + +@menu +* Information provided by the linker:: +* Relocating the section contents:: +* Writing the symbol table:: +@end menu + +@node Information provided by the linker, Relocating the section contents, Performing the Final Link, Performing the Final Link +@subsubsection Information provided by the linker +Before the linker calls the @code{_bfd_final_link} entry point, +it sets up some data structures for the function to use. + +The @code{input_bfds} field of the @code{bfd_link_info} structure +will point to a list of all the input files included in the +link. These files are linked through the @code{link_next} field +of the @code{bfd} structure. + +Each section in the output file will have a list of +@code{link_order} structures attached to the @code{link_order_head} +field (the @code{link_order} structure is defined in +@code{bfdlink.h}). These structures describe how to create the +contents of the output section in terms of the contents of +various input sections, fill constants, and, eventually, other +types of information. They also describe relocs that must be +created by the BFD backend, but do not correspond to any input +file; this is used to support -Ur, which builds constructors +while generating a relocateable object file. + +@node Relocating the section contents, Writing the symbol table, Information provided by the linker, Performing the Final Link +@subsubsection Relocating the section contents +The @code{_bfd_final_link} function should look through the +@code{link_order} structures attached to each section of the +output file. Each @code{link_order} structure should either be +handled specially, or it should be passed to the function +@code{_bfd_default_link_order} which will do the right thing +(@code{_bfd_default_link_order} is defined in @code{linker.c}). + +For efficiency, a @code{link_order} of type +@code{bfd_indirect_link_order} whose associated section belongs +to a BFD of the same format as the output BFD must be handled +specially. This type of @code{link_order} describes part of an +output section in terms of a section belonging to one of the +input files. The @code{_bfd_final_link} function should read the +contents of the section and any associated relocs, apply the +relocs to the section contents, and write out the modified +section contents. If performing a relocateable link, the +relocs themselves must also be modified and written out. + +@findex _bfd_relocate_contents +@findex _bfd_final_link_relocate +The functions @code{_bfd_relocate_contents} and +@code{_bfd_final_link_relocate} provide some general support for +performing the actual relocations, notably overflow checking. +Their arguments include information about the symbol the +relocation is against and a @code{reloc_howto_type} argument +which describes the relocation to perform. These functions +are defined in @code{reloc.c}. + +The a.out function which handles reading, relocating, and +writing section contents is @code{aout_link_input_section}. The +actual relocation is done in @code{aout_link_input_section_std} +and @code{aout_link_input_section_ext}. + +@node Writing the symbol table, , Relocating the section contents, Performing the Final Link +@subsubsection Writing the symbol table +The @code{_bfd_final_link} function must gather all the symbols +in the input files and write them out. It must also write out +all the symbols in the global hash table. This must be +controlled by the @code{strip} and @code{discard} fields of the +@code{bfd_link_info} structure. + +The local symbols of the input files will not have been +entered into the linker hash table. The @code{_bfd_final_link} +routine must consider each input file and include the symbols +in the output file. It may be convenient to do this when +looking through the @code{link_order} structures, or it may be +done by stepping through the @code{input_bfds} list. + +The @code{_bfd_final_link} routine must also traverse the global +hash table to gather all the externally visible symbols. It +is possible that most of the externally visible symbols may be +written out when considering the symbols of each input file, +but it is still necessary to traverse the hash table since the +linker script may have defined some symbols that are not in +any of the input files. + +The @code{strip} field of the @code{bfd_link_info} structure +controls which symbols are written out. The possible values +are listed in @code{bfdlink.h}. If the value is @code{strip_some}, +then the @code{keep_hash} field of the @code{bfd_link_info} +structure is a hash table of symbols to keep; each symbol +should be looked up in this hash table, and only symbols which +are present should be included in the output file. + +If the @code{strip} field of the @code{bfd_link_info} structure +permits local symbols to be written out, the @code{discard} field +is used to further controls which local symbols are included +in the output file. If the value is @code{discard_l}, then all +local symbols which begin with a certain prefix are discarded; +this is controlled by the @code{bfd_is_local_label_name} entry point. + +The a.out backend handles symbols by calling +@code{aout_link_write_symbols} on each input BFD and then +traversing the global hash table with the function +@code{aout_link_write_other_symbol}. It builds a string table +while writing out the symbols, which is written to the output +file at the end of @code{NAME(aout,final_link)}. + +@findex bfd_link_split_section +@subsubsection @code{bfd_link_split_section} +@strong{Synopsis} +@example +boolean bfd_link_split_section(bfd *abfd, asection *sec); +@end example +@strong{Description}@* +Return nonzero if @var{sec} should be split during a +reloceatable or final link. +@example +#define bfd_link_split_section(abfd, sec) \ + BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec)) + +@end example + diff --git a/bfd/doc/opncls.texi b/bfd/doc/opncls.texi new file mode 100644 index 00000000000..fcea49b4e04 --- /dev/null +++ b/bfd/doc/opncls.texi @@ -0,0 +1,159 @@ +@section Opening and closing BFDs + + +@findex bfd_openr +@subsubsection @code{bfd_openr} +@strong{Synopsis} +@example +bfd *bfd_openr(CONST char *filename, CONST char *target); +@end example +@strong{Description}@* +Open the file @var{filename} (using @code{fopen}) with the target +@var{target}. Return a pointer to the created BFD. + +Calls @code{bfd_find_target}, so @var{target} is interpreted as by +that function. + +If @code{NULL} is returned then an error has occured. Possible errors +are @code{bfd_error_no_memory}, @code{bfd_error_invalid_target} or @code{system_call} error. + +@findex bfd_fdopenr +@subsubsection @code{bfd_fdopenr} +@strong{Synopsis} +@example +bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd); +@end example +@strong{Description}@* +@code{bfd_fdopenr} is to @code{bfd_fopenr} much like @code{fdopen} is to @code{fopen}. +It opens a BFD on a file already described by the @var{fd} +supplied. + +When the file is later @code{bfd_close}d, the file descriptor will be closed. + +If the caller desires that this file descriptor be cached by BFD +(opened as needed, closed as needed to free descriptors for +other opens), with the supplied @var{fd} used as an initial +file descriptor (but subject to closure at any time), call +bfd_set_cacheable(bfd, 1) on the returned BFD. The default is to +assume no cacheing; the file descriptor will remain open until +@code{bfd_close}, and will not be affected by BFD operations on other +files. + +Possible errors are @code{bfd_error_no_memory}, @code{bfd_error_invalid_target} and @code{bfd_error_system_call}. + +@findex bfd_openstreamr +@subsubsection @code{bfd_openstreamr} +@strong{Synopsis} +@example +bfd *bfd_openstreamr(const char *, const char *, PTR); +@end example +@strong{Description}@* +Open a BFD for read access on an existing stdio stream. When +the BFD is passed to @code{bfd_close}, the stream will be closed. + +@findex bfd_openw +@subsubsection @code{bfd_openw} +@strong{Synopsis} +@example +bfd *bfd_openw(CONST char *filename, CONST char *target); +@end example +@strong{Description}@* +Create a BFD, associated with file @var{filename}, using the +file format @var{target}, and return a pointer to it. + +Possible errors are @code{bfd_error_system_call}, @code{bfd_error_no_memory}, +@code{bfd_error_invalid_target}. + +@findex bfd_close +@subsubsection @code{bfd_close} +@strong{Synopsis} +@example +boolean bfd_close(bfd *abfd); +@end example +@strong{Description}@* +Close a BFD. If the BFD was open for writing, +then pending operations are completed and the file written out +and closed. If the created file is executable, then +@code{chmod} is called to mark it as such. + +All memory attached to the BFD is released. + +The file descriptor associated with the BFD is closed (even +if it was passed in to BFD by @code{bfd_fdopenr}). + +@strong{Returns}@* +@code{true} is returned if all is ok, otherwise @code{false}. + +@findex bfd_close_all_done +@subsubsection @code{bfd_close_all_done} +@strong{Synopsis} +@example +boolean bfd_close_all_done(bfd *); +@end example +@strong{Description}@* +Close a BFD. Differs from @code{bfd_close} +since it does not complete any pending operations. This +routine would be used if the application had just used BFD for +swapping and didn't want to use any of the writing code. + +If the created file is executable, then @code{chmod} is called +to mark it as such. + +All memory attached to the BFD is released. + +@strong{Returns}@* +@code{true} is returned if all is ok, otherwise @code{false}. + +@findex bfd_create +@subsubsection @code{bfd_create} +@strong{Synopsis} +@example +bfd *bfd_create(CONST char *filename, bfd *templ); +@end example +@strong{Description}@* +Create a new BFD in the manner of +@code{bfd_openw}, but without opening a file. The new BFD +takes the target from the target used by @var{template}. The +format is always set to @code{bfd_object}. + +@findex bfd_make_writable +@subsubsection @code{bfd_make_writable} +@strong{Synopsis} +@example +boolean bfd_make_writable(bfd *abfd); +@end example +@strong{Description}@* +Takes a BFD as created by @code{bfd_create} and converts it +into one like as returned by @code{bfd_openw}. It does this +by converting the BFD to BFD_IN_MEMORY. It's assumed that +you will call @code{bfd_make_readable} on this bfd later. + +@strong{Returns}@* +@code{true} is returned if all is ok, otherwise @code{false}. + +@findex bfd_make_readable +@subsubsection @code{bfd_make_readable} +@strong{Synopsis} +@example +boolean bfd_make_readable(bfd *abfd); +@end example +@strong{Description}@* +Takes a BFD as created by @code{bfd_create} and +@code{bfd_make_writable} and converts it into one like as +returned by @code{bfd_openr}. It does this by writing the +contents out to the memory buffer, then reversing the +direction. + +@strong{Returns}@* +@code{true} is returned if all is ok, otherwise @code{false}. + +@findex bfd_alloc +@subsubsection @code{bfd_alloc} +@strong{Synopsis} +@example +PTR bfd_alloc (bfd *abfd, size_t wanted); +@end example +@strong{Description}@* +Allocate a block of @var{wanted} bytes of memory attached to +@code{abfd} and return a pointer to it. + diff --git a/bfd/doc/reloc.texi b/bfd/doc/reloc.texi new file mode 100644 index 00000000000..89811d81186 --- /dev/null +++ b/bfd/doc/reloc.texi @@ -0,0 +1,1267 @@ +@section Relocations +BFD maintains relocations in much the same way it maintains +symbols: they are left alone until required, then read in +en-masse and translated into an internal form. A common +routine @code{bfd_perform_relocation} acts upon the +canonical form to do the fixup. + +Relocations are maintained on a per section basis, +while symbols are maintained on a per BFD basis. + +All that a back end has to do to fit the BFD interface is to create +a @code{struct reloc_cache_entry} for each relocation +in a particular section, and fill in the right bits of the structures. + +@menu +* typedef arelent:: +* howto manager:: +@end menu + + +@node typedef arelent, howto manager, Relocations, Relocations +@subsection typedef arelent +This is the structure of a relocation entry: + + +@example + +typedef enum bfd_reloc_status +@{ + /* No errors detected */ + bfd_reloc_ok, + + /* The relocation was performed, but there was an overflow. */ + bfd_reloc_overflow, + + /* The address to relocate was not within the section supplied. */ + bfd_reloc_outofrange, + + /* Used by special functions */ + bfd_reloc_continue, + + /* Unsupported relocation size requested. */ + bfd_reloc_notsupported, + + /* Unused */ + bfd_reloc_other, + + /* The symbol to relocate against was undefined. */ + bfd_reloc_undefined, + + /* The relocation was performed, but may not be ok - presently + generated only when linking i960 coff files with i960 b.out + symbols. If this type is returned, the error_message argument + to bfd_perform_relocation will be set. */ + bfd_reloc_dangerous + @} + bfd_reloc_status_type; + + +typedef struct reloc_cache_entry +@{ + /* A pointer into the canonical table of pointers */ + struct symbol_cache_entry **sym_ptr_ptr; + + /* offset in section */ + bfd_size_type address; + + /* addend for relocation value */ + bfd_vma addend; + + /* Pointer to how to perform the required relocation */ + reloc_howto_type *howto; + +@} arelent; +@end example +@strong{Description}@* +Here is a description of each of the fields within an @code{arelent}: + +@itemize @bullet + +@item +@code{sym_ptr_ptr} +@end itemize +The symbol table pointer points to a pointer to the symbol +associated with the relocation request. It is +the pointer into the table returned by the back end's +@code{get_symtab} action. @xref{Symbols}. The symbol is referenced +through a pointer to a pointer so that tools like the linker +can fix up all the symbols of the same name by modifying only +one pointer. The relocation routine looks in the symbol and +uses the base of the section the symbol is attached to and the +value of the symbol as the initial relocation offset. If the +symbol pointer is zero, then the section provided is looked up. + +@itemize @bullet + +@item +@code{address} +@end itemize +The @code{address} field gives the offset in bytes from the base of +the section data which owns the relocation record to the first +byte of relocatable information. The actual data relocated +will be relative to this point; for example, a relocation +type which modifies the bottom two bytes of a four byte word +would not touch the first byte pointed to in a big endian +world. + +@itemize @bullet + +@item +@code{addend} +@end itemize +The @code{addend} is a value provided by the back end to be added (!) +to the relocation offset. Its interpretation is dependent upon +the howto. For example, on the 68k the code: + +@example + char foo[]; + main() + @{ + return foo[0x12345678]; + @} +@end example + +Could be compiled into: + +@example + linkw fp,#-4 + moveb @@#12345678,d0 + extbl d0 + unlk fp + rts +@end example + +This could create a reloc pointing to @code{foo}, but leave the +offset in the data, something like: + +@example +RELOCATION RECORDS FOR [.text]: +offset type value +00000006 32 _foo + +00000000 4e56 fffc ; linkw fp,#-4 +00000004 1039 1234 5678 ; moveb @@#12345678,d0 +0000000a 49c0 ; extbl d0 +0000000c 4e5e ; unlk fp +0000000e 4e75 ; rts +@end example + +Using coff and an 88k, some instructions don't have enough +space in them to represent the full address range, and +pointers have to be loaded in two parts. So you'd get something like: + +@example + or.u r13,r0,hi16(_foo+0x12345678) + ld.b r2,r13,lo16(_foo+0x12345678) + jmp r1 +@end example + +This should create two relocs, both pointing to @code{_foo}, and with +0x12340000 in their addend field. The data would consist of: + +@example +RELOCATION RECORDS FOR [.text]: +offset type value +00000002 HVRT16 _foo+0x12340000 +00000006 LVRT16 _foo+0x12340000 + +00000000 5da05678 ; or.u r13,r0,0x5678 +00000004 1c4d5678 ; ld.b r2,r13,0x5678 +00000008 f400c001 ; jmp r1 +@end example + +The relocation routine digs out the value from the data, adds +it to the addend to get the original offset, and then adds the +value of @code{_foo}. Note that all 32 bits have to be kept around +somewhere, to cope with carry from bit 15 to bit 16. + +One further example is the sparc and the a.out format. The +sparc has a similar problem to the 88k, in that some +instructions don't have room for an entire offset, but on the +sparc the parts are created in odd sized lumps. The designers of +the a.out format chose to not use the data within the section +for storing part of the offset; all the offset is kept within +the reloc. Anything in the data should be ignored. + +@example + save %sp,-112,%sp + sethi %hi(_foo+0x12345678),%g2 + ldsb [%g2+%lo(_foo+0x12345678)],%i0 + ret + restore +@end example + +Both relocs contain a pointer to @code{foo}, and the offsets +contain junk. + +@example +RELOCATION RECORDS FOR [.text]: +offset type value +00000004 HI22 _foo+0x12345678 +00000008 LO10 _foo+0x12345678 + +00000000 9de3bf90 ; save %sp,-112,%sp +00000004 05000000 ; sethi %hi(_foo+0),%g2 +00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0 +0000000c 81c7e008 ; ret +00000010 81e80000 ; restore +@end example + +@itemize @bullet + +@item +@code{howto} +@end itemize +The @code{howto} field can be imagined as a +relocation instruction. It is a pointer to a structure which +contains information on what to do with all of the other +information in the reloc record and data section. A back end +would normally have a relocation instruction set and turn +relocations into pointers to the correct structure on input - +but it would be possible to create each howto field on demand. + +@subsubsection @code{enum complain_overflow} +Indicates what sort of overflow checking should be done when +performing a relocation. + + +@example + +enum complain_overflow +@{ + /* Do not complain on overflow. */ + complain_overflow_dont, + + /* Complain if the bitfield overflows, whether it is considered + as signed or unsigned. */ + complain_overflow_bitfield, + + /* Complain if the value overflows when considered as signed + number. */ + complain_overflow_signed, + + /* Complain if the value overflows when considered as an + unsigned number. */ + complain_overflow_unsigned +@}; +@end example +@subsubsection @code{reloc_howto_type} +The @code{reloc_howto_type} is a structure which contains all the +information that libbfd needs to know to tie up a back end's data. + + +@example +struct symbol_cache_entry; /* Forward declaration */ + +struct reloc_howto_struct +@{ + /* The type field has mainly a documentary use - the back end can + do what it wants with it, though normally the back end's + external idea of what a reloc number is stored + in this field. For example, a PC relative word relocation + in a coff environment has the type 023 - because that's + what the outside world calls a R_PCRWORD reloc. */ + unsigned int type; + + /* The value the final relocation is shifted right by. This drops + unwanted data from the relocation. */ + unsigned int rightshift; + + /* The size of the item to be relocated. This is *not* a + power-of-two measure. To get the number of bytes operated + on by a type of relocation, use bfd_get_reloc_size. */ + int size; + + /* The number of bits in the item to be relocated. This is used + when doing overflow checking. */ + unsigned int bitsize; + + /* Notes that the relocation is relative to the location in the + data section of the addend. The relocation function will + subtract from the relocation value the address of the location + being relocated. */ + boolean pc_relative; + + /* The bit position of the reloc value in the destination. + The relocated value is left shifted by this amount. */ + unsigned int bitpos; + + /* What type of overflow error should be checked for when + relocating. */ + enum complain_overflow complain_on_overflow; + + /* If this field is non null, then the supplied function is + called rather than the normal function. This allows really + strange relocation methods to be accomodated (e.g., i960 callj + instructions). */ + bfd_reloc_status_type (*special_function) + PARAMS ((bfd *abfd, + arelent *reloc_entry, + struct symbol_cache_entry *symbol, + PTR data, + asection *input_section, + bfd *output_bfd, + char **error_message)); + + /* The textual name of the relocation type. */ + char *name; + + /* Some formats record a relocation addend in the section contents + rather than with the relocation. For ELF formats this is the + distinction between USE_REL and USE_RELA (though the code checks + for USE_REL == 1/0). The value of this field is TRUE if the + addend is recorded with the section contents; when performing a + partial link (ld -r) the section contents (the data) will be + modified. The value of this field is FALSE if addends are + recorded with the relocation (in arelent.addend); when performing + a partial link the relocation will be modified. + All relocations for all ELF USE_RELA targets should set this field + to FALSE (values of TRUE should be looked on with suspicion). + However, the converse is not true: not all relocations of all ELF + USE_REL targets set this field to TRUE. Why this is so is peculiar + to each particular target. For relocs that aren't used in partial + links (e.g. GOT stuff) it doesn't matter what this is set to. */ + boolean partial_inplace; + + /* The src_mask selects which parts of the read in data + are to be used in the relocation sum. E.g., if this was an 8 bit + byte of data which we read and relocated, this would be + 0x000000ff. When we have relocs which have an addend, such as + sun4 extended relocs, the value in the offset part of a + relocating field is garbage so we never use it. In this case + the mask would be 0x00000000. */ + bfd_vma src_mask; + + /* The dst_mask selects which parts of the instruction are replaced + into the instruction. In most cases src_mask == dst_mask, + except in the above special case, where dst_mask would be + 0x000000ff, and src_mask would be 0x00000000. */ + bfd_vma dst_mask; + + /* When some formats create PC relative instructions, they leave + the value of the pc of the place being relocated in the offset + slot of the instruction, so that a PC relative relocation can + be made just by adding in an ordinary offset (e.g., sun3 a.out). + Some formats leave the displacement part of an instruction + empty (e.g., m88k bcs); this flag signals the fact.*/ + boolean pcrel_offset; + +@}; +@end example +@findex The HOWTO Macro +@subsubsection @code{The HOWTO Macro} +@strong{Description}@* +The HOWTO define is horrible and will go away. +@example +#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ + @{(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC@} +@end example + +@strong{Description}@* +And will be replaced with the totally magic way. But for the +moment, we are compatible, so do it this way. +@example +#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN) + +@end example + +@strong{Description}@* +This is used to fill in an empty howto entry in an array. +@example +#define EMPTY_HOWTO(C) \ + HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false) + +@end example + +@strong{Description}@* +Helper routine to turn a symbol into a relocation value. +@example +#define HOWTO_PREPARE(relocation, symbol) \ + @{ \ + if (symbol != (asymbol *)NULL) @{ \ + if (bfd_is_com_section (symbol->section)) @{ \ + relocation = 0; \ + @} \ + else @{ \ + relocation = symbol->value; \ + @} \ + @} \ +@} +@end example + +@findex bfd_get_reloc_size +@subsubsection @code{bfd_get_reloc_size} +@strong{Synopsis} +@example +unsigned int bfd_get_reloc_size (reloc_howto_type *); +@end example +@strong{Description}@* +For a reloc_howto_type that operates on a fixed number of bytes, +this returns the number of bytes operated on. + +@findex arelent_chain +@subsubsection @code{arelent_chain} +@strong{Description}@* +How relocs are tied together in an @code{asection}: +@example +typedef struct relent_chain @{ + arelent relent; + struct relent_chain *next; +@} arelent_chain; +@end example + +@findex bfd_check_overflow +@subsubsection @code{bfd_check_overflow} +@strong{Synopsis} +@example +bfd_reloc_status_type +bfd_check_overflow + (enum complain_overflow how, + unsigned int bitsize, + unsigned int rightshift, + unsigned int addrsize, + bfd_vma relocation); +@end example +@strong{Description}@* +Perform overflow checking on @var{relocation} which has +@var{bitsize} significant bits and will be shifted right by +@var{rightshift} bits, on a machine with addresses containing +@var{addrsize} significant bits. The result is either of +@code{bfd_reloc_ok} or @code{bfd_reloc_overflow}. + +@findex bfd_perform_relocation +@subsubsection @code{bfd_perform_relocation} +@strong{Synopsis} +@example +bfd_reloc_status_type +bfd_perform_relocation + (bfd *abfd, + arelent *reloc_entry, + PTR data, + asection *input_section, + bfd *output_bfd, + char **error_message); +@end example +@strong{Description}@* +If @var{output_bfd} is supplied to this function, the +generated image will be relocatable; the relocations are +copied to the output file after they have been changed to +reflect the new state of the world. There are two ways of +reflecting the results of partial linkage in an output file: +by modifying the output data in place, and by modifying the +relocation record. Some native formats (e.g., basic a.out and +basic coff) have no way of specifying an addend in the +relocation type, so the addend has to go in the output data. +This is no big deal since in these formats the output data +slot will always be big enough for the addend. Complex reloc +types with addends were invented to solve just this problem. +The @var{error_message} argument is set to an error message if +this return @code{bfd_reloc_dangerous}. + +@findex bfd_install_relocation +@subsubsection @code{bfd_install_relocation} +@strong{Synopsis} +@example +bfd_reloc_status_type +bfd_install_relocation + (bfd *abfd, + arelent *reloc_entry, + PTR data, bfd_vma data_start, + asection *input_section, + char **error_message); +@end example +@strong{Description}@* +This looks remarkably like @code{bfd_perform_relocation}, except it +does not expect that the section contents have been filled in. +I.e., it's suitable for use when creating, rather than applying +a relocation. + +For now, this function should be considered reserved for the +assembler. + + +@node howto manager, , typedef arelent, Relocations +@section The howto manager +When an application wants to create a relocation, but doesn't +know what the target machine might call it, it can find out by +using this bit of code. + +@findex bfd_reloc_code_type +@subsubsection @code{bfd_reloc_code_type} +@strong{Description}@* +The insides of a reloc code. The idea is that, eventually, there +will be one enumerator for every type of relocation we ever do. +Pass one of these values to @code{bfd_reloc_type_lookup}, and it'll +return a howto pointer. + +This does mean that the application must determine the correct +enumerator value; you can't get a howto pointer from a random set +of attributes. + +Here are the possible values for @code{enum bfd_reloc_code_real}: + +@deffn {} BFD_RELOC_64 +@deffnx {} BFD_RELOC_32 +@deffnx {} BFD_RELOC_26 +@deffnx {} BFD_RELOC_24 +@deffnx {} BFD_RELOC_16 +@deffnx {} BFD_RELOC_14 +@deffnx {} BFD_RELOC_8 +Basic absolute relocations of N bits. +@end deffn +@deffn {} BFD_RELOC_64_PCREL +@deffnx {} BFD_RELOC_32_PCREL +@deffnx {} BFD_RELOC_24_PCREL +@deffnx {} BFD_RELOC_16_PCREL +@deffnx {} BFD_RELOC_12_PCREL +@deffnx {} BFD_RELOC_8_PCREL +PC-relative relocations. Sometimes these are relative to the address +of the relocation itself; sometimes they are relative to the start of +the section containing the relocation. It depends on the specific target. + +The 24-bit relocation is used in some Intel 960 configurations. +@end deffn +@deffn {} BFD_RELOC_32_GOT_PCREL +@deffnx {} BFD_RELOC_16_GOT_PCREL +@deffnx {} BFD_RELOC_8_GOT_PCREL +@deffnx {} BFD_RELOC_32_GOTOFF +@deffnx {} BFD_RELOC_16_GOTOFF +@deffnx {} BFD_RELOC_LO16_GOTOFF +@deffnx {} BFD_RELOC_HI16_GOTOFF +@deffnx {} BFD_RELOC_HI16_S_GOTOFF +@deffnx {} BFD_RELOC_8_GOTOFF +@deffnx {} BFD_RELOC_32_PLT_PCREL +@deffnx {} BFD_RELOC_24_PLT_PCREL +@deffnx {} BFD_RELOC_16_PLT_PCREL +@deffnx {} BFD_RELOC_8_PLT_PCREL +@deffnx {} BFD_RELOC_32_PLTOFF +@deffnx {} BFD_RELOC_16_PLTOFF +@deffnx {} BFD_RELOC_LO16_PLTOFF +@deffnx {} BFD_RELOC_HI16_PLTOFF +@deffnx {} BFD_RELOC_HI16_S_PLTOFF +@deffnx {} BFD_RELOC_8_PLTOFF +For ELF. +@end deffn +@deffn {} BFD_RELOC_68K_GLOB_DAT +@deffnx {} BFD_RELOC_68K_JMP_SLOT +@deffnx {} BFD_RELOC_68K_RELATIVE +Relocations used by 68K ELF. +@end deffn +@deffn {} BFD_RELOC_32_BASEREL +@deffnx {} BFD_RELOC_16_BASEREL +@deffnx {} BFD_RELOC_LO16_BASEREL +@deffnx {} BFD_RELOC_HI16_BASEREL +@deffnx {} BFD_RELOC_HI16_S_BASEREL +@deffnx {} BFD_RELOC_8_BASEREL +@deffnx {} BFD_RELOC_RVA +Linkage-table relative. +@end deffn +@deffn {} BFD_RELOC_8_FFnn +Absolute 8-bit relocation, but used to form an address like 0xFFnn. +@end deffn +@deffn {} BFD_RELOC_32_PCREL_S2 +@deffnx {} BFD_RELOC_16_PCREL_S2 +@deffnx {} BFD_RELOC_23_PCREL_S2 +These PC-relative relocations are stored as word displacements -- +i.e., byte displacements shifted right two bits. The 30-bit word +displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the +SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The +signed 16-bit displacement is used on the MIPS, and the 23-bit +displacement is used on the Alpha. +@end deffn +@deffn {} BFD_RELOC_HI22 +@deffnx {} BFD_RELOC_LO10 +High 22 bits and low 10 bits of 32-bit value, placed into lower bits of +the target word. These are used on the SPARC. +@end deffn +@deffn {} BFD_RELOC_GPREL16 +@deffnx {} BFD_RELOC_GPREL32 +For systems that allocate a Global Pointer register, these are +displacements off that register. These relocation types are +handled specially, because the value the register will have is +decided relatively late. +@end deffn +@deffn {} BFD_RELOC_I960_CALLJ +Reloc types used for i960/b.out. +@end deffn +@deffn {} BFD_RELOC_NONE +@deffnx {} BFD_RELOC_SPARC_WDISP22 +@deffnx {} BFD_RELOC_SPARC22 +@deffnx {} BFD_RELOC_SPARC13 +@deffnx {} BFD_RELOC_SPARC_GOT10 +@deffnx {} BFD_RELOC_SPARC_GOT13 +@deffnx {} BFD_RELOC_SPARC_GOT22 +@deffnx {} BFD_RELOC_SPARC_PC10 +@deffnx {} BFD_RELOC_SPARC_PC22 +@deffnx {} BFD_RELOC_SPARC_WPLT30 +@deffnx {} BFD_RELOC_SPARC_COPY +@deffnx {} BFD_RELOC_SPARC_GLOB_DAT +@deffnx {} BFD_RELOC_SPARC_JMP_SLOT +@deffnx {} BFD_RELOC_SPARC_RELATIVE +@deffnx {} BFD_RELOC_SPARC_UA32 +SPARC ELF relocations. There is probably some overlap with other +relocation types already defined. +@end deffn +@deffn {} BFD_RELOC_SPARC_BASE13 +@deffnx {} BFD_RELOC_SPARC_BASE22 +I think these are specific to SPARC a.out (e.g., Sun 4). +@end deffn +@deffn {} BFD_RELOC_SPARC_64 +@deffnx {} BFD_RELOC_SPARC_10 +@deffnx {} BFD_RELOC_SPARC_11 +@deffnx {} BFD_RELOC_SPARC_OLO10 +@deffnx {} BFD_RELOC_SPARC_HH22 +@deffnx {} BFD_RELOC_SPARC_HM10 +@deffnx {} BFD_RELOC_SPARC_LM22 +@deffnx {} BFD_RELOC_SPARC_PC_HH22 +@deffnx {} BFD_RELOC_SPARC_PC_HM10 +@deffnx {} BFD_RELOC_SPARC_PC_LM22 +@deffnx {} BFD_RELOC_SPARC_WDISP16 +@deffnx {} BFD_RELOC_SPARC_WDISP19 +@deffnx {} BFD_RELOC_SPARC_7 +@deffnx {} BFD_RELOC_SPARC_6 +@deffnx {} BFD_RELOC_SPARC_5 +@deffnx {} BFD_RELOC_SPARC_DISP64 +@deffnx {} BFD_RELOC_SPARC_PLT64 +@deffnx {} BFD_RELOC_SPARC_HIX22 +@deffnx {} BFD_RELOC_SPARC_LOX10 +@deffnx {} BFD_RELOC_SPARC_H44 +@deffnx {} BFD_RELOC_SPARC_M44 +@deffnx {} BFD_RELOC_SPARC_L44 +@deffnx {} BFD_RELOC_SPARC_REGISTER +SPARC64 relocations +@end deffn +@deffn {} BFD_RELOC_SPARC_REV32 +SPARC little endian relocation +@end deffn +@deffn {} BFD_RELOC_ALPHA_GPDISP_HI16 +Alpha ECOFF and ELF relocations. Some of these treat the symbol or +"addend" in some special way. +For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when +writing; when reading, it will be the absolute section symbol. The +addend is the displacement in bytes of the "lda" instruction from +the "ldah" instruction (which is at the address of this reloc). +@end deffn +@deffn {} BFD_RELOC_ALPHA_GPDISP_LO16 +For GPDISP_LO16 ("ignore") relocations, the symbol is handled as +with GPDISP_HI16 relocs. The addend is ignored when writing the +relocations out, and is filled in with the file's GP value on +reading, for convenience. +@end deffn +@deffn {} BFD_RELOC_ALPHA_GPDISP +The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 +relocation except that there is no accompanying GPDISP_LO16 +relocation. +@end deffn +@deffn {} BFD_RELOC_ALPHA_LITERAL +@deffnx {} BFD_RELOC_ALPHA_ELF_LITERAL +@deffnx {} BFD_RELOC_ALPHA_LITUSE +The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; +the assembler turns it into a LDQ instruction to load the address of +the symbol, and then fills in a register in the real instruction. + +The LITERAL reloc, at the LDQ instruction, refers to the .lita +section symbol. The addend is ignored when writing, but is filled +in with the file's GP value on reading, for convenience, as with the +GPDISP_LO16 reloc. + +The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. +It should refer to the symbol to be referenced, as with 16_GOTOFF, +but it generates output not based on the position within the .got +section, but relative to the GP value chosen for the file during the +final link stage. + +The LITUSE reloc, on the instruction using the loaded address, gives +information to the linker that it might be able to use to optimize +away some literal section references. The symbol is ignored (read +as the absolute section symbol), and the "addend" indicates the type +of instruction using the register: +1 - "memory" fmt insn +2 - byte-manipulation (byte offset reg) +3 - jsr (target of branch) + +The GNU linker currently doesn't do any of this optimizing. +@end deffn +@deffn {} BFD_RELOC_ALPHA_USER_LITERAL +@deffnx {} BFD_RELOC_ALPHA_USER_LITUSE_BASE +@deffnx {} BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF +@deffnx {} BFD_RELOC_ALPHA_USER_LITUSE_JSR +@deffnx {} BFD_RELOC_ALPHA_USER_GPDISP +@deffnx {} BFD_RELOC_ALPHA_USER_GPRELHIGH +@deffnx {} BFD_RELOC_ALPHA_USER_GPRELLOW +The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to +process the explicit !<reloc>!sequence relocations, and are mapped +into the normal relocations at the end of processing. +@end deffn +@deffn {} BFD_RELOC_ALPHA_HINT +The HINT relocation indicates a value that should be filled into the +"hint" field of a jmp/jsr/ret instruction, for possible branch- +prediction logic which may be provided on some processors. +@end deffn +@deffn {} BFD_RELOC_ALPHA_LINKAGE +The LINKAGE relocation outputs a linkage pair in the object file, +which is filled by the linker. +@end deffn +@deffn {} BFD_RELOC_ALPHA_CODEADDR +The CODEADDR relocation outputs a STO_CA in the object file, +which is filled by the linker. +@end deffn +@deffn {} BFD_RELOC_MIPS_JMP +Bits 27..2 of the relocation address shifted right 2 bits; +simple reloc otherwise. +@end deffn +@deffn {} BFD_RELOC_MIPS16_JMP +The MIPS16 jump instruction. +@end deffn +@deffn {} BFD_RELOC_MIPS16_GPREL +MIPS16 GP relative reloc. +@end deffn +@deffn {} BFD_RELOC_HI16 +High 16 bits of 32-bit value; simple reloc. +@end deffn +@deffn {} BFD_RELOC_HI16_S +High 16 bits of 32-bit value but the low 16 bits will be sign +extended and added to form the final result. If the low 16 +bits form a negative number, we need to add one to the high value +to compensate for the borrow when the low bits are added. +@end deffn +@deffn {} BFD_RELOC_LO16 +Low 16 bits. +@end deffn +@deffn {} BFD_RELOC_PCREL_HI16_S +Like BFD_RELOC_HI16_S, but PC relative. +@end deffn +@deffn {} BFD_RELOC_PCREL_LO16 +Like BFD_RELOC_LO16, but PC relative. +@end deffn +@deffn {} BFD_RELOC_MIPS_GPREL +Relocation relative to the global pointer. +@end deffn +@deffn {} BFD_RELOC_MIPS_LITERAL +Relocation against a MIPS literal section. +@end deffn +@deffn {} BFD_RELOC_MIPS_GOT16 +@deffnx {} BFD_RELOC_MIPS_CALL16 +@deffnx {} BFD_RELOC_MIPS_GPREL32 +@deffnx {} BFD_RELOC_MIPS_GOT_HI16 +@deffnx {} BFD_RELOC_MIPS_GOT_LO16 +@deffnx {} BFD_RELOC_MIPS_CALL_HI16 +@deffnx {} BFD_RELOC_MIPS_CALL_LO16 +@deffnx {} BFD_RELOC_MIPS_SUB +@deffnx {} BFD_RELOC_MIPS_GOT_PAGE +@deffnx {} BFD_RELOC_MIPS_GOT_OFST +@deffnx {} BFD_RELOC_MIPS_GOT_DISP +MIPS ELF relocations. +@end deffn +@deffn {} BFD_RELOC_386_GOT32 +@deffnx {} BFD_RELOC_386_PLT32 +@deffnx {} BFD_RELOC_386_COPY +@deffnx {} BFD_RELOC_386_GLOB_DAT +@deffnx {} BFD_RELOC_386_JUMP_SLOT +@deffnx {} BFD_RELOC_386_RELATIVE +@deffnx {} BFD_RELOC_386_GOTOFF +@deffnx {} BFD_RELOC_386_GOTPC +i386/elf relocations +@end deffn +@deffn {} BFD_RELOC_NS32K_IMM_8 +@deffnx {} BFD_RELOC_NS32K_IMM_16 +@deffnx {} BFD_RELOC_NS32K_IMM_32 +@deffnx {} BFD_RELOC_NS32K_IMM_8_PCREL +@deffnx {} BFD_RELOC_NS32K_IMM_16_PCREL +@deffnx {} BFD_RELOC_NS32K_IMM_32_PCREL +@deffnx {} BFD_RELOC_NS32K_DISP_8 +@deffnx {} BFD_RELOC_NS32K_DISP_16 +@deffnx {} BFD_RELOC_NS32K_DISP_32 +@deffnx {} BFD_RELOC_NS32K_DISP_8_PCREL +@deffnx {} BFD_RELOC_NS32K_DISP_16_PCREL +@deffnx {} BFD_RELOC_NS32K_DISP_32_PCREL +ns32k relocations +@end deffn +@deffn {} BFD_RELOC_PJ_CODE_HI16 +@deffnx {} BFD_RELOC_PJ_CODE_LO16 +@deffnx {} BFD_RELOC_PJ_CODE_DIR16 +@deffnx {} BFD_RELOC_PJ_CODE_DIR32 +@deffnx {} BFD_RELOC_PJ_CODE_REL16 +@deffnx {} BFD_RELOC_PJ_CODE_REL32 +Picojava relocs. Not all of these appear in object files. +@end deffn +@deffn {} BFD_RELOC_PPC_B26 +@deffnx {} BFD_RELOC_PPC_BA26 +@deffnx {} BFD_RELOC_PPC_TOC16 +@deffnx {} BFD_RELOC_PPC_B16 +@deffnx {} BFD_RELOC_PPC_B16_BRTAKEN +@deffnx {} BFD_RELOC_PPC_B16_BRNTAKEN +@deffnx {} BFD_RELOC_PPC_BA16 +@deffnx {} BFD_RELOC_PPC_BA16_BRTAKEN +@deffnx {} BFD_RELOC_PPC_BA16_BRNTAKEN +@deffnx {} BFD_RELOC_PPC_COPY +@deffnx {} BFD_RELOC_PPC_GLOB_DAT +@deffnx {} BFD_RELOC_PPC_JMP_SLOT +@deffnx {} BFD_RELOC_PPC_RELATIVE +@deffnx {} BFD_RELOC_PPC_LOCAL24PC +@deffnx {} BFD_RELOC_PPC_EMB_NADDR32 +@deffnx {} BFD_RELOC_PPC_EMB_NADDR16 +@deffnx {} BFD_RELOC_PPC_EMB_NADDR16_LO +@deffnx {} BFD_RELOC_PPC_EMB_NADDR16_HI +@deffnx {} BFD_RELOC_PPC_EMB_NADDR16_HA +@deffnx {} BFD_RELOC_PPC_EMB_SDAI16 +@deffnx {} BFD_RELOC_PPC_EMB_SDA2I16 +@deffnx {} BFD_RELOC_PPC_EMB_SDA2REL +@deffnx {} BFD_RELOC_PPC_EMB_SDA21 +@deffnx {} BFD_RELOC_PPC_EMB_MRKREF +@deffnx {} BFD_RELOC_PPC_EMB_RELSEC16 +@deffnx {} BFD_RELOC_PPC_EMB_RELST_LO +@deffnx {} BFD_RELOC_PPC_EMB_RELST_HI +@deffnx {} BFD_RELOC_PPC_EMB_RELST_HA +@deffnx {} BFD_RELOC_PPC_EMB_BIT_FLD +@deffnx {} BFD_RELOC_PPC_EMB_RELSDA +Power(rs6000) and PowerPC relocations. +@end deffn +@deffn {} BFD_RELOC_I370_D12 +IBM 370/390 relocations +@end deffn +@deffn {} BFD_RELOC_CTOR +The type of reloc used to build a contructor table - at the moment +probably a 32 bit wide absolute relocation, but the target can choose. +It generally does map to one of the other relocation types. +@end deffn +@deffn {} BFD_RELOC_ARM_PCREL_BRANCH +ARM 26 bit pc-relative branch. The lowest two bits must be zero and are +not stored in the instruction. +@end deffn +@deffn {} BFD_RELOC_ARM_IMMEDIATE +@deffnx {} BFD_RELOC_ARM_ADRL_IMMEDIATE +@deffnx {} BFD_RELOC_ARM_OFFSET_IMM +@deffnx {} BFD_RELOC_ARM_SHIFT_IMM +@deffnx {} BFD_RELOC_ARM_SWI +@deffnx {} BFD_RELOC_ARM_MULTI +@deffnx {} BFD_RELOC_ARM_CP_OFF_IMM +@deffnx {} BFD_RELOC_ARM_ADR_IMM +@deffnx {} BFD_RELOC_ARM_LDR_IMM +@deffnx {} BFD_RELOC_ARM_LITERAL +@deffnx {} BFD_RELOC_ARM_IN_POOL +@deffnx {} BFD_RELOC_ARM_OFFSET_IMM8 +@deffnx {} BFD_RELOC_ARM_HWLITERAL +@deffnx {} BFD_RELOC_ARM_THUMB_ADD +@deffnx {} BFD_RELOC_ARM_THUMB_IMM +@deffnx {} BFD_RELOC_ARM_THUMB_SHIFT +@deffnx {} BFD_RELOC_ARM_THUMB_OFFSET +@deffnx {} BFD_RELOC_ARM_GOT12 +@deffnx {} BFD_RELOC_ARM_GOT32 +@deffnx {} BFD_RELOC_ARM_JUMP_SLOT +@deffnx {} BFD_RELOC_ARM_COPY +@deffnx {} BFD_RELOC_ARM_GLOB_DAT +@deffnx {} BFD_RELOC_ARM_PLT32 +@deffnx {} BFD_RELOC_ARM_RELATIVE +@deffnx {} BFD_RELOC_ARM_GOTOFF +@deffnx {} BFD_RELOC_ARM_GOTPC +These relocs are only used within the ARM assembler. They are not +(at present) written to any object files. +@end deffn +@deffn {} BFD_RELOC_SH_PCDISP8BY2 +@deffnx {} BFD_RELOC_SH_PCDISP12BY2 +@deffnx {} BFD_RELOC_SH_IMM4 +@deffnx {} BFD_RELOC_SH_IMM4BY2 +@deffnx {} BFD_RELOC_SH_IMM4BY4 +@deffnx {} BFD_RELOC_SH_IMM8 +@deffnx {} BFD_RELOC_SH_IMM8BY2 +@deffnx {} BFD_RELOC_SH_IMM8BY4 +@deffnx {} BFD_RELOC_SH_PCRELIMM8BY2 +@deffnx {} BFD_RELOC_SH_PCRELIMM8BY4 +@deffnx {} BFD_RELOC_SH_SWITCH16 +@deffnx {} BFD_RELOC_SH_SWITCH32 +@deffnx {} BFD_RELOC_SH_USES +@deffnx {} BFD_RELOC_SH_COUNT +@deffnx {} BFD_RELOC_SH_ALIGN +@deffnx {} BFD_RELOC_SH_CODE +@deffnx {} BFD_RELOC_SH_DATA +@deffnx {} BFD_RELOC_SH_LABEL +Hitachi SH relocs. Not all of these appear in object files. +@end deffn +@deffn {} BFD_RELOC_THUMB_PCREL_BRANCH9 +@deffnx {} BFD_RELOC_THUMB_PCREL_BRANCH12 +@deffnx {} BFD_RELOC_THUMB_PCREL_BRANCH23 +Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must +be zero and is not stored in the instruction. +@end deffn +@deffn {} BFD_RELOC_ARC_B22_PCREL +Argonaut RISC Core (ARC) relocs. +ARC 22 bit pc-relative branch. The lowest two bits must be zero and are +not stored in the instruction. The high 20 bits are installed in bits 26 +through 7 of the instruction. +@end deffn +@deffn {} BFD_RELOC_ARC_B26 +ARC 26 bit absolute branch. The lowest two bits must be zero and are not +stored in the instruction. The high 24 bits are installed in bits 23 +through 0. +@end deffn +@deffn {} BFD_RELOC_D10V_10_PCREL_R +Mitsubishi D10V relocs. +This is a 10-bit reloc with the right 2 bits +assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D10V_10_PCREL_L +Mitsubishi D10V relocs. +This is a 10-bit reloc with the right 2 bits +assumed to be 0. This is the same as the previous reloc +except it is in the left container, i.e., +shifted left 15 bits. +@end deffn +@deffn {} BFD_RELOC_D10V_18 +This is an 18-bit reloc with the right 2 bits +assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D10V_18_PCREL +This is an 18-bit reloc with the right 2 bits +assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D30V_6 +Mitsubishi D30V relocs. +This is a 6-bit absolute reloc. +@end deffn +@deffn {} BFD_RELOC_D30V_9_PCREL +This is a 6-bit pc-relative reloc with +the right 3 bits assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D30V_9_PCREL_R +This is a 6-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. +@end deffn +@deffn {} BFD_RELOC_D30V_15 +This is a 12-bit absolute reloc with the +right 3 bitsassumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D30V_15_PCREL +This is a 12-bit pc-relative reloc with +the right 3 bits assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D30V_15_PCREL_R +This is a 12-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. +@end deffn +@deffn {} BFD_RELOC_D30V_21 +This is an 18-bit absolute reloc with +the right 3 bits assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D30V_21_PCREL +This is an 18-bit pc-relative reloc with +the right 3 bits assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_D30V_21_PCREL_R +This is an 18-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. +@end deffn +@deffn {} BFD_RELOC_D30V_32 +This is a 32-bit absolute reloc. +@end deffn +@deffn {} BFD_RELOC_D30V_32_PCREL +This is a 32-bit pc-relative reloc. +@end deffn +@deffn {} BFD_RELOC_M32R_24 +Mitsubishi M32R relocs. +This is a 24 bit absolute address. +@end deffn +@deffn {} BFD_RELOC_M32R_10_PCREL +This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_M32R_18_PCREL +This is an 18-bit reloc with the right 2 bits assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_M32R_26_PCREL +This is a 26-bit reloc with the right 2 bits assumed to be 0. +@end deffn +@deffn {} BFD_RELOC_M32R_HI16_ULO +This is a 16-bit reloc containing the high 16 bits of an address +used when the lower 16 bits are treated as unsigned. +@end deffn +@deffn {} BFD_RELOC_M32R_HI16_SLO +This is a 16-bit reloc containing the high 16 bits of an address +used when the lower 16 bits are treated as signed. +@end deffn +@deffn {} BFD_RELOC_M32R_LO16 +This is a 16-bit reloc containing the lower 16 bits of an address. +@end deffn +@deffn {} BFD_RELOC_M32R_SDA16 +This is a 16-bit reloc containing the small data area offset for use in +add3, load, and store instructions. +@end deffn +@deffn {} BFD_RELOC_V850_9_PCREL +This is a 9-bit reloc +@end deffn +@deffn {} BFD_RELOC_V850_22_PCREL +This is a 22-bit reloc +@end deffn +@deffn {} BFD_RELOC_V850_SDA_16_16_OFFSET +This is a 16 bit offset from the short data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_SDA_15_16_OFFSET +This is a 16 bit offset (of which only 15 bits are used) from the +short data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_ZDA_16_16_OFFSET +This is a 16 bit offset from the zero data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_ZDA_15_16_OFFSET +This is a 16 bit offset (of which only 15 bits are used) from the +zero data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_TDA_6_8_OFFSET +This is an 8 bit offset (of which only 6 bits are used) from the +tiny data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_TDA_7_8_OFFSET +This is an 8bit offset (of which only 7 bits are used) from the tiny +data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_TDA_7_7_OFFSET +This is a 7 bit offset from the tiny data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_TDA_16_16_OFFSET +This is a 16 bit offset from the tiny data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_TDA_4_5_OFFSET +This is a 5 bit offset (of which only 4 bits are used) from the tiny +data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_TDA_4_4_OFFSET +This is a 4 bit offset from the tiny data area pointer. +@end deffn +@deffn {} BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET +This is a 16 bit offset from the short data area pointer, with the +bits placed non-contigously in the instruction. +@end deffn +@deffn {} BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET +This is a 16 bit offset from the zero data area pointer, with the +bits placed non-contigously in the instruction. +@end deffn +@deffn {} BFD_RELOC_V850_CALLT_6_7_OFFSET +This is a 6 bit offset from the call table base pointer. +@end deffn +@deffn {} BFD_RELOC_V850_CALLT_16_16_OFFSET +This is a 16 bit offset from the call table base pointer. +@end deffn +@deffn {} BFD_RELOC_MN10300_32_PCREL +This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. +@end deffn +@deffn {} BFD_RELOC_MN10300_16_PCREL +This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. +@end deffn +@deffn {} BFD_RELOC_TIC30_LDP +This is a 8bit DP reloc for the tms320c30, where the most +significant 8 bits of a 24 bit word are placed into the least +significant 8 bits of the opcode. +@end deffn +@deffn {} BFD_RELOC_FR30_48 +This is a 48 bit reloc for the FR30 that stores 32 bits. +@end deffn +@deffn {} BFD_RELOC_FR30_20 +This is a 32 bit reloc for the FR30 that stores 20 bits split up into +two sections. +@end deffn +@deffn {} BFD_RELOC_FR30_6_IN_4 +This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in +4 bits. +@end deffn +@deffn {} BFD_RELOC_FR30_8_IN_8 +This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset +into 8 bits. +@end deffn +@deffn {} BFD_RELOC_FR30_9_IN_8 +This is a 16 bit reloc for the FR30 that stores a 9 bit short offset +into 8 bits. +@end deffn +@deffn {} BFD_RELOC_FR30_10_IN_8 +This is a 16 bit reloc for the FR30 that stores a 10 bit word offset +into 8 bits. +@end deffn +@deffn {} BFD_RELOC_FR30_9_PCREL +This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative +short offset into 8 bits. +@end deffn +@deffn {} BFD_RELOC_FR30_12_PCREL +This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative +short offset into 11 bits. +@end deffn +@deffn {} BFD_RELOC_MCORE_PCREL_IMM8BY4 +@deffnx {} BFD_RELOC_MCORE_PCREL_IMM11BY2 +@deffnx {} BFD_RELOC_MCORE_PCREL_IMM4BY2 +@deffnx {} BFD_RELOC_MCORE_PCREL_32 +@deffnx {} BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2 +@deffnx {} BFD_RELOC_MCORE_RVA +Motorola Mcore relocations. +@end deffn +@deffn {} BFD_RELOC_AVR_7_PCREL +This is a 16 bit reloc for the AVR that stores 8 bit pc relative +short offset into 7 bits. +@end deffn +@deffn {} BFD_RELOC_AVR_13_PCREL +This is a 16 bit reloc for the AVR that stores 13 bit pc relative +short offset into 12 bits. +@end deffn +@deffn {} BFD_RELOC_AVR_16_PM +This is a 16 bit reloc for the AVR that stores 17 bit value (usually +program memory address) into 16 bits. +@end deffn +@deffn {} BFD_RELOC_AVR_LO8_LDI +This is a 16 bit reloc for the AVR that stores 8 bit value (usually +data memory address) into 8 bit immediate value of LDI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HI8_LDI +This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit +of data memory address) into 8 bit immediate value of LDI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HH8_LDI +This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit +of program memory address) into 8 bit immediate value of LDI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_LO8_LDI_NEG +This is a 16 bit reloc for the AVR that stores negated 8 bit value +(usually data memory address) into 8 bit immediate value of SUBI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HI8_LDI_NEG +This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 8 bit of data memory address) into 8 bit immediate value of +SUBI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HH8_LDI_NEG +This is a 16 bit reloc for the AVR that stores negated 8 bit value +(most high 8 bit of program memory address) into 8 bit immediate value +of LDI or SUBI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_LO8_LDI_PM +This is a 16 bit reloc for the AVR that stores 8 bit value (usually +command address) into 8 bit immediate value of LDI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HI8_LDI_PM +This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit +of command address) into 8 bit immediate value of LDI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HH8_LDI_PM +This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit +of command address) into 8 bit immediate value of LDI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_LO8_LDI_PM_NEG +This is a 16 bit reloc for the AVR that stores negated 8 bit value +(usually command address) into 8 bit immediate value of SUBI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HI8_LDI_PM_NEG +This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 8 bit of 16 bit command address) into 8 bit immediate value +of SUBI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_HH8_LDI_PM_NEG +This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 6 bit of 22 bit command address) into 8 bit immediate +value of SUBI insn. +@end deffn +@deffn {} BFD_RELOC_AVR_CALL +This is a 32 bit reloc for the AVR that stores 23 bit value +into 22 bits. +@end deffn +@deffn {} BFD_RELOC_VTABLE_INHERIT +@deffnx {} BFD_RELOC_VTABLE_ENTRY +These two relocations are used by the linker to determine which of +the entries in a C++ virtual function table are actually used. When +the --gc-sections option is given, the linker will zero out the entries +that are not used, so that the code for those functions need not be +included in the output. + +VTABLE_INHERIT is a zero-space relocation used to describe to the +linker the inheritence tree of a C++ virtual function table. The +relocation's symbol should be the parent class' vtable, and the +relocation should be located at the child vtable. + +VTABLE_ENTRY is a zero-space relocation that describes the use of a +virtual function table entry. The reloc's symbol should refer to the +table of the class mentioned in the code. Off of that base, an offset +describes the entry that is being used. For Rela hosts, this offset +is stored in the reloc's addend. For Rel hosts, we are forced to put +this offset in the reloc's section offset. +@end deffn + +@example + +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; +@end example +@findex bfd_reloc_type_lookup +@subsubsection @code{bfd_reloc_type_lookup} +@strong{Synopsis} +@example +reloc_howto_type * +bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code); +@end example +@strong{Description}@* +Return a pointer to a howto structure which, when +invoked, will perform the relocation @var{code} on data from the +architecture noted. + +@findex bfd_default_reloc_type_lookup +@subsubsection @code{bfd_default_reloc_type_lookup} +@strong{Synopsis} +@example +reloc_howto_type *bfd_default_reloc_type_lookup + (bfd *abfd, bfd_reloc_code_real_type code); +@end example +@strong{Description}@* +Provides a default relocation lookup routine for any architecture. + +@findex bfd_get_reloc_code_name +@subsubsection @code{bfd_get_reloc_code_name} +@strong{Synopsis} +@example +const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); +@end example +@strong{Description}@* +Provides a printable name for the supplied relocation code. +Useful mainly for printing error messages. + +@findex bfd_generic_relax_section +@subsubsection @code{bfd_generic_relax_section} +@strong{Synopsis} +@example +boolean bfd_generic_relax_section + (bfd *abfd, + asection *section, + struct bfd_link_info *, + boolean *); +@end example +@strong{Description}@* +Provides default handling for relaxing for back ends which +don't do relaxing -- i.e., does nothing. + +@findex bfd_generic_gc_sections +@subsubsection @code{bfd_generic_gc_sections} +@strong{Synopsis} +@example +boolean bfd_generic_gc_sections + (bfd *, struct bfd_link_info *); +@end example +@strong{Description}@* +Provides default handling for relaxing for back ends which +don't do section gc -- i.e., does nothing. + +@findex bfd_generic_get_relocated_section_contents +@subsubsection @code{bfd_generic_get_relocated_section_contents} +@strong{Synopsis} +@example +bfd_byte * +bfd_generic_get_relocated_section_contents (bfd *abfd, + struct bfd_link_info *link_info, + struct bfd_link_order *link_order, + bfd_byte *data, + boolean relocateable, + asymbol **symbols); +@end example +@strong{Description}@* +Provides default handling of relocation effort for back ends +which can't be bothered to do it efficiently. + diff --git a/bfd/doc/section.texi b/bfd/doc/section.texi new file mode 100644 index 00000000000..25695900573 --- /dev/null +++ b/bfd/doc/section.texi @@ -0,0 +1,707 @@ +@section Sections +The raw data contained within a BFD is maintained through the +section abstraction. A single BFD may have any number of +sections. It keeps hold of them by pointing to the first; +each one points to the next in the list. + +Sections are supported in BFD in @code{section.c}. + +@menu +* Section Input:: +* Section Output:: +* typedef asection:: +* section prototypes:: +@end menu + +@node Section Input, Section Output, Sections, Sections +@subsection Section input +When a BFD is opened for reading, the section structures are +created and attached to the BFD. + +Each section has a name which describes the section in the +outside world---for example, @code{a.out} would contain at least +three sections, called @code{.text}, @code{.data} and @code{.bss}. + +Names need not be unique; for example a COFF file may have several +sections named @code{.data}. + +Sometimes a BFD will contain more than the ``natural'' number of +sections. A back end may attach other sections containing +constructor data, or an application may add a section (using +@code{bfd_make_section}) to the sections attached to an already open +BFD. For example, the linker creates an extra section +@code{COMMON} for each input file's BFD to hold information about +common storage. + +The raw data is not necessarily read in when +the section descriptor is created. Some targets may leave the +data in place until a @code{bfd_get_section_contents} call is +made. Other back ends may read in all the data at once. For +example, an S-record file has to be read once to determine the +size of the data. An IEEE-695 file doesn't contain raw data in +sections, but data and relocation expressions intermixed, so +the data area has to be parsed to get out the data and +relocations. + +@node Section Output, typedef asection, Section Input, Sections +@subsection Section output +To write a new object style BFD, the various sections to be +written have to be created. They are attached to the BFD in +the same way as input sections; data is written to the +sections using @code{bfd_set_section_contents}. + +Any program that creates or combines sections (e.g., the assembler +and linker) must use the @code{asection} fields @code{output_section} and +@code{output_offset} to indicate the file sections to which each +section must be written. (If the section is being created from +scratch, @code{output_section} should probably point to the section +itself and @code{output_offset} should probably be zero.) + +The data to be written comes from input sections attached +(via @code{output_section} pointers) to +the output sections. The output section structure can be +considered a filter for the input section: the output section +determines the vma of the output data and the name, but the +input section determines the offset into the output section of +the data to be written. + +E.g., to create a section "O", starting at 0x100, 0x123 long, +containing two subsections, "A" at offset 0x0 (i.e., at vma +0x100) and "B" at offset 0x20 (i.e., at vma 0x120) the @code{asection} +structures would look like: + +@example + section name "A" + output_offset 0x00 + size 0x20 + output_section -----------> section name "O" + | vma 0x100 + section name "B" | size 0x123 + output_offset 0x20 | + size 0x103 | + output_section --------| +@end example + +@subsection Link orders +The data within a section is stored in a @dfn{link_order}. +These are much like the fixups in @code{gas}. The link_order +abstraction allows a section to grow and shrink within itself. + +A link_order knows how big it is, and which is the next +link_order and where the raw data for it is; it also points to +a list of relocations which apply to it. + +The link_order is used by the linker to perform relaxing on +final code. The compiler creates code which is as big as +necessary to make it work without relaxing, and the user can +select whether to relax. Sometimes relaxing takes a lot of +time. The linker runs around the relocations to see if any +are attached to data which can be shrunk, if so it does it on +a link_order by link_order basis. + + +@node typedef asection, section prototypes, Section Output, Sections +@subsection typedef asection +Here is the section structure: + + +@example + + /* This structure is used for a comdat section, as in PE. A comdat + section is associated with a particular symbol. When the linker + sees a comdat section, it keeps only one of the sections with a + given name and associated with a given symbol. */ + +struct bfd_comdat_info +@{ + /* The name of the symbol associated with a comdat section. */ + const char *name; + + /* The local symbol table index of the symbol associated with a + comdat section. This is only meaningful to the object file format + specific code; it is not an index into the list returned by + bfd_canonicalize_symtab. */ + long symbol; + + /* If this section is being discarded, the linker uses this field + to point to the input section which is being kept. */ + struct sec *sec; +@}; + +typedef struct sec +@{ + /* The name of the section; the name isn't a copy, the pointer is + the same as that passed to bfd_make_section. */ + + CONST char *name; + + /* Which section is it; 0..nth. */ + + int index; + + /* The next section in the list belonging to the BFD, or NULL. */ + + struct sec *next; + + /* The field flags contains attributes of the section. Some + flags are read in from the object file, and some are + synthesized from other information. */ + + flagword flags; + +#define SEC_NO_FLAGS 0x000 + + /* Tells the OS to allocate space for this section when loading. + This is clear for a section containing debug information + only. */ +#define SEC_ALLOC 0x001 + + /* Tells the OS to load the section from the file when loading. + This is clear for a .bss section. */ +#define SEC_LOAD 0x002 + + /* The section contains data still to be relocated, so there is + some relocation information too. */ +#define SEC_RELOC 0x004 + +#if 0 /* Obsolete ? */ +#define SEC_BALIGN 0x008 +#endif + + /* A signal to the OS that the section contains read only + data. */ +#define SEC_READONLY 0x010 + + /* The section contains code only. */ +#define SEC_CODE 0x020 + + /* The section contains data only. */ +#define SEC_DATA 0x040 + + /* The section will reside in ROM. */ +#define SEC_ROM 0x080 + + /* The section contains constructor information. This section + type is used by the linker to create lists of constructors and + destructors used by @code{g++}. When a back end sees a symbol + which should be used in a constructor list, it creates a new + section for the type of name (e.g., @code{__CTOR_LIST__}), attaches + the symbol to it, and builds a relocation. To build the lists + of constructors, all the linker has to do is catenate all the + sections called @code{__CTOR_LIST__} and relocate the data + contained within - exactly the operations it would peform on + standard data. */ +#define SEC_CONSTRUCTOR 0x100 + + /* The section is a constructor, and should be placed at the + end of the text, data, or bss section(?). */ +#define SEC_CONSTRUCTOR_TEXT 0x1100 +#define SEC_CONSTRUCTOR_DATA 0x2100 +#define SEC_CONSTRUCTOR_BSS 0x3100 + + /* The section has contents - a data section could be + @code{SEC_ALLOC} | @code{SEC_HAS_CONTENTS}; a debug section could be + @code{SEC_HAS_CONTENTS} */ +#define SEC_HAS_CONTENTS 0x200 + + /* An instruction to the linker to not output the section + even if it has information which would normally be written. */ +#define SEC_NEVER_LOAD 0x400 + + /* The section is a COFF shared library section. This flag is + only for the linker. If this type of section appears in + the input file, the linker must copy it to the output file + without changing the vma or size. FIXME: Although this + was originally intended to be general, it really is COFF + specific (and the flag was renamed to indicate this). It + might be cleaner to have some more general mechanism to + allow the back end to control what the linker does with + sections. */ +#define SEC_COFF_SHARED_LIBRARY 0x800 + + /* The section contains common symbols (symbols may be defined + multiple times, the value of a symbol is the amount of + space it requires, and the largest symbol value is the one + used). Most targets have exactly one of these (which we + translate to bfd_com_section_ptr), but ECOFF has two. */ +#define SEC_IS_COMMON 0x8000 + + /* The section contains only debugging information. For + example, this is set for ELF .debug and .stab sections. + strip tests this flag to see if a section can be + discarded. */ +#define SEC_DEBUGGING 0x10000 + + /* The contents of this section are held in memory pointed to + by the contents field. This is checked by + bfd_get_section_contents, and the data is retrieved from + memory if appropriate. */ +#define SEC_IN_MEMORY 0x20000 + + /* The contents of this section are to be excluded by the + linker for executable and shared objects unless those + objects are to be further relocated. */ +#define SEC_EXCLUDE 0x40000 + + /* The contents of this section are to be sorted by the + based on the address specified in the associated symbol + table. */ +#define SEC_SORT_ENTRIES 0x80000 + + /* When linking, duplicate sections of the same name should be + discarded, rather than being combined into a single section as + is usually done. This is similar to how common symbols are + handled. See SEC_LINK_DUPLICATES below. */ +#define SEC_LINK_ONCE 0x100000 + + /* If SEC_LINK_ONCE is set, this bitfield describes how the linker + should handle duplicate sections. */ +#define SEC_LINK_DUPLICATES 0x600000 + + /* This value for SEC_LINK_DUPLICATES means that duplicate + sections with the same name should simply be discarded. */ +#define SEC_LINK_DUPLICATES_DISCARD 0x0 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if there are any duplicate sections, although + it should still only link one copy. */ +#define SEC_LINK_DUPLICATES_ONE_ONLY 0x200000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections are a different size. */ +#define SEC_LINK_DUPLICATES_SAME_SIZE 0x400000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections contain different + contents. */ +#define SEC_LINK_DUPLICATES_SAME_CONTENTS 0x600000 + + /* This section was created by the linker as part of dynamic + relocation or other arcane processing. It is skipped when + going through the first-pass output, trusting that someone + else up the line will take care of it later. */ +#define SEC_LINKER_CREATED 0x800000 + + /* This section should not be subject to garbage collection. */ +#define SEC_KEEP 0x1000000 + + /* This section contains "short" data, and should be placed + "near" the GP. */ +#define SEC_SMALL_DATA 0x2000000 + + /* This section contains data which may be shared with other + executables or shared objects. */ +#define SEC_SHARED 0x4000000 + + /* End of section flags. */ + + /* Some internal packed boolean fields. */ + + /* See the vma field. */ + unsigned int user_set_vma : 1; + + /* Whether relocations have been processed. */ + unsigned int reloc_done : 1; + + /* A mark flag used by some of the linker backends. */ + unsigned int linker_mark : 1; + + /* A mark flag used by some linker backends for garbage collection. */ + unsigned int gc_mark : 1; + + /* End of internal packed boolean fields. */ + + /* The virtual memory address of the section - where it will be + at run time. The symbols are relocated against this. The + user_set_vma flag is maintained by bfd; if it's not set, the + backend can assign addresses (for example, in @code{a.out}, where + the default address for @code{.data} is dependent on the specific + target and various flags). */ + + bfd_vma vma; + + /* The load address of the section - where it would be in a + rom image; really only used for writing section header + information. */ + + bfd_vma lma; + + /* The size of the section in octets, as it will be output. + Contains a value even if the section has no contents (e.g., the + size of @code{.bss}). This will be filled in after relocation. */ + + bfd_size_type _cooked_size; + + /* The original size on disk of the section, in octets. Normally this + value is the same as the size, but if some relaxing has + been done, then this value will be bigger. */ + + bfd_size_type _raw_size; + + /* If this section is going to be output, then this value is the + offset in *bytes* into the output section of the first byte in the + input section (byte ==> smallest addressable unit on the + target). In most cases, if this was going to start at the + 100th octet (8-bit quantity) in the output section, this value + would be 100. However, if the target byte size is 16 bits + (bfd_octets_per_byte is "2"), this value would be 50. */ + + bfd_vma output_offset; + + /* The output section through which to map on output. */ + + struct sec *output_section; + + /* The alignment requirement of the section, as an exponent of 2 - + e.g., 3 aligns to 2^3 (or 8). */ + + unsigned int alignment_power; + + /* If an input section, a pointer to a vector of relocation + records for the data in this section. */ + + struct reloc_cache_entry *relocation; + + /* If an output section, a pointer to a vector of pointers to + relocation records for the data in this section. */ + + struct reloc_cache_entry **orelocation; + + /* The number of relocation records in one of the above */ + + unsigned reloc_count; + + /* Information below is back end specific - and not always used + or updated. */ + + /* File position of section data */ + + file_ptr filepos; + + /* File position of relocation info */ + + file_ptr rel_filepos; + + /* File position of line data */ + + file_ptr line_filepos; + + /* Pointer to data for applications */ + + PTR userdata; + + /* If the SEC_IN_MEMORY flag is set, this points to the actual + contents. */ + unsigned char *contents; + + /* Attached line number information */ + + alent *lineno; + + /* Number of line number records */ + + unsigned int lineno_count; + + /* Optional information about a COMDAT entry; NULL if not COMDAT */ + + struct bfd_comdat_info *comdat; + + /* When a section is being output, this value changes as more + linenumbers are written out */ + + file_ptr moving_line_filepos; + + /* What the section number is in the target world */ + + int target_index; + + PTR used_by_bfd; + + /* If this is a constructor section then here is a list of the + relocations created to relocate items within it. */ + + struct relent_chain *constructor_chain; + + /* The BFD which owns the section. */ + + bfd *owner; + + /* A symbol which points at this section only */ + struct symbol_cache_entry *symbol; + struct symbol_cache_entry **symbol_ptr_ptr; + + struct bfd_link_order *link_order_head; + struct bfd_link_order *link_order_tail; +@} asection ; + + /* These sections are global, and are managed by BFD. The application + and target back end are not permitted to change the values in + these sections. New code should use the section_ptr macros rather + than referring directly to the const sections. The const sections + may eventually vanish. */ +#define BFD_ABS_SECTION_NAME "*ABS*" +#define BFD_UND_SECTION_NAME "*UND*" +#define BFD_COM_SECTION_NAME "*COM*" +#define BFD_IND_SECTION_NAME "*IND*" + + /* the absolute section */ +extern const asection bfd_abs_section; +#define bfd_abs_section_ptr ((asection *) &bfd_abs_section) +#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) + /* Pointer to the undefined section */ +extern const asection bfd_und_section; +#define bfd_und_section_ptr ((asection *) &bfd_und_section) +#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) + /* Pointer to the common section */ +extern const asection bfd_com_section; +#define bfd_com_section_ptr ((asection *) &bfd_com_section) + /* Pointer to the indirect section */ +extern const asection bfd_ind_section; +#define bfd_ind_section_ptr ((asection *) &bfd_ind_section) +#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr) + +extern const struct symbol_cache_entry * const bfd_abs_symbol; +extern const struct symbol_cache_entry * const bfd_com_symbol; +extern const struct symbol_cache_entry * const bfd_und_symbol; +extern const struct symbol_cache_entry * const bfd_ind_symbol; +#define bfd_get_section_size_before_reloc(section) \ + ((section)->reloc_done ? (abort (), (bfd_size_type) 1) \ + : (section)->_raw_size) +#define bfd_get_section_size_after_reloc(section) \ + ((section)->reloc_done ? (section)->_cooked_size \ + : (abort (), (bfd_size_type) 1)) +@end example + +@node section prototypes, , typedef asection, Sections +@subsection Section prototypes +These are the functions exported by the section handling part of BFD. + +@findex bfd_get_section_by_name +@subsubsection @code{bfd_get_section_by_name} +@strong{Synopsis} +@example +asection *bfd_get_section_by_name(bfd *abfd, CONST char *name); +@end example +@strong{Description}@* +Run through @var{abfd} and return the one of the +@code{asection}s whose name matches @var{name}, otherwise @code{NULL}. +@xref{Sections}, for more information. + +This should only be used in special cases; the normal way to process +all sections of a given name is to use @code{bfd_map_over_sections} and +@code{strcmp} on the name (or better yet, base it on the section flags +or something else) for each section. + +@findex bfd_make_section_old_way +@subsubsection @code{bfd_make_section_old_way} +@strong{Synopsis} +@example +asection *bfd_make_section_old_way(bfd *abfd, CONST char *name); +@end example +@strong{Description}@* +Create a new empty section called @var{name} +and attach it to the end of the chain of sections for the +BFD @var{abfd}. An attempt to create a section with a name which +is already in use returns its pointer without changing the +section chain. + +It has the funny name since this is the way it used to be +before it was rewritten.... + +Possible errors are: +@itemize @bullet + +@item +@code{bfd_error_invalid_operation} - +If output has already started for this BFD. +@item +@code{bfd_error_no_memory} - +If memory allocation fails. +@end itemize + +@findex bfd_make_section_anyway +@subsubsection @code{bfd_make_section_anyway} +@strong{Synopsis} +@example +asection *bfd_make_section_anyway(bfd *abfd, CONST char *name); +@end example +@strong{Description}@* +Create a new empty section called @var{name} and attach it to the end of +the chain of sections for @var{abfd}. Create a new section even if there +is already a section with that name. + +Return @code{NULL} and set @code{bfd_error} on error; possible errors are: +@itemize @bullet + +@item +@code{bfd_error_invalid_operation} - If output has already started for @var{abfd}. +@item +@code{bfd_error_no_memory} - If memory allocation fails. +@end itemize + +@findex bfd_make_section +@subsubsection @code{bfd_make_section} +@strong{Synopsis} +@example +asection *bfd_make_section(bfd *, CONST char *name); +@end example +@strong{Description}@* +Like @code{bfd_make_section_anyway}, but return @code{NULL} (without calling +bfd_set_error ()) without changing the section chain if there is already a +section named @var{name}. If there is an error, return @code{NULL} and set +@code{bfd_error}. + +@findex bfd_set_section_flags +@subsubsection @code{bfd_set_section_flags} +@strong{Synopsis} +@example +boolean bfd_set_section_flags(bfd *abfd, asection *sec, flagword flags); +@end example +@strong{Description}@* +Set the attributes of the section @var{sec} in the BFD +@var{abfd} to the value @var{flags}. Return @code{true} on success, +@code{false} on error. Possible error returns are: + +@itemize @bullet + +@item +@code{bfd_error_invalid_operation} - +The section cannot have one or more of the attributes +requested. For example, a .bss section in @code{a.out} may not +have the @code{SEC_HAS_CONTENTS} field set. +@end itemize + +@findex bfd_map_over_sections +@subsubsection @code{bfd_map_over_sections} +@strong{Synopsis} +@example +void bfd_map_over_sections(bfd *abfd, + void (*func)(bfd *abfd, + asection *sect, + PTR obj), + PTR obj); +@end example +@strong{Description}@* +Call the provided function @var{func} for each section +attached to the BFD @var{abfd}, passing @var{obj} as an +argument. The function will be called as if by + +@example + func(abfd, the_section, obj); +@end example + +This is the prefered method for iterating over sections; an +alternative would be to use a loop: + +@example + section *p; + for (p = abfd->sections; p != NULL; p = p->next) + func(abfd, p, ...) +@end example + +@findex bfd_set_section_size +@subsubsection @code{bfd_set_section_size} +@strong{Synopsis} +@example +boolean bfd_set_section_size(bfd *abfd, asection *sec, bfd_size_type val); +@end example +@strong{Description}@* +Set @var{sec} to the size @var{val}. If the operation is +ok, then @code{true} is returned, else @code{false}. + +Possible error returns: +@itemize @bullet + +@item +@code{bfd_error_invalid_operation} - +Writing has started to the BFD, so setting the size is invalid. +@end itemize + +@findex bfd_set_section_contents +@subsubsection @code{bfd_set_section_contents} +@strong{Synopsis} +@example +boolean bfd_set_section_contents + (bfd *abfd, + asection *section, + PTR data, + file_ptr offset, + bfd_size_type count); +@end example +@strong{Description}@* +Sets the contents of the section @var{section} in BFD +@var{abfd} to the data starting in memory at @var{data}. The +data is written to the output section starting at offset +@var{offset} for @var{count} octets. + +Normally @code{true} is returned, else @code{false}. Possible error +returns are: +@itemize @bullet + +@item +@code{bfd_error_no_contents} - +The output section does not have the @code{SEC_HAS_CONTENTS} +attribute, so nothing can be written to it. +@item +and some more too +@end itemize +This routine is front end to the back end function +@code{_bfd_set_section_contents}. + +@findex bfd_get_section_contents +@subsubsection @code{bfd_get_section_contents} +@strong{Synopsis} +@example +boolean bfd_get_section_contents + (bfd *abfd, asection *section, PTR location, + file_ptr offset, bfd_size_type count); +@end example +@strong{Description}@* +Read data from @var{section} in BFD @var{abfd} +into memory starting at @var{location}. The data is read at an +offset of @var{offset} from the start of the input section, +and is read for @var{count} bytes. + +If the contents of a constructor with the @code{SEC_CONSTRUCTOR} +flag set are requested or if the section does not have the +@code{SEC_HAS_CONTENTS} flag set, then the @var{location} is filled +with zeroes. If no errors occur, @code{true} is returned, else +@code{false}. + +@findex bfd_copy_private_section_data +@subsubsection @code{bfd_copy_private_section_data} +@strong{Synopsis} +@example +boolean bfd_copy_private_section_data(bfd *ibfd, asection *isec, bfd *obfd, asection *osec); +@end example +@strong{Description}@* +Copy private section information from @var{isec} in the BFD +@var{ibfd} to the section @var{osec} in the BFD @var{obfd}. +Return @code{true} on success, @code{false} on error. Possible error +returns are: + +@itemize @bullet + +@item +@code{bfd_error_no_memory} - +Not enough memory exists to create private data for @var{osec}. +@end itemize +@example +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ + BFD_SEND (obfd, _bfd_copy_private_section_data, \ + (ibfd, isection, obfd, osection)) +@end example + +@findex _bfd_strip_section_from_output +@subsubsection @code{_bfd_strip_section_from_output} +@strong{Synopsis} +@example +void _bfd_strip_section_from_output + (struct bfd_link_info *info, asection *section); +@end example +@strong{Description}@* +Remove @var{section} from the output. If the output section +becomes empty, remove it from the output bfd. @var{info} may +be NULL; if it is not, it is used to decide whether the output +section is empty. + diff --git a/bfd/doc/syms.texi b/bfd/doc/syms.texi new file mode 100644 index 00000000000..74c151b1195 --- /dev/null +++ b/bfd/doc/syms.texi @@ -0,0 +1,424 @@ +@section Symbols +BFD tries to maintain as much symbol information as it can when +it moves information from file to file. BFD passes information +to applications though the @code{asymbol} structure. When the +application requests the symbol table, BFD reads the table in +the native form and translates parts of it into the internal +format. To maintain more than the information passed to +applications, some targets keep some information ``behind the +scenes'' in a structure only the particular back end knows +about. For example, the coff back end keeps the original +symbol table structure as well as the canonical structure when +a BFD is read in. On output, the coff back end can reconstruct +the output symbol table so that no information is lost, even +information unique to coff which BFD doesn't know or +understand. If a coff symbol table were read, but were written +through an a.out back end, all the coff specific information +would be lost. The symbol table of a BFD +is not necessarily read in until a canonicalize request is +made. Then the BFD back end fills in a table provided by the +application with pointers to the canonical information. To +output symbols, the application provides BFD with a table of +pointers to pointers to @code{asymbol}s. This allows applications +like the linker to output a symbol as it was read, since the ``behind +the scenes'' information will be still available. +@menu +* Reading Symbols:: +* Writing Symbols:: +* Mini Symbols:: +* typedef asymbol:: +* symbol handling functions:: +@end menu + +@node Reading Symbols, Writing Symbols, Symbols, Symbols +@subsection Reading symbols +There are two stages to reading a symbol table from a BFD: +allocating storage, and the actual reading process. This is an +excerpt from an application which reads the symbol table: + +@example + long storage_needed; + asymbol **symbol_table; + long number_of_symbols; + long i; + + storage_needed = bfd_get_symtab_upper_bound (abfd); + + if (storage_needed < 0) + FAIL + + if (storage_needed == 0) @{ + return ; + @} + symbol_table = (asymbol **) xmalloc (storage_needed); + ... + number_of_symbols = + bfd_canonicalize_symtab (abfd, symbol_table); + + if (number_of_symbols < 0) + FAIL + + for (i = 0; i < number_of_symbols; i++) @{ + process_symbol (symbol_table[i]); + @} +@end example + +All storage for the symbols themselves is in an objalloc +connected to the BFD; it is freed when the BFD is closed. + +@node Writing Symbols, Mini Symbols, Reading Symbols, Symbols +@subsection Writing symbols +Writing of a symbol table is automatic when a BFD open for +writing is closed. The application attaches a vector of +pointers to pointers to symbols to the BFD being written, and +fills in the symbol count. The close and cleanup code reads +through the table provided and performs all the necessary +operations. The BFD output code must always be provided with an +``owned'' symbol: one which has come from another BFD, or one +which has been created using @code{bfd_make_empty_symbol}. Here is an +example showing the creation of a symbol table with only one element: + +@example + #include "bfd.h" + main() + @{ + bfd *abfd; + asymbol *ptrs[2]; + asymbol *new; + + abfd = bfd_openw("foo","a.out-sunos-big"); + bfd_set_format(abfd, bfd_object); + new = bfd_make_empty_symbol(abfd); + new->name = "dummy_symbol"; + new->section = bfd_make_section_old_way(abfd, ".text"); + new->flags = BSF_GLOBAL; + new->value = 0x12345; + + ptrs[0] = new; + ptrs[1] = (asymbol *)0; + + bfd_set_symtab(abfd, ptrs, 1); + bfd_close(abfd); + @} + + ./makesym + nm foo + 00012345 A dummy_symbol +@end example + +Many formats cannot represent arbitary symbol information; for +instance, the @code{a.out} object format does not allow an +arbitary number of sections. A symbol pointing to a section +which is not one of @code{.text}, @code{.data} or @code{.bss} cannot +be described. + +@node Mini Symbols, typedef asymbol, Writing Symbols, Symbols +@subsection Mini Symbols +Mini symbols provide read-only access to the symbol table. +They use less memory space, but require more time to access. +They can be useful for tools like nm or objdump, which may +have to handle symbol tables of extremely large executables. + +The @code{bfd_read_minisymbols} function will read the symbols +into memory in an internal form. It will return a @code{void *} +pointer to a block of memory, a symbol count, and the size of +each symbol. The pointer is allocated using @code{malloc}, and +should be freed by the caller when it is no longer needed. + +The function @code{bfd_minisymbol_to_symbol} will take a pointer +to a minisymbol, and a pointer to a structure returned by +@code{bfd_make_empty_symbol}, and return a @code{asymbol} structure. +The return value may or may not be the same as the value from +@code{bfd_make_empty_symbol} which was passed in. + + +@node typedef asymbol, symbol handling functions, Mini Symbols, Symbols +@subsection typedef asymbol +An @code{asymbol} has the form: + + +@example + +typedef struct symbol_cache_entry +@{ + /* A pointer to the BFD which owns the symbol. This information + is necessary so that a back end can work out what additional + information (invisible to the application writer) is carried + with the symbol. + + This field is *almost* redundant, since you can use section->owner + instead, except that some symbols point to the global sections + bfd_@{abs,com,und@}_section. This could be fixed by making + these globals be per-bfd (or per-target-flavor). FIXME. */ + + struct _bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */ + + /* The text of the symbol. The name is left alone, and not copied; the + application may not alter it. */ + CONST char *name; + + /* The value of the symbol. This really should be a union of a + numeric value with a pointer, since some flags indicate that + a pointer to another symbol is stored here. */ + symvalue value; + + /* Attributes of a symbol: */ + +#define BSF_NO_FLAGS 0x00 + + /* The symbol has local scope; @code{static} in @code{C}. The value + is the offset into the section of the data. */ +#define BSF_LOCAL 0x01 + + /* The symbol has global scope; initialized data in @code{C}. The + value is the offset into the section of the data. */ +#define BSF_GLOBAL 0x02 + + /* The symbol has global scope and is exported. The value is + the offset into the section of the data. */ +#define BSF_EXPORT BSF_GLOBAL /* no real difference */ + + /* A normal C symbol would be one of: + @code{BSF_LOCAL}, @code{BSF_FORT_COMM}, @code{BSF_UNDEFINED} or + @code{BSF_GLOBAL} */ + + /* The symbol is a debugging record. The value has an arbitary + meaning, unless BSF_DEBUGGING_RELOC is also set. */ +#define BSF_DEBUGGING 0x08 + + /* The symbol denotes a function entry point. Used in ELF, + perhaps others someday. */ +#define BSF_FUNCTION 0x10 + + /* Used by the linker. */ +#define BSF_KEEP 0x20 +#define BSF_KEEP_G 0x40 + + /* A weak global symbol, overridable without warnings by + a regular global symbol of the same name. */ +#define BSF_WEAK 0x80 + + /* This symbol was created to point to a section, e.g. ELF's + STT_SECTION symbols. */ +#define BSF_SECTION_SYM 0x100 + + /* The symbol used to be a common symbol, but now it is + allocated. */ +#define BSF_OLD_COMMON 0x200 + + /* The default value for common data. */ +#define BFD_FORT_COMM_DEFAULT_VALUE 0 + + /* In some files the type of a symbol sometimes alters its + location in an output file - ie in coff a @code{ISFCN} symbol + which is also @code{C_EXT} symbol appears where it was + declared and not at the end of a section. This bit is set + by the target BFD part to convey this information. */ + +#define BSF_NOT_AT_END 0x400 + + /* Signal that the symbol is the label of constructor section. */ +#define BSF_CONSTRUCTOR 0x800 + + /* Signal that the symbol is a warning symbol. The name is a + warning. The name of the next symbol is the one to warn about; + if a reference is made to a symbol with the same name as the next + symbol, a warning is issued by the linker. */ +#define BSF_WARNING 0x1000 + + /* Signal that the symbol is indirect. This symbol is an indirect + pointer to the symbol with the same name as the next symbol. */ +#define BSF_INDIRECT 0x2000 + + /* BSF_FILE marks symbols that contain a file name. This is used + for ELF STT_FILE symbols. */ +#define BSF_FILE 0x4000 + + /* Symbol is from dynamic linking information. */ +#define BSF_DYNAMIC 0x8000 + + /* The symbol denotes a data object. Used in ELF, and perhaps + others someday. */ +#define BSF_OBJECT 0x10000 + + /* This symbol is a debugging symbol. The value is the offset + into the section of the data. BSF_DEBUGGING should be set + as well. */ +#define BSF_DEBUGGING_RELOC 0x20000 + + flagword flags; + + /* A pointer to the section to which this symbol is + relative. This will always be non NULL, there are special + sections for undefined and absolute symbols. */ + struct sec *section; + + /* Back end special data. */ + union + @{ + PTR p; + bfd_vma i; + @} udata; + +@} asymbol; +@end example + +@node symbol handling functions, , typedef asymbol, Symbols +@subsection Symbol handling functions + + +@findex bfd_get_symtab_upper_bound +@subsubsection @code{bfd_get_symtab_upper_bound} +@strong{Description}@* +Return the number of bytes required to store a vector of pointers +to @code{asymbols} for all the symbols in the BFD @var{abfd}, +including a terminal NULL pointer. If there are no symbols in +the BFD, then return 0. If an error occurs, return -1. +@example +#define bfd_get_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) +@end example + +@findex bfd_is_local_label +@subsubsection @code{bfd_is_local_label} +@strong{Synopsis} +@example +boolean bfd_is_local_label(bfd *abfd, asymbol *sym); +@end example +@strong{Description}@* +Return true if the given symbol @var{sym} in the BFD @var{abfd} is +a compiler generated local label, else return false. + +@findex bfd_is_local_label_name +@subsubsection @code{bfd_is_local_label_name} +@strong{Synopsis} +@example +boolean bfd_is_local_label_name(bfd *abfd, const char *name); +@end example +@strong{Description}@* +Return true if a symbol with the name @var{name} in the BFD +@var{abfd} is a compiler generated local label, else return +false. This just checks whether the name has the form of a +local label. +@example +#define bfd_is_local_label_name(abfd, name) \ + BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) +@end example + +@findex bfd_canonicalize_symtab +@subsubsection @code{bfd_canonicalize_symtab} +@strong{Description}@* +Read the symbols from the BFD @var{abfd}, and fills in +the vector @var{location} with pointers to the symbols and +a trailing NULL. +Return the actual number of symbol pointers, not +including the NULL. +@example +#define bfd_canonicalize_symtab(abfd, location) \ + BFD_SEND (abfd, _bfd_canonicalize_symtab,\ + (abfd, location)) +@end example + +@findex bfd_set_symtab +@subsubsection @code{bfd_set_symtab} +@strong{Synopsis} +@example +boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count); +@end example +@strong{Description}@* +Arrange that when the output BFD @var{abfd} is closed, +the table @var{location} of @var{count} pointers to symbols +will be written. + +@findex bfd_print_symbol_vandf +@subsubsection @code{bfd_print_symbol_vandf} +@strong{Synopsis} +@example +void bfd_print_symbol_vandf(PTR file, asymbol *symbol); +@end example +@strong{Description}@* +Print the value and flags of the @var{symbol} supplied to the +stream @var{file}. + +@findex bfd_make_empty_symbol +@subsubsection @code{bfd_make_empty_symbol} +@strong{Description}@* +Create a new @code{asymbol} structure for the BFD @var{abfd} +and return a pointer to it. + +This routine is necessary because each back end has private +information surrounding the @code{asymbol}. Building your own +@code{asymbol} and pointing to it will not create the private +information, and will cause problems later on. +@example +#define bfd_make_empty_symbol(abfd) \ + BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) +@end example + +@findex bfd_make_debug_symbol +@subsubsection @code{bfd_make_debug_symbol} +@strong{Description}@* +Create a new @code{asymbol} structure for the BFD @var{abfd}, +to be used as a debugging symbol. Further details of its use have +yet to be worked out. +@example +#define bfd_make_debug_symbol(abfd,ptr,size) \ + BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) +@end example + +@findex bfd_decode_symclass +@subsubsection @code{bfd_decode_symclass} +@strong{Description}@* +Return a character corresponding to the symbol +class of @var{symbol}, or '?' for an unknown class. + +@strong{Synopsis} +@example +int bfd_decode_symclass(asymbol *symbol); +@end example +@findex bfd_is_undefined_symclass +@subsubsection @code{bfd_is_undefined_symclass } +@strong{Description}@* +Returns non-zero if the class symbol returned by +bfd_decode_symclass represents an undefined symbol. +Returns zero otherwise. + +@strong{Synopsis} +@example +boolean bfd_is_undefined_symclass (int symclass); +@end example +@findex bfd_symbol_info +@subsubsection @code{bfd_symbol_info} +@strong{Description}@* +Fill in the basic info about symbol that nm needs. +Additional info may be added by the back-ends after +calling this function. + +@strong{Synopsis} +@example +void bfd_symbol_info(asymbol *symbol, symbol_info *ret); +@end example +@findex bfd_copy_private_symbol_data +@subsubsection @code{bfd_copy_private_symbol_data} +@strong{Synopsis} +@example +boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); +@end example +@strong{Description}@* +Copy private symbol information from @var{isym} in the BFD +@var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}. +Return @code{true} on success, @code{false} on error. Possible error +returns are: + +@itemize @bullet + +@item +@code{bfd_error_no_memory} - +Not enough memory exists to create private data for @var{osec}. +@end itemize +@example +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ + BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ + (ibfd, isymbol, obfd, osymbol)) +@end example + diff --git a/bfd/doc/targets.texi b/bfd/doc/targets.texi new file mode 100644 index 00000000000..50086c4d825 --- /dev/null +++ b/bfd/doc/targets.texi @@ -0,0 +1,508 @@ +@section Targets + + +@strong{Description}@* +Each port of BFD to a different machine requries the creation +of a target back end. All the back end provides to the root +part of BFD is a structure containing pointers to functions +which perform certain low level operations on files. BFD +translates the applications's requests through a pointer into +calls to the back end routines. + +When a file is opened with @code{bfd_openr}, its format and +target are unknown. BFD uses various mechanisms to determine +how to interpret the file. The operations performed are: + +@itemize @bullet + +@item +Create a BFD by calling the internal routine +@code{_bfd_new_bfd}, then call @code{bfd_find_target} with the +target string supplied to @code{bfd_openr} and the new BFD pointer. + +@item +If a null target string was provided to @code{bfd_find_target}, +look up the environment variable @code{GNUTARGET} and use +that as the target string. + +@item +If the target string is still @code{NULL}, or the target string is +@code{default}, then use the first item in the target vector +as the target type, and set @code{target_defaulted} in the BFD to +cause @code{bfd_check_format} to loop through all the targets. +@xref{bfd_target}. @xref{Formats}. + +@item +Otherwise, inspect the elements in the target vector +one by one, until a match on target name is found. When found, +use it. + +@item +Otherwise return the error @code{bfd_error_invalid_target} to +@code{bfd_openr}. + +@item +@code{bfd_openr} attempts to open the file using +@code{bfd_open_file}, and returns the BFD. +@end itemize +Once the BFD has been opened and the target selected, the file +format may be determined. This is done by calling +@code{bfd_check_format} on the BFD with a suggested format. +If @code{target_defaulted} has been set, each possible target +type is tried to see if it recognizes the specified format. +@code{bfd_check_format} returns @code{true} when the caller guesses right. +@menu +* bfd_target:: +@end menu + +@node bfd_target, , Targets, Targets + +@subsection bfd_target + + +@strong{Description}@* +This structure contains everything that BFD knows about a +target. It includes things like its byte order, name, and which +routines to call to do various operations. + +Every BFD points to a target structure with its @code{xvec} +member. + +The macros below are used to dispatch to functions through the +@code{bfd_target} vector. They are used in a number of macros further +down in @file{bfd.h}, and are also used when calling various +routines by hand inside the BFD implementation. The @var{arglist} +argument must be parenthesized; it contains all the arguments +to the called function. + +They make the documentation (more) unpleasant to read, so if +someone wants to fix this and not break the above, please do. +@example +#define BFD_SEND(bfd, message, arglist) \ + ((*((bfd)->xvec->message)) arglist) + +#ifdef DEBUG_BFD_SEND +#undef BFD_SEND +#define BFD_SEND(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + ((*((bfd)->xvec->message)) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) +#endif +@end example +For operations which index on the BFD format: +@example +#define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) + +#ifdef DEBUG_BFD_SEND +#undef BFD_SEND_FMT +#define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) +#endif +@end example +This is the structure which defines the type of BFD this is. The +@code{xvec} member of the struct @code{bfd} itself points here. Each +module that implements access to a different target under BFD, +defines one of these. + +FIXME, these names should be rationalised with the names of +the entry points which call them. Too bad we can't have one +macro to define them both! +@example +enum bfd_flavour @{ + bfd_target_unknown_flavour, + bfd_target_aout_flavour, + bfd_target_coff_flavour, + bfd_target_ecoff_flavour, + bfd_target_elf_flavour, + bfd_target_ieee_flavour, + bfd_target_nlm_flavour, + bfd_target_oasys_flavour, + bfd_target_tekhex_flavour, + bfd_target_srec_flavour, + bfd_target_ihex_flavour, + bfd_target_som_flavour, + bfd_target_os9k_flavour, + bfd_target_versados_flavour, + bfd_target_msdos_flavour, + bfd_target_ovax_flavour, + bfd_target_evax_flavour +@}; + +enum bfd_endian @{ BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN @}; + + /* Forward declaration. */ +typedef struct bfd_link_info _bfd_link_info; + +typedef struct bfd_target +@{ +@end example +Identifies the kind of target, e.g., SunOS4, Ultrix, etc. +@example + char *name; +@end example +The "flavour" of a back end is a general indication about the contents +of a file. +@example + enum bfd_flavour flavour; +@end example +The order of bytes within the data area of a file. +@example + enum bfd_endian byteorder; +@end example +The order of bytes within the header parts of a file. +@example + enum bfd_endian header_byteorder; +@end example +A mask of all the flags which an executable may have set - +from the set @code{BFD_NO_FLAGS}, @code{HAS_RELOC}, ...@code{D_PAGED}. +@example + flagword object_flags; +@end example +A mask of all the flags which a section may have set - from +the set @code{SEC_NO_FLAGS}, @code{SEC_ALLOC}, ...@code{SET_NEVER_LOAD}. +@example + flagword section_flags; +@end example +The character normally found at the front of a symbol +(if any), perhaps `_'. +@example + char symbol_leading_char; +@end example +The pad character for file names within an archive header. +@example + char ar_pad_char; +@end example +The maximum number of characters in an archive header. +@example + unsigned short ar_max_namelen; +@end example +Entries for byte swapping for data. These are different from the other +entry points, since they don't take a BFD asthe first argument. +Certain other handlers could do the same. +@example + bfd_vma (*bfd_getx64) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *)); + void (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_getx32) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *)); + void (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_getx16) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *)); + void (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *)); +@end example +Byte swapping for the headers +@example + bfd_vma (*bfd_h_getx64) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *)); + void (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_h_getx32) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *)); + void (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_h_getx16) PARAMS ((const bfd_byte *)); + bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *)); + void (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *)); +@end example +Format dependent routines: these are vectors of entry points +within the target vector structure, one for each format to check. + +Check the format of a file being read. Return a @code{bfd_target *} or zero. +@example + const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *)); +@end example +Set the format of a file being written. +@example + boolean (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *)); +@end example +Write cached information into a file being written, at @code{bfd_close}. +@example + boolean (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *)); +@end example +The general target vector. These vectors are initialized using the +BFD_JUMP_TABLE macros. +@example + + /* Generic entry points. */ +#define BFD_JUMP_TABLE_GENERIC(NAME)\ +CAT(NAME,_close_and_cleanup),\ +CAT(NAME,_bfd_free_cached_info),\ +CAT(NAME,_new_section_hook),\ +CAT(NAME,_get_section_contents),\ +CAT(NAME,_get_section_contents_in_window) + + /* Called when the BFD is being closed to do any necessary cleanup. */ + boolean (*_close_and_cleanup) PARAMS ((bfd *)); + /* Ask the BFD to free all cached information. */ + boolean (*_bfd_free_cached_info) PARAMS ((bfd *)); + /* Called when a new section is created. */ + boolean (*_new_section_hook) PARAMS ((bfd *, sec_ptr)); + /* Read the contents of a section. */ + boolean (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR, + file_ptr, bfd_size_type)); + boolean (*_bfd_get_section_contents_in_window) + PARAMS ((bfd *, sec_ptr, bfd_window *, + file_ptr, bfd_size_type)); + + /* Entry points to copy private data. */ +#define BFD_JUMP_TABLE_COPY(NAME)\ +CAT(NAME,_bfd_copy_private_bfd_data),\ +CAT(NAME,_bfd_merge_private_bfd_data),\ +CAT(NAME,_bfd_copy_private_section_data),\ +CAT(NAME,_bfd_copy_private_symbol_data),\ +CAT(NAME,_bfd_set_private_flags),\ +CAT(NAME,_bfd_print_private_bfd_data)\ + /* Called to copy BFD general private data from one object file + to another. */ + boolean (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *)); + /* Called to merge BFD general private data from one object file + to a common output file when linking. */ + boolean (*_bfd_merge_private_bfd_data) PARAMS ((bfd *, bfd *)); + /* Called to copy BFD private section data from one object file + to another. */ + boolean (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr, + bfd *, sec_ptr)); + /* Called to copy BFD private symbol data from one symbol + to another. */ + boolean (*_bfd_copy_private_symbol_data) PARAMS ((bfd *, asymbol *, + bfd *, asymbol *)); + /* Called to set private backend flags */ + boolean (*_bfd_set_private_flags) PARAMS ((bfd *, flagword)); + + /* Called to print private BFD data */ + boolean (*_bfd_print_private_bfd_data) PARAMS ((bfd *, PTR)); + + /* Core file entry points. */ +#define BFD_JUMP_TABLE_CORE(NAME)\ +CAT(NAME,_core_file_failing_command),\ +CAT(NAME,_core_file_failing_signal),\ +CAT(NAME,_core_file_matches_executable_p) + char * (*_core_file_failing_command) PARAMS ((bfd *)); + int (*_core_file_failing_signal) PARAMS ((bfd *)); + boolean (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *)); + + /* Archive entry points. */ +#define BFD_JUMP_TABLE_ARCHIVE(NAME)\ +CAT(NAME,_slurp_armap),\ +CAT(NAME,_slurp_extended_name_table),\ +CAT(NAME,_construct_extended_name_table),\ +CAT(NAME,_truncate_arname),\ +CAT(NAME,_write_armap),\ +CAT(NAME,_read_ar_hdr),\ +CAT(NAME,_openr_next_archived_file),\ +CAT(NAME,_get_elt_at_index),\ +CAT(NAME,_generic_stat_arch_elt),\ +CAT(NAME,_update_armap_timestamp) + boolean (*_bfd_slurp_armap) PARAMS ((bfd *)); + boolean (*_bfd_slurp_extended_name_table) PARAMS ((bfd *)); + boolean (*_bfd_construct_extended_name_table) + PARAMS ((bfd *, char **, bfd_size_type *, const char **)); + void (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *)); + boolean (*write_armap) PARAMS ((bfd *arch, + unsigned int elength, + struct orl *map, + unsigned int orl_count, + int stridx)); + PTR (*_bfd_read_ar_hdr_fn) PARAMS ((bfd *)); + bfd * (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev)); +#define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i)) + bfd * (*_bfd_get_elt_at_index) PARAMS ((bfd *, symindex)); + int (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *)); + boolean (*_bfd_update_armap_timestamp) PARAMS ((bfd *)); + + /* Entry points used for symbols. */ +#define BFD_JUMP_TABLE_SYMBOLS(NAME)\ +CAT(NAME,_get_symtab_upper_bound),\ +CAT(NAME,_get_symtab),\ +CAT(NAME,_make_empty_symbol),\ +CAT(NAME,_print_symbol),\ +CAT(NAME,_get_symbol_info),\ +CAT(NAME,_bfd_is_local_label_name),\ +CAT(NAME,_get_lineno),\ +CAT(NAME,_find_nearest_line),\ +CAT(NAME,_bfd_make_debug_symbol),\ +CAT(NAME,_read_minisymbols),\ +CAT(NAME,_minisymbol_to_symbol) + long (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *)); + long (*_bfd_canonicalize_symtab) PARAMS ((bfd *, + struct symbol_cache_entry **)); + struct symbol_cache_entry * + (*_bfd_make_empty_symbol) PARAMS ((bfd *)); + void (*_bfd_print_symbol) PARAMS ((bfd *, PTR, + struct symbol_cache_entry *, + bfd_print_symbol_type)); +#define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e)) + void (*_bfd_get_symbol_info) PARAMS ((bfd *, + struct symbol_cache_entry *, + symbol_info *)); +#define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e)) + boolean (*_bfd_is_local_label_name) PARAMS ((bfd *, const char *)); + + alent * (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *)); + boolean (*_bfd_find_nearest_line) PARAMS ((bfd *abfd, + struct sec *section, struct symbol_cache_entry **symbols, + bfd_vma offset, CONST char **file, CONST char **func, + unsigned int *line)); + /* Back-door to allow format-aware applications to create debug symbols + while using BFD for everything else. Currently used by the assembler + when creating COFF files. */ + asymbol * (*_bfd_make_debug_symbol) PARAMS (( + bfd *abfd, + void *ptr, + unsigned long size)); +#define bfd_read_minisymbols(b, d, m, s) \ + BFD_SEND (b, _read_minisymbols, (b, d, m, s)) + long (*_read_minisymbols) PARAMS ((bfd *, boolean, PTR *, + unsigned int *)); +#define bfd_minisymbol_to_symbol(b, d, m, f) \ + BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f)) + asymbol *(*_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR, + asymbol *)); + + /* Routines for relocs. */ +#define BFD_JUMP_TABLE_RELOCS(NAME)\ +CAT(NAME,_get_reloc_upper_bound),\ +CAT(NAME,_canonicalize_reloc),\ +CAT(NAME,_bfd_reloc_type_lookup) + long (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr)); + long (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **, + struct symbol_cache_entry **)); + /* See documentation on reloc types. */ + reloc_howto_type * + (*reloc_type_lookup) PARAMS ((bfd *abfd, + bfd_reloc_code_real_type code)); + + /* Routines used when writing an object file. */ +#define BFD_JUMP_TABLE_WRITE(NAME)\ +CAT(NAME,_set_arch_mach),\ +CAT(NAME,_set_section_contents) + boolean (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture, + unsigned long)); + boolean (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR, + file_ptr, bfd_size_type)); + + /* Routines used by the linker. */ +#define BFD_JUMP_TABLE_LINK(NAME)\ +CAT(NAME,_sizeof_headers),\ +CAT(NAME,_bfd_get_relocated_section_contents),\ +CAT(NAME,_bfd_relax_section),\ +CAT(NAME,_bfd_link_hash_table_create),\ +CAT(NAME,_bfd_link_add_symbols),\ +CAT(NAME,_bfd_final_link),\ +CAT(NAME,_bfd_link_split_section),\ +CAT(NAME,_bfd_gc_sections) + int (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean)); + bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *, + struct bfd_link_info *, struct bfd_link_order *, + bfd_byte *data, boolean relocateable, + struct symbol_cache_entry **)); + + boolean (*_bfd_relax_section) PARAMS ((bfd *, struct sec *, + struct bfd_link_info *, boolean *again)); + + /* Create a hash table for the linker. Different backends store + different information in this table. */ + struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *)); + + /* Add symbols from this object file into the hash table. */ + boolean (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *)); + + /* Do a link based on the link_order structures attached to each + section of the BFD. */ + boolean (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *)); + + /* Should this section be split up into smaller pieces during linking. */ + boolean (*_bfd_link_split_section) PARAMS ((bfd *, struct sec *)); + + /* Remove sections that are not referenced from the output. */ + boolean (*_bfd_gc_sections) PARAMS ((bfd *, struct bfd_link_info *)); + + /* Routines to handle dynamic symbols and relocs. */ +#define BFD_JUMP_TABLE_DYNAMIC(NAME)\ +CAT(NAME,_get_dynamic_symtab_upper_bound),\ +CAT(NAME,_canonicalize_dynamic_symtab),\ +CAT(NAME,_get_dynamic_reloc_upper_bound),\ +CAT(NAME,_canonicalize_dynamic_reloc) + /* Get the amount of memory required to hold the dynamic symbols. */ + long (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *)); + /* Read in the dynamic symbols. */ + long (*_bfd_canonicalize_dynamic_symtab) + PARAMS ((bfd *, struct symbol_cache_entry **)); + /* Get the amount of memory required to hold the dynamic relocs. */ + long (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *)); + /* Read in the dynamic relocs. */ + long (*_bfd_canonicalize_dynamic_reloc) + PARAMS ((bfd *, arelent **, struct symbol_cache_entry **)); + +@end example +A pointer to an alternative bfd_target in case the current one is not +satisfactory. This can happen when the target cpu supports both big +and little endian code, and target chosen by the linker has the wrong +endianness. The function open_output() in ld/ldlang.c uses this field +to find an alternative output format that is suitable. +@example + /* Opposite endian version of this target. */ + const struct bfd_target * alternative_target; + +@end example +Data for use by back-end routines, which isn't generic enough to belong +in this structure. +@example + PTR backend_data; + +@} bfd_target; +@end example + +@findex bfd_set_default_target +@subsubsection @code{bfd_set_default_target} +@strong{Synopsis} +@example +boolean bfd_set_default_target (const char *name); +@end example +@strong{Description}@* +Set the default target vector to use when recognizing a BFD. +This takes the name of the target, which may be a BFD target +name or a configuration triplet. + +@findex bfd_find_target +@subsubsection @code{bfd_find_target} +@strong{Synopsis} +@example +const bfd_target *bfd_find_target(CONST char *target_name, bfd *abfd); +@end example +@strong{Description}@* +Return a pointer to the transfer vector for the object target +named @var{target_name}. If @var{target_name} is @code{NULL}, choose the +one in the environment variable @code{GNUTARGET}; if that is null or not +defined, then choose the first entry in the target list. +Passing in the string "default" or setting the environment +variable to "default" will cause the first entry in the target +list to be returned, and "target_defaulted" will be set in the +BFD. This causes @code{bfd_check_format} to loop over all the +targets to find the one that matches the file being read. + +@findex bfd_target_list +@subsubsection @code{bfd_target_list} +@strong{Synopsis} +@example +const char **bfd_target_list(void); +@end example +@strong{Description}@* +Return a freshly malloced NULL-terminated +vector of the names of all the valid BFD targets. Do not +modify the names. + +@findex bfd_seach_for_target +@subsubsection @code{bfd_seach_for_target} +@strong{Synopsis} +@example +const bfd_target * bfd_search_for_target (int (* search_func)(const bfd_target *, void *), void *); +@end example +@strong{Description}@* +Return a pointer to the first transfer vector in the list of +transfer vectors maintained by BFD that produces a non-zero +result when passed to the function @var{search_func}. The +parameter @var{data} is passed, unexamined, to the search +function. + diff --git a/binutils/arlex.c b/binutils/arlex.c new file mode 100644 index 00000000000..23ca1f01dd5 --- /dev/null +++ b/binutils/arlex.c @@ -0,0 +1,1835 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> +#include <unistd.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 40 +#define YY_END_OF_BUFFER 41 +static yyconst short int yy_accept[177] = + { 0, + 0, 0, 41, 40, 39, 38, 35, 32, 33, 36, + 40, 34, 37, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 36, 31, 37, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 7, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 22, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + + 35, 35, 35, 10, 11, 12, 35, 15, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 25, 26, 27, + 35, 30, 35, 35, 35, 3, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 18, 35, 35, 35, 35, + 35, 35, 35, 1, 2, 4, 5, 35, 35, 35, + 35, 35, 16, 17, 19, 20, 35, 35, 35, 35, + 35, 35, 8, 9, 13, 14, 35, 23, 24, 28, + 29, 35, 35, 6, 21, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 3, 1, 1, 1, 4, 1, 1, 1, 5, + 6, 7, 8, 9, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 10, 1, + 1, 1, 1, 1, 11, 12, 13, 14, 15, 16, + 4, 17, 18, 4, 4, 19, 20, 21, 22, 23, + 4, 24, 25, 26, 27, 28, 4, 29, 30, 4, + 1, 1, 1, 1, 4, 1, 31, 32, 33, 34, + + 35, 36, 4, 37, 38, 4, 4, 39, 40, 41, + 42, 43, 4, 44, 45, 46, 47, 48, 4, 49, + 50, 4, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[51] = + { 0, + 1, 2, 1, 3, 1, 1, 1, 1, 1, 1, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[180] = + { 0, + 0, 0, 193, 194, 194, 194, 0, 194, 194, 0, + 190, 194, 0, 177, 32, 37, 32, 163, 174, 170, + 164, 171, 174, 169, 149, 15, 22, 17, 135, 146, + 142, 136, 143, 146, 141, 0, 0, 194, 0, 161, + 159, 158, 153, 147, 156, 143, 149, 148, 141, 150, + 141, 135, 138, 127, 125, 124, 119, 113, 122, 109, + 115, 114, 107, 116, 107, 101, 104, 43, 136, 135, + 130, 129, 0, 119, 123, 118, 114, 118, 119, 122, + 124, 25, 104, 103, 98, 97, 0, 87, 91, 86, + 82, 86, 87, 90, 92, 105, 100, 97, 94, 93, + + 105, 106, 102, 0, 0, 0, 104, 0, 92, 75, + 70, 67, 64, 63, 75, 76, 72, 0, 0, 0, + 74, 0, 62, 91, 88, 0, 86, 85, 73, 85, + 79, 83, 70, 62, 59, 0, 57, 56, 44, 56, + 50, 54, 41, 0, 0, 0, 0, 63, 58, 59, + 67, 66, 0, 0, 0, 0, 38, 33, 34, 42, + 41, 51, 0, 0, 0, 0, 30, 0, 0, 0, + 0, 43, 21, 0, 0, 194, 65, 66, 69 + } ; + +static yyconst short int yy_def[180] = + { 0, + 176, 1, 176, 176, 176, 176, 177, 176, 176, 178, + 176, 176, 179, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 178, 176, 179, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, + 177, 177, 177, 177, 177, 0, 176, 176, 176 + } ; + +static yyconst short int yy_nxt[245] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 7, 15, 16, 17, 18, 19, 7, 20, 7, + 7, 21, 7, 22, 23, 7, 7, 24, 7, 7, + 25, 7, 26, 27, 28, 29, 30, 7, 31, 7, + 7, 32, 7, 33, 34, 7, 7, 35, 7, 7, + 41, 43, 45, 55, 44, 42, 57, 59, 56, 58, + 46, 96, 97, 110, 111, 60, 37, 36, 37, 39, + 175, 39, 174, 173, 172, 171, 170, 169, 168, 167, + 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, + 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, + + 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, + 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, + 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, + 116, 115, 114, 113, 112, 109, 108, 107, 106, 105, + 104, 103, 102, 101, 100, 99, 98, 95, 94, 93, + 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, + 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, + 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, + 62, 61, 54, 53, 52, 51, 50, 49, 48, 47, + 40, 38, 176, 3, 176, 176, 176, 176, 176, 176, + + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176 + } ; + +static yyconst short int yy_chk[245] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 15, 16, 17, 26, 16, 15, 27, 28, 26, 27, + 17, 68, 68, 82, 82, 28, 178, 177, 178, 179, + 173, 179, 172, 167, 162, 161, 160, 159, 158, 157, + 152, 151, 150, 149, 148, 143, 142, 141, 140, 139, + 138, 137, 135, 134, 133, 132, 131, 130, 129, 128, + + 127, 125, 124, 123, 121, 117, 116, 115, 114, 113, + 112, 111, 110, 109, 107, 103, 102, 101, 100, 99, + 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, + 88, 86, 85, 84, 83, 81, 80, 79, 78, 77, + 76, 75, 74, 72, 71, 70, 69, 67, 66, 65, + 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, + 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, + 44, 43, 42, 41, 40, 35, 34, 33, 32, 31, + 30, 29, 25, 24, 23, 22, 21, 20, 19, 18, + 14, 11, 3, 176, 176, 176, 176, 176, 176, 176, + + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 176, 176, 176, 176 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "arlex.l" +#define INITIAL 0 +#line 2 "arlex.l" +/* arlex.l - Strange script language lexer */ + +/* Copyright (C) 1992, 95, 1997 Free Software Foundation, Inc. + +This file is part of GNU Binutils. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + + +/* Contributed by Steve Chamberlain + sac@cygnus.com + +*/ +#define DONTDECLARE_MALLOC +#include <ansidecl.h> +#include "libiberty.h" +#include "arparse.h" + +int linenumber; +#line 505 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 38 "arlex.l" + + +#line 659 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 177 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 194 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 40 "arlex.l" +{ return ADDLIB; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 41 "arlex.l" +{ return ADDMOD; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 42 "arlex.l" +{ return CLEAR; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 43 "arlex.l" +{ return CREATE; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 44 "arlex.l" +{ return DELETE; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 45 "arlex.l" +{ return DIRECTORY; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 46 "arlex.l" +{ return END; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 47 "arlex.l" +{ return EXTRACT; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 48 "arlex.l" +{ return FULLDIR; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 49 "arlex.l" +{ return HELP; } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 50 "arlex.l" +{ return LIST; } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 51 "arlex.l" +{ return OPEN; } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 52 "arlex.l" +{ return REPLACE; } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 53 "arlex.l" +{ return VERBOSE; } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 54 "arlex.l" +{ return SAVE; } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 55 "arlex.l" +{ return ADDLIB; } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 56 "arlex.l" +{ return ADDMOD; } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 57 "arlex.l" +{ return CLEAR; } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 58 "arlex.l" +{ return CREATE; } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 59 "arlex.l" +{ return DELETE; } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 60 "arlex.l" +{ return DIRECTORY; } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 61 "arlex.l" +{ return END; } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 62 "arlex.l" +{ return EXTRACT; } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 63 "arlex.l" +{ return FULLDIR; } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 64 "arlex.l" +{ return HELP; } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 65 "arlex.l" +{ return LIST; } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 66 "arlex.l" +{ return OPEN; } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 67 "arlex.l" +{ return REPLACE; } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 68 "arlex.l" +{ return VERBOSE; } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 69 "arlex.l" +{ return SAVE; } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 70 "arlex.l" +{ linenumber ++; } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 71 "arlex.l" +{ return '('; } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 72 "arlex.l" +{ return ')'; } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 73 "arlex.l" +{ return ','; } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 74 "arlex.l" +{ + yylval.name = xstrdup (yytext); + return FILENAME; + } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 78 "arlex.l" +{ } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 79 "arlex.l" +{ } + YY_BREAK +case 38: +YY_RULE_SETUP +#line 80 "arlex.l" +{ } + YY_BREAK +case 39: +YY_RULE_SETUP +#line 81 "arlex.l" +{ linenumber ++; return NEWLINE; } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 83 "arlex.l" +ECHO; + YY_BREAK +#line 945 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 177 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 177 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 176); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 83 "arlex.l" + +#ifndef yywrap +/* Needed for lex, though not flex. */ +int yywrap() { return 1; } +#endif diff --git a/binutils/arparse.c b/binutils/arparse.c new file mode 100644 index 00000000000..23d6565ead6 --- /dev/null +++ b/binutils/arparse.c @@ -0,0 +1,1090 @@ + +/* A Bison parser, made from arparse.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define NEWLINE 257 +#define VERBOSE 258 +#define FILENAME 259 +#define ADDLIB 260 +#define LIST 261 +#define ADDMOD 262 +#define CLEAR 263 +#define CREATE 264 +#define DELETE 265 +#define DIRECTORY 266 +#define END 267 +#define EXTRACT 268 +#define FULLDIR 269 +#define HELP 270 +#define QUIT 271 +#define REPLACE 272 +#define SAVE 273 +#define OPEN 274 + +#line 1 "arparse.y" + +/* arparse.y - Stange script language parser */ + +/* Copyright (C) 1992, 93, 95, 97, 98, 1999 Free Software Foundation, Inc. + +This file is part of GNU Binutils. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + + +/* Contributed by Steve Chamberlain + sac@cygnus.com + +*/ +#define DONTDECLARE_MALLOC +#include "bfd.h" +#include "bucomm.h" +#include "arsup.h" +extern int verbose; +extern int yylex PARAMS ((void)); +static int yyerror PARAMS ((const char *)); + +#line 36 "arparse.y" +typedef union { + char *name; +struct list *list ; + +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 53 +#define YYFLAG -32768 +#define YYNTBASE 24 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 274 ? yytranslate[x] : 45) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 21, + 22, 2, 2, 23, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 1, 4, 7, 8, 11, 13, 15, 17, 19, + 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, + 41, 42, 45, 48, 50, 53, 56, 58, 60, 63, + 66, 70, 75, 77, 78, 82, 83, 87, 88, 90, + 91 +}; + +static const short yyrhs[] = { -1, + 25, 26, 0, 26, 27, 0, 0, 28, 3, 0, + 36, 0, 37, 0, 44, 0, 39, 0, 38, 0, + 31, 0, 33, 0, 35, 0, 29, 0, 30, 0, + 32, 0, 34, 0, 13, 0, 1, 0, 5, 0, + 0, 14, 42, 0, 18, 42, 0, 9, 0, 11, + 42, 0, 8, 42, 0, 7, 0, 19, 0, 20, + 5, 0, 10, 5, 0, 6, 5, 41, 0, 12, + 5, 41, 40, 0, 5, 0, 0, 21, 42, 22, + 0, 0, 42, 43, 5, 0, 0, 23, 0, 0, + 4, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 66, 68, 70, 72, 75, 78, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 98, 103, 108, 113, 117, 122, 127, 134, 139, + 145, 149, 156, 159, 162, 165, 169, 176, 180, 182, + 186 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","NEWLINE", +"VERBOSE","FILENAME","ADDLIB","LIST","ADDMOD","CLEAR","CREATE","DELETE","DIRECTORY", +"END","EXTRACT","FULLDIR","HELP","QUIT","REPLACE","SAVE","OPEN","'('","')'", +"','","start","@1","session","command_line","command","extract_command","replace_command", +"clear_command","delete_command","addmod_command","list_command","save_command", +"open_command","create_command","addlib_command","directory_command","optional_filename", +"modulelist","modulename","optcomma","verbose_command", NULL +}; +#endif + +static const short yyr1[] = { 0, + 25, 24, 26, 26, 27, 28, 28, 28, 28, 28, + 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 40, 41, 41, 42, 42, 43, 43, + 44 +}; + +static const short yyr2[] = { 0, + 0, 2, 2, 0, 2, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 2, 2, 1, 2, 2, 1, 1, 2, 2, + 3, 4, 1, 0, 3, 0, 3, 0, 1, 0, + 1 +}; + +static const short yydefact[] = { 1, + 4, 0, 19, 41, 20, 0, 27, 38, 24, 0, + 38, 0, 18, 38, 38, 28, 0, 3, 0, 14, + 15, 11, 16, 12, 17, 13, 6, 7, 10, 9, + 8, 36, 26, 30, 25, 36, 22, 23, 29, 5, + 38, 31, 39, 0, 34, 40, 37, 33, 32, 35, + 0, 0, 0 +}; + +static const short yydefgoto[] = { 51, + 1, 2, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 49, 42, 33, 44, 31 +}; + +static const short yypact[] = {-32768, +-32768, 5,-32768,-32768,-32768, -4,-32768,-32768,-32768, 2, +-32768, 21,-32768,-32768,-32768,-32768, 22,-32768, 25,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 8, -3,-32768, -3, 8, -3, -3,-32768,-32768, +-32768,-32768,-32768, 26, 27, -1,-32768,-32768,-32768,-32768, + 33, 34,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, 0, -11,-32768,-32768 +}; + + +#define YYLAST 36 + + +static const short yytable[] = { 35, + 32, -40, 37, 38, -2, 3, 34, -21, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 43, + 50, 43, 15, 16, 17, 36, 39, 40, 41, 46, + 47, 48, 52, 53, 0, 45 +}; + +static const short yycheck[] = { 11, + 5, 5, 14, 15, 0, 1, 5, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 23, + 22, 23, 18, 19, 20, 5, 5, 3, 21, 41, + 5, 5, 0, 0, -1, 36 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 1: +#line 67 "arparse.y" +{ prompt(); ; + break;} +case 5: +#line 76 "arparse.y" +{ prompt(); ; + break;} +case 18: +#line 91 "arparse.y" +{ ar_end(); return 0; ; + break;} +case 20: +#line 93 "arparse.y" +{ yyerror("foo"); ; + break;} +case 22: +#line 100 "arparse.y" +{ ar_extract(yyvsp[0].list); ; + break;} +case 23: +#line 105 "arparse.y" +{ ar_replace(yyvsp[0].list); ; + break;} +case 24: +#line 110 "arparse.y" +{ ar_clear(); ; + break;} +case 25: +#line 115 "arparse.y" +{ ar_delete(yyvsp[0].list); ; + break;} +case 26: +#line 119 "arparse.y" +{ ar_addmod(yyvsp[0].list); ; + break;} +case 27: +#line 124 "arparse.y" +{ ar_list(); ; + break;} +case 28: +#line 129 "arparse.y" +{ ar_save(); ; + break;} +case 29: +#line 136 "arparse.y" +{ ar_open(yyvsp[0].name,0); ; + break;} +case 30: +#line 141 "arparse.y" +{ ar_open(yyvsp[0].name,1); ; + break;} +case 31: +#line 147 "arparse.y" +{ ar_addlib(yyvsp[-1].name,yyvsp[0].list); ; + break;} +case 32: +#line 151 "arparse.y" +{ ar_directory(yyvsp[-2].name, yyvsp[-1].list, yyvsp[0].name); ; + break;} +case 33: +#line 158 "arparse.y" +{ yyval.name = yyvsp[0].name; ; + break;} +case 34: +#line 159 "arparse.y" +{ yyval.name = 0; ; + break;} +case 35: +#line 164 "arparse.y" +{ yyval.list = yyvsp[-1].list; ; + break;} +case 36: +#line 166 "arparse.y" +{ yyval.list = 0; ; + break;} +case 37: +#line 171 "arparse.y" +{ struct list *n = (struct list *) malloc(sizeof(struct list)); + n->next = yyvsp[-2].list; + n->name = yyvsp[0].name; + yyval.list = n; + ; + break;} +case 38: +#line 176 "arparse.y" +{ yyval.list = 0; ; + break;} +case 41: +#line 188 "arparse.y" +{ verbose = !verbose; ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 192 "arparse.y" + + +static int +yyerror (x) + const char *x ATTRIBUTE_UNUSED; +{ + extern int linenumber; + + printf (_("Syntax error in archive script, line %d\n"), linenumber + 1); + return 0; +} diff --git a/binutils/arparse.h b/binutils/arparse.h new file mode 100644 index 00000000000..960453720bd --- /dev/null +++ b/binutils/arparse.h @@ -0,0 +1,26 @@ +typedef union { + char *name; +struct list *list ; + +} YYSTYPE; +#define NEWLINE 257 +#define VERBOSE 258 +#define FILENAME 259 +#define ADDLIB 260 +#define LIST 261 +#define ADDMOD 262 +#define CLEAR 263 +#define CREATE 264 +#define DELETE 265 +#define DIRECTORY 266 +#define END 267 +#define EXTRACT 268 +#define FULLDIR 269 +#define HELP 270 +#define QUIT 271 +#define REPLACE 272 +#define SAVE 273 +#define OPEN 274 + + +extern YYSTYPE yylval; diff --git a/binutils/binutils.info b/binutils/binutils.info new file mode 100644 index 00000000000..13af724d97e --- /dev/null +++ b/binutils/binutils.info @@ -0,0 +1,74 @@ +This is binutils.info, produced by makeinfo version 4.0 from +binutils.texi. + +START-INFO-DIR-ENTRY +* Binutils: (binutils). The GNU binary utilities. +* ar: (binutils)ar. Create, modify, and extract from archives +* nm: (binutils)nm. List symbols from object files +* objcopy: (binutils)objcopy. Copy and translate object files +* objdump: (binutils)objdump. Display information from object files +* ranlib: (binutils)ranlib. Generate index to archive contents +* readelf: (binutils)readelf. Display the contents of ELF format files. +* size: (binutils)size. List section sizes and total size +* strings: (binutils)strings. List printable strings from files +* strip: (binutils)strip. Discard symbols +* c++filt: (binutils)c++filt. Filter to demangle encoded C++ symbols +* cxxfilt: (binutils)c++filt. MS-DOS name for c++filt +* addr2line: (binutils)addr2line. Convert addresses to file and line +* nlmconv: (binutils)nlmconv. Converts object code into an NLM +* windres: (binutils)windres. Manipulate Windows resources +* dlltool: (binutils)dlltool. Create files needed to build and use DLLs +END-INFO-DIR-ENTRY + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +Indirect: +binutils.info-1: 1845 +binutils.info-2: 49760 +binutils.info-3: 96951 + +Tag Table: +(Indirect) +Node: Top1845 +Node: ar3094 +Node: ar cmdline5268 +Node: ar scripts13107 +Node: nm18786 +Node: objcopy25756 +Node: objdump38583 +Node: ranlib49011 +Node: size49760 +Node: strings52491 +Node: strip54316 +Node: c++filt57281 +Ref: c++filt-Footnote-160138 +Node: addr2line60244 +Node: nlmconv62650 +Node: windres65254 +Node: dlltool70306 +Node: readelf79647 +Node: Selecting The Target System82798 +Node: Target Selection83815 +Node: Architecture Selection86516 +Node: Linker Emulation Selection87747 +Node: Reporting Bugs88625 +Node: Bug Criteria89376 +Node: Bug Reporting89922 +Node: Index96951 + +End Tag Table diff --git a/binutils/binutils.info-1 b/binutils/binutils.info-1 new file mode 100644 index 00000000000..27ad36abc29 --- /dev/null +++ b/binutils/binutils.info-1 @@ -0,0 +1,1277 @@ +This is binutils.info, produced by makeinfo version 4.0 from +binutils.texi. + +START-INFO-DIR-ENTRY +* Binutils: (binutils). The GNU binary utilities. +* ar: (binutils)ar. Create, modify, and extract from archives +* nm: (binutils)nm. List symbols from object files +* objcopy: (binutils)objcopy. Copy and translate object files +* objdump: (binutils)objdump. Display information from object files +* ranlib: (binutils)ranlib. Generate index to archive contents +* readelf: (binutils)readelf. Display the contents of ELF format files. +* size: (binutils)size. List section sizes and total size +* strings: (binutils)strings. List printable strings from files +* strip: (binutils)strip. Discard symbols +* c++filt: (binutils)c++filt. Filter to demangle encoded C++ symbols +* cxxfilt: (binutils)c++filt. MS-DOS name for c++filt +* addr2line: (binutils)addr2line. Convert addresses to file and line +* nlmconv: (binutils)nlmconv. Converts object code into an NLM +* windres: (binutils)windres. Manipulate Windows resources +* dlltool: (binutils)dlltool. Create files needed to build and use DLLs +END-INFO-DIR-ENTRY + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: binutils.info, Node: Top, Next: ar, Up: (dir) + +Introduction +************ + + This brief manual contains preliminary documentation for the GNU +binary utilities (collectively version 2.10): + +* Menu: + +* ar:: Create, modify, and extract from archives +* nm:: List symbols from object files +* objcopy:: Copy and translate object files +* objdump:: Display information from object files +* ranlib:: Generate index to archive contents +* readelf:: Display the contents of ELF format files. +* size:: List section sizes and total size +* strings:: List printable strings from files +* strip:: Discard symbols +* c++filt:: Filter to demangle encoded C++ symbols +* cxxfilt: c++filt. MS-DOS name for c++filt +* addr2line:: Convert addresses to file and line +* nlmconv:: Converts object code into an NLM +* windres:: Manipulate Windows resources +* dlltool:: Create files needed to build and use DLLs +* Selecting The Target System:: How these utilities determine the target. +* Reporting Bugs:: Reporting Bugs +* Index:: Index + + +File: binutils.info, Node: ar, Next: nm, Prev: Top, Up: Top + +ar +** + + ar [-]P[MOD [RELPOS] [COUNT]] ARCHIVE [MEMBER...] + ar -M [ <mri-script ] + + The GNU `ar' program creates, modifies, and extracts from archives. +An "archive" is a single file holding a collection of other files in a +structure that makes it possible to retrieve the original individual +files (called "members" of the archive). + + The original files' contents, mode (permissions), timestamp, owner, +and group are preserved in the archive, and can be restored on +extraction. + + GNU `ar' can maintain archives whose members have names of any +length; however, depending on how `ar' is configured on your system, a +limit on member-name length may be imposed for compatibility with +archive formats maintained with other tools. If it exists, the limit +is often 15 characters (typical of formats related to a.out) or 16 +characters (typical of formats related to coff). + + `ar' is considered a binary utility because archives of this sort +are most often used as "libraries" holding commonly needed subroutines. + + `ar' creates an index to the symbols defined in relocatable object +modules in the archive when you specify the modifier `s'. Once +created, this index is updated in the archive whenever `ar' makes a +change to its contents (save for the `q' update operation). An archive +with such an index speeds up linking to the library, and allows +routines in the library to call each other without regard to their +placement in the archive. + + You may use `nm -s' or `nm --print-armap' to list this index table. +If an archive lacks the table, another form of `ar' called `ranlib' can +be used to add just the table. + + GNU `ar' is designed to be compatible with two different facilities. +You can control its activity using command-line options, like the +different varieties of `ar' on Unix systems; or, if you specify the +single command-line option `-M', you can control it with a script +supplied via standard input, like the MRI "librarian" program. + +* Menu: + +* ar cmdline:: Controlling `ar' on the command line +* ar scripts:: Controlling `ar' with a script + + +File: binutils.info, Node: ar cmdline, Next: ar scripts, Up: ar + +Controlling `ar' on the command line +==================================== + + ar [-]P[MOD [RELPOS] [COUNT]] ARCHIVE [MEMBER...] + + When you use `ar' in the Unix style, `ar' insists on at least two +arguments to execute: one keyletter specifying the _operation_ +(optionally accompanied by other keyletters specifying _modifiers_), +and the archive name to act on. + + Most operations can also accept further MEMBER arguments, specifying +particular files to operate on. + + GNU `ar' allows you to mix the operation code P and modifier flags +MOD in any order, within the first command-line argument. + + If you wish, you may begin the first command-line argument with a +dash. + + The P keyletter specifies what operation to execute; it may be any +of the following, but you must specify only one of them: + +`d' + _Delete_ modules from the archive. Specify the names of modules to + be deleted as MEMBER...; the archive is untouched if you specify + no files to delete. + + If you specify the `v' modifier, `ar' lists each module as it is + deleted. + +`m' + Use this operation to _move_ members in an archive. + + The ordering of members in an archive can make a difference in how + programs are linked using the library, if a symbol is defined in + more than one member. + + If no modifiers are used with `m', any members you name in the + MEMBER arguments are moved to the _end_ of the archive; you can + use the `a', `b', or `i' modifiers to move them to a specified + place instead. + +`p' + _Print_ the specified members of the archive, to the standard + output file. If the `v' modifier is specified, show the member + name before copying its contents to standard output. + + If you specify no MEMBER arguments, all the files in the archive + are printed. + +`q' + _Quick append_; Historically, add the files MEMBER... to the end of + ARCHIVE, without checking for replacement. + + The modifiers `a', `b', and `i' do _not_ affect this operation; + new members are always placed at the end of the archive. + + The modifier `v' makes `ar' list each file as it is appended. + + Since the point of this operation is speed, the archive's symbol + table index is not updated, even if it already existed; you can + use `ar s' or `ranlib' explicitly to update the symbol table index. + + However, too many different systems assume quick append rebuilds + the index, so GNU ar implements `q' as a synonym for `r'. + +`r' + Insert the files MEMBER... into ARCHIVE (with _replacement_). This + operation differs from `q' in that any previously existing members + are deleted if their names match those being added. + + If one of the files named in MEMBER... does not exist, `ar' + displays an error message, and leaves undisturbed any existing + members of the archive matching that name. + + By default, new members are added at the end of the file; but you + may use one of the modifiers `a', `b', or `i' to request placement + relative to some existing member. + + The modifier `v' used with this operation elicits a line of output + for each file inserted, along with one of the letters `a' or `r' + to indicate whether the file was appended (no old member deleted) + or replaced. + +`t' + Display a _table_ listing the contents of ARCHIVE, or those of the + files listed in MEMBER... that are present in the archive. + Normally only the member name is shown; if you also want to see + the modes (permissions), timestamp, owner, group, and size, you can + request that by also specifying the `v' modifier. + + If you do not specify a MEMBER, all files in the archive are + listed. + + If there is more than one file with the same name (say, `fie') in + an archive (say `b.a'), `ar t b.a fie' lists only the first + instance; to see them all, you must ask for a complete listing--in + our example, `ar t b.a'. + +`x' + _Extract_ members (named MEMBER) from the archive. You can use + the `v' modifier with this operation, to request that `ar' list + each name as it extracts it. + + If you do not specify a MEMBER, all files in the archive are + extracted. + + A number of modifiers (MOD) may immediately follow the P keyletter, +to specify variations on an operation's behavior: + +`a' + Add new files _after_ an existing member of the archive. If you + use the modifier `a', the name of an existing archive member must + be present as the RELPOS argument, before the ARCHIVE + specification. + +`b' + Add new files _before_ an existing member of the archive. If you + use the modifier `b', the name of an existing archive member must + be present as the RELPOS argument, before the ARCHIVE + specification. (same as `i'). + +`c' + _Create_ the archive. The specified ARCHIVE is always created if + it did not exist, when you request an update. But a warning is + issued unless you specify in advance that you expect to create it, + by using this modifier. + +`f' + Truncate names in the archive. GNU `ar' will normally permit file + names of any length. This will cause it to create archives which + are not compatible with the native `ar' program on some systems. + If this is a concern, the `f' modifier may be used to truncate file + names when putting them in the archive. + +`i' + Insert new files _before_ an existing member of the archive. If + you use the modifier `i', the name of an existing archive member + must be present as the RELPOS argument, before the ARCHIVE + specification. (same as `b'). + +`l' + This modifier is accepted but not used. + +`N' + Uses the COUNT parameter. This is used if there are multiple + entries in the archive with the same name. Extract or delete + instance COUNT of the given name from the archive. + +`o' + Preserve the _original_ dates of members when extracting them. If + you do not specify this modifier, files extracted from the archive + are stamped with the time of extraction. + +`P' + Use the full path name when matching names in the archive. GNU + `ar' can not create an archive with a full path name (such archives + are not POSIX complaint), but other archive creators can. This + option will cause GNU `ar' to match file names using a complete + path name, which can be convenient when extracting a single file + from an archive created by another tool. + +`s' + Write an object-file index into the archive, or update an existing + one, even if no other change is made to the archive. You may use + this modifier flag either with any operation, or alone. Running + `ar s' on an archive is equivalent to running `ranlib' on it. + +`S' + Do not generate an archive symbol table. This can speed up + building a large library in several steps. The resulting archive + can not be used with the linker. In order to build a symbol + table, you must omit the `S' modifier on the last execution of + `ar', or you must run `ranlib' on the archive. + +`u' + Normally, `ar r'... inserts all files listed into the archive. If + you would like to insert _only_ those of the files you list that + are newer than existing members of the same names, use this + modifier. The `u' modifier is allowed only for the operation `r' + (replace). In particular, the combination `qu' is not allowed, + since checking the timestamps would lose any speed advantage from + the operation `q'. + +`v' + This modifier requests the _verbose_ version of an operation. Many + operations display additional information, such as filenames + processed, when the modifier `v' is appended. + +`V' + This modifier shows the version number of `ar'. + + +File: binutils.info, Node: ar scripts, Prev: ar cmdline, Up: ar + +Controlling `ar' with a script +============================== + + ar -M [ <SCRIPT ] + + If you use the single command-line option `-M' with `ar', you can +control its operation with a rudimentary command language. This form +of `ar' operates interactively if standard input is coming directly +from a terminal. During interactive use, `ar' prompts for input (the +prompt is `AR >'), and continues executing even after errors. If you +redirect standard input to a script file, no prompts are issued, and +`ar' abandons execution (with a nonzero exit code) on any error. + + The `ar' command language is _not_ designed to be equivalent to the +command-line options; in fact, it provides somewhat less control over +archives. The only purpose of the command language is to ease the +transition to GNU `ar' for developers who already have scripts written +for the MRI "librarian" program. + + The syntax for the `ar' command language is straightforward: + * commands are recognized in upper or lower case; for example, `LIST' + is the same as `list'. In the following descriptions, commands are + shown in upper case for clarity. + + * a single command may appear on each line; it is the first word on + the line. + + * empty lines are allowed, and have no effect. + + * comments are allowed; text after either of the characters `*' or + `;' is ignored. + + * Whenever you use a list of names as part of the argument to an `ar' + command, you can separate the individual names with either commas + or blanks. Commas are shown in the explanations below, for + clarity. + + * `+' is used as a line continuation character; if `+' appears at + the end of a line, the text on the following line is considered + part of the current command. + + Here are the commands you can use in `ar' scripts, or when using +`ar' interactively. Three of them have special significance: + + `OPEN' or `CREATE' specify a "current archive", which is a temporary +file required for most of the other commands. + + `SAVE' commits the changes so far specified by the script. Prior to +`SAVE', commands affect only the temporary copy of the current archive. + +`ADDLIB ARCHIVE' +`ADDLIB ARCHIVE (MODULE, MODULE, ... MODULE)' + Add all the contents of ARCHIVE (or, if specified, each named + MODULE from ARCHIVE) to the current archive. + + Requires prior use of `OPEN' or `CREATE'. + +`ADDMOD MEMBER, MEMBER, ... MEMBER' + Add each named MEMBER as a module in the current archive. + + Requires prior use of `OPEN' or `CREATE'. + +`CLEAR' + Discard the contents of the current archive, canceling the effect + of any operations since the last `SAVE'. May be executed (with no + effect) even if no current archive is specified. + +`CREATE ARCHIVE' + Creates an archive, and makes it the current archive (required for + many other commands). The new archive is created with a temporary + name; it is not actually saved as ARCHIVE until you use `SAVE'. + You can overwrite existing archives; similarly, the contents of any + existing file named ARCHIVE will not be destroyed until `SAVE'. + +`DELETE MODULE, MODULE, ... MODULE' + Delete each listed MODULE from the current archive; equivalent to + `ar -d ARCHIVE MODULE ... MODULE'. + + Requires prior use of `OPEN' or `CREATE'. + +`DIRECTORY ARCHIVE (MODULE, ... MODULE)' +`DIRECTORY ARCHIVE (MODULE, ... MODULE) OUTPUTFILE' + List each named MODULE present in ARCHIVE. The separate command + `VERBOSE' specifies the form of the output: when verbose output is + off, output is like that of `ar -t ARCHIVE MODULE...'. When + verbose output is on, the listing is like `ar -tv ARCHIVE + MODULE...'. + + Output normally goes to the standard output stream; however, if you + specify OUTPUTFILE as a final argument, `ar' directs the output to + that file. + +`END' + Exit from `ar', with a `0' exit code to indicate successful + completion. This command does not save the output file; if you + have changed the current archive since the last `SAVE' command, + those changes are lost. + +`EXTRACT MODULE, MODULE, ... MODULE' + Extract each named MODULE from the current archive, writing them + into the current directory as separate files. Equivalent to `ar -x + ARCHIVE MODULE...'. + + Requires prior use of `OPEN' or `CREATE'. + +`LIST' + Display full contents of the current archive, in "verbose" style + regardless of the state of `VERBOSE'. The effect is like `ar tv + ARCHIVE'. (This single command is a GNU `ar' enhancement, rather + than present for MRI compatibility.) + + Requires prior use of `OPEN' or `CREATE'. + +`OPEN ARCHIVE' + Opens an existing archive for use as the current archive (required + for many other commands). Any changes as the result of subsequent + commands will not actually affect ARCHIVE until you next use + `SAVE'. + +`REPLACE MODULE, MODULE, ... MODULE' + In the current archive, replace each existing MODULE (named in the + `REPLACE' arguments) from files in the current working directory. + To execute this command without errors, both the file, and the + module in the current archive, must exist. + + Requires prior use of `OPEN' or `CREATE'. + +`VERBOSE' + Toggle an internal flag governing the output from `DIRECTORY'. + When the flag is on, `DIRECTORY' output matches output from `ar + -tv '.... + +`SAVE' + Commit your changes to the current archive, and actually save it + as a file with the name specified in the last `CREATE' or `OPEN' + command. + + Requires prior use of `OPEN' or `CREATE'. + + +File: binutils.info, Node: nm, Next: objcopy, Prev: ar, Up: Top + +nm +** + + nm [ -a | --debug-syms ] [ -g | --extern-only ] + [ -B ] [ -C | --demangle ] [ -D | --dynamic ] + [ -s | --print-armap ] [ -A | -o | --print-file-name ] + [ -n | -v | --numeric-sort ] [ -p | --no-sort ] + [ -r | --reverse-sort ] [ --size-sort ] [ -u | --undefined-only ] + [ -t RADIX | --radix=RADIX ] [ -P | --portability ] + [ --target=BFDNAME ] [ -f FORMAT | --format=FORMAT ] + [ --defined-only ] [-l | --line-numbers ] + [ --no-demangle ] [ -V | --version ] [ --help ] [ OBJFILE... ] + + GNU `nm' lists the symbols from object files OBJFILE.... If no +object files are listed as arguments, `nm' assumes the file `a.out'. + + For each symbol, `nm' shows: + + * The symbol value, in the radix selected by options (see below), or + hexadecimal by default. + + * The symbol type. At least the following types are used; others + are, as well, depending on the object file format. If lowercase, + the symbol is local; if uppercase, the symbol is global (external). + + `A' + The symbol's value is absolute, and will not be changed by + further linking. + + `B' + The symbol is in the uninitialized data section (known as + BSS). + + `C' + The symbol is common. Common symbols are uninitialized data. + When linking, multiple common symbols may appear with the + same name. If the symbol is defined anywhere, the common + symbols are treated as undefined references. For more + details on common symbols, see the discussion of -warn-common + in *Note Linker options: (ld.info)Options. + + `D' + The symbol is in the initialized data section. + + `G' + The symbol is in an initialized data section for small + objects. Some object file formats permit more efficient + access to small data objects, such as a global int variable + as opposed to a large global array. + + `I' + The symbol is an indirect reference to another symbol. This + is a GNU extension to the a.out object file format which is + rarely used. + + `N' + The symbol is a debugging symbol. + + `R' + The symbol is in a read only data section. + + `S' + The symbol is in an uninitialized data section for small + objects. + + `T' + The symbol is in the text (code) section. + + `U' + The symbol is undefined. + + `V' + The symbol is a weak object. When a weak defined symbol is + linked with a normal defined symbol, the normal defined + symbol is used with no error. When a weak undefined symbol + is linked and the symbol is not defined, the value of the + weak symbol becomes zero with no error. + + `W' + The symbol is a weak symbol that has not been specifically + tagged as a weak object symbol. When a weak defined symbol + is linked with a normal defined symbol, the normal defined + symbol is used with no error. When a weak undefined symbol + is linked and the symbol is not defined, the value of the + weak symbol becomes zero with no error. + + `-' + The symbol is a stabs symbol in an a.out object file. In + this case, the next values printed are the stabs other field, + the stabs desc field, and the stab type. Stabs symbols are + used to hold debugging information; for more information, see + *Note Stabs: (stabs.info)Top. + + `?' + The symbol type is unknown, or object file format specific. + + * The symbol name. + + The long and short forms of options, shown here as alternatives, are +equivalent. + +`-A' +`-o' +`--print-file-name' + Precede each symbol by the name of the input file (or archive + member) in which it was found, rather than identifying the input + file once only, before all of its symbols. + +`-a' +`--debug-syms' + Display all symbols, even debugger-only symbols; normally these + are not listed. + +`-B' + The same as `--format=bsd' (for compatibility with the MIPS `nm'). + +`-C' +`--demangle' + Decode ("demangle") low-level symbol names into user-level names. + Besides removing any initial underscore prepended by the system, + this makes C++ function names readable. *Note c++filt::, for more + information on demangling. + +`--no-demangle' + Do not demangle low-level symbol names. This is the default. + +`-D' +`--dynamic' + Display the dynamic symbols rather than the normal symbols. This + is only meaningful for dynamic objects, such as certain types of + shared libraries. + +`-f FORMAT' +`--format=FORMAT' + Use the output format FORMAT, which can be `bsd', `sysv', or + `posix'. The default is `bsd'. Only the first character of + FORMAT is significant; it can be either upper or lower case. + +`-g' +`--extern-only' + Display only external symbols. + +`-l' +`--line-numbers' + For each symbol, use debugging information to try to find a + filename and line number. For a defined symbol, look for the line + number of the address of the symbol. For an undefined symbol, + look for the line number of a relocation entry which refers to the + symbol. If line number information can be found, print it after + the other symbol information. + +`-n' +`-v' +`--numeric-sort' + Sort symbols numerically by their addresses, rather than + alphabetically by their names. + +`-p' +`--no-sort' + Do not bother to sort the symbols in any order; print them in the + order encountered. + +`-P' +`--portability' + Use the POSIX.2 standard output format instead of the default + format. Equivalent to `-f posix'. + +`-s' +`--print-armap' + When listing symbols from archive members, include the index: a + mapping (stored in the archive by `ar' or `ranlib') of which + modules contain definitions for which names. + +`-r' +`--reverse-sort' + Reverse the order of the sort (whether numeric or alphabetic); let + the last come first. + +`--size-sort' + Sort symbols by size. The size is computed as the difference + between the value of the symbol and the value of the symbol with + the next higher value. The size of the symbol is printed, rather + than the value. + +`-t RADIX' +`--radix=RADIX' + Use RADIX as the radix for printing the symbol values. It must be + `d' for decimal, `o' for octal, or `x' for hexadecimal. + +`--target=BFDNAME' + Specify an object code format other than your system's default + format. *Note Target Selection::, for more information. + +`-u' +`--undefined-only' + Display only undefined symbols (those external to each object + file). + +`--defined-only' + Display only defined symbols for each object file. + +`-V' +`--version' + Show the version number of `nm' and exit. + +`--help' + Show a summary of the options to `nm' and exit. + + +File: binutils.info, Node: objcopy, Next: objdump, Prev: nm, Up: Top + +objcopy +******* + + objcopy [ -F BFDNAME | --target=BFDNAME ] + [ -I BFDNAME | --input-target=BFDNAME ] + [ -O BFDNAME | --output-target=BFDNAME ] + [ -S | --strip-all ] [ -g | --strip-debug ] + [ -K SYMBOLNAME | --keep-symbol=SYMBOLNAME ] + [ -N SYMBOLNAME | --strip-symbol=SYMBOLNAME ] + [ -L SYMBOLNAME | --localize-symbol=SYMBOLNAME ] + [ -W SYMBOLNAME | --weaken-symbol=SYMBOLNAME ] + [ -x | --discard-all ] [ -X | --discard-locals ] + [ -b BYTE | --byte=BYTE ] + [ -i INTERLEAVE | --interleave=INTERLEAVE ] + [ -j SECTIONNAME | --only-section=SECTIONNAME ] + [ -R SECTIONNAME | --remove-section=SECTIONNAME ] + [ -p | --preserve-dates ] [ --debugging ] + [ --gap-fill=VAL ] [ --pad-to=ADDRESS ] + [ --set-start=VAL ] [ --adjust-start=INCR ] + [ --change-addresses=INCR ] + [ --change-section-address SECTION{=,+,-}VAL ] + [ --change-section-lma SECTION{=,+,-}VAL ] + [ --change-section-vma SECTION{=,+,-}VAL ] + [ --change-warnings ] [ --no-change-warnings ] + [ --set-section-flags SECTION=FLAGS ] + [ --add-section SECTIONNAME=FILENAME ] + [ --change-leading-char ] [ --remove-leading-char ] + [ --redefine-sym OLD=NEW ] [ --weaken ] + [ -v | --verbose ] [ -V | --version ] [ --help ] + INFILE [OUTFILE] + + The GNU `objcopy' utility copies the contents of an object file to +another. `objcopy' uses the GNU BFD Library to read and write the +object files. It can write the destination object file in a format +different from that of the source object file. The exact behavior of +`objcopy' is controlled by command-line options. + + `objcopy' creates temporary files to do its translations and deletes +them afterward. `objcopy' uses BFD to do all its translation work; it +has access to all the formats described in BFD and thus is able to +recognize most formats without being told explicitly. *Note BFD: +(ld.info)BFD. + + `objcopy' can be used to generate S-records by using an output +target of `srec' (e.g., use `-O srec'). + + `objcopy' can be used to generate a raw binary file by using an +output target of `binary' (e.g., use `-O binary'). When `objcopy' +generates a raw binary file, it will essentially produce a memory dump +of the contents of the input object file. All symbols and relocation +information will be discarded. The memory dump will start at the load +address of the lowest section copied into the output file. + + When generating an S-record or a raw binary file, it may be helpful +to use `-S' to remove sections containing debugging information. In +some cases `-R' will be useful to remove sections which contain +information that is not needed by the binary file. + +`INFILE' +`OUTFILE' + The input and output files, respectively. If you do not specify + OUTFILE, `objcopy' creates a temporary file and destructively + renames the result with the name of INFILE. + +`-I BFDNAME' +`--input-target=BFDNAME' + Consider the source file's object format to be BFDNAME, rather than + attempting to deduce it. *Note Target Selection::, for more + information. + +`-O BFDNAME' +`--output-target=BFDNAME' + Write the output file using the object format BFDNAME. *Note + Target Selection::, for more information. + +`-F BFDNAME' +`--target=BFDNAME' + Use BFDNAME as the object format for both the input and the output + file; i.e., simply transfer data from source to destination with no + translation. *Note Target Selection::, for more information. + +`-j SECTIONNAME' +`--only-section=SECTIONNAME' + Copy only the named section from the input file to the output file. + This option may be given more than once. Note that using this + option inappropriately may make the output file unusable. + +`-R SECTIONNAME' +`--remove-section=SECTIONNAME' + Remove any section named SECTIONNAME from the output file. This + option may be given more than once. Note that using this option + inappropriately may make the output file unusable. + +`-S' +`--strip-all' + Do not copy relocation and symbol information from the source file. + +`-g' +`--strip-debug' + Do not copy debugging symbols from the source file. + +`--strip-unneeded' + Strip all symbols that are not needed for relocation processing. + +`-K SYMBOLNAME' +`--keep-symbol=SYMBOLNAME' + Copy only symbol SYMBOLNAME from the source file. This option may + be given more than once. + +`-N SYMBOLNAME' +`--strip-symbol=SYMBOLNAME' + Do not copy symbol SYMBOLNAME from the source file. This option + may be given more than once. + +`-L SYMBOLNAME' +`--localize-symbol=SYMBOLNAME' + Make symbol SYMBOLNAME local to the file, so that it is not + visible externally. This option may be given more than once. + +`-W SYMBOLNAME' +`--weaken-symbol=SYMBOLNAME' + Make symbol SYMBOLNAME weak. This option may be given more than + once. + +`-x' +`--discard-all' + Do not copy non-global symbols from the source file. + +`-X' +`--discard-locals' + Do not copy compiler-generated local symbols. (These usually + start with `L' or `.'.) + +`-b BYTE' +`--byte=BYTE' + Keep only every BYTEth byte of the input file (header data is not + affected). BYTE can be in the range from 0 to INTERLEAVE-1, where + INTERLEAVE is given by the `-i' or `--interleave' option, or the + default of 4. This option is useful for creating files to program + ROM. It is typically used with an `srec' output target. + +`-i INTERLEAVE' +`--interleave=INTERLEAVE' + Only copy one out of every INTERLEAVE bytes. Select which byte to + copy with the -B or `--byte' option. The default is 4. `objcopy' + ignores this option if you do not specify either `-b' or `--byte'. + +`-p' +`--preserve-dates' + Set the access and modification dates of the output file to be the + same as those of the input file. + +`--debugging' + Convert debugging information, if possible. This is not the + default because only certain debugging formats are supported, and + the conversion process can be time consuming. + +`--gap-fill VAL' + Fill gaps between sections with VAL. This operation applies to + the _load address_ (LMA) of the sections. It is done by increasing + the size of the section with the lower address, and filling in the + extra space created with VAL. + +`--pad-to ADDRESS' + Pad the output file up to the load address ADDRESS. This is done + by increasing the size of the last section. The extra space is + filled in with the value specified by `--gap-fill' (default zero). + +`--set-start VAL' + Set the start address of the new file to VAL. Not all object file + formats support setting the start address. + +`--change-start INCR' +`--adjust-start INCR' + Change the start address by adding INCR. Not all object file + formats support setting the start address. + +`--change-addresses INCR' +`--adjust-vma INCR' + Change the VMA and LMA addresses of all sections, as well as the + start address, by adding INCR. Some object file formats do not + permit section addresses to be changed arbitrarily. Note that + this does not relocate the sections; if the program expects + sections to be loaded at a certain address, and this option is + used to change the sections such that they are loaded at a + different address, the program may fail. + +`--change-section-address SECTION{=,+,-}VAL' +`--adjust-section-vma SECTION{=,+,-}VAL' + Set or change both the VMA address and the LMA address of the named + SECTION. If `=' is used, the section address is set to VAL. + Otherwise, VAL is added to or subtracted from the section address. + See the comments under `--change-addresses', above. If SECTION + does not exist in the input file, a warning will be issued, unless + `--no-change-warnings' is used. + +`--change-section-lma SECTION{=,+,-}VAL' + Set or change the LMA address of the named SECTION. The LMA + address is the address where the section will be loaded into + memory at program load time. Normally this is the same as the VMA + address, which is the address of the section at program run time, + but on some systems, especially those where a program is held in + ROM, the two can be different. If `=' is used, the section + address is set to VAL. Otherwise, VAL is added to or subtracted + from the section address. See the comments under + `--change-addresses', above. If SECTION does not exist in the + input file, a warning will be issued, unless + `--no-change-warnings' is used. + +`--change-section-vma SECTION{=,+,-}VAL' + Set or change the VMA address of the named SECTION. The VMA + address is the address where the section will be located once the + program has started executing. Normally this is the same as the + LMA address, which is the address where the section will be loaded + into memory, but on some systems, especially those where a program + is held in ROM, the two can be different. If `=' is used, the + section address is set to VAL. Otherwise, VAL is added to or + subtracted from the section address. See the comments under + `--change-addresses', above. If SECTION does not exist in the + input file, a warning will be issued, unless + `--no-change-warnings' is used. + +`--change-warnings' +`--adjust-warnings' + If `--change-section-address' or `--change-section-lma' or + `--change-section-vma' is used, and the named section does not + exist, issue a warning. This is the default. + +`--no-change-warnings' +`--no-adjust-warnings' + Do not issue a warning if `--change-section-address' or + `--adjust-section-lma' or `--adjust-section-vma' is used, even if + the named section does not exist. + +`--set-section-flags SECTION=FLAGS' + Set the flags for the named section. The FLAGS argument is a + comma separated string of flag names. The recognized names are + `alloc', `contents', `load', `noload', `readonly', `code', `data', + `rom', `share', and `debug'. You can set the `contents' flag for + a section which does not have contents, but it is not meaningful + to clear the `contents' flag of a section which does have + contents-just remove the section instead. Not all flags are + meaningful for all object file formats. + +`--add-section SECTIONNAME=FILENAME' + Add a new section named SECTIONNAME while copying the file. The + contents of the new section are taken from the file FILENAME. The + size of the section will be the size of the file. This option only + works on file formats which can support sections with arbitrary + names. + +`--change-leading-char' + Some object file formats use special characters at the start of + symbols. The most common such character is underscore, which + compilers often add before every symbol. This option tells + `objcopy' to change the leading character of every symbol when it + converts between object file formats. If the object file formats + use the same leading character, this option has no effect. + Otherwise, it will add a character, or remove a character, or + change a character, as appropriate. + +`--remove-leading-char' + If the first character of a global symbol is a special symbol + leading character used by the object file format, remove the + character. The most common symbol leading character is + underscore. This option will remove a leading underscore from all + global symbols. This can be useful if you want to link together + objects of different file formats with different conventions for + symbol names. This is different from `--change-leading-char' + because it always changes the symbol name when appropriate, + regardless of the object file format of the output file. + +`--redefine-sym OLD=NEW' + Change the name of a symbol OLD, to NEW. This can be useful when + one is trying link two things together for which you have no + source, and there are name collisions. + +`--weaken' + Change all global symbols in the file to be weak. This can be + useful when building an object which will be linked against other + objects using the `-R' option to the linker. This option is only + effective when using an object file format which supports weak + symbols. + +`-V' +`--version' + Show the version number of `objcopy'. + +`-v' +`--verbose' + Verbose output: list all object files modified. In the case of + archives, `objcopy -V' lists all members of the archive. + +`--help' + Show a summary of the options to `objcopy'. + + +File: binutils.info, Node: objdump, Next: ranlib, Prev: objcopy, Up: Top + +objdump +******* + + objdump [ -a | --archive-headers ] + [ -b BFDNAME | --target=BFDNAME ] + [ -C | --demangle ] + [ -d | --disassemble ] + [ -D | --disassemble-all ] + [ -z | --disassemble-zeroes ] + [ -EB | -EL | --endian={big | little } ] + [ -f | --file-headers ] + [ --file-start-context ] + [ -g | --debugging ] + [ -h | --section-headers | --headers ] + [ -i | --info ] + [ -j SECTION | --section=SECTION ] + [ -l | --line-numbers ] + [ -S | --source ] + [ -m MACHINE | --architecture=MACHINE ] + [ -M OPTIONS | --disassembler-options=OPTIONS] + [ -p | --private-headers ] + [ -r | --reloc ] + [ -R | --dynamic-reloc ] + [ -s | --full-contents ] + [ -G | --stabs ] + [ -t | --syms ] + [ -T | --dynamic-syms ] + [ -x | --all-headers ] + [ -w | --wide ] + [ --start-address=ADDRESS ] + [ --stop-address=ADDRESS ] + [ --prefix-addresses] + [ --[no-]show-raw-insn ] + [ --adjust-vma=OFFSET ] + [ -V | --version ] + [ -H | --help ] + OBJFILE... + + `objdump' displays information about one or more object files. The +options control what particular information to display. This +information is mostly useful to programmers who are working on the +compilation tools, as opposed to programmers who just want their +program to compile and work. + + OBJFILE... are the object files to be examined. When you specify +archives, `objdump' shows information on each of the member object +files. + + The long and short forms of options, shown here as alternatives, are +equivalent. At least one option from the list +`-a,-d,-D,-f,-g,-G,-h,-H,-p,-r,-R,-S,-t,-T,-V,-x' must be given. + +`-a' +`--archive-header' + If any of the OBJFILE files are archives, display the archive + header information (in a format similar to `ls -l'). Besides the + information you could list with `ar tv', `objdump -a' shows the + object file format of each archive member. + +`--adjust-vma=OFFSET' + When dumping information, first add OFFSET to all the section + addresses. This is useful if the section addresses do not + correspond to the symbol table, which can happen when putting + sections at particular addresses when using a format which can not + represent section addresses, such as a.out. + +`-b BFDNAME' +`--target=BFDNAME' + Specify that the object-code format for the object files is + BFDNAME. This option may not be necessary; OBJDUMP can + automatically recognize many formats. + + For example, + objdump -b oasys -m vax -h fu.o + + displays summary information from the section headers (`-h') of + `fu.o', which is explicitly identified (`-m') as a VAX object file + in the format produced by Oasys compilers. You can list the + formats available with the `-i' option. *Note Target Selection::, + for more information. + +`-C' +`--demangle' + Decode ("demangle") low-level symbol names into user-level names. + Besides removing any initial underscore prepended by the system, + this makes C++ function names readable. *Note c++filt::, for more + information on demangling. + +`-G' + +`--debugging' + Display debugging information. This attempts to parse debugging + information stored in the file and print it out using a C like + syntax. Only certain types of debugging information have been + implemented. + +`-d' +`--disassemble' + Display the assembler mnemonics for the machine instructions from + OBJFILE. This option only disassembles those sections which are + expected to contain instructions. + +`-D' +`--disassemble-all' + Like `-d', but disassemble the contents of all sections, not just + those expected to contain instructions. + +`--prefix-addresses' + When disassembling, print the complete address on each line. This + is the older disassembly format. + +`--disassemble-zeroes' + Normally the disassembly output will skip blocks of zeroes. This + option directs the disassembler to disassemble those blocks, just + like any other data. + +`-EB' +`-EL' +`--endian={big|little}' + Specify the endianness of the object files. This only affects + disassembly. This can be useful when disassembling a file format + which does not describe endianness information, such as S-records. + +`-f' +`--file-header' + Display summary information from the overall header of each of the + OBJFILE files. + +`--file-start-context' + Specify that when displaying interlisted source code/disassembly + (assumes '-S') from a file that has not yet been displayed, extend + the context to the start of the file. + +`-h' +`--section-header' +`--header' + Display summary information from the section headers of the object + file. + + File segments may be relocated to nonstandard addresses, for + example by using the `-Ttext', `-Tdata', or `-Tbss' options to + `ld'. However, some object file formats, such as a.out, do not + store the starting address of the file segments. In those + situations, although `ld' relocates the sections correctly, using + `objdump -h' to list the file section headers cannot show the + correct addresses. Instead, it shows the usual addresses, which + are implicit for the target. + +`--help' + Print a summary of the options to `objdump' and exit. + +`-i' +`--info' + Display a list showing all architectures and object formats + available for specification with `-b' or `-m'. + +`-j NAME' +`--section=NAME' + Display information only for section NAME. + +`-l' +`--line-numbers' + Label the display (using debugging information) with the filename + and source line numbers corresponding to the object code or relocs + shown. Only useful with `-d', `-D', or `-r'. + +`-m MACHINE' +`--architecture=MACHINE' + Specify the architecture to use when disassembling object files. + This can be useful when disassembling object files which do not + describe architecture information, such as S-records. You can + list the available architectures with the `-i' option. + +`-M OPTIONS' +`--disassembler-options=OPTIONS' + Pass target specific information to the disassembler. Only + supported on some targets. + + If the target is an ARM architecture then this switch can be used + to select which register name set is used during disassembler. + Specifying `-M reg-name-std' (the default) will select the + register names as used in ARM's instruction set documentation, but + with register 13 called 'sp', register 14 called 'lr' and register + 15 called 'pc'. Specifying `-M reg-names-apcs' will select the + name set used by the ARM Procedure Call Standard, whilst + specifying `-M reg-names-raw' will just use `r' followed by the + register number. + + There are also two variants on the APCS register naming scheme + enabled by `-M reg-names-atpcs' and `-M reg-names-special-atpcs' + which use the ARM/Thumb Procedure Call Standard naming + conventions. (Eiuther with the normal register name sor the + special register names). + + This option can also be used for ARM architectures to force the + disassembler to interpret all instructions as THUMB instructions by + using the switch `--disassembler-options=force-thumb'. This can be + useful when attempting to disassemble thumb code produced by other + compilers. + +`-p' +`--private-headers' + Print information that is specific to the object file format. The + exact information printed depends upon the object file format. + For some object file formats, no additional information is printed. + +`-r' +`--reloc' + Print the relocation entries of the file. If used with `-d' or + `-D', the relocations are printed interspersed with the + disassembly. + +`-R' +`--dynamic-reloc' + Print the dynamic relocation entries of the file. This is only + meaningful for dynamic objects, such as certain types of shared + libraries. + +`-s' +`--full-contents' + Display the full contents of any sections requested. + +`-S' +`--source' + Display source code intermixed with disassembly, if possible. + Implies `-d'. + +`--show-raw-insn' + When disassembling instructions, print the instruction in hex as + well as in symbolic form. This is the default except when + `--prefix-addresses' is used. + +`--no-show-raw-insn' + When disassembling instructions, do not print the instruction + bytes. This is the default when `--prefix-addresses' is used. + +`-G' + +`--stabs' + Display the full contents of any sections requested. Display the + contents of the .stab and .stab.index and .stab.excl sections from + an ELF file. This is only useful on systems (such as Solaris 2.0) + in which `.stab' debugging symbol-table entries are carried in an + ELF section. In most other file formats, debugging symbol-table + entries are interleaved with linkage symbols, and are visible in + the `--syms' output. For more information on stabs symbols, see + *Note Stabs: (stabs.info)Top. + +`--start-address=ADDRESS' + Start displaying data at the specified address. This affects the + output of the `-d', `-r' and `-s' options. + +`--stop-address=ADDRESS' + Stop displaying data at the specified address. This affects the + output of the `-d', `-r' and `-s' options. + +`-t' +`--syms' + Print the symbol table entries of the file. This is similar to + the information provided by the `nm' program. + +`-T' +`--dynamic-syms' + Print the dynamic symbol table entries of the file. This is only + meaningful for dynamic objects, such as certain types of shared + libraries. This is similar to the information provided by the `nm' + program when given the `-D' (`--dynamic') option. + +`--version' + Print the version number of `objdump' and exit. + +`-x' +`--all-header' + Display all available header information, including the symbol + table and relocation entries. Using `-x' is equivalent to + specifying all of `-a -f -h -r -t'. + +`-w' +`--wide' + Format some lines for output devices that have more than 80 + columns. + + +File: binutils.info, Node: ranlib, Next: readelf, Prev: objdump, Up: Top + +ranlib +****** + + ranlib [-vV] ARCHIVE + + `ranlib' generates an index to the contents of an archive and stores +it in the archive. The index lists each symbol defined by a member of +an archive that is a relocatable object file. + + You may use `nm -s' or `nm --print-armap' to list this index. + + An archive with such an index speeds up linking to the library and +allows routines in the library to call each other without regard to +their placement in the archive. + + The GNU `ranlib' program is another form of GNU `ar'; running +`ranlib' is completely equivalent to executing `ar -s'. *Note ar::. + +`-v' +`-V' +`--version' + Show the version number of `ranlib'. + diff --git a/binutils/binutils.info-2 b/binutils/binutils.info-2 new file mode 100644 index 00000000000..def5a0d3264 --- /dev/null +++ b/binutils/binutils.info-2 @@ -0,0 +1,1404 @@ +This is binutils.info, produced by makeinfo version 4.0 from +binutils.texi. + +START-INFO-DIR-ENTRY +* Binutils: (binutils). The GNU binary utilities. +* ar: (binutils)ar. Create, modify, and extract from archives +* nm: (binutils)nm. List symbols from object files +* objcopy: (binutils)objcopy. Copy and translate object files +* objdump: (binutils)objdump. Display information from object files +* ranlib: (binutils)ranlib. Generate index to archive contents +* readelf: (binutils)readelf. Display the contents of ELF format files. +* size: (binutils)size. List section sizes and total size +* strings: (binutils)strings. List printable strings from files +* strip: (binutils)strip. Discard symbols +* c++filt: (binutils)c++filt. Filter to demangle encoded C++ symbols +* cxxfilt: (binutils)c++filt. MS-DOS name for c++filt +* addr2line: (binutils)addr2line. Convert addresses to file and line +* nlmconv: (binutils)nlmconv. Converts object code into an NLM +* windres: (binutils)windres. Manipulate Windows resources +* dlltool: (binutils)dlltool. Create files needed to build and use DLLs +END-INFO-DIR-ENTRY + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: binutils.info, Node: size, Next: strings, Prev: readelf, Up: Top + +size +**** + + size [ -A | -B | --format=COMPATIBILITY ] + [ --help ] [ -d | -o | -x | --radix=NUMBER ] + [ --target=BFDNAME ] [ -V | --version ] + [ OBJFILE... ] + + The GNU `size' utility lists the section sizes--and the total +size--for each of the object or archive files OBJFILE in its argument +list. By default, one line of output is generated for each object file +or each module in an archive. + + OBJFILE... are the object files to be examined. If none are +specified, the file `a.out' will be used. + + The command line options have the following meanings: + +`-A' +`-B' +`--format=COMPATIBILITY' + Using one of these options, you can choose whether the output from + GNU `size' resembles output from System V `size' (using `-A', or + `--format=sysv'), or Berkeley `size' (using `-B', or + `--format=berkeley'). The default is the one-line format similar + to Berkeley's. + + Here is an example of the Berkeley (default) format of output from + `size': + $ size --format=Berkeley ranlib size + text data bss dec hex filename + 294880 81920 11592 388392 5ed28 ranlib + 294880 81920 11888 388688 5ee50 size + + This is the same data, but displayed closer to System V + conventions: + + $ size --format=SysV ranlib size + ranlib : + section size addr + .text 294880 8192 + .data 81920 303104 + .bss 11592 385024 + Total 388392 + + + size : + section size addr + .text 294880 8192 + .data 81920 303104 + .bss 11888 385024 + Total 388688 + +`--help' + Show a summary of acceptable arguments and options. + +`-d' +`-o' +`-x' +`--radix=NUMBER' + Using one of these options, you can control whether the size of + each section is given in decimal (`-d', or `--radix=10'); octal + (`-o', or `--radix=8'); or hexadecimal (`-x', or `--radix=16'). + In `--radix=NUMBER', only the three values (8, 10, 16) are + supported. The total size is always given in two radices; decimal + and hexadecimal for `-d' or `-x' output, or octal and hexadecimal + if you're using `-o'. + +`--target=BFDNAME' + Specify that the object-code format for OBJFILE is BFDNAME. This + option may not be necessary; `size' can automatically recognize + many formats. *Note Target Selection::, for more information. + +`-V' +`--version' + Display the version number of `size'. + + +File: binutils.info, Node: strings, Next: strip, Prev: size, Up: Top + +strings +******* + + strings [-afov] [-MIN-LEN] [-n MIN-LEN] [-t RADIX] [-] + [--all] [--print-file-name] [--bytes=MIN-LEN] + [--radix=RADIX] [--target=BFDNAME] + [--help] [--version] FILE... + + For each FILE given, GNU `strings' prints the printable character +sequences that are at least 4 characters long (or the number given with +the options below) and are followed by an unprintable character. By +default, it only prints the strings from the initialized and loaded +sections of object files; for other types of files, it prints the +strings from the whole file. + + `strings' is mainly useful for determining the contents of non-text +files. + +`-a' +`--all' +`-' + Do not scan only the initialized and loaded sections of object + files; scan the whole files. + +`-f' +`--print-file-name' + Print the name of the file before each string. + +`--help' + Print a summary of the program usage on the standard output and + exit. + +`-MIN-LEN' +`-n MIN-LEN' +`--bytes=MIN-LEN' + Print sequences of characters that are at least MIN-LEN characters + long, instead of the default 4. + +`-o' + Like `-t o'. Some other versions of `strings' have `-o' act like + `-t d' instead. Since we can not be compatible with both ways, we + simply chose one. + +`-t RADIX' +`--radix=RADIX' + Print the offset within the file before each string. The single + character argument specifies the radix of the offset--`o' for + octal, `x' for hexadecimal, or `d' for decimal. + +`--target=BFDNAME' + Specify an object code format other than your system's default + format. *Note Target Selection::, for more information. + +`-v' +`--version' + Print the program version number on the standard output and exit. + + +File: binutils.info, Node: strip, Next: c++filt, Prev: strings, Up: Top + +strip +***** + + strip [ -F BFDNAME | --target=BFDNAME ] + [ -I BFDNAME | --input-target=BFDNAME ] + [ -O BFDNAME | --output-target=BFDNAME ] + [ -s | --strip-all ] [ -S | -g | --strip-debug ] + [ -K SYMBOLNAME | --keep-symbol=SYMBOLNAME ] + [ -N SYMBOLNAME | --strip-symbol=SYMBOLNAME ] + [ -x | --discard-all ] [ -X | --discard-locals ] + [ -R SECTIONNAME | --remove-section=SECTIONNAME ] + [ -o FILE ] [ -p | --preserve-dates ] + [ -v | --verbose ] [ -V | --version ] [ --help ] + OBJFILE... + + GNU `strip' discards all symbols from object files OBJFILE. The +list of object files may include archives. At least one object file +must be given. + + `strip' modifies the files named in its argument, rather than +writing modified copies under different names. + +`-F BFDNAME' +`--target=BFDNAME' + Treat the original OBJFILE as a file with the object code format + BFDNAME, and rewrite it in the same format. *Note Target + Selection::, for more information. + +`--help' + Show a summary of the options to `strip' and exit. + +`-I BFDNAME' +`--input-target=BFDNAME' + Treat the original OBJFILE as a file with the object code format + BFDNAME. *Note Target Selection::, for more information. + +`-O BFDNAME' +`--output-target=BFDNAME' + Replace OBJFILE with a file in the output format BFDNAME. *Note + Target Selection::, for more information. + +`-R SECTIONNAME' +`--remove-section=SECTIONNAME' + Remove any section named SECTIONNAME from the output file. This + option may be given more than once. Note that using this option + inappropriately may make the output file unusable. + +`-s' +`--strip-all' + Remove all symbols. + +`-g' +`-S' +`--strip-debug' + Remove debugging symbols only. + +`--strip-unneeded' + Remove all symbols that are not needed for relocation processing. + +`-K SYMBOLNAME' +`--keep-symbol=SYMBOLNAME' + Keep only symbol SYMBOLNAME from the source file. This option may + be given more than once. + +`-N SYMBOLNAME' +`--strip-symbol=SYMBOLNAME' + Remove symbol SYMBOLNAME from the source file. This option may be + given more than once, and may be combined with strip options other + than `-K'. + +`-o FILE' + Put the stripped output in FILE, rather than replacing the + existing file. When this argument is used, only one OBJFILE + argument may be specified. + +`-p' +`--preserve-dates' + Preserve the access and modification dates of the file. + +`-x' +`--discard-all' + Remove non-global symbols. + +`-X' +`--discard-locals' + Remove compiler-generated local symbols. (These usually start + with `L' or `.'.) + +`-V' +`--version' + Show the version number for `strip'. + +`-v' +`--verbose' + Verbose output: list all object files modified. In the case of + archives, `strip -v' lists all members of the archive. + + +File: binutils.info, Node: c++filt, Next: addr2line, Prev: strip, Up: Top + +c++filt +******* + + c++filt [ -_ | --strip-underscores ] + [ -j | --java ] + [ -n | --no-strip-underscores ] + [ -s FORMAT | --format=FORMAT ] + [ --help ] [ --version ] [ SYMBOL... ] + + The C++ and Java languages provides function overloading, which means +that you can write many functions with the same name (providing each +takes parameters of different types). All C++ and Java function names +are encoded into a low-level assembly label (this process is known as +"mangling"). The `c++filt' (1) program does the inverse mapping: it +decodes ("demangles") low-level names into user-level names so that the +linker can keep these overloaded functions from clashing. + + Every alphanumeric word (consisting of letters, digits, underscores, +dollars, or periods) seen in the input is a potential label. If the +label decodes into a C++ name, the C++ name replaces the low-level name +in the output. + + You can use `c++filt' to decipher individual symbols: + + c++filt SYMBOL + + If no SYMBOL arguments are given, `c++filt' reads symbol names from +the standard input and writes the demangled names to the standard +output. All results are printed on the standard output. + +`-_' +`--strip-underscores' + On some systems, both the C and C++ compilers put an underscore in + front of every name. For example, the C name `foo' gets the + low-level name `_foo'. This option removes the initial + underscore. Whether `c++filt' removes the underscore by default + is target dependent. + +`-j' +`--java' + Prints demangled names using Java syntax. The default is to use + C++ syntax. + +`-n' +`--no-strip-underscores' + Do not remove the initial underscore. + +`-s FORMAT' +`--format=FORMAT' + GNU `nm' can decode three different methods of mangling, used by + different C++ compilers. The argument to this option selects which + method it uses: + + `gnu' + the one used by the GNU compiler (the default method) + + `lucid' + the one used by the Lucid compiler + + `arm' + the one specified by the C++ Annotated Reference Manual + + `hp' + the one used by the HP compiler + + `edg' + the one used by the EDG compiler + +`--help' + Print a summary of the options to `c++filt' and exit. + +`--version' + Print the version number of `c++filt' and exit. + + _Warning:_ `c++filt' is a new utility, and the details of its user + interface are subject to change in future releases. In particular, + a command-line option may be required in the the future to decode + a name passed as an argument on the command line; in other words, + + c++filt SYMBOL + + may in a future release become + + c++filt OPTION SYMBOL + + ---------- Footnotes ---------- + + (1) MS-DOS does not allow `+' characters in file names, so on MS-DOS +this program is named `cxxfilt'. + + +File: binutils.info, Node: addr2line, Next: nlmconv, Prev: c++filt, Up: Top + +addr2line +********* + + addr2line [ -b BFDNAME | --target=BFDNAME ] + [ -C | --demangle ] + [ -e FILENAME | --exe=FILENAME ] + [ -f | --functions ] [ -s | --basename ] + [ -H | --help ] [ -V | --version ] + [ addr addr ... ] + + `addr2line' translates program addresses into file names and line +numbers. Given an address and an executable, it uses the debugging +information in the executable to figure out which file name and line +number are associated with a given address. + + The executable to use is specified with the `-e' option. The +default is the file `a.out'. + + `addr2line' has two modes of operation. + + In the first, hexadecimal addresses are specified on the command +line, and `addr2line' displays the file name and line number for each +address. + + In the second, `addr2line' reads hexadecimal addresses from standard +input, and prints the file name and line number for each address on +standard output. In this mode, `addr2line' may be used in a pipe to +convert dynamically chosen addresses. + + The format of the output is `FILENAME:LINENO'. The file name and +line number for each address is printed on a separate line. If the +`-f' option is used, then each `FILENAME:LINENO' line is preceded by a +`FUNCTIONNAME' line which is the name of the function containing the +address. + + If the file name or function name can not be determined, `addr2line' +will print two question marks in their place. If the line number can +not be determined, `addr2line' will print 0. + + The long and short forms of options, shown here as alternatives, are +equivalent. + +`-b BFDNAME' +`--target=BFDNAME' + Specify that the object-code format for the object files is + BFDNAME. + +`-C' +`--demangle' + Decode ("demangle") low-level symbol names into user-level names. + Besides removing any initial underscore prepended by the system, + this makes C++ function names readable. *Note c++filt::, for more + information on demangling. + +`-e FILENAME' +`--exe=FILENAME' + Specify the name of the executable for which addresses should be + translated. The default file is `a.out'. + +`-f' +`--functions' + Display function names as well as file and line number information. + +`-s' +`--basenames' + Display only the base of each file name. + + +File: binutils.info, Node: nlmconv, Next: windres, Prev: addr2line, Up: Top + +nlmconv +******* + + `nlmconv' converts a relocatable object file into a NetWare Loadable +Module. + + _Warning:_ `nlmconv' is not always built as part of the binary + utilities, since it is only useful for NLM targets. + + nlmconv [ -I BFDNAME | --input-target=BFDNAME ] + [ -O BFDNAME | --output-target=BFDNAME ] + [ -T HEADERFILE | --header-file=HEADERFILE ] + [ -d | --debug] [ -l LINKER | --linker=LINKER ] + [ -h | --help ] [ -V | --version ] + INFILE OUTFILE + + `nlmconv' converts the relocatable `i386' object file INFILE into +the NetWare Loadable Module OUTFILE, optionally reading HEADERFILE for +NLM header information. For instructions on writing the NLM command +file language used in header files, see the `linkers' section, +`NLMLINK' in particular, of the `NLM Development and Tools Overview', +which is part of the NLM Software Developer's Kit ("NLM SDK"), +available from Novell, Inc. `nlmconv' uses the GNU Binary File +Descriptor library to read INFILE; see *Note BFD: (ld.info)BFD, for +more information. + + `nlmconv' can perform a link step. In other words, you can list +more than one object file for input if you list them in the definitions +file (rather than simply specifying one input file on the command line). +In this case, `nlmconv' calls the linker for you. + +`-I BFDNAME' +`--input-target=BFDNAME' + Object format of the input file. `nlmconv' can usually determine + the format of a given file (so no default is necessary). *Note + Target Selection::, for more information. + +`-O BFDNAME' +`--output-target=BFDNAME' + Object format of the output file. `nlmconv' infers the output + format based on the input format, e.g. for a `i386' input file the + output format is `nlm32-i386'. *Note Target Selection::, for more + information. + +`-T HEADERFILE' +`--header-file=HEADERFILE' + Reads HEADERFILE for NLM header information. For instructions on + writing the NLM command file language used in header files, see + see the `linkers' section, of the `NLM Development and Tools + Overview', which is part of the NLM Software Developer's Kit, + available from Novell, Inc. + +`-d' +`--debug' + Displays (on standard error) the linker command line used by + `nlmconv'. + +`-l LINKER' +`--linker=LINKER' + Use LINKER for any linking. LINKER can be an absolute or a + relative pathname. + +`-h' +`--help' + Prints a usage summary. + +`-V' +`--version' + Prints the version number for `nlmconv'. + + +File: binutils.info, Node: windres, Next: dlltool, Prev: nlmconv, Up: Top + +windres +******* + + `windres' may be used to manipulate Windows resources. + + _Warning:_ `windres' is not always built as part of the binary + utilities, since it is only useful for Windows targets. + + windres [options] [input-file] [output-file] + + `windres' reads resources from an input file and copies them into an +output file. Either file may be in one of three formats: + +`rc' + A text format read by the Resource Compiler. + +`res' + A binary format generated by the Resource Compiler. + +`coff' + A COFF object or executable. + + The exact description of these different formats is available in +documentation from Microsoft. + + When `windres' converts from the `rc' format to the `res' format, it +is acting like the Windows Resource Compiler. When `windres' converts +from the `res' format to the `coff' format, it is acting like the +Windows `CVTRES' program. + + When `windres' generates an `rc' file, the output is similar but not +identical to the format expected for the input. When an input `rc' +file refers to an external filename, an output `rc' file will instead +include the file contents. + + If the input or output format is not specified, `windres' will guess +based on the file name, or, for the input file, the file contents. A +file with an extension of `.rc' will be treated as an `rc' file, a file +with an extension of `.res' will be treated as a `res' file, and a file +with an extension of `.o' or `.exe' will be treated as a `coff' file. + + If no output file is specified, `windres' will print the resources +in `rc' format to standard output. + + The normal use is for you to write an `rc' file, use `windres' to +convert it to a COFF object file, and then link the COFF file into your +application. This will make the resources described in the `rc' file +available to Windows. + +`-i FILENAME' +`--input FILENAME' + The name of the input file. If this option is not used, then + `windres' will use the first non-option argument as the input file + name. If there are no non-option arguments, then `windres' will + read from standard input. `windres' can not read a COFF file from + standard input. + +`-o FILENAME' +`--output FILENAME' + The name of the output file. If this option is not used, then + `windres' will use the first non-option argument, after any used + for the input file name, as the output file name. If there is no + non-option argument, then `windres' will write to standard output. + `windres' can not write a COFF file to standard output. + +`-I FORMAT' +`--input-format FORMAT' + The input format to read. FORMAT may be `res', `rc', or `coff'. + If no input format is specified, `windres' will guess, as + described above. + +`-O FORMAT' +`--output-format FORMAT' + The output format to generate. FORMAT may be `res', `rc', or + `coff'. If no output format is specified, `windres' will guess, + as described above. + +`-F TARGET' +`--target TARGET' + Specify the BFD format to use for a COFF file as input or output. + This is a BFD target name; you can use the `--help' option to see + a list of supported targets. Normally `windres' will use the + default format, which is the first one listed by the `--help' + option. *Note Target Selection::. + +`--preprocessor PROGRAM' + When `windres' reads an `rc' file, it runs it through the C + preprocessor first. This option may be used to specify the + preprocessor to use, including any leading arguments. The default + preprocessor argument is `gcc -E -xc-header -DRC_INVOKED'. + +`--include-dir DIRECTORY' + Specify an include directory to use when reading an `rc' file. + `windres' will pass this to the preprocessor as an `-I' option. + `windres' will also search this directory when looking for files + named in the `rc' file. + +`-D TARGET' +`--define SYM[=VAL]' + Specify a `-D' option to pass to the preprocessor when reading an + `rc' file. + +`-v' + Enable verbose mode. This tells you what the preprocessor is if + you didn't specify one. + +`--language VAL' + Specify the default language to use when reading an `rc' file. + VAL should be a hexadecimal language code. The low eight bits are + the language, and the high eight bits are the sublanguage. + +`--use-temp-file' + Use a temporary file to instead of using popen to read the output + of the preprocessor. Use this option if the popen implementation + is buggy on the host (eg., certain non-English language versions + of Windows 95 and Windows 98 are known to have buggy popen where + the output will instead go the console). + +`--no-use-temp-file' + Use popen, not a temporary file, to read the output of the + preprocessor. This is the default behaviour. + +`--help' + Prints a usage summary. + +`--version' + Prints the version number for `windres'. + +`--yydebug' + If `windres' is compiled with `YYDEBUG' defined as `1', this will + turn on parser debugging. + + +File: binutils.info, Node: dlltool, Next: Selecting The Target System, Prev: windres, Up: Top + +Create files needed to build and use DLLs +***************************************** + + `dlltool' may be used to create the files needed to build and use +dynamic link libraries (DLLs). + + _Warning:_ `dlltool' is not always built as part of the binary + utilities, since it is only useful for those targets which support + DLLs. + + dlltool [-d|--input-def DEF-FILE-NAME] + [-b|--base-file BASE-FILE-NAME] + [-e|--output-exp EXPORTS-FILE-NAME] + [-z|--output-def DEF-FILE-NAME] + [-l|--output-lib LIBRARY-FILE-NAME] + [--export-all-symbols] [--no-export-all-symbols] + [--exclude-symbols LIST] + [--no-default-excludes] + [-S|--as PATH-TO-ASSEMBLER] [-f|--as-flags OPTIONS] + [-D|--dllname NAME] [-m|--machine MACHINE] + [-a|--add-indirect] [-U|--add-underscore] [-k|--kill-at] + [-A|--add-stdcall-alias] + [-x|--no-idata4] [-c|--no-idata5] [-i|--interwork] + [-n|--nodelete] [-v|--verbose] [-h|--help] [-V|--version] + [object-file ...] + + `dlltool' reads its inputs, which can come from the `-d' and `-b' +options as well as object files specified on the command line. It then +processes these inputs and if the `-e' option has been specified it +creates a exports file. If the `-l' option has been specified it +creates a library file and if the `-z' option has been specified it +creates a def file. Any or all of the -e, -l and -z options can be +present in one invocation of dlltool. + + When creating a DLL, along with the source for the DLL, it is +necessary to have three other files. `dlltool' can help with the +creation of these files. + + The first file is a `.def' file which specifies which functions are +exported from the DLL, which functions the DLL imports, and so on. This +is a text file and can be created by hand, or `dlltool' can be used to +create it using the `-z' option. In this case `dlltool' will scan the +object files specified on its command line looking for those functions +which have been specially marked as being exported and put entries for +them in the .def file it creates. + + In order to mark a function as being exported from a DLL, it needs to +have an `-export:<name_of_function>' entry in the `.drectve' section of +the object file. This can be done in C by using the asm() operator: + + asm (".section .drectve"); + asm (".ascii \"-export:my_func\""); + + int my_func (void) { ... } + + The second file needed for DLL creation is an exports file. This +file is linked with the object files that make up the body of the DLL +and it handles the interface between the DLL and the outside world. +This is a binary file and it can be created by giving the `-e' option to +`dlltool' when it is creating or reading in a .def file. + + The third file needed for DLL creation is the library file that +programs will link with in order to access the functions in the DLL. +This file can be created by giving the `-l' option to dlltool when it +is creating or reading in a .def file. + + `dlltool' builds the library file by hand, but it builds the exports +file by creating temporary files containing assembler statements and +then assembling these. The `-S' command line option can be used to +specify the path to the assembler that dlltool will use, and the `-f' +option can be used to pass specific flags to that assembler. The `-n' +can be used to prevent dlltool from deleting these temporary assembler +files when it is done, and if `-n' is specified twice then this will +prevent dlltool from deleting the temporary object files it used to +build the library. + + Here is an example of creating a DLL from a source file `dll.c' and +also creating a program (from an object file called `program.o') that +uses that DLL: + + gcc -c dll.c + dlltool -e exports.o -l dll.lib dll.o + gcc dll.o exports.o -o dll.dll + gcc program.o dll.lib -o program + + The command line options have the following meanings: + +`-d FILENAME' +`--input-def FILENAME' + Specifies the name of a .def file to be read in and processed. + +`-b FILENAME' +`--base-file FILENAME' + Specifies the name of a base file to be read in and processed. The + contents of this file will be added to the relocation section in + the exports file generated by dlltool. + +`-e FILENAME' +`--output-exp FILENAME' + Specifies the name of the export file to be created by dlltool. + +`-z FILENAME' +`--output-def FILENAME' + Specifies the name of the .def file to be created by dlltool. + +`-l FILENAME' +`--output-lib FILENAME' + Specifies the name of the library file to be created by dlltool. + +`--export-all-symbols' + Treat all global and weak defined symbols found in the input object + files as symbols to be exported. There is a small list of symbols + which are not exported by default; see the `--no-default-excludes' + option. You may add to the list of symbols to not export by using + the `--exclude-symbols' option. + +`--no-export-all-symbols' + Only export symbols explicitly listed in an input .def file or in + `.drectve' sections in the input object files. This is the default + behaviour. The `.drectve' sections are created by `dllexport' + attributes in the source code. + +`--exclude-symbols LIST' + Do not export the symbols in LIST. This is a list of symbol names + separated by comma or colon characters. The symbol names should + not contain a leading underscore. This is only meaningful when + `--export-all-symbols' is used. + +`--no-default-excludes' + When `--export-all-symbols' is used, it will by default avoid + exporting certain special symbols. The current list of symbols to + avoid exporting is `DllMain@12', `DllEntryPoint@0', `impure_ptr'. + You may use the `--no-default-excludes' option to go ahead and + export these special symbols. This is only meaningful when + `--export-all-symbols' is used. + +`-S PATH' +`--as PATH' + Specifies the path, including the filename, of the assembler to be + used to create the exports file. + +`-f SWITCHES' +`--as-flags SWITCHES' + Specifies any specific command line switches to be passed to the + assembler when building the exports file. This option will work + even if the `-S' option is not used. This option only takes one + argument, and if it occurs more than once on the command line, + then later occurrences will override earlier occurrences. So if + it is necessary to pass multiple switches to the assembler they + should be enclosed in double quotes. + +`-D NAME' +`--dll-name NAME' + Specifies the name to be stored in the .def file as the name of + the DLL when the `-e' option is used. If this option is not + present, then the filename given to the `-e' option will be used + as the name of the DLL. + +`-m MACHINE' +`-machine MACHINE' + Specifies the type of machine for which the library file should be + built. `dlltool' has a built in default type, depending upon how + it was created, but this option can be used to override that. + This is normally only useful when creating DLLs for an ARM + processor, when the contents of the DLL are actually encode using + THUMB instructions. + +`-a' +`--add-indirect' + Specifies that when `dlltool' is creating the exports file it + should add a section which allows the exported functions to be + referenced without using the import library. Whatever the hell + that means! + +`-U' +`--add-underscore' + Specifies that when `dlltool' is creating the exports file it + should prepend an underscore to the names of the exported + functions. + +`-k' +`--kill-at' + Specifies that when `dlltool' is creating the exports file it + should not append the string `@ <number>'. These numbers are + called ordinal numbers and they represent another way of accessing + the function in a DLL, other than by name. + +`-A' +`--add-stdcall-alias' + Specifies that when `dlltool' is creating the exports file it + should add aliases for stdcall symbols without `@ <number>' in + addition to the symbols with `@ <number>'. + +`-x' +`--no-idata4' + Specifies that when `dlltool' is creating the exports and library + files it should omit the .idata4 section. This is for + compatibility with certain operating systems. + +`-c' +`--no-idata5' + Specifies that when `dlltool' is creating the exports and library + files it should omit the .idata5 section. This is for + compatibility with certain operating systems. + +`-i' +`--interwork' + Specifies that `dlltool' should mark the objects in the library + file and exports file that it produces as supporting interworking + between ARM and THUMB code. + +`-n' +`--nodelete' + Makes `dlltool' preserve the temporary assembler files it used to + create the exports file. If this option is repeated then dlltool + will also preserve the temporary object files it uses to create + the library file. + +`-v' +`--verbose' + Make dlltool describe what it is doing. + +`-h' +`--help' + Displays a list of command line options and then exits. + +`-V' +`--version' + Displays dlltool's version number and then exits. + + +File: binutils.info, Node: readelf, Next: size, Prev: ranlib, Up: Top + +readelf +******* + + readelf [ -a | --all ] + [ -h | --file-header] + [ -l | --program-headers | --segments] + [ -S | --section-headers | --sections] + [ -e | --headers] + [ -s | --syms | --symbols] + [ -n | --notes] + [ -r | --relocs] + [ -d | --dynamic] + [ -V | --version-info] + [ -D | --use-dynamic] + [ -x <number> | --hex-dump=<number>] + [ -w[liapr] | --debug-dump[=info,=line,=abbrev,=pubnames,=ranges]] + [ --histogram] + [ -v | --version] + [ -H | --help] + ELFFILE... + + `readelf' displays information about one or more ELF format object +files. The options control what particular information to display. + + ELFFILE... are the object files to be examined. At the moment, +`readelf' does not support examining archives, nor does it support +examing 64 bit ELF files. + + The long and short forms of options, shown here as alternatives, are +equivalent. At least one option besides `-v' or `-H' must be given. + +`-a' +`--all' + Equivalent to specifiying `--file-header', `--program-headers', + `--sections', `--symbols', `--relocs', `--dynamic', `--notes' and + `--version-info'. + +`-h' +`--file-header' + Displays the information contained in the ELF header at the start + of the file. + +`-l' +`--program-headers' +`--segments' + Displays the information contained in the file's segment headers, + if it has any. + +`-S' +`--sections' +`--section-headers' + Displays the information contained in the file's section headers, + if it has any. + +`-s' +`--symbols' +`--syms' + Displays the entries in symbol table section of the file, if it + has one. + +`-e' +`--headers' + Display all the headers in the file. Equivalent to `-h -l -S'. + +`-n' +`--notes' + Displays the contents of the NOTE segment, if it exists. + +`-r' +`--relocs' + Displays the contents of the file's relocation section, if it ha + one. + +`-d' +`--dynamic' + Displays the contents of the file's dynamic section, if it has one. + +`-V' +`--version-info' + Displays the contents of the version sections in the file, it they + exist. + +`-D' +`--use-dynamic' + When displaying symbols, this option makes `readelf' use the + symblol table in the file's dynamic section, rather than the one + in the symbols section. + +`-x <number>' +`--hex-dump=<number>' + Displays the contents of the indicated section as a hexadecimal + dump. + +`-w[liapr]' +`--debug-dump[=line,=info,=abbrev,=pubnames,=ranges]' + Displays the contents of the debug sections in the file, if any are + present. If one of the optional letters or words follows the + switch then only data found in those specific sections will be + dumped. + +`--histogram' + Display a histogram of bucket list lengths when displaying the + contents of the symbol tables. + +`-v' +`--version' + Display the version number of readelf. + +`-H' +`--help' + Display the command line options understood by `readelf'. + + +File: binutils.info, Node: Selecting The Target System, Next: Reporting Bugs, Prev: dlltool, Up: Top + +Selecting the target system +*************************** + + You can specify three aspects of the target system to the GNU binary +file utilities, each in several ways: + + * the target + + * the architecture + + * the linker emulation (which applies to the linker only) + + In the following summaries, the lists of ways to specify values are +in order of decreasing precedence. The ways listed first override those +listed later. + + The commands to list valid values only list the values for which the +programs you are running were configured. If they were configured with +`--enable-targets=all', the commands list most of the available values, +but a few are left out; not all targets can be configured in at once +because some of them can only be configured "native" (on hosts with the +same type as the target system). + +* Menu: + +* Target Selection:: +* Architecture Selection:: +* Linker Emulation Selection:: + + +File: binutils.info, Node: Target Selection, Next: Architecture Selection, Up: Selecting The Target System + +Target Selection +================ + + A "target" is an object file format. A given target may be +supported for multiple architectures (*note Architecture Selection::). +A target selection may also have variations for different operating +systems or architectures. + + The command to list valid target values is `objdump -i' (the first +column of output contains the relevant information). + + Some sample values are: `a.out-hp300bsd', `ecoff-littlemips', +`a.out-sunos-big'. + + You can also specify a target using a configuration triplet. This is +the same sort of name that is passed to `configure' to specify a +target. When you use a configuration triplet as an argument, it must be +fully canonicalized. You can see the canonical version of a triplet by +running the shell script `config.sub' which is included with the +sources. + + Some sample configuration triplets are: `m68k-hp-bsd', +`mips-dec-ultrix', `sparc-sun-sunos'. + +`objdump' Target +---------------- + + Ways to specify: + + 1. command line option: `-b' or `--target' + + 2. environment variable `GNUTARGET' + + 3. deduced from the input file + +`objcopy' and `strip' Input Target +---------------------------------- + + Ways to specify: + + 1. command line options: `-I' or `--input-target', or `-F' or + `--target' + + 2. environment variable `GNUTARGET' + + 3. deduced from the input file + +`objcopy' and `strip' Output Target +----------------------------------- + + Ways to specify: + + 1. command line options: `-O' or `--output-target', or `-F' or + `--target' + + 2. the input target (see "`objcopy' and `strip' Input Target" above) + + 3. environment variable `GNUTARGET' + + 4. deduced from the input file + +`nm', `size', and `strings' Target +---------------------------------- + + Ways to specify: + + 1. command line option: `--target' + + 2. environment variable `GNUTARGET' + + 3. deduced from the input file + +Linker Input Target +------------------- + + Ways to specify: + + 1. command line option: `-b' or `--format' (*note Options: + (ld.info)Options.) + + 2. script command `TARGET' (*note Option Commands: (ld.info)Option + Commands.) + + 3. environment variable `GNUTARGET' (*note Environment: + (ld.info)Environment.) + + 4. the default target of the selected linker emulation (*note Linker + Emulation Selection::) + +Linker Output Target +-------------------- + + Ways to specify: + + 1. command line option: `-oformat' (*note Options: (ld.info)Options.) + + 2. script command `OUTPUT_FORMAT' (*note Option Commands: + (ld.info)Option Commands.) + + 3. the linker input target (see "Linker Input Target" above) + + +File: binutils.info, Node: Architecture Selection, Next: Linker Emulation Selection, Prev: Target Selection, Up: Selecting The Target System + +Architecture selection +====================== + + An "architecture" is a type of CPU on which an object file is to +run. Its name may contain a colon, separating the name of the +processor family from the name of the particular CPU. + + The command to list valid architecture values is `objdump -i' (the +second column contains the relevant information). + + Sample values: `m68k:68020', `mips:3000', `sparc'. + +`objdump' Architecture +---------------------- + + Ways to specify: + + 1. command line option: `-m' or `--architecture' + + 2. deduced from the input file + +`objcopy', `nm', `size', `strings' Architecture +----------------------------------------------- + + Ways to specify: + + 1. deduced from the input file + +Linker Input Architecture +------------------------- + + Ways to specify: + + 1. deduced from the input file + +Linker Output Architecture +-------------------------- + + Ways to specify: + + 1. script command `OUTPUT_ARCH' (*note Option Commands: + (ld.info)Option Commands.) + + 2. the default architecture from the linker output target (*note + Target Selection::) + + +File: binutils.info, Node: Linker Emulation Selection, Prev: Architecture Selection, Up: Selecting The Target System + +Linker emulation selection +========================== + + A linker "emulation" is a "personality" of the linker, which gives +the linker default values for the other aspects of the target system. +In particular, it consists of + + * the linker script + + * the target + + * several "hook" functions that are run at certain stages of the + linking process to do special things that some targets require + + The command to list valid linker emulation values is `ld -V'. + + Sample values: `hp300bsd', `mipslit', `sun4'. + + Ways to specify: + + 1. command line option: `-m' (*note Options: (ld.info)Options.) + + 2. environment variable `LDEMULATION' + + 3. compiled-in `DEFAULT_EMULATION' from `Makefile', which comes from + `EMUL' in `config/TARGET.mt' + + +File: binutils.info, Node: Reporting Bugs, Next: Index, Prev: Selecting The Target System, Up: Top + +Reporting Bugs +************** + + Your bug reports play an essential role in making the binary +utilities reliable. + + Reporting a bug may help you by bringing a solution to your problem, +or it may not. But in any case the principal function of a bug report +is to help the entire community by making the next version of the binary +utilities work better. Bug reports are your contribution to their +maintenance. + + In order for a bug report to serve its purpose, you must include the +information that enables us to fix the bug. + +* Menu: + +* Bug Criteria:: Have you found a bug? +* Bug Reporting:: How to report bugs + + +File: binutils.info, Node: Bug Criteria, Next: Bug Reporting, Up: Reporting Bugs + +Have you found a bug? +===================== + + If you are not sure whether you have found a bug, here are some +guidelines: + + * If a binary utility gets a fatal signal, for any input whatever, + that is a bug. Reliable utilities never crash. + + * If a binary utility produces an error message for valid input, + that is a bug. + + * If you are an experienced user of binary utilities, your + suggestions for improvement are welcome in any case. + + +File: binutils.info, Node: Bug Reporting, Prev: Bug Criteria, Up: Reporting Bugs + +How to report bugs +================== + + A number of companies and individuals offer support for GNU +products. If you obtained the binary utilities from a support +organization, we recommend you contact that organization first. + + You can find contact information for many support companies and +individuals in the file `etc/SERVICE' in the GNU Emacs distribution. + + In any event, we also recommend that you send bug reports for the +binary utilities to `bug-gnu-utils@gnu.org'. + + The fundamental principle of reporting bugs usefully is this: +*report all the facts*. If you are not sure whether to state a fact or +leave it out, state it! + + Often people omit facts because they think they know what causes the +problem and assume that some details do not matter. Thus, you might +assume that the name of a file you use in an example does not matter. +Well, probably it does not, but one cannot be sure. Perhaps the bug is +a stray memory reference which happens to fetch from the location where +that pathname is stored in memory; perhaps, if the pathname were +different, the contents of that location would fool the utility into +doing the right thing despite the bug. Play it safe and give a +specific, complete example. That is the easiest thing for you to do, +and the most helpful. + + Keep in mind that the purpose of a bug report is to enable us to fix +the bug if it is new to us. Therefore, always write your bug reports +on the assumption that the bug has not been reported previously. + + Sometimes people give a few sketchy facts and ask, "Does this ring a +bell?" Those bug reports are useless, and we urge everyone to _refuse +to respond to them_ except to chide the sender to report bugs properly. + + To enable us to fix the bug, you should include all these things: + + * The version of the utility. Each utility announces it if you + start it with the `--version' argument. + + Without this, we will not know whether there is any point in + looking for the bug in the current version of the binary utilities. + + * Any patches you may have applied to the source, including any + patches made to the `BFD' library. + + * The type of machine you are using, and the operating system name + and version number. + + * What compiler (and its version) was used to compile the + utilities--e.g. "`gcc-2.7'". + + * The command arguments you gave the utility to observe the bug. To + guarantee you will not omit something important, list them all. A + copy of the Makefile (or the output from make) is sufficient. + + If we were to try to guess the arguments, we would probably guess + wrong and then we might not encounter the bug. + + * A complete input file, or set of input files, that will reproduce + the bug. If the utility is reading an object file or files, then + it is generally most helpful to send the actual object files, + uuencoded if necessary to get them through the mail system. Note + that `bug-gnu-utils@gnu.org' is a mailing list, so you should avoid + sending very large files to it. Making the files available for + anonymous FTP is OK. + + If the source files were produced exclusively using GNU programs + (e.g., `gcc', `gas', and/or the GNU `ld'), then it may be OK to + send the source files rather than the object files. In this case, + be sure to say exactly what version of `gcc', or whatever, was + used to produce the object files. Also say how `gcc', or + whatever, was configured. + + * A description of what behavior you observe that you believe is + incorrect. For example, "It gets a fatal signal." + + Of course, if the bug is that the utility gets a fatal signal, + then we will certainly notice it. But if the bug is incorrect + output, we might not notice unless it is glaringly wrong. You + might as well not give us a chance to make a mistake. + + Even if the problem you experience is a fatal signal, you should + still say so explicitly. Suppose something strange is going on, + such as your copy of the utility is out of synch, or you have + encountered a bug in the C library on your system. (This has + happened!) Your copy might crash and ours would not. If you told + us to expect a crash, then when ours fails to crash, we would know + that the bug was not happening for us. If you had not told us to + expect a crash, then we would not be able to draw any conclusion + from our observations. + + * If you wish to suggest changes to the source, send us context + diffs, as generated by `diff' with the `-u', `-c', or `-p' option. + Always send diffs from the old file to the new file. If you wish + to discuss something in the `ld' source, refer to it by context, + not by line number. + + The line numbers in our development sources will not match those + in your sources. Your line numbers would convey no useful + information to us. + + Here are some things that are not necessary: + + * A description of the envelope of the bug. + + Often people who encounter a bug spend a lot of time investigating + which changes to the input file will make the bug go away and which + changes will not affect it. + + This is often time consuming and not very useful, because the way + we will find the bug is by running a single example under the + debugger with breakpoints, not by pure deduction from a series of + examples. We recommend that you save your time for something else. + + Of course, if you can find a simpler example to report _instead_ + of the original one, that is a convenience for us. Errors in the + output will be easier to spot, running under the debugger will take + less time, and so on. + + However, simplification is not vital; if you do not want to do + this, report the bug anyway and send us the entire test case you + used. + + * A patch for the bug. + + A patch for the bug does help us if it is a good one. But do not + omit the necessary information, such as the test case, on the + assumption that a patch is all we need. We might see problems + with your patch and decide to fix the problem another way, or we + might not understand it at all. + + Sometimes with programs as complicated as the binary utilities it + is very hard to construct an example that will make the program + follow a certain path through the code. If you do not send us the + example, we will not be able to construct one, so we will not be + able to verify that the bug is fixed. + + And if we cannot understand what bug you are trying to fix, or why + your patch should be an improvement, we will not install it. A + test case will help us to understand. + + * A guess about what the bug is or what it depends on. + + Such guesses are usually wrong. Even we cannot guess right about + such things without first using the debugger to find the facts. + diff --git a/binutils/binutils.info-3 b/binutils/binutils.info-3 new file mode 100644 index 00000000000..4de1e8e001a --- /dev/null +++ b/binutils/binutils.info-3 @@ -0,0 +1,182 @@ +This is binutils.info, produced by makeinfo version 4.0 from +binutils.texi. + +START-INFO-DIR-ENTRY +* Binutils: (binutils). The GNU binary utilities. +* ar: (binutils)ar. Create, modify, and extract from archives +* nm: (binutils)nm. List symbols from object files +* objcopy: (binutils)objcopy. Copy and translate object files +* objdump: (binutils)objdump. Display information from object files +* ranlib: (binutils)ranlib. Generate index to archive contents +* readelf: (binutils)readelf. Display the contents of ELF format files. +* size: (binutils)size. List section sizes and total size +* strings: (binutils)strings. List printable strings from files +* strip: (binutils)strip. Discard symbols +* c++filt: (binutils)c++filt. Filter to demangle encoded C++ symbols +* cxxfilt: (binutils)c++filt. MS-DOS name for c++filt +* addr2line: (binutils)addr2line. Convert addresses to file and line +* nlmconv: (binutils)nlmconv. Converts object code into an NLM +* windres: (binutils)windres. Manipulate Windows resources +* dlltool: (binutils)dlltool. Create files needed to build and use DLLs +END-INFO-DIR-ENTRY + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: binutils.info, Node: Index, Prev: Reporting Bugs, Up: Top + +Index +***** + +* Menu: + +* .stab: objdump. +* addr2line: addr2line. +* address to file name and line number: addr2line. +* all header information, object file: objdump. +* ar: ar. +* ar compatibility: ar. +* architecture: objdump. +* architectures available: objdump. +* archive contents: ranlib. +* archive headers: objdump. +* archives: ar. +* base files: dlltool. +* bug criteria: Bug Criteria. +* bug reports: Bug Reporting. +* bugs: Reporting Bugs. +* bugs, reporting: Bug Reporting. +* c++filt: c++filt. +* changing object addresses: objcopy. +* changing section address: objcopy. +* changing section LMA: objcopy. +* changing section VMA: objcopy. +* changing start address: objcopy. +* collections of files: ar. +* compatibility, ar: ar. +* contents of archive: ar cmdline. +* crash: Bug Criteria. +* creating archives: ar cmdline. +* cxxfilt: c++filt. +* dates in archive: ar cmdline. +* debug symbols: objdump. +* debugging symbols: nm. +* deleting from archive: ar cmdline. +* demangling C++ symbols: c++filt. +* demangling in nm: nm. +* demangling in objdump <1>: addr2line. +* demangling in objdump: objdump. +* disassembling object code: objdump. +* disassembly architecture: objdump. +* disassembly endianness: objdump. +* disassembly, with source: objdump. +* discarding symbols: strip. +* DLL: dlltool. +* dlltool: dlltool. +* dynamic relocation entries, in object file: objdump. +* dynamic symbol table entries, printing: objdump. +* dynamic symbols: nm. +* ELF core notes: readelf. +* ELF dynamic section information: readelf. +* ELF file header information: readelf. +* ELF file information: readelf. +* ELF object file format: objdump. +* ELF program header information: readelf. +* ELF reloc information: readelf. +* ELF section information: readelf. +* ELF segment information: readelf. +* ELF symbol table information: readelf. +* ELF version sections informations: readelf. +* endianness: objdump. +* error on valid input: Bug Criteria. +* external symbols: nm. +* extract from archive: ar cmdline. +* fatal signal: Bug Criteria. +* file name: nm. +* header information, all: objdump. +* input .def file: dlltool. +* input file name: nm. +* libraries: ar. +* listings strings: strings. +* machine instructions: objdump. +* moving in archive: ar cmdline. +* MRI compatibility, ar: ar scripts. +* name duplication in archive: ar cmdline. +* name length: ar. +* nm: nm. +* nm compatibility: nm. +* nm format: nm. +* not writing archive index: ar cmdline. +* objdump: objdump. +* object code format <1>: addr2line. +* object code format <2>: strings. +* object code format <3>: size. +* object code format <4>: objdump. +* object code format: nm. +* object file header: objdump. +* object file information: objdump. +* object file sections: objdump. +* object formats available: objdump. +* operations on archive: ar cmdline. +* printing from archive: ar cmdline. +* printing strings: strings. +* quick append to archive: ar cmdline. +* radix for section sizes: size. +* ranlib: ranlib. +* readelf: readelf. +* relative placement in archive: ar cmdline. +* relocation entries, in object file: objdump. +* removing symbols: strip. +* repeated names in archive: ar cmdline. +* replacement in archive: ar cmdline. +* reporting bugs: Reporting Bugs. +* scripts, ar: ar scripts. +* section addresses in objdump: objdump. +* section headers: objdump. +* section information: objdump. +* section sizes: size. +* sections, full contents: objdump. +* size: size. +* size display format: size. +* size number format: size. +* sorting symbols: nm. +* source code context: objdump. +* source disassembly: objdump. +* source file name: nm. +* source filenames for object files: objdump. +* stab: objdump. +* start-address: objdump. +* stop-address: objdump. +* strings: strings. +* strings, printing: strings. +* strip: strip. +* symbol index <1>: ranlib. +* symbol index: ar. +* symbol index, listing: nm. +* symbol line numbers: nm. +* symbol table entries, printing: objdump. +* symbols: nm. +* symbols, discarding: strip. +* undefined symbols: nm. +* Unix compatibility, ar: ar cmdline. +* updating an archive: ar cmdline. +* version: Top. +* VMA in objdump: objdump. +* wide output, printing: objdump. +* writing archive index: ar cmdline. + + diff --git a/binutils/config.texi b/binutils/config.texi new file mode 100644 index 00000000000..b696ac718c9 --- /dev/null +++ b/binutils/config.texi @@ -0,0 +1 @@ +@set VERSION 2.10 diff --git a/binutils/deflex.c b/binutils/deflex.c new file mode 100644 index 00000000000..fd9553c56fc --- /dev/null +++ b/binutils/deflex.c @@ -0,0 +1,1844 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> +#include <unistd.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 39 +#define YY_END_OF_BUFFER 40 +static yyconst short int yy_accept[189] = + { 0, + 0, 0, 40, 39, 33, 34, 32, 39, 27, 39, + 30, 38, 36, 26, 31, 35, 37, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 0, 28, 27, 0, 29, 30, 26, 31, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 12, 6, 27, 7, 27, 27, 27, 27, 27, + 27, 27, 27, 1, 27, 27, 15, 27, 27, 27, + + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 16, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 14, 27, 27, 18, 20, 27, + 27, 27, 27, 27, 27, 17, 9, 27, 10, 27, + 27, 2, 27, 27, 27, 27, 27, 27, 11, 13, + 27, 5, 27, 27, 21, 27, 8, 27, 27, 27, + 27, 27, 27, 19, 4, 27, 27, 27, 23, 27, + 25, 27, 3, 27, 27, 22, 24, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 1, 5, 1, 6, 1, 1, 7, 1, + 1, 8, 1, 9, 6, 10, 11, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 6, 13, 1, + 14, 1, 6, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 6, 25, 26, 27, 28, 29, 30, + 6, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 1, 1, 1, 1, 6, 1, 21, 21, 21, 21, + + 21, 21, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 21, + 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[40] = + { 0, + 1, 1, 2, 1, 1, 3, 1, 1, 1, 1, + 3, 4, 1, 1, 3, 4, 4, 4, 4, 4, + 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[195] = + { 0, + 0, 0, 209, 210, 210, 210, 210, 203, 0, 200, + 0, 210, 210, 0, 0, 210, 210, 190, 176, 24, + 167, 183, 14, 178, 167, 27, 180, 25, 179, 178, + 166, 191, 210, 0, 188, 210, 0, 0, 0, 162, + 27, 160, 160, 27, 175, 160, 165, 171, 161, 159, + 157, 168, 165, 166, 153, 164, 148, 147, 153, 156, + 155, 142, 157, 154, 153, 141, 139, 139, 134, 135, + 132, 144, 34, 144, 129, 130, 138, 141, 131, 125, + 123, 0, 0, 122, 0, 123, 119, 121, 119, 119, + 29, 133, 124, 0, 120, 123, 0, 121, 124, 117, + + 117, 30, 117, 120, 123, 114, 104, 103, 111, 101, + 107, 104, 100, 100, 109, 112, 98, 107, 105, 92, + 97, 94, 92, 0, 92, 89, 98, 85, 77, 83, + 85, 81, 74, 85, 0, 79, 81, 0, 0, 84, + 78, 74, 77, 71, 70, 0, 0, 82, 0, 84, + 67, 0, 79, 78, 65, 57, 78, 61, 0, 0, + 69, 0, 76, 75, 0, 71, 0, 69, 72, 71, + 57, 59, 54, 0, 0, 52, 37, 36, 0, 45, + 0, 44, 0, 41, 40, 0, 0, 210, 66, 68, + 72, 76, 55, 80 + + } ; + +static yyconst short int yy_def[195] = + { 0, + 188, 1, 188, 188, 188, 188, 188, 189, 190, 191, + 192, 188, 188, 193, 194, 188, 188, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 189, 188, 190, 191, 188, 192, 193, 194, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 0, 188, 188, + 188, 188, 188, 188 + + } ; + +static yyconst short int yy_nxt[250] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 4, 14, 15, 16, 17, 9, 18, 19, 20, 21, + 9, 9, 22, 23, 9, 24, 25, 26, 9, 9, + 27, 28, 29, 9, 30, 31, 9, 9, 9, 42, + 46, 47, 50, 43, 53, 61, 65, 54, 55, 95, + 111, 121, 112, 122, 62, 51, 66, 56, 38, 187, + 186, 185, 184, 183, 182, 96, 32, 32, 32, 32, + 34, 34, 35, 35, 35, 35, 37, 181, 37, 37, + 39, 180, 39, 39, 179, 178, 177, 176, 175, 174, + 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, + + 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, + 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, + 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, + 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, + 123, 120, 119, 118, 117, 116, 115, 114, 113, 110, + 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, + 99, 98, 97, 94, 93, 92, 91, 90, 89, 88, + 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, + 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, + 67, 64, 63, 60, 36, 33, 59, 58, 57, 52, + + 49, 48, 45, 44, 41, 40, 36, 33, 188, 3, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188 + } ; + +static yyconst short int yy_chk[250] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 20, + 23, 23, 26, 20, 28, 41, 44, 28, 28, 73, + 91, 102, 91, 102, 41, 26, 44, 28, 193, 185, + 184, 182, 180, 178, 177, 73, 189, 189, 189, 189, + 190, 190, 191, 191, 191, 191, 192, 176, 192, 192, + 194, 173, 194, 194, 172, 171, 170, 169, 168, 166, + 164, 163, 161, 158, 157, 156, 155, 154, 153, 151, + + 150, 148, 145, 144, 143, 142, 141, 140, 137, 136, + 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, + 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, + 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, + 103, 101, 100, 99, 98, 96, 95, 93, 92, 90, + 89, 88, 87, 86, 84, 81, 80, 79, 78, 77, + 76, 75, 74, 72, 71, 70, 69, 68, 67, 66, + 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, + 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, + 45, 43, 42, 40, 35, 32, 31, 30, 29, 27, + + 25, 24, 22, 21, 19, 18, 10, 8, 3, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "deflex.l" +#define INITIAL 0 +#line 2 "deflex.l" + +/* Copyright (C) 1995, 1997, 1998, 1999 Free Software Foundation, Inc. + +This file is part of GNU Binutils. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + + +/* Contributed by Steve Chamberlain + sac@cygnus.com + +*/ +#define DONTDECLARE_MALLOC +#include "libiberty.h" +#include "defparse.h" +#include "dlltool.h" + +int linenumber; + +#line 511 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 34 "deflex.l" + +#line 664 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 189 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 210 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 35 "deflex.l" +{ return NAME;} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 36 "deflex.l" +{ return LIBRARY;} + YY_BREAK +case 3: +YY_RULE_SETUP +#line 37 "deflex.l" +{ return DESCRIPTION;} + YY_BREAK +case 4: +YY_RULE_SETUP +#line 38 "deflex.l" +{ return STACKSIZE;} + YY_BREAK +case 5: +YY_RULE_SETUP +#line 39 "deflex.l" +{ return HEAPSIZE;} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 40 "deflex.l" +{ return CODE;} + YY_BREAK +case 7: +YY_RULE_SETUP +#line 41 "deflex.l" +{ return DATA;} + YY_BREAK +case 8: +YY_RULE_SETUP +#line 42 "deflex.l" +{ return SECTIONS;} + YY_BREAK +case 9: +YY_RULE_SETUP +#line 43 "deflex.l" +{ return EXPORTS;} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 44 "deflex.l" +{ return IMPORTS;} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 45 "deflex.l" +{ return VERSIONK;} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 46 "deflex.l" +{ return BASE;} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 47 "deflex.l" +{ return CONSTANT; } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 48 "deflex.l" +{ return NONAME; } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 49 "deflex.l" +{ return READ;} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 50 "deflex.l" +{ return WRITE;} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 51 "deflex.l" +{ return EXECUTE;} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 52 "deflex.l" +{ return SHARED;} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 53 "deflex.l" +{ return NONSHARED;} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 54 "deflex.l" +{ return SINGLE;} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 55 "deflex.l" +{ return MULTIPLE;} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 56 "deflex.l" +{ return INITINSTANCE;} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 57 "deflex.l" +{ return INITGLOBAL;} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 58 "deflex.l" +{ return TERMINSTANCE;} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 59 "deflex.l" +{ return TERMGLOBAL;} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 61 "deflex.l" +{ yylval.number = strtol (yytext,0,0); + return NUMBER; } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 64 "deflex.l" +{ + yylval.id = xstrdup (yytext); + return ID; + } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 69 "deflex.l" +{ + yylval.id = xstrdup (yytext+1); + yylval.id[yyleng-2] = 0; + return ID; + } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 75 "deflex.l" +{ + yylval.id = xstrdup (yytext+1); + yylval.id[yyleng-2] = 0; + return ID; + } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 80 "deflex.l" +{ } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 81 "deflex.l" +{ } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 82 "deflex.l" +{ } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 83 "deflex.l" +{ } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 84 "deflex.l" +{ linenumber ++ ;} + YY_BREAK +case 35: +YY_RULE_SETUP +#line 85 "deflex.l" +{ return '=';} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 86 "deflex.l" +{ return '.';} + YY_BREAK +case 37: +YY_RULE_SETUP +#line 87 "deflex.l" +{ return '@';} + YY_BREAK +case 38: +YY_RULE_SETUP +#line 88 "deflex.l" +{ return ',';} + YY_BREAK +case 39: +YY_RULE_SETUP +#line 89 "deflex.l" +ECHO; + YY_BREAK +#line 954 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 189 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 189 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 188); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 89 "deflex.l" + +#ifndef yywrap +/* Needed for lex, though not flex. */ +int yywrap() { return 1; } +#endif diff --git a/binutils/defparse.c b/binutils/defparse.c new file mode 100644 index 00000000000..f36480f8452 --- /dev/null +++ b/binutils/defparse.c @@ -0,0 +1,1202 @@ + +/* A Bison parser, made from defparse.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define NAME 257 +#define LIBRARY 258 +#define DESCRIPTION 259 +#define STACKSIZE 260 +#define HEAPSIZE 261 +#define CODE 262 +#define DATA 263 +#define SECTIONS 264 +#define EXPORTS 265 +#define IMPORTS 266 +#define VERSIONK 267 +#define BASE 268 +#define CONSTANT 269 +#define READ 270 +#define WRITE 271 +#define EXECUTE 272 +#define SHARED 273 +#define NONSHARED 274 +#define NONAME 275 +#define SINGLE 276 +#define MULTIPLE 277 +#define INITINSTANCE 278 +#define INITGLOBAL 279 +#define TERMINSTANCE 280 +#define TERMGLOBAL 281 +#define ID 282 +#define NUMBER 283 + +#line 1 "defparse.y" + /* defparse.y - parser for .def files */ + +/* Copyright (C) 1995, 1997, 1998, 1999 Free Software Foundation, Inc. + +This file is part of GNU Binutils. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "bfd.h" +#include "bucomm.h" +#include "dlltool.h" + +#line 26 "defparse.y" +typedef union { + char *id; + int number; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 94 +#define YYFLAG -32768 +#define YYNTBASE 34 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 283 ? yytranslate[x] : 55) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 32, 2, 30, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 31, 2, 2, 33, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 3, 5, 9, 14, 17, 20, 24, 28, 31, + 34, 37, 40, 43, 48, 49, 52, 59, 62, 64, + 72, 80, 86, 92, 98, 104, 108, 112, 115, 117, + 120, 124, 126, 128, 129, 132, 133, 135, 137, 139, + 141, 143, 145, 147, 149, 150, 152, 153, 155, 156, + 158, 162, 163, 166, 167, 170, 171, 175, 176, 177, + 181, 183, 185, 187 +}; + +static const short yyrhs[] = { 34, + 35, 0, 35, 0, 3, 49, 52, 0, 4, 49, + 52, 53, 0, 11, 36, 0, 5, 28, 0, 6, + 29, 44, 0, 7, 29, 44, 0, 8, 42, 0, + 9, 42, 0, 10, 40, 0, 12, 38, 0, 13, + 29, 0, 13, 29, 30, 29, 0, 0, 36, 37, + 0, 28, 51, 50, 47, 46, 48, 0, 38, 39, + 0, 39, 0, 28, 31, 28, 30, 28, 30, 28, + 0, 28, 31, 28, 30, 28, 30, 29, 0, 28, + 31, 28, 30, 28, 0, 28, 31, 28, 30, 29, + 0, 28, 30, 28, 30, 28, 0, 28, 30, 28, + 30, 29, 0, 28, 30, 28, 0, 28, 30, 29, + 0, 40, 41, 0, 41, 0, 28, 42, 0, 42, + 43, 45, 0, 45, 0, 32, 0, 0, 32, 29, + 0, 0, 16, 0, 17, 0, 18, 0, 19, 0, + 20, 0, 22, 0, 23, 0, 15, 0, 0, 21, + 0, 0, 9, 0, 0, 28, 0, 28, 30, 28, + 0, 0, 33, 29, 0, 0, 31, 28, 0, 0, + 14, 31, 29, 0, 0, 0, 53, 43, 54, 0, + 24, 0, 25, 0, 26, 0, 27, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 43, 44, 47, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 63, 65, 68, 72, 74, 77, + 79, 80, 81, 82, 83, 84, 85, 88, 90, 93, + 97, 99, 102, 104, 106, 107, 110, 112, 113, 114, + 115, 116, 117, 120, 122, 125, 127, 130, 132, 135, + 136, 142, 145, 147, 150, 152, 155, 156, 159, 161, + 164, 166, 167, 168 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","NAME","LIBRARY", +"DESCRIPTION","STACKSIZE","HEAPSIZE","CODE","DATA","SECTIONS","EXPORTS","IMPORTS", +"VERSIONK","BASE","CONSTANT","READ","WRITE","EXECUTE","SHARED","NONSHARED","NONAME", +"SINGLE","MULTIPLE","INITINSTANCE","INITGLOBAL","TERMINSTANCE","TERMGLOBAL", +"ID","NUMBER","'.'","'='","','","'@'","start","command","explist","expline", +"implist","impline","seclist","secline","attr_list","opt_comma","opt_number", +"attr","opt_CONSTANT","opt_NONAME","opt_DATA","opt_name","opt_ordinal","opt_equal_name", +"opt_base","option_list","option", NULL +}; +#endif + +static const short yyr1[] = { 0, + 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 36, 36, 37, 38, 38, 39, + 39, 39, 39, 39, 39, 39, 39, 40, 40, 41, + 42, 42, 43, 43, 44, 44, 45, 45, 45, 45, + 45, 45, 45, 46, 46, 47, 47, 48, 48, 49, + 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, + 54, 54, 54, 54 +}; + +static const short yyr2[] = { 0, + 2, 1, 3, 4, 2, 2, 3, 3, 2, 2, + 2, 2, 2, 4, 0, 2, 6, 2, 1, 7, + 7, 5, 5, 5, 5, 3, 3, 2, 1, 2, + 3, 1, 1, 0, 2, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, + 3, 0, 2, 0, 2, 0, 3, 0, 0, 3, + 1, 1, 1, 1 +}; + +static const short yydefact[] = { 0, + 52, 52, 0, 0, 0, 0, 0, 0, 15, 0, + 0, 0, 2, 50, 58, 58, 6, 36, 36, 37, + 38, 39, 40, 41, 42, 43, 9, 32, 10, 0, + 11, 29, 5, 0, 12, 19, 13, 1, 0, 0, + 3, 59, 0, 7, 8, 33, 0, 30, 28, 56, + 16, 0, 0, 18, 0, 51, 0, 4, 35, 31, + 0, 54, 26, 27, 0, 14, 57, 0, 55, 0, + 47, 0, 0, 61, 62, 63, 64, 60, 53, 46, + 45, 24, 25, 22, 23, 44, 49, 0, 48, 17, + 20, 21, 0, 0 +}; + +static const short yydefgoto[] = { 12, + 13, 33, 51, 35, 36, 31, 32, 27, 47, 44, + 28, 87, 81, 90, 15, 71, 62, 41, 58, 78 +}; + +static const short yypact[] = { 32, + -22, -22, -19, -13, 22, 30, 30, -6,-32768, 26, + 38, 21,-32768, 29, 46, 46,-32768, 36, 36,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, -15,-32768, -15, 30, + -6,-32768, 41, -16, 26,-32768, 40,-32768, 43, 42, +-32768,-32768, 45,-32768,-32768,-32768, 30, -15,-32768, 44, +-32768, -9, 48,-32768, 49,-32768, 50, -14,-32768,-32768, + 52, 39, 47,-32768, 51,-32768,-32768, 31,-32768, 53, + 62, 33, 35,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 69,-32768,-32768, 55,-32768,-32768, 77, 37,-32768,-32768, +-32768,-32768, 87,-32768 +}; + +static const short yypgoto[] = {-32768, + 76,-32768,-32768,-32768, 54,-32768, 59, -7, 34, 72, + 56,-32768,-32768,-32768, 91,-32768,-32768, 78,-32768,-32768 +}; + + +#define YYLAST 103 + + +static const short yytable[] = { 29, + -34, -34, -34, -34, -34, 14, -34, -34, 17, -34, + -34, -34, -34, 52, 53, 18, 46, 46, 63, 64, + 93, 30, 48, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, + 19, 25, 26, 34, 74, 75, 76, 77, 39, 40, + 82, 83, 84, 85, 91, 92, 37, 43, 50, 55, + 56, 70, 57, 59, 61, 65, 72, 66, 67, 69, + 73, 79, 80, 86, 88, 89, 94, 38, 54, 49, + 45, 68, 16, 42, 0, 0, 0, 0, 0, 0, + 0, 0, 60 +}; + +static const short yycheck[] = { 7, + 16, 17, 18, 19, 20, 28, 22, 23, 28, 24, + 25, 26, 27, 30, 31, 29, 32, 32, 28, 29, + 0, 28, 30, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 16, 17, 18, 19, 20, + 29, 22, 23, 28, 24, 25, 26, 27, 30, 14, + 28, 29, 28, 29, 28, 29, 29, 32, 28, 30, + 28, 33, 31, 29, 31, 28, 30, 29, 29, 28, + 30, 29, 21, 15, 30, 9, 0, 12, 35, 31, + 19, 58, 2, 16, -1, -1, -1, -1, -1, -1, + -1, -1, 47 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 3: +#line 48 "defparse.y" +{ def_name (yyvsp[-1].id, yyvsp[0].number); ; + break;} +case 4: +#line 49 "defparse.y" +{ def_library (yyvsp[-2].id, yyvsp[-1].number); ; + break;} +case 6: +#line 51 "defparse.y" +{ def_description (yyvsp[0].id);; + break;} +case 7: +#line 52 "defparse.y" +{ def_stacksize (yyvsp[-1].number, yyvsp[0].number);; + break;} +case 8: +#line 53 "defparse.y" +{ def_heapsize (yyvsp[-1].number, yyvsp[0].number);; + break;} +case 9: +#line 54 "defparse.y" +{ def_code (yyvsp[0].number);; + break;} +case 10: +#line 55 "defparse.y" +{ def_data (yyvsp[0].number);; + break;} +case 13: +#line 58 "defparse.y" +{ def_version (yyvsp[0].number,0);; + break;} +case 14: +#line 59 "defparse.y" +{ def_version (yyvsp[-2].number,yyvsp[0].number);; + break;} +case 17: +#line 70 "defparse.y" +{ def_exports (yyvsp[-5].id, yyvsp[-4].id, yyvsp[-3].number, yyvsp[-2].number, yyvsp[-1].number, yyvsp[0].number);; + break;} +case 20: +#line 78 "defparse.y" +{ def_import (yyvsp[-6].id,yyvsp[-4].id,yyvsp[-2].id,yyvsp[0].id, 0); ; + break;} +case 21: +#line 79 "defparse.y" +{ def_import (yyvsp[-6].id,yyvsp[-4].id,yyvsp[-2].id, 0,yyvsp[0].number); ; + break;} +case 22: +#line 80 "defparse.y" +{ def_import (yyvsp[-4].id,yyvsp[-2].id, 0,yyvsp[0].id, 0); ; + break;} +case 23: +#line 81 "defparse.y" +{ def_import (yyvsp[-4].id,yyvsp[-2].id, 0, 0,yyvsp[0].number); ; + break;} +case 24: +#line 82 "defparse.y" +{ def_import ( 0,yyvsp[-4].id,yyvsp[-2].id,yyvsp[0].id, 0); ; + break;} +case 25: +#line 83 "defparse.y" +{ def_import ( 0,yyvsp[-4].id,yyvsp[-2].id, 0,yyvsp[0].number); ; + break;} +case 26: +#line 84 "defparse.y" +{ def_import ( 0,yyvsp[-2].id, 0,yyvsp[0].id, 0); ; + break;} +case 27: +#line 85 "defparse.y" +{ def_import ( 0,yyvsp[-2].id, 0, 0,yyvsp[0].number); ; + break;} +case 30: +#line 94 "defparse.y" +{ def_section (yyvsp[-1].id,yyvsp[0].number);; + break;} +case 35: +#line 106 "defparse.y" +{ yyval.number=yyvsp[0].number;; + break;} +case 36: +#line 107 "defparse.y" +{ yyval.number=-1;; + break;} +case 37: +#line 111 "defparse.y" +{ yyval.number = 1; ; + break;} +case 38: +#line 112 "defparse.y" +{ yyval.number = 2; ; + break;} +case 39: +#line 113 "defparse.y" +{ yyval.number = 4; ; + break;} +case 40: +#line 114 "defparse.y" +{ yyval.number = 8; ; + break;} +case 41: +#line 115 "defparse.y" +{ yyval.number = 0; ; + break;} +case 42: +#line 116 "defparse.y" +{ yyval.number = 0; ; + break;} +case 43: +#line 117 "defparse.y" +{ yyval.number = 0; ; + break;} +case 44: +#line 121 "defparse.y" +{yyval.number=1;; + break;} +case 45: +#line 122 "defparse.y" +{yyval.number=0;; + break;} +case 46: +#line 126 "defparse.y" +{yyval.number=1;; + break;} +case 47: +#line 127 "defparse.y" +{yyval.number=0;; + break;} +case 48: +#line 131 "defparse.y" +{ yyval.number = 1; ; + break;} +case 49: +#line 132 "defparse.y" +{ yyval.number = 0; ; + break;} +case 50: +#line 135 "defparse.y" +{ yyval.id =yyvsp[0].id; ; + break;} +case 51: +#line 137 "defparse.y" +{ + char *name = xmalloc (strlen (yyvsp[-2].id) + 1 + strlen (yyvsp[0].id) + 1); + sprintf (name, "%s.%s", yyvsp[-2].id, yyvsp[0].id); + yyval.id = name; + ; + break;} +case 52: +#line 142 "defparse.y" +{ yyval.id=""; ; + break;} +case 53: +#line 146 "defparse.y" +{ yyval.number=yyvsp[0].number;; + break;} +case 54: +#line 147 "defparse.y" +{ yyval.number=-1;; + break;} +case 55: +#line 151 "defparse.y" +{ yyval.id = yyvsp[0].id; ; + break;} +case 56: +#line 152 "defparse.y" +{ yyval.id = 0; ; + break;} +case 57: +#line 155 "defparse.y" +{ yyval.number= yyvsp[0].number;; + break;} +case 58: +#line 156 "defparse.y" +{ yyval.number=-1;; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 170 "defparse.y" diff --git a/binutils/defparse.h b/binutils/defparse.h new file mode 100644 index 00000000000..d1167c61bd3 --- /dev/null +++ b/binutils/defparse.h @@ -0,0 +1,34 @@ +typedef union { + char *id; + int number; +} YYSTYPE; +#define NAME 257 +#define LIBRARY 258 +#define DESCRIPTION 259 +#define STACKSIZE 260 +#define HEAPSIZE 261 +#define CODE 262 +#define DATA 263 +#define SECTIONS 264 +#define EXPORTS 265 +#define IMPORTS 266 +#define VERSIONK 267 +#define BASE 268 +#define CONSTANT 269 +#define READ 270 +#define WRITE 271 +#define EXECUTE 272 +#define SHARED 273 +#define NONSHARED 274 +#define NONAME 275 +#define SINGLE 276 +#define MULTIPLE 277 +#define INITINSTANCE 278 +#define INITGLOBAL 279 +#define TERMINSTANCE 280 +#define TERMGLOBAL 281 +#define ID 282 +#define NUMBER 283 + + +extern YYSTYPE yylval; diff --git a/binutils/nlmheader.c b/binutils/nlmheader.c new file mode 100644 index 00000000000..830e6b70a0e --- /dev/null +++ b/binutils/nlmheader.c @@ -0,0 +1,1991 @@ + +/* A Bison parser, made from nlmheader.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define CHECK 257 +#define CODESTART 258 +#define COPYRIGHT 259 +#define CUSTOM 260 +#define DATE 261 +#define DEBUG 262 +#define DESCRIPTION 263 +#define EXIT 264 +#define EXPORT 265 +#define FLAG_ON 266 +#define FLAG_OFF 267 +#define FULLMAP 268 +#define HELP 269 +#define IMPORT 270 +#define INPUT 271 +#define MAP 272 +#define MESSAGES 273 +#define MODULE 274 +#define MULTIPLE 275 +#define OS_DOMAIN 276 +#define OUTPUT 277 +#define PSEUDOPREEMPTION 278 +#define REENTRANT 279 +#define SCREENNAME 280 +#define SHARELIB 281 +#define STACK 282 +#define START 283 +#define SYNCHRONIZE 284 +#define THREADNAME 285 +#define TYPE 286 +#define VERBOSE 287 +#define VERSIONK 288 +#define XDCDATA 289 +#define STRING 290 +#define QUOTED_STRING 291 + +#line 1 "nlmheader.y" +/* nlmheader.y - parse NLM header specification keywords. + Copyright (C) 1993, 94, 95, 97, 1998 Free Software Foundation, Inc. + +This file is part of GNU Binutils. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* Written by Ian Lance Taylor <ian@cygnus.com>. + + This bison file parses the commands recognized by the NetWare NLM + linker, except for lists of object files. It stores the + information in global variables. + + This implementation is based on the description in the NetWare Tool + Maker Specification manual, edition 1.0. */ + +#include <ansidecl.h> +#include <stdio.h> +#include <ctype.h> +#include "bfd.h" +#include "bucomm.h" +#include "nlm/common.h" +#include "nlm/internal.h" +#include "nlmconv.h" + +/* Information is stored in the structures pointed to by these + variables. */ + +Nlm_Internal_Fixed_Header *fixed_hdr; +Nlm_Internal_Variable_Header *var_hdr; +Nlm_Internal_Version_Header *version_hdr; +Nlm_Internal_Copyright_Header *copyright_hdr; +Nlm_Internal_Extended_Header *extended_hdr; + +/* Procedure named by CHECK. */ +char *check_procedure; +/* File named by CUSTOM. */ +char *custom_file; +/* Whether to generate debugging information (DEBUG). */ +boolean debug_info; +/* Procedure named by EXIT. */ +char *exit_procedure; +/* Exported symbols (EXPORT). */ +struct string_list *export_symbols; +/* List of files from INPUT. */ +struct string_list *input_files; +/* Map file name (MAP, FULLMAP). */ +char *map_file; +/* Whether a full map has been requested (FULLMAP). */ +boolean full_map; +/* File named by HELP. */ +char *help_file; +/* Imported symbols (IMPORT). */ +struct string_list *import_symbols; +/* File named by MESSAGES. */ +char *message_file; +/* Autoload module list (MODULE). */ +struct string_list *modules; +/* File named by OUTPUT. */ +char *output_file; +/* File named by SHARELIB. */ +char *sharelib_file; +/* Start procedure name (START). */ +char *start_procedure; +/* VERBOSE. */ +boolean verbose; +/* RPC description file (XDCDATA). */ +char *rpc_file; + +/* The number of serious errors that have occurred. */ +int parse_errors; + +/* The current symbol prefix when reading a list of import or export + symbols. */ +static char *symbol_prefix; + +/* Parser error message handler. */ +#define yyerror(msg) nlmheader_error (msg); + +/* Local functions. */ +static int yylex PARAMS ((void)); +static void nlmlex_file_push PARAMS ((const char *)); +static boolean nlmlex_file_open PARAMS ((const char *)); +static int nlmlex_buf_init PARAMS ((void)); +static char nlmlex_buf_add PARAMS ((int)); +static long nlmlex_get_number PARAMS ((const char *)); +static void nlmheader_identify PARAMS ((void)); +static void nlmheader_warn PARAMS ((const char *, int)); +static void nlmheader_error PARAMS ((const char *)); +static struct string_list * string_list_cons PARAMS ((char *, + struct string_list *)); +static struct string_list * string_list_append PARAMS ((struct string_list *, + struct string_list *)); +static struct string_list * string_list_append1 PARAMS ((struct string_list *, + char *)); +static char *xstrdup PARAMS ((const char *)); + + +#line 112 "nlmheader.y" +typedef union +{ + char *string; + struct string_list *list; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 82 +#define YYFLAG -32768 +#define YYNTBASE 40 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 291 ? yytranslate[x] : 50) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 38, + 39, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 3, 6, 9, 12, 15, 18, 23, 25, + 28, 31, 32, 36, 39, 42, 44, 47, 50, 51, + 55, 58, 60, 63, 66, 69, 71, 73, 76, 78, + 80, 83, 86, 89, 92, 94, 97, 100, 102, 107, + 111, 114, 115, 117, 119, 121, 124, 127, 131, 133, + 134 +}; + +static const short yyrhs[] = { 41, + 0, 0, 42, 41, 0, 3, 36, 0, 4, 36, + 0, 5, 37, 0, 6, 36, 0, 7, 36, 36, + 36, 0, 8, 0, 9, 37, 0, 10, 36, 0, + 0, 11, 43, 45, 0, 12, 36, 0, 13, 36, + 0, 14, 0, 14, 36, 0, 15, 36, 0, 0, + 16, 44, 45, 0, 17, 49, 0, 18, 0, 18, + 36, 0, 19, 36, 0, 20, 49, 0, 21, 0, + 22, 0, 23, 36, 0, 24, 0, 25, 0, 26, + 37, 0, 27, 36, 0, 28, 36, 0, 29, 36, + 0, 30, 0, 31, 37, 0, 32, 36, 0, 33, + 0, 34, 36, 36, 36, 0, 34, 36, 36, 0, + 35, 36, 0, 0, 46, 0, 48, 0, 47, 0, + 46, 48, 0, 46, 47, 0, 38, 36, 39, 0, + 36, 0, 0, 36, 49, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 143, 149, 151, 156, 161, 166, 183, 187, 205, 209, + 225, 229, 234, 237, 242, 247, 252, 257, 261, 266, + 269, 273, 277, 281, 285, 289, 293, 297, 304, 308, + 312, 328, 332, 337, 341, 345, 361, 366, 370, 394, + 410, 418, 423, 433, 438, 442, 446, 454, 465, 481, + 486 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","CHECK", +"CODESTART","COPYRIGHT","CUSTOM","DATE","DEBUG","DESCRIPTION","EXIT","EXPORT", +"FLAG_ON","FLAG_OFF","FULLMAP","HELP","IMPORT","INPUT","MAP","MESSAGES","MODULE", +"MULTIPLE","OS_DOMAIN","OUTPUT","PSEUDOPREEMPTION","REENTRANT","SCREENNAME", +"SHARELIB","STACK","START","SYNCHRONIZE","THREADNAME","TYPE","VERBOSE","VERSIONK", +"XDCDATA","STRING","QUOTED_STRING","'('","')'","file","commands","command","@1", +"@2","symbol_list_opt","symbol_list","symbol_prefix","symbol","string_list", NULL +}; +#endif + +static const short yyr1[] = { 0, + 40, 41, 41, 42, 42, 42, 42, 42, 42, 42, + 42, 43, 42, 42, 42, 42, 42, 42, 44, 42, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + 42, 45, 45, 46, 46, 46, 46, 47, 48, 49, + 49 +}; + +static const short yyr2[] = { 0, + 1, 0, 2, 2, 2, 2, 2, 4, 1, 2, + 2, 0, 3, 2, 2, 1, 2, 2, 0, 3, + 2, 1, 2, 2, 2, 1, 1, 2, 1, 1, + 2, 2, 2, 2, 1, 2, 2, 1, 4, 3, + 2, 0, 1, 1, 1, 2, 2, 3, 1, 0, + 2 +}; + +static const short yydefact[] = { 2, + 0, 0, 0, 0, 0, 9, 0, 0, 12, 0, + 0, 16, 0, 19, 50, 22, 0, 50, 26, 27, + 0, 29, 30, 0, 0, 0, 0, 35, 0, 0, + 38, 0, 0, 1, 2, 4, 5, 6, 7, 0, + 10, 11, 42, 14, 15, 17, 18, 42, 50, 21, + 23, 24, 25, 28, 31, 32, 33, 34, 36, 37, + 0, 41, 3, 0, 49, 0, 13, 43, 45, 44, + 20, 51, 40, 8, 0, 47, 46, 39, 48, 0, + 0, 0 +}; + +static const short yydefgoto[] = { 80, + 34, 35, 43, 48, 67, 68, 69, 70, 50 +}; + +static const short yypact[] = { -3, + -1, 1, 2, 4, 5,-32768, 6, 8,-32768, 9, + 10, 11, 12,-32768, 13, 14, 16, 13,-32768,-32768, + 17,-32768,-32768, 18, 20, 21, 22,-32768, 23, 25, +-32768, 26, 27,-32768, -3,-32768,-32768,-32768,-32768, 29, +-32768,-32768, -2,-32768,-32768,-32768,-32768, -2, 13,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 30,-32768,-32768, 31,-32768, 32,-32768, -2,-32768,-32768, +-32768,-32768, 33,-32768, 3,-32768,-32768,-32768,-32768, 38, + 51,-32768 +}; + +static const short yypgoto[] = {-32768, + 19,-32768,-32768,-32768, 24,-32768, -9, 7, 15 +}; + + +#define YYLAST 75 + + +static const short yytable[] = { 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 53, 65, 36, 66, 37, 81, 38, 39, + 40, 79, 41, 42, 44, 45, 46, 47, 49, 51, + 82, 52, 54, 63, 55, 56, 57, 58, 76, 59, + 60, 61, 62, 72, 64, 73, 74, 75, 78, 0, + 0, 71, 0, 0, 77 +}; + +static const short yycheck[] = { 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 18, 36, 36, 38, 36, 0, 37, 36, + 36, 39, 37, 36, 36, 36, 36, 36, 36, 36, + 0, 36, 36, 35, 37, 36, 36, 36, 68, 37, + 36, 36, 36, 49, 36, 36, 36, 36, 36, -1, + -1, 48, -1, -1, 68 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 4: +#line 158 "nlmheader.y" +{ + check_procedure = yyvsp[0].string; + ; + break;} +case 5: +#line 162 "nlmheader.y" +{ + nlmheader_warn (_("CODESTART is not implemented; sorry"), -1); + free (yyvsp[0].string); + ; + break;} +case 6: +#line 167 "nlmheader.y" +{ + int len; + + strncpy (copyright_hdr->stamp, "CoPyRiGhT=", 10); + len = strlen (yyvsp[0].string); + if (len >= NLM_MAX_COPYRIGHT_MESSAGE_LENGTH) + { + nlmheader_warn (_("copyright string is too long"), + NLM_MAX_COPYRIGHT_MESSAGE_LENGTH - 1); + len = NLM_MAX_COPYRIGHT_MESSAGE_LENGTH - 1; + } + copyright_hdr->copyrightMessageLength = len; + strncpy (copyright_hdr->copyrightMessage, yyvsp[0].string, len); + copyright_hdr->copyrightMessage[len] = '\0'; + free (yyvsp[0].string); + ; + break;} +case 7: +#line 184 "nlmheader.y" +{ + custom_file = yyvsp[0].string; + ; + break;} +case 8: +#line 188 "nlmheader.y" +{ + /* We don't set the version stamp here, because we use the + version stamp to detect whether the required VERSION + keyword was given. */ + version_hdr->month = nlmlex_get_number (yyvsp[-2].string); + version_hdr->day = nlmlex_get_number (yyvsp[-1].string); + version_hdr->year = nlmlex_get_number (yyvsp[0].string); + free (yyvsp[-2].string); + free (yyvsp[-1].string); + free (yyvsp[0].string); + if (version_hdr->month < 1 || version_hdr->month > 12) + nlmheader_warn (_("illegal month"), -1); + if (version_hdr->day < 1 || version_hdr->day > 31) + nlmheader_warn (_("illegal day"), -1); + if (version_hdr->year < 1900 || version_hdr->year > 3000) + nlmheader_warn (_("illegal year"), -1); + ; + break;} +case 9: +#line 206 "nlmheader.y" +{ + debug_info = true; + ; + break;} +case 10: +#line 210 "nlmheader.y" +{ + int len; + + len = strlen (yyvsp[0].string); + if (len > NLM_MAX_DESCRIPTION_LENGTH) + { + nlmheader_warn (_("description string is too long"), + NLM_MAX_DESCRIPTION_LENGTH); + len = NLM_MAX_DESCRIPTION_LENGTH; + } + var_hdr->descriptionLength = len; + strncpy (var_hdr->descriptionText, yyvsp[0].string, len); + var_hdr->descriptionText[len] = '\0'; + free (yyvsp[0].string); + ; + break;} +case 11: +#line 226 "nlmheader.y" +{ + exit_procedure = yyvsp[0].string; + ; + break;} +case 12: +#line 230 "nlmheader.y" +{ + symbol_prefix = NULL; + ; + break;} +case 13: +#line 234 "nlmheader.y" +{ + export_symbols = string_list_append (export_symbols, yyvsp[0].list); + ; + break;} +case 14: +#line 238 "nlmheader.y" +{ + fixed_hdr->flags |= nlmlex_get_number (yyvsp[0].string); + free (yyvsp[0].string); + ; + break;} +case 15: +#line 243 "nlmheader.y" +{ + fixed_hdr->flags &=~ nlmlex_get_number (yyvsp[0].string); + free (yyvsp[0].string); + ; + break;} +case 16: +#line 248 "nlmheader.y" +{ + map_file = ""; + full_map = true; + ; + break;} +case 17: +#line 253 "nlmheader.y" +{ + map_file = yyvsp[0].string; + full_map = true; + ; + break;} +case 18: +#line 258 "nlmheader.y" +{ + help_file = yyvsp[0].string; + ; + break;} +case 19: +#line 262 "nlmheader.y" +{ + symbol_prefix = NULL; + ; + break;} +case 20: +#line 266 "nlmheader.y" +{ + import_symbols = string_list_append (import_symbols, yyvsp[0].list); + ; + break;} +case 21: +#line 270 "nlmheader.y" +{ + input_files = string_list_append (input_files, yyvsp[0].list); + ; + break;} +case 22: +#line 274 "nlmheader.y" +{ + map_file = ""; + ; + break;} +case 23: +#line 278 "nlmheader.y" +{ + map_file = yyvsp[0].string; + ; + break;} +case 24: +#line 282 "nlmheader.y" +{ + message_file = yyvsp[0].string; + ; + break;} +case 25: +#line 286 "nlmheader.y" +{ + modules = string_list_append (modules, yyvsp[0].list); + ; + break;} +case 26: +#line 290 "nlmheader.y" +{ + fixed_hdr->flags |= 0x2; + ; + break;} +case 27: +#line 294 "nlmheader.y" +{ + fixed_hdr->flags |= 0x10; + ; + break;} +case 28: +#line 298 "nlmheader.y" +{ + if (output_file == NULL) + output_file = yyvsp[0].string; + else + nlmheader_warn (_("ignoring duplicate OUTPUT statement"), -1); + ; + break;} +case 29: +#line 305 "nlmheader.y" +{ + fixed_hdr->flags |= 0x8; + ; + break;} +case 30: +#line 309 "nlmheader.y" +{ + fixed_hdr->flags |= 0x1; + ; + break;} +case 31: +#line 313 "nlmheader.y" +{ + int len; + + len = strlen (yyvsp[0].string); + if (len >= NLM_MAX_SCREEN_NAME_LENGTH) + { + nlmheader_warn (_("screen name is too long"), + NLM_MAX_SCREEN_NAME_LENGTH); + len = NLM_MAX_SCREEN_NAME_LENGTH; + } + var_hdr->screenNameLength = len; + strncpy (var_hdr->screenName, yyvsp[0].string, len); + var_hdr->screenName[NLM_MAX_SCREEN_NAME_LENGTH] = '\0'; + free (yyvsp[0].string); + ; + break;} +case 32: +#line 329 "nlmheader.y" +{ + sharelib_file = yyvsp[0].string; + ; + break;} +case 33: +#line 333 "nlmheader.y" +{ + var_hdr->stackSize = nlmlex_get_number (yyvsp[0].string); + free (yyvsp[0].string); + ; + break;} +case 34: +#line 338 "nlmheader.y" +{ + start_procedure = yyvsp[0].string; + ; + break;} +case 35: +#line 342 "nlmheader.y" +{ + fixed_hdr->flags |= 0x4; + ; + break;} +case 36: +#line 346 "nlmheader.y" +{ + int len; + + len = strlen (yyvsp[0].string); + if (len >= NLM_MAX_THREAD_NAME_LENGTH) + { + nlmheader_warn (_("thread name is too long"), + NLM_MAX_THREAD_NAME_LENGTH); + len = NLM_MAX_THREAD_NAME_LENGTH; + } + var_hdr->threadNameLength = len; + strncpy (var_hdr->threadName, yyvsp[0].string, len); + var_hdr->threadName[len] = '\0'; + free (yyvsp[0].string); + ; + break;} +case 37: +#line 362 "nlmheader.y" +{ + fixed_hdr->moduleType = nlmlex_get_number (yyvsp[0].string); + free (yyvsp[0].string); + ; + break;} +case 38: +#line 367 "nlmheader.y" +{ + verbose = true; + ; + break;} +case 39: +#line 371 "nlmheader.y" +{ + long val; + + strncpy (version_hdr->stamp, "VeRsIoN#", 8); + version_hdr->majorVersion = nlmlex_get_number (yyvsp[-2].string); + val = nlmlex_get_number (yyvsp[-1].string); + if (val < 0 || val > 99) + nlmheader_warn (_("illegal minor version number (must be between 0 and 99)"), + -1); + else + version_hdr->minorVersion = val; + val = nlmlex_get_number (yyvsp[0].string); + if (val < 0) + nlmheader_warn (_("illegal revision number (must be between 0 and 26)"), + -1); + else if (val > 26) + version_hdr->revision = 0; + else + version_hdr->revision = val; + free (yyvsp[-2].string); + free (yyvsp[-1].string); + free (yyvsp[0].string); + ; + break;} +case 40: +#line 395 "nlmheader.y" +{ + long val; + + strncpy (version_hdr->stamp, "VeRsIoN#", 8); + version_hdr->majorVersion = nlmlex_get_number (yyvsp[-1].string); + val = nlmlex_get_number (yyvsp[0].string); + if (val < 0 || val > 99) + nlmheader_warn (_("illegal minor version number (must be between 0 and 99)"), + -1); + else + version_hdr->minorVersion = val; + version_hdr->revision = 0; + free (yyvsp[-1].string); + free (yyvsp[0].string); + ; + break;} +case 41: +#line 411 "nlmheader.y" +{ + rpc_file = yyvsp[0].string; + ; + break;} +case 42: +#line 420 "nlmheader.y" +{ + yyval.list = NULL; + ; + break;} +case 43: +#line 424 "nlmheader.y" +{ + yyval.list = yyvsp[0].list; + ; + break;} +case 44: +#line 435 "nlmheader.y" +{ + yyval.list = string_list_cons (yyvsp[0].string, NULL); + ; + break;} +case 45: +#line 439 "nlmheader.y" +{ + yyval.list = NULL; + ; + break;} +case 46: +#line 443 "nlmheader.y" +{ + yyval.list = string_list_append1 (yyvsp[-1].list, yyvsp[0].string); + ; + break;} +case 47: +#line 447 "nlmheader.y" +{ + yyval.list = yyvsp[-1].list; + ; + break;} +case 48: +#line 456 "nlmheader.y" +{ + if (symbol_prefix != NULL) + free (symbol_prefix); + symbol_prefix = yyvsp[-1].string; + ; + break;} +case 49: +#line 467 "nlmheader.y" +{ + if (symbol_prefix == NULL) + yyval.string = yyvsp[0].string; + else + { + yyval.string = xmalloc (strlen (symbol_prefix) + strlen (yyvsp[0].string) + 2); + sprintf (yyval.string, "%s@%s", symbol_prefix, yyvsp[0].string); + free (yyvsp[0].string); + } + ; + break;} +case 50: +#line 483 "nlmheader.y" +{ + yyval.list = NULL; + ; + break;} +case 51: +#line 487 "nlmheader.y" +{ + yyval.list = string_list_cons (yyvsp[-1].string, yyvsp[0].list); + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 492 "nlmheader.y" + + +/* If strerror is just a macro, we want to use the one from libiberty + since it will handle undefined values. */ +#undef strerror +extern char *strerror (); + +/* The lexer is simple, too simple for flex. Keywords are only + recognized at the start of lines. Everything else must be an + argument. A comma is treated as whitespace. */ + +/* The states the lexer can be in. */ + +enum lex_state +{ + /* At the beginning of a line. */ + BEGINNING_OF_LINE, + /* In the middle of a line. */ + IN_LINE +}; + +/* We need to keep a stack of files to handle file inclusion. */ + +struct input +{ + /* The file to read from. */ + FILE *file; + /* The name of the file. */ + char *name; + /* The current line number. */ + int lineno; + /* The current state. */ + enum lex_state state; + /* The next file on the stack. */ + struct input *next; +}; + +/* The current input file. */ + +static struct input current; + +/* The character which introduces comments. */ +#define COMMENT_CHAR '#' + +/* Start the lexer going on the main input file. */ + +boolean +nlmlex_file (name) + const char *name; +{ + current.next = NULL; + return nlmlex_file_open (name); +} + +/* Start the lexer going on a subsidiary input file. */ + +static void +nlmlex_file_push (name) + const char *name; +{ + struct input *push; + + push = (struct input *) xmalloc (sizeof (struct input)); + *push = current; + if (nlmlex_file_open (name)) + current.next = push; + else + { + current = *push; + free (push); + } +} + +/* Start lexing from a file. */ + +static boolean +nlmlex_file_open (name) + const char *name; +{ + current.file = fopen (name, "r"); + if (current.file == NULL) + { + fprintf (stderr, "%s:%s: %s\n", program_name, name, strerror (errno)); + ++parse_errors; + return false; + } + current.name = xstrdup (name); + current.lineno = 1; + current.state = BEGINNING_OF_LINE; + return true; +} + +/* Table used to turn keywords into tokens. */ + +struct keyword_tokens_struct +{ + const char *keyword; + int token; +}; + +struct keyword_tokens_struct keyword_tokens[] = +{ + { "CHECK", CHECK }, + { "CODESTART", CODESTART }, + { "COPYRIGHT", COPYRIGHT }, + { "CUSTOM", CUSTOM }, + { "DATE", DATE }, + { "DEBUG", DEBUG }, + { "DESCRIPTION", DESCRIPTION }, + { "EXIT", EXIT }, + { "EXPORT", EXPORT }, + { "FLAG_ON", FLAG_ON }, + { "FLAG_OFF", FLAG_OFF }, + { "FULLMAP", FULLMAP }, + { "HELP", HELP }, + { "IMPORT", IMPORT }, + { "INPUT", INPUT }, + { "MAP", MAP }, + { "MESSAGES", MESSAGES }, + { "MODULE", MODULE }, + { "MULTIPLE", MULTIPLE }, + { "OS_DOMAIN", OS_DOMAIN }, + { "OUTPUT", OUTPUT }, + { "PSEUDOPREEMPTION", PSEUDOPREEMPTION }, + { "REENTRANT", REENTRANT }, + { "SCREENNAME", SCREENNAME }, + { "SHARELIB", SHARELIB }, + { "STACK", STACK }, + { "STACKSIZE", STACK }, + { "START", START }, + { "SYNCHRONIZE", SYNCHRONIZE }, + { "THREADNAME", THREADNAME }, + { "TYPE", TYPE }, + { "VERBOSE", VERBOSE }, + { "VERSION", VERSIONK }, + { "XDCDATA", XDCDATA } +}; + +#define KEYWORD_COUNT (sizeof (keyword_tokens) / sizeof (keyword_tokens[0])) + +/* The lexer accumulates strings in these variables. */ +static char *lex_buf; +static int lex_size; +static int lex_pos; + +/* Start accumulating strings into the buffer. */ +#define BUF_INIT() \ + ((void) (lex_buf != NULL ? lex_pos = 0 : nlmlex_buf_init ())) + +static int +nlmlex_buf_init () +{ + lex_size = 10; + lex_buf = xmalloc (lex_size + 1); + lex_pos = 0; + return 0; +} + +/* Finish a string in the buffer. */ +#define BUF_FINISH() ((void) (lex_buf[lex_pos] = '\0')) + +/* Accumulate a character into the buffer. */ +#define BUF_ADD(c) \ + ((void) (lex_pos < lex_size \ + ? lex_buf[lex_pos++] = (c) \ + : nlmlex_buf_add (c))) + +static char +nlmlex_buf_add (c) + int c; +{ + if (lex_pos >= lex_size) + { + lex_size *= 2; + lex_buf = xrealloc (lex_buf, lex_size + 1); + } + + return lex_buf[lex_pos++] = c; +} + +/* The lexer proper. This is called by the bison generated parsing + code. */ + +static int +yylex () +{ + int c; + +tail_recurse: + + c = getc (current.file); + + /* Commas are treated as whitespace characters. */ + while (isspace ((unsigned char) c) || c == ',') + { + current.state = IN_LINE; + if (c == '\n') + { + ++current.lineno; + current.state = BEGINNING_OF_LINE; + } + c = getc (current.file); + } + + /* At the end of the file we either pop to the previous file or + finish up. */ + if (c == EOF) + { + fclose (current.file); + free (current.name); + if (current.next == NULL) + return 0; + else + { + struct input *next; + + next = current.next; + current = *next; + free (next); + goto tail_recurse; + } + } + + /* A comment character always means to drop everything until the + next newline. */ + if (c == COMMENT_CHAR) + { + do + { + c = getc (current.file); + } + while (c != '\n'); + ++current.lineno; + current.state = BEGINNING_OF_LINE; + goto tail_recurse; + } + + /* An '@' introduces an include file. */ + if (c == '@') + { + do + { + c = getc (current.file); + if (c == '\n') + ++current.lineno; + } + while (isspace ((unsigned char) c)); + BUF_INIT (); + while (! isspace ((unsigned char) c) && c != EOF) + { + BUF_ADD (c); + c = getc (current.file); + } + BUF_FINISH (); + + ungetc (c, current.file); + + nlmlex_file_push (lex_buf); + goto tail_recurse; + } + + /* A non-space character at the start of a line must be the start of + a keyword. */ + if (current.state == BEGINNING_OF_LINE) + { + BUF_INIT (); + while (isalnum ((unsigned char) c) || c == '_') + { + if (islower ((unsigned char) c)) + BUF_ADD (toupper ((unsigned char) c)); + else + BUF_ADD (c); + c = getc (current.file); + } + BUF_FINISH (); + + if (c != EOF && ! isspace ((unsigned char) c) && c != ',') + { + nlmheader_identify (); + fprintf (stderr, _("%s:%d: illegal character in keyword: %c\n"), + current.name, current.lineno, c); + } + else + { + unsigned int i; + + for (i = 0; i < KEYWORD_COUNT; i++) + { + if (lex_buf[0] == keyword_tokens[i].keyword[0] + && strcmp (lex_buf, keyword_tokens[i].keyword) == 0) + { + /* Pushing back the final whitespace avoids worrying + about \n here. */ + ungetc (c, current.file); + current.state = IN_LINE; + return keyword_tokens[i].token; + } + } + + nlmheader_identify (); + fprintf (stderr, _("%s:%d: unrecognized keyword: %s\n"), + current.name, current.lineno, lex_buf); + } + + ++parse_errors; + /* Treat the rest of this line as a comment. */ + ungetc (COMMENT_CHAR, current.file); + goto tail_recurse; + } + + /* Parentheses just represent themselves. */ + if (c == '(' || c == ')') + return c; + + /* Handle quoted strings. */ + if (c == '"' || c == '\'') + { + int quote; + int start_lineno; + + quote = c; + start_lineno = current.lineno; + + c = getc (current.file); + BUF_INIT (); + while (c != quote && c != EOF) + { + BUF_ADD (c); + if (c == '\n') + ++current.lineno; + c = getc (current.file); + } + BUF_FINISH (); + + if (c == EOF) + { + nlmheader_identify (); + fprintf (stderr, _("%s:%d: end of file in quoted string\n"), + current.name, start_lineno); + ++parse_errors; + } + + /* FIXME: Possible memory leak. */ + yylval.string = xstrdup (lex_buf); + return QUOTED_STRING; + } + + /* Gather a generic argument. */ + BUF_INIT (); + while (! isspace (c) + && c != ',' + && c != COMMENT_CHAR + && c != '(' + && c != ')') + { + BUF_ADD (c); + c = getc (current.file); + } + BUF_FINISH (); + + ungetc (c, current.file); + + /* FIXME: Possible memory leak. */ + yylval.string = xstrdup (lex_buf); + return STRING; +} + +/* Get a number from a string. */ + +static long +nlmlex_get_number (s) + const char *s; +{ + long ret; + char *send; + + ret = strtol (s, &send, 10); + if (*send != '\0') + nlmheader_warn (_("bad number"), -1); + return ret; +} + +/* Prefix the nlmconv warnings with a note as to where they come from. + We don't use program_name on every warning, because then some + versions of the emacs next-error function can't recognize the line + number. */ + +static void +nlmheader_identify () +{ + static int done; + + if (! done) + { + fprintf (stderr, _("%s: problems in NLM command language input:\n"), + program_name); + done = 1; + } +} + +/* Issue a warning. */ + +static void +nlmheader_warn (s, imax) + const char *s; + int imax; +{ + nlmheader_identify (); + fprintf (stderr, "%s:%d: %s", current.name, current.lineno, s); + if (imax != -1) + fprintf (stderr, " (max %d)", imax); + fprintf (stderr, "\n"); +} + +/* Report an error. */ + +static void +nlmheader_error (s) + const char *s; +{ + nlmheader_warn (s, -1); + ++parse_errors; +} + +/* Add a string to a string list. */ + +static struct string_list * +string_list_cons (s, l) + char *s; + struct string_list *l; +{ + struct string_list *ret; + + ret = (struct string_list *) xmalloc (sizeof (struct string_list)); + ret->next = l; + ret->string = s; + return ret; +} + +/* Append a string list to another string list. */ + +static struct string_list * +string_list_append (l1, l2) + struct string_list *l1; + struct string_list *l2; +{ + register struct string_list **pp; + + for (pp = &l1; *pp != NULL; pp = &(*pp)->next) + ; + *pp = l2; + return l1; +} + +/* Append a string to a string list. */ + +static struct string_list * +string_list_append1 (l, s) + struct string_list *l; + char *s; +{ + struct string_list *n; + register struct string_list **pp; + + n = (struct string_list *) xmalloc (sizeof (struct string_list)); + n->next = NULL; + n->string = s; + for (pp = &l; *pp != NULL; pp = &(*pp)->next) + ; + *pp = n; + return l; +} + +/* Duplicate a string in memory. */ + +static char * +xstrdup (s) + const char *s; +{ + unsigned long len; + char *ret; + + len = strlen (s); + ret = xmalloc (len + 1); + strcpy (ret, s); + return ret; +} diff --git a/binutils/nlmheader.h b/binutils/nlmheader.h new file mode 100644 index 00000000000..8c4f2c958b0 --- /dev/null +++ b/binutils/nlmheader.h @@ -0,0 +1,43 @@ +typedef union +{ + char *string; + struct string_list *list; +} YYSTYPE; +#define CHECK 257 +#define CODESTART 258 +#define COPYRIGHT 259 +#define CUSTOM 260 +#define DATE 261 +#define DEBUG 262 +#define DESCRIPTION 263 +#define EXIT 264 +#define EXPORT 265 +#define FLAG_ON 266 +#define FLAG_OFF 267 +#define FULLMAP 268 +#define HELP 269 +#define IMPORT 270 +#define INPUT 271 +#define MAP 272 +#define MESSAGES 273 +#define MODULE 274 +#define MULTIPLE 275 +#define OS_DOMAIN 276 +#define OUTPUT 277 +#define PSEUDOPREEMPTION 278 +#define REENTRANT 279 +#define SCREENNAME 280 +#define SHARELIB 281 +#define STACK 282 +#define START 283 +#define SYNCHRONIZE 284 +#define THREADNAME 285 +#define TYPE 286 +#define VERBOSE 287 +#define VERSIONK 288 +#define XDCDATA 289 +#define STRING 290 +#define QUOTED_STRING 291 + + +extern YYSTYPE yylval; diff --git a/binutils/rclex.c b/binutils/rclex.c new file mode 100644 index 00000000000..6508e1d8b8d --- /dev/null +++ b/binutils/rclex.c @@ -0,0 +1,2589 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> +#include <unistd.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 86 +#define YY_END_OF_BUFFER 87 +static yyconst short int yy_accept[470] = + { 0, + 0, 0, 87, 85, 84, 83, 85, 78, 80, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 2, 4, 84, + 0, 81, 78, 80, 79, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 81, 0, 82, 11, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + + 82, 82, 82, 82, 82, 3, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 76, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 41, 82, 82, + 82, 53, 42, 82, 82, 82, 82, 82, 82, 82, + 46, 82, 82, 82, 82, 82, 82, 71, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + + 82, 82, 82, 7, 82, 82, 82, 38, 1, 82, + 82, 82, 82, 82, 18, 82, 82, 25, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 70, + 82, 82, 39, 40, 82, 82, 82, 82, 82, 30, + 82, 82, 82, 82, 82, 82, 50, 82, 82, 82, + 82, 82, 34, 82, 82, 9, 82, 82, 19, 82, + 68, 82, 82, 82, 82, 82, 82, 12, 0, 82, + 82, 82, 82, 82, 82, 82, 13, 82, 14, 82, + 82, 82, 82, 65, 82, 82, 82, 52, 82, 72, + 82, 82, 82, 82, 82, 82, 47, 82, 82, 82, + + 82, 82, 82, 82, 82, 82, 58, 82, 82, 36, + 82, 82, 82, 82, 82, 82, 82, 82, 0, 82, + 0, 77, 17, 82, 82, 51, 82, 10, 82, 82, + 82, 82, 16, 82, 82, 82, 82, 82, 82, 82, + 29, 82, 82, 82, 82, 82, 82, 82, 73, 82, + 31, 82, 82, 82, 82, 82, 82, 45, 6, 82, + 82, 82, 82, 77, 82, 23, 24, 82, 15, 82, + 27, 82, 82, 66, 82, 28, 54, 43, 82, 82, + 82, 48, 82, 69, 8, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + + 64, 82, 82, 82, 82, 56, 82, 82, 82, 82, + 35, 49, 82, 82, 82, 82, 20, 82, 82, 82, + 82, 82, 82, 82, 82, 74, 82, 82, 82, 32, + 82, 82, 37, 82, 82, 82, 82, 82, 82, 75, + 82, 67, 61, 82, 82, 82, 33, 59, 60, 5, + 21, 82, 82, 82, 82, 55, 57, 82, 82, 82, + 26, 63, 82, 82, 82, 62, 22, 44, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 5, 6, 1, 1, 1, 1, 1, + 1, 1, 1, 7, 1, 1, 1, 8, 8, 8, + 9, 8, 8, 8, 8, 8, 8, 1, 1, 1, + 1, 1, 1, 1, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 19, 26, 27, 28, 29, 30, 19, 31, 32, 19, + 1, 1, 1, 1, 1, 1, 33, 33, 33, 33, + + 33, 33, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 33, + 19, 19, 34, 1, 35, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[36] = + { 0, + 1, 2, 3, 2, 1, 4, 2, 5, 5, 5, + 5, 5, 5, 5, 5, 1, 1, 1, 1, 1, + 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 5, 1, 1 + } ; + +static yyconst short int yy_base[476] = + { 0, + 0, 0, 515, 516, 34, 516, 509, 0, 492, 25, + 26, 45, 25, 28, 24, 486, 497, 49, 0, 40, + 43, 486, 51, 66, 67, 482, 35, 516, 516, 81, + 503, 84, 0, 486, 516, 0, 494, 477, 492, 475, + 74, 474, 477, 475, 46, 489, 69, 484, 471, 481, + 55, 477, 481, 466, 67, 469, 83, 83, 467, 477, + 464, 478, 464, 459, 475, 470, 74, 453, 81, 457, + 86, 76, 468, 467, 465, 452, 452, 458, 95, 461, + 453, 447, 446, 106, 466, 456, 0, 451, 444, 449, + 448, 443, 452, 435, 436, 449, 433, 448, 430, 426, + + 429, 430, 433, 441, 424, 0, 423, 436, 435, 420, + 415, 417, 427, 419, 420, 424, 412, 428, 423, 410, + 424, 405, 406, 407, 419, 409, 0, 402, 409, 416, + 414, 410, 408, 415, 393, 399, 412, 406, 392, 401, + 397, 391, 387, 388, 386, 392, 394, 103, 383, 387, + 399, 388, 389, 396, 385, 377, 379, 376, 373, 376, + 370, 374, 387, 368, 363, 98, 381, 0, 379, 367, + 363, 0, 0, 362, 363, 360, 358, 375, 361, 356, + 105, 373, 372, 351, 355, 355, 349, 0, 366, 352, + 347, 346, 352, 346, 343, 356, 346, 354, 356, 352, + + 347, 344, 349, 0, 335, 344, 350, 0, 0, 334, + 115, 334, 345, 119, 0, 345, 331, 0, 328, 326, + 336, 325, 336, 328, 327, 320, 317, 313, 330, 0, + 330, 331, 0, 0, 327, 322, 329, 314, 314, 0, + 114, 305, 307, 318, 322, 318, 0, 321, 318, 107, + 318, 318, 0, 306, 316, 0, 316, 308, 0, 294, + 0, 298, 307, 294, 291, 304, 304, 0, 132, 137, + 293, 287, 290, 300, 288, 290, 0, 293, 295, 295, + 276, 292, 295, 0, 293, 278, 276, 0, 277, 0, + 270, 283, 267, 285, 270, 281, 0, 280, 279, 271, + + 265, 277, 261, 257, 259, 257, 0, 274, 256, 0, + 255, 254, 258, 248, 269, 268, 265, 258, 270, 143, + 269, 149, 0, 259, 241, 0, 240, 0, 259, 238, + 258, 239, 0, 250, 237, 250, 236, 231, 247, 246, + 0, 249, 247, 247, 234, 227, 240, 225, 0, 222, + 0, 223, 222, 239, 224, 237, 218, 227, 0, 216, + 215, 222, 217, 235, 213, 0, 0, 209, 0, 226, + 0, 209, 203, 0, 216, 0, 0, 0, 212, 206, + 211, 0, 220, 0, 0, 215, 204, 199, 200, 199, + 213, 199, 199, 197, 206, 208, 207, 199, 188, 194, + + 192, 188, 188, 190, 196, 0, 198, 182, 184, 182, + 0, 0, 184, 181, 188, 176, 0, 177, 171, 172, + 170, 183, 186, 181, 171, 0, 183, 171, 164, 0, + 167, 175, 0, 164, 160, 155, 157, 156, 159, 0, + 155, 0, 0, 160, 165, 156, 0, 0, 0, 0, + 0, 141, 150, 141, 139, 0, 0, 128, 122, 126, + 0, 0, 109, 91, 79, 0, 0, 0, 516, 156, + 161, 65, 166, 171, 176 + } ; + +static yyconst short int yy_def[476] = + { 0, + 469, 1, 469, 469, 469, 469, 470, 471, 472, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 469, 469, 469, + 470, 469, 471, 472, 469, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 469, 470, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 469, 474, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 475, 474, + 475, 474, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 475, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 0, 469, + 469, 469, 469, 469, 469 + } ; + +static yyconst short int yy_nxt[552] = + { 0, + 4, 5, 6, 5, 7, 8, 4, 9, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, + 20, 21, 22, 19, 23, 24, 25, 19, 26, 27, + 19, 19, 19, 28, 29, 30, 37, 30, 50, 41, + 52, 55, 51, 42, 81, 38, 43, 56, 82, 63, + 53, 39, 83, 40, 44, 95, 67, 64, 54, 96, + 59, 45, 60, 65, 103, 46, 68, 66, 47, 34, + 61, 62, 48, 49, 70, 73, 71, 74, 76, 72, + 77, 104, 30, 78, 30, 84, 90, 108, 85, 91, + 98, 99, 111, 75, 79, 113, 123, 109, 126, 129, + + 124, 131, 132, 114, 139, 468, 112, 84, 127, 130, + 85, 205, 225, 467, 206, 241, 269, 269, 242, 270, + 140, 226, 243, 295, 227, 228, 141, 229, 207, 273, + 304, 466, 274, 269, 269, 305, 319, 465, 321, 296, + 321, 322, 36, 321, 321, 464, 321, 322, 36, 321, + 321, 463, 321, 322, 36, 321, 31, 31, 462, 31, + 31, 33, 33, 461, 33, 33, 36, 460, 459, 36, + 36, 320, 320, 458, 320, 320, 321, 321, 457, 456, + 321, 455, 454, 453, 452, 451, 450, 449, 448, 447, + 446, 445, 444, 443, 442, 441, 440, 439, 438, 437, + + 436, 435, 434, 433, 432, 431, 430, 429, 428, 427, + 426, 425, 424, 423, 422, 421, 420, 419, 418, 417, + 416, 415, 414, 413, 412, 411, 410, 409, 408, 407, + 406, 405, 404, 403, 402, 401, 400, 399, 398, 364, + 397, 396, 395, 394, 393, 392, 391, 390, 389, 388, + 387, 386, 385, 384, 383, 382, 381, 380, 379, 378, + 377, 376, 375, 374, 373, 372, 371, 370, 369, 368, + 367, 366, 365, 364, 364, 363, 362, 361, 360, 359, + 358, 357, 356, 355, 354, 353, 352, 351, 350, 349, + 348, 347, 346, 345, 344, 343, 342, 341, 340, 339, + + 338, 337, 336, 335, 334, 333, 332, 331, 330, 329, + 328, 327, 326, 325, 324, 323, 318, 317, 316, 315, + 314, 313, 312, 311, 310, 309, 308, 307, 306, 303, + 302, 301, 300, 299, 298, 297, 294, 293, 292, 291, + 290, 289, 288, 287, 286, 285, 284, 283, 282, 281, + 280, 279, 278, 277, 276, 275, 272, 271, 268, 267, + 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, + 256, 255, 254, 253, 252, 251, 250, 249, 248, 247, + 246, 245, 244, 240, 239, 238, 237, 236, 235, 234, + 233, 232, 231, 230, 224, 223, 222, 221, 220, 219, + + 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, + 208, 204, 203, 202, 201, 200, 199, 198, 197, 196, + 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, + 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, + 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, + 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, + 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, + 32, 145, 144, 143, 142, 138, 137, 136, 135, 134, + 133, 128, 125, 122, 121, 120, 119, 118, 117, 116, + 115, 110, 107, 106, 105, 102, 101, 100, 97, 94, + + 93, 92, 89, 88, 87, 86, 35, 32, 80, 69, + 58, 57, 35, 32, 469, 3, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469 + } ; + +static yyconst short int yy_chk[552] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 5, 10, 5, 13, 11, + 14, 15, 13, 11, 27, 10, 11, 15, 27, 20, + 14, 10, 27, 10, 12, 45, 21, 20, 14, 45, + 18, 12, 18, 20, 51, 12, 21, 20, 12, 472, + 18, 18, 12, 12, 23, 24, 23, 24, 25, 23, + 25, 51, 30, 25, 30, 32, 41, 55, 32, 41, + 47, 47, 57, 24, 25, 58, 67, 55, 69, 71, + + 67, 72, 72, 58, 79, 465, 57, 84, 69, 71, + 84, 148, 166, 464, 148, 181, 211, 211, 181, 211, + 79, 166, 181, 241, 166, 166, 79, 166, 148, 214, + 250, 463, 214, 269, 269, 250, 269, 460, 270, 241, + 270, 270, 270, 270, 320, 459, 320, 320, 320, 320, + 322, 458, 322, 322, 322, 322, 470, 470, 455, 470, + 470, 471, 471, 454, 471, 471, 473, 453, 452, 473, + 473, 474, 474, 446, 474, 474, 475, 475, 445, 444, + 475, 441, 439, 438, 437, 436, 435, 434, 432, 431, + 429, 428, 427, 425, 424, 423, 422, 421, 420, 419, + + 418, 416, 415, 414, 413, 410, 409, 408, 407, 405, + 404, 403, 402, 401, 400, 399, 398, 397, 396, 395, + 394, 393, 392, 391, 390, 389, 388, 387, 386, 383, + 381, 380, 379, 375, 373, 372, 370, 368, 365, 364, + 363, 362, 361, 360, 358, 357, 356, 355, 354, 353, + 352, 350, 348, 347, 346, 345, 344, 343, 342, 340, + 339, 338, 337, 336, 335, 334, 332, 331, 330, 329, + 327, 325, 324, 321, 319, 318, 317, 316, 315, 314, + 313, 312, 311, 309, 308, 306, 305, 304, 303, 302, + 301, 300, 299, 298, 296, 295, 294, 293, 292, 291, + + 289, 287, 286, 285, 283, 282, 281, 280, 279, 278, + 276, 275, 274, 273, 272, 271, 267, 266, 265, 264, + 263, 262, 260, 258, 257, 255, 254, 252, 251, 249, + 248, 246, 245, 244, 243, 242, 239, 238, 237, 236, + 235, 232, 231, 229, 228, 227, 226, 225, 224, 223, + 222, 221, 220, 219, 217, 216, 213, 212, 210, 207, + 206, 205, 203, 202, 201, 200, 199, 198, 197, 196, + 195, 194, 193, 192, 191, 190, 189, 187, 186, 185, + 184, 183, 182, 180, 179, 178, 177, 176, 175, 174, + 171, 170, 169, 167, 165, 164, 163, 162, 161, 160, + + 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, + 149, 147, 146, 145, 144, 143, 142, 141, 140, 139, + 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, + 128, 126, 125, 124, 123, 122, 121, 120, 119, 118, + 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, + 107, 105, 104, 103, 102, 101, 100, 99, 98, 97, + 96, 95, 94, 93, 92, 91, 90, 89, 88, 86, + 85, 83, 82, 81, 80, 78, 77, 76, 75, 74, + 73, 70, 68, 66, 65, 64, 63, 62, 61, 60, + 59, 56, 54, 53, 52, 50, 49, 48, 46, 44, + + 43, 42, 40, 39, 38, 37, 34, 31, 26, 22, + 17, 16, 9, 7, 3, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "rclex.l" +#define INITIAL 0 +#line 2 "rclex.l" +/* Copyright 1997, 1998 Free Software Foundation, Inc. + Written by Ian Lance Taylor, Cygnus Support. + + This file is part of GNU Binutils. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ + +/* This is a lex input file which generates a lexer used by the + Windows rc file parser. It basically just recognized a bunch of + keywords. */ + +#include "bfd.h" +#include "bucomm.h" +#include "libiberty.h" +#include "windres.h" +#include "rcparse.h" + +#include <ctype.h> +#include <assert.h> + +/* Whether we are in rcdata mode, in which we returns the lengths of + strings. */ + +static int rcdata_mode; + +/* Whether we are supressing lines from cpp (including windows.h or + headers from your C sources may bring in externs and typedefs). + When active, we return IGNORED_TOKEN, which lets us ignore these + outside of resource constructs. Thus, it isn't required to protect + all the non-preprocessor lines in your header files with #ifdef + RC_INVOKED. It also means your RC file can't include other RC + files if they're named "*.h". Sorry. Name them *.rch or whatever. */ + +static int suppress_cpp_data; + +#define MAYBE_RETURN(x) return suppress_cpp_data ? IGNORED_TOKEN : (x) + +/* The first filename we detect in the cpp output. We use this to + tell included files from the original file. */ + +static char *initial_fn; + +/* List of allocated strings. */ + +struct alloc_string +{ + struct alloc_string *next; + char *s; +}; + +static struct alloc_string *strings; + +/* Local functions. */ + +static void cpp_line PARAMS ((const char *)); +static char *handle_quotes PARAMS ((const char *, unsigned long *)); +static char *get_string PARAMS ((int)); + +#line 710 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 75 "rclex.l" + + +#line 864 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 470 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 516 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 77 "rclex.l" +{ MAYBE_RETURN (BEG); } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 78 "rclex.l" +{ MAYBE_RETURN (BEG); } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 79 "rclex.l" +{ MAYBE_RETURN (END); } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 80 "rclex.l" +{ MAYBE_RETURN (END); } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 81 "rclex.l" +{ MAYBE_RETURN (ACCELERATORS); } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 82 "rclex.l" +{ MAYBE_RETURN (VIRTKEY); } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 83 "rclex.l" +{ MAYBE_RETURN (ASCII); } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 84 "rclex.l" +{ MAYBE_RETURN (NOINVERT); } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 85 "rclex.l" +{ MAYBE_RETURN (SHIFT); } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 86 "rclex.l" +{ MAYBE_RETURN (CONTROL); } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 87 "rclex.l" +{ MAYBE_RETURN (ALT); } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 88 "rclex.l" +{ MAYBE_RETURN (BITMAP); } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 89 "rclex.l" +{ MAYBE_RETURN (CURSOR); } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 90 "rclex.l" +{ MAYBE_RETURN (DIALOG); } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 91 "rclex.l" +{ MAYBE_RETURN (DIALOGEX); } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 92 "rclex.l" +{ MAYBE_RETURN (EXSTYLE); } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 93 "rclex.l" +{ MAYBE_RETURN (CAPTION); } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 94 "rclex.l" +{ MAYBE_RETURN (CLASS); } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 95 "rclex.l" +{ MAYBE_RETURN (STYLE); } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 96 "rclex.l" +{ MAYBE_RETURN (AUTO3STATE); } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 97 "rclex.l" +{ MAYBE_RETURN (AUTOCHECKBOX); } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 98 "rclex.l" +{ MAYBE_RETURN (AUTORADIOBUTTON); } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 99 "rclex.l" +{ MAYBE_RETURN (CHECKBOX); } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 100 "rclex.l" +{ MAYBE_RETURN (COMBOBOX); } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 101 "rclex.l" +{ MAYBE_RETURN (CTEXT); } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 102 "rclex.l" +{ MAYBE_RETURN (DEFPUSHBUTTON); } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 103 "rclex.l" +{ MAYBE_RETURN (EDITTEXT); } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 104 "rclex.l" +{ MAYBE_RETURN (GROUPBOX); } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 105 "rclex.l" +{ MAYBE_RETURN (LISTBOX); } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 106 "rclex.l" +{ MAYBE_RETURN (LTEXT); } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 107 "rclex.l" +{ MAYBE_RETURN (PUSHBOX); } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 108 "rclex.l" +{ MAYBE_RETURN (PUSHBUTTON); } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 109 "rclex.l" +{ MAYBE_RETURN (RADIOBUTTON); } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 110 "rclex.l" +{ MAYBE_RETURN (RTEXT); } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 111 "rclex.l" +{ MAYBE_RETURN (SCROLLBAR); } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 112 "rclex.l" +{ MAYBE_RETURN (STATE3); } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 113 "rclex.l" +{ MAYBE_RETURN (USERBUTTON); } + YY_BREAK +case 38: +YY_RULE_SETUP +#line 114 "rclex.l" +{ MAYBE_RETURN (BEDIT); } + YY_BREAK +case 39: +YY_RULE_SETUP +#line 115 "rclex.l" +{ MAYBE_RETURN (HEDIT); } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 116 "rclex.l" +{ MAYBE_RETURN (IEDIT); } + YY_BREAK +case 41: +YY_RULE_SETUP +#line 117 "rclex.l" +{ MAYBE_RETURN (FONT); } + YY_BREAK +case 42: +YY_RULE_SETUP +#line 118 "rclex.l" +{ MAYBE_RETURN (ICON); } + YY_BREAK +case 43: +YY_RULE_SETUP +#line 119 "rclex.l" +{ MAYBE_RETURN (LANGUAGE); } + YY_BREAK +case 44: +YY_RULE_SETUP +#line 120 "rclex.l" +{ MAYBE_RETURN (CHARACTERISTICS); } + YY_BREAK +case 45: +YY_RULE_SETUP +#line 121 "rclex.l" +{ MAYBE_RETURN (VERSIONK); } + YY_BREAK +case 46: +YY_RULE_SETUP +#line 122 "rclex.l" +{ MAYBE_RETURN (MENU); } + YY_BREAK +case 47: +YY_RULE_SETUP +#line 123 "rclex.l" +{ MAYBE_RETURN (MENUEX); } + YY_BREAK +case 48: +YY_RULE_SETUP +#line 124 "rclex.l" +{ MAYBE_RETURN (MENUITEM); } + YY_BREAK +case 49: +YY_RULE_SETUP +#line 125 "rclex.l" +{ MAYBE_RETURN (SEPARATOR); } + YY_BREAK +case 50: +YY_RULE_SETUP +#line 126 "rclex.l" +{ MAYBE_RETURN (POPUP); } + YY_BREAK +case 51: +YY_RULE_SETUP +#line 127 "rclex.l" +{ MAYBE_RETURN (CHECKED); } + YY_BREAK +case 52: +YY_RULE_SETUP +#line 128 "rclex.l" +{ MAYBE_RETURN (GRAYED); } + YY_BREAK +case 53: +YY_RULE_SETUP +#line 129 "rclex.l" +{ MAYBE_RETURN (HELP); } + YY_BREAK +case 54: +YY_RULE_SETUP +#line 130 "rclex.l" +{ MAYBE_RETURN (INACTIVE); } + YY_BREAK +case 55: +YY_RULE_SETUP +#line 131 "rclex.l" +{ MAYBE_RETURN (MENUBARBREAK); } + YY_BREAK +case 56: +YY_RULE_SETUP +#line 132 "rclex.l" +{ MAYBE_RETURN (MENUBREAK); } + YY_BREAK +case 57: +YY_RULE_SETUP +#line 133 "rclex.l" +{ MAYBE_RETURN (MESSAGETABLE); } + YY_BREAK +case 58: +YY_RULE_SETUP +#line 134 "rclex.l" +{ MAYBE_RETURN (RCDATA); } + YY_BREAK +case 59: +YY_RULE_SETUP +#line 135 "rclex.l" +{ MAYBE_RETURN (STRINGTABLE); } + YY_BREAK +case 60: +YY_RULE_SETUP +#line 136 "rclex.l" +{ MAYBE_RETURN (VERSIONINFO); } + YY_BREAK +case 61: +YY_RULE_SETUP +#line 137 "rclex.l" +{ MAYBE_RETURN (FILEVERSION); } + YY_BREAK +case 62: +YY_RULE_SETUP +#line 138 "rclex.l" +{ MAYBE_RETURN (PRODUCTVERSION); } + YY_BREAK +case 63: +YY_RULE_SETUP +#line 139 "rclex.l" +{ MAYBE_RETURN (FILEFLAGSMASK); } + YY_BREAK +case 64: +YY_RULE_SETUP +#line 140 "rclex.l" +{ MAYBE_RETURN (FILEFLAGS); } + YY_BREAK +case 65: +YY_RULE_SETUP +#line 141 "rclex.l" +{ MAYBE_RETURN (FILEOS); } + YY_BREAK +case 66: +YY_RULE_SETUP +#line 142 "rclex.l" +{ MAYBE_RETURN (FILETYPE); } + YY_BREAK +case 67: +YY_RULE_SETUP +#line 143 "rclex.l" +{ MAYBE_RETURN (FILESUBTYPE); } + YY_BREAK +case 68: +YY_RULE_SETUP +#line 144 "rclex.l" +{ MAYBE_RETURN (VALUE); } + YY_BREAK +case 69: +YY_RULE_SETUP +#line 145 "rclex.l" +{ MAYBE_RETURN (MOVEABLE); } + YY_BREAK +case 70: +YY_RULE_SETUP +#line 146 "rclex.l" +{ MAYBE_RETURN (FIXED); } + YY_BREAK +case 71: +YY_RULE_SETUP +#line 147 "rclex.l" +{ MAYBE_RETURN (PURE); } + YY_BREAK +case 72: +YY_RULE_SETUP +#line 148 "rclex.l" +{ MAYBE_RETURN (IMPURE); } + YY_BREAK +case 73: +YY_RULE_SETUP +#line 149 "rclex.l" +{ MAYBE_RETURN (PRELOAD); } + YY_BREAK +case 74: +YY_RULE_SETUP +#line 150 "rclex.l" +{ MAYBE_RETURN (LOADONCALL); } + YY_BREAK +case 75: +YY_RULE_SETUP +#line 151 "rclex.l" +{ MAYBE_RETURN (DISCARDABLE); } + YY_BREAK +case 76: +YY_RULE_SETUP +#line 152 "rclex.l" +{ MAYBE_RETURN (NOT); } + YY_BREAK +case 77: +YY_RULE_SETUP +#line 154 "rclex.l" +{ + char *s, *send; + + /* This is a hack to let us parse version + information easily. */ + + s = strchr (yytext, '"'); + ++s; + send = strchr (s, '"'); + if (strncmp (s, "StringFileInfo", + sizeof "StringFileInfo" - 1) == 0 + && s + sizeof "StringFileInfo" - 1 == send) + MAYBE_RETURN (BLOCKSTRINGFILEINFO); + else if (strncmp (s, "VarFileInfo", + sizeof "VarFileInfo" - 1) == 0 + && s + sizeof "VarFileInfo" - 1 == send) + MAYBE_RETURN (BLOCKVARFILEINFO); + else + { + char *r; + + r = get_string (send - s + 1); + strncpy (r, s, send - s); + r[send - s] = '\0'; + yylval.s = r; + MAYBE_RETURN (BLOCK); + } + } + YY_BREAK +case 78: +YY_RULE_SETUP +#line 183 "rclex.l" +{ + cpp_line (yytext); + } + YY_BREAK +case 79: +YY_RULE_SETUP +#line 187 "rclex.l" +{ + yylval.i.val = strtoul (yytext, 0, 0); + yylval.i.dword = 1; + MAYBE_RETURN (NUMBER); + } + YY_BREAK +case 80: +YY_RULE_SETUP +#line 193 "rclex.l" +{ + yylval.i.val = strtoul (yytext, 0, 0); + yylval.i.dword = 0; + MAYBE_RETURN (NUMBER); + } + YY_BREAK +case 81: +YY_RULE_SETUP +#line 199 "rclex.l" +{ + char *s; + unsigned long length; + + s = handle_quotes (yytext, &length); + if (! rcdata_mode) + { + yylval.s = s; + MAYBE_RETURN (QUOTEDSTRING); + } + else + { + yylval.ss.length = length; + yylval.ss.s = s; + MAYBE_RETURN (SIZEDSTRING); + } + } + YY_BREAK +case 82: +YY_RULE_SETUP +#line 217 "rclex.l" +{ + char *s; + + /* I rejected comma in a string in order to + handle VIRTKEY, CONTROL in an accelerator + resource. This means that an unquoted + file name can not contain a comma. I + don't know what rc permits. */ + + s = get_string (strlen (yytext) + 1); + strcpy (s, yytext); + yylval.s = s; + MAYBE_RETURN (STRING); + } + YY_BREAK +case 83: +YY_RULE_SETUP +#line 232 "rclex.l" +{ ++rc_lineno; } + YY_BREAK +case 84: +YY_RULE_SETUP +#line 233 "rclex.l" +{ /* ignore whitespace */ } + YY_BREAK +case 85: +YY_RULE_SETUP +#line 234 "rclex.l" +{ MAYBE_RETURN (*yytext); } + YY_BREAK +case 86: +YY_RULE_SETUP +#line 236 "rclex.l" +ECHO; + YY_BREAK +#line 1443 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 470 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 470 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 469); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 236 "rclex.l" + +#ifndef yywrap +/* This is needed for some versions of lex. */ +int yywrap () +{ + return 1; +} +#endif + +/* Handle a C preprocessor line. */ + +static void +cpp_line (s) + const char *s; +{ + int line; + char *send, *fn; + + ++s; + while (isspace ((unsigned char) *s)) + ++s; + + line = strtol (s, &send, 0); + if (*send != '\0' && ! isspace ((unsigned char) *send)) + return; + + /* Subtract 1 because we are about to count the newline. */ + rc_lineno = line - 1; + + s = send; + while (isspace ((unsigned char) *s)) + ++s; + + if (*s != '"') + return; + + ++s; + send = strchr (s, '"'); + if (send == NULL) + return; + + fn = (char *) xmalloc (send - s + 1); + strncpy (fn, s, send - s); + fn[send - s] = '\0'; + + free (rc_filename); + rc_filename = fn; + + if (!initial_fn) + { + initial_fn = xmalloc (strlen (fn) + 1); + strcpy(initial_fn, fn); + } + + /* Allow the initial file, regardless of name. Suppress all other + files if they end in ".h" (this allows included "*.rc") */ + if (strcmp (initial_fn, fn) == 0 + || strcmp (fn + strlen (fn) - 2, ".h") != 0) + suppress_cpp_data = 0; + else + suppress_cpp_data = 1; +} + +/* Handle a quoted string. The quotes are stripped. A pair of quotes + in a string are turned into a single quote. Adjacent strings are + merged separated by whitespace are merged, as in C. */ + +static char * +handle_quotes (input, len) + const char *input; + unsigned long *len; +{ + char *ret, *s; + const char *t; + int ch; + + ret = get_string (strlen (input) + 1); + + s = ret; + t = input; + if (*t == '"') + ++t; + while (*t != '\0') + { + if (*t == '\\') + { + ++t; + switch (*t) + { + case '\0': + rcparse_warning ("backslash at end of string"); + break; + + case '\"': + rcparse_warning ("use \"\" to put \" in a string"); + break; + + case 'a': + *s++ = ESCAPE_A; + ++t; + break; + + case 'b': + *s++ = ESCAPE_B; + ++t; + break; + + case 'f': + *s++ = ESCAPE_F; + ++t; + break; + + case 'n': + *s++ = ESCAPE_N; + ++t; + break; + + case 'r': + *s++ = ESCAPE_R; + ++t; + break; + + case 't': + *s++ = ESCAPE_T; + ++t; + break; + + case 'v': + *s++ = ESCAPE_V; + ++t; + break; + + case '\\': + *s++ = *t++; + break; + + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + ch = *t - '0'; + ++t; + if (*t >= '0' && *t <= '7') + { + ch = (ch << 3) | (*t - '0'); + ++t; + if (*t >= '0' && *t <= '7') + { + ch = (ch << 3) | (*t - '0'); + ++t; + } + } + *s++ = ch; + break; + + case 'x': + ++t; + ch = 0; + while (1) + { + if (*t >= '0' && *t <= '9') + ch = (ch << 4) | (*t - '0'); + else if (*t >= 'a' && *t <= 'f') + ch = (ch << 4) | (*t - 'a'); + else if (*t >= 'A' && *t <= 'F') + ch = (ch << 4) | (*t - 'A'); + else + break; + ++t; + } + *s++ = ch; + break; + + default: + rcparse_warning ("unrecognized escape sequence"); + *s++ = '\\'; + *s++ = *t++; + break; + } + } + else if (*t != '"') + *s++ = *t++; + else if (t[1] == '\0') + break; + else if (t[1] == '"') + { + *s++ = '"'; + t += 2; + } + else + { + ++t; + assert (isspace ((unsigned char) *t)); + while (isspace ((unsigned char) *t)) + ++t; + if (*t == '\0') + break; + assert (*t == '"'); + ++t; + } + } + + *s = '\0'; + + *len = s - ret; + + return ret; +} + +/* Allocate a string of a given length. */ + +static char * +get_string (len) + int len; +{ + struct alloc_string *as; + + as = (struct alloc_string *) xmalloc (sizeof *as); + as->s = xmalloc (len); + + as->next = strings; + strings = as->next; + + return as->s; +} + +/* Discard all the strings we have allocated. The parser calls this + when it no longer needs them. */ + +void +rcparse_discard_strings () +{ + struct alloc_string *as; + + as = strings; + while (as != NULL) + { + struct alloc_string *n; + + free (as->s); + n = as->next; + free (as); + as = n; + } + + strings = NULL; +} + +/* Enter rcdata mode. */ + +void +rcparse_rcdata () +{ + rcdata_mode = 1; +} + +/* Go back to normal mode from rcdata mode. */ + +void +rcparse_normal () +{ + rcdata_mode = 0; +} diff --git a/binutils/rcparse.c b/binutils/rcparse.c new file mode 100644 index 00000000000..dff3302b3d9 --- /dev/null +++ b/binutils/rcparse.c @@ -0,0 +1,3107 @@ + +/* A Bison parser, made from rcparse.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define BEG 257 +#define END 258 +#define ACCELERATORS 259 +#define VIRTKEY 260 +#define ASCII 261 +#define NOINVERT 262 +#define SHIFT 263 +#define CONTROL 264 +#define ALT 265 +#define BITMAP 266 +#define CURSOR 267 +#define DIALOG 268 +#define DIALOGEX 269 +#define EXSTYLE 270 +#define CAPTION 271 +#define CLASS 272 +#define STYLE 273 +#define AUTO3STATE 274 +#define AUTOCHECKBOX 275 +#define AUTORADIOBUTTON 276 +#define CHECKBOX 277 +#define COMBOBOX 278 +#define CTEXT 279 +#define DEFPUSHBUTTON 280 +#define EDITTEXT 281 +#define GROUPBOX 282 +#define LISTBOX 283 +#define LTEXT 284 +#define PUSHBOX 285 +#define PUSHBUTTON 286 +#define RADIOBUTTON 287 +#define RTEXT 288 +#define SCROLLBAR 289 +#define STATE3 290 +#define USERBUTTON 291 +#define BEDIT 292 +#define HEDIT 293 +#define IEDIT 294 +#define FONT 295 +#define ICON 296 +#define LANGUAGE 297 +#define CHARACTERISTICS 298 +#define VERSIONK 299 +#define MENU 300 +#define MENUEX 301 +#define MENUITEM 302 +#define SEPARATOR 303 +#define POPUP 304 +#define CHECKED 305 +#define GRAYED 306 +#define HELP 307 +#define INACTIVE 308 +#define MENUBARBREAK 309 +#define MENUBREAK 310 +#define MESSAGETABLE 311 +#define RCDATA 312 +#define STRINGTABLE 313 +#define VERSIONINFO 314 +#define FILEVERSION 315 +#define PRODUCTVERSION 316 +#define FILEFLAGSMASK 317 +#define FILEFLAGS 318 +#define FILEOS 319 +#define FILETYPE 320 +#define FILESUBTYPE 321 +#define BLOCKSTRINGFILEINFO 322 +#define BLOCKVARFILEINFO 323 +#define VALUE 324 +#define BLOCK 325 +#define MOVEABLE 326 +#define FIXED 327 +#define PURE 328 +#define IMPURE 329 +#define PRELOAD 330 +#define LOADONCALL 331 +#define DISCARDABLE 332 +#define NOT 333 +#define QUOTEDSTRING 334 +#define STRING 335 +#define NUMBER 336 +#define SIZEDSTRING 337 +#define IGNORED_TOKEN 338 +#define NEG 339 + +#line 1 "rcparse.y" + /* rcparse.y -- parser for Windows rc files + Copyright 1997, 1998 Free Software Foundation, Inc. + Written by Ian Lance Taylor, Cygnus Support. + + This file is part of GNU Binutils. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ + +/* This is a parser for Windows rc files. It is based on the parser + by Gunther Ebert <gunther.ebert@ixos-leipzig.de>. */ + +#include "bfd.h" +#include "bucomm.h" +#include "libiberty.h" +#include "windres.h" + +#include <ctype.h> + +/* The current language. */ + +static unsigned short language; + +/* The resource information during a sub statement. */ + +static struct res_res_info sub_res_info; + +/* Dialog information. This is built by the nonterminals styles and + controls. */ + +static struct dialog dialog; + +/* This is used when building a style. It is modified by the + nonterminal styleexpr. */ + +static unsigned long style; + +/* These are used when building a control. They are set before using + control_params. */ + +static unsigned long base_style; +static unsigned long default_style; +static unsigned long class; + + +#line 59 "rcparse.y" +typedef union +{ + struct accelerator acc; + struct accelerator *pacc; + struct dialog_control *dialog_control; + struct menuitem *menuitem; + struct + { + struct rcdata_item *first; + struct rcdata_item *last; + } rcdata; + struct rcdata_item *rcdata_item; + struct stringtable_data *stringtable; + struct fixed_versioninfo *fixver; + struct ver_info *verinfo; + struct ver_stringinfo *verstring; + struct ver_varinfo *vervar; + struct res_id id; + struct res_res_info res_info; + struct + { + unsigned short on; + unsigned short off; + } memflags; + struct + { + unsigned long val; + /* Nonzero if this number was explicitly specified as long. */ + int dword; + } i; + unsigned long il; + unsigned short is; + const char *s; + struct + { + unsigned long length; + const char *s; + } ss; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 475 +#define YYFLAG -32768 +#define YYNTBASE 99 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 339 ? yytranslate[x] : 189) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 92, 87, 2, 97, + 98, 90, 88, 95, 89, 2, 91, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 96, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 86, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 85, 2, 93, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 94 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 1, 5, 9, 13, 17, 21, 25, 29, 33, + 37, 41, 45, 49, 53, 57, 61, 62, 69, 70, + 73, 76, 81, 83, 85, 87, 91, 94, 96, 98, + 100, 102, 104, 106, 111, 116, 117, 131, 132, 146, + 147, 162, 163, 167, 168, 172, 176, 177, 182, 186, + 192, 200, 204, 208, 213, 217, 218, 221, 222, 226, + 227, 231, 232, 236, 237, 241, 242, 246, 247, 251, + 263, 276, 289, 303, 304, 308, 309, 313, 314, 318, + 319, 323, 324, 328, 335, 346, 358, 359, 363, 364, + 368, 369, 373, 374, 378, 379, 383, 384, 388, 389, + 393, 394, 398, 399, 403, 404, 421, 429, 439, 450, + 451, 454, 455, 459, 460, 464, 465, 469, 470, 474, + 479, 484, 488, 495, 496, 499, 504, 507, 514, 515, + 519, 522, 524, 526, 528, 530, 532, 534, 541, 542, + 545, 548, 552, 558, 561, 567, 574, 582, 592, 597, + 604, 605, 608, 609, 611, 613, 615, 619, 623, 624, + 631, 632, 636, 641, 648, 653, 660, 661, 668, 675, + 679, 683, 687, 691, 695, 696, 705, 713, 714, 720, + 721, 725, 727, 729, 730, 733, 737, 742, 746, 747, + 750, 751, 754, 756, 758, 760, 762, 764, 766, 768, + 770, 772, 774, 777, 781, 786, 788, 792, 793, 795, + 798, 800, 802, 806, 809, 812, 816, 820, 824, 828, + 832, 836, 840, 844, 847, 849, 851, 855, 858, 862, + 866, 870, 874, 878, 882, 886 +}; + +static const short yyrhs[] = { -1, + 99, 100, 101, 0, 99, 100, 107, 0, 99, 100, + 108, 0, 99, 100, 109, 0, 99, 100, 148, 0, + 99, 100, 149, 0, 99, 100, 150, 0, 99, 100, + 151, 0, 99, 100, 156, 0, 99, 100, 159, 0, + 99, 100, 160, 0, 99, 100, 165, 0, 99, 100, + 168, 0, 99, 100, 169, 0, 99, 100, 84, 0, + 0, 174, 5, 175, 3, 102, 4, 0, 0, 102, + 103, 0, 104, 186, 0, 104, 186, 95, 105, 0, + 80, 0, 187, 0, 106, 0, 105, 95, 106, 0, + 105, 106, 0, 6, 0, 7, 0, 8, 0, 9, + 0, 10, 0, 11, 0, 174, 12, 177, 179, 0, + 174, 13, 176, 179, 0, 0, 174, 14, 177, 113, + 187, 183, 183, 183, 110, 114, 3, 116, 4, 0, + 0, 174, 15, 177, 113, 187, 183, 183, 183, 111, + 114, 3, 116, 4, 0, 0, 174, 15, 177, 113, + 187, 183, 183, 183, 183, 112, 114, 3, 116, 4, + 0, 0, 16, 96, 184, 0, 0, 114, 17, 80, + 0, 114, 18, 174, 0, 0, 114, 19, 115, 180, + 0, 114, 16, 184, 0, 114, 41, 184, 95, 80, + 0, 114, 41, 184, 95, 80, 183, 183, 0, 114, + 46, 174, 0, 114, 44, 184, 0, 114, 43, 184, + 183, 0, 114, 45, 184, 0, 0, 116, 117, 0, + 0, 20, 118, 139, 0, 0, 21, 119, 139, 0, + 0, 22, 120, 139, 0, 0, 38, 121, 139, 0, + 0, 23, 122, 139, 0, 0, 24, 123, 139, 0, + 10, 140, 184, 183, 142, 183, 183, 183, 183, 182, + 141, 0, 10, 140, 184, 183, 142, 183, 183, 183, + 183, 183, 183, 141, 0, 10, 140, 184, 95, 80, + 142, 183, 183, 183, 183, 182, 141, 0, 10, 140, + 184, 95, 80, 142, 183, 183, 183, 183, 183, 183, + 141, 0, 0, 25, 124, 139, 0, 0, 26, 125, + 139, 0, 0, 27, 126, 139, 0, 0, 28, 127, + 139, 0, 0, 39, 128, 139, 0, 42, 140, 184, + 183, 183, 141, 0, 42, 140, 184, 183, 183, 183, + 183, 144, 182, 141, 0, 42, 140, 184, 183, 183, + 183, 183, 144, 183, 183, 141, 0, 0, 40, 129, + 139, 0, 0, 29, 130, 139, 0, 0, 30, 131, + 139, 0, 0, 31, 132, 139, 0, 0, 32, 133, + 139, 0, 0, 33, 134, 139, 0, 0, 34, 135, + 139, 0, 0, 35, 136, 139, 0, 0, 36, 137, + 139, 0, 0, 37, 80, 95, 184, 95, 184, 95, + 184, 95, 184, 95, 184, 95, 138, 180, 182, 0, + 140, 184, 183, 183, 183, 183, 141, 0, 140, 184, + 183, 183, 183, 183, 146, 182, 141, 0, 140, 184, + 183, 183, 183, 183, 146, 183, 183, 141, 0, 0, + 80, 95, 0, 0, 3, 161, 4, 0, 0, 95, + 143, 180, 0, 0, 95, 145, 180, 0, 0, 95, + 147, 180, 0, 174, 41, 176, 179, 0, 174, 42, + 176, 179, 0, 43, 184, 183, 0, 174, 46, 175, + 3, 152, 4, 0, 0, 152, 153, 0, 48, 80, + 183, 154, 0, 48, 49, 0, 50, 80, 154, 3, + 152, 4, 0, 0, 154, 95, 155, 0, 154, 155, + 0, 51, 0, 52, 0, 53, 0, 54, 0, 55, + 0, 56, 0, 174, 47, 175, 3, 157, 4, 0, + 0, 157, 158, 0, 48, 80, 0, 48, 80, 183, + 0, 48, 80, 183, 183, 182, 0, 48, 49, 0, + 50, 80, 3, 157, 4, 0, 50, 80, 183, 3, + 157, 4, 0, 50, 80, 183, 183, 3, 157, 4, + 0, 50, 80, 183, 183, 183, 182, 3, 157, 4, + 0, 174, 57, 177, 179, 0, 174, 58, 175, 3, + 161, 4, 0, 0, 162, 163, 0, 0, 164, 0, + 83, 0, 185, 0, 164, 95, 83, 0, 164, 95, + 185, 0, 0, 59, 175, 3, 166, 167, 4, 0, + 0, 167, 184, 80, 0, 167, 184, 95, 80, 0, + 174, 174, 175, 3, 161, 4, 0, 174, 174, 175, + 179, 0, 174, 60, 170, 3, 171, 4, 0, 0, + 170, 61, 184, 183, 183, 183, 0, 170, 62, 184, + 183, 183, 183, 0, 170, 63, 184, 0, 170, 64, + 184, 0, 170, 65, 184, 0, 170, 66, 184, 0, + 170, 67, 184, 0, 0, 171, 68, 3, 71, 3, + 172, 4, 4, 0, 171, 69, 3, 70, 80, 173, + 4, 0, 0, 172, 70, 80, 95, 80, 0, 0, + 173, 183, 183, 0, 187, 0, 81, 0, 0, 175, + 178, 0, 175, 44, 184, 0, 175, 43, 184, 183, + 0, 175, 45, 184, 0, 0, 176, 178, 0, 0, + 177, 178, 0, 72, 0, 73, 0, 74, 0, 75, + 0, 76, 0, 77, 0, 78, 0, 80, 0, 81, + 0, 181, 0, 79, 181, 0, 180, 85, 181, 0, + 180, 85, 79, 181, 0, 82, 0, 97, 184, 98, + 0, 0, 183, 0, 95, 184, 0, 185, 0, 82, + 0, 97, 185, 98, 0, 93, 185, 0, 89, 185, + 0, 185, 90, 185, 0, 185, 91, 185, 0, 185, + 92, 185, 0, 185, 88, 185, 0, 185, 89, 185, + 0, 185, 87, 185, 0, 185, 86, 185, 0, 185, + 85, 185, 0, 95, 187, 0, 188, 0, 82, 0, + 97, 185, 98, 0, 93, 185, 0, 188, 90, 185, + 0, 188, 91, 185, 0, 188, 92, 185, 0, 188, + 88, 185, 0, 188, 89, 185, 0, 188, 87, 185, + 0, 188, 86, 185, 0, 188, 85, 185, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 155, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 174, 183, 190, 195, + 215, 221, 232, 254, 263, 268, 273, 279, 284, 289, + 293, 297, 301, 309, 318, 327, 345, 349, 368, 372, + 392, 398, 403, 409, 411, 415, 419, 422, 425, 429, + 435, 448, 452, 456, 460, 466, 468, 478, 486, 489, + 496, 499, 506, 509, 516, 522, 529, 532, 539, 542, + 553, 562, 575, 586, 593, 596, 603, 606, 613, 616, + 623, 626, 633, 639, 650, 662, 672, 679, 685, 692, + 695, 702, 705, 712, 715, 722, 725, 732, 735, 742, + 745, 752, 755, 762, 765, 768, 782, 795, 806, 817, + 822, 828, 833, 841, 845, 847, 851, 853, 857, 861, + 870, 880, 889, 896, 901, 917, 922, 926, 932, 937, + 941, 947, 952, 956, 960, 964, 968, 976, 983, 988, + 1004, 1009, 1013, 1017, 1021, 1025, 1029, 1033, 1042, 1051, + 1061, 1066, 1072, 1078, 1084, 1093, 1101, 1110, 1123, 1126, + 1129, 1131, 1135, 1144, 1149, 1157, 1164, 1171, 1177, 1183, + 1188, 1193, 1198, 1203, 1216, 1221, 1225, 1231, 1236, 1242, + 1247, 1255, 1261, 1278, 1286, 1292, 1297, 1302, 1311, 1318, + 1328, 1335, 1346, 1352, 1357, 1362, 1367, 1372, 1377, 1386, + 1391, 1407, 1412, 1416, 1420, 1426, 1431, 1439, 1444, 1452, + 1461, 1470, 1475, 1479, 1484, 1489, 1494, 1499, 1504, 1509, + 1514, 1519, 1524, 1534, 1543, 1554, 1559, 1563, 1568, 1573, + 1578, 1583, 1588, 1593, 1598, 1603 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","BEG","END", +"ACCELERATORS","VIRTKEY","ASCII","NOINVERT","SHIFT","CONTROL","ALT","BITMAP", +"CURSOR","DIALOG","DIALOGEX","EXSTYLE","CAPTION","CLASS","STYLE","AUTO3STATE", +"AUTOCHECKBOX","AUTORADIOBUTTON","CHECKBOX","COMBOBOX","CTEXT","DEFPUSHBUTTON", +"EDITTEXT","GROUPBOX","LISTBOX","LTEXT","PUSHBOX","PUSHBUTTON","RADIOBUTTON", +"RTEXT","SCROLLBAR","STATE3","USERBUTTON","BEDIT","HEDIT","IEDIT","FONT","ICON", +"LANGUAGE","CHARACTERISTICS","VERSIONK","MENU","MENUEX","MENUITEM","SEPARATOR", +"POPUP","CHECKED","GRAYED","HELP","INACTIVE","MENUBARBREAK","MENUBREAK","MESSAGETABLE", +"RCDATA","STRINGTABLE","VERSIONINFO","FILEVERSION","PRODUCTVERSION","FILEFLAGSMASK", +"FILEFLAGS","FILEOS","FILETYPE","FILESUBTYPE","BLOCKSTRINGFILEINFO","BLOCKVARFILEINFO", +"VALUE","BLOCK","MOVEABLE","FIXED","PURE","IMPURE","PRELOAD","LOADONCALL","DISCARDABLE", +"NOT","QUOTEDSTRING","STRING","NUMBER","SIZEDSTRING","IGNORED_TOKEN","'|'","'^'", +"'&'","'+'","'-'","'*'","'/'","'%'","'~'","NEG","','","'='","'('","')'","input", +"newcmd","accelerator","acc_entries","acc_entry","acc_event","acc_options","acc_option", +"bitmap","cursor","dialog","@1","@2","@3","exstyle","styles","@4","controls", +"control","@5","@6","@7","@8","@9","@10","@11","@12","@13","@14","@15","@16", +"@17","@18","@19","@20","@21","@22","@23","@24","@25","control_params","optstringc", +"opt_control_data","control_styleexpr","@26","icon_styleexpr","@27","control_params_styleexpr", +"@28","font","icon","language","menu","menuitems","menuitem","menuitem_flags", +"menuitem_flag","menuex","menuexitems","menuexitem","messagetable","rcdata", +"optrcdata_data","@29","optrcdata_data_int","rcdata_data","stringtable","@30", +"string_data","user","versioninfo","fixedverinfo","verblocks","vervals","vertrans", +"id","suboptions","memflags_move_discard","memflags_move","memflag","file_name", +"styleexpr","parennumber","optcnumexpr","cnumexpr","numexpr","sizednumexpr", +"cposnumexpr","posnumexpr","sizedposnumexpr", NULL +}; +#endif + +static const short yyr1[] = { 0, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 100, 101, 102, 102, + 103, 103, 104, 104, 105, 105, 105, 106, 106, 106, + 106, 106, 106, 107, 108, 110, 109, 111, 109, 112, + 109, 113, 113, 114, 114, 114, 115, 114, 114, 114, + 114, 114, 114, 114, 114, 116, 116, 118, 117, 119, + 117, 120, 117, 121, 117, 122, 117, 123, 117, 117, + 117, 117, 117, 124, 117, 125, 117, 126, 117, 127, + 117, 128, 117, 117, 117, 117, 129, 117, 130, 117, + 131, 117, 132, 117, 133, 117, 134, 117, 135, 117, + 136, 117, 137, 117, 138, 117, 139, 139, 139, 140, + 140, 141, 141, 143, 142, 145, 144, 147, 146, 148, + 149, 150, 151, 152, 152, 153, 153, 153, 154, 154, + 154, 155, 155, 155, 155, 155, 155, 156, 157, 157, + 158, 158, 158, 158, 158, 158, 158, 158, 159, 160, + 162, 161, 163, 163, 164, 164, 164, 164, 166, 165, + 167, 167, 167, 168, 168, 169, 170, 170, 170, 170, + 170, 170, 170, 170, 171, 171, 171, 172, 172, 173, + 173, 174, 174, 175, 175, 175, 175, 175, 176, 176, + 177, 177, 178, 178, 178, 178, 178, 178, 178, 179, + 179, 180, 180, 180, 180, 181, 181, 182, 182, 183, + 184, 185, 185, 185, 185, 185, 185, 185, 185, 185, + 185, 185, 185, 186, 187, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188 +}; + +static const short yyr2[] = { 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 0, 6, 0, 2, + 2, 4, 1, 1, 1, 3, 2, 1, 1, 1, + 1, 1, 1, 4, 4, 0, 13, 0, 13, 0, + 14, 0, 3, 0, 3, 3, 0, 4, 3, 5, + 7, 3, 3, 4, 3, 0, 2, 0, 3, 0, + 3, 0, 3, 0, 3, 0, 3, 0, 3, 11, + 12, 12, 13, 0, 3, 0, 3, 0, 3, 0, + 3, 0, 3, 6, 10, 11, 0, 3, 0, 3, + 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, + 0, 3, 0, 3, 0, 16, 7, 9, 10, 0, + 2, 0, 3, 0, 3, 0, 3, 0, 3, 4, + 4, 3, 6, 0, 2, 4, 2, 6, 0, 3, + 2, 1, 1, 1, 1, 1, 1, 6, 0, 2, + 2, 3, 5, 2, 5, 6, 7, 9, 4, 6, + 0, 2, 0, 1, 1, 1, 3, 3, 0, 6, + 0, 3, 4, 6, 4, 6, 0, 6, 6, 3, + 3, 3, 3, 3, 0, 8, 7, 0, 5, 0, + 3, 1, 1, 0, 2, 3, 4, 3, 0, 2, + 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 3, 4, 1, 3, 0, 1, 2, + 1, 1, 3, 2, 2, 3, 3, 3, 3, 3, + 3, 3, 3, 2, 1, 1, 3, 2, 3, 3, + 3, 3, 3, 3, 3, 3 +}; + +static const short yydefact[] = { 1, + 17, 0, 0, 184, 183, 226, 16, 0, 0, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 0, 182, 225, 212, 0, 0, 0, + 0, 211, 0, 228, 0, 184, 191, 189, 191, 191, + 189, 189, 184, 184, 191, 184, 167, 184, 0, 0, + 0, 0, 0, 0, 0, 0, 215, 214, 0, 0, + 122, 0, 0, 0, 0, 0, 0, 0, 0, 159, + 0, 0, 0, 193, 194, 195, 196, 197, 198, 199, + 185, 227, 0, 0, 0, 42, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 236, 235, 234, 232, 233, + 229, 230, 231, 213, 210, 223, 222, 221, 219, 220, + 216, 217, 218, 161, 0, 186, 188, 19, 200, 201, + 192, 34, 190, 35, 0, 0, 0, 120, 121, 124, + 139, 149, 151, 175, 0, 0, 0, 0, 0, 0, + 0, 151, 165, 0, 187, 0, 0, 0, 0, 0, + 0, 0, 153, 0, 0, 0, 170, 171, 172, 173, + 174, 0, 160, 0, 18, 23, 20, 0, 24, 43, + 0, 0, 123, 0, 0, 125, 138, 0, 0, 140, + 150, 155, 152, 154, 156, 166, 0, 0, 0, 0, + 164, 162, 0, 0, 21, 0, 0, 127, 0, 129, + 144, 141, 0, 0, 0, 0, 0, 0, 163, 224, + 0, 36, 38, 129, 0, 142, 139, 0, 157, 158, + 0, 0, 168, 169, 28, 29, 30, 31, 32, 33, + 22, 25, 44, 44, 40, 126, 124, 132, 133, 134, + 135, 136, 137, 0, 131, 208, 0, 139, 0, 178, + 180, 0, 27, 0, 0, 44, 0, 130, 143, 209, + 145, 0, 139, 208, 0, 0, 26, 56, 0, 0, + 0, 47, 0, 0, 0, 0, 0, 56, 0, 128, + 146, 0, 0, 0, 0, 177, 0, 0, 49, 45, + 46, 0, 0, 0, 53, 55, 52, 0, 56, 147, + 139, 176, 0, 181, 37, 110, 58, 60, 62, 66, + 68, 74, 76, 78, 80, 89, 91, 93, 95, 97, + 99, 101, 103, 0, 64, 82, 87, 110, 57, 0, + 206, 0, 48, 202, 0, 54, 39, 0, 0, 0, + 0, 0, 110, 110, 110, 110, 110, 110, 110, 110, + 110, 110, 110, 110, 110, 110, 110, 110, 110, 0, + 110, 110, 110, 0, 203, 0, 0, 50, 41, 148, + 179, 111, 0, 59, 0, 61, 63, 67, 69, 75, + 77, 79, 81, 90, 92, 94, 96, 98, 100, 102, + 104, 0, 65, 83, 88, 0, 207, 0, 204, 0, + 0, 0, 0, 0, 0, 205, 51, 0, 114, 0, + 0, 0, 112, 0, 0, 0, 0, 0, 151, 84, + 0, 0, 115, 0, 0, 0, 0, 0, 0, 0, + 112, 0, 113, 116, 208, 0, 208, 118, 107, 208, + 0, 0, 112, 209, 208, 112, 209, 0, 112, 209, + 0, 117, 85, 112, 112, 209, 70, 112, 119, 108, + 112, 0, 86, 72, 112, 71, 109, 0, 73, 105, + 0, 208, 106, 0, 0 +}; + +static const short yydefgoto[] = { 1, + 2, 10, 146, 167, 168, 231, 232, 11, 12, 13, + 233, 234, 256, 126, 254, 292, 288, 329, 343, 344, + 345, 361, 346, 347, 348, 349, 350, 351, 362, 363, + 352, 353, 354, 355, 356, 357, 358, 359, 471, 374, + 375, 420, 410, 415, 435, 442, 440, 448, 14, 15, + 16, 17, 150, 176, 215, 245, 18, 151, 180, 19, + 20, 152, 153, 183, 184, 21, 114, 144, 22, 23, + 94, 154, 265, 266, 24, 33, 85, 84, 81, 122, + 333, 334, 259, 260, 105, 32, 195, 25, 26 +}; + +static const short yypact[] = {-32768, + 39, 284, 231,-32768,-32768,-32768,-32768, 231, 231,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 233,-32768, 601,-32768, 231, 231, 231, + -60, 609, 35,-32768, 314,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 231, 231, + 231, 231, 231, 231, 231, 231,-32768,-32768, 577, 231, +-32768, 231, 231, 231, 231, 231, 231, 231, 231,-32768, + 231, 231, 231,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, 209, 604, 604, 234, 234, 604, 604, 259, + 273, 604, 319, 169, 113, 616, 152, 386, -33, -33, +-32768,-32768,-32768,-32768,-32768, 616, 152, 386, -33, -33, +-32768,-32768,-32768,-32768, -60,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768, -1, 99, 99,-32768,-32768,-32768, +-32768,-32768,-32768,-32768, 231, 231, 231, 231, 231, 231, + 231,-32768,-32768, 0,-32768, 1, 231, -60, -60, 92, + 95, 110, 337, 52, -60, -60,-32768,-32768,-32768,-32768, +-32768, 124,-32768, 59,-32768,-32768,-32768, 32,-32768,-32768, + -60, -60,-32768, -36, 51,-32768,-32768, 42, 68,-32768, +-32768,-32768,-32768, 54, 609,-32768, 150, 161, -60, -60, +-32768,-32768, 75, 99, 66, -60, -60,-32768, -60,-32768, +-32768, -60, 5, 527, 107, 136, -60, -60,-32768,-32768, + 703,-32768, -60,-32768, 20, -60,-32768, 6,-32768, 609, + 212, 137,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 23,-32768,-32768,-32768,-32768, 303,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 664,-32768, -60, 102,-32768, 7,-32768, +-32768, 703,-32768, 446, 454,-32768, 115,-32768,-32768,-32768, +-32768, 120,-32768, -60, 15, 10,-32768,-32768, 231, 141, + 123,-32768, 231, 231, 231, 231, 123,-32768, 463,-32768, +-32768, 121, 219, 221, 143,-32768, -60, 492,-32768,-32768, +-32768, -57, 131, -60,-32768,-32768,-32768, 529,-32768,-32768, +-32768,-32768, 133,-32768,-32768, 157,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 177,-32768,-32768,-32768, 157,-32768, 65, +-32768, 231, 171,-32768, 184,-32768,-32768, 566, 125, 185, + 172, 231, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 173, + 157, 157, 157, 231,-32768, 190, 98, -60,-32768,-32768, +-32768,-32768, 174,-32768, 231,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 231,-32768,-32768,-32768, -60,-32768, 65,-32768, -60, + 289, 194, -60, 197, -60,-32768,-32768, 194,-32768, -60, + -60, 231, 8, -60, -57, -60, -60, 199,-32768,-32768, + -60, -60, 171, -60, -60, 231, 291, 201, -60, -60, + 9, 202,-32768,-32768, -60, -60, -60,-32768,-32768, -60, + 231, -57, 296, -60, -60, 296, -60, -57, 296, -60, + 205, 171,-32768, 296, 296, -60,-32768, 296, 171,-32768, + 296, 231,-32768,-32768, 296,-32768,-32768, 206,-32768,-32768, + -57, 114,-32768, 321,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768,-32768,-32768,-32768,-32768,-32768, -211,-32768,-32768,-32768, +-32768,-32768,-32768, 232, -219,-32768, -254,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 298, + -285, 176, -85,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, 88,-32768, 126, 94,-32768, -171,-32768,-32768, +-32768, -141,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768, -22, 215, 46, 158, 493, 452, + -325, -312, -261, 11, -3, -2,-32768, -110,-32768 +}; + + +#define YYLAST 720 + + +static const short yytable[] = { 31, + 162, 48, 283, 163, 165, 34, 35, 217, 248, 263, + 419, 419, 198, 286, 255, 148, 149, 365, 284, 253, + 342, 330, 237, 298, 331, 57, 58, 59, 225, 226, + 227, 228, 229, 230, 60, 169, 279, 70, 474, 332, + 267, 61, 364, 199, 338, 247, 96, 97, 98, 99, + 100, 101, 102, 103, 399, 186, 67, 68, 69, 106, + 107, 108, 109, 110, 111, 112, 113, 115, 116, 117, + 238, 239, 240, 241, 242, 243, 262, 71, 72, 73, + 166, 27, 6, 210, 285, 406, 88, 89, 28, 423, + 201, 282, 29, 8, 147, 173, 30, 9, 177, 60, + 60, 60, 60, 438, 60, 261, 74, 75, 76, 77, + 78, 79, 80, 181, 244, 142, 452, 252, 280, 187, + 188, 202, 459, 281, 300, 145, 194, 191, 370, 339, + 200, 155, 156, 157, 158, 159, 160, 161, 192, 174, + 164, 175, 178, 170, 179, 472, 331, 203, 204, 178, + 185, 179, 205, 193, 209, 71, 72, 73, 171, 172, + 211, 332, 174, 206, 175, 189, 190, 178, 178, 179, + 179, 134, 178, 443, 179, 446, 398, 221, 449, 331, + 6, 196, 197, 455, 74, 75, 76, 77, 78, 79, + 80, 8, 119, 120, 332, 9, 86, 87, 367, 207, + 208, 220, 92, 5, 6, 222, 212, 213, 60, 214, + 473, 118, 216, 218, 250, 8, 251, 223, 224, 9, + 290, 301, 303, 235, 302, 335, 246, 340, 249, 135, + 136, 137, 138, 139, 140, 141, 341, 36, 64, 65, + 66, 67, 68, 69, 37, 38, 39, 40, 291, 125, + 83, 71, 72, 73, 297, 367, 360, 90, 91, 264, + 93, 130, 95, 368, 371, 289, 372, 392, 401, 293, + 294, 295, 296, 41, 42, 131, 287, 427, 43, 44, + 74, 75, 76, 77, 78, 79, 80, 397, 409, 45, + 46, 412, 47, 426, 433, 434, 441, 304, 419, 462, + 470, 71, 72, 73, 336, 74, 75, 76, 77, 78, + 79, 80, 27, 5, 6, 71, 72, 73, 127, 28, + 475, 133, 414, 29, 257, 8, 3, 30, 366, 9, + 74, 75, 76, 77, 78, 79, 80, 258, 373, 236, + 0, 0, 4, 0, 74, 75, 76, 77, 78, 79, + 80, 0, 0, 238, 239, 240, 241, 242, 243, 0, + 396, 71, 72, 73, 5, 6, 0, 7, 408, 0, + 27, 403, 0, 0, 0, 0, 8, 28, 400, 0, + 9, 29, 0, 402, 0, 30, 0, 0, 404, 0, + 74, 75, 76, 77, 78, 79, 80, 244, 62, 63, + 64, 65, 66, 67, 68, 69, 405, 0, 418, 0, + 407, 82, 0, 411, 0, 413, 0, 0, 27, 182, + 416, 417, 432, 421, 422, 28, 424, 425, 0, 29, + 0, 428, 429, 30, 430, 431, 0, 451, 0, 436, + 437, 0, 0, 0, 0, 444, 445, 447, 268, 0, + 450, 0, 0, 0, 454, 456, 278, 458, 468, 0, + 461, 269, 270, 271, 272, 299, 465, 0, 0, 269, + 270, 271, 272, 65, 66, 67, 68, 69, 269, 270, + 271, 272, 0, 0, 0, 0, 273, 0, 274, 275, + 276, 277, 0, 0, 273, 305, 274, 275, 276, 277, + 0, 306, 0, 273, 0, 274, 275, 276, 277, 0, + 0, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 337, 328, 0, 0, 124, 0, 306, 128, + 129, 0, 0, 132, 0, 0, 143, 0, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 369, + 328, 0, 0, 0, 0, 306, 121, 123, 121, 121, + 123, 123, 0, 0, 121, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 439, 328, 27, 219, + 0, 0, 0, 0, 0, 28, 0, 0, 453, 29, + 0, 457, 0, 30, 460, 0, 0, 0, 0, 463, + 464, 0, 0, 466, 0, 0, 467, 0, 0, 0, + 469, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 0, 393, 394, + 395, 62, 63, 64, 65, 66, 67, 68, 69, 0, + 0, 0, 0, 0, 104, 74, 75, 76, 77, 78, + 79, 80, 0, 119, 120, 49, 50, 51, 52, 53, + 54, 55, 56, 62, 63, 64, 65, 66, 67, 68, + 69, 63, 64, 65, 66, 67, 68, 69, 225, 226, + 227, 228, 229, 230, 238, 239, 240, 241, 242, 243 +}; + +static const short yycheck[] = { 3, + 142, 24, 264, 4, 4, 8, 9, 3, 3, 3, + 3, 3, 49, 4, 234, 126, 127, 330, 4, 231, + 306, 79, 3, 278, 82, 28, 29, 30, 6, 7, + 8, 9, 10, 11, 95, 146, 256, 3, 0, 97, + 252, 31, 328, 80, 299, 217, 49, 50, 51, 52, + 53, 54, 55, 56, 367, 4, 90, 91, 92, 62, + 63, 64, 65, 66, 67, 68, 69, 71, 72, 73, + 51, 52, 53, 54, 55, 56, 248, 43, 44, 45, + 80, 82, 82, 194, 70, 398, 41, 42, 89, 415, + 49, 263, 93, 93, 96, 4, 97, 97, 4, 95, + 95, 95, 95, 95, 95, 4, 72, 73, 74, 75, + 76, 77, 78, 4, 95, 3, 442, 95, 4, 68, + 69, 80, 448, 4, 4, 115, 95, 4, 4, 301, + 80, 135, 136, 137, 138, 139, 140, 141, 80, 48, + 144, 50, 48, 147, 50, 471, 82, 80, 95, 48, + 153, 50, 3, 95, 80, 43, 44, 45, 148, 149, + 95, 97, 48, 3, 50, 155, 156, 48, 48, 50, + 50, 3, 48, 435, 50, 437, 79, 71, 440, 82, + 82, 171, 172, 445, 72, 73, 74, 75, 76, 77, + 78, 93, 80, 81, 97, 97, 39, 40, 85, 189, + 190, 204, 45, 81, 82, 70, 196, 197, 95, 199, + 472, 3, 202, 203, 3, 93, 80, 207, 208, 97, + 80, 3, 80, 213, 4, 95, 216, 95, 218, 61, + 62, 63, 64, 65, 66, 67, 80, 5, 87, 88, + 89, 90, 91, 92, 12, 13, 14, 15, 271, 16, + 36, 43, 44, 45, 277, 85, 80, 43, 44, 249, + 46, 3, 48, 80, 80, 269, 95, 95, 95, 273, + 274, 275, 276, 41, 42, 3, 266, 419, 46, 47, + 72, 73, 74, 75, 76, 77, 78, 98, 95, 57, + 58, 95, 60, 95, 4, 95, 95, 287, 3, 95, + 95, 43, 44, 45, 294, 72, 73, 74, 75, 76, + 77, 78, 82, 81, 82, 43, 44, 45, 87, 89, + 0, 3, 408, 93, 237, 93, 43, 97, 332, 97, + 72, 73, 74, 75, 76, 77, 78, 244, 342, 214, + -1, -1, 59, -1, 72, 73, 74, 75, 76, 77, + 78, -1, -1, 51, 52, 53, 54, 55, 56, -1, + 364, 43, 44, 45, 81, 82, -1, 84, 80, -1, + 82, 375, -1, -1, -1, -1, 93, 89, 368, -1, + 97, 93, -1, 373, -1, 97, -1, -1, 392, -1, + 72, 73, 74, 75, 76, 77, 78, 95, 85, 86, + 87, 88, 89, 90, 91, 92, 396, -1, 412, -1, + 400, 98, -1, 403, -1, 405, -1, -1, 82, 83, + 410, 411, 426, 413, 414, 89, 416, 417, -1, 93, + -1, 421, 422, 97, 424, 425, -1, 441, -1, 429, + 430, -1, -1, -1, -1, 435, 436, 437, 3, -1, + 440, -1, -1, -1, 444, 445, 3, 447, 462, -1, + 450, 16, 17, 18, 19, 3, 456, -1, -1, 16, + 17, 18, 19, 88, 89, 90, 91, 92, 16, 17, + 18, 19, -1, -1, -1, -1, 41, -1, 43, 44, + 45, 46, -1, -1, 41, 4, 43, 44, 45, 46, + -1, 10, -1, 41, -1, 43, 44, 45, 46, -1, + -1, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 4, 42, -1, -1, 85, -1, 10, 88, + 89, -1, -1, 92, -1, -1, 95, -1, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 4, + 42, -1, -1, -1, -1, 10, 84, 85, 86, 87, + 88, 89, -1, -1, 92, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 431, 42, 82, 83, + -1, -1, -1, -1, -1, 89, -1, -1, 443, 93, + -1, 446, -1, 97, 449, -1, -1, -1, -1, 454, + 455, -1, -1, 458, -1, -1, 461, -1, -1, -1, + 465, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, -1, 361, 362, + 363, 85, 86, 87, 88, 89, 90, 91, 92, -1, + -1, -1, -1, -1, 98, 72, 73, 74, 75, 76, + 77, 78, -1, 80, 81, 85, 86, 87, 88, 89, + 90, 91, 92, 85, 86, 87, 88, 89, 90, 91, + 92, 86, 87, 88, 89, 90, 91, 92, 6, 7, + 8, 9, 10, 11, 51, 52, 53, 54, 55, 56 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 17: +#line 176 "rcparse.y" +{ + rcparse_discard_strings (); + ; + break;} +case 18: +#line 185 "rcparse.y" +{ + define_accelerator (yyvsp[-5].id, &yyvsp[-3].res_info, yyvsp[-1].pacc); + ; + break;} +case 19: +#line 192 "rcparse.y" +{ + yyval.pacc = NULL; + ; + break;} +case 20: +#line 196 "rcparse.y" +{ + struct accelerator *a; + + a = (struct accelerator *) res_alloc (sizeof *a); + *a = yyvsp[0].acc; + if (yyvsp[-1].pacc == NULL) + yyval.pacc = a; + else + { + struct accelerator **pp; + + for (pp = &yyvsp[-1].pacc->next; *pp != NULL; pp = &(*pp)->next) + ; + *pp = a; + yyval.pacc = yyvsp[-1].pacc; + } + ; + break;} +case 21: +#line 217 "rcparse.y" +{ + yyval.acc = yyvsp[-1].acc; + yyval.acc.id = yyvsp[0].il; + ; + break;} +case 22: +#line 222 "rcparse.y" +{ + yyval.acc = yyvsp[-3].acc; + yyval.acc.id = yyvsp[-2].il; + yyval.acc.flags |= yyvsp[0].is; + if ((yyval.acc.flags & ACC_VIRTKEY) == 0 + && (yyval.acc.flags & (ACC_SHIFT | ACC_CONTROL | ACC_ALT)) != 0) + rcparse_warning (_("inappropriate modifiers for non-VIRTKEY")); + ; + break;} +case 23: +#line 234 "rcparse.y" +{ + const char *s = yyvsp[0].s; + char ch; + + yyval.acc.next = NULL; + yyval.acc.id = 0; + ch = *s; + if (ch != '^') + yyval.acc.flags = 0; + else + { + yyval.acc.flags = ACC_CONTROL | ACC_VIRTKEY; + ++s; + ch = *s; + ch = toupper ((unsigned char) ch); + } + yyval.acc.key = ch; + if (s[1] != '\0') + rcparse_warning (_("accelerator should only be one character")); + ; + break;} +case 24: +#line 255 "rcparse.y" +{ + yyval.acc.next = NULL; + yyval.acc.flags = 0; + yyval.acc.id = 0; + yyval.acc.key = yyvsp[0].il; + ; + break;} +case 25: +#line 265 "rcparse.y" +{ + yyval.is = yyvsp[0].is; + ; + break;} +case 26: +#line 269 "rcparse.y" +{ + yyval.is = yyvsp[-2].is | yyvsp[0].is; + ; + break;} +case 27: +#line 274 "rcparse.y" +{ + yyval.is = yyvsp[-1].is | yyvsp[0].is; + ; + break;} +case 28: +#line 281 "rcparse.y" +{ + yyval.is = ACC_VIRTKEY; + ; + break;} +case 29: +#line 285 "rcparse.y" +{ + /* This is just the absence of VIRTKEY. */ + yyval.is = 0; + ; + break;} +case 30: +#line 290 "rcparse.y" +{ + yyval.is = ACC_NOINVERT; + ; + break;} +case 31: +#line 294 "rcparse.y" +{ + yyval.is = ACC_SHIFT; + ; + break;} +case 32: +#line 298 "rcparse.y" +{ + yyval.is = ACC_CONTROL; + ; + break;} +case 33: +#line 302 "rcparse.y" +{ + yyval.is = ACC_ALT; + ; + break;} +case 34: +#line 311 "rcparse.y" +{ + define_bitmap (yyvsp[-3].id, &yyvsp[-1].res_info, yyvsp[0].s); + ; + break;} +case 35: +#line 320 "rcparse.y" +{ + define_cursor (yyvsp[-3].id, &yyvsp[-1].res_info, yyvsp[0].s); + ; + break;} +case 36: +#line 330 "rcparse.y" +{ + memset (&dialog, 0, sizeof dialog); + dialog.x = yyvsp[-3].il; + dialog.y = yyvsp[-2].il; + dialog.width = yyvsp[-1].il; + dialog.height = yyvsp[0].il; + dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU; + dialog.exstyle = yyvsp[-4].il; + dialog.menu.named = 1; + dialog.class.named = 1; + dialog.font = NULL; + dialog.ex = NULL; + dialog.controls = NULL; + sub_res_info = yyvsp[-5].res_info; + ; + break;} +case 37: +#line 346 "rcparse.y" +{ + define_dialog (yyvsp[-12].id, &sub_res_info, &dialog); + ; + break;} +case 38: +#line 351 "rcparse.y" +{ + memset (&dialog, 0, sizeof dialog); + dialog.x = yyvsp[-3].il; + dialog.y = yyvsp[-2].il; + dialog.width = yyvsp[-1].il; + dialog.height = yyvsp[0].il; + dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU; + dialog.exstyle = yyvsp[-4].il; + dialog.menu.named = 1; + dialog.class.named = 1; + dialog.font = NULL; + dialog.ex = ((struct dialog_ex *) + res_alloc (sizeof (struct dialog_ex))); + memset (dialog.ex, 0, sizeof (struct dialog_ex)); + dialog.controls = NULL; + sub_res_info = yyvsp[-5].res_info; + ; + break;} +case 39: +#line 369 "rcparse.y" +{ + define_dialog (yyvsp[-12].id, &sub_res_info, &dialog); + ; + break;} +case 40: +#line 374 "rcparse.y" +{ + memset (&dialog, 0, sizeof dialog); + dialog.x = yyvsp[-4].il; + dialog.y = yyvsp[-3].il; + dialog.width = yyvsp[-2].il; + dialog.height = yyvsp[-1].il; + dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU; + dialog.exstyle = yyvsp[-5].il; + dialog.menu.named = 1; + dialog.class.named = 1; + dialog.font = NULL; + dialog.ex = ((struct dialog_ex *) + res_alloc (sizeof (struct dialog_ex))); + memset (dialog.ex, 0, sizeof (struct dialog_ex)); + dialog.ex->help = yyvsp[0].il; + dialog.controls = NULL; + sub_res_info = yyvsp[-6].res_info; + ; + break;} +case 41: +#line 393 "rcparse.y" +{ + define_dialog (yyvsp[-13].id, &sub_res_info, &dialog); + ; + break;} +case 42: +#line 400 "rcparse.y" +{ + yyval.il = 0; + ; + break;} +case 43: +#line 404 "rcparse.y" +{ + yyval.il = yyvsp[0].il; + ; + break;} +case 45: +#line 412 "rcparse.y" +{ + unicode_from_ascii ((int *) NULL, &dialog.caption, yyvsp[0].s); + ; + break;} +case 46: +#line 416 "rcparse.y" +{ + dialog.class = yyvsp[0].id; + ; + break;} +case 47: +#line 420 "rcparse.y" +{ style = dialog.style; ; + break;} +case 48: +#line 422 "rcparse.y" +{ + dialog.style = style; + ; + break;} +case 49: +#line 426 "rcparse.y" +{ + dialog.exstyle = yyvsp[0].il; + ; + break;} +case 50: +#line 430 "rcparse.y" +{ + dialog.style |= DS_SETFONT; + dialog.pointsize = yyvsp[-2].il; + unicode_from_ascii ((int *) NULL, &dialog.font, yyvsp[0].s); + ; + break;} +case 51: +#line 436 "rcparse.y" +{ + dialog.style |= DS_SETFONT; + dialog.pointsize = yyvsp[-4].il; + unicode_from_ascii ((int *) NULL, &dialog.font, yyvsp[-2].s); + if (dialog.ex == NULL) + rcparse_warning (_("extended FONT requires DIALOGEX")); + else + { + dialog.ex->weight = yyvsp[-1].il; + dialog.ex->italic = yyvsp[0].il; + } + ; + break;} +case 52: +#line 449 "rcparse.y" +{ + dialog.menu = yyvsp[0].id; + ; + break;} +case 53: +#line 453 "rcparse.y" +{ + sub_res_info.characteristics = yyvsp[0].il; + ; + break;} +case 54: +#line 457 "rcparse.y" +{ + sub_res_info.language = yyvsp[-1].il | (yyvsp[0].il << 8); + ; + break;} +case 55: +#line 461 "rcparse.y" +{ + sub_res_info.version = yyvsp[0].il; + ; + break;} +case 57: +#line 469 "rcparse.y" +{ + struct dialog_control **pp; + + for (pp = &dialog.controls; *pp != NULL; pp = &(*pp)->next) + ; + *pp = yyvsp[0].dialog_control; + ; + break;} +case 58: +#line 480 "rcparse.y" +{ + default_style = BS_AUTO3STATE | WS_TABSTOP; + base_style = BS_AUTO3STATE; + class = CTL_BUTTON; + ; + break;} +case 59: +#line 486 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 60: +#line 490 "rcparse.y" +{ + default_style = BS_AUTOCHECKBOX | WS_TABSTOP; + base_style = BS_AUTOCHECKBOX; + class = CTL_BUTTON; + ; + break;} +case 61: +#line 496 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 62: +#line 500 "rcparse.y" +{ + default_style = BS_AUTORADIOBUTTON | WS_TABSTOP; + base_style = BS_AUTORADIOBUTTON; + class = CTL_BUTTON; + ; + break;} +case 63: +#line 506 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 64: +#line 510 "rcparse.y" +{ + default_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + base_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + class = CTL_EDIT; + ; + break;} +case 65: +#line 516 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + if (dialog.ex == NULL) + rcparse_warning (_("IEDIT requires DIALOGEX")); + res_string_to_id (&yyval.dialog_control->class, "BEDIT"); + ; + break;} +case 66: +#line 523 "rcparse.y" +{ + default_style = BS_CHECKBOX | WS_TABSTOP; + base_style = BS_CHECKBOX | WS_TABSTOP; + class = CTL_BUTTON; + ; + break;} +case 67: +#line 529 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 68: +#line 533 "rcparse.y" +{ + default_style = CBS_SIMPLE | WS_TABSTOP; + base_style = 0; + class = CTL_COMBOBOX; + ; + break;} +case 69: +#line 539 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 70: +#line 544 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-9].s, yyvsp[-8].il, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, yyvsp[-2].il, yyvsp[-7].il, style, yyvsp[-1].il); + if (yyvsp[0].rcdata_item != NULL) + { + if (dialog.ex == NULL) + rcparse_warning (_("control data requires DIALOGEX")); + yyval.dialog_control->data = yyvsp[0].rcdata_item; + } + ; + break;} +case 71: +#line 555 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-10].s, yyvsp[-9].il, yyvsp[-6].il, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, yyvsp[-8].il, style, yyvsp[-2].il); + if (dialog.ex == NULL) + rcparse_warning (_("help ID requires DIALOGEX")); + yyval.dialog_control->help = yyvsp[-1].il; + yyval.dialog_control->data = yyvsp[0].rcdata_item; + ; + break;} +case 72: +#line 564 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-10].s, yyvsp[-9].il, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, yyvsp[-2].il, 0, style, yyvsp[-1].il); + if (yyvsp[0].rcdata_item != NULL) + { + if (dialog.ex == NULL) + rcparse_warning ("control data requires DIALOGEX"); + yyval.dialog_control->data = yyvsp[0].rcdata_item; + } + yyval.dialog_control->class.named = 1; + unicode_from_ascii(&yyval.dialog_control->class.u.n.length, &yyval.dialog_control->class.u.n.name, yyvsp[-7].s); + ; + break;} +case 73: +#line 577 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-11].s, yyvsp[-10].il, yyvsp[-6].il, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, 0, style, yyvsp[-2].il); + if (dialog.ex == NULL) + rcparse_warning ("help ID requires DIALOGEX"); + yyval.dialog_control->help = yyvsp[-1].il; + yyval.dialog_control->data = yyvsp[0].rcdata_item; + yyval.dialog_control->class.named = 1; + unicode_from_ascii(&yyval.dialog_control->class.u.n.length, &yyval.dialog_control->class.u.n.name, yyvsp[-8].s); + ; + break;} +case 74: +#line 587 "rcparse.y" +{ + default_style = SS_CENTER | WS_GROUP; + base_style = SS_CENTER; + class = CTL_STATIC; + ; + break;} +case 75: +#line 593 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 76: +#line 597 "rcparse.y" +{ + default_style = BS_DEFPUSHBUTTON | WS_TABSTOP; + base_style = BS_DEFPUSHBUTTON | WS_TABSTOP; + class = CTL_BUTTON; + ; + break;} +case 77: +#line 603 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 78: +#line 607 "rcparse.y" +{ + default_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + base_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + class = CTL_EDIT; + ; + break;} +case 79: +#line 613 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 80: +#line 617 "rcparse.y" +{ + default_style = BS_GROUPBOX; + base_style = BS_GROUPBOX; + class = CTL_BUTTON; + ; + break;} +case 81: +#line 623 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 82: +#line 627 "rcparse.y" +{ + default_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + base_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + class = CTL_EDIT; + ; + break;} +case 83: +#line 633 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + if (dialog.ex == NULL) + rcparse_warning (_("IEDIT requires DIALOGEX")); + res_string_to_id (&yyval.dialog_control->class, "HEDIT"); + ; + break;} +case 84: +#line 640 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-4].s, yyvsp[-3].il, yyvsp[-2].il, yyvsp[-1].il, 0, 0, CTL_STATIC, + SS_ICON | WS_CHILD | WS_VISIBLE, 0); + if (yyvsp[0].rcdata_item != NULL) + { + if (dialog.ex == NULL) + rcparse_warning (_("control data requires DIALOGEX")); + yyval.dialog_control->data = yyvsp[0].rcdata_item; + } + ; + break;} +case 85: +#line 652 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-8].s, yyvsp[-7].il, yyvsp[-6].il, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, CTL_STATIC, + style, yyvsp[-1].il); + if (yyvsp[0].rcdata_item != NULL) + { + if (dialog.ex == NULL) + rcparse_warning (_("control data requires DIALOGEX")); + yyval.dialog_control->data = yyvsp[0].rcdata_item; + } + ; + break;} +case 86: +#line 664 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-9].s, yyvsp[-8].il, yyvsp[-7].il, yyvsp[-6].il, yyvsp[-5].il, yyvsp[-4].il, CTL_STATIC, + style, yyvsp[-2].il); + if (dialog.ex == NULL) + rcparse_warning (_("help ID requires DIALOGEX")); + yyval.dialog_control->help = yyvsp[-1].il; + yyval.dialog_control->data = yyvsp[0].rcdata_item; + ; + break;} +case 87: +#line 673 "rcparse.y" +{ + default_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + base_style = ES_LEFT | WS_BORDER | WS_TABSTOP; + class = CTL_EDIT; + ; + break;} +case 88: +#line 679 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + if (dialog.ex == NULL) + rcparse_warning (_("IEDIT requires DIALOGEX")); + res_string_to_id (&yyval.dialog_control->class, "IEDIT"); + ; + break;} +case 89: +#line 686 "rcparse.y" +{ + default_style = LBS_NOTIFY | WS_BORDER; + base_style = LBS_NOTIFY | WS_BORDER; + class = CTL_LISTBOX; + ; + break;} +case 90: +#line 692 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 91: +#line 696 "rcparse.y" +{ + default_style = SS_LEFT | WS_GROUP; + base_style = SS_LEFT; + class = CTL_STATIC; + ; + break;} +case 92: +#line 702 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 93: +#line 706 "rcparse.y" +{ + default_style = BS_PUSHBOX | WS_TABSTOP; + base_style = BS_PUSHBOX; + class = CTL_BUTTON; + ; + break;} +case 94: +#line 712 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 95: +#line 716 "rcparse.y" +{ + default_style = BS_PUSHBUTTON | WS_TABSTOP; + base_style = BS_PUSHBUTTON | WS_TABSTOP; + class = CTL_BUTTON; + ; + break;} +case 96: +#line 722 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 97: +#line 726 "rcparse.y" +{ + default_style = BS_RADIOBUTTON | WS_TABSTOP; + base_style = BS_RADIOBUTTON; + class = CTL_BUTTON; + ; + break;} +case 98: +#line 732 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 99: +#line 736 "rcparse.y" +{ + default_style = SS_RIGHT | WS_GROUP; + base_style = SS_RIGHT; + class = CTL_STATIC; + ; + break;} +case 100: +#line 742 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 101: +#line 746 "rcparse.y" +{ + default_style = SBS_HORZ; + base_style = 0; + class = CTL_SCROLLBAR; + ; + break;} +case 102: +#line 752 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 103: +#line 756 "rcparse.y" +{ + default_style = BS_3STATE | WS_TABSTOP; + base_style = BS_3STATE; + class = CTL_BUTTON; + ; + break;} +case 104: +#line 762 "rcparse.y" +{ + yyval.dialog_control = yyvsp[0].dialog_control; + ; + break;} +case 105: +#line 767 "rcparse.y" +{ style = WS_CHILD | WS_VISIBLE; ; + break;} +case 106: +#line 769 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-14].s, yyvsp[-12].il, yyvsp[-10].il, yyvsp[-8].il, yyvsp[-6].il, yyvsp[-4].il, CTL_BUTTON, + style, yyvsp[0].il); + ; + break;} +case 107: +#line 785 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-6].s, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, yyvsp[-2].il, yyvsp[-1].il, class, + default_style | WS_CHILD | WS_VISIBLE, 0); + if (yyvsp[0].rcdata_item != NULL) + { + if (dialog.ex == NULL) + rcparse_warning (_("control data requires DIALOGEX")); + yyval.dialog_control->data = yyvsp[0].rcdata_item; + } + ; + break;} +case 108: +#line 797 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-8].s, yyvsp[-7].il, yyvsp[-6].il, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, class, style, yyvsp[-1].il); + if (yyvsp[0].rcdata_item != NULL) + { + if (dialog.ex == NULL) + rcparse_warning (_("control data requires DIALOGEX")); + yyval.dialog_control->data = yyvsp[0].rcdata_item; + } + ; + break;} +case 109: +#line 808 "rcparse.y" +{ + yyval.dialog_control = define_control (yyvsp[-9].s, yyvsp[-8].il, yyvsp[-7].il, yyvsp[-6].il, yyvsp[-5].il, yyvsp[-4].il, class, style, yyvsp[-2].il); + if (dialog.ex == NULL) + rcparse_warning (_("help ID requires DIALOGEX")); + yyval.dialog_control->help = yyvsp[-1].il; + yyval.dialog_control->data = yyvsp[0].rcdata_item; + ; + break;} +case 110: +#line 819 "rcparse.y" +{ + yyval.s = NULL; + ; + break;} +case 111: +#line 823 "rcparse.y" +{ + yyval.s = yyvsp[-1].s; + ; + break;} +case 112: +#line 830 "rcparse.y" +{ + yyval.rcdata_item = NULL; + ; + break;} +case 113: +#line 834 "rcparse.y" +{ + yyval.rcdata_item = yyvsp[-1].rcdata.first; + ; + break;} +case 114: +#line 843 "rcparse.y" +{ style = WS_CHILD | WS_VISIBLE; ; + break;} +case 116: +#line 849 "rcparse.y" +{ style = SS_ICON | WS_CHILD | WS_VISIBLE; ; + break;} +case 118: +#line 855 "rcparse.y" +{ style = base_style | WS_CHILD | WS_VISIBLE; ; + break;} +case 120: +#line 863 "rcparse.y" +{ + define_font (yyvsp[-3].id, &yyvsp[-1].res_info, yyvsp[0].s); + ; + break;} +case 121: +#line 872 "rcparse.y" +{ + define_icon (yyvsp[-3].id, &yyvsp[-1].res_info, yyvsp[0].s); + ; + break;} +case 122: +#line 882 "rcparse.y" +{ + language = yyvsp[-1].il | (yyvsp[0].il << 8); + ; + break;} +case 123: +#line 891 "rcparse.y" +{ + define_menu (yyvsp[-5].id, &yyvsp[-3].res_info, yyvsp[-1].menuitem); + ; + break;} +case 124: +#line 898 "rcparse.y" +{ + yyval.menuitem = NULL; + ; + break;} +case 125: +#line 902 "rcparse.y" +{ + if (yyvsp[-1].menuitem == NULL) + yyval.menuitem = yyvsp[0].menuitem; + else + { + struct menuitem **pp; + + for (pp = &yyvsp[-1].menuitem->next; *pp != NULL; pp = &(*pp)->next) + ; + *pp = yyvsp[0].menuitem; + yyval.menuitem = yyvsp[-1].menuitem; + } + ; + break;} +case 126: +#line 919 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-2].s, yyvsp[-1].il, yyvsp[0].is, 0, 0, NULL); + ; + break;} +case 127: +#line 923 "rcparse.y" +{ + yyval.menuitem = define_menuitem (NULL, 0, 0, 0, 0, NULL); + ; + break;} +case 128: +#line 927 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-4].s, 0, yyvsp[-3].is, 0, 0, yyvsp[-1].menuitem); + ; + break;} +case 129: +#line 934 "rcparse.y" +{ + yyval.is = 0; + ; + break;} +case 130: +#line 938 "rcparse.y" +{ + yyval.is = yyvsp[-2].is | yyvsp[0].is; + ; + break;} +case 131: +#line 942 "rcparse.y" +{ + yyval.is = yyvsp[-1].is | yyvsp[0].is; + ; + break;} +case 132: +#line 949 "rcparse.y" +{ + yyval.is = MENUITEM_CHECKED; + ; + break;} +case 133: +#line 953 "rcparse.y" +{ + yyval.is = MENUITEM_GRAYED; + ; + break;} +case 134: +#line 957 "rcparse.y" +{ + yyval.is = MENUITEM_HELP; + ; + break;} +case 135: +#line 961 "rcparse.y" +{ + yyval.is = MENUITEM_INACTIVE; + ; + break;} +case 136: +#line 965 "rcparse.y" +{ + yyval.is = MENUITEM_MENUBARBREAK; + ; + break;} +case 137: +#line 969 "rcparse.y" +{ + yyval.is = MENUITEM_MENUBREAK; + ; + break;} +case 138: +#line 978 "rcparse.y" +{ + define_menu (yyvsp[-5].id, &yyvsp[-3].res_info, yyvsp[-1].menuitem); + ; + break;} +case 139: +#line 985 "rcparse.y" +{ + yyval.menuitem = NULL; + ; + break;} +case 140: +#line 989 "rcparse.y" +{ + if (yyvsp[-1].menuitem == NULL) + yyval.menuitem = yyvsp[0].menuitem; + else + { + struct menuitem **pp; + + for (pp = &yyvsp[-1].menuitem->next; *pp != NULL; pp = &(*pp)->next) + ; + *pp = yyvsp[0].menuitem; + yyval.menuitem = yyvsp[-1].menuitem; + } + ; + break;} +case 141: +#line 1006 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[0].s, 0, 0, 0, 0, NULL); + ; + break;} +case 142: +#line 1010 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-1].s, yyvsp[0].il, 0, 0, 0, NULL); + ; + break;} +case 143: +#line 1014 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-3].s, yyvsp[-2].il, yyvsp[-1].il, yyvsp[0].il, 0, NULL); + ; + break;} +case 144: +#line 1018 "rcparse.y" +{ + yyval.menuitem = define_menuitem (NULL, 0, 0, 0, 0, NULL); + ; + break;} +case 145: +#line 1022 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-3].s, 0, 0, 0, 0, yyvsp[-1].menuitem); + ; + break;} +case 146: +#line 1026 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-4].s, yyvsp[-3].il, 0, 0, 0, yyvsp[-1].menuitem); + ; + break;} +case 147: +#line 1030 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-5].s, yyvsp[-4].il, yyvsp[-3].il, 0, 0, yyvsp[-1].menuitem); + ; + break;} +case 148: +#line 1035 "rcparse.y" +{ + yyval.menuitem = define_menuitem (yyvsp[-7].s, yyvsp[-6].il, yyvsp[-5].il, yyvsp[-4].il, yyvsp[-3].il, yyvsp[-1].menuitem); + ; + break;} +case 149: +#line 1044 "rcparse.y" +{ + define_messagetable (yyvsp[-3].id, &yyvsp[-1].res_info, yyvsp[0].s); + ; + break;} +case 150: +#line 1053 "rcparse.y" +{ + define_rcdata (yyvsp[-5].id, &yyvsp[-3].res_info, yyvsp[-1].rcdata.first); + ; + break;} +case 151: +#line 1062 "rcparse.y" +{ + rcparse_rcdata (); + ; + break;} +case 152: +#line 1066 "rcparse.y" +{ + rcparse_normal (); + yyval.rcdata = yyvsp[0].rcdata; + ; + break;} +case 153: +#line 1074 "rcparse.y" +{ + yyval.rcdata.first = NULL; + yyval.rcdata.last = NULL; + ; + break;} +case 154: +#line 1079 "rcparse.y" +{ + yyval.rcdata = yyvsp[0].rcdata; + ; + break;} +case 155: +#line 1086 "rcparse.y" +{ + struct rcdata_item *ri; + + ri = define_rcdata_string (yyvsp[0].ss.s, yyvsp[0].ss.length); + yyval.rcdata.first = ri; + yyval.rcdata.last = ri; + ; + break;} +case 156: +#line 1094 "rcparse.y" +{ + struct rcdata_item *ri; + + ri = define_rcdata_number (yyvsp[0].i.val, yyvsp[0].i.dword); + yyval.rcdata.first = ri; + yyval.rcdata.last = ri; + ; + break;} +case 157: +#line 1102 "rcparse.y" +{ + struct rcdata_item *ri; + + ri = define_rcdata_string (yyvsp[0].ss.s, yyvsp[0].ss.length); + yyval.rcdata.first = yyvsp[-2].rcdata.first; + yyvsp[-2].rcdata.last->next = ri; + yyval.rcdata.last = ri; + ; + break;} +case 158: +#line 1111 "rcparse.y" +{ + struct rcdata_item *ri; + + ri = define_rcdata_number (yyvsp[0].i.val, yyvsp[0].i.dword); + yyval.rcdata.first = yyvsp[-2].rcdata.first; + yyvsp[-2].rcdata.last->next = ri; + yyval.rcdata.last = ri; + ; + break;} +case 159: +#line 1125 "rcparse.y" +{ sub_res_info = yyvsp[-1].res_info; ; + break;} +case 162: +#line 1132 "rcparse.y" +{ + define_stringtable (&sub_res_info, yyvsp[-1].il, yyvsp[0].s); + ; + break;} +case 163: +#line 1136 "rcparse.y" +{ + define_stringtable (&sub_res_info, yyvsp[-2].il, yyvsp[0].s); + ; + break;} +case 164: +#line 1146 "rcparse.y" +{ + define_user_data (yyvsp[-5].id, yyvsp[-4].id, &yyvsp[-3].res_info, yyvsp[-1].rcdata.first); + ; + break;} +case 165: +#line 1150 "rcparse.y" +{ + define_user_file (yyvsp[-3].id, yyvsp[-2].id, &yyvsp[-1].res_info, yyvsp[0].s); + ; + break;} +case 166: +#line 1159 "rcparse.y" +{ + define_versioninfo (yyvsp[-5].id, language, yyvsp[-3].fixver, yyvsp[-1].verinfo); + ; + break;} +case 167: +#line 1166 "rcparse.y" +{ + yyval.fixver = ((struct fixed_versioninfo *) + res_alloc (sizeof (struct fixed_versioninfo))); + memset (yyval.fixver, 0, sizeof (struct fixed_versioninfo)); + ; + break;} +case 168: +#line 1172 "rcparse.y" +{ + yyvsp[-5].fixver->file_version_ms = (yyvsp[-3].il << 16) | yyvsp[-2].il; + yyvsp[-5].fixver->file_version_ls = (yyvsp[-1].il << 16) | yyvsp[0].il; + yyval.fixver = yyvsp[-5].fixver; + ; + break;} +case 169: +#line 1178 "rcparse.y" +{ + yyvsp[-5].fixver->product_version_ms = (yyvsp[-3].il << 16) | yyvsp[-2].il; + yyvsp[-5].fixver->product_version_ls = (yyvsp[-1].il << 16) | yyvsp[0].il; + yyval.fixver = yyvsp[-5].fixver; + ; + break;} +case 170: +#line 1184 "rcparse.y" +{ + yyvsp[-2].fixver->file_flags_mask = yyvsp[0].il; + yyval.fixver = yyvsp[-2].fixver; + ; + break;} +case 171: +#line 1189 "rcparse.y" +{ + yyvsp[-2].fixver->file_flags = yyvsp[0].il; + yyval.fixver = yyvsp[-2].fixver; + ; + break;} +case 172: +#line 1194 "rcparse.y" +{ + yyvsp[-2].fixver->file_os = yyvsp[0].il; + yyval.fixver = yyvsp[-2].fixver; + ; + break;} +case 173: +#line 1199 "rcparse.y" +{ + yyvsp[-2].fixver->file_type = yyvsp[0].il; + yyval.fixver = yyvsp[-2].fixver; + ; + break;} +case 174: +#line 1204 "rcparse.y" +{ + yyvsp[-2].fixver->file_subtype = yyvsp[0].il; + yyval.fixver = yyvsp[-2].fixver; + ; + break;} +case 175: +#line 1218 "rcparse.y" +{ + yyval.verinfo = NULL; + ; + break;} +case 176: +#line 1222 "rcparse.y" +{ + yyval.verinfo = append_ver_stringfileinfo (yyvsp[-7].verinfo, yyvsp[-4].s, yyvsp[-2].verstring); + ; + break;} +case 177: +#line 1226 "rcparse.y" +{ + yyval.verinfo = append_ver_varfileinfo (yyvsp[-6].verinfo, yyvsp[-2].s, yyvsp[-1].vervar); + ; + break;} +case 178: +#line 1233 "rcparse.y" +{ + yyval.verstring = NULL; + ; + break;} +case 179: +#line 1237 "rcparse.y" +{ + yyval.verstring = append_verval (yyvsp[-4].verstring, yyvsp[-2].s, yyvsp[0].s); + ; + break;} +case 180: +#line 1244 "rcparse.y" +{ + yyval.vervar = NULL; + ; + break;} +case 181: +#line 1248 "rcparse.y" +{ + yyval.vervar = append_vertrans (yyvsp[-2].vervar, yyvsp[-1].il, yyvsp[0].il); + ; + break;} +case 182: +#line 1257 "rcparse.y" +{ + yyval.id.named = 0; + yyval.id.u.id = yyvsp[0].il; + ; + break;} +case 183: +#line 1262 "rcparse.y" +{ + char *copy, *s; + + /* It seems that resource ID's are forced to upper case. */ + copy = xstrdup (yyvsp[0].s); + for (s = copy; *s != '\0'; s++) + if (islower ((unsigned char) *s)) + *s = toupper ((unsigned char) *s); + res_string_to_id (&yyval.id, copy); + free (copy); + ; + break;} +case 184: +#line 1280 "rcparse.y" +{ + memset (&yyval.res_info, 0, sizeof (struct res_res_info)); + yyval.res_info.language = language; + /* FIXME: Is this the right default? */ + yyval.res_info.memflags = MEMFLAG_MOVEABLE; + ; + break;} +case 185: +#line 1287 "rcparse.y" +{ + yyval.res_info = yyvsp[-1].res_info; + yyval.res_info.memflags |= yyvsp[0].memflags.on; + yyval.res_info.memflags &=~ yyvsp[0].memflags.off; + ; + break;} +case 186: +#line 1293 "rcparse.y" +{ + yyval.res_info = yyvsp[-2].res_info; + yyval.res_info.characteristics = yyvsp[0].il; + ; + break;} +case 187: +#line 1298 "rcparse.y" +{ + yyval.res_info = yyvsp[-3].res_info; + yyval.res_info.language = yyvsp[-1].il | (yyvsp[0].il << 8); + ; + break;} +case 188: +#line 1303 "rcparse.y" +{ + yyval.res_info = yyvsp[-2].res_info; + yyval.res_info.version = yyvsp[0].il; + ; + break;} +case 189: +#line 1313 "rcparse.y" +{ + memset (&yyval.res_info, 0, sizeof (struct res_res_info)); + yyval.res_info.language = language; + yyval.res_info.memflags = MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE; + ; + break;} +case 190: +#line 1319 "rcparse.y" +{ + yyval.res_info = yyvsp[-1].res_info; + yyval.res_info.memflags |= yyvsp[0].memflags.on; + yyval.res_info.memflags &=~ yyvsp[0].memflags.off; + ; + break;} +case 191: +#line 1330 "rcparse.y" +{ + memset (&yyval.res_info, 0, sizeof (struct res_res_info)); + yyval.res_info.language = language; + yyval.res_info.memflags = MEMFLAG_MOVEABLE; + ; + break;} +case 192: +#line 1336 "rcparse.y" +{ + yyval.res_info = yyvsp[-1].res_info; + yyval.res_info.memflags |= yyvsp[0].memflags.on; + yyval.res_info.memflags &=~ yyvsp[0].memflags.off; + ; + break;} +case 193: +#line 1348 "rcparse.y" +{ + yyval.memflags.on = MEMFLAG_MOVEABLE; + yyval.memflags.off = 0; + ; + break;} +case 194: +#line 1353 "rcparse.y" +{ + yyval.memflags.on = 0; + yyval.memflags.off = MEMFLAG_MOVEABLE; + ; + break;} +case 195: +#line 1358 "rcparse.y" +{ + yyval.memflags.on = MEMFLAG_PURE; + yyval.memflags.off = 0; + ; + break;} +case 196: +#line 1363 "rcparse.y" +{ + yyval.memflags.on = 0; + yyval.memflags.off = MEMFLAG_PURE; + ; + break;} +case 197: +#line 1368 "rcparse.y" +{ + yyval.memflags.on = MEMFLAG_PRELOAD; + yyval.memflags.off = 0; + ; + break;} +case 198: +#line 1373 "rcparse.y" +{ + yyval.memflags.on = 0; + yyval.memflags.off = MEMFLAG_PRELOAD; + ; + break;} +case 199: +#line 1378 "rcparse.y" +{ + yyval.memflags.on = MEMFLAG_DISCARDABLE; + yyval.memflags.off = 0; + ; + break;} +case 200: +#line 1388 "rcparse.y" +{ + yyval.s = yyvsp[0].s; + ; + break;} +case 201: +#line 1392 "rcparse.y" +{ + yyval.s = yyvsp[0].s; + ; + break;} +case 202: +#line 1409 "rcparse.y" +{ + style |= yyvsp[0].il; + ; + break;} +case 203: +#line 1413 "rcparse.y" +{ + style &=~ yyvsp[0].il; + ; + break;} +case 204: +#line 1417 "rcparse.y" +{ + style |= yyvsp[0].il; + ; + break;} +case 205: +#line 1421 "rcparse.y" +{ + style &=~ yyvsp[0].il; + ; + break;} +case 206: +#line 1428 "rcparse.y" +{ + yyval.il = yyvsp[0].i.val; + ; + break;} +case 207: +#line 1432 "rcparse.y" +{ + yyval.il = yyvsp[-1].il; + ; + break;} +case 208: +#line 1441 "rcparse.y" +{ + yyval.il = 0; + ; + break;} +case 209: +#line 1445 "rcparse.y" +{ + yyval.il = yyvsp[0].il; + ; + break;} +case 210: +#line 1454 "rcparse.y" +{ + yyval.il = yyvsp[0].il; + ; + break;} +case 211: +#line 1463 "rcparse.y" +{ + yyval.il = yyvsp[0].i.val; + ; + break;} +case 212: +#line 1472 "rcparse.y" +{ + yyval.i = yyvsp[0].i; + ; + break;} +case 213: +#line 1476 "rcparse.y" +{ + yyval.i = yyvsp[-1].i; + ; + break;} +case 214: +#line 1480 "rcparse.y" +{ + yyval.i.val = ~ yyvsp[0].i.val; + yyval.i.dword = yyvsp[0].i.dword; + ; + break;} +case 215: +#line 1485 "rcparse.y" +{ + yyval.i.val = - yyvsp[0].i.val; + yyval.i.dword = yyvsp[0].i.dword; + ; + break;} +case 216: +#line 1490 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val * yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 217: +#line 1495 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val / yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 218: +#line 1500 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val % yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 219: +#line 1505 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val + yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 220: +#line 1510 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val - yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 221: +#line 1515 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val & yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 222: +#line 1520 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val ^ yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 223: +#line 1525 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val | yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 224: +#line 1536 "rcparse.y" +{ + yyval.il = yyvsp[0].il; + ; + break;} +case 225: +#line 1545 "rcparse.y" +{ + yyval.il = yyvsp[0].i.val; + ; + break;} +case 226: +#line 1556 "rcparse.y" +{ + yyval.i = yyvsp[0].i; + ; + break;} +case 227: +#line 1560 "rcparse.y" +{ + yyval.i = yyvsp[-1].i; + ; + break;} +case 228: +#line 1564 "rcparse.y" +{ + yyval.i.val = ~ yyvsp[0].i.val; + yyval.i.dword = yyvsp[0].i.dword; + ; + break;} +case 229: +#line 1569 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val * yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 230: +#line 1574 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val / yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 231: +#line 1579 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val % yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 232: +#line 1584 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val + yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 233: +#line 1589 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val - yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 234: +#line 1594 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val & yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 235: +#line 1599 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val ^ yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +case 236: +#line 1604 "rcparse.y" +{ + yyval.i.val = yyvsp[-2].i.val | yyvsp[0].i.val; + yyval.i.dword = yyvsp[-2].i.dword || yyvsp[0].i.dword; + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 1610 "rcparse.y" + + +/* Set the language from the command line. */ + +void +rcparse_set_language (lang) + int lang; +{ + language = lang; +} diff --git a/binutils/rcparse.h b/binutils/rcparse.h new file mode 100644 index 00000000000..9661d54c3d7 --- /dev/null +++ b/binutils/rcparse.h @@ -0,0 +1,125 @@ +typedef union +{ + struct accelerator acc; + struct accelerator *pacc; + struct dialog_control *dialog_control; + struct menuitem *menuitem; + struct + { + struct rcdata_item *first; + struct rcdata_item *last; + } rcdata; + struct rcdata_item *rcdata_item; + struct stringtable_data *stringtable; + struct fixed_versioninfo *fixver; + struct ver_info *verinfo; + struct ver_stringinfo *verstring; + struct ver_varinfo *vervar; + struct res_id id; + struct res_res_info res_info; + struct + { + unsigned short on; + unsigned short off; + } memflags; + struct + { + unsigned long val; + /* Nonzero if this number was explicitly specified as long. */ + int dword; + } i; + unsigned long il; + unsigned short is; + const char *s; + struct + { + unsigned long length; + const char *s; + } ss; +} YYSTYPE; +#define BEG 257 +#define END 258 +#define ACCELERATORS 259 +#define VIRTKEY 260 +#define ASCII 261 +#define NOINVERT 262 +#define SHIFT 263 +#define CONTROL 264 +#define ALT 265 +#define BITMAP 266 +#define CURSOR 267 +#define DIALOG 268 +#define DIALOGEX 269 +#define EXSTYLE 270 +#define CAPTION 271 +#define CLASS 272 +#define STYLE 273 +#define AUTO3STATE 274 +#define AUTOCHECKBOX 275 +#define AUTORADIOBUTTON 276 +#define CHECKBOX 277 +#define COMBOBOX 278 +#define CTEXT 279 +#define DEFPUSHBUTTON 280 +#define EDITTEXT 281 +#define GROUPBOX 282 +#define LISTBOX 283 +#define LTEXT 284 +#define PUSHBOX 285 +#define PUSHBUTTON 286 +#define RADIOBUTTON 287 +#define RTEXT 288 +#define SCROLLBAR 289 +#define STATE3 290 +#define USERBUTTON 291 +#define BEDIT 292 +#define HEDIT 293 +#define IEDIT 294 +#define FONT 295 +#define ICON 296 +#define LANGUAGE 297 +#define CHARACTERISTICS 298 +#define VERSIONK 299 +#define MENU 300 +#define MENUEX 301 +#define MENUITEM 302 +#define SEPARATOR 303 +#define POPUP 304 +#define CHECKED 305 +#define GRAYED 306 +#define HELP 307 +#define INACTIVE 308 +#define MENUBARBREAK 309 +#define MENUBREAK 310 +#define MESSAGETABLE 311 +#define RCDATA 312 +#define STRINGTABLE 313 +#define VERSIONINFO 314 +#define FILEVERSION 315 +#define PRODUCTVERSION 316 +#define FILEFLAGSMASK 317 +#define FILEFLAGS 318 +#define FILEOS 319 +#define FILETYPE 320 +#define FILESUBTYPE 321 +#define BLOCKSTRINGFILEINFO 322 +#define BLOCKVARFILEINFO 323 +#define VALUE 324 +#define BLOCK 325 +#define MOVEABLE 326 +#define FIXED 327 +#define PURE 328 +#define IMPURE 329 +#define PRELOAD 330 +#define LOADONCALL 331 +#define DISCARDABLE 332 +#define NOT 333 +#define QUOTEDSTRING 334 +#define STRING 335 +#define NUMBER 336 +#define SIZEDSTRING 337 +#define IGNORED_TOKEN 338 +#define NEG 339 + + +extern YYSTYPE yylval; diff --git a/binutils/sysinfo.c b/binutils/sysinfo.c new file mode 100644 index 00000000000..68c258ce186 --- /dev/null +++ b/binutils/sysinfo.c @@ -0,0 +1,1309 @@ + +/* A Bison parser, made from sysinfo.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define COND 257 +#define REPEAT 258 +#define TYPE 259 +#define NAME 260 +#define NUMBER 261 +#define UNIT 262 + +#line 1 "sysinfo.y" + +#include <stdio.h> +#include <stdlib.h> + +extern char *word; +extern char writecode; +extern int number; +extern int unit; +char nice_name[1000]; +char *it; +int sofar; +int width; +int code; +char * repeat; +char *oldrepeat; +char *name; +int rdepth; +char *loop [] = {"","n","m","/*BAD*/"}; +char *names[] = {" ","[n]","[n][m]"}; +char *pnames[]= {"","*","**"}; + +#line 24 "sysinfo.y" +typedef union { + int i; + char *s; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 55 +#define YYFLAG -32768 +#define YYNTBASE 11 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 262 ? yytranslate[x] : 29) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, + 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 7, 8, + 9, 10 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 1, 4, 7, 8, 9, 16, 19, 22, 25, + 26, 27, 34, 35, 42, 43, 54, 56, 57, 61, + 64, 68, 69, 70, 74, 75 +}; + +static const short yyrhs[] = { -1, + 12, 13, 0, 14, 13, 0, 0, 0, 5, 8, + 9, 15, 16, 6, 0, 21, 16, 0, 19, 16, + 0, 17, 16, 0, 0, 0, 5, 4, 8, 18, + 16, 6, 0, 0, 5, 3, 8, 20, 16, 6, + 0, 0, 5, 24, 5, 23, 25, 6, 26, 22, + 27, 6, 0, 7, 0, 0, 5, 8, 6, 0, + 9, 10, 0, 5, 8, 6, 0, 0, 0, 5, + 28, 6, 0, 0, 28, 5, 8, 8, 6, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 38, 59, 75, 76, 79, 130, 150, 152, 153, 154, + 157, 186, 204, 217, 230, 233, 338, 340, 343, 348, + 354, 356, 359, 360, 362, 363 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","COND","REPEAT", +"'('","')'","TYPE","NAME","NUMBER","UNIT","top","@1","it_list","it","@2","it_field_list", +"repeat_it_field","@3","cond_it_field","@4","it_field","@5","attr_type","attr_desc", +"attr_size","attr_id","enums","enum_list", NULL +}; +#endif + +static const short yyr1[] = { 0, + 12, 11, 13, 13, 15, 14, 16, 16, 16, 16, + 18, 17, 20, 19, 22, 21, 23, 23, 24, 25, + 26, 26, 27, 27, 28, 28 +}; + +static const short yyr2[] = { 0, + 0, 2, 2, 0, 0, 6, 2, 2, 2, 0, + 0, 6, 0, 6, 0, 10, 1, 0, 3, 2, + 3, 0, 0, 3, 0, 5 +}; + +static const short yydefact[] = { 1, + 4, 0, 2, 4, 0, 3, 5, 10, 0, 0, + 10, 10, 10, 0, 0, 0, 0, 6, 9, 8, + 7, 13, 11, 0, 18, 10, 10, 19, 17, 0, + 0, 0, 0, 0, 14, 12, 20, 22, 0, 15, + 0, 23, 21, 25, 0, 0, 16, 0, 24, 0, + 0, 26, 0, 0, 0 +}; + +static const short yydefgoto[] = { 53, + 1, 3, 4, 8, 10, 11, 27, 12, 26, 13, + 42, 30, 17, 34, 40, 45, 46 +}; + +static const short yypact[] = {-32768, + 3, 2,-32768, 3, 4,-32768,-32768, 6, 0, 8, + 6, 6, 6, 9, 10, 11, 7,-32768,-32768,-32768, +-32768,-32768,-32768, 14, 15, 6, 6,-32768,-32768, 12, + 17, 18, -1, 19,-32768,-32768,-32768, 21, 20,-32768, + 23, 22,-32768,-32768, 24, 1,-32768, 25,-32768, 26, + 29,-32768, 31, 32,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768, 33,-32768,-32768, -11,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768 +}; + + +#define YYLAST 37 + + +static const short yytable[] = { 19, + 20, 21, 14, 15, 16, 48, 49, 2, 37, 5, + 9, 25, 7, 18, 31, 32, 22, 23, 24, 28, + 33, 29, 35, 36, 38, 39, 44, 41, 43, 47, + 54, 55, 50, 51, 52, 0, 6 +}; + +static const short yycheck[] = { 11, + 12, 13, 3, 4, 5, 5, 6, 5, 10, 8, + 5, 5, 9, 6, 26, 27, 8, 8, 8, 6, + 9, 7, 6, 6, 6, 5, 5, 8, 6, 6, + 0, 0, 8, 8, 6, -1, 4 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 1: +#line 38 "sysinfo.y" +{ + switch (writecode) + { + case 'i': + printf("#ifdef SYSROFF_SWAP_IN\n"); + break; + case 'p': + printf("#ifdef SYSROFF_p\n"); + break; + case 'd': + break; + case 'g': + printf("#ifdef SYSROFF_SWAP_OUT\n"); + break; + case 'c': + printf("#ifdef SYSROFF_PRINT\n"); + printf("#include <stdio.h>\n"); + printf("#include <stdlib.h>\n"); + break; + } + ; + break;} +case 2: +#line 59 "sysinfo.y" +{ + switch (writecode) { + case 'i': + case 'p': + case 'g': + case 'c': + printf("#endif\n"); + break; + case 'd': + break; + } +; + break;} +case 5: +#line 81 "sysinfo.y" +{ + it = yyvsp[-1].s; code = yyvsp[0].i; + switch (writecode) + { + case 'd': + printf("\n\n\n#define IT_%s_CODE 0x%x\n", it,code); + printf("struct IT_%s { \n", it); + break; + case 'i': + printf("void sysroff_swap_%s_in(ptr)\n",yyvsp[-1].s); + printf("struct IT_%s *ptr;\n", it); + printf("{\n"); + printf("char raw[255];\n"); + printf("\tint idx = 0 ;\n"); + printf("\tint size;\n"); + printf("memset(raw,0,255);\n"); + printf("memset(ptr,0,sizeof(*ptr));\n"); + printf("size = fillup(raw);\n"); + break; + case 'g': + printf("void sysroff_swap_%s_out(file,ptr)\n",yyvsp[-1].s); + printf("FILE * file;\n"); + printf("struct IT_%s *ptr;\n", it); + printf("{\n"); + printf("\tchar raw[255];\n"); + printf("\tint idx = 16 ;\n"); + printf("\tmemset (raw, 0, 255);\n"); + printf("\tcode = IT_%s_CODE;\n", it); + break; + case 'o': + printf("void sysroff_swap_%s_out(abfd,ptr)\n",yyvsp[-1].s); + printf("bfd * abfd;\n"); + printf("struct IT_%s *ptr;\n",it); + printf("{\n"); + printf("int idx = 0 ;\n"); + break; + case 'c': + printf("void sysroff_print_%s_out(ptr)\n",yyvsp[-1].s); + printf("struct IT_%s *ptr;\n", it); + printf("{\n"); + printf("itheader(\"%s\", IT_%s_CODE);\n",yyvsp[-1].s,yyvsp[-1].s); + break; + + case 't': + break; + } + + ; + break;} +case 6: +#line 131 "sysinfo.y" +{ + switch (writecode) { + case 'd': + printf("};\n"); + break; + case 'g': + printf("\tchecksum(file,raw, idx, IT_%s_CODE);\n", it); + + case 'i': + + case 'o': + case 'c': + printf("}\n"); + } +; + break;} +case 11: +#line 158 "sysinfo.y" +{ + rdepth++; + switch (writecode) + { + case 'c': + if (rdepth==1) + printf("\tprintf(\"repeat %%d\\n\", %s);\n",yyvsp[0].s); + if (rdepth==2) + printf("\tprintf(\"repeat %%d\\n\", %s[n]);\n",yyvsp[0].s); + case 'i': + case 'g': + case 'o': + + if (rdepth==1) + { + printf("\t{ int n; for (n = 0; n < %s; n++) {\n", yyvsp[0].s); + } + if (rdepth == 2) { + printf("\t{ int m; for (m = 0; m < %s[n]; m++) {\n", yyvsp[0].s); + } + + break; + } + + oldrepeat = repeat; + repeat = yyvsp[0].s; + ; + break;} +case 12: +#line 188 "sysinfo.y" +{ + repeat = oldrepeat; + oldrepeat =0; + rdepth--; + switch (writecode) + { + case 'i': + case 'g': + case 'o': + case 'c': + printf("\t}}\n"); + } + ; + break;} +case 13: +#line 205 "sysinfo.y" +{ + switch (writecode) + { + case 'i': + case 'g': + case 'o': + case 'c': + printf("\tif (%s) {\n", yyvsp[0].s); + break; + } + ; + break;} +case 14: +#line 218 "sysinfo.y" +{ + switch (writecode) + { + case 'i': + case 'g': + case 'o': + case 'c': + printf("\t}\n"); + } + ; + break;} +case 15: +#line 232 "sysinfo.y" +{name = yyvsp[0].s; ; + break;} +case 16: +#line 234 "sysinfo.y" +{ + char *desc = yyvsp[-8].s; + char *type = yyvsp[-6].s; + int size = yyvsp[-5].i; + char *id = yyvsp[-3].s; +char *p = names[rdepth]; +char *ptr = pnames[rdepth]; + switch (writecode) + { + case 'g': + if (size % 8) + { + + printf("\twriteBITS(ptr->%s%s,raw,&idx,%d);\n", + id, + names[rdepth], size); + + } + else { + printf("\twrite%s(ptr->%s%s,raw,&idx,%d,file);\n", + type, + id, + names[rdepth],size/8); + } + break; + case 'i': + { + + if (rdepth >= 1) + + { + printf("if (!ptr->%s) ptr->%s = (%s*)xcalloc(%s, sizeof(ptr->%s[0]));\n", + id, + id, + type, + repeat, + id); + } + + if (rdepth == 2) + { + printf("if (!ptr->%s[n]) ptr->%s[n] = (%s**)xcalloc(%s[n], sizeof(ptr->%s[n][0]));\n", + id, + id, + type, + repeat, + id); + } + + } + + if (size % 8) + { + printf("\tptr->%s%s = getBITS(raw,&idx, %d,size);\n", + id, + names[rdepth], + size); + } + else { + printf("\tptr->%s%s = get%s(raw,&idx, %d,size);\n", + id, + names[rdepth], + type, + size/8); + } + break; + case 'o': + printf("\tput%s(raw,%d,%d,&idx,ptr->%s%s);\n", type,size/8,size%8,id,names[rdepth]); + break; + case 'd': + if (repeat) + printf("\t/* repeat %s */\n", repeat); + + if (type[0] == 'I') { + printf("\tint %s%s; \t/* %s */\n",ptr,id, desc); + } + else if (type[0] =='C') { + printf("\tchar %s*%s;\t /* %s */\n",ptr,id, desc); + } + else { + printf("\tbarray %s%s;\t /* %s */\n",ptr,id, desc); + } + break; + case 'c': + printf("tabout();\n"); + printf("\tprintf(\"/*%-30s*/ ptr->%s = \");\n", desc, id); + + if (type[0] == 'I') + printf("\tprintf(\"%%d\\n\",ptr->%s%s);\n", id,p); + else if (type[0] == 'C') + printf("\tprintf(\"%%s\\n\",ptr->%s%s);\n", id,p); + + else if (type[0] == 'B') + { + printf("\tpbarray(&ptr->%s%s);\n", id,p); + } + else abort(); + break; + } + ; + break;} +case 17: +#line 339 "sysinfo.y" +{ yyval.s = yyvsp[0].s; ; + break;} +case 18: +#line 340 "sysinfo.y" +{ yyval.s = "INT";; + break;} +case 19: +#line 345 "sysinfo.y" +{ yyval.s = yyvsp[-1].s; ; + break;} +case 20: +#line 350 "sysinfo.y" +{ yyval.i = yyvsp[-1].i * yyvsp[0].i; ; + break;} +case 21: +#line 355 "sysinfo.y" +{ yyval.s = yyvsp[-1].s; ; + break;} +case 22: +#line 356 "sysinfo.y" +{ yyval.s = "dummy";; + break;} +case 26: +#line 364 "sysinfo.y" +{ + switch (writecode) + { + case 'd': + printf("#define %s %s\n", yyvsp[-2].s,yyvsp[-1].s); + break; + case 'c': + printf("if (ptr->%s%s == %s) { tabout(); printf(\"%s\\n\");}\n", name, names[rdepth],yyvsp[-1].s,yyvsp[-2].s); + } + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 379 "sysinfo.y" + +/* four modes + + -d write structure defintions for sysroff in host format + -i write functions to swap into sysroff format in + -o write functions to swap into sysroff format out + -c write code to print info in human form */ + +int yydebug; +char writecode; + +int +main(ac,av) +int ac; +char **av; +{ + yydebug=0; + if (ac > 1) + writecode = av[1][1]; +if (writecode == 'd') + { + printf("typedef struct { unsigned char *data; int len; } barray; \n"); + printf("typedef int INT;\n"); + printf("typedef char * CHARS;\n"); + + } + yyparse(); +return 0; +} + +int +yyerror(s) + char *s; +{ + fprintf(stderr, "%s\n" , s); + return 0; +} diff --git a/binutils/sysinfo.h b/binutils/sysinfo.h new file mode 100644 index 00000000000..871c3bed76a --- /dev/null +++ b/binutils/sysinfo.h @@ -0,0 +1,13 @@ +typedef union { + int i; + char *s; +} YYSTYPE; +#define COND 257 +#define REPEAT 258 +#define TYPE 259 +#define NAME 260 +#define NUMBER 261 +#define UNIT 262 + + +extern YYSTYPE yylval; diff --git a/binutils/syslex.c b/binutils/syslex.c new file mode 100644 index 00000000000..73ff50fbf1e --- /dev/null +++ b/binutils/syslex.c @@ -0,0 +1,1683 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> +#include <unistd.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 25 +#define YY_END_OF_BUFFER 26 +static yyconst short int yy_accept[81] = + { 0, + 0, 0, 26, 25, 7, 8, 5, 25, 1, 2, + 11, 11, 6, 3, 4, 25, 25, 25, 25, 25, + 25, 25, 0, 9, 11, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, + 13, 0, 0, 0, 0, 16, 0, 0, 0, 0, + 0, 12, 15, 0, 23, 0, 0, 0, 0, 0, + 0, 14, 18, 0, 0, 0, 0, 0, 17, 0, + 24, 0, 0, 0, 20, 22, 0, 21, 19, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 1, 5, 1, 1, 1, 1, 1, 6, + 7, 1, 1, 1, 1, 1, 1, 8, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 1, 10, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 11, 1, 12, 1, 1, 1, 13, 14, 15, 16, + + 17, 18, 19, 20, 21, 1, 1, 22, 1, 23, + 24, 25, 1, 26, 27, 28, 29, 30, 1, 31, + 32, 33, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[34] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 3, 3, 1, + 1, 1, 3, 3, 3, 3, 3, 3, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1 + } ; + +static yyconst short int yy_base[84] = + { 0, + 0, 0, 100, 101, 101, 101, 101, 94, 101, 101, + 26, 28, 0, 101, 101, 82, 26, 18, 74, 79, + 78, 81, 88, 101, 32, 0, 0, 76, 65, 62, + 61, 75, 20, 59, 61, 66, 58, 0, 57, 56, + 54, 63, 53, 62, 54, 101, 59, 48, 53, 46, + 59, 101, 44, 43, 101, 41, 55, 46, 53, 44, + 31, 101, 101, 39, 27, 21, 39, 19, 101, 35, + 101, 33, 26, 29, 101, 101, 28, 101, 101, 101, + 58, 61, 41 + } ; + +static yyconst short int yy_def[84] = + { 0, + 80, 1, 80, 80, 80, 80, 80, 81, 80, 80, + 80, 80, 82, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 81, 80, 80, 83, 82, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 83, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 0, + 80, 80, 80 + } ; + +static yyconst short int yy_nxt[135] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 4, 4, 4, 4, 4, + 19, 4, 4, 4, 4, 20, 21, 4, 4, 22, + 4, 4, 4, 25, 25, 25, 25, 32, 29, 25, + 25, 33, 44, 38, 79, 78, 30, 77, 45, 76, + 75, 74, 73, 72, 71, 70, 26, 31, 23, 23, + 23, 27, 69, 27, 68, 67, 66, 65, 64, 63, + 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, + 52, 51, 50, 49, 48, 47, 46, 43, 42, 41, + 40, 39, 24, 37, 36, 35, 34, 28, 24, 80, + + 3, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80 + } ; + +static yyconst short int yy_chk[135] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 11, 11, 12, 12, 18, 17, 25, + 25, 18, 33, 83, 77, 74, 17, 73, 33, 72, + 70, 68, 67, 66, 65, 64, 11, 17, 81, 81, + 81, 82, 61, 82, 60, 59, 58, 57, 56, 54, + 53, 51, 50, 49, 48, 47, 45, 44, 43, 42, + 41, 40, 39, 37, 36, 35, 34, 32, 31, 30, + 29, 28, 23, 22, 21, 20, 19, 16, 8, 3, + + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "syslex.l" +#define INITIAL 0 +#line 2 "syslex.l" +#include "sysinfo.h" +char *word; +int number; +int unit; + +#ifndef yywrap +static int yywrap () { return 1; } +#endif +#line 426 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 11 "syslex.l" + +#line 579 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 81 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 101 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 12 "syslex.l" +{ return '(';} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 13 "syslex.l" +{ return ')';} + YY_BREAK +case 3: +YY_RULE_SETUP +#line 14 "syslex.l" +{ return '[';} + YY_BREAK +case 4: +YY_RULE_SETUP +#line 15 "syslex.l" +{ return ']';} + YY_BREAK +case 5: +YY_RULE_SETUP +#line 16 "syslex.l" +{ ; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 17 "syslex.l" +{ ; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 18 "syslex.l" +{ ; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 19 "syslex.l" +{ ; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 20 "syslex.l" +{ +yylval.s = malloc(strlen (yytext)); +strcpy(yylval.s, yytext+1); +yylval.s[strlen(yylval.s)-1] = 0; + return NAME; + } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 27 "syslex.l" +{ + yylval.i = strtol(yytext,0,16); + return NUMBER; + } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 32 "syslex.l" +{ + yylval.i = atoi(yytext); + return NUMBER; + } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 38 "syslex.l" +{ yylval.i =1 ;return UNIT;} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 39 "syslex.l" +{ yylval.i = 1; return UNIT;} + YY_BREAK +case 14: +YY_RULE_SETUP +#line 40 "syslex.l" +{ yylval.i= 8; return UNIT;} + YY_BREAK +case 15: +YY_RULE_SETUP +#line 41 "syslex.l" +{ yylval.i = 8; return UNIT;} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 43 "syslex.l" +{ yylval.s = "INT"; return TYPE;} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 44 "syslex.l" +{ yylval.s = "BARRAY"; return TYPE;} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 45 "syslex.l" +{ yylval.s = "CHARS"; return TYPE;} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 46 "syslex.l" +{ yylval.i = 0; return NUMBER;} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 47 "syslex.l" +{ yylval.i = -4; return NUMBER;} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 48 "syslex.l" +{ yylval.i = -2; return NUMBER; } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 49 "syslex.l" +{ yylval.i = -1; return NUMBER; } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 50 "syslex.l" +{ return COND;} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 51 "syslex.l" +{ return REPEAT;} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 52 "syslex.l" +ECHO; + YY_BREAK +#line 798 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 81 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 81 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 80); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 52 "syslex.l" diff --git a/etc/configure.info b/etc/configure.info new file mode 100644 index 00000000000..2ed20df83bd --- /dev/null +++ b/etc/configure.info @@ -0,0 +1,95 @@ +This is configure.info, produced by makeinfo version 4.0 from +./configure.texi. + +INFO-DIR-SECTION GNU admin +START-INFO-DIR-ENTRY +* configure: (configure). The GNU configure and build system +END-INFO-DIR-ENTRY + + This file documents the GNU configure and build system. + + Copyright (C) 1998 Cygnus Solutions. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that this permission notice may be stated in a +translation approved by the Foundation. + + +Indirect: +configure.info-1: 971 +configure.info-2: 48782 +configure.info-3: 98073 + +Tag Table: +(Indirect) +Node: Top971 +Node: Introduction1502 +Node: Goals2583 +Node: Tools3302 +Node: History4291 +Node: Building7284 +Node: Getting Started10374 +Node: Write configure.in10886 +Node: Write Makefile.am18132 +Node: Write acconfig.h21290 +Node: Generate files22827 +Node: Getting Started Example24788 +Node: Getting Started Example 125538 +Node: Getting Started Example 227475 +Node: Getting Started Example 330591 +Node: Generate Files in Example32961 +Node: Files34042 +Node: Developer Files34653 +Node: Developer Files Picture35028 +Node: Written Developer Files36320 +Node: Generated Developer Files38863 +Node: Build Files41998 +Node: Build Files Picture42654 +Node: Build Files Description43409 +Node: Support Files45406 +Node: Configuration Names48283 +Node: Configuration Name Definition48782 +Node: Using Configuration Names51100 +Node: Cross Compilation Tools53067 +Node: Cross Compilation Concepts53757 +Node: Host and Target54719 +Node: Using the Host Type56215 +Node: Specifying the Target57559 +Node: Using the Target Type58343 +Node: Cross Tools in the Cygnus Tree61769 +Node: Host and Target Libraries62821 +Node: Target Library Configure Scripts66561 +Node: Make Targets in Cygnus Tree69644 +Node: Target libiberty70983 +Node: Canadian Cross72361 +Node: Canadian Cross Example73201 +Node: Canadian Cross Concepts74315 +Node: Build Cross Host Tools75822 +Node: Build and Host Options76769 +Node: CCross not in Cygnus Tree78550 +Node: CCross in Cygnus Tree79523 +Node: Standard Cygnus CCross79939 +Node: Cross Cygnus CCross81294 +Node: Supporting Canadian Cross84085 +Node: CCross in Configure84695 +Node: CCross in Make87852 +Node: Cygnus Configure89446 +Node: Cygnus Configure Basics90280 +Node: Cygnus Configure in C++ Libraries94954 +Node: Multilibs95956 +Node: Multilibs in gcc97000 +Node: Multilibs in Target Libraries98073 +Node: FAQ102257 +Node: Index106353 + +End Tag Table diff --git a/etc/configure.info-1 b/etc/configure.info-1 new file mode 100644 index 00000000000..bb65d7dce46 --- /dev/null +++ b/etc/configure.info-1 @@ -0,0 +1,1313 @@ +This is configure.info, produced by makeinfo version 4.0 from +./configure.texi. + +INFO-DIR-SECTION GNU admin +START-INFO-DIR-ENTRY +* configure: (configure). The GNU configure and build system +END-INFO-DIR-ENTRY + + This file documents the GNU configure and build system. + + Copyright (C) 1998 Cygnus Solutions. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that this permission notice may be stated in a +translation approved by the Foundation. + + +File: configure.info, Node: Top, Next: Introduction, Up: (dir) + +GNU configure and build system +****************************** + + The GNU configure and build system. + +* Menu: + +* Introduction:: Introduction. +* Getting Started:: Getting Started. +* Files:: Files. +* Configuration Names:: Configuration Names. +* Cross Compilation Tools:: Cross Compilation Tools. +* Canadian Cross:: Canadian Cross. +* Cygnus Configure:: Cygnus Configure. +* Multilibs:: Multilibs. +* FAQ:: Frequently Asked Questions. +* Index:: Index. + + +File: configure.info, Node: Introduction, Next: Getting Started, Prev: Top, Up: Top + +Introduction +************ + + This document describes the GNU configure and build systems. It +describes how autoconf, automake, libtool, and make fit together. It +also includes a discussion of the older Cygnus configure system. + + This document does not describe in detail how to use each of the +tools; see the respective manuals for that. Instead, it describes +which files the developer must write, which files are machine generated +and how they are generated, and where certain common problems should be +addressed. + + This document draws on several sources, including the autoconf +manual by David MacKenzie (*note autoconf overview: (autoconf)Top.), +the automake manual by David MacKenzie and Tom Tromey (*note automake +overview: (automake)Top.), the libtool manual by Gordon Matzigkeit +(*note libtool overview: (libtool)Top.), and the Cygnus configure +manual by K. Richard Pixley. + +* Menu: + +* Goals:: Goals. +* Tools:: The tools. +* History:: History. +* Building:: Building. + + +File: configure.info, Node: Goals, Next: Tools, Up: Introduction + +Goals +===== + + The GNU configure and build system has two main goals. + + The first is to simplify the development of portable programs. The +system permits the developer to concentrate on writing the program, +simplifying many details of portability across Unix and even Windows +systems, and permitting the developer to describe how to build the +program using simple rules rather than complex Makefiles. + + The second is to simplify the building of programs distributed as +source code. All programs are built using a simple, standardized, two +step process. The program builder need not install any special tools in +order to build the program. + + +File: configure.info, Node: Tools, Next: History, Prev: Goals, Up: Introduction + +Tools +===== + + The GNU configure and build system is comprised of several different +tools. Program developers must build and install all of these tools. + + People who just want to build programs from distributed sources +normally do not need any special tools beyond a Unix shell, a make +program, and a C compiler. + +autoconf + provides a general portability framework, based on testing the + features of the host system at build time. + +automake + a system for describing how to build a program, permitting the + developer to write a simplified `Makefile'. + +libtool + a standardized approach to building shared libraries. + +gettext + provides a framework for translation of text messages into other + languages; not really discussed in this document. + +m4 + autoconf requires the GNU version of m4; the standard Unix m4 does + not suffice. + +perl + automake requires perl. + + +File: configure.info, Node: History, Next: Building, Prev: Tools, Up: Introduction + +History +======= + + This is a very brief and probably inaccurate history. + + As the number of Unix variants increased during the 1980s, it became +harder to write programs which could run on all variants. While it was +often possible to use `#ifdef' to identify particular systems, +developers frequently did not have access to every system, and the +characteristics of some systems changed from version to version. + + By 1992, at least three different approaches had been developed: + * The Metaconfig program, by Larry Wall, Harlan Stenn, and Raphael + Manfredi. + + * The Cygnus configure script, by K. Richard Pixley, and the gcc + configure script, by Richard Stallman. These use essentially the + same approach, and the developers communicated regularly. + + * The autoconf program, by David MacKenzie. + + The Metaconfig program is still used for Perl and a few other +programs. It is part of the Dist package. I do not know if it is +being developed. + + In 1994, David MacKenzie and others modified autoconf to incorporate +all the features of Cygnus configure. Since then, there has been a +slow but steady conversion of GNU programs from Cygnus configure to +autoconf. gcc has been converted, eliminating the gcc configure script. + + GNU autoconf was regularly maintained until late 1996. As of this +writing in June, 1998, it has no public maintainer. + + Most programs are built using the make program, which requires the +developer to write Makefiles describing how to build the programs. +Since most programs are built in pretty much the same way, this led to a +lot of duplication. + + The X Window system is built using the imake tool, which uses a +database of rules to eliminate the duplication. However, building a +tool which was developed using imake requires that the builder have +imake installed, violating one of the goals of the GNU system. + + The new BSD make provides a standard library of Makefile fragments, +which permits developers to write very simple Makefiles. However, this +requires that the builder install the new BSD make program. + + In 1994, David MacKenzie wrote the first version of automake, which +permitted writing a simple build description which was converted into a +Makefile which could be used by the standard make program. In 1995, Tom +Tromey completely rewrote automake in Perl, and he continues to enhance +it. + + Various free packages built libraries, and by around 1995 several +included support to build shared libraries on various platforms. +However, there was no consistent approach. In early 1996, Gordon +Matzigkeit began working on libtool, which provided a standardized +approach to building shared libraries. This was integrated into +automake from the start. + + The development of automake and libtool was driven by the GNITS +project, a group of GNU maintainers who designed standardized tools to +help meet the GNU coding standards. + + +File: configure.info, Node: Building, Prev: History, Up: Introduction + +Building +======== + + Most readers of this document should already know how to build a +tool by running `configure' and `make'. This section may serve as a +quick introduction or reminder. + + Building a tool is normally as simple as running `configure' +followed by `make'. You should normally run `configure' from an empty +directory, using some path to refer to the `configure' script in the +source directory. The directory in which you run `configure' is called +the "object directory". + + In order to use a object directory which is different from the source +directory, you must be using the GNU version of `make', which has the +required `VPATH' support. Despite this restriction, using a different +object directory is highly recommended: + * It keeps the files generated during the build from cluttering up + your sources. + + * It permits you to remove the built files by simply removing the + entire build directory. + + * It permits you to build from the same sources with several sets of + configure options simultaneously. + + If you don't have GNU `make', you will have to run `configure' in +the source directory. All GNU packages should support this; in +particular, GNU packages should not assume the presence of GNU `make'. + + After running `configure', you can build the tools by running `make'. + + To install the tools, run `make install'. Installing the tools will +copy the programs and any required support files to the "installation +directory". The location of the installation directory is controlled +by `configure' options, as described below. + + In the Cygnus tree at present, the info files are built and +installed as a separate step. To build them, run `make info'. To +install them, run `make install-info'. + + All `configure' scripts support a wide variety of options. The most +interesting ones are `--with' and `--enable' options which are +generally specific to particular tools. You can usually use the +`--help' option to get a list of interesting options for a particular +configure script. + + The only generic options you are likely to use are the `--prefix' +and `--exec-prefix' options. These options are used to specify the +installation directory. + + The directory named by the `--prefix' option will hold machine +independent files such as info files. + + The directory named by the `--exec-prefix' option, which is normally +a subdirectory of the `--prefix' directory, will hold machine dependent +files such as executables. + + The default for `--prefix' is `/usr/local'. The default for +`--exec-prefix' is the value used for `--prefix'. + + The convention used in Cygnus releases is to use a `--prefix' option +of `/usr/cygnus/RELEASE', where RELEASE is the name of the release, and +to use a `--exec-prefix' option of `/usr/cygnus/RELEASE/H-HOST', where +HOST is the configuration name of the host system (*note Configuration +Names::). + + Do not use either the source or the object directory as the +installation directory. That will just lead to confusion. + + +File: configure.info, Node: Getting Started, Next: Files, Prev: Introduction, Up: Top + +Getting Started +*************** + + To start using the GNU configure and build system with your software +package, you must write three files, and you must run some tools to +manually generate additional files. + +* Menu: + +* Write configure.in:: Write configure.in. +* Write Makefile.am:: Write Makefile.am. +* Write acconfig.h:: Write acconfig.h. +* Generate files:: Generate files. +* Getting Started Example:: Example. + + +File: configure.info, Node: Write configure.in, Next: Write Makefile.am, Up: Getting Started + +Write configure.in +================== + + You must first write the file `configure.in'. This is an autoconf +input file, and the autoconf manual describes in detail what this file +should look like. + + You will write tests in your `configure.in' file to check for +conditions that may change from one system to another, such as the +presence of particular header files or functions. + + For example, not all systems support the `gettimeofday' function. +If you want to use the `gettimeofday' function when it is available, +and to use some other function when it is not, you would check for this +by putting `AC_CHECK_FUNCS(gettimeofday)' in `configure.in'. + + When the configure script is run at build time, this will arrange to +define the preprocessor macro `HAVE_GETTIMEOFDAY' to the value 1 if the +`gettimeofday' function is available, and to not define the macro at +all if the function is not available. Your code can then use `#ifdef' +to test whether it is safe to call `gettimeofday'. + + If you have an existing body of code, the `autoscan' program may +help identify potential portability problems, and hence configure tests +that you will want to use. *Note Invoking autoscan: (autoconf)Invoking +autoscan. + + Another handy tool for an existing body of code is `ifnames'. This +will show you all the preprocessor conditionals that the code already +uses. *Note Invoking ifnames: (autoconf)Invoking ifnames. + + Besides the portability tests which are specific to your particular +package, every `configure.in' file should contain the following macros. + +`AC_INIT' + This macro takes a single argument, which is the name of a file in + your package. For example, `AC_INIT(foo.c)'. + +`AC_PREREQ(VERSION)' + This macro is optional. It may be used to indicate the version of + `autoconf' that you are using. This will prevent users from + running an earlier version of `autoconf' and perhaps getting an + invalid `configure' script. For example, `AC_PREREQ(2.12)'. + +`AM_INIT_AUTOMAKE' + This macro takes two arguments: the name of the package, and a + version number. For example, `AM_INIT_AUTOMAKE(foo, 1.0)'. (This + macro is not needed if you are not using automake). + +`AM_CONFIG_HEADER' + This macro names the header file which will hold the preprocessor + macro definitions at run time. Normally this should be + `config.h'. Your sources would then use `#include "config.h"' to + include it. + + This macro may optionally name the input file for that header + file; by default, this is `config.h.in', but that file name works + poorly on DOS filesystems. Therefore, it is often better to name + it explicitly as `config.in'. + + This is what you should normally put in `configure.in': + AM_CONFIG_HEADER(config.h:config.in) + + (If you are not using automake, use `AC_CONFIG_HEADER' rather than + `AM_CONFIG_HEADER'). + +`AM_MAINTAINER_MODE' + This macro always appears in Cygnus configure scripts. Other + programs may or may not use it. + + If this macro is used, the `--enable-maintainer-mode' option is + required to enable automatic rebuilding of generated files used by + the configure system. This of course requires that developers be + aware of, and use, that option. + + If this macro is not used, then the generated files will always be + rebuilt automatically. This will cause problems if the wrong + versions of autoconf, automake, or others are in the builder's + `PATH'. + + (If you are not using automake, you do not need to use this macro). + +`AC_EXEEXT' + Either this macro or `AM_EXEEXT' always appears in Cygnus configure + files. Other programs may or may not use one of them. + + This macro looks for the executable suffix used on the host + system. On Unix systems, this is the empty string. On Windows + systems, this is `.exe'. This macro directs automake to use the + executable suffix as appropriate when creating programs. This + macro does not take any arguments. + + The `AC_EXEEXT' form is new, and is part of a Cygnus patch to + autoconf to support compiling with Visual C++. Older programs use + `AM_EXEEXT' instead. + + (Programs which do not use automake use neither `AC_EXEEXT' nor + `AM_EXEEXT'). + +`AC_PROG_CC' + If you are writing C code, you will normally want to use this + macro. It locates the C compiler to use. It does not take any + arguments. + + However, if this `configure.in' file is for a library which is to + be compiled by a cross compiler which may not fully work, then you + will not want to use `AC_PROG_CC'. Instead, you will want to use a + variant which does not call the macro `AC_PROG_CC_WORKS'. Examples + can be found in various `configure.in' files for libraries that are + compiled with cross compilers, such as libiberty or libgloss. + This is essentially a bug in autoconf, and there will probably be + a better workaround at some point. + +`AC_PROG_CXX' + If you are writing C++ code, you will want to use this macro. It + locates the C++ compiler to use. It does not take any arguments. + The same cross compiler comments apply as for `AC_PROG_CC'. + +`AM_PROG_LIBTOOL' + If you want to build libraries, and you want to permit them to be + shared, or you want to link against libraries which were built + using libtool, then you will need this macro. This macro is + required in order to use libtool. + + By default, this will cause all libraries to be built as shared + libraries. To prevent this-to change the default-use + `AM_DISABLE_SHARED' before `AM_PROG_LIBTOOL'. The configure + options `--enable-shared' and `--disable-shared' may be used to + override the default at build time. + +`AC_DEFINE(_GNU_SOURCE)' + GNU packages should normally include this line before any other + feature tests. This defines the macro `_GNU_SOURCE' when + compiling, which directs the libc header files to provide the + standard GNU system interfaces including all GNU extensions. If + this macro is not defined, certain GNU extensions may not be + available. + +`AC_OUTPUT' + This macro takes a list of file names which the configure process + should produce. This is normally a list of one or more `Makefile' + files in different directories. If your package lives entirely in + a single directory, you would use simply `AC_OUTPUT(Makefile)'. + If you also have, for example, a `lib' subdirectory, you would use + `AC_OUTPUT(Makefile lib/Makefile)'. + + If you want to use locally defined macros in your `configure.in' +file, then you will need to write a `acinclude.m4' file which defines +them (if not using automake, this file is called `aclocal.m4'). +Alternatively, you can put separate macros in an `m4' subdirectory, and +put `ACLOCAL_AMFLAGS = -I m4' in your `Makefile.am' file so that the +`aclocal' program will be able to find them. + + The different macro prefixes indicate which tool defines the macro. +Macros which start with `AC_' are part of autoconf. Macros which start +with `AM_' are provided by automake or libtool. + + +File: configure.info, Node: Write Makefile.am, Next: Write acconfig.h, Prev: Write configure.in, Up: Getting Started + +Write Makefile.am +================= + + You must write the file `Makefile.am'. This is an automake input +file, and the automake manual describes in detail what this file should +look like. + + The automake commands in `Makefile.am' mostly look like variable +assignments in a `Makefile'. automake recognizes special variable +names, and automatically add make rules to the output as needed. + + There will be one `Makefile.am' file for each directory in your +package. For each directory with subdirectories, the `Makefile.am' +file should contain the line + SUBDIRS = DIR DIR ... + +where each DIR is the name of a subdirectory. + + For each `Makefile.am', there should be a corresponding `Makefile' +in the `AC_OUTPUT' macro in `configure.in'. + + Every `Makefile.am' written at Cygnus should contain the line + AUTOMAKE_OPTIONS = cygnus + +This puts automake into Cygnus mode. See the automake manual for +details. + + You may to include the version number of `automake' that you are +using on the `AUTOMAKE_OPTIONS' line. For example, + AUTOMAKE_OPTIONS = cygnus 1.3 + +This will prevent users from running an earlier version of `automake' +and perhaps getting an invalid `Makefile.in'. + + If your package builds a program, then in the directory where that +program is built you will normally want a line like + bin_PROGRAMS = PROGRAM + +where PROGRAM is the name of the program. You will then want a line +like + PROGRAM_SOURCES = FILE FILE ... + +where each FILE is the name of a source file to link into the program +(e.g., `foo.c'). + + If your package builds a library, and you do not want the library to +ever be built as a shared library, then in the directory where that +library is built you will normally want a line like + lib_LIBRARIES = libNAME.a + +where `libNAME.a' is the name of the library. You will then want a +line like + libNAME_a_SOURCES = FILE FILE ... + +where each FILE is the name of a source file to add to the library. + + If your package builds a library, and you want to permit building the +library as a shared library, then in the directory where that library is +built you will normally want a line like + lib_LTLIBRARIES = libNAME.la + The use of `LTLIBRARIES', and the `.la' extension, indicate a +library to be built using libtool. As usual, you will then want a line +like + libNAME_la_SOURCES = FILE FILE ... + + The strings `bin' and `lib' that appear above in `bin_PROGRAMS' and +`lib_LIBRARIES' are not arbitrary. They refer to particular +directories, which may be set by the `--bindir' and `--libdir' options +to `configure'. If those options are not used, the default values are +based on the `--prefix' or `--exec-prefix' options to `configure'. It +is possible to use other names if the program or library should be +installed in some other directory. + + The `Makefile.am' file may also contain almost anything that may +appear in a normal `Makefile'. automake also supports many other +special variables, as well as conditionals. + + See the automake manual for more information. + + +File: configure.info, Node: Write acconfig.h, Next: Generate files, Prev: Write Makefile.am, Up: Getting Started + +Write acconfig.h +================ + + If you are generating a portability header file, (i.e., you are using +`AM_CONFIG_HEADER' in `configure.in'), then you will have to write a +`acconfig.h' file. It will have to contain the following lines. + + /* Name of package. */ + #undef PACKAGE + + /* Version of package. */ + #undef VERSION + + This requirement is really a bug in the system, and the requirement +may be eliminated at some later date. + + The `acconfig.h' file will also similar comment and `#undef' lines +for any unusual macros in the `configure.in' file, including any macro +which appears in a `AC_DEFINE' macro. + + In particular, if you are writing a GNU package and therefore include +`AC_DEFINE(_GNU_SOURCE)' in `configure.in' as suggested above, you will +need lines like this in `acconfig.h': + /* Enable GNU extensions. */ + #undef _GNU_SOURCE + + Normally the `autoheader' program will inform you of any such +requirements by printing an error message when it is run. However, if +you do anything particular odd in your `configure.in' file, you will +have to make sure that the right entries appear in `acconfig.h', since +otherwise the results of the tests may not be available in the +`config.h' file which your code will use. + + (Thee `PACKAGE' and `VERSION' lines are not required if you are not +using automake, and in that case you may not need a `acconfig.h' file +at all). + + +File: configure.info, Node: Generate files, Next: Getting Started Example, Prev: Write acconfig.h, Up: Getting Started + +Generate files +============== + + Once you have written `configure.in', `Makefile.am', `acconfig.h', +and possibly `acinclude.m4', you must use autoconf and automake +programs to produce the first versions of the generated files. This is +done by executing the following sequence of commands. + + aclocal + autoconf + autoheader + automake + + The `aclocal' and `automake' commands are part of the automake +package, and the `autoconf' and `autoheader' commands are part of the +autoconf package. + + If you are using a `m4' subdirectory for your macros, you will need +to use the `-I m4' option when you run `aclocal'. + + If you are not using the Cygnus tree, use the `-a' option when +running `automake' command in order to copy the required support files +into your source directory. + + If you are using libtool, you must build and install the libtool +package with the same `--prefix' and `--exec-prefix' options as you +used with the autoconf and automake packages. You must do this before +running any of the above commands. If you are not using the Cygnus +tree, you will need to run the `libtoolize' program to copy the libtool +support files into your directory. + + Once you have managed to run these commands without getting any +errors, you should create a new empty directory, and run the `configure' +script which will have been created by `autoconf' with the +`--enable-maintainer-mode' option. This will give you a set of +Makefiles which will include rules to automatically rebuild all the +generated files. + + After doing that, whenever you have changed some of the input files +and want to regenerated the other files, go to your object directory +and run `make'. Doing this is more reliable than trying to rebuild the +files manually, because there are complex order dependencies and it is +easy to forget something. + + +File: configure.info, Node: Getting Started Example, Prev: Generate files, Up: Getting Started + +Example +======= + + Let's consider a trivial example. + + Suppose we want to write a simple version of `touch'. Our program, +which we will call `poke', will take a single file name argument, and +use the `utime' system call to set the modification and access times of +the file to the current time. We want this program to be highly +portable. + + We'll first see what this looks like without using autoconf and +automake, and then see what it looks like with them. + +* Menu: + +* Getting Started Example 1:: First Try. +* Getting Started Example 2:: Second Try. +* Getting Started Example 3:: Third Try. +* Generate Files in Example:: Generate Files. + + +File: configure.info, Node: Getting Started Example 1, Next: Getting Started Example 2, Up: Getting Started Example + +First Try +--------- + + Here is our first try at `poke.c'. Note that we've written it +without ANSI/ISO C prototypes, since we want it to be highly portable. + + #include <stdio.h> + #include <stdlib.h> + #include <sys/types.h> + #include <utime.h> + + int + main (argc, argv) + int argc; + char **argv; + { + if (argc != 2) + { + fprintf (stderr, "Usage: poke file\n"); + exit (1); + } + + if (utime (argv[1], NULL) < 0) + { + perror ("utime"); + exit (1); + } + + exit (0); + } + + We also write a simple `Makefile'. + + CC = gcc + CFLAGS = -g -O2 + + all: poke + + poke: poke.o + $(CC) -o poke $(CFLAGS) $(LDFLAGS) poke.o + + So far, so good. + + Unfortunately, there are a few problems. + + On older Unix systems derived from BSD 4.3, the `utime' system call +does not accept a second argument of `NULL'. On those systems, we need +to pass a pointer to `struct utimbuf' structure. Unfortunately, even +older systems don't define that structure; on those systems, we need to +pass an array of two `long' values. + + The header file `stdlib.h' was invented by ANSI C, and older systems +don't have a copy. We included it above to get a declaration of `exit'. + + We can find some of these portability problems by running +`autoscan', which will create a `configure.scan' file which we can use +as a prototype for our `configure.in' file. I won't show the output, +but it will notice the potential problems with `utime' and `stdlib.h'. + + In our `Makefile', we don't provide any way to install the program. +This doesn't matter much for such a simple example, but a real program +will need an `install' target. For that matter, we will also want a +`clean' target. + + +File: configure.info, Node: Getting Started Example 2, Next: Getting Started Example 3, Prev: Getting Started Example 1, Up: Getting Started Example + +Second Try +---------- + + Here is our second try at this program. + + We modify `poke.c' to use preprocessor macros to control what +features are available. (I've cheated a bit by using the same macro +names which autoconf will use). + + #include <stdio.h> + + #ifdef STDC_HEADERS + #include <stdlib.h> + #endif + + #include <sys/types.h> + + #ifdef HAVE_UTIME_H + #include <utime.h> + #endif + + #ifndef HAVE_UTIME_NULL + + #include <time.h> + + #ifndef HAVE_STRUCT_UTIMBUF + + struct utimbuf + { + long actime; + long modtime; + }; + + #endif + + static int + utime_now (file) + char *file; + { + struct utimbuf now; + + now.actime = now.modtime = time (NULL); + return utime (file, &now); + } + + #define utime(f, p) utime_now (f) + + #endif /* HAVE_UTIME_NULL */ + + int + main (argc, argv) + int argc; + char **argv; + { + if (argc != 2) + { + fprintf (stderr, "Usage: poke file\n"); + exit (1); + } + + if (utime (argv[1], NULL) < 0) + { + perror ("utime"); + exit (1); + } + + exit (0); + } + + Here is the associated `Makefile'. We've added support for the +preprocessor flags we use. We've also added `install' and `clean' +targets. + + # Set this to your installation directory. + bindir = /usr/local/bin + + # Uncomment this if you have the standard ANSI/ISO C header files. + # STDC_HDRS = -DSTDC_HEADERS + + # Uncomment this if you have utime.h. + # UTIME_H = -DHAVE_UTIME_H + + # Uncomment this if utime (FILE, NULL) works on your system. + # UTIME_NULL = -DHAVE_UTIME_NULL + + # Uncomment this if struct utimbuf is defined in utime.h. + # UTIMBUF = -DHAVE_STRUCT_UTIMBUF + + CC = gcc + CFLAGS = -g -O2 + + ALL_CFLAGS = $(STDC_HDRS) $(UTIME_H) $(UTIME_NULL) $(UTIMBUF) $(CFLAGS) + + all: poke + + poke: poke.o + $(CC) -o poke $(ALL_CFLAGS) $(LDFLAGS) poke.o + + .c.o: + $(CC) -c $(ALL_CFLAGS) poke.c + + install: poke + cp poke $(bindir)/poke + + clean: + rm poke poke.o + + Some problems with this approach should be clear. + + Users who want to compile poke will have to know how `utime' works +on their systems, so that they can uncomment the `Makefile' correctly. + + The installation is done using `cp', but many systems have an +`install' program which may be used, and which supports optional +features such as stripping debugging information out of the installed +binary. + + The use of `Makefile' variables like `CC', `CFLAGS' and `LDFLAGS' +follows the requirements of the GNU standards. This is convenient for +all packages, since it reduces surprises for users. However, it is +easy to get the details wrong, and wind up with a slightly nonstandard +distribution. + + +File: configure.info, Node: Getting Started Example 3, Next: Generate Files in Example, Prev: Getting Started Example 2, Up: Getting Started Example + +Third Try +--------- + + For our third try at this program, we will write a `configure.in' +script to discover the configuration features on the host system, rather +than requiring the user to edit the `Makefile'. We will also write a +`Makefile.am' rather than a `Makefile'. + + The only change to `poke.c' is to add a line at the start of the +file: + #include "config.h" + + The new `configure.in' file is as follows. + + AC_INIT(poke.c) + AM_INIT_AUTOMAKE(poke, 1.0) + AM_CONFIG_HEADER(config.h:config.in) + AC_PROG_CC + AC_HEADER_STDC + AC_CHECK_HEADERS(utime.h) + AC_EGREP_HEADER(utimbuf, utime.h, AC_DEFINE(HAVE_STRUCT_UTIMBUF)) + AC_FUNC_UTIME_NULL + AC_OUTPUT(Makefile) + + The first four macros in this file, and the last one, were described +above; see *Note Write configure.in::. If we omit these macros, then +when we run `automake' we will get a reminder that we need them. + + The other macros are standard autoconf macros. + +`AC_HEADER_STDC' + Check for standard C headers. + +`AC_CHECK_HEADERS' + Check whether a particular header file exists. + +`AC_EGREP_HEADER' + Check for a particular string in a particular header file, in this + case checking for `utimbuf' in `utime.h'. + +`AC_FUNC_UTIME_NULL' + Check whether `utime' accepts a NULL second argument to set the + file change time to the current time. + + See the autoconf manual for a more complete description. + + The new `Makefile.am' file is as follows. Note how simple this is +compared to our earlier `Makefile'. + + bin_PROGRAMS = poke + + poke_SOURCES = poke.c + + This means that we should build a single program name `poke'. It +should be installed in the binary directory, which we called `bindir' +earlier. The program `poke' is built from the source file `poke.c'. + + We must also write a `acconfig.h' file. Besides `PACKAGE' and +`VERSION', which must be mentioned for all packages which use automake, +we must include `HAVE_STRUCT_UTIMBUF', since we mentioned it in an +`AC_DEFINE'. + + /* Name of package. */ + #undef PACKAGE + + /* Version of package. */ + #undef VERSION + + /* Whether utime.h defines struct utimbuf. */ + #undef HAVE_STRUCT_UTIMBUF + + +File: configure.info, Node: Generate Files in Example, Prev: Getting Started Example 3, Up: Getting Started Example + +Generate Files +-------------- + + We must now generate the other files, using the following commands. + + aclocal + autoconf + autoheader + automake + + When we run `autoheader', it will remind us of any macros we forgot +to add to `acconfig.h'. + + When we run `automake', it will want to add some files to our +distribution. It will add them automatically if we use the +`--add-missing' option. + + By default, `automake' will run in GNU mode, which means that it +will want us to create certain additional files; as of this writing, it +will want `NEWS', `README', `AUTHORS', and `ChangeLog', all of which +are files which should appear in a standard GNU distribution. We can +either add those files, or run `automake' with the `--foreign' option. + + Running these tools will generate the following files, all of which +are described in the next chapter. + + * `aclocal.m4' + + * `configure' + + * `config.in' + + * `Makefile.in' + + * `stamp-h.in' + + +File: configure.info, Node: Files, Next: Configuration Names, Prev: Getting Started, Up: Top + +Files +***** + + As was seen in the previous chapter, the GNU configure and build +system uses a number of different files. The developer must write a +few files. The others are generated by various tools. + + The system is rather flexible, and can be used in many different +ways. In describing the files that it uses, I will describe the common +case, and mention some other cases that may arise. + +* Menu: + +* Developer Files:: Developer Files. +* Build Files:: Build Files. +* Support Files:: Support Files. + + +File: configure.info, Node: Developer Files, Next: Build Files, Up: Files + +Developer Files +=============== + + This section describes the files written or generated by the +developer of a package. + +* Menu: + +* Developer Files Picture:: Developer Files Picture. +* Written Developer Files:: Written Developer Files. +* Generated Developer Files:: Generated Developer Files. + + +File: configure.info, Node: Developer Files Picture, Next: Written Developer Files, Up: Developer Files + +Developer Files Picture +----------------------- + + Here is a picture of the files which are written by the developer, +the generated files which would be included with a complete source +distribution, and the tools which create those files. The file names +are plain text and the tool names are enclosed by `*' characters (e.g., +`autoheader' is the name of a tool, not the name of a file). + + acconfig.h configure.in Makefile.am + | | | + | --------------+---------------------- | + | | | | | + v v | acinclude.m4 | | + *autoheader* | | v v + | | v --->*automake* + v |--->*aclocal* | | + config.in | | | v + | v | Makefile.in + | aclocal.m4--- + | | + v v + *autoconf* + | + v + configure + + +File: configure.info, Node: Written Developer Files, Next: Generated Developer Files, Prev: Developer Files Picture, Up: Developer Files + +Written Developer Files +----------------------- + + The following files would be written by the developer. + +`configure.in' + This is the configuration script. This script contains + invocations of autoconf macros. It may also contain ordinary + shell script code. This file will contain feature tests for + portability issues. The last thing in the file will normally be + an `AC_OUTPUT' macro listing which files to create when the + builder runs the configure script. This file is always required + when using the GNU configure system. *Note Write configure.in::. + +`Makefile.am' + This is the automake input file. It describes how the code should + be built. It consists of definitions of automake variables. It + may also contain ordinary Makefile targets. This file is only + needed when using automake (newer tools normally use automake, but + there are still older tools which have not been converted, in + which the developer writes `Makefile.in' directly). *Note Write + Makefile.am::. + +`acconfig.h' + When the configure script creates a portability header file, by + using `AM_CONFIG_HEADER' (or, if not using automake, + `AC_CONFIG_HEADER'), this file is used to describe macros which are + not recognized by the `autoheader' command. This is normally a + fairly uninteresting file, consisting of a collection of `#undef' + lines with comments. Normally any call to `AC_DEFINE' in + `configure.in' will require a line in this file. *Note Write + acconfig.h::. + +`acinclude.m4' + This file is not always required. It defines local autoconf + macros. These macros may then be used in `configure.in'. If you + don't need any local autoconf macros, then you don't need this + file at all. In fact, in general, you never need local autoconf + macros, since you can put everything in `configure.in', but + sometimes a local macro is convenient. + + Newer tools may omit `acinclude.m4', and instead use a + subdirectory, typically named `m4', and define `ACLOCAL_AMFLAGS = + -I m4' in `Makefile.am' to force `aclocal' to look there for macro + definitions. The macro definitions are then placed in separate + files in that directory. + + The `acinclude.m4' file is only used when using automake; in older + tools, the developer writes `aclocal.m4' directly, if it is needed. + + +File: configure.info, Node: Generated Developer Files, Prev: Written Developer Files, Up: Developer Files + +Generated Developer Files +------------------------- + + The following files would be generated by the developer. + + When using automake, these files are normally not generated manually +after the first time. Instead, the generated `Makefile' contains rules +to automatically rebuild the files as required. When +`AM_MAINTAINER_MODE' is used in `configure.in' (the normal case in +Cygnus code), the automatic rebuilding rules will only be defined if +you configure using the `--enable-maintainer-mode' option. + + When using automatic rebuilding, it is important to ensure that all +the various tools have been built and installed on your `PATH'. Using +automatic rebuilding is highly recommended, so much so that I'm not +going to explain what you have to do if you don't use it. + +`configure' + This is the configure script which will be run when building the + package. This is generated by `autoconf' from `configure.in' and + `aclocal.m4'. This is a shell script. + +`Makefile.in' + This is the file which the configure script will turn into the + `Makefile' at build time. This file is generated by `automake' + from `Makefile.am'. If you aren't using automake, you must write + this file yourself. This file is pretty much a normal `Makefile', + with some configure substitutions for certain variables. + +`aclocal.m4' + This file is created by the `aclocal' program, based on the + contents of `configure.in' and `acinclude.m4' (or, as noted in the + description of `acinclude.m4' above, on the contents of an `m4' + subdirectory). This file contains definitions of autoconf macros + which `autoconf' will use when generating the file `configure'. + These autoconf macros may be defined by you in `acinclude.m4' or + they may be defined by other packages such as automake, libtool or + gettext. If you aren't using automake, you will normally write + this file yourself; in that case, if `configure.in' uses only + standard autoconf macros, this file will not be needed at all. + +`config.in' + This file is created by `autoheader' based on `acconfig.h' and + `configure.in'. At build time, the configure script will define + some of the macros in it to create `config.h', which may then be + included by your program. This permits your C code to use + preprocessor conditionals to change its behaviour based on the + characteristics of the host system. This file may also be called + `config.h.in'. + +`stamp.h-in' + This rather uninteresting file, which I omitted from the picture, + is generated by `automake'. It always contains the string + `timestamp'. It is used as a timestamp file indicating whether + `config.in' is up to date. Using a timestamp file means that + `config.in' can be marked as up to date without actually changing + its modification time. This is useful since `config.in' depends + upon `configure.in', but it is easy to change `configure.in' in a + way which does not affect `config.in'. + + +File: configure.info, Node: Build Files, Next: Support Files, Prev: Developer Files, Up: Files + +Build Files +=========== + + This section describes the files which are created at configure and +build time. These are the files which somebody who builds the package +will see. + + Of course, the developer will also build the package. The +distinction between developer files and build files is not that the +developer does not see the build files, but that somebody who only +builds the package does not have to worry about the developer files. + +* Menu: + +* Build Files Picture:: Build Files Picture. +* Build Files Description:: Build Files Description. + + +File: configure.info, Node: Build Files Picture, Next: Build Files Description, Up: Build Files + +Build Files Picture +------------------- + + Here is a picture of the files which will be created at build time. +`config.status' is both a created file and a shell script which is run +to create other files, and the picture attempts to show that. + + config.in *configure* Makefile.in + | | | + | v | + | config.status | + | | | + *config.status*<======+==========>*config.status* + | | + v v + config.h Makefile + + +File: configure.info, Node: Build Files Description, Prev: Build Files Picture, Up: Build Files + +Build Files Description +----------------------- + + This is a description of the files which are created at build time. + +`config.status' + The first step in building a package is to run the `configure' + script. The `configure' script will create the file + `config.status', which is itself a shell script. When you first + run `configure', it will automatically run `config.status'. An + `Makefile' derived from an automake generated `Makefile.in' will + contain rules to automatically run `config.status' again when + necessary to recreate certain files if their inputs change. + +`Makefile' + This is the file which make will read to build the program. The + `config.status' script will transform `Makefile.in' into + `Makefile'. + +`config.h' + This file defines C preprocessor macros which C code can use to + adjust its behaviour on different systems. The `config.status' + script will transform `config.in' into `config.h'. + +`config.cache' + This file did not fit neatly into the picture, and I omitted it. + It is used by the `configure' script to cache results between + runs. This can be an important speedup. If you modify + `configure.in' in such a way that the results of old tests should + change (perhaps you have added a new library to `LDFLAGS'), then + you will have to remove `config.cache' to force the tests to be + rerun. + + The autoconf manual explains how to set up a site specific cache + file. This can speed up running `configure' scripts on your + system. + +`stamp.h' + This file, which I omitted from the picture, is similar to + `stamp-h.in'. It is used as a timestamp file indicating whether + `config.h' is up to date. This is useful since `config.h' depends + upon `config.status', but it is easy for `config.status' to change + in a way which does not affect `config.h'. + + +File: configure.info, Node: Support Files, Prev: Build Files, Up: Files + +Support Files +============= + + The GNU configure and build system requires several support files to +be included with your distribution. You do not normally need to concern +yourself with these. If you are using the Cygnus tree, most are already +present. Otherwise, they will be installed with your source by +`automake' (with the `--add-missing' option) and `libtoolize'. + + You don't have to put the support files in the top level directory. +You can put them in a subdirectory, and use the `AC_CONFIG_AUX_DIR' +macro in `configure.in' to tell `automake' and the `configure' script +where they are. + + In this section, I describe the support files, so that you can know +what they are and why they are there. + +`ABOUT-NLS' + Added by automake if you are using gettext. This is a + documentation file about the gettext project. + +`ansi2knr.c' + Used by an automake generated `Makefile' if you put `ansi2knr' in + `AUTOMAKE_OPTIONS' in `Makefile.am'. This permits compiling ANSI + C code with a K&R C compiler. + +`ansi2knr.1' + The man page which goes with `ansi2knr.c'. + +`config.guess' + A shell script which determines the configuration name for the + system on which it is run. + +`config.sub' + A shell script which canonicalizes a configuration name entered by + a user. + +`elisp-comp' + Used to compile Emacs LISP files. + +`install-sh' + A shell script which installs a program. This is used if the + configure script can not find an install binary. + +`ltconfig' + Used by libtool. This is a shell script which configures libtool + for the particular system on which it is used. + +`ltmain.sh' + Used by libtool. This is the actual libtool script which is used, + after it is configured by `ltconfig' to build a library. + +`mdate-sh' + A shell script used by an automake generated `Makefile' to pretty + print the modification time of a file. This is used to maintain + version numbers for texinfo files. + +`missing' + A shell script used if some tool is missing entirely. This is + used by an automake generated `Makefile' to avoid certain sorts of + timestamp problems. + +`mkinstalldirs' + A shell script which creates a directory, including all parent + directories. This is used by an automake generated `Makefile' + during installation. + +`texinfo.tex' + Required if you have any texinfo files. This is used when + converting Texinfo files into DVI using `texi2dvi' and TeX. + +`ylwrap' + A shell script used by an automake generated `Makefile' to run + programs like `bison', `yacc', `flex', and `lex'. These programs + default to producing output files with a fixed name, and the + `ylwrap' script runs them in a subdirectory to avoid file name + conflicts when using a parallel make program. + + +File: configure.info, Node: Configuration Names, Next: Cross Compilation Tools, Prev: Files, Up: Top + +Configuration Names +******************* + + The GNU configure system names all systems using a "configuration +name". All such names used to be triplets (they may now contain four +parts in certain cases), and the term "configuration triplet" is still +seen. + +* Menu: + +* Configuration Name Definition:: Configuration Name Definition. +* Using Configuration Names:: Using Configuration Names. + diff --git a/etc/configure.info-2 b/etc/configure.info-2 new file mode 100644 index 00000000000..2c9c6676f75 --- /dev/null +++ b/etc/configure.info-2 @@ -0,0 +1,1137 @@ +This is configure.info, produced by makeinfo version 4.0 from +./configure.texi. + +INFO-DIR-SECTION GNU admin +START-INFO-DIR-ENTRY +* configure: (configure). The GNU configure and build system +END-INFO-DIR-ENTRY + + This file documents the GNU configure and build system. + + Copyright (C) 1998 Cygnus Solutions. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that this permission notice may be stated in a +translation approved by the Foundation. + + +File: configure.info, Node: Configuration Name Definition, Next: Using Configuration Names, Up: Configuration Names + +Configuration Name Definition +============================= + + This is a string of the form CPU-MANUFACTURER-OPERATING_SYSTEM. In +some cases, this is extended to a four part form: +CPU-MANUFACTURER-KERNEL-OPERATING_SYSTEM. + + When using a configuration name in a configure option, it is normally +not necessary to specify an entire name. In particular, the +MANUFACTURER field is often omitted, leading to strings such as +`i386-linux' or `sparc-sunos'. The shell script `config.sub' will +translate these shortened strings into the canonical form. autoconf +will arrange for `config.sub' to be run automatically when it is needed. + + The fields of a configuration name are as follows: + +CPU + The type of processor. This is typically something like `i386' or + `sparc'. More specific variants are used as well, such as + `mipsel' to indicate a little endian MIPS processor. + +MANUFACTURER + A somewhat freeform field which indicates the manufacturer of the + system. This is often simply `unknown'. Other common strings are + `pc' for an IBM PC compatible system, or the name of a workstation + vendor, such as `sun'. + +OPERATING_SYSTEM + The name of the operating system which is run on the system. This + will be something like `solaris2.5' or `irix6.3'. There is no + particular restriction on the version number, and strings like + `aix4.1.4.0' are seen. For an embedded system, which has no + operating system, this field normally indicates the type of object + file format, such as `elf' or `coff'. + +KERNEL + This is used mainly for GNU/Linux. A typical GNU/Linux + configuration name is `i586-pc-linux-gnulibc1'. In this case the + kernel, `linux', is separated from the operating system, + `gnulibc1'. + + The shell script `config.guess' will normally print the correct +configuration name for the system on which it is run. It does by +running `uname' and by examining other characteristics of the system. + + Because `config.guess' can normally determine the configuration name +for a machine, it is normally only necessary to specify a configuration +name when building a cross-compiler or when building using a +cross-compiler. + + +File: configure.info, Node: Using Configuration Names, Prev: Configuration Name Definition, Up: Configuration Names + +Using Configuration Names +========================= + + A configure script will sometimes have to make a decision based on a +configuration name. You will need to do this if you have to compile +code differently based on something which can not be tested using a +standard autoconf feature test. + + It is normally better to test for particular features, rather than to +test for a particular system. This is because as Unix evolves, +different systems copy features from one another. Even if you need to +determine whether the feature is supported based on a configuration +name, you should define a macro which describes the feature, rather than +defining a macro which describes the particular system you are on. + + Testing for a particular system is normally done using a case +statement in `configure.in'. The case statement might look something +like the following, assuming that `host' is a shell variable holding a +canonical configuration name (which will be the case if `configure.in' +uses the `AC_CANONICAL_HOST' or `AC_CANONICAL_SYSTEM' macro). + + case "${host}" in + i[3456]86-*-linux-gnu*) do something ;; + sparc*-sun-solaris2.[56789]*) do something ;; + sparc*-sun-solaris*) do something ;; + mips*-*-elf*) do something ;; + esac + + It is particularly important to use `*' after the operating system +field, in order to match the version number which will be generated by +`config.guess'. + + In most cases you must be careful to match a range of processor +types. For most processor families, a trailing `*' suffices, as in +`mips*' above. For the i386 family, something along the lines of +`i[3456]86' suffices at present. For the m68k family, you will need +something like `m68*'. Of course, if you do not need to match on the +processor, it is simpler to just replace the entire field by a `*', as +in `*-*-irix*'. + + +File: configure.info, Node: Cross Compilation Tools, Next: Canadian Cross, Prev: Configuration Names, Up: Top + +Cross Compilation Tools +*********************** + + The GNU configure and build system can be used to build "cross +compilation" tools. A cross compilation tool is a tool which runs on +one system and produces code which runs on another system. + +* Menu: + +* Cross Compilation Concepts:: Cross Compilation Concepts. +* Host and Target:: Host and Target. +* Using the Host Type:: Using the Host Type. +* Specifying the Target:: Specifying the Target. +* Using the Target Type:: Using the Target Type. +* Cross Tools in the Cygnus Tree:: Cross Tools in the Cygnus Tree + + +File: configure.info, Node: Cross Compilation Concepts, Next: Host and Target, Up: Cross Compilation Tools + +Cross Compilation Concepts +========================== + + A compiler which produces programs which run on a different system +is a cross compilation compiler, or simply a "cross compiler". +Similarly, we speak of cross assemblers, cross linkers, etc. + + In the normal case, a compiler produces code which runs on the same +system as the one on which the compiler runs. When it is necessary to +distinguish this case from the cross compilation case, such a compiler +is called a "native compiler". Similarly, we speak of native +assemblers, etc. + + Although the debugger is not strictly speaking a compilation tool, +it is nevertheless meaningful to speak of a cross debugger: a debugger +which is used to debug code which runs on another system. Everything +that is said below about configuring cross compilation tools applies to +the debugger as well. + + +File: configure.info, Node: Host and Target, Next: Using the Host Type, Prev: Cross Compilation Concepts, Up: Cross Compilation Tools + +Host and Target +=============== + + When building cross compilation tools, there are two different +systems involved: the system on which the tools will run, and the +system for which the tools generate code. + + The system on which the tools will run is called the "host" system. + + The system for which the tools generate code is called the "target" +system. + + For example, suppose you have a compiler which runs on a GNU/Linux +system and generates ELF programs for a MIPS embedded system. In this +case the GNU/Linux system is the host, and the MIPS ELF system is the +target. Such a compiler could be called a GNU/Linux cross MIPS ELF +compiler, or, equivalently, a `i386-linux-gnu' cross `mips-elf' +compiler. + + Naturally, most programs are not cross compilation tools. For those +programs, it does not make sense to speak of a target. It only makes +sense to speak of a target for tools like `gcc' or the `binutils' which +actually produce running code. For example, it does not make sense to +speak of the target of a tool like `bison' or `make'. + + Most cross compilation tools can also serve as native tools. For a +native compilation tool, it is still meaningful to speak of a target. +For a native tool, the target is the same as the host. For example, for +a GNU/Linux native compiler, the host is GNU/Linux, and the target is +also GNU/Linux. + + +File: configure.info, Node: Using the Host Type, Next: Specifying the Target, Prev: Host and Target, Up: Cross Compilation Tools + +Using the Host Type +=================== + + In almost all cases the host system is the system on which you run +the `configure' script, and on which you build the tools (for the case +when they differ, *note Canadian Cross::). + + If your configure script needs to know the configuration name of the +host system, and the package is not a cross compilation tool and +therefore does not have a target, put `AC_CANONICAL_HOST' in +`configure.in'. This macro will arrange to define a few shell +variables when the `configure' script is run. + +`host' + The canonical configuration name of the host. This will normally + be determined by running the `config.guess' shell script, although + the user is permitted to override this by using an explicit + `--host' option. + +`host_alias' + In the unusual case that the user used an explicit `--host' option, + this will be the argument to `--host'. In the normal case, this + will be the same as the `host' variable. + +`host_cpu' +`host_vendor' +`host_os' + The first three parts of the canonical configuration name. + + The shell variables may be used by putting shell code in +`configure.in'. For an example, see *Note Using Configuration Names::. + + +File: configure.info, Node: Specifying the Target, Next: Using the Target Type, Prev: Using the Host Type, Up: Cross Compilation Tools + +Specifying the Target +===================== + + By default, the `configure' script will assume that the target is +the same as the host. This is the more common case; for example, it +leads to a native compiler rather than a cross compiler. + + If you want to build a cross compilation tool, you must specify the +target explicitly by using the `--target' option when you run +`configure'. The argument to `--target' is the configuration name of +the system for which you wish to generate code. *Note Configuration +Names::. + + For example, to build tools which generate code for a MIPS ELF +embedded system, you would use `--target mips-elf'. + + +File: configure.info, Node: Using the Target Type, Next: Cross Tools in the Cygnus Tree, Prev: Specifying the Target, Up: Cross Compilation Tools + +Using the Target Type +===================== + + When writing `configure.in' for a cross compilation tool, you will +need to use information about the target. To do this, put +`AC_CANONICAL_SYSTEM' in `configure.in'. + + `AC_CANONICAL_SYSTEM' will look for a `--target' option and +canonicalize it using the `config.sub' shell script. It will also run +`AC_CANONICAL_HOST' (*note Using the Host Type::). + + The target type will be recorded in the following shell variables. +Note that the host versions of these variables will also be defined by +`AC_CANONICAL_HOST'. + +`target' + The canonical configuration name of the target. + +`target_alias' + The argument to the `--target' option. If the user did not specify + a `--target' option, this will be the same as `host_alias'. + +`target_cpu' +`target_vendor' +`target_os' + The first three parts of the canonical target configuration name. + + Note that if `host' and `target' are the same string, you can assume +a native configuration. If they are different, you can assume a cross +configuration. + + It is arguably possible for `host' and `target' to represent the +same system, but for the strings to not be identical. For example, if +`config.guess' returns `sparc-sun-sunos4.1.4', and somebody configures +with `--target sparc-sun-sunos4.1', then the slight differences between +the two versions of SunOS may be unimportant for your tool. However, +in the general case it can be quite difficult to determine whether the +differences between two configuration names are significant or not. +Therefore, by convention, if the user specifies a `--target' option +without specifying a `--host' option, it is assumed that the user wants +to configure a cross compilation tool. + + The variables `target' and `target_alias' should be handled +differently. + + In general, whenever the user may actually see a string, +`target_alias' should be used. This includes anything which may appear +in the file system, such as a directory name or part of a tool name. +It also includes any tool output, unless it is clearly labelled as the +canonical target configuration name. This permits the user to use the +`--target' option to specify how the tool will appear to the outside +world. + + On the other hand, when checking for characteristics of the target +system, `target' should be used. This is because a wide variety of +`--target' options may map into the same canonical configuration name. +You should not attempt to duplicate the canonicalization done by +`config.sub' in your own code. + + By convention, cross tools are installed with a prefix of the +argument used with the `--target' option, also known as `target_alias' +(*note Using the Target Type::). If the user does not use the +`--target' option, and thus is building a native tool, no prefix is +used. + + For example, if gcc is configured with `--target mips-elf', then the +installed binary will be named `mips-elf-gcc'. If gcc is configured +without a `--target' option, then the installed binary will be named +`gcc'. + + The autoconf macro `AC_ARG_PROGRAM' will handle this for you. If +you are using automake, no more need be done; the programs will +automatically be installed with the correct prefixes. Otherwise, see +the autoconf documentation for `AC_ARG_PROGRAM'. + + +File: configure.info, Node: Cross Tools in the Cygnus Tree, Prev: Using the Target Type, Up: Cross Compilation Tools + +Cross Tools in the Cygnus Tree +============================== + + The Cygnus tree is used for various packages including gdb, the GNU +binutils, and egcs. It is also, of course, used for Cygnus releases. + + In the Cygnus tree, the top level `configure' script uses the old +Cygnus configure system, not autoconf. The top level `Makefile.in' is +written to build packages based on what is in the source tree, and +supports building a large number of tools in a single +`configure'/`make' step. + + The Cygnus tree may be configured with a `--target' option. The +`--target' option applies recursively to every subdirectory, and +permits building an entire set of cross tools at once. + +* Menu: + +* Host and Target Libraries:: Host and Target Libraries. +* Target Library Configure Scripts:: Target Library Configure Scripts. +* Make Targets in Cygnus Tree:: Make Targets in Cygnus Tree. +* Target libiberty:: Target libiberty + + +File: configure.info, Node: Host and Target Libraries, Next: Target Library Configure Scripts, Up: Cross Tools in the Cygnus Tree + +Host and Target Libraries +------------------------- + + The Cygnus tree distinguishes host libraries from target libraries. + + Host libraries are built with the compiler used to build the programs +which run on the host, which is called the host compiler. This includes +libraries such as `bfd' and `tcl'. These libraries are built with the +host compiler, and are linked into programs like the binutils or gcc +which run on the host. + + Target libraries are built with the target compiler. If gcc is +present in the source tree, then the target compiler is the gcc that is +built using the host compiler. Target libraries are libraries such as +`newlib' and `libstdc++'. These libraries are not linked into the host +programs, but are instead made available for use with programs built +with the target compiler. + + For the rest of this section, assume that gcc is present in the +source tree, so that it will be used to build the target libraries. + + There is a complication here. The configure process needs to know +which compiler you are going to use to build a tool; otherwise, the +feature tests will not work correctly. The Cygnus tree handles this by +not configuring the target libraries until the target compiler is +built. In order to permit everything to build using a single +`configure'/`make', the configuration of the target libraries is +actually triggered during the make step. + + When the target libraries are configured, the `--target' option is +not used. Instead, the `--host' option is used with the argument of +the `--target' option for the overall configuration. If no `--target' +option was used for the overall configuration, the `--host' option will +be passed with the output of the `config.guess' shell script. Any +`--build' option is passed down unchanged. + + This translation of configuration options is done because since the +target libraries are compiled with the target compiler, they are being +built in order to run on the target of the overall configuration. By +the definition of host, this means that their host system is the same as +the target system of the overall configuration. + + The same process is used for both a native configuration and a cross +configuration. Even when using a native configuration, the target +libraries will be configured and built using the newly built compiler. +This is particularly important for the C++ libraries, since there is no +reason to assume that the C++ compiler used to build the host tools (if +there even is one) uses the same ABI as the g++ compiler which will be +used to build the target libraries. + + There is one difference between a native configuration and a cross +configuration. In a native configuration, the target libraries are +normally configured and built as siblings of the host tools. In a cross +configuration, the target libraries are normally built in a subdirectory +whose name is the argument to `--target'. This is mainly for +historical reasons. + + To summarize, running `configure' in the Cygnus tree configures all +the host libraries and tools, but does not configure any of the target +libraries. Running `make' then does the following steps: + + * Build the host libraries. + + * Build the host programs, including gcc. Note that we call gcc + both a host program (since it runs on the host) and a target + compiler (since it generates code for the target). + + * Using the newly built target compiler, configure the target + libraries. + + * Build the target libraries. + + The steps need not be done in precisely this order, since they are +actually controlled by `Makefile' targets. + + +File: configure.info, Node: Target Library Configure Scripts, Next: Make Targets in Cygnus Tree, Prev: Host and Target Libraries, Up: Cross Tools in the Cygnus Tree + +Target Library Configure Scripts +-------------------------------- + + There are a few things you must know in order to write a configure +script for a target library. This is just a quick sketch, and beginners +shouldn't worry if they don't follow everything here. + + The target libraries are configured and built using a newly built +target compiler. There may not be any startup files or libraries for +this target compiler. In fact, those files will probably be built as +part of some target library, which naturally means that they will not +exist when your target library is configured. + + This means that the configure script for a target library may not use +any test which requires doing a link. This unfortunately includes many +useful autoconf macros, such as `AC_CHECK_FUNCS'. autoconf macros +which do a compile but not a link, such as `AC_CHECK_HEADERS', may be +used. + + This is a severe restriction, but normally not a fatal one, as target +libraries can often assume the presence of other target libraries, and +thus know which functions will be available. + + As of this writing, the autoconf macro `AC_PROG_CC' does a link to +make sure that the compiler works. This may fail in a target library, +so target libraries must use a different set of macros to locate the +compiler. See the `configure.in' file in a directory like `libiberty' +or `libgloss' for an example. + + As noted in the previous section, target libraries are sometimes +built in directories which are siblings to the host tools, and are +sometimes built in a subdirectory. The `--with-target-subdir' configure +option will be passed when the library is configured. Its value will be +an empty string if the target library is a sibling. Its value will be +the name of the subdirectory if the target library is in a subdirectory. + + If the overall build is not a native build (i.e., the overall +configure used the `--target' option), then the library will be +configured with the `--with-cross-host' option. The value of this +option will be the host system of the overall build. Recall that the +host system of the library will be the target of the overall build. If +the overall build is a native build, the `--with-cross-host' option +will not be used. + + A library which can be built both standalone and as a target library +may want to install itself into different directories depending upon the +case. When built standalone, or when built native, the library should +be installed in `$(libdir)'. When built as a target library which is +not native, the library should be installed in `$(tooldir)/lib'. The +`--with-cross-host' option may be used to distinguish these cases. + + This same test of `--with-cross-host' may be used to see whether it +is OK to use link tests in the configure script. If the +`--with-cross-host' option is not used, then the library is being built +either standalone or native, and a link should work. + + +File: configure.info, Node: Make Targets in Cygnus Tree, Next: Target libiberty, Prev: Target Library Configure Scripts, Up: Cross Tools in the Cygnus Tree + +Make Targets in Cygnus Tree +--------------------------- + + The top level `Makefile' in the Cygnus tree defines targets for +every known subdirectory. + + For every subdirectory DIR which holds a host library or program, +the `Makefile' target `all-DIR' will build that library or program. + + There are dependencies among host tools. For example, building gcc +requires first building gas, because the gcc build process invokes the +target assembler. These dependencies are reflected in the top level +`Makefile'. + + For every subdirectory DIR which holds a target library, the +`Makefile' target `configure-target-DIR' will configure that library. +The `Makefile' target `all-target-DIR' will build that library. + + Every `configure-target-DIR' target depends upon `all-gcc', since +gcc, the target compiler, is required to configure the tool. Every +`all-target-DIR' target depends upon the corresponding +`configure-target-DIR' target. + + There are several other targets which may be of interest for each +directory: `install-DIR', `clean-DIR', and `check-DIR'. There are also +corresponding `target' versions of these for the target libraries , +such as `install-target-DIR'. + + +File: configure.info, Node: Target libiberty, Prev: Make Targets in Cygnus Tree, Up: Cross Tools in the Cygnus Tree + +Target libiberty +---------------- + + The `libiberty' subdirectory is currently a special case, in that it +is the only directory which is built both using the host compiler and +using the target compiler. + + This is because the files in `libiberty' are used when building the +host tools, and they are also incorporated into the `libstdc++' target +library as support code. + + This duality does not pose any particular difficulties. It means +that there are targets for both `all-libiberty' and +`all-target-libiberty'. + + In a native configuration, when target libraries are not built in a +subdirectory, the same objects are normally used as both the host build +and the target build. This is normally OK, since libiberty contains +only C code, and in a native configuration the results of the host +compiler and the target compiler are normally interoperable. + + Irix 6 is again an exception here, since the SGI native compiler +defaults to using the `O32' ABI, and gcc defaults to using the `N32' +ABI. On Irix 6, the target libraries are built in a subdirectory even +for a native configuration, avoiding this problem. + + There are currently no other libraries built for both the host and +the target, but there is no conceptual problem with adding more. + + +File: configure.info, Node: Canadian Cross, Next: Cygnus Configure, Prev: Cross Compilation Tools, Up: Top + +Canadian Cross +************** + + It is possible to use the GNU configure and build system to build a +program which will run on a system which is different from the system on +which the tools are built. In other words, it is possible to build +programs using a cross compiler. + + This is referred to as a "Canadian Cross". + +* Menu: + +* Canadian Cross Example:: Canadian Cross Example. +* Canadian Cross Concepts:: Canadian Cross Concepts. +* Build Cross Host Tools:: Build Cross Host Tools. +* Build and Host Options:: Build and Host Options. +* CCross not in Cygnus Tree:: Canadian Cross not in Cygnus Tree. +* CCross in Cygnus Tree:: Canadian Cross in Cygnus Tree. +* Supporting Canadian Cross:: Supporting Canadian Cross. + + +File: configure.info, Node: Canadian Cross Example, Next: Canadian Cross Concepts, Up: Canadian Cross + +Canadian Cross Example +====================== + + Here is an example of a Canadian Cross. + + While running on a GNU/Linux, you can build a program which will run +on a Solaris system. You would use a GNU/Linux cross Solaris compiler +to build the program. + + Of course, you could not run the resulting program on your GNU/Linux +system. You would have to copy it over to a Solaris system before you +would run it. + + Of course, you could also simply build the programs on the Solaris +system in the first place. However, perhaps the Solaris system is not +available for some reason; perhaps you actually don't have one, but you +want to build the tools for somebody else to use. Or perhaps your +GNU/Linux system is much faster than your Solaris system. + + A Canadian Cross build is most frequently used when building +programs to run on a non-Unix system, such as DOS or Windows. It may +be simpler to configure and build on a Unix system than to support the +configuration machinery on a non-Unix system. + + +File: configure.info, Node: Canadian Cross Concepts, Next: Build Cross Host Tools, Prev: Canadian Cross Example, Up: Canadian Cross + +Canadian Cross Concepts +======================= + + When building a Canadian Cross, there are at least two different +systems involved: the system on which the tools are being built, and +the system on which the tools will run. + + The system on which the tools are being built is called the "build" +system. + + The system on which the tools will run is called the host system. + + For example, if you are building a Solaris program on a GNU/Linux +system, as in the previous section, the build system would be GNU/Linux, +and the host system would be Solaris. + + It is, of course, possible to build a cross compiler using a Canadian +Cross (i.e., build a cross compiler using a cross compiler). In this +case, the system for which the resulting cross compiler generates code +is called the target system. (For a more complete discussion of host +and target systems, *note Host and Target::). + + An example of building a cross compiler using a Canadian Cross would +be building a Windows cross MIPS ELF compiler on a GNU/Linux system. In +this case the build system would be GNU/Linux, the host system would be +Windows, and the target system would be MIPS ELF. + + The name Canadian Cross comes from the case when the build, host, and +target systems are all different. At the time that these issues were +all being hashed out, Canada had three national political parties. + + +File: configure.info, Node: Build Cross Host Tools, Next: Build and Host Options, Prev: Canadian Cross Concepts, Up: Canadian Cross + +Build Cross Host Tools +====================== + + In order to configure a program for a Canadian Cross build, you must +first build and install the set of cross tools you will use to build the +program. + + These tools will be build cross host tools. That is, they will run +on the build system, and will produce code that runs on the host system. + + It is easy to confuse the meaning of build and host here. Always +remember that the build system is where you are doing the build, and the +host system is where the resulting program will run. Therefore, you +need a build cross host compiler. + + In general, you must have a complete cross environment in order to do +the build. This normally means a cross compiler, cross assembler, and +so forth, as well as libraries and include files for the host system. + + +File: configure.info, Node: Build and Host Options, Next: CCross not in Cygnus Tree, Prev: Build Cross Host Tools, Up: Canadian Cross + +Build and Host Options +====================== + + When you run `configure', you must use both the `--build' and +`--host' options. + + The `--build' option is used to specify the configuration name of +the build system. This can normally be the result of running the +`config.guess' shell script, and it is reasonable to use +`--build=`config.guess`'. + + The `--host' option is used to specify the configuration name of the +host system. + + As we explained earlier, `config.guess' is used to set the default +value for the `--host' option (*note Using the Host Type::). We can +now see that since `config.guess' returns the type of system on which +it is run, it really identifies the build system. Since the host +system is normally the same as the build system (i.e., people do not +normally build using a cross compiler), it is reasonable to use the +result of `config.guess' as the default for the host system when the +`--host' option is not used. + + It might seem that if the `--host' option were used without the +`--build' option that the configure script could run `config.guess' to +determine the build system, and presume a Canadian Cross if the result +of `config.guess' differed from the `--host' option. However, for +historical reasons, some configure scripts are routinely run using an +explicit `--host' option, rather than using the default from +`config.guess'. As noted earlier, it is difficult or impossible to +reliably compare configuration names (*note Using the Target Type::). +Therefore, by convention, if the `--host' option is used, but the +`--build' option is not used, then the build system defaults to the +host system. + + +File: configure.info, Node: CCross not in Cygnus Tree, Next: CCross in Cygnus Tree, Prev: Build and Host Options, Up: Canadian Cross + +Canadian Cross not in Cygnus Tree. +================================== + + If you are not using the Cygnus tree, you must explicitly specify the +cross tools which you want to use to build the program. This is done by +setting environment variables before running the `configure' script. + + You must normally set at least the environment variables `CC', `AR', +and `RANLIB' to the cross tools which you want to use to build. + + For some programs, you must set additional cross tools as well, such +as `AS', `LD', or `NM'. + + You would set these environment variables to the build cross tools +which you are going to use. + + For example, if you are building a Solaris program on a GNU/Linux +system, and your GNU/Linux cross Solaris compiler were named +`solaris-gcc', then you would set the environment variable `CC' to +`solaris-gcc'. + + +File: configure.info, Node: CCross in Cygnus Tree, Next: Supporting Canadian Cross, Prev: CCross not in Cygnus Tree, Up: Canadian Cross + +Canadian Cross in Cygnus Tree +============================= + + This section describes configuring and building a Canadian Cross when +using the Cygnus tree. + +* Menu: + +* Standard Cygnus CCross:: Building a Normal Program. +* Cross Cygnus CCross:: Building a Cross Program. + + +File: configure.info, Node: Standard Cygnus CCross, Next: Cross Cygnus CCross, Up: CCross in Cygnus Tree + +Building a Normal Program +------------------------- + + When configuring a Canadian Cross in the Cygnus tree, all the +appropriate environment variables are automatically set to `HOST-TOOL', +where HOST is the value used for the `--host' option, and TOOL is the +name of the tool (e.g., `gcc', `as', etc.). These tools must be on +your `PATH'. + + Adding a prefix of HOST will give the usual name for the build cross +host tools. To see this, consider that when these cross tools were +built, they were configured to run on the build system and to produce +code for the host system. That is, they were configured with a +`--target' option that is the same as the system which we are now +calling the host. Recall that the default name for installed cross +tools uses the target system as a prefix (*note Using the Target +Type::). Since that is the system which we are now calling the host, +HOST is the right prefix to use. + + For example, if you configure with `--build=i386-linux-gnu' and +`--host=solaris', then the Cygnus tree will automatically default to +using the compiler `solaris-gcc'. You must have previously built and +installed this compiler, probably by doing a build with no `--host' +option and with a `--target' option of `solaris'. + + +File: configure.info, Node: Cross Cygnus CCross, Prev: Standard Cygnus CCross, Up: CCross in Cygnus Tree + +Building a Cross Program +------------------------ + + There are additional considerations if you want to build a cross +compiler, rather than a native compiler, in the Cygnus tree using a +Canadian Cross. + + When you build a cross compiler using the Cygnus tree, then the +target libraries will normally be built with the newly built target +compiler (*note Host and Target Libraries::). However, this will not +work when building with a Canadian Cross. This is because the newly +built target compiler will be a program which runs on the host system, +and therefore will not be able to run on the build system. + + Therefore, when building a cross compiler with the Cygnus tree, you +must first install a set of build cross target tools. These tools will +be used when building the target libraries. + + Note that this is not a requirement of a Canadian Cross in general. +For example, it would be possible to build just the host cross target +tools on the build system, to copy the tools to the host system, and to +build the target libraries on the host system. The requirement for +build cross target tools is imposed by the Cygnus tree, which expects +to be able to build both host programs and target libraries in a single +`configure'/`make' step. Because it builds these in a single step, it +expects to be able to build the target libraries on the build system, +which means that it must use a build cross target toolchain. + + For example, suppose you want to build a Windows cross MIPS ELF +compiler on a GNU/Linux system. You must have previously installed +both a GNU/Linux cross Windows compiler and a GNU/Linux cross MIPS ELF +compiler. + + In order to build the Windows (configuration name `i386-cygwin32') +cross MIPS ELF (configure name `mips-elf') compiler, you might execute +the following commands (long command lines are broken across lines with +a trailing backslash as a continuation character). + + mkdir linux-x-cygwin32 + cd linux-x-cygwin32 + SRCDIR/configure --target i386-cygwin32 --prefix=INSTALLDIR \ + --exec-prefix=INSTALLDIR/H-i386-linux + make + make install + cd .. + mkdir linux-x-mips-elf + cd linux-x-mips-elf + SRCDIR/configure --target mips-elf --prefix=INSTALLDIR \ + --exec-prefix=INSTALLDIR/H-i386-linux + make + make install + cd .. + mkdir cygwin32-x-mips-elf + cd cygwin32-x-mips-elf + SRCDIR/configure --build=i386-linux-gnu --host=i386-cygwin32 \ + --target=mips-elf --prefix=WININSTALLDIR \ + --exec-prefix=WININSTALLDIR/H-i386-cygwin32 + make + make install + + You would then copy the contents of WININSTALLDIR over to the +Windows machine, and run the resulting programs. + + +File: configure.info, Node: Supporting Canadian Cross, Prev: CCross in Cygnus Tree, Up: Canadian Cross + +Supporting Canadian Cross +========================= + + If you want to make it possible to build a program you are developing +using a Canadian Cross, you must take some care when writing your +configure and make rules. Simple cases will normally work correctly. +However, it is not hard to write configure and make tests which will +fail in a Canadian Cross. + +* Menu: + +* CCross in Configure:: Supporting Canadian Cross in Configure Scripts. +* CCross in Make:: Supporting Canadian Cross in Makefiles. + + +File: configure.info, Node: CCross in Configure, Next: CCross in Make, Up: Supporting Canadian Cross + +Supporting Canadian Cross in Configure Scripts +---------------------------------------------- + + In a `configure.in' file, after calling `AC_PROG_CC', you can find +out whether this is a Canadian Cross configure by examining the shell +variable `cross_compiling'. In a Canadian Cross, which means that the +compiler is a cross compiler, `cross_compiling' will be `yes'. In a +normal configuration, `cross_compiling' will be `no'. + + You ordinarily do not need to know the type of the build system in a +configure script. However, if you do need that information, you can get +it by using the macro `AC_CANONICAL_SYSTEM', the same macro that is +used to determine the target system. This macro will set the variables +`build', `build_alias', `build_cpu', `build_vendor', and `build_os', +which correspond to the similar `target' and `host' variables, except +that they describe the build system. + + When writing tests in `configure.in', you must remember that you +want to test the host environment, not the build environment. + + Macros like `AC_CHECK_FUNCS' which use the compiler will test the +host environment. That is because the tests will be done by running the +compiler, which is actually a build cross host compiler. If the +compiler can find the function, that means that the function is present +in the host environment. + + Tests like `test -f /dev/ptyp0', on the other hand, will test the +build environment. Remember that the configure script is running on the +build system, not the host system. If your configure scripts examines +files, those files will be on the build system. Whatever you determine +based on those files may or may not be the case on the host system. + + Most autoconf macros will work correctly for a Canadian Cross. The +main exception is `AC_TRY_RUN'. This macro tries to compile and run a +test program. This will fail in a Canadian Cross, because the program +will be compiled for the host system, which means that it will not run +on the build system. + + The `AC_TRY_RUN' macro provides an optional argument to tell the +configure script what to do in a Canadian Cross. If that argument is +not present, you will get a warning when you run `autoconf': + warning: AC_TRY_RUN called without default to allow cross compiling + +This tells you that the resulting `configure' script will not work with +a Canadian Cross. + + In some cases while it may better to perform a test at configure +time, it is also possible to perform the test at run time. In such a +case you can use the cross compiling argument to `AC_TRY_RUN' to tell +your program that the test could not be performed at configure time. + + There are a few other autoconf macros which will not work correctly +with a Canadian Cross: a partial list is `AC_FUNC_GETPGRP', +`AC_FUNC_SETPGRP', `AC_FUNC_SETVBUF_REVERSED', and +`AC_SYS_RESTARTABLE_SYSCALLS'. The `AC_CHECK_SIZEOF' macro is +generally not very useful with a Canadian Cross; it permits an optional +argument indicating the default size, but there is no way to know what +the correct default should be. + + +File: configure.info, Node: CCross in Make, Prev: CCross in Configure, Up: Supporting Canadian Cross + +Supporting Canadian Cross in Makefiles. +--------------------------------------- + + The main Canadian Cross issue in a `Makefile' arises when you want +to use a subsidiary program to generate code or data which you will then +include in your real program. + + If you compile this subsidiary program using `$(CC)' in the usual +way, you will not be able to run it. This is because `$(CC)' will +build a program for the host system, but the program is being built on +the build system. + + You must instead use a compiler for the build system, rather than the +host system. In the Cygnus tree, this make variable `$(CC_FOR_BUILD)' +will hold a compiler for the build system. + + Note that you should not include `config.h' in a file you are +compiling with `$(CC_FOR_BUILD)'. The `configure' script will build +`config.h' with information for the host system. However, you are +compiling the file using a compiler for the build system (a native +compiler). Subsidiary programs are normally simple filters which do no +user interaction, and it is normally possible to write them in a highly +portable fashion so that the absence of `config.h' is not crucial. + + The gcc `Makefile.in' shows a complex situation in which certain +files, such as `rtl.c', must be compiled into both subsidiary programs +run on the build system and into the final program. This approach may +be of interest for advanced build system hackers. Note that the build +system compiler is rather confusingly called `HOST_CC'. + + +File: configure.info, Node: Cygnus Configure, Next: Multilibs, Prev: Canadian Cross, Up: Top + +Cygnus Configure +**************** + + The Cygnus configure script predates autoconf. All of its +interesting features have been incorporated into autoconf. No new +programs should be written to use the Cygnus configure script. + + However, the Cygnus configure script is still used in a few places: +at the top of the Cygnus tree and in a few target libraries in the +Cygnus tree. Until those uses have been replaced with autoconf, some +brief notes are appropriate here. This is not complete documentation, +but it should be possible to use this as a guide while examining the +scripts themselves. + +* Menu: + +* Cygnus Configure Basics:: Cygnus Configure Basics. +* Cygnus Configure in C++ Libraries:: Cygnus Configure in C++ Libraries. + + +File: configure.info, Node: Cygnus Configure Basics, Next: Cygnus Configure in C++ Libraries, Up: Cygnus Configure + +Cygnus Configure Basics +======================= + + Cygnus configure does not use any generated files; there is no +program corresponding to `autoconf'. Instead, there is a single shell +script named `configure' which may be found at the top of the Cygnus +tree. This shell script was written by hand; it was not generated by +autoconf, and it is incorrect, and indeed harmful, to run `autoconf' in +the top level of a Cygnus tree. + + Cygnus configure works in a particular directory by examining the +file `configure.in' in that directory. That file is broken into four +separate shell scripts. + + The first is the contents of `configure.in' up to a line that starts +with `# per-host:'. This is the common part. + + The second is the rest of `configure.in' up to a line that starts +with `# per-target:'. This is the per host part. + + The third is the rest of `configure.in' up to a line that starts +with `# post-target:'. This is the per target part. + + The fourth is the remainder of `configure.in'. This is the post +target part. + + If any of these comment lines are missing, the corresponding shell +script is empty. + + Cygnus configure will first execute the common part. This must set +the shell variable `srctrigger' to the name of a source file, to +confirm that Cygnus configure is looking at the right directory. This +may set the shell variables `package_makefile_frag' and +`package_makefile_rules_frag'. + + Cygnus configure will next set the `build' and `host' shell +variables, and execute the per host part. This may set the shell +variable `host_makefile_frag'. + + Cygnus configure will next set the `target' variable, and execute +the per target part. This may set the shell variable +`target_makefile_frag'. + + Any of these scripts may set the `subdirs' shell variable. This +variable is a list of subdirectories where a `Makefile.in' file may be +found. Cygnus configure will automatically look for a `Makefile.in' +file in the current directory. The `subdirs' shell variable is not +normally used, and I believe that the only directory which uses it at +present is `newlib'. + + For each `Makefile.in', Cygnus configure will automatically create a +`Makefile' by adding definitions for `make' variables such as `host' +and `target', and automatically editing the values of `make' variables +such as `prefix' if they are present. + + Also, if any of the `makefile_frag' shell variables are set, Cygnus +configure will interpret them as file names relative to either the +working directory or the source directory, and will read the contents of +the file into the generated `Makefile'. The file contents will be read +in after the first line in `Makefile.in' which starts with `####'. + + These `Makefile' fragments are used to customize behaviour for a +particular host or target. They serve to select particular files to +compile, and to define particular preprocessor macros by providing +values for `make' variables which are then used during compilation. +Cygnus configure, unlike autoconf, normally does not do feature tests, +and normally requires support to be added manually for each new host. + + The `Makefile' fragment support is similar to the autoconf +`AC_SUBST_FILE' macro. + + After creating each `Makefile', the post target script will be run +(i.e., it may be run several times). This script may further customize +the `Makefile'. When it is run, the shell variable `Makefile' will +hold the name of the `Makefile', including the appropriate directory +component. + + Like an autoconf generated `configure' script, Cygnus configure will +create a file named `config.status' which, when run, will automatically +recreate the configuration. The `config.status' file will simply +execute the Cygnus configure script again with the appropriate +arguments. + + Any of the parts of `configure.in' may set the shell variables +`files' and `links'. Cygnus configure will set up symlinks from the +names in `links' to the files named in `files'. This is similar to the +autoconf `AC_LINK_FILES' macro. + + Finally, any of the parts of `configure.in' may set the shell +variable `configdirs' to a set of subdirectories. If it is set, Cygnus +configure will recursively run the configure process in each +subdirectory. If the subdirectory uses Cygnus configure, it will +contain a `configure.in' file but no `configure' file, in which case +Cygnus configure will invoke itself recursively. If the subdirectory +has a `configure' file, Cygnus configure assumes that it is an autoconf +generated `configure' script, and simply invokes it directly. + + +File: configure.info, Node: Cygnus Configure in C++ Libraries, Prev: Cygnus Configure Basics, Up: Cygnus Configure + +Cygnus Configure in C++ Libraries +================================= + + The C++ library configure system, written by Per Bothner, deserves +special mention. It uses Cygnus configure, but it does feature testing +like that done by autoconf generated `configure' scripts. This +approach is used in the libraries `libio', `libstdc++', and `libg++'. + + Most of the `Makefile' information is written out by the shell +script `libio/config.shared'. Each `configure.in' file sets certain +shell variables, and then invokes `config.shared' to create two package +`Makefile' fragments. These fragments are then incorporated into the +resulting `Makefile' by the Cygnus configure script. + + The file `_G_config.h' is created in the `libio' object directory by +running the shell script `libio/gen-params'. This shell script uses +feature tests to define macros and typedefs in `_G_config.h'. + + +File: configure.info, Node: Multilibs, Next: FAQ, Prev: Cygnus Configure, Up: Top + +Multilibs +********* + + For some targets gcc may have different processor requirements +depending upon command line options. An obvious example is the +`-msoft-float' option supported on several processors. This option +means that the floating point registers are not available, which means +that floating point operations must be done by calling an emulation +subroutine rather than by using machine instructions. + + For such options, gcc is often configured to compile target libraries +twice: once with `-msoft-float' and once without. When gcc compiles +target libraries more than once, the resulting libraries are called +"multilibs". + + Multilibs are not really part of the GNU configure and build system, +but we discuss them here since they require support in the `configure' +scripts and `Makefile's used for target libraries. + +* Menu: + +* Multilibs in gcc:: Multilibs in gcc. +* Multilibs in Target Libraries:: Multilibs in Target Libraries. + + +File: configure.info, Node: Multilibs in gcc, Next: Multilibs in Target Libraries, Up: Multilibs + +Multilibs in gcc +================ + + In gcc, multilibs are defined by setting the variable +`MULTILIB_OPTIONS' in the target `Makefile' fragment. Several other +`MULTILIB' variables may also be defined there. *Note The Target +Makefile Fragment: (gcc)Target Fragment. + + If you have built gcc, you can see what multilibs it uses by running +it with the `-print-multi-lib' option. The output `.;' means that no +multilibs are used. In general, the output is a sequence of lines, one +per multilib. The first part of each line, up to the `;', is the name +of the multilib directory. The second part is a list of compiler +options separated by `@' characters. + + Multilibs are built in a tree of directories. The top of the tree, +represented by `.' in the list of multilib directories, is the default +library to use when no special compiler options are used. The +subdirectories of the tree hold versions of the library to use when +particular compiler options are used. + diff --git a/etc/configure.info-3 b/etc/configure.info-3 new file mode 100644 index 00000000000..bf1dcc076b1 --- /dev/null +++ b/etc/configure.info-3 @@ -0,0 +1,285 @@ +This is configure.info, produced by makeinfo version 4.0 from +./configure.texi. + +INFO-DIR-SECTION GNU admin +START-INFO-DIR-ENTRY +* configure: (configure). The GNU configure and build system +END-INFO-DIR-ENTRY + + This file documents the GNU configure and build system. + + Copyright (C) 1998 Cygnus Solutions. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that this permission notice may be stated in a +translation approved by the Foundation. + + +File: configure.info, Node: Multilibs in Target Libraries, Prev: Multilibs in gcc, Up: Multilibs + +Multilibs in Target Libraries +============================= + + The target libraries in the Cygnus tree are automatically built with +multilibs. That means that each library is built multiple times. + + This default is set in the top level `configure.in' file, by adding +`--enable-multilib' to the list of arguments passed to configure when +it is run for the target libraries (*note Host and Target Libraries::). + + Each target library uses the shell script `config-ml.in', written by +Doug Evans, to prepare to build target libraries. This shell script is +invoked after the `Makefile' has been created by the `configure' +script. If multilibs are not enabled, it does nothing, otherwise it +modifies the `Makefile' to support multilibs. + + The `config-ml.in' script makes one copy of the `Makefile' for each +multilib in the appropriate subdirectory. When configuring in the +source directory (which is not recommended), it will build a symlink +tree of the sources in each subdirectory. + + The `config-ml.in' script sets several variables in the various +`Makefile's. The `Makefile.in' must have definitions for these +variables already; `config-ml.in' simply changes the existing values. +The `Makefile' should use default values for these variables which will +do the right thing in the subdirectories. + +`MULTISRCTOP' + `config-ml.in' will set this to a sequence of `../' strings, where + the number of strings is the number of multilib levels in the + source tree. The default value should be the empty string. + +`MULTIBUILDTOP' + `config-ml.in' will set this to a sequence of `../' strings, where + the number of strings is number of multilib levels in the object + directory. The default value should be the empty string. This + will differ from `MULTISRCTOP' when configuring in the source tree + (which is not recommended). + +`MULTIDIRS' + In the top level `Makefile' only, `config-ml.in' will set this to + the list of multilib subdirectories. The default value should be + the empty string. + +`MULTISUBDIR' + `config-ml.in' will set this to the installed subdirectory name to + use for this subdirectory, with a leading `/'. The default value + shold be the empty string. + +`MULTIDO' +`MULTICLEAN' + In the top level `Makefile' only, `config-ml.in' will set these + variables to commands to use when doing a recursive make. These + variables should both default to the string `true', so that by + default nothing happens. + + All references to the parent of the source directory should use the +variable `MULTISRCTOP'. Instead of writing `$(srcdir)/..', you must +write `$(srcdir)/$(MULTISRCTOP)..'. + + Similarly, references to the parent of the object directory should +use the variable `MULTIBUILDTOP'. + + In the installation target, the libraries should be installed in the +subdirectory `MULTISUBDIR'. Instead of installing +`$(libdir)/libfoo.a', install `$(libdir)$(MULTISUBDIR)/libfoo.a'. + + The `config-ml.in' script also modifies the top level `Makefile' to +add `multi-do' and `multi-clean' targets which are used when building +multilibs. + + The default target of the `Makefile' should include the following +command: + @$(MULTIDO) $(FLAGS_TO_PASS) DO=all multi-do + +This assumes that `$(FLAGS_TO_PASS)' is defined as a set of variables +to pass to a recursive invocation of `make'. This will build all the +multilibs. Note that the default value of `MULTIDO' is `true', so by +default this command will do nothing. It will only do something in the +top level `Makefile' if multilibs were enabled. + + The `install' target of the `Makefile' should include the following +command: + @$(MULTIDO) $(FLAGS_TO_PASS) DO=install multi-do + + In general, any operation, other than clean, which should be +performed on all the multilibs should use a `$(MULTIDO)' line, setting +the variable `DO' to the target of each recursive call to `make'. + + The `clean' targets (`clean', `mostlyclean', etc.) should use +`$(MULTICLEAN)'. For example, the `clean' target should do this: + @$(MULTICLEAN) DO=clean multi-clean + + +File: configure.info, Node: FAQ, Next: Index, Prev: Multilibs, Up: Top + +Frequently Asked Questions +************************** + +Which do I run first, `autoconf' or `automake'? + Except when you first add autoconf or automake support to a + package, you shouldn't run either by hand. Instead, configure + with the `--enable-maintainer-mode' option, and let `make' take + care of it. + +`autoconf' says something about undefined macros. + This means that you have macros in your `configure.in' which are + not defined by `autoconf'. You may be using an old version of + `autoconf'; try building and installing a newer one. Make sure the + newly installled `autoconf' is first on your `PATH'. Also, see + the next question. + +My `configure' script has stuff like `CY_GNU_GETTEXT' in it. + This means that you have macros in your `configure.in' which should + be defined in your `aclocal.m4' file, but aren't. This usually + means that `aclocal' was not able to appropriate definitions of the + macros. Make sure that you have installed all the packages you + need. In particular, make sure that you have installed libtool + (this is where `AM_PROG_LIBTOOL' is defined) and gettext (this is + where `CY_GNU_GETTEXT' is defined, at least in the Cygnus version + of gettext). + +My `Makefile' has `@' characters in it. + This may mean that you tried to use an autoconf substitution in + your `Makefile.in' without adding the appropriate `AC_SUBST' call + to your `configure' script. Or it may just mean that you need to + rebuild `Makefile' in your build directory. To rebuild `Makefile' + from `Makefile.in', run the shell script `config.status' with no + arguments. If you need to force `configure' to run again, first + run `config.status --recheck'. These runs are normally done + automatically by `Makefile' targets, but if your `Makefile' has + gotten messed up you'll need to help them along. + +Why do I have to run both `config.status --recheck' and `config.status'? + Normally, you don't; they will be run automatically by `Makefile' + targets. If you do need to run them, use `config.status --recheck' + to run the `configure' script again with the same arguments as the + first time you ran it. Use `config.status' (with no arguments) to + regenerate all files (`Makefile', `config.h', etc.) based on the + results of the configure script. The two cases are separate + because it isn't always necessary to regenerate all the files + after running `config.status --recheck'. The `Makefile' targets + generated by automake will use the environment variables + `CONFIG_FILES' and `CONFIG_HEADERS' to only regenerate files as + they are needed. + +What is the Cygnus tree? + The Cygnus tree is used for various packages including gdb, the GNU + binutils, and egcs. It is also, of course, used for Cygnus + releases. It is the build system which was developed at Cygnus, + using the Cygnus configure script. It permits building many + different packages with a single configure and make. The + configure scripts in the tree are being converted to autoconf, but + the general build structure remains intact. + +Why do I have to keep rebuilding and reinstalling the tools? + I know, it's a pain. Unfortunately, there are bugs in the tools + themselves which need to be fixed, and each time that happens + everybody who uses the tools need to reinstall new versions of + them. I don't know if there is going to be a clever fix until the + tools stabilize. + +Why not just have a Cygnus tree `make' target to update the tools? + The tools unfortunately need to be installed before they can be + used. That means that they must be built using an appropriate + prefix, and it seems unwise to assume that every configuration + uses an appropriate prefix. It might be possible to make them + work in place, or it might be possible to install them in some + subdirectory; so far these approaches have not been implemented. + + +File: configure.info, Node: Index, Prev: FAQ, Up: Top + +Index +***** + +* Menu: + +* --build option: Build and Host Options. +* --host option: Build and Host Options. +* --target option: Specifying the Target. +* _GNU_SOURCE: Write configure.in. +* AC_CANONICAL_HOST: Using the Host Type. +* AC_CANONICAL_SYSTEM: Using the Target Type. +* AC_CONFIG_HEADER: Write configure.in. +* AC_EXEEXT: Write configure.in. +* AC_INIT: Write configure.in. +* AC_OUTPUT: Write configure.in. +* AC_PREREQ: Write configure.in. +* AC_PROG_CC: Write configure.in. +* AC_PROG_CXX: Write configure.in. +* acconfig.h: Written Developer Files. +* acconfig.h, writing: Write acconfig.h. +* acinclude.m4: Written Developer Files. +* aclocal.m4: Generated Developer Files. +* AM_CONFIG_HEADER: Write configure.in. +* AM_DISABLE_SHARED: Write configure.in. +* AM_EXEEXT: Write configure.in. +* AM_INIT_AUTOMAKE: Write configure.in. +* AM_MAINTAINER_MODE: Write configure.in. +* AM_PROG_LIBTOOL: Write configure.in. +* AM_PROG_LIBTOOL in configure: FAQ. +* build option: Build and Host Options. +* building with a cross compiler: Canadian Cross. +* canadian cross: Canadian Cross. +* canadian cross in configure: CCross in Configure. +* canadian cross in cygnus tree: CCross in Cygnus Tree. +* canadian cross in makefile: CCross in Make. +* canadian cross, configuring: Build and Host Options. +* canonical system names: Configuration Names. +* config.cache: Build Files Description. +* config.h: Build Files Description. +* config.h.in: Generated Developer Files. +* config.in: Generated Developer Files. +* config.status: Build Files Description. +* config.status --recheck: FAQ. +* configuration names: Configuration Names. +* configuration triplets: Configuration Names. +* configure: Generated Developer Files. +* configure build system: Build and Host Options. +* configure host: Build and Host Options. +* configure target: Specifying the Target. +* configure.in: Written Developer Files. +* configure.in, writing: Write configure.in. +* configuring a canadian cross: Build and Host Options. +* cross compiler: Cross Compilation Concepts. +* cross compiler, building with: Canadian Cross. +* cross tools: Cross Compilation Tools. +* CY_GNU_GETTEXT in configure: FAQ. +* cygnus configure: Cygnus Configure. +* goals: Goals. +* history: History. +* host names: Configuration Names. +* host option: Build and Host Options. +* host system: Host and Target. +* host triplets: Configuration Names. +* HOST_CC: CCross in Make. +* libg++ configure: Cygnus Configure in C++ Libraries. +* libio configure: Cygnus Configure in C++ Libraries. +* libstdc++ configure: Cygnus Configure in C++ Libraries. +* Makefile: Build Files Description. +* Makefile, garbage characters: FAQ. +* Makefile.am: Written Developer Files. +* Makefile.am, writing: Write Makefile.am. +* Makefile.in: Generated Developer Files. +* multilibs: Multilibs. +* stamp-h: Build Files Description. +* stamp-h.in: Generated Developer Files. +* system names: Configuration Names. +* system types: Configuration Names. +* target option: Specifying the Target. +* target system: Host and Target. +* triplets: Configuration Names. +* undefined macros: FAQ. + + diff --git a/etc/standards.info b/etc/standards.info new file mode 100644 index 00000000000..47501bda4f7 --- /dev/null +++ b/etc/standards.info @@ -0,0 +1,3833 @@ +This is standards.info, produced by makeinfo version 4.0 from +./standards.texi. + +START-INFO-DIR-ENTRY +* Standards: (standards). GNU coding standards. +END-INFO-DIR-ENTRY + + GNU Coding Standards Copyright (C) 1992, 1993, 1994, 1995, 1996, +1997, 1998 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that this permission notice may be stated in a +translation approved by the Free Software Foundation. + + +File: standards.info, Node: Top, Next: Preface, Prev: (dir), Up: (dir) + +Version +******* + + Last updated March 13, 1998. + +* Menu: + +* Preface:: About the GNU Coding Standards +* Intellectual Property:: Keeping Free Software Free +* Design Advice:: General Program Design +* Program Behavior:: Program Behavior for All Programs +* Writing C:: Making The Best Use of C +* Documentation:: Documenting Programs +* Managing Releases:: The Release Process + + +File: standards.info, Node: Preface, Next: Intellectual Property, Prev: Top, Up: Top + +About the GNU Coding Standards +****************************** + + The GNU Coding Standards were written by Richard Stallman and other +GNU Project volunteers. Their purpose is to make the GNU system clean, +consistent, and easy to install. This document can also be read as a +guide to writing portable, robust and reliable programs. It focuses on +programs written in C, but many of the rules and principles are useful +even if you write in another programming language. The rules often +state reasons for writing in a certain way. + + Corrections or suggestions for this document should be sent to +<gnu@gnu.org>. If you make a suggestion, please include a suggested +new wording for it; our time is limited. We prefer a context diff to +the `standards.texi' or `make-stds.texi' files, but if you don't have +those files, please mail your suggestion anyway. + + This release of the GNU Coding Standards was last updated March 13, +1998. + + +File: standards.info, Node: Intellectual Property, Next: Design Advice, Prev: Preface, Up: Top + +Keeping Free Software Free +************************** + + This node discusses how you can make sure that GNU software remains +unencumbered. + +* Menu: + +* Reading Non-Free Code:: Referring to Proprietary Programs +* Contributions:: Accepting Contributions + + +File: standards.info, Node: Reading Non-Free Code, Next: Contributions, Up: Intellectual Property + +Referring to Proprietary Programs +================================= + + Don't in any circumstances refer to Unix source code for or during +your work on GNU! (Or to any other proprietary programs.) + + If you have a vague recollection of the internals of a Unix program, +this does not absolutely mean you can't write an imitation of it, but +do try to organize the imitation internally along different lines, +because this is likely to make the details of the Unix version +irrelevant and dissimilar to your results. + + For example, Unix utilities were generally optimized to minimize +memory use; if you go for speed instead, your program will be very +different. You could keep the entire input file in core and scan it +there instead of using stdio. Use a smarter algorithm discovered more +recently than the Unix program. Eliminate use of temporary files. Do +it in one pass instead of two (we did this in the assembler). + + Or, on the contrary, emphasize simplicity instead of speed. For some +applications, the speed of today's computers makes simpler algorithms +adequate. + + Or go for generality. For example, Unix programs often have static +tables or fixed-size strings, which make for arbitrary limits; use +dynamic allocation instead. Make sure your program handles NULs and +other funny characters in the input files. Add a programming language +for extensibility and write part of the program in that language. + + Or turn some parts of the program into independently usable +libraries. Or use a simple garbage collector instead of tracking +precisely when to free memory, or use a new GNU facility such as +obstacks. + + +File: standards.info, Node: Contributions, Prev: Reading Non-Free Code, Up: Intellectual Property + +Accepting Contributions +======================= + + If someone else sends you a piece of code to add to the program you +are working on, we need legal papers to use it--the same sort of legal +papers we will need to get from you. _Each_ significant contributor to +a program must sign some sort of legal papers in order for us to have +clear title to the program. The main author alone is not enough. + + So, before adding in any contributions from other people, please tell +us, so we can arrange to get the papers. Then wait until we tell you +that we have received the signed papers, before you actually use the +contribution. + + This applies both before you release the program and afterward. If +you receive diffs to fix a bug, and they make significant changes, we +need legal papers for that change. + + This also applies to comments and documentation files. For copyright +law, comments and code are just text. Copyright applies to all kinds of +text, so we need legal papers for all kinds. + + You don't need papers for changes of a few lines here or there, since +they are not significant for copyright purposes. Also, you don't need +papers if all you get from the suggestion is some ideas, not actual code +which you use. For example, if you write a different solution to the +problem, you don't need to get papers. + + We know this is frustrating; it's frustrating for us as well. But if +you don't wait, you are going out on a limb--for example, what if the +contributor's employer won't sign a disclaimer? You might have to take +that code out again! + + The very worst thing is if you forget to tell us about the other +contributor. We could be very embarrassed in court some day as a +result. + + We have more detailed advice for maintainers of programs; if you have +reached the stage of actually maintaining a program for GNU (whether +released or not), please ask us for a copy. + + +File: standards.info, Node: Design Advice, Next: Program Behavior, Prev: Intellectual Property, Up: Top + +General Program Design +********************** + + This node discusses some of the issues you should take into account +when designing your program. + +* Menu: + +* Compatibility:: Compatibility with other implementations +* Using Extensions:: Using non-standard features +* ANSI C:: Using ANSI C features +* Source Language:: Using languages other than C + + +File: standards.info, Node: Compatibility, Next: Using Extensions, Up: Design Advice + +Compatibility with Other Implementations +======================================== + + With occasional exceptions, utility programs and libraries for GNU +should be upward compatible with those in Berkeley Unix, and upward +compatible with ANSI C if ANSI C specifies their behavior, and upward +compatible with POSIX if POSIX specifies their behavior. + + When these standards conflict, it is useful to offer compatibility +modes for each of them. + + ANSI C and POSIX prohibit many kinds of extensions. Feel free to +make the extensions anyway, and include a `--ansi', `--posix', or +`--compatible' option to turn them off. However, if the extension has +a significant chance of breaking any real programs or scripts, then it +is not really upward compatible. Try to redesign its interface. + + Many GNU programs suppress extensions that conflict with POSIX if the +environment variable `POSIXLY_CORRECT' is defined (even if it is +defined with a null value). Please make your program recognize this +variable if appropriate. + + When a feature is used only by users (not by programs or command +files), and it is done poorly in Unix, feel free to replace it +completely with something totally different and better. (For example, +`vi' is replaced with Emacs.) But it is nice to offer a compatible +feature as well. (There is a free `vi' clone, so we offer it.) + + Additional useful features not in Berkeley Unix are welcome. + + +File: standards.info, Node: Using Extensions, Next: ANSI C, Prev: Compatibility, Up: Design Advice + +Using Non-standard Features +=========================== + + Many GNU facilities that already exist support a number of convenient +extensions over the comparable Unix facilities. Whether to use these +extensions in implementing your program is a difficult question. + + On the one hand, using the extensions can make a cleaner program. +On the other hand, people will not be able to build the program unless +the other GNU tools are available. This might cause the program to +work on fewer kinds of machines. + + With some extensions, it might be easy to provide both alternatives. +For example, you can define functions with a "keyword" `INLINE' and +define that as a macro to expand into either `inline' or nothing, +depending on the compiler. + + In general, perhaps it is best not to use the extensions if you can +straightforwardly do without them, but to use the extensions if they +are a big improvement. + + An exception to this rule are the large, established programs (such +as Emacs) which run on a great variety of systems. Such programs would +be broken by use of GNU extensions. + + Another exception is for programs that are used as part of +compilation: anything that must be compiled with other compilers in +order to bootstrap the GNU compilation facilities. If these require +the GNU compiler, then no one can compile them without having them +installed already. That would be no good. + + +File: standards.info, Node: ANSI C, Next: Source Language, Prev: Using Extensions, Up: Design Advice + +ANSI C and pre-ANSI C +===================== + + Do not ever use the "trigraph" feature of ANSI C. + + ANSI C is widespread enough now that it is ok to write new programs +that use ANSI C features (and therefore will not work in non-ANSI +compilers). And if a program is already written in ANSI C, there's no +need to convert it to support non-ANSI compilers. + + However, it is easy to support non-ANSI compilers in most programs, +so you might still consider doing so when you write a program. Instead +of writing function definitions in ANSI prototype form, + + int + foo (int x, int y) + ... + +write the definition in pre-ANSI style like this, + + int + foo (x, y) + int x, y; + ... + +and use a separate declaration to specify the argument prototype: + + int foo (int, int); + + You need such a declaration anyway, in a header file, to get the +benefit of ANSI C prototypes in all the files where the function is +called. And once you have it, you lose nothing by writing the function +definition in the pre-ANSI style. + + If you don't know non-ANSI C, there's no need to learn it; just +write in ANSI C. + + +File: standards.info, Node: Source Language, Prev: ANSI C, Up: Design Advice + +Using Languages Other Than C +============================ + + Using a language other than C is like using a non-standard feature: +it will cause trouble for users. Even if GCC supports the other +language, users may find it inconvenient to have to install the +compiler for that other language in order to build your program. For +example, if you write your program in C++, people will have to install +the C++ compiler in order to compile your program. Thus, it is better +if you write in C. + + But there are three situations when there is no disadvantage in using +some other language: + + * It is okay to use another language if your program contains an + interpreter for that language. + + For example, if your program links with GUILE, it is ok to write + part of the program in Scheme or another language supported by + GUILE. + + * It is okay to use another language in a tool specifically intended + for use with that language. + + This is okay because the only people who want to build the tool + will be those who have installed the other language anyway. + + * If an application is of interest to a narrow community, then + perhaps it's not important if the application is inconvenient to + install. + + C has one other advantage over C++ and other compiled languages: more +people know C, so more people will find it easy to read and modify the +program if it is written in C. + + +File: standards.info, Node: Program Behavior, Next: Writing C, Prev: Design Advice, Up: Top + +Program Behavior for All Programs +********************************* + + This node describes how to write robust software. It also describes +general standards for error messages, the command line interface, and +how libraries should behave. + +* Menu: + +* Semantics:: Writing robust programs +* Libraries:: Library behavior +* Errors:: Formatting error messages +* User Interfaces:: Standards for command line interfaces +* Option Table:: Table of long options. +* Memory Usage:: When and how to care about memory needs + + +File: standards.info, Node: Semantics, Next: Libraries, Up: Program Behavior + +Writing Robust Programs +======================= + + Avoid arbitrary limits on the length or number of _any_ data +structure, including file names, lines, files, and symbols, by +allocating all data structures dynamically. In most Unix utilities, +"long lines are silently truncated". This is not acceptable in a GNU +utility. + + Utilities reading files should not drop NUL characters, or any other +nonprinting characters _including those with codes above 0177_. The +only sensible exceptions would be utilities specifically intended for +interface to certain types of printers that can't handle those +characters. + + Check every system call for an error return, unless you know you +wish to ignore errors. Include the system error text (from `perror' or +equivalent) in _every_ error message resulting from a failing system +call, as well as the name of the file if any and the name of the +utility. Just "cannot open foo.c" or "stat failed" is not sufficient. + + Check every call to `malloc' or `realloc' to see if it returned +zero. Check `realloc' even if you are making the block smaller; in a +system that rounds block sizes to a power of 2, `realloc' may get a +different block if you ask for less space. + + In Unix, `realloc' can destroy the storage block if it returns zero. +GNU `realloc' does not have this bug: if it fails, the original block +is unchanged. Feel free to assume the bug is fixed. If you wish to +run your program on Unix, and wish to avoid lossage in this case, you +can use the GNU `malloc'. + + You must expect `free' to alter the contents of the block that was +freed. Anything you want to fetch from the block, you must fetch before +calling `free'. + + If `malloc' fails in a noninteractive program, make that a fatal +error. In an interactive program (one that reads commands from the +user), it is better to abort the command and return to the command +reader loop. This allows the user to kill other processes to free up +virtual memory, and then try the command again. + + Use `getopt_long' to decode arguments, unless the argument syntax +makes this unreasonable. + + When static storage is to be written in during program execution, use +explicit C code to initialize it. Reserve C initialized declarations +for data that will not be changed. + + Try to avoid low-level interfaces to obscure Unix data structures +(such as file directories, utmp, or the layout of kernel memory), since +these are less likely to work compatibly. If you need to find all the +files in a directory, use `readdir' or some other high-level interface. +These will be supported compatibly by GNU. + + By default, the GNU system will provide the signal handling +functions of BSD and of POSIX. So GNU software should be written to use +these. + + In error checks that detect "impossible" conditions, just abort. +There is usually no point in printing any message. These checks +indicate the existence of bugs. Whoever wants to fix the bugs will have +to read the source code and run a debugger. So explain the problem with +comments in the source. The relevant data will be in variables, which +are easy to examine with the debugger, so there is no point moving them +elsewhere. + + Do not use a count of errors as the exit status for a program. +_That does not work_, because exit status values are limited to 8 bits +(0 through 255). A single run of the program might have 256 errors; if +you try to return 256 as the exit status, the parent process will see 0 +as the status, and it will appear that the program succeeded. + + If you make temporary files, check the `TMPDIR' environment +variable; if that variable is defined, use the specified directory +instead of `/tmp'. + + +File: standards.info, Node: Libraries, Next: Errors, Prev: Semantics, Up: Program Behavior + +Library Behavior +================ + + Try to make library functions reentrant. If they need to do dynamic +storage allocation, at least try to avoid any nonreentrancy aside from +that of `malloc' itself. + + Here are certain name conventions for libraries, to avoid name +conflicts. + + Choose a name prefix for the library, more than two characters long. +All external function and variable names should start with this prefix. +In addition, there should only be one of these in any given library +member. This usually means putting each one in a separate source file. + + An exception can be made when two external symbols are always used +together, so that no reasonable program could use one without the +other; then they can both go in the same file. + + External symbols that are not documented entry points for the user +should have names beginning with `_'. They should also contain the +chosen name prefix for the library, to prevent collisions with other +libraries. These can go in the same files with user entry points if +you like. + + Static functions and variables can be used as you like and need not +fit any naming convention. + + +File: standards.info, Node: Errors, Next: User Interfaces, Prev: Libraries, Up: Program Behavior + +Formatting Error Messages +========================= + + Error messages from compilers should look like this: + + SOURCE-FILE-NAME:LINENO: MESSAGE + + Error messages from other noninteractive programs should look like +this: + + PROGRAM:SOURCE-FILE-NAME:LINENO: MESSAGE + +when there is an appropriate source file, or like this: + + PROGRAM: MESSAGE + +when there is no relevant source file. + + In an interactive program (one that is reading commands from a +terminal), it is better not to include the program name in an error +message. The place to indicate which program is running is in the +prompt or with the screen layout. (When the same program runs with +input from a source other than a terminal, it is not interactive and +would do best to print error messages using the noninteractive style.) + + The string MESSAGE should not begin with a capital letter when it +follows a program name and/or file name. Also, it should not end with +a period. + + Error messages from interactive programs, and other messages such as +usage messages, should start with a capital letter. But they should not +end with a period. + + +File: standards.info, Node: User Interfaces, Next: Option Table, Prev: Errors, Up: Program Behavior + +Standards for Command Line Interfaces +===================================== + + Please don't make the behavior of a utility depend on the name used +to invoke it. It is useful sometimes to make a link to a utility with +a different name, and that should not change what it does. + + Instead, use a run time option or a compilation switch or both to +select among the alternate behaviors. + + Likewise, please don't make the behavior of the program depend on the +type of output device it is used with. Device independence is an +important principle of the system's design; do not compromise it merely +to save someone from typing an option now and then. + + If you think one behavior is most useful when the output is to a +terminal, and another is most useful when the output is a file or a +pipe, then it is usually best to make the default behavior the one that +is useful with output to a terminal, and have an option for the other +behavior. + + Compatibility requires certain programs to depend on the type of +output device. It would be disastrous if `ls' or `sh' did not do so in +the way all users expect. In some of these cases, we supplement the +program with a preferred alternate version that does not depend on the +output device type. For example, we provide a `dir' program much like +`ls' except that its default output format is always multi-column +format. + + It is a good idea to follow the POSIX guidelines for the +command-line options of a program. The easiest way to do this is to use +`getopt' to parse them. Note that the GNU version of `getopt' will +normally permit options anywhere among the arguments unless the special +argument `--' is used. This is not what POSIX specifies; it is a GNU +extension. + + Please define long-named options that are equivalent to the +single-letter Unix-style options. We hope to make GNU more user +friendly this way. This is easy to do with the GNU function +`getopt_long'. + + One of the advantages of long-named options is that they can be +consistent from program to program. For example, users should be able +to expect the "verbose" option of any GNU program which has one, to be +spelled precisely `--verbose'. To achieve this uniformity, look at the +table of common long-option names when you choose the option names for +your program (*note Option Table::). + + It is usually a good idea for file names given as ordinary arguments +to be input files only; any output files would be specified using +options (preferably `-o' or `--output'). Even if you allow an output +file name as an ordinary argument for compatibility, try to provide an +option as another way to specify it. This will lead to more consistency +among GNU utilities, and fewer idiosyncracies for users to remember. + + All programs should support two standard options: `--version' and +`--help'. + +`--version' + This option should direct the program to information about its + name, version, origin and legal status, all on standard output, + and then exit successfully. Other options and arguments should be + ignored once this is seen, and the program should not perform its + normal function. + + The first line is meant to be easy for a program to parse; the + version number proper starts after the last space. In addition, + it contains the canonical name for this program, in this format: + + GNU Emacs 19.30 + + The program's name should be a constant string; _don't_ compute it + from `argv[0]'. The idea is to state the standard or canonical + name for the program, not its file name. There are other ways to + find out the precise file name where a command is found in `PATH'. + + If the program is a subsidiary part of a larger package, mention + the package name in parentheses, like this: + + emacsserver (GNU Emacs) 19.30 + + If the package has a version number which is different from this + program's version number, you can mention the package version + number just before the close-parenthesis. + + If you *need* to mention the version numbers of libraries which + are distributed separately from the package which contains this + program, you can do so by printing an additional line of version + info for each library you want to mention. Use the same format + for these lines as for the first line. + + Please do not mention all of the libraries that the program uses + "just for completeness"--that would produce a lot of unhelpful + clutter. Please mention library version numbers only if you find + in practice that they are very important to you in debugging. + + The following line, after the version number line or lines, should + be a copyright notice. If more than one copyright notice is + called for, put each on a separate line. + + Next should follow a brief statement that the program is free + software, and that users are free to copy and change it on certain + conditions. If the program is covered by the GNU GPL, say so + here. Also mention that there is no warranty, to the extent + permitted by law. + + It is ok to finish the output with a list of the major authors of + the program, as a way of giving credit. + + Here's an example of output that follows these rules: + + GNU Emacs 19.34.5 + Copyright (C) 1996 Free Software Foundation, Inc. + GNU Emacs comes with NO WARRANTY, + to the extent permitted by law. + You may redistribute copies of GNU Emacs + under the terms of the GNU General Public License. + For more information about these matters, + see the files named COPYING. + + You should adapt this to your program, of course, filling in the + proper year, copyright holder, name of program, and the references + to distribution terms, and changing the rest of the wording as + necessary. + + This copyright notice only needs to mention the most recent year in + which changes were made--there's no need to list the years for + previous versions' changes. You don't have to mention the name of + the program in these notices, if that is inconvenient, since it + appeared in the first line. + +`--help' + This option should output brief documentation for how to invoke the + program, on standard output, then exit successfully. Other + options and arguments should be ignored once this is seen, and the + program should not perform its normal function. + + Near the end of the `--help' option's output there should be a line + that says where to mail bug reports. It should have this format: + + Report bugs to MAILING-ADDRESS. + + +File: standards.info, Node: Option Table, Next: Memory Usage, Prev: User Interfaces, Up: Program Behavior + +Table of Long Options +===================== + + Here is a table of long options used by GNU programs. It is surely +incomplete, but we aim to list all the options that a new program might +want to be compatible with. If you use names not already in the table, +please send <gnu@gnu.org> a list of them, with their meanings, so we +can update the table. + +`after-date' + `-N' in `tar'. + +`all' + `-a' in `du', `ls', `nm', `stty', `uname', and `unexpand'. + +`all-text' + `-a' in `diff'. + +`almost-all' + `-A' in `ls'. + +`append' + `-a' in `etags', `tee', `time'; `-r' in `tar'. + +`archive' + `-a' in `cp'. + +`archive-name' + `-n' in `shar'. + +`arglength' + `-l' in `m4'. + +`ascii' + `-a' in `diff'. + +`assign' + `-v' in `gawk'. + +`assume-new' + `-W' in Make. + +`assume-old' + `-o' in Make. + +`auto-check' + `-a' in `recode'. + +`auto-pager' + `-a' in `wdiff'. + +`auto-reference' + `-A' in `ptx'. + +`avoid-wraps' + `-n' in `wdiff'. + +`backward-search' + `-B' in `ctags'. + +`basename' + `-f' in `shar'. + +`batch' + Used in GDB. + +`baud' + Used in GDB. + +`before' + `-b' in `tac'. + +`binary' + `-b' in `cpio' and `diff'. + +`bits-per-code' + `-b' in `shar'. + +`block-size' + Used in `cpio' and `tar'. + +`blocks' + `-b' in `head' and `tail'. + +`break-file' + `-b' in `ptx'. + +`brief' + Used in various programs to make output shorter. + +`bytes' + `-c' in `head', `split', and `tail'. + +`c++' + `-C' in `etags'. + +`catenate' + `-A' in `tar'. + +`cd' + Used in various programs to specify the directory to use. + +`changes' + `-c' in `chgrp' and `chown'. + +`classify' + `-F' in `ls'. + +`colons' + `-c' in `recode'. + +`command' + `-c' in `su'; `-x' in GDB. + +`compare' + `-d' in `tar'. + +`compat' + Used in `gawk'. + +`compress' + `-Z' in `tar' and `shar'. + +`concatenate' + `-A' in `tar'. + +`confirmation' + `-w' in `tar'. + +`context' + Used in `diff'. + +`copyleft' + `-W copyleft' in `gawk'. + +`copyright' + `-C' in `ptx', `recode', and `wdiff'; `-W copyright' in `gawk'. + +`core' + Used in GDB. + +`count' + `-q' in `who'. + +`count-links' + `-l' in `du'. + +`create' + Used in `tar' and `cpio'. + +`cut-mark' + `-c' in `shar'. + +`cxref' + `-x' in `ctags'. + +`date' + `-d' in `touch'. + +`debug' + `-d' in Make and `m4'; `-t' in Bison. + +`define' + `-D' in `m4'. + +`defines' + `-d' in Bison and `ctags'. + +`delete' + `-D' in `tar'. + +`dereference' + `-L' in `chgrp', `chown', `cpio', `du', `ls', and `tar'. + +`dereference-args' + `-D' in `du'. + +`diacritics' + `-d' in `recode'. + +`dictionary-order' + `-d' in `look'. + +`diff' + `-d' in `tar'. + +`digits' + `-n' in `csplit'. + +`directory' + Specify the directory to use, in various programs. In `ls', it + means to show directories themselves rather than their contents. + In `rm' and `ln', it means to not treat links to directories + specially. + +`discard-all' + `-x' in `strip'. + +`discard-locals' + `-X' in `strip'. + +`dry-run' + `-n' in Make. + +`ed' + `-e' in `diff'. + +`elide-empty-files' + `-z' in `csplit'. + +`end-delete' + `-x' in `wdiff'. + +`end-insert' + `-z' in `wdiff'. + +`entire-new-file' + `-N' in `diff'. + +`environment-overrides' + `-e' in Make. + +`eof' + `-e' in `xargs'. + +`epoch' + Used in GDB. + +`error-limit' + Used in `makeinfo'. + +`error-output' + `-o' in `m4'. + +`escape' + `-b' in `ls'. + +`exclude-from' + `-X' in `tar'. + +`exec' + Used in GDB. + +`exit' + `-x' in `xargs'. + +`exit-0' + `-e' in `unshar'. + +`expand-tabs' + `-t' in `diff'. + +`expression' + `-e' in `sed'. + +`extern-only' + `-g' in `nm'. + +`extract' + `-i' in `cpio'; `-x' in `tar'. + +`faces' + `-f' in `finger'. + +`fast' + `-f' in `su'. + +`fatal-warnings' + `-E' in `m4'. + +`file' + `-f' in `info', `gawk', Make, `mt', and `tar'; `-n' in `sed'; `-r' + in `touch'. + +`field-separator' + `-F' in `gawk'. + +`file-prefix' + `-b' in Bison. + +`file-type' + `-F' in `ls'. + +`files-from' + `-T' in `tar'. + +`fill-column' + Used in `makeinfo'. + +`flag-truncation' + `-F' in `ptx'. + +`fixed-output-files' + `-y' in Bison. + +`follow' + `-f' in `tail'. + +`footnote-style' + Used in `makeinfo'. + +`force' + `-f' in `cp', `ln', `mv', and `rm'. + +`force-prefix' + `-F' in `shar'. + +`format' + Used in `ls', `time', and `ptx'. + +`freeze-state' + `-F' in `m4'. + +`fullname' + Used in GDB. + +`gap-size' + `-g' in `ptx'. + +`get' + `-x' in `tar'. + +`graphic' + `-i' in `ul'. + +`graphics' + `-g' in `recode'. + +`group' + `-g' in `install'. + +`gzip' + `-z' in `tar' and `shar'. + +`hashsize' + `-H' in `m4'. + +`header' + `-h' in `objdump' and `recode' + +`heading' + `-H' in `who'. + +`help' + Used to ask for brief usage information. + +`here-delimiter' + `-d' in `shar'. + +`hide-control-chars' + `-q' in `ls'. + +`idle' + `-u' in `who'. + +`ifdef' + `-D' in `diff'. + +`ignore' + `-I' in `ls'; `-x' in `recode'. + +`ignore-all-space' + `-w' in `diff'. + +`ignore-backups' + `-B' in `ls'. + +`ignore-blank-lines' + `-B' in `diff'. + +`ignore-case' + `-f' in `look' and `ptx'; `-i' in `diff' and `wdiff'. + +`ignore-errors' + `-i' in Make. + +`ignore-file' + `-i' in `ptx'. + +`ignore-indentation' + `-I' in `etags'. + +`ignore-init-file' + `-f' in Oleo. + +`ignore-interrupts' + `-i' in `tee'. + +`ignore-matching-lines' + `-I' in `diff'. + +`ignore-space-change' + `-b' in `diff'. + +`ignore-zeros' + `-i' in `tar'. + +`include' + `-i' in `etags'; `-I' in `m4'. + +`include-dir' + `-I' in Make. + +`incremental' + `-G' in `tar'. + +`info' + `-i', `-l', and `-m' in Finger. + +`initial' + `-i' in `expand'. + +`initial-tab' + `-T' in `diff'. + +`inode' + `-i' in `ls'. + +`interactive' + `-i' in `cp', `ln', `mv', `rm'; `-e' in `m4'; `-p' in `xargs'; + `-w' in `tar'. + +`intermix-type' + `-p' in `shar'. + +`jobs' + `-j' in Make. + +`just-print' + `-n' in Make. + +`keep-going' + `-k' in Make. + +`keep-files' + `-k' in `csplit'. + +`kilobytes' + `-k' in `du' and `ls'. + +`language' + `-l' in `etags'. + +`less-mode' + `-l' in `wdiff'. + +`level-for-gzip' + `-g' in `shar'. + +`line-bytes' + `-C' in `split'. + +`lines' + Used in `split', `head', and `tail'. + +`link' + `-l' in `cpio'. + +`lint' +`lint-old' + Used in `gawk'. + +`list' + `-t' in `cpio'; `-l' in `recode'. + +`list' + `-t' in `tar'. + +`literal' + `-N' in `ls'. + +`load-average' + `-l' in Make. + +`login' + Used in `su'. + +`machine' + No listing of which programs already use this; someone should + check to see if any actually do, and tell <gnu@gnu.org>. + +`macro-name' + `-M' in `ptx'. + +`mail' + `-m' in `hello' and `uname'. + +`make-directories' + `-d' in `cpio'. + +`makefile' + `-f' in Make. + +`mapped' + Used in GDB. + +`max-args' + `-n' in `xargs'. + +`max-chars' + `-n' in `xargs'. + +`max-lines' + `-l' in `xargs'. + +`max-load' + `-l' in Make. + +`max-procs' + `-P' in `xargs'. + +`mesg' + `-T' in `who'. + +`message' + `-T' in `who'. + +`minimal' + `-d' in `diff'. + +`mixed-uuencode' + `-M' in `shar'. + +`mode' + `-m' in `install', `mkdir', and `mkfifo'. + +`modification-time' + `-m' in `tar'. + +`multi-volume' + `-M' in `tar'. + +`name-prefix' + `-a' in Bison. + +`nesting-limit' + `-L' in `m4'. + +`net-headers' + `-a' in `shar'. + +`new-file' + `-W' in Make. + +`no-builtin-rules' + `-r' in Make. + +`no-character-count' + `-w' in `shar'. + +`no-check-existing' + `-x' in `shar'. + +`no-common' + `-3' in `wdiff'. + +`no-create' + `-c' in `touch'. + +`no-defines' + `-D' in `etags'. + +`no-deleted' + `-1' in `wdiff'. + +`no-dereference' + `-d' in `cp'. + +`no-inserted' + `-2' in `wdiff'. + +`no-keep-going' + `-S' in Make. + +`no-lines' + `-l' in Bison. + +`no-piping' + `-P' in `shar'. + +`no-prof' + `-e' in `gprof'. + +`no-regex' + `-R' in `etags'. + +`no-sort' + `-p' in `nm'. + +`no-split' + Used in `makeinfo'. + +`no-static' + `-a' in `gprof'. + +`no-time' + `-E' in `gprof'. + +`no-timestamp' + `-m' in `shar'. + +`no-validate' + Used in `makeinfo'. + +`no-wait' + Used in `emacsclient'. + +`no-warn' + Used in various programs to inhibit warnings. + +`node' + `-n' in `info'. + +`nodename' + `-n' in `uname'. + +`nonmatching' + `-f' in `cpio'. + +`nstuff' + `-n' in `objdump'. + +`null' + `-0' in `xargs'. + +`number' + `-n' in `cat'. + +`number-nonblank' + `-b' in `cat'. + +`numeric-sort' + `-n' in `nm'. + +`numeric-uid-gid' + `-n' in `cpio' and `ls'. + +`nx' + Used in GDB. + +`old-archive' + `-o' in `tar'. + +`old-file' + `-o' in Make. + +`one-file-system' + `-l' in `tar', `cp', and `du'. + +`only-file' + `-o' in `ptx'. + +`only-prof' + `-f' in `gprof'. + +`only-time' + `-F' in `gprof'. + +`output' + In various programs, specify the output file name. + +`output-prefix' + `-o' in `shar'. + +`override' + `-o' in `rm'. + +`overwrite' + `-c' in `unshar'. + +`owner' + `-o' in `install'. + +`paginate' + `-l' in `diff'. + +`paragraph-indent' + Used in `makeinfo'. + +`parents' + `-p' in `mkdir' and `rmdir'. + +`pass-all' + `-p' in `ul'. + +`pass-through' + `-p' in `cpio'. + +`port' + `-P' in `finger'. + +`portability' + `-c' in `cpio' and `tar'. + +`posix' + Used in `gawk'. + +`prefix-builtins' + `-P' in `m4'. + +`prefix' + `-f' in `csplit'. + +`preserve' + Used in `tar' and `cp'. + +`preserve-environment' + `-p' in `su'. + +`preserve-modification-time' + `-m' in `cpio'. + +`preserve-order' + `-s' in `tar'. + +`preserve-permissions' + `-p' in `tar'. + +`print' + `-l' in `diff'. + +`print-chars' + `-L' in `cmp'. + +`print-data-base' + `-p' in Make. + +`print-directory' + `-w' in Make. + +`print-file-name' + `-o' in `nm'. + +`print-symdefs' + `-s' in `nm'. + +`printer' + `-p' in `wdiff'. + +`prompt' + `-p' in `ed'. + +`query-user' + `-X' in `shar'. + +`question' + `-q' in Make. + +`quiet' + Used in many programs to inhibit the usual output. *Note:* every + program accepting `--quiet' should accept `--silent' as a synonym. + +`quiet-unshar' + `-Q' in `shar' + +`quote-name' + `-Q' in `ls'. + +`rcs' + `-n' in `diff'. + +`re-interval' + Used in `gawk'. + +`read-full-blocks' + `-B' in `tar'. + +`readnow' + Used in GDB. + +`recon' + `-n' in Make. + +`record-number' + `-R' in `tar'. + +`recursive' + Used in `chgrp', `chown', `cp', `ls', `diff', and `rm'. + +`reference-limit' + Used in `makeinfo'. + +`references' + `-r' in `ptx'. + +`regex' + `-r' in `tac' and `etags'. + +`release' + `-r' in `uname'. + +`reload-state' + `-R' in `m4'. + +`relocation' + `-r' in `objdump'. + +`rename' + `-r' in `cpio'. + +`replace' + `-i' in `xargs'. + +`report-identical-files' + `-s' in `diff'. + +`reset-access-time' + `-a' in `cpio'. + +`reverse' + `-r' in `ls' and `nm'. + +`reversed-ed' + `-f' in `diff'. + +`right-side-defs' + `-R' in `ptx'. + +`same-order' + `-s' in `tar'. + +`same-permissions' + `-p' in `tar'. + +`save' + `-g' in `stty'. + +`se' + Used in GDB. + +`sentence-regexp' + `-S' in `ptx'. + +`separate-dirs' + `-S' in `du'. + +`separator' + `-s' in `tac'. + +`sequence' + Used by `recode' to chose files or pipes for sequencing passes. + +`shell' + `-s' in `su'. + +`show-all' + `-A' in `cat'. + +`show-c-function' + `-p' in `diff'. + +`show-ends' + `-E' in `cat'. + +`show-function-line' + `-F' in `diff'. + +`show-tabs' + `-T' in `cat'. + +`silent' + Used in many programs to inhibit the usual output. *Note:* every + program accepting `--silent' should accept `--quiet' as a synonym. + +`size' + `-s' in `ls'. + +`sort' + Used in `ls'. + +`source' + `-W source' in `gawk'. + +`sparse' + `-S' in `tar'. + +`speed-large-files' + `-H' in `diff'. + +`split-at' + `-E' in `unshar'. + +`split-size-limit' + `-L' in `shar'. + +`squeeze-blank' + `-s' in `cat'. + +`start-delete' + `-w' in `wdiff'. + +`start-insert' + `-y' in `wdiff'. + +`starting-file' + Used in `tar' and `diff' to specify which file within a directory + to start processing with. + +`statistics' + `-s' in `wdiff'. + +`stdin-file-list' + `-S' in `shar'. + +`stop' + `-S' in Make. + +`strict' + `-s' in `recode'. + +`strip' + `-s' in `install'. + +`strip-all' + `-s' in `strip'. + +`strip-debug' + `-S' in `strip'. + +`submitter' + `-s' in `shar'. + +`suffix' + `-S' in `cp', `ln', `mv'. + +`suffix-format' + `-b' in `csplit'. + +`sum' + `-s' in `gprof'. + +`summarize' + `-s' in `du'. + +`symbolic' + `-s' in `ln'. + +`symbols' + Used in GDB and `objdump'. + +`synclines' + `-s' in `m4'. + +`sysname' + `-s' in `uname'. + +`tabs' + `-t' in `expand' and `unexpand'. + +`tabsize' + `-T' in `ls'. + +`terminal' + `-T' in `tput' and `ul'. `-t' in `wdiff'. + +`text' + `-a' in `diff'. + +`text-files' + `-T' in `shar'. + +`time' + Used in `ls' and `touch'. + +`to-stdout' + `-O' in `tar'. + +`total' + `-c' in `du'. + +`touch' + `-t' in Make, `ranlib', and `recode'. + +`trace' + `-t' in `m4'. + +`traditional' + `-t' in `hello'; `-W traditional' in `gawk'; `-G' in `ed', `m4', + and `ptx'. + +`tty' + Used in GDB. + +`typedefs' + `-t' in `ctags'. + +`typedefs-and-c++' + `-T' in `ctags'. + +`typeset-mode' + `-t' in `ptx'. + +`uncompress' + `-z' in `tar'. + +`unconditional' + `-u' in `cpio'. + +`undefine' + `-U' in `m4'. + +`undefined-only' + `-u' in `nm'. + +`update' + `-u' in `cp', `ctags', `mv', `tar'. + +`usage' + Used in `gawk'; same as `--help'. + +`uuencode' + `-B' in `shar'. + +`vanilla-operation' + `-V' in `shar'. + +`verbose' + Print more information about progress. Many programs support this. + +`verify' + `-W' in `tar'. + +`version' + Print the version number. + +`version-control' + `-V' in `cp', `ln', `mv'. + +`vgrind' + `-v' in `ctags'. + +`volume' + `-V' in `tar'. + +`what-if' + `-W' in Make. + +`whole-size-limit' + `-l' in `shar'. + +`width' + `-w' in `ls' and `ptx'. + +`word-regexp' + `-W' in `ptx'. + +`writable' + `-T' in `who'. + +`zeros' + `-z' in `gprof'. + + +File: standards.info, Node: Memory Usage, Prev: Option Table, Up: Program Behavior + +Memory Usage +============ + + If it typically uses just a few meg of memory, don't bother making +any effort to reduce memory usage. For example, if it is impractical +for other reasons to operate on files more than a few meg long, it is +reasonable to read entire input files into core to operate on them. + + However, for programs such as `cat' or `tail', that can usefully +operate on very large files, it is important to avoid using a technique +that would artificially limit the size of files it can handle. If a +program works by lines and could be applied to arbitrary user-supplied +input files, it should keep only a line in memory, because this is not +very hard and users will want to be able to operate on input files that +are bigger than will fit in core all at once. + + If your program creates complicated data structures, just make them +in core and give a fatal error if `malloc' returns zero. + + +File: standards.info, Node: Writing C, Next: Documentation, Prev: Program Behavior, Up: Top + +Making The Best Use of C +************************ + + This node provides advice on how best to use the C language when +writing GNU software. + +* Menu: + +* Formatting:: Formatting Your Source Code +* Comments:: Commenting Your Work +* Syntactic Conventions:: Clean Use of C Constructs +* Names:: Naming Variables and Functions +* System Portability:: Portability between different operating systems +* CPU Portability:: Supporting the range of CPU types +* System Functions:: Portability and ``standard'' library functions +* Internationalization:: Techniques for internationalization +* Mmap:: How you can safely use `mmap'. + + +File: standards.info, Node: Formatting, Next: Comments, Up: Writing C + +Formatting Your Source Code +=========================== + + It is important to put the open-brace that starts the body of a C +function in column zero, and avoid putting any other open-brace or +open-parenthesis or open-bracket in column zero. Several tools look +for open-braces in column zero to find the beginnings of C functions. +These tools will not work on code not formatted that way. + + It is also important for function definitions to start the name of +the function in column zero. This helps people to search for function +definitions, and may also help certain tools recognize them. Thus, the +proper format is this: + + static char * + concat (s1, s2) /* Name starts in column zero here */ + char *s1, *s2; + { /* Open brace in column zero here */ + ... + } + +or, if you want to use ANSI C, format the definition like this: + + static char * + concat (char *s1, char *s2) + { + ... + } + + In ANSI C, if the arguments don't fit nicely on one line, split it +like this: + + int + lots_of_args (int an_integer, long a_long, short a_short, + double a_double, float a_float) + ... + + For the body of the function, we prefer code formatted like this: + + if (x < foo (y, z)) + haha = bar[4] + 5; + else + { + while (z) + { + haha += foo (z, z); + z--; + } + return ++x + bar (); + } + + We find it easier to read a program when it has spaces before the +open-parentheses and after the commas. Especially after the commas. + + When you split an expression into multiple lines, split it before an +operator, not after one. Here is the right way: + + if (foo_this_is_long && bar > win (x, y, z) + && remaining_condition) + + Try to avoid having two operators of different precedence at the same +level of indentation. For example, don't write this: + + mode = (inmode[j] == VOIDmode + || GET_MODE_SIZE (outmode[j]) > GET_MODE_SIZE (inmode[j]) + ? outmode[j] : inmode[j]); + + Instead, use extra parentheses so that the indentation shows the +nesting: + + mode = ((inmode[j] == VOIDmode + || (GET_MODE_SIZE (outmode[j]) > GET_MODE_SIZE (inmode[j]))) + ? outmode[j] : inmode[j]); + + Insert extra parentheses so that Emacs will indent the code properly. +For example, the following indentation looks nice if you do it by hand, +but Emacs would mess it up: + + v = rup->ru_utime.tv_sec*1000 + rup->ru_utime.tv_usec/1000 + + rup->ru_stime.tv_sec*1000 + rup->ru_stime.tv_usec/1000; + + But adding a set of parentheses solves the problem: + + v = (rup->ru_utime.tv_sec*1000 + rup->ru_utime.tv_usec/1000 + + rup->ru_stime.tv_sec*1000 + rup->ru_stime.tv_usec/1000); + + Format do-while statements like this: + + do + { + a = foo (a); + } + while (a > 0); + + Please use formfeed characters (control-L) to divide the program into +pages at logical places (but not within a function). It does not matter +just how long the pages are, since they do not have to fit on a printed +page. The formfeeds should appear alone on lines by themselves. + + +File: standards.info, Node: Comments, Next: Syntactic Conventions, Prev: Formatting, Up: Writing C + +Commenting Your Work +==================== + + Every program should start with a comment saying briefly what it is +for. Example: `fmt - filter for simple filling of text'. + + Please write the comments in a GNU program in English, because +English is the one language that nearly all programmers in all +countries can read. If you do not write English well, please write +comments in English as well as you can, then ask other people to help +rewrite them. If you can't write comments in English, please find +someone to work with you and translate your comments into English. + + Please put a comment on each function saying what the function does, +what sorts of arguments it gets, and what the possible values of +arguments mean and are used for. It is not necessary to duplicate in +words the meaning of the C argument declarations, if a C type is being +used in its customary fashion. If there is anything nonstandard about +its use (such as an argument of type `char *' which is really the +address of the second character of a string, not the first), or any +possible values that would not work the way one would expect (such as, +that strings containing newlines are not guaranteed to work), be sure +to say so. + + Also explain the significance of the return value, if there is one. + + Please put two spaces after the end of a sentence in your comments, +so that the Emacs sentence commands will work. Also, please write +complete sentences and capitalize the first word. If a lower-case +identifier comes at the beginning of a sentence, don't capitalize it! +Changing the spelling makes it a different identifier. If you don't +like starting a sentence with a lower case letter, write the sentence +differently (e.g., "The identifier lower-case is ..."). + + The comment on a function is much clearer if you use the argument +names to speak about the argument values. The variable name itself +should be lower case, but write it in upper case when you are speaking +about the value rather than the variable itself. Thus, "the inode +number NODE_NUM" rather than "an inode". + + There is usually no purpose in restating the name of the function in +the comment before it, because the reader can see that for himself. +There might be an exception when the comment is so long that the +function itself would be off the bottom of the screen. + + There should be a comment on each static variable as well, like this: + + /* Nonzero means truncate lines in the display; + zero means continue them. */ + int truncate_lines; + + Every `#endif' should have a comment, except in the case of short +conditionals (just a few lines) that are not nested. The comment should +state the condition of the conditional that is ending, _including its +sense_. `#else' should have a comment describing the condition _and +sense_ of the code that follows. For example: + + #ifdef foo + ... + #else /* not foo */ + ... + #endif /* not foo */ + #ifdef foo + ... + #endif /* foo */ + +but, by contrast, write the comments this way for a `#ifndef': + + #ifndef foo + ... + #else /* foo */ + ... + #endif /* foo */ + #ifndef foo + ... + #endif /* not foo */ + + +File: standards.info, Node: Syntactic Conventions, Next: Names, Prev: Comments, Up: Writing C + +Clean Use of C Constructs +========================= + + Please explicitly declare all arguments to functions. Don't omit +them just because they are `int's. + + Declarations of external functions and functions to appear later in +the source file should all go in one place near the beginning of the +file (somewhere before the first function definition in the file), or +else should go in a header file. Don't put `extern' declarations inside +functions. + + It used to be common practice to use the same local variables (with +names like `tem') over and over for different values within one +function. Instead of doing this, it is better declare a separate local +variable for each distinct purpose, and give it a name which is +meaningful. This not only makes programs easier to understand, it also +facilitates optimization by good compilers. You can also move the +declaration of each local variable into the smallest scope that includes +all its uses. This makes the program even cleaner. + + Don't use local variables or parameters that shadow global +identifiers. + + Don't declare multiple variables in one declaration that spans lines. +Start a new declaration on each line, instead. For example, instead of +this: + + int foo, + bar; + +write either this: + + int foo, bar; + +or this: + + int foo; + int bar; + +(If they are global variables, each should have a comment preceding it +anyway.) + + When you have an `if'-`else' statement nested in another `if' +statement, always put braces around the `if'-`else'. Thus, never write +like this: + + if (foo) + if (bar) + win (); + else + lose (); + +always like this: + + if (foo) + { + if (bar) + win (); + else + lose (); + } + + If you have an `if' statement nested inside of an `else' statement, +either write `else if' on one line, like this, + + if (foo) + ... + else if (bar) + ... + +with its `then'-part indented like the preceding `then'-part, or write +the nested `if' within braces like this: + + if (foo) + ... + else + { + if (bar) + ... + } + + Don't declare both a structure tag and variables or typedefs in the +same declaration. Instead, declare the structure tag separately and +then use it to declare the variables or typedefs. + + Try to avoid assignments inside `if'-conditions. For example, don't +write this: + + if ((foo = (char *) malloc (sizeof *foo)) == 0) + fatal ("virtual memory exhausted"); + +instead, write this: + + foo = (char *) malloc (sizeof *foo); + if (foo == 0) + fatal ("virtual memory exhausted"); + + Don't make the program ugly to placate `lint'. Please don't insert +any casts to `void'. Zero without a cast is perfectly fine as a null +pointer constant, except when calling a varargs function. + + +File: standards.info, Node: Names, Next: System Portability, Prev: Syntactic Conventions, Up: Writing C + +Naming Variables and Functions +============================== + + The names of global variables and functions in a program serve as +comments of a sort. So don't choose terse names--instead, look for +names that give useful information about the meaning of the variable or +function. In a GNU program, names should be English, like other +comments. + + Local variable names can be shorter, because they are used only +within one context, where (presumably) comments explain their purpose. + + Please use underscores to separate words in a name, so that the Emacs +word commands can be useful within them. Stick to lower case; reserve +upper case for macros and `enum' constants, and for name-prefixes that +follow a uniform convention. + + For example, you should use names like `ignore_space_change_flag'; +don't use names like `iCantReadThis'. + + Variables that indicate whether command-line options have been +specified should be named after the meaning of the option, not after +the option-letter. A comment should state both the exact meaning of +the option and its letter. For example, + + /* Ignore changes in horizontal whitespace (-b). */ + int ignore_space_change_flag; + + When you want to define names with constant integer values, use +`enum' rather than `#define'. GDB knows about enumeration constants. + + Use file names of 14 characters or less, to avoid creating gratuitous +problems on older System V systems. You can use the program `doschk' +to test for this. `doschk' also tests for potential name conflicts if +the files were loaded onto an MS-DOS file system--something you may or +may not care about. + + +File: standards.info, Node: System Portability, Next: CPU Portability, Prev: Names, Up: Writing C + +Portability between System Types +================================ + + In the Unix world, "portability" refers to porting to different Unix +versions. For a GNU program, this kind of portability is desirable, but +not paramount. + + The primary purpose of GNU software is to run on top of the GNU +kernel, compiled with the GNU C compiler, on various types of CPU. The +amount and kinds of variation among GNU systems on different CPUs will +be comparable to the variation among Linux-based GNU systems or among +BSD systems today. So the kinds of portability that are absolutely +necessary are quite limited. + + But many users do run GNU software on non-GNU Unix or Unix-like +systems. So supporting a variety of Unix-like systems is desirable, +although not paramount. + + The easiest way to achieve portability to most Unix-like systems is +to use Autoconf. It's unlikely that your program needs to know more +information about the host platform than Autoconf can provide, simply +because most of the programs that need such knowledge have already been +written. + + Avoid using the format of semi-internal data bases (e.g., +directories) when there is a higher-level alternative (`readdir'). + + As for systems that are not like Unix, such as MSDOS, Windows, the +Macintosh, VMS, and MVS, supporting them is usually so much work that it +is better if you don't. + + The planned GNU kernel is not finished yet, but you can tell which +facilities it will provide by looking at the GNU C Library Manual. The +GNU kernel is based on Mach, so the features of Mach will also be +available. However, if you use Mach features, you'll probably have +trouble debugging your program today. + + +File: standards.info, Node: CPU Portability, Next: System Functions, Prev: System Portability, Up: Writing C + +Portability between CPUs +======================== + + Even GNU systems will differ because of differences among CPU +types--for example, difference in byte ordering and alignment +requirements. It is absolutely essential to handle these differences. +However, don't make any effort to cater to the possibility that an +`int' will be less than 32 bits. We don't support 16-bit machines in +GNU. + + Don't assume that the address of an `int' object is also the address +of its least-significant byte. This is false on big-endian machines. +Thus, don't make the following mistake: + + int c; + ... + while ((c = getchar()) != EOF) + write(file_descriptor, &c, 1); + + When calling functions, you need not worry about the difference +between pointers of various types, or between pointers and integers. +On most machines, there's no difference anyway. As for the few +machines where there is a difference, all of them support ANSI C, so +you can use prototypes (conditionalized to be active only in ANSI C) to +make the code work on those systems. + + In certain cases, it is ok to pass integer and pointer arguments +indiscriminately to the same function, and use no prototype on any +system. For example, many GNU programs have error-reporting functions +that pass their arguments along to `printf' and friends: + + error (s, a1, a2, a3) + char *s; + int a1, a2, a3; + { + fprintf (stderr, "error: "); + fprintf (stderr, s, a1, a2, a3); + } + +In practice, this works on all machines, and it is much simpler than any +"correct" alternative. Be sure _not_ to use a prototype for such +functions. + + However, avoid casting pointers to integers unless you really need +to. These assumptions really reduce portability, and in most programs +they are easy to avoid. In the cases where casting pointers to +integers is essential--such as, a Lisp interpreter which stores type +information as well as an address in one word--it is ok to do so, but +you'll have to make explicit provisions to handle different word sizes. + + +File: standards.info, Node: System Functions, Next: Internationalization, Prev: CPU Portability, Up: Writing C + +Calling System Functions +======================== + + C implementations differ substantially. ANSI C reduces but does not +eliminate the incompatibilities; meanwhile, many users wish to compile +GNU software with pre-ANSI compilers. This chapter gives +recommendations for how to use the more or less standard C library +functions to avoid unnecessary loss of portability. + + * Don't use the value of `sprintf'. It returns the number of + characters written on some systems, but not on all systems. + + * `main' should be declared to return type `int'. It should + terminate either by calling `exit' or by returning the integer + status code; make sure it cannot ever return an undefined value. + + * Don't declare system functions explicitly. + + Almost any declaration for a system function is wrong on some + system. To minimize conflicts, leave it to the system header + files to declare system functions. If the headers don't declare a + function, let it remain undeclared. + + While it may seem unclean to use a function without declaring it, + in practice this works fine for most system library functions on + the systems where this really happens; thus, the disadvantage is + only theoretical. By contrast, actual declarations have + frequently caused actual conflicts. + + * If you must declare a system function, don't specify the argument + types. Use an old-style declaration, not an ANSI prototype. The + more you specify about the function, the more likely a conflict. + + * In particular, don't unconditionally declare `malloc' or `realloc'. + + Most GNU programs use those functions just once, in functions + conventionally named `xmalloc' and `xrealloc'. These functions + call `malloc' and `realloc', respectively, and check the results. + + Because `xmalloc' and `xrealloc' are defined in your program, you + can declare them in other files without any risk of type conflict. + + On most systems, `int' is the same length as a pointer; thus, the + calls to `malloc' and `realloc' work fine. For the few + exceptional systems (mostly 64-bit machines), you can use + *conditionalized* declarations of `malloc' and `realloc'--or put + these declarations in configuration files specific to those + systems. + + * The string functions require special treatment. Some Unix systems + have a header file `string.h'; others have `strings.h'. Neither + file name is portable. There are two things you can do: use + Autoconf to figure out which file to include, or don't include + either file. + + * If you don't include either strings file, you can't get + declarations for the string functions from the header file in the + usual way. + + That causes less of a problem than you might think. The newer ANSI + string functions should be avoided anyway because many systems + still don't support them. The string functions you can use are + these: + + strcpy strncpy strcat strncat + strlen strcmp strncmp + strchr strrchr + + The copy and concatenate functions work fine without a declaration + as long as you don't use their values. Using their values without + a declaration fails on systems where the width of a pointer + differs from the width of `int', and perhaps in other cases. It + is trivial to avoid using their values, so do that. + + The compare functions and `strlen' work fine without a declaration + on most systems, possibly all the ones that GNU software runs on. + You may find it necessary to declare them *conditionally* on a few + systems. + + The search functions must be declared to return `char *'. Luckily, + there is no variation in the data type they return. But there is + variation in their names. Some systems give these functions the + names `index' and `rindex'; other systems use the names `strchr' + and `strrchr'. Some systems support both pairs of names, but + neither pair works on all systems. + + You should pick a single pair of names and use it throughout your + program. (Nowadays, it is better to choose `strchr' and `strrchr' + for new programs, since those are the standard ANSI names.) + Declare both of those names as functions returning `char *'. On + systems which don't support those names, define them as macros in + terms of the other pair. For example, here is what to put at the + beginning of your file (or in a header) if you want to use the + names `strchr' and `strrchr' throughout: + + #ifndef HAVE_STRCHR + #define strchr index + #endif + #ifndef HAVE_STRRCHR + #define strrchr rindex + #endif + + char *strchr (); + char *strrchr (); + + Here we assume that `HAVE_STRCHR' and `HAVE_STRRCHR' are macros +defined in systems where the corresponding functions exist. One way to +get them properly defined is to use Autoconf. + + +File: standards.info, Node: Internationalization, Next: Mmap, Prev: System Functions, Up: Writing C + +Internationalization +==================== + + GNU has a library called GNU gettext that makes it easy to translate +the messages in a program into various languages. You should use this +library in every program. Use English for the messages as they appear +in the program, and let gettext provide the way to translate them into +other languages. + + Using GNU gettext involves putting a call to the `gettext' macro +around each string that might need translation--like this: + + printf (gettext ("Processing file `%s'...")); + +This permits GNU gettext to replace the string `"Processing file +`%s'..."' with a translated version. + + Once a program uses gettext, please make a point of writing calls to +`gettext' when you add new strings that call for translation. + + Using GNU gettext in a package involves specifying a "text domain +name" for the package. The text domain name is used to separate the +translations for this package from the translations for other packages. +Normally, the text domain name should be the same as the name of the +package--for example, `fileutils' for the GNU file utilities. + + To enable gettext to work well, avoid writing code that makes +assumptions about the structure of words or sentences. When you want +the precise text of a sentence to vary depending on the data, use two or +more alternative string constants each containing a complete sentences, +rather than inserting conditionalized words or phrases into a single +sentence framework. + + Here is an example of what not to do: + + printf ("%d file%s processed", nfiles, + nfiles != 1 ? "s" : ""); + +The problem with that example is that it assumes that plurals are made +by adding `s'. If you apply gettext to the format string, like this, + + printf (gettext ("%d file%s processed"), nfiles, + nfiles != 1 ? "s" : ""); + +the message can use different words, but it will still be forced to use +`s' for the plural. Here is a better way: + + printf ((nfiles != 1 ? "%d files processed" + : "%d file processed"), + nfiles); + +This way, you can apply gettext to each of the two strings +independently: + + printf ((nfiles != 1 ? gettext ("%d files processed") + : gettext ("%d file processed")), + nfiles); + +This can be any method of forming the plural of the word for "file", and +also handles languages that require agreement in the word for +"processed". + + A similar problem appears at the level of sentence structure with +this code: + + printf ("# Implicit rule search has%s been done.\n", + f->tried_implicit ? "" : " not"); + +Adding `gettext' calls to this code cannot give correct results for all +languages, because negation in some languages requires adding words at +more than one place in the sentence. By contrast, adding `gettext' +calls does the job straightfowardly if the code starts out like this: + + printf (f->tried_implicit + ? "# Implicit rule search has been done.\n", + : "# Implicit rule search has not been done.\n"); + + +File: standards.info, Node: Mmap, Prev: Internationalization, Up: Writing C + +Mmap +==== + + Don't assume that `mmap' either works on all files or fails for all +files. It may work on some files and fail on others. + + The proper way to use `mmap' is to try it on the specific file for +which you want to use it--and if `mmap' doesn't work, fall back on +doing the job in another way using `read' and `write'. + + The reason this precaution is needed is that the GNU kernel (the +HURD) provides a user-extensible file system, in which there can be many +different kinds of "ordinary files." Many of them support `mmap', but +some do not. It is important to make programs handle all these kinds +of files. + + +File: standards.info, Node: Documentation, Next: Managing Releases, Prev: Writing C, Up: Top + +Documenting Programs +******************** + +* Menu: + +* GNU Manuals:: Writing proper manuals. +* Manual Structure Details:: Specific structure conventions. +* NEWS File:: NEWS files supplement manuals. +* Change Logs:: Recording Changes +* Man Pages:: Man pages are secondary. +* Reading other Manuals:: How far you can go in learning + from other manuals. + + +File: standards.info, Node: GNU Manuals, Next: Manual Structure Details, Up: Documentation + +GNU Manuals +=========== + + The preferred way to document part of the GNU system is to write a +manual in the Texinfo formatting language. See the Texinfo manual, +either the hardcopy, or the on-line version available through `info' or +the Emacs Info subsystem (`C-h i'). + + Programmers often find it most natural to structure the documentation +following the structure of the implementation, which they know. But +this structure is not necessarily good for explaining how to use the +program; it may be irrelevant and confusing for a user. + + At every level, from the sentences in a paragraph to the grouping of +topics into separate manuals, the right way to structure documentation +is according to the concepts and questions that a user will have in mind +when reading it. Sometimes this structure of ideas matches the +structure of the implementation of the software being documented--but +often they are different. Often the most important part of learning to +write good documentation is learning to notice when you are structuring +the documentation like the implementation, and think about better +alternatives. + + For example, each program in the GNU system probably ought to be +documented in one manual; but this does not mean each program should +have its own manual. That would be following the structure of the +implementation, rather than the structure that helps the user +understand. + + Instead, each manual should cover a coherent _topic_. For example, +instead of a manual for `diff' and a manual for `diff3', we have one +manual for "comparison of files" which covers both of those programs, +as well as `cmp'. By documenting these programs together, we can make +the whole subject clearer. + + The manual which discusses a program should document all of the +program's command-line options and all of its commands. It should give +examples of their use. But don't organize the manual as a list of +features. Instead, organize it logically, by subtopics. Address the +questions that a user will ask when thinking about the job that the +program does. + + In general, a GNU manual should serve both as tutorial and reference. +It should be set up for convenient access to each topic through Info, +and for reading straight through (appendixes aside). A GNU manual +should give a good introduction to a beginner reading through from the +start, and should also provide all the details that hackers want. + + That is not as hard as it first sounds. Arrange each chapter as a +logical breakdown of its topic, but order the sections, and write their +text, so that reading the chapter straight through makes sense. Do +likewise when structuring the book into chapters, and when structuring a +section into paragraphs. The watchword is, _at each point, address the +most fundamental and important issue raised by the preceding text._ + + If necessary, add extra chapters at the beginning of the manual which +are purely tutorial and cover the basics of the subject. These provide +the framework for a beginner to understand the rest of the manual. The +Bison manual provides a good example of how to do this. + + Don't use Unix man pages as a model for how to write GNU +documentation; most of them are terse, badly structured, and give +inadequate explanation of the underlying concepts. (There are, of +course exceptions.) Also Unix man pages use a particular format which +is different from what we use in GNU manuals. + + Please do not use the term "pathname" that is used in Unix +documentation; use "file name" (two words) instead. We use the term +"path" only for search paths, which are lists of file names. + + Please do not use the term "illegal" to refer to erroneous input to a +computer program. Please use "invalid" for this, and reserve the term +"illegal" for violations of law. + + +File: standards.info, Node: Manual Structure Details, Next: NEWS File, Prev: GNU Manuals, Up: Documentation + +Manual Structure Details +======================== + + The title page of the manual should state the version of the +programs or packages documented in the manual. The Top node of the +manual should also contain this information. If the manual is changing +more frequently than or independent of the program, also state a version +number for the manual in both of these places. + + Each program documented in the manual should should have a node named +`PROGRAM Invocation' or `Invoking PROGRAM'. This node (together with +its subnodes, if any) should describe the program's command line +arguments and how to run it (the sort of information people would look +in a man page for). Start with an `@example' containing a template for +all the options and arguments that the program uses. + + Alternatively, put a menu item in some menu whose item name fits one +of the above patterns. This identifies the node which that item points +to as the node for this purpose, regardless of the node's actual name. + + There will be automatic features for specifying a program name and +quickly reading just this part of its manual. + + If one manual describes several programs, it should have such a node +for each program described. + + +File: standards.info, Node: NEWS File, Next: Change Logs, Prev: Manual Structure Details, Up: Documentation + +The NEWS File +============= + + In addition to its manual, the package should have a file named +`NEWS' which contains a list of user-visible changes worth mentioning. +In each new release, add items to the front of the file and identify +the version they pertain to. Don't discard old items; leave them in +the file after the newer items. This way, a user upgrading from any +previous version can see what is new. + + If the `NEWS' file gets very long, move some of the older items into +a file named `ONEWS' and put a note at the end referring the user to +that file. + + +File: standards.info, Node: Change Logs, Next: Man Pages, Prev: NEWS File, Up: Documentation + +Change Logs +=========== + + Keep a change log to describe all the changes made to program source +files. The purpose of this is so that people investigating bugs in the +future will know about the changes that might have introduced the bug. +Often a new bug can be found by looking at what was recently changed. +More importantly, change logs can help you eliminate conceptual +inconsistencies between different parts of a program, by giving you a +history of how the conflicting concepts arose and who they came from. + +* Menu: + +* Change Log Concepts:: +* Style of Change Logs:: +* Simple Changes:: +* Conditional Changes:: + + +File: standards.info, Node: Change Log Concepts, Next: Style of Change Logs, Up: Change Logs + +Change Log Concepts +------------------- + + You can think of the change log as a conceptual "undo list" which +explains how earlier versions were different from the current version. +People can see the current version; they don't need the change log to +tell them what is in it. What they want from a change log is a clear +explanation of how the earlier version differed. + + The change log file is normally called `ChangeLog' and covers an +entire directory. Each directory can have its own change log, or a +directory can use the change log of its parent directory-it's up to you. + + Another alternative is to record change log information with a +version control system such as RCS or CVS. This can be converted +automatically to a `ChangeLog' file. + + There's no need to describe the full purpose of the changes or how +they work together. If you think that a change calls for explanation, +you're probably right. Please do explain it--but please put the +explanation in comments in the code, where people will see it whenever +they see the code. For example, "New function" is enough for the +change log when you add a function, because there should be a comment +before the function definition to explain what it does. + + However, sometimes it is useful to write one line to describe the +overall purpose of a batch of changes. + + The easiest way to add an entry to `ChangeLog' is with the Emacs +command `M-x add-change-log-entry'. An entry should have an asterisk, +the name of the changed file, and then in parentheses the name of the +changed functions, variables or whatever, followed by a colon. Then +describe the changes you made to that function or variable. + + +File: standards.info, Node: Style of Change Logs, Next: Simple Changes, Prev: Change Log Concepts, Up: Change Logs + +Style of Change Logs +-------------------- + + Here are some examples of change log entries: + + * register.el (insert-register): Return nil. + (jump-to-register): Likewise. + + * sort.el (sort-subr): Return nil. + + * tex-mode.el (tex-bibtex-file, tex-file, tex-region): + Restart the tex shell if process is gone or stopped. + (tex-shell-running): New function. + + * expr.c (store_one_arg): Round size up for move_block_to_reg. + (expand_call): Round up when emitting USE insns. + * stmt.c (assign_parms): Round size up for move_block_from_reg. + + It's important to name the changed function or variable in full. +Don't abbreviate function or variable names, and don't combine them. +Subsequent maintainers will often search for a function name to find all +the change log entries that pertain to it; if you abbreviate the name, +they won't find it when they search. + + For example, some people are tempted to abbreviate groups of function +names by writing `* register.el ({insert,jump-to}-register)'; this is +not a good idea, since searching for `jump-to-register' or +`insert-register' would not find that entry. + + Separate unrelated change log entries with blank lines. When two +entries represent parts of the same change, so that they work together, +then don't put blank lines between them. Then you can omit the file +name and the asterisk when successive entries are in the same file. + + +File: standards.info, Node: Simple Changes, Next: Conditional Changes, Prev: Style of Change Logs, Up: Change Logs + +Simple Changes +-------------- + + Certain simple kinds of changes don't need much detail in the change +log. + + When you change the calling sequence of a function in a simple +fashion, and you change all the callers of the function, there is no +need to make individual entries for all the callers that you changed. +Just write in the entry for the function being called, "All callers +changed." + + * keyboard.c (Fcommand_execute): New arg SPECIAL. + All callers changed. + + When you change just comments or doc strings, it is enough to write +an entry for the file, without mentioning the functions. Just "Doc +fixes" is enough for the change log. + + There's no need to make change log entries for documentation files. +This is because documentation is not susceptible to bugs that are hard +to fix. Documentation does not consist of parts that must interact in a +precisely engineered fashion. To correct an error, you need not know +the history of the erroneous passage; it is enough to compare what the +documentation says with the way the program actually works. + + +File: standards.info, Node: Conditional Changes, Prev: Simple Changes, Up: Change Logs + +Conditional Changes +------------------- + + C programs often contain compile-time `#if' conditionals. Many +changes are conditional; sometimes you add a new definition which is +entirely contained in a conditional. It is very useful to indicate in +the change log the conditions for which the change applies. + + Our convention for indicating conditional changes is to use square +brackets around the name of the condition. + + Here is a simple example, describing a change which is conditional +but does not have a function or entity name associated with it: + + * xterm.c [SOLARIS2]: Include string.h. + + Here is an entry describing a new definition which is entirely +conditional. This new definition for the macro `FRAME_WINDOW_P' is +used only when `HAVE_X_WINDOWS' is defined: + + * frame.h [HAVE_X_WINDOWS] (FRAME_WINDOW_P): Macro defined. + + Here is an entry for a change within the function `init_display', +whose definition as a whole is unconditional, but the changes themselves +are contained in a `#ifdef HAVE_LIBNCURSES' conditional: + + * dispnew.c (init_display) [HAVE_LIBNCURSES]: If X, call tgetent. + + Here is an entry for a change that takes affect only when a certain +macro is _not_ defined: + + (gethostname) [!HAVE_SOCKETS]: Replace with winsock version. + + +File: standards.info, Node: Man Pages, Next: Reading other Manuals, Prev: Change Logs, Up: Documentation + +Man Pages +========= + + In the GNU project, man pages are secondary. It is not necessary or +expected for every GNU program to have a man page, but some of them do. +It's your choice whether to include a man page in your program. + + When you make this decision, consider that supporting a man page +requires continual effort each time the program is changed. The time +you spend on the man page is time taken away from more useful work. + + For a simple program which changes little, updating the man page may +be a small job. Then there is little reason not to include a man page, +if you have one. + + For a large program that changes a great deal, updating a man page +may be a substantial burden. If a user offers to donate a man page, +you may find this gift costly to accept. It may be better to refuse +the man page unless the same person agrees to take full responsibility +for maintaining it--so that you can wash your hands of it entirely. If +this volunteer later ceases to do the job, then don't feel obliged to +pick it up yourself; it may be better to withdraw the man page from the +distribution until someone else agrees to update it. + + When a program changes only a little, you may feel that the +discrepancies are small enough that the man page remains useful without +updating. If so, put a prominent note near the beginning of the man +page explaining that you don't maintain it and that the Texinfo manual +is more authoritative. The note should say how to access the Texinfo +documentation. + + +File: standards.info, Node: Reading other Manuals, Prev: Man Pages, Up: Documentation + +Reading other Manuals +===================== + + There may be non-free books or documentation files that describe the +program you are documenting. + + It is ok to use these documents for reference, just as the author of +a new algebra textbook can read other books on algebra. A large portion +of any non-fiction book consists of facts, in this case facts about how +a certain program works, and these facts are necessarily the same for +everyone who writes about the subject. But be careful not to copy your +outline structure, wording, tables or examples from preexisting non-free +documentation. Copying from free documentation may be ok; please check +with the FSF about the individual case. + + +File: standards.info, Node: Managing Releases, Prev: Documentation, Up: Top + +The Release Process +******************* + + Making a release is more than just bundling up your source files in a +tar file and putting it up for FTP. You should set up your software so +that it can be configured to run on a variety of systems. Your Makefile +should conform to the GNU standards described below, and your directory +layout should also conform to the standards discussed below. Doing so +makes it easy to include your package into the larger framework of all +GNU software. + +* Menu: + +* Configuration:: How Configuration Should Work +* Makefile Conventions:: Makefile Conventions +* Releases:: Making Releases + + +File: standards.info, Node: Configuration, Next: Makefile Conventions, Up: Managing Releases + +How Configuration Should Work +============================= + + Each GNU distribution should come with a shell script named +`configure'. This script is given arguments which describe the kind of +machine and system you want to compile the program for. + + The `configure' script must record the configuration options so that +they affect compilation. + + One way to do this is to make a link from a standard name such as +`config.h' to the proper configuration file for the chosen system. If +you use this technique, the distribution should _not_ contain a file +named `config.h'. This is so that people won't be able to build the +program without configuring it first. + + Another thing that `configure' can do is to edit the Makefile. If +you do this, the distribution should _not_ contain a file named +`Makefile'. Instead, it should include a file `Makefile.in' which +contains the input used for editing. Once again, this is so that people +won't be able to build the program without configuring it first. + + If `configure' does write the `Makefile', then `Makefile' should +have a target named `Makefile' which causes `configure' to be rerun, +setting up the same configuration that was set up last time. The files +that `configure' reads should be listed as dependencies of `Makefile'. + + All the files which are output from the `configure' script should +have comments at the beginning explaining that they were generated +automatically using `configure'. This is so that users won't think of +trying to edit them by hand. + + The `configure' script should write a file named `config.status' +which describes which configuration options were specified when the +program was last configured. This file should be a shell script which, +if run, will recreate the same configuration. + + The `configure' script should accept an option of the form +`--srcdir=DIRNAME' to specify the directory where sources are found (if +it is not the current directory). This makes it possible to build the +program in a separate directory, so that the actual source directory is +not modified. + + If the user does not specify `--srcdir', then `configure' should +check both `.' and `..' to see if it can find the sources. If it finds +the sources in one of these places, it should use them from there. +Otherwise, it should report that it cannot find the sources, and should +exit with nonzero status. + + Usually the easy way to support `--srcdir' is by editing a +definition of `VPATH' into the Makefile. Some rules may need to refer +explicitly to the specified source directory. To make this possible, +`configure' can add to the Makefile a variable named `srcdir' whose +value is precisely the specified directory. + + The `configure' script should also take an argument which specifies +the type of system to build the program for. This argument should look +like this: + + CPU-COMPANY-SYSTEM + + For example, a Sun 3 might be `m68k-sun-sunos4.1'. + + The `configure' script needs to be able to decode all plausible +alternatives for how to describe a machine. Thus, `sun3-sunos4.1' +would be a valid alias. For many programs, `vax-dec-ultrix' would be +an alias for `vax-dec-bsd', simply because the differences between +Ultrix and BSD are rarely noticeable, but a few programs might need to +distinguish them. + + There is a shell script called `config.sub' that you can use as a +subroutine to validate system types and canonicalize aliases. + + Other options are permitted to specify in more detail the software +or hardware present on the machine, and include or exclude optional +parts of the package: + +`--enable-FEATURE[=PARAMETER]' + Configure the package to build and install an optional user-level + facility called FEATURE. This allows users to choose which + optional features to include. Giving an optional PARAMETER of + `no' should omit FEATURE, if it is built by default. + + No `--enable' option should *ever* cause one feature to replace + another. No `--enable' option should ever substitute one useful + behavior for another useful behavior. The only proper use for + `--enable' is for questions of whether to build part of the program + or exclude it. + +`--with-PACKAGE' + The package PACKAGE will be installed, so configure this package + to work with PACKAGE. + + Possible values of PACKAGE include `gnu-as' (or `gas'), `gnu-ld', + `gnu-libc', `gdb', `x', and `x-toolkit'. + + Do not use a `--with' option to specify the file name to use to + find certain files. That is outside the scope of what `--with' + options are for. + +`--nfp' + The target machine has no floating point processor. + +`--gas' + The target machine assembler is GAS, the GNU assembler. This is + obsolete; users should use `--with-gnu-as' instead. + +`--x' + The target machine has the X Window System installed. This is + obsolete; users should use `--with-x' instead. + + All `configure' scripts should accept all of these "detail" options, +whether or not they make any difference to the particular package at +hand. In particular, they should accept any option that starts with +`--with-' or `--enable-'. This is so users will be able to configure +an entire GNU source tree at once with a single set of options. + + You will note that the categories `--with-' and `--enable-' are +narrow: they *do not* provide a place for any sort of option you might +think of. That is deliberate. We want to limit the possible +configuration options in GNU software. We do not want GNU programs to +have idiosyncratic configuration options. + + Packages that perform part of the compilation process may support +cross-compilation. In such a case, the host and target machines for +the program may be different. The `configure' script should normally +treat the specified type of system as both the host and the target, +thus producing a program which works for the same type of machine that +it runs on. + + The way to build a cross-compiler, cross-assembler, or what have +you, is to specify the option `--host=HOSTTYPE' when running +`configure'. This specifies the host system without changing the type +of target system. The syntax for HOSTTYPE is the same as described +above. + + Bootstrapping a cross-compiler requires compiling it on a machine +other than the host it will run on. Compilation packages accept a +configuration option `--build=HOSTTYPE' for specifying the +configuration on which you will compile them, in case that is different +from the host. + + Programs for which cross-operation is not meaningful need not accept +the `--host' option, because configuring an entire operating system for +cross-operation is not a meaningful thing. + + Some programs have ways of configuring themselves automatically. If +your program is set up to do this, your `configure' script can simply +ignore most of its arguments. + + +File: standards.info, Node: Makefile Conventions, Next: Releases, Prev: Configuration, Up: Managing Releases + +Makefile Conventions +==================== + + This node describes conventions for writing the Makefiles for GNU +programs. + +* Menu: + +* Makefile Basics:: General Conventions for Makefiles +* Utilities in Makefiles:: Utilities in Makefiles +* Command Variables:: Variables for Specifying Commands +* Directory Variables:: Variables for Installation Directories +* Standard Targets:: Standard Targets for Users +* Install Command Categories:: Three categories of commands in the `install' + rule: normal, pre-install and post-install. + + +File: standards.info, Node: Makefile Basics, Next: Utilities in Makefiles, Up: Makefile Conventions + +General Conventions for Makefiles +--------------------------------- + + Every Makefile should contain this line: + + SHELL = /bin/sh + +to avoid trouble on systems where the `SHELL' variable might be +inherited from the environment. (This is never a problem with GNU +`make'.) + + Different `make' programs have incompatible suffix lists and +implicit rules, and this sometimes creates confusion or misbehavior. So +it is a good idea to set the suffix list explicitly using only the +suffixes you need in the particular Makefile, like this: + + .SUFFIXES: + .SUFFIXES: .c .o + +The first line clears out the suffix list, the second introduces all +suffixes which may be subject to implicit rules in this Makefile. + + Don't assume that `.' is in the path for command execution. When +you need to run programs that are a part of your package during the +make, please make sure that it uses `./' if the program is built as +part of the make or `$(srcdir)/' if the file is an unchanging part of +the source code. Without one of these prefixes, the current search +path is used. + + The distinction between `./' (the "build directory") and +`$(srcdir)/' (the "source directory") is important because users can +build in a separate directory using the `--srcdir' option to +`configure'. A rule of the form: + + foo.1 : foo.man sedscript + sed -e sedscript foo.man > foo.1 + +will fail when the build directory is not the source directory, because +`foo.man' and `sedscript' are in the the source directory. + + When using GNU `make', relying on `VPATH' to find the source file +will work in the case where there is a single dependency file, since +the `make' automatic variable `$<' will represent the source file +wherever it is. (Many versions of `make' set `$<' only in implicit +rules.) A Makefile target like + + foo.o : bar.c + $(CC) -I. -I$(srcdir) $(CFLAGS) -c bar.c -o foo.o + +should instead be written as + + foo.o : bar.c + $(CC) -I. -I$(srcdir) $(CFLAGS) -c $< -o $@ + +in order to allow `VPATH' to work correctly. When the target has +multiple dependencies, using an explicit `$(srcdir)' is the easiest way +to make the rule work well. For example, the target above for `foo.1' +is best written as: + + foo.1 : foo.man sedscript + sed -e $(srcdir)/sedscript $(srcdir)/foo.man > $@ + + GNU distributions usually contain some files which are not source +files--for example, Info files, and the output from Autoconf, Automake, +Bison or Flex. Since these files normally appear in the source +directory, they should always appear in the source directory, not in the +build directory. So Makefile rules to update them should put the +updated files in the source directory. + + However, if a file does not appear in the distribution, then the +Makefile should not put it in the source directory, because building a +program in ordinary circumstances should not modify the source directory +in any way. + + Try to make the build and installation targets, at least (and all +their subtargets) work correctly with a parallel `make'. + + +File: standards.info, Node: Utilities in Makefiles, Next: Command Variables, Prev: Makefile Basics, Up: Makefile Conventions + +Utilities in Makefiles +---------------------- + + Write the Makefile commands (and any shell scripts, such as +`configure') to run in `sh', not in `csh'. Don't use any special +features of `ksh' or `bash'. + + The `configure' script and the Makefile rules for building and +installation should not use any utilities directly except these: + + cat cmp cp diff echo egrep expr false grep install-info + ln ls mkdir mv pwd rm rmdir sed sleep sort tar test touch true + + The compression program `gzip' can be used in the `dist' rule. + + Stick to the generally supported options for these programs. For +example, don't use `mkdir -p', convenient as it may be, because most +systems don't support it. + + It is a good idea to avoid creating symbolic links in makefiles, +since a few systems don't support them. + + The Makefile rules for building and installation can also use +compilers and related programs, but should do so via `make' variables +so that the user can substitute alternatives. Here are some of the +programs we mean: + + ar bison cc flex install ld ldconfig lex + make makeinfo ranlib texi2dvi yacc + + Use the following `make' variables to run those programs: + + $(AR) $(BISON) $(CC) $(FLEX) $(INSTALL) $(LD) $(LDCONFIG) $(LEX) + $(MAKE) $(MAKEINFO) $(RANLIB) $(TEXI2DVI) $(YACC) + + When you use `ranlib' or `ldconfig', you should make sure nothing +bad happens if the system does not have the program in question. +Arrange to ignore an error from that command, and print a message before +the command to tell the user that failure of this command does not mean +a problem. (The Autoconf `AC_PROG_RANLIB' macro can help with this.) + + If you use symbolic links, you should implement a fallback for +systems that don't have symbolic links. + + Additional utilities that can be used via Make variables are: + + chgrp chmod chown mknod + + It is ok to use other utilities in Makefile portions (or scripts) +intended only for particular systems where you know those utilities +exist. + + +File: standards.info, Node: Command Variables, Next: Directory Variables, Prev: Utilities in Makefiles, Up: Makefile Conventions + +Variables for Specifying Commands +--------------------------------- + + Makefiles should provide variables for overriding certain commands, +options, and so on. + + In particular, you should run most utility programs via variables. +Thus, if you use Bison, have a variable named `BISON' whose default +value is set with `BISON = bison', and refer to it with `$(BISON)' +whenever you need to use Bison. + + File management utilities such as `ln', `rm', `mv', and so on, need +not be referred to through variables in this way, since users don't +need to replace them with other programs. + + Each program-name variable should come with an options variable that +is used to supply options to the program. Append `FLAGS' to the +program-name variable name to get the options variable name--for +example, `BISONFLAGS'. (The names `CFLAGS' for the C compiler, +`YFLAGS' for yacc, and `LFLAGS' for lex, are exceptions to this rule, +but we keep them because they are standard.) Use `CPPFLAGS' in any +compilation command that runs the preprocessor, and use `LDFLAGS' in +any compilation command that does linking as well as in any direct use +of `ld'. + + If there are C compiler options that _must_ be used for proper +compilation of certain files, do not include them in `CFLAGS'. Users +expect to be able to specify `CFLAGS' freely themselves. Instead, +arrange to pass the necessary options to the C compiler independently +of `CFLAGS', by writing them explicitly in the compilation commands or +by defining an implicit rule, like this: + + CFLAGS = -g + ALL_CFLAGS = -I. $(CFLAGS) + .c.o: + $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $< + + Do include the `-g' option in `CFLAGS', because that is not +_required_ for proper compilation. You can consider it a default that +is only recommended. If the package is set up so that it is compiled +with GCC by default, then you might as well include `-O' in the default +value of `CFLAGS' as well. + + Put `CFLAGS' last in the compilation command, after other variables +containing compiler options, so the user can use `CFLAGS' to override +the others. + + `CFLAGS' should be used in every invocation of the C compiler, both +those which do compilation and those which do linking. + + Every Makefile should define the variable `INSTALL', which is the +basic command for installing a file into the system. + + Every Makefile should also define the variables `INSTALL_PROGRAM' +and `INSTALL_DATA'. (The default for each of these should be +`$(INSTALL)'.) Then it should use those variables as the commands for +actual installation, for executables and nonexecutables respectively. +Use these variables as follows: + + $(INSTALL_PROGRAM) foo $(bindir)/foo + $(INSTALL_DATA) libfoo.a $(libdir)/libfoo.a + + Optionally, you may prepend the value of `DESTDIR' to the target +filename. Doing this allows the installer to create a snapshot of the +installation to be copied onto the real target filesystem later. Do not +set the value of `DESTDIR' in your Makefile, and do not include it in +any installed files. With support for `DESTDIR', the above examples +become: + + $(INSTALL_PROGRAM) foo $(DESTDIR)$(bindir)/foo + $(INSTALL_DATA) libfoo.a $(DESTDIR)$(libdir)/libfoo.a + +Always use a file name, not a directory name, as the second argument of +the installation commands. Use a separate command for each file to be +installed. + + +File: standards.info, Node: Directory Variables, Next: Standard Targets, Prev: Command Variables, Up: Makefile Conventions + +Variables for Installation Directories +-------------------------------------- + + Installation directories should always be named by variables, so it +is easy to install in a nonstandard place. The standard names for these +variables are described below. They are based on a standard filesystem +layout; variants of it are used in SVR4, 4.4BSD, Linux, Ultrix v4, and +other modern operating systems. + + These two variables set the root for the installation. All the other +installation directories should be subdirectories of one of these two, +and nothing should be directly installed into these two directories. + +`prefix' + A prefix used in constructing the default values of the variables + listed below. The default value of `prefix' should be + `/usr/local'. When building the complete GNU system, the prefix + will be empty and `/usr' will be a symbolic link to `/'. (If you + are using Autoconf, write it as `@prefix@'.) + + Running `make install' with a different value of `prefix' from the + one used to build the program should NOT recompile the program. + +`exec_prefix' + A prefix used in constructing the default values of some of the + variables listed below. The default value of `exec_prefix' should + be `$(prefix)'. (If you are using Autoconf, write it as + `@exec_prefix@'.) + + Generally, `$(exec_prefix)' is used for directories that contain + machine-specific files (such as executables and subroutine + libraries), while `$(prefix)' is used directly for other + directories. + + Running `make install' with a different value of `exec_prefix' + from the one used to build the program should NOT recompile the + program. + + Executable programs are installed in one of the following +directories. + +`bindir' + The directory for installing executable programs that users can + run. This should normally be `/usr/local/bin', but write it as + `$(exec_prefix)/bin'. (If you are using Autoconf, write it as + `@bindir@'.) + +`sbindir' + The directory for installing executable programs that can be run + from the shell, but are only generally useful to system + administrators. This should normally be `/usr/local/sbin', but + write it as `$(exec_prefix)/sbin'. (If you are using Autoconf, + write it as `@sbindir@'.) + +`libexecdir' + The directory for installing executable programs to be run by other + programs rather than by users. This directory should normally be + `/usr/local/libexec', but write it as `$(exec_prefix)/libexec'. + (If you are using Autoconf, write it as `@libexecdir@'.) + + Data files used by the program during its execution are divided into +categories in two ways. + + * Some files are normally modified by programs; others are never + normally modified (though users may edit some of these). + + * Some files are architecture-independent and can be shared by all + machines at a site; some are architecture-dependent and can be + shared only by machines of the same kind and operating system; + others may never be shared between two machines. + + This makes for six different possibilities. However, we want to +discourage the use of architecture-dependent files, aside from object +files and libraries. It is much cleaner to make other data files +architecture-independent, and it is generally not hard. + + Therefore, here are the variables Makefiles should use to specify +directories: + +`datadir' + The directory for installing read-only architecture independent + data files. This should normally be `/usr/local/share', but write + it as `$(prefix)/share'. (If you are using Autoconf, write it as + `@datadir@'.) As a special exception, see `$(infodir)' and + `$(includedir)' below. + +`sysconfdir' + The directory for installing read-only data files that pertain to a + single machine-that is to say, files for configuring a host. + Mailer and network configuration files, `/etc/passwd', and so + forth belong here. All the files in this directory should be + ordinary ASCII text files. This directory should normally be + `/usr/local/etc', but write it as `$(prefix)/etc'. (If you are + using Autoconf, write it as `@sysconfdir@'.) + + Do not install executables here in this directory (they probably + belong in `$(libexecdir)' or `$(sbindir)'). Also do not install + files that are modified in the normal course of their use (programs + whose purpose is to change the configuration of the system + excluded). Those probably belong in `$(localstatedir)'. + +`sharedstatedir' + The directory for installing architecture-independent data files + which the programs modify while they run. This should normally be + `/usr/local/com', but write it as `$(prefix)/com'. (If you are + using Autoconf, write it as `@sharedstatedir@'.) + +`localstatedir' + The directory for installing data files which the programs modify + while they run, and that pertain to one specific machine. Users + should never need to modify files in this directory to configure + the package's operation; put such configuration information in + separate files that go in `$(datadir)' or `$(sysconfdir)'. + `$(localstatedir)' should normally be `/usr/local/var', but write + it as `$(prefix)/var'. (If you are using Autoconf, write it as + `@localstatedir@'.) + +`libdir' + The directory for object files and libraries of object code. Do + not install executables here, they probably ought to go in + `$(libexecdir)' instead. The value of `libdir' should normally be + `/usr/local/lib', but write it as `$(exec_prefix)/lib'. (If you + are using Autoconf, write it as `@libdir@'.) + +`infodir' + The directory for installing the Info files for this package. By + default, it should be `/usr/local/info', but it should be written + as `$(prefix)/info'. (If you are using Autoconf, write it as + `@infodir@'.) + +`lispdir' + The directory for installing any Emacs Lisp files in this package. + By default, it should be `/usr/local/share/emacs/site-lisp', but + it should be written as `$(prefix)/share/emacs/site-lisp'. + + If you are using Autoconf, write the default as `@lispdir@'. In + order to make `@lispdir@' work, you need the following lines in + your `configure.in' file: + + lispdir='${datadir}/emacs/site-lisp' + AC_SUBST(lispdir) + +`includedir' + The directory for installing header files to be included by user + programs with the C `#include' preprocessor directive. This + should normally be `/usr/local/include', but write it as + `$(prefix)/include'. (If you are using Autoconf, write it as + `@includedir@'.) + + Most compilers other than GCC do not look for header files in + directory `/usr/local/include'. So installing the header files + this way is only useful with GCC. Sometimes this is not a problem + because some libraries are only really intended to work with GCC. + But some libraries are intended to work with other compilers. + They should install their header files in two places, one + specified by `includedir' and one specified by `oldincludedir'. + +`oldincludedir' + The directory for installing `#include' header files for use with + compilers other than GCC. This should normally be `/usr/include'. + (If you are using Autoconf, you can write it as `@oldincludedir@'.) + + The Makefile commands should check whether the value of + `oldincludedir' is empty. If it is, they should not try to use + it; they should cancel the second installation of the header files. + + A package should not replace an existing header in this directory + unless the header came from the same package. Thus, if your Foo + package provides a header file `foo.h', then it should install the + header file in the `oldincludedir' directory if either (1) there + is no `foo.h' there or (2) the `foo.h' that exists came from the + Foo package. + + To tell whether `foo.h' came from the Foo package, put a magic + string in the file--part of a comment--and `grep' for that string. + + Unix-style man pages are installed in one of the following: + +`mandir' + The top-level directory for installing the man pages (if any) for + this package. It will normally be `/usr/local/man', but you should + write it as `$(prefix)/man'. (If you are using Autoconf, write it + as `@mandir@'.) + +`man1dir' + The directory for installing section 1 man pages. Write it as + `$(mandir)/man1'. + +`man2dir' + The directory for installing section 2 man pages. Write it as + `$(mandir)/man2' + +`...' + *Don't make the primary documentation for any GNU software be a + man page. Write a manual in Texinfo instead. Man pages are just + for the sake of people running GNU software on Unix, which is a + secondary application only.* + +`manext' + The file name extension for the installed man page. This should + contain a period followed by the appropriate digit; it should + normally be `.1'. + +`man1ext' + The file name extension for installed section 1 man pages. + +`man2ext' + The file name extension for installed section 2 man pages. + +`...' + Use these names instead of `manext' if the package needs to + install man pages in more than one section of the manual. + + And finally, you should set the following variable: + +`srcdir' + The directory for the sources being compiled. The value of this + variable is normally inserted by the `configure' shell script. + (If you are using Autconf, use `srcdir = @srcdir@'.) + + For example: + + # Common prefix for installation directories. + # NOTE: This directory must exist when you start the install. + prefix = /usr/local + exec_prefix = $(prefix) + # Where to put the executable for the command `gcc'. + bindir = $(exec_prefix)/bin + # Where to put the directories used by the compiler. + libexecdir = $(exec_prefix)/libexec + # Where to put the Info files. + infodir = $(prefix)/info + + If your program installs a large number of files into one of the +standard user-specified directories, it might be useful to group them +into a subdirectory particular to that program. If you do this, you +should write the `install' rule to create these subdirectories. + + Do not expect the user to include the subdirectory name in the value +of any of the variables listed above. The idea of having a uniform set +of variable names for installation directories is to enable the user to +specify the exact same values for several different GNU packages. In +order for this to be useful, all the packages must be designed so that +they will work sensibly when the user does so. + + +File: standards.info, Node: Standard Targets, Next: Install Command Categories, Prev: Directory Variables, Up: Makefile Conventions + +Standard Targets for Users +-------------------------- + + All GNU programs should have the following targets in their +Makefiles: + +`all' + Compile the entire program. This should be the default target. + This target need not rebuild any documentation files; Info files + should normally be included in the distribution, and DVI files + should be made only when explicitly asked for. + + By default, the Make rules should compile and link with `-g', so + that executable programs have debugging symbols. Users who don't + mind being helpless can strip the executables later if they wish. + +`install' + Compile the program and copy the executables, libraries, and so on + to the file names where they should reside for actual use. If + there is a simple test to verify that a program is properly + installed, this target should run that test. + + Do not strip executables when installing them. Devil-may-care + users can use the `install-strip' target to do that. + + If possible, write the `install' target rule so that it does not + modify anything in the directory where the program was built, + provided `make all' has just been done. This is convenient for + building the program under one user name and installing it under + another. + + The commands should create all the directories in which files are + to be installed, if they don't already exist. This includes the + directories specified as the values of the variables `prefix' and + `exec_prefix', as well as all subdirectories that are needed. One + way to do this is by means of an `installdirs' target as described + below. + + Use `-' before any command for installing a man page, so that + `make' will ignore any errors. This is in case there are systems + that don't have the Unix man page documentation system installed. + + The way to install Info files is to copy them into `$(infodir)' + with `$(INSTALL_DATA)' (*note Command Variables::), and then run + the `install-info' program if it is present. `install-info' is a + program that edits the Info `dir' file to add or update the menu + entry for the given Info file; it is part of the Texinfo package. + Here is a sample rule to install an Info file: + + $(DESTDIR)$(infodir)/foo.info: foo.info + $(POST_INSTALL) + # There may be a newer info file in . than in srcdir. + -if test -f foo.info; then d=.; \ + else d=$(srcdir); fi; \ + $(INSTALL_DATA) $$d/foo.info $(DESTDIR)$@; \ + # Run install-info only if it exists. + # Use `if' instead of just prepending `-' to the + # line so we notice real errors from install-info. + # We use `$(SHELL) -c' because some shells do not + # fail gracefully when there is an unknown command. + if $(SHELL) -c 'install-info --version' \ + >/dev/null 2>&1; then \ + install-info --dir-file=$(DESTDIR)$(infodir)/dir \ + $(DESTDIR)$(infodir)/foo.info; \ + else true; fi + + When writing the `install' target, you must classify all the + commands into three categories: normal ones, "pre-installation" + commands and "post-installation" commands. *Note Install Command + Categories::. + +`uninstall' + Delete all the installed files--the copies that the `install' + target creates. + + This rule should not modify the directories where compilation is + done, only the directories where files are installed. + + The uninstallation commands are divided into three categories, + just like the installation commands. *Note Install Command + Categories::. + +`install-strip' + Like `install', but strip the executable files while installing + them. In many cases, the definition of this target can be very + simple: + + install-strip: + $(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' \ + install + + Normally we do not recommend stripping an executable unless you + are sure the program has no bugs. However, it can be reasonable + to install a stripped executable for actual execution while saving + the unstripped executable elsewhere in case there is a bug. + +`clean' + Delete all files from the current directory that are normally + created by building the program. Don't delete the files that + record the configuration. Also preserve files that could be made + by building, but normally aren't because the distribution comes + with them. + + Delete `.dvi' files here if they are not part of the distribution. + +`distclean' + Delete all files from the current directory that are created by + configuring or building the program. If you have unpacked the + source and built the program without creating any other files, + `make distclean' should leave only the files that were in the + distribution. + +`mostlyclean' + Like `clean', but may refrain from deleting a few files that people + normally don't want to recompile. For example, the `mostlyclean' + target for GCC does not delete `libgcc.a', because recompiling it + is rarely necessary and takes a lot of time. + +`maintainer-clean' + Delete almost everything from the current directory that can be + reconstructed with this Makefile. This typically includes + everything deleted by `distclean', plus more: C source files + produced by Bison, tags tables, Info files, and so on. + + The reason we say "almost everything" is that running the command + `make maintainer-clean' should not delete `configure' even if + `configure' can be remade using a rule in the Makefile. More + generally, `make maintainer-clean' should not delete anything that + needs to exist in order to run `configure' and then begin to build + the program. This is the only exception; `maintainer-clean' should + delete everything else that can be rebuilt. + + The `maintainer-clean' target is intended to be used by a + maintainer of the package, not by ordinary users. You may need + special tools to reconstruct some of the files that `make + maintainer-clean' deletes. Since these files are normally + included in the distribution, we don't take care to make them easy + to reconstruct. If you find you need to unpack the full + distribution again, don't blame us. + + To help make users aware of this, the commands for the special + `maintainer-clean' target should start with these two: + + @echo 'This command is intended for maintainers to use; it' + @echo 'deletes files that may need special tools to rebuild.' + +`TAGS' + Update a tags table for this program. + +`info' + Generate any Info files needed. The best way to write the rules + is as follows: + + info: foo.info + + foo.info: foo.texi chap1.texi chap2.texi + $(MAKEINFO) $(srcdir)/foo.texi + + You must define the variable `MAKEINFO' in the Makefile. It should + run the `makeinfo' program, which is part of the Texinfo + distribution. + + Normally a GNU distribution comes with Info files, and that means + the Info files are present in the source directory. Therefore, + the Make rule for an info file should update it in the source + directory. When users build the package, ordinarily Make will not + update the Info files because they will already be up to date. + +`dvi' + Generate DVI files for all Texinfo documentation. For example: + + dvi: foo.dvi + + foo.dvi: foo.texi chap1.texi chap2.texi + $(TEXI2DVI) $(srcdir)/foo.texi + + You must define the variable `TEXI2DVI' in the Makefile. It should + run the program `texi2dvi', which is part of the Texinfo + distribution.(1) Alternatively, write just the dependencies, and + allow GNU `make' to provide the command. + +`dist' + Create a distribution tar file for this program. The tar file + should be set up so that the file names in the tar file start with + a subdirectory name which is the name of the package it is a + distribution for. This name can include the version number. + + For example, the distribution tar file of GCC version 1.40 unpacks + into a subdirectory named `gcc-1.40'. + + The easiest way to do this is to create a subdirectory + appropriately named, use `ln' or `cp' to install the proper files + in it, and then `tar' that subdirectory. + + Compress the tar file file with `gzip'. For example, the actual + distribution file for GCC version 1.40 is called `gcc-1.40.tar.gz'. + + The `dist' target should explicitly depend on all non-source files + that are in the distribution, to make sure they are up to date in + the distribution. *Note Making Releases: Releases. + +`check' + Perform self-tests (if any). The user must build the program + before running the tests, but need not install the program; you + should write the self-tests so that they work when the program is + built but not installed. + + The following targets are suggested as conventional names, for +programs in which they are useful. + +`installcheck' + Perform installation tests (if any). The user must build and + install the program before running the tests. You should not + assume that `$(bindir)' is in the search path. + +`installdirs' + It's useful to add a target named `installdirs' to create the + directories where files are installed, and their parent + directories. There is a script called `mkinstalldirs' which is + convenient for this; you can find it in the Texinfo package. You + can use a rule like this: + + # Make sure all installation directories (e.g. $(bindir)) + # actually exist by making them if necessary. + installdirs: mkinstalldirs + $(srcdir)/mkinstalldirs $(bindir) $(datadir) \ + $(libdir) $(infodir) \ + $(mandir) + + This rule should not modify the directories where compilation is + done. It should do nothing but create installation directories. + + ---------- Footnotes ---------- + + (1) `texi2dvi' uses TeX to do the real work of formatting. TeX is +not distributed with Texinfo. + + +File: standards.info, Node: Install Command Categories, Prev: Standard Targets, Up: Makefile Conventions + +Install Command Categories +-------------------------- + + When writing the `install' target, you must classify all the +commands into three categories: normal ones, "pre-installation" +commands and "post-installation" commands. + + Normal commands move files into their proper places, and set their +modes. They may not alter any files except the ones that come entirely +from the package they belong to. + + Pre-installation and post-installation commands may alter other +files; in particular, they can edit global configuration files or data +bases. + + Pre-installation commands are typically executed before the normal +commands, and post-installation commands are typically run after the +normal commands. + + The most common use for a post-installation command is to run +`install-info'. This cannot be done with a normal command, since it +alters a file (the Info directory) which does not come entirely and +solely from the package being installed. It is a post-installation +command because it needs to be done after the normal command which +installs the package's Info files. + + Most programs don't need any pre-installation commands, but we have +the feature just in case it is needed. + + To classify the commands in the `install' rule into these three +categories, insert "category lines" among them. A category line +specifies the category for the commands that follow. + + A category line consists of a tab and a reference to a special Make +variable, plus an optional comment at the end. There are three +variables you can use, one for each category; the variable name +specifies the category. Category lines are no-ops in ordinary execution +because these three Make variables are normally undefined (and you +_should not_ define them in the makefile). + + Here are the three possible category lines, each with a comment that +explains what it means: + + $(PRE_INSTALL) # Pre-install commands follow. + $(POST_INSTALL) # Post-install commands follow. + $(NORMAL_INSTALL) # Normal commands follow. + + If you don't use a category line at the beginning of the `install' +rule, all the commands are classified as normal until the first category +line. If you don't use any category lines, all the commands are +classified as normal. + + These are the category lines for `uninstall': + + $(PRE_UNINSTALL) # Pre-uninstall commands follow. + $(POST_UNINSTALL) # Post-uninstall commands follow. + $(NORMAL_UNINSTALL) # Normal commands follow. + + Typically, a pre-uninstall command would be used for deleting entries +from the Info directory. + + If the `install' or `uninstall' target has any dependencies which +act as subroutines of installation, then you should start _each_ +dependency's commands with a category line, and start the main target's +commands with a category line also. This way, you can ensure that each +command is placed in the right category regardless of which of the +dependencies actually run. + + Pre-installation and post-installation commands should not run any +programs except for these: + + [ basename bash cat chgrp chmod chown cmp cp dd diff echo + egrep expand expr false fgrep find getopt grep gunzip gzip + hostname install install-info kill ldconfig ln ls md5sum + mkdir mkfifo mknod mv printenv pwd rm rmdir sed sort tee + test touch true uname xargs yes + + The reason for distinguishing the commands in this way is for the +sake of making binary packages. Typically a binary package contains +all the executables and other files that need to be installed, and has +its own method of installing them--so it does not need to run the normal +installation commands. But installing the binary package does need to +execute the pre-installation and post-installation commands. + + Programs to build binary packages work by extracting the +pre-installation and post-installation commands. Here is one way of +extracting the pre-installation commands: + + make -n install -o all \ + PRE_INSTALL=pre-install \ + POST_INSTALL=post-install \ + NORMAL_INSTALL=normal-install \ + | gawk -f pre-install.awk + +where the file `pre-install.awk' could contain this: + + $0 ~ /^\t[ \t]*(normal_install|post_install)[ \t]*$/ {on = 0} + on {print $0} + $0 ~ /^\t[ \t]*pre_install[ \t]*$/ {on = 1} + + The resulting file of pre-installation commands is executed as a +shell script as part of installing the binary package. + + +File: standards.info, Node: Releases, Prev: Makefile Conventions, Up: Managing Releases + +Making Releases +=============== + + Package the distribution of `Foo version 69.96' up in a gzipped tar +file with the name `foo-69.96.tar.gz'. It should unpack into a +subdirectory named `foo-69.96'. + + Building and installing the program should never modify any of the +files contained in the distribution. This means that all the files +that form part of the program in any way must be classified into "source +files" and "non-source files". Source files are written by humans and +never changed automatically; non-source files are produced from source +files by programs under the control of the Makefile. + + Naturally, all the source files must be in the distribution. It is +okay to include non-source files in the distribution, provided they are +up-to-date and machine-independent, so that building the distribution +normally will never modify them. We commonly include non-source files +produced by Bison, `lex', TeX, and `makeinfo'; this helps avoid +unnecessary dependencies between our distributions, so that users can +install whichever packages they want to install. + + Non-source files that might actually be modified by building and +installing the program should *never* be included in the distribution. +So if you do distribute non-source files, always make sure they are up +to date when you make a new distribution. + + Make sure that the directory into which the distribution unpacks (as +well as any subdirectories) are all world-writable (octal mode 777). +This is so that old versions of `tar' which preserve the ownership and +permissions of the files from the tar archive will be able to extract +all the files even if the user is unprivileged. + + Make sure that all the files in the distribution are world-readable. + + Make sure that no file name in the distribution is more than 14 +characters long. Likewise, no file created by building the program +should have a name longer than 14 characters. The reason for this is +that some systems adhere to a foolish interpretation of the POSIX +standard, and refuse to open a longer name, rather than truncating as +they did in the past. + + Don't include any symbolic links in the distribution itself. If the +tar file contains symbolic links, then people cannot even unpack it on +systems that don't support symbolic links. Also, don't use multiple +names for one file in different directories, because certain file +systems cannot handle this and that prevents unpacking the distribution. + + Try to make sure that all the file names will be unique on MS-DOS. A +name on MS-DOS consists of up to 8 characters, optionally followed by a +period and up to three characters. MS-DOS will truncate extra +characters both before and after the period. Thus, `foobarhacker.c' +and `foobarhacker.o' are not ambiguous; they are truncated to +`foobarha.c' and `foobarha.o', which are distinct. + + Include in your distribution a copy of the `texinfo.tex' you used to +test print any `*.texinfo' or `*.texi' files. + + Likewise, if your program uses small GNU software packages like +regex, getopt, obstack, or termcap, include them in the distribution +file. Leaving them out would make the distribution file a little +smaller at the expense of possible inconvenience to a user who doesn't +know what other files to get. + + + +Tag Table: +Node: Top962 +Node: Preface1505 +Node: Intellectual Property2532 +Node: Reading Non-Free Code2907 +Node: Contributions4639 +Node: Design Advice6633 +Node: Compatibility7150 +Node: Using Extensions8661 +Node: ANSI C10163 +Node: Source Language11399 +Node: Program Behavior12892 +Node: Semantics13601 +Node: Libraries17355 +Node: Errors18590 +Node: User Interfaces19813 +Node: Option Table26559 +Node: Memory Usage40648 +Node: Writing C41642 +Node: Formatting42483 +Node: Comments45755 +Node: Syntactic Conventions49053 +Node: Names51991 +Node: System Portability53727 +Node: CPU Portability55503 +Node: System Functions57664 +Node: Internationalization62768 +Node: Mmap65916 +Node: Documentation66621 +Node: GNU Manuals67179 +Node: Manual Structure Details71066 +Node: NEWS File72396 +Node: Change Logs73077 +Node: Change Log Concepts73794 +Node: Style of Change Logs75562 +Node: Simple Changes77116 +Node: Conditional Changes78307 +Node: Man Pages79684 +Node: Reading other Manuals81303 +Node: Managing Releases82087 +Node: Configuration82823 +Node: Makefile Conventions89763 +Node: Makefile Basics90443 +Node: Utilities in Makefiles93612 +Node: Command Variables95748 +Node: Directory Variables99249 +Node: Standard Targets110126 +Ref: Standard Targets-Footnote-1120565 +Node: Install Command Categories120665 +Node: Releases125238 + +End Tag Table diff --git a/gas/doc/as.info b/gas/doc/as.info new file mode 100644 index 00000000000..d401de51c73 --- /dev/null +++ b/gas/doc/as.info @@ -0,0 +1,343 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +Indirect: +as.info-1: 866 +as.info-2: 50563 +as.info-3: 100403 +as.info-4: 149485 +as.info-5: 197985 +as.info-6: 244546 +as.info-7: 294439 +as.info-8: 315111 + +Tag Table: +(Indirect) +Node: Top866 +Node: Overview1538 +Node: Manual13605 +Node: GNU Assembler14544 +Node: Object Formats15710 +Node: Command Line16157 +Node: Input Files17239 +Node: Object19218 +Node: Errors20165 +Node: Invoking21355 +Node: a23201 +Node: D24535 +Node: f24755 +Node: I25258 +Node: K25797 +Node: L26096 +Node: M26947 +Node: MD31337 +Node: o31756 +Node: R32204 +Node: statistics33220 +Node: traditional-format33620 +Node: v34086 +Node: W34354 +Node: Z35254 +Node: Syntax35769 +Node: Preprocessing36359 +Node: Whitespace37919 +Node: Comments38309 +Node: Symbol Intro40329 +Node: Statements41012 +Node: Constants42926 +Node: Characters43552 +Node: Strings44045 +Node: Chars46198 +Node: Numbers46939 +Node: Integers47470 +Node: Bignums48113 +Node: Flonums48456 +Node: Sections50189 +Node: Secs Background50563 +Node: Ld Sections55589 +Node: As Sections57983 +Node: Sub-Sections58888 +Node: bss61887 +Node: Symbols62832 +Node: Labels63479 +Node: Setting Symbols64205 +Node: Symbol Names64570 +Node: Dot67532 +Node: Symbol Attributes67974 +Node: Symbol Value68706 +Node: Symbol Type69742 +Node: a.out Symbols70121 +Node: Symbol Desc70371 +Node: Symbol Other70653 +Node: COFF Symbols70809 +Node: SOM Symbols71438 +Node: Expressions71871 +Node: Empty Exprs72619 +Node: Integer Exprs72961 +Node: Arguments73351 +Node: Operators74448 +Node: Prefix Ops74774 +Node: Infix Ops75093 +Node: Pseudo Ops76585 +Node: Abort80802 +Node: ABORT81203 +Node: Align81465 +Node: Ascii83627 +Node: Asciz83928 +Node: Balign84168 +Node: Byte86026 +Node: Comm86259 +Node: Data87618 +Node: Def87928 +Node: Desc88296 +Node: Dim88789 +Node: Double89180 +Node: Eject89511 +Node: Else89679 +Node: Elseif89969 +Node: End90253 +Node: Endef90461 +Node: Endfunc90784 +Node: Endif90952 +Node: Equ91205 +Node: Equiv91508 +Node: Err91904 +Node: Exitm92207 +Node: Extern92367 +Node: Fail92621 +Node: File93059 +Node: Fill93668 +Node: Float94625 +Node: Func94959 +Node: Global95539 +Node: hword96281 +Node: Ident96602 +Node: If96902 +Node: Include99494 +Node: Int100034 +Node: Irp100403 +Node: Irpc101197 +Node: Lcomm102016 +Node: Lflags102757 +Node: Line102944 +Node: Linkonce103967 +Node: Ln105187 +Node: MRI105335 +Node: List105662 +Node: Long106265 +Node: Macro106435 +Node: Nolist108819 +Node: Octa109235 +Node: Org109561 +Node: P2align110836 +Node: Print112752 +Node: Psize112969 +Node: Purgem113642 +Node: Quad113849 +Node: Rept114290 +Node: Sbttl114696 +Node: Scl115054 +Node: Section115550 +Node: Set117951 +Node: Short118503 +Node: Single118816 +Node: Size119153 +Node: Sleb128119548 +Node: Skip119863 +Node: Space120178 +Node: Stab121063 +Node: String123058 +Node: Struct123477 +Node: Symver124189 +Node: Tag125774 +Node: Text126282 +Node: Title126594 +Node: Type126966 +Node: Val127342 +Node: Uleb128127703 +Node: Visibility128025 +Node: Word129068 +Node: Deprecated130904 +Node: Machine Dependencies131129 +Node: ARC-Dependent133007 +Node: ARC-Opts133321 +Node: ARC-Float134055 +Node: ARC-Directives134353 +Node: AMD29K-Dependent134746 +Node: AMD29K Options135127 +Node: AMD29K Syntax135301 +Node: AMD29K-Macros135565 +Node: AMD29K-Chars135816 +Node: AMD29K-Regs136079 +Node: AMD29K Floating Point137343 +Node: AMD29K Directives137549 +Node: AMD29K Opcodes138957 +Node: ARM-Dependent139293 +Node: ARM Options139667 +Node: ARM Syntax142165 +Node: ARM-Chars142385 +Node: ARM-Regs142937 +Node: ARM Floating Point143109 +Node: ARM Directives143299 +Node: ARM Opcodes144977 +Node: D10V-Dependent147030 +Node: D10V-Opts147372 +Node: D10V-Syntax148005 +Node: D10V-Size148525 +Node: D10V-Subs149485 +Node: D10V-Chars150507 +Node: D10V-Regs152093 +Node: D10V-Addressing153124 +Node: D10V-Word153797 +Node: D10V-Float154298 +Node: D10V-Opcodes154600 +Node: D30V-Dependent154984 +Node: D30V-Opts155329 +Node: D30V-Syntax155995 +Node: D30V-Size156518 +Node: D30V-Subs157476 +Node: D30V-Chars158498 +Node: D30V-Guarded160783 +Node: D30V-Regs161451 +Node: D30V-Addressing162577 +Node: D30V-Float163232 +Node: D30V-Opcodes163534 +Node: H8/300-Dependent163918 +Node: H8/300 Options164322 +Node: H8/300 Syntax164503 +Node: H8/300-Chars164790 +Node: H8/300-Regs165074 +Node: H8/300-Addressing165978 +Node: H8/300 Floating Point167004 +Node: H8/300 Directives167320 +Node: H8/300 Opcodes167840 +Node: H8/500-Dependent176193 +Node: H8/500 Options176597 +Node: H8/500 Syntax176778 +Node: H8/500-Chars177065 +Node: H8/500-Regs177356 +Node: H8/500-Addressing178112 +Node: H8/500 Floating Point178729 +Node: H8/500 Directives179045 +Node: H8/500 Opcodes179364 +Node: HPPA-Dependent184477 +Node: HPPA Notes184902 +Node: HPPA Options185649 +Node: HPPA Syntax185833 +Node: HPPA Floating Point187092 +Node: HPPA Directives187287 +Node: HPPA Opcodes193878 +Node: ESA/390-Dependent194126 +Node: ESA/390 Notes194576 +Node: ESA/390 Options195356 +Node: ESA/390 Syntax195555 +Node: ESA/390 Floating Point197716 +Node: ESA/390 Directives197985 +Node: ESA/390 Opcodes201262 +Node: i386-Dependent201513 +Node: i386-Options202321 +Node: i386-Syntax202465 +Node: i386-Mnemonics204578 +Node: i386-Regs206720 +Node: i386-Prefixes207863 +Node: i386-Memory209951 +Node: i386-jumps212260 +Node: i386-Float213350 +Node: i386-SIMD215168 +Node: i386-16bit216266 +Node: i386-Bugs218229 +Node: i386-Notes218969 +Node: i960-Dependent219809 +Node: Options-i960220201 +Node: Floating Point-i960224082 +Node: Directives-i960224339 +Node: Opcodes for i960226359 +Node: callj-i960226965 +Node: Compare-and-branch-i960227440 +Node: M68K-Dependent229329 +Node: M68K-Opts229783 +Node: M68K-Syntax234731 +Node: M68K-Moto-Syntax236559 +Node: M68K-Float239137 +Node: M68K-Directives239646 +Node: M68K-opcodes240241 +Node: M68K-Branch240453 +Node: M68K-Chars243268 +Node: MIPS-Dependent243666 +Node: MIPS Opts244546 +Node: MIPS Object248576 +Node: MIPS Stabs250131 +Node: MIPS ISA250842 +Node: MIPS autoextend251950 +Node: MIPS insn252661 +Node: MIPS option stack253147 +Node: PJ-Dependent253860 +Node: PJ Options254073 +Node: SH-Dependent254340 +Node: SH Options254720 +Node: SH Syntax254885 +Node: SH-Chars255144 +Node: SH-Regs255423 +Node: SH-Addressing256022 +Node: SH Floating Point256916 +Node: SH Directives257212 +Node: SH Opcodes257568 +Node: Sparc-Dependent261815 +Node: Sparc-Opts262187 +Node: Sparc-Aligned-Data264433 +Node: Sparc-Float265277 +Node: Sparc-Directives265467 +Node: Z8000-Dependent267416 +Node: Z8000 Options268375 +Node: Z8000 Syntax268550 +Node: Z8000-Chars268826 +Node: Z8000-Regs269044 +Node: Z8000-Addressing269834 +Node: Z8000 Directives270777 +Node: Z8000 Opcodes272375 +Node: Vax-Dependent282311 +Node: VAX-Opts282818 +Node: VAX-float286542 +Node: VAX-directives287163 +Node: VAX-opcodes288012 +Node: VAX-branch288390 +Node: VAX-operands290886 +Node: VAX-no291638 +Node: V850-Dependent291864 +Node: V850 Options292250 +Node: V850 Syntax294063 +Node: V850-Chars294289 +Node: V850-Regs294439 +Node: V850 Floating Point295976 +Node: V850 Directives296171 +Node: V850 Opcodes297071 +Node: Reporting Bugs302356 +Node: Bug Criteria303079 +Node: Bug Reporting303839 +Node: Acknowledgements310408 +Ref: Acknowledgements-Footnote-1315085 +Node: Index315111 + +End Tag Table diff --git a/gas/doc/as.info-1 b/gas/doc/as.info-1 new file mode 100644 index 00000000000..0a164a84ec8 --- /dev/null +++ b/gas/doc/as.info-1 @@ -0,0 +1,1424 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: Top, Next: Overview, Up: (dir) + +Using as +******** + + This file is a user guide to the GNU assembler `as' version 2.10. + +* Menu: + +* Overview:: Overview +* Invoking:: Command-Line Options +* Syntax:: Syntax +* Sections:: Sections and Relocation +* Symbols:: Symbols +* Expressions:: Expressions +* Pseudo Ops:: Assembler Directives +* Machine Dependencies:: Machine Dependent Features +* Reporting Bugs:: Reporting Bugs +* Acknowledgements:: Who Did What +* Index:: Index + + +File: as.info, Node: Overview, Next: Invoking, Prev: Top, Up: Top + +Overview +******** + + Here is a brief summary of how to invoke `as'. For details, *note +Comand-Line Options: Invoking.. + + as [ -a[cdhlns][=file] ] [ -D ] [ --defsym SYM=VAL ] + [ -f ] [ --gstabs ] [ --gdwarf2 ] [ --help ] [ -I DIR ] [ -J ] [ -K ] [ -L ] + [ --keep-locals ] [ -o OBJFILE ] [ -R ] [ --statistics ] [ -v ] + [ -version ] [ --version ] [ -W ] [ --warn ] [ --fatal-warnings ] + [ -w ] [ -x ] [ -Z ] + [ -mbig-endian | -mlittle-endian ] + [ -m[arm]1 | -m[arm]2 | -m[arm]250 | -m[arm]3 | -m[arm]6 | -m[arm]60 | + -m[arm]600 | -m[arm]610 | -m[arm]620 | -m[arm]7[t][[d]m[i]][fe] | -m[arm]70 | + -m[arm]700 | -m[arm]710[c] | -m[arm]7100 | -m[arm]7500 | -m[arm]8 | + -m[arm]810 | -m[arm]9 | -m[arm]920 | -m[arm]920t | -m[arm]9tdmi | + -mstrongarm | -mstrongarm110 | -mstrongarm1100 ] + [ -m[arm]v2 | -m[arm]v2a | -m[arm]v3 | -m[arm]v3m | -m[arm]v4 | -m[arm]v4t | + -m[arm]v5 | -[arm]v5t ] + [ -mthumb | -mall ] + [ -mfpa10 | -mfpa11 | -mfpe-old | -mno-fpu ] + [ -EB | -EL ] + [ -mapcs-32 | -mapcs-26 | -mapcs-float | -mapcs-reentrant ] + [ -mthumb-interwork ] + [ -moabi ] + [ -k ] + [ -O ] + [ -O | -n | -N ] + [ -mb | -me ] + [ -Av6 | -Av7 | -Av8 | -Asparclet | -Asparclite + -Av8plus | -Av8plusa | -Av9 | -Av9a ] + [ -xarch=v8plus | -xarch=v8plusa ] [ -bump ] [ -32 | -64 ] + [ -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC ] + [ -b ] [ -no-relax ] + [ -l ] [ -m68000 | -m68010 | -m68020 | ... ] + [ -jsri2bsr ] [ -sifilter ] [ -relax ] + [ -nocpp ] [ -EL ] [ -EB ] [ -G NUM ] [ -mcpu=CPU ] + [ -mips1 ] [ -mips2 ] [ -mips3 ] [ -m4650 ] [ -no-m4650 ] + [ --trap ] [ --break ] + [ --emulation=NAME ] + [ -- | FILES ... ] + +`-a[cdhlmns]' + Turn on listings, in any of a variety of ways: + + `-ac' + omit false conditionals + + `-ad' + omit debugging directives + + `-ah' + include high-level source + + `-al' + include assembly + + `-am' + include macro expansions + + `-an' + omit forms processing + + `-as' + include symbols + + `=file' + set the name of the listing file + + You may combine these options; for example, use `-aln' for assembly + listing without forms processing. The `=file' option, if used, + must be the last one. By itself, `-a' defaults to `-ahls'. + +`-D' + Ignored. This option is accepted for script compatibility with + calls to other assemblers. + +`--defsym SYM=VALUE' + Define the symbol SYM to be VALUE before assembling the input file. + VALUE must be an integer constant. As in C, a leading `0x' + indicates a hexadecimal value, and a leading `0' indicates an + octal value. + +`-f' + "fast"--skip whitespace and comment preprocessing (assume source is + compiler output). + +`--gstabs' + Generate stabs debugging information for each assembler line. This + may help debugging assembler code, if the debugger can handle it. + +`--gdwarf2' + Generate DWARF2 debugging information for each assembler line. + This may help debugging assembler code, if the debugger can handle + it. + +`--help' + Print a summary of the command line options and exit. + +`-I DIR' + Add directory DIR to the search list for `.include' directives. + +`-J' + Don't warn about signed overflow. + +`-K' + Issue warnings when difference tables altered for long + displacements. + +`-L' +`--keep-locals' + Keep (in the symbol table) local symbols. On traditional a.out + systems these start with `L', but different systems have different + local label prefixes. + +`-o OBJFILE' + Name the object-file output from `as' OBJFILE. + +`-R' + Fold the data section into the text section. + +`--statistics' + Print the maximum space (in bytes) and total time (in seconds) + used by assembly. + +`--strip-local-absolute' + Remove local absolute symbols from the outgoing symbol table. + +`-v' +`-version' + Print the `as' version. + +`--version' + Print the `as' version and exit. + +`-W' +`--no-warn' + Suppress warning messages. + +`--fatal-warnings' + Treat warnings as errors. + +`--warn' + Don't suppress warning messages or treat them as errors. + +`-w' + Ignored. + +`-x' + Ignored. + +`-Z' + Generate an object file even after errors. + +`-- | FILES ...' + Standard input, or source files to assemble. + + The following options are available when as is configured for an ARC +processor. + +`-mbig-endian' + Generate "big endian" format output. + +`-mlittle-endian' + Generate "little endian" format output. + + The following options are available when as is configured for the ARM +processor family. + +`-m[arm][1|2|3|6|7|8|9][...]' + Specify which ARM processor variant is the target. + +`-m[arm]v[2|2a|3|3m|4|4t|5|5t]' + Specify which ARM architecture variant is used by the target. + +`-mthumb | -mall' + Enable or disable Thumb only instruction decoding. + +`-mfpa10 | -mfpa11 | -mfpe-old | -mno-fpu' + Select which Floating Point architcture is the target. + +`-mapcs-32 | -mapcs-26 | -mapcs-float | -mapcs-reentrant | -moabi' + Select which procedure calling convention is in use. + +`-EB | -EL' + Select either big-endian (-EB) or little-endian (-EL) output. + +`-mthumb-interwork' + Specify that the code has been generated with interworking between + Thumb and ARM code in mind. + +`-k' + Specify that PIC code has been generated. + + The following options are available when as is configured for a D10V +processor. +`-O' + Optimize output by parallelizing instructions. + + The following options are available when as is configured for a D30V +processor. +`-O' + Optimize output by parallelizing instructions. + +`-n' + Warn when nops are generated. + +`-N' + Warn when a nop after a 32-bit multiply instruction is generated. + + The following options are available when as is configured for the +Intel 80960 processor. + +`-ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC' + Specify which variant of the 960 architecture is the target. + +`-b' + Add code to collect statistics about branches taken. + +`-no-relax' + Do not alter compare-and-branch instructions for long + displacements; error if necessary. + + The following options are available when as is configured for the +Motorola 68000 series. + +`-l' + Shorten references to undefined symbols, to one word instead of + two. + +`-m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040 | -m68060' +`| -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -mcpu32 | -m5200' + Specify what processor in the 68000 family is the target. The + default is normally the 68020, but this can be changed at + configuration time. + +`-m68881 | -m68882 | -mno-68881 | -mno-68882' + The target machine does (or does not) have a floating-point + coprocessor. The default is to assume a coprocessor for 68020, + 68030, and cpu32. Although the basic 68000 is not compatible with + the 68881, a combination of the two can be specified, since it's + possible to do emulation of the coprocessor instructions with the + main processor. + +`-m68851 | -mno-68851' + The target machine does (or does not) have a memory-management + unit coprocessor. The default is to assume an MMU for 68020 and + up. + + The following options are available when as is configured for a +picoJava processor. + +`-mb' + Generate "big endian" format output. + +`-ml' + Generate "little endian" format output. + + The following options are available when `as' is configured for the +SPARC architecture: + +`-Av6 | -Av7 | -Av8 | -Asparclet | -Asparclite' +`-Av8plus | -Av8plusa | -Av9 | -Av9a' + Explicitly select a variant of the SPARC architecture. + + `-Av8plus' and `-Av8plusa' select a 32 bit environment. `-Av9' + and `-Av9a' select a 64 bit environment. + + `-Av8plusa' and `-Av9a' enable the SPARC V9 instruction set with + UltraSPARC extensions. + +`-xarch=v8plus | -xarch=v8plusa' + For compatibility with the Solaris v9 assembler. These options are + equivalent to -Av8plus and -Av8plusa, respectively. + +`-bump' + Warn when the assembler switches to another architecture. + + The following options are available when as is configured for a MIPS +processor. + +`-G NUM' + This option sets the largest size of an object that can be + referenced implicitly with the `gp' register. It is only accepted + for targets that use ECOFF format, such as a DECstation running + Ultrix. The default value is 8. + +`-EB' + Generate "big endian" format output. + +`-EL' + Generate "little endian" format output. + +`-mips1' +`-mips2' +`-mips3' + Generate code for a particular MIPS Instruction Set Architecture + level. `-mips1' corresponds to the R2000 and R3000 processors, + `-mips2' to the R6000 processor, and `-mips3' to the R4000 + processor. + +`-m4650' +`-no-m4650' + Generate code for the MIPS R4650 chip. This tells the assembler + to accept the `mad' and `madu' instruction, and to not schedule + `nop' instructions around accesses to the `HI' and `LO' registers. + `-no-m4650' turns off this option. + +`-mcpu=CPU' + Generate code for a particular MIPS cpu. This has little effect + on the assembler, but it is passed by `gcc'. + +`--emulation=NAME' + This option causes `as' to emulate `as' configured for some other + target, in all respects, including output format (choosing between + ELF and ECOFF only), handling of pseudo-opcodes which may generate + debugging information or store symbol table information, and + default endianness. The available configuration names are: + `mipsecoff', `mipself', `mipslecoff', `mipsbecoff', `mipslelf', + `mipsbelf'. The first two do not alter the default endianness + from that of the primary target for which the assembler was + configured; the others change the default to little- or big-endian + as indicated by the `b' or `l' in the name. Using `-EB' or `-EL' + will override the endianness selection in any case. + + This option is currently supported only when the primary target + `as' is configured for is a MIPS ELF or ECOFF target. + Furthermore, the primary target or others specified with + `--enable-targets=...' at configuration time must include support + for the other format, if both are to be available. For example, + the Irix 5 configuration includes support for both. + + Eventually, this option will support more configurations, with more + fine-grained control over the assembler's behavior, and will be + supported for more processors. + +`-nocpp' + `as' ignores this option. It is accepted for compatibility with + the native tools. + +`--trap' +`--no-trap' +`--break' +`--no-break' + Control how to deal with multiplication overflow and division by + zero. `--trap' or `--no-break' (which are synonyms) take a trap + exception (and only work for Instruction Set Architecture level 2 + and higher); `--break' or `--no-trap' (also synonyms, and the + default) take a break exception. + + The following options are available when as is configured for an +MCore processor. + +`-jsri2bsr' +`-nojsri2bsr' + Enable or disable the JSRI to BSR transformation. By default this + is enabled. The command line option `-nojsri2bsr' can be used to + disable it. + +`-sifilter' +`-nosifilter' + Enable or disable the silicon filter behaviour. By default this + is disabled. The default can be overidden by the `-sifilter' + command line option. + +`-relax' + Alter jump instructions for long displacements. + +* Menu: + +* Manual:: Structure of this Manual +* GNU Assembler:: The GNU Assembler +* Object Formats:: Object File Formats +* Command Line:: Command Line +* Input Files:: Input Files +* Object:: Output (Object) File +* Errors:: Error and Warning Messages + + +File: as.info, Node: Manual, Next: GNU Assembler, Up: Overview + +Structure of this Manual +======================== + + This manual is intended to describe what you need to know to use GNU +`as'. We cover the syntax expected in source files, including notation +for symbols, constants, and expressions; the directives that `as' +understands; and of course how to invoke `as'. + + This manual also describes some of the machine-dependent features of +various flavors of the assembler. + + On the other hand, this manual is _not_ intended as an introduction +to programming in assembly language--let alone programming in general! +In a similar vein, we make no attempt to introduce the machine +architecture; we do _not_ describe the instruction set, standard +mnemonics, registers or addressing modes that are standard to a +particular architecture. You may want to consult the manufacturer's +machine architecture manual for this information. + + +File: as.info, Node: GNU Assembler, Next: Object Formats, Prev: Manual, Up: Overview + +The GNU Assembler +================= + + GNU `as' is really a family of assemblers. If you use (or have +used) the GNU assembler on one architecture, you should find a fairly +similar environment when you use it on another architecture. Each +version has much in common with the others, including object file +formats, most assembler directives (often called "pseudo-ops") and +assembler syntax. + + `as' is primarily intended to assemble the output of the GNU C +compiler `gcc' for use by the linker `ld'. Nevertheless, we've tried +to make `as' assemble correctly everything that other assemblers for +the same machine would assemble. Any exceptions are documented +explicitly (*note Machine Dependencies::). This doesn't mean `as' +always uses the same syntax as another assembler for the same +architecture; for example, we know of several incompatible versions of +680x0 assembly language syntax. + + Unlike older assemblers, `as' is designed to assemble a source +program in one pass of the source file. This has a subtle impact on the +`.org' directive (*note `.org': Org.). + + +File: as.info, Node: Object Formats, Next: Command Line, Prev: GNU Assembler, Up: Overview + +Object File Formats +=================== + + The GNU assembler can be configured to produce several alternative +object file formats. For the most part, this does not affect how you +write assembly language programs; but directives for debugging symbols +are typically different in different file formats. *Note Symbol +Attributes: Symbol Attributes. + + +File: as.info, Node: Command Line, Next: Input Files, Prev: Object Formats, Up: Overview + +Command Line +============ + + After the program name `as', the command line may contain options +and file names. Options may appear in any order, and may be before, +after, or between file names. The order of file names is significant. + + `--' (two hyphens) by itself names the standard input file +explicitly, as one of the files for `as' to assemble. + + Except for `--' any command line argument that begins with a hyphen +(`-') is an option. Each option changes the behavior of `as'. No +option changes the way another option works. An option is a `-' +followed by one or more letters; the case of the letter is important. +All options are optional. + + Some options expect exactly one file name to follow them. The file +name may either immediately follow the option's letter (compatible with +older assemblers) or it may be the next command argument (GNU +standard). These two command lines are equivalent: + + as -o my-object-file.o mumble.s + as -omy-object-file.o mumble.s + + +File: as.info, Node: Input Files, Next: Object, Prev: Command Line, Up: Overview + +Input Files +=========== + + We use the phrase "source program", abbreviated "source", to +describe the program input to one run of `as'. The program may be in +one or more files; how the source is partitioned into files doesn't +change the meaning of the source. + + The source program is a concatenation of the text in all the files, +in the order specified. + + Each time you run `as' it assembles exactly one source program. The +source program is made up of one or more files. (The standard input is +also a file.) + + You give `as' a command line that has zero or more input file names. +The input files are read (from left file name to right). A command +line argument (in any position) that has no special meaning is taken to +be an input file name. + + If you give `as' no file names it attempts to read one input file +from the `as' standard input, which is normally your terminal. You may +have to type <ctl-D> to tell `as' there is no more program to assemble. + + Use `--' if you need to explicitly name the standard input file in +your command line. + + If the source is empty, `as' produces a small, empty object file. + +Filenames and Line-numbers +-------------------------- + + There are two ways of locating a line in the input file (or files) +and either may be used in reporting error messages. One way refers to +a line number in a physical file; the other refers to a line number in a +"logical" file. *Note Error and Warning Messages: Errors. + + "Physical files" are those files named in the command line given to +`as'. + + "Logical files" are simply names declared explicitly by assembler +directives; they bear no relation to physical files. Logical file +names help error messages reflect the original source file, when `as' +source is itself synthesized from other files. `as' understands the +`#' directives emitted by the `gcc' preprocessor. See also *Note +`.file': File. + + +File: as.info, Node: Object, Next: Errors, Prev: Input Files, Up: Overview + +Output (Object) File +==================== + + Every time you run `as' it produces an output file, which is your +assembly language program translated into numbers. This file is the +object file. Its default name is `a.out', or `b.out' when `as' is +configured for the Intel 80960. You can give it another name by using +the `-o' option. Conventionally, object file names end with `.o'. The +default name is used for historical reasons: older assemblers were +capable of assembling self-contained programs directly into a runnable +program. (For some formats, this isn't currently possible, but it can +be done for the `a.out' format.) + + The object file is meant for input to the linker `ld'. It contains +assembled program code, information to help `ld' integrate the +assembled program into a runnable file, and (optionally) symbolic +information for the debugger. + + +File: as.info, Node: Errors, Prev: Object, Up: Overview + +Error and Warning Messages +========================== + + `as' may write warnings and error messages to the standard error +file (usually your terminal). This should not happen when a compiler +runs `as' automatically. Warnings report an assumption made so that +`as' could keep assembling a flawed program; errors report a grave +problem that stops the assembly. + + Warning messages have the format + + file_name:NNN:Warning Message Text + +(where NNN is a line number). If a logical file name has been given +(*note `.file': File.) it is used for the filename, otherwise the name +of the current input file is used. If a logical line number was given +(*note `.line': Line.) then it is used to calculate the number printed, +otherwise the actual line in the current source file is printed. The +message text is intended to be self explanatory (in the grand Unix +tradition). + + Error messages have the format + file_name:NNN:FATAL:Error Message Text + The file name and line number are derived as for warning messages. +The actual message text may be rather less explanatory because many of +them aren't supposed to happen. + + +File: as.info, Node: Invoking, Next: Syntax, Prev: Overview, Up: Top + +Command-Line Options +******************** + + This chapter describes command-line options available in _all_ +versions of the GNU assembler; *note Machine Dependencies::, for +options specific to particular machine architectures. + + If you are invoking `as' via the GNU C compiler (version 2), you can +use the `-Wa' option to pass arguments through to the assembler. The +assembler arguments must be separated from each other (and the `-Wa') +by commas. For example: + + gcc -c -g -O -Wa,-alh,-L file.c + +This passes two options to the assembler: `-alh' (emit a listing to +standard output with with high-level and assembly source) and `-L' +(retain local symbols in the symbol table). + + Usually you do not need to use this `-Wa' mechanism, since many +compiler command-line options are automatically passed to the assembler +by the compiler. (You can call the GNU compiler driver with the `-v' +option to see precisely what options it passes to each compilation +pass, including the assembler.) + +* Menu: + +* a:: -a[cdhlns] enable listings +* D:: -D for compatibility +* f:: -f to work faster +* I:: -I for .include search path + +* K:: -K for difference tables + +* L:: -L to retain local labels +* M:: -M or --mri to assemble in MRI compatibility mode +* MD:: --MD for dependency tracking +* o:: -o to name the object file +* R:: -R to join data and text sections +* statistics:: --statistics to see statistics about assembly +* traditional-format:: --traditional-format for compatible output +* v:: -v to announce version +* W:: -W, --no-warn, --warn, --fatal-warnings to control warnings +* Z:: -Z to make object file even after errors + + +File: as.info, Node: a, Next: D, Up: Invoking + +Enable Listings: `-a[cdhlns]' +============================= + + These options enable listing output from the assembler. By itself, +`-a' requests high-level, assembly, and symbols listing. You can use +other letters to select specific options for the list: `-ah' requests a +high-level language listing, `-al' requests an output-program assembly +listing, and `-as' requests a symbol table listing. High-level +listings require that a compiler debugging option like `-g' be used, +and that assembly listings (`-al') be requested also. + + Use the `-ac' option to omit false conditionals from a listing. Any +lines which are not assembled because of a false `.if' (or `.ifdef', or +any other conditional), or a true `.if' followed by an `.else', will be +omitted from the listing. + + Use the `-ad' option to omit debugging directives from the listing. + + Once you have specified one of these options, you can further control +listing output and its appearance using the directives `.list', +`.nolist', `.psize', `.eject', `.title', and `.sbttl'. The `-an' +option turns off all forms processing. If you do not request listing +output with one of the `-a' options, the listing-control directives +have no effect. + + The letters after `-a' may be combined into one option, _e.g._, +`-aln'. + + +File: as.info, Node: D, Next: f, Prev: a, Up: Invoking + +`-D' +==== + + This option has no effect whatsoever, but it is accepted to make it +more likely that scripts written for other assemblers also work with +`as'. + + +File: as.info, Node: f, Next: I, Prev: D, Up: Invoking + +Work Faster: `-f' +================= + + `-f' should only be used when assembling programs written by a +(trusted) compiler. `-f' stops the assembler from doing whitespace and +comment preprocessing on the input file(s) before assembling them. +*Note Preprocessing: Preprocessing. + + _Warning:_ if you use `-f' when the files actually need to be + preprocessed (if they contain comments, for example), `as' does + not work correctly. + + +File: as.info, Node: I, Next: K, Prev: f, Up: Invoking + +`.include' search path: `-I' PATH +================================= + + Use this option to add a PATH to the list of directories `as' +searches for files specified in `.include' directives (*note +`.include': Include.). You may use `-I' as many times as necessary to +include a variety of paths. The current working directory is always +searched first; after that, `as' searches any `-I' directories in the +same order as they were specified (left to right) on the command line. + + +File: as.info, Node: K, Next: L, Prev: I, Up: Invoking + +Difference Tables: `-K' +======================= + + `as' sometimes alters the code emitted for directives of the form +`.word SYM1-SYM2'; *note `.word': Word.. You can use the `-K' option +if you want a warning issued when this is done. + + +File: as.info, Node: L, Next: M, Prev: K, Up: Invoking + +Include Local Labels: `-L' +========================== + + Labels beginning with `L' (upper case only) are called "local +labels". *Note Symbol Names::. Normally you do not see such labels when +debugging, because they are intended for the use of programs (like +compilers) that compose assembler programs, not for your notice. +Normally both `as' and `ld' discard such labels, so you do not normally +debug with them. + + This option tells `as' to retain those `L...' symbols in the object +file. Usually if you do this you also tell the linker `ld' to preserve +symbols whose names begin with `L'. + + By default, a local label is any label beginning with `L', but each +target is allowed to redefine the local label prefix. On the HPPA +local labels begin with `L$'. `;' for the ARM family; + + +File: as.info, Node: M, Next: MD, Prev: L, Up: Invoking + +Assemble in MRI Compatibility Mode: `-M' +======================================== + + The `-M' or `--mri' option selects MRI compatibility mode. This +changes the syntax and pseudo-op handling of `as' to make it compatible +with the `ASM68K' or the `ASM960' (depending upon the configured +target) assembler from Microtec Research. The exact nature of the MRI +syntax will not be documented here; see the MRI manuals for more +information. Note in particular that the handling of macros and macro +arguments is somewhat different. The purpose of this option is to +permit assembling existing MRI assembler code using `as'. + + The MRI compatibility is not complete. Certain operations of the +MRI assembler depend upon its object file format, and can not be +supported using other object file formats. Supporting these would +require enhancing each object file format individually. These are: + + * global symbols in common section + + The m68k MRI assembler supports common sections which are merged + by the linker. Other object file formats do not support this. + `as' handles common sections by treating them as a single common + symbol. It permits local symbols to be defined within a common + section, but it can not support global symbols, since it has no + way to describe them. + + * complex relocations + + The MRI assemblers support relocations against a negated section + address, and relocations which combine the start addresses of two + or more sections. These are not support by other object file + formats. + + * `END' pseudo-op specifying start address + + The MRI `END' pseudo-op permits the specification of a start + address. This is not supported by other object file formats. The + start address may instead be specified using the `-e' option to + the linker, or in a linker script. + + * `IDNT', `.ident' and `NAME' pseudo-ops + + The MRI `IDNT', `.ident' and `NAME' pseudo-ops assign a module + name to the output file. This is not supported by other object + file formats. + + * `ORG' pseudo-op + + The m68k MRI `ORG' pseudo-op begins an absolute section at a given + address. This differs from the usual `as' `.org' pseudo-op, which + changes the location within the current section. Absolute + sections are not supported by other object file formats. The + address of a section may be assigned within a linker script. + + There are some other features of the MRI assembler which are not +supported by `as', typically either because they are difficult or +because they seem of little consequence. Some of these may be +supported in future releases. + + * EBCDIC strings + + EBCDIC strings are not supported. + + * packed binary coded decimal + + Packed binary coded decimal is not supported. This means that the + `DC.P' and `DCB.P' pseudo-ops are not supported. + + * `FEQU' pseudo-op + + The m68k `FEQU' pseudo-op is not supported. + + * `NOOBJ' pseudo-op + + The m68k `NOOBJ' pseudo-op is not supported. + + * `OPT' branch control options + + The m68k `OPT' branch control options--`B', `BRS', `BRB', `BRL', + and `BRW'--are ignored. `as' automatically relaxes all branches, + whether forward or backward, to an appropriate size, so these + options serve no purpose. + + * `OPT' list control options + + The following m68k `OPT' list control options are ignored: `C', + `CEX', `CL', `CRE', `E', `G', `I', `M', `MEX', `MC', `MD', `X'. + + * other `OPT' options + + The following m68k `OPT' options are ignored: `NEST', `O', `OLD', + `OP', `P', `PCO', `PCR', `PCS', `R'. + + * `OPT' `D' option is default + + The m68k `OPT' `D' option is the default, unlike the MRI assembler. + `OPT NOD' may be used to turn it off. + + * `XREF' pseudo-op. + + The m68k `XREF' pseudo-op is ignored. + + * `.debug' pseudo-op + + The i960 `.debug' pseudo-op is not supported. + + * `.extended' pseudo-op + + The i960 `.extended' pseudo-op is not supported. + + * `.list' pseudo-op. + + The various options of the i960 `.list' pseudo-op are not + supported. + + * `.optimize' pseudo-op + + The i960 `.optimize' pseudo-op is not supported. + + * `.output' pseudo-op + + The i960 `.output' pseudo-op is not supported. + + * `.setreal' pseudo-op + + The i960 `.setreal' pseudo-op is not supported. + + + +File: as.info, Node: MD, Next: o, Prev: M, Up: Invoking + +Dependency tracking: `--MD' +=========================== + + `as' can generate a dependency file for the file it creates. This +file consists of a single rule suitable for `make' describing the +dependencies of the main source file. + + The rule is written to the file named in its argument. + + This feature is used in the automatic updating of makefiles. + + +File: as.info, Node: o, Next: R, Prev: MD, Up: Invoking + +Name the Object File: `-o' +========================== + + There is always one object file output when you run `as'. By +default it has the name `a.out' (or `b.out', for Intel 960 targets +only). You use this option (which takes exactly one filename) to give +the object file a different name. + + Whatever the object file is called, `as' overwrites any existing +file of the same name. + + +File: as.info, Node: R, Next: statistics, Prev: o, Up: Invoking + +Join Data and Text Sections: `-R' +================================= + + `-R' tells `as' to write the object file as if all data-section data +lives in the text section. This is only done at the very last moment: +your binary data are the same, but data section parts are relocated +differently. The data section part of your object file is zero bytes +long because all its bytes are appended to the text section. (*Note +Sections and Relocation: Sections.) + + When you specify `-R' it would be possible to generate shorter +address displacements (because we do not have to cross between text and +data section). We refrain from doing this simply for compatibility with +older versions of `as'. In future, `-R' may work this way. + + When `as' is configured for COFF output, this option is only useful +if you use sections named `.text' and `.data'. + + `-R' is not supported for any of the HPPA targets. Using `-R' +generates a warning from `as'. + + +File: as.info, Node: statistics, Next: traditional-format, Prev: R, Up: Invoking + +Display Assembly Statistics: `--statistics' +=========================================== + + Use `--statistics' to display two statistics about the resources +used by `as': the maximum amount of space allocated during the assembly +(in bytes), and the total execution time taken for the assembly (in CPU +seconds). + + +File: as.info, Node: traditional-format, Next: v, Prev: statistics, Up: Invoking + +Compatible output: `--traditional-format' +========================================= + + For some targets, the output of `as' is different in some ways from +the output of some existing assembler. This switch requests `as' to +use the traditional format instead. + + For example, it disables the exception frame optimizations which +`as' normally does by default on `gcc' output. + + +File: as.info, Node: v, Next: W, Prev: traditional-format, Up: Invoking + +Announce Version: `-v' +====================== + + You can find out what version of as is running by including the +option `-v' (which you can also spell as `-version') on the command +line. + + +File: as.info, Node: W, Next: Z, Prev: v, Up: Invoking + +Control Warnings: `-W', `--warn', `--no-warn', `--fatal-warnings' +================================================================= + + `as' should never give a warning or error message when assembling +compiler output. But programs written by people often cause `as' to +give a warning that a particular assumption was made. All such +warnings are directed to the standard error file. + + If you use the `-W' and `--no-warn' options, no warnings are issued. +This only affects the warning messages: it does not change any +particular of how `as' assembles your file. Errors, which stop the +assembly, are still reported. + + If you use the `--fatal-warnings' option, `as' considers files that +generate warnings to be in error. + + You can switch these options off again by specifying `--warn', which +causes warnings to be output as usual. + + +File: as.info, Node: Z, Prev: W, Up: Invoking + +Generate Object File in Spite of Errors: `-Z' +============================================= + + After an error message, `as' normally produces no output. If for +some reason you are interested in object file output even after `as' +gives an error message on your program, use the `-Z' option. If there +are any errors, `as' continues anyways, and writes an object file after +a final warning message of the form `N errors, M warnings, generating +bad object file.' + + +File: as.info, Node: Syntax, Next: Sections, Prev: Invoking, Up: Top + +Syntax +****** + + This chapter describes the machine-independent syntax allowed in a +source file. `as' syntax is similar to what many other assemblers use; +it is inspired by the BSD 4.2 assembler, except that `as' does not +assemble Vax bit-fields. + +* Menu: + +* Preprocessing:: Preprocessing +* Whitespace:: Whitespace +* Comments:: Comments +* Symbol Intro:: Symbols +* Statements:: Statements +* Constants:: Constants + + +File: as.info, Node: Preprocessing, Next: Whitespace, Up: Syntax + +Preprocessing +============= + + The `as' internal preprocessor: + * adjusts and removes extra whitespace. It leaves one space or tab + before the keywords on a line, and turns any other whitespace on + the line into a single space. + + * removes all comments, replacing them with a single space, or an + appropriate number of newlines. + + * converts character constants into the appropriate numeric values. + + It does not do macro processing, include file handling, or anything +else you may get from your C compiler's preprocessor. You can do +include file processing with the `.include' directive (*note +`.include': Include.). You can use the GNU C compiler driver to get +other "CPP" style preprocessing, by giving the input file a `.S' +suffix. *Note Options Controlling the Kind of Output: +(gcc.info)Overall Options. + + Excess whitespace, comments, and character constants cannot be used +in the portions of the input text that are not preprocessed. + + If the first line of an input file is `#NO_APP' or if you use the +`-f' option, whitespace and comments are not removed from the input +file. Within an input file, you can ask for whitespace and comment +removal in specific portions of the by putting a line that says `#APP' +before the text that may contain whitespace or comments, and putting a +line that says `#NO_APP' after this text. This feature is mainly +intend to support `asm' statements in compilers whose output is +otherwise free of comments and whitespace. + + +File: as.info, Node: Whitespace, Next: Comments, Prev: Preprocessing, Up: Syntax + +Whitespace +========== + + "Whitespace" is one or more blanks or tabs, in any order. +Whitespace is used to separate symbols, and to make programs neater for +people to read. Unless within character constants (*note Character +Constants: Characters.), any whitespace means the same as exactly one +space. + + +File: as.info, Node: Comments, Next: Symbol Intro, Prev: Whitespace, Up: Syntax + +Comments +======== + + There are two ways of rendering comments to `as'. In both cases the +comment is equivalent to one space. + + Anything from `/*' through the next `*/' is a comment. This means +you may not nest these comments. + + /* + The only way to include a newline ('\n') in a comment + is to use this sort of comment. + */ + + /* This sort of comment does not nest. */ + + Anything from the "line comment" character to the next newline is +considered a comment and is ignored. The line comment character is `;' +for the AMD 29K family; `;' on the ARC; `@' on the ARM; `;' for the +H8/300 family; `!' for the H8/500 family; `;' for the HPPA; `#' on the +i960; `;' for picoJava; `!' for the Hitachi SH; `!' on the SPARC; `#' +on the m32r; `|' on the 680x0; `#' on the Vax; `!' for the Z8000; `#' +on the V850; see *Note Machine Dependencies::. + + On some machines there are two different line comment characters. +One character only begins a comment if it is the first non-whitespace +character on a line, while the other always begins a comment. + + The V850 assembler also supports a double dash as starting a comment +that extends to the end of the line. + + `--'; + + To be compatible with past assemblers, lines that begin with `#' +have a special interpretation. Following the `#' should be an absolute +expression (*note Expressions::): the logical line number of the _next_ +line. Then a string (*note Strings: Strings.) is allowed: if present +it is a new logical file name. The rest of the line, if any, should be +whitespace. + + If the first non-whitespace characters on the line are not numeric, +the line is ignored. (Just like a comment.) + + # This is an ordinary comment. + # 42-6 "new_file_name" # New logical file name + # This is logical line # 36. + This feature is deprecated, and may disappear from future versions +of `as'. + + +File: as.info, Node: Symbol Intro, Next: Statements, Prev: Comments, Up: Syntax + +Symbols +======= + + A "symbol" is one or more characters chosen from the set of all +letters (both upper and lower case), digits and the three characters +`_.$'. On most machines, you can also use `$' in symbol names; +exceptions are noted in *Note Machine Dependencies::. No symbol may +begin with a digit. Case is significant. There is no length limit: +all characters are significant. Symbols are delimited by characters +not in that set, or by the beginning of a file (since the source +program must end with a newline, the end of a file is not a possible +symbol delimiter). *Note Symbols::. + + +File: as.info, Node: Statements, Next: Constants, Prev: Symbol Intro, Up: Syntax + +Statements +========== + + A "statement" ends at a newline character (`\n') or line separator +character. (The line separator is usually `;', unless this conflicts +with the comment character; *note Machine Dependencies::.) The newline +or separator character is considered part of the preceding statement. +Newlines and separators within character constants are an exception: +they do not end statements. + + It is an error to end any statement with end-of-file: the last +character of any input file should be a newline. + + An empty statement is allowed, and may include whitespace. It is +ignored. + + A statement begins with zero or more labels, optionally followed by a +key symbol which determines what kind of statement it is. The key +symbol determines the syntax of the rest of the statement. If the +symbol begins with a dot `.' then the statement is an assembler +directive: typically valid for any computer. If the symbol begins with +a letter the statement is an assembly language "instruction": it +assembles into a machine language instruction. Different versions of +`as' for different computers recognize different instructions. In +fact, the same symbol may represent a different instruction in a +different computer's assembly language. + + A label is a symbol immediately followed by a colon (`:'). +Whitespace before a label or after a colon is permitted, but you may not +have whitespace between a label's symbol and its colon. *Note Labels::. + + For HPPA targets, labels need not be immediately followed by a +colon, but the definition of a label must begin in column zero. This +also implies that only one label may be defined on each line. + + label: .directive followed by something + another_label: # This is an empty statement. + instruction operand_1, operand_2, ... + + +File: as.info, Node: Constants, Prev: Statements, Up: Syntax + +Constants +========= + + A constant is a number, written so that its value is known by +inspection, without knowing any context. Like this: + .byte 74, 0112, 092, 0x4A, 0X4a, 'J, '\J # All the same value. + .ascii "Ring the bell\7" # A string constant. + .octa 0x123456789abcdef0123456789ABCDEF0 # A bignum. + .float 0f-314159265358979323846264338327\ + 95028841971.693993751E-40 # - pi, a flonum. + +* Menu: + +* Characters:: Character Constants +* Numbers:: Number Constants + + +File: as.info, Node: Characters, Next: Numbers, Up: Constants + +Character Constants +------------------- + + There are two kinds of character constants. A "character" stands +for one character in one byte and its value may be used in numeric +expressions. String constants (properly called string _literals_) are +potentially many bytes and their values may not be used in arithmetic +expressions. + +* Menu: + +* Strings:: Strings +* Chars:: Characters + + +File: as.info, Node: Strings, Next: Chars, Up: Characters + +Strings +....... + + A "string" is written between double-quotes. It may contain +double-quotes or null characters. The way to get special characters +into a string is to "escape" these characters: precede them with a +backslash `\' character. For example `\\' represents one backslash: +the first `\' is an escape which tells `as' to interpret the second +character literally as a backslash (which prevents `as' from +recognizing the second `\' as an escape character). The complete list +of escapes follows. + +`\b' + Mnemonic for backspace; for ASCII this is octal code 010. + +`\f' + Mnemonic for FormFeed; for ASCII this is octal code 014. + +`\n' + Mnemonic for newline; for ASCII this is octal code 012. + +`\r' + Mnemonic for carriage-Return; for ASCII this is octal code 015. + +`\t' + Mnemonic for horizontal Tab; for ASCII this is octal code 011. + +`\ DIGIT DIGIT DIGIT' + An octal character code. The numeric code is 3 octal digits. For + compatibility with other Unix systems, 8 and 9 are accepted as + digits: for example, `\008' has the value 010, and `\009' the + value 011. + +`\`x' HEX-DIGITS...' + A hex character code. All trailing hex digits are combined. + Either upper or lower case `x' works. + +`\\' + Represents one `\' character. + +`\"' + Represents one `"' character. Needed in strings to represent this + character, because an unescaped `"' would end the string. + +`\ ANYTHING-ELSE' + Any other character when escaped by `\' gives a warning, but + assembles as if the `\' was not present. The idea is that if you + used an escape sequence you clearly didn't want the literal + interpretation of the following character. However `as' has no + other interpretation, so `as' knows it is giving you the wrong + code and warns you of the fact. + + Which characters are escapable, and what those escapes represent, +varies widely among assemblers. The current set is what we think the +BSD 4.2 assembler recognizes, and is a subset of what most C compilers +recognize. If you are in doubt, do not use an escape sequence. + + +File: as.info, Node: Chars, Prev: Strings, Up: Characters + +Characters +.......... + + A single character may be written as a single quote immediately +followed by that character. The same escapes apply to characters as to +strings. So if you want to write the character backslash, you must +write `'\\' where the first `\' escapes the second `\'. As you can +see, the quote is an acute accent, not a grave accent. A newline +immediately following an acute accent is taken as a literal character +and does not count as the end of a statement. The value of a character +constant in a numeric expression is the machine's byte-wide code for +that character. `as' assumes your character code is ASCII: `'A' means +65, `'B' means 66, and so on. + + +File: as.info, Node: Numbers, Prev: Characters, Up: Constants + +Number Constants +---------------- + + `as' distinguishes three kinds of numbers according to how they are +stored in the target machine. _Integers_ are numbers that would fit +into an `int' in the C language. _Bignums_ are integers, but they are +stored in more than 32 bits. _Flonums_ are floating point numbers, +described below. + +* Menu: + +* Integers:: Integers +* Bignums:: Bignums +* Flonums:: Flonums + + +File: as.info, Node: Integers, Next: Bignums, Up: Numbers + +Integers +........ + + A binary integer is `0b' or `0B' followed by zero or more of the +binary digits `01'. + + An octal integer is `0' followed by zero or more of the octal digits +(`01234567'). + + A decimal integer starts with a non-zero digit followed by zero or +more digits (`0123456789'). + + A hexadecimal integer is `0x' or `0X' followed by one or more +hexadecimal digits chosen from `0123456789abcdefABCDEF'. + + Integers have the usual values. To denote a negative integer, use +the prefix operator `-' discussed under expressions (*note Prefix +Operators: Prefix Ops.). + + +File: as.info, Node: Bignums, Next: Flonums, Prev: Integers, Up: Numbers + +Bignums +....... + + A "bignum" has the same syntax and semantics as an integer except +that the number (or its negative) takes more than 32 bits to represent +in binary. The distinction is made because in some places integers are +permitted while bignums are not. + + +File: as.info, Node: Flonums, Prev: Bignums, Up: Numbers + +Flonums +....... + + A "flonum" represents a floating point number. The translation is +indirect: a decimal floating point number from the text is converted by +`as' to a generic binary floating point number of more than sufficient +precision. This generic floating point number is converted to a +particular computer's floating point format (or formats) by a portion +of `as' specialized to that computer. + + A flonum is written by writing (in order) + * The digit `0'. (`0' is optional on the HPPA.) + + * A letter, to tell `as' the rest of the number is a flonum. `e' is + recommended. Case is not important. + + On the H8/300, H8/500, Hitachi SH, and AMD 29K architectures, the + letter must be one of the letters `DFPRSX' (in upper or lower + case). + + On the ARC, the letter must be one of the letters `DFRS' (in upper + or lower case). + + On the Intel 960 architecture, the letter must be one of the + letters `DFT' (in upper or lower case). + + On the HPPA architecture, the letter must be `E' (upper case only). + + * An optional sign: either `+' or `-'. + + * An optional "integer part": zero or more decimal digits. + + * An optional "fractional part": `.' followed by zero or more + decimal digits. + + * An optional exponent, consisting of: + + * An `E' or `e'. + + * Optional sign: either `+' or `-'. + + * One or more decimal digits. + + + At least one of the integer part or the fractional part must be +present. The floating point number has the usual base-10 value. + + `as' does all processing using integers. Flonums are computed +independently of any floating point hardware in the computer running +`as'. + + +File: as.info, Node: Sections, Next: Symbols, Prev: Syntax, Up: Top + +Sections and Relocation +*********************** + +* Menu: + +* Secs Background:: Background +* Ld Sections:: Linker Sections +* As Sections:: Assembler Internal Sections +* Sub-Sections:: Sub-Sections +* bss:: bss Section + diff --git a/gas/doc/as.info-2 b/gas/doc/as.info-2 new file mode 100644 index 00000000000..1ef6f51221c --- /dev/null +++ b/gas/doc/as.info-2 @@ -0,0 +1,1391 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: Secs Background, Next: Ld Sections, Up: Sections + +Background +========== + + Roughly, a section is a range of addresses, with no gaps; all data +"in" those addresses is treated the same for some particular purpose. +For example there may be a "read only" section. + + The linker `ld' reads many object files (partial programs) and +combines their contents to form a runnable program. When `as' emits an +object file, the partial program is assumed to start at address 0. +`ld' assigns the final addresses for the partial program, so that +different partial programs do not overlap. This is actually an +oversimplification, but it suffices to explain how `as' uses sections. + + `ld' moves blocks of bytes of your program to their run-time +addresses. These blocks slide to their run-time addresses as rigid +units; their length does not change and neither does the order of bytes +within them. Such a rigid unit is called a _section_. Assigning +run-time addresses to sections is called "relocation". It includes the +task of adjusting mentions of object-file addresses so they refer to +the proper run-time addresses. For the H8/300 and H8/500, and for the +Hitachi SH, `as' pads sections if needed to ensure they end on a word +(sixteen bit) boundary. + + An object file written by `as' has at least three sections, any of +which may be empty. These are named "text", "data" and "bss" sections. + + When it generates COFF output, `as' can also generate whatever other +named sections you specify using the `.section' directive (*note +`.section': Section.). If you do not use any directives that place +output in the `.text' or `.data' sections, these sections still exist, +but are empty. + + When `as' generates SOM or ELF output for the HPPA, `as' can also +generate whatever other named sections you specify using the `.space' +and `.subspace' directives. See `HP9000 Series 800 Assembly Language +Reference Manual' (HP 92432-90001) for details on the `.space' and +`.subspace' assembler directives. + + Additionally, `as' uses different names for the standard text, data, +and bss sections when generating SOM output. Program text is placed +into the `$CODE$' section, data into `$DATA$', and BSS into `$BSS$'. + + Within the object file, the text section starts at address `0', the +data section follows, and the bss section follows the data section. + + When generating either SOM or ELF output files on the HPPA, the text +section starts at address `0', the data section at address `0x4000000', +and the bss section follows the data section. + + To let `ld' know which data changes when the sections are relocated, +and how to change that data, `as' also writes to the object file +details of the relocation needed. To perform relocation `ld' must +know, each time an address in the object file is mentioned: + * Where in the object file is the beginning of this reference to an + address? + + * How long (in bytes) is this reference? + + * Which section does the address refer to? What is the numeric + value of + (ADDRESS) - (START-ADDRESS OF SECTION)? + + * Is the reference to an address "Program-Counter relative"? + + In fact, every address `as' ever uses is expressed as + (SECTION) + (OFFSET INTO SECTION) + +Further, most expressions `as' computes have this section-relative +nature. (For some object formats, such as SOM for the HPPA, some +expressions are symbol-relative instead.) + + In this manual we use the notation {SECNAME N} to mean "offset N +into section SECNAME." + + Apart from text, data and bss sections you need to know about the +"absolute" section. When `ld' mixes partial programs, addresses in the +absolute section remain unchanged. For example, address `{absolute 0}' +is "relocated" to run-time address 0 by `ld'. Although the linker +never arranges two partial programs' data sections with overlapping +addresses after linking, _by definition_ their absolute sections must +overlap. Address `{absolute 239}' in one part of a program is always +the same address when the program is running as address `{absolute +239}' in any other part of the program. + + The idea of sections is extended to the "undefined" section. Any +address whose section is unknown at assembly time is by definition +rendered {undefined U}--where U is filled in later. Since numbers are +always defined, the only way to generate an undefined address is to +mention an undefined symbol. A reference to a named common block would +be such a symbol: its value is unknown at assembly time so it has +section _undefined_. + + By analogy the word _section_ is used to describe groups of sections +in the linked program. `ld' puts all partial programs' text sections +in contiguous addresses in the linked program. It is customary to +refer to the _text section_ of a program, meaning all the addresses of +all partial programs' text sections. Likewise for data and bss +sections. + + Some sections are manipulated by `ld'; others are invented for use +of `as' and have no meaning except during assembly. + + +File: as.info, Node: Ld Sections, Next: As Sections, Prev: Secs Background, Up: Sections + +Linker Sections +=============== + + `ld' deals with just four kinds of sections, summarized below. + +*named sections* +*text section* +*data section* + These sections hold your program. `as' and `ld' treat them as + separate but equal sections. Anything you can say of one section + is true another. When the program is running, however, it is + customary for the text section to be unalterable. The text + section is often shared among processes: it contains instructions, + constants and the like. The data section of a running program is + usually alterable: for example, C variables would be stored in the + data section. + +*bss section* + This section contains zeroed bytes when your program begins + running. It is used to hold unitialized variables or common + storage. The length of each partial program's bss section is + important, but because it starts out containing zeroed bytes there + is no need to store explicit zero bytes in the object file. The + bss section was invented to eliminate those explicit zeros from + object files. + +*absolute section* + Address 0 of this section is always "relocated" to runtime address + 0. This is useful if you want to refer to an address that `ld' + must not change when relocating. In this sense we speak of + absolute addresses being "unrelocatable": they do not change + during relocation. + +*undefined section* + This "section" is a catch-all for address references to objects + not in the preceding sections. + + An idealized example of three relocatable sections follows. The +example uses the traditional section names `.text' and `.data'. Memory +addresses are on the horizontal axis. + + +-----+----+--+ + partial program # 1: |ttttt|dddd|00| + +-----+----+--+ + + text data bss + seg. seg. seg. + + +---+---+---+ + partial program # 2: |TTT|DDD|000| + +---+---+---+ + + +--+---+-----+--+----+---+-----+~~ + linked program: | |TTT|ttttt| |dddd|DDD|00000| + +--+---+-----+--+----+---+-----+~~ + + addresses: 0 ... + + +File: as.info, Node: As Sections, Next: Sub-Sections, Prev: Ld Sections, Up: Sections + +Assembler Internal Sections +=========================== + + These sections are meant only for the internal use of `as'. They +have no meaning at run-time. You do not really need to know about these +sections for most purposes; but they can be mentioned in `as' warning +messages, so it might be helpful to have an idea of their meanings to +`as'. These sections are used to permit the value of every expression +in your assembly language program to be a section-relative address. + +ASSEMBLER-INTERNAL-LOGIC-ERROR! + An internal assembler logic error has been found. This means + there is a bug in the assembler. + +expr section + The assembler stores complex expression internally as combinations + of symbols. When it needs to represent an expression as a symbol, + it puts it in the expr section. + + +File: as.info, Node: Sub-Sections, Next: bss, Prev: As Sections, Up: Sections + +Sub-Sections +============ + + Assembled bytes conventionally fall into two sections: text and data. +You may have separate groups of data in named sections that you want to +end up near to each other in the object file, even though they are not +contiguous in the assembler source. `as' allows you to use +"subsections" for this purpose. Within each section, there can be +numbered subsections with values from 0 to 8192. Objects assembled +into the same subsection go into the object file together with other +objects in the same subsection. For example, a compiler might want to +store constants in the text section, but might not want to have them +interspersed with the program being assembled. In this case, the +compiler could issue a `.text 0' before each section of code being +output, and a `.text 1' before each group of constants being output. + + Subsections are optional. If you do not use subsections, everything +goes in subsection number zero. + + Each subsection is zero-padded up to a multiple of four bytes. +(Subsections may be padded a different amount on different flavors of +`as'.) + + Subsections appear in your object file in numeric order, lowest +numbered to highest. (All this to be compatible with other people's +assemblers.) The object file contains no representation of +subsections; `ld' and other programs that manipulate object files see +no trace of them. They just see all your text subsections as a text +section, and all your data subsections as a data section. + + To specify which subsection you want subsequent statements assembled +into, use a numeric argument to specify it, in a `.text EXPRESSION' or +a `.data EXPRESSION' statement. When generating COFF output, you can +also use an extra subsection argument with arbitrary named sections: +`.section NAME, EXPRESSION'. EXPRESSION should be an absolute +expression. (*Note Expressions::.) If you just say `.text' then +`.text 0' is assumed. Likewise `.data' means `.data 0'. Assembly +begins in `text 0'. For instance: + .text 0 # The default subsection is text 0 anyway. + .ascii "This lives in the first text subsection. *" + .text 1 + .ascii "But this lives in the second text subsection." + .data 0 + .ascii "This lives in the data section," + .ascii "in the first data subsection." + .text 0 + .ascii "This lives in the first text section," + .ascii "immediately following the asterisk (*)." + + Each section has a "location counter" incremented by one for every +byte assembled into that section. Because subsections are merely a +convenience restricted to `as' there is no concept of a subsection +location counter. There is no way to directly manipulate a location +counter--but the `.align' directive changes it, and any label +definition captures its current value. The location counter of the +section where statements are being assembled is said to be the "active" +location counter. + + +File: as.info, Node: bss, Prev: Sub-Sections, Up: Sections + +bss Section +=========== + + The bss section is used for local common variable storage. You may +allocate address space in the bss section, but you may not dictate data +to load into it before your program executes. When your program starts +running, all the contents of the bss section are zeroed bytes. + + The `.lcomm' pseudo-op defines a symbol in the bss section; see +*Note `.lcomm': Lcomm. + + The `.comm' pseudo-op may be used to declare a common symbol, which +is another form of uninitialized symbol; see *Note `.comm': Comm. + + When assembling for a target which supports multiple sections, such +as ELF or COFF, you may switch into the `.bss' section and define +symbols as usual; see *Note `.section': Section. You may only assemble +zero values into the section. Typically the section will only contain +symbol definitions and `.skip' directives (*note `.skip': Skip.). + + +File: as.info, Node: Symbols, Next: Expressions, Prev: Sections, Up: Top + +Symbols +******* + + Symbols are a central concept: the programmer uses symbols to name +things, the linker uses symbols to link, and the debugger uses symbols +to debug. + + _Warning:_ `as' does not place symbols in the object file in the + same order they were declared. This may break some debuggers. + +* Menu: + +* Labels:: Labels +* Setting Symbols:: Giving Symbols Other Values +* Symbol Names:: Symbol Names +* Dot:: The Special Dot Symbol +* Symbol Attributes:: Symbol Attributes + + +File: as.info, Node: Labels, Next: Setting Symbols, Up: Symbols + +Labels +====== + + A "label" is written as a symbol immediately followed by a colon +`:'. The symbol then represents the current value of the active +location counter, and is, for example, a suitable instruction operand. +You are warned if you use the same symbol to represent two different +locations: the first definition overrides any other definitions. + + On the HPPA, the usual form for a label need not be immediately +followed by a colon, but instead must start in column zero. Only one +label may be defined on a single line. To work around this, the HPPA +version of `as' also provides a special directive `.label' for defining +labels more flexibly. + + +File: as.info, Node: Setting Symbols, Next: Symbol Names, Prev: Labels, Up: Symbols + +Giving Symbols Other Values +=========================== + + A symbol can be given an arbitrary value by writing a symbol, +followed by an equals sign `=', followed by an expression (*note +Expressions::). This is equivalent to using the `.set' directive. +*Note `.set': Set. + + +File: as.info, Node: Symbol Names, Next: Dot, Prev: Setting Symbols, Up: Symbols + +Symbol Names +============ + + Symbol names begin with a letter or with one of `._'. On most +machines, you can also use `$' in symbol names; exceptions are noted in +*Note Machine Dependencies::. That character may be followed by any +string of digits, letters, dollar signs (unless otherwise noted in +*Note Machine Dependencies::), and underscores. For the AMD 29K +family, `?' is also allowed in the body of a symbol name, though not at +its beginning. + + Case of letters is significant: `foo' is a different symbol name +than `Foo'. + + Each symbol has exactly one name. Each name in an assembly language +program refers to exactly one symbol. You may use that symbol name any +number of times in a program. + +Local Symbol Names +------------------ + + Local symbols help compilers and programmers use names temporarily. +There are ten local symbol names, which are re-used throughout the +program. You may refer to them using the names `0' `1' ... `9'. To +define a local symbol, write a label of the form `N:' (where N +represents any digit). To refer to the most recent previous definition +of that symbol write `Nb', using the same digit as when you defined the +label. To refer to the next definition of a local label, write +`Nf'--where N gives you a choice of 10 forward references. The `b' +stands for "backwards" and the `f' stands for "forwards". + + Local symbols are not emitted by the current GNU C compiler. + + There is no restriction on how you can use these labels, but +remember that at any point in the assembly you can refer to at most 10 +prior local labels and to at most 10 forward local labels. + + Local symbol names are only a notation device. They are immediately +transformed into more conventional symbol names before the assembler +uses them. The symbol names stored in the symbol table, appearing in +error messages and optionally emitted to the object file have these +parts: + +`L' + All local labels begin with `L'. Normally both `as' and `ld' + forget symbols that start with `L'. These labels are used for + symbols you are never intended to see. If you use the `-L' option + then `as' retains these symbols in the object file. If you also + instruct `ld' to retain these symbols, you may use them in + debugging. + +`DIGIT' + If the label is written `0:' then the digit is `0'. If the label + is written `1:' then the digit is `1'. And so on up through `9:'. + +`C-A' + This unusual character is included so you do not accidentally + invent a symbol of the same name. The character has ASCII value + `\001'. + +`_ordinal number_' + This is a serial number to keep the labels distinct. The first + `0:' gets the number `1'; The 15th `0:' gets the number `15'; + _etc._. Likewise for the other labels `1:' through `9:'. + + For instance, the first `1:' is named `L1C-A1', the 44th `3:' is +named `L3C-A44'. + + +File: as.info, Node: Dot, Next: Symbol Attributes, Prev: Symbol Names, Up: Symbols + +The Special Dot Symbol +====================== + + The special symbol `.' refers to the current address that `as' is +assembling into. Thus, the expression `melvin: .long .' defines +`melvin' to contain its own address. Assigning a value to `.' is +treated the same as a `.org' directive. Thus, the expression `.=.+4' +is the same as saying `.space 4'. + + +File: as.info, Node: Symbol Attributes, Prev: Dot, Up: Symbols + +Symbol Attributes +================= + + Every symbol has, as well as its name, the attributes "Value" and +"Type". Depending on output format, symbols can also have auxiliary +attributes. + + If you use a symbol without defining it, `as' assumes zero for all +these attributes, and probably won't warn you. This makes the symbol +an externally defined symbol, which is generally what you would want. + +* Menu: + +* Symbol Value:: Value +* Symbol Type:: Type + + +* a.out Symbols:: Symbol Attributes: `a.out' + +* COFF Symbols:: Symbol Attributes for COFF + +* SOM Symbols:: Symbol Attributes for SOM + + +File: as.info, Node: Symbol Value, Next: Symbol Type, Up: Symbol Attributes + +Value +----- + + The value of a symbol is (usually) 32 bits. For a symbol which +labels a location in the text, data, bss or absolute sections the value +is the number of addresses from the start of that section to the label. +Naturally for text, data and bss sections the value of a symbol changes +as `ld' changes section base addresses during linking. Absolute +symbols' values do not change during linking: that is why they are +called absolute. + + The value of an undefined symbol is treated in a special way. If it +is 0 then the symbol is not defined in this assembler source file, and +`ld' tries to determine its value from other files linked into the same +program. You make this kind of symbol simply by mentioning a symbol +name without defining it. A non-zero value represents a `.comm' common +declaration. The value is how much common storage to reserve, in bytes +(addresses). The symbol refers to the first address of the allocated +storage. + + +File: as.info, Node: Symbol Type, Next: a.out Symbols, Prev: Symbol Value, Up: Symbol Attributes + +Type +---- + + The type attribute of a symbol contains relocation (section) +information, any flag settings indicating that a symbol is external, and +(optionally), other information for linkers and debuggers. The exact +format depends on the object-code output format in use. + + +File: as.info, Node: a.out Symbols, Next: COFF Symbols, Prev: Symbol Type, Up: Symbol Attributes + +Symbol Attributes: `a.out' +-------------------------- + +* Menu: + +* Symbol Desc:: Descriptor +* Symbol Other:: Other + + +File: as.info, Node: Symbol Desc, Next: Symbol Other, Up: a.out Symbols + +Descriptor +.......... + + This is an arbitrary 16-bit value. You may establish a symbol's +descriptor value by using a `.desc' statement (*note `.desc': Desc.). +A descriptor value means nothing to `as'. + + +File: as.info, Node: Symbol Other, Prev: Symbol Desc, Up: a.out Symbols + +Other +..... + + This is an arbitrary 8-bit value. It means nothing to `as'. + + +File: as.info, Node: COFF Symbols, Next: SOM Symbols, Prev: a.out Symbols, Up: Symbol Attributes + +Symbol Attributes for COFF +-------------------------- + + The COFF format supports a multitude of auxiliary symbol attributes; +like the primary symbol attributes, they are set between `.def' and +`.endef' directives. + +Primary Attributes +.................. + + The symbol name is set with `.def'; the value and type, +respectively, with `.val' and `.type'. + +Auxiliary Attributes +.................... + + The `as' directives `.dim', `.line', `.scl', `.size', and `.tag' can +generate auxiliary symbol table information for COFF. + + +File: as.info, Node: SOM Symbols, Prev: COFF Symbols, Up: Symbol Attributes + +Symbol Attributes for SOM +------------------------- + + The SOM format for the HPPA supports a multitude of symbol +attributes set with the `.EXPORT' and `.IMPORT' directives. + + The attributes are described in `HP9000 Series 800 Assembly Language +Reference Manual' (HP 92432-90001) under the `IMPORT' and `EXPORT' +assembler directive documentation. + + +File: as.info, Node: Expressions, Next: Pseudo Ops, Prev: Symbols, Up: Top + +Expressions +*********** + + An "expression" specifies an address or numeric value. Whitespace +may precede and/or follow an expression. + + The result of an expression must be an absolute number, or else an +offset into a particular section. If an expression is not absolute, +and there is not enough information when `as' sees the expression to +know its section, a second pass over the source program might be +necessary to interpret the expression--but the second pass is currently +not implemented. `as' aborts with an error message in this situation. + +* Menu: + +* Empty Exprs:: Empty Expressions +* Integer Exprs:: Integer Expressions + + +File: as.info, Node: Empty Exprs, Next: Integer Exprs, Up: Expressions + +Empty Expressions +================= + + An empty expression has no value: it is just whitespace or null. +Wherever an absolute expression is required, you may omit the +expression, and `as' assumes a value of (absolute) 0. This is +compatible with other assemblers. + + +File: as.info, Node: Integer Exprs, Prev: Empty Exprs, Up: Expressions + +Integer Expressions +=================== + + An "integer expression" is one or more _arguments_ delimited by +_operators_. + +* Menu: + +* Arguments:: Arguments +* Operators:: Operators +* Prefix Ops:: Prefix Operators +* Infix Ops:: Infix Operators + + +File: as.info, Node: Arguments, Next: Operators, Up: Integer Exprs + +Arguments +--------- + + "Arguments" are symbols, numbers or subexpressions. In other +contexts arguments are sometimes called "arithmetic operands". In this +manual, to avoid confusing them with the "instruction operands" of the +machine language, we use the term "argument" to refer to parts of +expressions only, reserving the word "operand" to refer only to machine +instruction operands. + + Symbols are evaluated to yield {SECTION NNN} where SECTION is one of +text, data, bss, absolute, or undefined. NNN is a signed, 2's +complement 32 bit integer. + + Numbers are usually integers. + + A number can be a flonum or bignum. In this case, you are warned +that only the low order 32 bits are used, and `as' pretends these 32 +bits are an integer. You may write integer-manipulating instructions +that act on exotic constants, compatible with other assemblers. + + Subexpressions are a left parenthesis `(' followed by an integer +expression, followed by a right parenthesis `)'; or a prefix operator +followed by an argument. + + +File: as.info, Node: Operators, Next: Prefix Ops, Prev: Arguments, Up: Integer Exprs + +Operators +--------- + + "Operators" are arithmetic functions, like `+' or `%'. Prefix +operators are followed by an argument. Infix operators appear between +their arguments. Operators may be preceded and/or followed by +whitespace. + + +File: as.info, Node: Prefix Ops, Next: Infix Ops, Prev: Operators, Up: Integer Exprs + +Prefix Operator +--------------- + + `as' has the following "prefix operators". They each take one +argument, which must be absolute. + +`-' + "Negation". Two's complement negation. + +`~' + "Complementation". Bitwise not. + + +File: as.info, Node: Infix Ops, Prev: Prefix Ops, Up: Integer Exprs + +Infix Operators +--------------- + + "Infix operators" take two arguments, one on either side. Operators +have precedence, but operations with equal precedence are performed left +to right. Apart from `+' or `-', both arguments must be absolute, and +the result is absolute. + + 1. Highest Precedence + + `*' + "Multiplication". + + `/' + "Division". Truncation is the same as the C operator `/' + + `%' + "Remainder". + + `<' + `<<' + "Shift Left". Same as the C operator `<<'. + + `>' + `>>' + "Shift Right". Same as the C operator `>>'. + + 2. Intermediate precedence + + `|' + "Bitwise Inclusive Or". + + `&' + "Bitwise And". + + `^' + "Bitwise Exclusive Or". + + `!' + "Bitwise Or Not". + + 3. Lowest Precedence + + `+' + "Addition". If either argument is absolute, the result has + the section of the other argument. You may not add together + arguments from different sections. + + `-' + "Subtraction". If the right argument is absolute, the result + has the section of the left argument. If both arguments are + in the same section, the result is absolute. You may not + subtract arguments from different sections. + + In short, it's only meaningful to add or subtract the _offsets_ in an +address; you can only have a defined section in one of the two +arguments. + + +File: as.info, Node: Pseudo Ops, Next: Machine Dependencies, Prev: Expressions, Up: Top + +Assembler Directives +******************** + + All assembler directives have names that begin with a period (`.'). +The rest of the name is letters, usually in lower case. + + This chapter discusses directives that are available regardless of +the target machine configuration for the GNU assembler. Some machine +configurations provide additional directives. *Note Machine +Dependencies::. + +* Menu: + +* Abort:: `.abort' + +* ABORT:: `.ABORT' + +* Align:: `.align ABS-EXPR , ABS-EXPR' +* Ascii:: `.ascii "STRING"'... +* Asciz:: `.asciz "STRING"'... +* Balign:: `.balign ABS-EXPR , ABS-EXPR' +* Byte:: `.byte EXPRESSIONS' +* Comm:: `.comm SYMBOL , LENGTH ' +* Data:: `.data SUBSECTION' + +* Def:: `.def NAME' + +* Desc:: `.desc SYMBOL, ABS-EXPRESSION' + +* Dim:: `.dim' + +* Double:: `.double FLONUMS' +* Eject:: `.eject' +* Else:: `.else' +* Elseif:: `.elseif' +* End:: `.end' + +* Endef:: `.endef' + +* Endfunc:: `.endfunc' +* Endif:: `.endif' +* Equ:: `.equ SYMBOL, EXPRESSION' +* Equiv:: `.equiv SYMBOL, EXPRESSION' +* Err:: `.err' +* Exitm:: `.exitm' +* Extern:: `.extern' +* Fail:: `.fail' + +* File:: `.file STRING' + +* Fill:: `.fill REPEAT , SIZE , VALUE' +* Float:: `.float FLONUMS' +* Func:: `.func' +* Global:: `.global SYMBOL', `.globl SYMBOL' +* hword:: `.hword EXPRESSIONS' +* Ident:: `.ident' +* If:: `.if ABSOLUTE EXPRESSION' +* Include:: `.include "FILE"' +* Int:: `.int EXPRESSIONS' +* Irp:: `.irp SYMBOL,VALUES'... +* Irpc:: `.irpc SYMBOL,VALUES'... +* Lcomm:: `.lcomm SYMBOL , LENGTH' +* Lflags:: `.lflags' + +* Line:: `.line LINE-NUMBER' + +* Ln:: `.ln LINE-NUMBER' +* Linkonce:: `.linkonce [TYPE]' +* List:: `.list' +* Long:: `.long EXPRESSIONS' + +* Macro:: `.macro NAME ARGS'... +* MRI:: `.mri VAL' + +* Nolist:: `.nolist' +* Octa:: `.octa BIGNUMS' +* Org:: `.org NEW-LC , FILL' +* P2align:: `.p2align ABS-EXPR , ABS-EXPR' +* Print:: `.print STRING' +* Psize:: `.psize LINES, COLUMNS' +* Purgem:: `.purgem NAME' +* Quad:: `.quad BIGNUMS' +* Rept:: `.rept COUNT' +* Sbttl:: `.sbttl "SUBHEADING"' + +* Scl:: `.scl CLASS' +* Section:: `.section NAME, SUBSECTION' + +* Set:: `.set SYMBOL, EXPRESSION' +* Short:: `.short EXPRESSIONS' +* Single:: `.single FLONUMS' + +* Size:: `.size' + +* Skip:: `.skip SIZE , FILL' +* Sleb128:: `.sleb128 EXPRESSIONS' +* Space:: `.space SIZE , FILL' + +* Stab:: `.stabd, .stabn, .stabs' + +* String:: `.string "STR"' +* Struct:: `.struct EXPRESSION' + +* Symver:: `.symver NAME,NAME2@NODENAME' + +* Tag:: `.tag STRUCTNAME' + +* Text:: `.text SUBSECTION' +* Title:: `.title "HEADING"' + +* Type:: `.type INT' +* Val:: `.val ADDR' + +* Visibility:: `.internal NAME, .hidden NAME, .protected NAME' + +* Uleb128:: `.uleb128 EXPRESSIONS' +* Word:: `.word EXPRESSIONS' +* Deprecated:: Deprecated Directives + + +File: as.info, Node: Abort, Next: ABORT, Up: Pseudo Ops + +`.abort' +======== + + This directive stops the assembly immediately. It is for +compatibility with other assemblers. The original idea was that the +assembly language source would be piped into the assembler. If the +sender of the source quit, it could use this directive tells `as' to +quit also. One day `.abort' will not be supported. + + +File: as.info, Node: ABORT, Next: Align, Prev: Abort, Up: Pseudo Ops + +`.ABORT' +======== + + When producing COFF output, `as' accepts this directive as a synonym +for `.abort'. + + When producing `b.out' output, `as' accepts this directive, but +ignores it. + + +File: as.info, Node: Align, Next: Ascii, Prev: ABORT, Up: Pseudo Ops + +`.align ABS-EXPR, ABS-EXPR, ABS-EXPR' +===================================== + + Pad the location counter (in the current subsection) to a particular +storage boundary. The first expression (which must be absolute) is the +alignment required, as described below. + + The second expression (also absolute) gives the fill value to be +stored in the padding bytes. It (and the comma) may be omitted. If it +is omitted, the padding bytes are normally zero. However, on some +systems, if the section is marked as containing code and the fill value +is omitted, the space is filled with no-op instructions. + + The third expression is also absolute, and is also optional. If it +is present, it is the maximum number of bytes that should be skipped by +this alignment directive. If doing the alignment would require +skipping more bytes than the specified maximum, then the alignment is +not done at all. You can omit the fill value (the second argument) +entirely by simply using two commas after the required alignment; this +can be useful if you want the alignment to be filled with no-op +instructions when appropriate. + + The way the required alignment is specified varies from system to +system. For the a29k, hppa, m68k, m88k, w65, sparc, and Hitachi SH, +and i386 using ELF format, the first expression is the alignment +request in bytes. For example `.align 8' advances the location counter +until it is a multiple of 8. If the location counter is already a +multiple of 8, no change is needed. + + For other systems, including the i386 using a.out format, it is the +number of low-order zero bits the location counter must have after +advancement. For example `.align 3' advances the location counter +until it a multiple of 8. If the location counter is already a +multiple of 8, no change is needed. + + This inconsistency is due to the different behaviors of the various +native assemblers for these systems which GAS must emulate. GAS also +provides `.balign' and `.p2align' directives, described later, which +have a consistent behavior across all architectures (but are specific +to GAS). + + +File: as.info, Node: Ascii, Next: Asciz, Prev: Align, Up: Pseudo Ops + +`.ascii "STRING"'... +==================== + + `.ascii' expects zero or more string literals (*note Strings::) +separated by commas. It assembles each string (with no automatic +trailing zero byte) into consecutive addresses. + + +File: as.info, Node: Asciz, Next: Balign, Prev: Ascii, Up: Pseudo Ops + +`.asciz "STRING"'... +==================== + + `.asciz' is just like `.ascii', but each string is followed by a +zero byte. The "z" in `.asciz' stands for "zero". + + +File: as.info, Node: Balign, Next: Byte, Prev: Asciz, Up: Pseudo Ops + +`.balign[wl] ABS-EXPR, ABS-EXPR, ABS-EXPR' +========================================== + + Pad the location counter (in the current subsection) to a particular +storage boundary. The first expression (which must be absolute) is the +alignment request in bytes. For example `.balign 8' advances the +location counter until it is a multiple of 8. If the location counter +is already a multiple of 8, no change is needed. + + The second expression (also absolute) gives the fill value to be +stored in the padding bytes. It (and the comma) may be omitted. If it +is omitted, the padding bytes are normally zero. However, on some +systems, if the section is marked as containing code and the fill value +is omitted, the space is filled with no-op instructions. + + The third expression is also absolute, and is also optional. If it +is present, it is the maximum number of bytes that should be skipped by +this alignment directive. If doing the alignment would require +skipping more bytes than the specified maximum, then the alignment is +not done at all. You can omit the fill value (the second argument) +entirely by simply using two commas after the required alignment; this +can be useful if you want the alignment to be filled with no-op +instructions when appropriate. + + The `.balignw' and `.balignl' directives are variants of the +`.balign' directive. The `.balignw' directive treats the fill pattern +as a two byte word value. The `.balignl' directives treats the fill +pattern as a four byte longword value. For example, `.balignw +4,0x368d' will align to a multiple of 4. If it skips two bytes, they +will be filled in with the value 0x368d (the exact placement of the +bytes depends upon the endianness of the processor). If it skips 1 or +3 bytes, the fill value is undefined. + + +File: as.info, Node: Byte, Next: Comm, Prev: Balign, Up: Pseudo Ops + +`.byte EXPRESSIONS' +=================== + + `.byte' expects zero or more expressions, separated by commas. Each +expression is assembled into the next byte. + + +File: as.info, Node: Comm, Next: Data, Prev: Byte, Up: Pseudo Ops + +`.comm SYMBOL , LENGTH ' +======================== + + `.comm' declares a common symbol named SYMBOL. When linking, a +common symbol in one object file may be merged with a defined or common +symbol of the same name in another object file. If `ld' does not see a +definition for the symbol-just one or more common symbols-then it will +allocate LENGTH bytes of uninitialized memory. LENGTH must be an +absolute expression. If `ld' sees multiple common symbols with the +same name, and they do not all have the same size, it will allocate +space using the largest size. + + When using ELF, the `.comm' directive takes an optional third +argument. This is the desired alignment of the symbol, specified as a +byte boundary (for example, an alignment of 16 means that the least +significant 4 bits of the address should be zero). The alignment must +be an absolute expression, and it must be a power of two. If `ld' +allocates uninitialized memory for the common symbol, it will use the +alignment when placing the symbol. If no alignment is specified, `as' +will set the alignment to the largest power of two less than or equal +to the size of the symbol, up to a maximum of 16. + + The syntax for `.comm' differs slightly on the HPPA. The syntax is +`SYMBOL .comm, LENGTH'; SYMBOL is optional. + + +File: as.info, Node: Data, Next: Def, Prev: Comm, Up: Pseudo Ops + +`.data SUBSECTION' +================== + + `.data' tells `as' to assemble the following statements onto the end +of the data subsection numbered SUBSECTION (which is an absolute +expression). If SUBSECTION is omitted, it defaults to zero. + + +File: as.info, Node: Def, Next: Desc, Prev: Data, Up: Pseudo Ops + +`.def NAME' +=========== + + Begin defining debugging information for a symbol NAME; the +definition extends until the `.endef' directive is encountered. + + This directive is only observed when `as' is configured for COFF +format output; when producing `b.out', `.def' is recognized, but +ignored. + + +File: as.info, Node: Desc, Next: Dim, Prev: Def, Up: Pseudo Ops + +`.desc SYMBOL, ABS-EXPRESSION' +============================== + + This directive sets the descriptor of the symbol (*note Symbol +Attributes::) to the low 16 bits of an absolute expression. + + The `.desc' directive is not available when `as' is configured for +COFF output; it is only for `a.out' or `b.out' object format. For the +sake of compatibility, `as' accepts it, but produces no output, when +configured for COFF. + + +File: as.info, Node: Dim, Next: Double, Prev: Desc, Up: Pseudo Ops + +`.dim' +====== + + This directive is generated by compilers to include auxiliary +debugging information in the symbol table. It is only permitted inside +`.def'/`.endef' pairs. + + `.dim' is only meaningful when generating COFF format output; when +`as' is generating `b.out', it accepts this directive but ignores it. + + +File: as.info, Node: Double, Next: Eject, Prev: Dim, Up: Pseudo Ops + +`.double FLONUMS' +================= + + `.double' expects zero or more flonums, separated by commas. It +assembles floating point numbers. The exact kind of floating point +numbers emitted depends on how `as' is configured. *Note Machine +Dependencies::. + + +File: as.info, Node: Eject, Next: Else, Prev: Double, Up: Pseudo Ops + +`.eject' +======== + + Force a page break at this point, when generating assembly listings. + + +File: as.info, Node: Else, Next: Elseif, Prev: Eject, Up: Pseudo Ops + +`.else' +======= + + `.else' is part of the `as' support for conditional assembly; *note +`.if': If.. It marks the beginning of a section of code to be +assembled if the condition for the preceding `.if' was false. + + +File: as.info, Node: Elseif, Next: End, Prev: Else, Up: Pseudo Ops + +`.elseif' +========= + + `.elseif' is part of the `as' support for conditional assembly; +*note `.if': If.. It is shorthand for beginning a new `.if' block that +would otherwise fill the entire `.else' section. + + +File: as.info, Node: End, Next: Endef, Prev: Elseif, Up: Pseudo Ops + +`.end' +====== + + `.end' marks the end of the assembly file. `as' does not process +anything in the file past the `.end' directive. + + +File: as.info, Node: Endef, Next: Endfunc, Prev: End, Up: Pseudo Ops + +`.endef' +======== + + This directive flags the end of a symbol definition begun with +`.def'. + + `.endef' is only meaningful when generating COFF format output; if +`as' is configured to generate `b.out', it accepts this directive but +ignores it. + + +File: as.info, Node: Endfunc, Next: Endif, Prev: Endef, Up: Pseudo Ops + +`.endfunc' +========== + + `.endfunc' marks the end of a function specified with `.func'. + + +File: as.info, Node: Endif, Next: Equ, Prev: Endfunc, Up: Pseudo Ops + +`.endif' +======== + + `.endif' is part of the `as' support for conditional assembly; it +marks the end of a block of code that is only assembled conditionally. +*Note `.if': If. + + +File: as.info, Node: Equ, Next: Equiv, Prev: Endif, Up: Pseudo Ops + +`.equ SYMBOL, EXPRESSION' +========================= + + This directive sets the value of SYMBOL to EXPRESSION. It is +synonymous with `.set'; *note `.set': Set.. + + The syntax for `equ' on the HPPA is `SYMBOL .equ EXPRESSION'. + + +File: as.info, Node: Equiv, Next: Err, Prev: Equ, Up: Pseudo Ops + +`.equiv SYMBOL, EXPRESSION' +=========================== + + The `.equiv' directive is like `.equ' and `.set', except that the +assembler will signal an error if SYMBOL is already defined. + + Except for the contents of the error message, this is roughly +equivalent to + .ifdef SYM + .err + .endif + .equ SYM,VAL + + +File: as.info, Node: Err, Next: Exitm, Prev: Equiv, Up: Pseudo Ops + +`.err' +====== + + If `as' assembles a `.err' directive, it will print an error message +and, unless the `-Z' option was used, it will not generate an object +file. This can be used to signal error an conditionally compiled code. + + +File: as.info, Node: Exitm, Next: Extern, Prev: Err, Up: Pseudo Ops + +`.exitm' +======== + + Exit early from the current macro definition. *Note Macro::. + + +File: as.info, Node: Extern, Next: Fail, Prev: Exitm, Up: Pseudo Ops + +`.extern' +========= + + `.extern' is accepted in the source program--for compatibility with +other assemblers--but it is ignored. `as' treats all undefined symbols +as external. + + +File: as.info, Node: Fail, Next: File, Prev: Extern, Up: Pseudo Ops + +`.fail EXPRESSION' +================== + + Generates an error or a warning. If the value of the EXPRESSION is +500 or more, `as' will print a warning message. If the value is less +than 500, `as' will print an error message. The message will include +the value of EXPRESSION. This can occasionally be useful inside +complex nested macros or conditional assembly. + + +File: as.info, Node: File, Next: Fill, Prev: Fail, Up: Pseudo Ops + +`.file STRING' +============== + + `.file' tells `as' that we are about to start a new logical file. +STRING is the new file name. In general, the filename is recognized +whether or not it is surrounded by quotes `"'; but if you wish to +specify an empty file name, you must give the quotes-`""'. This +statement may go away in future: it is only recognized to be compatible +with old `as' programs. In some configurations of `as', `.file' has +already been removed to avoid conflicts with other assemblers. *Note +Machine Dependencies::. + + +File: as.info, Node: Fill, Next: Float, Prev: File, Up: Pseudo Ops + +`.fill REPEAT , SIZE , VALUE' +============================= + + RESULT, SIZE and VALUE are absolute expressions. This emits REPEAT +copies of SIZE bytes. REPEAT may be zero or more. SIZE may be zero or +more, but if it is more than 8, then it is deemed to have the value 8, +compatible with other people's assemblers. The contents of each REPEAT +bytes is taken from an 8-byte number. The highest order 4 bytes are +zero. The lowest order 4 bytes are VALUE rendered in the byte-order of +an integer on the computer `as' is assembling for. Each SIZE bytes in +a repetition is taken from the lowest order SIZE bytes of this number. +Again, this bizarre behavior is compatible with other people's +assemblers. + + SIZE and VALUE are optional. If the second comma and VALUE are +absent, VALUE is assumed zero. If the first comma and following tokens +are absent, SIZE is assumed to be 1. + + +File: as.info, Node: Float, Next: Func, Prev: Fill, Up: Pseudo Ops + +`.float FLONUMS' +================ + + This directive assembles zero or more flonums, separated by commas. +It has the same effect as `.single'. The exact kind of floating point +numbers emitted depends on how `as' is configured. *Note Machine +Dependencies::. + + +File: as.info, Node: Func, Next: Global, Prev: Float, Up: Pseudo Ops + +`.func NAME[,LABEL]' +==================== + + `.func' emits debugging information to denote function NAME, and is +ignored unless the file is assembled with debugging enabled. Only +`--gstabs' is currently supported. LABEL is the entry point of the +function and if omitted NAME prepended with the `leading char' is used. +`leading char' is usually `_' or nothing, depending on the target. All +functions are currently defined to have `void' return type. The +function must be terminated with `.endfunc'. + + +File: as.info, Node: Global, Next: hword, Prev: Func, Up: Pseudo Ops + +`.global SYMBOL', `.globl SYMBOL' +================================= + + `.global' makes the symbol visible to `ld'. If you define SYMBOL in +your partial program, its value is made available to other partial +programs that are linked with it. Otherwise, SYMBOL takes its +attributes from a symbol of the same name from another file linked into +the same program. + + Both spellings (`.globl' and `.global') are accepted, for +compatibility with other assemblers. + + On the HPPA, `.global' is not always enough to make it accessible to +other partial programs. You may need the HPPA-only `.EXPORT' directive +as well. *Note HPPA Assembler Directives: HPPA Directives. + + +File: as.info, Node: hword, Next: Ident, Prev: Global, Up: Pseudo Ops + +`.hword EXPRESSIONS' +==================== + + This expects zero or more EXPRESSIONS, and emits a 16 bit number for +each. + + This directive is a synonym for `.short'; depending on the target +architecture, it may also be a synonym for `.word'. + + +File: as.info, Node: Ident, Next: If, Prev: hword, Up: Pseudo Ops + +`.ident' +======== + + This directive is used by some assemblers to place tags in object +files. `as' simply accepts the directive for source-file compatibility +with such assemblers, but does not actually emit anything for it. + + +File: as.info, Node: If, Next: Include, Prev: Ident, Up: Pseudo Ops + +`.if ABSOLUTE EXPRESSION' +========================= + + `.if' marks the beginning of a section of code which is only +considered part of the source program being assembled if the argument +(which must be an ABSOLUTE EXPRESSION) is non-zero. The end of the +conditional section of code must be marked by `.endif' (*note `.endif': +Endif.); optionally, you may include code for the alternative +condition, flagged by `.else' (*note `.else': Else.). If you have +several conditions to check, `.elseif' may be used to avoid nesting +blocks if/else within each subsequent `.else' block. + + The following variants of `.if' are also supported: +`.ifdef SYMBOL' + Assembles the following section of code if the specified SYMBOL + has been defined. + +`.ifc STRING1,STRING2' + Assembles the following section of code if the two strings are the + same. The strings may be optionally quoted with single quotes. + If they are not quoted, the first string stops at the first comma, + and the second string stops at the end of the line. Strings which + contain whitespace should be quoted. The string comparison is + case sensitive. + +`.ifeq ABSOLUTE EXPRESSION' + Assembles the following section of code if the argument is zero. + +`.ifeqs STRING1,STRING2' + Another form of `.ifc'. The strings must be quoted using double + quotes. + +`.ifge ABSOLUTE EXPRESSION' + Assembles the following section of code if the argument is greater + than or equal to zero. + +`.ifgt ABSOLUTE EXPRESSION' + Assembles the following section of code if the argument is greater + than zero. + +`.ifle ABSOLUTE EXPRESSION' + Assembles the following section of code if the argument is less + than or equal to zero. + +`.iflt ABSOLUTE EXPRESSION' + Assembles the following section of code if the argument is less + than zero. + +`.ifnc STRING1,STRING2.' + Like `.ifc', but the sense of the test is reversed: this assembles + the following section of code if the two strings are not the same. + +`.ifndef SYMBOL' +`.ifnotdef SYMBOL' + Assembles the following section of code if the specified SYMBOL + has not been defined. Both spelling variants are equivalent. + +`.ifne ABSOLUTE EXPRESSION' + Assembles the following section of code if the argument is not + equal to zero (in other words, this is equivalent to `.if'). + +`.ifnes STRING1,STRING2' + Like `.ifeqs', but the sense of the test is reversed: this + assembles the following section of code if the two strings are not + the same. + + +File: as.info, Node: Include, Next: Int, Prev: If, Up: Pseudo Ops + +`.include "FILE"' +================= + + This directive provides a way to include supporting files at +specified points in your source program. The code from FILE is +assembled as if it followed the point of the `.include'; when the end +of the included file is reached, assembly of the original file +continues. You can control the search paths used with the `-I' +command-line option (*note Command-Line Options: Invoking.). Quotation +marks are required around FILE. + + +File: as.info, Node: Int, Next: Irp, Prev: Include, Up: Pseudo Ops + +`.int EXPRESSIONS' +================== + + Expect zero or more EXPRESSIONS, of any section, separated by commas. +For each expression, emit a number that, at run time, is the value of +that expression. The byte order and bit size of the number depends on +what kind of target the assembly is for. + diff --git a/gas/doc/as.info-3 b/gas/doc/as.info-3 new file mode 100644 index 00000000000..34e4c5a3a8b --- /dev/null +++ b/gas/doc/as.info-3 @@ -0,0 +1,1482 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: Irp, Next: Irpc, Prev: Int, Up: Pseudo Ops + +`.irp SYMBOL,VALUES'... +======================= + + Evaluate a sequence of statements assigning different values to +SYMBOL. The sequence of statements starts at the `.irp' directive, and +is terminated by an `.endr' directive. For each VALUE, SYMBOL is set +to VALUE, and the sequence of statements is assembled. If no VALUE is +listed, the sequence of statements is assembled once, with SYMBOL set +to the null string. To refer to SYMBOL within the sequence of +statements, use \SYMBOL. + + For example, assembling + + .irp param,1,2,3 + move d\param,sp@- + .endr + + is equivalent to assembling + + move d1,sp@- + move d2,sp@- + move d3,sp@- + + +File: as.info, Node: Irpc, Next: Lcomm, Prev: Irp, Up: Pseudo Ops + +`.irpc SYMBOL,VALUES'... +======================== + + Evaluate a sequence of statements assigning different values to +SYMBOL. The sequence of statements starts at the `.irpc' directive, +and is terminated by an `.endr' directive. For each character in VALUE, +SYMBOL is set to the character, and the sequence of statements is +assembled. If no VALUE is listed, the sequence of statements is +assembled once, with SYMBOL set to the null string. To refer to SYMBOL +within the sequence of statements, use \SYMBOL. + + For example, assembling + + .irpc param,123 + move d\param,sp@- + .endr + + is equivalent to assembling + + move d1,sp@- + move d2,sp@- + move d3,sp@- + + +File: as.info, Node: Lcomm, Next: Lflags, Prev: Irpc, Up: Pseudo Ops + +`.lcomm SYMBOL , LENGTH' +======================== + + Reserve LENGTH (an absolute expression) bytes for a local common +denoted by SYMBOL. The section and value of SYMBOL are those of the +new local common. The addresses are allocated in the bss section, so +that at run-time the bytes start off zeroed. SYMBOL is not declared +global (*note `.global': Global.), so is normally not visible to `ld'. + + Some targets permit a third argument to be used with `.lcomm'. This +argument specifies the desired alignment of the symbol in the bss +section. + + The syntax for `.lcomm' differs slightly on the HPPA. The syntax is +`SYMBOL .lcomm, LENGTH'; SYMBOL is optional. + + +File: as.info, Node: Lflags, Next: Line, Prev: Lcomm, Up: Pseudo Ops + +`.lflags' +========= + + `as' accepts this directive, for compatibility with other +assemblers, but ignores it. + + +File: as.info, Node: Line, Next: Ln, Prev: Lflags, Up: Pseudo Ops + +`.line LINE-NUMBER' +=================== + + Change the logical line number. LINE-NUMBER must be an absolute +expression. The next line has that logical line number. Therefore any +other statements on the current line (after a statement separator +character) are reported as on logical line number LINE-NUMBER - 1. One +day `as' will no longer support this directive: it is recognized only +for compatibility with existing assembler programs. + + _Warning:_ In the AMD29K configuration of as, this command is not +available; use the synonym `.ln' in that context. + + Even though this is a directive associated with the `a.out' or +`b.out' object-code formats, `as' still recognizes it when producing +COFF output, and treats `.line' as though it were the COFF `.ln' _if_ +it is found outside a `.def'/`.endef' pair. + + Inside a `.def', `.line' is, instead, one of the directives used by +compilers to generate auxiliary symbol information for debugging. + + +File: as.info, Node: Linkonce, Next: List, Prev: Ln, Up: Pseudo Ops + +`.linkonce [TYPE]' +================== + + Mark the current section so that the linker only includes a single +copy of it. This may be used to include the same section in several +different object files, but ensure that the linker will only include it +once in the final output file. The `.linkonce' pseudo-op must be used +for each instance of the section. Duplicate sections are detected +based on the section name, so it should be unique. + + This directive is only supported by a few object file formats; as of +this writing, the only object file format which supports it is the +Portable Executable format used on Windows NT. + + The TYPE argument is optional. If specified, it must be one of the +following strings. For example: + .linkonce same_size + Not all types may be supported on all object file formats. + +`discard' + Silently discard duplicate sections. This is the default. + +`one_only' + Warn if there are duplicate sections, but still keep only one copy. + +`same_size' + Warn if any of the duplicates have different sizes. + +`same_contents' + Warn if any of the duplicates do not have exactly the same + contents. + + +File: as.info, Node: Ln, Next: Linkonce, Prev: Line, Up: Pseudo Ops + +`.ln LINE-NUMBER' +================= + + `.ln' is a synonym for `.line'. + + +File: as.info, Node: MRI, Next: Nolist, Prev: Macro, Up: Pseudo Ops + +`.mri VAL' +========== + + If VAL is non-zero, this tells `as' to enter MRI mode. If VAL is +zero, this tells `as' to exit MRI mode. This change affects code +assembled until the next `.mri' directive, or until the end of the +file. *Note MRI mode: M. + + +File: as.info, Node: List, Next: Long, Prev: Linkonce, Up: Pseudo Ops + +`.list' +======= + + Control (in conjunction with the `.nolist' directive) whether or not +assembly listings are generated. These two directives maintain an +internal counter (which is zero initially). `.list' increments the +counter, and `.nolist' decrements it. Assembly listings are generated +whenever the counter is greater than zero. + + By default, listings are disabled. When you enable them (with the +`-a' command line option; *note Command-Line Options: Invoking.), the +initial value of the listing counter is one. + + +File: as.info, Node: Long, Next: Macro, Prev: List, Up: Pseudo Ops + +`.long EXPRESSIONS' +=================== + + `.long' is the same as `.int', *note `.int': Int.. + + +File: as.info, Node: Macro, Next: MRI, Prev: Long, Up: Pseudo Ops + +`.macro' +======== + + The commands `.macro' and `.endm' allow you to define macros that +generate assembly output. For example, this definition specifies a +macro `sum' that puts a sequence of numbers into memory: + + .macro sum from=0, to=5 + .long \from + .if \to-\from + sum "(\from+1)",\to + .endif + .endm + +With that definition, `SUM 0,5' is equivalent to this assembly input: + + .long 0 + .long 1 + .long 2 + .long 3 + .long 4 + .long 5 + +`.macro MACNAME' +`.macro MACNAME MACARGS ...' + Begin the definition of a macro called MACNAME. If your macro + definition requires arguments, specify their names after the macro + name, separated by commas or spaces. You can supply a default + value for any macro argument by following the name with `=DEFLT'. + For example, these are all valid `.macro' statements: + + `.macro comm' + Begin the definition of a macro called `comm', which takes no + arguments. + + `.macro plus1 p, p1' + `.macro plus1 p p1' + Either statement begins the definition of a macro called + `plus1', which takes two arguments; within the macro + definition, write `\p' or `\p1' to evaluate the arguments. + + `.macro reserve_str p1=0 p2' + Begin the definition of a macro called `reserve_str', with two + arguments. The first argument has a default value, but not + the second. After the definition is complete, you can call + the macro either as `reserve_str A,B' (with `\p1' evaluating + to A and `\p2' evaluating to B), or as `reserve_str ,B' (with + `\p1' evaluating as the default, in this case `0', and `\p2' + evaluating to B). + + When you call a macro, you can specify the argument values either + by position, or by keyword. For example, `sum 9,17' is equivalent + to `sum to=17, from=9'. + +`.endm' + Mark the end of a macro definition. + +`.exitm' + Exit early from the current macro definition. + +`\@' + `as' maintains a counter of how many macros it has executed in + this pseudo-variable; you can copy that number to your output with + `\@', but _only within a macro definition_. + + +File: as.info, Node: Nolist, Next: Octa, Prev: MRI, Up: Pseudo Ops + +`.nolist' +========= + + Control (in conjunction with the `.list' directive) whether or not +assembly listings are generated. These two directives maintain an +internal counter (which is zero initially). `.list' increments the +counter, and `.nolist' decrements it. Assembly listings are generated +whenever the counter is greater than zero. + + +File: as.info, Node: Octa, Next: Org, Prev: Nolist, Up: Pseudo Ops + +`.octa BIGNUMS' +=============== + + This directive expects zero or more bignums, separated by commas. +For each bignum, it emits a 16-byte integer. + + The term "octa" comes from contexts in which a "word" is two bytes; +hence _octa_-word for 16 bytes. + + +File: as.info, Node: Org, Next: P2align, Prev: Octa, Up: Pseudo Ops + +`.org NEW-LC , FILL' +==================== + + Advance the location counter of the current section to NEW-LC. +NEW-LC is either an absolute expression or an expression with the same +section as the current subsection. That is, you can't use `.org' to +cross sections: if NEW-LC has the wrong section, the `.org' directive +is ignored. To be compatible with former assemblers, if the section of +NEW-LC is absolute, `as' issues a warning, then pretends the section of +NEW-LC is the same as the current subsection. + + `.org' may only increase the location counter, or leave it +unchanged; you cannot use `.org' to move the location counter backwards. + + Because `as' tries to assemble programs in one pass, NEW-LC may not +be undefined. If you really detest this restriction we eagerly await a +chance to share your improved assembler. + + Beware that the origin is relative to the start of the section, not +to the start of the subsection. This is compatible with other people's +assemblers. + + When the location counter (of the current subsection) is advanced, +the intervening bytes are filled with FILL which should be an absolute +expression. If the comma and FILL are omitted, FILL defaults to zero. + + +File: as.info, Node: P2align, Next: Print, Prev: Org, Up: Pseudo Ops + +`.p2align[wl] ABS-EXPR, ABS-EXPR, ABS-EXPR' +=========================================== + + Pad the location counter (in the current subsection) to a particular +storage boundary. The first expression (which must be absolute) is the +number of low-order zero bits the location counter must have after +advancement. For example `.p2align 3' advances the location counter +until it a multiple of 8. If the location counter is already a +multiple of 8, no change is needed. + + The second expression (also absolute) gives the fill value to be +stored in the padding bytes. It (and the comma) may be omitted. If it +is omitted, the padding bytes are normally zero. However, on some +systems, if the section is marked as containing code and the fill value +is omitted, the space is filled with no-op instructions. + + The third expression is also absolute, and is also optional. If it +is present, it is the maximum number of bytes that should be skipped by +this alignment directive. If doing the alignment would require +skipping more bytes than the specified maximum, then the alignment is +not done at all. You can omit the fill value (the second argument) +entirely by simply using two commas after the required alignment; this +can be useful if you want the alignment to be filled with no-op +instructions when appropriate. + + The `.p2alignw' and `.p2alignl' directives are variants of the +`.p2align' directive. The `.p2alignw' directive treats the fill +pattern as a two byte word value. The `.p2alignl' directives treats the +fill pattern as a four byte longword value. For example, `.p2alignw +2,0x368d' will align to a multiple of 4. If it skips two bytes, they +will be filled in with the value 0x368d (the exact placement of the +bytes depends upon the endianness of the processor). If it skips 1 or +3 bytes, the fill value is undefined. + + +File: as.info, Node: Print, Next: Psize, Prev: P2align, Up: Pseudo Ops + +`.print STRING' +=============== + + `as' will print STRING on the standard output during assembly. You +must put STRING in double quotes. + + +File: as.info, Node: Psize, Next: Purgem, Prev: Print, Up: Pseudo Ops + +`.psize LINES , COLUMNS' +======================== + + Use this directive to declare the number of lines--and, optionally, +the number of columns--to use for each page, when generating listings. + + If you do not use `.psize', listings use a default line-count of 60. +You may omit the comma and COLUMNS specification; the default width is +200 columns. + + `as' generates formfeeds whenever the specified number of lines is +exceeded (or whenever you explicitly request one, using `.eject'). + + If you specify LINES as `0', no formfeeds are generated save those +explicitly specified with `.eject'. + + +File: as.info, Node: Purgem, Next: Quad, Prev: Psize, Up: Pseudo Ops + +`.purgem NAME' +============== + + Undefine the macro NAME, so that later uses of the string will not be +expanded. *Note Macro::. + + +File: as.info, Node: Quad, Next: Rept, Prev: Purgem, Up: Pseudo Ops + +`.quad BIGNUMS' +=============== + + `.quad' expects zero or more bignums, separated by commas. For each +bignum, it emits an 8-byte integer. If the bignum won't fit in 8 +bytes, it prints a warning message; and just takes the lowest order 8 +bytes of the bignum. + + The term "quad" comes from contexts in which a "word" is two bytes; +hence _quad_-word for 8 bytes. + + +File: as.info, Node: Rept, Next: Sbttl, Prev: Quad, Up: Pseudo Ops + +`.rept COUNT' +============= + + Repeat the sequence of lines between the `.rept' directive and the +next `.endr' directive COUNT times. + + For example, assembling + + .rept 3 + .long 0 + .endr + + is equivalent to assembling + + .long 0 + .long 0 + .long 0 + + +File: as.info, Node: Sbttl, Next: Scl, Prev: Rept, Up: Pseudo Ops + +`.sbttl "SUBHEADING"' +===================== + + Use SUBHEADING as the title (third line, immediately after the title +line) when generating assembly listings. + + This directive affects subsequent pages, as well as the current page +if it appears within ten lines of the top of a page. + + +File: as.info, Node: Scl, Next: Section, Prev: Sbttl, Up: Pseudo Ops + +`.scl CLASS' +============ + + Set the storage-class value for a symbol. This directive may only be +used inside a `.def'/`.endef' pair. Storage class may flag whether a +symbol is static or external, or it may record further symbolic +debugging information. + + The `.scl' directive is primarily associated with COFF output; when +configured to generate `b.out' output format, `as' accepts this +directive but ignores it. + + +File: as.info, Node: Section, Next: Set, Prev: Scl, Up: Pseudo Ops + +`.section NAME' +=============== + + Use the `.section' directive to assemble the following code into a +section named NAME. + + This directive is only supported for targets that actually support +arbitrarily named sections; on `a.out' targets, for example, it is not +accepted, even with a standard `a.out' section name. + + For COFF targets, the `.section' directive is used in one of the +following ways: + .section NAME[, "FLAGS"] + .section NAME[, SUBSEGMENT] + + If the optional argument is quoted, it is taken as flags to use for +the section. Each flag is a single character. The following flags are +recognized: +`b' + bss section (uninitialized data) + +`n' + section is not loaded + +`w' + writable section + +`d' + data section + +`r' + read-only section + +`x' + executable section + +`s' + shared section (meaningful for PE targets) + + If no flags are specified, the default flags depend upon the section +name. If the section name is not recognized, the default will be for +the section to be loaded and writable. + + If the optional argument to the `.section' directive is not quoted, +it is taken as a subsegment number (*note Sub-Sections::). + + For ELF targets, the `.section' directive is used like this: + .section NAME[, "FLAGS"[, @TYPE]] + The optional FLAGS argument is a quoted string which may contain any +combintion of the following characters: +`a' + section is allocatable + +`w' + section is writable + +`x' + section is executable + + The optional TYPE argument may contain one of the following +constants: +`@progbits' + section contains data + +`@nobits' + section does not contain data (i.e., section only occupies space) + + If no flags are specified, the default flags depend upon the section +name. If the section name is not recognized, the default will be for +the section to have none of the above flags: it will not be allocated +in memory, nor writable, nor executable. The section will contain data. + + For ELF targets, the assembler supports another type of `.section' +directive for compatibility with the Solaris assembler: + .section "NAME"[, FLAGS...] + Note that the section name is quoted. There may be a sequence of +comma separated flags: +`#alloc' + section is allocatable + +`#write' + section is writable + +`#execinstr' + section is executable + + +File: as.info, Node: Set, Next: Short, Prev: Section, Up: Pseudo Ops + +`.set SYMBOL, EXPRESSION' +========================= + + Set the value of SYMBOL to EXPRESSION. This changes SYMBOL's value +and type to conform to EXPRESSION. If SYMBOL was flagged as external, +it remains flagged (*note Symbol Attributes::). + + You may `.set' a symbol many times in the same assembly. + + If you `.set' a global symbol, the value stored in the object file +is the last value stored into it. + + The syntax for `set' on the HPPA is `SYMBOL .set EXPRESSION'. + + +File: as.info, Node: Short, Next: Single, Prev: Set, Up: Pseudo Ops + +`.short EXPRESSIONS' +==================== + + `.short' is normally the same as `.word'. *Note `.word': Word. + + In some configurations, however, `.short' and `.word' generate +numbers of different lengths; *note Machine Dependencies::. + + +File: as.info, Node: Single, Next: Size, Prev: Short, Up: Pseudo Ops + +`.single FLONUMS' +================= + + This directive assembles zero or more flonums, separated by commas. +It has the same effect as `.float'. The exact kind of floating point +numbers emitted depends on how `as' is configured. *Note Machine +Dependencies::. + + +File: as.info, Node: Size, Next: Skip, Prev: Single, Up: Pseudo Ops + +`.size' +======= + + This directive is generated by compilers to include auxiliary +debugging information in the symbol table. It is only permitted inside +`.def'/`.endef' pairs. + + `.size' is only meaningful when generating COFF format output; when +`as' is generating `b.out', it accepts this directive but ignores it. + + +File: as.info, Node: Sleb128, Next: Space, Prev: Skip, Up: Pseudo Ops + +`.sleb128 EXPRESSIONS' +====================== + + SLEB128 stands for "signed little endian base 128." This is a +compact, variable length representation of numbers used by the DWARF +symbolic debugging format. *Note `.uleb128': Uleb128. + + +File: as.info, Node: Skip, Next: Sleb128, Prev: Size, Up: Pseudo Ops + +`.skip SIZE , FILL' +=================== + + This directive emits SIZE bytes, each of value FILL. Both SIZE and +FILL are absolute expressions. If the comma and FILL are omitted, FILL +is assumed to be zero. This is the same as `.space'. + + +File: as.info, Node: Space, Next: Stab, Prev: Sleb128, Up: Pseudo Ops + +`.space SIZE , FILL' +==================== + + This directive emits SIZE bytes, each of value FILL. Both SIZE and +FILL are absolute expressions. If the comma and FILL are omitted, FILL +is assumed to be zero. This is the same as `.skip'. + + _Warning:_ `.space' has a completely different meaning for HPPA + targets; use `.block' as a substitute. See `HP9000 Series 800 + Assembly Language Reference Manual' (HP 92432-90001) for the + meaning of the `.space' directive. *Note HPPA Assembler + Directives: HPPA Directives, for a summary. + + On the AMD 29K, this directive is ignored; it is accepted for +compatibility with other AMD 29K assemblers. + + _Warning:_ In most versions of the GNU assembler, the directive + `.space' has the effect of `.block' *Note Machine Dependencies::. + + +File: as.info, Node: Stab, Next: String, Prev: Space, Up: Pseudo Ops + +`.stabd, .stabn, .stabs' +======================== + + There are three directives that begin `.stab'. All emit symbols +(*note Symbols::), for use by symbolic debuggers. The symbols are not +entered in the `as' hash table: they cannot be referenced elsewhere in +the source file. Up to five fields are required: + +STRING + This is the symbol's name. It may contain any character except + `\000', so is more general than ordinary symbol names. Some + debuggers used to code arbitrarily complex structures into symbol + names using this field. + +TYPE + An absolute expression. The symbol's type is set to the low 8 + bits of this expression. Any bit pattern is permitted, but `ld' + and debuggers choke on silly bit patterns. + +OTHER + An absolute expression. The symbol's "other" attribute is set to + the low 8 bits of this expression. + +DESC + An absolute expression. The symbol's descriptor is set to the low + 16 bits of this expression. + +VALUE + An absolute expression which becomes the symbol's value. + + If a warning is detected while reading a `.stabd', `.stabn', or +`.stabs' statement, the symbol has probably already been created; you +get a half-formed symbol in your object file. This is compatible with +earlier assemblers! + +`.stabd TYPE , OTHER , DESC' + The "name" of the symbol generated is not even an empty string. + It is a null pointer, for compatibility. Older assemblers used a + null pointer so they didn't waste space in object files with empty + strings. + + The symbol's value is set to the location counter, relocatably. + When your program is linked, the value of this symbol is the + address of the location counter when the `.stabd' was assembled. + +`.stabn TYPE , OTHER , DESC , VALUE' + The name of the symbol is set to the empty string `""'. + +`.stabs STRING , TYPE , OTHER , DESC , VALUE' + All five fields are specified. + + +File: as.info, Node: String, Next: Struct, Prev: Stab, Up: Pseudo Ops + +`.string' "STR" +=============== + + Copy the characters in STR to the object file. You may specify more +than one string to copy, separated by commas. Unless otherwise +specified for a particular machine, the assembler marks the end of each +string with a 0 byte. You can use any of the escape sequences +described in *Note Strings: Strings. + + +File: as.info, Node: Struct, Next: Symver, Prev: String, Up: Pseudo Ops + +`.struct EXPRESSION' +==================== + + Switch to the absolute section, and set the section offset to +EXPRESSION, which must be an absolute expression. You might use this +as follows: + .struct 0 + field1: + .struct field1 + 4 + field2: + .struct field2 + 4 + field3: + This would define the symbol `field1' to have the value 0, the symbol +`field2' to have the value 4, and the symbol `field3' to have the value +8. Assembly would be left in the absolute section, and you would need +to use a `.section' directive of some sort to change to some other +section before further assembly. + + +File: as.info, Node: Symver, Next: Tag, Prev: Struct, Up: Pseudo Ops + +`.symver' +========= + + Use the `.symver' directive to bind symbols to specific version nodes +within a source file. This is only supported on ELF platforms, and is +typically used when assembling files to be linked into a shared library. +There are cases where it may make sense to use this in objects to be +bound into an application itself so as to override a versioned symbol +from a shared library. + + For ELF targets, the `.symver' directive is used like this: + .symver NAME, NAME2@NODENAME + In this case, the symbol NAME must exist and be defined within the +file being assembled. The `.versym' directive effectively creates a +symbol alias with the name NAME2@NODENAME, and in fact the main reason +that we just don't try and create a regular alias is that the @ +character isn't permitted in symbol names. The NAME2 part of the name +is the actual name of the symbol by which it will be externally +referenced. The name NAME itself is merely a name of convenience that +is used so that it is possible to have definitions for multiple +versions of a function within a single source file, and so that the +compiler can unambiguously know which version of a function is being +mentioned. The NODENAME portion of the alias should be the name of a +node specified in the version script supplied to the linker when +building a shared library. If you are attempting to override a +versioned symbol from a shared library, then NODENAME should correspond +to the nodename of the symbol you are trying to override. + + +File: as.info, Node: Tag, Next: Text, Prev: Symver, Up: Pseudo Ops + +`.tag STRUCTNAME' +================= + + This directive is generated by compilers to include auxiliary +debugging information in the symbol table. It is only permitted inside +`.def'/`.endef' pairs. Tags are used to link structure definitions in +the symbol table with instances of those structures. + + `.tag' is only used when generating COFF format output; when `as' is +generating `b.out', it accepts this directive but ignores it. + + +File: as.info, Node: Text, Next: Title, Prev: Tag, Up: Pseudo Ops + +`.text SUBSECTION' +================== + + Tells `as' to assemble the following statements onto the end of the +text subsection numbered SUBSECTION, which is an absolute expression. +If SUBSECTION is omitted, subsection number zero is used. + + +File: as.info, Node: Title, Next: Type, Prev: Text, Up: Pseudo Ops + +`.title "HEADING"' +================== + + Use HEADING as the title (second line, immediately after the source +file name and pagenumber) when generating assembly listings. + + This directive affects subsequent pages, as well as the current page +if it appears within ten lines of the top of a page. + + +File: as.info, Node: Type, Next: Val, Prev: Title, Up: Pseudo Ops + +`.type INT' +=========== + + This directive, permitted only within `.def'/`.endef' pairs, records +the integer INT as the type attribute of a symbol table entry. + + `.type' is associated only with COFF format output; when `as' is +configured for `b.out' output, it accepts this directive but ignores it. + + +File: as.info, Node: Val, Next: Visibility, Prev: Type, Up: Pseudo Ops + +`.val ADDR' +=========== + + This directive, permitted only within `.def'/`.endef' pairs, records +the address ADDR as the value attribute of a symbol table entry. + + `.val' is used only for COFF output; when `as' is configured for +`b.out', it accepts this directive but ignores it. + + +File: as.info, Node: Uleb128, Next: Word, Prev: Visibility, Up: Pseudo Ops + +`.uleb128 EXPRESSIONS' +====================== + + ULEB128 stands for "unsigned little endian base 128." This is a +compact, variable length representation of numbers used by the DWARF +symbolic debugging format. *Note `.sleb128': Sleb128. + + +File: as.info, Node: Visibility, Next: Uleb128, Prev: Val, Up: Pseudo Ops + +`.internal', `.hidden', `.protected' +==================================== + + These directives can be used to set the visibility of a specified +symbol. By default a symbol's visibility is set by its binding (local, +global or weak), but these directives can be used to override that. + + A visibility of `protected' means that any references to the symbol +from within the component that defines the symbol must be resolved to +the definition in that component, even if a definition in another +component would normally preempt this. + + A visibility of `hidden' means that the symbol is not visible to +other components. Such a symbol is always considered to be protected +as well. + + A visibility of `internal' is the same as a visibility of `hidden', +except that some extra, processor specific processing must also be +performed upon the symbol. + + For ELF targets, the directives are used like this: + + .internal NAME + .hidden NAME + .protected NAME + + +File: as.info, Node: Word, Next: Deprecated, Prev: Uleb128, Up: Pseudo Ops + +`.word EXPRESSIONS' +=================== + + This directive expects zero or more EXPRESSIONS, of any section, +separated by commas. + + The size of the number emitted, and its byte order, depend on what +target computer the assembly is for. + + _Warning: Special Treatment to support Compilers_ + + Machines with a 32-bit address space, but that do less than 32-bit +addressing, require the following special treatment. If the machine of +interest to you does 32-bit addressing (or doesn't require it; *note +Machine Dependencies::), you can ignore this issue. + + In order to assemble compiler output into something that works, `as' +occasionlly does strange things to `.word' directives. Directives of +the form `.word sym1-sym2' are often emitted by compilers as part of +jump tables. Therefore, when `as' assembles a directive of the form +`.word sym1-sym2', and the difference between `sym1' and `sym2' does +not fit in 16 bits, `as' creates a "secondary jump table", immediately +before the next label. This secondary jump table is preceded by a +short-jump to the first byte after the secondary table. This +short-jump prevents the flow of control from accidentally falling into +the new table. Inside the table is a long-jump to `sym2'. The +original `.word' contains `sym1' minus the address of the long-jump to +`sym2'. + + If there were several occurrences of `.word sym1-sym2' before the +secondary jump table, all of them are adjusted. If there was a `.word +sym3-sym4', that also did not fit in sixteen bits, a long-jump to +`sym4' is included in the secondary jump table, and the `.word' +directives are adjusted to contain `sym3' minus the address of the +long-jump to `sym4'; and so on, for as many entries in the original +jump table as necessary. + + +File: as.info, Node: Deprecated, Prev: Word, Up: Pseudo Ops + +Deprecated Directives +===================== + + One day these directives won't work. They are included for +compatibility with older assemblers. +.abort + +.line + +File: as.info, Node: Machine Dependencies, Next: Reporting Bugs, Prev: Pseudo Ops, Up: Top + +Machine Dependent Features +************************** + + The machine instruction sets are (almost by definition) different on +each machine where `as' runs. Floating point representations vary as +well, and `as' often supports a few additional directives or +command-line options for compatibility with other assemblers on a +particular platform. Finally, some versions of `as' support special +pseudo-instructions for branch optimization. + + This chapter discusses most of these differences, though it does not +include details on any machine's instruction set. For details on that +subject, see the hardware manufacturer's manual. + +* Menu: + + +* AMD29K-Dependent:: AMD 29K Dependent Features + +* ARC-Dependent:: ARC Dependent Features + +* ARM-Dependent:: ARM Dependent Features + +* D10V-Dependent:: D10V Dependent Features + +* D30V-Dependent:: D30V Dependent Features + +* H8/300-Dependent:: Hitachi H8/300 Dependent Features + +* H8/500-Dependent:: Hitachi H8/500 Dependent Features + +* HPPA-Dependent:: HPPA Dependent Features + +* ESA/390-Dependent:: IBM ESA/390 Dependent Features + +* i386-Dependent:: Intel 80386 Dependent Features + +* i960-Dependent:: Intel 80960 Dependent Features + +* M68K-Dependent:: M680x0 Dependent Features + +* MIPS-Dependent:: MIPS Dependent Features + +* SH-Dependent:: Hitachi SH Dependent Features + +* PJ-Dependent:: picoJava Dependent Features + +* Sparc-Dependent:: SPARC Dependent Features + +* V850-Dependent:: V850 Dependent Features + +* Z8000-Dependent:: Z8000 Dependent Features + +* Vax-Dependent:: VAX Dependent Features + + +File: as.info, Node: ARC-Dependent, Next: ARM-Dependent, Prev: AMD29K-Dependent, Up: Machine Dependencies + +ARC Dependent Features +====================== + +* Menu: + +* ARC-Opts:: Options +* ARC-Float:: Floating Point +* ARC-Directives:: Sparc Machine Directives + + +File: as.info, Node: ARC-Opts, Next: ARC-Float, Up: ARC-Dependent + +Options +------- + + The ARC chip family includes several successive levels (or other +variants) of chip, using the same core instruction set, but including a +few additional instructions at each level. + + By default, `as' assumes the core instruction set (ARC base). The +`.cpu' pseudo-op is intended to be used to select the variant. + +`-mbig-endian' +`-mlittle-endian' + Any ARC configuration of `as' can select big-endian or + little-endian output at run time (unlike most other GNU development + tools, which must be configured for one or the other). Use + `-mbig-endian' to select big-endian output, and `-mlittle-endian' + for little-endian. + + +File: as.info, Node: ARC-Float, Next: ARC-Directives, Prev: ARC-Opts, Up: ARC-Dependent + +Floating Point +-------------- + + The ARC cpu family currently does not have hardware floating point +support. Software floating point support is provided by `GCC' and uses +IEEE floating-point numbers. + + +File: as.info, Node: ARC-Directives, Prev: ARC-Float, Up: ARC-Dependent + +ARC Machine Directives +---------------------- + + The ARC version of `as' supports the following additional machine +directives: + +`.cpu' + This must be followed by the desired cpu. The ARC is intended to + be customizable, `.cpu' is used to select the desired variant + [though currently there are none]. + + +File: as.info, Node: AMD29K-Dependent, Next: ARC-Dependent, Up: Machine Dependencies + +AMD 29K Dependent Features +========================== + +* Menu: + +* AMD29K Options:: Options +* AMD29K Syntax:: Syntax +* AMD29K Floating Point:: Floating Point +* AMD29K Directives:: AMD 29K Machine Directives +* AMD29K Opcodes:: Opcodes + + +File: as.info, Node: AMD29K Options, Next: AMD29K Syntax, Up: AMD29K-Dependent + +Options +------- + + `as' has no additional command-line options for the AMD 29K family. + + +File: as.info, Node: AMD29K Syntax, Next: AMD29K Floating Point, Prev: AMD29K Options, Up: AMD29K-Dependent + +Syntax +------ + +* Menu: + +* AMD29K-Macros:: Macros +* AMD29K-Chars:: Special Characters +* AMD29K-Regs:: Register Names + + +File: as.info, Node: AMD29K-Macros, Next: AMD29K-Chars, Up: AMD29K Syntax + +Macros +...... + + The macro syntax used on the AMD 29K is like that described in the +AMD 29K Family Macro Assembler Specification. Normal `as' macros +should still work. + + +File: as.info, Node: AMD29K-Chars, Next: AMD29K-Regs, Prev: AMD29K-Macros, Up: AMD29K Syntax + +Special Characters +.................. + + `;' is the line comment character. + + The character `?' is permitted in identifiers (but may not begin an +identifier). + + +File: as.info, Node: AMD29K-Regs, Prev: AMD29K-Chars, Up: AMD29K Syntax + +Register Names +.............. + + General-purpose registers are represented by predefined symbols of +the form `GRNNN' (for global registers) or `LRNNN' (for local +registers), where NNN represents a number between `0' and `127', +written with no leading zeros. The leading letters may be in either +upper or lower case; for example, `gr13' and `LR7' are both valid +register names. + + You may also refer to general-purpose registers by specifying the +register number as the result of an expression (prefixed with `%%' to +flag the expression as a register number): + %%EXPRESSION + +--where EXPRESSION must be an absolute expression evaluating to a +number between `0' and `255'. The range [0, 127] refers to global +registers, and the range [128, 255] to local registers. + + In addition, `as' understands the following protected +special-purpose register names for the AMD 29K family: + + vab chd pc0 + ops chc pc1 + cps rbp pc2 + cfg tmc mmu + cha tmr lru + + These unprotected special-purpose register names are also recognized: + ipc alu fpe + ipa bp inte + ipb fc fps + q cr exop + + +File: as.info, Node: AMD29K Floating Point, Next: AMD29K Directives, Prev: AMD29K Syntax, Up: AMD29K-Dependent + +Floating Point +-------------- + + The AMD 29K family uses IEEE floating-point numbers. + + +File: as.info, Node: AMD29K Directives, Next: AMD29K Opcodes, Prev: AMD29K Floating Point, Up: AMD29K-Dependent + +AMD 29K Machine Directives +-------------------------- + +`.block SIZE , FILL' + This directive emits SIZE bytes, each of value FILL. Both SIZE + and FILL are absolute expressions. If the comma and FILL are + omitted, FILL is assumed to be zero. + + In other versions of the GNU assembler, this directive is called + `.space'. + +`.cputype' + This directive is ignored; it is accepted for compatibility with + other AMD 29K assemblers. + +`.file' + This directive is ignored; it is accepted for compatibility with + other AMD 29K assemblers. + + _Warning:_ in other versions of the GNU assembler, `.file' is + used for the directive called `.app-file' in the AMD 29K + support. + +`.line' + This directive is ignored; it is accepted for compatibility with + other AMD 29K assemblers. + +`.sect' + This directive is ignored; it is accepted for compatibility with + other AMD 29K assemblers. + +`.use SECTION NAME' + Establishes the section and subsection for the following code; + SECTION NAME may be one of `.text', `.data', `.data1', or `.lit'. + With one of the first three SECTION NAME options, `.use' is + equivalent to the machine directive SECTION NAME; the remaining + case, `.use .lit', is the same as `.data 200'. + + +File: as.info, Node: AMD29K Opcodes, Prev: AMD29K Directives, Up: AMD29K-Dependent + +Opcodes +------- + + `as' implements all the standard AMD 29K opcodes. No additional +pseudo-instructions are needed on this family. + + For information on the 29K machine instruction set, see `Am29000 +User's Manual', Advanced Micro Devices, Inc. + + +File: as.info, Node: ARM-Dependent, Next: D10V-Dependent, Prev: ARC-Dependent, Up: Machine Dependencies + +ARM Dependent Features +====================== + +* Menu: + +* ARM Options:: Options +* ARM Syntax:: Syntax +* ARM Floating Point:: Floating Point +* ARM Directives:: ARM Machine Directives +* ARM Opcodes:: Opcodes + + +File: as.info, Node: ARM Options, Next: ARM Syntax, Up: ARM-Dependent + +Options +------- + +`-marm [2|250|3|6|60|600|610|620|7|7M|7D|7DM|7DI|7DMI|70|700|700I|710|710C|7100|7500|7500FE|7TDMI|8|810|9|9TDMI|920|STRONGARM|STRONGARM110|STRONGARM1100]' + This option specifies the target processor. The assembler will + issue an error message if an attempt is made to assemble an + instruction which will not execute on the target processor. + +`-marmv [2|2A|3|3M|4|4T|5|5T]' + This option specifies the target architecture. The assembler will + issue an error message if an attempt is made to assemble an + instruction which will not execute on the target architecture. + +`-mthumb' + This option specifies that only Thumb instructions should be + assembled. + +`-mall' + This option specifies that any Arm or Thumb instruction should be + assembled. + +`-mfpa [10|11]' + This option specifies the floating point architecture in use on the + target processor. + +`-mfpe-old' + Do not allow the assemble of floating point multiple instructions. + +`-mno-fpu' + Do not allow the assembly of any floating point instructions. + +`-mthumb-interwork' + This option specifies that the output generated by the assembler + should be marked as supporting interworking. + +`-mapcs [26|32]' + This option specifies that the output generated by the assembler + should be marked as supporting the indicated version of the Arm + Procedure. Calling Standard. + +`-mapcs-float' + This indicates the the floating point variant of the APCS should be + used. In this variant floating point arguments are passed in FP + registers rather than integer registers. + +`-mapcs-reentrant' + This indicates that the reentrant variant of the APCS should be + used. This variant supports position independent code. + +`-EB' + This option specifies that the output generated by the assembler + should be marked as being encoded for a big-endian processor. + +`-EL' + This option specifies that the output generated by the assembler + should be marked as being encoded for a little-endian processor. + +`-k' + This option enables the generation of PIC (position independent + code). + +`-moabi' + This indicates that the code should be assembled using the old ARM + ELF conventions, based on a beta release release of the ARM-ELF + specifications, rather than the default conventions which are + based on the final release of the ARM-ELF specifications. + + +File: as.info, Node: ARM Syntax, Next: ARM Floating Point, Prev: ARM Options, Up: ARM-Dependent + +Syntax +------ + +* Menu: + +* ARM-Chars:: Special Characters +* ARM-Regs:: Register Names + + +File: as.info, Node: ARM-Chars, Next: ARM-Regs, Up: ARM Syntax + +Special Characters +.................. + + The presence of a `@' on a line indicates the start of a comment +that extends to the end of the current line. If a `#' appears as the +first character of a line, the whole line is treated as a comment. + + On ARM systems running the GNU/Linux operating system, `;' can be +used instead of a newline to separate statements. + + Either `#' or `$' can be used to indicate immediate operands. + + *TODO* Explain about /data modifier on symbols. + + +File: as.info, Node: ARM-Regs, Prev: ARM-Chars, Up: ARM Syntax + +Register Names +.............. + + *TODO* Explain about ARM register naming, and the predefined names. + + +File: as.info, Node: ARM Floating Point, Next: ARM Directives, Prev: ARM Syntax, Up: ARM-Dependent + +Floating Point +-------------- + + The ARM family uses IEEE floating-point numbers. + + +File: as.info, Node: ARM Directives, Next: ARM Opcodes, Prev: ARM Floating Point, Up: ARM-Dependent + +ARM Machine Directives +---------------------- + +`NAME .req REGISTER NAME' + This creates an alias for REGISTER NAME called NAME. For example: + + foo .req r0 + +`.code [16|32]' + This directive selects the instruction set being generated. The + value 16 selects Thumb, with the value 32 selecting ARM. + +`.thumb' + This performs the same action as .CODE 16. + +`.arm' + This performs the same action as .CODE 32. + +`.force_thumb' + This directive forces the selection of Thumb instructions, even if + the target processor does not support those instructions + +`.thumb_func' + This directive specifies that the following symbol is the name of a + Thumb encoded function. This information is necessary in order to + allow the assembler and linker to generate correct code for + interworking between Arm and Thumb instructions and should be used + even if interworking is not going to be performed. + +`.thumb_set' + This performs the equivalent of a `.set' directive in that it + creates a symbol which is an alias for another symbol (possibly + not yet defined). This directive also has the added property in + that it marks the aliased symbol as being a thumb function entry + point, in the same way that the `.thumb_func' directive does. + +`.ltorg' + This directive causes the current contents of the literal pool to + be dumped into the current section (which is assumed to be the + .text section) at the current location (aligned to a word + boundary). + +`.pool' + This is a synonym for .ltorg. + + +File: as.info, Node: ARM Opcodes, Prev: ARM Directives, Up: ARM-Dependent + +Opcodes +------- + + `as' implements all the standard ARM opcodes. It also implements +several pseudo opcodes, including several synthetic load instructions. + +`NOP' + nop + + This pseudo op will always evaluate to a legal ARM instruction + that does nothing. Currently it will evaluate to MOV r0, r0. + +`LDR' + ldr <register> , = <expression> + + If expression evaluates to a numeric constant then a MOV or MVN + instruction will be used in place of the LDR instruction, if the + constant can be generated by either of these instructions. + Otherwise the constant will be placed into the nearest literal + pool (if it not already there) and a PC relative LDR instruction + will be generated. + +`ADR' + adr <register> <label> + + This instruction will load the address of LABEL into the indicated + register. The instruction will evaluate to a PC relative ADD or + SUB instruction depending upon where the label is located. If the + label is out of range, or if it is not defined in the same file + (and section) as the ADR instruction, then an error will be + generated. This instruction will not make use of the literal pool. + +`ADRL' + adrl <register> <label> + + This instruction will load the address of LABEL into the indicated + register. The instruction will evaluate to one or two a PC + relative ADD or SUB instructions depending upon where the label is + located. If a second instruction is not needed a NOP instruction + will be generated in its place, so that this instruction is always + 8 bytes long. + + If the label is out of range, or if it is not defined in the same + file (and section) as the ADRL instruction, then an error will be + generated. This instruction will not make use of the literal pool. + + For information on the ARM or Thumb instruction sets, see `ARM +Software Development Toolkit Reference Manual', Advanced RISC Machines +Ltd. + + +File: as.info, Node: D10V-Dependent, Next: D30V-Dependent, Prev: ARM-Dependent, Up: Machine Dependencies + +D10V Dependent Features +======================= + +* Menu: + +* D10V-Opts:: D10V Options +* D10V-Syntax:: Syntax +* D10V-Float:: Floating Point +* D10V-Opcodes:: Opcodes + + +File: as.info, Node: D10V-Opts, Next: D10V-Syntax, Up: D10V-Dependent + +D10V Options +------------ + + The Mitsubishi D10V version of `as' has a few machine dependent +options. + +`-O' + The D10V can often execute two sub-instructions in parallel. When + this option is used, `as' will attempt to optimize its output by + detecting when instructions can be executed in parallel. + +`--nowarnswap' + To optimize execution performance, `as' will sometimes swap the + order of instructions. Normally this generates a warning. When + this option is used, no warning will be generated when + instructions are swapped. + + +File: as.info, Node: D10V-Syntax, Next: D10V-Float, Prev: D10V-Opts, Up: D10V-Dependent + +Syntax +------ + + The D10V syntax is based on the syntax in Mitsubishi's D10V +architecture manual. The differences are detailed below. + +* Menu: + +* D10V-Size:: Size Modifiers +* D10V-Subs:: Sub-Instructions +* D10V-Chars:: Special Characters +* D10V-Regs:: Register Names +* D10V-Addressing:: Addressing Modes +* D10V-Word:: @WORD Modifier + + +File: as.info, Node: D10V-Size, Next: D10V-Subs, Up: D10V-Syntax + +Size Modifiers +.............. + + The D10V version of `as' uses the instruction names in the D10V +Architecture Manual. However, the names in the manual are sometimes +ambiguous. There are instruction names that can assemble to a short or +long form opcode. How does the assembler pick the correct form? `as' +will always pick the smallest form if it can. When dealing with a +symbol that is not defined yet when a line is being assembled, it will +always use the long form. If you need to force the assembler to use +either the short or long form of the instruction, you can append either +`.s' (short) or `.l' (long) to it. For example, if you are writing an +assembly program and you want to do a branch to a symbol that is +defined later in your program, you can write `bra.s foo'. Objdump +and GDB will always append `.s' or `.l' to instructions which have both +short and long forms. + diff --git a/gas/doc/as.info-4 b/gas/doc/as.info-4 new file mode 100644 index 00000000000..b0921e07258 --- /dev/null +++ b/gas/doc/as.info-4 @@ -0,0 +1,1507 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: D10V-Subs, Next: D10V-Chars, Prev: D10V-Size, Up: D10V-Syntax + +Sub-Instructions +................ + + The D10V assembler takes as input a series of instructions, either +one-per-line, or in the special two-per-line format described in the +next section. Some of these instructions will be short-form or +sub-instructions. These sub-instructions can be packed into a single +instruction. The assembler will do this automatically. It will also +detect when it should not pack instructions. For example, when a label +is defined, the next instruction will never be packaged with the +previous one. Whenever a branch and link instruction is called, it +will not be packaged with the next instruction so the return address +will be valid. Nops are automatically inserted when necessary. + + If you do not want the assembler automatically making these +decisions, you can control the packaging and execution type (parallel +or sequential) with the special execution symbols described in the next +section. + + +File: as.info, Node: D10V-Chars, Next: D10V-Regs, Prev: D10V-Subs, Up: D10V-Syntax + +Special Characters +.................. + + `;' and `#' are the line comment characters. Sub-instructions may +be executed in order, in reverse-order, or in parallel. Instructions +listed in the standard one-per-line format will be executed +sequentially. To specify the executing order, use the following +symbols: +`->' + Sequential with instruction on the left first. + +`<-' + Sequential with instruction on the right first. + +`||' + Parallel The D10V syntax allows either one instruction per line, +one instruction per line with the execution symbol, or two instructions +per line. For example +`abs a1 -> abs r0' + Execute these sequentially. The instruction on the right is in + the right container and is executed second. + +`abs r0 <- abs a1' + Execute these reverse-sequentially. The instruction on the right + is in the right container, and is executed first. + +`ld2w r2,@r8+ || mac a0,r0,r7' + Execute these in parallel. + +`ld2w r2,@r8+ ||' +`mac a0,r0,r7' + Two-line format. Execute these in parallel. + +`ld2w r2,@r8+' +`mac a0,r0,r7' + Two-line format. Execute these sequentially. Assembler will put + them in the proper containers. + +`ld2w r2,@r8+ ->' +`mac a0,r0,r7' + Two-line format. Execute these sequentially. Same as above but + second instruction will always go into right container. Since `$' +has no special meaning, you may use it in symbol names. + + +File: as.info, Node: D10V-Regs, Next: D10V-Addressing, Prev: D10V-Chars, Up: D10V-Syntax + +Register Names +.............. + + You can use the predefined symbols `r0' through `r15' to refer to +the D10V registers. You can also use `sp' as an alias for `r15'. The +accumulators are `a0' and `a1'. There are special register-pair names +that may optionally be used in opcodes that require even-numbered +registers. Register names are not case sensitive. + + Register Pairs +`r0-r1' + +`r2-r3' + +`r4-r5' + +`r6-r7' + +`r8-r9' + +`r10-r11' + +`r12-r13' + +`r14-r15' + The D10V also has predefined symbols for these control registers and +status bits: +`psw' + Processor Status Word + +`bpsw' + Backup Processor Status Word + +`pc' + Program Counter + +`bpc' + Backup Program Counter + +`rpt_c' + Repeat Count + +`rpt_s' + Repeat Start address + +`rpt_e' + Repeat End address + +`mod_s' + Modulo Start address + +`mod_e' + Modulo End address + +`iba' + Instruction Break Address + +`f0' + Flag 0 + +`f1' + Flag 1 + +`c' + Carry flag + + +File: as.info, Node: D10V-Addressing, Next: D10V-Word, Prev: D10V-Regs, Up: D10V-Syntax + +Addressing Modes +................ + + `as' understands the following addressing modes for the D10V. `RN' +in the following refers to any of the numbered registers, but _not_ the +control registers. +`RN' + Register direct + +`@RN' + Register indirect + +`@RN+' + Register indirect with post-increment + +`@RN-' + Register indirect with post-decrement + +`@-SP' + Register indirect with pre-decrement + +`@(DISP, RN)' + Register indirect with displacement + +`ADDR' + PC relative address (for branch or rep). + +`#IMM' + Immediate data (the `#' is optional and ignored) + + +File: as.info, Node: D10V-Word, Prev: D10V-Addressing, Up: D10V-Syntax + +@WORD Modifier +.............. + + Any symbol followed by `@word' will be replaced by the symbol's value +shifted right by 2. This is used in situations such as loading a +register with the address of a function (or any other code fragment). +For example, if you want to load a register with the location of the +function `main' then jump to that function, you could do it as follws: + ldi r2, main@word + jmp r2 + + +File: as.info, Node: D10V-Float, Next: D10V-Opcodes, Prev: D10V-Syntax, Up: D10V-Dependent + +Floating Point +-------------- + + The D10V has no hardware floating point, but the `.float' and +`.double' directives generates IEEE floating-point numbers for +compatibility with other development tools. + + +File: as.info, Node: D10V-Opcodes, Prev: D10V-Float, Up: D10V-Dependent + +Opcodes +------- + + For detailed information on the D10V machine instruction set, see +`D10V Architecture: A VLIW Microprocessor for Multimedia Applications' +(Mitsubishi Electric Corp.). `as' implements all the standard D10V +opcodes. The only changes are those described in the section on size +modifiers + + +File: as.info, Node: D30V-Dependent, Next: H8/300-Dependent, Prev: D10V-Dependent, Up: Machine Dependencies + +D30V Dependent Features +======================= + +* Menu: + +* D30V-Opts:: D30V Options +* D30V-Syntax:: Syntax +* D30V-Float:: Floating Point +* D30V-Opcodes:: Opcodes + + +File: as.info, Node: D30V-Opts, Next: D30V-Syntax, Up: D30V-Dependent + +D30V Options +------------ + + The Mitsubishi D30V version of `as' has a few machine dependent +options. + +`-O' + The D30V can often execute two sub-instructions in parallel. When + this option is used, `as' will attempt to optimize its output by + detecting when instructions can be executed in parallel. + +`-n' + When this option is used, `as' will issue a warning every time it + adds a nop instruction. + +`-N' + When this option is used, `as' will issue a warning if it needs to + insert a nop after a 32-bit multiply before a load or 16-bit + multiply instruction. + + +File: as.info, Node: D30V-Syntax, Next: D30V-Float, Prev: D30V-Opts, Up: D30V-Dependent + +Syntax +------ + + The D30V syntax is based on the syntax in Mitsubishi's D30V +architecture manual. The differences are detailed below. + +* Menu: + +* D30V-Size:: Size Modifiers +* D30V-Subs:: Sub-Instructions +* D30V-Chars:: Special Characters +* D30V-Guarded:: Guarded Execution +* D30V-Regs:: Register Names +* D30V-Addressing:: Addressing Modes + + +File: as.info, Node: D30V-Size, Next: D30V-Subs, Up: D30V-Syntax + +Size Modifiers +.............. + + The D30V version of `as' uses the instruction names in the D30V +Architecture Manual. However, the names in the manual are sometimes +ambiguous. There are instruction names that can assemble to a short or +long form opcode. How does the assembler pick the correct form? `as' +will always pick the smallest form if it can. When dealing with a +symbol that is not defined yet when a line is being assembled, it will +always use the long form. If you need to force the assembler to use +either the short or long form of the instruction, you can append either +`.s' (short) or `.l' (long) to it. For example, if you are writing an +assembly program and you want to do a branch to a symbol that is +defined later in your program, you can write `bra.s foo'. Objdump and +GDB will always append `.s' or `.l' to instructions which have both +short and long forms. + + +File: as.info, Node: D30V-Subs, Next: D30V-Chars, Prev: D30V-Size, Up: D30V-Syntax + +Sub-Instructions +................ + + The D30V assembler takes as input a series of instructions, either +one-per-line, or in the special two-per-line format described in the +next section. Some of these instructions will be short-form or +sub-instructions. These sub-instructions can be packed into a single +instruction. The assembler will do this automatically. It will also +detect when it should not pack instructions. For example, when a label +is defined, the next instruction will never be packaged with the +previous one. Whenever a branch and link instruction is called, it +will not be packaged with the next instruction so the return address +will be valid. Nops are automatically inserted when necessary. + + If you do not want the assembler automatically making these +decisions, you can control the packaging and execution type (parallel +or sequential) with the special execution symbols described in the next +section. + + +File: as.info, Node: D30V-Chars, Next: D30V-Guarded, Prev: D30V-Subs, Up: D30V-Syntax + +Special Characters +.................. + + `;' and `#' are the line comment characters. Sub-instructions may +be executed in order, in reverse-order, or in parallel. Instructions +listed in the standard one-per-line format will be executed +sequentially unless you use the `-O' option. + + To specify the executing order, use the following symbols: +`->' + Sequential with instruction on the left first. + +`<-' + Sequential with instruction on the right first. + +`||' + Parallel + + The D30V syntax allows either one instruction per line, one +instruction per line with the execution symbol, or two instructions per +line. For example +`abs r2,r3 -> abs r4,r5' + Execute these sequentially. The instruction on the right is in + the right container and is executed second. + +`abs r2,r3 <- abs r4,r5' + Execute these reverse-sequentially. The instruction on the right + is in the right container, and is executed first. + +`abs r2,r3 || abs r4,r5' + Execute these in parallel. + +`ldw r2,@(r3,r4) ||' +`mulx r6,r8,r9' + Two-line format. Execute these in parallel. + +`mulx a0,r8,r9' +`stw r2,@(r3,r4)' + Two-line format. Execute these sequentially unless `-O' option is + used. If the `-O' option is used, the assembler will determine if + the instructions could be done in parallel (the above two + instructions can be done in parallel), and if so, emit them as + parallel instructions. The assembler will put them in the proper + containers. In the above example, the assembler will put the + `stw' instruction in left container and the `mulx' instruction in + the right container. + +`stw r2,@(r3,r4) ->' +`mulx a0,r8,r9' + Two-line format. Execute the `stw' instruction followed by the + `mulx' instruction sequentially. The first instruction goes in the + left container and the second instruction goes into right + container. The assembler will give an error if the machine + ordering constraints are violated. + +`stw r2,@(r3,r4) <-' +`mulx a0,r8,r9' + Same as previous example, except that the `mulx' instruction is + executed before the `stw' instruction. + + Since `$' has no special meaning, you may use it in symbol names. + + +File: as.info, Node: D30V-Guarded, Next: D30V-Regs, Prev: D30V-Chars, Up: D30V-Syntax + +Guarded Execution +................. + + `as' supports the full range of guarded execution directives for +each instruction. Just append the directive after the instruction +proper. The directives are: + +`/tx' + Execute the instruction if flag f0 is true. + +`/fx' + Execute the instruction if flag f0 is false. + +`/xt' + Execute the instruction if flag f1 is true. + +`/xf' + Execute the instruction if flag f1 is false. + +`/tt' + Execute the instruction if both flags f0 and f1 are true. + +`/tf' + Execute the instruction if flag f0 is true and flag f1 is false. + + +File: as.info, Node: D30V-Regs, Next: D30V-Addressing, Prev: D30V-Guarded, Up: D30V-Syntax + +Register Names +.............. + + You can use the predefined symbols `r0' through `r63' to refer to +the D30V registers. You can also use `sp' as an alias for `r63' and +`link' as an alias for `r62'. The accumulators are `a0' and `a1'. + + The D30V also has predefined symbols for these control registers and +status bits: +`psw' + Processor Status Word + +`bpsw' + Backup Processor Status Word + +`pc' + Program Counter + +`bpc' + Backup Program Counter + +`rpt_c' + Repeat Count + +`rpt_s' + Repeat Start address + +`rpt_e' + Repeat End address + +`mod_s' + Modulo Start address + +`mod_e' + Modulo End address + +`iba' + Instruction Break Address + +`f0' + Flag 0 + +`f1' + Flag 1 + +`f2' + Flag 2 + +`f3' + Flag 3 + +`f4' + Flag 4 + +`f5' + Flag 5 + +`f6' + Flag 6 + +`f7' + Flag 7 + +`s' + Same as flag 4 (saturation flag) + +`v' + Same as flag 5 (overflow flag) + +`va' + Same as flag 6 (sticky overflow flag) + +`c' + Same as flag 7 (carry/borrow flag) + +`b' + Same as flag 7 (carry/borrow flag) + + +File: as.info, Node: D30V-Addressing, Prev: D30V-Regs, Up: D30V-Syntax + +Addressing Modes +................ + + `as' understands the following addressing modes for the D30V. `RN' +in the following refers to any of the numbered registers, but _not_ the +control registers. +`RN' + Register direct + +`@RN' + Register indirect + +`@RN+' + Register indirect with post-increment + +`@RN-' + Register indirect with post-decrement + +`@-SP' + Register indirect with pre-decrement + +`@(DISP, RN)' + Register indirect with displacement + +`ADDR' + PC relative address (for branch or rep). + +`#IMM' + Immediate data (the `#' is optional and ignored) + + +File: as.info, Node: D30V-Float, Next: D30V-Opcodes, Prev: D30V-Syntax, Up: D30V-Dependent + +Floating Point +-------------- + + The D30V has no hardware floating point, but the `.float' and +`.double' directives generates IEEE floating-point numbers for +compatibility with other development tools. + + +File: as.info, Node: D30V-Opcodes, Prev: D30V-Float, Up: D30V-Dependent + +Opcodes +------- + + For detailed information on the D30V machine instruction set, see +`D30V Architecture: A VLIW Microprocessor for Multimedia Applications' +(Mitsubishi Electric Corp.). `as' implements all the standard D30V +opcodes. The only changes are those described in the section on size +modifiers + + +File: as.info, Node: H8/300-Dependent, Next: H8/500-Dependent, Prev: D30V-Dependent, Up: Machine Dependencies + +H8/300 Dependent Features +========================= + +* Menu: + +* H8/300 Options:: Options +* H8/300 Syntax:: Syntax +* H8/300 Floating Point:: Floating Point +* H8/300 Directives:: H8/300 Machine Directives +* H8/300 Opcodes:: Opcodes + + +File: as.info, Node: H8/300 Options, Next: H8/300 Syntax, Up: H8/300-Dependent + +Options +------- + + `as' has no additional command-line options for the Hitachi H8/300 +family. + + +File: as.info, Node: H8/300 Syntax, Next: H8/300 Floating Point, Prev: H8/300 Options, Up: H8/300-Dependent + +Syntax +------ + +* Menu: + +* H8/300-Chars:: Special Characters +* H8/300-Regs:: Register Names +* H8/300-Addressing:: Addressing Modes + + +File: as.info, Node: H8/300-Chars, Next: H8/300-Regs, Up: H8/300 Syntax + +Special Characters +.................. + + `;' is the line comment character. + + `$' can be used instead of a newline to separate statements. +Therefore _you may not use `$' in symbol names_ on the H8/300. + + +File: as.info, Node: H8/300-Regs, Next: H8/300-Addressing, Prev: H8/300-Chars, Up: H8/300 Syntax + +Register Names +.............. + + You can use predefined symbols of the form `rNh' and `rNl' to refer +to the H8/300 registers as sixteen 8-bit general-purpose registers. N +is a digit from `0' to `7'); for instance, both `r0h' and `r7l' are +valid register names. + + You can also use the eight predefined symbols `rN' to refer to the +H8/300 registers as 16-bit registers (you must use this form for +addressing). + + On the H8/300H, you can also use the eight predefined symbols `erN' +(`er0' ... `er7') to refer to the 32-bit general purpose registers. + + The two control registers are called `pc' (program counter; a 16-bit +register, except on the H8/300H where it is 24 bits) and `ccr' +(condition code register; an 8-bit register). `r7' is used as the +stack pointer, and can also be called `sp'. + + +File: as.info, Node: H8/300-Addressing, Prev: H8/300-Regs, Up: H8/300 Syntax + +Addressing Modes +................ + + as understands the following addressing modes for the H8/300: +`rN' + Register direct + +`@rN' + Register indirect + +`@(D, rN)' +`@(D:16, rN)' +`@(D:24, rN)' + Register indirect: 16-bit or 24-bit displacement D from register + N. (24-bit displacements are only meaningful on the H8/300H.) + +`@rN+' + Register indirect with post-increment + +`@-rN' + Register indirect with pre-decrement + +``@'AA' +``@'AA:8' +``@'AA:16' +``@'AA:24' + Absolute address `aa'. (The address size `:24' only makes sense + on the H8/300H.) + +`#XX' +`#XX:8' +`#XX:16' +`#XX:32' + Immediate data XX. You may specify the `:8', `:16', or `:32' for + clarity, if you wish; but `as' neither requires this nor uses + it--the data size required is taken from context. + +``@'`@'AA' +``@'`@'AA:8' + Memory indirect. You may specify the `:8' for clarity, if you + wish; but `as' neither requires this nor uses it. + + +File: as.info, Node: H8/300 Floating Point, Next: H8/300 Directives, Prev: H8/300 Syntax, Up: H8/300-Dependent + +Floating Point +-------------- + + The H8/300 family has no hardware floating point, but the `.float' +directive generates IEEE floating-point numbers for compatibility with +other development tools. + + +File: as.info, Node: H8/300 Directives, Next: H8/300 Opcodes, Prev: H8/300 Floating Point, Up: H8/300-Dependent + +H8/300 Machine Directives +------------------------- + + `as' has only one machine-dependent directive for the H8/300: + +`.h8300h' + Recognize and emit additional instructions for the H8/300H + variant, and also make `.int' emit 32-bit numbers rather than the + usual (16-bit) for the H8/300 family. + + On the H8/300 family (including the H8/300H) `.word' directives +generate 16-bit numbers. + + +File: as.info, Node: H8/300 Opcodes, Prev: H8/300 Directives, Up: H8/300-Dependent + +Opcodes +------- + + For detailed information on the H8/300 machine instruction set, see +`H8/300 Series Programming Manual' (Hitachi ADE-602-025). For +information specific to the H8/300H, see `H8/300H Series Programming +Manual' (Hitachi). + + `as' implements all the standard H8/300 opcodes. No additional +pseudo-instructions are needed on this family. + + The following table summarizes the H8/300 opcodes, and their +arguments. Entries marked `*' are opcodes used only on the H8/300H. + + Legend: + Rs source register + Rd destination register + abs absolute address + imm immediate data + disp:N N-bit displacement from a register + pcrel:N N-bit displacement relative to program counter + + add.b #imm,rd * andc #imm,ccr + add.b rs,rd band #imm,rd + add.w rs,rd band #imm,@rd + * add.w #imm,rd band #imm,@abs:8 + * add.l rs,rd bra pcrel:8 + * add.l #imm,rd * bra pcrel:16 + adds #imm,rd bt pcrel:8 + addx #imm,rd * bt pcrel:16 + addx rs,rd brn pcrel:8 + and.b #imm,rd * brn pcrel:16 + and.b rs,rd bf pcrel:8 + * and.w rs,rd * bf pcrel:16 + * and.w #imm,rd bhi pcrel:8 + * and.l #imm,rd * bhi pcrel:16 + * and.l rs,rd bls pcrel:8 + + * bls pcrel:16 bld #imm,rd + bcc pcrel:8 bld #imm,@rd + * bcc pcrel:16 bld #imm,@abs:8 + bhs pcrel:8 bnot #imm,rd + * bhs pcrel:16 bnot #imm,@rd + bcs pcrel:8 bnot #imm,@abs:8 + * bcs pcrel:16 bnot rs,rd + blo pcrel:8 bnot rs,@rd + * blo pcrel:16 bnot rs,@abs:8 + bne pcrel:8 bor #imm,rd + * bne pcrel:16 bor #imm,@rd + beq pcrel:8 bor #imm,@abs:8 + * beq pcrel:16 bset #imm,rd + bvc pcrel:8 bset #imm,@rd + * bvc pcrel:16 bset #imm,@abs:8 + bvs pcrel:8 bset rs,rd + * bvs pcrel:16 bset rs,@rd + bpl pcrel:8 bset rs,@abs:8 + * bpl pcrel:16 bsr pcrel:8 + bmi pcrel:8 bsr pcrel:16 + * bmi pcrel:16 bst #imm,rd + bge pcrel:8 bst #imm,@rd + * bge pcrel:16 bst #imm,@abs:8 + blt pcrel:8 btst #imm,rd + * blt pcrel:16 btst #imm,@rd + bgt pcrel:8 btst #imm,@abs:8 + * bgt pcrel:16 btst rs,rd + ble pcrel:8 btst rs,@rd + * ble pcrel:16 btst rs,@abs:8 + bclr #imm,rd bxor #imm,rd + bclr #imm,@rd bxor #imm,@rd + bclr #imm,@abs:8 bxor #imm,@abs:8 + bclr rs,rd cmp.b #imm,rd + bclr rs,@rd cmp.b rs,rd + bclr rs,@abs:8 cmp.w rs,rd + biand #imm,rd cmp.w rs,rd + biand #imm,@rd * cmp.w #imm,rd + biand #imm,@abs:8 * cmp.l #imm,rd + bild #imm,rd * cmp.l rs,rd + bild #imm,@rd daa rs + bild #imm,@abs:8 das rs + bior #imm,rd dec.b rs + bior #imm,@rd * dec.w #imm,rd + bior #imm,@abs:8 * dec.l #imm,rd + bist #imm,rd divxu.b rs,rd + bist #imm,@rd * divxu.w rs,rd + bist #imm,@abs:8 * divxs.b rs,rd + bixor #imm,rd * divxs.w rs,rd + bixor #imm,@rd eepmov + bixor #imm,@abs:8 * eepmovw + + * exts.w rd mov.w rs,@abs:16 + * exts.l rd * mov.l #imm,rd + * extu.w rd * mov.l rs,rd + * extu.l rd * mov.l @rs,rd + inc rs * mov.l @(disp:16,rs),rd + * inc.w #imm,rd * mov.l @(disp:24,rs),rd + * inc.l #imm,rd * mov.l @rs+,rd + jmp @rs * mov.l @abs:16,rd + jmp abs * mov.l @abs:24,rd + jmp @@abs:8 * mov.l rs,@rd + jsr @rs * mov.l rs,@(disp:16,rd) + jsr abs * mov.l rs,@(disp:24,rd) + jsr @@abs:8 * mov.l rs,@-rd + ldc #imm,ccr * mov.l rs,@abs:16 + ldc rs,ccr * mov.l rs,@abs:24 + * ldc @abs:16,ccr movfpe @abs:16,rd + * ldc @abs:24,ccr movtpe rs,@abs:16 + * ldc @(disp:16,rs),ccr mulxu.b rs,rd + * ldc @(disp:24,rs),ccr * mulxu.w rs,rd + * ldc @rs+,ccr * mulxs.b rs,rd + * ldc @rs,ccr * mulxs.w rs,rd + * mov.b @(disp:24,rs),rd neg.b rs + * mov.b rs,@(disp:24,rd) * neg.w rs + mov.b @abs:16,rd * neg.l rs + mov.b rs,rd nop + mov.b @abs:8,rd not.b rs + mov.b rs,@abs:8 * not.w rs + mov.b rs,rd * not.l rs + mov.b #imm,rd or.b #imm,rd + mov.b @rs,rd or.b rs,rd + mov.b @(disp:16,rs),rd * or.w #imm,rd + mov.b @rs+,rd * or.w rs,rd + mov.b @abs:8,rd * or.l #imm,rd + mov.b rs,@rd * or.l rs,rd + mov.b rs,@(disp:16,rd) orc #imm,ccr + mov.b rs,@-rd pop.w rs + mov.b rs,@abs:8 * pop.l rs + mov.w rs,@rd push.w rs + * mov.w @(disp:24,rs),rd * push.l rs + * mov.w rs,@(disp:24,rd) rotl.b rs + * mov.w @abs:24,rd * rotl.w rs + * mov.w rs,@abs:24 * rotl.l rs + mov.w rs,rd rotr.b rs + mov.w #imm,rd * rotr.w rs + mov.w @rs,rd * rotr.l rs + mov.w @(disp:16,rs),rd rotxl.b rs + mov.w @rs+,rd * rotxl.w rs + mov.w @abs:16,rd * rotxl.l rs + mov.w rs,@(disp:16,rd) rotxr.b rs + mov.w rs,@-rd * rotxr.w rs + + * rotxr.l rs * stc ccr,@(disp:24,rd) + bpt * stc ccr,@-rd + rte * stc ccr,@abs:16 + rts * stc ccr,@abs:24 + shal.b rs sub.b rs,rd + * shal.w rs sub.w rs,rd + * shal.l rs * sub.w #imm,rd + shar.b rs * sub.l rs,rd + * shar.w rs * sub.l #imm,rd + * shar.l rs subs #imm,rd + shll.b rs subx #imm,rd + * shll.w rs subx rs,rd + * shll.l rs * trapa #imm + shlr.b rs xor #imm,rd + * shlr.w rs xor rs,rd + * shlr.l rs * xor.w #imm,rd + sleep * xor.w rs,rd + stc ccr,rd * xor.l #imm,rd + * stc ccr,@rs * xor.l rs,rd + * stc ccr,@(disp:16,rd) xorc #imm,ccr + + Four H8/300 instructions (`add', `cmp', `mov', `sub') are defined +with variants using the suffixes `.b', `.w', and `.l' to specify the +size of a memory operand. `as' supports these suffixes, but does not +require them; since one of the operands is always a register, `as' can +deduce the correct size. + + For example, since `r0' refers to a 16-bit register, + mov r0,@foo +is equivalent to + mov.w r0,@foo + + If you use the size suffixes, `as' issues a warning when the suffix +and the register size do not match. + + +File: as.info, Node: H8/500-Dependent, Next: HPPA-Dependent, Prev: H8/300-Dependent, Up: Machine Dependencies + +H8/500 Dependent Features +========================= + +* Menu: + +* H8/500 Options:: Options +* H8/500 Syntax:: Syntax +* H8/500 Floating Point:: Floating Point +* H8/500 Directives:: H8/500 Machine Directives +* H8/500 Opcodes:: Opcodes + + +File: as.info, Node: H8/500 Options, Next: H8/500 Syntax, Up: H8/500-Dependent + +Options +------- + + `as' has no additional command-line options for the Hitachi H8/500 +family. + + +File: as.info, Node: H8/500 Syntax, Next: H8/500 Floating Point, Prev: H8/500 Options, Up: H8/500-Dependent + +Syntax +------ + +* Menu: + +* H8/500-Chars:: Special Characters +* H8/500-Regs:: Register Names +* H8/500-Addressing:: Addressing Modes + + +File: as.info, Node: H8/500-Chars, Next: H8/500-Regs, Up: H8/500 Syntax + +Special Characters +.................. + + `!' is the line comment character. + + `;' can be used instead of a newline to separate statements. + + Since `$' has no special meaning, you may use it in symbol names. + + +File: as.info, Node: H8/500-Regs, Next: H8/500-Addressing, Prev: H8/500-Chars, Up: H8/500 Syntax + +Register Names +.............. + + You can use the predefined symbols `r0', `r1', `r2', `r3', `r4', +`r5', `r6', and `r7' to refer to the H8/500 registers. + + The H8/500 also has these control registers: + +`cp' + code pointer + +`dp' + data pointer + +`bp' + base pointer + +`tp' + stack top pointer + +`ep' + extra pointer + +`sr' + status register + +`ccr' + condition code register + + All registers are 16 bits long. To represent 32 bit numbers, use two +adjacent registers; for distant memory addresses, use one of the segment +pointers (`cp' for the program counter; `dp' for `r0'-`r3'; `ep' for +`r4' and `r5'; and `tp' for `r6' and `r7'. + + +File: as.info, Node: H8/500-Addressing, Prev: H8/500-Regs, Up: H8/500 Syntax + +Addressing Modes +................ + + as understands the following addressing modes for the H8/500: +`RN' + Register direct + +`@RN' + Register indirect + +`@(d:8, RN)' + Register indirect with 8 bit signed displacement + +`@(d:16, RN)' + Register indirect with 16 bit signed displacement + +`@-RN' + Register indirect with pre-decrement + +`@RN+' + Register indirect with post-increment + +`@AA:8' + 8 bit absolute address + +`@AA:16' + 16 bit absolute address + +`#XX:8' + 8 bit immediate + +`#XX:16' + 16 bit immediate + + +File: as.info, Node: H8/500 Floating Point, Next: H8/500 Directives, Prev: H8/500 Syntax, Up: H8/500-Dependent + +Floating Point +-------------- + + The H8/500 family has no hardware floating point, but the `.float' +directive generates IEEE floating-point numbers for compatibility with +other development tools. + + +File: as.info, Node: H8/500 Directives, Next: H8/500 Opcodes, Prev: H8/500 Floating Point, Up: H8/500-Dependent + +H8/500 Machine Directives +------------------------- + + `as' has no machine-dependent directives for the H8/500. However, +on this platform the `.int' and `.word' directives generate 16-bit +numbers. + + +File: as.info, Node: H8/500 Opcodes, Prev: H8/500 Directives, Up: H8/500-Dependent + +Opcodes +------- + + For detailed information on the H8/500 machine instruction set, see +`H8/500 Series Programming Manual' (Hitachi M21T001). + + `as' implements all the standard H8/500 opcodes. No additional +pseudo-instructions are needed on this family. + + The following table summarizes H8/500 opcodes and their operands: + + Legend: + abs8 8-bit absolute address + abs16 16-bit absolute address + abs24 24-bit absolute address + crb `ccr', `br', `ep', `dp', `tp', `dp' + disp8 8-bit displacement + ea `rn', `@rn', `@(d:8, rn)', `@(d:16, rn)', + `@-rn', `@rn+', `@aa:8', `@aa:16', + `#xx:8', `#xx:16' + ea_mem `@rn', `@(d:8, rn)', `@(d:16, rn)', + `@-rn', `@rn+', `@aa:8', `@aa:16' + ea_noimm `rn', `@rn', `@(d:8, rn)', `@(d:16, rn)', + `@-rn', `@rn+', `@aa:8', `@aa:16' + fp r6 + imm4 4-bit immediate data + imm8 8-bit immediate data + imm16 16-bit immediate data + pcrel8 8-bit offset from program counter + pcrel16 16-bit offset from program counter + qim `-2', `-1', `1', `2' + rd any register + rs a register distinct from rd + rlist comma-separated list of registers in parentheses; + register ranges `rd-rs' are allowed + sp stack pointer (`r7') + sr status register + sz size; `.b' or `.w'. If omitted, default `.w' + + ldc[.b] ea,crb bcc[.w] pcrel16 + ldc[.w] ea,sr bcc[.b] pcrel8 + add[:q] sz qim,ea_noimm bhs[.w] pcrel16 + add[:g] sz ea,rd bhs[.b] pcrel8 + adds sz ea,rd bcs[.w] pcrel16 + addx sz ea,rd bcs[.b] pcrel8 + and sz ea,rd blo[.w] pcrel16 + andc[.b] imm8,crb blo[.b] pcrel8 + andc[.w] imm16,sr bne[.w] pcrel16 + bpt bne[.b] pcrel8 + bra[.w] pcrel16 beq[.w] pcrel16 + bra[.b] pcrel8 beq[.b] pcrel8 + bt[.w] pcrel16 bvc[.w] pcrel16 + bt[.b] pcrel8 bvc[.b] pcrel8 + brn[.w] pcrel16 bvs[.w] pcrel16 + brn[.b] pcrel8 bvs[.b] pcrel8 + bf[.w] pcrel16 bpl[.w] pcrel16 + bf[.b] pcrel8 bpl[.b] pcrel8 + bhi[.w] pcrel16 bmi[.w] pcrel16 + bhi[.b] pcrel8 bmi[.b] pcrel8 + bls[.w] pcrel16 bge[.w] pcrel16 + bls[.b] pcrel8 bge[.b] pcrel8 + + blt[.w] pcrel16 mov[:g][.b] imm8,ea_mem + blt[.b] pcrel8 mov[:g][.w] imm16,ea_mem + bgt[.w] pcrel16 movfpe[.b] ea,rd + bgt[.b] pcrel8 movtpe[.b] rs,ea_noimm + ble[.w] pcrel16 mulxu sz ea,rd + ble[.b] pcrel8 neg sz ea + bclr sz imm4,ea_noimm nop + bclr sz rs,ea_noimm not sz ea + bnot sz imm4,ea_noimm or sz ea,rd + bnot sz rs,ea_noimm orc[.b] imm8,crb + bset sz imm4,ea_noimm orc[.w] imm16,sr + bset sz rs,ea_noimm pjmp abs24 + bsr[.b] pcrel8 pjmp @rd + bsr[.w] pcrel16 pjsr abs24 + btst sz imm4,ea_noimm pjsr @rd + btst sz rs,ea_noimm prtd imm8 + clr sz ea prtd imm16 + cmp[:e][.b] imm8,rd prts + cmp[:i][.w] imm16,rd rotl sz ea + cmp[:g].b imm8,ea_noimm rotr sz ea + cmp[:g][.w] imm16,ea_noimm rotxl sz ea + Cmp[:g] sz ea,rd rotxr sz ea + dadd rs,rd rtd imm8 + divxu sz ea,rd rtd imm16 + dsub rs,rd rts + exts[.b] rd scb/f rs,pcrel8 + extu[.b] rd scb/ne rs,pcrel8 + jmp @rd scb/eq rs,pcrel8 + jmp @(imm8,rd) shal sz ea + jmp @(imm16,rd) shar sz ea + jmp abs16 shll sz ea + jsr @rd shlr sz ea + jsr @(imm8,rd) sleep + jsr @(imm16,rd) stc[.b] crb,ea_noimm + jsr abs16 stc[.w] sr,ea_noimm + ldm @sp+,(rlist) stm (rlist),@-sp + link fp,imm8 sub sz ea,rd + link fp,imm16 subs sz ea,rd + mov[:e][.b] imm8,rd subx sz ea,rd + mov[:i][.w] imm16,rd swap[.b] rd + mov[:l][.w] abs8,rd tas[.b] ea + mov[:l].b abs8,rd trapa imm4 + mov[:s][.w] rs,abs8 trap/vs + mov[:s].b rs,abs8 tst sz ea + mov[:f][.w] @(disp8,fp),rd unlk fp + mov[:f][.w] rs,@(disp8,fp) xch[.w] rs,rd + mov[:f].b @(disp8,fp),rd xor sz ea,rd + mov[:f].b rs,@(disp8,fp) xorc.b imm8,crb + mov[:g] sz rs,ea_mem xorc.w imm16,sr + mov[:g] sz ea,rd + + +File: as.info, Node: HPPA-Dependent, Next: ESA/390-Dependent, Prev: H8/500-Dependent, Up: Machine Dependencies + +HPPA Dependent Features +======================= + +* Menu: + +* HPPA Notes:: Notes +* HPPA Options:: Options +* HPPA Syntax:: Syntax +* HPPA Floating Point:: Floating Point +* HPPA Directives:: HPPA Machine Directives +* HPPA Opcodes:: Opcodes + + +File: as.info, Node: HPPA Notes, Next: HPPA Options, Up: HPPA-Dependent + +Notes +----- + + As a back end for GNU CC `as' has been throughly tested and should +work extremely well. We have tested it only minimally on hand written +assembly code and no one has tested it much on the assembly output from +the HP compilers. + + The format of the debugging sections has changed since the original +`as' port (version 1.3X) was released; therefore, you must rebuild all +HPPA objects and libraries with the new assembler so that you can debug +the final executable. + + The HPPA `as' port generates a small subset of the relocations +available in the SOM and ELF object file formats. Additional relocation +support will be added as it becomes necessary. + + +File: as.info, Node: HPPA Options, Next: HPPA Syntax, Prev: HPPA Notes, Up: HPPA-Dependent + +Options +------- + + `as' has no machine-dependent command-line options for the HPPA. + + +File: as.info, Node: HPPA Syntax, Next: HPPA Floating Point, Prev: HPPA Options, Up: HPPA-Dependent + +Syntax +------ + + The assembler syntax closely follows the HPPA instruction set +reference manual; assembler directives and general syntax closely +follow the HPPA assembly language reference manual, with a few +noteworthy differences. + + First, a colon may immediately follow a label definition. This is +simply for compatibility with how most assembly language programmers +write code. + + Some obscure expression parsing problems may affect hand written +code which uses the `spop' instructions, or code which makes significant +use of the `!' line separator. + + `as' is much less forgiving about missing arguments and other +similar oversights than the HP assembler. `as' notifies you of missing +arguments as syntax errors; this is regarded as a feature, not a bug. + + Finally, `as' allows you to use an external symbol without +explicitly importing the symbol. _Warning:_ in the future this will be +an error for HPPA targets. + + Special characters for HPPA targets include: + + `;' is the line comment character. + + `!' can be used instead of a newline to separate statements. + + Since `$' has no special meaning, you may use it in symbol names. + + +File: as.info, Node: HPPA Floating Point, Next: HPPA Directives, Prev: HPPA Syntax, Up: HPPA-Dependent + +Floating Point +-------------- + + The HPPA family uses IEEE floating-point numbers. + + +File: as.info, Node: HPPA Directives, Next: HPPA Opcodes, Prev: HPPA Floating Point, Up: HPPA-Dependent + +HPPA Assembler Directives +------------------------- + + `as' for the HPPA supports many additional directives for +compatibility with the native assembler. This section describes them +only briefly. For detailed information on HPPA-specific assembler +directives, see `HP9000 Series 800 Assembly Language Reference Manual' +(HP 92432-90001). + + `as' does _not_ support the following assembler directives described +in the HP manual: + + .endm .liston + .enter .locct + .leave .macro + .listoff + + Beyond those implemented for compatibility, `as' supports one +additional assembler directive for the HPPA: `.param'. It conveys +register argument locations for static functions. Its syntax closely +follows the `.export' directive. + + These are the additional directives in `as' for the HPPA: + +`.block N' +`.blockz N' + Reserve N bytes of storage, and initialize them to zero. + +`.call' + Mark the beginning of a procedure call. Only the special case + with _no arguments_ is allowed. + +`.callinfo [ PARAM=VALUE, ... ] [ FLAG, ... ]' + Specify a number of parameters and flags that define the + environment for a procedure. + + PARAM may be any of `frame' (frame size), `entry_gr' (end of + general register range), `entry_fr' (end of float register range), + `entry_sr' (end of space register range). + + The values for FLAG are `calls' or `caller' (proc has + subroutines), `no_calls' (proc does not call subroutines), + `save_rp' (preserve return pointer), `save_sp' (proc preserves + stack pointer), `no_unwind' (do not unwind this proc), `hpux_int' + (proc is interrupt routine). + +`.code' + Assemble into the standard section called `$TEXT$', subsection + `$CODE$'. + +`.copyright "STRING"' + In the SOM object format, insert STRING into the object code, + marked as a copyright string. + +`.copyright "STRING"' + In the ELF object format, insert STRING into the object code, + marked as a version string. + +`.enter' + Not yet supported; the assembler rejects programs containing this + directive. + +`.entry' + Mark the beginning of a procedure. + +`.exit' + Mark the end of a procedure. + +`.export NAME [ ,TYP ] [ ,PARAM=R ]' + Make a procedure NAME available to callers. TYP, if present, must + be one of `absolute', `code' (ELF only, not SOM), `data', `entry', + `data', `entry', `millicode', `plabel', `pri_prog', or `sec_prog'. + + PARAM, if present, provides either relocation information for the + procedure arguments and result, or a privilege level. PARAM may be + `argwN' (where N ranges from `0' to `3', and indicates one of four + one-word arguments); `rtnval' (the procedure's result); or + `priv_lev' (privilege level). For arguments or the result, R + specifies how to relocate, and must be one of `no' (not + relocatable), `gr' (argument is in general register), `fr' (in + floating point register), or `fu' (upper half of float register). + For `priv_lev', R is an integer. + +`.half N' + Define a two-byte integer constant N; synonym for the portable + `as' directive `.short'. + +`.import NAME [ ,TYP ]' + Converse of `.export'; make a procedure available to call. The + arguments use the same conventions as the first two arguments for + `.export'. + +`.label NAME' + Define NAME as a label for the current assembly location. + +`.leave' + Not yet supported; the assembler rejects programs containing this + directive. + +`.origin LC' + Advance location counter to LC. Synonym for the `{No value for + `as'}' portable directive `.org'. + +`.param NAME [ ,TYP ] [ ,PARAM=R ]' + Similar to `.export', but used for static procedures. + +`.proc' + Use preceding the first statement of a procedure. + +`.procend' + Use following the last statement of a procedure. + +`LABEL .reg EXPR' + Synonym for `.equ'; define LABEL with the absolute expression EXPR + as its value. + +`.space SECNAME [ ,PARAMS ]' + Switch to section SECNAME, creating a new section by that name if + necessary. You may only use PARAMS when creating a new section, + not when switching to an existing one. SECNAME may identify a + section by number rather than by name. + + If specified, the list PARAMS declares attributes of the section, + identified by keywords. The keywords recognized are `spnum=EXP' + (identify this section by the number EXP, an absolute expression), + `sort=EXP' (order sections according to this sort key when linking; + EXP is an absolute expression), `unloadable' (section contains no + loadable data), `notdefined' (this section defined elsewhere), and + `private' (data in this section not available to other programs). + +`.spnum SECNAM' + Allocate four bytes of storage, and initialize them with the + section number of the section named SECNAM. (You can define the + section number with the HPPA `.space' directive.) + +`.string "STR"' + Copy the characters in the string STR to the object file. *Note + Strings: Strings, for information on escape sequences you can use + in `as' strings. + + _Warning!_ The HPPA version of `.string' differs from the usual + `as' definition: it does _not_ write a zero byte after copying STR. + +`.stringz "STR"' + Like `.string', but appends a zero byte after copying STR to object + file. + +`.subspa NAME [ ,PARAMS ]' +`.nsubspa NAME [ ,PARAMS ]' + Similar to `.space', but selects a subsection NAME within the + current section. You may only specify PARAMS when you create a + subsection (in the first instance of `.subspa' for this NAME). + + If specified, the list PARAMS declares attributes of the + subsection, identified by keywords. The keywords recognized are + `quad=EXPR' ("quadrant" for this subsection), `align=EXPR' + (alignment for beginning of this subsection; a power of two), + `access=EXPR' (value for "access rights" field), `sort=EXPR' + (sorting order for this subspace in link), `code_only' (subsection + contains only code), `unloadable' (subsection cannot be loaded + into memory), `common' (subsection is common block), `dup_comm' + (initialized data may have duplicate names), or `zero' (subsection + is all zeros, do not write in object file). + + `.nsubspa' always creates a new subspace with the given name, even + if one with the same name already exists. + +`.version "STR"' + Write STR as version identifier in object code. + + +File: as.info, Node: HPPA Opcodes, Prev: HPPA Directives, Up: HPPA-Dependent + +Opcodes +------- + + For detailed information on the HPPA machine instruction set, see +`PA-RISC Architecture and Instruction Set Reference Manual' (HP +09740-90039). + + +File: as.info, Node: ESA/390-Dependent, Next: i386-Dependent, Prev: HPPA-Dependent, Up: Machine Dependencies + +ESA/390 Dependent Features +========================== + +* Menu: + +* ESA/390 Notes:: Notes +* ESA/390 Options:: Options +* ESA/390 Syntax:: Syntax +* ESA/390 Floating Point:: Floating Point +* ESA/390 Directives:: ESA/390 Machine Directives +* ESA/390 Opcodes:: Opcodes + + +File: as.info, Node: ESA/390 Notes, Next: ESA/390 Options, Up: ESA/390-Dependent + +Notes +----- + + The ESA/390 `as' port is currently intended to be a back-end for the +GNU CC compiler. It is not HLASM compatible, although it does support +a subset of some of the HLASM directives. The only supported binary +file format is ELF; none of the usual MVS/VM/OE/USS object file +formats, such as ESD or XSD, are supported. + + When used with the GNU CC compiler, the ESA/390 `as' will produce +correct, fully relocated, functional binaries, and has been used to +compile and execute large projects. However, many aspects should still +be considered experimental; these include shared library support, +dynamically loadable objects, and any relocation other than the 31-bit +relocation. + + +File: as.info, Node: ESA/390 Options, Next: ESA/390 Syntax, Prev: ESA/390 Notes, Up: ESA/390-Dependent + +Options +------- + + `as' has no machine-dependent command-line options for the ESA/390. + + +File: as.info, Node: ESA/390 Syntax, Next: ESA/390 Floating Point, Prev: ESA/390 Options, Up: ESA/390-Dependent + +Syntax +------ + + The opcode/operand syntax follows the ESA/390 Principles of Operation +manual; assembler directives and general syntax are loosely based on the +prevailing AT&T/SVR4/ELF/Solaris style notation. HLASM-style directives +are _not_ supported for the most part, with the exception of those +described herein. + + A leading dot in front of directives is optional, and the case of +directives is ignored; thus for example, .using and USING have the same +effect. + + A colon may immediately follow a label definition. This is simply +for compatibility with how most assembly language programmers write +code. + + `#' is the line comment character. + + `;' can be used instead of a newline to separate statements. + + Since `$' has no special meaning, you may use it in symbol names. + + Registers can be given the symbolic names r0..r15, fp0, fp2, fp4, +fp6. By using thesse symbolic names, `as' can detect simple syntax +errors. The name rarg or r.arg is a synonym for r11, rtca or r.tca for +r12, sp, r.sp, dsa r.dsa for r13, lr or r.lr for r14, rbase or r.base +for r3 and rpgt or r.pgt for r4. + + `*' is the current location counter. Unlike `.' it is always +relative to the last USING directive. Note that this means that +expressions cannot use multiplication, as any occurence of `*' will be +interpreted as a location counter. + + All labels are relative to the last USING. Thus, branches to a label +always imply the use of base+displacement. + + Many of the usual forms of address constants / address literals are +supported. Thus, + .using *,r3 + L r15,=A(some_routine) + LM r6,r7,=V(some_longlong_extern) + A r1,=F'12' + AH r0,=H'42' + ME r6,=E'3.1416' + MD r6,=D'3.14159265358979' + O r6,=XL4'cacad0d0' + .ltorg + should all behave as expected: that is, an entry in the literal pool +will be created (or reused if it already exists), and the instruction +operands will be the displacement into the literal pool using the +current base register (as last declared with the `.using' directive). + + +File: as.info, Node: ESA/390 Floating Point, Next: ESA/390 Directives, Prev: ESA/390 Syntax, Up: ESA/390-Dependent + +Floating Point +-------------- + + The assembler generates only IEEE floating-point numbers. The older +floiating point formats are not supported. + diff --git a/gas/doc/as.info-5 b/gas/doc/as.info-5 new file mode 100644 index 00000000000..73e6ecd0653 --- /dev/null +++ b/gas/doc/as.info-5 @@ -0,0 +1,1214 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: ESA/390 Directives, Next: ESA/390 Opcodes, Prev: ESA/390 Floating Point, Up: ESA/390-Dependent + +ESA/390 Assembler Directives +---------------------------- + + `as' for the ESA/390 supports all of the standard ELF/SVR4 assembler +directives that are documented in the main part of this documentation. +Several additional directives are supported in order to implement the +ESA/390 addressing model. The most important of these are `.using' and +`.ltorg' + + These are the additional directives in `as' for the ESA/390: + +`.dc' + A small subset of the usual DC directive is supported. + +`.drop REGNO' + Stop using REGNO as the base register. The REGNO must have been + previously declared with a `.using' directive in the same section + as the current section. + +`.ebcdic STRING' + Emit the EBCDIC equivalent of the indicated string. The emitted + string will be null terminated. Note that the directives + `.string' etc. emit ascii strings by default. + +`EQU' + The standard HLASM-style EQU directive is not supported; however, + the standard `as' directive .equ can be used to the same effect. + +`.ltorg' + Dump the literal pool accumulated so far; begin a new literal pool. + The literal pool will be written in the current section; in order + to generate correct assembly, a `.using' must have been previously + specified in the same section. + +`.using EXPR,REGNO' + Use REGNO as the base register for all subsequent RX, RS, and SS + form instructions. The EXPR will be evaluated to obtain the base + address; usually, EXPR will merely be `*'. + + This assembler allows two `.using' directives to be simultaneously + outstanding, one in the `.text' section, and one in another section + (typically, the `.data' section). This feature allows dynamically + loaded objects to be implemented in a relatively straightforward + way. A `.using' directive must always be specified in the `.text' + section; this will specify the base register that will be used for + branches in the `.text' section. A second `.using' may be + specified in another section; this will specify the base register + that is used for non-label address literals. When a second + `.using' is specified, then the subsequent `.ltorg' must be put in + the same section; otherwise an error will result. + + Thus, for example, the following code uses `r3' to address branch + targets and `r4' to address the literal pool, which has been + written to the `.data' section. The is, the constants + `=A(some_routine)', `=H'42'' and `=E'3.1416'' will all appear in + the `.data' section. + + .data + .using LITPOOL,r4 + .text + BASR r3,0 + .using *,r3 + B START + .long LITPOOL + START: + L r4,4(,r3) + L r15,=A(some_routine) + LTR r15,r15 + BNE LABEL + AH r0,=H'42' + LABEL: + ME r6,=E'3.1416' + .data + LITPOOL: + .ltorg + + Note that this dual-`.using' directive semantics extends and is + not compatible with HLASM semantics. Note that this assembler + directive does not support the full range of HLASM semantics. + + +File: as.info, Node: ESA/390 Opcodes, Prev: ESA/390 Directives, Up: ESA/390-Dependent + +Opcodes +------- + + For detailed information on the ESA/390 machine instruction set, see +`ESA/390 Principles of Operation' (IBM Publication Number DZ9AR004). + + +File: as.info, Node: i386-Dependent, Next: i960-Dependent, Prev: ESA/390-Dependent, Up: Machine Dependencies + +80386 Dependent Features +======================== + +* Menu: + +* i386-Options:: Options +* i386-Syntax:: AT&T Syntax versus Intel Syntax +* i386-Mnemonics:: Instruction Naming +* i386-Regs:: Register Naming +* i386-Prefixes:: Instruction Prefixes +* i386-Memory:: Memory References +* i386-jumps:: Handling of Jump Instructions +* i386-Float:: Floating Point +* i386-SIMD:: Intel's MMX and AMD's 3DNow! SIMD Operations +* i386-16bit:: Writing 16-bit Code +* i386-Bugs:: AT&T Syntax bugs +* i386-Notes:: Notes + + +File: as.info, Node: i386-Options, Next: i386-Syntax, Up: i386-Dependent + +Options +------- + + The 80386 has no machine dependent options. + + +File: as.info, Node: i386-Syntax, Next: i386-Mnemonics, Prev: i386-Options, Up: i386-Dependent + +AT&T Syntax versus Intel Syntax +------------------------------- + + In order to maintain compatibility with the output of `gcc', `as' +supports AT&T System V/386 assembler syntax. This is quite different +from Intel syntax. We mention these differences because almost all +80386 documents use Intel syntax. Notable differences between the two +syntaxes are: + + * AT&T immediate operands are preceded by `$'; Intel immediate + operands are undelimited (Intel `push 4' is AT&T `pushl $4'). + AT&T register operands are preceded by `%'; Intel register operands + are undelimited. AT&T absolute (as opposed to PC relative) + jump/call operands are prefixed by `*'; they are undelimited in + Intel syntax. + + * AT&T and Intel syntax use the opposite order for source and + destination operands. Intel `add eax, 4' is `addl $4, %eax'. The + `source, dest' convention is maintained for compatibility with + previous Unix assemblers. Note that instructions with more than + one source operand, such as the `enter' instruction, do _not_ have + reversed order. *Note i386-Bugs::. + + * In AT&T syntax the size of memory operands is determined from the + last character of the instruction mnemonic. Mnemonic suffixes of + `b', `w', and `l' specify byte (8-bit), word (16-bit), and long + (32-bit) memory references. Intel syntax accomplishes this by + prefixing memory operands (_not_ the instruction mnemonics) with + `byte ptr', `word ptr', and `dword ptr'. Thus, Intel `mov al, + byte ptr FOO' is `movb FOO, %al' in AT&T syntax. + + * Immediate form long jumps and calls are `lcall/ljmp $SECTION, + $OFFSET' in AT&T syntax; the Intel syntax is `call/jmp far + SECTION:OFFSET'. Also, the far return instruction is `lret + $STACK-ADJUST' in AT&T syntax; Intel syntax is `ret far + STACK-ADJUST'. + + * The AT&T assembler does not provide support for multiple section + programs. Unix style systems expect all programs to be single + sections. + + +File: as.info, Node: i386-Mnemonics, Next: i386-Regs, Prev: i386-Syntax, Up: i386-Dependent + +Instruction Naming +------------------ + + Instruction mnemonics are suffixed with one character modifiers which +specify the size of operands. The letters `b', `w', and `l' specify +byte, word, and long operands. If no suffix is specified by an +instruction then `as' tries to fill in the missing suffix based on the +destination register operand (the last one by convention). Thus, `mov +%ax, %bx' is equivalent to `movw %ax, %bx'; also, `mov $1, %bx' is +equivalent to `movw $1, %bx'. Note that this is incompatible with the +AT&T Unix assembler which assumes that a missing mnemonic suffix +implies long operand size. (This incompatibility does not affect +compiler output since compilers always explicitly specify the mnemonic +suffix.) + + Almost all instructions have the same names in AT&T and Intel format. +There are a few exceptions. The sign extend and zero extend +instructions need two sizes to specify them. They need a size to +sign/zero extend _from_ and a size to zero extend _to_. This is +accomplished by using two instruction mnemonic suffixes in AT&T syntax. +Base names for sign extend and zero extend are `movs...' and `movz...' +in AT&T syntax (`movsx' and `movzx' in Intel syntax). The instruction +mnemonic suffixes are tacked on to this base name, the _from_ suffix +before the _to_ suffix. Thus, `movsbl %al, %edx' is AT&T syntax for +"move sign extend _from_ %al _to_ %edx." Possible suffixes, thus, are +`bl' (from byte to long), `bw' (from byte to word), and `wl' (from word +to long). + + The Intel-syntax conversion instructions + + * `cbw' -- sign-extend byte in `%al' to word in `%ax', + + * `cwde' -- sign-extend word in `%ax' to long in `%eax', + + * `cwd' -- sign-extend word in `%ax' to long in `%dx:%ax', + + * `cdq' -- sign-extend dword in `%eax' to quad in `%edx:%eax', + +are called `cbtw', `cwtl', `cwtd', and `cltd' in AT&T naming. `as' +accepts either naming for these instructions. + + Far call/jump instructions are `lcall' and `ljmp' in AT&T syntax, +but are `call far' and `jump far' in Intel convention. + + +File: as.info, Node: i386-Regs, Next: i386-Prefixes, Prev: i386-Mnemonics, Up: i386-Dependent + +Register Naming +--------------- + + Register operands are always prefixed with `%'. The 80386 registers +consist of + + * the 8 32-bit registers `%eax' (the accumulator), `%ebx', `%ecx', + `%edx', `%edi', `%esi', `%ebp' (the frame pointer), and `%esp' + (the stack pointer). + + * the 8 16-bit low-ends of these: `%ax', `%bx', `%cx', `%dx', `%di', + `%si', `%bp', and `%sp'. + + * the 8 8-bit registers: `%ah', `%al', `%bh', `%bl', `%ch', `%cl', + `%dh', and `%dl' (These are the high-bytes and low-bytes of `%ax', + `%bx', `%cx', and `%dx') + + * the 6 section registers `%cs' (code section), `%ds' (data + section), `%ss' (stack section), `%es', `%fs', and `%gs'. + + * the 3 processor control registers `%cr0', `%cr2', and `%cr3'. + + * the 6 debug registers `%db0', `%db1', `%db2', `%db3', `%db6', and + `%db7'. + + * the 2 test registers `%tr6' and `%tr7'. + + * the 8 floating point register stack `%st' or equivalently + `%st(0)', `%st(1)', `%st(2)', `%st(3)', `%st(4)', `%st(5)', + `%st(6)', and `%st(7)'. + + +File: as.info, Node: i386-Prefixes, Next: i386-Memory, Prev: i386-Regs, Up: i386-Dependent + +Instruction Prefixes +-------------------- + + Instruction prefixes are used to modify the following instruction. +They are used to repeat string instructions, to provide section +overrides, to perform bus lock operations, and to change operand and +address sizes. (Most instructions that normally operate on 32-bit +operands will use 16-bit operands if the instruction has an "operand +size" prefix.) Instruction prefixes are best written on the same line +as the instruction they act upon. For example, the `scas' (scan string) +instruction is repeated with: + + repne scas %es:(%edi),%al + + You may also place prefixes on the lines immediately preceding the +instruction, but this circumvents checks that `as' does with prefixes, +and will not work with all prefixes. + + Here is a list of instruction prefixes: + + * Section override prefixes `cs', `ds', `ss', `es', `fs', `gs'. + These are automatically added by specifying using the + SECTION:MEMORY-OPERAND form for memory references. + + * Operand/Address size prefixes `data16' and `addr16' change 32-bit + operands/addresses into 16-bit operands/addresses, while `data32' + and `addr32' change 16-bit ones (in a `.code16' section) into + 32-bit operands/addresses. These prefixes _must_ appear on the + same line of code as the instruction they modify. For example, in + a 16-bit `.code16' section, you might write: + + addr32 jmpl *(%ebx) + + * The bus lock prefix `lock' inhibits interrupts during execution of + the instruction it precedes. (This is only valid with certain + instructions; see a 80386 manual for details). + + * The wait for coprocessor prefix `wait' waits for the coprocessor to + complete the current instruction. This should never be needed for + the 80386/80387 combination. + + * The `rep', `repe', and `repne' prefixes are added to string + instructions to make them repeat `%ecx' times (`%cx' times if the + current address size is 16-bits). + + +File: as.info, Node: i386-Memory, Next: i386-jumps, Prev: i386-Prefixes, Up: i386-Dependent + +Memory References +----------------- + + An Intel syntax indirect memory reference of the form + + SECTION:[BASE + INDEX*SCALE + DISP] + +is translated into the AT&T syntax + + SECTION:DISP(BASE, INDEX, SCALE) + +where BASE and INDEX are the optional 32-bit base and index registers, +DISP is the optional displacement, and SCALE, taking the values 1, 2, +4, and 8, multiplies INDEX to calculate the address of the operand. If +no SCALE is specified, SCALE is taken to be 1. SECTION specifies the +optional section register for the memory operand, and may override the +default section register (see a 80386 manual for section register +defaults). Note that section overrides in AT&T syntax _must_ be +preceded by a `%'. If you specify a section override which coincides +with the default section register, `as' does _not_ output any section +register override prefixes to assemble the given instruction. Thus, +section overrides can be specified to emphasize which section register +is used for a given memory operand. + + Here are some examples of Intel and AT&T style memory references: + +AT&T: `-4(%ebp)', Intel: `[ebp - 4]' + BASE is `%ebp'; DISP is `-4'. SECTION is missing, and the default + section is used (`%ss' for addressing with `%ebp' as the base + register). INDEX, SCALE are both missing. + +AT&T: `foo(,%eax,4)', Intel: `[foo + eax*4]' + INDEX is `%eax' (scaled by a SCALE 4); DISP is `foo'. All other + fields are missing. The section register here defaults to `%ds'. + +AT&T: `foo(,1)'; Intel `[foo]' + This uses the value pointed to by `foo' as a memory operand. Note + that BASE and INDEX are both missing, but there is only _one_ `,'. + This is a syntactic exception. + +AT&T: `%gs:foo'; Intel `gs:foo' + This selects the contents of the variable `foo' with section + register SECTION being `%gs'. + + Absolute (as opposed to PC relative) call and jump operands must be +prefixed with `*'. If no `*' is specified, `as' always chooses PC +relative addressing for jump/call labels. + + Any instruction that has a memory operand, but no register operand, +_must_ specify its size (byte, word, or long) with an instruction +mnemonic suffix (`b', `w', or `l', respectively). + + +File: as.info, Node: i386-jumps, Next: i386-Float, Prev: i386-Memory, Up: i386-Dependent + +Handling of Jump Instructions +----------------------------- + + Jump instructions are always optimized to use the smallest possible +displacements. This is accomplished by using byte (8-bit) displacement +jumps whenever the target is sufficiently close. If a byte displacement +is insufficient a long (32-bit) displacement is used. We do not support +word (16-bit) displacement jumps in 32-bit mode (i.e. prefixing the jump +instruction with the `data16' instruction prefix), since the 80386 +insists upon masking `%eip' to 16 bits after the word displacement is +added. + + Note that the `jcxz', `jecxz', `loop', `loopz', `loope', `loopnz' +and `loopne' instructions only come in byte displacements, so that if +you use these instructions (`gcc' does not use them) you may get an +error message (and incorrect code). The AT&T 80386 assembler tries to +get around this problem by expanding `jcxz foo' to + + jcxz cx_zero + jmp cx_nonzero + cx_zero: jmp foo + cx_nonzero: + + +File: as.info, Node: i386-Float, Next: i386-SIMD, Prev: i386-jumps, Up: i386-Dependent + +Floating Point +-------------- + + All 80387 floating point types except packed BCD are supported. +(BCD support may be added without much difficulty). These data types +are 16-, 32-, and 64- bit integers, and single (32-bit), double +(64-bit), and extended (80-bit) precision floating point. Each +supported type has an instruction mnemonic suffix and a constructor +associated with it. Instruction mnemonic suffixes specify the operand's +data type. Constructors build these data types into memory. + + * Floating point constructors are `.float' or `.single', `.double', + and `.tfloat' for 32-, 64-, and 80-bit formats. These correspond + to instruction mnemonic suffixes `s', `l', and `t'. `t' stands for + 80-bit (ten byte) real. The 80387 only supports this format via + the `fldt' (load 80-bit real to stack top) and `fstpt' (store + 80-bit real and pop stack) instructions. + + * Integer constructors are `.word', `.long' or `.int', and `.quad' + for the 16-, 32-, and 64-bit integer formats. The corresponding + instruction mnemonic suffixes are `s' (single), `l' (long), and + `q' (quad). As with the 80-bit real format, the 64-bit `q' format + is only present in the `fildq' (load quad integer to stack top) + and `fistpq' (store quad integer and pop stack) instructions. + + Register to register operations should not use instruction mnemonic +suffixes. `fstl %st, %st(1)' will give a warning, and be assembled as +if you wrote `fst %st, %st(1)', since all register to register +operations use 80-bit floating point operands. (Contrast this with +`fstl %st, mem', which converts `%st' from 80-bit to 64-bit floating +point format, then stores the result in the 4 byte location `mem') + + +File: as.info, Node: i386-SIMD, Next: i386-16bit, Prev: i386-Float, Up: i386-Dependent + +Intel's MMX and AMD's 3DNow! SIMD Operations +-------------------------------------------- + + `as' supports Intel's MMX instruction set (SIMD instructions for +integer data), available on Intel's Pentium MMX processors and Pentium +II processors, AMD's K6 and K6-2 processors, Cyrix' M2 processor, and +probably others. It also supports AMD's 3DNow! instruction set (SIMD +instructions for 32-bit floating point data) available on AMD's K6-2 +processor and possibly others in the future. + + Currently, `as' does not support Intel's floating point SIMD, Katmai +(KNI). + + The eight 64-bit MMX operands, also used by 3DNow!, are called +`%mm0', `%mm1', ... `%mm7'. They contain eight 8-bit integers, four +16-bit integers, two 32-bit integers, one 64-bit integer, or two 32-bit +floating point values. The MMX registers cannot be used at the same +time as the floating point stack. + + See Intel and AMD documentation, keeping in mind that the operand +order in instructions is reversed from the Intel syntax. + + +File: as.info, Node: i386-16bit, Next: i386-Bugs, Prev: i386-SIMD, Up: i386-Dependent + +Writing 16-bit Code +------------------- + + While `as' normally writes only "pure" 32-bit i386 code, it also +supports writing code to run in real mode or in 16-bit protected mode +code segments. To do this, put a `.code16' or `.code16gcc' directive +before the assembly language instructions to be run in 16-bit mode. +You can switch `as' back to writing normal 32-bit code with the +`.code32' directive. + + `.code16gcc' provides experimental support for generating 16-bit +code from gcc, and differs from `.code16' in that `call', `ret', +`enter', `leave', `push', `pop', `pusha', `popa', `pushf', and `popf' +instructions default to 32-bit size. This is so that the stack pointer +is manipulated in the same way over function calls, allowing access to +function parameters at the same stack offsets as in 32-bit mode. +`.code16gcc' also automatically adds address size prefixes where +necessary to use the 32-bit addressing modes that gcc generates. + + The code which `as' generates in 16-bit mode will not necessarily +run on a 16-bit pre-80386 processor. To write code that runs on such a +processor, you must refrain from using _any_ 32-bit constructs which +require `as' to output address or operand size prefixes. + + Note that writing 16-bit code instructions by explicitly specifying a +prefix or an instruction mnemonic suffix within a 32-bit code section +generates different machine instructions than those generated for a +16-bit code segment. In a 32-bit code section, the following code +generates the machine opcode bytes `66 6a 04', which pushes the value +`4' onto the stack, decrementing `%esp' by 2. + + pushw $4 + + The same code in a 16-bit code section would generate the machine +opcode bytes `6a 04' (ie. without the operand size prefix), which is +correct since the processor default operand size is assumed to be 16 +bits in a 16-bit code section. + + +File: as.info, Node: i386-Bugs, Next: i386-Notes, Prev: i386-16bit, Up: i386-Dependent + +AT&T Syntax bugs +---------------- + + The UnixWare assembler, and probably other AT&T derived ix86 Unix +assemblers, generate floating point instructions with reversed source +and destination registers in certain cases. Unfortunately, gcc and +possibly many other programs use this reversed syntax, so we're stuck +with it. + + For example + + fsub %st,%st(3) + +results in `%st(3)' being updated to `%st - %st(3)' rather than the +expected `%st(3) - %st'. This happens with all the non-commutative +arithmetic floating point operations with two register operands where +the source register is `%st' and the destination register is `%st(i)'. + + +File: as.info, Node: i386-Notes, Prev: i386-Bugs, Up: i386-Dependent + +Notes +----- + + There is some trickery concerning the `mul' and `imul' instructions +that deserves mention. The 16-, 32-, and 64-bit expanding multiplies +(base opcode `0xf6'; extension 4 for `mul' and 5 for `imul') can be +output only in the one operand form. Thus, `imul %ebx, %eax' does +_not_ select the expanding multiply; the expanding multiply would +clobber the `%edx' register, and this would confuse `gcc' output. Use +`imul %ebx' to get the 64-bit product in `%edx:%eax'. + + We have added a two operand form of `imul' when the first operand is +an immediate mode expression and the second operand is a register. +This is just a shorthand, so that, multiplying `%eax' by 69, for +example, can be done with `imul $69, %eax' rather than `imul $69, %eax, +%eax'. + + +File: as.info, Node: i960-Dependent, Next: M68K-Dependent, Prev: i386-Dependent, Up: Machine Dependencies + +Intel 80960 Dependent Features +============================== + +* Menu: + +* Options-i960:: i960 Command-line Options +* Floating Point-i960:: Floating Point +* Directives-i960:: i960 Machine Directives +* Opcodes for i960:: i960 Opcodes + + +File: as.info, Node: Options-i960, Next: Floating Point-i960, Up: i960-Dependent + +i960 Command-line Options +------------------------- + +`-ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC' + Select the 80960 architecture. Instructions or features not + supported by the selected architecture cause fatal errors. + + `-ACA' is equivalent to `-ACA_A'; `-AKC' is equivalent to `-AMC'. + Synonyms are provided for compatibility with other tools. + + If you do not specify any of these options, `as' generates code + for any instruction or feature that is supported by _some_ version + of the 960 (even if this means mixing architectures!). In + principle, `as' attempts to deduce the minimal sufficient + processor type if none is specified; depending on the object code + format, the processor type may be recorded in the object file. If + it is critical that the `as' output match a specific architecture, + specify that architecture explicitly. + +`-b' + Add code to collect information about conditional branches taken, + for later optimization using branch prediction bits. (The + conditional branch instructions have branch prediction bits in the + CA, CB, and CC architectures.) If BR represents a conditional + branch instruction, the following represents the code generated by + the assembler when `-b' is specified: + + call INCREMENT ROUTINE + .word 0 # pre-counter + Label: BR + call INCREMENT ROUTINE + .word 0 # post-counter + + The counter following a branch records the number of times that + branch was _not_ taken; the differenc between the two counters is + the number of times the branch _was_ taken. + + A table of every such `Label' is also generated, so that the + external postprocessor `gbr960' (supplied by Intel) can locate all + the counters. This table is always labelled `__BRANCH_TABLE__'; + this is a local symbol to permit collecting statistics for many + separate object files. The table is word aligned, and begins with + a two-word header. The first word, initialized to 0, is used in + maintaining linked lists of branch tables. The second word is a + count of the number of entries in the table, which follow + immediately: each is a word, pointing to one of the labels + illustrated above. + + +------------+------------+------------+ ... +------------+ + | | | | | | + | *NEXT | COUNT: N | *BRLAB 1 | | *BRLAB N | + | | | | | | + +------------+------------+------------+ ... +------------+ + + __BRANCH_TABLE__ layout + + The first word of the header is used to locate multiple branch + tables, since each object file may contain one. Normally the links + are maintained with a call to an initialization routine, placed at + the beginning of each function in the file. The GNU C compiler + generates these calls automatically when you give it a `-b' option. + For further details, see the documentation of `gbr960'. + +`-no-relax' + Normally, Compare-and-Branch instructions with targets that require + displacements greater than 13 bits (or that have external targets) + are replaced with the corresponding compare (or `chkbit') and + branch instructions. You can use the `-no-relax' option to + specify that `as' should generate errors instead, if the target + displacement is larger than 13 bits. + + This option does not affect the Compare-and-Jump instructions; the + code emitted for them is _always_ adjusted when necessary + (depending on displacement size), regardless of whether you use + `-no-relax'. + + +File: as.info, Node: Floating Point-i960, Next: Directives-i960, Prev: Options-i960, Up: i960-Dependent + +Floating Point +-------------- + + `as' generates IEEE floating-point numbers for the directives +`.float', `.double', `.extended', and `.single'. + + +File: as.info, Node: Directives-i960, Next: Opcodes for i960, Prev: Floating Point-i960, Up: i960-Dependent + +i960 Machine Directives +----------------------- + +`.bss SYMBOL, LENGTH, ALIGN' + Reserve LENGTH bytes in the bss section for a local SYMBOL, + aligned to the power of two specified by ALIGN. LENGTH and ALIGN + must be positive absolute expressions. This directive differs + from `.lcomm' only in that it permits you to specify an alignment. + *Note `.lcomm': Lcomm. + +`.extended FLONUMS' + `.extended' expects zero or more flonums, separated by commas; for + each flonum, `.extended' emits an IEEE extended-format (80-bit) + floating-point number. + +`.leafproc CALL-LAB, BAL-LAB' + You can use the `.leafproc' directive in conjunction with the + optimized `callj' instruction to enable faster calls of leaf + procedures. If a procedure is known to call no other procedures, + you may define an entry point that skips procedure prolog code + (and that does not depend on system-supplied saved context), and + declare it as the BAL-LAB using `.leafproc'. If the procedure + also has an entry point that goes through the normal prolog, you + can specify that entry point as CALL-LAB. + + A `.leafproc' declaration is meant for use in conjunction with the + optimized call instruction `callj'; the directive records the data + needed later to choose between converting the `callj' into a `bal' + or a `call'. + + CALL-LAB is optional; if only one argument is present, or if the + two arguments are identical, the single argument is assumed to be + the `bal' entry point. + +`.sysproc NAME, INDEX' + The `.sysproc' directive defines a name for a system procedure. + After you define it using `.sysproc', you can use NAME to refer to + the system procedure identified by INDEX when calling procedures + with the optimized call instruction `callj'. + + Both arguments are required; INDEX must be between 0 and 31 + (inclusive). + + +File: as.info, Node: Opcodes for i960, Prev: Directives-i960, Up: i960-Dependent + +i960 Opcodes +------------ + + All Intel 960 machine instructions are supported; *note i960 +Command-line Options: Options-i960. for a discussion of selecting the +instruction subset for a particular 960 architecture. + + Some opcodes are processed beyond simply emitting a single +corresponding instruction: `callj', and Compare-and-Branch or +Compare-and-Jump instructions with target displacements larger than 13 +bits. + +* Menu: + +* callj-i960:: `callj' +* Compare-and-branch-i960:: Compare-and-Branch + + +File: as.info, Node: callj-i960, Next: Compare-and-branch-i960, Up: Opcodes for i960 + +`callj' +....... + + You can write `callj' to have the assembler or the linker determine +the most appropriate form of subroutine call: `call', `bal', or +`calls'. If the assembly source contains enough information--a +`.leafproc' or `.sysproc' directive defining the operand--then `as' +translates the `callj'; if not, it simply emits the `callj', leaving it +for the linker to resolve. + + +File: as.info, Node: Compare-and-branch-i960, Prev: callj-i960, Up: Opcodes for i960 + +Compare-and-Branch +.................. + + The 960 architectures provide combined Compare-and-Branch +instructions that permit you to store the branch target in the lower 13 +bits of the instruction word itself. However, if you specify a branch +target far enough away that its address won't fit in 13 bits, the +assembler can either issue an error, or convert your Compare-and-Branch +instruction into separate instructions to do the compare and the branch. + + Whether `as' gives an error or expands the instruction depends on +two choices you can make: whether you use the `-no-relax' option, and +whether you use a "Compare and Branch" instruction or a "Compare and +Jump" instruction. The "Jump" instructions are _always_ expanded if +necessary; the "Branch" instructions are expanded when necessary +_unless_ you specify `-no-relax'--in which case `as' gives an error +instead. + + These are the Compare-and-Branch instructions, their "Jump" variants, +and the instruction pairs they may expand into: + + Compare and + Branch Jump Expanded to + ------ ------ ------------ + bbc chkbit; bno + bbs chkbit; bo + cmpibe cmpije cmpi; be + cmpibg cmpijg cmpi; bg + cmpibge cmpijge cmpi; bge + cmpibl cmpijl cmpi; bl + cmpible cmpijle cmpi; ble + cmpibno cmpijno cmpi; bno + cmpibne cmpijne cmpi; bne + cmpibo cmpijo cmpi; bo + cmpobe cmpoje cmpo; be + cmpobg cmpojg cmpo; bg + cmpobge cmpojge cmpo; bge + cmpobl cmpojl cmpo; bl + cmpoble cmpojle cmpo; ble + cmpobne cmpojne cmpo; bne + + +File: as.info, Node: M68K-Dependent, Next: MIPS-Dependent, Prev: i960-Dependent, Up: Machine Dependencies + +M680x0 Dependent Features +========================= + +* Menu: + +* M68K-Opts:: M680x0 Options +* M68K-Syntax:: Syntax +* M68K-Moto-Syntax:: Motorola Syntax +* M68K-Float:: Floating Point +* M68K-Directives:: 680x0 Machine Directives +* M68K-opcodes:: Opcodes + + +File: as.info, Node: M68K-Opts, Next: M68K-Syntax, Up: M68K-Dependent + +M680x0 Options +-------------- + + The Motorola 680x0 version of `as' has a few machine dependent +options. + + You can use the `-l' option to shorten the size of references to +undefined symbols. If you do not use the `-l' option, references to +undefined symbols are wide enough for a full `long' (32 bits). (Since +`as' cannot know where these symbols end up, `as' can only allocate +space for the linker to fill in later. Since `as' does not know how +far away these symbols are, it allocates as much space as it can.) If +you use this option, the references are only one word wide (16 bits). +This may be useful if you want the object file to be as small as +possible, and you know that the relevant symbols are always less than +17 bits away. + + For some configurations, especially those where the compiler normally +does not prepend an underscore to the names of user variables, the +assembler requires a `%' before any use of a register name. This is +intended to let the assembler distinguish between C variables and +functions named `a0' through `a7', and so on. The `%' is always +accepted, but is not required for certain configurations, notably +`sun3'. The `--register-prefix-optional' option may be used to permit +omitting the `%' even for configurations for which it is normally +required. If this is done, it will generally be impossible to refer to +C variables and functions with the same names as register names. + + Normally the character `|' is treated as a comment character, which +means that it can not be used in expressions. The `--bitwise-or' +option turns `|' into a normal character. In this mode, you must +either use C style comments, or start comments with a `#' character at +the beginning of a line. + + If you use an addressing mode with a base register without specifying +the size, `as' will normally use the full 32 bit value. For example, +the addressing mode `%a0@(%d0)' is equivalent to `%a0@(%d0:l)'. You +may use the `--base-size-default-16' option to tell `as' to default to +using the 16 bit value. In this case, `%a0@(%d0)' is equivalent to +`%a0@(%d0:w)'. You may use the `--base-size-default-32' option to +restore the default behaviour. + + If you use an addressing mode with a displacement, and the value of +the displacement is not known, `as' will normally assume that the value +is 32 bits. For example, if the symbol `disp' has not been defined, +`as' will assemble the addressing mode `%a0@(disp,%d0)' as though +`disp' is a 32 bit value. You may use the `--disp-size-default-16' +option to tell `as' to instead assume that the displacement is 16 bits. +In this case, `as' will assemble `%a0@(disp,%d0)' as though `disp' is +a 16 bit value. You may use the `--disp-size-default-32' option to +restore the default behaviour. + + `as' can assemble code for several different members of the Motorola +680x0 family. The default depends upon how `as' was configured when it +was built; normally, the default is to assemble code for the 68020 +microprocessor. The following options may be used to change the +default. These options control which instructions and addressing modes +are permitted. The members of the 680x0 family are very similar. For +detailed information about the differences, see the Motorola manuals. + +`-m68000' +`-m68ec000' +`-m68hc000' +`-m68hc001' +`-m68008' +`-m68302' +`-m68306' +`-m68307' +`-m68322' +`-m68356' + Assemble for the 68000. `-m68008', `-m68302', and so on are + synonyms for `-m68000', since the chips are the same from the + point of view of the assembler. + +`-m68010' + Assemble for the 68010. + +`-m68020' +`-m68ec020' + Assemble for the 68020. This is normally the default. + +`-m68030' +`-m68ec030' + Assemble for the 68030. + +`-m68040' +`-m68ec040' + Assemble for the 68040. + +`-m68060' +`-m68ec060' + Assemble for the 68060. + +`-mcpu32' +`-m68330' +`-m68331' +`-m68332' +`-m68333' +`-m68334' +`-m68336' +`-m68340' +`-m68341' +`-m68349' +`-m68360' + Assemble for the CPU32 family of chips. + +`-m5200' + Assemble for the ColdFire family of chips. + +`-m68881' +`-m68882' + Assemble 68881 floating point instructions. This is the default + for the 68020, 68030, and the CPU32. The 68040 and 68060 always + support floating point instructions. + +`-mno-68881' + Do not assemble 68881 floating point instructions. This is the + default for 68000 and the 68010. The 68040 and 68060 always + support floating point instructions, even if this option is used. + +`-m68851' + Assemble 68851 MMU instructions. This is the default for the + 68020, 68030, and 68060. The 68040 accepts a somewhat different + set of MMU instructions; `-m68851' and `-m68040' should not be used + together. + +`-mno-68851' + Do not assemble 68851 MMU instructions. This is the default for + the 68000, 68010, and the CPU32. The 68040 accepts a somewhat + different set of MMU instructions. + + +File: as.info, Node: M68K-Syntax, Next: M68K-Moto-Syntax, Prev: M68K-Opts, Up: M68K-Dependent + +Syntax +------ + + This syntax for the Motorola 680x0 was developed at MIT. + + The 680x0 version of `as' uses instructions names and syntax +compatible with the Sun assembler. Intervening periods are ignored; +for example, `movl' is equivalent to `mov.l'. + + In the following table APC stands for any of the address registers +(`%a0' through `%a7'), the program counter (`%pc'), the zero-address +relative to the program counter (`%zpc'), a suppressed address register +(`%za0' through `%za7'), or it may be omitted entirely. The use of +SIZE means one of `w' or `l', and it may be omitted, along with the +leading colon, unless a scale is also specified. The use of SCALE +means one of `1', `2', `4', or `8', and it may always be omitted along +with the leading colon. + + The following addressing modes are understood: +"Immediate" + `#NUMBER' + +"Data Register" + `%d0' through `%d7' + +"Address Register" + `%a0' through `%a7' + `%a7' is also known as `%sp', i.e. the Stack Pointer. `%a6' is + also known as `%fp', the Frame Pointer. + +"Address Register Indirect" + `%a0@' through `%a7@' + +"Address Register Postincrement" + `%a0@+' through `%a7@+' + +"Address Register Predecrement" + `%a0@-' through `%a7@-' + +"Indirect Plus Offset" + `APC@(NUMBER)' + +"Index" + `APC@(NUMBER,REGISTER:SIZE:SCALE)' + + The NUMBER may be omitted. + +"Postindex" + `APC@(NUMBER)@(ONUMBER,REGISTER:SIZE:SCALE)' + + The ONUMBER or the REGISTER, but not both, may be omitted. + +"Preindex" + `APC@(NUMBER,REGISTER:SIZE:SCALE)@(ONUMBER)' + + The NUMBER may be omitted. Omitting the REGISTER produces the + Postindex addressing mode. + +"Absolute" + `SYMBOL', or `DIGITS', optionally followed by `:b', `:w', or `:l'. + + +File: as.info, Node: M68K-Moto-Syntax, Next: M68K-Float, Prev: M68K-Syntax, Up: M68K-Dependent + +Motorola Syntax +--------------- + + The standard Motorola syntax for this chip differs from the syntax +already discussed (*note Syntax: M68K-Syntax.). `as' can accept +Motorola syntax for operands, even if MIT syntax is used for other +operands in the same instruction. The two kinds of syntax are fully +compatible. + + In the following table APC stands for any of the address registers +(`%a0' through `%a7'), the program counter (`%pc'), the zero-address +relative to the program counter (`%zpc'), or a suppressed address +register (`%za0' through `%za7'). The use of SIZE means one of `w' or +`l', and it may always be omitted along with the leading dot. The use +of SCALE means one of `1', `2', `4', or `8', and it may always be +omitted along with the leading asterisk. + + The following additional addressing modes are understood: + +"Address Register Indirect" + `(%a0)' through `(%a7)' + `%a7' is also known as `%sp', i.e. the Stack Pointer. `%a6' is + also known as `%fp', the Frame Pointer. + +"Address Register Postincrement" + `(%a0)+' through `(%a7)+' + +"Address Register Predecrement" + `-(%a0)' through `-(%a7)' + +"Indirect Plus Offset" + `NUMBER(%A0)' through `NUMBER(%A7)', or `NUMBER(%PC)'. + + The NUMBER may also appear within the parentheses, as in + `(NUMBER,%A0)'. When used with the PC, the NUMBER may be omitted + (with an address register, omitting the NUMBER produces Address + Register Indirect mode). + +"Index" + `NUMBER(APC,REGISTER.SIZE*SCALE)' + + The NUMBER may be omitted, or it may appear within the + parentheses. The APC may be omitted. The REGISTER and the APC + may appear in either order. If both APC and REGISTER are address + registers, and the SIZE and SCALE are omitted, then the first + register is taken as the base register, and the second as the + index register. + +"Postindex" + `([NUMBER,APC],REGISTER.SIZE*SCALE,ONUMBER)' + + The ONUMBER, or the REGISTER, or both, may be omitted. Either the + NUMBER or the APC may be omitted, but not both. + +"Preindex" + `([NUMBER,APC,REGISTER.SIZE*SCALE],ONUMBER)' + + The NUMBER, or the APC, or the REGISTER, or any two of them, may + be omitted. The ONUMBER may be omitted. The REGISTER and the APC + may appear in either order. If both APC and REGISTER are address + registers, and the SIZE and SCALE are omitted, then the first + register is taken as the base register, and the second as the + index register. + + +File: as.info, Node: M68K-Float, Next: M68K-Directives, Prev: M68K-Moto-Syntax, Up: M68K-Dependent + +Floating Point +-------------- + + Packed decimal (P) format floating literals are not supported. Feel +free to add the code! + + The floating point formats generated by directives are these. + +`.float' + `Single' precision floating point constants. + +`.double' + `Double' precision floating point constants. + +`.extend' +`.ldouble' + `Extended' precision (`long double') floating point constants. + + +File: as.info, Node: M68K-Directives, Next: M68K-opcodes, Prev: M68K-Float, Up: M68K-Dependent + +680x0 Machine Directives +------------------------ + + In order to be compatible with the Sun assembler the 680x0 assembler +understands the following directives. + +`.data1' + This directive is identical to a `.data 1' directive. + +`.data2' + This directive is identical to a `.data 2' directive. + +`.even' + This directive is a special case of the `.align' directive; it + aligns the output to an even byte boundary. + +`.skip' + This directive is identical to a `.space' directive. + + +File: as.info, Node: M68K-opcodes, Prev: M68K-Directives, Up: M68K-Dependent + +Opcodes +------- + +* Menu: + +* M68K-Branch:: Branch Improvement +* M68K-Chars:: Special Characters + + +File: as.info, Node: M68K-Branch, Next: M68K-Chars, Up: M68K-opcodes + +Branch Improvement +.................. + + Certain pseudo opcodes are permitted for branch instructions. They +expand to the shortest branch instruction that reach the target. +Generally these mnemonics are made by substituting `j' for `b' at the +start of a Motorola mnemonic. + + The following table summarizes the pseudo-operations. A `*' flags +cases that are more fully described after the table: + + Displacement + +------------------------------------------------- + | 68020 68000/10 + Pseudo-Op |BYTE WORD LONG LONG non-PC relative + +------------------------------------------------- + jbsr |bsrs bsr bsrl jsr jsr + jra |bras bra bral jmp jmp + * jXX |bXXs bXX bXXl bNXs;jmpl bNXs;jmp + * dbXX |dbXX dbXX dbXX; bra; jmpl + * fjXX |fbXXw fbXXw fbXXl fbNXw;jmp + + XX: condition + NX: negative of condition XX + + `*'--see full description below + +`jbsr' +`jra' + These are the simplest jump pseudo-operations; they always map to + one particular machine instruction, depending on the displacement + to the branch target. + +`jXX' + Here, `jXX' stands for an entire family of pseudo-operations, + where XX is a conditional branch or condition-code test. The full + list of pseudo-ops in this family is: + jhi jls jcc jcs jne jeq jvc + jvs jpl jmi jge jlt jgt jle + + For the cases of non-PC relative displacements and long + displacements on the 68000 or 68010, `as' issues a longer code + fragment in terms of NX, the opposite condition to XX. For + example, for the non-PC relative case: + jXX foo + gives + bNXs oof + jmp foo + oof: + +`dbXX' + The full family of pseudo-operations covered here is + dbhi dbls dbcc dbcs dbne dbeq dbvc + dbvs dbpl dbmi dbge dblt dbgt dble + dbf dbra dbt + + Other than for word and byte displacements, when the source reads + `dbXX foo', `as' emits + dbXX oo1 + bra oo2 + oo1:jmpl foo + oo2: + +`fjXX' + This family includes + fjne fjeq fjge fjlt fjgt fjle fjf + fjt fjgl fjgle fjnge fjngl fjngle fjngt + fjnle fjnlt fjoge fjogl fjogt fjole fjolt + fjor fjseq fjsf fjsne fjst fjueq fjuge + fjugt fjule fjult fjun + + For branch targets that are not PC relative, `as' emits + fbNX oof + jmp foo + oof: + when it encounters `fjXX foo'. + + +File: as.info, Node: M68K-Chars, Prev: M68K-Branch, Up: M68K-opcodes + +Special Characters +.................. + + The immediate character is `#' for Sun compatibility. The +line-comment character is `|' (unless the `--bitwise-or' option is +used). If a `#' appears at the beginning of a line, it is treated as a +comment unless it looks like `# line file', in which case it is treated +normally. + + +File: as.info, Node: MIPS-Dependent, Next: SH-Dependent, Prev: M68K-Dependent, Up: Machine Dependencies + +MIPS Dependent Features +======================= + + GNU `as' for MIPS architectures supports several different MIPS +processors, and MIPS ISA levels I through IV. For information about +the MIPS instruction set, see `MIPS RISC Architecture', by Kane and +Heindrich (Prentice-Hall). For an overview of MIPS assembly +conventions, see "Appendix D: Assembly Language Programming" in the +same work. + +* Menu: + +* MIPS Opts:: Assembler options +* MIPS Object:: ECOFF object code +* MIPS Stabs:: Directives for debugging information +* MIPS ISA:: Directives to override the ISA level +* MIPS autoextend:: Directives for extending MIPS 16 bit instructions +* MIPS insn:: Directive to mark data as an instruction +* MIPS option stack:: Directives to save and restore options + diff --git a/gas/doc/as.info-6 b/gas/doc/as.info-6 new file mode 100644 index 00000000000..182407a969e --- /dev/null +++ b/gas/doc/as.info-6 @@ -0,0 +1,1384 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: MIPS Opts, Next: MIPS Object, Up: MIPS-Dependent + +Assembler options +----------------- + + The MIPS configurations of GNU `as' support these special options: + +`-G NUM' + This option sets the largest size of an object that can be + referenced implicitly with the `gp' register. It is only accepted + for targets that use ECOFF format. The default value is 8. + +`-EB' +`-EL' + Any MIPS configuration of `as' can select big-endian or + little-endian output at run time (unlike the other GNU development + tools, which must be configured for one or the other). Use `-EB' + to select big-endian output, and `-EL' for little-endian. + +`-mips1' +`-mips2' +`-mips3' +`-mips4' + Generate code for a particular MIPS Instruction Set Architecture + level. `-mips1' corresponds to the R2000 and R3000 processors, + `-mips2' to the R6000 processor, `-mips3' to the R4000 processor, + and `-mips4' to the R8000 and R10000 processors. You can also + switch instruction sets during the assembly; see *Note Directives + to override the ISA level: MIPS ISA. + +`-mgp32' + Assume that 32-bit general purpose registers are available. This + affects synthetic instructions such as `move', which will assemble + to a 32-bit or a 64-bit instruction depending on this flag. On + some MIPS variants there is a 32-bit mode flag; when this flag is + set, 64-bit instructions generate a trap. Also, some 32-bit OSes + only save the 32-bit registers on a context switch, so it is + essential never to use the 64-bit registers. + +`-mgp64' + Assume that 64-bit general purpose registers are available. This + is provided in the interests of symmetry with -gp32. + +`-mips16' +`-no-mips16' + Generate code for the MIPS 16 processor. This is equivalent to + putting `.set mips16' at the start of the assembly file. + `-no-mips16' turns off this option. + +`-mfix7000' +`-no-mfix7000' + Cause nops to be inserted if the read of the destination register + of an mfhi or mflo instruction occurs in the following two + instructions. + +`-m4010' +`-no-m4010' + Generate code for the LSI R4010 chip. This tells the assembler to + accept the R4010 specific instructions (`addciu', `ffc', etc.), + and to not schedule `nop' instructions around accesses to the `HI' + and `LO' registers. `-no-m4010' turns off this option. + +`-m4650' +`-no-m4650' + Generate code for the MIPS R4650 chip. This tells the assembler + to accept the `mad' and `madu' instruction, and to not schedule + `nop' instructions around accesses to the `HI' and `LO' registers. + `-no-m4650' turns off this option. + +`-m3900' +`-no-m3900' +`-m4100' +`-no-m4100' + For each option `-mNNNN', generate code for the MIPS RNNNN chip. + This tells the assembler to accept instructions specific to that + chip, and to schedule for that chip's hazards. + +`-mcpu=CPU' + Generate code for a particular MIPS cpu. It is exactly equivalent + to `-mCPU', except that there are more value of CPU understood. + Valid CPU value are: + + 2000, 3000, 3900, 4000, 4010, 4100, 4111, 4300, 4400, 4600, + 4650, 5000, 6000, 8000, 10000 + +`-nocpp' + This option is ignored. It is accepted for command-line + compatibility with other assemblers, which use it to turn off C + style preprocessing. With GNU `as', there is no need for + `-nocpp', because the GNU assembler itself never runs the C + preprocessor. + +`--trap' +`--no-break' + `as' automatically macro expands certain division and + multiplication instructions to check for overflow and division by + zero. This option causes `as' to generate code to take a trap + exception rather than a break exception when an error is detected. + The trap instructions are only supported at Instruction Set + Architecture level 2 and higher. + +`--break' +`--no-trap' + Generate code to take a break exception rather than a trap + exception when an error is detected. This is the default. + + +File: as.info, Node: MIPS Object, Next: MIPS Stabs, Prev: MIPS Opts, Up: MIPS-Dependent + +MIPS ECOFF object code +---------------------- + + Assembling for a MIPS ECOFF target supports some additional sections +besides the usual `.text', `.data' and `.bss'. The additional sections +are `.rdata', used for read-only data, `.sdata', used for small data, +and `.sbss', used for small common objects. + + When assembling for ECOFF, the assembler uses the `$gp' (`$28') +register to form the address of a "small object". Any object in the +`.sdata' or `.sbss' sections is considered "small" in this sense. For +external objects, or for objects in the `.bss' section, you can use the +`gcc' `-G' option to control the size of objects addressed via `$gp'; +the default value is 8, meaning that a reference to any object eight +bytes or smaller uses `$gp'. Passing `-G 0' to `as' prevents it from +using the `$gp' register on the basis of object size (but the assembler +uses `$gp' for objects in `.sdata' or `sbss' in any case). The size of +an object in the `.bss' section is set by the `.comm' or `.lcomm' +directive that defines it. The size of an external object may be set +with the `.extern' directive. For example, `.extern sym,4' declares +that the object at `sym' is 4 bytes in length, whie leaving `sym' +otherwise undefined. + + Using small ECOFF objects requires linker support, and assumes that +the `$gp' register is correctly initialized (normally done +automatically by the startup code). MIPS ECOFF assembly code must not +modify the `$gp' register. + + +File: as.info, Node: MIPS Stabs, Next: MIPS ISA, Prev: MIPS Object, Up: MIPS-Dependent + +Directives for debugging information +------------------------------------ + + MIPS ECOFF `as' supports several directives used for generating +debugging information which are not support by traditional MIPS +assemblers. These are `.def', `.endef', `.dim', `.file', `.scl', +`.size', `.tag', `.type', `.val', `.stabd', `.stabn', and `.stabs'. +The debugging information generated by the three `.stab' directives can +only be read by GDB, not by traditional MIPS debuggers (this +enhancement is required to fully support C++ debugging). These +directives are primarily used by compilers, not assembly language +programmers! + + +File: as.info, Node: MIPS ISA, Next: MIPS autoextend, Prev: MIPS Stabs, Up: MIPS-Dependent + +Directives to override the ISA level +------------------------------------ + + GNU `as' supports an additional directive to change the MIPS +Instruction Set Architecture level on the fly: `.set mipsN'. N should +be a number from 0 to 4. A value from 1 to 4 makes the assembler +accept instructions for the corresponding ISA level, from that point on +in the assembly. `.set mipsN' affects not only which instructions are +permitted, but also how certain macros are expanded. `.set mips0' +restores the ISA level to its original level: either the level you +selected with command line options, or the default for your +configuration. You can use this feature to permit specific R4000 +instructions while assembling in 32 bit mode. Use this directive with +care! + + The directive `.set mips16' puts the assembler into MIPS 16 mode, in +which it will assemble instructions for the MIPS 16 processor. Use +`.set nomips16' to return to normal 32 bit mode. + + Traditional MIPS assemblers do not support this directive. + + +File: as.info, Node: MIPS autoextend, Next: MIPS insn, Prev: MIPS ISA, Up: MIPS-Dependent + +Directives for extending MIPS 16 bit instructions +------------------------------------------------- + + By default, MIPS 16 instructions are automatically extended to 32 +bits when necessary. The directive `.set noautoextend' will turn this +off. When `.set noautoextend' is in effect, any 32 bit instruction +must be explicitly extended with the `.e' modifier (e.g., `li.e +$4,1000'). The directive `.set autoextend' may be used to once again +automatically extend instructions when necessary. + + This directive is only meaningful when in MIPS 16 mode. Traditional +MIPS assemblers do not support this directive. + + +File: as.info, Node: MIPS insn, Next: MIPS option stack, Prev: MIPS autoextend, Up: MIPS-Dependent + +Directive to mark data as an instruction +---------------------------------------- + + The `.insn' directive tells `as' that the following data is actually +instructions. This makes a difference in MIPS 16 mode: when loading +the address of a label which precedes instructions, `as' automatically +adds 1 to the value, so that jumping to the loaded address will do the +right thing. + + +File: as.info, Node: MIPS option stack, Prev: MIPS insn, Up: MIPS-Dependent + +Directives to save and restore options +-------------------------------------- + + The directives `.set push' and `.set pop' may be used to save and +restore the current settings for all the options which are controlled +by `.set'. The `.set push' directive saves the current settings on a +stack. The `.set pop' directive pops the stack and restores the +settings. + + These directives can be useful inside an macro which must change an +option such as the ISA level or instruction reordering but does not want +to change the state of the code which invoked the macro. + + Traditional MIPS assemblers do not support these directives. + + +File: as.info, Node: PJ-Dependent, Next: Sparc-Dependent, Prev: SH-Dependent, Up: Machine Dependencies + +picoJava Dependent Features +=========================== + +* Menu: + +* PJ Options:: Options + + +File: as.info, Node: PJ Options, Up: PJ-Dependent + +Options +------- + + `as' has two addiitional command-line options for the picoJava +architecture. +`-ml' + This option selects little endian data output. + +`-mb' + This option selects big endian data output. + + +File: as.info, Node: SH-Dependent, Next: PJ-Dependent, Prev: MIPS-Dependent, Up: Machine Dependencies + +Hitachi SH Dependent Features +============================= + +* Menu: + +* SH Options:: Options +* SH Syntax:: Syntax +* SH Floating Point:: Floating Point +* SH Directives:: SH Machine Directives +* SH Opcodes:: Opcodes + + +File: as.info, Node: SH Options, Next: SH Syntax, Up: SH-Dependent + +Options +------- + + `as' has no additional command-line options for the Hitachi SH +family. + + +File: as.info, Node: SH Syntax, Next: SH Floating Point, Prev: SH Options, Up: SH-Dependent + +Syntax +------ + +* Menu: + +* SH-Chars:: Special Characters +* SH-Regs:: Register Names +* SH-Addressing:: Addressing Modes + + +File: as.info, Node: SH-Chars, Next: SH-Regs, Up: SH Syntax + +Special Characters +.................. + + `!' is the line comment character. + + You can use `;' instead of a newline to separate statements. + + Since `$' has no special meaning, you may use it in symbol names. + + +File: as.info, Node: SH-Regs, Next: SH-Addressing, Prev: SH-Chars, Up: SH Syntax + +Register Names +.............. + + You can use the predefined symbols `r0', `r1', `r2', `r3', `r4', +`r5', `r6', `r7', `r8', `r9', `r10', `r11', `r12', `r13', `r14', and +`r15' to refer to the SH registers. + + The SH also has these control registers: + +`pr' + procedure register (holds return address) + +`pc' + program counter + +`mach' +`macl' + high and low multiply accumulator registers + +`sr' + status register + +`gbr' + global base register + +`vbr' + vector base register (for interrupt vectors) + + +File: as.info, Node: SH-Addressing, Prev: SH-Regs, Up: SH Syntax + +Addressing Modes +................ + + `as' understands the following addressing modes for the SH. `RN' in +the following refers to any of the numbered registers, but _not_ the +control registers. + +`RN' + Register direct + +`@RN' + Register indirect + +`@-RN' + Register indirect with pre-decrement + +`@RN+' + Register indirect with post-increment + +`@(DISP, RN)' + Register indirect with displacement + +`@(R0, RN)' + Register indexed + +`@(DISP, GBR)' + `GBR' offset + +`@(R0, GBR)' + GBR indexed + +`ADDR' +`@(DISP, PC)' + PC relative address (for branch or for addressing memory). The + `as' implementation allows you to use the simpler form ADDR + anywhere a PC relative address is called for; the alternate form + is supported for compatibility with other assemblers. + +`#IMM' + Immediate data + + +File: as.info, Node: SH Floating Point, Next: SH Directives, Prev: SH Syntax, Up: SH-Dependent + +Floating Point +-------------- + + The SH family has no hardware floating point, but the `.float' +directive generates IEEE floating-point numbers for compatibility with +other development tools. + + +File: as.info, Node: SH Directives, Next: SH Opcodes, Prev: SH Floating Point, Up: SH-Dependent + +SH Machine Directives +--------------------- + +`uaword' +`ualong' + `as' will issue a warning when a misaligned `.word' or `.long' + directive is used. You may use `.uaword' or `.ualong' to indicate + that the value is intentionally misaligned. + + +File: as.info, Node: SH Opcodes, Prev: SH Directives, Up: SH-Dependent + +Opcodes +------- + + For detailed information on the SH machine instruction set, see +`SH-Microcomputer User's Manual' (Hitachi Micro Systems, Inc.). + + `as' implements all the standard SH opcodes. No additional +pseudo-instructions are needed on this family. Note, however, that +because `as' supports a simpler form of PC-relative addressing, you may +simply write (for example) + + mov.l bar,r0 + +where other assemblers might require an explicit displacement to `bar' +from the program counter: + + mov.l @(DISP, PC) + + Here is a summary of SH opcodes: + + Legend: + Rn a numbered register + Rm another numbered register + #imm immediate data + disp displacement + disp8 8-bit displacement + disp12 12-bit displacement + + add #imm,Rn lds.l @Rn+,PR + add Rm,Rn mac.w @Rm+,@Rn+ + addc Rm,Rn mov #imm,Rn + addv Rm,Rn mov Rm,Rn + and #imm,R0 mov.b Rm,@(R0,Rn) + and Rm,Rn mov.b Rm,@-Rn + and.b #imm,@(R0,GBR) mov.b Rm,@Rn + bf disp8 mov.b @(disp,Rm),R0 + bra disp12 mov.b @(disp,GBR),R0 + bsr disp12 mov.b @(R0,Rm),Rn + bt disp8 mov.b @Rm+,Rn + clrmac mov.b @Rm,Rn + clrt mov.b R0,@(disp,Rm) + cmp/eq #imm,R0 mov.b R0,@(disp,GBR) + cmp/eq Rm,Rn mov.l Rm,@(disp,Rn) + cmp/ge Rm,Rn mov.l Rm,@(R0,Rn) + cmp/gt Rm,Rn mov.l Rm,@-Rn + cmp/hi Rm,Rn mov.l Rm,@Rn + cmp/hs Rm,Rn mov.l @(disp,Rn),Rm + cmp/pl Rn mov.l @(disp,GBR),R0 + cmp/pz Rn mov.l @(disp,PC),Rn + cmp/str Rm,Rn mov.l @(R0,Rm),Rn + div0s Rm,Rn mov.l @Rm+,Rn + div0u mov.l @Rm,Rn + div1 Rm,Rn mov.l R0,@(disp,GBR) + exts.b Rm,Rn mov.w Rm,@(R0,Rn) + exts.w Rm,Rn mov.w Rm,@-Rn + extu.b Rm,Rn mov.w Rm,@Rn + extu.w Rm,Rn mov.w @(disp,Rm),R0 + jmp @Rn mov.w @(disp,GBR),R0 + jsr @Rn mov.w @(disp,PC),Rn + ldc Rn,GBR mov.w @(R0,Rm),Rn + ldc Rn,SR mov.w @Rm+,Rn + ldc Rn,VBR mov.w @Rm,Rn + ldc.l @Rn+,GBR mov.w R0,@(disp,Rm) + ldc.l @Rn+,SR mov.w R0,@(disp,GBR) + ldc.l @Rn+,VBR mova @(disp,PC),R0 + lds Rn,MACH movt Rn + lds Rn,MACL muls Rm,Rn + lds Rn,PR mulu Rm,Rn + lds.l @Rn+,MACH neg Rm,Rn + lds.l @Rn+,MACL negc Rm,Rn + + nop stc VBR,Rn + not Rm,Rn stc.l GBR,@-Rn + or #imm,R0 stc.l SR,@-Rn + or Rm,Rn stc.l VBR,@-Rn + or.b #imm,@(R0,GBR) sts MACH,Rn + rotcl Rn sts MACL,Rn + rotcr Rn sts PR,Rn + rotl Rn sts.l MACH,@-Rn + rotr Rn sts.l MACL,@-Rn + rte sts.l PR,@-Rn + rts sub Rm,Rn + sett subc Rm,Rn + shal Rn subv Rm,Rn + shar Rn swap.b Rm,Rn + shll Rn swap.w Rm,Rn + shll16 Rn tas.b @Rn + shll2 Rn trapa #imm + shll8 Rn tst #imm,R0 + shlr Rn tst Rm,Rn + shlr16 Rn tst.b #imm,@(R0,GBR) + shlr2 Rn xor #imm,R0 + shlr8 Rn xor Rm,Rn + sleep xor.b #imm,@(R0,GBR) + stc GBR,Rn xtrct Rm,Rn + stc SR,Rn + + +File: as.info, Node: Sparc-Dependent, Next: V850-Dependent, Prev: PJ-Dependent, Up: Machine Dependencies + +SPARC Dependent Features +======================== + +* Menu: + +* Sparc-Opts:: Options +* Sparc-Aligned-Data:: Option to enforce aligned data +* Sparc-Float:: Floating Point +* Sparc-Directives:: Sparc Machine Directives + + +File: as.info, Node: Sparc-Opts, Next: Sparc-Aligned-Data, Up: Sparc-Dependent + +Options +------- + + The SPARC chip family includes several successive levels, using the +same core instruction set, but including a few additional instructions +at each level. There are exceptions to this however. For details on +what instructions each variant supports, please see the chip's +architecture reference manual. + + By default, `as' assumes the core instruction set (SPARC v6), but +"bumps" the architecture level as needed: it switches to successively +higher architectures as it encounters instructions that only exist in +the higher levels. + + If not configured for SPARC v9 (`sparc64-*-*') GAS will not bump +passed sparclite by default, an option must be passed to enable the v9 +instructions. + + GAS treats sparclite as being compatible with v8, unless an +architecture is explicitly requested. SPARC v9 is always incompatible +with sparclite. + +`-Av6 | -Av7 | -Av8 | -Asparclet | -Asparclite' +`-Av8plus | -Av8plusa | -Av9 | -Av9a' + Use one of the `-A' options to select one of the SPARC + architectures explicitly. If you select an architecture + explicitly, `as' reports a fatal error if it encounters an + instruction or feature requiring an incompatible or higher level. + + `-Av8plus' and `-Av8plusa' select a 32 bit environment. + + `-Av9' and `-Av9a' select a 64 bit environment and are not + available unless GAS is explicitly configured with 64 bit + environment support. + + `-Av8plusa' and `-Av9a' enable the SPARC V9 instruction set with + UltraSPARC extensions. + +`-xarch=v8plus | -xarch=v8plusa' + For compatibility with the Solaris v9 assembler. These options are + equivalent to -Av8plus and -Av8plusa, respectively. + +`-bump' + Warn whenever it is necessary to switch to another level. If an + architecture level is explicitly requested, GAS will not issue + warnings until that level is reached, and will then bump the level + as required (except between incompatible levels). + +`-32 | -64' + Select the word size, either 32 bits or 64 bits. These options + are only available with the ELF object file format, and require + that the necessary BFD support has been included. + + +File: as.info, Node: Sparc-Aligned-Data, Next: Sparc-Float, Prev: Sparc-Opts, Up: Sparc-Dependent + +Enforcing aligned data +---------------------- + + SPARC GAS normally permits data to be misaligned. For example, it +permits the `.long' pseudo-op to be used on a byte boundary. However, +the native SunOS and Solaris assemblers issue an error when they see +misaligned data. + + You can use the `--enforce-aligned-data' option to make SPARC GAS +also issue an error about misaligned data, just as the SunOS and Solaris +assemblers do. + + The `--enforce-aligned-data' option is not the default because gcc +issues misaligned data pseudo-ops when it initializes certain packed +data structures (structures defined using the `packed' attribute). You +may have to assemble with GAS in order to initialize packed data +structures in your own code. + + +File: as.info, Node: Sparc-Float, Next: Sparc-Directives, Prev: Sparc-Aligned-Data, Up: Sparc-Dependent + +Floating Point +-------------- + + The Sparc uses IEEE floating-point numbers. + + +File: as.info, Node: Sparc-Directives, Prev: Sparc-Float, Up: Sparc-Dependent + +Sparc Machine Directives +------------------------ + + The Sparc version of `as' supports the following additional machine +directives: + +`.align' + This must be followed by the desired alignment in bytes. + +`.common' + This must be followed by a symbol name, a positive number, and + `"bss"'. This behaves somewhat like `.comm', but the syntax is + different. + +`.half' + This is functionally identical to `.short'. + +`.nword' + On the Sparc, the `.nword' directive produces native word sized + value, ie. if assembling with -32 it is equivalent to `.word', if + assembling with -64 it is equivalent to `.xword'. + +`.proc' + This directive is ignored. Any text following it on the same line + is also ignored. + +`.register' + This directive declares use of a global application or system + register. It must be followed by a register name %g2, %g3, %g6 or + %g7, comma and the symbol name for that register. If symbol name + is `#scratch', it is a scratch register, if it is `#ignore', it + just surpresses any errors about using undeclared global register, + but does not emit any information about it into the object file. + This can be useful e.g. if you save the register before use and + restore it after. + +`.reserve' + This must be followed by a symbol name, a positive number, and + `"bss"'. This behaves somewhat like `.lcomm', but the syntax is + different. + +`.seg' + This must be followed by `"text"', `"data"', or `"data1"'. It + behaves like `.text', `.data', or `.data 1'. + +`.skip' + This is functionally identical to the `.space' directive. + +`.word' + On the Sparc, the `.word' directive produces 32 bit values, + instead of the 16 bit values it produces on many other machines. + +`.xword' + On the Sparc V9 processor, the `.xword' directive produces 64 bit + values. + + +File: as.info, Node: Z8000-Dependent, Next: Vax-Dependent, Prev: V850-Dependent, Up: Machine Dependencies + +Z8000 Dependent Features +======================== + + The Z8000 as supports both members of the Z8000 family: the +unsegmented Z8002, with 16 bit addresses, and the segmented Z8001 with +24 bit addresses. + + When the assembler is in unsegmented mode (specified with the +`unsegm' directive), an address takes up one word (16 bit) sized +register. When the assembler is in segmented mode (specified with the +`segm' directive), a 24-bit address takes up a long (32 bit) register. +*Note Assembler Directives for the Z8000: Z8000 Directives, for a list +of other Z8000 specific assembler directives. + +* Menu: + +* Z8000 Options:: No special command-line options for Z8000 +* Z8000 Syntax:: Assembler syntax for the Z8000 +* Z8000 Directives:: Special directives for the Z8000 +* Z8000 Opcodes:: Opcodes + + +File: as.info, Node: Z8000 Options, Next: Z8000 Syntax, Up: Z8000-Dependent + +Options +------- + + `as' has no additional command-line options for the Zilog Z8000 +family. + + +File: as.info, Node: Z8000 Syntax, Next: Z8000 Directives, Prev: Z8000 Options, Up: Z8000-Dependent + +Syntax +------ + +* Menu: + +* Z8000-Chars:: Special Characters +* Z8000-Regs:: Register Names +* Z8000-Addressing:: Addressing Modes + + +File: as.info, Node: Z8000-Chars, Next: Z8000-Regs, Up: Z8000 Syntax + +Special Characters +.................. + + `!' is the line comment character. + + You can use `;' instead of a newline to separate statements. + + +File: as.info, Node: Z8000-Regs, Next: Z8000-Addressing, Prev: Z8000-Chars, Up: Z8000 Syntax + +Register Names +.............. + + The Z8000 has sixteen 16 bit registers, numbered 0 to 15. You can +refer to different sized groups of registers by register number, with +the prefix `r' for 16 bit registers, `rr' for 32 bit registers and `rq' +for 64 bit registers. You can also refer to the contents of the first +eight (of the sixteen 16 bit registers) by bytes. They are named `rNh' +and `rNl'. + +_byte registers_ + r0l r0h r1h r1l r2h r2l r3h r3l + r4h r4l r5h r5l r6h r6l r7h r7l + +_word registers_ + r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 + +_long word registers_ + rr0 rr2 rr4 rr6 rr8 rr10 rr12 rr14 + +_quad word registers_ + rq0 rq4 rq8 rq12 + + +File: as.info, Node: Z8000-Addressing, Prev: Z8000-Regs, Up: Z8000 Syntax + +Addressing Modes +................ + + as understands the following addressing modes for the Z8000: + +`rN' + Register direct + +`@rN' + Indirect register + +`ADDR' + Direct: the 16 bit or 24 bit address (depending on whether the + assembler is in segmented or unsegmented mode) of the operand is + in the instruction. + +`address(rN)' + Indexed: the 16 or 24 bit address is added to the 16 bit register + to produce the final address in memory of the operand. + +`rN(#IMM)' + Base Address: the 16 or 24 bit register is added to the 16 bit sign + extended immediate displacement to produce the final address in + memory of the operand. + +`rN(rM)' + Base Index: the 16 or 24 bit register rN is added to the sign + extended 16 bit index register rM to produce the final address in + memory of the operand. + +`#XX' + Immediate data XX. + + +File: as.info, Node: Z8000 Directives, Next: Z8000 Opcodes, Prev: Z8000 Syntax, Up: Z8000-Dependent + +Assembler Directives for the Z8000 +---------------------------------- + + The Z8000 port of as includes these additional assembler directives, +for compatibility with other Z8000 assemblers. As shown, these do not +begin with `.' (unlike the ordinary as directives). + +`segm' + Generates code for the segmented Z8001. + +`unsegm' + Generates code for the unsegmented Z8002. + +`name' + Synonym for `.file' + +`global' + Synonym for `.global' + +`wval' + Synonym for `.word' + +`lval' + Synonym for `.long' + +`bval' + Synonym for `.byte' + +`sval' + Assemble a string. `sval' expects one string literal, delimited by + single quotes. It assembles each byte of the string into + consecutive addresses. You can use the escape sequence `%XX' + (where XX represents a two-digit hexadecimal number) to represent + the character whose ASCII value is XX. Use this feature to + describe single quote and other characters that may not appear in + string literals as themselves. For example, the C statement + `char *a = "he said \"it's 50% off\"";' is represented in Z8000 + assembly language (shown with the assembler output in hex at the + left) as + + 68652073 sval 'he said %22it%27s 50%25 off%22%00' + 61696420 + 22697427 + 73203530 + 25206F66 + 662200 + +`rsect' + synonym for `.section' + +`block' + synonym for `.space' + +`even' + special case of `.align'; aligns output to even byte boundary. + + +File: as.info, Node: Z8000 Opcodes, Prev: Z8000 Directives, Up: Z8000-Dependent + +Opcodes +------- + + For detailed information on the Z8000 machine instruction set, see +`Z8000 Technical Manual'. + + The following table summarizes the opcodes and their arguments: + + rs 16 bit source register + rd 16 bit destination register + rbs 8 bit source register + rbd 8 bit destination register + rrs 32 bit source register + rrd 32 bit destination register + rqs 64 bit source register + rqd 64 bit destination register + addr 16/24 bit address + imm immediate data + + adc rd,rs clrb addr cpsir @rd,@rs,rr,cc + adcb rbd,rbs clrb addr(rd) cpsirb @rd,@rs,rr,cc + add rd,@rs clrb rbd dab rbd + add rd,addr com @rd dbjnz rbd,disp7 + add rd,addr(rs) com addr dec @rd,imm4m1 + add rd,imm16 com addr(rd) dec addr(rd),imm4m1 + add rd,rs com rd dec addr,imm4m1 + addb rbd,@rs comb @rd dec rd,imm4m1 + addb rbd,addr comb addr decb @rd,imm4m1 + addb rbd,addr(rs) comb addr(rd) decb addr(rd),imm4m1 + addb rbd,imm8 comb rbd decb addr,imm4m1 + addb rbd,rbs comflg flags decb rbd,imm4m1 + addl rrd,@rs cp @rd,imm16 di i2 + addl rrd,addr cp addr(rd),imm16 div rrd,@rs + addl rrd,addr(rs) cp addr,imm16 div rrd,addr + addl rrd,imm32 cp rd,@rs div rrd,addr(rs) + addl rrd,rrs cp rd,addr div rrd,imm16 + and rd,@rs cp rd,addr(rs) div rrd,rs + and rd,addr cp rd,imm16 divl rqd,@rs + and rd,addr(rs) cp rd,rs divl rqd,addr + and rd,imm16 cpb @rd,imm8 divl rqd,addr(rs) + and rd,rs cpb addr(rd),imm8 divl rqd,imm32 + andb rbd,@rs cpb addr,imm8 divl rqd,rrs + andb rbd,addr cpb rbd,@rs djnz rd,disp7 + andb rbd,addr(rs) cpb rbd,addr ei i2 + andb rbd,imm8 cpb rbd,addr(rs) ex rd,@rs + andb rbd,rbs cpb rbd,imm8 ex rd,addr + bit @rd,imm4 cpb rbd,rbs ex rd,addr(rs) + bit addr(rd),imm4 cpd rd,@rs,rr,cc ex rd,rs + bit addr,imm4 cpdb rbd,@rs,rr,cc exb rbd,@rs + bit rd,imm4 cpdr rd,@rs,rr,cc exb rbd,addr + bit rd,rs cpdrb rbd,@rs,rr,cc exb rbd,addr(rs) + bitb @rd,imm4 cpi rd,@rs,rr,cc exb rbd,rbs + bitb addr(rd),imm4 cpib rbd,@rs,rr,cc ext0e imm8 + bitb addr,imm4 cpir rd,@rs,rr,cc ext0f imm8 + bitb rbd,imm4 cpirb rbd,@rs,rr,cc ext8e imm8 + bitb rbd,rs cpl rrd,@rs ext8f imm8 + bpt cpl rrd,addr exts rrd + call @rd cpl rrd,addr(rs) extsb rd + call addr cpl rrd,imm32 extsl rqd + call addr(rd) cpl rrd,rrs halt + calr disp12 cpsd @rd,@rs,rr,cc in rd,@rs + clr @rd cpsdb @rd,@rs,rr,cc in rd,imm16 + clr addr cpsdr @rd,@rs,rr,cc inb rbd,@rs + clr addr(rd) cpsdrb @rd,@rs,rr,cc inb rbd,imm16 + clr rd cpsi @rd,@rs,rr,cc inc @rd,imm4m1 + clrb @rd cpsib @rd,@rs,rr,cc inc addr(rd),imm4m1 + inc addr,imm4m1 ldb rbd,rs(rx) mult rrd,addr(rs) + inc rd,imm4m1 ldb rd(imm16),rbs mult rrd,imm16 + incb @rd,imm4m1 ldb rd(rx),rbs mult rrd,rs + incb addr(rd),imm4m1 ldctl ctrl,rs multl rqd,@rs + incb addr,imm4m1 ldctl rd,ctrl multl rqd,addr + incb rbd,imm4m1 ldd @rs,@rd,rr multl rqd,addr(rs) + ind @rd,@rs,ra lddb @rs,@rd,rr multl rqd,imm32 + indb @rd,@rs,rba lddr @rs,@rd,rr multl rqd,rrs + inib @rd,@rs,ra lddrb @rs,@rd,rr neg @rd + inibr @rd,@rs,ra ldi @rd,@rs,rr neg addr + iret ldib @rd,@rs,rr neg addr(rd) + jp cc,@rd ldir @rd,@rs,rr neg rd + jp cc,addr ldirb @rd,@rs,rr negb @rd + jp cc,addr(rd) ldk rd,imm4 negb addr + jr cc,disp8 ldl @rd,rrs negb addr(rd) + ld @rd,imm16 ldl addr(rd),rrs negb rbd + ld @rd,rs ldl addr,rrs nop + ld addr(rd),imm16 ldl rd(imm16),rrs or rd,@rs + ld addr(rd),rs ldl rd(rx),rrs or rd,addr + ld addr,imm16 ldl rrd,@rs or rd,addr(rs) + ld addr,rs ldl rrd,addr or rd,imm16 + ld rd(imm16),rs ldl rrd,addr(rs) or rd,rs + ld rd(rx),rs ldl rrd,imm32 orb rbd,@rs + ld rd,@rs ldl rrd,rrs orb rbd,addr + ld rd,addr ldl rrd,rs(imm16) orb rbd,addr(rs) + ld rd,addr(rs) ldl rrd,rs(rx) orb rbd,imm8 + ld rd,imm16 ldm @rd,rs,n orb rbd,rbs + ld rd,rs ldm addr(rd),rs,n out @rd,rs + ld rd,rs(imm16) ldm addr,rs,n out imm16,rs + ld rd,rs(rx) ldm rd,@rs,n outb @rd,rbs + lda rd,addr ldm rd,addr(rs),n outb imm16,rbs + lda rd,addr(rs) ldm rd,addr,n outd @rd,@rs,ra + lda rd,rs(imm16) ldps @rs outdb @rd,@rs,rba + lda rd,rs(rx) ldps addr outib @rd,@rs,ra + ldar rd,disp16 ldps addr(rs) outibr @rd,@rs,ra + ldb @rd,imm8 ldr disp16,rs pop @rd,@rs + ldb @rd,rbs ldr rd,disp16 pop addr(rd),@rs + ldb addr(rd),imm8 ldrb disp16,rbs pop addr,@rs + ldb addr(rd),rbs ldrb rbd,disp16 pop rd,@rs + ldb addr,imm8 ldrl disp16,rrs popl @rd,@rs + ldb addr,rbs ldrl rrd,disp16 popl addr(rd),@rs + ldb rbd,@rs mbit popl addr,@rs + ldb rbd,addr mreq rd popl rrd,@rs + ldb rbd,addr(rs) mres push @rd,@rs + ldb rbd,imm8 mset push @rd,addr + ldb rbd,rbs mult rrd,@rs push @rd,addr(rs) + ldb rbd,rs(imm16) mult rrd,addr push @rd,imm16 + push @rd,rs set addr,imm4 subl rrd,imm32 + pushl @rd,@rs set rd,imm4 subl rrd,rrs + pushl @rd,addr set rd,rs tcc cc,rd + pushl @rd,addr(rs) setb @rd,imm4 tccb cc,rbd + pushl @rd,rrs setb addr(rd),imm4 test @rd + res @rd,imm4 setb addr,imm4 test addr + res addr(rd),imm4 setb rbd,imm4 test addr(rd) + res addr,imm4 setb rbd,rs test rd + res rd,imm4 setflg imm4 testb @rd + res rd,rs sinb rbd,imm16 testb addr + resb @rd,imm4 sinb rd,imm16 testb addr(rd) + resb addr(rd),imm4 sind @rd,@rs,ra testb rbd + resb addr,imm4 sindb @rd,@rs,rba testl @rd + resb rbd,imm4 sinib @rd,@rs,ra testl addr + resb rbd,rs sinibr @rd,@rs,ra testl addr(rd) + resflg imm4 sla rd,imm8 testl rrd + ret cc slab rbd,imm8 trdb @rd,@rs,rba + rl rd,imm1or2 slal rrd,imm8 trdrb @rd,@rs,rba + rlb rbd,imm1or2 sll rd,imm8 trib @rd,@rs,rbr + rlc rd,imm1or2 sllb rbd,imm8 trirb @rd,@rs,rbr + rlcb rbd,imm1or2 slll rrd,imm8 trtdrb @ra,@rb,rbr + rldb rbb,rba sout imm16,rs trtib @ra,@rb,rr + rr rd,imm1or2 soutb imm16,rbs trtirb @ra,@rb,rbr + rrb rbd,imm1or2 soutd @rd,@rs,ra trtrb @ra,@rb,rbr + rrc rd,imm1or2 soutdb @rd,@rs,rba tset @rd + rrcb rbd,imm1or2 soutib @rd,@rs,ra tset addr + rrdb rbb,rba soutibr @rd,@rs,ra tset addr(rd) + rsvd36 sra rd,imm8 tset rd + rsvd38 srab rbd,imm8 tsetb @rd + rsvd78 sral rrd,imm8 tsetb addr + rsvd7e srl rd,imm8 tsetb addr(rd) + rsvd9d srlb rbd,imm8 tsetb rbd + rsvd9f srll rrd,imm8 xor rd,@rs + rsvdb9 sub rd,@rs xor rd,addr + rsvdbf sub rd,addr xor rd,addr(rs) + sbc rd,rs sub rd,addr(rs) xor rd,imm16 + sbcb rbd,rbs sub rd,imm16 xor rd,rs + sc imm8 sub rd,rs xorb rbd,@rs + sda rd,rs subb rbd,@rs xorb rbd,addr + sdab rbd,rs subb rbd,addr xorb rbd,addr(rs) + sdal rrd,rs subb rbd,addr(rs) xorb rbd,imm8 + sdl rd,rs subb rbd,imm8 xorb rbd,rbs + sdlb rbd,rs subb rbd,rbs xorb rbd,rbs + sdll rrd,rs subl rrd,@rs + set @rd,imm4 subl rrd,addr + set addr(rd),imm4 subl rrd,addr(rs) + + +File: as.info, Node: Vax-Dependent, Prev: Z8000-Dependent, Up: Machine Dependencies + +VAX Dependent Features +====================== + +* Menu: + +* VAX-Opts:: VAX Command-Line Options +* VAX-float:: VAX Floating Point +* VAX-directives:: Vax Machine Directives +* VAX-opcodes:: VAX Opcodes +* VAX-branch:: VAX Branch Improvement +* VAX-operands:: VAX Operands +* VAX-no:: Not Supported on VAX + + +File: as.info, Node: VAX-Opts, Next: VAX-float, Up: Vax-Dependent + +VAX Command-Line Options +------------------------ + + The Vax version of `as' accepts any of the following options, gives +a warning message that the option was ignored and proceeds. These +options are for compatibility with scripts designed for other people's +assemblers. + +``-D' (Debug)' +``-S' (Symbol Table)' +``-T' (Token Trace)' + These are obsolete options used to debug old assemblers. + +``-d' (Displacement size for JUMPs)' + This option expects a number following the `-d'. Like options + that expect filenames, the number may immediately follow the `-d' + (old standard) or constitute the whole of the command line + argument that follows `-d' (GNU standard). + +``-V' (Virtualize Interpass Temporary File)' + Some other assemblers use a temporary file. This option commanded + them to keep the information in active memory rather than in a + disk file. `as' always does this, so this option is redundant. + +``-J' (JUMPify Longer Branches)' + Many 32-bit computers permit a variety of branch instructions to + do the same job. Some of these instructions are short (and fast) + but have a limited range; others are long (and slow) but can + branch anywhere in virtual memory. Often there are 3 flavors of + branch: short, medium and long. Some other assemblers would emit + short and medium branches, unless told by this option to emit + short and long branches. + +``-t' (Temporary File Directory)' + Some other assemblers may use a temporary file, and this option + takes a filename being the directory to site the temporary file. + Since `as' does not use a temporary disk file, this option makes + no difference. `-t' needs exactly one filename. + + The Vax version of the assembler accepts additional options when +compiled for VMS: + +`-h N' + External symbol or section (used for global variables) names are + not case sensitive on VAX/VMS and always mapped to upper case. + This is contrary to the C language definition which explicitly + distinguishes upper and lower case. To implement a standard + conforming C compiler, names must be changed (mapped) to preserve + the case information. The default mapping is to convert all lower + case characters to uppercase and adding an underscore followed by + a 6 digit hex value, representing a 24 digit binary value. The + one digits in the binary value represent which characters are + uppercase in the original symbol name. + + The `-h N' option determines how we map names. This takes several + values. No `-h' switch at all allows case hacking as described + above. A value of zero (`-h0') implies names should be upper + case, and inhibits the case hack. A value of 2 (`-h2') implies + names should be all lower case, with no case hack. A value of 3 + (`-h3') implies that case should be preserved. The value 1 is + unused. The `-H' option directs `as' to display every mapped + symbol during assembly. + + Symbols whose names include a dollar sign `$' are exceptions to the + general name mapping. These symbols are normally only used to + reference VMS library names. Such symbols are always mapped to + upper case. + +`-+' + The `-+' option causes `as' to truncate any symbol name larger + than 31 characters. The `-+' option also prevents some code + following the `_main' symbol normally added to make the object + file compatible with Vax-11 "C". + +`-1' + This option is ignored for backward compatibility with `as' + version 1.x. + +`-H' + The `-H' option causes `as' to print every symbol which was + changed by case mapping. + + +File: as.info, Node: VAX-float, Next: VAX-directives, Prev: VAX-Opts, Up: Vax-Dependent + +VAX Floating Point +------------------ + + Conversion of flonums to floating point is correct, and compatible +with previous assemblers. Rounding is towards zero if the remainder is +exactly half the least significant bit. + + `D', `F', `G' and `H' floating point formats are understood. + + Immediate floating literals (_e.g._ `S`$6.9') are rendered +correctly. Again, rounding is towards zero in the boundary case. + + The `.float' directive produces `f' format numbers. The `.double' +directive produces `d' format numbers. + + +File: as.info, Node: VAX-directives, Next: VAX-opcodes, Prev: VAX-float, Up: Vax-Dependent + +Vax Machine Directives +---------------------- + + The Vax version of the assembler supports four directives for +generating Vax floating point constants. They are described in the +table below. + +`.dfloat' + This expects zero or more flonums, separated by commas, and + assembles Vax `d' format 64-bit floating point constants. + +`.ffloat' + This expects zero or more flonums, separated by commas, and + assembles Vax `f' format 32-bit floating point constants. + +`.gfloat' + This expects zero or more flonums, separated by commas, and + assembles Vax `g' format 64-bit floating point constants. + +`.hfloat' + This expects zero or more flonums, separated by commas, and + assembles Vax `h' format 128-bit floating point constants. + + +File: as.info, Node: VAX-opcodes, Next: VAX-branch, Prev: VAX-directives, Up: Vax-Dependent + +VAX Opcodes +----------- + + All DEC mnemonics are supported. Beware that `case...' instructions +have exactly 3 operands. The dispatch table that follows the `case...' +instruction should be made with `.word' statements. This is compatible +with all unix assemblers we know of. + + +File: as.info, Node: VAX-branch, Next: VAX-operands, Prev: VAX-opcodes, Up: Vax-Dependent + +VAX Branch Improvement +---------------------- + + Certain pseudo opcodes are permitted. They are for branch +instructions. They expand to the shortest branch instruction that +reaches the target. Generally these mnemonics are made by substituting +`j' for `b' at the start of a DEC mnemonic. This feature is included +both for compatibility and to help compilers. If you do not need this +feature, avoid these opcodes. Here are the mnemonics, and the code +they can expand into. + +`jbsb' + `Jsb' is already an instruction mnemonic, so we chose `jbsb'. + (byte displacement) + `bsbb ...' + + (word displacement) + `bsbw ...' + + (long displacement) + `jsb ...' + +`jbr' +`jr' + Unconditional branch. + (byte displacement) + `brb ...' + + (word displacement) + `brw ...' + + (long displacement) + `jmp ...' + +`jCOND' + COND may be any one of the conditional branches `neq', `nequ', + `eql', `eqlu', `gtr', `geq', `lss', `gtru', `lequ', `vc', `vs', + `gequ', `cc', `lssu', `cs'. COND may also be one of the bit tests + `bs', `bc', `bss', `bcs', `bsc', `bcc', `bssi', `bcci', `lbs', + `lbc'. NOTCOND is the opposite condition to COND. + (byte displacement) + `bCOND ...' + + (word displacement) + `bNOTCOND foo ; brw ... ; foo:' + + (long displacement) + `bNOTCOND foo ; jmp ... ; foo:' + +`jacbX' + X may be one of `b d f g h l w'. + (word displacement) + `OPCODE ...' + + (long displacement) + OPCODE ..., foo ; + brb bar ; + foo: jmp ... ; + bar: + +`jaobYYY' + YYY may be one of `lss leq'. + +`jsobZZZ' + ZZZ may be one of `geq gtr'. + (byte displacement) + `OPCODE ...' + + (word displacement) + OPCODE ..., foo ; + brb bar ; + foo: brw DESTINATION ; + bar: + + (long displacement) + OPCODE ..., foo ; + brb bar ; + foo: jmp DESTINATION ; + bar: + +`aobleq' +`aoblss' +`sobgeq' +`sobgtr' + + (byte displacement) + `OPCODE ...' + + (word displacement) + OPCODE ..., foo ; + brb bar ; + foo: brw DESTINATION ; + bar: + + (long displacement) + OPCODE ..., foo ; + brb bar ; + foo: jmp DESTINATION ; + bar: + + +File: as.info, Node: VAX-operands, Next: VAX-no, Prev: VAX-branch, Up: Vax-Dependent + +VAX Operands +------------ + + The immediate character is `$' for Unix compatibility, not `#' as +DEC writes it. + + The indirect character is `*' for Unix compatibility, not `@' as DEC +writes it. + + The displacement sizing character is ``' (an accent grave) for Unix +compatibility, not `^' as DEC writes it. The letter preceding ``' may +have either case. `G' is not understood, but all other letters (`b i l +s w') are understood. + + Register names understood are `r0 r1 r2 ... r15 ap fp sp pc'. Upper +and lower case letters are equivalent. + + For instance + tstb *w`$4(r5) + + Any expression is permitted in an operand. Operands are comma +separated. + + +File: as.info, Node: VAX-no, Prev: VAX-operands, Up: Vax-Dependent + +Not Supported on VAX +-------------------- + + Vax bit fields can not be assembled with `as'. Someone can add the +required code if they really need it. + + +File: as.info, Node: V850-Dependent, Next: Z8000-Dependent, Prev: Sparc-Dependent, Up: Machine Dependencies + +v850 Dependent Features +======================= + +* Menu: + +* V850 Options:: Options +* V850 Syntax:: Syntax +* V850 Floating Point:: Floating Point +* V850 Directives:: V850 Machine Directives +* V850 Opcodes:: Opcodes + + +File: as.info, Node: V850 Options, Next: V850 Syntax, Up: V850-Dependent + +Options +------- + + `as' supports the following additional command-line options for the +V850 processor family: + +`-wsigned_overflow' + Causes warnings to be produced when signed immediate values + overflow the space available for then within their opcodes. By + default this option is disabled as it is possible to receive + spurious warnings due to using exact bit patterns as immediate + constants. + +`-wunsigned_overflow' + Causes warnings to be produced when unsigned immediate values + overflow the space available for then within their opcodes. By + default this option is disabled as it is possible to receive + spurious warnings due to using exact bit patterns as immediate + constants. + +`-mv850' + Specifies that the assembled code should be marked as being + targeted at the V850 processor. This allows the linker to detect + attempts to link such code with code assembled for other + processors. + +`-mv850e' + Specifies that the assembled code should be marked as being + targeted at the V850E processor. This allows the linker to detect + attempts to link such code with code assembled for other + processors. + +`-mv850any' + Specifies that the assembled code should be marked as being + targeted at the V850 processor but support instructions that are + specific to the extended variants of the process. This allows the + production of binaries that contain target specific code, but + which are also intended to be used in a generic fashion. For + example libgcc.a contains generic routines used by the code + produced by GCC for all versions of the v850 architecture, + together with support routines only used by the V850E architecture. + + +File: as.info, Node: V850 Syntax, Next: V850 Floating Point, Prev: V850 Options, Up: V850-Dependent + +Syntax +------ + +* Menu: + +* V850-Chars:: Special Characters +* V850-Regs:: Register Names + + +File: as.info, Node: V850-Chars, Next: V850-Regs, Up: V850 Syntax + +Special Characters +.................. + + `#' is the line comment character. + diff --git a/gas/doc/as.info-7 b/gas/doc/as.info-7 new file mode 100644 index 00000000000..c36016f2581 --- /dev/null +++ b/gas/doc/as.info-7 @@ -0,0 +1,612 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: V850-Regs, Prev: V850-Chars, Up: V850 Syntax + +Register Names +.............. + + `as' supports the following names for registers: +`general register 0' + r0, zero + +`general register 1' + r1 + +`general register 2' + r2, hp + +`general register 3' + r3, sp + +`general register 4' + r4, gp + +`general register 5' + r5, tp + +`general register 6' + r6 + +`general register 7' + r7 + +`general register 8' + r8 + +`general register 9' + r9 + +`general register 10' + r10 + +`general register 11' + r11 + +`general register 12' + r12 + +`general register 13' + r13 + +`general register 14' + r14 + +`general register 15' + r15 + +`general register 16' + r16 + +`general register 17' + r17 + +`general register 18' + r18 + +`general register 19' + r19 + +`general register 20' + r20 + +`general register 21' + r21 + +`general register 22' + r22 + +`general register 23' + r23 + +`general register 24' + r24 + +`general register 25' + r25 + +`general register 26' + r26 + +`general register 27' + r27 + +`general register 28' + r28 + +`general register 29' + r29 + +`general register 30' + r30, ep + +`general register 31' + r31, lp + +`system register 0' + eipc + +`system register 1' + eipsw + +`system register 2' + fepc + +`system register 3' + fepsw + +`system register 4' + ecr + +`system register 5' + psw + +`system register 16' + ctpc + +`system register 17' + ctpsw + +`system register 18' + dbpc + +`system register 19' + dbpsw + +`system register 20' + ctbp + + +File: as.info, Node: V850 Floating Point, Next: V850 Directives, Prev: V850 Syntax, Up: V850-Dependent + +Floating Point +-------------- + + The V850 family uses IEEE floating-point numbers. + + +File: as.info, Node: V850 Directives, Next: V850 Opcodes, Prev: V850 Floating Point, Up: V850-Dependent + +V850 Machine Directives +----------------------- + +`.offset <EXPRESSION>' + Moves the offset into the current section to the specified amount. + +`.section "name", <type>' + This is an extension to the standard .section directive. It sets + the current section to be <type> and creates an alias for this + section called "name". + +`.v850' + Specifies that the assembled code should be marked as being + targeted at the V850 processor. This allows the linker to detect + attempts to link such code with code assembled for other + processors. + +`.v850e' + Specifies that the assembled code should be marked as being + targeted at the V850E processor. This allows the linker to detect + attempts to link such code with code assembled for other + processors. + + +File: as.info, Node: V850 Opcodes, Prev: V850 Directives, Up: V850-Dependent + +Opcodes +------- + + `as' implements all the standard V850 opcodes. + + `as' also implements the following pseudo ops: + +`hi0()' + Computes the higher 16 bits of the given expression and stores it + into the immediate operand field of the given instruction. For + example: + + `mulhi hi0(here - there), r5, r6' + + computes the difference between the address of labels 'here' and + 'there', takes the upper 16 bits of this difference, shifts it + down 16 bits and then mutliplies it by the lower 16 bits in + register 5, putting the result into register 6. + +`lo()' + Computes the lower 16 bits of the given expression and stores it + into the immediate operand field of the given instruction. For + example: + + `addi lo(here - there), r5, r6' + + computes the difference between the address of labels 'here' and + 'there', takes the lower 16 bits of this difference and adds it to + register 5, putting the result into register 6. + +`hi()' + Computes the higher 16 bits of the given expression and then adds + the value of the most significant bit of the lower 16 bits of the + expression and stores the result into the immediate operand field + of the given instruction. For example the following code can be + used to compute the address of the label 'here' and store it into + register 6: + + `movhi hi(here), r0, r6' `movea lo(here), r6, r6' + + The reason for this special behaviour is that movea performs a sign + extention on its immediate operand. So for example if the address + of 'here' was 0xFFFFFFFF then without the special behaviour of the + hi() pseudo-op the movhi instruction would put 0xFFFF0000 into r6, + then the movea instruction would takes its immediate operand, + 0xFFFF, sign extend it to 32 bits, 0xFFFFFFFF, and then add it + into r6 giving 0xFFFEFFFF which is wrong (the fifth nibble is E). + With the hi() pseudo op adding in the top bit of the lo() pseudo + op, the movhi instruction actually stores 0 into r6 (0xFFFF + 1 = + 0x0000), so that the movea instruction stores 0xFFFFFFFF into r6 - + the right value. + +`hilo()' + Computes the 32 bit value of the given expression and stores it + into the immediate operand field of the given instruction (which + must be a mov instruction). For example: + + `mov hilo(here), r6' + + computes the absolute address of label 'here' and puts the result + into register 6. + +`sdaoff()' + Computes the offset of the named variable from the start of the + Small Data Area (whoes address is held in register 4, the GP + register) and stores the result as a 16 bit signed value in the + immediate operand field of the given instruction. For example: + + `ld.w sdaoff(_a_variable)[gp],r6' + + loads the contents of the location pointed to by the label + '_a_variable' into register 6, provided that the label is located + somewhere within +/- 32K of the address held in the GP register. + [Note the linker assumes that the GP register contains a fixed + address set to the address of the label called '__gp'. This can + either be set up automatically by the linker, or specifically set + by using the `--defsym __gp=<value>' command line option]. + +`tdaoff()' + Computes the offset of the named variable from the start of the + Tiny Data Area (whoes address is held in register 30, the EP + register) and stores the result as a 4,5, 7 or 8 bit unsigned + value in the immediate operand field of the given instruction. + For example: + + `sld.w tdaoff(_a_variable)[ep],r6' + + loads the contents of the location pointed to by the label + '_a_variable' into register 6, provided that the label is located + somewhere within +256 bytes of the address held in the EP + register. [Note the linker assumes that the EP register contains + a fixed address set to the address of the label called '__ep'. + This can either be set up automatically by the linker, or + specifically set by using the `--defsym __ep=<value>' command line + option]. + +`zdaoff()' + Computes the offset of the named variable from address 0 and + stores the result as a 16 bit signed value in the immediate + operand field of the given instruction. For example: + + `movea zdaoff(_a_variable),zero,r6' + + puts the address of the label '_a_variable' into register 6, + assuming that the label is somewhere within the first 32K of + memory. (Strictly speaking it also possible to access the last + 32K of memory as well, as the offsets are signed). + +`ctoff()' + Computes the offset of the named variable from the start of the + Call Table Area (whoes address is helg in system register 20, the + CTBP register) and stores the result a 6 or 16 bit unsigned value + in the immediate field of then given instruction or piece of data. + For example: + + `callt ctoff(table_func1)' + + will put the call the function whoes address is held in the call + table at the location labeled 'table_func1'. + + For information on the V850 instruction set, see `V850 Family +32-/16-Bit single-Chip Microcontroller Architecture Manual' from NEC. +Ltd. + + +File: as.info, Node: Reporting Bugs, Next: Acknowledgements, Prev: Machine Dependencies, Up: Top + +Reporting Bugs +************** + + Your bug reports play an essential role in making `as' reliable. + + Reporting a bug may help you by bringing a solution to your problem, +or it may not. But in any case the principal function of a bug report +is to help the entire community by making the next version of `as' work +better. Bug reports are your contribution to the maintenance of `as'. + + In order for a bug report to serve its purpose, you must include the +information that enables us to fix the bug. + +* Menu: + +* Bug Criteria:: Have you found a bug? +* Bug Reporting:: How to report bugs + + +File: as.info, Node: Bug Criteria, Next: Bug Reporting, Up: Reporting Bugs + +Have you found a bug? +===================== + + If you are not sure whether you have found a bug, here are some +guidelines: + + * If the assembler gets a fatal signal, for any input whatever, that + is a `as' bug. Reliable assemblers never crash. + + * If `as' produces an error message for valid input, that is a bug. + + * If `as' does not produce an error message for invalid input, that + is a bug. However, you should note that your idea of "invalid + input" might be our idea of "an extension" or "support for + traditional practice". + + * If you are an experienced user of assemblers, your suggestions for + improvement of `as' are welcome in any case. + + +File: as.info, Node: Bug Reporting, Prev: Bug Criteria, Up: Reporting Bugs + +How to report bugs +================== + + A number of companies and individuals offer support for GNU +products. If you obtained `as' from a support organization, we +recommend you contact that organization first. + + You can find contact information for many support companies and +individuals in the file `etc/SERVICE' in the GNU Emacs distribution. + + In any event, we also recommend that you send bug reports for `as' +to `bug-gnu-utils@gnu.org'. + + The fundamental principle of reporting bugs usefully is this: +*report all the facts*. If you are not sure whether to state a fact or +leave it out, state it! + + Often people omit facts because they think they know what causes the +problem and assume that some details do not matter. Thus, you might +assume that the name of a symbol you use in an example does not matter. +Well, probably it does not, but one cannot be sure. Perhaps the bug +is a stray memory reference which happens to fetch from the location +where that name is stored in memory; perhaps, if the name were +different, the contents of that location would fool the assembler into +doing the right thing despite the bug. Play it safe and give a +specific, complete example. That is the easiest thing for you to do, +and the most helpful. + + Keep in mind that the purpose of a bug report is to enable us to fix +the bug if it is new to us. Therefore, always write your bug reports +on the assumption that the bug has not been reported previously. + + Sometimes people give a few sketchy facts and ask, "Does this ring a +bell?" Those bug reports are useless, and we urge everyone to _refuse +to respond to them_ except to chide the sender to report bugs properly. + + To enable us to fix the bug, you should include all these things: + + * The version of `as'. `as' announces it if you start it with the + `--version' argument. + + Without this, we will not know whether there is any point in + looking for the bug in the current version of `as'. + + * Any patches you may have applied to the `as' source. + + * The type of machine you are using, and the operating system name + and version number. + + * What compiler (and its version) was used to compile `as'--e.g. + "`gcc-2.7'". + + * The command arguments you gave the assembler to assemble your + example and observe the bug. To guarantee you will not omit + something important, list them all. A copy of the Makefile (or + the output from make) is sufficient. + + If we were to try to guess the arguments, we would probably guess + wrong and then we might not encounter the bug. + + * A complete input file that will reproduce the bug. If the bug is + observed when the assembler is invoked via a compiler, send the + assembler source, not the high level language source. Most + compilers will produce the assembler source when run with the `-S' + option. If you are using `gcc', use the options `-v + --save-temps'; this will save the assembler source in a file with + an extension of `.s', and also show you exactly how `as' is being + run. + + * A description of what behavior you observe that you believe is + incorrect. For example, "It gets a fatal signal." + + Of course, if the bug is that `as' gets a fatal signal, then we + will certainly notice it. But if the bug is incorrect output, we + might not notice unless it is glaringly wrong. You might as well + not give us a chance to make a mistake. + + Even if the problem you experience is a fatal signal, you should + still say so explicitly. Suppose something strange is going on, + such as, your copy of `as' is out of synch, or you have + encountered a bug in the C library on your system. (This has + happened!) Your copy might crash and ours would not. If you told + us to expect a crash, then when ours fails to crash, we would know + that the bug was not happening for us. If you had not told us to + expect a crash, then we would not be able to draw any conclusion + from our observations. + + * If you wish to suggest changes to the `as' source, send us context + diffs, as generated by `diff' with the `-u', `-c', or `-p' option. + Always send diffs from the old file to the new file. If you even + discuss something in the `as' source, refer to it by context, not + by line number. + + The line numbers in our development sources will not match those + in your sources. Your line numbers would convey no useful + information to us. + + Here are some things that are not necessary: + + * A description of the envelope of the bug. + + Often people who encounter a bug spend a lot of time investigating + which changes to the input file will make the bug go away and which + changes will not affect it. + + This is often time consuming and not very useful, because the way + we will find the bug is by running a single example under the + debugger with breakpoints, not by pure deduction from a series of + examples. We recommend that you save your time for something else. + + Of course, if you can find a simpler example to report _instead_ + of the original one, that is a convenience for us. Errors in the + output will be easier to spot, running under the debugger will take + less time, and so on. + + However, simplification is not vital; if you do not want to do + this, report the bug anyway and send us the entire test case you + used. + + * A patch for the bug. + + A patch for the bug does help us if it is a good one. But do not + omit the necessary information, such as the test case, on the + assumption that a patch is all we need. We might see problems + with your patch and decide to fix the problem another way, or we + might not understand it at all. + + Sometimes with a program as complicated as `as' it is very hard to + construct an example that will make the program follow a certain + path through the code. If you do not send us the example, we will + not be able to construct one, so we will not be able to verify + that the bug is fixed. + + And if we cannot understand what bug you are trying to fix, or why + your patch should be an improvement, we will not install it. A + test case will help us to understand. + + * A guess about what the bug is or what it depends on. + + Such guesses are usually wrong. Even we cannot guess right about + such things without first using the debugger to find the facts. + + +File: as.info, Node: Acknowledgements, Next: Index, Prev: Reporting Bugs, Up: Top + +Acknowledgements +**************** + + If you have contributed to `as' and your name isn't listed here, it +is not meant as a slight. We just don't know about it. Send mail to +the maintainer, and we'll correct the situation. Currently the +maintainer is Ken Raeburn (email address `raeburn@cygnus.com'). + + Dean Elsner wrote the original GNU assembler for the VAX.(1) + + Jay Fenlason maintained GAS for a while, adding support for +GDB-specific debug information and the 68k series machines, most of the +preprocessing pass, and extensive changes in `messages.c', +`input-file.c', `write.c'. + + K. Richard Pixley maintained GAS for a while, adding various +enhancements and many bug fixes, including merging support for several +processors, breaking GAS up to handle multiple object file format back +ends (including heavy rewrite, testing, an integration of the coff and +b.out back ends), adding configuration including heavy testing and +verification of cross assemblers and file splits and renaming, +converted GAS to strictly ANSI C including full prototypes, added +support for m680[34]0 and cpu32, did considerable work on i960 +including a COFF port (including considerable amounts of reverse +engineering), a SPARC opcode file rewrite, DECstation, rs6000, and +hp300hpux host ports, updated "know" assertions and made them work, +much other reorganization, cleanup, and lint. + + Ken Raeburn wrote the high-level BFD interface code to replace most +of the code in format-specific I/O modules. + + The original VMS support was contributed by David L. Kashtan. Eric +Youngdale has done much work with it since. + + The Intel 80386 machine description was written by Eliot Dresselhaus. + + Minh Tran-Le at IntelliCorp contributed some AIX 386 support. + + The Motorola 88k machine description was contributed by Devon Bowen +of Buffalo University and Torbjorn Granlund of the Swedish Institute of +Computer Science. + + Keith Knowles at the Open Software Foundation wrote the original +MIPS back end (`tc-mips.c', `tc-mips.h'), and contributed Rose format +support (which hasn't been merged in yet). Ralph Campbell worked with +the MIPS code to support a.out format. + + Support for the Zilog Z8k and Hitachi H8/300 and H8/500 processors +(tc-z8k, tc-h8300, tc-h8500), and IEEE 695 object file format +(obj-ieee), was written by Steve Chamberlain of Cygnus Support. Steve +also modified the COFF back end to use BFD for some low-level +operations, for use with the H8/300 and AMD 29k targets. + + John Gilmore built the AMD 29000 support, added `.include' support, +and simplified the configuration of which versions accept which +directives. He updated the 68k machine description so that Motorola's +opcodes always produced fixed-size instructions (e.g. `jsr'), while +synthetic instructions remained shrinkable (`jbsr'). John fixed many +bugs, including true tested cross-compilation support, and one bug in +relaxation that took a week and required the proverbial one-bit fix. + + Ian Lance Taylor of Cygnus Support merged the Motorola and MIT +syntax for the 68k, completed support for some COFF targets (68k, i386 +SVR3, and SCO Unix), added support for MIPS ECOFF and ELF targets, +wrote the initial RS/6000 and PowerPC assembler, and made a few other +minor patches. + + Steve Chamberlain made `as' able to generate listings. + + Hewlett-Packard contributed support for the HP9000/300. + + Jeff Law wrote GAS and BFD support for the native HPPA object format +(SOM) along with a fairly extensive HPPA testsuite (for both SOM and +ELF object formats). This work was supported by both the Center for +Software Science at the University of Utah and Cygnus Support. + + Support for ELF format files has been worked on by Mark Eichin of +Cygnus Support (original, incomplete implementation for SPARC), Pete +Hoogenboom and Jeff Law at the University of Utah (HPPA mainly), +Michael Meissner of the Open Software Foundation (i386 mainly), and Ken +Raeburn of Cygnus Support (sparc, and some initial 64-bit support). + + Linas Vepstas added GAS support for the ESA/390 "IBM 370" +architecture. + + Richard Henderson rewrote the Alpha assembler. Klaus Kaempf wrote +GAS and BFD support for openVMS/Alpha. + + Several engineers at Cygnus Support have also provided many small +bug fixes and configuration enhancements. + + Many others have contributed large or small bugfixes and +enhancements. If you have contributed significant work and are not +mentioned on this list, and want to be, let us know. Some of the +history has been lost; we are not intentionally leaving anyone out. + + ---------- Footnotes ---------- + + (1) Any more details? + diff --git a/gas/doc/as.info-8 b/gas/doc/as.info-8 new file mode 100644 index 00000000000..2aa6dec6ab0 --- /dev/null +++ b/gas/doc/as.info-8 @@ -0,0 +1,1038 @@ +This is as.info, produced by makeinfo version 4.0 from as.texinfo. + +START-INFO-DIR-ENTRY +* As: (as). The GNU assembler. +END-INFO-DIR-ENTRY + + This file documents the GNU Assembler "as". + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: as.info, Node: Index, Prev: Acknowledgements, Up: Top + +Index +***** + +* Menu: + +* #: Comments. +* #APP: Preprocessing. +* #NO_APP: Preprocessing. +* $ in symbol names <1>: SH-Chars. +* $ in symbol names <2>: H8/500-Chars. +* $ in symbol names <3>: D30V-Chars. +* $ in symbol names: D10V-Chars. +* -+ option, VAX/VMS: VAX-Opts. +* --: Command Line. +* --base-size-default-16: M68K-Opts. +* --base-size-default-32: M68K-Opts. +* --bitwise-or option, M680x0: M68K-Opts. +* --disp-size-default-16: M68K-Opts. +* --disp-size-default-32: M68K-Opts. +* --enforce-aligned-data: Sparc-Aligned-Data. +* --fatal-warnings: W. +* --MD: MD. +* --no-warn: W. +* --register-prefix-optional option, M680x0: M68K-Opts. +* --statistics: statistics. +* --traditional-format: traditional-format. +* --warn: W. +* -1 option, VAX/VMS: VAX-Opts. +* -a: a. +* -A options, i960: Options-i960. +* -ac: a. +* -ad: a. +* -ah: a. +* -al: a. +* -an: a. +* -as: a. +* -Asparclet: Sparc-Opts. +* -Asparclite: Sparc-Opts. +* -Av6: Sparc-Opts. +* -Av8: Sparc-Opts. +* -Av9: Sparc-Opts. +* -Av9a: Sparc-Opts. +* -b option, i960: Options-i960. +* -D: D. +* -D, ignored on VAX: VAX-Opts. +* -d, VAX option: VAX-Opts. +* -EB command line option, ARM: ARM Options. +* -EB option (MIPS): MIPS Opts. +* -EL command line option, ARM: ARM Options. +* -EL option (MIPS): MIPS Opts. +* -f: f. +* -G option (MIPS): MIPS Opts. +* -H option, VAX/VMS: VAX-Opts. +* -h option, VAX/VMS: VAX-Opts. +* -I PATH: I. +* -J, ignored on VAX: VAX-Opts. +* -K: K. +* -k command line option, ARM: ARM Options. +* -L: L. +* -l option, M680x0: M68K-Opts. +* -M: M. +* -m68000 and related options: M68K-Opts. +* -mall command line option, ARM: ARM Options. +* -mapcs command line option, ARM: ARM Options. +* -marm command line option, ARM: ARM Options. +* -marmv command line option, ARM: ARM Options. +* -mbig-endian option (ARC): ARC-Opts. +* -mfpa command line option, ARM: ARM Options. +* -mfpe-old command line option, ARM: ARM Options. +* -mlittle-endian option (ARC): ARC-Opts. +* -mno-fpu command line option, ARM: ARM Options. +* -mthumb command line option, ARM: ARM Options. +* -mthumb-interwork command line option, ARM: ARM Options. +* -mv850 command line option, V850: V850 Options. +* -mv850any command line option, V850: V850 Options. +* -mv850e command line option, V850: V850 Options. +* -no-relax option, i960: Options-i960. +* -nocpp ignored (MIPS): MIPS Opts. +* -o: o. +* -R: R. +* -S, ignored on VAX: VAX-Opts. +* -t, ignored on VAX: VAX-Opts. +* -T, ignored on VAX: VAX-Opts. +* -v: v. +* -V, redundant on VAX: VAX-Opts. +* -version: v. +* -W: W. +* -wsigned_overflow command line option, V850: V850 Options. +* -wunsigned_overflow command line option, V850: V850 Options. +* . (symbol): Dot. +* .insn: MIPS insn. +* .ltorg directive, ARM: ARM Directives. +* .o: Object. +* .param on HPPA: HPPA Directives. +* .pool directive, ARM: ARM Directives. +* .set autoextend: MIPS autoextend. +* .set mipsN: MIPS ISA. +* .set noautoextend: MIPS autoextend. +* .set pop: MIPS option stack. +* .set push: MIPS option stack. +* .v850 directive, V850: V850 Directives. +* .v850e directive, V850: V850 Directives. +* 16-bit code, i386: i386-16bit. +* 29K support: AMD29K-Dependent. +* 3DNow!, i386: i386-SIMD. +* : (label): Statements. +* @word modifier, D10V: D10V-Word. +* \" (doublequote character): Strings. +* \\ (\ character): Strings. +* \b (backspace character): Strings. +* \DDD (octal character code): Strings. +* \f (formfeed character): Strings. +* \n (newline character): Strings. +* \r (carriage return character): Strings. +* \t (tab): Strings. +* \XD... (hex character code): Strings. +* a.out: Object. +* a.out symbol attributes: a.out Symbols. +* ABORT directive: ABORT. +* abort directive: Abort. +* absolute section: Ld Sections. +* addition, permitted arguments: Infix Ops. +* addresses: Expressions. +* addresses, format of: Secs Background. +* addressing modes, D10V: D10V-Addressing. +* addressing modes, D30V: D30V-Addressing. +* addressing modes, H8/300: H8/300-Addressing. +* addressing modes, H8/500: H8/500-Addressing. +* addressing modes, M680x0: M68K-Syntax. +* addressing modes, SH: SH-Addressing. +* addressing modes, Z8000: Z8000-Addressing. +* ADR reg,<label> pseudo op, ARM: ARM Opcodes. +* ADRL reg,<label> pseudo op, ARM: ARM Opcodes. +* advancing location counter: Org. +* align directive: Align. +* align directive, SPARC: Sparc-Directives. +* altered difference tables: Word. +* alternate syntax for the 680x0: M68K-Moto-Syntax. +* AMD 29K floating point (IEEE): AMD29K Floating Point. +* AMD 29K identifiers: AMD29K-Chars. +* AMD 29K line comment character: AMD29K-Chars. +* AMD 29K machine directives: AMD29K Directives. +* AMD 29K macros: AMD29K-Macros. +* AMD 29K opcodes: AMD29K Opcodes. +* AMD 29K options (none): AMD29K Options. +* AMD 29K protected registers: AMD29K-Regs. +* AMD 29K register names: AMD29K-Regs. +* AMD 29K special purpose registers: AMD29K-Regs. +* AMD 29K support: AMD29K-Dependent. +* ARC architectures: ARC-Opts. +* ARC big-endian output: ARC-Opts. +* ARC endianness: Overview. +* ARC floating point (IEEE): ARC-Float. +* ARC little-endian output: ARC-Opts. +* ARC machine directives: ARC-Directives. +* ARC options: ARC-Opts. +* ARC support: ARC-Dependent. +* architecture options, i960: Options-i960. +* architecture options, M680x0: M68K-Opts. +* architectures, ARC: ARC-Opts. +* architectures, SPARC: Sparc-Opts. +* arguments for addition: Infix Ops. +* arguments for subtraction: Infix Ops. +* arguments in expressions: Arguments. +* arithmetic functions: Operators. +* arithmetic operands: Arguments. +* arm directive, ARM: ARM Directives. +* ARM floating point (IEEE): ARM Floating Point. +* ARM identifiers: ARM-Chars. +* ARM immediate character: ARM-Chars. +* ARM line comment character: ARM-Chars. +* ARM line separator: ARM-Chars. +* ARM machine directives: ARM Directives. +* ARM opcodes: ARM Opcodes. +* ARM options (none): ARM Options. +* ARM register names: ARM-Regs. +* ARM support: ARM-Dependent. +* ascii directive: Ascii. +* asciz directive: Asciz. +* assembler bugs, reporting: Bug Reporting. +* assembler crash: Bug Criteria. +* assembler internal logic error: As Sections. +* assembler version: v. +* assembler, and linker: Secs Background. +* assembly listings, enabling: a. +* assigning values to symbols <1>: Equ. +* assigning values to symbols: Setting Symbols. +* attributes, symbol: Symbol Attributes. +* auxiliary attributes, COFF symbols: COFF Symbols. +* auxiliary symbol information, COFF: Dim. +* Av7: Sparc-Opts. +* backslash (\\): Strings. +* backspace (\b): Strings. +* balign directive: Balign. +* balignl directive: Balign. +* balignw directive: Balign. +* big endian output, ARC: Overview. +* big endian output, MIPS: Overview. +* big endian output, PJ: Overview. +* big-endian output, ARC: ARC-Opts. +* big-endian output, MIPS: MIPS Opts. +* bignums: Bignums. +* binary integers: Integers. +* bitfields, not supported on VAX: VAX-no. +* block: Z8000 Directives. +* block directive, AMD 29K: AMD29K Directives. +* branch improvement, M680x0: M68K-Branch. +* branch improvement, VAX: VAX-branch. +* branch recording, i960: Options-i960. +* branch statistics table, i960: Options-i960. +* bss directive, i960: Directives-i960. +* bss section <1>: bss. +* bss section: Ld Sections. +* bug criteria: Bug Criteria. +* bug reports: Bug Reporting. +* bugs in assembler: Reporting Bugs. +* bus lock prefixes, i386: i386-Prefixes. +* bval: Z8000 Directives. +* byte directive: Byte. +* call instructions, i386: i386-Mnemonics. +* callj, i960 pseudo-opcode: callj-i960. +* carriage return (\r): Strings. +* character constants: Characters. +* character escape codes: Strings. +* character, single: Chars. +* characters used in symbols: Symbol Intro. +* code directive, ARM: ARM Directives. +* code16 directive, i386: i386-16bit. +* code16gcc directive, i386: i386-16bit. +* code32 directive, i386: i386-16bit. +* COFF auxiliary symbol information: Dim. +* COFF structure debugging: Tag. +* COFF symbol attributes: COFF Symbols. +* COFF symbol descriptor: Desc. +* COFF symbol storage class: Scl. +* COFF symbol type: Type. +* COFF symbols, debugging: Def. +* COFF value attribute: Val. +* COMDAT: Linkonce. +* comm directive: Comm. +* command line conventions: Command Line. +* command line options, V850: V850 Options. +* command-line options ignored, VAX: VAX-Opts. +* comments: Comments. +* comments, M680x0: M68K-Chars. +* comments, removed by preprocessor: Preprocessing. +* common directive, SPARC: Sparc-Directives. +* common sections: Linkonce. +* common variable storage: bss. +* compare and jump expansions, i960: Compare-and-branch-i960. +* compare/branch instructions, i960: Compare-and-branch-i960. +* conditional assembly: If. +* constant, single character: Chars. +* constants: Constants. +* constants, bignum: Bignums. +* constants, character: Characters. +* constants, converted by preprocessor: Preprocessing. +* constants, floating point: Flonums. +* constants, integer: Integers. +* constants, number: Numbers. +* constants, string: Strings. +* conversion instructions, i386: i386-Mnemonics. +* coprocessor wait, i386: i386-Prefixes. +* cpu directive, SPARC: ARC-Directives. +* cputype directive, AMD 29K: AMD29K Directives. +* crash of assembler: Bug Criteria. +* ctbp register, V850: V850-Regs. +* ctoff pseudo-op, V850: V850 Opcodes. +* ctpc register, V850: V850-Regs. +* ctpsw register, V850: V850-Regs. +* current address: Dot. +* current address, advancing: Org. +* D10V @word modifier: D10V-Word. +* D10V addressing modes: D10V-Addressing. +* D10V floating point: D10V-Float. +* D10V line comment character: D10V-Chars. +* D10V opcode summary: D10V-Opcodes. +* D10V optimization: Overview. +* D10V options: D10V-Opts. +* D10V registers: D10V-Regs. +* D10V size modifiers: D10V-Size. +* D10V sub-instruction ordering: D10V-Chars. +* D10V sub-instructions: D10V-Subs. +* D10V support: D10V-Dependent. +* D10V syntax: D10V-Syntax. +* D30V addressing modes: D30V-Addressing. +* D30V floating point: D30V-Float. +* D30V Guarded Execution: D30V-Guarded. +* D30V line comment character: D30V-Chars. +* D30V nops: Overview. +* D30V nops after 32-bit multiply: Overview. +* D30V opcode summary: D30V-Opcodes. +* D30V optimization: Overview. +* D30V options: D30V-Opts. +* D30V registers: D30V-Regs. +* D30V size modifiers: D30V-Size. +* D30V sub-instruction ordering: D30V-Chars. +* D30V sub-instructions: D30V-Subs. +* D30V support: D30V-Dependent. +* D30V syntax: D30V-Syntax. +* data alignment on SPARC: Sparc-Aligned-Data. +* data and text sections, joining: R. +* data directive: Data. +* data section: Ld Sections. +* data1 directive, M680x0: M68K-Directives. +* data2 directive, M680x0: M68K-Directives. +* dbpc register, V850: V850-Regs. +* dbpsw register, V850: V850-Regs. +* debuggers, and symbol order: Symbols. +* debugging COFF symbols: Def. +* decimal integers: Integers. +* def directive: Def. +* dependency tracking: MD. +* deprecated directives: Deprecated. +* desc directive: Desc. +* descriptor, of a.out symbol: Symbol Desc. +* dfloat directive, VAX: VAX-directives. +* difference tables altered: Word. +* difference tables, warning: K. +* dim directive: Dim. +* directives and instructions: Statements. +* directives, M680x0: M68K-Directives. +* directives, machine independent: Pseudo Ops. +* directives, Z8000: Z8000 Directives. +* displacement sizing character, VAX: VAX-operands. +* dot (symbol): Dot. +* double directive: Double. +* double directive, i386: i386-Float. +* double directive, M680x0: M68K-Float. +* double directive, VAX: VAX-float. +* doublequote (\"): Strings. +* ECOFF sections: MIPS Object. +* ecr register, V850: V850-Regs. +* eight-byte integer: Quad. +* eipc register, V850: V850-Regs. +* eipsw register, V850: V850-Regs. +* eject directive: Eject. +* else directive: Else. +* elseif directive: Elseif. +* empty expressions: Empty Exprs. +* emulation: Overview. +* end directive: End. +* endef directive: Endef. +* endfunc directive: Endfunc. +* endianness, ARC: Overview. +* endianness, MIPS: Overview. +* endianness, PJ: Overview. +* endif directive: Endif. +* endm directive: Macro. +* EOF, newline must precede: Statements. +* ep register, V850: V850-Regs. +* equ directive: Equ. +* equiv directive: Equiv. +* err directive: Err. +* error messsages: Errors. +* error on valid input: Bug Criteria. +* errors, caused by warnings: W. +* errors, continuing after: Z. +* ESA/390 floating point (IEEE): ESA/390 Floating Point. +* ESA/390 support: ESA/390-Dependent. +* ESA/390 Syntax: ESA/390 Options. +* ESA/390-only directives: ESA/390 Directives. +* escape codes, character: Strings. +* even: Z8000 Directives. +* even directive, M680x0: M68K-Directives. +* exitm directive: Macro. +* expr (internal section): As Sections. +* expression arguments: Arguments. +* expressions: Expressions. +* expressions, empty: Empty Exprs. +* expressions, integer: Integer Exprs. +* extend directive M680x0: M68K-Float. +* extended directive, i960: Directives-i960. +* extern directive: Extern. +* fail directive: Fail. +* faster processing (-f): f. +* fatal signal: Bug Criteria. +* fepc register, V850: V850-Regs. +* fepsw register, V850: V850-Regs. +* ffloat directive, VAX: VAX-directives. +* file directive: File. +* file directive, AMD 29K: AMD29K Directives. +* file name, logical: File. +* files, including: Include. +* files, input: Input Files. +* fill directive: Fill. +* filling memory <1>: Space. +* filling memory: Skip. +* float directive: Float. +* float directive, i386: i386-Float. +* float directive, M680x0: M68K-Float. +* float directive, VAX: VAX-float. +* floating point numbers: Flonums. +* floating point numbers (double): Double. +* floating point numbers (single) <1>: Single. +* floating point numbers (single): Float. +* floating point, AMD 29K (IEEE): AMD29K Floating Point. +* floating point, ARC (IEEE): ARC-Float. +* floating point, ARM (IEEE): ARM Floating Point. +* floating point, D10V: D10V-Float. +* floating point, D30V: D30V-Float. +* floating point, ESA/390 (IEEE): ESA/390 Floating Point. +* floating point, H8/300 (IEEE): H8/300 Floating Point. +* floating point, H8/500 (IEEE): H8/500 Floating Point. +* floating point, HPPA (IEEE): HPPA Floating Point. +* floating point, i386: i386-Float. +* floating point, i960 (IEEE): Floating Point-i960. +* floating point, M680x0: M68K-Float. +* floating point, SH (IEEE): SH Floating Point. +* floating point, SPARC (IEEE): Sparc-Float. +* floating point, V850 (IEEE): V850 Floating Point. +* floating point, VAX: VAX-float. +* flonums: Flonums. +* force_thumb directive, ARM: ARM Directives. +* format of error messages: Errors. +* format of warning messages: Errors. +* formfeed (\f): Strings. +* func directive: Func. +* functions, in expressions: Operators. +* gbr960, i960 postprocessor: Options-i960. +* gfloat directive, VAX: VAX-directives. +* global: Z8000 Directives. +* global directive: Global. +* gp register, MIPS: MIPS Object. +* gp register, V850: V850-Regs. +* grouping data: Sub-Sections. +* H8/300 addressing modes: H8/300-Addressing. +* H8/300 floating point (IEEE): H8/300 Floating Point. +* H8/300 line comment character: H8/300-Chars. +* H8/300 line separator: H8/300-Chars. +* H8/300 machine directives (none): H8/300 Directives. +* H8/300 opcode summary: H8/300 Opcodes. +* H8/300 options (none): H8/300 Options. +* H8/300 registers: H8/300-Regs. +* H8/300 size suffixes: H8/300 Opcodes. +* H8/300 support: H8/300-Dependent. +* H8/300H, assembling for: H8/300 Directives. +* H8/500 addressing modes: H8/500-Addressing. +* H8/500 floating point (IEEE): H8/500 Floating Point. +* H8/500 line comment character: H8/500-Chars. +* H8/500 line separator: H8/500-Chars. +* H8/500 machine directives (none): H8/500 Directives. +* H8/500 opcode summary: H8/500 Opcodes. +* H8/500 options (none): H8/500 Options. +* H8/500 registers: H8/500-Regs. +* H8/500 support: H8/500-Dependent. +* half directive, SPARC: Sparc-Directives. +* hex character code (\XD...): Strings. +* hexadecimal integers: Integers. +* hfloat directive, VAX: VAX-directives. +* hi pseudo-op, V850: V850 Opcodes. +* hi0 pseudo-op, V850: V850 Opcodes. +* hidden directive: Visibility. +* hilo pseudo-op, V850: V850 Opcodes. +* HPPA directives not supported: HPPA Directives. +* HPPA floating point (IEEE): HPPA Floating Point. +* HPPA Syntax: HPPA Options. +* HPPA-only directives: HPPA Directives. +* hword directive: hword. +* i370 support: ESA/390-Dependent. +* i386 16-bit code: i386-16bit. +* i386 conversion instructions: i386-Mnemonics. +* i386 floating point: i386-Float. +* i386 immediate operands: i386-Syntax. +* i386 instruction naming: i386-Mnemonics. +* i386 instruction prefixes: i386-Prefixes. +* i386 jump optimization: i386-jumps. +* i386 jump, call, return: i386-Syntax. +* i386 jump/call operands: i386-Syntax. +* i386 memory references: i386-Memory. +* i386 mul, imul instructions: i386-Notes. +* i386 options (none): i386-Options. +* i386 register operands: i386-Syntax. +* i386 registers: i386-Regs. +* i386 sections: i386-Syntax. +* i386 size suffixes: i386-Syntax. +* i386 source, destination operands: i386-Syntax. +* i386 support: i386-Dependent. +* i386 syntax compatibility: i386-Syntax. +* i80306 support: i386-Dependent. +* i960 architecture options: Options-i960. +* i960 branch recording: Options-i960. +* i960 callj pseudo-opcode: callj-i960. +* i960 compare and jump expansions: Compare-and-branch-i960. +* i960 compare/branch instructions: Compare-and-branch-i960. +* i960 floating point (IEEE): Floating Point-i960. +* i960 machine directives: Directives-i960. +* i960 opcodes: Opcodes for i960. +* i960 options: Options-i960. +* i960 support: i960-Dependent. +* ident directive: Ident. +* identifiers, AMD 29K: AMD29K-Chars. +* identifiers, ARM: ARM-Chars. +* if directive: If. +* ifc directive: If. +* ifdef directive: If. +* ifeq directive: If. +* ifeqs directive: If. +* ifge directive: If. +* ifgt directive: If. +* ifle directive: If. +* iflt directive: If. +* ifnc directive: If. +* ifndef directive: If. +* ifne directive: If. +* ifnes directive: If. +* ifnotdef directive: If. +* immediate character, ARM: ARM-Chars. +* immediate character, M680x0: M68K-Chars. +* immediate character, VAX: VAX-operands. +* immediate operands, i386: i386-Syntax. +* imul instruction, i386: i386-Notes. +* include directive: Include. +* include directive search path: I. +* indirect character, VAX: VAX-operands. +* infix operators: Infix Ops. +* inhibiting interrupts, i386: i386-Prefixes. +* input: Input Files. +* input file linenumbers: Input Files. +* instruction naming, i386: i386-Mnemonics. +* instruction prefixes, i386: i386-Prefixes. +* instruction set, M680x0: M68K-opcodes. +* instruction summary, D10V: D10V-Opcodes. +* instruction summary, D30V: D30V-Opcodes. +* instruction summary, H8/300: H8/300 Opcodes. +* instruction summary, H8/500: H8/500 Opcodes. +* instruction summary, SH: SH Opcodes. +* instruction summary, Z8000: Z8000 Opcodes. +* instructions and directives: Statements. +* int directive: Int. +* int directive, H8/300: H8/300 Directives. +* int directive, H8/500: H8/500 Directives. +* int directive, i386: i386-Float. +* integer expressions: Integer Exprs. +* integer, 16-byte: Octa. +* integer, 8-byte: Quad. +* integers: Integers. +* integers, 16-bit: hword. +* integers, 32-bit: Int. +* integers, binary: Integers. +* integers, decimal: Integers. +* integers, hexadecimal: Integers. +* integers, octal: Integers. +* integers, one byte: Byte. +* internal assembler sections: As Sections. +* internal directive: Visibility. +* invalid input: Bug Criteria. +* invocation summary: Overview. +* irp directive: Irp. +* irpc directive: Irpc. +* joining text and data sections: R. +* jump instructions, i386: i386-Mnemonics. +* jump optimization, i386: i386-jumps. +* jump/call operands, i386: i386-Syntax. +* label (:): Statements. +* labels: Labels. +* lcomm directive: Lcomm. +* ld: Object. +* ldouble directive M680x0: M68K-Float. +* LDR reg,=<label> pseudo op, ARM: ARM Opcodes. +* leafproc directive, i960: Directives-i960. +* length of symbols: Symbol Intro. +* lflags directive (ignored): Lflags. +* line comment character: Comments. +* line comment character, AMD 29K: AMD29K-Chars. +* line comment character, ARM: ARM-Chars. +* line comment character, D10V: D10V-Chars. +* line comment character, D30V: D30V-Chars. +* line comment character, H8/300: H8/300-Chars. +* line comment character, H8/500: H8/500-Chars. +* line comment character, M680x0: M68K-Chars. +* line comment character, SH: SH-Chars. +* line comment character, V850: V850-Chars. +* line comment character, Z8000: Z8000-Chars. +* line directive: Line. +* line directive, AMD 29K: AMD29K Directives. +* line numbers, in input files: Input Files. +* line numbers, in warnings/errors: Errors. +* line separator character: Statements. +* line separator, ARM: ARM-Chars. +* line separator, H8/300: H8/300-Chars. +* line separator, H8/500: H8/500-Chars. +* line separator, SH: SH-Chars. +* line separator, Z8000: Z8000-Chars. +* lines starting with #: Comments. +* linker: Object. +* linker, and assembler: Secs Background. +* linkonce directive: Linkonce. +* list directive: List. +* listing control, turning off: Nolist. +* listing control, turning on: List. +* listing control: new page: Eject. +* listing control: paper size: Psize. +* listing control: subtitle: Sbttl. +* listing control: title line: Title. +* listings, enabling: a. +* little endian output, ARC: Overview. +* little endian output, MIPS: Overview. +* little endian output, PJ: Overview. +* little-endian output, ARC: ARC-Opts. +* little-endian output, MIPS: MIPS Opts. +* ln directive: Ln. +* lo pseudo-op, V850: V850 Opcodes. +* local common symbols: Lcomm. +* local labels, retaining in output: L. +* local symbol names: Symbol Names. +* location counter: Dot. +* location counter, advancing: Org. +* logical file name: File. +* logical line number: Line. +* logical line numbers: Comments. +* long directive: Long. +* long directive, i386: i386-Float. +* lp register, V850: V850-Regs. +* lval: Z8000 Directives. +* M680x0 addressing modes: M68K-Syntax. +* M680x0 architecture options: M68K-Opts. +* M680x0 branch improvement: M68K-Branch. +* M680x0 directives: M68K-Directives. +* M680x0 floating point: M68K-Float. +* M680x0 immediate character: M68K-Chars. +* M680x0 line comment character: M68K-Chars. +* M680x0 opcodes: M68K-opcodes. +* M680x0 options: M68K-Opts. +* M680x0 pseudo-opcodes: M68K-Branch. +* M680x0 size modifiers: M68K-Syntax. +* M680x0 support: M68K-Dependent. +* M680x0 syntax: M68K-Syntax. +* machine dependencies: Machine Dependencies. +* machine directives, AMD 29K: AMD29K Directives. +* machine directives, ARC: ARC-Directives. +* machine directives, ARM: ARM Directives. +* machine directives, H8/300 (none): H8/300 Directives. +* machine directives, H8/500 (none): H8/500 Directives. +* machine directives, i960: Directives-i960. +* machine directives, SH: SH Directives. +* machine directives, SPARC: Sparc-Directives. +* machine directives, V850: V850 Directives. +* machine directives, VAX: VAX-directives. +* machine independent directives: Pseudo Ops. +* machine instructions (not covered): Manual. +* machine-independent syntax: Syntax. +* macro directive: Macro. +* macros: Macro. +* Macros, AMD 29K: AMD29K-Macros. +* macros, count executed: Macro. +* make rules: MD. +* manual, structure and purpose: Manual. +* memory references, i386: i386-Memory. +* merging text and data sections: R. +* messages from assembler: Errors. +* minus, permitted arguments: Infix Ops. +* MIPS architecture options: MIPS Opts. +* MIPS big-endian output: MIPS Opts. +* MIPS debugging directives: MIPS Stabs. +* MIPS ECOFF sections: MIPS Object. +* MIPS endianness: Overview. +* MIPS ISA: Overview. +* MIPS ISA override: MIPS ISA. +* MIPS little-endian output: MIPS Opts. +* MIPS option stack: MIPS option stack. +* MIPS processor: MIPS-Dependent. +* MIT: M68K-Syntax. +* MMX, i386: i386-SIMD. +* mnemonic suffixes, i386: i386-Syntax. +* mnemonics for opcodes, VAX: VAX-opcodes. +* mnemonics, D10V: D10V-Opcodes. +* mnemonics, D30V: D30V-Opcodes. +* mnemonics, H8/300: H8/300 Opcodes. +* mnemonics, H8/500: H8/500 Opcodes. +* mnemonics, SH: SH Opcodes. +* mnemonics, Z8000: Z8000 Opcodes. +* Motorola syntax for the 680x0: M68K-Moto-Syntax. +* MRI compatibility mode: M. +* mri directive: MRI. +* MRI mode, temporarily: MRI. +* mul instruction, i386: i386-Notes. +* name: Z8000 Directives. +* named section: Section. +* named sections: Ld Sections. +* names, symbol: Symbol Names. +* naming object file: o. +* new page, in listings: Eject. +* newline (\n): Strings. +* newline, required at file end: Statements. +* nolist directive: Nolist. +* NOP pseudo op, ARM: ARM Opcodes. +* null-terminated strings: Asciz. +* number constants: Numbers. +* number of macros executed: Macro. +* numbered subsections: Sub-Sections. +* numbers, 16-bit: hword. +* numeric values: Expressions. +* nword directive, SPARC: Sparc-Directives. +* object file: Object. +* object file format: Object Formats. +* object file name: o. +* object file, after errors: Z. +* obsolescent directives: Deprecated. +* octa directive: Octa. +* octal character code (\DDD): Strings. +* octal integers: Integers. +* offset directive, V850: V850 Directives. +* opcode mnemonics, VAX: VAX-opcodes. +* opcode summary, D10V: D10V-Opcodes. +* opcode summary, D30V: D30V-Opcodes. +* opcode summary, H8/300: H8/300 Opcodes. +* opcode summary, H8/500: H8/500 Opcodes. +* opcode summary, SH: SH Opcodes. +* opcode summary, Z8000: Z8000 Opcodes. +* opcodes for AMD 29K: AMD29K Opcodes. +* opcodes for ARM: ARM Opcodes. +* opcodes for V850: V850 Opcodes. +* opcodes, i960: Opcodes for i960. +* opcodes, M680x0: M68K-opcodes. +* operand delimiters, i386: i386-Syntax. +* operand notation, VAX: VAX-operands. +* operands in expressions: Arguments. +* operator precedence: Infix Ops. +* operators, in expressions: Operators. +* operators, permitted arguments: Infix Ops. +* optimization, D10V: Overview. +* optimization, D30V: Overview. +* option summary: Overview. +* options for AMD29K (none): AMD29K Options. +* options for ARC: ARC-Opts. +* options for ARM (none): ARM Options. +* options for i386 (none): i386-Options. +* options for SPARC: Sparc-Opts. +* options for V850 (none): V850 Options. +* options for VAX/VMS: VAX-Opts. +* options, all versions of assembler: Invoking. +* options, command line: Command Line. +* options, D10V: D10V-Opts. +* options, D30V: D30V-Opts. +* options, H8/300 (none): H8/300 Options. +* options, H8/500 (none): H8/500 Options. +* options, i960: Options-i960. +* options, M680x0: M68K-Opts. +* options, PJ: PJ Options. +* options, SH (none): SH Options. +* options, Z8000: Z8000 Options. +* org directive: Org. +* other attribute, of a.out symbol: Symbol Other. +* output file: Object. +* p2align directive: P2align. +* p2alignl directive: P2align. +* p2alignw directive: P2align. +* padding the location counter: Align. +* padding the location counter given a power of two: P2align. +* padding the location counter given number of bytes: Balign. +* page, in listings: Eject. +* paper size, for listings: Psize. +* paths for .include: I. +* patterns, writing in memory: Fill. +* PIC code generation for ARM: ARM Options. +* PJ endianness: Overview. +* PJ options: PJ Options. +* PJ support: PJ-Dependent. +* plus, permitted arguments: Infix Ops. +* precedence of operators: Infix Ops. +* precision, floating point: Flonums. +* prefix operators: Prefix Ops. +* prefixes, i386: i386-Prefixes. +* preprocessing: Preprocessing. +* preprocessing, turning on and off: Preprocessing. +* primary attributes, COFF symbols: COFF Symbols. +* print directive: Print. +* proc directive, SPARC: Sparc-Directives. +* protected directive: Visibility. +* protected registers, AMD 29K: AMD29K-Regs. +* pseudo-opcodes, M680x0: M68K-Branch. +* pseudo-ops for branch, VAX: VAX-branch. +* pseudo-ops, machine independent: Pseudo Ops. +* psize directive: Psize. +* psw register, V850: V850-Regs. +* purgem directive: Purgem. +* purpose of GNU assembler: GNU Assembler. +* quad directive: Quad. +* quad directive, i386: i386-Float. +* real-mode code, i386: i386-16bit. +* register directive, SPARC: Sparc-Directives. +* register names, AMD 29K: AMD29K-Regs. +* register names, ARM: ARM-Regs. +* register names, H8/300: H8/300-Regs. +* register names, V850: V850-Regs. +* register names, VAX: VAX-operands. +* register operands, i386: i386-Syntax. +* registers, D10V: D10V-Regs. +* registers, D30V: D30V-Regs. +* registers, H8/500: H8/500-Regs. +* registers, i386: i386-Regs. +* registers, SH: SH-Regs. +* registers, Z8000: Z8000-Regs. +* relocation: Sections. +* relocation example: Ld Sections. +* repeat prefixes, i386: i386-Prefixes. +* reporting bugs in assembler: Reporting Bugs. +* rept directive: Rept. +* req directive, ARM: ARM Directives. +* reserve directive, SPARC: Sparc-Directives. +* return instructions, i386: i386-Syntax. +* rsect: Z8000 Directives. +* sbttl directive: Sbttl. +* scl directive: Scl. +* sdaoff pseudo-op, V850: V850 Opcodes. +* search path for .include: I. +* sect directive, AMD 29K: AMD29K Directives. +* section directive: Section. +* section directive, V850: V850 Directives. +* section override prefixes, i386: i386-Prefixes. +* section-relative addressing: Secs Background. +* sections: Sections. +* sections in messages, internal: As Sections. +* sections, i386: i386-Syntax. +* sections, named: Ld Sections. +* seg directive, SPARC: Sparc-Directives. +* segm: Z8000 Directives. +* set directive: Set. +* SH addressing modes: SH-Addressing. +* SH floating point (IEEE): SH Floating Point. +* SH line comment character: SH-Chars. +* SH line separator: SH-Chars. +* SH machine directives: SH Directives. +* SH opcode summary: SH Opcodes. +* SH options (none): SH Options. +* SH registers: SH-Regs. +* SH support: SH-Dependent. +* short directive: Short. +* SIMD, i386: i386-SIMD. +* single character constant: Chars. +* single directive: Single. +* single directive, i386: i386-Float. +* sixteen bit integers: hword. +* sixteen byte integer: Octa. +* size directive: Size. +* size modifiers, D10V: D10V-Size. +* size modifiers, D30V: D30V-Size. +* size modifiers, M680x0: M68K-Syntax. +* size prefixes, i386: i386-Prefixes. +* size suffixes, H8/300: H8/300 Opcodes. +* sizes operands, i386: i386-Syntax. +* skip directive: Skip. +* skip directive, M680x0: M68K-Directives. +* skip directive, SPARC: Sparc-Directives. +* sleb128 directive: Sleb128. +* small objects, MIPS ECOFF: MIPS Object. +* SOM symbol attributes: SOM Symbols. +* source program: Input Files. +* source, destination operands; i386: i386-Syntax. +* sp register, V850: V850-Regs. +* space directive: Space. +* space used, maximum for assembly: statistics. +* SPARC architectures: Sparc-Opts. +* SPARC data alignment: Sparc-Aligned-Data. +* SPARC floating point (IEEE): Sparc-Float. +* SPARC machine directives: Sparc-Directives. +* SPARC options: Sparc-Opts. +* SPARC support: Sparc-Dependent. +* special characters, M680x0: M68K-Chars. +* special purpose registers, AMD 29K: AMD29K-Regs. +* stabd directive: Stab. +* stabn directive: Stab. +* stabs directive: Stab. +* stabX directives: Stab. +* standard assembler sections: Secs Background. +* standard input, as input file: Command Line. +* statement separator character: Statements. +* statement separator, ARM: ARM-Chars. +* statement separator, H8/300: H8/300-Chars. +* statement separator, H8/500: H8/500-Chars. +* statement separator, SH: SH-Chars. +* statement separator, Z8000: Z8000-Chars. +* statements, structure of: Statements. +* statistics, about assembly: statistics. +* stopping the assembly: Abort. +* string constants: Strings. +* string directive: String. +* string directive on HPPA: HPPA Directives. +* string literals: Ascii. +* string, copying to object file: String. +* struct directive: Struct. +* structure debugging, COFF: Tag. +* sub-instruction ordering, D10V: D10V-Chars. +* sub-instruction ordering, D30V: D30V-Chars. +* sub-instructions, D10V: D10V-Subs. +* sub-instructions, D30V: D30V-Subs. +* subexpressions: Arguments. +* subtitles for listings: Sbttl. +* subtraction, permitted arguments: Infix Ops. +* summary of options: Overview. +* support: HPPA-Dependent. +* supporting files, including: Include. +* suppressing warnings: W. +* sval: Z8000 Directives. +* symbol attributes: Symbol Attributes. +* symbol attributes, a.out: a.out Symbols. +* symbol attributes, COFF: COFF Symbols. +* symbol attributes, SOM: SOM Symbols. +* symbol descriptor, COFF: Desc. +* symbol names: Symbol Names. +* symbol names, $ in <1>: SH-Chars. +* symbol names, $ in <2>: H8/500-Chars. +* symbol names, $ in <3>: D30V-Chars. +* symbol names, $ in: D10V-Chars. +* symbol names, local: Symbol Names. +* symbol names, temporary: Symbol Names. +* symbol storage class (COFF): Scl. +* symbol type: Symbol Type. +* symbol type, COFF: Type. +* symbol value: Symbol Value. +* symbol value, setting: Set. +* symbol values, assigning: Setting Symbols. +* symbol versioning: Symver. +* symbol visibility: Visibility. +* symbol, common: Comm. +* symbol, making visible to linker: Global. +* symbolic debuggers, information for: Stab. +* symbols: Symbols. +* symbols with uppercase, VAX/VMS: VAX-Opts. +* symbols, assigning values to: Equ. +* symbols, local common: Lcomm. +* symver directive: Symver. +* syntax compatibility, i386: i386-Syntax. +* syntax, D10V: D10V-Syntax. +* syntax, D30V: D30V-Syntax. +* syntax, M680x0: M68K-Syntax. +* syntax, machine-independent: Syntax. +* sysproc directive, i960: Directives-i960. +* tab (\t): Strings. +* tag directive: Tag. +* tdaoff pseudo-op, V850: V850 Opcodes. +* temporary symbol names: Symbol Names. +* text and data sections, joining: R. +* text directive: Text. +* text section: Ld Sections. +* tfloat directive, i386: i386-Float. +* thumb directive, ARM: ARM Directives. +* Thumb support: ARM-Dependent. +* thumb_func directive, ARM: ARM Directives. +* thumb_set directive, ARM: ARM Directives. +* time, total for assembly: statistics. +* title directive: Title. +* tp register, V850: V850-Regs. +* trusted compiler: f. +* turning preprocessing on and off: Preprocessing. +* type directive: Type. +* type of a symbol: Symbol Type. +* ualong directive, SH: SH Directives. +* uaword directive, SH: SH Directives. +* uleb128 directive: Uleb128. +* undefined section: Ld Sections. +* unsegm: Z8000 Directives. +* use directive, AMD 29K: AMD29K Directives. +* V850 command line options: V850 Options. +* V850 floating point (IEEE): V850 Floating Point. +* V850 line comment character: V850-Chars. +* V850 machine directives: V850 Directives. +* V850 opcodes: V850 Opcodes. +* V850 options (none): V850 Options. +* V850 register names: V850-Regs. +* V850 support: V850-Dependent. +* val directive: Val. +* value attribute, COFF: Val. +* value of a symbol: Symbol Value. +* VAX bitfields not supported: VAX-no. +* VAX branch improvement: VAX-branch. +* VAX command-line options ignored: VAX-Opts. +* VAX displacement sizing character: VAX-operands. +* VAX floating point: VAX-float. +* VAX immediate character: VAX-operands. +* VAX indirect character: VAX-operands. +* VAX machine directives: VAX-directives. +* VAX opcode mnemonics: VAX-opcodes. +* VAX operand notation: VAX-operands. +* VAX register names: VAX-operands. +* VAX support: Vax-Dependent. +* Vax-11 C compatibility: VAX-Opts. +* VAX/VMS options: VAX-Opts. +* version of assembler: v. +* versions of symbols: Symver. +* VMS (VAX) options: VAX-Opts. +* warning for altered difference tables: K. +* warning messages: Errors. +* warnings, causing error: W. +* warnings, suppressing: W. +* warnings, switching on: W. +* whitespace: Whitespace. +* whitespace, removed by preprocessor: Preprocessing. +* wide floating point directives, VAX: VAX-directives. +* word directive: Word. +* word directive, H8/300: H8/300 Directives. +* word directive, H8/500: H8/500 Directives. +* word directive, i386: i386-Float. +* word directive, SPARC: Sparc-Directives. +* writing patterns in memory: Fill. +* wval: Z8000 Directives. +* xword directive, SPARC: Sparc-Directives. +* Z800 addressing modes: Z8000-Addressing. +* Z8000 directives: Z8000 Directives. +* Z8000 line comment character: Z8000-Chars. +* Z8000 line separator: Z8000-Chars. +* Z8000 opcode summary: Z8000 Opcodes. +* Z8000 options: Z8000 Options. +* Z8000 registers: Z8000-Regs. +* Z8000 support: Z8000-Dependent. +* zdaoff pseudo-op, V850: V850 Opcodes. +* zero register, V850: V850-Regs. +* zero-terminated strings: Asciz. + + diff --git a/gas/doc/gasp.info b/gas/doc/gasp.info new file mode 100644 index 00000000000..07979042e12 --- /dev/null +++ b/gas/doc/gasp.info @@ -0,0 +1,1085 @@ +This is gasp.info, produced by makeinfo version 4.0 from gasp.texi. + +START-INFO-DIR-ENTRY +* gasp: (gasp). The GNU Assembler Preprocessor +END-INFO-DIR-ENTRY + + Copyright (C) 1994, 1995 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: gasp.info, Node: Top, Next: Overview, Up: (dir) + +GASP +**** + + GASP is a preprocessor for assembly programs. + + This file describes version 1 of GASP. + + Steve Chamberlain wrote GASP; Roland Pesch wrote this manual. + +* Menu: + +* Overview:: What is GASP? +* Invoking GASP:: Command line options. +* Commands:: Preprocessor commands. +* Index:: Index. + + +File: gasp.info, Node: Overview, Next: Invoking GASP, Prev: Top, Up: Top + +What is GASP? +************* + + The primary purpose of the GNU assembler is to assemble the output of +other programs--notably compilers. When you have to hand-code +specialized routines in assembly, that means the GNU assembler is an +unfriendly processor: it has no directives for macros, conditionals, or +many other conveniences that you might expect. + + In some cases you can simply use the C preprocessor, or a generalized +preprocessor like M4; but this can be awkward, since none of these +things are designed with assembly in mind. + + GASP fills this need. It is expressly designed to provide the +facilities you need with hand-coded assembly code. Implementing it as a +preprocessor, rather than part of the assembler, allows the maximum +flexibility: you can use it with hand-coded assembly, without paying a +penalty of added complexity in the assembler you use for compiler +output. + + Here is a small example to give the flavor of GASP. This input to +GASP + + .MACRO saveregs from=8 to=14 + count .ASSIGNA \from + ! save r\from..r\to + .AWHILE \&count LE \to + mov r\&count,@-sp + count .ASSIGNA \&count + 1 + .AENDW + .ENDM + + saveregs from=12 + + bar: mov #H'dead+10,r0 + foo .SDATAC "hello"<10> + .END + +generates this assembly program: + + ! save r12..r14 + mov r12,@-sp + mov r13,@-sp + mov r14,@-sp + + bar: mov #57005+10,r0 + foo: .byte 6,104,101,108,108,111,10 + + +File: gasp.info, Node: Invoking GASP, Next: Commands, Prev: Overview, Up: Top + +Command Line Options +******************** + + The simplest way to use GASP is to run it as a filter and assemble +its output. In Unix and its ilk, you can do this, for example: + + $ gasp prog.asm | as -o prog.o + + Naturally, there are also a few command-line options to allow you to +request variations on this basic theme. Here is the full set of +possibilities for the GASP command line. + + gasp [ -a | --alternate ] + [ -c CHAR | --commentchar CHAR ] + [ -d | --debug ] [ -h | --help ] [ -M | --mri ] + [ -o OUTFILE | --output OUTFILE ] + [ -p | --print ] [ -s | --copysource ] + [ -u | --unreasonable ] [ -v | --version ] + INFILE ... + +`INFILE ...' + The input file names. You must specify at least one input file; + if you specify more, GASP preprocesses them all, concatenating the + output in the order you list the INFILE arguments. + + Mark the end of each input file with the preprocessor command + `.END'. *Note Miscellaneous commands: Other Commands. + +`-a' +`--alternate' + Use alternative macro syntax. *Note Alternate macro syntax: + Alternate, for a discussion of how this syntax differs from the + default GASP syntax. + +`-c 'CHAR'' +`--commentchar 'CHAR'' + Use CHAR as the comment character. The default comment character + is `!'. For example, to use a semicolon as the comment character, + specify `-c ';'' on the GASP command line. Since assembler + command characters often have special significance to command + shells, it is a good idea to quote or escape CHAR when you specify + a comment character. + + For the sake of simplicity, all examples in this manual use the + default comment character `!'. + +`-d' +`--debug' + Show debugging statistics. In this version of GASP, this option + produces statistics about the string buffers that GASP allocates + internally. For each defined buffersize S, GASP shows the number + of strings N that it allocated, with a line like this: + + strings size S : N + + GASP displays these statistics on the standard error stream, when + done preprocessing. + +`-h' +`--help' + Display a summary of the GASP command line options. + +`-M' +`--mri' + Use MRI compatibility mode. Using this option causes GASP to + accept the syntax and pseudo-ops used by the Microtec Research + `ASM68K' assembler. + +`-o OUTFILE' +`--output OUTFILE' + Write the output in a file called OUTFILE. If you do not use the + `-o' option, GASP writes its output on the standard output stream. + +`-p' +`--print' + Print line numbers. GASP obeys this option _only_ if you also + specify `-s' to copy source lines to its output. With `-s -p', + GASP displays the line number of each source line copied + (immediately after the comment character at the beginning of the + line). + +`-s' +`--copysource' + Copy the source lines to the output file. Use this option to see + the effect of each preprocessor line on the GASP output. GASP + places a comment character (`!' by default) at the beginning of + each source line it copies, so that you can use this option and + still assemble the result. + +`-u' +`--unreasonable' + Bypass "unreasonable expansion" limit. Since you can define GASP + macros inside other macro definitions, the preprocessor normally + includes a sanity check. If your program requires more than 1,000 + nested expansions, GASP normally exits with an error message. Use + this option to turn off this check, allowing unlimited nested + expansions. + +`-v' +`--version' + Display the GASP version number. + + +File: gasp.info, Node: Commands, Next: Index, Prev: Invoking GASP, Up: Top + +Preprocessor Commands +********************* + + GASP commands have a straightforward syntax that fits in well with +assembly conventions. In general, a command extends for a line, and may +have up to three fields: an optional label, the command itself, and +optional arguments to the command. You can write commands in upper or +lower case, though this manual shows them in upper case. *Note Details +of the GASP syntax: Syntax Details, for more information. + +* Menu: + +* Conditionals:: +* Loops:: +* Variables:: +* Macros:: +* Data:: +* Listings:: +* Other Commands:: +* Syntax Details:: +* Alternate:: + + +File: gasp.info, Node: Conditionals, Next: Loops, Up: Commands + +Conditional assembly +==================== + + The conditional-assembly directives allow you to include or exclude +portions of an assembly depending on how a pair of expressions, or a +pair of strings, compare. + + The overall structure of conditionals is familiar from many other +contexts. `.AIF' marks the start of a conditional, and precedes +assembly for the case when the condition is true. An optional +`.AELSE' precedes assembly for the converse case, and an `.AENDI' marks +the end of the condition. + + You may nest conditionals up to a depth of 100; GASP rejects nesting +beyond that, because it may indicate a bug in your macro structure. + + Conditionals are primarily useful inside macro definitions, where you +often need different effects depending on argument values. *Note +Defining your own directives: Macros, for details about defining macros. + +`.AIF EXPRA CMP EXPRB' +`.AIF "STRA" CMP "STRB"' + The governing condition goes on the same line as the `.AIF' + preprocessor command. You may compare either two strings, or two + expressions. + + When you compare strings, only two conditional CMP comparison + operators are available: `EQ' (true if STRA and STRB are + identical), and `NE' (the opposite). + + When you compare two expressions, _both expressions must be + absolute_ (*note Arithmetic expressions in GASP: Expressions.). + You can use these CMP comparison operators with expressions: + + `EQ' + Are EXPRA and EXPRB equal? (For strings, are STRA and STRB + identical?) + + `NE' + Are EXPRA and EXPRB different? (For strings, are STRA and + STRB different? + + `LT' + Is EXPRA less than EXPRB? (Not allowed for strings.) + + `LE' + Is EXPRA less than or equal to EXPRB? (Not allowed for + strings.) + + `GT' + Is EXPRA greater than EXPRB? (Not allowed for strings.) + + `GE' + Is EXPRA greater than or equal to EXPRB? (Not allowed for + strings.) + +`.AELSE' + Marks the start of assembly code to be included if the condition + fails. Optional, and only allowed within a conditional (between + `.AIF' and `.AENDI'). + +`.AENDI' + Marks the end of a conditional assembly. + + +File: gasp.info, Node: Loops, Next: Variables, Prev: Conditionals, Up: Commands + +Repetitive sections of assembly +=============================== + + Two preprocessor directives allow you to repeatedly issue copies of +the same block of assembly code. + +`.AREPEAT AEXP' +`.AENDR' + If you simply need to repeat the same block of assembly over and + over a fixed number of times, sandwich one instance of the + repeated block between `.AREPEAT' and `.AENDR'. Specify the + number of copies as AEXP (which must be an absolute expression). + For example, this repeats two assembly statements three times in + succession: + + .AREPEAT 3 + rotcl r2 + div1 r0,r1 + .AENDR + +`.AWHILE EXPRA CMP EXPRB' +`.AENDW' +`.AWHILE STRA CMP STRB' +`.AENDW' + To repeat a block of assembly depending on a conditional test, + rather than repeating it for a specific number of times, use + `.AWHILE'. `.AENDW' marks the end of the repeated block. The + conditional comparison works exactly the same way as for `.AIF', + with the same comparison operators (*note Conditional assembly: + Conditionals.). + + Since the terms of the comparison must be absolute expression, + `.AWHILE' is primarily useful within macros. *Note Defining your + own directives: Macros. + + You can use the `.EXITM' preprocessor directive to break out of +loops early (as well as to break out of macros). *Note Defining your +own directives: Macros. + + +File: gasp.info, Node: Variables, Next: Macros, Prev: Loops, Up: Commands + +Preprocessor variables +====================== + + You can use variables in GASP to represent strings, registers, or +the results of expressions. + + You must distinguish two kinds of variables: + 1. Variables defined with `.EQU' or `.ASSIGN'. To evaluate this kind + of variable in your assembly output, simply mention its name. For + example, these two lines define and use a variable `eg': + + eg .EQU FLIP-64 + ... + mov.l eg,r0 + + _Do not use_ this kind of variable in conditional expressions or + while loops; GASP only evaluates these variables when writing + assembly output. + + 2. Variables for use during preprocessing. You can define these with + `.ASSIGNC' or `.ASSIGNA'. To evaluate this kind of variable, + write `\&' before the variable name; for example, + + opcit .ASSIGNA 47 + ... + .AWHILE \&opcit GT 0 + ... + .AENDW + + GASP treats macro arguments almost the same way, but to evaluate + them you use the prefix `\' rather than `\&'. *Note Defining your + own directives: Macros. + +`PVAR .EQU EXPR' + Assign preprocessor variable PVAR the value of the expression + EXPR. There are no restrictions on redefinition; use `.EQU' with + the same PVAR as often as you find it convenient. + +`PVAR .ASSIGN EXPR' + Almost the same as `.EQU', save that you may not redefine PVAR + using `.ASSIGN' once it has a value. + +`PVAR .ASSIGNA AEXPR' + Define a variable with a numeric value, for use during + preprocessing. AEXPR must be an absolute expression. You can + redefine variables with `.ASSIGNA' at any time. + +`PVAR .ASSIGNC "STR"' + Define a variable with a string value, for use during + preprocessing. You can redefine variables with `.ASSIGNC' at any + time. + +`PVAR .REG (REGISTER)' + Use `.REG' to define a variable that represents a register. In + particular, REGISTER is _not evaluated_ as an expression. You may + use `.REG' at will to redefine register variables. + + All these directives accept the variable name in the "label" +position, that is at the left margin. You may specify a colon after +the variable name if you wish; the first example above could have +started `eg:' with the same effect. + + +File: gasp.info, Node: Macros, Next: Data, Prev: Variables, Up: Commands + +Defining your own directives +============================ + + The commands `.MACRO' and `.ENDM' allow you to define macros that +generate assembly output. You can use these macros with a syntax +similar to built-in GASP or assembler directives. For example, this +definition specifies a macro `SUM' that adds together a range of +consecutive registers: + + .MACRO SUM FROM=0, TO=9 + ! \FROM \TO + mov r\FROM,r10 + COUNT .ASSIGNA \FROM+1 + .AWHILE \&COUNT LE \TO + add r\&COUNT,r10 + COUNT .ASSIGNA \&COUNT+1 + .AENDW + .ENDM + +With that definition, `SUM 0,5' generates this assembly output: + + ! 0 5 + mov r0,r10 + add r1,r10 + add r2,r10 + add r3,r10 + add r4,r10 + add r5,r10 + +`.MACRO MACNAME' +`.MACRO MACNAME MACARGS ...' + Begin the definition of a macro called MACNAME. If your macro + definition requires arguments, specify their names after the macro + name, separated by commas or spaces. You can supply a default + value for any macro argument by following the name with `=DEFLT'. + For example, these are all valid `.MACRO' statements: + + `.MACRO COMM' + Begin the definition of a macro called `COMM', which takes no + arguments. + + `.MACRO PLUS1 P, P1' + `.MACRO PLUS1 P P1' + Either statement begins the definition of a macro called + `PLUS1', which takes two arguments; within the macro + definition, write `\P' or `\P1' to evaluate the arguments. + + `.MACRO RESERVE_STR P1=0 P2' + Begin the definition of a macro called `RESERVE_STR', with two + arguments. The first argument has a default value, but not + the second. After the definition is complete, you can call + the macro either as `RESERVE_STR A,B' (with `\P1' evaluating + to A and `\P2' evaluating to B), or as `RESERVE_STR ,B' (with + `\P1' evaluating as the default, in this case `0', and `\P2' + evaluating to B). + + When you call a macro, you can specify the argument values either + by position, or by keyword. For example, `SUM 9,17' is equivalent + to `SUM TO=17, FROM=9'. Macro arguments are preprocessor variables + similar to the variables you define with `.ASSIGNA' or `.ASSIGNC'; + in particular, you can use them in conditionals or for loop + control. (The only difference is the prefix you write to evaluate + the variable: for a macro argument, write `\ARGNAME', but for a + preprocessor variable, write `\&VARNAME'.) + +`NAME .MACRO' +`NAME .MACRO ( MACARGS ... )' + An alternative form of introducing a macro definition: specify the + macro name in the label position, and the arguments (if any) + between parentheses after the name. Defaulting rules and usage + work the same way as for the other macro definition syntax. + +`.ENDM' + Mark the end of a macro definition. + +`.EXITM' + Exit early from the current macro definition, `.AREPEAT' loop, or + `.AWHILE' loop. + +`\@' + GASP maintains a counter of how many macros it has executed in + this pseudo-variable; you can copy that number to your output with + `\@', but _only within a macro definition_. + +`LOCAL NAME [ , ... ]' + _Warning: `LOCAL' is only available if you select "alternate macro + syntax" with `-a' or `--alternate'._ *Note Alternate macro + syntax: Alternate. + + Generate a string replacement for each of the NAME arguments, and + replace any instances of NAME in each macro expansion. The + replacement string is unique in the assembly, and different for + each separate macro expansion. `LOCAL' allows you to write macros + that define symbols, without fear of conflict between separate + macro expansions. + + +File: gasp.info, Node: Data, Next: Listings, Prev: Macros, Up: Commands + +Data output +=========== + + In assembly code, you often need to specify working areas of memory; +depending on the application, you may want to initialize such memory or +not. GASP provides preprocessor directives to help you avoid +repetitive coding for both purposes. + + You can use labels as usual to mark the data areas. + +* Menu: + +* Initialized:: +* Uninitialized:: + + +File: gasp.info, Node: Initialized, Next: Uninitialized, Up: Data + +Initialized data +---------------- + + These are the GASP directives for initialized data, and the standard +GNU assembler directives they expand to: + +`.DATA EXPR, EXPR, ...' +`.DATA.B EXPR, EXPR, ...' +`.DATA.W EXPR, EXPR, ...' +`.DATA.L EXPR, EXPR, ...' + Evaluate arithmetic expressions EXPR, and emit the corresponding + `as' directive (labelled with LAB). The unqualified `.DATA' emits + `.long'; `.DATA.B' emits `.byte'; `.DATA.W' emits `.short'; and + `.DATA.L' emits `.long'. + + For example, `foo .DATA 1,2,3' emits `foo: .long 1,2,3'. + +`.DATAB REPEAT, EXPR' +`.DATAB.B REPEAT, EXPR' +`.DATAB.W REPEAT, EXPR' +`.DATAB.L REPEAT, EXPR' + Make `as' emit REPEAT copies of the value of the expression EXPR + (using the `as' directive `.fill'). `.DATAB.B' repeats one-byte + values; `.DATAB.W' repeats two-byte values; and `.DATAB.L' repeats + four-byte values. `.DATAB' without a suffix repeats four-byte + values, just like `.DATAB.L'. + + REPEAT must be an absolute expression with a positive value. + +`.SDATA "STR" ...' + String data. Emits a concatenation of bytes, precisely as you + specify them (in particular, _nothing is added to mark the end_ of + the string). *Note String and numeric constants: Constants, for + details about how to write strings. `.SDATA' concatenates multiple + arguments, making it easy to switch between string + representations. You can use commas to separate the individual + arguments for clarity, if you choose. + +`.SDATAB REPEAT, "STR" ...' + Repeated string data. The first argument specifies how many + copies of the string to emit; the remaining arguments specify the + string, in the same way as the arguments to `.SDATA'. + +`.SDATAZ "STR" ...' + Zero-terminated string data. Just like `.SDATA', except that + `.SDATAZ' writes a zero byte at the end of the string. + +`.SDATAC "STR" ...' + Count-prefixed string data. Just like `.SDATA', except that GASP + precedes the string with a leading one-byte count. For example, + `.SDATAC "HI"' generates `.byte 2,72,73'. Since the count field + is only one byte, you can only use `.SDATAC' for strings less than + 256 bytes in length. + + +File: gasp.info, Node: Uninitialized, Prev: Initialized, Up: Data + +Uninitialized data +------------------ + + Use the `.RES', `.SRES', `.SRESC', and `.SRESZ' directives to +reserve memory and leave it uninitialized. GASP resolves these +directives to appropriate calls of the GNU `as' `.space' directive. + +`.RES COUNT' +`.RES.B COUNT' +`.RES.W COUNT' +`.RES.L COUNT' + Reserve room for COUNT uninitialized elements of data. The suffix + specifies the size of each element: `.RES.B' reserves COUNT bytes, + `.RES.W' reserves COUNT pairs of bytes, and `.RES.L' reserves + COUNT quartets. `.RES' without a suffix is equivalent to `.RES.L'. + +`.SRES COUNT' +`.SRES.B COUNT' +`.SRES.W COUNT' +`.SRES.L COUNT' + `.SRES' is a synonym for `.RES'. + +`.SRESC COUNT' +`.SRESC.B COUNT' +`.SRESC.W COUNT' +`.SRESC.L COUNT' + Like `.SRES', but reserves space for `COUNT+1' elements. + +`.SRESZ COUNT' +`.SRESZ.B COUNT' +`.SRESZ.W COUNT' +`.SRESZ.L COUNT' + Like `.SRES', but reserves space for `COUNT+1' elements. + + +File: gasp.info, Node: Listings, Next: Other Commands, Prev: Data, Up: Commands + +Assembly listing control +======================== + + The GASP listing-control directives correspond to related GNU `as' +directives. + +`.PRINT LIST' +`.PRINT NOLIST' + Print control. This directive emits the GNU `as' directive + `.list' or `.nolist', according to its argument. *Note `.list': + (as.info)List, for details on how these directives interact. + +`.FORM LIN=LN' +`.FORM COL=COLS' +`.FORM LIN=LN COL=COLS' + Specify the page size for assembly listings: LN represents the + number of lines, and COLS the number of columns. You may specify + either page dimension independently, or both together. If you do + not specify the number of lines, GASP assumes 60 lines; if you do + not specify the number of columns, GASP assumes 132 columns. (Any + values you may have specified in previous instances of `.FORM' do + _not_ carry over as defaults.) Emits the `.psize' assembler + directive. + +`.HEADING STRING' + Specify STRING as the title of your assembly listings. Emits + `.title "STRING"'. + +`.PAGE' + Force a new page in assembly listings. Emits `.eject'. + + +File: gasp.info, Node: Other Commands, Next: Syntax Details, Prev: Listings, Up: Commands + +Miscellaneous commands +====================== + +`.ALTERNATE' + Use the alternate macro syntax henceforth in the assembly. *Note + Alternate macro syntax: Alternate. + +`.ORG' + This command is recognized, but not yet implemented. GASP + generates an error message for programs that use `.ORG'. + +`.RADIX S' + GASP understands numbers in any of base two, eight, ten, or + sixteen. You can encode the base explicitly in any numeric + constant (*note String and numeric constants: Constants.). If you + write numbers without an explicit indication of the base, the most + recent `.RADIX S' command determines how they are interpreted. S + is a single letter, one of the following: + + `.RADIX B' + Base 2. + + `.RADIX Q' + Base 8. + + `.RADIX D' + Base 10. This is the original default radix. + + `.RADIX H' + Base 16. + + You may specify the argument S in lower case (any of `bqdh') with + the same effects. + +`.EXPORT NAME' +`.GLOBAL NAME' + Declare NAME global (emits `.global NAME'). The two directives + are synonymous. + +`.PROGRAM' + No effect: GASP accepts this directive, and silently ignores it. + +`.END' + Mark end of each preprocessor file. GASP issues a warning if it + reaches end of file without seeing this command. + +`.INCLUDE "STR"' + Preprocess the file named by STR, as if its contents appeared + where the `.INCLUDE' directive does. GASP imposes a maximum limit + of 30 stacked include files, as a sanity check. + +`.ALIGN SIZE' + Evaluate the absolute expression SIZE, and emit the assembly + instruction `.align SIZE' using the result. + + +File: gasp.info, Node: Syntax Details, Next: Alternate, Prev: Other Commands, Up: Commands + +Details of the GASP syntax +========================== + + Since GASP is meant to work with assembly code, its statement syntax +has no surprises for the assembly programmer. + + _Whitespace_ (blanks or tabs; _not_ newline) is partially +significant, in that it delimits up to three fields in a line. The +amount of whitespace does not matter; you may line up fields in separate +lines if you wish, but GASP does not require that. + + The _first field_, an optional "label", must be flush left in a line +(with no leading whitespace) if it appears at all. You may use a colon +after the label if you wish; GASP neither requires the colon nor +objects to it (but will not include it as part of the label name). + + The _second field_, which must appear after some whitespace, +contains a GASP or assembly "directive". + + Any _further fields_ on a line are "arguments" to the directive; you +can separate them from one another using either commas or whitespace. + +* Menu: + +* Markers:: +* Constants:: +* Symbols:: +* Expressions:: +* String Builtins:: + + +File: gasp.info, Node: Markers, Next: Constants, Up: Syntax Details + +Special syntactic markers +------------------------- + + GASP recognizes a few special markers: to delimit comments, to +continue a statement on the next line, to separate symbols from other +characters, and to copy text to the output literally. (One other +special marker, `\@', works only within macro definitions; *note +Defining your own directives: Macros..) + + The trailing part of any GASP source line may be a "comment". A +comment begins with the first unquoted comment character (`!' by +default), or an escaped or doubled comment character (`\!' or `!!' by +default), and extends to the end of a line. You can specify what +comment character to use with the `-c' option (*note Command Line +Options: Invoking GASP.). The two kinds of comment markers lead to +slightly different treatment: + +`!' + A single, un-escaped comment character generates an assembly + comment in the GASP output. GASP evaluates any preprocessor + variables (macro arguments, or variables defined with `.ASSIGNA' or + `.ASSIGNC') present. For example, a macro that begins like this + + .MACRO SUM FROM=0, TO=9 + ! \FROM \TO + + issues as the first line of output a comment that records the + values you used to call the macro. + +`\!' +`!!' + Either an escaped comment character, or a double comment character, + marks a GASP source comment. GASP does not copy such comments to + the assembly output. + + To _continue a statement_ on the next line of the file, begin the +second line with the character `+'. + + Occasionally you may want to prevent GASP from preprocessing some +particular bit of text. To _copy literally_ from the GASP source to +its output, place `\(' before the string to copy, and `)' at the end. +For example, write `\(\!)' if you need the characters `\!' in your +assembly output. + + To _separate a preprocessor variable_ from text to appear +immediately after its value, write a single quote (`''). For example, +`.SDATA "\P'1"' writes a string built by concatenating the value of `P' +and the digit `1'. (You cannot achieve this by writing just `\P1', +since `P1' is itself a valid name for a preprocessor variable.) + + +File: gasp.info, Node: Constants, Next: Symbols, Prev: Markers, Up: Syntax Details + +String and numeric constants +---------------------------- + + There are two ways of writing "string constants" in GASP: as literal +text, and by numeric byte value. Specify a string literal between +double quotes (`"STR"'). Specify an individual numeric byte value as +an absolute expression between angle brackets (`<EXPR>'. Directives +that output strings allow you to specify any number of either kind of +value, in whatever order is convenient, and concatenate the result. +(Alternate syntax mode introduces a number of alternative string +notations; *note Alternate macro syntax: Alternate..) + + You can write "numeric constants" either in a specific base, or in +whatever base is currently selected (either 10, or selected by the most +recent `.RADIX'). + + To write a number in a _specific base_, use the pattern `S'DDD': a +base specifier character S, followed by a single quote followed by +digits DDD. The base specifier character matches those you can specify +with `.RADIX': `B' for base 2, `Q' for base 8, `D' for base 10, and `H' +for base 16. (You can write this character in lower case if you +prefer.) + + +File: gasp.info, Node: Symbols, Next: Expressions, Prev: Constants, Up: Syntax Details + +Symbols +------- + + GASP recognizes symbol names that start with any alphabetic +character, `_', or `$', and continue with any of the same characters or +with digits. Label names follow the same rules. + + +File: gasp.info, Node: Expressions, Next: String Builtins, Prev: Symbols, Up: Syntax Details + +Arithmetic expressions in GASP +------------------------------ + + There are two kinds of expressions, depending on their result: +"absolute" expressions, which resolve to a constant (that is, they do +not involve any values unknown to GASP), and "relocatable" expressions, +which must reduce to the form + + ADDSYM+CONST-SUBSYM + +where ADDSYM and SUBSYM are assembly symbols of unknown value, and +CONST is a constant. + + Arithmetic for GASP expressions follows very similar rules to C. +You can use parentheses to change precedence; otherwise, arithmetic +primitives have decreasing precedence in the order of the following +list. + + 1. Single-argument `+' (identity), `-' (arithmetic opposite), or `~' + (bitwise negation). _The argument must be an absolute expression._ + + 2. `*' (multiplication) and `/' (division). _Both arguments must be + absolute expressions._ + + 3. `+' (addition) and `-' (subtraction). _At least one argument must + be absolute._ + + 4. `&' (bitwise and). _Both arguments must be absolute._ + + 5. `|' (bitwise or) and `~' (bitwise exclusive or; `^' in C). _Both + arguments must be absolute._ + + +File: gasp.info, Node: String Builtins, Prev: Expressions, Up: Syntax Details + +String primitives +----------------- + + You can use these primitives to manipulate strings (in the argument +field of GASP statements): + +`.LEN("STR")' + Calculate the length of string `"STR"', as an absolute expression. + For example, `.RES.B .LEN("sample")' reserves six bytes of memory. + +`.INSTR("STRING", "SEG", IX)' + Search for the first occurrence of SEG after position IX of + STRING. For example, `.INSTR("ABCDEFG", "CDE", 0)' evaluates to + the absolute result `2'. + + The result is `-1' if SEG does not occur in STRING after position + IX. + +`.SUBSTR("STRING",START,LEN)' + The substring of STRING beginning at byte number START and + extending for LEN bytes. + + +File: gasp.info, Node: Alternate, Prev: Syntax Details, Up: Commands + +Alternate macro syntax +====================== + + If you specify `-a' or `--alternate' on the GASP command line, the +preprocessor uses somewhat different syntax. This syntax is +reminiscent of the syntax of Phar Lap macro assembler, but it is _not_ +meant to be a full emulation of Phar Lap or similar assemblers. In +particular, GASP does not support directives such as `DB' and `IRP', +even in alternate syntax mode. + + In particular, `-a' (or `--alternate') elicits these differences: + +_Preprocessor directives_ + You can use GASP preprocessor directives without a leading `.' + dot. For example, you can write `SDATA' with the same effect as + `.SDATA'. + +_LOCAL_ + One additional directive, `LOCAL', is available. *Note Defining + your own directives: Macros, for an explanation of how to use + `LOCAL'. + +_String delimiters_ + You can write strings delimited in these other ways besides + `"STRING"': + + `'STRING'' + You can delimit strings with single-quote charaters. + + `<STRING>' + You can delimit strings with matching angle brackets. + +_single-character string escape_ + To include any single character literally in a string (even if the + character would otherwise have some special meaning), you can + prefix the character with `!' (an exclamation mark). For example, + you can write `<4.3 !> 5.4!!>' to get the literal text `4.3 > + 5.4!'. + +_Expression results as strings_ + You can write `%EXPR' to evaluate the expression EXPR and use the + result as a string. + + +File: gasp.info, Node: Index, Prev: Commands, Up: Top + +Index +***** + +* Menu: + +* ! default comment char: Invoking GASP. +* +: Markers. +* --alternate: Invoking GASP. +* --commentchar 'CHAR': Invoking GASP. +* --copysource: Invoking GASP. +* --debug: Invoking GASP. +* --help: Invoking GASP. +* --mri: Invoking GASP. +* --output OUTFILE: Invoking GASP. +* --print: Invoking GASP. +* --unreasonable: Invoking GASP. +* --version: Invoking GASP. +* -a: Invoking GASP. +* -c 'CHAR': Invoking GASP. +* -d: Invoking GASP. +* -h: Invoking GASP. +* -M: Invoking GASP. +* -o OUTFILE: Invoking GASP. +* -p: Invoking GASP. +* -s: Invoking GASP. +* -u: Invoking GASP. +* -v: Invoking GASP. +* .AELSE: Conditionals. +* .AENDI: Conditionals. +* .AENDR: Loops. +* .AENDW: Loops. +* .AIF "STRA" CMP "STRB": Conditionals. +* .AIF EXPRA CMP EXPRB: Conditionals. +* .ALIGN SIZE: Other Commands. +* .ALTERNATE: Other Commands. +* .AREPEAT AEXP: Loops. +* .AWHILE EXPRA CMP EXPRB: Loops. +* .AWHILE STRA CMP STRB: Loops. +* .DATA EXPR, EXPR, ...: Initialized. +* .DATA.B EXPR, EXPR, ...: Initialized. +* .DATA.L EXPR, EXPR, ...: Initialized. +* .DATA.W EXPR, EXPR, ...: Initialized. +* .DATAB REPEAT, EXPR: Initialized. +* .DATAB.B REPEAT, EXPR: Initialized. +* .DATAB.L REPEAT, EXPR: Initialized. +* .DATAB.W REPEAT, EXPR: Initialized. +* .END: Other Commands. +* .ENDM: Macros. +* .EXITM: Macros. +* .EXPORT NAME: Other Commands. +* .FORM COL=COLS: Listings. +* .FORM LIN=LN: Listings. +* .FORM LIN=LN COL=COLS: Listings. +* .GLOBAL NAME: Other Commands. +* .HEADING STRING: Listings. +* .INCLUDE "STR": Other Commands. +* .INSTR("STRING", "SEG", IX): String Builtins. +* .LEN("STR"): String Builtins. +* .MACRO MACNAME: Macros. +* .MACRO MACNAME MACARGS ...: Macros. +* .ORG: Other Commands. +* .PAGE: Listings. +* .PRINT LIST: Listings. +* .PRINT NOLIST: Listings. +* .PROGRAM: Other Commands. +* .RADIX S: Other Commands. +* .RES COUNT: Uninitialized. +* .RES.B COUNT: Uninitialized. +* .RES.L COUNT: Uninitialized. +* .RES.W COUNT: Uninitialized. +* .SDATA "STR" ...: Initialized. +* .SDATAB REPEAT, "STR" ...: Initialized. +* .SDATAC "STR" ...: Initialized. +* .SDATAZ "STR" ...: Initialized. +* .SRES COUNT: Uninitialized. +* .SRES.B COUNT: Uninitialized. +* .SRES.L COUNT: Uninitialized. +* .SRES.W COUNT: Uninitialized. +* .SRESC COUNT: Uninitialized. +* .SRESC.B COUNT: Uninitialized. +* .SRESC.L COUNT: Uninitialized. +* .SRESC.W COUNT: Uninitialized. +* .SRESZ COUNT: Uninitialized. +* .SRESZ.B COUNT: Uninitialized. +* .SRESZ.L COUNT: Uninitialized. +* .SRESZ.W COUNT: Uninitialized. +* .SUBSTR("STRING",START,LEN): String Builtins. +* ; as comment char: Invoking GASP. +* \@: Macros. +* absolute expressions: Expressions. +* argument fields: Syntax Details. +* avoiding preprocessing: Markers. +* bang, as comment: Invoking GASP. +* breaking out of loops: Loops. +* comment character, changing: Invoking GASP. +* comments: Markers. +* continuation character: Markers. +* copying literally to output: Markers. +* directive field: Syntax Details. +* EQ: Conditionals. +* exclamation mark, as comment: Invoking GASP. +* fields of GASP source line: Syntax Details. +* GE: Conditionals. +* GT: Conditionals. +* INFILE ...: Invoking GASP. +* label field: Syntax Details. +* LE: Conditionals. +* literal copy to output: Markers. +* LOCAL NAME [ , ... ]: Macros. +* loops, breaking out of: Loops. +* LT: Conditionals. +* macros, count executed: Macros. +* NAME .MACRO: Macros. +* NAME .MACRO ( MACARGS ... ): Macros. +* NE: Conditionals. +* number of macros executed: Macros. +* preprocessing, avoiding: Markers. +* PVAR .ASSIGN EXPR: Variables. +* PVAR .ASSIGNA AEXPR: Variables. +* PVAR .ASSIGNC "STR": Variables. +* PVAR .EQU EXPR: Variables. +* PVAR .REG (REGISTER): Variables. +* relocatable expressions: Expressions. +* semicolon, as comment: Invoking GASP. +* shriek, as comment: Invoking GASP. +* symbol separator: Markers. +* symbols, separating from text: Markers. +* text, separating from symbols: Markers. +* whitespace: Syntax Details. + + + +Tag Table: +Node: Top808 +Node: Overview1242 +Node: Invoking GASP2908 +Node: Commands6644 +Node: Conditionals7320 +Node: Loops9612 +Node: Variables11137 +Node: Macros13532 +Node: Data17494 +Node: Initialized17942 +Node: Uninitialized20221 +Node: Listings21232 +Node: Other Commands22428 +Node: Syntax Details24180 +Node: Markers25316 +Node: Constants27564 +Node: Symbols28766 +Node: Expressions29062 +Node: String Builtins30294 +Node: Alternate31075 +Node: Index32693 + +End Tag Table diff --git a/gas/doc/gasver.texi b/gas/doc/gasver.texi new file mode 100644 index 00000000000..b696ac718c9 --- /dev/null +++ b/gas/doc/gasver.texi @@ -0,0 +1 @@ +@set VERSION 2.10 diff --git a/gas/itbl-parse.c b/gas/itbl-parse.c new file mode 100644 index 00000000000..e98e17cab74 --- /dev/null +++ b/gas/itbl-parse.c @@ -0,0 +1,1346 @@ + +/* A Bison parser, made from itbl-parse.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define DREG 257 +#define CREG 258 +#define GREG 259 +#define IMMED 260 +#define ADDR 261 +#define INSN 262 +#define NUM 263 +#define ID 264 +#define NL 265 +#define PNUM 266 + +#line 21 "itbl-parse.y" + + +/* + +Yacc grammar for instruction table entries. + +======================================================================= +Original Instruction table specification document: + + MIPS Coprocessor Table Specification + ==================================== + +This document describes the format of the MIPS coprocessor table. The +table specifies a list of valid functions, data registers and control +registers that can be used in coprocessor instructions. This list, +together with the coprocessor instruction classes listed below, +specifies the complete list of coprocessor instructions that will +be recognized and assembled by the GNU assembler. In effect, +this makes the GNU assembler table-driven, where the table is +specified by the programmer. + +The table is an ordinary text file that the GNU assembler reads when +it starts. Using the information in the table, the assembler +generates an internal list of valid coprocessor registers and +functions. The assembler uses this internal list in addition to the +standard MIPS registers and instructions which are built-in to the +assembler during code generation. + +To specify the coprocessor table when invoking the GNU assembler, use +the command line option "--itbl file", where file is the +complete name of the table, including path and extension. + +Examples: + + gas -t cop.tbl test.s -o test.o + gas -t /usr/local/lib/cop.tbl test.s -o test.o + gas --itbl d:\gnu\data\cop.tbl test.s -o test.o + +Only one table may be supplied during a single invocation of +the assembler. + + +Instruction classes +=================== + +Below is a list of the valid coprocessor instruction classes for +any given coprocessor "z". These instructions are already recognized +by the assembler, and are listed here only for reference. + +Class format instructions +------------------------------------------------- +Class1: + op base rt offset + LWCz rt,offset (base) + SWCz rt,offset (base) +Class2: + COPz sub rt rd 0 + MTCz rt,rd + MFCz rt,rd + CTCz rt,rd + CFCz rt,rd +Class3: + COPz CO cofun + COPz cofun +Class4: + COPz BC br offset + BCzT offset + BCzF offset +Class5: + COPz sub rt rd 0 + DMFCz rt,rd + DMTCz rt,rd +Class6: + op base rt offset + LDCz rt,offset (base) + SDCz rt,offset (base) +Class7: + COPz BC br offset + BCzTL offset + BCzFL offset + +The coprocessor table defines coprocessor-specific registers that can +be used with all of the above classes of instructions, where +appropriate. It also defines additional coprocessor-specific +functions for Class3 (COPz cofun) instructions, Thus, the table allows +the programmer to use convenient mnemonics and operands for these +functions, instead of the COPz mmenmonic and cofun operand. + +The names of the MIPS general registers and their aliases are defined +by the assembler and will be recognized as valid register names by the +assembler when used (where allowed) in coprocessor instructions. +However, the names and values of all coprocessor data and control +register mnemonics must be specified in the coprocessor table. + + +Table Grammar +============= + +Here is the grammar for the coprocessor table: + + table -> entry* + + entry -> [z entrydef] [comment] '\n' + + entrydef -> type name val + entrydef -> 'insn' name val funcdef ; type of entry (instruction) + + z -> 'p'['0'..'3'] ; processor number + type -> ['dreg' | 'creg' | 'greg' ] ; type of entry (register) + ; 'dreg', 'creg' or 'greg' specifies a data, control, or general + ; register mnemonic, respectively + name -> [ltr|dec]* ; mnemonic of register/function + val -> [dec|hex] ; register/function number (integer constant) + + funcdef -> frange flags fields + ; bitfield range for opcode + ; list of fields' formats + fields -> field* + field -> [','] ftype frange flags + flags -> ['*' flagexpr] + flagexpr -> '[' flagexpr ']' + flagexpr -> val '|' flagexpr + ftype -> [ type | 'immed' | 'addr' ] + ; 'immed' specifies an immediate value; see grammar for "val" above + ; 'addr' specifies a C identifier; name of symbol to be resolved at + ; link time + frange -> ':' val '-' val ; starting to ending bit positions, where + ; where 0 is least significant bit + frange -> (null) ; default range of 31-0 will be assumed + + comment -> [';'|'#'] [char]* + char -> any printable character + ltr -> ['a'..'z'|'A'..'Z'] + dec -> ['0'..'9']* ; value in decimal + hex -> '0x'['0'..'9' | 'a'..'f' | 'A'..'F']* ; value in hexidecimal + + +Examples +======== + +Example 1: + +The table: + + 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 func fill 0x1f:24-20 ; function "fill" for COP3 has value 31 and + ; no fields + +will allow the assembler to accept the following coprocessor instructions: + + LWC1 d1,0x100 ($2) + fill + +Here, the general purpose register "$2", and instruction "LWC1", are standard +mnemonics built-in to the MIPS assembler. + + +Example 2: + +The table: + + 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 func fee 0x1f:24-20 dreg:17-13 creg:12-8 immed:7-0 + ; function "fee" for COP3 has value 31, and 3 fields + ; consisting of a data register, a control register, + ; and an immediate value. + +will allow the assembler to accept the following coprocessor instruction: + + fee d3,c2,0x1 + +and will emit the object code: + + 31-26 25 24-20 19-18 17-13 12-8 7-0 + COPz CO fun dreg creg immed + 010011 1 11111 00 00011 10110 00000001 + + 0x4ff07601 + + +Example 3: + +The table: + + 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 func fuu 0x01f00001 dreg:17-13 creg:12-8 + +will allow the assembler to accept the following coprocessor +instruction: + + fuu d3,c2 + +and will emit the object code: + + 31-26 25 24-20 19-18 17-13 12-8 7-0 + COPz CO fun dreg creg + 010011 1 11111 00 00011 10110 00000001 + + 0x4ff07601 + +In this way, the programmer can force arbitrary bits of an instruction +to have predefined values. + +======================================================================= +Additional notes: + +Encoding of ranges: +To handle more than one bit position range within an instruction, +use 0s to mask out the ranges which don't apply. +May decide to modify the syntax to allow commas separate multiple +ranges within an instruction (range','range). + +Changes in grammar: + The number of parms argument to the function entry +was deleted from the original format such that we now count the fields. + +---- +FIXME! should really change lexical analyzer +to recognize 'dreg' etc. in context sensative way. +Currently function names or mnemonics may be incorrectly parsed as keywords + +FIXME! hex is ambiguous with any digit + +*/ + +#include <stdio.h> +#include "itbl-ops.h" + +/* #define DEBUG */ + +#ifdef DEBUG +#ifndef DBG_LVL +#define DBG_LVL 1 +#endif +#else +#define DBG_LVL 0 +#endif + +#if DBG_LVL >= 1 +#define DBG(x) printf x +#else +#define DBG(x) +#endif + +#if DBG_LVL >= 2 +#define DBGL2(x) printf x +#else +#define DBGL2(x) +#endif + +static int sbit, ebit; +static struct itbl_entry *insn=0; +extern int insntbl_line; +int yyparse PARAMS ((void)); +int yylex PARAMS ((void)); +static int yyerror PARAMS ((const char *)); + + +#line 283 "itbl-parse.y" +typedef union + { + char *str; + int num; + int processor; + unsigned long val; + } YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 51 +#define YYFLAG -32768 +#define YYNTBASE 20 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 266 ? yytranslate[x] : 34) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 17, 2, 13, 19, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 18, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 15, 2, 16, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 14, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 5, 6, 12, 13, 23, 25, 28, 32, + 35, 36, 38, 40, 42, 46, 50, 54, 56, 59, + 60, 65, 66, 68, 70, 72, 74, 76, 78 +}; + +static const short yyrhs[] = { 21, + 0, 22, 21, 0, 0, 30, 31, 32, 33, 11, + 0, 0, 30, 8, 32, 33, 29, 28, 23, 24, + 11, 0, 11, 0, 1, 11, 0, 13, 26, 24, + 0, 26, 24, 0, 0, 31, 0, 7, 0, 6, + 0, 25, 29, 28, 0, 9, 14, 27, 0, 15, + 27, 16, 0, 9, 0, 17, 27, 0, 0, 18, + 9, 19, 9, 0, 0, 12, 0, 3, 0, 4, + 0, 5, 0, 10, 0, 9, 0, 9, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 300, 304, 306, 309, 316, 323, 324, 325, 328, 330, + 331, 334, 340, 345, 352, 361, 366, 370, 376, 382, + 388, 395, 402, 410, 416, 421, 428, 436, 444 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","DREG","CREG", +"GREG","IMMED","ADDR","INSN","NUM","ID","NL","PNUM","','","'|'","'['","']'", +"'*'","':'","'-'","insntbl","entrys","entry","@1","fieldspecs","ftype","fieldspec", +"flagexpr","flags","range","pnum","regtype","name","value", NULL +}; +#endif + +static const short yyr1[] = { 0, + 20, 21, 21, 22, 23, 22, 22, 22, 24, 24, + 24, 25, 25, 25, 26, 27, 27, 27, 28, 28, + 29, 29, 30, 31, 31, 31, 32, -1, 33 +}; + +static const short yyr2[] = { 0, + 1, 2, 0, 5, 0, 9, 1, 2, 3, 2, + 0, 1, 1, 1, 3, 3, 3, 1, 2, 0, + 4, 0, 1, 1, 1, 1, 1, 1, 1 +}; + +static const short yydefact[] = { 0, + 0, 7, 23, 1, 0, 0, 8, 2, 24, 25, + 26, 0, 0, 27, 0, 0, 29, 22, 0, 0, + 20, 4, 0, 0, 5, 0, 18, 0, 19, 11, + 21, 0, 0, 14, 13, 0, 0, 22, 11, 12, + 16, 17, 11, 6, 20, 10, 9, 15, 0, 0, + 0 +}; + +static const short yydefgoto[] = { 49, + 4, 5, 30, 37, 38, 39, 29, 25, 21, 6, + 40, 15, 18 +}; + +static const short yypact[] = { 0, + -9,-32768,-32768,-32768, 0, 12,-32768,-32768,-32768,-32768, +-32768, 3, 3,-32768, 9, 9,-32768, -8, 8, 19, + 15,-32768, 10, -6,-32768, 24, 20, -6,-32768, 1, +-32768, -6, 21,-32768,-32768, 18, 25, -8, 1,-32768, +-32768,-32768, 1,-32768, 15,-32768,-32768,-32768, 35, 38, +-32768 +}; + +static const short yypgoto[] = {-32768, + 34,-32768,-32768, -13,-32768, 4, -1, -4, 5,-32768, + 36, 31, 29 +}; + + +#define YYLAST 45 + + +static const short yytable[] = { -3, + 1, 7, 27, 9, 10, 11, 34, 35, 28, 20, + 2, 3, 14, 36, 9, 10, 11, 17, 22, 12, + 9, 10, 11, 34, 35, 46, 33, 23, 26, 47, + 41, 24, 31, 32, 50, 44, 42, 51, 8, 43, + 48, 13, 45, 16, 19 +}; + +static const short yycheck[] = { 0, + 1, 11, 9, 3, 4, 5, 6, 7, 15, 18, + 11, 12, 10, 13, 3, 4, 5, 9, 11, 8, + 3, 4, 5, 6, 7, 39, 28, 9, 19, 43, + 32, 17, 9, 14, 0, 11, 16, 0, 5, 36, + 45, 6, 38, 13, 16 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 4: +#line 311 "itbl-parse.y" +{ + DBG (("line %d: entry pnum=%d type=%d name=%s value=x%x\n", + insntbl_line, yyvsp[-4].num, yyvsp[-3].num, yyvsp[-2].str, yyvsp[-1].val)); + itbl_add_reg (yyvsp[-4].num, yyvsp[-3].num, yyvsp[-2].str, yyvsp[-1].val); + ; + break;} +case 5: +#line 317 "itbl-parse.y" +{ + DBG (("line %d: entry pnum=%d type=INSN name=%s value=x%x", + insntbl_line, yyvsp[-5].num, yyvsp[-3].str, yyvsp[-2].val)); + DBG ((" sbit=%d ebit=%d flags=0x%x\n", sbit, ebit, yyvsp[0].val)); + insn=itbl_add_insn (yyvsp[-5].num, yyvsp[-3].str, yyvsp[-2].val, sbit, ebit, yyvsp[0].val); + ; + break;} +case 12: +#line 336 "itbl-parse.y" +{ + DBGL2 (("ftype\n")); + yyval.num = yyvsp[0].num; + ; + break;} +case 13: +#line 341 "itbl-parse.y" +{ + DBGL2 (("addr\n")); + yyval.num = ADDR; + ; + break;} +case 14: +#line 346 "itbl-parse.y" +{ + DBGL2 (("immed\n")); + yyval.num = IMMED; + ; + break;} +case 15: +#line 354 "itbl-parse.y" +{ + DBG (("line %d: field type=%d sbit=%d ebit=%d, flags=0x%x\n", + insntbl_line, yyvsp[-2].num, sbit, ebit, yyvsp[0].val)); + itbl_add_operand (insn, yyvsp[-2].num, sbit, ebit, yyvsp[0].val); + ; + break;} +case 16: +#line 363 "itbl-parse.y" +{ + yyval.val = yyvsp[-2].num | yyvsp[0].val; + ; + break;} +case 17: +#line 367 "itbl-parse.y" +{ + yyval.val = yyvsp[-1].val; + ; + break;} +case 18: +#line 371 "itbl-parse.y" +{ + yyval.val = yyvsp[0].num; + ; + break;} +case 19: +#line 378 "itbl-parse.y" +{ + DBGL2 (("flags=%d\n", yyvsp[0].val)); + yyval.val = yyvsp[0].val; + ; + break;} +case 20: +#line 383 "itbl-parse.y" +{ + yyval.val = 0; + ; + break;} +case 21: +#line 390 "itbl-parse.y" +{ + DBGL2 (("range %d %d\n", yyvsp[-2].num, yyvsp[0].num)); + sbit = yyvsp[-2].num; + ebit = yyvsp[0].num; + ; + break;} +case 22: +#line 396 "itbl-parse.y" +{ + sbit = 31; + ebit = 0; + ; + break;} +case 23: +#line 404 "itbl-parse.y" +{ + DBGL2 (("pnum=%d\n",yyvsp[0].num)); + yyval.num = yyvsp[0].num; + ; + break;} +case 24: +#line 412 "itbl-parse.y" +{ + DBGL2 (("dreg\n")); + yyval.num = DREG; + ; + break;} +case 25: +#line 417 "itbl-parse.y" +{ + DBGL2 (("creg\n")); + yyval.num = CREG; + ; + break;} +case 26: +#line 422 "itbl-parse.y" +{ + DBGL2 (("greg\n")); + yyval.num = GREG; + ; + break;} +case 27: +#line 430 "itbl-parse.y" +{ + DBGL2 (("name=%s\n",yyvsp[0].str)); + yyval.str = yyvsp[0].str; + ; + break;} +case 28: +#line 438 "itbl-parse.y" +{ + DBGL2 (("num=%d\n",yyvsp[0].num)); + yyval.num = yyvsp[0].num; + ; + break;} +case 29: +#line 446 "itbl-parse.y" +{ + DBGL2 (("val=x%x\n",yyvsp[0].num)); + yyval.val = yyvsp[0].num; + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 451 "itbl-parse.y" + + +static int +yyerror (msg) + const char *msg; +{ + printf ("line %d: %s\n", insntbl_line, msg); + return 0; +} diff --git a/gas/itbl-parse.h b/gas/itbl-parse.h new file mode 100644 index 00000000000..bede63a19f6 --- /dev/null +++ b/gas/itbl-parse.h @@ -0,0 +1,20 @@ +typedef union + { + char *str; + int num; + int processor; + unsigned long val; + } YYSTYPE; +#define DREG 257 +#define CREG 258 +#define GREG 259 +#define IMMED 260 +#define ADDR 261 +#define INSN 262 +#define NUM 263 +#define ID 264 +#define NL 265 +#define PNUM 266 + + +extern YYSTYPE yylval; diff --git a/gas/m68k-parse.c b/gas/m68k-parse.c new file mode 100644 index 00000000000..886e5876647 --- /dev/null +++ b/gas/m68k-parse.c @@ -0,0 +1,2066 @@ + +/* A Bison parser, made from m68k-parse.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define DR 257 +#define AR 258 +#define FPR 259 +#define FPCR 260 +#define LPC 261 +#define ZAR 262 +#define ZDR 263 +#define LZPC 264 +#define CREG 265 +#define INDEXREG 266 +#define EXPR 267 + +#line 27 "m68k-parse.y" + + +#include "as.h" +#include "tc-m68k.h" +#include "m68k-parse.h" + +/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, + etc), as well as gratuitiously global symbol names If other parser + generators (bison, byacc, etc) produce additional global names that + conflict at link time, then those parser generators need to be + fixed instead of adding those names to this list. */ + +#define yymaxdepth m68k_maxdepth +#define yyparse m68k_parse +#define yylex m68k_lex +#define yyerror m68k_error +#define yylval m68k_lval +#define yychar m68k_char +#define yydebug m68k_debug +#define yypact m68k_pact +#define yyr1 m68k_r1 +#define yyr2 m68k_r2 +#define yydef m68k_def +#define yychk m68k_chk +#define yypgo m68k_pgo +#define yyact m68k_act +#define yyexca m68k_exca +#define yyerrflag m68k_errflag +#define yynerrs m68k_nerrs +#define yyps m68k_ps +#define yypv m68k_pv +#define yys m68k_s +#define yy_yys m68k_yys +#define yystate m68k_state +#define yytmp m68k_tmp +#define yyv m68k_v +#define yy_yyv m68k_yyv +#define yyval m68k_val +#define yylloc m68k_lloc +#define yyreds m68k_reds /* With YYDEBUG defined */ +#define yytoks m68k_toks /* With YYDEBUG defined */ +#define yylhs m68k_yylhs +#define yylen m68k_yylen +#define yydefred m68k_yydefred +#define yydgoto m68k_yydgoto +#define yysindex m68k_yysindex +#define yyrindex m68k_yyrindex +#define yygindex m68k_yygindex +#define yytable m68k_yytable +#define yycheck m68k_yycheck + +#ifndef YYDEBUG +#define YYDEBUG 1 +#endif + +/* Internal functions. */ + +static enum m68k_register m68k_reg_parse PARAMS ((char **)); +static int yylex PARAMS ((void)); +static void yyerror PARAMS ((const char *)); + +/* The parser sets fields pointed to by this global variable. */ +static struct m68k_op *op; + + +#line 93 "m68k-parse.y" +typedef union +{ + struct m68k_indexreg indexreg; + enum m68k_register reg; + struct m68k_exp exp; + unsigned long mask; + int onereg; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 173 +#define YYFLAG -32768 +#define YYNTBASE 25 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 267 ? yytranslate[x] : 44) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 14, 2, 2, 15, 2, 16, + 17, 2, 18, 20, 19, 2, 24, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 23, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 21, 2, 22, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, + 21, 24, 26, 30, 35, 40, 46, 52, 57, 61, + 65, 69, 77, 85, 92, 98, 105, 111, 118, 124, + 130, 135, 145, 153, 162, 169, 180, 189, 200, 209, + 218, 221, 225, 229, 235, 242, 253, 263, 274, 276, + 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, + 298, 300, 302, 303, 305, 307, 309, 310, 313, 314, + 317, 318, 321, 323, 327, 331, 333, 335, 339, 343, + 347, 349, 351, 353 +}; + +static const short yyrhs[] = { 26, + 0, 27, 0, 28, 0, 3, 0, 4, 0, 5, + 0, 6, 0, 11, 0, 13, 0, 14, 13, 0, + 15, 13, 0, 40, 0, 16, 4, 17, 0, 16, + 4, 17, 18, 0, 19, 16, 4, 17, 0, 16, + 13, 20, 34, 17, 0, 16, 34, 20, 13, 17, + 0, 13, 16, 34, 17, 0, 16, 7, 17, 0, + 16, 8, 17, 0, 16, 10, 17, 0, 16, 13, + 20, 34, 20, 29, 17, 0, 16, 13, 20, 34, + 20, 36, 17, 0, 16, 13, 20, 30, 37, 17, + 0, 16, 30, 20, 13, 17, 0, 13, 16, 34, + 20, 29, 17, 0, 16, 34, 20, 29, 17, 0, + 13, 16, 34, 20, 36, 17, 0, 16, 34, 20, + 36, 17, 0, 13, 16, 30, 37, 17, 0, 16, + 30, 37, 17, 0, 16, 21, 13, 37, 22, 20, + 29, 38, 17, 0, 16, 21, 13, 37, 22, 38, + 17, 0, 16, 21, 34, 22, 20, 29, 38, 17, + 0, 16, 21, 34, 22, 38, 17, 0, 16, 21, + 13, 20, 34, 20, 29, 22, 38, 17, 0, 16, + 21, 34, 20, 29, 22, 38, 17, 0, 16, 21, + 13, 20, 34, 20, 36, 22, 38, 17, 0, 16, + 21, 34, 20, 36, 22, 38, 17, 0, 16, 21, + 39, 30, 37, 22, 38, 17, 0, 35, 23, 0, + 35, 23, 18, 0, 35, 23, 19, 0, 35, 23, + 16, 13, 17, 0, 35, 23, 16, 39, 29, 17, + 0, 35, 23, 16, 13, 17, 23, 16, 39, 29, + 17, 0, 35, 23, 16, 13, 17, 23, 16, 13, + 17, 0, 35, 23, 16, 39, 29, 17, 23, 16, + 13, 17, 0, 12, 0, 31, 0, 12, 0, 32, + 0, 32, 0, 4, 0, 8, 0, 3, 0, 9, + 0, 4, 0, 7, 0, 33, 0, 10, 0, 8, + 0, 0, 34, 0, 7, 0, 10, 0, 0, 20, + 34, 0, 0, 20, 13, 0, 0, 13, 20, 0, + 42, 0, 42, 24, 41, 0, 43, 24, 41, 0, + 43, 0, 42, 0, 42, 24, 41, 0, 43, 24, + 41, 0, 43, 19, 43, 0, 3, 0, 4, 0, + 5, 0, 6, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 116, 118, 119, 124, 130, 135, 140, 145, 150, 155, + 160, 165, 177, 183, 188, 193, 203, 213, 223, 228, + 233, 238, 245, 256, 263, 269, 276, 282, 293, 303, + 310, 316, 324, 331, 338, 344, 352, 359, 371, 382, + 394, 403, 411, 419, 429, 436, 444, 451, 464, 466, + 478, 480, 491, 493, 494, 499, 501, 506, 508, 514, + 516, 517, 522, 527, 532, 534, 539, 544, 552, 558, + 566, 572, 580, 582, 586, 597, 602, 603, 607, 613, + 623, 628, 632, 636 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","DR","AR", +"FPR","FPCR","LPC","ZAR","ZDR","LZPC","CREG","INDEXREG","EXPR","'#'","'&'","'('", +"')'","'+'","'-'","','","'['","']'","'@'","'/'","operand","generic_operand", +"motorola_operand","mit_operand","zireg","zdireg","zadr","zdr","apc","zapc", +"optzapc","zpc","optczapc","optcexpr","optexprc","reglist","ireglist","reglistpair", +"reglistreg", NULL +}; +#endif + +static const short yyr1[] = { 0, + 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, + 30, 30, 31, 31, 31, 32, 32, 33, 33, 34, + 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, + 39, 39, 40, 40, 40, 41, 41, 41, 41, 42, + 43, 43, 43, 43 +}; + +static const short yyr2[] = { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 2, 1, 3, 4, 4, 5, 5, 4, 3, 3, + 3, 7, 7, 6, 5, 6, 5, 6, 5, 5, + 4, 9, 7, 8, 6, 10, 8, 10, 8, 8, + 2, 3, 3, 5, 6, 10, 9, 10, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 1, 1, 1, 0, 2, 0, 2, + 0, 2, 1, 3, 3, 1, 1, 3, 3, 3, + 1, 1, 1, 1 +}; + +static const short yydefact[] = { 63, + 81, 82, 83, 84, 59, 62, 61, 8, 9, 0, + 0, 0, 0, 1, 2, 3, 60, 64, 0, 12, + 73, 0, 0, 10, 11, 56, 58, 59, 62, 57, + 61, 51, 0, 71, 67, 52, 0, 0, 41, 0, + 0, 0, 58, 67, 0, 13, 19, 20, 21, 0, + 67, 0, 0, 0, 0, 0, 0, 71, 42, 43, + 81, 82, 83, 84, 74, 77, 76, 80, 75, 0, + 0, 18, 0, 14, 67, 0, 72, 0, 0, 69, + 67, 0, 68, 31, 54, 65, 55, 66, 49, 0, + 0, 50, 53, 0, 15, 0, 0, 0, 0, 30, + 0, 0, 0, 16, 0, 68, 69, 0, 0, 0, + 0, 0, 25, 17, 27, 29, 44, 72, 0, 78, + 79, 26, 28, 24, 0, 0, 0, 0, 0, 69, + 69, 70, 69, 35, 69, 0, 45, 22, 23, 0, + 0, 69, 33, 0, 0, 0, 0, 0, 71, 0, + 69, 69, 0, 37, 39, 34, 40, 0, 0, 0, + 0, 0, 32, 47, 0, 0, 36, 38, 46, 48, + 0, 0, 0 +}; + +static const short yydefgoto[] = { 171, + 14, 15, 16, 91, 35, 92, 93, 17, 83, 19, + 94, 55, 111, 53, 20, 65, 66, 67 +}; + +static const short yypact[] = { 89, + 10, 11, 19, 23,-32768,-32768,-32768,-32768, 13, -4, + 22, 57, 36,-32768,-32768,-32768,-32768,-32768, 18,-32768, + 33, -2, 114,-32768,-32768,-32768, 46, 62, 66,-32768, + 67,-32768, 68, 131, 69,-32768, 70, 105, 147, 156, + 156, 156,-32768, 94, 25, 101,-32768,-32768,-32768, 114, + 100, 53, 9, 138, 108, 103, 112, 117,-32768,-32768, +-32768,-32768,-32768,-32768,-32768, 119, 12,-32768,-32768, 64, + 130,-32768, 124,-32768, 94, 81, 64, 135, 124, 132, + 94, 150,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 151, + 152,-32768,-32768, 153,-32768, 120, 146, 156, 156,-32768, + 154, 155, 157,-32768, 124, 144, 158, 159, 160, 73, + 162, 161,-32768,-32768,-32768,-32768, 163,-32768, 167,-32768, +-32768,-32768,-32768,-32768, 168, 170, 124, 73, 171, 169, + 169,-32768, 169,-32768, 169, 164, 172,-32768,-32768, 174, + 175, 169,-32768, 177, 176, 181, 182, 183, 178, 185, + 169, 169, 186,-32768,-32768,-32768,-32768, 136, 146, 179, + 187, 188,-32768,-32768, 189, 190,-32768,-32768,-32768,-32768, + 173, 194,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768,-32768,-32768, -72, 1,-32768, -7,-32768, 3,-32768, + -65, -31, -103, -58,-32768, -40, 202, 6 +}; + + +#define YYLAST 207 + + +static const short yytable[] = { 97, + 101, 69, 18, 129, 36, 22, 108, 102, 24, -4, + -5, 26, 71, 109, 37, 36, 41, 30, -6, 78, + 32, 42, -7, 44, 119, 45, 145, 146, 23, 147, + 41, 148, 125, -58, 25, 99, 52, 133, 153, 126, + 39, 72, 36, 103, 73, 36, 68, 161, 162, 112, + 75, 38, 76, 81, 140, 142, 40, 120, 121, 26, + 27, 141, 46, 28, 29, 30, 31, 43, 32, 33, + 5, 6, 79, 7, 80, 26, 85, 34, 47, 106, + 87, 30, 48, 49, 89, 132, 165, 50, 54, 56, + 159, 1, 2, 3, 4, 5, 6, 104, 7, 8, + 105, 9, 10, 11, 12, 26, 85, 13, 57, 86, + 87, 30, 88, 70, 89, 90, 26, 43, 74, 77, + 5, 6, 30, 7, 84, 32, 26, 85, 95, 96, + 86, 87, 30, 88, 43, 89, 117, 5, 6, 118, + 7, 43, 98, 51, 5, 6, 100, 7, 26, 85, + 82, 110, 164, 87, 30, 118, 107, 89, 61, 62, + 63, 64, 58, 127, 59, 60, 113, 114, 115, 116, + 122, 123, 172, 124, 0, 0, 0, 128, 134, 149, + 130, 131, 135, 137, 138, 136, 139, 143, 144, 132, + 158, 166, 154, 173, 150, 151, 152, 155, 156, 157, + 160, 21, 163, 167, 168, 169, 170 +}; + +static const short yycheck[] = { 58, + 73, 42, 0, 107, 12, 0, 79, 73, 13, 0, + 0, 3, 44, 79, 12, 23, 19, 9, 0, 51, + 12, 24, 0, 23, 97, 23, 130, 131, 16, 133, + 19, 135, 105, 23, 13, 24, 34, 110, 142, 105, + 23, 17, 50, 75, 20, 53, 41, 151, 152, 81, + 50, 16, 50, 53, 127, 128, 24, 98, 99, 3, + 4, 127, 17, 7, 8, 9, 10, 4, 12, 13, + 7, 8, 20, 10, 22, 3, 4, 21, 17, 77, + 8, 9, 17, 17, 12, 13, 159, 20, 20, 20, + 149, 3, 4, 5, 6, 7, 8, 17, 10, 11, + 20, 13, 14, 15, 16, 3, 4, 19, 4, 7, + 8, 9, 10, 20, 12, 13, 3, 4, 18, 20, + 7, 8, 9, 10, 17, 12, 3, 4, 17, 13, + 7, 8, 9, 10, 4, 12, 17, 7, 8, 20, + 10, 4, 24, 13, 7, 8, 17, 10, 3, 4, + 13, 20, 17, 8, 9, 20, 22, 12, 3, 4, + 5, 6, 16, 20, 18, 19, 17, 17, 17, 17, + 17, 17, 0, 17, -1, -1, -1, 20, 17, 16, + 22, 22, 22, 17, 17, 23, 17, 17, 20, 13, + 13, 13, 17, 0, 23, 22, 22, 17, 17, 17, + 16, 0, 17, 17, 17, 17, 17 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 4: +#line 126 "m68k-parse.y" +{ + op->mode = DREG; + op->reg = yyvsp[0].reg; + ; + break;} +case 5: +#line 131 "m68k-parse.y" +{ + op->mode = AREG; + op->reg = yyvsp[0].reg; + ; + break;} +case 6: +#line 136 "m68k-parse.y" +{ + op->mode = FPREG; + op->reg = yyvsp[0].reg; + ; + break;} +case 7: +#line 141 "m68k-parse.y" +{ + op->mode = CONTROL; + op->reg = yyvsp[0].reg; + ; + break;} +case 8: +#line 146 "m68k-parse.y" +{ + op->mode = CONTROL; + op->reg = yyvsp[0].reg; + ; + break;} +case 9: +#line 151 "m68k-parse.y" +{ + op->mode = ABSL; + op->disp = yyvsp[0].exp; + ; + break;} +case 10: +#line 156 "m68k-parse.y" +{ + op->mode = IMMED; + op->disp = yyvsp[0].exp; + ; + break;} +case 11: +#line 161 "m68k-parse.y" +{ + op->mode = IMMED; + op->disp = yyvsp[0].exp; + ; + break;} +case 12: +#line 166 "m68k-parse.y" +{ + op->mode = REGLST; + op->mask = yyvsp[0].mask; + ; + break;} +case 13: +#line 179 "m68k-parse.y" +{ + op->mode = AINDR; + op->reg = yyvsp[-1].reg; + ; + break;} +case 14: +#line 184 "m68k-parse.y" +{ + op->mode = AINC; + op->reg = yyvsp[-2].reg; + ; + break;} +case 15: +#line 189 "m68k-parse.y" +{ + op->mode = ADEC; + op->reg = yyvsp[-1].reg; + ; + break;} +case 16: +#line 194 "m68k-parse.y" +{ + op->reg = yyvsp[-1].reg; + op->disp = yyvsp[-3].exp; + if ((yyvsp[-1].reg >= ZADDR0 && yyvsp[-1].reg <= ZADDR7) + || yyvsp[-1].reg == ZPC) + op->mode = BASE; + else + op->mode = DISP; + ; + break;} +case 17: +#line 204 "m68k-parse.y" +{ + op->reg = yyvsp[-3].reg; + op->disp = yyvsp[-1].exp; + if ((yyvsp[-3].reg >= ZADDR0 && yyvsp[-3].reg <= ZADDR7) + || yyvsp[-3].reg == ZPC) + op->mode = BASE; + else + op->mode = DISP; + ; + break;} +case 18: +#line 214 "m68k-parse.y" +{ + op->reg = yyvsp[-1].reg; + op->disp = yyvsp[-3].exp; + if ((yyvsp[-1].reg >= ZADDR0 && yyvsp[-1].reg <= ZADDR7) + || yyvsp[-1].reg == ZPC) + op->mode = BASE; + else + op->mode = DISP; + ; + break;} +case 19: +#line 224 "m68k-parse.y" +{ + op->mode = DISP; + op->reg = yyvsp[-1].reg; + ; + break;} +case 20: +#line 229 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-1].reg; + ; + break;} +case 21: +#line 234 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-1].reg; + ; + break;} +case 22: +#line 239 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-3].reg; + op->disp = yyvsp[-5].exp; + op->index = yyvsp[-1].indexreg; + ; + break;} +case 23: +#line 246 "m68k-parse.y" +{ + if (yyvsp[-3].reg == PC || yyvsp[-3].reg == ZPC) + yyerror (_("syntax error")); + op->mode = BASE; + op->reg = yyvsp[-1].reg; + op->disp = yyvsp[-5].exp; + op->index.reg = yyvsp[-3].reg; + op->index.size = SIZE_UNSPEC; + op->index.scale = 1; + ; + break;} +case 24: +#line 257 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-1].reg; + op->disp = yyvsp[-4].exp; + op->index = yyvsp[-2].indexreg; + ; + break;} +case 25: +#line 264 "m68k-parse.y" +{ + op->mode = BASE; + op->disp = yyvsp[-1].exp; + op->index = yyvsp[-3].indexreg; + ; + break;} +case 26: +#line 270 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-3].reg; + op->disp = yyvsp[-5].exp; + op->index = yyvsp[-1].indexreg; + ; + break;} +case 27: +#line 277 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-3].reg; + op->index = yyvsp[-1].indexreg; + ; + break;} +case 28: +#line 283 "m68k-parse.y" +{ + if (yyvsp[-3].reg == PC || yyvsp[-3].reg == ZPC) + yyerror (_("syntax error")); + op->mode = BASE; + op->reg = yyvsp[-1].reg; + op->disp = yyvsp[-5].exp; + op->index.reg = yyvsp[-3].reg; + op->index.size = SIZE_UNSPEC; + op->index.scale = 1; + ; + break;} +case 29: +#line 294 "m68k-parse.y" +{ + if (yyvsp[-3].reg == PC || yyvsp[-3].reg == ZPC) + yyerror (_("syntax error")); + op->mode = BASE; + op->reg = yyvsp[-1].reg; + op->index.reg = yyvsp[-3].reg; + op->index.size = SIZE_UNSPEC; + op->index.scale = 1; + ; + break;} +case 30: +#line 304 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-1].reg; + op->disp = yyvsp[-4].exp; + op->index = yyvsp[-2].indexreg; + ; + break;} +case 31: +#line 311 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-1].reg; + op->index = yyvsp[-2].indexreg; + ; + break;} +case 32: +#line 317 "m68k-parse.y" +{ + op->mode = POST; + op->reg = yyvsp[-5].reg; + op->disp = yyvsp[-6].exp; + op->index = yyvsp[-2].indexreg; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 33: +#line 325 "m68k-parse.y" +{ + op->mode = POST; + op->reg = yyvsp[-3].reg; + op->disp = yyvsp[-4].exp; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 34: +#line 332 "m68k-parse.y" +{ + op->mode = POST; + op->reg = yyvsp[-5].reg; + op->index = yyvsp[-2].indexreg; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 35: +#line 339 "m68k-parse.y" +{ + op->mode = POST; + op->reg = yyvsp[-3].reg; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 36: +#line 345 "m68k-parse.y" +{ + op->mode = PRE; + op->reg = yyvsp[-5].reg; + op->disp = yyvsp[-7].exp; + op->index = yyvsp[-3].indexreg; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 37: +#line 353 "m68k-parse.y" +{ + op->mode = PRE; + op->reg = yyvsp[-5].reg; + op->index = yyvsp[-3].indexreg; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 38: +#line 360 "m68k-parse.y" +{ + if (yyvsp[-5].reg == PC || yyvsp[-5].reg == ZPC) + yyerror (_("syntax error")); + op->mode = PRE; + op->reg = yyvsp[-3].reg; + op->disp = yyvsp[-7].exp; + op->index.reg = yyvsp[-5].reg; + op->index.size = SIZE_UNSPEC; + op->index.scale = 1; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 39: +#line 372 "m68k-parse.y" +{ + if (yyvsp[-5].reg == PC || yyvsp[-5].reg == ZPC) + yyerror (_("syntax error")); + op->mode = PRE; + op->reg = yyvsp[-3].reg; + op->index.reg = yyvsp[-5].reg; + op->index.size = SIZE_UNSPEC; + op->index.scale = 1; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 40: +#line 383 "m68k-parse.y" +{ + op->mode = PRE; + op->reg = yyvsp[-3].reg; + op->disp = yyvsp[-5].exp; + op->index = yyvsp[-4].indexreg; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 41: +#line 396 "m68k-parse.y" +{ + /* We use optzapc to avoid a shift/reduce conflict. */ + if (yyvsp[-1].reg < ADDR0 || yyvsp[-1].reg > ADDR7) + yyerror (_("syntax error")); + op->mode = AINDR; + op->reg = yyvsp[-1].reg; + ; + break;} +case 42: +#line 404 "m68k-parse.y" +{ + /* We use optzapc to avoid a shift/reduce conflict. */ + if (yyvsp[-2].reg < ADDR0 || yyvsp[-2].reg > ADDR7) + yyerror (_("syntax error")); + op->mode = AINC; + op->reg = yyvsp[-2].reg; + ; + break;} +case 43: +#line 412 "m68k-parse.y" +{ + /* We use optzapc to avoid a shift/reduce conflict. */ + if (yyvsp[-2].reg < ADDR0 || yyvsp[-2].reg > ADDR7) + yyerror (_("syntax error")); + op->mode = ADEC; + op->reg = yyvsp[-2].reg; + ; + break;} +case 44: +#line 420 "m68k-parse.y" +{ + op->reg = yyvsp[-4].reg; + op->disp = yyvsp[-1].exp; + if ((yyvsp[-4].reg >= ZADDR0 && yyvsp[-4].reg <= ZADDR7) + || yyvsp[-4].reg == ZPC) + op->mode = BASE; + else + op->mode = DISP; + ; + break;} +case 45: +#line 430 "m68k-parse.y" +{ + op->mode = BASE; + op->reg = yyvsp[-5].reg; + op->disp = yyvsp[-2].exp; + op->index = yyvsp[-1].indexreg; + ; + break;} +case 46: +#line 437 "m68k-parse.y" +{ + op->mode = POST; + op->reg = yyvsp[-9].reg; + op->disp = yyvsp[-6].exp; + op->index = yyvsp[-1].indexreg; + op->odisp = yyvsp[-2].exp; + ; + break;} +case 47: +#line 445 "m68k-parse.y" +{ + op->mode = POST; + op->reg = yyvsp[-8].reg; + op->disp = yyvsp[-5].exp; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 48: +#line 452 "m68k-parse.y" +{ + op->mode = PRE; + op->reg = yyvsp[-9].reg; + op->disp = yyvsp[-6].exp; + op->index = yyvsp[-5].indexreg; + op->odisp = yyvsp[-1].exp; + ; + break;} +case 50: +#line 467 "m68k-parse.y" +{ + yyval.indexreg.reg = yyvsp[0].reg; + yyval.indexreg.size = SIZE_UNSPEC; + yyval.indexreg.scale = 1; + ; + break;} +case 52: +#line 481 "m68k-parse.y" +{ + yyval.indexreg.reg = yyvsp[0].reg; + yyval.indexreg.size = SIZE_UNSPEC; + yyval.indexreg.scale = 1; + ; + break;} +case 63: +#line 524 "m68k-parse.y" +{ + yyval.reg = ZADDR0; + ; + break;} +case 67: +#line 541 "m68k-parse.y" +{ + yyval.reg = ZADDR0; + ; + break;} +case 68: +#line 545 "m68k-parse.y" +{ + yyval.reg = yyvsp[0].reg; + ; + break;} +case 69: +#line 554 "m68k-parse.y" +{ + yyval.exp.exp.X_op = O_absent; + yyval.exp.size = SIZE_UNSPEC; + ; + break;} +case 70: +#line 559 "m68k-parse.y" +{ + yyval.exp = yyvsp[0].exp; + ; + break;} +case 71: +#line 568 "m68k-parse.y" +{ + yyval.exp.exp.X_op = O_absent; + yyval.exp.size = SIZE_UNSPEC; + ; + break;} +case 72: +#line 573 "m68k-parse.y" +{ + yyval.exp = yyvsp[-1].exp; + ; + break;} +case 74: +#line 583 "m68k-parse.y" +{ + yyval.mask = yyvsp[-2].mask | yyvsp[0].mask; + ; + break;} +case 75: +#line 587 "m68k-parse.y" +{ + yyval.mask = (1 << yyvsp[-2].onereg) | yyvsp[0].mask; + ; + break;} +case 76: +#line 599 "m68k-parse.y" +{ + yyval.mask = 1 << yyvsp[0].onereg; + ; + break;} +case 78: +#line 604 "m68k-parse.y" +{ + yyval.mask = yyvsp[-2].mask | yyvsp[0].mask; + ; + break;} +case 79: +#line 608 "m68k-parse.y" +{ + yyval.mask = (1 << yyvsp[-2].onereg) | yyvsp[0].mask; + ; + break;} +case 80: +#line 615 "m68k-parse.y" +{ + if (yyvsp[-2].onereg <= yyvsp[0].onereg) + yyval.mask = (1 << (yyvsp[0].onereg + 1)) - 1 - ((1 << yyvsp[-2].onereg) - 1); + else + yyval.mask = (1 << (yyvsp[-2].onereg + 1)) - 1 - ((1 << yyvsp[0].onereg) - 1); + ; + break;} +case 81: +#line 625 "m68k-parse.y" +{ + yyval.onereg = yyvsp[0].reg - DATA0; + ; + break;} +case 82: +#line 629 "m68k-parse.y" +{ + yyval.onereg = yyvsp[0].reg - ADDR0 + 8; + ; + break;} +case 83: +#line 633 "m68k-parse.y" +{ + yyval.onereg = yyvsp[0].reg - FP0 + 16; + ; + break;} +case 84: +#line 637 "m68k-parse.y" +{ + if (yyvsp[0].reg == FPI) + yyval.onereg = 24; + else if (yyvsp[0].reg == FPS) + yyval.onereg = 25; + else + yyval.onereg = 26; + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 647 "m68k-parse.y" + + +/* The string to parse is stored here, and modified by yylex. */ + +static char *str; + +/* The original string pointer. */ + +static char *strorig; + +/* If *CCP could be a register, return the register number and advance + *CCP. Otherwise don't change *CCP, and return 0. */ + +static enum m68k_register +m68k_reg_parse (ccp) + register char **ccp; +{ + char *start = *ccp; + char c; + char *p; + symbolS *symbolp; + + if (flag_reg_prefix_optional) + { + if (*start == REGISTER_PREFIX) + start++; + p = start; + } + else + { + if (*start != REGISTER_PREFIX) + return 0; + p = start + 1; + } + + if (! is_name_beginner (*p)) + return 0; + + p++; + while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*') + p++; + + c = *p; + *p = 0; + symbolp = symbol_find (start); + *p = c; + + if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section) + { + *ccp = p; + return S_GET_VALUE (symbolp); + } + + /* In MRI mode, something like foo.bar can be equated to a register + name. */ + while (flag_mri && c == '.') + { + ++p; + while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*') + p++; + c = *p; + *p = '\0'; + symbolp = symbol_find (start); + *p = c; + if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section) + { + *ccp = p; + return S_GET_VALUE (symbolp); + } + } + + return 0; +} + +/* The lexer. */ + +static int +yylex () +{ + enum m68k_register reg; + char *s; + int parens; + int c = 0; + int tail = 0; + char *hold; + + if (*str == ' ') + ++str; + + if (*str == '\0') + return 0; + + /* Various special characters are just returned directly. */ + switch (*str) + { + case '@': + /* In MRI mode, this can be the start of an octal number. */ + if (flag_mri) + { + if (isdigit (str[1]) + || ((str[1] == '+' || str[1] == '-') + && isdigit (str[2]))) + break; + } + /* Fall through. */ + case '#': + case '&': + case ',': + case ')': + case '/': + case '[': + case ']': + return *str++; + case '+': + /* It so happens that a '+' can only appear at the end of an + operand. If it appears anywhere else, it must be a unary + plus on an expression. */ + if (str[1] == '\0') + return *str++; + break; + case '-': + /* A '-' can only appear in -(ar), rn-rn, or ar@-. If it + appears anywhere else, it must be a unary minus on an + expression. */ + if (str[1] == '\0') + return *str++; + s = str + 1; + if (*s == '(') + ++s; + if (m68k_reg_parse (&s) != 0) + return *str++; + break; + case '(': + /* A '(' can only appear in `(reg)', `(expr,...', `([', `@(', or + `)('. If it appears anywhere else, it must be starting an + expression. */ + if (str[1] == '[' + || (str > strorig + && (str[-1] == '@' + || str[-1] == ')'))) + return *str++; + s = str + 1; + if (m68k_reg_parse (&s) != 0) + return *str++; + /* Check for the case of '(expr,...' by scanning ahead. If we + find a comma outside of balanced parentheses, we return '('. + If we find an unbalanced right parenthesis, then presumably + the '(' really starts an expression. */ + parens = 0; + for (s = str + 1; *s != '\0'; s++) + { + if (*s == '(') + ++parens; + else if (*s == ')') + { + if (parens == 0) + break; + --parens; + } + else if (*s == ',' && parens == 0) + { + /* A comma can not normally appear in an expression, so + this is a case of '(expr,...'. */ + return *str++; + } + } + } + + /* See if it's a register. */ + + reg = m68k_reg_parse (&str); + if (reg != 0) + { + int ret; + + yylval.reg = reg; + + if (reg >= DATA0 && reg <= DATA7) + ret = DR; + else if (reg >= ADDR0 && reg <= ADDR7) + ret = AR; + else if (reg >= FP0 && reg <= FP7) + return FPR; + else if (reg == FPI + || reg == FPS + || reg == FPC) + return FPCR; + else if (reg == PC) + return LPC; + else if (reg >= ZDATA0 && reg <= ZDATA7) + ret = ZDR; + else if (reg >= ZADDR0 && reg <= ZADDR7) + ret = ZAR; + else if (reg == ZPC) + return LZPC; + else + return CREG; + + /* If we get here, we have a data or address register. We + must check for a size or scale; if we find one, we must + return INDEXREG. */ + + s = str; + + if (*s != '.' && *s != ':' && *s != '*') + return ret; + + yylval.indexreg.reg = reg; + + if (*s != '.' && *s != ':') + yylval.indexreg.size = SIZE_UNSPEC; + else + { + ++s; + switch (*s) + { + case 'w': + case 'W': + yylval.indexreg.size = SIZE_WORD; + ++s; + break; + case 'l': + case 'L': + yylval.indexreg.size = SIZE_LONG; + ++s; + break; + default: + yyerror (_("illegal size specification")); + yylval.indexreg.size = SIZE_UNSPEC; + break; + } + } + + yylval.indexreg.scale = 1; + + if (*s == '*' || *s == ':') + { + expressionS scale; + + ++s; + + hold = input_line_pointer; + input_line_pointer = s; + expression (&scale); + s = input_line_pointer; + input_line_pointer = hold; + + if (scale.X_op != O_constant) + yyerror (_("scale specification must resolve to a number")); + else + { + switch (scale.X_add_number) + { + case 1: + case 2: + case 4: + case 8: + yylval.indexreg.scale = scale.X_add_number; + break; + default: + yyerror (_("invalid scale value")); + break; + } + } + } + + str = s; + + return INDEXREG; + } + + /* It must be an expression. Before we call expression, we need to + look ahead to see if there is a size specification. We must do + that first, because otherwise foo.l will be treated as the symbol + foo.l, rather than as the symbol foo with a long size + specification. The grammar requires that all expressions end at + the end of the operand, or with ',', '(', ']', ')'. */ + + parens = 0; + for (s = str; *s != '\0'; s++) + { + if (*s == '(') + { + if (parens == 0 + && s > str + && (s[-1] == ')' || isalnum ((unsigned char) s[-1]))) + break; + ++parens; + } + else if (*s == ')') + { + if (parens == 0) + break; + --parens; + } + else if (parens == 0 + && (*s == ',' || *s == ']')) + break; + } + + yylval.exp.size = SIZE_UNSPEC; + if (s <= str + 2 + || (s[-2] != '.' && s[-2] != ':')) + tail = 0; + else + { + switch (s[-1]) + { + case 's': + case 'S': + case 'b': + case 'B': + yylval.exp.size = SIZE_BYTE; + break; + case 'w': + case 'W': + yylval.exp.size = SIZE_WORD; + break; + case 'l': + case 'L': + yylval.exp.size = SIZE_LONG; + break; + default: + break; + } + if (yylval.exp.size != SIZE_UNSPEC) + tail = 2; + } + +#ifdef OBJ_ELF + { + /* Look for @PLTPC, etc. */ + char *cp; + + yylval.exp.pic_reloc = pic_none; + cp = s - tail; + if (cp - 6 > str && cp[-6] == '@') + { + if (strncmp (cp - 6, "@PLTPC", 6) == 0) + { + yylval.exp.pic_reloc = pic_plt_pcrel; + tail += 6; + } + else if (strncmp (cp - 6, "@GOTPC", 6) == 0) + { + yylval.exp.pic_reloc = pic_got_pcrel; + tail += 6; + } + } + else if (cp - 4 > str && cp[-4] == '@') + { + if (strncmp (cp - 4, "@PLT", 4) == 0) + { + yylval.exp.pic_reloc = pic_plt_off; + tail += 4; + } + else if (strncmp (cp - 4, "@GOT", 4) == 0) + { + yylval.exp.pic_reloc = pic_got_off; + tail += 4; + } + } + } +#endif + + if (tail != 0) + { + c = s[-tail]; + s[-tail] = 0; + } + + hold = input_line_pointer; + input_line_pointer = str; + expression (&yylval.exp.exp); + str = input_line_pointer; + input_line_pointer = hold; + + if (tail != 0) + { + s[-tail] = c; + str = s; + } + + return EXPR; +} + +/* Parse an m68k operand. This is the only function which is called + from outside this file. */ + +int +m68k_ip_op (s, oparg) + char *s; + struct m68k_op *oparg; +{ + memset (oparg, 0, sizeof *oparg); + oparg->error = NULL; + oparg->index.reg = ZDATA0; + oparg->index.scale = 1; + oparg->disp.exp.X_op = O_absent; + oparg->odisp.exp.X_op = O_absent; + + str = strorig = s; + op = oparg; + + return yyparse (); +} + +/* The error handler. */ + +static void +yyerror (s) + const char *s; +{ + op->error = s; +} diff --git a/gas/make-gas.com b/gas/make-gas.com new file mode 100644 index 00000000000..227426505ee --- /dev/null +++ b/gas/make-gas.com @@ -0,0 +1,155 @@ +$!make-gas.com +$! Set the def dir to proper place for use in batch. Works for interactive to. +$flnm = f$enviroment("PROCEDURE") ! get current procedure name +$set default 'f$parse(flnm,,,"DEVICE")''f$parse(flnm,,,"DIRECTORY")' +$v = 'f$verify(0)' +$! +$! Command file to build a GNU assembler on VMS +$! +$! If you are using a version of GCC that supports global constants +$! you should remove the define="const=" from the gcc lines. +$! +$! Caution: Versions 1.38.1 and earlier had a bug in the handling of +$! some static constants. If you are using such a version of the +$! assembler, and you wish to compile without the "const=" hack, +$! you should first build this version *with* the "const=" +$! definition, and then use that assembler to rebuild it without the +$! "const=" definition. Failure to do this will result in an assembler +$! that will mung floating point constants. +$! +$! Note: The version of gas shipped on the GCC VMS tapes has been patched +$! to fix the above mentioned bug. +$! +$ !The gcc-vms driver was modified to use `-1' quite some time ago, +$ !so don't echo this text any more... +$ !write sys$output "If this assembler is going to be used with GCC 1.n, you" +$ !write sys$output "need to modify the driver to supply the -1 switch to gas." +$ !write sys$output "This is required because of a small change in how global" +$ !write sys$output "constant variables are handled. Failure to include this" +$ !write sys$output "will result in linker warning messages about mismatched +$ !write sys$output "psect attributes." +$! +$ gas_host="vms" +$ arch_indx = 1 + ((f$getsyi("CPU").ge.128).and.1) ! vax==1, alpha==2 +$ arch = f$element(arch_indx,"|","|VAX|Alpha|") +$ if arch.eqs."VAX" +$ then +$ cpu_type="vax" +$ obj_format="vms" +$ atof="vax" +$ else +$ cpu_type="alpha" +$ obj_format="evax" +$ atof="ieee" +$ endif +$ emulation="generic" +$! +$ COPY = "copy/noLog" +$! +$ C_DEFS :="""VMS""" +$! C_DEFS :="""VMS""","""const=""" +$ C_INCLUDES = "/Include=([],[.config],[-.include],[-.include.aout])" +$ C_FLAGS = "/noVerbose/Debug" + c_includes +$! +$! +$ on error then goto bail +$ if f$search("[-.libiberty]liberty.olb").eqs."" +$ then @[-.libiberty]vmsbuild.com +$ write sys$output "Now building gas." +$ endif +$ if "''p1'" .eqs. "LINK" then goto Link +$! +$! This helps gcc 1.nn find the aout/* files. +$! +$ aout_dev = f$parse(flnm,,,"DEVICE") +$ tmp = aout_dev - ":" +$if f$trnlnm(tmp).nes."" then aout_dev = f$trnlnm(tmp) +$ aout_dir = aout_dev+f$parse(flnm,,,"DIRECTORY")' - + - "GAS]" + "INCLUDE.AOUT.]" - "][" +$assign 'aout_dir' aout/tran=conc +$ opcode_dir = aout_dev+f$parse(flnm,,,"DIRECTORY")' - + - "GAS]" + "INCLUDE.OPCODE.]" - "][" +$assign 'opcode_dir' opcode/tran=conc +$! +$ set verify +$! +$ gcc 'c_flags'/Define=('C_DEFS')/Object=[]tc-'cpu_type'.obj [.config]tc-'cpu_type'.c +$ gcc 'c_flags'/Define=('C_DEFS')/Object=[]obj-'obj_format'.obj [.config]obj-'obj_format'.c +$ gcc 'c_flags'/Define=('C_DEFS')/Object=[]atof-'atof'.obj [.config]atof-'atof'.c +$ gcc 'c_flags'/Define=('C_DEFS') app.c +$ gcc 'c_flags'/Define=('C_DEFS') as.c +$ gcc 'c_flags'/Define=('C_DEFS') atof-generic.c +$ gcc 'c_flags'/Define=('C_DEFS') bignum-copy.c +$ gcc 'c_flags'/Define=('C_DEFS') cond.c +$ gcc 'c_flags'/Define=('C_DEFS') depend.c +$ gcc 'c_flags'/Define=('C_DEFS') dwarf2dbg.c +$ gcc 'c_flags'/Define=('C_DEFS') ehopt.c +$ gcc 'c_flags'/Define=('C_DEFS') expr.c +$ gcc 'c_flags'/Define=('C_DEFS') flonum-konst.c +$ gcc 'c_flags'/Define=('C_DEFS') flonum-copy.c +$ gcc 'c_flags'/Define=('C_DEFS') flonum-mult.c +$ gcc 'c_flags'/Define=('C_DEFS') frags.c +$ gcc 'c_flags'/Define=('C_DEFS') hash.c +$ gcc 'c_flags'/Define=('C_DEFS') input-file.c +$ gcc 'c_flags'/Define=('C_DEFS') input-scrub.c +$ gcc 'c_flags'/Define=('C_DEFS') literal.c +$ gcc 'c_flags'/Define=('C_DEFS') messages.c +$ gcc 'c_flags'/Define=('C_DEFS') output-file.c +$ gcc 'c_flags'/Define=('C_DEFS') read.c +$ gcc 'c_flags'/Define=('C_DEFS') subsegs.c +$ gcc 'c_flags'/Define=('C_DEFS') symbols.c +$ gcc 'c_flags'/Define=('C_DEFS') write.c +$ gcc 'c_flags'/Define=('C_DEFS') listing.c +$ gcc 'c_flags'/Define=('C_DEFS') ecoff.c +$ gcc 'c_flags'/Define=('C_DEFS') stabs.c +$ gcc 'c_flags'/Define=('C_DEFS') sb.c +$ gcc 'c_flags'/Define=('C_DEFS') macro.c +$link: +$!'f$verify(0)' +$ if f$trnlnm("IFILE$").nes."" then close/noLog ifile$ +$ create gcc-as.opt +! +! Linker options file for GNU assembler +! +$ open/Append ifile$ gcc-as.opt +$ write ifile$ "tc-''cpu_type'.obj" +$ write ifile$ "obj-''obj_format'.obj" +$ write ifile$ "atof-''atof'.obj" +$ COPY sys$input: ifile$: +app.obj,- +as.obj,- +atof-generic.obj,- +bignum-copy.obj,- +cond.obj,- +depend.obj,- +dwarf2dbg.obj,- +ehopt.obj,- +expr.obj,- +flonum-konst.obj,- +flonum-copy.obj,- +flonum-mult.obj,- +frags.obj,- +hash.obj,- +input-file.obj,- +input-scrub.obj,- +literal.obj,- +messages.obj,- +output-file.obj,- +read.obj,- +subsegs.obj,- +symbols.obj,- +write.obj,- +listing.obj,- +ecoff.obj,- +stabs.obj,- +sb.obj,- +macro.obj,- +[-.libiberty]liberty.olb/Lib +gnu_cc:[000000]gcclib.olb/Lib,sys$library:vaxcrtl.olb/Lib +! Tell linker exactly what psect attributes we want -- match VAXCRTL. +psect_attr=ENVIRON,long,pic,ovr,rel,gbl,noshr,noexe,rd,wrt +$ close ifile$ +$ set verify=(Proc,noImag) +$ link/noMap/Exec=gcc-as.exe gcc-as.opt/Opt,version.opt/Opt +$! +$bail: exit $status + 0*f$verify(v) !'f$verify(0)' diff --git a/gprof/bsd_callg_bl.c b/gprof/bsd_callg_bl.c new file mode 100644 index 00000000000..5be63b9a24c --- /dev/null +++ b/gprof/bsd_callg_bl.c @@ -0,0 +1,118 @@ +/* ==> Do not modify this file!! It is created automatically + from bsd_callg_bl.m using the gen-c-prog.awk script. <== */ + +#include <stdio.h> + +void +bsd_callg_blurb (file) + FILE *file; +{ + fputs ("\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs ("call graph profile:\n", file); + fputs (" The sum of self and descendents is the major sort\n", file); + fputs (" for this listing.\n", file); + fputs ("\n", file); + fputs (" function entries:\n", file); + fputs ("\n", file); + fputs ("index the index of the function in the call graph\n", file); + fputs (" listing, as an aid to locating it (see below).\n", file); + fputs ("\n", file); + fputs ("%time the percentage of the total time of the program\n", file); + fputs (" accounted for by this function and its\n", file); + fputs (" descendents.\n", file); + fputs ("\n", file); + fputs ("self the number of seconds spent in this function\n", file); + fputs (" itself.\n", file); + fputs ("\n", file); + fputs ("descendents\n", file); + fputs (" the number of seconds spent in the descendents of\n", file); + fputs (" this function on behalf of this function.\n", file); + fputs ("\n", file); + fputs ("called the number of times this function is called (other\n", file); + fputs (" than recursive calls).\n", file); + fputs ("\n", file); + fputs ("self the number of times this function calls itself\n", file); + fputs (" recursively.\n", file); + fputs ("\n", file); + fputs ("name the name of the function, with an indication of\n", file); + fputs (" its membership in a cycle, if any.\n", file); + fputs ("\n", file); + fputs ("index the index of the function in the call graph\n", file); + fputs (" listing, as an aid to locating it.\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs (" parent listings:\n", file); + fputs ("\n", file); + fputs ("self* the number of seconds of this function's self time\n", file); + fputs (" which is due to calls from this parent.\n", file); + fputs ("\n", file); + fputs ("descendents*\n", file); + fputs (" the number of seconds of this function's\n", file); + fputs (" descendent time which is due to calls from this\n", file); + fputs (" parent.\n", file); + fputs ("\n", file); + fputs ("called** the number of times this function is called by\n", file); + fputs (" this parent. This is the numerator of the\n", file); + fputs (" fraction which divides up the function's time to\n", file); + fputs (" its parents.\n", file); + fputs ("\n", file); + fputs ("total* the number of times this function was called by\n", file); + fputs (" all of its parents. This is the denominator of\n", file); + fputs (" the propagation fraction.\n", file); + fputs ("\n", file); + fputs ("parents the name of this parent, with an indication of the\n", file); + fputs (" parent's membership in a cycle, if any.\n", file); + fputs ("\n", file); + fputs ("index the index of this parent in the call graph\n", file); + fputs (" listing, as an aid in locating it.\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs (" children listings:\n", file); + fputs ("\n", file); + fputs ("self* the number of seconds of this child's self time\n", file); + fputs (" which is due to being called by this function.\n", file); + fputs ("\n", file); + fputs ("descendent*\n", file); + fputs (" the number of seconds of this child's descendent's\n", file); + fputs (" time which is due to being called by this\n", file); + fputs (" function.\n", file); + fputs ("\n", file); + fputs ("called** the number of times this child is called by this\n", file); + fputs (" function. This is the numerator of the\n", file); + fputs (" propagation fraction for this child.\n", file); + fputs ("\n", file); + fputs ("total* the number of times this child is called by all\n", file); + fputs (" functions. This is the denominator of the\n", file); + fputs (" propagation fraction.\n", file); + fputs ("\n", file); + fputs ("children the name of this child, and an indication of its\n", file); + fputs (" membership in a cycle, if any.\n", file); + fputs ("\n", file); + fputs ("index the index of this child in the call graph listing,\n", file); + fputs (" as an aid to locating it.\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs (" * these fields are omitted for parents (or\n", file); + fputs (" children) in the same cycle as the function. If\n", file); + fputs (" the function (or child) is a member of a cycle,\n", file); + fputs (" the propagated times and propagation denominator\n", file); + fputs (" represent the self time and descendent time of the\n", file); + fputs (" cycle as a whole.\n", file); + fputs ("\n", file); + fputs (" ** static-only parents and children are indicated\n", file); + fputs (" by a call count of 0.\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs (" cycle listings:\n", file); + fputs (" the cycle as a whole is listed with the same\n", file); + fputs (" fields as a function entry. Below it are listed\n", file); + fputs (" the members of the cycle, and their contributions\n", file); + fputs (" to the time and call counts of the cycle.\n", file); + fputs (" \n", file); +} diff --git a/gprof/flat_bl.c b/gprof/flat_bl.c new file mode 100644 index 00000000000..e02c209798c --- /dev/null +++ b/gprof/flat_bl.c @@ -0,0 +1,37 @@ +/* ==> Do not modify this file!! It is created automatically + from flat_bl.m using the gen-c-prog.awk script. <== */ + +#include <stdio.h> + +void +flat_blurb (file) + FILE *file; +{ + fputs ("\n", file); + fputs (" % the percentage of the total running time of the\n", file); + fputs ("time program used by this function.\n", file); + fputs ("\n", file); + fputs ("cumulative a running sum of the number of seconds accounted\n", file); + fputs (" seconds for by this function and those listed above it.\n", file); + fputs ("\n", file); + fputs (" self the number of seconds accounted for by this\n", file); + fputs ("seconds function alone. This is the major sort for this\n", file); + fputs (" listing.\n", file); + fputs ("\n", file); + fputs ("calls the number of times this function was invoked, if\n", file); + fputs (" this function is profiled, else blank.\n", file); + fputs (" \n", file); + fputs (" self the average number of milliseconds spent in this\n", file); + fputs ("ms/call function per call, if this function is profiled,\n", file); + fputs (" else blank.\n", file); + fputs ("\n", file); + fputs (" total the average number of milliseconds spent in this\n", file); + fputs ("ms/call function and its descendents per call, if this \n", file); + fputs (" function is profiled, else blank.\n", file); + fputs ("\n", file); + fputs ("name the name of the function. This is the minor sort\n", file); + fputs (" for this listing. The index shows the location of\n", file); + fputs (" the function in the gprof listing. If the index is\n", file); + fputs (" in parenthesis it shows where it would appear in\n", file); + fputs (" the gprof listing if it were to be printed.\n", file); +} diff --git a/gprof/fsf_callg_bl.c b/gprof/fsf_callg_bl.c new file mode 100644 index 00000000000..d8182b551b0 --- /dev/null +++ b/gprof/fsf_callg_bl.c @@ -0,0 +1,93 @@ +/* ==> Do not modify this file!! It is created automatically + from fsf_callg_bl.m using the gen-c-prog.awk script. <== */ + +#include <stdio.h> + +void +fsf_callg_blurb (file) + FILE *file; +{ + fputs ("\n", file); + fputs (" This table describes the call tree of the program, and was sorted by\n", file); + fputs (" the total amount of time spent in each function and its children.\n", file); + fputs ("\n", file); + fputs (" Each entry in this table consists of several lines. The line with the\n", file); + fputs (" index number at the left hand margin lists the current function.\n", file); + fputs (" The lines above it list the functions that called this function,\n", file); + fputs (" and the lines below it list the functions this one called.\n", file); + fputs (" This line lists:\n", file); + fputs (" index A unique number given to each element of the table.\n", file); + fputs (" Index numbers are sorted numerically.\n", file); + fputs (" The index number is printed next to every function name so\n", file); + fputs (" it is easier to look up where the function in the table.\n", file); + fputs ("\n", file); + fputs (" % time This is the percentage of the `total' time that was spent\n", file); + fputs (" in this function and its children. Note that due to\n", file); + fputs (" different viewpoints, functions excluded by options, etc,\n", file); + fputs (" these numbers will NOT add up to 100%.\n", file); + fputs ("\n", file); + fputs (" self This is the total amount of time spent in this function.\n", file); + fputs ("\n", file); + fputs (" children This is the total amount of time propagated into this\n", file); + fputs (" function by its children.\n", file); + fputs ("\n", file); + fputs (" called This is the number of times the function was called.\n", file); + fputs (" If the function called itself recursively, the number\n", file); + fputs (" only includes non-recursive calls, and is followed by\n", file); + fputs (" a `+' and the number of recursive calls.\n", file); + fputs ("\n", file); + fputs (" name The name of the current function. The index number is\n", file); + fputs (" printed after it. If the function is a member of a\n", file); + fputs (" cycle, the cycle number is printed between the\n", file); + fputs (" function's name and the index number.\n", file); + fputs ("\n", file); + fputs ("\n", file); + fputs (" For the function's parents, the fields have the following meanings:\n", file); + fputs ("\n", file); + fputs (" self This is the amount of time that was propagated directly\n", file); + fputs (" from the function into this parent.\n", file); + fputs ("\n", file); + fputs (" children This is the amount of time that was propagated from\n", file); + fputs (" the function's children into this parent.\n", file); + fputs ("\n", file); + fputs (" called This is the number of times this parent called the\n", file); + fputs (" function `/' the total number of times the function\n", file); + fputs (" was called. Recursive calls to the function are not\n", file); + fputs (" included in the number after the `/'.\n", file); + fputs ("\n", file); + fputs (" name This is the name of the parent. The parent's index\n", file); + fputs (" number is printed after it. If the parent is a\n", file); + fputs (" member of a cycle, the cycle number is printed between\n", file); + fputs (" the name and the index number.\n", file); + fputs ("\n", file); + fputs (" If the parents of the function cannot be determined, the word\n", file); + fputs (" `<spontaneous>' is printed in the `name' field, and all the other\n", file); + fputs (" fields are blank.\n", file); + fputs ("\n", file); + fputs (" For the function's children, the fields have the following meanings:\n", file); + fputs ("\n", file); + fputs (" self This is the amount of time that was propagated directly\n", file); + fputs (" from the child into the function.\n", file); + fputs ("\n", file); + fputs (" children This is the amount of time that was propagated from the\n", file); + fputs (" child's children to the function.\n", file); + fputs ("\n", file); + fputs (" called This is the number of times the function called\n", file); + fputs (" this child `/' the total number of times the child\n", file); + fputs (" was called. Recursive calls by the child are not\n", file); + fputs (" listed in the number after the `/'.\n", file); + fputs ("\n", file); + fputs (" name This is the name of the child. The child's index\n", file); + fputs (" number is printed after it. If the child is a\n", file); + fputs (" member of a cycle, the cycle number is printed\n", file); + fputs (" between the name and the index number.\n", file); + fputs ("\n", file); + fputs (" If there are any cycles (circles) in the call graph, there is an\n", file); + fputs (" entry for the cycle-as-a-whole. This entry shows who called the\n", file); + fputs (" cycle (as parents) and the members of the cycle (as children.)\n", file); + fputs (" The `+' recursive calls entry shows the number of function calls that\n", file); + fputs (" were internal to the cycle, and the calls entry for each member shows,\n", file); + fputs (" for that member, how many times it was called from other members of\n", file); + fputs (" the cycle.\n", file); + fputs ("\n", file); +} diff --git a/gprof/gprof.info b/gprof/gprof.info new file mode 100644 index 00000000000..f7d591daad6 --- /dev/null +++ b/gprof/gprof.info @@ -0,0 +1,62 @@ +This is gprof.info, produced by makeinfo version 4.0 from gprof.texi. + +START-INFO-DIR-ENTRY +* gprof: (gprof). Profiling your program's execution +END-INFO-DIR-ENTRY + + This file documents the gprof profiler of the GNU system. + + Copyright (C) 1988, 92, 97, 98, 99, 2000 Free Software Foundation, +Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +Indirect: +gprof.info-1: 884 +gprof.info-2: 47890 + +Tag Table: +(Indirect) +Node: Top884 +Node: Introduction1878 +Node: Compiling4207 +Node: Executing6868 +Node: Invoking9232 +Node: Output Options10646 +Node: Analysis Options17270 +Node: Miscellaneous Options20463 +Node: Deprecated Options21624 +Node: Symspecs23694 +Node: Output25515 +Node: Flat Profile26540 +Node: Call Graph31470 +Node: Primary34685 +Node: Callers37217 +Node: Subroutines39325 +Node: Cycles41125 +Node: Line-by-line47890 +Node: Annotated Source51689 +Node: Inaccuracy54550 +Node: Sampling Error54804 +Node: Assumptions57369 +Node: How do I?58837 +Node: Incompatibilities60055 +Node: Details61522 +Node: Implementation61872 +Node: File Format67764 +Node: Internals72019 +Node: Debugging80389 + +End Tag Table diff --git a/gprof/gprof.info-1 b/gprof/gprof.info-1 new file mode 100644 index 00000000000..b631818c52d --- /dev/null +++ b/gprof/gprof.info-1 @@ -0,0 +1,1121 @@ +This is gprof.info, produced by makeinfo version 4.0 from gprof.texi. + +START-INFO-DIR-ENTRY +* gprof: (gprof). Profiling your program's execution +END-INFO-DIR-ENTRY + + This file documents the gprof profiler of the GNU system. + + Copyright (C) 1988, 92, 97, 98, 99, 2000 Free Software Foundation, +Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: gprof.info, Node: Top, Next: Introduction, Up: (dir) + +Profiling a Program: Where Does It Spend Its Time? +************************************************** + + This manual describes the GNU profiler, `gprof', and how you can use +it to determine which parts of a program are taking most of the +execution time. We assume that you know how to write, compile, and +execute programs. GNU `gprof' was written by Jay Fenlason. + +* Menu: + +* Introduction:: What profiling means, and why it is useful. + +* Compiling:: How to compile your program for profiling. +* Executing:: Executing your program to generate profile data +* Invoking:: How to run `gprof', and its options + +* Output:: Interpreting `gprof''s output + +* Inaccuracy:: Potential problems you should be aware of +* How do I?:: Answers to common questions +* Incompatibilities:: (between GNU `gprof' and Unix `gprof'.) +* Details:: Details of how profiling is done + + +File: gprof.info, Node: Introduction, Next: Compiling, Prev: Top, Up: Top + +Introduction to Profiling +************************* + + Profiling allows you to learn where your program spent its time and +which functions called which other functions while it was executing. +This information can show you which pieces of your program are slower +than you expected, and might be candidates for rewriting to make your +program execute faster. It can also tell you which functions are being +called more or less often than you expected. This may help you spot +bugs that had otherwise been unnoticed. + + Since the profiler uses information collected during the actual +execution of your program, it can be used on programs that are too +large or too complex to analyze by reading the source. However, how +your program is run will affect the information that shows up in the +profile data. If you don't use some feature of your program while it +is being profiled, no profile information will be generated for that +feature. + + Profiling has several steps: + + * You must compile and link your program with profiling enabled. + *Note Compiling::. + + * You must execute your program to generate a profile data file. + *Note Executing::. + + * You must run `gprof' to analyze the profile data. *Note + Invoking::. + + The next three chapters explain these steps in greater detail. + + Several forms of output are available from the analysis. + + The "flat profile" shows how much time your program spent in each +function, and how many times that function was called. If you simply +want to know which functions burn most of the cycles, it is stated +concisely here. *Note Flat Profile::. + + The "call graph" shows, for each function, which functions called +it, which other functions it called, and how many times. There is also +an estimate of how much time was spent in the subroutines of each +function. This can suggest places where you might try to eliminate +function calls that use a lot of time. *Note Call Graph::. + + The "annotated source" listing is a copy of the program's source +code, labeled with the number of times each line of the program was +executed. *Note Annotated Source::. + + To better understand how profiling works, you may wish to read a +description of its implementation. *Note Implementation::. + + +File: gprof.info, Node: Compiling, Next: Executing, Prev: Introduction, Up: Top + +Compiling a Program for Profiling +********************************* + + The first step in generating profile information for your program is +to compile and link it with profiling enabled. + + To compile a source file for profiling, specify the `-pg' option when +you run the compiler. (This is in addition to the options you normally +use.) + + To link the program for profiling, if you use a compiler such as `cc' +to do the linking, simply specify `-pg' in addition to your usual +options. The same option, `-pg', alters either compilation or linking +to do what is necessary for profiling. Here are examples: + + cc -g -c myprog.c utils.c -pg + cc -o myprog myprog.o utils.o -pg + + The `-pg' option also works with a command that both compiles and +links: + + cc -o myprog myprog.c utils.c -g -pg + + If you run the linker `ld' directly instead of through a compiler +such as `cc', you may have to specify a profiling startup file +`gcrt0.o' as the first input file instead of the usual startup file +`crt0.o'. In addition, you would probably want to specify the +profiling C library, `libc_p.a', by writing `-lc_p' instead of the +usual `-lc'. This is not absolutely necessary, but doing this gives +you number-of-calls information for standard library functions such as +`read' and `open'. For example: + + ld -o myprog /lib/gcrt0.o myprog.o utils.o -lc_p + + If you compile only some of the modules of the program with `-pg', +you can still profile the program, but you won't get complete +information about the modules that were compiled without `-pg'. The +only information you get for the functions in those modules is the +total time spent in them; there is no record of how many times they +were called, or from where. This will not affect the flat profile +(except that the `calls' field for the functions will be blank), but +will greatly reduce the usefulness of the call graph. + + If you wish to perform line-by-line profiling, you will also need to +specify the `-g' option, instructing the compiler to insert debugging +symbols into the program that match program addresses to source code +lines. *Note Line-by-line::. + + In addition to the `-pg' and `-g' options, you may also wish to +specify the `-a' option when compiling. This will instrument the +program to perform basic-block counting. As the program runs, it will +count how many times it executed each branch of each `if' statement, +each iteration of each `do' loop, etc. This will enable `gprof' to +construct an annotated source code listing showing how many times each +line of code was executed. + + +File: gprof.info, Node: Executing, Next: Invoking, Prev: Compiling, Up: Top + +Executing the Program +********************* + + Once the program is compiled for profiling, you must run it in order +to generate the information that `gprof' needs. Simply run the program +as usual, using the normal arguments, file names, etc. The program +should run normally, producing the same output as usual. It will, +however, run somewhat slower than normal because of the time spent +collecting and the writing the profile data. + + The way you run the program--the arguments and input that you give +it--may have a dramatic effect on what the profile information shows. +The profile data will describe the parts of the program that were +activated for the particular input you use. For example, if the first +command you give to your program is to quit, the profile data will show +the time used in initialization and in cleanup, but not much else. + + Your program will write the profile data into a file called +`gmon.out' just before exiting. If there is already a file called +`gmon.out', its contents are overwritten. There is currently no way to +tell the program to write the profile data under a different name, but +you can rename the file afterward if you are concerned that it may be +overwritten. + + In order to write the `gmon.out' file properly, your program must +exit normally: by returning from `main' or by calling `exit'. Calling +the low-level function `_exit' does not write the profile data, and +neither does abnormal termination due to an unhandled signal. + + The `gmon.out' file is written in the program's _current working +directory_ at the time it exits. This means that if your program calls +`chdir', the `gmon.out' file will be left in the last directory your +program `chdir''d to. If you don't have permission to write in this +directory, the file is not written, and you will get an error message. + + Older versions of the GNU profiling library may also write a file +called `bb.out'. This file, if present, contains an human-readable +listing of the basic-block execution counts. Unfortunately, the +appearance of a human-readable `bb.out' means the basic-block counts +didn't get written into `gmon.out'. The Perl script `bbconv.pl', +included with the `gprof' source distribution, will convert a `bb.out' +file into a format readable by `gprof'. + + +File: gprof.info, Node: Invoking, Next: Output, Prev: Executing, Up: Top + +`gprof' Command Summary +*********************** + + After you have a profile data file `gmon.out', you can run `gprof' +to interpret the information in it. The `gprof' program prints a flat +profile and a call graph on standard output. Typically you would +redirect the output of `gprof' into a file with `>'. + + You run `gprof' like this: + + gprof OPTIONS [EXECUTABLE-FILE [PROFILE-DATA-FILES...]] [> OUTFILE] + +Here square-brackets indicate optional arguments. + + If you omit the executable file name, the file `a.out' is used. If +you give no profile data file name, the file `gmon.out' is used. If +any file is not in the proper format, or if the profile data file does +not appear to belong to the executable file, an error message is +printed. + + You can give more than one profile data file by entering all their +names after the executable file name; then the statistics in all the +data files are summed together. + + The order of these options does not matter. + +* Menu: + +* Output Options:: Controlling `gprof''s output style +* Analysis Options:: Controlling how `gprof' analyses its data +* Miscellaneous Options:: +* Deprecated Options:: Options you no longer need to use, but which + have been retained for compatibility +* Symspecs:: Specifying functions to include or exclude + + +File: gprof.info, Node: Output Options, Next: Analysis Options, Up: Invoking + +Output Options +============== + + These options specify which of several output formats `gprof' should +produce. + + Many of these options take an optional "symspec" to specify +functions to be included or excluded. These options can be specified +multiple times, with different symspecs, to include or exclude sets of +symbols. *Note Symspecs::. + + Specifying any of these options overrides the default (`-p -q'), +which prints a flat profile and call graph analysis for all functions. + +`-A[SYMSPEC]' +`--annotated-source[=SYMSPEC]' + The `-A' option causes `gprof' to print annotated source code. If + SYMSPEC is specified, print output only for matching symbols. + *Note Annotated Source::. + +`-b' +`--brief' + If the `-b' option is given, `gprof' doesn't print the verbose + blurbs that try to explain the meaning of all of the fields in the + tables. This is useful if you intend to print out the output, or + are tired of seeing the blurbs. + +`-C[SYMSPEC]' +`--exec-counts[=SYMSPEC]' + The `-C' option causes `gprof' to print a tally of functions and + the number of times each was called. If SYMSPEC is specified, + print tally only for matching symbols. + + If the profile data file contains basic-block count records, + specifying the `-l' option, along with `-C', will cause basic-block + execution counts to be tallied and displayed. + +`-i' +`--file-info' + The `-i' option causes `gprof' to display summary information + about the profile data file(s) and then exit. The number of + histogram, call graph, and basic-block count records is displayed. + +`-I DIRS' +`--directory-path=DIRS' + The `-I' option specifies a list of search directories in which to + find source files. Environment variable GPROF_PATH can also be + used to convey this information. Used mostly for annotated source + output. + +`-J[SYMSPEC]' +`--no-annotated-source[=SYMSPEC]' + The `-J' option causes `gprof' not to print annotated source code. + If SYMSPEC is specified, `gprof' prints annotated source, but + excludes matching symbols. + +`-L' +`--print-path' + Normally, source filenames are printed with the path component + suppressed. The `-L' option causes `gprof' to print the full + pathname of source filenames, which is determined from symbolic + debugging information in the image file and is relative to the + directory in which the compiler was invoked. + +`-p[SYMSPEC]' +`--flat-profile[=SYMSPEC]' + The `-p' option causes `gprof' to print a flat profile. If + SYMSPEC is specified, print flat profile only for matching symbols. + *Note Flat Profile::. + +`-P[SYMSPEC]' +`--no-flat-profile[=SYMSPEC]' + The `-P' option causes `gprof' to suppress printing a flat profile. + If SYMSPEC is specified, `gprof' prints a flat profile, but + excludes matching symbols. + +`-q[SYMSPEC]' +`--graph[=SYMSPEC]' + The `-q' option causes `gprof' to print the call graph analysis. + If SYMSPEC is specified, print call graph only for matching symbols + and their children. *Note Call Graph::. + +`-Q[SYMSPEC]' +`--no-graph[=SYMSPEC]' + The `-Q' option causes `gprof' to suppress printing the call graph. + If SYMSPEC is specified, `gprof' prints a call graph, but excludes + matching symbols. + +`-y' +`--separate-files' + This option affects annotated source output only. Normally, + `gprof' prints annotated source files to standard-output. If this + option is specified, annotated source for a file named + `path/FILENAME' is generated in the file `FILENAME-ann'. If the + underlying filesystem would truncate `FILENAME-ann' so that it + overwrites the original `FILENAME', `gprof' generates annotated + source in the file `FILENAME.ann' instead (if the original file + name has an extension, that extension is _replaced_ with `.ann'). + +`-Z[SYMSPEC]' +`--no-exec-counts[=SYMSPEC]' + The `-Z' option causes `gprof' not to print a tally of functions + and the number of times each was called. If SYMSPEC is specified, + print tally, but exclude matching symbols. + +`--function-ordering' + The `--function-ordering' option causes `gprof' to print a + suggested function ordering for the program based on profiling + data. This option suggests an ordering which may improve paging, + tlb and cache behavior for the program on systems which support + arbitrary ordering of functions in an executable. + + The exact details of how to force the linker to place functions in + a particular order is system dependent and out of the scope of this + manual. + +`--file-ordering MAP_FILE' + The `--file-ordering' option causes `gprof' to print a suggested + .o link line ordering for the program based on profiling data. + This option suggests an ordering which may improve paging, tlb and + cache behavior for the program on systems which do not support + arbitrary ordering of functions in an executable. + + Use of the `-a' argument is highly recommended with this option. + + The MAP_FILE argument is a pathname to a file which provides + function name to object file mappings. The format of the file is + similar to the output of the program `nm'. + + c-parse.o:00000000 T yyparse + c-parse.o:00000004 C yyerrflag + c-lang.o:00000000 T maybe_objc_method_name + c-lang.o:00000000 T print_lang_statistics + c-lang.o:00000000 T recognize_objc_keyword + c-decl.o:00000000 T print_lang_identifier + c-decl.o:00000000 T print_lang_type + ... + + To create a MAP_FILE with GNU `nm', type a command like `nm + --extern-only --defined-only -v --print-file-name program-name'. + +`-T' +`--traditional' + The `-T' option causes `gprof' to print its output in + "traditional" BSD style. + +`-w WIDTH' +`--width=WIDTH' + Sets width of output lines to WIDTH. Currently only used when + printing the function index at the bottom of the call graph. + +`-x' +`--all-lines' + This option affects annotated source output only. By default, + only the lines at the beginning of a basic-block are annotated. + If this option is specified, every line in a basic-block is + annotated by repeating the annotation for the first line. This + behavior is similar to `tcov''s `-a'. + +`--demangle' +`--no-demangle' + These options control whether C++ symbol names should be demangled + when printing output. The default is to demangle symbols. The + `--no-demangle' option may be used to turn off demangling. + + +File: gprof.info, Node: Analysis Options, Next: Miscellaneous Options, Prev: Output Options, Up: Invoking + +Analysis Options +================ + +`-a' +`--no-static' + The `-a' option causes `gprof' to suppress the printing of + statically declared (private) functions. (These are functions + whose names are not listed as global, and which are not visible + outside the file/function/block where they were defined.) Time + spent in these functions, calls to/from them, etc, will all be + attributed to the function that was loaded directly before it in + the executable file. This option affects both the flat profile + and the call graph. + +`-c' +`--static-call-graph' + The `-c' option causes the call graph of the program to be + augmented by a heuristic which examines the text space of the + object file and identifies function calls in the binary machine + code. Since normal call graph records are only generated when + functions are entered, this option identifies children that could + have been called, but never were. Calls to functions that were + not compiled with profiling enabled are also identified, but only + if symbol table entries are present for them. Calls to dynamic + library routines are typically _not_ found by this option. + Parents or children identified via this heuristic are indicated in + the call graph with call counts of `0'. + +`-D' +`--ignore-non-functions' + The `-D' option causes `gprof' to ignore symbols which are not + known to be functions. This option will give more accurate + profile data on systems where it is supported (Solaris and HPUX for + example). + +`-k FROM/TO' + The `-k' option allows you to delete from the call graph any arcs + from symbols matching symspec FROM to those matching symspec TO. + +`-l' +`--line' + The `-l' option enables line-by-line profiling, which causes + histogram hits to be charged to individual source code lines, + instead of functions. If the program was compiled with + basic-block counting enabled, this option will also identify how + many times each line of code was executed. While line-by-line + profiling can help isolate where in a large function a program is + spending its time, it also significantly increases the running + time of `gprof', and magnifies statistical inaccuracies. *Note + Sampling Error::. + +`-m NUM' +`--min-count=NUM' + This option affects execution count output only. Symbols that are + executed less than NUM times are suppressed. + +`-n[SYMSPEC]' +`--time[=SYMSPEC]' + The `-n' option causes `gprof', in its call graph analysis, to + only propagate times for symbols matching SYMSPEC. + +`-N[SYMSPEC]' +`--no-time[=SYMSPEC]' + The `-n' option causes `gprof', in its call graph analysis, not to + propagate times for symbols matching SYMSPEC. + +`-z' +`--display-unused-functions' + If you give the `-z' option, `gprof' will mention all functions in + the flat profile, even those that were never called, and that had + no time spent in them. This is useful in conjunction with the + `-c' option for discovering which routines were never called. + + +File: gprof.info, Node: Miscellaneous Options, Next: Deprecated Options, Prev: Analysis Options, Up: Invoking + +Miscellaneous Options +===================== + +`-d[NUM]' +`--debug[=NUM]' + The `-d NUM' option specifies debugging options. If NUM is not + specified, enable all debugging. *Note Debugging::. + +`-ONAME' +`--file-format=NAME' + Selects the format of the profile data files. Recognized formats + are `auto' (the default), `bsd', `4.4bsd', `magic', and `prof' + (not yet supported). + +`-s' +`--sum' + The `-s' option causes `gprof' to summarize the information in the + profile data files it read in, and write out a profile data file + called `gmon.sum', which contains all the information from the + profile data files that `gprof' read in. The file `gmon.sum' may + be one of the specified input files; the effect of this is to + merge the data in the other input files into `gmon.sum'. + + Eventually you can run `gprof' again without `-s' to analyze the + cumulative data in the file `gmon.sum'. + +`-v' +`--version' + The `-v' flag causes `gprof' to print the current version number, + and then exit. + + +File: gprof.info, Node: Deprecated Options, Next: Symspecs, Prev: Miscellaneous Options, Up: Invoking + +Deprecated Options +================== + + These options have been replaced with newer versions that use + symspecs. + +`-e FUNCTION_NAME' + The `-e FUNCTION' option tells `gprof' to not print information + about the function FUNCTION_NAME (and its children...) in the call + graph. The function will still be listed as a child of any + functions that call it, but its index number will be shown as + `[not printed]'. More than one `-e' option may be given; only one + FUNCTION_NAME may be indicated with each `-e' option. + +`-E FUNCTION_NAME' + The `-E FUNCTION' option works like the `-e' option, but time + spent in the function (and children who were not called from + anywhere else), will not be used to compute the + percentages-of-time for the call graph. More than one `-E' option + may be given; only one FUNCTION_NAME may be indicated with each + `-E' option. + +`-f FUNCTION_NAME' + The `-f FUNCTION' option causes `gprof' to limit the call graph to + the function FUNCTION_NAME and its children (and their + children...). More than one `-f' option may be given; only one + FUNCTION_NAME may be indicated with each `-f' option. + +`-F FUNCTION_NAME' + The `-F FUNCTION' option works like the `-f' option, but only time + spent in the function and its children (and their children...) + will be used to determine total-time and percentages-of-time for + the call graph. More than one `-F' option may be given; only one + FUNCTION_NAME may be indicated with each `-F' option. The `-F' + option overrides the `-E' option. + + Note that only one function can be specified with each `-e', `-E', +`-f' or `-F' option. To specify more than one function, use multiple +options. For example, this command: + + gprof -e boring -f foo -f bar myprogram > gprof.output + +lists in the call graph all functions that were reached from either +`foo' or `bar' and were not reachable from `boring'. + + +File: gprof.info, Node: Symspecs, Prev: Deprecated Options, Up: Invoking + +Symspecs +======== + + Many of the output options allow functions to be included or excluded +using "symspecs" (symbol specifications), which observe the following +syntax: + + filename_containing_a_dot + | funcname_not_containing_a_dot + | linenumber + | ( [ any_filename ] `:' ( any_funcname | linenumber ) ) + + Here are some sample symspecs: + +`main.c' + Selects everything in file `main.c'--the dot in the string tells + `gprof' to interpret the string as a filename, rather than as a + function name. To select a file whose name does not contain a + dot, a trailing colon should be specified. For example, `odd:' is + interpreted as the file named `odd'. + +`main' + Selects all functions named `main'. + + Note that there may be multiple instances of the same function name + because some of the definitions may be local (i.e., static). + Unless a function name is unique in a program, you must use the + colon notation explained below to specify a function from a + specific source file. + + Sometimes, function names contain dots. In such cases, it is + necessary to add a leading colon to the name. For example, + `:.mul' selects function `.mul'. + + In some object file formats, symbols have a leading underscore. + `gprof' will normally not print these underscores. When you name a + symbol in a symspec, you should type it exactly as `gprof' prints + it in its output. For example, if the compiler produces a symbol + `_main' from your `main' function, `gprof' still prints it as + `main' in its output, so you should use `main' in symspecs. + +`main.c:main' + Selects function `main' in file `main.c'. + +`main.c:134' + Selects line 134 in file `main.c'. + + +File: gprof.info, Node: Output, Next: Inaccuracy, Prev: Invoking, Up: Top + +Interpreting `gprof''s Output +***************************** + + `gprof' can produce several different output styles, the most +important of which are described below. The simplest output styles +(file information, execution count, and function and file ordering) are +not described here, but are documented with the respective options that +trigger them. *Note Output Options::. + +* Menu: + +* Flat Profile:: The flat profile shows how much time was spent + executing directly in each function. +* Call Graph:: The call graph shows which functions called which + others, and how much time each function used + when its subroutine calls are included. +* Line-by-line:: `gprof' can analyze individual source code lines +* Annotated Source:: The annotated source listing displays source code + labeled with execution counts + + +File: gprof.info, Node: Flat Profile, Next: Call Graph, Up: Output + +The Flat Profile +================ + + The "flat profile" shows the total amount of time your program spent +executing each function. Unless the `-z' option is given, functions +with no apparent time spent in them, and no apparent calls to them, are +not mentioned. Note that if a function was not compiled for profiling, +and didn't run long enough to show up on the program counter histogram, +it will be indistinguishable from a function that was never called. + + This is part of a flat profile for a small program: + + Flat profile: + + Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls ms/call ms/call name + 33.34 0.02 0.02 7208 0.00 0.00 open + 16.67 0.03 0.01 244 0.04 0.12 offtime + 16.67 0.04 0.01 8 1.25 1.25 memccpy + 16.67 0.05 0.01 7 1.43 1.43 write + 16.67 0.06 0.01 mcount + 0.00 0.06 0.00 236 0.00 0.00 tzset + 0.00 0.06 0.00 192 0.00 0.00 tolower + 0.00 0.06 0.00 47 0.00 0.00 strlen + 0.00 0.06 0.00 45 0.00 0.00 strchr + 0.00 0.06 0.00 1 0.00 50.00 main + 0.00 0.06 0.00 1 0.00 0.00 memcpy + 0.00 0.06 0.00 1 0.00 10.11 print + 0.00 0.06 0.00 1 0.00 0.00 profil + 0.00 0.06 0.00 1 0.00 50.00 report + ... + +The functions are sorted by first by decreasing run-time spent in them, +then by decreasing number of calls, then alphabetically by name. The +functions `mcount' and `profil' are part of the profiling apparatus and +appear in every flat profile; their time gives a measure of the amount +of overhead due to profiling. + + Just before the column headers, a statement appears indicating how +much time each sample counted as. This "sampling period" estimates the +margin of error in each of the time figures. A time figure that is not +much larger than this is not reliable. In this example, each sample +counted as 0.01 seconds, suggesting a 100 Hz sampling rate. The +program's total execution time was 0.06 seconds, as indicated by the +`cumulative seconds' field. Since each sample counted for 0.01 +seconds, this means only six samples were taken during the run. Two of +the samples occurred while the program was in the `open' function, as +indicated by the `self seconds' field. Each of the other four samples +occurred one each in `offtime', `memccpy', `write', and `mcount'. +Since only six samples were taken, none of these values can be regarded +as particularly reliable. In another run, the `self seconds' field for +`mcount' might well be `0.00' or `0.02'. *Note Sampling Error::, for a +complete discussion. + + The remaining functions in the listing (those whose `self seconds' +field is `0.00') didn't appear in the histogram samples at all. +However, the call graph indicated that they were called, so therefore +they are listed, sorted in decreasing order by the `calls' field. +Clearly some time was spent executing these functions, but the paucity +of histogram samples prevents any determination of how much time each +took. + + Here is what the fields in each line mean: + +`% time' + This is the percentage of the total execution time your program + spent in this function. These should all add up to 100%. + +`cumulative seconds' + This is the cumulative total number of seconds the computer spent + executing this functions, plus the time spent in all the functions + above this one in this table. + +`self seconds' + This is the number of seconds accounted for by this function alone. + The flat profile listing is sorted first by this number. + +`calls' + This is the total number of times the function was called. If the + function was never called, or the number of times it was called + cannot be determined (probably because the function was not + compiled with profiling enabled), the "calls" field is blank. + +`self ms/call' + This represents the average number of milliseconds spent in this + function per call, if this function is profiled. Otherwise, this + field is blank for this function. + +`total ms/call' + This represents the average number of milliseconds spent in this + function and its descendants per call, if this function is + profiled. Otherwise, this field is blank for this function. This + is the only field in the flat profile that uses call graph + analysis. + +`name' + This is the name of the function. The flat profile is sorted by + this field alphabetically after the "self seconds" and "calls" + fields are sorted. + + +File: gprof.info, Node: Call Graph, Next: Line-by-line, Prev: Flat Profile, Up: Output + +The Call Graph +============== + + The "call graph" shows how much time was spent in each function and +its children. From this information, you can find functions that, +while they themselves may not have used much time, called other +functions that did use unusual amounts of time. + + Here is a sample call from a small program. This call came from the +same `gprof' run as the flat profile example in the previous chapter. + + granularity: each sample hit covers 2 byte(s) for 20.00% of 0.05 seconds + + index % time self children called name + <spontaneous> + [1] 100.0 0.00 0.05 start [1] + 0.00 0.05 1/1 main [2] + 0.00 0.00 1/2 on_exit [28] + 0.00 0.00 1/1 exit [59] + ----------------------------------------------- + 0.00 0.05 1/1 start [1] + [2] 100.0 0.00 0.05 1 main [2] + 0.00 0.05 1/1 report [3] + ----------------------------------------------- + 0.00 0.05 1/1 main [2] + [3] 100.0 0.00 0.05 1 report [3] + 0.00 0.03 8/8 timelocal [6] + 0.00 0.01 1/1 print [9] + 0.00 0.01 9/9 fgets [12] + 0.00 0.00 12/34 strncmp <cycle 1> [40] + 0.00 0.00 8/8 lookup [20] + 0.00 0.00 1/1 fopen [21] + 0.00 0.00 8/8 chewtime [24] + 0.00 0.00 8/16 skipspace [44] + ----------------------------------------------- + [4] 59.8 0.01 0.02 8+472 <cycle 2 as a whole> [4] + 0.01 0.02 244+260 offtime <cycle 2> [7] + 0.00 0.00 236+1 tzset <cycle 2> [26] + ----------------------------------------------- + + The lines full of dashes divide this table into "entries", one for +each function. Each entry has one or more lines. + + In each entry, the primary line is the one that starts with an index +number in square brackets. The end of this line says which function +the entry is for. The preceding lines in the entry describe the +callers of this function and the following lines describe its +subroutines (also called "children" when we speak of the call graph). + + The entries are sorted by time spent in the function and its +subroutines. + + The internal profiling function `mcount' (*note Flat Profile::) is +never mentioned in the call graph. + +* Menu: + +* Primary:: Details of the primary line's contents. +* Callers:: Details of caller-lines' contents. +* Subroutines:: Details of subroutine-lines' contents. +* Cycles:: When there are cycles of recursion, + such as `a' calls `b' calls `a'... + + +File: gprof.info, Node: Primary, Next: Callers, Up: Call Graph + +The Primary Line +---------------- + + The "primary line" in a call graph entry is the line that describes +the function which the entry is about and gives the overall statistics +for this function. + + For reference, we repeat the primary line from the entry for function +`report' in our main example, together with the heading line that shows +the names of the fields: + + index % time self children called name + ... + [3] 100.0 0.00 0.05 1 report [3] + + Here is what the fields in the primary line mean: + +`index' + Entries are numbered with consecutive integers. Each function + therefore has an index number, which appears at the beginning of + its primary line. + + Each cross-reference to a function, as a caller or subroutine of + another, gives its index number as well as its name. The index + number guides you if you wish to look for the entry for that + function. + +`% time' + This is the percentage of the total time that was spent in this + function, including time spent in subroutines called from this + function. + + The time spent in this function is counted again for the callers of + this function. Therefore, adding up these percentages is + meaningless. + +`self' + This is the total amount of time spent in this function. This + should be identical to the number printed in the `seconds' field + for this function in the flat profile. + +`children' + This is the total amount of time spent in the subroutine calls + made by this function. This should be equal to the sum of all the + `self' and `children' entries of the children listed directly + below this function. + +`called' + This is the number of times the function was called. + + If the function called itself recursively, there are two numbers, + separated by a `+'. The first number counts non-recursive calls, + and the second counts recursive calls. + + In the example above, the function `report' was called once from + `main'. + +`name' + This is the name of the current function. The index number is + repeated after it. + + If the function is part of a cycle of recursion, the cycle number + is printed between the function's name and the index number (*note + Cycles::). For example, if function `gnurr' is part of cycle + number one, and has index number twelve, its primary line would be + end like this: + + gnurr <cycle 1> [12] + + +File: gprof.info, Node: Callers, Next: Subroutines, Prev: Primary, Up: Call Graph + +Lines for a Function's Callers +------------------------------ + + A function's entry has a line for each function it was called by. +These lines' fields correspond to the fields of the primary line, but +their meanings are different because of the difference in context. + + For reference, we repeat two lines from the entry for the function +`report', the primary line and one caller-line preceding it, together +with the heading line that shows the names of the fields: + + index % time self children called name + ... + 0.00 0.05 1/1 main [2] + [3] 100.0 0.00 0.05 1 report [3] + + Here are the meanings of the fields in the caller-line for `report' +called from `main': + +`self' + An estimate of the amount of time spent in `report' itself when it + was called from `main'. + +`children' + An estimate of the amount of time spent in subroutines of `report' + when `report' was called from `main'. + + The sum of the `self' and `children' fields is an estimate of the + amount of time spent within calls to `report' from `main'. + +`called' + Two numbers: the number of times `report' was called from `main', + followed by the total number of non-recursive calls to `report' + from all its callers. + +`name and index number' + The name of the caller of `report' to which this line applies, + followed by the caller's index number. + + Not all functions have entries in the call graph; some options to + `gprof' request the omission of certain functions. When a caller + has no entry of its own, it still has caller-lines in the entries + of the functions it calls. + + If the caller is part of a recursion cycle, the cycle number is + printed between the name and the index number. + + If the identity of the callers of a function cannot be determined, a +dummy caller-line is printed which has `<spontaneous>' as the "caller's +name" and all other fields blank. This can happen for signal handlers. + + +File: gprof.info, Node: Subroutines, Next: Cycles, Prev: Callers, Up: Call Graph + +Lines for a Function's Subroutines +---------------------------------- + + A function's entry has a line for each of its subroutines--in other +words, a line for each other function that it called. These lines' +fields correspond to the fields of the primary line, but their meanings +are different because of the difference in context. + + For reference, we repeat two lines from the entry for the function +`main', the primary line and a line for a subroutine, together with the +heading line that shows the names of the fields: + + index % time self children called name + ... + [2] 100.0 0.00 0.05 1 main [2] + 0.00 0.05 1/1 report [3] + + Here are the meanings of the fields in the subroutine-line for `main' +calling `report': + +`self' + An estimate of the amount of time spent directly within `report' + when `report' was called from `main'. + +`children' + An estimate of the amount of time spent in subroutines of `report' + when `report' was called from `main'. + + The sum of the `self' and `children' fields is an estimate of the + total time spent in calls to `report' from `main'. + +`called' + Two numbers, the number of calls to `report' from `main' followed + by the total number of non-recursive calls to `report'. This + ratio is used to determine how much of `report''s `self' and + `children' time gets credited to `main'. *Note Assumptions::. + +`name' + The name of the subroutine of `main' to which this line applies, + followed by the subroutine's index number. + + If the caller is part of a recursion cycle, the cycle number is + printed between the name and the index number. + + +File: gprof.info, Node: Cycles, Prev: Subroutines, Up: Call Graph + +How Mutually Recursive Functions Are Described +---------------------------------------------- + + The graph may be complicated by the presence of "cycles of +recursion" in the call graph. A cycle exists if a function calls +another function that (directly or indirectly) calls (or appears to +call) the original function. For example: if `a' calls `b', and `b' +calls `a', then `a' and `b' form a cycle. + + Whenever there are call paths both ways between a pair of functions, +they belong to the same cycle. If `a' and `b' call each other and `b' +and `c' call each other, all three make one cycle. Note that even if +`b' only calls `a' if it was not called from `a', `gprof' cannot +determine this, so `a' and `b' are still considered a cycle. + + The cycles are numbered with consecutive integers. When a function +belongs to a cycle, each time the function name appears in the call +graph it is followed by `<cycle NUMBER>'. + + The reason cycles matter is that they make the time values in the +call graph paradoxical. The "time spent in children" of `a' should +include the time spent in its subroutine `b' and in `b''s +subroutines--but one of `b''s subroutines is `a'! How much of `a''s +time should be included in the children of `a', when `a' is indirectly +recursive? + + The way `gprof' resolves this paradox is by creating a single entry +for the cycle as a whole. The primary line of this entry describes the +total time spent directly in the functions of the cycle. The +"subroutines" of the cycle are the individual functions of the cycle, +and all other functions that were called directly by them. The +"callers" of the cycle are the functions, outside the cycle, that +called functions in the cycle. + + Here is an example portion of a call graph which shows a cycle +containing functions `a' and `b'. The cycle was entered by a call to +`a' from `main'; both `a' and `b' called `c'. + + index % time self children called name + ---------------------------------------- + 1.77 0 1/1 main [2] + [3] 91.71 1.77 0 1+5 <cycle 1 as a whole> [3] + 1.02 0 3 b <cycle 1> [4] + 0.75 0 2 a <cycle 1> [5] + ---------------------------------------- + 3 a <cycle 1> [5] + [4] 52.85 1.02 0 0 b <cycle 1> [4] + 2 a <cycle 1> [5] + 0 0 3/6 c [6] + ---------------------------------------- + 1.77 0 1/1 main [2] + 2 b <cycle 1> [4] + [5] 38.86 0.75 0 1 a <cycle 1> [5] + 3 b <cycle 1> [4] + 0 0 3/6 c [6] + ---------------------------------------- + +(The entire call graph for this program contains in addition an entry +for `main', which calls `a', and an entry for `c', with callers `a' and +`b'.) + + index % time self children called name + <spontaneous> + [1] 100.00 0 1.93 0 start [1] + 0.16 1.77 1/1 main [2] + ---------------------------------------- + 0.16 1.77 1/1 start [1] + [2] 100.00 0.16 1.77 1 main [2] + 1.77 0 1/1 a <cycle 1> [5] + ---------------------------------------- + 1.77 0 1/1 main [2] + [3] 91.71 1.77 0 1+5 <cycle 1 as a whole> [3] + 1.02 0 3 b <cycle 1> [4] + 0.75 0 2 a <cycle 1> [5] + 0 0 6/6 c [6] + ---------------------------------------- + 3 a <cycle 1> [5] + [4] 52.85 1.02 0 0 b <cycle 1> [4] + 2 a <cycle 1> [5] + 0 0 3/6 c [6] + ---------------------------------------- + 1.77 0 1/1 main [2] + 2 b <cycle 1> [4] + [5] 38.86 0.75 0 1 a <cycle 1> [5] + 3 b <cycle 1> [4] + 0 0 3/6 c [6] + ---------------------------------------- + 0 0 3/6 b <cycle 1> [4] + 0 0 3/6 a <cycle 1> [5] + [6] 0.00 0 0 6 c [6] + ---------------------------------------- + + The `self' field of the cycle's primary line is the total time spent +in all the functions of the cycle. It equals the sum of the `self' +fields for the individual functions in the cycle, found in the entry in +the subroutine lines for these functions. + + The `children' fields of the cycle's primary line and subroutine +lines count only subroutines outside the cycle. Even though `a' calls +`b', the time spent in those calls to `b' is not counted in `a''s +`children' time. Thus, we do not encounter the problem of what to do +when the time in those calls to `b' includes indirect recursive calls +back to `a'. + + The `children' field of a caller-line in the cycle's entry estimates +the amount of time spent _in the whole cycle_, and its other +subroutines, on the times when that caller called a function in the +cycle. + + The `calls' field in the primary line for the cycle has two numbers: +first, the number of times functions in the cycle were called by +functions outside the cycle; second, the number of times they were +called by functions in the cycle (including times when a function in +the cycle calls itself). This is a generalization of the usual split +into non-recursive and recursive calls. + + The `calls' field of a subroutine-line for a cycle member in the +cycle's entry says how many time that function was called from +functions in the cycle. The total of all these is the second number in +the primary line's `calls' field. + + In the individual entry for a function in a cycle, the other +functions in the same cycle can appear as subroutines and as callers. +These lines show how many times each function in the cycle called or +was called from each other function in the cycle. The `self' and +`children' fields in these lines are blank because of the difficulty of +defining meanings for them when recursion is going on. + diff --git a/gprof/gprof.info-2 b/gprof/gprof.info-2 new file mode 100644 index 00000000000..6cdfda58698 --- /dev/null +++ b/gprof/gprof.info-2 @@ -0,0 +1,760 @@ +This is gprof.info, produced by makeinfo version 4.0 from gprof.texi. + +START-INFO-DIR-ENTRY +* gprof: (gprof). Profiling your program's execution +END-INFO-DIR-ENTRY + + This file documents the gprof profiler of the GNU system. + + Copyright (C) 1988, 92, 97, 98, 99, 2000 Free Software Foundation, +Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: gprof.info, Node: Line-by-line, Next: Annotated Source, Prev: Call Graph, Up: Output + +Line-by-line Profiling +====================== + + `gprof''s `-l' option causes the program to perform "line-by-line" +profiling. In this mode, histogram samples are assigned not to +functions, but to individual lines of source code. The program usually +must be compiled with a `-g' option, in addition to `-pg', in order to +generate debugging symbols for tracking source code lines. + + The flat profile is the most useful output table in line-by-line +mode. The call graph isn't as useful as normal, since the current +version of `gprof' does not propagate call graph arcs from source code +lines to the enclosing function. The call graph does, however, show +each line of code that called each function, along with a count. + + Here is a section of `gprof''s output, without line-by-line +profiling. Note that `ct_init' accounted for four histogram hits, and +13327 calls to `init_block'. + + Flat profile: + + Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls us/call us/call name + 30.77 0.13 0.04 6335 6.31 6.31 ct_init + + + Call graph (explanation follows) + + + granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds + + index % time self children called name + + 0.00 0.00 1/13496 name_too_long + 0.00 0.00 40/13496 deflate + 0.00 0.00 128/13496 deflate_fast + 0.00 0.00 13327/13496 ct_init + [7] 0.0 0.00 0.00 13496 init_block + + Now let's look at some of `gprof''s output from the same program run, +this time with line-by-line profiling enabled. Note that `ct_init''s +four histogram hits are broken down into four lines of source code - +one hit occurred on each of lines 349, 351, 382 and 385. In the call +graph, note how `ct_init''s 13327 calls to `init_block' are broken down +into one call from line 396, 3071 calls from line 384, 3730 calls from +line 385, and 6525 calls from 387. + + Flat profile: + + Each sample counts as 0.01 seconds. + % cumulative self + time seconds seconds calls name + 7.69 0.10 0.01 ct_init (trees.c:349) + 7.69 0.11 0.01 ct_init (trees.c:351) + 7.69 0.12 0.01 ct_init (trees.c:382) + 7.69 0.13 0.01 ct_init (trees.c:385) + + + Call graph (explanation follows) + + + granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds + + % time self children called name + + 0.00 0.00 1/13496 name_too_long (gzip.c:1440) + 0.00 0.00 1/13496 deflate (deflate.c:763) + 0.00 0.00 1/13496 ct_init (trees.c:396) + 0.00 0.00 2/13496 deflate (deflate.c:727) + 0.00 0.00 4/13496 deflate (deflate.c:686) + 0.00 0.00 5/13496 deflate (deflate.c:675) + 0.00 0.00 12/13496 deflate (deflate.c:679) + 0.00 0.00 16/13496 deflate (deflate.c:730) + 0.00 0.00 128/13496 deflate_fast (deflate.c:654) + 0.00 0.00 3071/13496 ct_init (trees.c:384) + 0.00 0.00 3730/13496 ct_init (trees.c:385) + 0.00 0.00 6525/13496 ct_init (trees.c:387) + [6] 0.0 0.00 0.00 13496 init_block (trees.c:408) + + +File: gprof.info, Node: Annotated Source, Prev: Line-by-line, Up: Output + +The Annotated Source Listing +============================ + + `gprof''s `-A' option triggers an annotated source listing, which +lists the program's source code, each function labeled with the number +of times it was called. You may also need to specify the `-I' option, +if `gprof' can't find the source code files. + + Compiling with `gcc ... -g -pg -a' augments your program with +basic-block counting code, in addition to function counting code. This +enables `gprof' to determine how many times each line of code was +executed. For example, consider the following function, taken from +gzip, with line numbers added: + + 1 ulg updcrc(s, n) + 2 uch *s; + 3 unsigned n; + 4 { + 5 register ulg c; + 6 + 7 static ulg crc = (ulg)0xffffffffL; + 8 + 9 if (s == NULL) { + 10 c = 0xffffffffL; + 11 } else { + 12 c = crc; + 13 if (n) do { + 14 c = crc_32_tab[...]; + 15 } while (--n); + 16 } + 17 crc = c; + 18 return c ^ 0xffffffffL; + 19 } + + `updcrc' has at least five basic-blocks. One is the function +itself. The `if' statement on line 9 generates two more basic-blocks, +one for each branch of the `if'. A fourth basic-block results from the +`if' on line 13, and the contents of the `do' loop form the fifth +basic-block. The compiler may also generate additional basic-blocks to +handle various special cases. + + A program augmented for basic-block counting can be analyzed with +`gprof -l -A'. I also suggest use of the `-x' option, which ensures +that each line of code is labeled at least once. Here is `updcrc''s +annotated source listing for a sample `gzip' run: + + ulg updcrc(s, n) + uch *s; + unsigned n; + 2 ->{ + register ulg c; + + static ulg crc = (ulg)0xffffffffL; + + 2 -> if (s == NULL) { + 1 -> c = 0xffffffffL; + 1 -> } else { + 1 -> c = crc; + 1 -> if (n) do { + 26312 -> c = crc_32_tab[...]; + 26312,1,26311 -> } while (--n); + } + 2 -> crc = c; + 2 -> return c ^ 0xffffffffL; + 2 ->} + + In this example, the function was called twice, passing once through +each branch of the `if' statement. The body of the `do' loop was +executed a total of 26312 times. Note how the `while' statement is +annotated. It began execution 26312 times, once for each iteration +through the loop. One of those times (the last time) it exited, while +it branched back to the beginning of the loop 26311 times. + + +File: gprof.info, Node: Inaccuracy, Next: How do I?, Prev: Output, Up: Top + +Inaccuracy of `gprof' Output +**************************** + +* Menu: + +* Sampling Error:: Statistical margins of error +* Assumptions:: Estimating children times + + +File: gprof.info, Node: Sampling Error, Next: Assumptions, Up: Inaccuracy + +Statistical Sampling Error +========================== + + The run-time figures that `gprof' gives you are based on a sampling +process, so they are subject to statistical inaccuracy. If a function +runs only a small amount of time, so that on the average the sampling +process ought to catch that function in the act only once, there is a +pretty good chance it will actually find that function zero times, or +twice. + + By contrast, the number-of-calls and basic-block figures are derived +by counting, not sampling. They are completely accurate and will not +vary from run to run if your program is deterministic. + + The "sampling period" that is printed at the beginning of the flat +profile says how often samples are taken. The rule of thumb is that a +run-time figure is accurate if it is considerably bigger than the +sampling period. + + The actual amount of error can be predicted. For N samples, the +_expected_ error is the square-root of N. For example, if the sampling +period is 0.01 seconds and `foo''s run-time is 1 second, N is 100 +samples (1 second/0.01 seconds), sqrt(N) is 10 samples, so the expected +error in `foo''s run-time is 0.1 seconds (10*0.01 seconds), or ten +percent of the observed value. Again, if the sampling period is 0.01 +seconds and `bar''s run-time is 100 seconds, N is 10000 samples, +sqrt(N) is 100 samples, so the expected error in `bar''s run-time is 1 +second, or one percent of the observed value. It is likely to vary +this much _on the average_ from one profiling run to the next. +(_Sometimes_ it will vary more.) + + This does not mean that a small run-time figure is devoid of +information. If the program's _total_ run-time is large, a small +run-time for one function does tell you that that function used an +insignificant fraction of the whole program's time. Usually this means +it is not worth optimizing. + + One way to get more accuracy is to give your program more (but +similar) input data so it will take longer. Another way is to combine +the data from several runs, using the `-s' option of `gprof'. Here is +how: + + 1. Run your program once. + + 2. Issue the command `mv gmon.out gmon.sum'. + + 3. Run your program again, the same as before. + + 4. Merge the new data in `gmon.out' into `gmon.sum' with this command: + + gprof -s EXECUTABLE-FILE gmon.out gmon.sum + + 5. Repeat the last two steps as often as you wish. + + 6. Analyze the cumulative data using this command: + + gprof EXECUTABLE-FILE gmon.sum > OUTPUT-FILE + + +File: gprof.info, Node: Assumptions, Prev: Sampling Error, Up: Inaccuracy + +Estimating `children' Times +=========================== + + Some of the figures in the call graph are estimates--for example, the +`children' time values and all the the time figures in caller and +subroutine lines. + + There is no direct information about these measurements in the +profile data itself. Instead, `gprof' estimates them by making an +assumption about your program that might or might not be true. + + The assumption made is that the average time spent in each call to +any function `foo' is not correlated with who called `foo'. If `foo' +used 5 seconds in all, and 2/5 of the calls to `foo' came from `a', +then `foo' contributes 2 seconds to `a''s `children' time, by +assumption. + + This assumption is usually true enough, but for some programs it is +far from true. Suppose that `foo' returns very quickly when its +argument is zero; suppose that `a' always passes zero as an argument, +while other callers of `foo' pass other arguments. In this program, +all the time spent in `foo' is in the calls from callers other than `a'. +But `gprof' has no way of knowing this; it will blindly and incorrectly +charge 2 seconds of time in `foo' to the children of `a'. + + We hope some day to put more complete data into `gmon.out', so that +this assumption is no longer needed, if we can figure out how. For the +nonce, the estimated figures are usually more useful than misleading. + + +File: gprof.info, Node: How do I?, Next: Incompatibilities, Prev: Inaccuracy, Up: Top + +Answers to Common Questions +*************************** + +How do I find which lines in my program were executed the most times? + Compile your program with basic-block counting enabled, run it, + then use the following pipeline: + + gprof -l -C OBJFILE | sort -k 3 -n -r + + This listing will show you the lines in your code executed most + often, but not necessarily those that consumed the most time. + +How do I find which lines in my program called a particular function? + Use `gprof -l' and lookup the function in the call graph. The + callers will be broken down by function and line number. + +How do I analyze a program that runs for less than a second? + Try using a shell script like this one: + + for i in `seq 1 100`; do + fastprog + mv gmon.out gmon.out.$i + done + + gprof -s fastprog gmon.out.* + + gprof fastprog gmon.sum + + If your program is completely deterministic, all the call counts + will be simple multiples of 100 (i.e. a function called once in + each run will appear with a call count of 100). + + +File: gprof.info, Node: Incompatibilities, Next: Details, Prev: How do I?, Up: Top + +Incompatibilities with Unix `gprof' +*********************************** + + GNU `gprof' and Berkeley Unix `gprof' use the same data file +`gmon.out', and provide essentially the same information. But there +are a few differences. + + * GNU `gprof' uses a new, generalized file format with support for + basic-block execution counts and non-realtime histograms. A magic + cookie and version number allows `gprof' to easily identify new + style files. Old BSD-style files can still be read. *Note File + Format::. + + * For a recursive function, Unix `gprof' lists the function as a + parent and as a child, with a `calls' field that lists the number + of recursive calls. GNU `gprof' omits these lines and puts the + number of recursive calls in the primary line. + + * When a function is suppressed from the call graph with `-e', GNU + `gprof' still lists it as a subroutine of functions that call it. + + * GNU `gprof' accepts the `-k' with its argument in the form + `from/to', instead of `from to'. + + * In the annotated source listing, if there are multiple basic + blocks on the same line, GNU `gprof' prints all of their counts, + separated by commas. + + * The blurbs, field widths, and output formats are different. GNU + `gprof' prints blurbs after the tables, so that you can see the + tables without skipping the blurbs. + + +File: gprof.info, Node: Details, Prev: Incompatibilities, Up: Top + +Details of Profiling +******************** + +* Menu: + +* Implementation:: How a program collects profiling information +* File Format:: Format of `gmon.out' files +* Internals:: `gprof''s internal operation +* Debugging:: Using `gprof''s `-d' option + + +File: gprof.info, Node: Implementation, Next: File Format, Up: Details + +Implementation of Profiling +=========================== + + Profiling works by changing how every function in your program is +compiled so that when it is called, it will stash away some information +about where it was called from. From this, the profiler can figure out +what function called it, and can count how many times it was called. +This change is made by the compiler when your program is compiled with +the `-pg' option, which causes every function to call `mcount' (or +`_mcount', or `__mcount', depending on the OS and compiler) as one of +its first operations. + + The `mcount' routine, included in the profiling library, is +responsible for recording in an in-memory call graph table both its +parent routine (the child) and its parent's parent. This is typically +done by examining the stack frame to find both the address of the +child, and the return address in the original parent. Since this is a +very machine-dependent operation, `mcount' itself is typically a short +assembly-language stub routine that extracts the required information, +and then calls `__mcount_internal' (a normal C function) with two +arguments - `frompc' and `selfpc'. `__mcount_internal' is responsible +for maintaining the in-memory call graph, which records `frompc', +`selfpc', and the number of times each of these call arcs was traversed. + + GCC Version 2 provides a magical function +(`__builtin_return_address'), which allows a generic `mcount' function +to extract the required information from the stack frame. However, on +some architectures, most notably the SPARC, using this builtin can be +very computationally expensive, and an assembly language version of +`mcount' is used for performance reasons. + + Number-of-calls information for library routines is collected by +using a special version of the C library. The programs in it are the +same as in the usual C library, but they were compiled with `-pg'. If +you link your program with `gcc ... -pg', it automatically uses the +profiling version of the library. + + Profiling also involves watching your program as it runs, and +keeping a histogram of where the program counter happens to be every +now and then. Typically the program counter is looked at around 100 +times per second of run time, but the exact frequency may vary from +system to system. + + This is done is one of two ways. Most UNIX-like operating systems +provide a `profil()' system call, which registers a memory array with +the kernel, along with a scale factor that determines how the program's +address space maps into the array. Typical scaling values cause every +2 to 8 bytes of address space to map into a single array slot. On +every tick of the system clock (assuming the profiled program is +running), the value of the program counter is examined and the +corresponding slot in the memory array is incremented. Since this is +done in the kernel, which had to interrupt the process anyway to handle +the clock interrupt, very little additional system overhead is required. + + However, some operating systems, most notably Linux 2.0 (and +earlier), do not provide a `profil()' system call. On such a system, +arrangements are made for the kernel to periodically deliver a signal +to the process (typically via `setitimer()'), which then performs the +same operation of examining the program counter and incrementing a slot +in the memory array. Since this method requires a signal to be +delivered to user space every time a sample is taken, it uses +considerably more overhead than kernel-based profiling. Also, due to +the added delay required to deliver the signal, this method is less +accurate as well. + + A special startup routine allocates memory for the histogram and +either calls `profil()' or sets up a clock signal handler. This +routine (`monstartup') can be invoked in several ways. On Linux +systems, a special profiling startup file `gcrt0.o', which invokes +`monstartup' before `main', is used instead of the default `crt0.o'. +Use of this special startup file is one of the effects of using `gcc +... -pg' to link. On SPARC systems, no special startup files are used. +Rather, the `mcount' routine, when it is invoked for the first time +(typically when `main' is called), calls `monstartup'. + + If the compiler's `-a' option was used, basic-block counting is also +enabled. Each object file is then compiled with a static array of +counts, initially zero. In the executable code, every time a new +basic-block begins (i.e. when an `if' statement appears), an extra +instruction is inserted to increment the corresponding count in the +array. At compile time, a paired array was constructed that recorded +the starting address of each basic-block. Taken together, the two +arrays record the starting address of every basic-block, along with the +number of times it was executed. + + The profiling library also includes a function (`mcleanup') which is +typically registered using `atexit()' to be called as the program +exits, and is responsible for writing the file `gmon.out'. Profiling +is turned off, various headers are output, and the histogram is +written, followed by the call-graph arcs and the basic-block counts. + + The output from `gprof' gives no indication of parts of your program +that are limited by I/O or swapping bandwidth. This is because samples +of the program counter are taken at fixed intervals of the program's +run time. Therefore, the time measurements in `gprof' output say +nothing about time that your program was not running. For example, a +part of the program that creates so much data that it cannot all fit in +physical memory at once may run very slowly due to thrashing, but +`gprof' will say it uses little time. On the other hand, sampling by +run time has the advantage that the amount of load due to other users +won't directly affect the output you get. + + +File: gprof.info, Node: File Format, Next: Internals, Prev: Implementation, Up: Details + +Profiling Data File Format +========================== + + The old BSD-derived file format used for profile data does not +contain a magic cookie that allows to check whether a data file really +is a `gprof' file. Furthermore, it does not provide a version number, +thus rendering changes to the file format almost impossible. GNU +`gprof' uses a new file format that provides these features. For +backward compatibility, GNU `gprof' continues to support the old +BSD-derived format, but not all features are supported with it. For +example, basic-block execution counts cannot be accommodated by the old +file format. + + The new file format is defined in header file `gmon_out.h'. It +consists of a header containing the magic cookie and a version number, +as well as some spare bytes available for future extensions. All data +in a profile data file is in the native format of the host on which the +profile was collected. GNU `gprof' adapts automatically to the +byte-order in use. + + In the new file format, the header is followed by a sequence of +records. Currently, there are three different record types: histogram +records, call-graph arc records, and basic-block execution count +records. Each file can contain any number of each record type. When +reading a file, GNU `gprof' will ensure records of the same type are +compatible with each other and compute the union of all records. For +example, for basic-block execution counts, the union is simply the sum +of all execution counts for each basic-block. + +Histogram Records +----------------- + + Histogram records consist of a header that is followed by an array of +bins. The header contains the text-segment range that the histogram +spans, the size of the histogram in bytes (unlike in the old BSD +format, this does not include the size of the header), the rate of the +profiling clock, and the physical dimension that the bin counts +represent after being scaled by the profiling clock rate. The physical +dimension is specified in two parts: a long name of up to 15 characters +and a single character abbreviation. For example, a histogram +representing real-time would specify the long name as "seconds" and the +abbreviation as "s". This feature is useful for architectures that +support performance monitor hardware (which, fortunately, is becoming +increasingly common). For example, under DEC OSF/1, the "uprofile" +command can be used to produce a histogram of, say, instruction cache +misses. In this case, the dimension in the histogram header could be +set to "i-cache misses" and the abbreviation could be set to "1" +(because it is simply a count, not a physical dimension). Also, the +profiling rate would have to be set to 1 in this case. + + Histogram bins are 16-bit numbers and each bin represent an equal +amount of text-space. For example, if the text-segment is one thousand +bytes long and if there are ten bins in the histogram, each bin +represents one hundred bytes. + +Call-Graph Records +------------------ + + Call-graph records have a format that is identical to the one used in +the BSD-derived file format. It consists of an arc in the call graph +and a count indicating the number of times the arc was traversed during +program execution. Arcs are specified by a pair of addresses: the +first must be within caller's function and the second must be within +the callee's function. When performing profiling at the function +level, these addresses can point anywhere within the respective +function. However, when profiling at the line-level, it is better if +the addresses are as close to the call-site/entry-point as possible. +This will ensure that the line-level call-graph is able to identify +exactly which line of source code performed calls to a function. + +Basic-Block Execution Count Records +----------------------------------- + + Basic-block execution count records consist of a header followed by a +sequence of address/count pairs. The header simply specifies the +length of the sequence. In an address/count pair, the address +identifies a basic-block and the count specifies the number of times +that basic-block was executed. Any address within the basic-address can +be used. + + +File: gprof.info, Node: Internals, Next: Debugging, Prev: File Format, Up: Details + +`gprof''s Internal Operation +============================ + + Like most programs, `gprof' begins by processing its options. +During this stage, it may building its symspec list +(`sym_ids.c:sym_id_add'), if options are specified which use symspecs. +`gprof' maintains a single linked list of symspecs, which will +eventually get turned into 12 symbol tables, organized into six +include/exclude pairs - one pair each for the flat profile +(INCL_FLAT/EXCL_FLAT), the call graph arcs (INCL_ARCS/EXCL_ARCS), +printing in the call graph (INCL_GRAPH/EXCL_GRAPH), timing propagation +in the call graph (INCL_TIME/EXCL_TIME), the annotated source listing +(INCL_ANNO/EXCL_ANNO), and the execution count listing +(INCL_EXEC/EXCL_EXEC). + + After option processing, `gprof' finishes building the symspec list +by adding all the symspecs in `default_excluded_list' to the exclude +lists EXCL_TIME and EXCL_GRAPH, and if line-by-line profiling is +specified, EXCL_FLAT as well. These default excludes are not added to +EXCL_ANNO, EXCL_ARCS, and EXCL_EXEC. + + Next, the BFD library is called to open the object file, verify that +it is an object file, and read its symbol table (`core.c:core_init'), +using `bfd_canonicalize_symtab' after mallocing an appropriately sized +array of symbols. At this point, function mappings are read (if the +`--file-ordering' option has been specified), and the core text space +is read into memory (if the `-c' option was given). + + `gprof''s own symbol table, an array of Sym structures, is now built. +This is done in one of two ways, by one of two routines, depending on +whether line-by-line profiling (`-l' option) has been enabled. For +normal profiling, the BFD canonical symbol table is scanned. For +line-by-line profiling, every text space address is examined, and a new +symbol table entry gets created every time the line number changes. In +either case, two passes are made through the symbol table - one to +count the size of the symbol table required, and the other to actually +read the symbols. In between the two passes, a single array of type +`Sym' is created of the appropriate length. Finally, +`symtab.c:symtab_finalize' is called to sort the symbol table and +remove duplicate entries (entries with the same memory address). + + The symbol table must be a contiguous array for two reasons. First, +the `qsort' library function (which sorts an array) will be used to +sort the symbol table. Also, the symbol lookup routine +(`symtab.c:sym_lookup'), which finds symbols based on memory address, +uses a binary search algorithm which requires the symbol table to be a +sorted array. Function symbols are indicated with an `is_func' flag. +Line number symbols have no special flags set. Additionally, a symbol +can have an `is_static' flag to indicate that it is a local symbol. + + With the symbol table read, the symspecs can now be translated into +Syms (`sym_ids.c:sym_id_parse'). Remember that a single symspec can +match multiple symbols. An array of symbol tables (`syms') is created, +each entry of which is a symbol table of Syms to be included or +excluded from a particular listing. The master symbol table and the +symspecs are examined by nested loops, and every symbol that matches a +symspec is inserted into the appropriate syms table. This is done +twice, once to count the size of each required symbol table, and again +to build the tables, which have been malloced between passes. From now +on, to determine whether a symbol is on an include or exclude symspec +list, `gprof' simply uses its standard symbol lookup routine on the +appropriate table in the `syms' array. + + Now the profile data file(s) themselves are read +(`gmon_io.c:gmon_out_read'), first by checking for a new-style +`gmon.out' header, then assuming this is an old-style BSD `gmon.out' if +the magic number test failed. + + New-style histogram records are read by `hist.c:hist_read_rec'. For +the first histogram record, allocate a memory array to hold all the +bins, and read them in. When multiple profile data files (or files +with multiple histogram records) are read, the starting address, ending +address, number of bins and sampling rate must match between the +various histograms, or a fatal error will result. If everything +matches, just sum the additional histograms into the existing in-memory +array. + + As each call graph record is read (`call_graph.c:cg_read_rec'), the +parent and child addresses are matched to symbol table entries, and a +call graph arc is created by `cg_arcs.c:arc_add', unless the arc fails +a symspec check against INCL_ARCS/EXCL_ARCS. As each arc is added, a +linked list is maintained of the parent's child arcs, and of the child's +parent arcs. Both the child's call count and the arc's call count are +incremented by the record's call count. + + Basic-block records are read (`basic_blocks.c:bb_read_rec'), but +only if line-by-line profiling has been selected. Each basic-block +address is matched to a corresponding line symbol in the symbol table, +and an entry made in the symbol's bb_addr and bb_calls arrays. Again, +if multiple basic-block records are present for the same address, the +call counts are cumulative. + + A gmon.sum file is dumped, if requested (`gmon_io.c:gmon_out_write'). + + If histograms were present in the data files, assign them to symbols +(`hist.c:hist_assign_samples') by iterating over all the sample bins +and assigning them to symbols. Since the symbol table is sorted in +order of ascending memory addresses, we can simple follow along in the +symbol table as we make our pass over the sample bins. This step +includes a symspec check against INCL_FLAT/EXCL_FLAT. Depending on the +histogram scale factor, a sample bin may span multiple symbols, in +which case a fraction of the sample count is allocated to each symbol, +proportional to the degree of overlap. This effect is rare for normal +profiling, but overlaps are more common during line-by-line profiling, +and can cause each of two adjacent lines to be credited with half a +hit, for example. + + If call graph data is present, `cg_arcs.c:cg_assemble' is called. +First, if `-c' was specified, a machine-dependent routine (`find_call') +scans through each symbol's machine code, looking for subroutine call +instructions, and adding them to the call graph with a zero call count. +A topological sort is performed by depth-first numbering all the +symbols (`cg_dfn.c:cg_dfn'), so that children are always numbered less +than their parents, then making a array of pointers into the symbol +table and sorting it into numerical order, which is reverse topological +order (children appear before parents). Cycles are also detected at +this point, all members of which are assigned the same topological +number. Two passes are now made through this sorted array of symbol +pointers. The first pass, from end to beginning (parents to children), +computes the fraction of child time to propagate to each parent and a +print flag. The print flag reflects symspec handling of +INCL_GRAPH/EXCL_GRAPH, with a parent's include or exclude (print or no +print) property being propagated to its children, unless they +themselves explicitly appear in INCL_GRAPH or EXCL_GRAPH. A second +pass, from beginning to end (children to parents) actually propagates +the timings along the call graph, subject to a check against +INCL_TIME/EXCL_TIME. With the print flag, fractions, and timings now +stored in the symbol structures, the topological sort array is now +discarded, and a new array of pointers is assembled, this time sorted +by propagated time. + + Finally, print the various outputs the user requested, which is now +fairly straightforward. The call graph (`cg_print.c:cg_print') and +flat profile (`hist.c:hist_print') are regurgitations of values already +computed. The annotated source listing +(`basic_blocks.c:print_annotated_source') uses basic-block information, +if present, to label each line of code with call counts, otherwise only +the function call counts are presented. + + The function ordering code is marginally well documented in the +source code itself (`cg_print.c'). Basically, the functions with the +most use and the most parents are placed first, followed by other +functions with the most use, followed by lower use functions, followed +by unused functions at the end. + + +File: gprof.info, Node: Debugging, Prev: Internals, Up: Details + +Debugging `gprof' +----------------- + + If `gprof' was compiled with debugging enabled, the `-d' option +triggers debugging output (to stdout) which can be helpful in +understanding its operation. The debugging number specified is +interpreted as a sum of the following options: + +2 - Topological sort + Monitor depth-first numbering of symbols during call graph analysis + +4 - Cycles + Shows symbols as they are identified as cycle heads + +16 - Tallying + As the call graph arcs are read, show each arc and how the total + calls to each function are tallied + +32 - Call graph arc sorting + Details sorting individual parents/children within each call graph + entry + +64 - Reading histogram and call graph records + Shows address ranges of histograms as they are read, and each call + graph arc + +128 - Symbol table + Reading, classifying, and sorting the symbol table from the object + file. For line-by-line profiling (`-l' option), also shows line + numbers being assigned to memory addresses. + +256 - Static call graph + Trace operation of `-c' option + +512 - Symbol table and arc table lookups + Detail operation of lookup routines + +1024 - Call graph propagation + Shows how function times are propagated along the call graph + +2048 - Basic-blocks + Shows basic-block records as they are read from profile data (only + meaningful with `-l' option) + +4096 - Symspecs + Shows symspec-to-symbol pattern matching operation + +8192 - Annotate source + Tracks operation of `-A' option + + diff --git a/ld/ld.info b/ld/ld.info new file mode 100644 index 00000000000..69c36bd32e7 --- /dev/null +++ b/ld/ld.info @@ -0,0 +1,97 @@ +This is ld.info, produced by makeinfo version 4.0 from ./ld.texinfo. + +START-INFO-DIR-ENTRY +* Ld: (ld). The GNU linker. +END-INFO-DIR-ENTRY + + This file documents the GNU linker LD version 2.10. + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +Indirect: +ld.info-1: 880 +ld.info-2: 50060 +ld.info-3: 98401 +ld.info-4: 146817 + +Tag Table: +(Indirect) +Node: Top880 +Node: Overview1397 +Node: Invocation2510 +Node: Options2917 +Node: Environment50060 +Node: Scripts51815 +Node: Basic Script Concepts53548 +Node: Script Format56250 +Node: Simple Example57108 +Node: Simple Commands60198 +Node: Entry Point60644 +Node: File Commands61394 +Node: Format Commands64447 +Node: Miscellaneous Commands66403 +Node: Assignments68394 +Node: Simple Assignments68726 +Node: PROVIDE70422 +Node: SECTIONS71595 +Node: Output Section Description73481 +Node: Output Section Name74466 +Node: Output Section Address75333 +Node: Input Section76967 +Node: Input Section Basics77759 +Node: Input Section Wildcards80027 +Node: Input Section Common82834 +Node: Input Section Keep84303 +Node: Input Section Example84772 +Node: Output Section Data85729 +Node: Output Section Keywords88174 +Node: Output Section Discarding91606 +Node: Output Section Attributes92551 +Node: Output Section Type93385 +Node: Output Section LMA94526 +Node: Output Section Region96630 +Node: Output Section Phdr97043 +Node: Output Section Fill97694 +Node: Overlay Description98401 +Node: MEMORY102640 +Node: PHDRS106717 +Node: VERSION111756 +Node: Expressions117834 +Node: Constants118668 +Node: Symbols119224 +Node: Location Counter119956 +Node: Operators122261 +Node: Evaluation123172 +Node: Expression Section124526 +Node: Builtin Functions126002 +Node: Implicit Linker Scripts131004 +Node: Machine Dependent131772 +Node: H8/300132226 +Node: i960133022 +Node: ARM134702 +Node: BFD135837 +Node: BFD outline137291 +Node: BFD information loss138576 +Node: Canonical format141084 +Node: Reporting Bugs145430 +Node: Bug Criteria146123 +Node: Bug Reporting146817 +Node: MRI153578 +Node: Index158177 + +End Tag Table diff --git a/ld/ld.info-1 b/ld/ld.info-1 new file mode 100644 index 00000000000..f0f49b4caa2 --- /dev/null +++ b/ld/ld.info-1 @@ -0,0 +1,1141 @@ +This is ld.info, produced by makeinfo version 4.0 from ./ld.texinfo. + +START-INFO-DIR-ENTRY +* Ld: (ld). The GNU linker. +END-INFO-DIR-ENTRY + + This file documents the GNU linker LD version 2.10. + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: ld.info, Node: Top, Next: Overview, Up: (dir) + +Using ld +******** + + This file documents the GNU linker ld version 2.10. + +* Menu: + +* Overview:: Overview +* Invocation:: Invocation +* Scripts:: Linker Scripts + +* Machine Dependent:: Machine Dependent Features + +* BFD:: BFD + +* Reporting Bugs:: Reporting Bugs +* MRI:: MRI Compatible Script Files +* Index:: Index + + +File: ld.info, Node: Overview, Next: Invocation, Prev: Top, Up: Top + +Overview +******** + + `ld' combines a number of object and archive files, relocates their +data and ties up symbol references. Usually the last step in compiling +a program is to run `ld'. + + `ld' accepts Linker Command Language files written in a superset of +AT&T's Link Editor Command Language syntax, to provide explicit and +total control over the linking process. + + This version of `ld' uses the general purpose BFD libraries to +operate on object files. This allows `ld' to read, combine, and write +object files in many different formats--for example, COFF or `a.out'. +Different formats may be linked together to produce any available kind +of object file. *Note BFD::, for more information. + + Aside from its flexibility, the GNU linker is more helpful than other +linkers in providing diagnostic information. Many linkers abandon +execution immediately upon encountering an error; whenever possible, +`ld' continues executing, allowing you to identify other errors (or, in +some cases, to get an output file in spite of the error). + + +File: ld.info, Node: Invocation, Next: Scripts, Prev: Overview, Up: Top + +Invocation +********** + + The GNU linker `ld' is meant to cover a broad range of situations, +and to be as compatible as possible with other linkers. As a result, +you have many choices to control its behavior. + +* Menu: + +* Options:: Command Line Options +* Environment:: Environment Variables + + +File: ld.info, Node: Options, Next: Environment, Up: Invocation + +Command Line Options +==================== + + The linker supports a plethora of command-line options, but in actual +practice few of them are used in any particular context. For instance, +a frequent use of `ld' is to link standard Unix object files on a +standard, supported Unix system. On such a system, to link a file +`hello.o': + + ld -o OUTPUT /lib/crt0.o hello.o -lc + + This tells `ld' to produce a file called OUTPUT as the result of +linking the file `/lib/crt0.o' with `hello.o' and the library `libc.a', +which will come from the standard search directories. (See the +discussion of the `-l' option below.) + + Some of the command-line options to `ld' may be specified at any +point in the command line. However, options which refer to files, such +as `-l' or `-T', cause the file to be read at the point at which the +option appears in the command line, relative to the object files and +other file options. Repeating non-file options with a different +argument will either have no further effect, or override prior +occurrences (those further to the left on the command line) of that +option. Options which may be meaningfully specified more than once are +noted in the descriptions below. + + Non-option arguments are object files or archives which are to be +linked together. They may follow, precede, or be mixed in with +command-line options, except that an object file argument may not be +placed between an option and its argument. + + Usually the linker is invoked with at least one object file, but you +can specify other forms of binary input files using `-l', `-R', and the +script command language. If _no_ binary input files at all are +specified, the linker does not produce any output, and issues the +message `No input files'. + + If the linker can not recognize the format of an object file, it will +assume that it is a linker script. A script specified in this way +augments the main linker script used for the link (either the default +linker script or the one specified by using `-T'). This feature +permits the linker to link against a file which appears to be an object +or an archive, but actually merely defines some symbol values, or uses +`INPUT' or `GROUP' to load other objects. Note that specifying a +script in this way should only be used to augment the main linker +script; if you want to use some command that logically can only appear +once, such as the `SECTIONS' or `MEMORY' command, you must replace the +default linker script using the `-T' option. *Note Scripts::. + + For options whose names are a single letter, option arguments must +either follow the option letter without intervening whitespace, or be +given as separate arguments immediately following the option that +requires them. + + For options whose names are multiple letters, either one dash or two +can precede the option name; for example, `--oformat' and `--oformat' +are equivalent. Arguments to multiple-letter options must either be +separated from the option name by an equals sign, or be given as +separate arguments immediately following the option that requires them. +For example, `--oformat srec' and `--oformat=srec' are equivalent. +Unique abbreviations of the names of multiple-letter options are +accepted. + + Note - if the linker is being invoked indirectly, via a compiler +driver (eg `gcc') then all the linker command line options should be +prefixed by `-Wl,' (or whatever is appropriate for the particular +compiler driver) like this: + + gcc -Wl,--startgroup foo.o bar.o -Wl,--endgroup + + This is important, because otherwise the compiler driver program may +silently drop the linker options, resulting in a bad link. + + Here is a table of the generic command line switches accepted by the +GNU linker: + +`-aKEYWORD' + This option is supported for HP/UX compatibility. The KEYWORD + argument must be one of the strings `archive', `shared', or + `default'. `-aarchive' is functionally equivalent to `-Bstatic', + and the other two keywords are functionally equivalent to + `-Bdynamic'. This option may be used any number of times. + +`-AARCHITECTURE' +`--architecture=ARCHITECTURE' + In the current release of `ld', this option is useful only for the + Intel 960 family of architectures. In that `ld' configuration, the + ARCHITECTURE argument identifies the particular architecture in + the 960 family, enabling some safeguards and modifying the + archive-library search path. *Note `ld' and the Intel 960 family: + i960, for details. + + Future releases of `ld' may support similar functionality for + other architecture families. + +`-b INPUT-FORMAT' +`--format=INPUT-FORMAT' + `ld' may be configured to support more than one kind of object + file. If your `ld' is configured this way, you can use the `-b' + option to specify the binary format for input object files that + follow this option on the command line. Even when `ld' is + configured to support alternative object formats, you don't + usually need to specify this, as `ld' should be configured to + expect as a default input format the most usual format on each + machine. INPUT-FORMAT is a text string, the name of a particular + format supported by the BFD libraries. (You can list the + available binary formats with `objdump -i'.) *Note BFD::. + + You may want to use this option if you are linking files with an + unusual binary format. You can also use `-b' to switch formats + explicitly (when linking object files of different formats), by + including `-b INPUT-FORMAT' before each group of object files in a + particular format. + + The default format is taken from the environment variable + `GNUTARGET'. *Note Environment::. You can also define the input + format from a script, using the command `TARGET'; see *Note Format + Commands::. + +`-c MRI-COMMANDFILE' +`--mri-script=MRI-COMMANDFILE' + For compatibility with linkers produced by MRI, `ld' accepts script + files written in an alternate, restricted command language, + described in *Note MRI Compatible Script Files: MRI. Introduce + MRI script files with the option `-c'; use the `-T' option to run + linker scripts written in the general-purpose `ld' scripting + language. If MRI-CMDFILE does not exist, `ld' looks for it in the + directories specified by any `-L' options. + +`-d' +`-dc' +`-dp' + These three options are equivalent; multiple forms are supported + for compatibility with other linkers. They assign space to common + symbols even if a relocatable output file is specified (with + `-r'). The script command `FORCE_COMMON_ALLOCATION' has the same + effect. *Note Miscellaneous Commands::. + +`-e ENTRY' +`--entry=ENTRY' + Use ENTRY as the explicit symbol for beginning execution of your + program, rather than the default entry point. If there is no + symbol named ENTRY, the linker will try to parse ENTRY as a number, + and use that as the entry address (the number will be interpreted + in base 10; you may use a leading `0x' for base 16, or a leading + `0' for base 8). *Note Entry Point::, for a discussion of defaults + and other ways of specifying the entry point. + +`-E' +`--export-dynamic' + When creating a dynamically linked executable, add all symbols to + the dynamic symbol table. The dynamic symbol table is the set of + symbols which are visible from dynamic objects at run time. + + If you do not use this option, the dynamic symbol table will + normally contain only those symbols which are referenced by some + dynamic object mentioned in the link. + + If you use `dlopen' to load a dynamic object which needs to refer + back to the symbols defined by the program, rather than some other + dynamic object, then you will probably need to use this option when + linking the program itself. + +`-EB' + Link big-endian objects. This affects the default output format. + +`-EL' + Link little-endian objects. This affects the default output + format. + +`-f' +`--auxiliary NAME' + When creating an ELF shared object, set the internal DT_AUXILIARY + field to the specified name. This tells the dynamic linker that + the symbol table of the shared object should be used as an + auxiliary filter on the symbol table of the shared object NAME. + + If you later link a program against this filter object, then, when + you run the program, the dynamic linker will see the DT_AUXILIARY + field. If the dynamic linker resolves any symbols from the filter + object, it will first check whether there is a definition in the + shared object NAME. If there is one, it will be used instead of + the definition in the filter object. The shared object NAME need + not exist. Thus the shared object NAME may be used to provide an + alternative implementation of certain functions, perhaps for + debugging or for machine specific performance. + + This option may be specified more than once. The DT_AUXILIARY + entries will be created in the order in which they appear on the + command line. + +`-F NAME' +`--filter NAME' + When creating an ELF shared object, set the internal DT_FILTER + field to the specified name. This tells the dynamic linker that + the symbol table of the shared object which is being created + should be used as a filter on the symbol table of the shared + object NAME. + + If you later link a program against this filter object, then, when + you run the program, the dynamic linker will see the DT_FILTER + field. The dynamic linker will resolve symbols according to the + symbol table of the filter object as usual, but it will actually + link to the definitions found in the shared object NAME. Thus the + filter object can be used to select a subset of the symbols + provided by the object NAME. + + Some older linkers used the `-F' option throughout a compilation + toolchain for specifying object-file format for both input and + output object files. The GNU linker uses other mechanisms for this + purpose: the `-b', `--format', `--oformat' options, the `TARGET' + command in linker scripts, and the `GNUTARGET' environment + variable. The GNU linker will ignore the `-F' option when not + creating an ELF shared object. + +`-fini NAME' + When creating an ELF executable or shared object, call NAME when + the executable or shared object is unloaded, by setting DT_FINI to + the address of the function. By default, the linker uses `_fini' + as the function to call. + +`-g' + Ignored. Provided for compatibility with other tools. + +`-GVALUE' +`--gpsize=VALUE' + Set the maximum size of objects to be optimized using the GP + register to SIZE. This is only meaningful for object file formats + such as MIPS ECOFF which supports putting large and small objects + into different sections. This is ignored for other object file + formats. + +`-hNAME' +`-soname=NAME' + When creating an ELF shared object, set the internal DT_SONAME + field to the specified name. When an executable is linked with a + shared object which has a DT_SONAME field, then when the + executable is run the dynamic linker will attempt to load the + shared object specified by the DT_SONAME field rather than the + using the file name given to the linker. + +`-i' + Perform an incremental link (same as option `-r'). + +`-init NAME' + When creating an ELF executable or shared object, call NAME when + the executable or shared object is loaded, by setting DT_INIT to + the address of the function. By default, the linker uses `_init' + as the function to call. + +`-lARCHIVE' +`--library=ARCHIVE' + Add archive file ARCHIVE to the list of files to link. This + option may be used any number of times. `ld' will search its + path-list for occurrences of `libARCHIVE.a' for every ARCHIVE + specified. + + On systems which support shared libraries, `ld' may also search for + libraries with extensions other than `.a'. Specifically, on ELF + and SunOS systems, `ld' will search a directory for a library with + an extension of `.so' before searching for one with an extension of + `.a'. By convention, a `.so' extension indicates a shared library. + + The linker will search an archive only once, at the location where + it is specified on the command line. If the archive defines a + symbol which was undefined in some object which appeared before + the archive on the command line, the linker will include the + appropriate file(s) from the archive. However, an undefined + symbol in an object appearing later on the command line will not + cause the linker to search the archive again. + + See the `-(' option for a way to force the linker to search + archives multiple times. + + You may list the same archive multiple times on the command line. + + This type of archive searching is standard for Unix linkers. + However, if you are using `ld' on AIX, note that it is different + from the behaviour of the AIX linker. + +`-LSEARCHDIR' +`--library-path=SEARCHDIR' + Add path SEARCHDIR to the list of paths that `ld' will search for + archive libraries and `ld' control scripts. You may use this + option any number of times. The directories are searched in the + order in which they are specified on the command line. + Directories specified on the command line are searched before the + default directories. All `-L' options apply to all `-l' options, + regardless of the order in which the options appear. + + The default set of paths searched (without being specified with + `-L') depends on which emulation mode `ld' is using, and in some + cases also on how it was configured. *Note Environment::. + + The paths can also be specified in a link script with the + `SEARCH_DIR' command. Directories specified this way are searched + at the point in which the linker script appears in the command + line. + +`-mEMULATION' + Emulate the EMULATION linker. You can list the available + emulations with the `--verbose' or `-V' options. + + If the `-m' option is not used, the emulation is taken from the + `LDEMULATION' environment variable, if that is defined. + + Otherwise, the default emulation depends upon how the linker was + configured. + +`-M' +`--print-map' + Print a link map to the standard output. A link map provides + information about the link, including the following: + + * Where object files and symbols are mapped into memory. + + * How common symbols are allocated. + + * All archive members included in the link, with a mention of + the symbol which caused the archive member to be brought in. + +`-n' +`--nmagic' + Turn off page alignment of sections, and mark the output as + `NMAGIC' if possible. + +`-N' +`--omagic' + Set the text and data sections to be readable and writable. Also, + do not page-align the data segment. If the output format supports + Unix style magic numbers, mark the output as `OMAGIC'. + +`-o OUTPUT' +`--output=OUTPUT' + Use OUTPUT as the name for the program produced by `ld'; if this + option is not specified, the name `a.out' is used by default. The + script command `OUTPUT' can also specify the output file name. + +`-O LEVEL' + If LEVEL is a numeric values greater than zero `ld' optimizes the + output. This might take significantly longer and therefore + probably should only be enabled for the final binary. + +`-r' +`--relocateable' + Generate relocatable output--i.e., generate an output file that + can in turn serve as input to `ld'. This is often called "partial + linking". As a side effect, in environments that support standard + Unix magic numbers, this option also sets the output file's magic + number to `OMAGIC'. If this option is not specified, an absolute + file is produced. When linking C++ programs, this option _will + not_ resolve references to constructors; to do that, use `-Ur'. + + This option does the same thing as `-i'. + +`-R FILENAME' +`--just-symbols=FILENAME' + Read symbol names and their addresses from FILENAME, but do not + relocate it or include it in the output. This allows your output + file to refer symbolically to absolute locations of memory defined + in other programs. You may use this option more than once. + + For compatibility with other ELF linkers, if the `-R' option is + followed by a directory name, rather than a file name, it is + treated as the `-rpath' option. + +`-s' +`--strip-all' + Omit all symbol information from the output file. + +`-S' +`--strip-debug' + Omit debugger symbol information (but not all symbols) from the + output file. + +`-t' +`--trace' + Print the names of the input files as `ld' processes them. + +`-T SCRIPTFILE' +`--script=SCRIPTFILE' + Use SCRIPTFILE as the linker script. This script replaces `ld''s + default linker script (rather than adding to it), so COMMANDFILE + must specify everything necessary to describe the output file. + You must use this option if you want to use a command which can + only appear once in a linker script, such as the `SECTIONS' or + `MEMORY' command. *Note Scripts::. If SCRIPTFILE does not exist + in the current directory, `ld' looks for it in the directories + specified by any preceding `-L' options. Multiple `-T' options + accumulate. + +`-u SYMBOL' +`--undefined=SYMBOL' + Force SYMBOL to be entered in the output file as an undefined + symbol. Doing this may, for example, trigger linking of additional + modules from standard libraries. `-u' may be repeated with + different option arguments to enter additional undefined symbols. + This option is equivalent to the `EXTERN' linker script command. + +`-Ur' + For anything other than C++ programs, this option is equivalent to + `-r': it generates relocatable output--i.e., an output file that + can in turn serve as input to `ld'. When linking C++ programs, + `-Ur' _does_ resolve references to constructors, unlike `-r'. It + does not work to use `-Ur' on files that were themselves linked + with `-Ur'; once the constructor table has been built, it cannot + be added to. Use `-Ur' only for the last partial link, and `-r' + for the others. + +`-v' +`--version' +`-V' + Display the version number for `ld'. The `-V' option also lists + the supported emulations. + +`-x' +`--discard-all' + Delete all local symbols. + +`-X' +`--discard-locals' + Delete all temporary local symbols. For most targets, this is all + local symbols whose names begin with `L'. + +`-y SYMBOL' +`--trace-symbol=SYMBOL' + Print the name of each linked file in which SYMBOL appears. This + option may be given any number of times. On many systems it is + necessary to prepend an underscore. + + This option is useful when you have an undefined symbol in your + link but don't know where the reference is coming from. + +`-Y PATH' + Add PATH to the default library search path. This option exists + for Solaris compatibility. + +`-z KEYWORD' + This option is ignored for Solaris compatibility. + +`-( ARCHIVES -)' +`--start-group ARCHIVES --end-group' + The ARCHIVES should be a list of archive files. They may be + either explicit file names, or `-l' options. + + The specified archives are searched repeatedly until no new + undefined references are created. Normally, an archive is + searched only once in the order that it is specified on the + command line. If a symbol in that archive is needed to resolve an + undefined symbol referred to by an object in an archive that + appears later on the command line, the linker would not be able to + resolve that reference. By grouping the archives, they all be + searched repeatedly until all possible references are resolved. + + Using this option has a significant performance cost. It is best + to use it only when there are unavoidable circular references + between two or more archives. + +`-assert KEYWORD' + This option is ignored for SunOS compatibility. + +`-Bdynamic' +`-dy' +`-call_shared' + Link against dynamic libraries. This is only meaningful on + platforms for which shared libraries are supported. This option + is normally the default on such platforms. The different variants + of this option are for compatibility with various systems. You + may use this option multiple times on the command line: it affects + library searching for `-l' options which follow it. + +`-Bstatic' +`-dn' +`-non_shared' +`-static' + Do not link against shared libraries. This is only meaningful on + platforms for which shared libraries are supported. The different + variants of this option are for compatibility with various + systems. You may use this option multiple times on the command + line: it affects library searching for `-l' options which follow + it. + +`-Bsymbolic' + When creating a shared library, bind references to global symbols + to the definition within the shared library, if any. Normally, it + is possible for a program linked against a shared library to + override the definition within the shared library. This option is + only meaningful on ELF platforms which support shared libraries. + +`--check-sections' +`--no-check-sections' + Asks the linker _not_ to check section addresses after they have + been assigned to see if there any overlaps. Normally the linker + will perform this check, and if it finds any overlaps it will + produce suitable error messages. The linker does know about, and + does make allowances for sections in overlays. The default + behaviour can be restored by using the command line switch + `--check-sections'. + +`--cref' + Output a cross reference table. If a linker map file is being + generated, the cross reference table is printed to the map file. + Otherwise, it is printed on the standard output. + + The format of the table is intentionally simple, so that it may be + easily processed by a script if necessary. The symbols are + printed out, sorted by name. For each symbol, a list of file + names is given. If the symbol is defined, the first file listed + is the location of the definition. The remaining files contain + references to the symbol. + +`--defsym SYMBOL=EXPRESSION' + Create a global symbol in the output file, containing the absolute + address given by EXPRESSION. You may use this option as many + times as necessary to define multiple symbols in the command line. + A limited form of arithmetic is supported for the EXPRESSION in + this context: you may give a hexadecimal constant or the name of + an existing symbol, or use `+' and `-' to add or subtract + hexadecimal constants or symbols. If you need more elaborate + expressions, consider using the linker command language from a + script (*note Assignment: Symbol Definitions: Assignments.). + _Note:_ there should be no white space between SYMBOL, the equals + sign ("<=>"), and EXPRESSION. + +`--demangle' +`--no-demangle' + These options control whether to demangle symbol names in error + messages and other output. When the linker is told to demangle, + it tries to present symbol names in a readable fashion: it strips + leading underscores if they are used by the object file format, + and converts C++ mangled symbol names into user readable names. + The linker will demangle by default unless the environment + variable `COLLECT_NO_DEMANGLE' is set. These options may be used + to override the default. + +`--dynamic-linker FILE' + Set the name of the dynamic linker. This is only meaningful when + generating dynamically linked ELF executables. The default dynamic + linker is normally correct; don't use this unless you know what + you are doing. + +`--embedded-relocs' + This option is only meaningful when linking MIPS embedded PIC code, + generated by the -membedded-pic option to the GNU compiler and + assembler. It causes the linker to create a table which may be + used at runtime to relocate any data which was statically + initialized to pointer values. See the code in testsuite/ld-empic + for details. + +`--force-exe-suffix' + Make sure that an output file has a .exe suffix. + + If a successfully built fully linked output file does not have a + `.exe' or `.dll' suffix, this option forces the linker to copy the + output file to one of the same name with a `.exe' suffix. This + option is useful when using unmodified Unix makefiles on a + Microsoft Windows host, since some versions of Windows won't run + an image unless it ends in a `.exe' suffix. + +`--no-gc-sections' +`--gc-sections' + Enable garbage collection of unused input sections. It is ignored + on targets that do not support this option. This option is not + compatible with `-r', nor should it be used with dynamic linking. + The default behaviour (of not performing this garbage collection) + can be restored by specifying `--no-gc-sections' on the command + line. + +`--help' + Print a summary of the command-line options on the standard output + and exit. + +`-Map MAPFILE' + Print a link map to the file MAPFILE. See the description of the + `-M' option, above. + +`--no-keep-memory' + `ld' normally optimizes for speed over memory usage by caching the + symbol tables of input files in memory. This option tells `ld' to + instead optimize for memory usage, by rereading the symbol tables + as necessary. This may be required if `ld' runs out of memory + space while linking a large executable. + +`--no-undefined' + Normally when creating a non-symbolic shared library, undefined + symbols are allowed and left to be resolved by the runtime loader. + This option disallows such undefined symbols. + +`--no-warn-mismatch' + Normally `ld' will give an error if you try to link together input + files that are mismatched for some reason, perhaps because they + have been compiled for different processors or for different + endiannesses. This option tells `ld' that it should silently + permit such possible errors. This option should only be used with + care, in cases when you have taken some special action that + ensures that the linker errors are inappropriate. + +`--no-whole-archive' + Turn off the effect of the `--whole-archive' option for subsequent + archive files. + +`--noinhibit-exec' + Retain the executable output file whenever it is still usable. + Normally, the linker will not produce an output file if it + encounters errors during the link process; it exits without + writing an output file when it issues any error whatsoever. + +`--oformat OUTPUT-FORMAT' + `ld' may be configured to support more than one kind of object + file. If your `ld' is configured this way, you can use the + `--oformat' option to specify the binary format for the output + object file. Even when `ld' is configured to support alternative + object formats, you don't usually need to specify this, as `ld' + should be configured to produce as a default output format the most + usual format on each machine. OUTPUT-FORMAT is a text string, the + name of a particular format supported by the BFD libraries. (You + can list the available binary formats with `objdump -i'.) The + script command `OUTPUT_FORMAT' can also specify the output format, + but this option overrides it. *Note BFD::. + +`-qmagic' + This option is ignored for Linux compatibility. + +`-Qy' + This option is ignored for SVR4 compatibility. + +`--relax' + An option with machine dependent effects. This option is only + supported on a few targets. *Note `ld' and the H8/300: H8/300. + *Note `ld' and the Intel 960 family: i960. + + On some platforms, the `--relax' option performs global + optimizations that become possible when the linker resolves + addressing in the program, such as relaxing address modes and + synthesizing new instructions in the output object file. + + On some platforms these link time global optimizations may make + symbolic debugging of the resulting executable impossible. This + is known to be the case for the Matsushita MN10200 and MN10300 + family of processors. + + On platforms where this is not supported, `--relax' is accepted, + but ignored. + +`--retain-symbols-file FILENAME' + Retain _only_ the symbols listed in the file FILENAME, discarding + all others. FILENAME is simply a flat file, with one symbol name + per line. This option is especially useful in environments (such + as VxWorks) where a large global symbol table is accumulated + gradually, to conserve run-time memory. + + `--retain-symbols-file' does _not_ discard undefined symbols, or + symbols needed for relocations. + + You may only specify `--retain-symbols-file' once in the command + line. It overrides `-s' and `-S'. + +`-rpath DIR' + Add a directory to the runtime library search path. This is used + when linking an ELF executable with shared objects. All `-rpath' + arguments are concatenated and passed to the runtime linker, which + uses them to locate shared objects at runtime. The `-rpath' + option is also used when locating shared objects which are needed + by shared objects explicitly included in the link; see the + description of the `-rpath-link' option. If `-rpath' is not used + when linking an ELF executable, the contents of the environment + variable `LD_RUN_PATH' will be used if it is defined. + + The `-rpath' option may also be used on SunOS. By default, on + SunOS, the linker will form a runtime search patch out of all the + `-L' options it is given. If a `-rpath' option is used, the + runtime search path will be formed exclusively using the `-rpath' + options, ignoring the `-L' options. This can be useful when using + gcc, which adds many `-L' options which may be on NFS mounted + filesystems. + + For compatibility with other ELF linkers, if the `-R' option is + followed by a directory name, rather than a file name, it is + treated as the `-rpath' option. + +`-rpath-link DIR' + When using ELF or SunOS, one shared library may require another. + This happens when an `ld -shared' link includes a shared library + as one of the input files. + + When the linker encounters such a dependency when doing a + non-shared, non-relocatable link, it will automatically try to + locate the required shared library and include it in the link, if + it is not included explicitly. In such a case, the `-rpath-link' + option specifies the first set of directories to search. The + `-rpath-link' option may specify a sequence of directory names + either by specifying a list of names separated by colons, or by + appearing multiple times. + + The linker uses the following search paths to locate required + shared libraries. + 1. Any directories specified by `-rpath-link' options. + + 2. Any directories specified by `-rpath' options. The difference + between `-rpath' and `-rpath-link' is that directories + specified by `-rpath' options are included in the executable + and used at runtime, whereas the `-rpath-link' option is only + effective at link time. + + 3. On an ELF system, if the `-rpath' and `rpath-link' options + were not used, search the contents of the environment variable + `LD_RUN_PATH'. + + 4. On SunOS, if the `-rpath' option was not used, search any + directories specified using `-L' options. + + 5. For a native linker, the contents of the environment variable + `LD_LIBRARY_PATH'. + + 6. The default directories, normally `/lib' and `/usr/lib'. + + 7. For a native linker on an ELF system, if the file + `/etc/ld.so.conf' exists, the list of directories found in + that file. + + If the required shared library is not found, the linker will issue + a warning and continue with the link. + +`-shared' +`-Bshareable' + Create a shared library. This is currently only supported on ELF, + XCOFF and SunOS platforms. On SunOS, the linker will + automatically create a shared library if the `-e' option is not + used and there are undefined symbols in the link. + +`--sort-common' + This option tells `ld' to sort the common symbols by size when it + places them in the appropriate output sections. First come all + the one byte symbols, then all the two bytes, then all the four + bytes, and then everything else. This is to prevent gaps between + symbols due to alignment constraints. + +`--split-by-file' + Similar to `--split-by-reloc' but creates a new output section for + each input file. + +`--split-by-reloc COUNT' + Trys to creates extra sections in the output file so that no single + output section in the file contains more than COUNT relocations. + This is useful when generating huge relocatable for downloading + into certain real time kernels with the COFF object file format; + since COFF cannot represent more than 65535 relocations in a + single section. Note that this will fail to work with object file + formats which do not support arbitrary sections. The linker will + not split up individual input sections for redistribution, so if a + single input section contains more than COUNT relocations one + output section will contain that many relocations. + +`--stats' + Compute and display statistics about the operation of the linker, + such as execution time and memory usage. + +`--traditional-format' + For some targets, the output of `ld' is different in some ways from + the output of some existing linker. This switch requests `ld' to + use the traditional format instead. + + For example, on SunOS, `ld' combines duplicate entries in the + symbol string table. This can reduce the size of an output file + with full debugging information by over 30 percent. + Unfortunately, the SunOS `dbx' program can not read the resulting + program (`gdb' has no trouble). The `--traditional-format' switch + tells `ld' to not combine duplicate entries. + +`-Tbss ORG' +`-Tdata ORG' +`-Ttext ORG' + Use ORG as the starting address for--respectively--the `bss', + `data', or the `text' segment of the output file. ORG must be a + single hexadecimal integer; for compatibility with other linkers, + you may omit the leading `0x' usually associated with hexadecimal + values. + +`--dll-verbose' +`--verbose' + Display the version number for `ld' and list the linker emulations + supported. Display which input files can and cannot be opened. + Display the linker script if using a default builtin script. + +`--version-script=VERSION-SCRIPTFILE' + Specify the name of a version script to the linker. This is + typically used when creating shared libraries to specify + additional information about the version heirarchy for the library + being created. This option is only meaningful on ELF platforms + which support shared libraries. *Note VERSION::. + +`--warn-common' + Warn when a common symbol is combined with another common symbol + or with a symbol definition. Unix linkers allow this somewhat + sloppy practice, but linkers on some other operating systems do + not. This option allows you to find potential problems from + combining global symbols. Unfortunately, some C libraries use + this practice, so you may get some warnings about symbols in the + libraries as well as in your programs. + + There are three kinds of global symbols, illustrated here by C + examples: + + `int i = 1;' + A definition, which goes in the initialized data section of + the output file. + + `extern int i;' + An undefined reference, which does not allocate space. There + must be either a definition or a common symbol for the + variable somewhere. + + `int i;' + A common symbol. If there are only (one or more) common + symbols for a variable, it goes in the uninitialized data + area of the output file. The linker merges multiple common + symbols for the same variable into a single symbol. If they + are of different sizes, it picks the largest size. The + linker turns a common symbol into a declaration, if there is + a definition of the same variable. + + The `--warn-common' option can produce five kinds of warnings. + Each warning consists of a pair of lines: the first describes the + symbol just encountered, and the second describes the previous + symbol encountered with the same name. One or both of the two + symbols will be a common symbol. + + 1. Turning a common symbol into a reference, because there is + already a definition for the symbol. + FILE(SECTION): warning: common of `SYMBOL' + overridden by definition + FILE(SECTION): warning: defined here + + 2. Turning a common symbol into a reference, because a later + definition for the symbol is encountered. This is the same + as the previous case, except that the symbols are encountered + in a different order. + FILE(SECTION): warning: definition of `SYMBOL' + overriding common + FILE(SECTION): warning: common is here + + 3. Merging a common symbol with a previous same-sized common + symbol. + FILE(SECTION): warning: multiple common + of `SYMBOL' + FILE(SECTION): warning: previous common is here + + 4. Merging a common symbol with a previous larger common symbol. + FILE(SECTION): warning: common of `SYMBOL' + overridden by larger common + FILE(SECTION): warning: larger common is here + + 5. Merging a common symbol with a previous smaller common + symbol. This is the same as the previous case, except that + the symbols are encountered in a different order. + FILE(SECTION): warning: common of `SYMBOL' + overriding smaller common + FILE(SECTION): warning: smaller common is here + +`--warn-constructors' + Warn if any global constructors are used. This is only useful for + a few object file formats. For formats like COFF or ELF, the + linker can not detect the use of global constructors. + +`--warn-multiple-gp' + Warn if multiple global pointer values are required in the output + file. This is only meaningful for certain processors, such as the + Alpha. Specifically, some processors put large-valued constants + in a special section. A special register (the global pointer) + points into the middle of this section, so that constants can be + loaded efficiently via a base-register relative addressing mode. + Since the offset in base-register relative mode is fixed and + relatively small (e.g., 16 bits), this limits the maximum size of + the constant pool. Thus, in large programs, it is often necessary + to use multiple global pointer values in order to be able to + address all possible constants. This option causes a warning to + be issued whenever this case occurs. + +`--warn-once' + Only warn once for each undefined symbol, rather than once per + module which refers to it. + +`--warn-section-align' + Warn if the address of an output section is changed because of + alignment. Typically, the alignment will be set by an input + section. The address will only be changed if it not explicitly + specified; that is, if the `SECTIONS' command does not specify a + start address for the section (*note SECTIONS::). + +`--whole-archive' + For each archive mentioned on the command line after the + `--whole-archive' option, include every object file in the archive + in the link, rather than searching the archive for the required + object files. This is normally used to turn an archive file into + a shared library, forcing every object to be included in the + resulting shared library. This option may be used more than once. + +`--wrap SYMBOL' + Use a wrapper function for SYMBOL. Any undefined reference to + SYMBOL will be resolved to `__wrap_SYMBOL'. Any undefined + reference to `__real_SYMBOL' will be resolved to SYMBOL. + + This can be used to provide a wrapper for a system function. The + wrapper function should be called `__wrap_SYMBOL'. If it wishes + to call the system function, it should call `__real_SYMBOL'. + + Here is a trivial example: + + void * + __wrap_malloc (int c) + { + printf ("malloc called with %ld\n", c); + return __real_malloc (c); + } + + If you link other code with this file using `--wrap malloc', then + all calls to `malloc' will call the function `__wrap_malloc' + instead. The call to `__real_malloc' in `__wrap_malloc' will call + the real `malloc' function. + + You may wish to provide a `__real_malloc' function as well, so that + links without the `--wrap' option will succeed. If you do this, + you should not put the definition of `__real_malloc' in the same + file as `__wrap_malloc'; if you do, the assembler may resolve the + call before the linker has a chance to wrap it to `malloc'. + +Options specific to i386 PE targets +----------------------------------- + + The i386 PE linker supports the `-shared' option, which causes the +output to be a dynamically linked library (DLL) instead of a normal +executable. You should name the output `*.dll' when you use this +option. In addition, the linker fully supports the standard `*.def' +files, which may be specified on the linker command line like an object +file (in fact, it should precede archives it exports symbols from, to +ensure that they get linked in, just like a normal object file). + + In addition to the options common to all targets, the i386 PE linker +support additional command line options that are specific to the i386 +PE target. Options that take values may be separated from their values +by either a space or an equals sign. + +`--add-stdcall-alias' + If given, symbols with a stdcall suffix (@NN) will be exported + as-is and also with the suffix stripped. + +`--base-file FILE' + Use FILE as the name of a file in which to save the base addresses + of all the relocations needed for generating DLLs with `dlltool'. + +`--dll' + Create a DLL instead of a regular executable. You may also use + `-shared' or specify a `LIBRARY' in a given `.def' file. + +`--enable-stdcall-fixup' +`--disable-stdcall-fixup' + If the link finds a symbol that it cannot resolve, it will attempt + to do "fuzzy linking" by looking for another defined symbol that + differs only in the format of the symbol name (cdecl vs stdcall) + and will resolve that symbol by linking to the match. For + example, the undefined symbol `_foo' might be linked to the + function `_foo@12', or the undefined symbol `_bar@16' might be + linked to the function `_bar'. When the linker does this, it + prints a warning, since it normally should have failed to link, + but sometimes import libraries generated from third-party dlls may + need this feature to be usable. If you specify + `--enable-stdcall-fixup', this feature is fully enabled and + warnings are not printed. If you specify + `--disable-stdcall-fixup', this feature is disabled and such + mismatches are considered to be errors. + +`--export-all-symbols' + If given, all global symbols in the objects used to build a DLL + will be exported by the DLL. Note that this is the default if + there otherwise wouldn't be any exported symbols. When symbols are + explicitly exported via DEF files or implicitly exported via + function attributes, the default is to not export anything else + unless this option is given. Note that the symbols `DllMain@12', + `DllEntryPoint@0', and `impure_ptr' will not be automatically + exported. + +`--exclude-symbols SYMBOL,SYMBOL,...' + Specifies a list of symbols which should not be automatically + exported. The symbol names may be delimited by commas or colons. + +`--file-alignment' + Specify the file alignment. Sections in the file will always + begin at file offsets which are multiples of this number. This + defaults to 512. + +`--heap RESERVE' +`--heap RESERVE,COMMIT' + Specify the amount of memory to reserve (and optionally commit) to + be used as heap for this program. The default is 1Mb reserved, 4K + committed. + +`--image-base VALUE' + Use VALUE as the base address of your program or dll. This is the + lowest memory location that will be used when your program or dll + is loaded. To reduce the need to relocate and improve performance + of your dlls, each should have a unique base address and not + overlap any other dlls. The default is 0x400000 for executables, + and 0x10000000 for dlls. + +`--kill-at' + If given, the stdcall suffixes (@NN) will be stripped from symbols + before they are exported. + +`--major-image-version VALUE' + Sets the major number of the "image version". Defaults to 1. + +`--major-os-version VALUE' + Sets the major number of the "os version". Defaults to 4. + +`--major-subsystem-version VALUE' + Sets the major number of the "subsystem version". Defaults to 4. + +`--minor-image-version VALUE' + Sets the minor number of the "image version". Defaults to 0. + +`--minor-os-version VALUE' + Sets the minor number of the "os version". Defaults to 0. + +`--minor-subsystem-version VALUE' + Sets the minor number of the "subsystem version". Defaults to 0. + +`--output-def FILE' + The linker will create the file FILE which will contain a DEF file + corresponding to the DLL the linker is generating. This DEF file + (which should be called `*.def') may be used to create an import + library with `dlltool' or may be used as a reference to + automatically or implicitly exported symbols. + +`--section-alignment' + Sets the section alignment. Sections in memory will always begin + at addresses which are a multiple of this number. Defaults to + 0x1000. + +`--stack RESERVE' +`--stack RESERVE,COMMIT' + Specify the amount of memory to reserve (and optionally commit) to + be used as stack for this program. The default is 32Mb reserved, + 4K committed. + +`--subsystem WHICH' +`--subsystem WHICH:MAJOR' +`--subsystem WHICH:MAJOR.MINOR' + Specifies the subsystem under which your program will execute. The + legal values for WHICH are `native', `windows', `console', and + `posix'. You may optionally set the subsystem version also. + diff --git a/ld/ld.info-2 b/ld/ld.info-2 new file mode 100644 index 00000000000..9818847b65a --- /dev/null +++ b/ld/ld.info-2 @@ -0,0 +1,1229 @@ +This is ld.info, produced by makeinfo version 4.0 from ./ld.texinfo. + +START-INFO-DIR-ENTRY +* Ld: (ld). The GNU linker. +END-INFO-DIR-ENTRY + + This file documents the GNU linker LD version 2.10. + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: ld.info, Node: Environment, Prev: Options, Up: Invocation + +Environment Variables +===================== + + You can change the behavior of `ld' with the environment variables +`GNUTARGET', `LDEMULATION', and `COLLECT_NO_DEMANGLE'. + + `GNUTARGET' determines the input-file object format if you don't use +`-b' (or its synonym `--format'). Its value should be one of the BFD +names for an input format (*note BFD::). If there is no `GNUTARGET' in +the environment, `ld' uses the natural format of the target. If +`GNUTARGET' is set to `default' then BFD attempts to discover the input +format by examining binary input files; this method often succeeds, but +there are potential ambiguities, since there is no method of ensuring +that the magic number used to specify object-file formats is unique. +However, the configuration procedure for BFD on each system places the +conventional format for that system first in the search-list, so +ambiguities are resolved in favor of convention. + + `LDEMULATION' determines the default emulation if you don't use the +`-m' option. The emulation can affect various aspects of linker +behaviour, particularly the default linker script. You can list the +available emulations with the `--verbose' or `-V' options. If the `-m' +option is not used, and the `LDEMULATION' environment variable is not +defined, the default emulation depends upon how the linker was +configured. + + Normally, the linker will default to demangling symbols. However, if +`COLLECT_NO_DEMANGLE' is set in the environment, then it will default +to not demangling symbols. This environment variable is used in a +similar fashion by the `gcc' linker wrapper program. The default may +be overridden by the `--demangle' and `--no-demangle' options. + + +File: ld.info, Node: Scripts, Next: Machine Dependent, Prev: Invocation, Up: Top + +Linker Scripts +************** + + Every link is controlled by a "linker script". This script is +written in the linker command language. + + The main purpose of the linker script is to describe how the +sections in the input files should be mapped into the output file, and +to control the memory layout of the output file. Most linker scripts +do nothing more than this. However, when necessary, the linker script +can also direct the linker to perform many other operations, using the +commands described below. + + The linker always uses a linker script. If you do not supply one +yourself, the linker will use a default script that is compiled into the +linker executable. You can use the `--verbose' command line option to +display the default linker script. Certain command line options, such +as `-r' or `-N', will affect the default linker script. + + You may supply your own linker script by using the `-T' command line +option. When you do this, your linker script will replace the default +linker script. + + You may also use linker scripts implicitly by naming them as input +files to the linker, as though they were files to be linked. *Note +Implicit Linker Scripts::. + +* Menu: + +* Basic Script Concepts:: Basic Linker Script Concepts +* Script Format:: Linker Script Format +* Simple Example:: Simple Linker Script Example +* Simple Commands:: Simple Linker Script Commands +* Assignments:: Assigning Values to Symbols +* SECTIONS:: SECTIONS Command +* MEMORY:: MEMORY Command +* PHDRS:: PHDRS Command +* VERSION:: VERSION Command +* Expressions:: Expressions in Linker Scripts +* Implicit Linker Scripts:: Implicit Linker Scripts + + +File: ld.info, Node: Basic Script Concepts, Next: Script Format, Up: Scripts + +Basic Linker Script Concepts +============================ + + We need to define some basic concepts and vocabulary in order to +describe the linker script language. + + The linker combines input files into a single output file. The +output file and each input file are in a special data format known as an +"object file format". Each file is called an "object file". The +output file is often called an "executable", but for our purposes we +will also call it an object file. Each object file has, among other +things, a list of "sections". We sometimes refer to a section in an +input file as an "input section"; similarly, a section in the output +file is an "output section". + + Each section in an object file has a name and a size. Most sections +also have an associated block of data, known as the "section contents". +A section may be marked as "loadable", which mean that the contents +should be loaded into memory when the output file is run. A section +with no contents may be "allocatable", which means that an area in +memory should be set aside, but nothing in particular should be loaded +there (in some cases this memory must be zeroed out). A section which +is neither loadable nor allocatable typically contains some sort of +debugging information. + + Every loadable or allocatable output section has two addresses. The +first is the "VMA", or virtual memory address. This is the address the +section will have when the output file is run. The second is the +"LMA", or load memory address. This is the address at which the +section will be loaded. In most cases the two addresses will be the +same. An example of when they might be different is when a data section +is loaded into ROM, and then copied into RAM when the program starts up +(this technique is often used to initialize global variables in a ROM +based system). In this case the ROM address would be the LMA, and the +RAM address would be the VMA. + + You can see the sections in an object file by using the `objdump' +program with the `-h' option. + + Every object file also has a list of "symbols", known as the "symbol +table". A symbol may be defined or undefined. Each symbol has a name, +and each defined symbol has an address, among other information. If +you compile a C or C++ program into an object file, you will get a +defined symbol for every defined function and global or static +variable. Every undefined function or global variable which is +referenced in the input file will become an undefined symbol. + + You can see the symbols in an object file by using the `nm' program, +or by using the `objdump' program with the `-t' option. + + +File: ld.info, Node: Script Format, Next: Simple Example, Prev: Basic Script Concepts, Up: Scripts + +Linker Script Format +==================== + + Linker scripts are text files. + + You write a linker script as a series of commands. Each command is +either a keyword, possibly followed by arguments, or an assignment to a +symbol. You may separate commands using semicolons. Whitespace is +generally ignored. + + Strings such as file or format names can normally be entered +directly. If the file name contains a character such as a comma which +would otherwise serve to separate file names, you may put the file name +in double quotes. There is no way to use a double quote character in a +file name. + + You may include comments in linker scripts just as in C, delimited by +`/*' and `*/'. As in C, comments are syntactically equivalent to +whitespace. + + +File: ld.info, Node: Simple Example, Next: Simple Commands, Prev: Script Format, Up: Scripts + +Simple Linker Script Example +============================ + + Many linker scripts are fairly simple. + + The simplest possible linker script has just one command: +`SECTIONS'. You use the `SECTIONS' command to describe the memory +layout of the output file. + + The `SECTIONS' command is a powerful command. Here we will describe +a simple use of it. Let's assume your program consists only of code, +initialized data, and uninitialized data. These will be in the +`.text', `.data', and `.bss' sections, respectively. Let's assume +further that these are the only sections which appear in your input +files. + + For this example, let's say that the code should be loaded at address +0x10000, and that the data should start at address 0x8000000. Here is a +linker script which will do that: + SECTIONS + { + . = 0x10000; + .text : { *(.text) } + . = 0x8000000; + .data : { *(.data) } + .bss : { *(.bss) } + } + + You write the `SECTIONS' command as the keyword `SECTIONS', followed +by a series of symbol assignments and output section descriptions +enclosed in curly braces. + + The first line inside the `SECTIONS' command of the above example +sets the value of the special symbol `.', which is the location +counter. If you do not specify the address of an output section in some +other way (other ways are described later), the address is set from the +current value of the location counter. The location counter is then +incremented by the size of the output section. At the start of the +`SECTIONS' command, the location counter has the value `0'. + + The second line defines an output section, `.text'. The colon is +required syntax which may be ignored for now. Within the curly braces +after the output section name, you list the names of the input sections +which should be placed into this output section. The `*' is a wildcard +which matches any file name. The expression `*(.text)' means all +`.text' input sections in all input files. + + Since the location counter is `0x10000' when the output section +`.text' is defined, the linker will set the address of the `.text' +section in the output file to be `0x10000'. + + The remaining lines define the `.data' and `.bss' sections in the +output file. The linker will place the `.data' output section at +address `0x8000000'. After the linker places the `.data' output +section, the value of the location counter will be `0x8000000' plus the +size of the `.data' output section. The effect is that the linker will +place the `.bss' output section immediately after the `.data' output +section in memory + + The linker will ensure that each output section has the required +alignment, by increasing the location counter if necessary. In this +example, the specified addresses for the `.text' and `.data' sections +will probably satisfy any alignment constraints, but the linker may +have to create a small gap between the `.data' and `.bss' sections. + + That's it! That's a simple and complete linker script. + + +File: ld.info, Node: Simple Commands, Next: Assignments, Prev: Simple Example, Up: Scripts + +Simple Linker Script Commands +============================= + + In this section we describe the simple linker script commands. + +* Menu: + +* Entry Point:: Setting the entry point +* File Commands:: Commands dealing with files + +* Format Commands:: Commands dealing with object file formats + +* Miscellaneous Commands:: Other linker script commands + + +File: ld.info, Node: Entry Point, Next: File Commands, Up: Simple Commands + +Setting the entry point +----------------------- + + The first instruction to execute in a program is called the "entry +point". You can use the `ENTRY' linker script command to set the entry +point. The argument is a symbol name: + ENTRY(SYMBOL) + + There are several ways to set the entry point. The linker will set +the entry point by trying each of the following methods in order, and +stopping when one of them succeeds: + * the `-e' ENTRY command-line option; + + * the `ENTRY(SYMBOL)' command in a linker script; + + * the value of the symbol `start', if defined; + + * the address of the first byte of the `.text' section, if present; + + * The address `0'. + + +File: ld.info, Node: File Commands, Next: Format Commands, Prev: Entry Point, Up: Simple Commands + +Commands dealing with files +--------------------------- + + Several linker script commands deal with files. + +`INCLUDE FILENAME' + Include the linker script FILENAME at this point. The file will + be searched for in the current directory, and in any directory + specified with the `-L' option. You can nest calls to `INCLUDE' + up to 10 levels deep. + +`INPUT(FILE, FILE, ...)' +`INPUT(FILE FILE ...)' + The `INPUT' command directs the linker to include the named files + in the link, as though they were named on the command line. + + For example, if you always want to include `subr.o' any time you do + a link, but you can't be bothered to put it on every link command + line, then you can put `INPUT (subr.o)' in your linker script. + + In fact, if you like, you can list all of your input files in the + linker script, and then invoke the linker with nothing but a `-T' + option. + + The linker will first try to open the file in the current + directory. If it is not found, the linker will search through the + archive library search path. See the description of `-L' in *Note + Command Line Options: Options. + + If you use `INPUT (-lFILE)', `ld' will transform the name to + `libFILE.a', as with the command line argument `-l'. + + When you use the `INPUT' command in an implicit linker script, the + files will be included in the link at the point at which the linker + script file is included. This can affect archive searching. + +`GROUP(FILE, FILE, ...)' +`GROUP(FILE FILE ...)' + The `GROUP' command is like `INPUT', except that the named files + should all be archives, and they are searched repeatedly until no + new undefined references are created. See the description of `-(' + in *Note Command Line Options: Options. + +`OUTPUT(FILENAME)' + The `OUTPUT' command names the output file. Using + `OUTPUT(FILENAME)' in the linker script is exactly like using `-o + FILENAME' on the command line (*note Command Line Options: + Options.). If both are used, the command line option takes + precedence. + + You can use the `OUTPUT' command to define a default name for the + output file other than the usual default of `a.out'. + +`SEARCH_DIR(PATH)' + The `SEARCH_DIR' command adds PATH to the list of paths where `ld' + looks for archive libraries. Using `SEARCH_DIR(PATH)' is exactly + like using `-L PATH' on the command line (*note Command Line + Options: Options.). If both are used, then the linker will search + both paths. Paths specified using the command line option are + searched first. + +`STARTUP(FILENAME)' + The `STARTUP' command is just like the `INPUT' command, except + that FILENAME will become the first input file to be linked, as + though it were specified first on the command line. This may be + useful when using a system in which the entry point is always the + start of the first file. + + +File: ld.info, Node: Format Commands, Next: Miscellaneous Commands, Prev: File Commands, Up: Simple Commands + +Commands dealing with object file formats +----------------------------------------- + + A couple of linker script commands deal with object file formats. + +`OUTPUT_FORMAT(BFDNAME)' +`OUTPUT_FORMAT(DEFAULT, BIG, LITTLE)' + The `OUTPUT_FORMAT' command names the BFD format to use for the + output file (*note BFD::). Using `OUTPUT_FORMAT(BFDNAME)' is + exactly like using `-oformat BFDNAME' on the command line (*note + Command Line Options: Options.). If both are used, the command + line option takes precedence. + + You can use `OUTPUT_FORMAT' with three arguments to use different + formats based on the `-EB' and `-EL' command line options. This + permits the linker script to set the output format based on the + desired endianness. + + If neither `-EB' nor `-EL' are used, then the output format will + be the first argument, DEFAULT. If `-EB' is used, the output + format will be the second argument, BIG. If `-EL' is used, the + output format will be the third argument, LITTLE. + + For example, the default linker script for the MIPS ELF target + uses this command: + OUTPUT_FORMAT(elf32-bigmips, elf32-bigmips, elf32-littlemips) + This says that the default format for the output file is + `elf32-bigmips', but if the user uses the `-EL' command line + option, the output file will be created in the `elf32-littlemips' + format. + +`TARGET(BFDNAME)' + The `TARGET' command names the BFD format to use when reading input + files. It affects subsequent `INPUT' and `GROUP' commands. This + command is like using `-b BFDNAME' on the command line (*note + Command Line Options: Options.). If the `TARGET' command is used + but `OUTPUT_FORMAT' is not, then the last `TARGET' command is also + used to set the format for the output file. *Note BFD::. + + +File: ld.info, Node: Miscellaneous Commands, Prev: Format Commands, Up: Simple Commands + +Other linker script commands +---------------------------- + + There are a few other linker scripts commands. + +`ASSERT(EXP, MESSAGE)' + Ensure that EXP is non-zero. If it is zero, then exit the linker + with an error code, and print MESSAGE. + +`EXTERN(SYMBOL SYMBOL ...)' + Force SYMBOL to be entered in the output file as an undefined + symbol. Doing this may, for example, trigger linking of additional + modules from standard libraries. You may list several SYMBOLs for + each `EXTERN', and you may use `EXTERN' multiple times. This + command has the same effect as the `-u' command-line option. + +`FORCE_COMMON_ALLOCATION' + This command has the same effect as the `-d' command-line option: + to make `ld' assign space to common symbols even if a relocatable + output file is specified (`-r'). + +`NOCROSSREFS(SECTION SECTION ...)' + This command may be used to tell `ld' to issue an error about any + references among certain output sections. + + In certain types of programs, particularly on embedded systems when + using overlays, when one section is loaded into memory, another + section will not be. Any direct references between the two + sections would be errors. For example, it would be an error if + code in one section called a function defined in the other section. + + The `NOCROSSREFS' command takes a list of output section names. If + `ld' detects any cross references between the sections, it reports + an error and returns a non-zero exit status. Note that the + `NOCROSSREFS' command uses output section names, not input section + names. + +`OUTPUT_ARCH(BFDARCH)' + Specify a particular output machine architecture. The argument is + one of the names used by the BFD library (*note BFD::). You can + see the architecture of an object file by using the `objdump' + program with the `-f' option. + + +File: ld.info, Node: Assignments, Next: SECTIONS, Prev: Simple Commands, Up: Scripts + +Assigning Values to Symbols +=========================== + + You may assign a value to a symbol in a linker script. This will +define the symbol as a global symbol. + +* Menu: + +* Simple Assignments:: Simple Assignments +* PROVIDE:: PROVIDE + + +File: ld.info, Node: Simple Assignments, Next: PROVIDE, Up: Assignments + +Simple Assignments +------------------ + + You may assign to a symbol using any of the C assignment operators: + +`SYMBOL = EXPRESSION ;' +`SYMBOL += EXPRESSION ;' +`SYMBOL -= EXPRESSION ;' +`SYMBOL *= EXPRESSION ;' +`SYMBOL /= EXPRESSION ;' +`SYMBOL <<= EXPRESSION ;' +`SYMBOL >>= EXPRESSION ;' +`SYMBOL &= EXPRESSION ;' +`SYMBOL |= EXPRESSION ;' + The first case will define SYMBOL to the value of EXPRESSION. In +the other cases, SYMBOL must already be defined, and the value will be +adjusted accordingly. + + The special symbol name `.' indicates the location counter. You may +only use this within a `SECTIONS' command. + + The semicolon after EXPRESSION is required. + + Expressions are defined below; see *Note Expressions::. + + You may write symbol assignments as commands in their own right, or +as statements within a `SECTIONS' command, or as part of an output +section description in a `SECTIONS' command. + + The section of the symbol will be set from the section of the +expression; for more information, see *Note Expression Section::. + + Here is an example showing the three different places that symbol +assignments may be used: + + floating_point = 0; + SECTIONS + { + .text : + { + *(.text) + _etext = .; + } + _bdata = (. + 3) & ~ 4; + .data : { *(.data) } + } + +In this example, the symbol `floating_point' will be defined as zero. +The symbol `_etext' will be defined as the address following the last +`.text' input section. The symbol `_bdata' will be defined as the +address following the `.text' output section aligned upward to a 4 byte +boundary. + + +File: ld.info, Node: PROVIDE, Prev: Simple Assignments, Up: Assignments + +PROVIDE +------- + + In some cases, it is desirable for a linker script to define a symbol +only if it is referenced and is not defined by any object included in +the link. For example, traditional linkers defined the symbol `etext'. +However, ANSI C requires that the user be able to use `etext' as a +function name without encountering an error. The `PROVIDE' keyword may +be used to define a symbol, such as `etext', only if it is referenced +but not defined. The syntax is `PROVIDE(SYMBOL = EXPRESSION)'. + + Here is an example of using `PROVIDE' to define `etext': + SECTIONS + { + .text : + { + *(.text) + _etext = .; + PROVIDE(etext = .); + } + } + + In this example, if the program defines `_etext' (with a leading +underscore), the linker will give a multiple definition error. If, on +the other hand, the program defines `etext' (with no leading +underscore), the linker will silently use the definition in the program. +If the program references `etext' but does not define it, the linker +will use the definition in the linker script. + + +File: ld.info, Node: SECTIONS, Next: MEMORY, Prev: Assignments, Up: Scripts + +SECTIONS command +================ + + The `SECTIONS' command tells the linker how to map input sections +into output sections, and how to place the output sections in memory. + + The format of the `SECTIONS' command is: + SECTIONS + { + SECTIONS-COMMAND + SECTIONS-COMMAND + ... + } + + Each SECTIONS-COMMAND may of be one of the following: + + * an `ENTRY' command (*note Entry command: Entry Point.) + + * a symbol assignment (*note Assignments::) + + * an output section description + + * an overlay description + + The `ENTRY' command and symbol assignments are permitted inside the +`SECTIONS' command for convenience in using the location counter in +those commands. This can also make the linker script easier to +understand because you can use those commands at meaningful points in +the layout of the output file. + + Output section descriptions and overlay descriptions are described +below. + + If you do not use a `SECTIONS' command in your linker script, the +linker will place each input section into an identically named output +section in the order that the sections are first encountered in the +input files. If all input sections are present in the first file, for +example, the order of sections in the output file will match the order +in the first input file. The first section will be at address zero. + +* Menu: + +* Output Section Description:: Output section description +* Output Section Name:: Output section name +* Output Section Address:: Output section address +* Input Section:: Input section description +* Output Section Data:: Output section data +* Output Section Keywords:: Output section keywords +* Output Section Discarding:: Output section discarding +* Output Section Attributes:: Output section attributes +* Overlay Description:: Overlay description + + +File: ld.info, Node: Output Section Description, Next: Output Section Name, Up: SECTIONS + +Output section description +-------------------------- + + The full description of an output section looks like this: + SECTION [ADDRESS] [(TYPE)] : [AT(LMA)] + { + OUTPUT-SECTION-COMMAND + OUTPUT-SECTION-COMMAND + ... + } [>REGION] [AT>LMA_REGION] [:PHDR :PHDR ...] [=FILLEXP] + + Most output sections do not use most of the optional section +attributes. + + The whitespace around SECTION is required, so that the section name +is unambiguous. The colon and the curly braces are also required. The +line breaks and other white space are optional. + + Each OUTPUT-SECTION-COMMAND may be one of the following: + + * a symbol assignment (*note Assignments::) + + * an input section description (*note Input Section::) + + * data values to include directly (*note Output Section Data::) + + * a special output section keyword (*note Output Section Keywords::) + + +File: ld.info, Node: Output Section Name, Next: Output Section Address, Prev: Output Section Description, Up: SECTIONS + +Output section name +------------------- + + The name of the output section is SECTION. SECTION must meet the +constraints of your output format. In formats which only support a +limited number of sections, such as `a.out', the name must be one of +the names supported by the format (`a.out', for example, allows only +`.text', `.data' or `.bss'). If the output format supports any number +of sections, but with numbers and not names (as is the case for Oasys), +the name should be supplied as a quoted numeric string. A section name +may consist of any sequence of characters, but a name which contains +any unusual characters such as commas must be quoted. + + The output section name `/DISCARD/' is special; *Note Output Section +Discarding::. + + +File: ld.info, Node: Output Section Address, Next: Input Section, Prev: Output Section Name, Up: SECTIONS + +Output section address +---------------------- + + The ADDRESS is an expression for the VMA (the virtual memory +address) of the output section. If you do not provide ADDRESS, the +linker will set it based on REGION if present, or otherwise based on +the current value of the location counter. + + If you provide ADDRESS, the address of the output section will be +set to precisely that. If you provide neither ADDRESS nor REGION, then +the address of the output section will be set to the current value of +the location counter aligned to the alignment requirements of the +output section. The alignment requirement of the output section is the +strictest alignment of any input section contained within the output +section. + + For example, + .text . : { *(.text) } + +and + .text : { *(.text) } + +are subtly different. The first will set the address of the `.text' +output section to the current value of the location counter. The +second will set it to the current value of the location counter aligned +to the strictest alignment of a `.text' input section. + + The ADDRESS may be an arbitrary expression; *Note Expressions::. +For example, if you want to align the section on a 0x10 byte boundary, +so that the lowest four bits of the section address are zero, you could +do something like this: + .text ALIGN(0x10) : { *(.text) } + +This works because `ALIGN' returns the current location counter aligned +upward to the specified value. + + Specifying ADDRESS for a section will change the value of the +location counter. + + +File: ld.info, Node: Input Section, Next: Output Section Data, Prev: Output Section Address, Up: SECTIONS + +Input section description +------------------------- + + The most common output section command is an input section +description. + + The input section description is the most basic linker script +operation. You use output sections to tell the linker how to lay out +your program in memory. You use input section descriptions to tell the +linker how to map the input files into your memory layout. + +* Menu: + +* Input Section Basics:: Input section basics +* Input Section Wildcards:: Input section wildcard patterns +* Input Section Common:: Input section for common symbols +* Input Section Keep:: Input section and garbage collection +* Input Section Example:: Input section example + + +File: ld.info, Node: Input Section Basics, Next: Input Section Wildcards, Up: Input Section + +Input section basics +.................... + + An input section description consists of a file name optionally +followed by a list of section names in parentheses. + + The file name and the section name may be wildcard patterns, which we +describe further below (*note Input Section Wildcards::). + + The most common input section description is to include all input +sections with a particular name in the output section. For example, to +include all input `.text' sections, you would write: + *(.text) + +Here the `*' is a wildcard which matches any file name. To exclude a +list of files from matching the file name wildcard, EXCLUDE_FILE may be +used to match all files except the ones specified in the EXCLUDE_FILE +list. For example: + (*(EXCLUDE_FILE (*crtend.o *otherfile.o) .ctors)) + will cause all .ctors sections from all files except `crtend.o' and +`otherfile.o' to be included. + + There are two ways to include more than one section: + *(.text .rdata) + *(.text) *(.rdata) + +The difference between these is the order in which the `.text' and +`.rdata' input sections will appear in the output section. In the +first example, they will be intermingled. In the second example, all +`.text' input sections will appear first, followed by all `.rdata' +input sections. + + You can specify a file name to include sections from a particular +file. You would do this if one or more of your files contain special +data that needs to be at a particular location in memory. For example: + data.o(.data) + + If you use a file name without a list of sections, then all sections +in the input file will be included in the output section. This is not +commonly done, but it may by useful on occasion. For example: + data.o + + When you use a file name which does not contain any wild card +characters, the linker will first see if you also specified the file +name on the linker command line or in an `INPUT' command. If you did +not, the linker will attempt to open the file as an input file, as +though it appeared on the command line. Note that this differs from an +`INPUT' command, because the linker will not search for the file in the +archive search path. + + +File: ld.info, Node: Input Section Wildcards, Next: Input Section Common, Prev: Input Section Basics, Up: Input Section + +Input section wildcard patterns +............................... + + In an input section description, either the file name or the section +name or both may be wildcard patterns. + + The file name of `*' seen in many examples is a simple wildcard +pattern for the file name. + + The wildcard patterns are like those used by the Unix shell. + +`*' + matches any number of characters + +`?' + matches any single character + +`[CHARS]' + matches a single instance of any of the CHARS; the `-' character + may be used to specify a range of characters, as in `[a-z]' to + match any lower case letter + +`\' + quotes the following character + + When a file name is matched with a wildcard, the wildcard characters +will not match a `/' character (used to separate directory names on +Unix). A pattern consisting of a single `*' character is an exception; +it will always match any file name, whether it contains a `/' or not. +In a section name, the wildcard characters will match a `/' character. + + File name wildcard patterns only match files which are explicitly +specified on the command line or in an `INPUT' command. The linker +does not search directories to expand wildcards. + + If a file name matches more than one wildcard pattern, or if a file +name appears explicitly and is also matched by a wildcard pattern, the +linker will use the first match in the linker script. For example, this +sequence of input section descriptions is probably in error, because the +`data.o' rule will not be used: + .data : { *(.data) } + .data1 : { data.o(.data) } + + Normally, the linker will place files and sections matched by +wildcards in the order in which they are seen during the link. You can +change this by using the `SORT' keyword, which appears before a wildcard +pattern in parentheses (e.g., `SORT(.text*)'). When the `SORT' keyword +is used, the linker will sort the files or sections into ascending +order by name before placing them in the output file. + + If you ever get confused about where input sections are going, use +the `-M' linker option to generate a map file. The map file shows +precisely how input sections are mapped to output sections. + + This example shows how wildcard patterns might be used to partition +files. This linker script directs the linker to place all `.text' +sections in `.text' and all `.bss' sections in `.bss'. The linker will +place the `.data' section from all files beginning with an upper case +character in `.DATA'; for all other files, the linker will place the +`.data' section in `.data'. + SECTIONS { + .text : { *(.text) } + .DATA : { [A-Z]*(.data) } + .data : { *(.data) } + .bss : { *(.bss) } + } + + +File: ld.info, Node: Input Section Common, Next: Input Section Keep, Prev: Input Section Wildcards, Up: Input Section + +Input section for common symbols +................................ + + A special notation is needed for common symbols, because in many +object file formats common symbols do not have a particular input +section. The linker treats common symbols as though they are in an +input section named `COMMON'. + + You may use file names with the `COMMON' section just as with any +other input sections. You can use this to place common symbols from a +particular input file in one section while common symbols from other +input files are placed in another section. + + In most cases, common symbols in input files will be placed in the +`.bss' section in the output file. For example: + .bss { *(.bss) *(COMMON) } + + Some object file formats have more than one type of common symbol. +For example, the MIPS ELF object file format distinguishes standard +common symbols and small common symbols. In this case, the linker will +use a different special section name for other types of common symbols. +In the case of MIPS ELF, the linker uses `COMMON' for standard common +symbols and `.scommon' for small common symbols. This permits you to +map the different types of common symbols into memory at different +locations. + + You will sometimes see `[COMMON]' in old linker scripts. This +notation is now considered obsolete. It is equivalent to `*(COMMON)'. + + +File: ld.info, Node: Input Section Keep, Next: Input Section Example, Prev: Input Section Common, Up: Input Section + +Input section and garbage collection +.................................... + + When link-time garbage collection is in use (`--gc-sections'), it is +often useful to mark sections that should not be eliminated. This is +accomplished by surrounding an input section's wildcard entry with +`KEEP()', as in `KEEP(*(.init))' or `KEEP(SORT(*)(.ctors))'. + + +File: ld.info, Node: Input Section Example, Prev: Input Section Keep, Up: Input Section + +Input section example +..................... + + The following example is a complete linker script. It tells the +linker to read all of the sections from file `all.o' and place them at +the start of output section `outputa' which starts at location +`0x10000'. All of section `.input1' from file `foo.o' follows +immediately, in the same output section. All of section `.input2' from +`foo.o' goes into output section `outputb', followed by section +`.input1' from `foo1.o'. All of the remaining `.input1' and `.input2' +sections from any files are written to output section `outputc'. + + SECTIONS { + outputa 0x10000 : + { + all.o + foo.o (.input1) + } + outputb : + { + foo.o (.input2) + foo1.o (.input1) + } + outputc : + { + *(.input1) + *(.input2) + } + } + + +File: ld.info, Node: Output Section Data, Next: Output Section Keywords, Prev: Input Section, Up: SECTIONS + +Output section data +------------------- + + You can include explicit bytes of data in an output section by using +`BYTE', `SHORT', `LONG', `QUAD', or `SQUAD' as an output section +command. Each keyword is followed by an expression in parentheses +providing the value to store (*note Expressions::). The value of the +expression is stored at the current value of the location counter. + + The `BYTE', `SHORT', `LONG', and `QUAD' commands store one, two, +four, and eight bytes (respectively). After storing the bytes, the +location counter is incremented by the number of bytes stored. + + For example, this will store the byte 1 followed by the four byte +value of the symbol `addr': + BYTE(1) + LONG(addr) + + When using a 64 bit host or target, `QUAD' and `SQUAD' are the same; +they both store an 8 byte, or 64 bit, value. When both host and target +are 32 bits, an expression is computed as 32 bits. In this case `QUAD' +stores a 32 bit value zero extended to 64 bits, and `SQUAD' stores a 32 +bit value sign extended to 64 bits. + + If the object file format of the output file has an explicit +endianness, which is the normal case, the value will be stored in that +endianness. When the object file format does not have an explicit +endianness, as is true of, for example, S-records, the value will be +stored in the endianness of the first input object file. + + You may use the `FILL' command to set the fill pattern for the +current section. It is followed by an expression in parentheses. Any +otherwise unspecified regions of memory within the section (for example, +gaps left due to the required alignment of input sections) are filled +with the two least significant bytes of the expression, repeated as +necessary. A `FILL' statement covers memory locations after the point +at which it occurs in the section definition; by including more than +one `FILL' statement, you can have different fill patterns in different +parts of an output section. + + This example shows how to fill unspecified regions of memory with the +value `0x9090': + FILL(0x9090) + + The `FILL' command is similar to the `=FILLEXP' output section +attribute (*note Output Section Fill::), but it only affects the part +of the section following the `FILL' command, rather than the entire +section. If both are used, the `FILL' command takes precedence. + + +File: ld.info, Node: Output Section Keywords, Next: Output Section Discarding, Prev: Output Section Data, Up: SECTIONS + +Output section keywords +----------------------- + + There are a couple of keywords which can appear as output section +commands. + +`CREATE_OBJECT_SYMBOLS' + The command tells the linker to create a symbol for each input + file. The name of each symbol will be the name of the + corresponding input file. The section of each symbol will be the + output section in which the `CREATE_OBJECT_SYMBOLS' command + appears. + + This is conventional for the a.out object file format. It is not + normally used for any other object file format. + +`CONSTRUCTORS' + When linking using the a.out object file format, the linker uses an + unusual set construct to support C++ global constructors and + destructors. When linking object file formats which do not support + arbitrary sections, such as ECOFF and XCOFF, the linker will + automatically recognize C++ global constructors and destructors by + name. For these object file formats, the `CONSTRUCTORS' command + tells the linker to place constructor information in the output + section where the `CONSTRUCTORS' command appears. The + `CONSTRUCTORS' command is ignored for other object file formats. + + The symbol `__CTOR_LIST__' marks the start of the global + constructors, and the symbol `__DTOR_LIST' marks the end. The + first word in the list is the number of entries, followed by the + address of each constructor or destructor, followed by a zero + word. The compiler must arrange to actually run the code. For + these object file formats GNU C++ normally calls constructors from + a subroutine `__main'; a call to `__main' is automatically + inserted into the startup code for `main'. GNU C++ normally runs + destructors either by using `atexit', or directly from the function + `exit'. + + For object file formats such as `COFF' or `ELF' which support + arbitrary section names, GNU C++ will normally arrange to put the + addresses of global constructors and destructors into the `.ctors' + and `.dtors' sections. Placing the following sequence into your + linker script will build the sort of table which the GNU C++ + runtime code expects to see. + + __CTOR_LIST__ = .; + LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) + *(.ctors) + LONG(0) + __CTOR_END__ = .; + __DTOR_LIST__ = .; + LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) + *(.dtors) + LONG(0) + __DTOR_END__ = .; + + If you are using the GNU C++ support for initialization priority, + which provides some control over the order in which global + constructors are run, you must sort the constructors at link time + to ensure that they are executed in the correct order. When using + the `CONSTRUCTORS' command, use `SORT(CONSTRUCTORS)' instead. + When using the `.ctors' and `.dtors' sections, use + `*(SORT(.ctors))' and `*(SORT(.dtors))' instead of just + `*(.ctors)' and `*(.dtors)'. + + Normally the compiler and linker will handle these issues + automatically, and you will not need to concern yourself with + them. However, you may need to consider this if you are using C++ + and writing your own linker scripts. + + +File: ld.info, Node: Output Section Discarding, Next: Output Section Attributes, Prev: Output Section Keywords, Up: SECTIONS + +Output section discarding +------------------------- + + The linker will not create output section which do not have any +contents. This is for convenience when referring to input sections that +may or may not be present in any of the input files. For example: + .foo { *(.foo) } + +will only create a `.foo' section in the output file if there is a +`.foo' section in at least one input file. + + If you use anything other than an input section description as an +output section command, such as a symbol assignment, then the output +section will always be created, even if there are no matching input +sections. + + The special output section name `/DISCARD/' may be used to discard +input sections. Any input sections which are assigned to an output +section named `/DISCARD/' are not included in the output file. + + +File: ld.info, Node: Output Section Attributes, Next: Overlay Description, Prev: Output Section Discarding, Up: SECTIONS + +Output section attributes +------------------------- + + We showed above that the full description of an output section looked +like this: + SECTION [ADDRESS] [(TYPE)] : [AT(LMA)] + { + OUTPUT-SECTION-COMMAND + OUTPUT-SECTION-COMMAND + ... + } [>REGION] [AT>LMA_REGION] [:PHDR :PHDR ...] [=FILLEXP] +We've already described SECTION, ADDRESS, and +OUTPUT-SECTION-COMMAND. In this section we will describe the remaining +section attributes. + +* Menu: + +* Output Section Type:: Output section type +* Output Section LMA:: Output section LMA +* Output Section Region:: Output section region +* Output Section Phdr:: Output section phdr +* Output Section Fill:: Output section fill + + +File: ld.info, Node: Output Section Type, Next: Output Section LMA, Up: Output Section Attributes + +Output section type +................... + + Each output section may have a type. The type is a keyword in +parentheses. The following types are defined: + +`NOLOAD' + The section should be marked as not loadable, so that it will not + be loaded into memory when the program is run. + +`DSECT' +`COPY' +`INFO' +`OVERLAY' + These type names are supported for backward compatibility, and are + rarely used. They all have the same effect: the section should be + marked as not allocatable, so that no memory is allocated for the + section when the program is run. + + The linker normally sets the attributes of an output section based on +the input sections which map into it. You can override this by using +the section type. For example, in the script sample below, the `ROM' +section is addressed at memory location `0' and does not need to be +loaded when the program is run. The contents of the `ROM' section will +appear in the linker output file as usual. + SECTIONS { + ROM 0 (NOLOAD) : { ... } + ... + } + + +File: ld.info, Node: Output Section LMA, Next: Output Section Region, Prev: Output Section Type, Up: Output Section Attributes + +Output section LMA +.................. + + Every section has a virtual address (VMA) and a load address (LMA); +see *Note Basic Script Concepts::. The address expression which may +appear in an output section description sets the VMA (*note Output +Section Address::). + + The linker will normally set the LMA equal to the VMA. You can +change that by using the `AT' keyword. The expression LMA that follows +the `AT' keyword specifies the load address of the section. +Alternatively, with `AT>LMA_REGION' expression, you may specify a +memory region for the section's load address. *Note MEMORY::. + + This feature is designed to make it easy to build a ROM image. For +example, the following linker script creates three output sections: one +called `.text', which starts at `0x1000', one called `.mdata', which is +loaded at the end of the `.text' section even though its VMA is +`0x2000', and one called `.bss' to hold uninitialized data at address +`0x3000'. The symbol `_data' is defined with the value `0x2000', which +shows that the location counter holds the VMA value, not the LMA value. + + SECTIONS + { + .text 0x1000 : { *(.text) _etext = . ; } + .mdata 0x2000 : + AT ( ADDR (.text) + SIZEOF (.text) ) + { _data = . ; *(.data); _edata = . ; } + .bss 0x3000 : + { _bstart = . ; *(.bss) *(COMMON) ; _bend = . ;} + } + + The run-time initialization code for use with a program generated +with this linker script would include something like the following, to +copy the initialized data from the ROM image to its runtime address. +Notice how this code takes advantage of the symbols defined by the +linker script. + + extern char _etext, _data, _edata, _bstart, _bend; + char *src = &_etext; + char *dst = &_data; + + /* ROM has data at end of text; copy it. */ + while (dst < &_edata) { + *dst++ = *src++; + } + + /* Zero bss */ + for (dst = &_bstart; dst< &_bend; dst++) + *dst = 0; + + +File: ld.info, Node: Output Section Region, Next: Output Section Phdr, Prev: Output Section LMA, Up: Output Section Attributes + +Output section region +..................... + + You can assign a section to a previously defined region of memory by +using `>REGION'. *Note MEMORY::. + + Here is a simple example: + MEMORY { rom : ORIGIN = 0x1000, LENGTH = 0x1000 } + SECTIONS { ROM : { *(.text) } >rom } + + +File: ld.info, Node: Output Section Phdr, Next: Output Section Fill, Prev: Output Section Region, Up: Output Section Attributes + +Output section phdr +................... + + You can assign a section to a previously defined program segment by +using `:PHDR'. *Note PHDRS::. If a section is assigned to one or more +segments, then all subsequent allocated sections will be assigned to +those segments as well, unless they use an explicitly `:PHDR' modifier. +You can use `:NONE' to tell the linker to not put the section in any +segment at all. + + Here is a simple example: + PHDRS { text PT_LOAD ; } + SECTIONS { .text : { *(.text) } :text } + + +File: ld.info, Node: Output Section Fill, Prev: Output Section Phdr, Up: Output Section Attributes + +Output section fill +................... + + You can set the fill pattern for an entire section by using +`=FILLEXP'. FILLEXP is an expression (*note Expressions::). Any +otherwise unspecified regions of memory within the output section (for +example, gaps left due to the required alignment of input sections) +will be filled with the two least significant bytes of the value, +repeated as necessary. + + You can also change the fill value with a `FILL' command in the +output section commands; see *Note Output Section Data::. + + Here is a simple example: + SECTIONS { .text : { *(.text) } =0x9090 } + diff --git a/ld/ld.info-3 b/ld/ld.info-3 new file mode 100644 index 00000000000..68f54d7f4de --- /dev/null +++ b/ld/ld.info-3 @@ -0,0 +1,1204 @@ +This is ld.info, produced by makeinfo version 4.0 from ./ld.texinfo. + +START-INFO-DIR-ENTRY +* Ld: (ld). The GNU linker. +END-INFO-DIR-ENTRY + + This file documents the GNU linker LD version 2.10. + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: ld.info, Node: Overlay Description, Prev: Output Section Attributes, Up: SECTIONS + +Overlay description +------------------- + + An overlay description provides an easy way to describe sections +which are to be loaded as part of a single memory image but are to be +run at the same memory address. At run time, some sort of overlay +manager will copy the overlaid sections in and out of the runtime +memory address as required, perhaps by simply manipulating addressing +bits. This approach can be useful, for example, when a certain region +of memory is faster than another. + + Overlays are described using the `OVERLAY' command. The `OVERLAY' +command is used within a `SECTIONS' command, like an output section +description. The full syntax of the `OVERLAY' command is as follows: + OVERLAY [START] : [NOCROSSREFS] [AT ( LDADDR )] + { + SECNAME1 + { + OUTPUT-SECTION-COMMAND + OUTPUT-SECTION-COMMAND + ... + } [:PHDR...] [=FILL] + SECNAME2 + { + OUTPUT-SECTION-COMMAND + OUTPUT-SECTION-COMMAND + ... + } [:PHDR...] [=FILL] + ... + } [>REGION] [:PHDR...] [=FILL] + + Everything is optional except `OVERLAY' (a keyword), and each +section must have a name (SECNAME1 and SECNAME2 above). The section +definitions within the `OVERLAY' construct are identical to those +within the general `SECTIONS' contruct (*note SECTIONS::), except that +no addresses and no memory regions may be defined for sections within +an `OVERLAY'. + + The sections are all defined with the same starting address. The +load addresses of the sections are arranged such that they are +consecutive in memory starting at the load address used for the +`OVERLAY' as a whole (as with normal section definitions, the load +address is optional, and defaults to the start address; the start +address is also optional, and defaults to the current value of the +location counter). + + If the `NOCROSSREFS' keyword is used, and there any references among +the sections, the linker will report an error. Since the sections all +run at the same address, it normally does not make sense for one +section to refer directly to another. *Note NOCROSSREFS: Miscellaneous +Commands. + + For each section within the `OVERLAY', the linker automatically +defines two symbols. The symbol `__load_start_SECNAME' is defined as +the starting load address of the section. The symbol +`__load_stop_SECNAME' is defined as the final load address of the +section. Any characters within SECNAME which are not legal within C +identifiers are removed. C (or assembler) code may use these symbols +to move the overlaid sections around as necessary. + + At the end of the overlay, the value of the location counter is set +to the start address of the overlay plus the size of the largest +section. + + Here is an example. Remember that this would appear inside a +`SECTIONS' construct. + OVERLAY 0x1000 : AT (0x4000) + { + .text0 { o1/*.o(.text) } + .text1 { o2/*.o(.text) } + } + +This will define both `.text0' and `.text1' to start at address 0x1000. +`.text0' will be loaded at address 0x4000, and `.text1' will be loaded +immediately after `.text0'. The following symbols will be defined: +`__load_start_text0', `__load_stop_text0', `__load_start_text1', +`__load_stop_text1'. + + C code to copy overlay `.text1' into the overlay area might look +like the following. + + extern char __load_start_text1, __load_stop_text1; + memcpy ((char *) 0x1000, &__load_start_text1, + &__load_stop_text1 - &__load_start_text1); + + Note that the `OVERLAY' command is just syntactic sugar, since +everything it does can be done using the more basic commands. The above +example could have been written identically as follows. + + .text0 0x1000 : AT (0x4000) { o1/*.o(.text) } + __load_start_text0 = LOADADDR (.text0); + __load_stop_text0 = LOADADDR (.text0) + SIZEOF (.text0); + .text1 0x1000 : AT (0x4000 + SIZEOF (.text0)) { o2/*.o(.text) } + __load_start_text1 = LOADADDR (.text1); + __load_stop_text1 = LOADADDR (.text1) + SIZEOF (.text1); + . = 0x1000 + MAX (SIZEOF (.text0), SIZEOF (.text1)); + + +File: ld.info, Node: MEMORY, Next: PHDRS, Prev: SECTIONS, Up: Scripts + +MEMORY command +============== + + The linker's default configuration permits allocation of all +available memory. You can override this by using the `MEMORY' command. + + The `MEMORY' command describes the location and size of blocks of +memory in the target. You can use it to describe which memory regions +may be used by the linker, and which memory regions it must avoid. You +can then assign sections to particular memory regions. The linker will +set section addresses based on the memory regions, and will warn about +regions that become too full. The linker will not shuffle sections +around to fit into the available regions. + + A linker script may contain at most one use of the `MEMORY' command. +However, you can define as many blocks of memory within it as you +wish. The syntax is: + MEMORY + { + NAME [(ATTR)] : ORIGIN = ORIGIN, LENGTH = LEN + ... + } + + The NAME is a name used in the linker script to refer to the region. +The region name has no meaning outside of the linker script. Region +names are stored in a separate name space, and will not conflict with +symbol names, file names, or section names. Each memory region must +have a distinct name. + + The ATTR string is an optional list of attributes that specify +whether to use a particular memory region for an input section which is +not explicitly mapped in the linker script. As described in *Note +SECTIONS::, if you do not specify an output section for some input +section, the linker will create an output section with the same name as +the input section. If you define region attributes, the linker will use +them to select the memory region for the output section that it creates. + + The ATTR string must consist only of the following characters: +`R' + Read-only section + +`W' + Read/write section + +`X' + Executable section + +`A' + Allocatable section + +`I' + Initialized section + +`L' + Same as `I' + +`!' + Invert the sense of any of the preceding attributes + + If a unmapped section matches any of the listed attributes other than +`!', it will be placed in the memory region. The `!' attribute +reverses this test, so that an unmapped section will be placed in the +memory region only if it does not match any of the listed attributes. + + The ORIGIN is an expression for the start address of the memory +region. The expression must evaluate to a constant before memory +allocation is performed, which means that you may not use any section +relative symbols. The keyword `ORIGIN' may be abbreviated to `org' or +`o' (but not, for example, `ORG'). + + The LEN is an expression for the size in bytes of the memory region. +As with the ORIGIN expression, the expression must evaluate to a +constant before memory allocation is performed. The keyword `LENGTH' +may be abbreviated to `len' or `l'. + + In the following example, we specify that there are two memory +regions available for allocation: one starting at `0' for 256 kilobytes, +and the other starting at `0x40000000' for four megabytes. The linker +will place into the `rom' memory region every section which is not +explicitly mapped into a memory region, and is either read-only or +executable. The linker will place other sections which are not +explicitly mapped into a memory region into the `ram' memory region. + + MEMORY + { + rom (rx) : ORIGIN = 0, LENGTH = 256K + ram (!rx) : org = 0x40000000, l = 4M + } + + Once you define a memory region, you can direct the linker to place +specific output sections into that memory region by using the `>REGION' +output section attribute. For example, if you have a memory region +named `mem', you would use `>mem' in the output section definition. +*Note Output Section Region::. If no address was specified for the +output section, the linker will set the address to the next available +address within the memory region. If the combined output sections +directed to a memory region are too large for the region, the linker +will issue an error message. + + +File: ld.info, Node: PHDRS, Next: VERSION, Prev: MEMORY, Up: Scripts + +PHDRS Command +============= + + The ELF object file format uses "program headers", also knows as +"segments". The program headers describe how the program should be +loaded into memory. You can print them out by using the `objdump' +program with the `-p' option. + + When you run an ELF program on a native ELF system, the system loader +reads the program headers in order to figure out how to load the +program. This will only work if the program headers are set correctly. +This manual does not describe the details of how the system loader +interprets program headers; for more information, see the ELF ABI. + + The linker will create reasonable program headers by default. +However, in some cases, you may need to specify the program headers more +precisely. You may use the `PHDRS' command for this purpose. When the +linker sees the `PHDRS' command in the linker script, it will not +create any program headers other than the ones specified. + + The linker only pays attention to the `PHDRS' command when +generating an ELF output file. In other cases, the linker will simply +ignore `PHDRS'. + + This is the syntax of the `PHDRS' command. The words `PHDRS', +`FILEHDR', `AT', and `FLAGS' are keywords. + + PHDRS + { + NAME TYPE [ FILEHDR ] [ PHDRS ] [ AT ( ADDRESS ) ] + [ FLAGS ( FLAGS ) ] ; + } + + The NAME is used only for reference in the `SECTIONS' command of the +linker script. It is not put into the output file. Program header +names are stored in a separate name space, and will not conflict with +symbol names, file names, or section names. Each program header must +have a distinct name. + + Certain program header types describe segments of memory which the +system loader will load from the file. In the linker script, you +specify the contents of these segments by placing allocatable output +sections in the segments. You use the `:PHDR' output section attribute +to place a section in a particular segment. *Note Output Section +Phdr::. + + It is normal to put certain sections in more than one segment. This +merely implies that one segment of memory contains another. You may +repeat `:PHDR', using it once for each segment which should contain the +section. + + If you place a section in one or more segments using `:PHDR', then +the linker will place all subsequent allocatable sections which do not +specify `:PHDR' in the same segments. This is for convenience, since +generally a whole set of contiguous sections will be placed in a single +segment. You can use `:NONE' to override the default segment and tell +the linker to not put the section in any segment at all. + + You may use the `FILEHDR' and `PHDRS' keywords appear after the +program header type to further describe the contents of the segment. +The `FILEHDR' keyword means that the segment should include the ELF +file header. The `PHDRS' keyword means that the segment should include +the ELF program headers themselves. + + The TYPE may be one of the following. The numbers indicate the +value of the keyword. + +`PT_NULL' (0) + Indicates an unused program header. + +`PT_LOAD' (1) + Indicates that this program header describes a segment to be + loaded from the file. + +`PT_DYNAMIC' (2) + Indicates a segment where dynamic linking information can be found. + +`PT_INTERP' (3) + Indicates a segment where the name of the program interpreter may + be found. + +`PT_NOTE' (4) + Indicates a segment holding note information. + +`PT_SHLIB' (5) + A reserved program header type, defined but not specified by the + ELF ABI. + +`PT_PHDR' (6) + Indicates a segment where the program headers may be found. + +EXPRESSION + An expression giving the numeric type of the program header. This + may be used for types not defined above. + + You can specify that a segment should be loaded at a particular +address in memory by using an `AT' expression. This is identical to the +`AT' command used as an output section attribute (*note Output Section +LMA::). The `AT' command for a program header overrides the output +section attribute. + + The linker will normally set the segment flags based on the sections +which comprise the segment. You may use the `FLAGS' keyword to +explicitly specify the segment flags. The value of FLAGS must be an +integer. It is used to set the `p_flags' field of the program header. + + Here is an example of `PHDRS'. This shows a typical set of program +headers used on a native ELF system. + + PHDRS + { + headers PT_PHDR PHDRS ; + interp PT_INTERP ; + text PT_LOAD FILEHDR PHDRS ; + data PT_LOAD ; + dynamic PT_DYNAMIC ; + } + + SECTIONS + { + . = SIZEOF_HEADERS; + .interp : { *(.interp) } :text :interp + .text : { *(.text) } :text + .rodata : { *(.rodata) } /* defaults to :text */ + ... + . = . + 0x1000; /* move to a new page in memory */ + .data : { *(.data) } :data + .dynamic : { *(.dynamic) } :data :dynamic + ... + } + + +File: ld.info, Node: VERSION, Next: Expressions, Prev: PHDRS, Up: Scripts + +VERSION Command +=============== + + The linker supports symbol versions when using ELF. Symbol versions +are only useful when using shared libraries. The dynamic linker can use +symbol versions to select a specific version of a function when it runs +a program that may have been linked against an earlier version of the +shared library. + + You can include a version script directly in the main linker script, +or you can supply the version script as an implicit linker script. You +can also use the `--version-script' linker option. + + The syntax of the `VERSION' command is simply + VERSION { version-script-commands } + + The format of the version script commands is identical to that used +by Sun's linker in Solaris 2.5. The version script defines a tree of +version nodes. You specify the node names and interdependencies in the +version script. You can specify which symbols are bound to which +version nodes, and you can reduce a specified set of symbols to local +scope so that they are not globally visible outside of the shared +library. + + The easiest way to demonstrate the version script language is with a +few examples. + + VERS_1.1 { + global: + foo1; + local: + old*; + original*; + new*; + }; + + VERS_1.2 { + foo2; + } VERS_1.1; + + VERS_2.0 { + bar1; bar2; + } VERS_1.2; + + This example version script defines three version nodes. The first +version node defined is `VERS_1.1'; it has no other dependencies. The +script binds the symbol `foo1' to `VERS_1.1'. It reduces a number of +symbols to local scope so that they are not visible outside of the +shared library. + + Next, the version script defines node `VERS_1.2'. This node depends +upon `VERS_1.1'. The script binds the symbol `foo2' to the version +node `VERS_1.2'. + + Finally, the version script defines node `VERS_2.0'. This node +depends upon `VERS_1.2'. The scripts binds the symbols `bar1' and +`bar2' are bound to the version node `VERS_2.0'. + + When the linker finds a symbol defined in a library which is not +specifically bound to a version node, it will effectively bind it to an +unspecified base version of the library. You can bind all otherwise +unspecified symbols to a given version node by using `global: *' +somewhere in the version script. + + The names of the version nodes have no specific meaning other than +what they might suggest to the person reading them. The `2.0' version +could just as well have appeared in between `1.1' and `1.2'. However, +this would be a confusing way to write a version script. + + When you link an application against a shared library that has +versioned symbols, the application itself knows which version of each +symbol it requires, and it also knows which version nodes it needs from +each shared library it is linked against. Thus at runtime, the dynamic +loader can make a quick check to make sure that the libraries you have +linked against do in fact supply all of the version nodes that the +application will need to resolve all of the dynamic symbols. In this +way it is possible for the dynamic linker to know with certainty that +all external symbols that it needs will be resolvable without having to +search for each symbol reference. + + The symbol versioning is in effect a much more sophisticated way of +doing minor version checking that SunOS does. The fundamental problem +that is being addressed here is that typically references to external +functions are bound on an as-needed basis, and are not all bound when +the application starts up. If a shared library is out of date, a +required interface may be missing; when the application tries to use +that interface, it may suddenly and unexpectedly fail. With symbol +versioning, the user will get a warning when they start their program if +the libraries being used with the application are too old. + + There are several GNU extensions to Sun's versioning approach. The +first of these is the ability to bind a symbol to a version node in the +source file where the symbol is defined instead of in the versioning +script. This was done mainly to reduce the burden on the library +maintainer. You can do this by putting something like: + __asm__(".symver original_foo,foo@VERS_1.1"); + +in the C source file. This renames the function `original_foo' to be +an alias for `foo' bound to the version node `VERS_1.1'. The `local:' +directive can be used to prevent the symbol `original_foo' from being +exported. + + The second GNU extension is to allow multiple versions of the same +function to appear in a given shared library. In this way you can make +an incompatible change to an interface without increasing the major +version number of the shared library, while still allowing applications +linked against the old interface to continue to function. + + To do this, you must use multiple `.symver' directives in the source +file. Here is an example: + + __asm__(".symver original_foo,foo@"); + __asm__(".symver old_foo,foo@VERS_1.1"); + __asm__(".symver old_foo1,foo@VERS_1.2"); + __asm__(".symver new_foo,foo@@VERS_2.0"); + + In this example, `foo@' represents the symbol `foo' bound to the +unspecified base version of the symbol. The source file that contains +this example would define 4 C functions: `original_foo', `old_foo', +`old_foo1', and `new_foo'. + + When you have multiple definitions of a given symbol, there needs to +be some way to specify a default version to which external references to +this symbol will be bound. You can do this with the `foo@@VERS_2.0' +type of `.symver' directive. You can only declare one version of a +symbol as the default in this manner; otherwise you would effectively +have multiple definitions of the same symbol. + + If you wish to bind a reference to a specific version of the symbol +within the shared library, you can use the aliases of convenience (i.e. +`old_foo'), or you can use the `.symver' directive to specifically bind +to an external version of the function in question. + + +File: ld.info, Node: Expressions, Next: Implicit Linker Scripts, Prev: VERSION, Up: Scripts + +Expressions in Linker Scripts +============================= + + The syntax for expressions in the linker script language is +identical to that of C expressions. All expressions are evaluated as +integers. All expressions are evaluated in the same size, which is 32 +bits if both the host and target are 32 bits, and is otherwise 64 bits. + + You can use and set symbol values in expressions. + + The linker defines several special purpose builtin functions for use +in expressions. + +* Menu: + +* Constants:: Constants +* Symbols:: Symbol Names +* Location Counter:: The Location Counter +* Operators:: Operators +* Evaluation:: Evaluation +* Expression Section:: The Section of an Expression +* Builtin Functions:: Builtin Functions + + +File: ld.info, Node: Constants, Next: Symbols, Up: Expressions + +Constants +--------- + + All constants are integers. + + As in C, the linker considers an integer beginning with `0' to be +octal, and an integer beginning with `0x' or `0X' to be hexadecimal. +The linker considers other integers to be decimal. + + In addition, you can use the suffixes `K' and `M' to scale a +constant by `1024' or `1024*1024' respectively. For example, the +following all refer to the same quantity: + _fourk_1 = 4K; + _fourk_2 = 4096; + _fourk_3 = 0x1000; + + +File: ld.info, Node: Symbols, Next: Location Counter, Prev: Constants, Up: Expressions + +Symbol Names +------------ + + Unless quoted, symbol names start with a letter, underscore, or +period and may include letters, digits, underscores, periods, and +hyphens. Unquoted symbol names must not conflict with any keywords. +You can specify a symbol which contains odd characters or has the same +name as a keyword by surrounding the symbol name in double quotes: + "SECTION" = 9; + "with a space" = "also with a space" + 10; + + Since symbols can contain many non-alphabetic characters, it is +safest to delimit symbols with spaces. For example, `A-B' is one +symbol, whereas `A - B' is an expression involving subtraction. + + +File: ld.info, Node: Location Counter, Next: Operators, Prev: Symbols, Up: Expressions + +The Location Counter +-------------------- + + The special linker variable "dot" `.' always contains the current +output location counter. Since the `.' always refers to a location in +an output section, it may only appear in an expression within a +`SECTIONS' command. The `.' symbol may appear anywhere that an +ordinary symbol is allowed in an expression. + + Assigning a value to `.' will cause the location counter to be +moved. This may be used to create holes in the output section. The +location counter may never be moved backwards. + + SECTIONS + { + output : + { + file1(.text) + . = . + 1000; + file2(.text) + . += 1000; + file3(.text) + } = 0x1234; + } + +In the previous example, the `.text' section from `file1' is located at +the beginning of the output section `output'. It is followed by a 1000 +byte gap. Then the `.text' section from `file2' appears, also with a +1000 byte gap following before the `.text' section from `file3'. The +notation `= 0x1234' specifies what data to write in the gaps (*note +Output Section Fill::). + + Note: `.' actually refers to the byte offset from the start of the +current containing object. Normally this is the `SECTIONS' statement, +whoes start address is 0, hence `.' can be used as an absolute address. +If `.' is used inside a section description however, it refers to the +byte offset from the start of that section, not an absolute address. +Thus in a script like this: + + SECTIONS + { + . = 0x100 + .text: { + *(.text) + . = 0x200 + } + . = 0x500 + .data: { + *(.data) + . += 0x600 + } + } + + The `.text' section will be assigned a starting address of 0x100 and +a size of exactly 0x200 bytes, even if there is not enough data in the +`.text' input sections to fill this area. (If there is too much data, +an error will be produced because this would be an attempt to move `.' +backwards). The `.data' section will start at 0x500 and it will have +an extra 0x600 bytes worth of space after the end of the values from +the `.data' input sections and before the end of the `.data' output +section itself. + + +File: ld.info, Node: Operators, Next: Evaluation, Prev: Location Counter, Up: Expressions + +Operators +--------- + + The linker recognizes the standard C set of arithmetic operators, +with the standard bindings and precedence levels: + precedence associativity Operators Notes + (highest) + 1 left ! - ~ (1) + 2 left * / % + 3 left + - + 4 left >> << + 5 left == != > < <= >= + 6 left & + 7 left | + 8 left && + 9 left || + 10 right ? : + 11 right &= += -= *= /= (2) + (lowest) + Notes: (1) Prefix operators (2) *Note Assignments::. + + +File: ld.info, Node: Evaluation, Next: Expression Section, Prev: Operators, Up: Expressions + +Evaluation +---------- + + The linker evaluates expressions lazily. It only computes the value +of an expression when absolutely necessary. + + The linker needs some information, such as the value of the start +address of the first section, and the origins and lengths of memory +regions, in order to do any linking at all. These values are computed +as soon as possible when the linker reads in the linker script. + + However, other values (such as symbol values) are not known or needed +until after storage allocation. Such values are evaluated later, when +other information (such as the sizes of output sections) is available +for use in the symbol assignment expression. + + The sizes of sections cannot be known until after allocation, so +assignments dependent upon these are not performed until after +allocation. + + Some expressions, such as those depending upon the location counter +`.', must be evaluated during section allocation. + + If the result of an expression is required, but the value is not +available, then an error results. For example, a script like the +following + SECTIONS + { + .text 9+this_isnt_constant : + { *(.text) } + } + +will cause the error message `non constant expression for initial +address'. + + +File: ld.info, Node: Expression Section, Next: Builtin Functions, Prev: Evaluation, Up: Expressions + +The Section of an Expression +---------------------------- + + When the linker evaluates an expression, the result is either +absolute or relative to some section. A relative expression is +expressed as a fixed offset from the base of a section. + + The position of the expression within the linker script determines +whether it is absolute or relative. An expression which appears within +an output section definition is relative to the base of the output +section. An expression which appears elsewhere will be absolute. + + A symbol set to a relative expression will be relocatable if you +request relocatable output using the `-r' option. That means that a +further link operation may change the value of the symbol. The symbol's +section will be the section of the relative expression. + + A symbol set to an absolute expression will retain the same value +through any further link operation. The symbol will be absolute, and +will not have any particular associated section. + + You can use the builtin function `ABSOLUTE' to force an expression +to be absolute when it would otherwise be relative. For example, to +create an absolute symbol set to the address of the end of the output +section `.data': + SECTIONS + { + .data : { *(.data) _edata = ABSOLUTE(.); } + } + +If `ABSOLUTE' were not used, `_edata' would be relative to the `.data' +section. + + +File: ld.info, Node: Builtin Functions, Prev: Expression Section, Up: Expressions + +Builtin Functions +----------------- + + The linker script language includes a number of builtin functions for +use in linker script expressions. + +`ABSOLUTE(EXP)' + Return the absolute (non-relocatable, as opposed to non-negative) + value of the expression EXP. Primarily useful to assign an + absolute value to a symbol within a section definition, where + symbol values are normally section relative. *Note Expression + Section::. + +`ADDR(SECTION)' + Return the absolute address (the VMA) of the named SECTION. Your + script must previously have defined the location of that section. + In the following example, `symbol_1' and `symbol_2' are assigned + identical values: + SECTIONS { ... + .output1 : + { + start_of_output_1 = ABSOLUTE(.); + ... + } + .output : + { + symbol_1 = ADDR(.output1); + symbol_2 = start_of_output_1; + } + ... } + +`ALIGN(EXP)' + Return the location counter (`.') aligned to the next EXP + boundary. EXP must be an expression whose value is a power of + two. This is equivalent to + (. + EXP - 1) & ~(EXP - 1) + + `ALIGN' doesn't change the value of the location counter--it just + does arithmetic on it. Here is an example which aligns the output + `.data' section to the next `0x2000' byte boundary after the + preceding section and sets a variable within the section to the + next `0x8000' boundary after the input sections: + SECTIONS { ... + .data ALIGN(0x2000): { + *(.data) + variable = ALIGN(0x8000); + } + ... } + + The first use of `ALIGN' in this example specifies the location of + a section because it is used as the optional ADDRESS attribute of + a section definition (*note Output Section Address::). The second + use of `ALIGN' is used to defines the value of a symbol. + + The builtin function `NEXT' is closely related to `ALIGN'. + +`BLOCK(EXP)' + This is a synonym for `ALIGN', for compatibility with older linker + scripts. It is most often seen when setting the address of an + output section. + +`DEFINED(SYMBOL)' + Return 1 if SYMBOL is in the linker global symbol table and is + defined, otherwise return 0. You can use this function to provide + default values for symbols. For example, the following script + fragment shows how to set a global symbol `begin' to the first + location in the `.text' section--but if a symbol called `begin' + already existed, its value is preserved: + + SECTIONS { ... + .text : { + begin = DEFINED(begin) ? begin : . ; + ... + } + ... + } + +`LOADADDR(SECTION)' + Return the absolute LMA of the named SECTION. This is normally + the same as `ADDR', but it may be different if the `AT' attribute + is used in the output section definition (*note Output Section + LMA::). + +`MAX(EXP1, EXP2)' + Returns the maximum of EXP1 and EXP2. + +`MIN(EXP1, EXP2)' + Returns the minimum of EXP1 and EXP2. + +`NEXT(EXP)' + Return the next unallocated address that is a multiple of EXP. + This function is closely related to `ALIGN(EXP)'; unless you use + the `MEMORY' command to define discontinuous memory for the output + file, the two functions are equivalent. + +`SIZEOF(SECTION)' + Return the size in bytes of the named SECTION, if that section has + been allocated. If the section has not been allocated when this is + evaluated, the linker will report an error. In the following + example, `symbol_1' and `symbol_2' are assigned identical values: + SECTIONS{ ... + .output { + .start = . ; + ... + .end = . ; + } + symbol_1 = .end - .start ; + symbol_2 = SIZEOF(.output); + ... } + +`SIZEOF_HEADERS' +`sizeof_headers' + Return the size in bytes of the output file's headers. This is + information which appears at the start of the output file. You + can use this number when setting the start address of the first + section, if you choose, to facilitate paging. + + When producing an ELF output file, if the linker script uses the + `SIZEOF_HEADERS' builtin function, the linker must compute the + number of program headers before it has determined all the section + addresses and sizes. If the linker later discovers that it needs + additional program headers, it will report an error `not enough + room for program headers'. To avoid this error, you must avoid + using the `SIZEOF_HEADERS' function, or you must rework your linker + script to avoid forcing the linker to use additional program + headers, or you must define the program headers yourself using the + `PHDRS' command (*note PHDRS::). + + +File: ld.info, Node: Implicit Linker Scripts, Prev: Expressions, Up: Scripts + +Implicit Linker Scripts +======================= + + If you specify a linker input file which the linker can not +recognize as an object file or an archive file, it will try to read the +file as a linker script. If the file can not be parsed as a linker +script, the linker will report an error. + + An implicit linker script will not replace the default linker script. + + Typically an implicit linker script would contain only symbol +assignments, or the `INPUT', `GROUP', or `VERSION' commands. + + Any input files read because of an implicit linker script will be +read at the position in the command line where the implicit linker +script was read. This can affect archive searching. + + +File: ld.info, Node: Machine Dependent, Next: BFD, Prev: Scripts, Up: Top + +Machine Dependent Features +************************** + + `ld' has additional features on some platforms; the following +sections describe them. Machines where `ld' has no additional +functionality are not listed. + +* Menu: + +* H8/300:: `ld' and the H8/300 +* i960:: `ld' and the Intel 960 family +* ARM:: `ld' and the ARM family + + +File: ld.info, Node: H8/300, Next: i960, Up: Machine Dependent + +`ld' and the H8/300 +=================== + + For the H8/300, `ld' can perform these global optimizations when you +specify the `--relax' command-line option. + +_relaxing address modes_ + `ld' finds all `jsr' and `jmp' instructions whose targets are + within eight bits, and turns them into eight-bit program-counter + relative `bsr' and `bra' instructions, respectively. + +_synthesizing instructions_ + `ld' finds all `mov.b' instructions which use the sixteen-bit + absolute address form, but refer to the top page of memory, and + changes them to use the eight-bit address form. (That is: the + linker turns `mov.b `@'AA:16' into `mov.b `@'AA:8' whenever the + address AA is in the top page of memory). + + +File: ld.info, Node: i960, Next: ARM, Prev: H8/300, Up: Machine Dependent + +`ld' and the Intel 960 family +============================= + + You can use the `-AARCHITECTURE' command line option to specify one +of the two-letter names identifying members of the 960 family; the +option specifies the desired output target, and warns of any +incompatible instructions in the input files. It also modifies the +linker's search strategy for archive libraries, to support the use of +libraries specific to each particular architecture, by including in the +search loop names suffixed with the string identifying the architecture. + + For example, if your `ld' command line included `-ACA' as well as +`-ltry', the linker would look (in its built-in search paths, and in +any paths you specify with `-L') for a library with the names + + try + libtry.a + tryca + libtryca.a + +The first two possibilities would be considered in any event; the last +two are due to the use of `-ACA'. + + You can meaningfully use `-A' more than once on a command line, since +the 960 architecture family allows combination of target architectures; +each use will add another pair of name variants to search for when `-l' +specifies a library. + + `ld' supports the `--relax' option for the i960 family. If you +specify `--relax', `ld' finds all `balx' and `calx' instructions whose +targets are within 24 bits, and turns them into 24-bit program-counter +relative `bal' and `cal' instructions, respectively. `ld' also turns +`cal' instructions into `bal' instructions when it determines that the +target subroutine is a leaf routine (that is, the target subroutine does +not itself call any subroutines). + + +File: ld.info, Node: ARM, Prev: i960, Up: Machine Dependent + +`ld''s support for interworking between ARM and Thumb code +========================================================== + + For the ARM, `ld' will generate code stubs to allow functions calls +betweem ARM and Thumb code. These stubs only work with code that has +been compiled and assembled with the `-mthumb-interwork' command line +option. If it is necessary to link with old ARM object files or +libraries, which have not been compiled with the -mthumb-interwork +option then the `--support-old-code' command line switch should be +given to the linker. This will make it generate larger stub functions +which will work with non-interworking aware ARM code. Note, however, +the linker does not support generating stubs for function calls to +non-interworking aware Thumb code. + + The `--thumb-entry' switch is a duplicate of the generic `--entry' +switch, in that it sets the program's starting address. But it also +sets the bottom bit of the address, so that it can be branched to using +a BX instruction, and the program will start executing in Thumb mode +straight away. + + +File: ld.info, Node: BFD, Next: Reporting Bugs, Prev: Machine Dependent, Up: Top + +BFD +*** + + The linker accesses object and archive files using the BFD libraries. +These libraries allow the linker to use the same routines to operate on +object files whatever the object file format. A different object file +format can be supported simply by creating a new BFD back end and adding +it to the library. To conserve runtime memory, however, the linker and +associated tools are usually configured to support only a subset of the +object file formats available. You can use `objdump -i' (*note +objdump: (binutils.info)objdump.) to list all the formats available for +your configuration. + + As with most implementations, BFD is a compromise between several +conflicting requirements. The major factor influencing BFD design was +efficiency: any time used converting between formats is time which +would not have been spent had BFD not been involved. This is partly +offset by abstraction payback; since BFD simplifies applications and +back ends, more time and care may be spent optimizing algorithms for a +greater speed. + + One minor artifact of the BFD solution which you should bear in mind +is the potential for information loss. There are two places where +useful information can be lost using the BFD mechanism: during +conversion and during output. *Note BFD information loss::. + +* Menu: + +* BFD outline:: How it works: an outline of BFD + + +File: ld.info, Node: BFD outline, Up: BFD + +How it works: an outline of BFD +=============================== + + When an object file is opened, BFD subroutines automatically +determine the format of the input object file. They then build a +descriptor in memory with pointers to routines that will be used to +access elements of the object file's data structures. + + As different information from the the object files is required, BFD +reads from different sections of the file and processes them. For +example, a very common operation for the linker is processing symbol +tables. Each BFD back end provides a routine for converting between +the object file's representation of symbols and an internal canonical +format. When the linker asks for the symbol table of an object file, it +calls through a memory pointer to the routine from the relevant BFD +back end which reads and converts the table into a canonical form. The +linker then operates upon the canonical form. When the link is finished +and the linker writes the output file's symbol table, another BFD back +end routine is called to take the newly created symbol table and +convert it into the chosen output format. + +* Menu: + +* BFD information loss:: Information Loss +* Canonical format:: The BFD canonical object-file format + + +File: ld.info, Node: BFD information loss, Next: Canonical format, Up: BFD outline + +Information Loss +---------------- + + _Information can be lost during output._ The output formats +supported by BFD do not provide identical facilities, and information +which can be described in one form has nowhere to go in another format. +One example of this is alignment information in `b.out'. There is +nowhere in an `a.out' format file to store alignment information on the +contained data, so when a file is linked from `b.out' and an `a.out' +image is produced, alignment information will not propagate to the +output file. (The linker will still use the alignment information +internally, so the link is performed correctly). + + Another example is COFF section names. COFF files may contain an +unlimited number of sections, each one with a textual section name. If +the target of the link is a format which does not have many sections +(e.g., `a.out') or has sections without names (e.g., the Oasys format), +the link cannot be done simply. You can circumvent this problem by +describing the desired input-to-output section mapping with the linker +command language. + + _Information can be lost during canonicalization._ The BFD internal +canonical form of the external formats is not exhaustive; there are +structures in input formats for which there is no direct representation +internally. This means that the BFD back ends cannot maintain all +possible data richness through the transformation between external to +internal and back to external formats. + + This limitation is only a problem when an application reads one +format and writes another. Each BFD back end is responsible for +maintaining as much data as possible, and the internal BFD canonical +form has structures which are opaque to the BFD core, and exported only +to the back ends. When a file is read in one format, the canonical form +is generated for BFD and the application. At the same time, the back +end saves away any information which may otherwise be lost. If the data +is then written back in the same format, the back end routine will be +able to use the canonical form provided by the BFD core as well as the +information it prepared earlier. Since there is a great deal of +commonality between back ends, there is no information lost when +linking or copying big endian COFF to little endian COFF, or `a.out' to +`b.out'. When a mixture of formats is linked, the information is only +lost from the files whose format differs from the destination. + + +File: ld.info, Node: Canonical format, Prev: BFD information loss, Up: BFD outline + +The BFD canonical object-file format +------------------------------------ + + The greatest potential for loss of information occurs when there is +the least overlap between the information provided by the source +format, that stored by the canonical format, and that needed by the +destination format. A brief description of the canonical form may help +you understand which kinds of data you can count on preserving across +conversions. + +_files_ + Information stored on a per-file basis includes target machine + architecture, particular implementation format type, a demand + pageable bit, and a write protected bit. Information like Unix + magic numbers is not stored here--only the magic numbers' meaning, + so a `ZMAGIC' file would have both the demand pageable bit and the + write protected text bit set. The byte order of the target is + stored on a per-file basis, so that big- and little-endian object + files may be used with one another. + +_sections_ + Each section in the input file contains the name of the section, + the section's original address in the object file, size and + alignment information, various flags, and pointers into other BFD + data structures. + +_symbols_ + Each symbol contains a pointer to the information for the object + file which originally defined it, its name, its value, and various + flag bits. When a BFD back end reads in a symbol table, it + relocates all symbols to make them relative to the base of the + section where they were defined. Doing this ensures that each + symbol points to its containing section. Each symbol also has a + varying amount of hidden private data for the BFD back end. Since + the symbol points to the original file, the private data format + for that symbol is accessible. `ld' can operate on a collection + of symbols of wildly different formats without problems. + + Normal global and simple local symbols are maintained on output, + so an output file (no matter its format) will retain symbols + pointing to functions and to global, static, and common variables. + Some symbol information is not worth retaining; in `a.out', type + information is stored in the symbol table as long symbol names. + This information would be useless to most COFF debuggers; the + linker has command line switches to allow users to throw it away. + + There is one word of type information within the symbol, so if the + format supports symbol type information within symbols (for + example, COFF, IEEE, Oasys) and the type is simple enough to fit + within one word (nearly everything but aggregates), the + information will be preserved. + +_relocation level_ + Each canonical BFD relocation record contains a pointer to the + symbol to relocate to, the offset of the data to relocate, the + section the data is in, and a pointer to a relocation type + descriptor. Relocation is performed by passing messages through + the relocation type descriptor and the symbol pointer. Therefore, + relocations can be performed on output data using a relocation + method that is only available in one of the input formats. For + instance, Oasys provides a byte relocation format. A relocation + record requesting this relocation type would point indirectly to a + routine to perform this, so the relocation may be performed on a + byte being written to a 68k COFF file, even though 68k COFF has no + such relocation type. + +_line numbers_ + Object formats can contain, for debugging purposes, some form of + mapping between symbols, source line numbers, and addresses in the + output file. These addresses have to be relocated along with the + symbol information. Each symbol with an associated list of line + number records points to the first record of the list. The head + of a line number list consists of a pointer to the symbol, which + allows finding out the address of the function whose line number + is being described. The rest of the list is made up of pairs: + offsets into the section and line numbers. Any format which can + simply derive this information can pass it successfully between + formats (COFF, IEEE and Oasys). + + +File: ld.info, Node: Reporting Bugs, Next: MRI, Prev: BFD, Up: Top + +Reporting Bugs +************** + + Your bug reports play an essential role in making `ld' reliable. + + Reporting a bug may help you by bringing a solution to your problem, +or it may not. But in any case the principal function of a bug report +is to help the entire community by making the next version of `ld' work +better. Bug reports are your contribution to the maintenance of `ld'. + + In order for a bug report to serve its purpose, you must include the +information that enables us to fix the bug. + +* Menu: + +* Bug Criteria:: Have you found a bug? +* Bug Reporting:: How to report bugs + + +File: ld.info, Node: Bug Criteria, Next: Bug Reporting, Up: Reporting Bugs + +Have you found a bug? +===================== + + If you are not sure whether you have found a bug, here are some +guidelines: + + * If the linker gets a fatal signal, for any input whatever, that is + a `ld' bug. Reliable linkers never crash. + + * If `ld' produces an error message for valid input, that is a bug. + + * If `ld' does not produce an error message for invalid input, that + may be a bug. In the general case, the linker can not verify that + object files are correct. + + * If you are an experienced user of linkers, your suggestions for + improvement of `ld' are welcome in any case. + diff --git a/ld/ld.info-4 b/ld/ld.info-4 new file mode 100644 index 00000000000..f51054d1823 --- /dev/null +++ b/ld/ld.info-4 @@ -0,0 +1,759 @@ +This is ld.info, produced by makeinfo version 4.0 from ./ld.texinfo. + +START-INFO-DIR-ENTRY +* Ld: (ld). The GNU linker. +END-INFO-DIR-ENTRY + + This file documents the GNU linker LD version 2.10. + + Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free +Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the entire resulting derived work is distributed under the terms +of a permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions. + + +File: ld.info, Node: Bug Reporting, Prev: Bug Criteria, Up: Reporting Bugs + +How to report bugs +================== + + A number of companies and individuals offer support for GNU +products. If you obtained `ld' from a support organization, we +recommend you contact that organization first. + + You can find contact information for many support companies and +individuals in the file `etc/SERVICE' in the GNU Emacs distribution. + + Otherwise, send bug reports for `ld' to `bug-gnu-utils@gnu.org'. + + The fundamental principle of reporting bugs usefully is this: +*report all the facts*. If you are not sure whether to state a fact or +leave it out, state it! + + Often people omit facts because they think they know what causes the +problem and assume that some details do not matter. Thus, you might +assume that the name of a symbol you use in an example does not matter. +Well, probably it does not, but one cannot be sure. Perhaps the bug is +a stray memory reference which happens to fetch from the location where +that name is stored in memory; perhaps, if the name were different, the +contents of that location would fool the linker into doing the right +thing despite the bug. Play it safe and give a specific, complete +example. That is the easiest thing for you to do, and the most helpful. + + Keep in mind that the purpose of a bug report is to enable us to fix +the bug if it is new to us. Therefore, always write your bug reports +on the assumption that the bug has not been reported previously. + + Sometimes people give a few sketchy facts and ask, "Does this ring a +bell?" Those bug reports are useless, and we urge everyone to _refuse +to respond to them_ except to chide the sender to report bugs properly. + + To enable us to fix the bug, you should include all these things: + + * The version of `ld'. `ld' announces it if you start it with the + `--version' argument. + + Without this, we will not know whether there is any point in + looking for the bug in the current version of `ld'. + + * Any patches you may have applied to the `ld' source, including any + patches made to the `BFD' library. + + * The type of machine you are using, and the operating system name + and version number. + + * What compiler (and its version) was used to compile `ld'--e.g. + "`gcc-2.7'". + + * The command arguments you gave the linker to link your example and + observe the bug. To guarantee you will not omit something + important, list them all. A copy of the Makefile (or the output + from make) is sufficient. + + If we were to try to guess the arguments, we would probably guess + wrong and then we might not encounter the bug. + + * A complete input file, or set of input files, that will reproduce + the bug. It is generally most helpful to send the actual object + files, uuencoded if necessary to get them through the mail system. + Making them available for anonymous FTP is not as good, but may + be the only reasonable choice for large object files. + + If the source files were assembled using `gas' or compiled using + `gcc', then it may be OK to send the source files rather than the + object files. In this case, be sure to say exactly what version of + `gas' or `gcc' was used to produce the object files. Also say how + `gas' or `gcc' were configured. + + * A description of what behavior you observe that you believe is + incorrect. For example, "It gets a fatal signal." + + Of course, if the bug is that `ld' gets a fatal signal, then we + will certainly notice it. But if the bug is incorrect output, we + might not notice unless it is glaringly wrong. You might as well + not give us a chance to make a mistake. + + Even if the problem you experience is a fatal signal, you should + still say so explicitly. Suppose something strange is going on, + such as, your copy of `ld' is out of synch, or you have + encountered a bug in the C library on your system. (This has + happened!) Your copy might crash and ours would not. If you told + us to expect a crash, then when ours fails to crash, we would know + that the bug was not happening for us. If you had not told us to + expect a crash, then we would not be able to draw any conclusion + from our observations. + + * If you wish to suggest changes to the `ld' source, send us context + diffs, as generated by `diff' with the `-u', `-c', or `-p' option. + Always send diffs from the old file to the new file. If you even + discuss something in the `ld' source, refer to it by context, not + by line number. + + The line numbers in our development sources will not match those + in your sources. Your line numbers would convey no useful + information to us. + + Here are some things that are not necessary: + + * A description of the envelope of the bug. + + Often people who encounter a bug spend a lot of time investigating + which changes to the input file will make the bug go away and which + changes will not affect it. + + This is often time consuming and not very useful, because the way + we will find the bug is by running a single example under the + debugger with breakpoints, not by pure deduction from a series of + examples. We recommend that you save your time for something else. + + Of course, if you can find a simpler example to report _instead_ + of the original one, that is a convenience for us. Errors in the + output will be easier to spot, running under the debugger will take + less time, and so on. + + However, simplification is not vital; if you do not want to do + this, report the bug anyway and send us the entire test case you + used. + + * A patch for the bug. + + A patch for the bug does help us if it is a good one. But do not + omit the necessary information, such as the test case, on the + assumption that a patch is all we need. We might see problems + with your patch and decide to fix the problem another way, or we + might not understand it at all. + + Sometimes with a program as complicated as `ld' it is very hard to + construct an example that will make the program follow a certain + path through the code. If you do not send us the example, we will + not be able to construct one, so we will not be able to verify + that the bug is fixed. + + And if we cannot understand what bug you are trying to fix, or why + your patch should be an improvement, we will not install it. A + test case will help us to understand. + + * A guess about what the bug is or what it depends on. + + Such guesses are usually wrong. Even we cannot guess right about + such things without first using the debugger to find the facts. + + +File: ld.info, Node: MRI, Next: Index, Prev: Reporting Bugs, Up: Top + +MRI Compatible Script Files +*************************** + + To aid users making the transition to GNU `ld' from the MRI linker, +`ld' can use MRI compatible linker scripts as an alternative to the +more general-purpose linker scripting language described in *Note +Scripts::. MRI compatible linker scripts have a much simpler command +set than the scripting language otherwise used with `ld'. GNU `ld' +supports the most commonly used MRI linker commands; these commands are +described here. + + In general, MRI scripts aren't of much use with the `a.out' object +file format, since it only has three sections and MRI scripts lack some +features to make use of them. + + You can specify a file containing an MRI-compatible script using the +`-c' command-line option. + + Each command in an MRI-compatible script occupies its own line; each +command line starts with the keyword that identifies the command (though +blank lines are also allowed for punctuation). If a line of an +MRI-compatible script begins with an unrecognized keyword, `ld' issues +a warning message, but continues processing the script. + + Lines beginning with `*' are comments. + + You can write these commands using all upper-case letters, or all +lower case; for example, `chip' is the same as `CHIP'. The following +list shows only the upper-case form of each command. + +`ABSOLUTE SECNAME' +`ABSOLUTE SECNAME, SECNAME, ... SECNAME' + Normally, `ld' includes in the output file all sections from all + the input files. However, in an MRI-compatible script, you can + use the `ABSOLUTE' command to restrict the sections that will be + present in your output program. If the `ABSOLUTE' command is used + at all in a script, then only the sections named explicitly in + `ABSOLUTE' commands will appear in the linker output. You can + still use other input sections (whatever you select on the command + line, or using `LOAD') to resolve addresses in the output file. + +`ALIAS OUT-SECNAME, IN-SECNAME' + Use this command to place the data from input section IN-SECNAME + in a section called OUT-SECNAME in the linker output file. + + IN-SECNAME may be an integer. + +`ALIGN SECNAME = EXPRESSION' + Align the section called SECNAME to EXPRESSION. The EXPRESSION + should be a power of two. + +`BASE EXPRESSION' + Use the value of EXPRESSION as the lowest address (other than + absolute addresses) in the output file. + +`CHIP EXPRESSION' +`CHIP EXPRESSION, EXPRESSION' + This command does nothing; it is accepted only for compatibility. + +`END' + This command does nothing whatever; it's only accepted for + compatibility. + +`FORMAT OUTPUT-FORMAT' + Similar to the `OUTPUT_FORMAT' command in the more general linker + language, but restricted to one of these output formats: + + 1. S-records, if OUTPUT-FORMAT is `S' + + 2. IEEE, if OUTPUT-FORMAT is `IEEE' + + 3. COFF (the `coff-m68k' variant in BFD), if OUTPUT-FORMAT is + `COFF' + +`LIST ANYTHING...' + Print (to the standard output file) a link map, as produced by the + `ld' command-line option `-M'. + + The keyword `LIST' may be followed by anything on the same line, + with no change in its effect. + +`LOAD FILENAME' +`LOAD FILENAME, FILENAME, ... FILENAME' + Include one or more object file FILENAME in the link; this has the + same effect as specifying FILENAME directly on the `ld' command + line. + +`NAME OUTPUT-NAME' + OUTPUT-NAME is the name for the program produced by `ld'; the + MRI-compatible command `NAME' is equivalent to the command-line + option `-o' or the general script language command `OUTPUT'. + +`ORDER SECNAME, SECNAME, ... SECNAME' +`ORDER SECNAME SECNAME SECNAME' + Normally, `ld' orders the sections in its output file in the order + in which they first appear in the input files. In an + MRI-compatible script, you can override this ordering with the + `ORDER' command. The sections you list with `ORDER' will appear + first in your output file, in the order specified. + +`PUBLIC NAME=EXPRESSION' +`PUBLIC NAME,EXPRESSION' +`PUBLIC NAME EXPRESSION' + Supply a value (EXPRESSION) for external symbol NAME used in the + linker input files. + +`SECT SECNAME, EXPRESSION' +`SECT SECNAME=EXPRESSION' +`SECT SECNAME EXPRESSION' + You can use any of these three forms of the `SECT' command to + specify the start address (EXPRESSION) for section SECNAME. If + you have more than one `SECT' statement for the same SECNAME, only + the _first_ sets the start address. + + +File: ld.info, Node: Index, Prev: MRI, Up: Top + +Index +***** + +* Menu: + +* ": Symbols. +* -(: Options. +* --add-stdcall-alias: Options. +* --architecture=ARCH: Options. +* --auxiliary: Options. +* --base-file: Options. +* --check-sections: Options. +* --cref: Options. +* --defsym SYMBOL=EXP: Options. +* --demangle: Options. +* --disable-stdcall-fixup: Options. +* --discard-all: Options. +* --discard-locals: Options. +* --dll: Options. +* --dynamic-linker FILE: Options. +* --embedded-relocs: Options. +* --enable-stdcall-fixup: Options. +* --entry=ENTRY: Options. +* --exclude-symbols: Options. +* --export-all-symbols: Options. +* --export-dynamic: Options. +* --file-alignment: Options. +* --filter: Options. +* --force-exe-suffix: Options. +* --format=FORMAT: Options. +* --gc-sections: Options. +* --gpsize: Options. +* --heap: Options. +* --help: Options. +* --image-base: Options. +* --just-symbols=FILE: Options. +* --kill-at: Options. +* --library-path=DIR: Options. +* --library=ARCHIVE: Options. +* --major-image-version: Options. +* --major-os-version: Options. +* --major-subsystem-version: Options. +* --minor-image-version: Options. +* --minor-os-version: Options. +* --minor-subsystem-version: Options. +* --mri-script=MRI-CMDFILE: Options. +* --nmagic: Options. +* --no-check-sections: Options. +* --no-demangle: Options. +* --no-gc-sections: Options. +* --no-keep-memory: Options. +* --no-undefined: Options. +* --no-warn-mismatch: Options. +* --no-whole-archive: Options. +* --noinhibit-exec: Options. +* --oformat: Options. +* --omagic: Options. +* --output-def: Options. +* --output=OUTPUT: Options. +* --print-map: Options. +* --relax: Options. +* --relax on i960: i960. +* --relocateable: Options. +* --script=SCRIPT: Options. +* --section-alignment: Options. +* --sort-common: Options. +* --split-by-file: Options. +* --split-by-reloc: Options. +* --stack: Options. +* --stats: Options. +* --strip-all: Options. +* --strip-debug: Options. +* --subsystem: Options. +* --support-old-code: ARM. +* --thumb-entry=ENTRY: ARM. +* --trace: Options. +* --trace-symbol=SYMBOL: Options. +* --traditional-format: Options. +* --undefined=SYMBOL: Options. +* --verbose: Options. +* --version: Options. +* --version-script=VERSION-SCRIPTFILE: Options. +* --warn-comon: Options. +* --warn-constructors: Options. +* --warn-multiple-gp: Options. +* --warn-once: Options. +* --warn-section-align: Options. +* --whole-archive: Options. +* --wrap: Options. +* -AARCH: Options. +* -aKEYWORD: Options. +* -assert KEYWORD: Options. +* -b FORMAT: Options. +* -Bdynamic: Options. +* -Bshareable: Options. +* -Bstatic: Options. +* -Bsymbolic: Options. +* -c MRI-CMDFILE: Options. +* -call_shared: Options. +* -d: Options. +* -dc: Options. +* -dn: Options. +* -dp: Options. +* -dy: Options. +* -E: Options. +* -e ENTRY: Options. +* -EB: Options. +* -EL: Options. +* -F: Options. +* -f: Options. +* -fini: Options. +* -G: Options. +* -g: Options. +* -hNAME: Options. +* -i: Options. +* -init: Options. +* -lARCHIVE: Options. +* -LDIR: Options. +* -M: Options. +* -m EMULATION: Options. +* -Map: Options. +* -N: Options. +* -n: Options. +* -non_shared: Options. +* -O LEVEL: Options. +* -o OUTPUT: Options. +* -qmagic: Options. +* -Qy: Options. +* -r: Options. +* -R FILE: Options. +* -rpath: Options. +* -rpath-link: Options. +* -S: Options. +* -s: Options. +* -shared: Options. +* -soname=NAME: Options. +* -static: Options. +* -t: Options. +* -T SCRIPT: Options. +* -Tbss ORG: Options. +* -Tdata ORG: Options. +* -Ttext ORG: Options. +* -u SYMBOL: Options. +* -Ur: Options. +* -V: Options. +* -v: Options. +* -X: Options. +* -x: Options. +* -Y PATH: Options. +* -y SYMBOL: Options. +* -z KEYWORD: Options. +* .: Location Counter. +* /DISCARD/: Output Section Discarding. +* :PHDR: Output Section Phdr. +* =FILLEXP: Output Section Fill. +* >REGION: Output Section Region. +* [COMMON]: Input Section Common. +* ABSOLUTE (MRI): MRI. +* absolute and relocatable symbols: Expression Section. +* absolute expressions: Expression Section. +* ABSOLUTE(EXP): Builtin Functions. +* ADDR(SECTION): Builtin Functions. +* address, section: Output Section Address. +* ALIAS (MRI): MRI. +* ALIGN (MRI): MRI. +* align location counter: Builtin Functions. +* ALIGN(EXP): Builtin Functions. +* allocating memory: MEMORY. +* architecture: Miscellaneous Commands. +* architectures: Options. +* archive files, from cmd line: Options. +* archive search path in linker script: File Commands. +* arithmetic: Expressions. +* arithmetic operators: Operators. +* ARM interworking support: ARM. +* ASSERT: Miscellaneous Commands. +* assertion in linker script: Miscellaneous Commands. +* assignment in scripts: Assignments. +* AT(LMA): Output Section LMA. +* AT>LMA_REGION: Output Section LMA. +* back end: BFD. +* BASE (MRI): MRI. +* BFD canonical format: Canonical format. +* BFD requirements: BFD. +* big-endian objects: Options. +* binary input format: Options. +* BLOCK(EXP): Builtin Functions. +* bug criteria: Bug Criteria. +* bug reports: Bug Reporting. +* bugs in ld: Reporting Bugs. +* BYTE(EXPRESSION): Output Section Data. +* C++ constructors, arranging in link: Output Section Keywords. +* CHIP (MRI): MRI. +* COLLECT_NO_DEMANGLE: Environment. +* combining symbols, warnings on: Options. +* command files: Scripts. +* command line: Options. +* common allocation: Options. +* common allocation in linker script: Miscellaneous Commands. +* common symbol placement: Input Section Common. +* compatibility, MRI: Options. +* constants in linker scripts: Constants. +* CONSTRUCTORS: Output Section Keywords. +* constructors: Options. +* constructors, arranging in link: Output Section Keywords. +* crash of linker: Bug Criteria. +* CREATE_OBJECT_SYMBOLS: Output Section Keywords. +* cross reference table: Options. +* cross references: Miscellaneous Commands. +* current output location: Location Counter. +* data: Output Section Data. +* dbx: Options. +* DEF files, creating: Options. +* default emulation: Environment. +* default input format: Environment. +* DEFINED(SYMBOL): Builtin Functions. +* deleting local symbols: Options. +* demangling, default: Environment. +* demangling, from command line: Options. +* discarding sections: Output Section Discarding. +* discontinuous memory: MEMORY. +* DLLs, creating: Options. +* dot: Location Counter. +* dot inside sections: Location Counter. +* dynamic linker, from command line: Options. +* dynamic symbol table: Options. +* ELF program headers: PHDRS. +* emulation: Options. +* emulation, default: Environment. +* END (MRI): MRI. +* endianness: Options. +* entry point: Entry Point. +* entry point, from command line: Options. +* entry point, thumb: ARM. +* ENTRY(SYMBOL): Entry Point. +* error on valid input: Bug Criteria. +* example of linker script: Simple Example. +* expression evaluation order: Evaluation. +* expression sections: Expression Section. +* expression, absolute: Builtin Functions. +* expressions: Expressions. +* EXTERN: Miscellaneous Commands. +* fatal signal: Bug Criteria. +* file name wildcard patterns: Input Section Wildcards. +* FILEHDR: PHDRS. +* filename symbols: Output Section Keywords. +* fill pattern, entire section: Output Section Fill. +* FILL(EXPRESSION): Output Section Data. +* finalization function: Options. +* first input file: File Commands. +* first instruction: Entry Point. +* FORCE_COMMON_ALLOCATION: Miscellaneous Commands. +* FORMAT (MRI): MRI. +* functions in expressions: Builtin Functions. +* garbage collection <1>: Input Section Keep. +* garbage collection: Options. +* generating optimized output: Options. +* GNU linker: Overview. +* GNUTARGET: Environment. +* GROUP(FILES): File Commands. +* grouping input files: File Commands. +* groups of archives: Options. +* H8/300 support: H8/300. +* header size: Builtin Functions. +* heap size: Options. +* help: Options. +* holes: Location Counter. +* holes, filling: Output Section Data. +* i960 support: i960. +* image base: Options. +* implicit linker scripts: Implicit Linker Scripts. +* INCLUDE FILENAME: File Commands. +* including a linker script: File Commands. +* including an entire archive: Options. +* incremental link: Options. +* initialization function: Options. +* initialized data in ROM: Output Section LMA. +* input file format in linker script: Format Commands. +* input filename symbols: Output Section Keywords. +* input files in linker scripts: File Commands. +* input files, displaying: Options. +* input format: Options. +* input object files in linker scripts: File Commands. +* input section basics: Input Section Basics. +* input section wildcards: Input Section Wildcards. +* input sections: Input Section. +* INPUT(FILES): File Commands. +* integer notation: Constants. +* integer suffixes: Constants. +* internal object-file format: Canonical format. +* invalid input: Bug Criteria. +* K and M integer suffixes: Constants. +* KEEP: Input Section Keep. +* l =: MEMORY. +* L, deleting symbols beginning: Options. +* lazy evaluation: Evaluation. +* ld bugs, reporting: Bug Reporting. +* LDEMULATION: Environment. +* len =: MEMORY. +* LENGTH =: MEMORY. +* library search path in linker script: File Commands. +* link map: Options. +* link-time runtime library search path: Options. +* linker crash: Bug Criteria. +* linker script concepts: Basic Script Concepts. +* linker script example: Simple Example. +* linker script file commands: File Commands. +* linker script format: Script Format. +* linker script input object files: File Commands. +* linker script simple commands: Simple Commands. +* linker scripts: Scripts. +* LIST (MRI): MRI. +* little-endian objects: Options. +* LOAD (MRI): MRI. +* load address: Output Section LMA. +* LOADADDR(SECTION): Builtin Functions. +* loading, preventing: Output Section Type. +* local symbols, deleting: Options. +* location counter: Location Counter. +* LONG(EXPRESSION): Output Section Data. +* M and K integer suffixes: Constants. +* machine architecture: Miscellaneous Commands. +* machine dependencies: Machine Dependent. +* mapping input sections to output sections: Input Section. +* MAX: Builtin Functions. +* MEMORY: MEMORY. +* memory region attributes: MEMORY. +* memory regions: MEMORY. +* memory regions and sections: Output Section Region. +* memory usage: Options. +* MIN: Builtin Functions. +* MIPS embedded PIC code: Options. +* MRI compatibility: MRI. +* NAME (MRI): MRI. +* name, section: Output Section Name. +* names: Symbols. +* naming the output file: Options. +* NEXT(EXP): Builtin Functions. +* NMAGIC: Options. +* NOCROSSREFS(SECTIONS): Miscellaneous Commands. +* NOLOAD: Output Section Type. +* not enough room for program headers: Builtin Functions. +* o =: MEMORY. +* objdump -i: BFD. +* object file management: BFD. +* object files: Options. +* object formats available: BFD. +* object size: Options. +* OMAGIC: Options. +* opening object files: BFD outline. +* operators for arithmetic: Operators. +* options: Options. +* ORDER (MRI): MRI. +* org =: MEMORY. +* ORIGIN =: MEMORY. +* output file after errors: Options. +* output file format in linker script: Format Commands. +* output file name in linker scripot: File Commands. +* output section attributes: Output Section Attributes. +* output section data: Output Section Data. +* OUTPUT(FILENAME): File Commands. +* OUTPUT_ARCH(BFDARCH): Miscellaneous Commands. +* OUTPUT_FORMAT(BFDNAME): Format Commands. +* OVERLAY: Overlay Description. +* overlays: Overlay Description. +* partial link: Options. +* PHDRS: PHDRS. +* precedence in expressions: Operators. +* prevent unnecessary loading: Output Section Type. +* program headers: PHDRS. +* program headers and sections: Output Section Phdr. +* program headers, not enough room: Builtin Functions. +* program segments: PHDRS. +* PROVIDE: PROVIDE. +* PUBLIC (MRI): MRI. +* QUAD(EXPRESSION): Output Section Data. +* quoted symbol names: Symbols. +* read-only text: Options. +* read/write from cmd line: Options. +* regions of memory: MEMORY. +* relative expressions: Expression Section. +* relaxing addressing modes: Options. +* relaxing on H8/300: H8/300. +* relaxing on i960: i960. +* relocatable and absolute symbols: Expression Section. +* relocatable output: Options. +* removing sections: Output Section Discarding. +* reporting bugs in ld: Reporting Bugs. +* requirements for BFD: BFD. +* retaining specified symbols: Options. +* ROM initialized data: Output Section LMA. +* round up location counter: Builtin Functions. +* runtime library name: Options. +* runtime library search path: Options. +* scaled integers: Constants. +* scommon section: Input Section Common. +* script files: Options. +* scripts: Scripts. +* search directory, from cmd line: Options. +* search path in linker script: File Commands. +* SEARCH_DIR(PATH): File Commands. +* SECT (MRI): MRI. +* section address: Output Section Address. +* section address in expression: Builtin Functions. +* section alignment, warnings on: Options. +* section data: Output Section Data. +* section fill pattern: Output Section Fill. +* section load address: Output Section LMA. +* section load address in expression: Builtin Functions. +* section name: Output Section Name. +* section name wildcard patterns: Input Section Wildcards. +* section size: Builtin Functions. +* section, assigning to memory region: Output Section Region. +* section, assigning to program header: Output Section Phdr. +* SECTIONS: SECTIONS. +* sections, discarding: Output Section Discarding. +* segment origins, cmd line: Options. +* segments, ELF: PHDRS. +* shared libraries: Options. +* SHORT(EXPRESSION): Output Section Data. +* SIZEOF(SECTION): Builtin Functions. +* SIZEOF_HEADERS: Builtin Functions. +* small common symbols: Input Section Common. +* SORT: Input Section Wildcards. +* SQUAD(EXPRESSION): Output Section Data. +* stack size: Options. +* standard Unix system: Options. +* start of execution: Entry Point. +* STARTUP(FILENAME): File Commands. +* strip all symbols: Options. +* strip debugger symbols: Options. +* stripping all but some symbols: Options. +* suffixes for integers: Constants. +* symbol defaults: Builtin Functions. +* symbol definition, scripts: Assignments. +* symbol names: Symbols. +* symbol tracing: Options. +* symbol versions: VERSION. +* symbol-only input: Options. +* symbols, from command line: Options. +* symbols, relocatable and absolute: Expression Section. +* symbols, retaining selectively: Options. +* synthesizing linker: Options. +* synthesizing on H8/300: H8/300. +* TARGET(BFDNAME): Format Commands. +* thumb entry point: ARM. +* traditional format: Options. +* unallocated address, next: Builtin Functions. +* undefined symbol: Options. +* undefined symbol in linker script: Miscellaneous Commands. +* undefined symbols, warnings on: Options. +* uninitialized data placement: Input Section Common. +* unspecified memory: Output Section Data. +* usage: Options. +* variables, defining: Assignments. +* verbose: Options. +* version: Options. +* version script: VERSION. +* version script, symbol versions: Options. +* VERSION {script text}: VERSION. +* versions of symbols: VERSION. +* warnings, on combining symbols: Options. +* warnings, on section alignment: Options. +* warnings, on undefined symbols: Options. +* what is this?: Overview. +* wildcard file name patterns: Input Section Wildcards. + + diff --git a/ld/ldgram.c b/ld/ldgram.c new file mode 100644 index 00000000000..d6835c83b8d --- /dev/null +++ b/ld/ldgram.c @@ -0,0 +1,2808 @@ + +/* A Bison parser, made from ldgram.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define INT 257 +#define NAME 258 +#define LNAME 259 +#define PLUSEQ 260 +#define MINUSEQ 261 +#define MULTEQ 262 +#define DIVEQ 263 +#define LSHIFTEQ 264 +#define RSHIFTEQ 265 +#define ANDEQ 266 +#define OREQ 267 +#define OROR 268 +#define ANDAND 269 +#define EQ 270 +#define NE 271 +#define LE 272 +#define GE 273 +#define LSHIFT 274 +#define RSHIFT 275 +#define UNARY 276 +#define END 277 +#define ALIGN_K 278 +#define BLOCK 279 +#define BIND 280 +#define QUAD 281 +#define SQUAD 282 +#define LONG 283 +#define SHORT 284 +#define BYTE 285 +#define SECTIONS 286 +#define PHDRS 287 +#define SORT 288 +#define SIZEOF_HEADERS 289 +#define OUTPUT_FORMAT 290 +#define FORCE_COMMON_ALLOCATION 291 +#define OUTPUT_ARCH 292 +#define INCLUDE 293 +#define MEMORY 294 +#define DEFSYMEND 295 +#define NOLOAD 296 +#define DSECT 297 +#define COPY 298 +#define INFO 299 +#define OVERLAY 300 +#define DEFINED 301 +#define TARGET_K 302 +#define SEARCH_DIR 303 +#define MAP 304 +#define ENTRY 305 +#define NEXT 306 +#define SIZEOF 307 +#define ADDR 308 +#define LOADADDR 309 +#define MAX_K 310 +#define MIN_K 311 +#define STARTUP 312 +#define HLL 313 +#define SYSLIB 314 +#define FLOAT 315 +#define NOFLOAT 316 +#define NOCROSSREFS 317 +#define ORIGIN 318 +#define FILL 319 +#define LENGTH 320 +#define CREATE_OBJECT_SYMBOLS 321 +#define INPUT 322 +#define GROUP 323 +#define OUTPUT 324 +#define CONSTRUCTORS 325 +#define ALIGNMOD 326 +#define AT 327 +#define PROVIDE 328 +#define CHIP 329 +#define LIST 330 +#define SECT 331 +#define ABSOLUTE 332 +#define LOAD 333 +#define NEWLINE 334 +#define ENDWORD 335 +#define ORDER 336 +#define NAMEWORD 337 +#define ASSERT_K 338 +#define FORMAT 339 +#define PUBLIC 340 +#define BASE 341 +#define ALIAS 342 +#define TRUNCATE 343 +#define REL 344 +#define INPUT_SCRIPT 345 +#define INPUT_MRI_SCRIPT 346 +#define INPUT_DEFSYM 347 +#define CASE 348 +#define EXTERN 349 +#define START 350 +#define VERS_TAG 351 +#define VERS_IDENTIFIER 352 +#define GLOBAL 353 +#define LOCAL 354 +#define VERSIONK 355 +#define INPUT_VERSION_SCRIPT 356 +#define KEEP 357 +#define EXCLUDE_FILE 358 + +#line 22 "ldgram.y" + +/* + + */ + +#define DONTDECLARE_MALLOC + +#include "bfd.h" +#include "sysdep.h" +#include "bfdlink.h" +#include "ld.h" +#include "ldexp.h" +#include "ldver.h" +#include "ldlang.h" +#include "ldemul.h" +#include "ldfile.h" +#include "ldmisc.h" +#include "ldmain.h" +#include "mri.h" +#include "ldctor.h" +#include "ldlex.h" + +#ifndef YYDEBUG +#define YYDEBUG 1 +#endif + +static enum section_type sectype; + +lang_memory_region_type *region; + +struct wildcard_spec current_file; +boolean ldgram_want_filename = true; +boolean had_script = false; +boolean force_make_executable = false; + +boolean ldgram_in_script = false; +boolean ldgram_had_equals = false; +boolean ldgram_had_keep = false; +char *ldgram_vers_current_lang = NULL; + +#define ERROR_NAME_MAX 20 +static char *error_names[ERROR_NAME_MAX]; +static int error_index; +#define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++; +#define POP_ERROR() error_index--; + +#line 68 "ldgram.y" +typedef union { + bfd_vma integer; + char *name; + const char *cname; + struct wildcard_spec wildcard; + struct name_list *name_list; + int token; + union etree_union *etree; + struct phdr_info + { + boolean filehdr; + boolean phdrs; + union etree_union *at; + union etree_union *flags; + } phdr; + struct lang_nocrossref *nocrossref; + struct lang_output_section_phdr_list *section_phdr; + struct bfd_elf_version_deps *deflist; + struct bfd_elf_version_expr *versyms; + struct bfd_elf_version_tree *versnode; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 589 +#define YYFLAG -32768 +#define YYNTBASE 128 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 358 ? yytranslate[x] : 233) + +static const short yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 126, 2, 2, 2, 34, 21, 2, 37, + 123, 32, 30, 121, 31, 2, 33, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 16, 122, 24, + 10, 25, 15, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 124, 2, 125, 20, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 49, 19, 50, 127, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 11, 12, 13, 14, 17, 18, 22, + 23, 26, 27, 28, 29, 35, 36, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 3, 6, 9, 12, 14, 15, 20, 21, 24, + 28, 29, 32, 37, 39, 41, 44, 46, 51, 56, + 60, 63, 68, 72, 77, 82, 87, 92, 97, 100, + 103, 106, 111, 116, 119, 122, 125, 128, 129, 135, + 138, 139, 143, 146, 147, 149, 153, 155, 159, 160, + 162, 166, 168, 171, 175, 176, 179, 182, 183, 185, + 187, 189, 191, 193, 195, 197, 199, 201, 203, 208, + 213, 218, 223, 232, 237, 239, 244, 245, 251, 256, + 257, 263, 268, 273, 275, 279, 282, 284, 288, 291, + 296, 299, 302, 303, 308, 311, 313, 315, 317, 319, + 325, 330, 339, 342, 344, 346, 350, 352, 353, 358, + 359, 365, 367, 368, 374, 377, 379, 381, 383, 388, + 390, 395, 400, 403, 405, 406, 408, 410, 412, 414, + 416, 418, 421, 422, 424, 426, 428, 430, 432, 434, + 436, 438, 440, 442, 446, 450, 457, 459, 460, 466, + 469, 473, 474, 475, 483, 487, 491, 492, 496, 498, + 501, 503, 506, 511, 516, 520, 524, 526, 531, 535, + 536, 538, 540, 541, 544, 548, 549, 552, 555, 559, + 564, 567, 570, 573, 577, 581, 585, 589, 593, 597, + 601, 605, 609, 613, 617, 621, 625, 629, 633, 637, + 643, 647, 651, 656, 658, 660, 665, 670, 675, 680, + 685, 690, 692, 699, 706, 713, 717, 718, 723, 724, + 725, 726, 727, 728, 729, 746, 747, 748, 749, 750, + 751, 769, 770, 771, 779, 781, 783, 785, 787, 789, + 793, 794, 797, 801, 804, 811, 822, 825, 827, 828, + 830, 833, 834, 835, 839, 840, 841, 842, 843, 855, + 860, 861, 864, 865, 866, 873, 875, 876, 880, 886, + 887, 891, 892, 895, 896, 902, 904, 907, 913, 920, + 922, 925, 926, 929, 934, 939, 948, 950, 954, 955 +}; + +static const short yyrhs[] = { 107, + 142, 0, 108, 132, 0, 118, 223, 0, 109, 130, + 0, 4, 0, 0, 131, 4, 10, 188, 0, 0, + 133, 134, 0, 134, 135, 96, 0, 0, 91, 188, + 0, 91, 188, 121, 188, 0, 4, 0, 92, 0, + 98, 137, 0, 97, 0, 102, 4, 10, 188, 0, + 102, 4, 121, 188, 0, 102, 4, 188, 0, 101, + 4, 0, 93, 4, 121, 188, 0, 93, 4, 188, + 0, 93, 4, 10, 188, 0, 38, 4, 10, 188, + 0, 38, 4, 121, 188, 0, 88, 4, 10, 188, + 0, 88, 4, 121, 188, 0, 94, 139, 0, 95, + 138, 0, 99, 4, 0, 104, 4, 121, 4, 0, + 104, 4, 121, 3, 0, 103, 188, 0, 105, 3, + 0, 110, 140, 0, 111, 141, 0, 0, 55, 129, + 136, 134, 36, 0, 112, 4, 0, 0, 137, 121, + 4, 0, 137, 4, 0, 0, 4, 0, 138, 121, + 4, 0, 4, 0, 139, 121, 4, 0, 0, 4, + 0, 140, 121, 4, 0, 4, 0, 141, 4, 0, + 141, 121, 4, 0, 0, 143, 144, 0, 144, 145, + 0, 0, 170, 0, 149, 0, 215, 0, 179, 0, + 180, 0, 182, 0, 184, 0, 151, 0, 225, 0, + 122, 0, 64, 37, 4, 123, 0, 65, 37, 129, + 123, 0, 86, 37, 129, 123, 0, 52, 37, 4, + 123, 0, 52, 37, 4, 121, 4, 121, 4, 123, + 0, 54, 37, 4, 123, 0, 53, 0, 84, 37, + 148, 123, 0, 0, 85, 146, 37, 148, 123, 0, + 66, 37, 129, 123, 0, 0, 55, 129, 147, 144, + 36, 0, 79, 37, 185, 123, 0, 111, 37, 141, + 123, 0, 4, 0, 148, 121, 4, 0, 148, 4, + 0, 5, 0, 148, 121, 5, 0, 148, 5, 0, + 46, 49, 150, 50, 0, 150, 191, 0, 150, 151, + 0, 0, 67, 37, 4, 123, 0, 168, 167, 0, + 4, 0, 32, 0, 15, 0, 152, 0, 120, 37, + 154, 123, 152, 0, 48, 37, 152, 123, 0, 48, + 37, 120, 37, 154, 123, 152, 123, 0, 154, 152, + 0, 152, 0, 153, 0, 155, 169, 153, 0, 4, + 0, 0, 124, 157, 155, 125, 0, 0, 153, 158, + 37, 155, 123, 0, 156, 0, 0, 119, 37, 160, + 156, 123, 0, 168, 167, 0, 83, 0, 122, 0, + 87, 0, 48, 37, 87, 123, 0, 159, 0, 164, + 37, 186, 123, 0, 81, 37, 186, 123, 0, 162, + 161, 0, 161, 0, 0, 162, 0, 41, 0, 42, + 0, 43, 0, 44, 0, 45, 0, 10, 186, 0, + 0, 6, 0, 7, 0, 8, 0, 9, 0, 11, + 0, 12, 0, 13, 0, 14, 0, 122, 0, 121, + 0, 4, 10, 186, 0, 4, 166, 186, 0, 90, + 37, 4, 10, 186, 123, 0, 121, 0, 0, 56, + 49, 172, 171, 50, 0, 171, 172, 0, 171, 121, + 172, 0, 0, 0, 4, 173, 176, 16, 174, 169, + 175, 0, 80, 10, 186, 0, 82, 10, 186, 0, + 0, 37, 177, 123, 0, 178, 0, 177, 178, 0, + 4, 0, 126, 4, 0, 74, 37, 129, 123, 0, + 75, 37, 181, 123, 0, 75, 37, 123, 0, 181, + 169, 129, 0, 129, 0, 76, 37, 183, 123, 0, + 183, 169, 129, 0, 0, 77, 0, 78, 0, 0, + 4, 185, 0, 4, 121, 185, 0, 0, 187, 188, + 0, 31, 188, 0, 37, 188, 123, 0, 68, 37, + 188, 123, 0, 126, 188, 0, 30, 188, 0, 127, + 188, 0, 188, 32, 188, 0, 188, 33, 188, 0, + 188, 34, 188, 0, 188, 30, 188, 0, 188, 31, + 188, 0, 188, 28, 188, 0, 188, 29, 188, 0, + 188, 22, 188, 0, 188, 23, 188, 0, 188, 26, + 188, 0, 188, 27, 188, 0, 188, 24, 188, 0, + 188, 25, 188, 0, 188, 21, 188, 0, 188, 20, + 188, 0, 188, 19, 188, 0, 188, 15, 188, 16, + 188, 0, 188, 18, 188, 0, 188, 17, 188, 0, + 63, 37, 4, 123, 0, 3, 0, 51, 0, 69, + 37, 4, 123, 0, 70, 37, 4, 123, 0, 71, + 37, 4, 123, 0, 94, 37, 188, 123, 0, 38, + 37, 188, 123, 0, 39, 37, 188, 123, 0, 4, + 0, 72, 37, 188, 121, 188, 123, 0, 73, 37, + 188, 121, 188, 123, 0, 100, 37, 188, 121, 4, + 123, 0, 89, 25, 4, 0, 0, 89, 37, 188, + 123, 0, 0, 0, 0, 0, 0, 0, 4, 192, + 206, 190, 193, 49, 194, 163, 50, 195, 209, 189, + 210, 165, 196, 169, 0, 0, 0, 0, 0, 0, + 62, 197, 207, 208, 190, 198, 49, 199, 211, 50, + 200, 209, 189, 210, 165, 201, 169, 0, 0, 0, + 85, 202, 206, 203, 49, 150, 50, 0, 58, 0, + 59, 0, 60, 0, 61, 0, 62, 0, 37, 204, + 123, 0, 0, 37, 123, 0, 188, 205, 16, 0, + 205, 16, 0, 40, 37, 188, 123, 205, 16, 0, + 40, 37, 188, 123, 39, 37, 188, 123, 205, 16, + 0, 188, 16, 0, 16, 0, 0, 79, 0, 25, + 4, 0, 0, 0, 210, 16, 4, 0, 0, 0, + 0, 0, 211, 4, 212, 49, 163, 50, 213, 210, + 165, 214, 169, 0, 47, 49, 216, 50, 0, 0, + 216, 217, 0, 0, 0, 4, 218, 220, 221, 219, + 122, 0, 188, 0, 0, 4, 222, 221, 0, 89, + 37, 188, 123, 221, 0, 0, 37, 188, 123, 0, + 0, 224, 227, 0, 0, 226, 117, 49, 227, 50, + 0, 228, 0, 227, 228, 0, 113, 49, 230, 50, + 122, 0, 113, 49, 230, 50, 229, 122, 0, 113, + 0, 229, 113, 0, 0, 231, 122, 0, 115, 16, + 231, 122, 0, 116, 16, 231, 122, 0, 115, 16, + 231, 122, 116, 16, 231, 122, 0, 114, 0, 231, + 122, 114, 0, 0, 111, 4, 49, 232, 231, 50, + 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 153, 155, 156, 157, 161, 164, 166, 173, 179, 186, + 188, 191, 193, 194, 197, 200, 201, 202, 204, 206, + 208, 210, 212, 214, 216, 218, 220, 222, 224, 225, + 226, 228, 230, 232, 234, 236, 237, 238, 239, 240, + 242, 245, 247, 248, 251, 254, 257, 260, 264, 266, + 267, 270, 273, 275, 279, 284, 290, 292, 297, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 310, + 312, 314, 317, 319, 321, 323, 324, 326, 328, 330, + 331, 332, 336, 339, 343, 346, 349, 352, 355, 360, + 364, 366, 367, 370, 373, 378, 383, 387, 393, 400, + 406, 412, 422, 431, 442, 450, 459, 465, 470, 471, + 478, 481, 483, 485, 489, 491, 495, 496, 501, 506, + 507, 512, 522, 524, 527, 529, 532, 535, 537, 539, + 541, 545, 553, 558, 561, 563, 565, 567, 569, 571, + 573, 578, 578, 582, 587, 595, 602, 603, 606, 610, + 612, 613, 617, 619, 622, 630, 639, 642, 645, 647, + 650, 653, 657, 662, 664, 668, 671, 676, 678, 681, + 684, 687, 691, 696, 705, 716, 718, 721, 724, 726, + 728, 730, 732, 735, 737, 739, 741, 743, 745, 747, + 749, 751, 753, 755, 757, 759, 761, 763, 765, 767, + 769, 771, 773, 775, 777, 780, 782, 784, 786, 788, + 790, 792, 794, 796, 798, 803, 805, 808, 810, 813, + 815, 817, 823, 824, 830, 830, 832, 835, 839, 841, + 847, 847, 853, 857, 860, 862, 863, 864, 865, 868, + 870, 871, 874, 876, 877, 882, 886, 888, 891, 894, + 898, 901, 904, 909, 922, 924, 930, 932, 938, 940, + 944, 946, 949, 951, 953, 959, 989, 994, 1006, 1013, + 1018, 1026, 1032, 1040, 1044, 1050, 1052, 1055, 1060, 1066, + 1071, 1077, 1082, 1086, 1090, 1094, 1100, 1105, 1109, 1114 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","INT","NAME", +"LNAME","PLUSEQ","MINUSEQ","MULTEQ","DIVEQ","'='","LSHIFTEQ","RSHIFTEQ","ANDEQ", +"OREQ","'?'","':'","OROR","ANDAND","'|'","'^'","'&'","EQ","NE","'<'","'>'","LE", +"GE","LSHIFT","RSHIFT","'+'","'-'","'*'","'/'","'%'","UNARY","END","'('","ALIGN_K", +"BLOCK","BIND","QUAD","SQUAD","LONG","SHORT","BYTE","SECTIONS","PHDRS","SORT", +"'{'","'}'","SIZEOF_HEADERS","OUTPUT_FORMAT","FORCE_COMMON_ALLOCATION","OUTPUT_ARCH", +"INCLUDE","MEMORY","DEFSYMEND","NOLOAD","DSECT","COPY","INFO","OVERLAY","DEFINED", +"TARGET_K","SEARCH_DIR","MAP","ENTRY","NEXT","SIZEOF","ADDR","LOADADDR","MAX_K", +"MIN_K","STARTUP","HLL","SYSLIB","FLOAT","NOFLOAT","NOCROSSREFS","ORIGIN","FILL", +"LENGTH","CREATE_OBJECT_SYMBOLS","INPUT","GROUP","OUTPUT","CONSTRUCTORS","ALIGNMOD", +"AT","PROVIDE","CHIP","LIST","SECT","ABSOLUTE","LOAD","NEWLINE","ENDWORD","ORDER", +"NAMEWORD","ASSERT_K","FORMAT","PUBLIC","BASE","ALIAS","TRUNCATE","REL","INPUT_SCRIPT", +"INPUT_MRI_SCRIPT","INPUT_DEFSYM","CASE","EXTERN","START","VERS_TAG","VERS_IDENTIFIER", +"GLOBAL","LOCAL","VERSIONK","INPUT_VERSION_SCRIPT","KEEP","EXCLUDE_FILE","','", +"';'","')'","'['","']'","'!'","'~'","file","filename","defsym_expr","@1","mri_script_file", +"@2","mri_script_lines","mri_script_command","@3","ordernamelist","mri_load_name_list", +"mri_abs_name_list","casesymlist","extern_name_list","script_file","@4","ifile_list", +"ifile_p1","@5","@6","input_list","sections","sec_or_group_p1","statement_anywhere", +"wildcard_name","wildcard_spec","exclude_name_list","file_NAME_list","input_section_spec_no_keep", +"@7","@8","input_section_spec","@9","statement","statement_list","statement_list_opt", +"length","fill_opt","assign_op","end","assignment","opt_comma","memory","memory_spec_list", +"memory_spec","@10","origin_spec","length_spec","attributes_opt","attributes_list", +"attributes_string","startup","high_level_library","high_level_library_NAME_list", +"low_level_library","low_level_library_NAME_list","floating_point_support","nocrossref_list", +"mustbe_exp","@11","exp","memspec_at_opt","opt_at","section","@12","@13","@14", +"@15","@16","@17","@18","@19","@20","@21","@22","@23","type","atype","opt_exp_with_type", +"opt_exp_without_type","opt_nocrossrefs","memspec_opt","phdr_opt","overlay_section", +"@24","@25","@26","phdrs","phdr_list","phdr","@27","@28","phdr_type","phdr_qualifiers", +"phdr_val","version_script_file","@29","version","@30","vers_nodes","vers_node", +"verdep","vers_tag","vers_defns","@31", NULL +}; +#endif + +static const short yyr1[] = { 0, + 128, 128, 128, 128, 129, 131, 130, 133, 132, 134, + 134, 135, 135, 135, 135, 135, 135, 135, 135, 135, + 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, + 135, 135, 135, 135, 135, 135, 135, 136, 135, 135, + 135, 137, 137, 137, 138, 138, 139, 139, 140, 140, + 140, 141, 141, 141, 143, 142, 144, 144, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 146, 145, 145, 147, + 145, 145, 145, 148, 148, 148, 148, 148, 148, 149, + 150, 150, 150, 151, 151, 152, 152, 152, 153, 153, + 153, 153, 154, 154, 155, 155, 156, 157, 156, 158, + 156, 159, 160, 159, 161, 161, 161, 161, 161, 161, + 161, 161, 162, 162, 163, 163, 164, 164, 164, 164, + 164, 165, 165, 166, 166, 166, 166, 166, 166, 166, + 166, 167, 167, 168, 168, 168, 169, 169, 170, 171, + 171, 171, 173, 172, 174, 175, 176, 176, 177, 177, + 178, 178, 179, 180, 180, 181, 181, 182, 183, 183, + 184, 184, 185, 185, 185, 187, 186, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 189, 189, 190, 190, 192, + 193, 194, 195, 196, 191, 197, 198, 199, 200, 201, + 191, 202, 203, 191, 204, 204, 204, 204, 204, 205, + 205, 205, 206, 206, 206, 206, 207, 207, 208, 208, + 209, 209, 210, 210, 211, 212, 213, 214, 211, 215, + 216, 216, 218, 219, 217, 220, 221, 221, 221, 222, + 222, 224, 223, 226, 225, 227, 227, 228, 228, 229, + 229, 230, 230, 230, 230, 230, 231, 231, 232, 231 +}; + +static const short yyr2[] = { 0, + 2, 2, 2, 2, 1, 0, 4, 0, 2, 3, + 0, 2, 4, 1, 1, 2, 1, 4, 4, 3, + 2, 4, 3, 4, 4, 4, 4, 4, 2, 2, + 2, 4, 4, 2, 2, 2, 2, 0, 5, 2, + 0, 3, 2, 0, 1, 3, 1, 3, 0, 1, + 3, 1, 2, 3, 0, 2, 2, 0, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, + 4, 4, 8, 4, 1, 4, 0, 5, 4, 0, + 5, 4, 4, 1, 3, 2, 1, 3, 2, 4, + 2, 2, 0, 4, 2, 1, 1, 1, 1, 5, + 4, 8, 2, 1, 1, 3, 1, 0, 4, 0, + 5, 1, 0, 5, 2, 1, 1, 1, 4, 1, + 4, 4, 2, 1, 0, 1, 1, 1, 1, 1, + 1, 2, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 3, 3, 6, 1, 0, 5, 2, + 3, 0, 0, 7, 3, 3, 0, 3, 1, 2, + 1, 2, 4, 4, 3, 3, 1, 4, 3, 0, + 1, 1, 0, 2, 3, 0, 2, 2, 3, 4, + 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, + 3, 3, 4, 1, 1, 4, 4, 4, 4, 4, + 4, 1, 6, 6, 6, 3, 0, 4, 0, 0, + 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, + 17, 0, 0, 7, 1, 1, 1, 1, 1, 3, + 0, 2, 3, 2, 6, 10, 2, 1, 0, 1, + 2, 0, 0, 3, 0, 0, 0, 0, 11, 4, + 0, 2, 0, 0, 6, 1, 0, 3, 5, 0, + 3, 0, 2, 0, 5, 1, 2, 5, 6, 1, + 2, 0, 2, 4, 4, 8, 1, 3, 0, 6 +}; + +static const short yydefact[] = { 0, + 55, 8, 6, 272, 1, 58, 2, 11, 4, 0, + 3, 0, 56, 9, 0, 0, 273, 276, 0, 0, + 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 172, 0, 0, 77, 0, 0, + 0, 68, 57, 60, 66, 0, 59, 62, 63, 64, + 65, 61, 67, 0, 14, 0, 0, 0, 0, 15, + 0, 0, 0, 17, 44, 0, 0, 0, 0, 0, + 0, 49, 0, 0, 0, 0, 282, 277, 134, 135, + 136, 137, 176, 138, 139, 140, 141, 176, 93, 261, + 0, 0, 5, 80, 0, 0, 0, 0, 0, 0, + 0, 170, 173, 0, 0, 0, 0, 0, 143, 142, + 95, 0, 0, 38, 0, 204, 212, 0, 0, 0, + 0, 0, 205, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 0, 47, 29, 45, 30, + 16, 31, 21, 0, 34, 0, 35, 50, 36, 52, + 37, 40, 10, 7, 0, 287, 0, 0, 0, 0, + 144, 0, 145, 0, 0, 0, 0, 58, 153, 152, + 0, 0, 0, 0, 0, 165, 167, 148, 148, 173, + 0, 84, 87, 0, 0, 0, 0, 0, 0, 0, + 0, 11, 0, 0, 182, 178, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 181, 183, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 23, 0, 0, 43, 0, 0, 0, 20, + 0, 0, 53, 0, 0, 0, 0, 0, 283, 177, + 220, 90, 226, 232, 92, 91, 263, 260, 262, 0, + 72, 74, 274, 157, 0, 69, 70, 79, 94, 163, + 147, 164, 0, 168, 0, 173, 174, 82, 86, 89, + 0, 76, 0, 71, 176, 83, 0, 25, 26, 41, + 27, 28, 179, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 202, 201, 199, 198, 197, + 191, 192, 195, 196, 193, 194, 189, 190, 187, 188, + 184, 185, 186, 13, 24, 22, 48, 46, 42, 18, + 19, 33, 32, 51, 54, 289, 0, 0, 280, 278, + 0, 288, 241, 0, 241, 0, 0, 81, 0, 0, + 149, 0, 150, 166, 169, 175, 85, 88, 78, 0, + 275, 39, 210, 211, 203, 180, 206, 207, 208, 0, + 0, 209, 0, 0, 0, 284, 285, 281, 279, 0, + 0, 241, 0, 219, 248, 0, 249, 233, 266, 267, + 0, 161, 0, 0, 159, 0, 151, 146, 0, 0, + 0, 200, 0, 0, 235, 236, 237, 238, 239, 242, + 0, 0, 0, 0, 244, 0, 221, 247, 250, 219, + 0, 270, 0, 264, 0, 162, 158, 160, 0, 148, + 213, 214, 215, 290, 0, 0, 240, 0, 243, 0, + 0, 227, 93, 0, 267, 0, 0, 73, 176, 0, + 0, 241, 0, 222, 0, 0, 0, 268, 0, 265, + 155, 0, 154, 286, 0, 0, 218, 125, 228, 234, + 271, 267, 176, 0, 245, 107, 98, 97, 127, 128, + 129, 130, 131, 0, 0, 116, 118, 0, 0, 117, + 108, 99, 110, 112, 120, 124, 126, 0, 0, 0, + 255, 269, 156, 0, 0, 176, 113, 0, 0, 0, + 123, 223, 176, 115, 0, 241, 96, 0, 0, 0, + 0, 0, 104, 0, 0, 105, 148, 0, 252, 0, + 256, 229, 0, 119, 0, 101, 122, 96, 0, 0, + 103, 0, 109, 0, 148, 0, 217, 121, 0, 252, + 246, 0, 114, 100, 106, 111, 251, 0, 253, 125, + 217, 0, 0, 133, 0, 253, 0, 216, 176, 0, + 224, 257, 133, 102, 132, 254, 148, 253, 230, 225, + 133, 148, 258, 231, 148, 259, 0, 0, 0 +}; + +static const short yydefgoto[] = { 587, + 94, 9, 10, 7, 8, 14, 75, 192, 141, 140, + 138, 149, 151, 5, 6, 13, 43, 105, 168, 184, + 44, 164, 45, 492, 493, 524, 527, 494, 509, 510, + 495, 522, 496, 497, 498, 499, 571, 88, 111, 46, + 544, 47, 265, 170, 264, 430, 463, 350, 394, 395, + 48, 49, 178, 50, 179, 51, 181, 161, 162, 197, + 559, 417, 256, 343, 441, 468, 529, 577, 344, 455, + 501, 550, 582, 345, 421, 411, 383, 384, 387, 420, + 547, 564, 515, 549, 578, 585, 52, 165, 259, 346, + 447, 390, 424, 445, 11, 12, 53, 54, 17, 18, + 341, 159, 160, 375 +}; + +static const short yypact[] = { -66, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 23, +-32768, -73, 585, 695, 53, -4, -73,-32768, 1276, 40, + 63, 115,-32768, 140, 179, 143, 158, 184, 191, 215, + 224, 226, 227,-32768,-32768, 228, 230,-32768, 231, 233, + 234,-32768,-32768,-32768,-32768, -3,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 156,-32768, 270, 179, 272, 491,-32768, + 273, 274, 275,-32768,-32768, 276, 277, 280, 491, 288, + 290, 293, 296, 297, 198, 491, 85,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 298, 300,-32768,-32768, 301, 302, 179, 179, 303, 179, + 15,-32768, 304, 118, 281, 179, 305, 296,-32768,-32768, +-32768, 261, 6,-32768, 7,-32768,-32768, 491, 491, 491, + 282, 289,-32768, 291, 294, 295, 310, 311, 312, 313, + 314, 316, 491, 491, 1032, 252,-32768, 190,-32768, 196, + 10,-32768,-32768, 326, 1137, 206,-32768,-32768, 212,-32768, + 24,-32768,-32768, 1137, 330,-32768, 319, 339, 264, 236, +-32768, 491,-32768, 31, 29, -20, 237,-32768,-32768,-32768, + 239, 243, 244, 246, 247,-32768,-32768, -6, 65, 30, + 248,-32768,-32768, 61, 118, 249, 349, 68, -73, 491, + 491,-32768, 491, 491,-32768,-32768, 581, 491, 491, 370, + 491, 371, 372, 376, 491, 491, 491, 491,-32768,-32768, + 491, 491, 491, 491, 491, 491, 491, 491, 491, 491, + 491, 491, 491, 491, 491, 491, 491, 491, 491, 491, + 491, 491, 1137, 377, 379,-32768, 380, 491, 491, 1137, + 254, 383,-32768, 386, 342, -1, -1, -55, 278, 1137, + 1276,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 389, +-32768,-32768, 662, 363, 9,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, 179,-32768, 179, 304,-32768,-32768,-32768,-32768, + 255,-32768, 64,-32768,-32768,-32768, -21, 1137, 1137, 720, + 1137, 1137,-32768, 659, 818, 284, 838, 285, 287, 292, + 1052, 1072, 858, 1092, 1199, 1156, 1175, 1234, 738, 1247, + 549, 549, 186, 186, 186, 186, 216, 216, 193, 193, +-32768,-32768,-32768, 1137, 1137, 1137,-32768,-32768,-32768, 1137, + 1137,-32768,-32768,-32768,-32768,-32768, 283, 299,-32768,-32768, + -39,-32768, 399, 445, 399, 491, 306,-32768, 8, 388, +-32768, 301,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 308, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 491, + 491,-32768, 407, 491, -1, 122, 278,-32768,-32768, 172, + 375, 1112, 397, 325,-32768, 1219, 338,-32768, 1137, 20, + 415,-32768, 418, 3,-32768, 343,-32768,-32768, 878, 898, + 309, 1137, -27, 408,-32768,-32768,-32768,-32768,-32768,-32768, + 317, 491, 146, 412,-32768, 396,-32768,-32768,-32768, 325, + 385, 398, 404,-32768, 320,-32768,-32768,-32768, 432, 323, +-32768,-32768,-32768,-32768, 278, -1,-32768, 925,-32768, 491, + 402,-32768,-32768, 491, 20, 491, 324,-32768,-32768, 374, + 332, 200, 945,-32768, 410, 35, 965,-32768, 985,-32768, +-32768, 435,-32768, 278, 420, 444,-32768, 505,-32768,-32768, +-32768, 20,-32768, 491,-32768, 331,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 426, 427,-32768,-32768, 428, 429,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, 505, 423, 440, -3, +-32768,-32768,-32768, 1005, 92,-32768,-32768, 21, 58, 441, +-32768,-32768,-32768,-32768, 34, 442,-32768, 357, 449, 364, + 365, 22,-32768, 16, 452,-32768, -34, 58, 466, 378, +-32768,-32768, 481,-32768, 21,-32768,-32768, 381, 382, 21, +-32768, 73,-32768, 58, 130, 494, 411,-32768, 454, 466, +-32768, 67,-32768,-32768,-32768,-32768,-32768, 482,-32768, 505, + 411, 21, 502, 84, 460,-32768, 400,-32768,-32768, 507, +-32768,-32768, 84,-32768,-32768,-32768, 323,-32768,-32768,-32768, + 84, 323,-32768,-32768, 323,-32768, 519, 524,-32768 +}; + +static const short yypgoto[] = {-32768, + -51,-32768,-32768,-32768,-32768, 335,-32768,-32768,-32768,-32768, +-32768,-32768, 424,-32768,-32768, 366,-32768,-32768,-32768, 346, +-32768, 90, -160, -50, -315, 0, 12, 14,-32768,-32768, +-32768,-32768, 41,-32768, -19,-32768, -517,-32768, 43, -446, + -176,-32768,-32768, -244,-32768,-32768,-32768,-32768,-32768, 150, +-32768,-32768,-32768,-32768,-32768,-32768, -165, -88,-32768, -58, + -10, 132,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, -372, 210,-32768,-32768, + 17, -534,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, -415,-32768,-32768,-32768,-32768,-32768, 367, -12, +-32768,-32768, -238,-32768 +}; + + +#define YYLAST 1290 + + +static const short yytable[] = { 163, + 135, 273, 275, 255, 78, 114, 392, 337, 338, 414, + 145, 392, 169, 236, 277, 190, 193, 154, 93, 517, + 353, 500, 434, 422, 517, 538, 15, 243, 361, 458, + 477, 573, 257, 180, 251, 477, 477, 531, 251, 16, + 1, 2, 3, 581, 77, 172, 173, 478, 175, 177, + 500, 4, 478, 478, 186, 579, 502, 339, 351, 195, + 196, 517, 76, 583, 279, 280, 340, 279, 280, 525, + 517, 243, 477, 378, 209, 210, 517, 233, 258, 466, + 252, 477, 379, 532, 470, 240, 271, 477, 89, 478, + 543, 16, 253, 569, 435, 517, 253, 30, 478, 570, + 260, 30, 261, 250, 478, 525, 477, 397, 423, 155, + 356, 90, 156, 500, 271, 254, 272, 109, 110, 254, + 40, 182, 183, 478, 40, 427, 191, 194, 393, 352, + 237, 288, 289, 393, 291, 292, 403, 176, 540, 294, + 295, 489, 297, 533, 244, 491, 301, 302, 303, 304, + 276, 91, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 116, 117, 92, 489, 518, 330, + 331, 281, 93, 282, 281, 271, 359, 274, 244, 562, + 286, 95, 519, 526, 96, 155, 360, 451, 156, 157, + 158, 118, 119, 405, 406, 407, 408, 409, 120, 121, + 122, 519, 526, 223, 224, 225, 226, 227, 228, 229, + 97, 354, 123, 355, 227, 228, 229, 98, 555, 405, + 406, 407, 408, 409, 124, 342, 413, 404, 465, 125, + 126, 127, 128, 129, 130, 225, 226, 227, 228, 229, + 271, 99, 556, 450, 116, 117, 332, 333, 357, 358, + 100, 231, 101, 102, 103, 131, 104, 106, 410, 107, + 108, 132, 112, 113, 78, 115, 136, 137, 139, 142, + 143, 118, 119, 144, 382, 386, 382, 389, 120, 121, + 122, 146, 147, 153, 410, 255, 148, 133, 134, 150, + 152, 166, 123, 167, 169, 171, 174, 180, 187, 189, + 234, 399, 400, 248, 124, 402, 235, 185, 198, 125, + 126, 127, 128, 129, 130, 199, 241, 200, 116, 117, + 201, 202, 242, 245, 246, 238, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 131, 203, 204, 205, 206, + 207, 132, 208, 438, 247, 118, 119, 249, 285, 262, + 461, 266, 120, 121, 122, 267, 268, -96, 269, 270, + 278, 284, 232, 296, 298, 299, 123, 133, 134, 300, + 327, 453, 328, 329, 503, 457, 334, 459, 124, 335, + 336, 342, 347, 125, 126, 127, 128, 129, 130, 349, + 580, 116, 117, 396, 376, 584, 365, 367, 586, 368, + 401, 412, 415, 416, 369, 504, 419, 521, 425, 131, + 377, 426, 429, 436, 530, 132, 391, 439, 118, 119, + 398, 433, 440, 443, 444, 380, 121, 122, 381, 437, + 446, 449, 448, 271, 473, 460, 239, 116, 117, 123, + 454, 133, 134, 464, 520, 462, 474, 523, 469, 475, + 385, 124, 505, 506, 507, 508, 125, 126, 127, 128, + 129, 130, 512, 541, 118, 119, 513, 528, 413, 534, + 575, 120, 121, 122, 523, 535, 536, 537, 542, 554, + 546, 520, 131, 116, 117, 123, 551, 557, 132, 558, + 548, 541, 560, -107, 553, 568, 563, 124, 476, 572, + 576, 567, 125, 126, 127, 128, 129, 130, 588, 477, + 118, 119, 574, 589, 133, 134, 290, 120, 121, 122, + 283, 188, 456, 263, 552, 539, 478, 511, 131, 545, + 565, 123, 514, 428, 132, 479, 480, 481, 482, 483, + 566, 442, 484, 124, 388, 287, 0, 0, 125, 126, + 127, 128, 129, 130, 0, 0, 561, 0, 0, 0, + 133, 134, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 0, 131, 485, 0, 486, 19, 0, + 132, 487, 0, 0, 40, 211, 0, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 0, 133, 134, 0, 0, + 0, 0, 0, 488, 489, 0, 490, 0, 491, 0, + 20, 21, 0, 0, 0, 0, 22, 23, 24, 25, + 26, 0, 0, 0, 0, 0, 0, 0, 27, 28, + 29, 30, 0, 0, 0, 0, 0, 0, 31, 32, + 33, 34, 35, 36, 0, 19, 0, 0, 37, 38, + 39, 0, 0, 211, 40, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 0, 0, 41, 0, 348, 55, 0, + 0, -274, 0, 293, 0, 0, 42, 20, 21, 0, + 0, 0, 0, 22, 23, 24, 25, 26, 0, 0, + 0, 0, 0, 55, 0, 27, 28, 29, 30, 0, + 0, 0, 56, 0, 0, 31, 32, 33, 34, 35, + 36, 0, 0, 0, 0, 37, 38, 39, 0, 57, + 0, 40, 0, 0, 0, 362, 0, 56, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 41, 0, 57, 0, 0, 0, 0, 0, + 0, 363, 58, 42, 0, 59, 60, 61, 62, 63, + -41, 64, 65, 66, 0, 67, 68, 69, 70, 71, + 0, 0, 0, 0, 72, 73, 74, 58, 0, 0, + 59, 60, 61, 62, 63, 0, 64, 65, 66, 0, + 67, 68, 69, 70, 71, 0, 0, 0, 0, 72, + 73, 74, 211, 0, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 211, 0, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 211, 0, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 211, 0, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 211, 0, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 0, 0, 0, 0, 0, 0, 0, 211, + 364, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 211, + 366, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 211, + 372, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 211, + 431, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 211, + 432, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 0, + 0, 0, 0, 0, 0, 0, 211, 452, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 211, 467, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 211, 471, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 211, 472, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 211, 516, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 0, 0, 413, 0, + 0, 211, 230, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 0, 370, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 0, 0, 371, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 0, + 0, 0, 373, 211, 374, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 211, 418, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 79, 80, 81, 82, 83, 84, 85, 86, 87 +}; + +static const short yycheck[] = { 88, + 59, 178, 179, 164, 17, 57, 4, 246, 247, 382, + 69, 4, 4, 4, 180, 10, 10, 76, 4, 4, + 265, 468, 50, 4, 4, 4, 4, 4, 50, 445, + 15, 566, 4, 4, 4, 15, 15, 4, 4, 113, + 107, 108, 109, 578, 49, 97, 98, 32, 100, 101, + 497, 118, 32, 32, 106, 573, 472, 113, 50, 118, + 119, 4, 10, 581, 4, 5, 122, 4, 5, 48, + 4, 4, 15, 113, 133, 134, 4, 136, 50, 452, + 50, 15, 122, 50, 50, 144, 121, 15, 49, 32, + 125, 113, 62, 10, 122, 4, 62, 67, 32, 16, + 121, 67, 123, 162, 32, 48, 15, 352, 89, 111, + 276, 49, 114, 560, 121, 85, 123, 121, 122, 85, + 90, 4, 5, 32, 90, 123, 121, 121, 126, 121, + 121, 190, 191, 126, 193, 194, 375, 123, 123, 198, + 199, 120, 201, 516, 121, 124, 205, 206, 207, 208, + 121, 37, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 3, 4, 37, 120, 87, 238, + 239, 121, 4, 123, 121, 121, 123, 123, 121, 123, + 123, 49, 120, 509, 37, 111, 285, 436, 114, 115, + 116, 30, 31, 58, 59, 60, 61, 62, 37, 38, + 39, 120, 528, 28, 29, 30, 31, 32, 33, 34, + 37, 273, 51, 275, 32, 33, 34, 37, 544, 58, + 59, 60, 61, 62, 63, 114, 37, 116, 39, 68, + 69, 70, 71, 72, 73, 30, 31, 32, 33, 34, + 121, 37, 123, 430, 3, 4, 3, 4, 4, 5, + 37, 10, 37, 37, 37, 94, 37, 37, 123, 37, + 37, 100, 117, 4, 287, 4, 4, 4, 4, 4, + 4, 30, 31, 4, 343, 344, 345, 346, 37, 38, + 39, 4, 3, 96, 123, 456, 4, 126, 127, 4, + 4, 4, 51, 4, 4, 4, 4, 4, 4, 49, + 121, 370, 371, 50, 63, 374, 121, 37, 37, 68, + 69, 70, 71, 72, 73, 37, 121, 37, 3, 4, + 37, 37, 121, 4, 16, 10, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 94, 37, 37, 37, 37, + 37, 100, 37, 412, 16, 30, 31, 122, 10, 123, + 449, 123, 37, 38, 39, 123, 123, 37, 123, 123, + 123, 123, 121, 4, 4, 4, 51, 126, 127, 4, + 4, 440, 4, 4, 473, 444, 4, 446, 63, 4, + 49, 114, 4, 68, 69, 70, 71, 72, 73, 37, + 577, 3, 4, 16, 122, 582, 123, 123, 585, 123, + 4, 37, 16, 89, 123, 474, 79, 506, 4, 94, + 122, 4, 80, 16, 513, 100, 121, 16, 30, 31, + 123, 123, 37, 49, 37, 37, 38, 39, 40, 123, + 37, 10, 123, 121, 10, 122, 121, 3, 4, 51, + 49, 126, 127, 122, 505, 82, 37, 508, 49, 16, + 16, 63, 37, 37, 37, 37, 68, 69, 70, 71, + 72, 73, 50, 524, 30, 31, 37, 37, 37, 123, + 569, 37, 38, 39, 535, 37, 123, 123, 37, 540, + 25, 542, 94, 3, 4, 51, 16, 4, 100, 89, + 123, 552, 49, 123, 123, 4, 25, 63, 4, 50, + 4, 562, 68, 69, 70, 71, 72, 73, 0, 15, + 30, 31, 123, 0, 126, 127, 192, 37, 38, 39, + 185, 108, 443, 168, 535, 522, 32, 497, 94, 528, + 560, 51, 500, 394, 100, 41, 42, 43, 44, 45, + 561, 420, 48, 63, 345, 189, -1, -1, 68, 69, + 70, 71, 72, 73, -1, -1, 550, -1, -1, -1, + 126, 127, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, -1, 94, 81, -1, 83, 4, -1, + 100, 87, -1, -1, 90, 15, -1, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, -1, 126, 127, -1, -1, + -1, -1, -1, 119, 120, -1, 122, -1, 124, -1, + 46, 47, -1, -1, -1, -1, 52, 53, 54, 55, + 56, -1, -1, -1, -1, -1, -1, -1, 64, 65, + 66, 67, -1, -1, -1, -1, -1, -1, 74, 75, + 76, 77, 78, 79, -1, 4, -1, -1, 84, 85, + 86, -1, -1, 15, 90, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, -1, -1, 111, -1, 36, 4, -1, + -1, 117, -1, 123, -1, -1, 122, 46, 47, -1, + -1, -1, -1, 52, 53, 54, 55, 56, -1, -1, + -1, -1, -1, 4, -1, 64, 65, 66, 67, -1, + -1, -1, 38, -1, -1, 74, 75, 76, 77, 78, + 79, -1, -1, -1, -1, 84, 85, 86, -1, 55, + -1, 90, -1, -1, -1, 36, -1, 38, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 111, -1, 55, -1, -1, -1, -1, -1, + -1, 123, 88, 122, -1, 91, 92, 93, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + -1, -1, -1, -1, 110, 111, 112, 88, -1, -1, + 91, 92, 93, 94, 95, -1, 97, 98, 99, -1, + 101, 102, 103, 104, 105, -1, -1, -1, -1, 110, + 111, 112, 15, -1, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 15, -1, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 15, -1, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 15, -1, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 15, -1, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, -1, -1, -1, -1, -1, -1, -1, 15, + 123, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 15, + 123, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 15, + 123, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 15, + 123, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 15, + 123, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, -1, + -1, -1, -1, -1, -1, -1, 15, 123, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 15, 123, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 15, 123, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 15, 123, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 15, 123, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, -1, -1, 37, -1, + -1, 15, 121, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, -1, 121, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + -1, -1, 121, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, -1, + -1, -1, 121, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 6, 7, 8, 9, 10, 11, 12, 13, 14 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/misc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/misc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 6: +#line 165 "ldgram.y" +{ ldlex_defsym(); ; + break;} +case 7: +#line 167 "ldgram.y" +{ + ldlex_popstate(); + lang_add_assignment(exp_assop(yyvsp[-1].token,yyvsp[-2].name,yyvsp[0].etree)); + ; + break;} +case 8: +#line 174 "ldgram.y" +{ + ldlex_mri_script (); + PUSH_ERROR (_("MRI style script")); + ; + break;} +case 9: +#line 179 "ldgram.y" +{ + ldlex_popstate (); + mri_draw_tree (); + POP_ERROR (); + ; + break;} +case 14: +#line 194 "ldgram.y" +{ + einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),yyvsp[0].name); + ; + break;} +case 15: +#line 197 "ldgram.y" +{ + config.map_filename = "-"; + ; + break;} +case 18: +#line 203 "ldgram.y" +{ mri_public(yyvsp[-2].name, yyvsp[0].etree); ; + break;} +case 19: +#line 205 "ldgram.y" +{ mri_public(yyvsp[-2].name, yyvsp[0].etree); ; + break;} +case 20: +#line 207 "ldgram.y" +{ mri_public(yyvsp[-1].name, yyvsp[0].etree); ; + break;} +case 21: +#line 209 "ldgram.y" +{ mri_format(yyvsp[0].name); ; + break;} +case 22: +#line 211 "ldgram.y" +{ mri_output_section(yyvsp[-2].name, yyvsp[0].etree);; + break;} +case 23: +#line 213 "ldgram.y" +{ mri_output_section(yyvsp[-1].name, yyvsp[0].etree);; + break;} +case 24: +#line 215 "ldgram.y" +{ mri_output_section(yyvsp[-2].name, yyvsp[0].etree);; + break;} +case 25: +#line 217 "ldgram.y" +{ mri_align(yyvsp[-2].name,yyvsp[0].etree); ; + break;} +case 26: +#line 219 "ldgram.y" +{ mri_align(yyvsp[-2].name,yyvsp[0].etree); ; + break;} +case 27: +#line 221 "ldgram.y" +{ mri_alignmod(yyvsp[-2].name,yyvsp[0].etree); ; + break;} +case 28: +#line 223 "ldgram.y" +{ mri_alignmod(yyvsp[-2].name,yyvsp[0].etree); ; + break;} +case 31: +#line 227 "ldgram.y" +{ mri_name(yyvsp[0].name); ; + break;} +case 32: +#line 229 "ldgram.y" +{ mri_alias(yyvsp[-2].name,yyvsp[0].name,0);; + break;} +case 33: +#line 231 "ldgram.y" +{ mri_alias(yyvsp[-2].name,0,(int) yyvsp[0].integer);; + break;} +case 34: +#line 233 "ldgram.y" +{ mri_base(yyvsp[0].etree); ; + break;} +case 35: +#line 235 "ldgram.y" +{ mri_truncate((unsigned int) yyvsp[0].integer); ; + break;} +case 38: +#line 239 "ldgram.y" +{ ldfile_open_command_file (yyvsp[0].name); ; + break;} +case 40: +#line 241 "ldgram.y" +{ lang_add_entry (yyvsp[0].name, false); ; + break;} +case 42: +#line 246 "ldgram.y" +{ mri_order(yyvsp[0].name); ; + break;} +case 43: +#line 247 "ldgram.y" +{ mri_order(yyvsp[0].name); ; + break;} +case 45: +#line 253 "ldgram.y" +{ mri_load(yyvsp[0].name); ; + break;} +case 46: +#line 254 "ldgram.y" +{ mri_load(yyvsp[0].name); ; + break;} +case 47: +#line 259 "ldgram.y" +{ mri_only_load(yyvsp[0].name); ; + break;} +case 48: +#line 261 "ldgram.y" +{ mri_only_load(yyvsp[0].name); ; + break;} +case 49: +#line 265 "ldgram.y" +{ yyval.name = NULL; ; + break;} +case 52: +#line 272 "ldgram.y" +{ ldlang_add_undef (yyvsp[0].name); ; + break;} +case 53: +#line 274 "ldgram.y" +{ ldlang_add_undef (yyvsp[0].name); ; + break;} +case 54: +#line 276 "ldgram.y" +{ ldlang_add_undef (yyvsp[0].name); ; + break;} +case 55: +#line 280 "ldgram.y" +{ + ldlex_both(); + ; + break;} +case 56: +#line 284 "ldgram.y" +{ + ldlex_popstate(); + ; + break;} +case 69: +#line 309 "ldgram.y" +{ lang_add_target(yyvsp[-1].name); ; + break;} +case 70: +#line 311 "ldgram.y" +{ ldfile_add_library_path (yyvsp[-1].name, false); ; + break;} +case 71: +#line 313 "ldgram.y" +{ lang_add_output(yyvsp[-1].name, 1); ; + break;} +case 72: +#line 315 "ldgram.y" +{ lang_add_output_format (yyvsp[-1].name, (char *) NULL, + (char *) NULL, 1); ; + break;} +case 73: +#line 318 "ldgram.y" +{ lang_add_output_format (yyvsp[-5].name, yyvsp[-3].name, yyvsp[-1].name, 1); ; + break;} +case 74: +#line 320 "ldgram.y" +{ ldfile_set_output_arch(yyvsp[-1].name); ; + break;} +case 75: +#line 322 "ldgram.y" +{ command_line.force_common_definition = true ; ; + break;} +case 77: +#line 325 "ldgram.y" +{ lang_enter_group (); ; + break;} +case 78: +#line 327 "ldgram.y" +{ lang_leave_group (); ; + break;} +case 79: +#line 329 "ldgram.y" +{ lang_add_map(yyvsp[-1].name); ; + break;} +case 80: +#line 331 "ldgram.y" +{ ldfile_open_command_file(yyvsp[0].name); ; + break;} +case 82: +#line 333 "ldgram.y" +{ + lang_add_nocrossref (yyvsp[-1].nocrossref); + ; + break;} +case 84: +#line 341 "ldgram.y" +{ lang_add_input_file(yyvsp[0].name,lang_input_file_is_search_file_enum, + (char *)NULL); ; + break;} +case 85: +#line 344 "ldgram.y" +{ lang_add_input_file(yyvsp[0].name,lang_input_file_is_search_file_enum, + (char *)NULL); ; + break;} +case 86: +#line 347 "ldgram.y" +{ lang_add_input_file(yyvsp[0].name,lang_input_file_is_search_file_enum, + (char *)NULL); ; + break;} +case 87: +#line 350 "ldgram.y" +{ lang_add_input_file(yyvsp[0].name,lang_input_file_is_l_enum, + (char *)NULL); ; + break;} +case 88: +#line 353 "ldgram.y" +{ lang_add_input_file(yyvsp[0].name,lang_input_file_is_l_enum, + (char *)NULL); ; + break;} +case 89: +#line 356 "ldgram.y" +{ lang_add_input_file(yyvsp[0].name,lang_input_file_is_l_enum, + (char *)NULL); ; + break;} +case 94: +#line 372 "ldgram.y" +{ lang_add_entry (yyvsp[-1].name, false); ; + break;} +case 96: +#line 380 "ldgram.y" +{ + yyval.cname = yyvsp[0].name; + ; + break;} +case 97: +#line 384 "ldgram.y" +{ + yyval.cname = "*"; + ; + break;} +case 98: +#line 388 "ldgram.y" +{ + yyval.cname = "?"; + ; + break;} +case 99: +#line 395 "ldgram.y" +{ + yyval.wildcard.name = yyvsp[0].cname; + yyval.wildcard.sorted = false; + yyval.wildcard.exclude_name_list = NULL; + ; + break;} +case 100: +#line 401 "ldgram.y" +{ + yyval.wildcard.name = yyvsp[0].cname; + yyval.wildcard.sorted = false; + yyval.wildcard.exclude_name_list = yyvsp[-2].name_list; + ; + break;} +case 101: +#line 407 "ldgram.y" +{ + yyval.wildcard.name = yyvsp[-1].cname; + yyval.wildcard.sorted = true; + yyval.wildcard.exclude_name_list = NULL; + ; + break;} +case 102: +#line 413 "ldgram.y" +{ + yyval.wildcard.name = yyvsp[-1].cname; + yyval.wildcard.sorted = true; + yyval.wildcard.exclude_name_list = yyvsp[-3].name_list; + ; + break;} +case 103: +#line 424 "ldgram.y" +{ + struct name_list *tmp; + tmp = (struct name_list *) xmalloc (sizeof *tmp); + tmp->name = yyvsp[0].cname; + tmp->next = yyvsp[-1].name_list; + yyval.name_list = tmp; + ; + break;} +case 104: +#line 433 "ldgram.y" +{ + struct name_list *tmp; + tmp = (struct name_list *) xmalloc (sizeof *tmp); + tmp->name = yyvsp[0].cname; + tmp->next = NULL; + yyval.name_list = tmp; + ; + break;} +case 105: +#line 444 "ldgram.y" +{ + lang_add_wild (yyvsp[0].wildcard.name, yyvsp[0].wildcard.sorted, + current_file.name, + current_file.sorted, + ldgram_had_keep, yyvsp[0].wildcard.exclude_name_list); + ; + break;} +case 106: +#line 451 "ldgram.y" +{ + lang_add_wild (yyvsp[0].wildcard.name, yyvsp[0].wildcard.sorted, + current_file.name, + current_file.sorted, + ldgram_had_keep, yyvsp[0].wildcard.exclude_name_list); + ; + break;} +case 107: +#line 461 "ldgram.y" +{ + lang_add_wild (NULL, false, yyvsp[0].name, false, + ldgram_had_keep, NULL); + ; + break;} +case 108: +#line 466 "ldgram.y" +{ + current_file.name = NULL; + current_file.sorted = false; + ; + break;} +case 110: +#line 472 "ldgram.y" +{ + current_file = yyvsp[0].wildcard; + /* '*' matches any file name. */ + if (strcmp (current_file.name, "*") == 0) + current_file.name = NULL; + ; + break;} +case 113: +#line 484 "ldgram.y" +{ ldgram_had_keep = true; ; + break;} +case 114: +#line 486 "ldgram.y" +{ ldgram_had_keep = false; ; + break;} +case 116: +#line 492 "ldgram.y" +{ + lang_add_attribute(lang_object_symbols_statement_enum); + ; + break;} +case 118: +#line 497 "ldgram.y" +{ + + lang_add_attribute(lang_constructors_statement_enum); + ; + break;} +case 119: +#line 502 "ldgram.y" +{ + constructors_sorted = true; + lang_add_attribute (lang_constructors_statement_enum); + ; + break;} +case 121: +#line 508 "ldgram.y" +{ + lang_add_data((int) yyvsp[-3].integer,yyvsp[-1].etree); + ; + break;} +case 122: +#line 513 "ldgram.y" +{ + lang_add_fill + (exp_get_value_int(yyvsp[-1].etree, + 0, + "fill value", + lang_first_phase_enum)); + ; + break;} +case 127: +#line 534 "ldgram.y" +{ yyval.integer = yyvsp[0].token; ; + break;} +case 128: +#line 536 "ldgram.y" +{ yyval.integer = yyvsp[0].token; ; + break;} +case 129: +#line 538 "ldgram.y" +{ yyval.integer = yyvsp[0].token; ; + break;} +case 130: +#line 540 "ldgram.y" +{ yyval.integer = yyvsp[0].token; ; + break;} +case 131: +#line 542 "ldgram.y" +{ yyval.integer = yyvsp[0].token; ; + break;} +case 132: +#line 547 "ldgram.y" +{ + yyval.integer = exp_get_value_int(yyvsp[0].etree, + 0, + "fill value", + lang_first_phase_enum); + ; + break;} +case 133: +#line 553 "ldgram.y" +{ yyval.integer = 0; ; + break;} +case 134: +#line 560 "ldgram.y" +{ yyval.token = '+'; ; + break;} +case 135: +#line 562 "ldgram.y" +{ yyval.token = '-'; ; + break;} +case 136: +#line 564 "ldgram.y" +{ yyval.token = '*'; ; + break;} +case 137: +#line 566 "ldgram.y" +{ yyval.token = '/'; ; + break;} +case 138: +#line 568 "ldgram.y" +{ yyval.token = LSHIFT; ; + break;} +case 139: +#line 570 "ldgram.y" +{ yyval.token = RSHIFT; ; + break;} +case 140: +#line 572 "ldgram.y" +{ yyval.token = '&'; ; + break;} +case 141: +#line 574 "ldgram.y" +{ yyval.token = '|'; ; + break;} +case 144: +#line 584 "ldgram.y" +{ + lang_add_assignment (exp_assop (yyvsp[-1].token, yyvsp[-2].name, yyvsp[0].etree)); + ; + break;} +case 145: +#line 588 "ldgram.y" +{ + lang_add_assignment (exp_assop ('=', yyvsp[-2].name, + exp_binop (yyvsp[-1].token, + exp_nameop (NAME, + yyvsp[-2].name), + yyvsp[0].etree))); + ; + break;} +case 146: +#line 596 "ldgram.y" +{ + lang_add_assignment (exp_provide (yyvsp[-3].name, yyvsp[-1].etree)); + ; + break;} +case 153: +#line 618 "ldgram.y" +{ region = lang_memory_region_lookup(yyvsp[0].name); ; + break;} +case 155: +#line 624 "ldgram.y" +{ region->current = + region->origin = + exp_get_vma(yyvsp[0].etree, 0L,"origin", lang_first_phase_enum); +; + break;} +case 156: +#line 632 "ldgram.y" +{ region->length = exp_get_vma(yyvsp[0].etree, + ~((bfd_vma)0), + "length", + lang_first_phase_enum); + ; + break;} +case 157: +#line 641 "ldgram.y" +{ /* dummy action to avoid bison 1.25 error message */ ; + break;} +case 161: +#line 652 "ldgram.y" +{ lang_set_flags (region, yyvsp[0].name, 0); ; + break;} +case 162: +#line 654 "ldgram.y" +{ lang_set_flags (region, yyvsp[0].name, 1); ; + break;} +case 163: +#line 659 "ldgram.y" +{ lang_startup(yyvsp[-1].name); ; + break;} +case 165: +#line 665 "ldgram.y" +{ ldemul_hll((char *)NULL); ; + break;} +case 166: +#line 670 "ldgram.y" +{ ldemul_hll(yyvsp[0].name); ; + break;} +case 167: +#line 672 "ldgram.y" +{ ldemul_hll(yyvsp[0].name); ; + break;} +case 169: +#line 680 "ldgram.y" +{ ldemul_syslib(yyvsp[0].name); ; + break;} +case 171: +#line 686 "ldgram.y" +{ lang_float(true); ; + break;} +case 172: +#line 688 "ldgram.y" +{ lang_float(false); ; + break;} +case 173: +#line 693 "ldgram.y" +{ + yyval.nocrossref = NULL; + ; + break;} +case 174: +#line 697 "ldgram.y" +{ + struct lang_nocrossref *n; + + n = (struct lang_nocrossref *) xmalloc (sizeof *n); + n->name = yyvsp[-1].name; + n->next = yyvsp[0].nocrossref; + yyval.nocrossref = n; + ; + break;} +case 175: +#line 706 "ldgram.y" +{ + struct lang_nocrossref *n; + + n = (struct lang_nocrossref *) xmalloc (sizeof *n); + n->name = yyvsp[-2].name; + n->next = yyvsp[0].nocrossref; + yyval.nocrossref = n; + ; + break;} +case 176: +#line 716 "ldgram.y" +{ ldlex_expression(); ; + break;} +case 177: +#line 718 "ldgram.y" +{ ldlex_popstate(); yyval.etree=yyvsp[0].etree;; + break;} +case 178: +#line 723 "ldgram.y" +{ yyval.etree = exp_unop('-', yyvsp[0].etree); ; + break;} +case 179: +#line 725 "ldgram.y" +{ yyval.etree = yyvsp[-1].etree; ; + break;} +case 180: +#line 727 "ldgram.y" +{ yyval.etree = exp_unop((int) yyvsp[-3].integer,yyvsp[-1].etree); ; + break;} +case 181: +#line 729 "ldgram.y" +{ yyval.etree = exp_unop('!', yyvsp[0].etree); ; + break;} +case 182: +#line 731 "ldgram.y" +{ yyval.etree = yyvsp[0].etree; ; + break;} +case 183: +#line 733 "ldgram.y" +{ yyval.etree = exp_unop('~', yyvsp[0].etree);; + break;} +case 184: +#line 736 "ldgram.y" +{ yyval.etree = exp_binop('*', yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 185: +#line 738 "ldgram.y" +{ yyval.etree = exp_binop('/', yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 186: +#line 740 "ldgram.y" +{ yyval.etree = exp_binop('%', yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 187: +#line 742 "ldgram.y" +{ yyval.etree = exp_binop('+', yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 188: +#line 744 "ldgram.y" +{ yyval.etree = exp_binop('-' , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 189: +#line 746 "ldgram.y" +{ yyval.etree = exp_binop(LSHIFT , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 190: +#line 748 "ldgram.y" +{ yyval.etree = exp_binop(RSHIFT , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 191: +#line 750 "ldgram.y" +{ yyval.etree = exp_binop(EQ , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 192: +#line 752 "ldgram.y" +{ yyval.etree = exp_binop(NE , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 193: +#line 754 "ldgram.y" +{ yyval.etree = exp_binop(LE , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 194: +#line 756 "ldgram.y" +{ yyval.etree = exp_binop(GE , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 195: +#line 758 "ldgram.y" +{ yyval.etree = exp_binop('<' , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 196: +#line 760 "ldgram.y" +{ yyval.etree = exp_binop('>' , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 197: +#line 762 "ldgram.y" +{ yyval.etree = exp_binop('&' , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 198: +#line 764 "ldgram.y" +{ yyval.etree = exp_binop('^' , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 199: +#line 766 "ldgram.y" +{ yyval.etree = exp_binop('|' , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 200: +#line 768 "ldgram.y" +{ yyval.etree = exp_trinop('?' , yyvsp[-4].etree, yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 201: +#line 770 "ldgram.y" +{ yyval.etree = exp_binop(ANDAND , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 202: +#line 772 "ldgram.y" +{ yyval.etree = exp_binop(OROR , yyvsp[-2].etree, yyvsp[0].etree); ; + break;} +case 203: +#line 774 "ldgram.y" +{ yyval.etree = exp_nameop(DEFINED, yyvsp[-1].name); ; + break;} +case 204: +#line 776 "ldgram.y" +{ yyval.etree = exp_intop(yyvsp[0].integer); ; + break;} +case 205: +#line 778 "ldgram.y" +{ yyval.etree = exp_nameop(SIZEOF_HEADERS,0); ; + break;} +case 206: +#line 781 "ldgram.y" +{ yyval.etree = exp_nameop(SIZEOF,yyvsp[-1].name); ; + break;} +case 207: +#line 783 "ldgram.y" +{ yyval.etree = exp_nameop(ADDR,yyvsp[-1].name); ; + break;} +case 208: +#line 785 "ldgram.y" +{ yyval.etree = exp_nameop(LOADADDR,yyvsp[-1].name); ; + break;} +case 209: +#line 787 "ldgram.y" +{ yyval.etree = exp_unop(ABSOLUTE, yyvsp[-1].etree); ; + break;} +case 210: +#line 789 "ldgram.y" +{ yyval.etree = exp_unop(ALIGN_K,yyvsp[-1].etree); ; + break;} +case 211: +#line 791 "ldgram.y" +{ yyval.etree = exp_unop(ALIGN_K,yyvsp[-1].etree); ; + break;} +case 212: +#line 793 "ldgram.y" +{ yyval.etree = exp_nameop(NAME,yyvsp[0].name); ; + break;} +case 213: +#line 795 "ldgram.y" +{ yyval.etree = exp_binop (MAX_K, yyvsp[-3].etree, yyvsp[-1].etree ); ; + break;} +case 214: +#line 797 "ldgram.y" +{ yyval.etree = exp_binop (MIN_K, yyvsp[-3].etree, yyvsp[-1].etree ); ; + break;} +case 215: +#line 799 "ldgram.y" +{ yyval.etree = exp_assert (yyvsp[-3].etree, yyvsp[-1].name); ; + break;} +case 216: +#line 804 "ldgram.y" +{ yyval.name = yyvsp[0].name; ; + break;} +case 217: +#line 805 "ldgram.y" +{ yyval.name = "*default*"; ; + break;} +case 218: +#line 809 "ldgram.y" +{ yyval.etree = yyvsp[-1].etree; ; + break;} +case 219: +#line 810 "ldgram.y" +{ yyval.etree = 0; ; + break;} +case 220: +#line 813 "ldgram.y" +{ ldlex_expression(); ; + break;} +case 221: +#line 815 "ldgram.y" +{ ldlex_popstate (); ldlex_script (); ; + break;} +case 222: +#line 817 "ldgram.y" +{ + lang_enter_output_section_statement(yyvsp[-5].name, yyvsp[-3].etree, + sectype, + 0, 0, 0, yyvsp[-2].etree); + ; + break;} +case 223: +#line 823 "ldgram.y" +{ ldlex_popstate (); ldlex_expression (); ; + break;} +case 224: +#line 825 "ldgram.y" +{ + ldlex_popstate (); + lang_leave_output_section_statement (yyvsp[0].integer, yyvsp[-3].name, yyvsp[-1].section_phdr, yyvsp[-2].name); + ; + break;} +case 226: +#line 831 "ldgram.y" +{ ldlex_expression (); ; + break;} +case 227: +#line 833 "ldgram.y" +{ ldlex_popstate (); ldlex_script (); ; + break;} +case 228: +#line 835 "ldgram.y" +{ + lang_enter_overlay (yyvsp[-4].etree, yyvsp[-2].etree, (int) yyvsp[-3].integer); + ; + break;} +case 229: +#line 840 "ldgram.y" +{ ldlex_popstate (); ldlex_expression (); ; + break;} +case 230: +#line 842 "ldgram.y" +{ + ldlex_popstate (); + lang_leave_overlay (yyvsp[0].integer, yyvsp[-3].name, yyvsp[-1].section_phdr, yyvsp[-2].name); + ; + break;} +case 232: +#line 851 "ldgram.y" +{ ldlex_expression (); ; + break;} +case 233: +#line 853 "ldgram.y" +{ + ldlex_popstate (); + lang_add_assignment (exp_assop ('=', ".", yyvsp[0].etree)); + ; + break;} +case 235: +#line 861 "ldgram.y" +{ sectype = noload_section; ; + break;} +case 236: +#line 862 "ldgram.y" +{ sectype = dsect_section; ; + break;} +case 237: +#line 863 "ldgram.y" +{ sectype = copy_section; ; + break;} +case 238: +#line 864 "ldgram.y" +{ sectype = info_section; ; + break;} +case 239: +#line 865 "ldgram.y" +{ sectype = overlay_section; ; + break;} +case 241: +#line 870 "ldgram.y" +{ sectype = normal_section; ; + break;} +case 242: +#line 871 "ldgram.y" +{ sectype = normal_section; ; + break;} +case 243: +#line 875 "ldgram.y" +{ yyval.etree = yyvsp[-2].etree; ; + break;} +case 244: +#line 876 "ldgram.y" +{ yyval.etree = (etree_type *)NULL; ; + break;} +case 245: +#line 881 "ldgram.y" +{ yyval.etree = yyvsp[-3].etree; ; + break;} +case 246: +#line 883 "ldgram.y" +{ yyval.etree = yyvsp[-7].etree; ; + break;} +case 247: +#line 887 "ldgram.y" +{ yyval.etree = yyvsp[-1].etree; ; + break;} +case 248: +#line 888 "ldgram.y" +{ yyval.etree = (etree_type *) NULL; ; + break;} +case 249: +#line 893 "ldgram.y" +{ yyval.integer = 0; ; + break;} +case 250: +#line 895 "ldgram.y" +{ yyval.integer = 1; ; + break;} +case 251: +#line 900 "ldgram.y" +{ yyval.name = yyvsp[0].name; ; + break;} +case 252: +#line 901 "ldgram.y" +{ yyval.name = "*default*"; ; + break;} +case 253: +#line 906 "ldgram.y" +{ + yyval.section_phdr = NULL; + ; + break;} +case 254: +#line 910 "ldgram.y" +{ + struct lang_output_section_phdr_list *n; + + n = ((struct lang_output_section_phdr_list *) + xmalloc (sizeof *n)); + n->name = yyvsp[0].name; + n->used = false; + n->next = yyvsp[-2].section_phdr; + yyval.section_phdr = n; + ; + break;} +case 256: +#line 926 "ldgram.y" +{ + ldlex_script (); + lang_enter_overlay_section (yyvsp[0].name); + ; + break;} +case 257: +#line 931 "ldgram.y" +{ ldlex_popstate (); ldlex_expression (); ; + break;} +case 258: +#line 933 "ldgram.y" +{ + ldlex_popstate (); + lang_leave_overlay_section (yyvsp[0].integer, yyvsp[-1].section_phdr); + ; + break;} +case 263: +#line 950 "ldgram.y" +{ ldlex_expression (); ; + break;} +case 264: +#line 951 "ldgram.y" +{ ldlex_popstate (); ; + break;} +case 265: +#line 953 "ldgram.y" +{ + lang_new_phdr (yyvsp[-5].name, yyvsp[-3].etree, yyvsp[-2].phdr.filehdr, yyvsp[-2].phdr.phdrs, yyvsp[-2].phdr.at, + yyvsp[-2].phdr.flags); + ; + break;} +case 266: +#line 961 "ldgram.y" +{ + yyval.etree = yyvsp[0].etree; + + if (yyvsp[0].etree->type.node_class == etree_name + && yyvsp[0].etree->type.node_code == NAME) + { + const char *s; + unsigned int i; + static const char * const phdr_types[] = + { + "PT_NULL", "PT_LOAD", "PT_DYNAMIC", + "PT_INTERP", "PT_NOTE", "PT_SHLIB", + "PT_PHDR" + }; + + s = yyvsp[0].etree->name.name; + for (i = 0; + i < sizeof phdr_types / sizeof phdr_types[0]; + i++) + if (strcmp (s, phdr_types[i]) == 0) + { + yyval.etree = exp_intop (i); + break; + } + } + ; + break;} +case 267: +#line 991 "ldgram.y" +{ + memset (&yyval.phdr, 0, sizeof (struct phdr_info)); + ; + break;} +case 268: +#line 995 "ldgram.y" +{ + yyval.phdr = yyvsp[0].phdr; + if (strcmp (yyvsp[-2].name, "FILEHDR") == 0 && yyvsp[-1].etree == NULL) + yyval.phdr.filehdr = true; + else if (strcmp (yyvsp[-2].name, "PHDRS") == 0 && yyvsp[-1].etree == NULL) + yyval.phdr.phdrs = true; + else if (strcmp (yyvsp[-2].name, "FLAGS") == 0 && yyvsp[-1].etree != NULL) + yyval.phdr.flags = yyvsp[-1].etree; + else + einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), yyvsp[-2].name); + ; + break;} +case 269: +#line 1007 "ldgram.y" +{ + yyval.phdr = yyvsp[0].phdr; + yyval.phdr.at = yyvsp[-2].etree; + ; + break;} +case 270: +#line 1015 "ldgram.y" +{ + yyval.etree = NULL; + ; + break;} +case 271: +#line 1019 "ldgram.y" +{ + yyval.etree = yyvsp[-1].etree; + ; + break;} +case 272: +#line 1027 "ldgram.y" +{ + ldlex_version_file (); + PUSH_ERROR (_("VERSION script")); + ; + break;} +case 273: +#line 1032 "ldgram.y" +{ + ldlex_popstate (); + POP_ERROR (); + ; + break;} +case 274: +#line 1041 "ldgram.y" +{ + ldlex_version_script (); + ; + break;} +case 275: +#line 1045 "ldgram.y" +{ + ldlex_popstate (); + ; + break;} +case 278: +#line 1057 "ldgram.y" +{ + lang_register_vers_node (yyvsp[-4].name, yyvsp[-2].versnode, NULL); + ; + break;} +case 279: +#line 1061 "ldgram.y" +{ + lang_register_vers_node (yyvsp[-5].name, yyvsp[-3].versnode, yyvsp[-1].deflist); + ; + break;} +case 280: +#line 1068 "ldgram.y" +{ + yyval.deflist = lang_add_vers_depend (NULL, yyvsp[0].name); + ; + break;} +case 281: +#line 1072 "ldgram.y" +{ + yyval.deflist = lang_add_vers_depend (yyvsp[-1].deflist, yyvsp[0].name); + ; + break;} +case 282: +#line 1079 "ldgram.y" +{ + yyval.versnode = lang_new_vers_node (NULL, NULL); + ; + break;} +case 283: +#line 1083 "ldgram.y" +{ + yyval.versnode = lang_new_vers_node (yyvsp[-1].versyms, NULL); + ; + break;} +case 284: +#line 1087 "ldgram.y" +{ + yyval.versnode = lang_new_vers_node (yyvsp[-1].versyms, NULL); + ; + break;} +case 285: +#line 1091 "ldgram.y" +{ + yyval.versnode = lang_new_vers_node (NULL, yyvsp[-1].versyms); + ; + break;} +case 286: +#line 1095 "ldgram.y" +{ + yyval.versnode = lang_new_vers_node (yyvsp[-5].versyms, yyvsp[-1].versyms); + ; + break;} +case 287: +#line 1102 "ldgram.y" +{ + yyval.versyms = lang_new_vers_regex (NULL, yyvsp[0].name, ldgram_vers_current_lang); + ; + break;} +case 288: +#line 1106 "ldgram.y" +{ + yyval.versyms = lang_new_vers_regex (yyvsp[-2].versyms, yyvsp[0].name, ldgram_vers_current_lang); + ; + break;} +case 289: +#line 1110 "ldgram.y" +{ + yyval.name = ldgram_vers_current_lang; + ldgram_vers_current_lang = yyvsp[-1].name; + ; + break;} +case 290: +#line 1115 "ldgram.y" +{ + ldgram_vers_current_lang = yyvsp[-2].name; + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/misc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 1120 "ldgram.y" + +void +yyerror(arg) + const char *arg; +{ + if (ldfile_assumed_script) + einfo (_("%P:%s: file format not recognized; treating as linker script\n"), + ldfile_input_filename); + if (error_index > 0 && error_index < ERROR_NAME_MAX) + einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]); + else + einfo ("%P%F:%S: %s\n", arg); +} diff --git a/ld/ldgram.h b/ld/ldgram.h new file mode 100644 index 00000000000..c7890807b6a --- /dev/null +++ b/ld/ldgram.h @@ -0,0 +1,126 @@ +typedef union { + bfd_vma integer; + char *name; + const char *cname; + struct wildcard_spec wildcard; + struct name_list *name_list; + int token; + union etree_union *etree; + struct phdr_info + { + boolean filehdr; + boolean phdrs; + union etree_union *at; + union etree_union *flags; + } phdr; + struct lang_nocrossref *nocrossref; + struct lang_output_section_phdr_list *section_phdr; + struct bfd_elf_version_deps *deflist; + struct bfd_elf_version_expr *versyms; + struct bfd_elf_version_tree *versnode; +} YYSTYPE; +#define INT 257 +#define NAME 258 +#define LNAME 259 +#define PLUSEQ 260 +#define MINUSEQ 261 +#define MULTEQ 262 +#define DIVEQ 263 +#define LSHIFTEQ 264 +#define RSHIFTEQ 265 +#define ANDEQ 266 +#define OREQ 267 +#define OROR 268 +#define ANDAND 269 +#define EQ 270 +#define NE 271 +#define LE 272 +#define GE 273 +#define LSHIFT 274 +#define RSHIFT 275 +#define UNARY 276 +#define END 277 +#define ALIGN_K 278 +#define BLOCK 279 +#define BIND 280 +#define QUAD 281 +#define SQUAD 282 +#define LONG 283 +#define SHORT 284 +#define BYTE 285 +#define SECTIONS 286 +#define PHDRS 287 +#define SORT 288 +#define SIZEOF_HEADERS 289 +#define OUTPUT_FORMAT 290 +#define FORCE_COMMON_ALLOCATION 291 +#define OUTPUT_ARCH 292 +#define INCLUDE 293 +#define MEMORY 294 +#define DEFSYMEND 295 +#define NOLOAD 296 +#define DSECT 297 +#define COPY 298 +#define INFO 299 +#define OVERLAY 300 +#define DEFINED 301 +#define TARGET_K 302 +#define SEARCH_DIR 303 +#define MAP 304 +#define ENTRY 305 +#define NEXT 306 +#define SIZEOF 307 +#define ADDR 308 +#define LOADADDR 309 +#define MAX_K 310 +#define MIN_K 311 +#define STARTUP 312 +#define HLL 313 +#define SYSLIB 314 +#define FLOAT 315 +#define NOFLOAT 316 +#define NOCROSSREFS 317 +#define ORIGIN 318 +#define FILL 319 +#define LENGTH 320 +#define CREATE_OBJECT_SYMBOLS 321 +#define INPUT 322 +#define GROUP 323 +#define OUTPUT 324 +#define CONSTRUCTORS 325 +#define ALIGNMOD 326 +#define AT 327 +#define PROVIDE 328 +#define CHIP 329 +#define LIST 330 +#define SECT 331 +#define ABSOLUTE 332 +#define LOAD 333 +#define NEWLINE 334 +#define ENDWORD 335 +#define ORDER 336 +#define NAMEWORD 337 +#define ASSERT_K 338 +#define FORMAT 339 +#define PUBLIC 340 +#define BASE 341 +#define ALIAS 342 +#define TRUNCATE 343 +#define REL 344 +#define INPUT_SCRIPT 345 +#define INPUT_MRI_SCRIPT 346 +#define INPUT_DEFSYM 347 +#define CASE 348 +#define EXTERN 349 +#define START 350 +#define VERS_TAG 351 +#define VERS_IDENTIFIER 352 +#define GLOBAL 353 +#define LOCAL 354 +#define VERSIONK 355 +#define INPUT_VERSION_SCRIPT 356 +#define KEEP 357 +#define EXCLUDE_FILE 358 + + +extern YYSTYPE yylval; diff --git a/ld/ldlex.c b/ld/ldlex.c new file mode 100644 index 00000000000..f385d6e11bb --- /dev/null +++ b/ld/ldlex.c @@ -0,0 +1,3592 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> +#include <unistd.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 169 +#define YY_END_OF_BUFFER 170 +static yyconst short int yy_accept[1062] = + { 0, + 0, 0, 149, 149, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 170, 169, + 167, 152, 151, 32, 167, 149, 38, 29, 44, 43, + 34, 35, 28, 36, 149, 37, 8, 8, 45, 46, + 39, 40, 27, 33, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 10, 9, 149, 99, 97, 149, 42, + 30, 41, 31, 168, 152, 32, 168, 147, 38, 29, + 44, 43, 34, 35, 28, 36, 147, 37, 8, 8, + 45, 46, 39, 40, 27, 33, 147, 147, 147, 147, + + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 10, 9, 147, 147, 42, 30, 41, 31, 147, + 8, 8, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 99, 97, 4, 3, 2, 4, 5, 108, 107, 146, + 34, 35, 28, 36, 146, 37, 8, 8, 45, 46, + 40, 33, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 10, 9, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 31, 166, 164, + 165, 159, 158, 153, 160, 161, 157, 157, 157, 157, + + 162, 163, 152, 15, 0, 150, 149, 8, 26, 24, + 22, 20, 21, 1, 23, 8, 8, 149, 18, 17, + 14, 16, 19, 149, 149, 149, 103, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 25, 13, + 147, 6, 22, 20, 21, 0, 1, 23, 8, 0, + 7, 7, 8, 7, 14, 147, 7, 7, 7, 147, + 147, 103, 7, 147, 147, 7, 147, 147, 7, 147, + + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 7, 147, 8, 8, 0, 147, 147, 147, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 147, 147, 4, + 4, 107, 107, 146, 6, 109, 22, 23, 110, 146, + 7, 7, 7, 146, 146, 146, 7, 146, 7, 7, + 146, 146, 146, 146, 146, 146, 146, 146, 7, 146, + 146, 146, 7, 146, 7, 7, 146, 146, 146, 146, + 146, 146, 146, 146, 166, 165, 158, 157, 157, 157, + + 157, 11, 12, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 80, 149, 149, 149, 149, 149, 149, 149, 64, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 100, 98, 149, 8, 148, 8, 147, 7, + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 147, 56, 57, 147, 147, 147, 147, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 147, 80, 147, 147, 147, 147, 64, 147, 147, + + 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 147, 147, 147, 100, 98, 4, 8, 146, 146, + 146, 146, 146, 111, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 128, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 157, 157, 157, 149, 54, 149, 51, 149, 87, 149, + 94, 149, 149, 149, 149, 149, 149, 76, 149, 149, + 149, 149, 95, 149, 105, 149, 149, 85, 149, 61, + 149, 149, 149, 149, 149, 149, 149, 149, 83, 149, + 149, 149, 149, 91, 149, 149, 149, 149, 149, 149, + + 149, 147, 54, 147, 147, 51, 147, 94, 147, 147, + 147, 147, 95, 105, 147, 61, 147, 147, 147, 147, + 147, 147, 147, 87, 147, 147, 147, 147, 76, 147, + 147, 147, 147, 147, 85, 147, 147, 147, 147, 147, + 147, 83, 147, 147, 147, 91, 147, 147, 147, 147, + 147, 146, 146, 146, 115, 123, 114, 146, 146, 125, + 118, 121, 146, 146, 126, 146, 146, 146, 146, 146, + 132, 140, 131, 146, 146, 143, 135, 138, 146, 146, + 144, 146, 146, 157, 157, 157, 149, 53, 50, 149, + 149, 149, 93, 59, 149, 149, 82, 149, 70, 149, + + 69, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 102, 149, 149, 149, 86, 149, 84, 149, 149, 149, + 149, 149, 149, 147, 53, 147, 50, 147, 93, 147, + 70, 147, 147, 147, 147, 147, 147, 147, 147, 147, + 147, 59, 147, 82, 147, 147, 69, 147, 147, 147, + 147, 147, 147, 102, 147, 147, 86, 84, 147, 147, + 147, 147, 146, 116, 113, 146, 146, 125, 125, 120, + 146, 124, 146, 146, 133, 130, 146, 146, 143, 143, + 137, 146, 142, 146, 157, 157, 155, 149, 149, 149, + 149, 149, 60, 149, 149, 52, 149, 47, 149, 149, + + 92, 48, 68, 149, 149, 149, 149, 65, 149, 81, + 66, 149, 149, 149, 147, 58, 147, 147, 147, 147, + 92, 147, 147, 65, 147, 147, 147, 147, 60, 147, + 147, 52, 47, 147, 48, 68, 147, 147, 147, 147, + 81, 66, 147, 146, 146, 60, 122, 119, 146, 146, + 146, 141, 139, 136, 146, 156, 154, 149, 149, 149, + 71, 149, 149, 101, 149, 149, 88, 149, 90, 104, + 149, 149, 149, 77, 49, 149, 149, 147, 71, 147, + 147, 147, 96, 104, 147, 147, 147, 147, 147, 147, + 101, 88, 147, 90, 147, 147, 77, 49, 146, 146, + + 146, 146, 146, 146, 127, 149, 149, 149, 149, 55, + 149, 149, 149, 149, 75, 149, 145, 149, 127, 147, + 55, 147, 147, 145, 147, 147, 147, 147, 147, 147, + 147, 75, 127, 112, 117, 145, 129, 134, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 147, 149, 149, + 149, 149, 149, 149, 149, 67, 149, 149, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 67, 149, 149, + 149, 149, 89, 79, 149, 149, 149, 147, 89, 147, + 147, 147, 147, 147, 79, 147, 73, 149, 106, 149, + + 149, 149, 149, 106, 147, 147, 73, 147, 147, 147, + 149, 149, 78, 149, 149, 147, 147, 147, 147, 78, + 149, 149, 63, 62, 63, 62, 147, 147, 149, 149, + 147, 147, 149, 149, 147, 147, 149, 149, 147, 147, + 149, 149, 147, 147, 149, 149, 147, 147, 149, 149, + 147, 147, 72, 149, 72, 147, 149, 147, 74, 74, + 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 5, 6, 7, 8, 9, 1, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 20, 21, 22, + 23, 24, 25, 1, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 16, 48, 49, 50, + 51, 52, 53, 1, 54, 1, 55, 56, 57, 58, + + 59, 60, 61, 62, 63, 16, 64, 65, 66, 67, + 68, 69, 16, 70, 71, 72, 73, 16, 16, 74, + 16, 75, 76, 77, 78, 79, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[80] = + { 0, + 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, + 1, 4, 5, 6, 5, 7, 8, 9, 9, 5, + 1, 1, 6, 1, 4, 9, 9, 9, 9, 9, + 9, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 5, 8, 5, 7, 9, 9, 9, 9, 9, 9, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 1, 1, 1, 8 + } ; + +static yyconst short int yy_base[1084] = + { 0, + 0, 0, 0, 0, 79, 0, 152, 0, 220, 298, + 376, 0, 160, 170, 455, 534, 613, 692, 1902, 1903, + 1903, 1899, 1903, 1877, 1894, 754, 1903, 151, 1903, 1903, + 1875, 1874, 0, 1873, 0, 152, 296, 229, 0, 1903, + 145, 1872, 164, 0, 223, 164, 160, 172, 156, 217, + 1851, 1856, 1853, 1861, 175, 135, 219, 215, 220, 1844, + 236, 1863, 1858, 0, 0, 1831, 1827, 1815, 1821, 1903, + 195, 1903, 0, 1903, 1881, 1859, 1876, 797, 1903, 265, + 1903, 1903, 1857, 1856, 1903, 154, 0, 252, 840, 1804, + 1903, 1903, 233, 1854, 256, 1903, 897, 299, 302, 308, + + 321, 327, 1833, 1836, 1844, 1833, 180, 247, 1825, 1828, + 1836, 1903, 1903, 454, 1806, 1903, 214, 1903, 0, 954, + 700, 542, 457, 448, 243, 297, 320, 453, 1831, 1828, + 252, 462, 254, 457, 297, 1820, 479, 1839, 1834, 1807, + 1803, 1791, 997, 1903, 1903, 0, 1903, 1903, 1857, 1040, + 1836, 1835, 1903, 1834, 0, 1833, 0, 1781, 1903, 0, + 1831, 1903, 1083, 488, 490, 330, 535, 536, 321, 1827, + 1809, 1805, 139, 1807, 1903, 1903, 538, 540, 542, 572, + 561, 503, 1794, 1778, 1774, 446, 1776, 0, 1843, 1903, + 0, 1903, 0, 1903, 1903, 1903, 0, 1770, 1778, 1774, + + 1903, 1903, 1839, 1903, 1835, 1903, 0, 1140, 1903, 1903, + 0, 0, 0, 0, 0, 622, 0, 607, 1816, 1903, + 0, 1903, 1815, 1793, 1800, 1786, 0, 1772, 1762, 1750, + 481, 1762, 1759, 1759, 1740, 536, 1739, 1727, 1715, 1713, + 1714, 561, 1707, 1697, 581, 1694, 1690, 1614, 616, 1627, + 1615, 1629, 1629, 1617, 1630, 542, 1615, 1604, 1610, 1606, + 1625, 1606, 1606, 1605, 1576, 1579, 1584, 1569, 1903, 1903, + 0, 1189, 1903, 1903, 1903, 0, 1903, 0, 1569, 712, + 0, 1903, 1903, 0, 1903, 625, 695, 750, 0, 1608, + 1597, 0, 761, 1601, 1599, 1597, 802, 1607, 1608, 1595, + + 1603, 1603, 1606, 1583, 1591, 1581, 434, 1598, 1587, 1576, + 793, 1550, 613, 825, 0, 1580, 1594, 1577, 543, 1591, + 1589, 1574, 597, 1581, 1577, 1573, 1578, 692, 1575, 622, + 552, 1575, 697, 1573, 1561, 1575, 1575, 1577, 629, 1562, + 1557, 1548, 1564, 1540, 1540, 1539, 1510, 1513, 1518, 0, + 1238, 1575, 1903, 0, 1287, 0, 0, 1903, 0, 336, + 710, 564, 0, 1543, 715, 719, 1542, 1546, 1529, 1530, + 1528, 1545, 1532, 1540, 1541, 1539, 1540, 1519, 690, 1501, + 728, 764, 1500, 1504, 1489, 1490, 1488, 1503, 1491, 1498, + 1499, 1497, 1498, 1479, 1549, 0, 0, 0, 1478, 1481, + + 1491, 1903, 1903, 1507, 1503, 1513, 1515, 1515, 1512, 1497, + 1491, 1513, 1504, 1509, 1493, 1498, 1499, 1491, 1501, 1498, + 1479, 0, 1487, 1482, 1470, 1471, 1474, 1476, 1472, 0, + 1463, 1457, 1458, 1463, 1459, 1466, 1456, 1453, 1452, 1447, + 1464, 1449, 1446, 1447, 1459, 1443, 1461, 1443, 1448, 1452, + 1439, 1414, 0, 0, 1422, 0, 0, 796, 1440, 874, + 1447, 1448, 1448, 1448, 1426, 848, 1446, 1436, 1426, 1431, + 1429, 1440, 0, 0, 1423, 1424, 1426, 1422, 1417, 1433, + 1394, 1402, 1417, 1429, 1414, 1431, 1417, 1407, 1419, 1411, + 1421, 1418, 0, 1407, 1392, 1402, 1396, 0, 1387, 1389, + + 1393, 1383, 1380, 1379, 1392, 1377, 1374, 1375, 1372, 1390, + 1372, 1377, 1381, 1368, 0, 0, 0, 0, 1371, 463, + 1380, 1379, 1367, 0, 1377, 1368, 1360, 1375, 1373, 1372, + 1364, 1355, 1356, 1359, 1329, 535, 1337, 1336, 1325, 0, + 1334, 1326, 1319, 1332, 1330, 1329, 1322, 1314, 1315, 1317, + 1324, 1326, 1326, 1343, 0, 1340, 0, 1337, 0, 1327, + 0, 1326, 1331, 1324, 1319, 1320, 1317, 0, 1311, 1322, + 1309, 1303, 0, 1303, 0, 1296, 1314, 0, 1296, 0, + 1298, 1297, 1310, 1301, 1288, 1296, 1288, 1297, 0, 1302, + 1295, 1283, 1287, 0, 1297, 1279, 1288, 1291, 1286, 1254, + + 1244, 1274, 0, 1271, 1266, 0, 1272, 0, 1268, 1258, + 1255, 1259, 0, 0, 1273, 0, 1252, 1265, 1253, 1255, + 1248, 1222, 1218, 0, 1240, 1239, 1234, 1239, 0, 1236, + 1250, 1233, 1233, 1232, 0, 1232, 1233, 1238, 1225, 1233, + 1219, 0, 1234, 1227, 1215, 0, 1230, 1213, 1220, 1222, + 1217, 1213, 1199, 1203, 0, 0, 0, 1198, 1214, 1353, + 0, 0, 1196, 1204, 0, 1192, 1208, 1170, 1163, 1166, + 0, 0, 0, 1162, 1176, 1431, 0, 0, 1160, 1166, + 0, 1156, 1169, 1154, 1168, 1157, 1175, 0, 0, 1171, + 1183, 1182, 0, 0, 1182, 1171, 0, 1155, 0, 1176, + + 0, 1170, 1173, 1152, 1150, 1167, 1163, 1152, 1145, 1163, + 0, 1159, 1154, 1146, 0, 1154, 0, 1138, 1156, 1137, + 1141, 1107, 1119, 1131, 0, 1130, 0, 1144, 0, 1144, + 0, 1143, 1121, 1135, 1137, 1133, 1130, 1087, 1096, 1112, + 1124, 0, 1114, 0, 1098, 1121, 0, 1116, 1099, 1121, + 1107, 1099, 1111, 0, 1103, 1095, 0, 0, 1088, 1106, + 1087, 1090, 1083, 0, 1090, 1088, 1081, 0, 1509, 0, + 1097, 0, 1098, 1049, 0, 1055, 1052, 1046, 0, 1587, + 0, 1060, 0, 1060, 1041, 1042, 0, 1061, 1059, 1050, + 1074, 1064, 0, 1065, 1062, 0, 1062, 0, 1046, 1044, + + 0, 0, 1034, 1038, 1056, 1031, 1045, 1029, 1041, 0, + 0, 1042, 1008, 1025, 1033, 0, 1048, 1046, 260, 246, + 0, 275, 295, 457, 454, 475, 484, 487, 0, 522, + 575, 0, 0, 593, 0, 596, 607, 605, 624, 626, + 0, 0, 629, 630, 636, 0, 0, 0, 635, 609, + 614, 0, 0, 0, 611, 0, 0, 654, 657, 647, + 0, 645, 664, 0, 665, 678, 0, 736, 0, 0, + 697, 685, 702, 0, 0, 682, 687, 728, 0, 706, + 732, 746, 0, 0, 759, 734, 734, 769, 760, 762, + 0, 0, 777, 0, 775, 763, 0, 0, 787, 789, + + 789, 762, 778, 781, 0, 796, 815, 814, 810, 0, + 819, 807, 811, 831, 0, 842, 0, 815, 0, 848, + 0, 851, 853, 0, 825, 841, 860, 852, 851, 865, + 873, 0, 0, 0, 0, 0, 0, 0, 869, 875, + 878, 875, 889, 893, 879, 886, 905, 877, 899, 904, + 910, 883, 899, 905, 905, 916, 903, 904, 905, 919, + 913, 911, 914, 927, 923, 0, 933, 905, 927, 922, + 938, 910, 926, 940, 934, 942, 938, 0, 933, 950, + 949, 947, 0, 0, 961, 958, 930, 960, 0, 961, + 933, 949, 966, 956, 0, 970, 0, 952, 0, 944, + + 954, 957, 931, 0, 959, 933, 0, 959, 951, 961, + 953, 982, 0, 973, 947, 975, 949, 967, 996, 0, + 985, 993, 0, 0, 0, 0, 987, 995, 984, 997, + 986, 999, 999, 998, 1001, 1000, 1014, 1014, 1016, 1016, + 1005, 1020, 1007, 1022, 1012, 1005, 1014, 1015, 1017, 1028, + 1019, 1030, 0, 1025, 0, 1032, 1034, 1035, 0, 0, + 1903, 1665, 1674, 1683, 1692, 1701, 1710, 1717, 1724, 1731, + 1740, 1747, 1756, 1765, 1774, 1777, 1784, 1791, 1066, 1800, + 1809, 1818, 1827 + } ; + +static yyconst short int yy_def[1084] = + { 0, + 1062, 1062, 1061, 3, 1061, 5, 5, 7, 1063, 1063, + 1061, 11, 1064, 1064, 1065, 1065, 1066, 1066, 1061, 1061, + 1061, 1061, 1061, 1061, 1067, 1068, 1061, 1061, 1061, 1061, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1061, + 1061, 1068, 1061, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1061, + 1061, 1061, 1068, 1061, 1061, 1061, 1067, 1069, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1069, 1069, 1061, 89, + 1061, 1061, 1061, 1061, 1061, 1061, 1069, 97, 97, 97, + + 97, 97, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1061, 1061, 97, 1069, 1061, 1061, 1061, 1069, 1069, + 1061, 1061, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1070, 1061, 1061, 1070, 1061, 1061, 1071, 1072, + 1073, 1061, 1061, 1061, 1072, 1072, 89, 89, 1061, 1074, + 1061, 1061, 1072, 163, 163, 163, 163, 163, 1072, 1072, + 1072, 1072, 1072, 1072, 1061, 1061, 163, 163, 163, 163, + 163, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1061, 1061, + 1075, 1061, 1076, 1061, 1061, 1061, 1077, 1077, 1077, 1077, + + 1061, 1061, 1061, 1061, 1067, 1061, 1068, 1068, 1061, 1061, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 208, 1061, 1061, + 1068, 1061, 1061, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1061, 1061, + 1069, 1069, 1061, 1061, 1061, 1078, 1061, 1069, 89, 89, + 280, 1061, 1061, 1079, 1061, 97, 97, 97, 1069, 1069, + 1069, 1069, 97, 1069, 1069, 1069, 97, 1069, 1069, 1069, + + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 97, 1069, 120, 1061, 1079, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1070, + 1070, 1071, 1061, 1072, 1072, 1073, 1073, 1061, 1074, 163, + 163, 163, 1072, 1072, 163, 163, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 163, 1072, + 163, 163, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1072, 1061, 1075, 1076, 1077, 1077, 1077, + + 1077, 1061, 1061, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1069, 1078, 1079, 1069, 97, + 1069, 1069, 1069, 1069, 1069, 97, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1070, 1072, 1072, 1072, + 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, + 1077, 1077, 1077, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + + 1068, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1080, + 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1072, 1072, 1081, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1077, 1077, 1077, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1072, 1072, 1072, 1072, 1072, 1082, 1080, 1072, + 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1083, 1081, + 1072, 1072, 1072, 1072, 1077, 1077, 1077, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1072, 1072, 1072, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1072, 1072, 1077, 1077, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1072, 1072, + + 1072, 1072, 1072, 1072, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1069, 1069, 1072, 1072, 1072, 1072, 1072, 1072, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1068, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1069, 1069, 1069, + 1069, 1069, 1069, 1069, 1069, 1069, 1068, 1068, 1068, 1068, + + 1068, 1068, 1068, 1069, 1069, 1069, 1069, 1069, 1069, 1069, + 1068, 1068, 1068, 1068, 1068, 1069, 1069, 1069, 1069, 1069, + 1068, 1068, 1068, 1068, 1069, 1069, 1069, 1069, 1068, 1068, + 1069, 1069, 1068, 1068, 1069, 1069, 1068, 1068, 1069, 1069, + 1068, 1068, 1069, 1069, 1068, 1068, 1069, 1069, 1068, 1068, + 1069, 1069, 1068, 1068, 1069, 1069, 1068, 1069, 1068, 1069, + 0, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061 + } ; + +static yyconst short int yy_nxt[1983] = + { 0, + 21, 22, 23, 24, 25, 21, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 35, 54, 55, 56, 57, 58, + 59, 60, 35, 61, 62, 35, 63, 35, 35, 35, + 64, 35, 65, 35, 66, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 67, 35, 35, 68, 35, 35, + 69, 35, 35, 35, 35, 70, 71, 72, 73, 74, + 75, 23, 76, 77, 74, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 87, 104, 87, 105, 106, 107, 108, 109, 110, + 87, 87, 111, 87, 87, 87, 87, 87, 87, 112, + 87, 113, 87, 114, 102, 102, 102, 102, 102, 87, + 87, 87, 87, 87, 87, 87, 87, 87, 87, 115, + 87, 87, 87, 87, 116, 117, 118, 119, 120, 209, + 246, 189, 190, 214, 247, 191, 219, 220, 376, 121, + 122, 189, 190, 210, 215, 191, 275, 123, 124, 125, + 126, 127, 128, 377, 129, 130, 222, 223, 131, 132, + 133, 134, 135, 136, 235, 137, 138, 228, 139, 231, + + 229, 233, 232, 236, 244, 304, 140, 87, 87, 87, + 87, 87, 230, 305, 245, 234, 141, 269, 276, 142, + 74, 74, 20, 74, 74, 74, 143, 74, 74, 74, + 74, 74, 144, 74, 145, 192, 269, 121, 122, 74, + 74, 74, 147, 74, 74, 192, 216, 216, 248, 224, + 237, 225, 253, 238, 219, 220, 239, 250, 249, 226, + 251, 252, 254, 277, 217, 256, 217, 227, 257, 258, + 74, 270, 74, 209, 278, 259, 306, 260, 222, 223, + 261, 329, 319, 306, 262, 320, 307, 210, 881, 882, + 270, 330, 217, 333, 217, 74, 74, 74, 74, 74, + + 20, 74, 74, 74, 143, 74, 74, 74, 74, 74, + 144, 74, 145, 216, 216, 121, 122, 74, 74, 74, + 147, 74, 74, 883, 884, 293, 321, 293, 293, 337, + 293, 217, 294, 217, 293, 295, 293, 297, 271, 309, + 298, 296, 271, 271, 271, 271, 271, 293, 74, 293, + 74, 298, 271, 293, 371, 293, 362, 271, 322, 217, + 372, 217, 362, 271, 271, 271, 354, 323, 299, 218, + 271, 271, 354, 74, 74, 74, 21, 22, 148, 24, + 21, 149, 150, 27, 28, 29, 30, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 41, 161, 43, + + 162, 163, 164, 165, 166, 167, 168, 155, 155, 155, + 155, 155, 169, 155, 170, 171, 172, 155, 155, 173, + 174, 155, 155, 155, 155, 155, 175, 155, 176, 155, + 177, 178, 179, 166, 180, 181, 155, 155, 155, 155, + 182, 155, 183, 184, 185, 155, 186, 187, 155, 155, + 155, 70, 71, 72, 188, 21, 189, 190, 21, 21, + 191, 476, 21, 21, 21, 21, 21, 21, 194, 21, + 477, 21, 21, 21, 194, 194, 21, 21, 21, 21, + 293, 294, 293, 316, 295, 317, 324, 331, 653, 325, + 271, 332, 326, 290, 654, 305, 318, 271, 271, 334, + + 291, 292, 335, 336, 392, 21, 21, 21, 339, 311, + 885, 340, 310, 365, 362, 366, 362, 393, 341, 410, + 342, 411, 367, 343, 354, 886, 354, 344, 887, 888, + 195, 21, 196, 21, 21, 189, 190, 21, 21, 191, + 889, 21, 21, 21, 21, 21, 21, 194, 21, 890, + 21, 21, 21, 194, 194, 21, 21, 21, 21, 314, + 314, 362, 362, 416, 362, 387, 362, 442, 362, 443, + 388, 354, 354, 368, 354, 370, 354, 283, 354, 283, + 417, 485, 369, 465, 21, 21, 21, 362, 423, 669, + 362, 424, 498, 379, 381, 670, 382, 354, 362, 473, + + 354, 425, 380, 383, 891, 283, 428, 283, 354, 195, + 21, 196, 21, 21, 189, 190, 21, 25, 191, 429, + 21, 21, 21, 21, 468, 21, 194, 21, 386, 21, + 21, 21, 194, 194, 21, 21, 21, 892, 384, 216, + 216, 489, 207, 433, 207, 385, 434, 472, 456, 893, + 456, 293, 435, 293, 506, 894, 507, 217, 895, 217, + 497, 271, 896, 21, 21, 21, 897, 898, 271, 271, + 207, 198, 207, 199, 899, 900, 456, 200, 456, 901, + 902, 903, 904, 905, 906, 217, 907, 217, 201, 21, + 202, 21, 21, 189, 190, 21, 25, 191, 908, 21, + + 21, 21, 21, 909, 21, 194, 21, 910, 21, 21, + 21, 194, 194, 21, 21, 21, 362, 314, 314, 494, + 911, 293, 470, 293, 476, 914, 354, 500, 915, 280, + 280, 271, 495, 477, 916, 283, 362, 283, 459, 271, + 917, 362, 21, 21, 21, 362, 354, 1061, 918, 1061, + 198, 354, 199, 519, 362, 354, 200, 919, 521, 920, + 535, 912, 522, 283, 354, 283, 913, 201, 21, 202, + 21, 208, 208, 315, 921, 1061, 293, 1061, 460, 208, + 208, 208, 208, 208, 208, 282, 271, 293, 922, 293, + 362, 923, 924, 271, 271, 925, 926, 271, 537, 927, + + 354, 928, 929, 931, 271, 271, 932, 930, 208, 208, + 208, 208, 208, 208, 272, 272, 933, 934, 935, 293, + 936, 293, 272, 272, 272, 272, 272, 272, 293, 271, + 293, 283, 466, 283, 538, 937, 271, 271, 271, 938, + 939, 940, 314, 314, 941, 271, 271, 942, 943, 944, + 945, 272, 272, 272, 272, 272, 272, 279, 279, 283, + 283, 283, 283, 481, 946, 280, 281, 280, 281, 280, + 280, 947, 282, 948, 293, 283, 293, 283, 949, 282, + 950, 609, 951, 952, 271, 953, 954, 282, 283, 955, + 283, 271, 271, 956, 280, 281, 280, 281, 280, 280, + + 293, 282, 293, 283, 957, 283, 958, 282, 959, 960, + 271, 961, 962, 284, 286, 286, 603, 271, 271, 963, + 964, 965, 286, 287, 286, 288, 286, 286, 966, 289, + 967, 968, 969, 290, 970, 971, 289, 972, 973, 974, + 291, 292, 975, 976, 289, 977, 978, 979, 980, 981, + 982, 286, 293, 286, 293, 286, 286, 983, 289, 984, + 985, 986, 987, 988, 289, 989, 990, 991, 992, 993, + 289, 313, 313, 994, 995, 996, 997, 998, 999, 313, + 313, 313, 313, 313, 313, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, + + 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 313, 313, + 313, 313, 313, 313, 351, 351, 1023, 1024, 1025, 1026, + 1027, 1028, 351, 351, 351, 351, 351, 351, 1029, 1030, + 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, + 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, + 1051, 351, 351, 351, 351, 351, 351, 355, 355, 1052, + 1053, 1054, 1055, 1056, 1057, 355, 355, 355, 355, 355, + 355, 1058, 1059, 1060, 458, 880, 879, 878, 877, 876, + 875, 874, 873, 872, 871, 870, 869, 868, 867, 866, + 865, 864, 863, 862, 355, 355, 355, 355, 355, 355, + + 360, 360, 861, 860, 859, 858, 857, 856, 360, 361, + 360, 362, 360, 360, 855, 363, 854, 853, 852, 364, + 851, 850, 363, 849, 848, 847, 846, 845, 844, 843, + 363, 842, 841, 840, 839, 838, 837, 360, 362, 360, + 362, 360, 360, 836, 363, 835, 834, 833, 832, 831, + 363, 830, 829, 828, 827, 826, 363, 208, 208, 825, + 824, 823, 822, 821, 820, 208, 208, 208, 208, 208, + 208, 819, 818, 817, 816, 217, 815, 217, 814, 813, + 812, 811, 810, 809, 808, 807, 806, 805, 804, 803, + 802, 801, 800, 799, 208, 208, 208, 208, 208, 208, + + 798, 797, 796, 217, 795, 217, 272, 272, 794, 793, + 792, 791, 790, 789, 272, 272, 272, 272, 272, 272, + 788, 787, 786, 785, 456, 784, 456, 783, 782, 781, + 778, 777, 776, 775, 774, 773, 772, 771, 770, 767, + 766, 765, 764, 272, 272, 272, 272, 272, 272, 763, + 762, 761, 456, 760, 456, 351, 351, 759, 758, 757, + 756, 755, 754, 351, 351, 351, 351, 351, 351, 753, + 752, 751, 750, 517, 749, 517, 748, 747, 746, 745, + 744, 743, 742, 741, 740, 739, 738, 737, 736, 735, + 734, 733, 351, 351, 351, 351, 351, 351, 732, 731, + + 730, 517, 729, 517, 355, 355, 728, 727, 726, 725, + 724, 723, 355, 355, 355, 355, 355, 355, 722, 721, + 720, 719, 518, 718, 518, 717, 716, 715, 714, 713, + 712, 711, 710, 709, 708, 707, 706, 705, 704, 703, + 702, 355, 355, 355, 355, 355, 355, 701, 700, 699, + 518, 698, 518, 768, 768, 697, 768, 768, 768, 696, + 768, 768, 768, 768, 768, 695, 768, 694, 693, 692, + 691, 690, 689, 768, 768, 768, 768, 768, 688, 687, + 686, 685, 684, 683, 682, 681, 680, 679, 678, 677, + 676, 675, 674, 673, 672, 671, 668, 667, 666, 665, + + 664, 663, 662, 661, 660, 659, 658, 657, 656, 655, + 652, 651, 650, 649, 648, 647, 646, 645, 644, 643, + 642, 641, 640, 639, 638, 637, 636, 635, 768, 768, + 768, 779, 779, 634, 779, 779, 779, 633, 779, 779, + 779, 779, 779, 632, 779, 631, 630, 629, 628, 627, + 609, 779, 779, 779, 779, 779, 626, 625, 624, 603, + 623, 622, 621, 620, 619, 618, 617, 616, 615, 614, + 613, 612, 611, 610, 608, 607, 606, 605, 604, 602, + 601, 600, 599, 598, 597, 596, 595, 594, 593, 592, + 591, 590, 589, 588, 587, 586, 585, 584, 583, 582, + + 581, 580, 579, 578, 577, 576, 779, 779, 779, 768, + 768, 575, 768, 768, 768, 574, 768, 768, 768, 768, + 768, 573, 768, 572, 571, 570, 569, 568, 567, 768, + 768, 768, 768, 768, 566, 565, 564, 563, 562, 561, + 560, 559, 558, 557, 556, 555, 554, 553, 552, 551, + 395, 550, 549, 548, 547, 546, 545, 544, 543, 542, + 541, 540, 539, 536, 534, 533, 532, 531, 530, 529, + 528, 527, 526, 525, 524, 523, 520, 353, 516, 515, + 481, 514, 513, 512, 768, 768, 768, 779, 779, 511, + 779, 779, 779, 510, 779, 779, 779, 779, 779, 509, + + 779, 508, 505, 504, 503, 502, 501, 779, 779, 779, + 779, 779, 499, 496, 493, 492, 491, 490, 488, 487, + 486, 484, 483, 459, 482, 480, 479, 478, 475, 474, + 473, 472, 471, 470, 469, 468, 467, 465, 464, 463, + 462, 461, 282, 455, 454, 453, 452, 451, 450, 449, + 448, 447, 446, 445, 444, 441, 440, 439, 438, 437, + 436, 432, 779, 779, 779, 20, 20, 20, 20, 20, + 20, 20, 20, 20, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 193, 193, 193, 193, 193, 193, 193, 193, + + 193, 197, 197, 197, 197, 197, 197, 197, 197, 197, + 205, 205, 205, 205, 205, 205, 205, 205, 205, 207, + 207, 207, 207, 207, 207, 207, 271, 431, 271, 271, + 271, 271, 271, 350, 430, 427, 426, 350, 350, 350, + 352, 352, 352, 352, 352, 352, 352, 352, 352, 354, + 422, 354, 421, 354, 354, 354, 356, 420, 356, 356, + 356, 356, 356, 356, 356, 359, 419, 359, 359, 359, + 359, 359, 359, 359, 396, 418, 396, 396, 396, 396, + 396, 396, 396, 397, 415, 397, 398, 398, 414, 413, + 398, 412, 398, 457, 409, 457, 457, 457, 457, 457, + + 769, 408, 769, 769, 769, 769, 769, 769, 769, 780, + 407, 780, 780, 780, 780, 780, 780, 780, 768, 406, + 768, 768, 768, 768, 768, 768, 768, 779, 405, 779, + 779, 779, 779, 779, 779, 779, 404, 403, 402, 206, + 203, 401, 400, 399, 395, 394, 391, 390, 389, 378, + 375, 374, 373, 285, 282, 358, 275, 274, 357, 353, + 349, 348, 347, 346, 345, 338, 328, 327, 312, 310, + 309, 308, 303, 302, 301, 300, 285, 282, 274, 273, + 206, 204, 203, 268, 267, 266, 265, 264, 263, 255, + 243, 242, 241, 240, 221, 213, 212, 211, 206, 204, + + 203, 1061, 19, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061 + } ; + +static yyconst short int yy_chk[1983] = + { 0, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 7, 28, + 56, 13, 13, 36, 56, 13, 41, 41, 173, 7, + 7, 14, 14, 28, 36, 14, 86, 7, 7, 7, + 7, 7, 7, 173, 7, 7, 43, 43, 7, 7, + 7, 7, 7, 7, 49, 7, 7, 46, 7, 47, + + 46, 48, 47, 49, 55, 107, 7, 7, 7, 7, + 7, 7, 46, 107, 55, 48, 7, 71, 86, 7, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 13, 117, 9, 9, 9, + 9, 9, 9, 9, 9, 14, 38, 38, 57, 45, + 50, 45, 59, 50, 93, 93, 50, 58, 57, 45, + 58, 58, 59, 88, 38, 61, 38, 45, 61, 61, + 9, 71, 9, 80, 88, 61, 108, 61, 95, 95, + 61, 131, 125, 133, 61, 125, 108, 80, 819, 820, + 117, 131, 38, 133, 38, 9, 9, 9, 10, 10, + + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 37, 37, 10, 10, 10, 10, 10, + 10, 10, 10, 822, 823, 98, 126, 98, 99, 135, + 99, 37, 98, 37, 100, 98, 100, 100, 99, 135, + 126, 99, 98, 98, 100, 99, 99, 101, 10, 101, + 10, 100, 100, 102, 169, 102, 166, 101, 127, 37, + 169, 37, 360, 102, 101, 101, 166, 127, 101, 37, + 102, 102, 360, 10, 10, 10, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 15, 15, 15, 15, 15, + 15, 307, 15, 15, 15, 15, 15, 15, 15, 15, + 307, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 114, 124, 114, 123, 124, 123, 128, 132, 520, 128, + 114, 132, 128, 123, 520, 132, 124, 114, 114, 134, + + 123, 123, 134, 134, 186, 15, 15, 15, 137, 114, + 824, 137, 137, 164, 164, 165, 165, 186, 137, 231, + 137, 231, 165, 137, 164, 825, 165, 137, 826, 827, + 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, + 828, 16, 16, 16, 16, 16, 16, 16, 16, 830, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 122, + 122, 167, 168, 236, 177, 182, 178, 256, 179, 256, + 182, 167, 168, 167, 177, 168, 178, 122, 179, 122, + 236, 319, 167, 319, 16, 16, 16, 181, 242, 536, + 362, 242, 331, 177, 178, 536, 179, 181, 180, 331, + + 362, 242, 177, 179, 831, 122, 245, 122, 180, 16, + 16, 16, 16, 17, 17, 17, 17, 17, 17, 245, + 17, 17, 17, 17, 323, 17, 17, 17, 181, 17, + 17, 17, 17, 17, 17, 17, 17, 834, 180, 216, + 216, 323, 218, 249, 218, 180, 249, 330, 313, 836, + 313, 286, 249, 286, 339, 837, 339, 216, 838, 216, + 330, 286, 839, 17, 17, 17, 840, 843, 286, 286, + 218, 17, 218, 17, 844, 845, 313, 17, 313, 849, + 850, 851, 855, 858, 859, 216, 860, 216, 17, 17, + 17, 17, 18, 18, 18, 18, 18, 18, 862, 18, + + 18, 18, 18, 863, 18, 18, 18, 865, 18, 18, + 18, 18, 18, 18, 18, 18, 379, 121, 121, 328, + 866, 287, 328, 287, 333, 871, 379, 333, 872, 280, + 280, 287, 328, 333, 873, 121, 361, 121, 287, 287, + 876, 365, 18, 18, 18, 366, 361, 280, 877, 280, + 18, 365, 18, 361, 381, 366, 18, 878, 365, 880, + 379, 868, 366, 121, 381, 121, 868, 18, 18, 18, + 18, 26, 26, 121, 881, 280, 288, 280, 288, 26, + 26, 26, 26, 26, 26, 280, 288, 293, 882, 293, + 382, 885, 886, 288, 288, 887, 888, 293, 381, 889, + + 382, 890, 893, 895, 293, 293, 896, 893, 26, 26, + 26, 26, 26, 26, 78, 78, 899, 900, 901, 311, + 902, 311, 78, 78, 78, 78, 78, 78, 297, 311, + 297, 458, 297, 458, 382, 903, 311, 311, 297, 904, + 906, 907, 314, 314, 908, 297, 297, 909, 911, 912, + 913, 78, 78, 78, 78, 78, 78, 89, 89, 458, + 314, 458, 314, 311, 914, 89, 89, 89, 89, 89, + 89, 916, 89, 918, 466, 89, 466, 89, 920, 89, + 922, 466, 923, 925, 466, 926, 927, 89, 314, 928, + 314, 466, 466, 929, 89, 89, 89, 89, 89, 89, + + 460, 89, 460, 89, 930, 89, 931, 89, 939, 940, + 460, 941, 942, 89, 97, 97, 460, 460, 460, 943, + 944, 945, 97, 97, 97, 97, 97, 97, 946, 97, + 947, 948, 949, 97, 950, 951, 97, 952, 953, 954, + 97, 97, 955, 956, 97, 957, 958, 959, 960, 961, + 962, 97, 97, 97, 97, 97, 97, 963, 97, 964, + 965, 967, 968, 969, 97, 970, 971, 972, 973, 974, + 97, 120, 120, 975, 976, 977, 979, 980, 981, 120, + 120, 120, 120, 120, 120, 982, 985, 986, 987, 988, + 990, 991, 992, 993, 994, 996, 998, 1000, 1001, 1002, + + 1003, 1005, 1006, 1008, 1009, 1010, 1011, 1012, 120, 120, + 120, 120, 120, 120, 143, 143, 1014, 1015, 1016, 1017, + 1018, 1019, 143, 143, 143, 143, 143, 143, 1021, 1022, + 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, + 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, + 1047, 143, 143, 143, 143, 143, 143, 150, 150, 1048, + 1049, 1050, 1051, 1052, 1054, 150, 150, 150, 150, 150, + 150, 1056, 1057, 1058, 1079, 818, 817, 815, 814, 813, + 812, 809, 808, 807, 806, 805, 804, 803, 800, 799, + 797, 795, 794, 792, 150, 150, 150, 150, 150, 150, + + 163, 163, 791, 790, 789, 788, 786, 785, 163, 163, + 163, 163, 163, 163, 784, 163, 782, 778, 777, 163, + 776, 774, 163, 773, 771, 767, 766, 765, 763, 762, + 163, 761, 760, 759, 756, 755, 753, 163, 163, 163, + 163, 163, 163, 752, 163, 751, 750, 749, 748, 746, + 163, 745, 743, 741, 740, 739, 163, 208, 208, 738, + 737, 736, 735, 734, 733, 208, 208, 208, 208, 208, + 208, 732, 730, 728, 726, 208, 724, 208, 723, 722, + 721, 720, 719, 718, 716, 714, 713, 712, 710, 709, + 708, 707, 706, 705, 208, 208, 208, 208, 208, 208, + + 704, 703, 702, 208, 700, 208, 272, 272, 698, 696, + 695, 692, 691, 690, 272, 272, 272, 272, 272, 272, + 687, 686, 685, 684, 272, 683, 272, 682, 680, 679, + 675, 674, 670, 669, 668, 667, 666, 664, 663, 659, + 658, 654, 653, 272, 272, 272, 272, 272, 272, 652, + 651, 650, 272, 649, 272, 351, 351, 648, 647, 645, + 644, 643, 641, 351, 351, 351, 351, 351, 351, 640, + 639, 638, 637, 351, 636, 351, 634, 633, 632, 631, + 630, 628, 627, 626, 625, 623, 622, 621, 620, 619, + 618, 617, 351, 351, 351, 351, 351, 351, 615, 612, + + 611, 351, 610, 351, 355, 355, 609, 607, 605, 604, + 602, 601, 355, 355, 355, 355, 355, 355, 600, 599, + 598, 597, 355, 596, 355, 595, 593, 592, 591, 590, + 588, 587, 586, 585, 584, 583, 582, 581, 579, 577, + 576, 355, 355, 355, 355, 355, 355, 574, 572, 571, + 355, 570, 355, 660, 660, 569, 660, 660, 660, 567, + 660, 660, 660, 660, 660, 566, 660, 565, 564, 563, + 562, 560, 558, 660, 660, 660, 660, 660, 556, 554, + 553, 552, 551, 550, 549, 548, 547, 546, 545, 544, + 543, 542, 541, 539, 538, 537, 535, 534, 533, 532, + + 531, 530, 529, 528, 527, 526, 525, 523, 522, 521, + 519, 514, 513, 512, 511, 510, 509, 508, 507, 506, + 505, 504, 503, 502, 501, 500, 499, 497, 660, 660, + 660, 676, 676, 496, 676, 676, 676, 495, 676, 676, + 676, 676, 676, 494, 676, 492, 491, 490, 489, 488, + 487, 676, 676, 676, 676, 676, 486, 485, 484, 483, + 482, 481, 480, 479, 478, 477, 476, 475, 472, 471, + 470, 469, 468, 467, 465, 464, 463, 462, 461, 459, + 455, 452, 451, 450, 449, 448, 447, 446, 445, 444, + 443, 442, 441, 440, 439, 438, 437, 436, 435, 434, + + 433, 432, 431, 429, 428, 427, 676, 676, 676, 769, + 769, 426, 769, 769, 769, 425, 769, 769, 769, 769, + 769, 424, 769, 423, 421, 420, 419, 418, 417, 769, + 769, 769, 769, 769, 416, 415, 414, 413, 412, 411, + 410, 409, 408, 407, 406, 405, 404, 401, 400, 399, + 395, 394, 393, 392, 391, 390, 389, 388, 387, 386, + 385, 384, 383, 380, 378, 377, 376, 375, 374, 373, + 372, 371, 370, 369, 368, 367, 364, 352, 349, 348, + 347, 346, 345, 344, 769, 769, 769, 780, 780, 343, + 780, 780, 780, 342, 780, 780, 780, 780, 780, 341, + + 780, 340, 338, 337, 336, 335, 334, 780, 780, 780, + 780, 780, 332, 329, 327, 326, 325, 324, 322, 321, + 320, 318, 317, 316, 312, 310, 309, 308, 306, 305, + 304, 303, 302, 301, 300, 299, 298, 296, 295, 294, + 291, 290, 279, 268, 267, 266, 265, 264, 263, 262, + 261, 260, 259, 258, 257, 255, 254, 253, 252, 251, + 250, 248, 780, 780, 780, 1062, 1062, 1062, 1062, 1062, + 1062, 1062, 1062, 1062, 1063, 1063, 1063, 1063, 1063, 1063, + 1063, 1063, 1063, 1064, 1064, 1064, 1064, 1064, 1064, 1064, + 1064, 1064, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065, + + 1065, 1066, 1066, 1066, 1066, 1066, 1066, 1066, 1066, 1066, + 1067, 1067, 1067, 1067, 1067, 1067, 1067, 1067, 1067, 1068, + 1068, 1068, 1068, 1068, 1068, 1068, 1069, 247, 1069, 1069, + 1069, 1069, 1069, 1070, 246, 244, 243, 1070, 1070, 1070, + 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1072, + 241, 1072, 240, 1072, 1072, 1072, 1073, 239, 1073, 1073, + 1073, 1073, 1073, 1073, 1073, 1074, 238, 1074, 1074, 1074, + 1074, 1074, 1074, 1074, 1075, 237, 1075, 1075, 1075, 1075, + 1075, 1075, 1075, 1076, 235, 1076, 1077, 1077, 234, 233, + 1077, 232, 1077, 1078, 230, 1078, 1078, 1078, 1078, 1078, + + 1080, 229, 1080, 1080, 1080, 1080, 1080, 1080, 1080, 1081, + 228, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1082, 226, + 1082, 1082, 1082, 1082, 1082, 1082, 1082, 1083, 225, 1083, + 1083, 1083, 1083, 1083, 1083, 1083, 224, 223, 219, 205, + 203, 200, 199, 198, 189, 187, 185, 184, 183, 174, + 172, 171, 170, 161, 158, 156, 154, 152, 151, 149, + 142, 141, 140, 139, 138, 136, 130, 129, 115, 111, + 110, 109, 106, 105, 104, 103, 94, 90, 84, 83, + 77, 76, 75, 69, 68, 67, 66, 63, 62, 60, + 54, 53, 52, 51, 42, 34, 32, 31, 25, 24, + + 22, 19, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "ldlex.l" +#define INITIAL 0 +#line 2 "ldlex.l" + +/* Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999 + Free Software Foundation, Inc. + +This file is part of GLD, the Gnu Linker. + +GLD 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 2, or (at your option) +any later version. + +GLD 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 GLD; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ + +/* +This was written by steve chamberlain + sac@cygnus.com +*/ + + +#include <ansidecl.h> +#include <stdio.h> +#include <ctype.h> + +#ifdef MPW +/* Prevent enum redefinition problems. */ +#define TRUE_FALSE_ALREADY_DEFINED +#endif /* MPW */ + +#include "bfd.h" +#include "sysdep.h" +#include "ld.h" +#include "ldgram.h" +#include "ldmisc.h" +#include "ldexp.h" +#include "ldlang.h" +#include "ldfile.h" +#include "ldlex.h" +#include "ldmain.h" + +/* The type of top-level parser input. + yylex and yyparse (indirectly) both check this. */ +input_type parser_input; + +/* Line number in the current input file. + (FIXME Actually, it doesn't appear to get reset for each file?) */ +unsigned int lineno = 1; + +/* The string we are currently lexing, or NULL if we are reading a + file. */ +const char *lex_string = NULL; + +/* Support for flex reading from more than one input file (stream). + `include_stack' is flex's input state for each open file; + `file_name_stack' is the file names. `lineno_stack' is the current + line numbers. + + If `include_stack_ptr' is 0, we haven't started reading anything yet. + Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */ + +#undef YY_INPUT +#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size) + +#define MAX_INCLUDE_DEPTH 10 +static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH]; +static const char *file_name_stack[MAX_INCLUDE_DEPTH]; +static unsigned int lineno_stack[MAX_INCLUDE_DEPTH]; +static unsigned int include_stack_ptr = 0; +static int vers_node_nesting = 0; + +static YY_BUFFER_STATE yy_create_string_buffer PARAMS ((const char *string, + size_t size)); +static void yy_input PARAMS ((char *, int *result, int max_size)); + +static void comment PARAMS ((void)); +static void lex_warn_invalid PARAMS ((char *where, char *what)); + +/* STATES + EXPRESSION definitely in an expression + SCRIPT definitely in a script + BOTH either EXPRESSION or SCRIPT + DEFSYMEXP in an argument to -defsym + MRI in an MRI script + VERS_START starting a Sun style mapfile + VERS_SCRIPT a Sun style mapfile + VERS_NODE a node within a Sun style mapfile +*/ +#define RTOKEN(x) { yylval.token = x; return x; } + +/* Some versions of flex want this. */ +#ifndef yywrap +int yywrap () { return 1; } +#endif +#define SCRIPT 1 + +#define EXPRESSION 2 + +#define BOTH 3 + +#define DEFSYMEXP 4 + +#define MRI 5 + +#define VERS_START 6 + +#define VERS_SCRIPT 7 + +#define VERS_NODE 8 + +#line 1273 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 128 "ldlex.l" + + + if (parser_input != input_selected) + { + /* The first token of the input determines the initial parser state. */ + input_type t = parser_input; + parser_input = input_selected; + switch (t) + { + case input_script: return INPUT_SCRIPT; break; + case input_mri_script: return INPUT_MRI_SCRIPT; break; + case input_version_script: return INPUT_VERSION_SCRIPT; break; + case input_defsym: return INPUT_DEFSYM; break; + default: abort (); + } + } + +#line 1442 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1062 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 1903 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 145 "ldlex.l" +{ comment(); } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 148 "ldlex.l" +{ RTOKEN('-');} + YY_BREAK +case 3: +YY_RULE_SETUP +#line 149 "ldlex.l" +{ RTOKEN('+');} + YY_BREAK +case 4: +YY_RULE_SETUP +#line 150 "ldlex.l" +{ yylval.name = buystring(yytext); return NAME; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 151 "ldlex.l" +{ RTOKEN('='); } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 153 "ldlex.l" +{ + yylval.integer = bfd_scan_vma (yytext+1, 0,16); + return INT; + } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 158 "ldlex.l" +{ + int ibase ; + switch (yytext[yyleng-1]) { + case 'X': + case 'x': + case 'H': + case 'h': + ibase = 16; + break; + case 'O': + case 'o': + ibase = 8; + break; + case 'B': + case 'b': + ibase = 2; + break; + default: + ibase = 10; + } + yylval.integer = bfd_scan_vma (yytext, 0, + ibase); + return INT; + } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 182 "ldlex.l" +{ + char *s = yytext; + + if (*s == '$') + ++s; + yylval.integer = bfd_scan_vma (s, 0, 0); + if (yytext[yyleng-1] == 'M' + || yytext[yyleng-1] == 'm') + yylval.integer *= 1024 * 1024; + if (yytext[yyleng-1] == 'K' + || yytext[yyleng-1]=='k') + yylval.integer *= 1024; + return INT; + } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 196 "ldlex.l" +{ RTOKEN(']');} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 197 "ldlex.l" +{ RTOKEN('[');} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 198 "ldlex.l" +{ RTOKEN(LSHIFTEQ);} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 199 "ldlex.l" +{ RTOKEN(RSHIFTEQ);} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 200 "ldlex.l" +{ RTOKEN(OROR);} + YY_BREAK +case 14: +YY_RULE_SETUP +#line 201 "ldlex.l" +{ RTOKEN(EQ);} + YY_BREAK +case 15: +YY_RULE_SETUP +#line 202 "ldlex.l" +{ RTOKEN(NE);} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 203 "ldlex.l" +{ RTOKEN(GE);} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 204 "ldlex.l" +{ RTOKEN(LE);} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 205 "ldlex.l" +{ RTOKEN(LSHIFT);} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 206 "ldlex.l" +{ RTOKEN(RSHIFT);} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 207 "ldlex.l" +{ RTOKEN(PLUSEQ);} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 208 "ldlex.l" +{ RTOKEN(MINUSEQ);} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 209 "ldlex.l" +{ RTOKEN(MULTEQ);} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 210 "ldlex.l" +{ RTOKEN(DIVEQ);} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 211 "ldlex.l" +{ RTOKEN(ANDEQ);} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 212 "ldlex.l" +{ RTOKEN(OREQ);} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 213 "ldlex.l" +{ RTOKEN(ANDAND);} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 214 "ldlex.l" +{ RTOKEN('>');} + YY_BREAK +case 28: +YY_RULE_SETUP +#line 215 "ldlex.l" +{ RTOKEN(',');} + YY_BREAK +case 29: +YY_RULE_SETUP +#line 216 "ldlex.l" +{ RTOKEN('&');} + YY_BREAK +case 30: +YY_RULE_SETUP +#line 217 "ldlex.l" +{ RTOKEN('|');} + YY_BREAK +case 31: +YY_RULE_SETUP +#line 218 "ldlex.l" +{ RTOKEN('~');} + YY_BREAK +case 32: +YY_RULE_SETUP +#line 219 "ldlex.l" +{ RTOKEN('!');} + YY_BREAK +case 33: +YY_RULE_SETUP +#line 220 "ldlex.l" +{ RTOKEN('?');} + YY_BREAK +case 34: +YY_RULE_SETUP +#line 221 "ldlex.l" +{ RTOKEN('*');} + YY_BREAK +case 35: +YY_RULE_SETUP +#line 222 "ldlex.l" +{ RTOKEN('+');} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 223 "ldlex.l" +{ RTOKEN('-');} + YY_BREAK +case 37: +YY_RULE_SETUP +#line 224 "ldlex.l" +{ RTOKEN('/');} + YY_BREAK +case 38: +YY_RULE_SETUP +#line 225 "ldlex.l" +{ RTOKEN('%');} + YY_BREAK +case 39: +YY_RULE_SETUP +#line 226 "ldlex.l" +{ RTOKEN('<');} + YY_BREAK +case 40: +YY_RULE_SETUP +#line 227 "ldlex.l" +{ RTOKEN('=');} + YY_BREAK +case 41: +YY_RULE_SETUP +#line 228 "ldlex.l" +{ RTOKEN('}') ; } + YY_BREAK +case 42: +YY_RULE_SETUP +#line 229 "ldlex.l" +{ RTOKEN('{'); } + YY_BREAK +case 43: +YY_RULE_SETUP +#line 230 "ldlex.l" +{ RTOKEN(')');} + YY_BREAK +case 44: +YY_RULE_SETUP +#line 231 "ldlex.l" +{ RTOKEN('(');} + YY_BREAK +case 45: +YY_RULE_SETUP +#line 232 "ldlex.l" +{ RTOKEN(':'); } + YY_BREAK +case 46: +YY_RULE_SETUP +#line 233 "ldlex.l" +{ RTOKEN(';');} + YY_BREAK +case 47: +YY_RULE_SETUP +#line 234 "ldlex.l" +{ RTOKEN(MEMORY);} + YY_BREAK +case 48: +YY_RULE_SETUP +#line 235 "ldlex.l" +{ RTOKEN(ORIGIN);} + YY_BREAK +case 49: +YY_RULE_SETUP +#line 236 "ldlex.l" +{ RTOKEN(VERSIONK);} + YY_BREAK +case 50: +YY_RULE_SETUP +#line 237 "ldlex.l" +{ RTOKEN(BLOCK);} + YY_BREAK +case 51: +YY_RULE_SETUP +#line 238 "ldlex.l" +{ RTOKEN(BIND);} + YY_BREAK +case 52: +YY_RULE_SETUP +#line 239 "ldlex.l" +{ RTOKEN(LENGTH);} + YY_BREAK +case 53: +YY_RULE_SETUP +#line 240 "ldlex.l" +{ RTOKEN(ALIGN_K);} + YY_BREAK +case 54: +YY_RULE_SETUP +#line 241 "ldlex.l" +{ RTOKEN(ADDR);} + YY_BREAK +case 55: +YY_RULE_SETUP +#line 242 "ldlex.l" +{ RTOKEN(LOADADDR);} + YY_BREAK +case 56: +YY_RULE_SETUP +#line 243 "ldlex.l" +{ RTOKEN(MAX_K); } + YY_BREAK +case 57: +YY_RULE_SETUP +#line 244 "ldlex.l" +{ RTOKEN(MIN_K); } + YY_BREAK +case 58: +YY_RULE_SETUP +#line 245 "ldlex.l" +{ RTOKEN(ASSERT_K); } + YY_BREAK +case 59: +YY_RULE_SETUP +#line 246 "ldlex.l" +{ RTOKEN(ENTRY);} + YY_BREAK +case 60: +YY_RULE_SETUP +#line 247 "ldlex.l" +{ RTOKEN(EXTERN);} + YY_BREAK +case 61: +YY_RULE_SETUP +#line 248 "ldlex.l" +{ RTOKEN(NEXT);} + YY_BREAK +case 62: +YY_RULE_SETUP +#line 249 "ldlex.l" +{ RTOKEN(SIZEOF_HEADERS);} + YY_BREAK +case 63: +YY_RULE_SETUP +#line 250 "ldlex.l" +{ RTOKEN(SIZEOF_HEADERS);} + YY_BREAK +case 64: +YY_RULE_SETUP +#line 251 "ldlex.l" +{ RTOKEN(MAP);} + YY_BREAK +case 65: +YY_RULE_SETUP +#line 252 "ldlex.l" +{ RTOKEN(SIZEOF);} + YY_BREAK +case 66: +YY_RULE_SETUP +#line 253 "ldlex.l" +{ RTOKEN(TARGET_K);} + YY_BREAK +case 67: +YY_RULE_SETUP +#line 254 "ldlex.l" +{ RTOKEN(SEARCH_DIR);} + YY_BREAK +case 68: +YY_RULE_SETUP +#line 255 "ldlex.l" +{ RTOKEN(OUTPUT);} + YY_BREAK +case 69: +YY_RULE_SETUP +#line 256 "ldlex.l" +{ RTOKEN(INPUT);} + YY_BREAK +case 70: +YY_RULE_SETUP +#line 257 "ldlex.l" +{ RTOKEN(GROUP);} + YY_BREAK +case 71: +YY_RULE_SETUP +#line 258 "ldlex.l" +{ RTOKEN(DEFINED);} + YY_BREAK +case 72: +YY_RULE_SETUP +#line 259 "ldlex.l" +{ RTOKEN(CREATE_OBJECT_SYMBOLS);} + YY_BREAK +case 73: +YY_RULE_SETUP +#line 260 "ldlex.l" +{ RTOKEN( CONSTRUCTORS);} + YY_BREAK +case 74: +YY_RULE_SETUP +#line 261 "ldlex.l" +{ RTOKEN(FORCE_COMMON_ALLOCATION);} + YY_BREAK +case 75: +YY_RULE_SETUP +#line 262 "ldlex.l" +{ RTOKEN(SECTIONS);} + YY_BREAK +case 76: +YY_RULE_SETUP +#line 263 "ldlex.l" +{ RTOKEN(FILL);} + YY_BREAK +case 77: +YY_RULE_SETUP +#line 264 "ldlex.l" +{ RTOKEN(STARTUP);} + YY_BREAK +case 78: +YY_RULE_SETUP +#line 265 "ldlex.l" +{ RTOKEN(OUTPUT_FORMAT);} + YY_BREAK +case 79: +YY_RULE_SETUP +#line 266 "ldlex.l" +{ RTOKEN( OUTPUT_ARCH);} + YY_BREAK +case 80: +YY_RULE_SETUP +#line 267 "ldlex.l" +{ RTOKEN(HLL);} + YY_BREAK +case 81: +YY_RULE_SETUP +#line 268 "ldlex.l" +{ RTOKEN(SYSLIB);} + YY_BREAK +case 82: +YY_RULE_SETUP +#line 269 "ldlex.l" +{ RTOKEN(FLOAT);} + YY_BREAK +case 83: +YY_RULE_SETUP +#line 270 "ldlex.l" +{ RTOKEN( QUAD);} + YY_BREAK +case 84: +YY_RULE_SETUP +#line 271 "ldlex.l" +{ RTOKEN( SQUAD);} + YY_BREAK +case 85: +YY_RULE_SETUP +#line 272 "ldlex.l" +{ RTOKEN( LONG);} + YY_BREAK +case 86: +YY_RULE_SETUP +#line 273 "ldlex.l" +{ RTOKEN( SHORT);} + YY_BREAK +case 87: +YY_RULE_SETUP +#line 274 "ldlex.l" +{ RTOKEN( BYTE);} + YY_BREAK +case 88: +YY_RULE_SETUP +#line 275 "ldlex.l" +{ RTOKEN(NOFLOAT);} + YY_BREAK +case 89: +YY_RULE_SETUP +#line 276 "ldlex.l" +{ RTOKEN(NOCROSSREFS);} + YY_BREAK +case 90: +YY_RULE_SETUP +#line 277 "ldlex.l" +{ RTOKEN(OVERLAY); } + YY_BREAK +case 91: +YY_RULE_SETUP +#line 278 "ldlex.l" +{ RTOKEN(SORT); } + YY_BREAK +case 92: +YY_RULE_SETUP +#line 279 "ldlex.l" +{ RTOKEN(NOLOAD);} + YY_BREAK +case 93: +YY_RULE_SETUP +#line 280 "ldlex.l" +{ RTOKEN(DSECT);} + YY_BREAK +case 94: +YY_RULE_SETUP +#line 281 "ldlex.l" +{ RTOKEN(COPY);} + YY_BREAK +case 95: +YY_RULE_SETUP +#line 282 "ldlex.l" +{ RTOKEN(INFO);} + YY_BREAK +case 96: +YY_RULE_SETUP +#line 283 "ldlex.l" +{ RTOKEN(OVERLAY);} + YY_BREAK +case 97: +YY_RULE_SETUP +#line 284 "ldlex.l" +{ RTOKEN(ORIGIN);} + YY_BREAK +case 98: +YY_RULE_SETUP +#line 285 "ldlex.l" +{ RTOKEN(ORIGIN);} + YY_BREAK +case 99: +YY_RULE_SETUP +#line 286 "ldlex.l" +{ RTOKEN( LENGTH);} + YY_BREAK +case 100: +YY_RULE_SETUP +#line 287 "ldlex.l" +{ RTOKEN( LENGTH);} + YY_BREAK +case 101: +YY_RULE_SETUP +#line 288 "ldlex.l" +{ RTOKEN(INCLUDE);} + YY_BREAK +case 102: +YY_RULE_SETUP +#line 289 "ldlex.l" +{ RTOKEN (PHDRS); } + YY_BREAK +case 103: +YY_RULE_SETUP +#line 290 "ldlex.l" +{ RTOKEN(AT);} + YY_BREAK +case 104: +YY_RULE_SETUP +#line 291 "ldlex.l" +{ RTOKEN(PROVIDE); } + YY_BREAK +case 105: +YY_RULE_SETUP +#line 292 "ldlex.l" +{ RTOKEN(KEEP); } + YY_BREAK +case 106: +YY_RULE_SETUP +#line 293 "ldlex.l" +{ RTOKEN(EXCLUDE_FILE); } + YY_BREAK +case 107: +YY_RULE_SETUP +#line 294 "ldlex.l" +{ ++ lineno; } + YY_BREAK +case 108: +YY_RULE_SETUP +#line 295 "ldlex.l" +{ ++ lineno; RTOKEN(NEWLINE); } + YY_BREAK +case 109: +YY_RULE_SETUP +#line 296 "ldlex.l" +{ /* Mri comment line */ } + YY_BREAK +case 110: +YY_RULE_SETUP +#line 297 "ldlex.l" +{ /* Mri comment line */ } + YY_BREAK +case 111: +YY_RULE_SETUP +#line 298 "ldlex.l" +{ RTOKEN(ENDWORD); } + YY_BREAK +case 112: +YY_RULE_SETUP +#line 299 "ldlex.l" +{ RTOKEN(ALIGNMOD);} + YY_BREAK +case 113: +YY_RULE_SETUP +#line 300 "ldlex.l" +{ RTOKEN(ALIGN_K);} + YY_BREAK +case 114: +YY_RULE_SETUP +#line 301 "ldlex.l" +{ RTOKEN(CHIP); } + YY_BREAK +case 115: +YY_RULE_SETUP +#line 302 "ldlex.l" +{ RTOKEN(BASE); } + YY_BREAK +case 116: +YY_RULE_SETUP +#line 303 "ldlex.l" +{ RTOKEN(ALIAS); } + YY_BREAK +case 117: +YY_RULE_SETUP +#line 304 "ldlex.l" +{ RTOKEN(TRUNCATE); } + YY_BREAK +case 118: +YY_RULE_SETUP +#line 305 "ldlex.l" +{ RTOKEN(LOAD); } + YY_BREAK +case 119: +YY_RULE_SETUP +#line 306 "ldlex.l" +{ RTOKEN(PUBLIC); } + YY_BREAK +case 120: +YY_RULE_SETUP +#line 307 "ldlex.l" +{ RTOKEN(ORDER); } + YY_BREAK +case 121: +YY_RULE_SETUP +#line 308 "ldlex.l" +{ RTOKEN(NAMEWORD); } + YY_BREAK +case 122: +YY_RULE_SETUP +#line 309 "ldlex.l" +{ RTOKEN(FORMAT); } + YY_BREAK +case 123: +YY_RULE_SETUP +#line 310 "ldlex.l" +{ RTOKEN(CASE); } + YY_BREAK +case 124: +YY_RULE_SETUP +#line 311 "ldlex.l" +{ RTOKEN(START); } + YY_BREAK +case 125: +YY_RULE_SETUP +#line 312 "ldlex.l" +{ RTOKEN(LIST); /* LIST and ignore to end of line */ } + YY_BREAK +case 126: +YY_RULE_SETUP +#line 313 "ldlex.l" +{ RTOKEN(SECT); } + YY_BREAK +case 127: +YY_RULE_SETUP +#line 314 "ldlex.l" +{ RTOKEN(ABSOLUTE); } + YY_BREAK +case 128: +YY_RULE_SETUP +#line 315 "ldlex.l" +{ RTOKEN(ENDWORD); } + YY_BREAK +case 129: +YY_RULE_SETUP +#line 316 "ldlex.l" +{ RTOKEN(ALIGNMOD);} + YY_BREAK +case 130: +YY_RULE_SETUP +#line 317 "ldlex.l" +{ RTOKEN(ALIGN_K);} + YY_BREAK +case 131: +YY_RULE_SETUP +#line 318 "ldlex.l" +{ RTOKEN(CHIP); } + YY_BREAK +case 132: +YY_RULE_SETUP +#line 319 "ldlex.l" +{ RTOKEN(BASE); } + YY_BREAK +case 133: +YY_RULE_SETUP +#line 320 "ldlex.l" +{ RTOKEN(ALIAS); } + YY_BREAK +case 134: +YY_RULE_SETUP +#line 321 "ldlex.l" +{ RTOKEN(TRUNCATE); } + YY_BREAK +case 135: +YY_RULE_SETUP +#line 322 "ldlex.l" +{ RTOKEN(LOAD); } + YY_BREAK +case 136: +YY_RULE_SETUP +#line 323 "ldlex.l" +{ RTOKEN(PUBLIC); } + YY_BREAK +case 137: +YY_RULE_SETUP +#line 324 "ldlex.l" +{ RTOKEN(ORDER); } + YY_BREAK +case 138: +YY_RULE_SETUP +#line 325 "ldlex.l" +{ RTOKEN(NAMEWORD); } + YY_BREAK +case 139: +YY_RULE_SETUP +#line 326 "ldlex.l" +{ RTOKEN(FORMAT); } + YY_BREAK +case 140: +YY_RULE_SETUP +#line 327 "ldlex.l" +{ RTOKEN(CASE); } + YY_BREAK +case 141: +YY_RULE_SETUP +#line 328 "ldlex.l" +{ RTOKEN(EXTERN); } + YY_BREAK +case 142: +YY_RULE_SETUP +#line 329 "ldlex.l" +{ RTOKEN(START); } + YY_BREAK +case 143: +YY_RULE_SETUP +#line 330 "ldlex.l" +{ RTOKEN(LIST); /* LIST and ignore to end of line */ } + YY_BREAK +case 144: +YY_RULE_SETUP +#line 331 "ldlex.l" +{ RTOKEN(SECT); } + YY_BREAK +case 145: +YY_RULE_SETUP +#line 332 "ldlex.l" +{ RTOKEN(ABSOLUTE); } + YY_BREAK +case 146: +YY_RULE_SETUP +#line 334 "ldlex.l" +{ +/* Filename without commas, needed to parse mri stuff */ + yylval.name = buystring(yytext); + return NAME; + } + YY_BREAK +case 147: +YY_RULE_SETUP +#line 341 "ldlex.l" +{ + yylval.name = buystring(yytext); + return NAME; + } + YY_BREAK +case 148: +YY_RULE_SETUP +#line 345 "ldlex.l" +{ + yylval.name = buystring (yytext + 2); + return LNAME; + } + YY_BREAK +case 149: +YY_RULE_SETUP +#line 349 "ldlex.l" +{ + /* Annoyingly, this pattern can match comments, and we have + longest match issues to consider. So if the first two + characters are a comment opening, put the input back and + try again. */ + if (yytext[0] == '/' && yytext[1] == '*') + { + yyless(2); + comment (); + } + else + { + yylval.name = buystring(yytext); + return NAME; + } + } + YY_BREAK +case 150: +YY_RULE_SETUP +#line 366 "ldlex.l" +{ + /* No matter the state, quotes + give what's inside */ + yylval.name = buystring(yytext+1); + yylval.name[yyleng-2] = 0; + return NAME; + } + YY_BREAK +case 151: +YY_RULE_SETUP +#line 373 "ldlex.l" +{ lineno++;} + YY_BREAK +case 152: +YY_RULE_SETUP +#line 374 "ldlex.l" +{ } + YY_BREAK +case 153: +YY_RULE_SETUP +#line 376 "ldlex.l" +{ return *yytext; } + YY_BREAK +case 154: +YY_RULE_SETUP +#line 378 "ldlex.l" +{ RTOKEN(GLOBAL); } + YY_BREAK +case 155: +YY_RULE_SETUP +#line 380 "ldlex.l" +{ RTOKEN(LOCAL); } + YY_BREAK +case 156: +YY_RULE_SETUP +#line 382 "ldlex.l" +{ RTOKEN(EXTERN); } + YY_BREAK +case 157: +YY_RULE_SETUP +#line 384 "ldlex.l" +{ yylval.name = buystring (yytext); + return VERS_IDENTIFIER; } + YY_BREAK +case 158: +YY_RULE_SETUP +#line 387 "ldlex.l" +{ yylval.name = buystring (yytext); + return VERS_TAG; } + YY_BREAK +case 159: +YY_RULE_SETUP +#line 390 "ldlex.l" +{ BEGIN(VERS_SCRIPT); return *yytext; } + YY_BREAK +case 160: +YY_RULE_SETUP +#line 392 "ldlex.l" +{ BEGIN(VERS_NODE); + vers_node_nesting = 0; + return *yytext; + } + YY_BREAK +case 161: +YY_RULE_SETUP +#line 396 "ldlex.l" +{ return *yytext; } + YY_BREAK +case 162: +YY_RULE_SETUP +#line 397 "ldlex.l" +{ vers_node_nesting++; return *yytext; } + YY_BREAK +case 163: +YY_RULE_SETUP +#line 398 "ldlex.l" +{ if (--vers_node_nesting < 0) + BEGIN(VERS_SCRIPT); + return *yytext; + } + YY_BREAK +case 164: +YY_RULE_SETUP +#line 403 "ldlex.l" +{ lineno++; } + YY_BREAK +case 165: +YY_RULE_SETUP +#line 405 "ldlex.l" +{ /* Eat up comments */ } + YY_BREAK +case 166: +YY_RULE_SETUP +#line 407 "ldlex.l" +{ /* Eat up whitespace */ } + YY_BREAK +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(SCRIPT): +case YY_STATE_EOF(EXPRESSION): +case YY_STATE_EOF(BOTH): +case YY_STATE_EOF(DEFSYMEXP): +case YY_STATE_EOF(MRI): +case YY_STATE_EOF(VERS_START): +case YY_STATE_EOF(VERS_SCRIPT): +case YY_STATE_EOF(VERS_NODE): +#line 409 "ldlex.l" +{ + include_stack_ptr--; + + if (include_stack_ptr == 0) + { + yyterminate(); + } + else + { + yy_switch_to_buffer(include_stack[include_stack_ptr]); + + } + BEGIN(SCRIPT); + ldfile_input_filename = file_name_stack[include_stack_ptr - 1]; + lineno = lineno_stack[include_stack_ptr - 1]; + + return END; +} + YY_BREAK +case 167: +YY_RULE_SETUP +#line 428 "ldlex.l" +lex_warn_invalid(" in script", yytext); + YY_BREAK +case 168: +YY_RULE_SETUP +#line 429 "ldlex.l" +lex_warn_invalid(" in expression", yytext); + YY_BREAK +case 169: +YY_RULE_SETUP +#line 431 "ldlex.l" +ECHO; + YY_BREAK +#line 2477 "lex.yy.c" + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1062 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1062 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 1061); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 431 "ldlex.l" + + + +/* Switch flex to reading script file NAME, open on FILE, + saving the current input info on the include stack. */ + +void +lex_push_file (file, name) + FILE *file; + const char *name; +{ + if (include_stack_ptr >= MAX_INCLUDE_DEPTH) + { + einfo("%F:includes nested too deeply\n"); + } + file_name_stack[include_stack_ptr] = name; + lineno_stack[include_stack_ptr] = 1; + include_stack[include_stack_ptr] = YY_CURRENT_BUFFER; + + include_stack_ptr++; + yyin = file; + yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE)); + BEGIN (SCRIPT); +} + +/* Return a newly created flex input buffer containing STRING, + which is SIZE bytes long. */ + +static YY_BUFFER_STATE +yy_create_string_buffer (string, size) + CONST char *string; + size_t size; +{ + YY_BUFFER_STATE b; + + /* Calls to m-alloc get turned by sed into xm-alloc. */ + b = (YY_BUFFER_STATE) malloc (sizeof (struct yy_buffer_state)); + b->yy_input_file = 0; + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + we need to put in 2 end-of-buffer characters. */ + b->yy_ch_buf = (char *) malloc ((unsigned) (b->yy_buf_size + 3)); + + b->yy_ch_buf[0] = '\n'; + strcpy (b->yy_ch_buf+1, string); + b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR; + b->yy_n_chars = size+1; + b->yy_buf_pos = &b->yy_ch_buf[1]; + + /* flex 2.4.7 changed the interface. FIXME: We should not be using + a flex internal interface in the first place! */ +#ifdef YY_BUFFER_NEW + b->yy_buffer_status = YY_BUFFER_NEW; +#else + b->yy_eof_status = EOF_NOT_SEEN; +#endif + + return b; +} + +/* Switch flex to reading from STRING, saving the current input info + on the include stack. */ + +void +lex_redirect (string) + CONST char *string; +{ + YY_BUFFER_STATE tmp; + + yy_init = 0; + if (include_stack_ptr >= MAX_INCLUDE_DEPTH) + { + einfo("%F: macros nested too deeply\n"); + } + file_name_stack[include_stack_ptr] = "redirect"; + lineno_stack[include_stack_ptr] = 0; + include_stack[include_stack_ptr] = YY_CURRENT_BUFFER; + include_stack_ptr++; + tmp = yy_create_string_buffer (string, strlen (string)); + yy_switch_to_buffer (tmp); + BEGIN (SCRIPT); +} + +/* Functions to switch to a different flex start condition, + saving the current start condition on `state_stack'. */ + +static int state_stack[MAX_INCLUDE_DEPTH * 2]; +static int *state_stack_p = state_stack; + +void +ldlex_script () +{ + *(state_stack_p)++ = yy_start; + BEGIN (SCRIPT); +} + +void +ldlex_mri_script () +{ + *(state_stack_p)++ = yy_start; + BEGIN (MRI); +} + +void +ldlex_version_script () +{ + *(state_stack_p)++ = yy_start; + BEGIN (VERS_START); +} + +void +ldlex_version_file () +{ + *(state_stack_p)++ = yy_start; + BEGIN (VERS_SCRIPT); +} + +void +ldlex_defsym () +{ + *(state_stack_p)++ = yy_start; + BEGIN (DEFSYMEXP); +} + +void +ldlex_expression () +{ + *(state_stack_p)++ = yy_start; + BEGIN (EXPRESSION); +} + +void +ldlex_both () +{ + *(state_stack_p)++ = yy_start; + BEGIN (BOTH); +} + +void +ldlex_popstate () +{ + yy_start = *(--state_stack_p); +} + + +/* Place up to MAX_SIZE characters in BUF and return in *RESULT + either the number of characters read, or 0 to indicate EOF. */ + +static void +yy_input (buf, result, max_size) + char *buf; + int *result; + int max_size; +{ + *result = 0; + if (yy_current_buffer->yy_input_file) + { + if (yyin) + { + *result = read (fileno (yyin), (char *) buf, max_size); + if (*result < 0) + einfo ("%F%P: read in flex scanner failed\n"); + } + } +} + +/* Eat the rest of a C-style comment. */ + +static void +comment () +{ + int c; + + while (1) + { + c = input(); + while (c != '*' && c != EOF) + { + if (c == '\n') + lineno++; + c = input(); + } + + if (c == '*') + { + c = input(); + while (c == '*') + c = input(); + if (c == '/') + break; /* found the end */ + } + + if (c == '\n') + lineno++; + + if (c == EOF) + { + einfo( "%F%P: EOF in comment\n"); + break; + } + } +} + +/* Warn the user about a garbage character WHAT in the input + in context WHERE. */ + +static void +lex_warn_invalid (where, what) + char *where, *what; +{ + char buf[5]; + + /* If we have found an input file whose format we do not recognize, + and we are therefore treating it as a linker script, and we find + an invalid character, then most likely this is a real object file + of some different format. Treat it as such. */ + if (ldfile_assumed_script) + { + bfd_set_error (bfd_error_file_not_recognized); + einfo ("%F%s: file not recognized: %E\n", ldfile_input_filename); + } + + if (! isprint ((unsigned char) *what)) + { + sprintf (buf, "\\%03o", (unsigned int) *what); + what = buf; + } + + einfo ("%P:%S: ignoring invalid character `%s'%s\n", what, where); +} diff --git a/ld/ldver.texi b/ld/ldver.texi new file mode 100644 index 00000000000..b696ac718c9 --- /dev/null +++ b/ld/ldver.texi @@ -0,0 +1 @@ +@set VERSION 2.10 |