diff --git a/.gitignore b/.gitignore index 2fbb3bbf49..e5dea91c6f 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,4 @@ papermario/build/ .vscode/ .idea/ .DS_Store +venv/ diff --git a/PAPER_MARIO.u.yaml b/PAPER_MARIO.u.yaml index 8dba91f6a6..11c14932fe 100644 --- a/PAPER_MARIO.u.yaml +++ b/PAPER_MARIO.u.yaml @@ -82,7 +82,7 @@ ranges: - [0xf79b0, 0xf99b0, "asm", "CODE_f79b0_len_2000", 0x002D3000] # frame:0x00000001 header: 0x0 trace: Tbl mapped:802d4f20 - [0xf99b0, 0xfb9b0, "asm", "CODE_f99b0_len_2000", 0x002D5000] # frame:0x00000001 header: 0x2000000 trace: Tbl mapped:802d6d94 - [0xfb9b0, 0xfd9b0, "asm", "CODE_fb9b0_len_2000", 0x002D7000] # frame:0x00000001 header: 0x0 trace: Tbl mapped:802d8cec - - [0xfd9b0, 0xfee30, "asm", "CODE_fd9b0_len_1480", 0x002D9000] # frame:0x00000001 header: D 0x44000000 trace: Tbl mapped:802d9ab0 + - [0xfd9b0, 0x0fe650, "asm", "CODE_fd9b0_len_1480", 0x002D9000] # frame:0x00000001 header: D 0x44000000 trace: Tbl mapped:802d9ab0 - [0xfee30, 0x100e30, "asm", "CODE_fee30_len_2000", 0x002DBD40] # frame:0x00000001 header: 0x27000000 trace: Tbl mapped:802ddd34 - [0x100e30, 0x102610, "asm", "CODE_100e30_len_17e0", 0x002DDD40] # frame:0x00000001 header: 0x24000000 trace: Tbl mapped:802df354 - [0x102610, 0x104610, "asm", "CODE_102610_len_2000", 0x002E0D90] # frame:0x00000001 header: 0x3c000000 trace: Tbl mapped:802e13d4 diff --git a/oldbinutils/bin/mips-addr2line b/oldbinutils/bin/mips-addr2line new file mode 100755 index 0000000000..169f3186ee Binary files /dev/null and b/oldbinutils/bin/mips-addr2line differ diff --git a/oldbinutils/bin/mips-ar b/oldbinutils/bin/mips-ar new file mode 100755 index 0000000000..1b148076d6 Binary files /dev/null and b/oldbinutils/bin/mips-ar differ diff --git a/oldbinutils/bin/mips-as b/oldbinutils/bin/mips-as new file mode 100755 index 0000000000..d1fd3722d6 Binary files /dev/null and b/oldbinutils/bin/mips-as differ diff --git a/oldbinutils/bin/mips-c++filt b/oldbinutils/bin/mips-c++filt new file mode 100755 index 0000000000..2eb454a0be Binary files /dev/null and b/oldbinutils/bin/mips-c++filt differ diff --git a/oldbinutils/bin/mips-gasp b/oldbinutils/bin/mips-gasp new file mode 100755 index 0000000000..867d650a39 Binary files /dev/null and b/oldbinutils/bin/mips-gasp differ diff --git a/oldbinutils/bin/mips-ld b/oldbinutils/bin/mips-ld new file mode 100755 index 0000000000..91d95d733b Binary files /dev/null and b/oldbinutils/bin/mips-ld differ diff --git a/oldbinutils/bin/mips-nintendo-nu64-as b/oldbinutils/bin/mips-nintendo-nu64-as new file mode 100755 index 0000000000..5c58598f10 Binary files /dev/null and b/oldbinutils/bin/mips-nintendo-nu64-as differ diff --git a/oldbinutils/bin/mips-nm b/oldbinutils/bin/mips-nm new file mode 100755 index 0000000000..53ea7806cc Binary files /dev/null and b/oldbinutils/bin/mips-nm differ diff --git a/oldbinutils/bin/mips-objcopy b/oldbinutils/bin/mips-objcopy new file mode 100755 index 0000000000..afcf7bea48 Binary files /dev/null and b/oldbinutils/bin/mips-objcopy differ diff --git a/oldbinutils/bin/mips-objdump b/oldbinutils/bin/mips-objdump new file mode 100755 index 0000000000..f621c3279a Binary files /dev/null and b/oldbinutils/bin/mips-objdump differ diff --git a/oldbinutils/bin/mips-ranlib b/oldbinutils/bin/mips-ranlib new file mode 100755 index 0000000000..69d26a5927 Binary files /dev/null and b/oldbinutils/bin/mips-ranlib differ diff --git a/oldbinutils/bin/mips-size b/oldbinutils/bin/mips-size new file mode 100755 index 0000000000..c034dcdb8f Binary files /dev/null and b/oldbinutils/bin/mips-size differ diff --git a/oldbinutils/bin/mips-strings b/oldbinutils/bin/mips-strings new file mode 100755 index 0000000000..3be0b4fe42 Binary files /dev/null and b/oldbinutils/bin/mips-strings differ diff --git a/oldbinutils/bin/mips-strip b/oldbinutils/bin/mips-strip new file mode 100755 index 0000000000..6c8ab7cbee Binary files /dev/null and b/oldbinutils/bin/mips-strip differ diff --git a/oldbinutils/include/ansidecl.h b/oldbinutils/include/ansidecl.h new file mode 100644 index 0000000000..abe87a9390 --- /dev/null +++ b/oldbinutils/include/ansidecl.h @@ -0,0 +1,154 @@ +/* ANSI and traditional C compatability macros + Copyright 1991, 1992, 1996 Free Software Foundation, Inc. + This file is part of the GNU C Library. + +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. */ + +/* ANSI and traditional C compatibility macros + + ANSI C is assumed if __STDC__ is #defined. + + Macro ANSI C definition Traditional C definition + ----- ---- - ---------- ----------- - ---------- + PTR `void *' `char *' + LONG_DOUBLE `long double' `double' + VOLATILE `volatile' `' + SIGNED `signed' `' + PTRCONST `void *const' `char *' + ANSI_PROTOTYPES 1 not defined + + CONST is also defined, but is obsolete. Just use const. + + obsolete -- DEFUN (name, arglist, args) + + Defines function NAME. + + ARGLIST lists the arguments, separated by commas and enclosed in + parentheses. ARGLIST becomes the argument list in traditional C. + + ARGS list the arguments with their types. It becomes a prototype in + ANSI C, and the type declarations in traditional C. Arguments should + be separated with `AND'. For functions with a variable number of + arguments, the last thing listed should be `DOTS'. + + obsolete -- DEFUN_VOID (name) + + Defines a function NAME, which takes no arguments. + + obsolete -- EXFUN (name, (prototype)) -- obsolete. + + Replaced by PARAMS. Do not use; will disappear someday soon. + Was used in external function declarations. + In ANSI C it is `NAME PROTOTYPE' (so PROTOTYPE should be enclosed in + parentheses). In traditional C it is `NAME()'. + For a function that takes no arguments, PROTOTYPE should be `(void)'. + + obsolete -- PROTO (type, name, (prototype) -- obsolete. + + This one has also been replaced by PARAMS. Do not use. + + PARAMS ((args)) + + We could use the EXFUN macro to handle prototype declarations, but + the name is misleading and the result is ugly. So we just define a + simple macro to handle the parameter lists, as in: + + static int foo PARAMS ((int, char)); + + This produces: `static int foo();' or `static int foo (int, char);' + + EXFUN would have done it like this: + + static int EXFUN (foo, (int, char)); + + but the function is not external...and it's hard to visually parse + the function name out of the mess. EXFUN should be considered + obsolete; new code should be written to use PARAMS. + + DOTS is also obsolete. + + Examples: + + extern int printf PARAMS ((const char *format, ...)); +*/ + +#ifndef _ANSIDECL_H + +#define _ANSIDECL_H 1 + + +/* Every source file includes this file, + so they will all get the switch for lint. */ +/* LINTLIBRARY */ + + +#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) +/* All known AIX compilers implement these things (but don't always + define __STDC__). The RISC/OS MIPS compiler defines these things + in SVR4 mode, but does not define __STDC__. */ + +#define PTR void * +#define PTRCONST void *CONST +#define LONG_DOUBLE long double + +#define AND , +#define NOARGS void +#define VOLATILE volatile +#define SIGNED signed + +#define PARAMS(paramlist) paramlist +#define ANSI_PROTOTYPES 1 + +#define VPARAMS(ARGS) ARGS +#define VA_START(va_list,var) va_start(va_list,var) + +/* These are obsolete. Do not use. */ +#define CONST const +#define DOTS , ... +#define PROTO(type, name, arglist) type name arglist +#define EXFUN(name, proto) name proto +#define DEFUN(name, arglist, args) name(args) +#define DEFUN_VOID(name) name(void) + +#else /* Not ANSI C. */ + +#define PTR char * +#define PTRCONST PTR +#define LONG_DOUBLE double + +#define AND ; +#define NOARGS +#ifndef const /* some systems define it in header files for non-ansi mode */ +#define const +#endif +#define VOLATILE +#define SIGNED + +#define PARAMS(paramlist) () + +#define VPARAMS(ARGS) (va_alist) va_dcl +#define VA_START(va_list,var) va_start(va_list) + +/* These are obsolete. Do not use. */ +#define CONST +#define DOTS +#define PROTO(type, name, arglist) type name () +#define EXFUN(name, proto) name() +#define DEFUN(name, arglist, args) name arglist args; +#define DEFUN_VOID(name) name() + +#endif /* ANSI C. */ + +#endif /* ansidecl.h */ diff --git a/oldbinutils/include/bfd.h b/oldbinutils/include/bfd.h new file mode 100644 index 0000000000..19a36ff6d4 --- /dev/null +++ b/oldbinutils/include/bfd.h @@ -0,0 +1,2796 @@ +/* Main header file for the bfd library -- portable access to object files. + Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998 + Free Software Foundation, Inc. + Contributed by Cygnus Support. + +** NOTE: bfd.h and bfd-in2.h are GENERATED files. Don't change them; +** instead, change bfd-in.h or the other BFD source files processed to +** generate these files. + +This file is part of BFD, the Binary File Descriptor library. + +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. */ + +/* bfd.h -- The only header file required by users of the bfd library + +The bfd.h file is generated from bfd-in.h and various .c files; if you +change it, your changes will probably be lost. + +All the prototypes and definitions following the comment "THE FOLLOWING +IS EXTRACTED FROM THE SOURCE" are extracted from the source files for +BFD. If you change it, someone oneday will extract it from the source +again, and your changes will be lost. To save yourself from this bind, +change the definitions in the source in the bfd directory. Type "make +docs" and then "make headers" in that directory, and magically this file +will change to reflect your changes. + +If you don't have the tools to perform the extraction, then you are +safe from someone on your system trampling over your header files. +You should still maintain the equivalence between the source and this +file though; every change you make to the .c file should be reflected +here. */ + +#ifndef __BFD_H_SEEN__ +#define __BFD_H_SEEN__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "ansidecl.h" + +/* These two lines get substitutions done by commands in Makefile.in. */ +#define BFD_VERSION "2.9.1" +#define BFD_ARCH_SIZE 64 +#define BFD_HOST_64BIT_LONG 0 +#if 0 +#define BFD_HOST_64_BIT +#define BFD_HOST_U_64_BIT +#endif + +#if BFD_ARCH_SIZE >= 64 +#define BFD64 +#endif + +#ifndef INLINE +#if __GNUC__ >= 2 +#define INLINE __inline__ +#else +#define INLINE +#endif +#endif + +/* forward declaration */ +typedef struct _bfd bfd; + +/* To squelch erroneous compiler warnings ("illegal pointer + combination") from the SVR3 compiler, we would like to typedef + boolean to int (it doesn't like functions which return boolean. + Making sure they are never implicitly declared to return int + doesn't seem to help). But this file is not configured based on + the host. */ +/* General rules: functions which are boolean return true on success + and false on failure (unless they're a predicate). -- bfd.doc */ +/* I'm sure this is going to break something and someone is going to + force me to change it. */ +/* typedef enum boolean {false, true} boolean; */ +/* Yup, SVR4 has a "typedef enum boolean" in -fnf */ +/* It gets worse if the host also defines a true/false enum... -sts */ +/* And even worse if your compiler has built-in boolean types... -law */ +#if defined (__GNUG__) && (__GNUC_MINOR__ > 5) +#define TRUE_FALSE_ALREADY_DEFINED +#endif +#ifdef MPW +/* Pre-emptive strike - get the file with the enum. */ +#include +#define TRUE_FALSE_ALREADY_DEFINED +#endif /* MPW */ +#ifndef TRUE_FALSE_ALREADY_DEFINED +typedef enum bfd_boolean {false, true} boolean; +#define BFD_TRUE_FALSE +#else +/* Use enum names that will appear nowhere else. */ +typedef enum bfd_boolean {bfd_fffalse, bfd_tttrue} boolean; +#endif + +/* A pointer to a position in a file. */ +/* FIXME: This should be using off_t from . + For now, try to avoid breaking stuff by not including here. + This will break on systems with 64-bit file offsets (e.g. 4.4BSD). + Probably the best long-term answer is to avoid using file_ptr AND off_t + in this header file, and to handle this in the BFD implementation + rather than in its interface. */ +/* typedef off_t file_ptr; */ +typedef long int file_ptr; + +/* Support for different sizes of target format ints and addresses. + If the type `long' is at least 64 bits, BFD_HOST_64BIT_LONG will be + set to 1 above. Otherwise, if gcc is being used, this code will + use gcc's "long long" type. Otherwise, BFD_HOST_64_BIT must be + defined above. */ + +#ifdef BFD64 + +#ifndef BFD_HOST_64_BIT +#if BFD_HOST_64BIT_LONG +#define BFD_HOST_64_BIT long +#define BFD_HOST_U_64_BIT unsigned long +#else +#ifdef __GNUC__ +#define BFD_HOST_64_BIT long long +#define BFD_HOST_U_64_BIT unsigned long long +#else /* ! defined (__GNUC__) */ + #error No 64 bit integer type available +#endif /* ! defined (__GNUC__) */ +#endif /* ! BFD_HOST_64BIT_LONG */ +#endif /* ! defined (BFD_HOST_64_BIT) */ + +typedef BFD_HOST_U_64_BIT bfd_vma; +typedef BFD_HOST_64_BIT bfd_signed_vma; +typedef BFD_HOST_U_64_BIT bfd_size_type; +typedef BFD_HOST_U_64_BIT symvalue; + +#ifndef fprintf_vma +#if BFD_HOST_64BIT_LONG +#define sprintf_vma(s,x) sprintf (s, "%016lx", x) +#define fprintf_vma(f,x) fprintf (f, "%016lx", x) +#else +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff))) +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff)) +#define fprintf_vma(s,x) \ + fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) +#define sprintf_vma(s,x) \ + sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) +#endif +#endif + +#else /* not BFD64 */ + +/* Represent a target address. Also used as a generic unsigned type + which is guaranteed to be big enough to hold any arithmetic types + we need to deal with. */ +typedef unsigned long bfd_vma; + +/* A generic signed type which is guaranteed to be big enough to hold any + arithmetic types we need to deal with. Can be assumed to be compatible + with bfd_vma in the same way that signed and unsigned ints are compatible + (as parameters, in assignment, etc). */ +typedef long bfd_signed_vma; + +typedef unsigned long symvalue; +typedef unsigned long bfd_size_type; + +/* Print a bfd_vma x on stream s. */ +#define fprintf_vma(s,x) fprintf(s, "%08lx", x) +#define sprintf_vma(s,x) sprintf(s, "%08lx", x) +#endif /* not BFD64 */ +#define printf_vma(x) fprintf_vma(stdout,x) + +typedef unsigned int flagword; /* 32 bits of flags */ +typedef unsigned char bfd_byte; + +/** File formats */ + +typedef enum bfd_format { + bfd_unknown = 0, /* file format is unknown */ + bfd_object, /* linker/assember/compiler output */ + bfd_archive, /* object archive file */ + bfd_core, /* core dump */ + bfd_type_end} /* marks the end; don't use it! */ + bfd_format; + +/* Values that may appear in the flags field of a BFD. These also + appear in the object_flags field of the bfd_target structure, where + they indicate the set of flags used by that backend (not all flags + are meaningful for all object file formats) (FIXME: at the moment, + the object_flags values have mostly just been copied from backend + to another, and are not necessarily correct). */ + +/* No flags. */ +#define BFD_NO_FLAGS 0x00 + +/* BFD contains relocation entries. */ +#define HAS_RELOC 0x01 + +/* BFD is directly executable. */ +#define EXEC_P 0x02 + +/* BFD has line number information (basically used for F_LNNO in a + COFF header). */ +#define HAS_LINENO 0x04 + +/* BFD has debugging information. */ +#define HAS_DEBUG 0x08 + +/* BFD has symbols. */ +#define HAS_SYMS 0x10 + +/* BFD has local symbols (basically used for F_LSYMS in a COFF + header). */ +#define HAS_LOCALS 0x20 + +/* BFD is a dynamic object. */ +#define DYNAMIC 0x40 + +/* Text section is write protected (if D_PAGED is not set, this is + like an a.out NMAGIC file) (the linker sets this by default, but + clears it for -r or -N). */ +#define WP_TEXT 0x80 + +/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the + linker sets this by default, but clears it for -r or -n or -N). */ +#define D_PAGED 0x100 + +/* BFD is relaxable (this means that bfd_relax_section may be able to + do something) (sometimes bfd_relax_section can do something even if + this is not set). */ +#define BFD_IS_RELAXABLE 0x200 + +/* This may be set before writing out a BFD to request using a + traditional format. For example, this is used to request that when + writing out an a.out object the symbols not be hashed to eliminate + duplicates. */ +#define BFD_TRADITIONAL_FORMAT 0x400 + +/* This flag indicates that the BFD contents are actually cached in + memory. If this is set, iostream points to a bfd_in_memory struct. */ +#define BFD_IN_MEMORY 0x800 + +/* symbols and relocation */ + +/* A count of carsyms (canonical archive symbols). */ +typedef unsigned long symindex; + +/* How to perform a relocation. */ +typedef const struct reloc_howto_struct reloc_howto_type; + +#define BFD_NO_MORE_SYMBOLS ((symindex) ~0) + +/* General purpose part of a symbol X; + target specific parts are in libcoff.h, libaout.h, etc. */ + +#define bfd_get_section(x) ((x)->section) +#define bfd_get_output_section(x) ((x)->section->output_section) +#define bfd_set_section(x,y) ((x)->section) = (y) +#define bfd_asymbol_base(x) ((x)->section->vma) +#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value) +#define bfd_asymbol_name(x) ((x)->name) +/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/ +#define bfd_asymbol_bfd(x) ((x)->the_bfd) +#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour) + +/* A canonical archive symbol. */ +/* This is a type pun with struct ranlib on purpose! */ +typedef struct carsym { + char *name; + file_ptr file_offset; /* look here to find the file */ +} carsym; /* to make these you call a carsymogen */ + + +/* Used in generating armaps (archive tables of contents). + Perhaps just a forward definition would do? */ +struct orl { /* output ranlib */ + char **name; /* symbol name */ + file_ptr pos; /* bfd* or file position */ + int namidx; /* index into string table */ +}; + + +/* Linenumber stuff */ +typedef struct lineno_cache_entry { + unsigned int line_number; /* Linenumber from start of function*/ + union { + struct symbol_cache_entry *sym; /* Function name */ + unsigned long offset; /* Offset into section */ + } u; +} alent; + +/* object and core file sections */ + +#define align_power(addr, align) \ + ( ((addr) + ((1<<(align))-1)) & (-1 << (align))) + +typedef struct sec *sec_ptr; + +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0) +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0) +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0) +#define bfd_section_name(bfd, ptr) ((ptr)->name) +#define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr)) +#define bfd_section_vma(bfd, ptr) ((ptr)->vma) +#define bfd_section_lma(bfd, ptr) ((ptr)->lma) +#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) +#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0) +#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata) + +#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0) + +#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = (boolean)true), true) +#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true) +#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true) + +typedef struct stat stat_type; + +typedef enum bfd_print_symbol +{ + bfd_print_symbol_name, + bfd_print_symbol_more, + bfd_print_symbol_all +} bfd_print_symbol_type; + +/* Information about a symbol that nm needs. */ + +typedef struct _symbol_info +{ + symvalue value; + char type; + CONST char *name; /* Symbol name. */ + unsigned char stab_type; /* Stab type. */ + char stab_other; /* Stab other. */ + short stab_desc; /* Stab desc. */ + CONST char *stab_name; /* String for stab type. */ +} symbol_info; + +/* Get the name of a stabs type code. */ + +extern const char *bfd_get_stab_name PARAMS ((int)); + +/* Hash table routines. There is no way to free up a hash table. */ + +/* An element in the hash table. Most uses will actually use a larger + structure, and an instance of this will be the first field. */ + +struct bfd_hash_entry +{ + /* Next entry for this hash code. */ + struct bfd_hash_entry *next; + /* String being hashed. */ + const char *string; + /* Hash code. This is the full hash code, not the index into the + table. */ + unsigned long hash; +}; + +/* A hash table. */ + +struct bfd_hash_table +{ + /* The hash array. */ + struct bfd_hash_entry **table; + /* The number of slots in the hash table. */ + unsigned int size; + /* A function used to create new elements in the hash table. The + first entry is itself a pointer to an element. When this + function is first invoked, this pointer will be NULL. However, + having the pointer permits a hierarchy of method functions to be + built each of which calls the function in the superclass. Thus + each function should be written to allocate a new block of memory + only if the argument is NULL. */ + struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *)); + /* An objalloc for this hash table. This is a struct objalloc *, + but we use PTR to avoid requiring the inclusion of objalloc.h. */ + PTR memory; +}; + +/* Initialize a hash table. */ +extern boolean bfd_hash_table_init + PARAMS ((struct bfd_hash_table *, + struct bfd_hash_entry *(*) (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *))); + +/* Initialize a hash table specifying a size. */ +extern boolean bfd_hash_table_init_n + PARAMS ((struct bfd_hash_table *, + struct bfd_hash_entry *(*) (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *), + unsigned int size)); + +/* Free up a hash table. */ +extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *)); + +/* Look up a string in a hash table. If CREATE is true, a new entry + will be created for this string if one does not already exist. The + COPY argument must be true if this routine should copy the string + into newly allocated memory when adding an entry. */ +extern struct bfd_hash_entry *bfd_hash_lookup + PARAMS ((struct bfd_hash_table *, const char *, boolean create, + boolean copy)); + +/* Replace an entry in a hash table. */ +extern void bfd_hash_replace + PARAMS ((struct bfd_hash_table *, struct bfd_hash_entry *old, + struct bfd_hash_entry *nw)); + +/* Base method for creating a hash table entry. */ +extern struct bfd_hash_entry *bfd_hash_newfunc + PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, + const char *)); + +/* Grab some space for a hash table entry. */ +extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *, + unsigned int)); + +/* Traverse a hash table in a random order, calling a function on each + element. If the function returns false, the traversal stops. The + INFO argument is passed to the function. */ +extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *, + boolean (*) (struct bfd_hash_entry *, + PTR), + PTR info)); + +/* Semi-portable string concatenation in cpp. + The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors. + The problem is, "32_" is not a valid preprocessing token, and we don't + want extra underscores (e.g., "nlm_32_"). The XCAT2 macro will cause the + inner CAT macros to be evaluated first, producing still-valid pp-tokens. + Then the final concatenation can be done. (Sigh.) */ +#ifndef CAT +#ifdef SABER +#define CAT(a,b) a##b +#define CAT3(a,b,c) a##b##c +#define CAT4(a,b,c,d) a##b##c##d +#else +#if defined(__STDC__) || defined(ALMOST_STDC) +#define CAT(a,b) a##b +#define CAT3(a,b,c) a##b##c +#define XCAT2(a,b) CAT(a,b) +#define CAT4(a,b,c,d) XCAT2(CAT(a,b),CAT(c,d)) +#else +#define CAT(a,b) a/**/b +#define CAT3(a,b,c) a/**/b/**/c +#define CAT4(a,b,c,d) a/**/b/**/c/**/d +#endif +#endif +#endif + +#define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table + +/* User program access to BFD facilities */ + +/* Direct I/O routines, for programs which know more about the object + file than BFD does. Use higher level routines if possible. */ + +extern bfd_size_type bfd_read + PARAMS ((PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd)); +extern bfd_size_type bfd_write + PARAMS ((const PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd)); +extern int bfd_seek PARAMS ((bfd *abfd, file_ptr fp, int direction)); +extern long bfd_tell PARAMS ((bfd *abfd)); +extern int bfd_flush PARAMS ((bfd *abfd)); +extern int bfd_stat PARAMS ((bfd *abfd, struct stat *)); + + +/* Cast from const char * to char * so that caller can assign to + a char * without a warning. */ +#define bfd_get_filename(abfd) ((char *) (abfd)->filename) +#define bfd_get_cacheable(abfd) ((abfd)->cacheable) +#define bfd_get_format(abfd) ((abfd)->format) +#define bfd_get_target(abfd) ((abfd)->xvec->name) +#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour) +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG) +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE) +#define bfd_header_big_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG) +#define bfd_header_little_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE) +#define bfd_get_file_flags(abfd) ((abfd)->flags) +#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags) +#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags) +#define bfd_my_archive(abfd) ((abfd)->my_archive) +#define bfd_has_map(abfd) ((abfd)->has_armap) + +#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types) +#define bfd_usrdata(abfd) ((abfd)->usrdata) + +#define bfd_get_start_address(abfd) ((abfd)->start_address) +#define bfd_get_symcount(abfd) ((abfd)->symcount) +#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols) +#define bfd_count_sections(abfd) ((abfd)->section_count) + +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char) + +#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (boolean)(bool)), true) + +extern boolean bfd_record_phdr + PARAMS ((bfd *, unsigned long, boolean, flagword, boolean, bfd_vma, + boolean, boolean, unsigned int, struct sec **)); + +/* Byte swapping routines. */ + +bfd_vma bfd_getb64 PARAMS ((const unsigned char *)); +bfd_vma bfd_getl64 PARAMS ((const unsigned char *)); +bfd_signed_vma bfd_getb_signed_64 PARAMS ((const unsigned char *)); +bfd_signed_vma bfd_getl_signed_64 PARAMS ((const unsigned char *)); +bfd_vma bfd_getb32 PARAMS ((const unsigned char *)); +bfd_vma bfd_getl32 PARAMS ((const unsigned char *)); +bfd_signed_vma bfd_getb_signed_32 PARAMS ((const unsigned char *)); +bfd_signed_vma bfd_getl_signed_32 PARAMS ((const unsigned char *)); +bfd_vma bfd_getb16 PARAMS ((const unsigned char *)); +bfd_vma bfd_getl16 PARAMS ((const unsigned char *)); +bfd_signed_vma bfd_getb_signed_16 PARAMS ((const unsigned char *)); +bfd_signed_vma bfd_getl_signed_16 PARAMS ((const unsigned char *)); +void bfd_putb64 PARAMS ((bfd_vma, unsigned char *)); +void bfd_putl64 PARAMS ((bfd_vma, unsigned char *)); +void bfd_putb32 PARAMS ((bfd_vma, unsigned char *)); +void bfd_putl32 PARAMS ((bfd_vma, unsigned char *)); +void bfd_putb16 PARAMS ((bfd_vma, unsigned char *)); +void bfd_putl16 PARAMS ((bfd_vma, unsigned char *)); + +/* Externally visible ECOFF routines. */ + +#if defined(__STDC__) || defined(ALMOST_STDC) +struct ecoff_debug_info; +struct ecoff_debug_swap; +struct ecoff_extr; +struct symbol_cache_entry; +struct bfd_link_info; +struct bfd_link_hash_entry; +struct bfd_elf_version_tree; +#endif +extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd)); +extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value)); +extern boolean bfd_ecoff_set_regmasks + PARAMS ((bfd *abfd, unsigned long gprmask, unsigned long fprmask, + unsigned long *cprmask)); +extern PTR bfd_ecoff_debug_init + PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, + struct bfd_link_info *)); +extern void bfd_ecoff_debug_free + PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, + struct bfd_link_info *)); +extern boolean bfd_ecoff_debug_accumulate + PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, + bfd *input_bfd, struct ecoff_debug_info *input_debug, + const struct ecoff_debug_swap *input_swap, + struct bfd_link_info *)); +extern boolean bfd_ecoff_debug_accumulate_other + PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, bfd *input_bfd, + struct bfd_link_info *)); +extern boolean bfd_ecoff_debug_externals + PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, + boolean relocateable, + boolean (*get_extr) (struct symbol_cache_entry *, + struct ecoff_extr *), + void (*set_index) (struct symbol_cache_entry *, + bfd_size_type))); +extern boolean bfd_ecoff_debug_one_external + PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, + const char *name, struct ecoff_extr *esym)); +extern bfd_size_type bfd_ecoff_debug_size + PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap)); +extern boolean bfd_ecoff_write_debug + PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, file_ptr where)); +extern boolean bfd_ecoff_write_accumulated_debug + PARAMS ((PTR handle, bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, + struct bfd_link_info *info, file_ptr where)); +extern boolean bfd_mips_ecoff_create_embedded_relocs + PARAMS ((bfd *, struct bfd_link_info *, struct sec *, struct sec *, + char **)); + +/* Externally visible ELF routines. */ + +struct bfd_link_needed_list +{ + struct bfd_link_needed_list *next; + bfd *by; + const char *name; +}; + +extern boolean bfd_elf32_record_link_assignment + PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean)); +extern boolean bfd_elf64_record_link_assignment + PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean)); +extern struct bfd_link_needed_list *bfd_elf_get_needed_list + PARAMS ((bfd *, struct bfd_link_info *)); +extern boolean bfd_elf_get_bfd_needed_list + PARAMS ((bfd *, struct bfd_link_needed_list **)); +extern boolean bfd_elf32_size_dynamic_sections + PARAMS ((bfd *, const char *, const char *, boolean, const char *, + const char * const *, struct bfd_link_info *, struct sec **, + struct bfd_elf_version_tree *)); +extern boolean bfd_elf64_size_dynamic_sections + PARAMS ((bfd *, const char *, const char *, boolean, const char *, + const char * const *, struct bfd_link_info *, struct sec **, + struct bfd_elf_version_tree *)); +extern void bfd_elf_set_dt_needed_name PARAMS ((bfd *, const char *)); +extern const char *bfd_elf_get_dt_soname PARAMS ((bfd *)); + +/* SunOS shared library support routines for the linker. */ + +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list + PARAMS ((bfd *, struct bfd_link_info *)); +extern boolean bfd_sunos_record_link_assignment + PARAMS ((bfd *, struct bfd_link_info *, const char *)); +extern boolean bfd_sunos_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *, struct sec **, struct sec **, + struct sec **)); + +/* Linux shared library support routines for the linker. */ + +extern boolean bfd_i386linux_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); +extern boolean bfd_m68klinux_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); +extern boolean bfd_sparclinux_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); + +/* mmap hacks */ + +struct _bfd_window_internal; +typedef struct _bfd_window_internal bfd_window_internal; + +typedef struct _bfd_window { + /* What the user asked for. */ + PTR data; + bfd_size_type size; + /* The actual window used by BFD. Small user-requested read-only + regions sharing a page may share a single window into the object + file. Read-write versions shouldn't until I've fixed things to + keep track of which portions have been claimed by the + application; don't want to give the same region back when the + application wants two writable copies! */ + struct _bfd_window_internal *i; +} bfd_window; + +extern void bfd_init_window PARAMS ((bfd_window *)); +extern void bfd_free_window PARAMS ((bfd_window *)); +extern boolean bfd_get_file_window + PARAMS ((bfd *, file_ptr, bfd_size_type, bfd_window *, boolean)); + +/* XCOFF support routines for the linker. */ + +extern boolean bfd_xcoff_link_record_set + PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, + bfd_size_type)); +extern boolean bfd_xcoff_import_symbol + PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, + bfd_vma, const char *, const char *, const char *)); +extern boolean bfd_xcoff_export_symbol + PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, + boolean)); +extern boolean bfd_xcoff_link_count_reloc + PARAMS ((bfd *, struct bfd_link_info *, const char *)); +extern boolean bfd_xcoff_record_link_assignment + PARAMS ((bfd *, struct bfd_link_info *, const char *)); +extern boolean bfd_xcoff_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *, const char *, const char *, + unsigned long, unsigned long, unsigned long, boolean, + int, boolean, boolean, struct sec **)); + +/* Externally visible COFF routines. */ + +#if defined(__STDC__) || defined(ALMOST_STDC) +struct internal_syment; +union internal_auxent; +#endif + +extern boolean bfd_coff_get_syment + PARAMS ((bfd *, struct symbol_cache_entry *, struct internal_syment *)); +extern boolean bfd_coff_get_auxent + PARAMS ((bfd *, struct symbol_cache_entry *, int, union internal_auxent *)); + +/* And more from the source. */ +void +bfd_init PARAMS ((void)); + +bfd * +bfd_openr PARAMS ((CONST char *filename, CONST char *target)); + +bfd * +bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd)); + +bfd * +bfd_openstreamr PARAMS ((const char *, const char *, PTR)); + +bfd * +bfd_openw PARAMS ((CONST char *filename, CONST char *target)); + +boolean +bfd_close PARAMS ((bfd *abfd)); + +boolean +bfd_close_all_done PARAMS ((bfd *)); + +bfd * +bfd_create PARAMS ((CONST char *filename, bfd *templ)); + + + /* Byte swapping macros for user section data. */ + +#define bfd_put_8(abfd, val, ptr) \ + (*((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)) + + + /* 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)) + +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 <>. 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 constuctor, 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 + <> | <>; a debug section could be + <> */ +#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 + + /* 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; + + /* 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 <>, 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 bytes, 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 bytes. 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 into the output section of the first byte in the input + section. E.g., if this was going to start at the 100th byte in + the output section, this value would be 100. */ + + 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; + + /* 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(),1): (section)->_raw_size) +#define bfd_get_section_size_after_reloc(section) \ + ((section->reloc_done) ? (section)->_cooked_size: (abort(),1)) +asection * +bfd_get_section_by_name PARAMS ((bfd *abfd, CONST char *name)); + +asection * +bfd_make_section_old_way PARAMS ((bfd *abfd, CONST char *name)); + +asection * +bfd_make_section_anyway PARAMS ((bfd *abfd, CONST char *name)); + +asection * +bfd_make_section PARAMS ((bfd *, CONST char *name)); + +boolean +bfd_set_section_flags PARAMS ((bfd *abfd, asection *sec, flagword flags)); + +void +bfd_map_over_sections PARAMS ((bfd *abfd, + void (*func)(bfd *abfd, + asection *sect, + PTR obj), + PTR obj)); + +boolean +bfd_set_section_size PARAMS ((bfd *abfd, asection *sec, bfd_size_type val)); + +boolean +bfd_set_section_contents + PARAMS ((bfd *abfd, + asection *section, + PTR data, + file_ptr offset, + bfd_size_type count)); + +boolean +bfd_get_section_contents + PARAMS ((bfd *abfd, asection *section, PTR location, + file_ptr offset, bfd_size_type count)); + +boolean +bfd_copy_private_section_data PARAMS ((bfd *ibfd, asection *isec, bfd *obfd, asection *osec)); + +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ + BFD_SEND (obfd, _bfd_copy_private_section_data, \ + (ibfd, isection, obfd, osection)) +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 + 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_v9 6 +#define bfd_mach_sparc_v9a 7 /* 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_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 + bfd_arch_we32k, /* AT&T WE32xxx */ + bfd_arch_tahoe, /* CCI/Harris Tahoe */ + bfd_arch_i860, /* Intel 860 */ + 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 */ + 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_sh3 0x30 +#define bfd_mach_sh3e 0x3e +#define bfd_mach_sh4 0x40 + bfd_arch_alpha, /* Dec Alpha */ + 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 + bfd_arch_ns32k, /* National Semiconductors ns32000 */ + bfd_arch_w65, /* WDC 65816 */ + bfd_arch_tic30, /* Texas Instruments TMS320C30 */ + bfd_arch_v850, /* NEC V850 */ +#define bfd_mach_v850 0 + 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 */ + bfd_arch_mn10200, /* Matsushita MN10200 */ + bfd_arch_mn10300, /* Matsushita MN10300 */ + bfd_arch_last + }; + +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; +const char * +bfd_printable_name PARAMS ((bfd *abfd)); + +const bfd_arch_info_type * +bfd_scan_arch PARAMS ((const char *string)); + +const char ** +bfd_arch_list PARAMS ((void)); + +const bfd_arch_info_type * +bfd_arch_get_compatible PARAMS (( + const bfd *abfd, + const bfd *bbfd)); + +void +bfd_set_arch_info PARAMS ((bfd *abfd, const bfd_arch_info_type *arg)); + +enum bfd_architecture +bfd_get_arch PARAMS ((bfd *abfd)); + +unsigned long +bfd_get_mach PARAMS ((bfd *abfd)); + +unsigned int +bfd_arch_bits_per_byte PARAMS ((bfd *abfd)); + +unsigned int +bfd_arch_bits_per_address PARAMS ((bfd *abfd)); + +const bfd_arch_info_type * +bfd_get_arch_info PARAMS ((bfd *abfd)); + +const bfd_arch_info_type * +bfd_lookup_arch + PARAMS ((enum bfd_architecture + arch, + unsigned long machine)); + +const char * +bfd_printable_arch_mach + PARAMS ((enum bfd_architecture arch, unsigned long machine)); + +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; +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 +}; + +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; + + /* When performing a partial link, some formats must modify the + relocations rather than the data - this flag signals this.*/ + 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 + bit 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; + +}; +#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} +#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN) + +#define HOWTO_PREPARE(relocation, symbol) \ + { \ + if (symbol != (asymbol *)NULL) { \ + if (bfd_is_com_section (symbol->section)) { \ + relocation = 0; \ + } \ + else { \ + relocation = symbol->value; \ + } \ + } \ +} +unsigned int +bfd_get_reloc_size PARAMS ((reloc_howto_type *)); + +typedef struct relent_chain { + arelent relent; + struct relent_chain *next; +} arelent_chain; +bfd_reloc_status_type + +bfd_check_overflow + PARAMS ((enum complain_overflow how, + unsigned int bitsize, + unsigned int rightshift, + bfd_vma relocation)); + +bfd_reloc_status_type + +bfd_perform_relocation + PARAMS ((bfd *abfd, + arelent *reloc_entry, + PTR data, + asection *input_section, + bfd *output_bfd, + char **error_message)); + +bfd_reloc_status_type + +bfd_install_relocation + PARAMS ((bfd *abfd, + arelent *reloc_entry, + PTR data, bfd_vma data_start, + asection *input_section, + char **error_message)); + +enum bfd_reloc_code_real { + _dummy_first_bfd_reloc_code_real, + + +/* Basic absolute relocations of N bits. */ + BFD_RELOC_64, + BFD_RELOC_32, + BFD_RELOC_26, + BFD_RELOC_24, + BFD_RELOC_16, + BFD_RELOC_14, + BFD_RELOC_8, + +/* 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_64_PCREL, + BFD_RELOC_32_PCREL, + BFD_RELOC_24_PCREL, + BFD_RELOC_16_PCREL, + BFD_RELOC_12_PCREL, + BFD_RELOC_8_PCREL, + +/* For ELF. */ + 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, + +/* Relocations used by 68K ELF. */ + BFD_RELOC_68K_GLOB_DAT, + BFD_RELOC_68K_JMP_SLOT, + BFD_RELOC_68K_RELATIVE, + +/* Linkage-table relative. */ + 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, + +/* Absolute 8-bit relocation, but used to form an address like 0xFFnn. */ + BFD_RELOC_8_FFnn, + +/* 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 <>.) The +signed 16-bit displacement is used on the MIPS, and the 23-bit +displacement is used on the Alpha. */ + BFD_RELOC_32_PCREL_S2, + BFD_RELOC_16_PCREL_S2, + BFD_RELOC_23_PCREL_S2, + +/* 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_HI22, + BFD_RELOC_LO10, + +/* 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_GPREL16, + BFD_RELOC_GPREL32, + +/* Reloc types used for i960/b.out. */ + BFD_RELOC_I960_CALLJ, + +/* SPARC ELF relocations. There is probably some overlap with other +relocation types already defined. */ + 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, + +/* I think these are specific to SPARC a.out (e.g., Sun 4). */ + BFD_RELOC_SPARC_BASE13, + BFD_RELOC_SPARC_BASE22, + +/* SPARC64 relocations */ +#define BFD_RELOC_SPARC_64 BFD_RELOC_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, +#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL + 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, + +/* 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_HI16, + +/* 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_LO16, + +/* 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_GPDISP, + +/* 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_LITERAL, + BFD_RELOC_ALPHA_ELF_LITERAL, + BFD_RELOC_ALPHA_LITUSE, + +/* 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_HINT, + +/* The LINKAGE relocation outputs a linkage pair in the object file, +which is filled by the linker. */ + BFD_RELOC_ALPHA_LINKAGE, + +/* The CODEADDR relocation outputs a STO_CA in the object file, +which is filled by the linker. */ + BFD_RELOC_ALPHA_CODEADDR, + +/* Bits 27..2 of the relocation address shifted right 2 bits; +simple reloc otherwise. */ + BFD_RELOC_MIPS_JMP, + +/* The MIPS16 jump instruction. */ + BFD_RELOC_MIPS16_JMP, + +/* MIPS16 GP relative reloc. */ + BFD_RELOC_MIPS16_GPREL, + +/* High 16 bits of 32-bit value; simple reloc. */ + BFD_RELOC_HI16, + +/* 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_HI16_S, + +/* Low 16 bits. */ + BFD_RELOC_LO16, + +/* Like BFD_RELOC_HI16_S, but PC relative. */ + BFD_RELOC_PCREL_HI16_S, + +/* Like BFD_RELOC_LO16, but PC relative. */ + BFD_RELOC_PCREL_LO16, + +/* Relocation relative to the global pointer. */ +#define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16 + +/* Relocation against a MIPS literal section. */ + BFD_RELOC_MIPS_LITERAL, + +/* MIPS ELF relocations. */ + BFD_RELOC_MIPS_GOT16, + BFD_RELOC_MIPS_CALL16, +#define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32 + BFD_RELOC_MIPS_GOT_HI16, + BFD_RELOC_MIPS_GOT_LO16, + BFD_RELOC_MIPS_CALL_HI16, + BFD_RELOC_MIPS_CALL_LO16, + + +/* i386/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, + +/* ns32k 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, + +/* Power(rs6000) and PowerPC relocations. */ + 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, + +/* 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_CTOR, + +/* ARM 26 bit pc-relative branch. The lowest two bits must be zero and are +not stored in the instruction. */ + BFD_RELOC_ARM_PCREL_BRANCH, + +/* These relocs are only used within the ARM assembler. They are not +(at present) written to any object files. */ + BFD_RELOC_ARM_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, + +/* Hitachi SH relocs. Not all of these appear in 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, + +/* Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must +be zero and is not stored in the instruction. */ + BFD_RELOC_THUMB_PCREL_BRANCH9, + BFD_RELOC_THUMB_PCREL_BRANCH12, + BFD_RELOC_THUMB_PCREL_BRANCH23, + +/* 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_B22_PCREL, + +/* 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_ARC_B26, + +/* Mitsubishi D10V relocs. +This is a 10-bit reloc with the right 2 bits +assumed to be 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. This is the same as the previous reloc +except it is in the left container, i.e., +shifted left 15 bits. */ + BFD_RELOC_D10V_10_PCREL_L, + +/* This is an 18-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_18, + +/* This is an 18-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_18_PCREL, + + + +/* Mitsubishi M32R relocs. +This is a 24 bit absolute address. */ + BFD_RELOC_M32R_24, + +/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_10_PCREL, + +/* This is an 18-bit reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_18_PCREL, + +/* This is a 26-bit reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_26_PCREL, + +/* 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_ULO, + +/* 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_HI16_SLO, + +/* This is a 16-bit reloc containing the lower 16 bits of an address. */ + BFD_RELOC_M32R_LO16, + +/* This is a 16-bit reloc containing the small data area offset for use in +add3, load, and store instructions. */ + BFD_RELOC_M32R_SDA16, + +/* This is a 9-bit reloc */ + BFD_RELOC_V850_9_PCREL, + +/* This is a 22-bit reloc */ + BFD_RELOC_V850_22_PCREL, + +/* This is a 16 bit offset from the short data area pointer. */ + BFD_RELOC_V850_SDA_16_16_OFFSET, + +/* This is a 16 bit offset (of which only 15 bits are used) from the +short data area pointer. */ + BFD_RELOC_V850_SDA_15_16_OFFSET, + +/* This is a 16 bit offset from the zero data area pointer. */ + BFD_RELOC_V850_ZDA_16_16_OFFSET, + +/* This is a 16 bit offset (of which only 15 bits are used) from the +zero data area pointer. */ + BFD_RELOC_V850_ZDA_15_16_OFFSET, + +/* This is an 8 bit offset (of which only 6 bits are used) from the +tiny data area pointer. */ + BFD_RELOC_V850_TDA_6_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_8_OFFSET, + +/* This is a 7 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_7_7_OFFSET, + +/* This is a 16 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_16_16_OFFSET, + + +/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. */ + BFD_RELOC_MN10300_32_PCREL, + +/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. */ + BFD_RELOC_MN10300_16_PCREL, + +/* 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_TIC30_LDP, + BFD_RELOC_UNUSED }; +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; +reloc_howto_type * + +bfd_reloc_type_lookup PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); + +const char * +bfd_get_reloc_code_name PARAMS ((bfd_reloc_code_real_type code)); + + +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; <> in <>. The value + is the offset into the section of the data. */ +#define BSF_LOCAL 0x01 + + /* The symbol has global scope; initialized data in <>. 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: + <>, <>, <> or + <> */ + + /* The symbol is a debugging record. The value has an arbitary + meaning. */ +#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 <> symbol + which is also <> 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 + + 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; +#define bfd_get_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) +boolean +bfd_is_local_label PARAMS ((bfd *abfd, asymbol *sym)); + +boolean +bfd_is_local_label_name PARAMS ((bfd *abfd, const char *name)); + +#define bfd_is_local_label_name(abfd, name) \ + BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) +#define bfd_canonicalize_symtab(abfd, location) \ + BFD_SEND (abfd, _bfd_canonicalize_symtab,\ + (abfd, location)) +boolean +bfd_set_symtab PARAMS ((bfd *abfd, asymbol **location, unsigned int count)); + +void +bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol)); + +#define bfd_make_empty_symbol(abfd) \ + BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) +#define bfd_make_debug_symbol(abfd,ptr,size) \ + BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) +int +bfd_decode_symclass PARAMS ((asymbol *symbol)); + +void +bfd_symbol_info PARAMS ((asymbol *symbol, symbol_info *ret)); + +boolean +bfd_copy_private_symbol_data PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym)); + +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ + BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ + (ibfd, isymbol, obfd, osymbol)) +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 `<>', 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 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; +}; + +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_error_type +bfd_get_error PARAMS ((void)); + +void +bfd_set_error PARAMS ((bfd_error_type error_tag)); + +CONST char * +bfd_errmsg PARAMS ((bfd_error_type error_tag)); + +void +bfd_perror PARAMS ((CONST char *message)); + +typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...)); + +bfd_error_handler_type +bfd_set_error_handler PARAMS ((bfd_error_handler_type)); + +void +bfd_set_error_program_name PARAMS ((const char *)); + +bfd_error_handler_type +bfd_get_error_handler PARAMS ((void)); + +long +bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect)); + +long +bfd_canonicalize_reloc + PARAMS ((bfd *abfd, + asection *sec, + arelent **loc, + asymbol **syms)); + +void +bfd_set_reloc + PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count) + + ); + +boolean +bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags)); + +boolean +bfd_set_start_address PARAMS ((bfd *abfd, bfd_vma vma)); + +long +bfd_get_mtime PARAMS ((bfd *abfd)); + +long +bfd_get_size PARAMS ((bfd *abfd)); + +int +bfd_get_gp_size PARAMS ((bfd *abfd)); + +void +bfd_set_gp_size PARAMS ((bfd *abfd, int i)); + +bfd_vma +bfd_scan_vma PARAMS ((CONST char *string, CONST char **end, int base)); + +boolean +bfd_copy_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd)); + +#define bfd_copy_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ + (ibfd, obfd)) +boolean +bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd)); + +#define bfd_merge_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ + (ibfd, obfd)) +boolean +bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags)); + +#define bfd_set_private_flags(abfd, flags) \ + BFD_SEND (abfd, _bfd_set_private_flags, \ + (abfd, flags)) +#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_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 **)); + +symindex +bfd_get_next_mapent PARAMS ((bfd *abfd, symindex previous, carsym **sym)); + +boolean +bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head)); + +bfd * +bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous)); + +CONST char * +bfd_core_file_failing_command PARAMS ((bfd *abfd)); + +int +bfd_core_file_failing_signal PARAMS ((bfd *abfd)); + +boolean +core_file_matches_executable_p + PARAMS ((bfd *core_bfd, bfd *exec_bfd)); + +#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 +#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 +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_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 +{ + char *name; + enum bfd_flavour flavour; + enum bfd_endian byteorder; + enum bfd_endian header_byteorder; + flagword object_flags; + flagword section_flags; + char symbol_leading_char; + char ar_pad_char; + unsigned short ar_max_namelen; + 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 *)); + 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 *)); + const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *)); + boolean (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *)); + boolean (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *)); + + /* 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) + 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 *)); + + /* 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 **)); + + PTR backend_data; +} bfd_target; +boolean +bfd_set_default_target PARAMS ((const char *name)); + +const bfd_target * +bfd_find_target PARAMS ((CONST char *target_name, bfd *abfd)); + +const char ** +bfd_target_list PARAMS ((void)); + +boolean +bfd_check_format PARAMS ((bfd *abfd, bfd_format format)); + +boolean +bfd_check_format_matches PARAMS ((bfd *abfd, bfd_format format, char ***matching)); + +boolean +bfd_set_format PARAMS ((bfd *abfd, bfd_format format)); + +CONST char * +bfd_format_string PARAMS ((bfd_format format)); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/oldbinutils/include/bfdlink.h b/oldbinutils/include/bfdlink.h new file mode 100644 index 0000000000..f4acf2f491 --- /dev/null +++ b/oldbinutils/include/bfdlink.h @@ -0,0 +1,507 @@ +/* bfdlink.h -- header file for BFD link routines + Copyright 1993, 94, 95, 96, 1997 Free Software Foundation, Inc. + Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support. + +This file is part of BFD, the Binary File Descriptor library. + +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. */ + +#ifndef BFDLINK_H +#define BFDLINK_H + +/* Which symbols to strip during a link. */ +enum bfd_link_strip +{ + strip_none, /* Don't strip any symbols. */ + strip_debugger, /* Strip debugging symbols. */ + strip_some, /* keep_hash is the list of symbols to keep. */ + strip_all /* Strip all symbols. */ +}; + +/* Which local symbols to discard during a link. This is irrelevant + if strip_all is used. */ +enum bfd_link_discard +{ + discard_none, /* Don't discard any locals. */ + discard_l, /* Discard local temporary symbols. */ + discard_all /* Discard all locals. */ +}; + +/* These are the possible types of an entry in the BFD link hash + table. */ + +enum bfd_link_hash_type +{ + bfd_link_hash_new, /* Symbol is new. */ + bfd_link_hash_undefined, /* Symbol seen before, but undefined. */ + bfd_link_hash_undefweak, /* Symbol is weak and undefined. */ + bfd_link_hash_defined, /* Symbol is defined. */ + bfd_link_hash_defweak, /* Symbol is weak and defined. */ + bfd_link_hash_common, /* Symbol is common. */ + bfd_link_hash_indirect, /* Symbol is an indirect link. */ + bfd_link_hash_warning /* Like indirect, but warn if referenced. */ +}; + +/* The linking routines use a hash table which uses this structure for + its elements. */ + +struct bfd_link_hash_entry +{ + /* Base hash table entry structure. */ + struct bfd_hash_entry root; + /* Type of this entry. */ + enum bfd_link_hash_type type; + + /* Undefined and common symbols are kept in a linked list through + this field. This field is not in the union because that would + force us to remove entries from the list when we changed their + type, which would force the list to be doubly linked, which would + waste more memory. When an undefined or common symbol is + created, it should be added to this list, the head of which is in + the link hash table itself. As symbols are defined, they need + not be removed from the list; anything which reads the list must + doublecheck the symbol type. + + Weak symbols are not kept on this list. + + Defined and defweak symbols use this field as a reference marker. + If the field is not NULL, or this structure is the tail of the + undefined symbol list, the symbol has been referenced. If the + symbol is undefined and becomes defined, this field will + automatically be non-NULL since the symbol will have been on the + undefined symbol list. */ + struct bfd_link_hash_entry *next; + /* A union of information depending upon the type. */ + union + { + /* Nothing is kept for bfd_hash_new. */ + /* bfd_link_hash_undefined, bfd_link_hash_undefweak. */ + struct + { + bfd *abfd; /* BFD symbol was found in. */ + } undef; + /* bfd_link_hash_defined, bfd_link_hash_defweak. */ + struct + { + bfd_vma value; /* Symbol value. */ + asection *section; /* Symbol section. */ + } def; + /* bfd_link_hash_indirect, bfd_link_hash_warning. */ + struct + { + struct bfd_link_hash_entry *link; /* Real symbol. */ + const char *warning; /* Warning (bfd_link_hash_warning only). */ + } i; + /* bfd_link_hash_common. */ + struct + { + /* The linker needs to know three things about common + symbols: the size, the alignment, and the section in + which the symbol should be placed. We store the size + here, and we allocate a small structure to hold the + section and the alignment. The alignment is stored as a + power of two. We don't store all the information + directly because we don't want to increase the size of + the union; this structure is a major space user in the + linker. */ + bfd_size_type size; /* Common symbol size. */ + struct bfd_link_hash_common_entry + { + unsigned int alignment_power; /* Alignment. */ + asection *section; /* Symbol section. */ + } *p; + } c; + } u; +}; + +/* This is the link hash table. It is a derived class of + bfd_hash_table. */ + +struct bfd_link_hash_table +{ + /* The hash table itself. */ + struct bfd_hash_table table; + /* The back end which created this hash table. This indicates the + type of the entries in the hash table, which is sometimes + important information when linking object files of different + types together. */ + const bfd_target *creator; + /* A linked list of undefined and common symbols, linked through the + next field in the bfd_link_hash_entry structure. */ + struct bfd_link_hash_entry *undefs; + /* Entries are added to the tail of the undefs list. */ + struct bfd_link_hash_entry *undefs_tail; +}; + +/* Look up an entry in a link hash table. If FOLLOW is true, this + follows bfd_link_hash_indirect and bfd_link_hash_warning links to + the real symbol. */ +extern struct bfd_link_hash_entry *bfd_link_hash_lookup + PARAMS ((struct bfd_link_hash_table *, const char *, boolean create, + boolean copy, boolean follow)); + +/* Look up an entry in the main linker hash table if the symbol might + be wrapped. This should only be used for references to an + undefined symbol, not for definitions of a symbol. */ + +extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup + PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean, boolean, + boolean)); + +/* Traverse a link hash table. */ +extern void bfd_link_hash_traverse + PARAMS ((struct bfd_link_hash_table *, + boolean (*) (struct bfd_link_hash_entry *, PTR), + PTR)); + +/* Add an entry to the undefs list. */ +extern void bfd_link_add_undef + PARAMS ((struct bfd_link_hash_table *, struct bfd_link_hash_entry *)); + +/* This structure holds all the information needed to communicate + between BFD and the linker when doing a link. */ + +struct bfd_link_info +{ + /* Function callbacks. */ + const struct bfd_link_callbacks *callbacks; + /* true if BFD should generate a relocateable object file. */ + boolean relocateable; + /* true if BFD should generate a "task linked" object file, + similar to relocatable but also with globals converted to statics. */ + boolean task_link; + /* true if BFD should generate a shared object. */ + boolean shared; + /* true if BFD should pre-bind symbols in a shared object. */ + boolean symbolic; + /* true if shared objects should be linked directly, not shared. */ + boolean static_link; + /* true if the output file should be in a traditional format. This + is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag + on the output file, but may be checked when reading the input + files. */ + boolean traditional_format; + /* Which symbols to strip. */ + enum bfd_link_strip strip; + /* Which local symbols to discard. */ + enum bfd_link_discard discard; + /* true if symbols should be retained in memory, false if they + should be freed and reread. */ + boolean keep_memory; + /* The list of input BFD's involved in the link. These are chained + together via the link_next field. */ + bfd *input_bfds; + /* If a symbol should be created for each input BFD, this is section + where those symbols should be placed. It must be a section in + the output BFD. It may be NULL, in which case no such symbols + will be created. This is to support CREATE_OBJECT_SYMBOLS in the + linker command language. */ + asection *create_object_symbols_section; + /* Hash table handled by BFD. */ + struct bfd_link_hash_table *hash; + /* Hash table of symbols to keep. This is NULL unless strip is + strip_some. */ + struct bfd_hash_table *keep_hash; + /* true if every symbol should be reported back via the notice + callback. */ + boolean notice_all; + /* Hash table of symbols to report back via the notice callback. If + this is NULL, and notice_all is false, then no symbols are + reported back. */ + struct bfd_hash_table *notice_hash; + /* Hash table of symbols which are being wrapped (the --wrap linker + option). If this is NULL, no symbols are being wrapped. */ + struct bfd_hash_table *wrap_hash; + /* If a base output file is wanted, then this points to it */ + PTR base_file; +}; + +/* This structures holds a set of callback functions. These are + called by the BFD linker routines. The first argument to each + callback function is the bfd_link_info structure being used. Each + function returns a boolean value. If the function returns false, + then the BFD function which called it will return with a failure + indication. */ + +struct bfd_link_callbacks +{ + /* A function which is called when an object is added from an + archive. ABFD is the archive element being added. NAME is the + name of the symbol which caused the archive element to be pulled + in. */ + boolean (*add_archive_element) PARAMS ((struct bfd_link_info *, + bfd *abfd, + const char *name)); + /* A function which is called when a symbol is found with multiple + definitions. NAME is the symbol which is defined multiple times. + OBFD is the old BFD, OSEC is the old section, OVAL is the old + value, NBFD is the new BFD, NSEC is the new section, and NVAL is + the new value. OBFD may be NULL. OSEC and NSEC may be + bfd_com_section or bfd_ind_section. */ + boolean (*multiple_definition) PARAMS ((struct bfd_link_info *, + const char *name, + bfd *obfd, + asection *osec, + bfd_vma oval, + bfd *nbfd, + asection *nsec, + bfd_vma nval)); + /* A function which is called when a common symbol is defined + multiple times. NAME is the symbol appearing multiple times. + OBFD is the BFD of the existing symbol; it may be NULL if this is + not known. OTYPE is the type of the existing symbol, which may + be bfd_link_hash_defined, bfd_link_hash_defweak, + bfd_link_hash_common, or bfd_link_hash_indirect. If OTYPE is + bfd_link_hash_common, OSIZE is the size of the existing symbol. + NBFD is the BFD of the new symbol. NTYPE is the type of the new + symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or + bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE + is the size of the new symbol. */ + boolean (*multiple_common) PARAMS ((struct bfd_link_info *, + const char *name, + bfd *obfd, + enum bfd_link_hash_type otype, + bfd_vma osize, + bfd *nbfd, + enum bfd_link_hash_type ntype, + bfd_vma nsize)); + /* A function which is called to add a symbol to a set. ENTRY is + the link hash table entry for the set itself (e.g., + __CTOR_LIST__). RELOC is the relocation to use for an entry in + the set when generating a relocateable file, and is also used to + get the size of the entry when generating an executable file. + ABFD, SEC and VALUE identify the value to add to the set. */ + boolean (*add_to_set) PARAMS ((struct bfd_link_info *, + struct bfd_link_hash_entry *entry, + bfd_reloc_code_real_type reloc, + bfd *abfd, asection *sec, bfd_vma value)); + /* A function which is called when the name of a g++ constructor or + destructor is found. This is only called by some object file + formats. CONSTRUCTOR is true for a constructor, false for a + destructor. This will use BFD_RELOC_CTOR when generating a + relocateable file. NAME is the name of the symbol found. ABFD, + SECTION and VALUE are the value of the symbol. */ + boolean (*constructor) PARAMS ((struct bfd_link_info *, + boolean constructor, + const char *name, bfd *abfd, asection *sec, + bfd_vma value)); + /* A function which is called to issue a linker warning. For + example, this is called when there is a reference to a warning + symbol. WARNING is the warning to be issued. SYMBOL is the name + of the symbol which triggered the warning; it may be NULL if + there is none. ABFD, SECTION and ADDRESS identify the location + which trigerred the warning; either ABFD or SECTION or both may + be NULL if the location is not known. */ + boolean (*warning) PARAMS ((struct bfd_link_info *, + const char *warning, const char *symbol, + bfd *abfd, asection *section, + bfd_vma address)); + /* A function which is called when a relocation is attempted against + an undefined symbol. NAME is the symbol which is undefined. + ABFD, SECTION and ADDRESS identify the location from which the + reference is made. In some cases SECTION may be NULL. */ + boolean (*undefined_symbol) PARAMS ((struct bfd_link_info *, + const char *name, bfd *abfd, + asection *section, bfd_vma address)); + /* A function which is called when a reloc overflow occurs. NAME is + the name of the symbol or section the reloc is against, + RELOC_NAME is the name of the relocation, and ADDEND is any + addend that is used. ABFD, SECTION and ADDRESS identify the + location at which the overflow occurs; if this is the result of a + bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then + ABFD will be NULL. */ + boolean (*reloc_overflow) PARAMS ((struct bfd_link_info *, + const char *name, + const char *reloc_name, bfd_vma addend, + bfd *abfd, asection *section, + bfd_vma address)); + /* A function which is called when a dangerous reloc is performed. + The canonical example is an a29k IHCONST reloc which does not + follow an IHIHALF reloc. MESSAGE is an appropriate message. + ABFD, SECTION and ADDRESS identify the location at which the + problem occurred; if this is the result of a + bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then + ABFD will be NULL. */ + boolean (*reloc_dangerous) PARAMS ((struct bfd_link_info *, + const char *message, + bfd *abfd, asection *section, + bfd_vma address)); + /* A function which is called when a reloc is found to be attached + to a symbol which is not being written out. NAME is the name of + the symbol. ABFD, SECTION and ADDRESS identify the location of + the reloc; if this is the result of a + bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then + ABFD will be NULL. */ + boolean (*unattached_reloc) PARAMS ((struct bfd_link_info *, + const char *name, + bfd *abfd, asection *section, + bfd_vma address)); + /* A function which is called when a symbol in notice_hash is + defined or referenced. NAME is the symbol. ABFD, SECTION and + ADDRESS are the value of the symbol. If SECTION is + bfd_und_section, this is a reference. */ + boolean (*notice) PARAMS ((struct bfd_link_info *, const char *name, + bfd *abfd, asection *section, bfd_vma address)); +}; + +/* The linker builds link_order structures which tell the code how to + include input data in the output file. */ + +/* These are the types of link_order structures. */ + +enum bfd_link_order_type +{ + bfd_undefined_link_order, /* Undefined. */ + bfd_indirect_link_order, /* Built from a section. */ + bfd_fill_link_order, /* Fill with a 16 bit constant. */ + bfd_data_link_order, /* Set to explicit data. */ + bfd_section_reloc_link_order, /* Relocate against a section. */ + bfd_symbol_reloc_link_order /* Relocate against a symbol. */ +}; + +/* This is the link_order structure itself. These form a chain + attached to the section whose contents they are describing. */ + +struct bfd_link_order +{ + /* Next link_order in chain. */ + struct bfd_link_order *next; + /* Type of link_order. */ + enum bfd_link_order_type type; + /* Offset within output section. */ + bfd_vma offset; + /* Size within output section. */ + bfd_size_type size; + /* Type specific information. */ + union + { + struct + { + /* Section to include. If this is used, then + section->output_section must be the section the + link_order is attached to, section->output_offset must + equal the link_order offset field, and section->_raw_size + must equal the link_order size field. Maybe these + restrictions should be relaxed someday. */ + asection *section; + } indirect; + struct + { + /* Value to fill with. */ + unsigned int value; + } fill; + struct + { + /* Data to put into file. The size field gives the number + of bytes which this field points to. */ + bfd_byte *contents; + } data; + struct + { + /* Description of reloc to generate. Used for + bfd_section_reloc_link_order and + bfd_symbol_reloc_link_order. */ + struct bfd_link_order_reloc *p; + } reloc; + } u; +}; + +/* A linker order of type bfd_section_reloc_link_order or + bfd_symbol_reloc_link_order means to create a reloc against a + section or symbol, respectively. This is used to implement -Ur to + generate relocs for the constructor tables. The + bfd_link_order_reloc structure describes the reloc that BFD should + create. It is similar to a arelent, but I didn't use arelent + because the linker does not know anything about most symbols, and + any asymbol structure it creates will be partially meaningless. + This information could logically be in the bfd_link_order struct, + but I didn't want to waste the space since these types of relocs + are relatively rare. */ + +struct bfd_link_order_reloc +{ + /* Reloc type. */ + bfd_reloc_code_real_type reloc; + + union + { + /* For type bfd_section_reloc_link_order, this is the section + the reloc should be against. This must be a section in the + output BFD, not any of the input BFDs. */ + asection *section; + /* For type bfd_symbol_reloc_link_order, this is the name of the + symbol the reloc should be against. */ + const char *name; + } u; + + /* Addend to use. The object file should contain zero. The BFD + backend is responsible for filling in the contents of the object + file correctly. For some object file formats (e.g., COFF) the + addend must be stored into in the object file, and for some + (e.g., SPARC a.out) it is kept in the reloc. */ + bfd_vma addend; +}; + +/* Allocate a new link_order for a section. */ +extern struct bfd_link_order *bfd_new_link_order PARAMS ((bfd *, asection *)); + +/* These structures are used to describe version information for the + ELF linker. These structures could be manipulated entirely inside + BFD, but it would be a pain. Instead, the regular linker sets up + these structures, and then passes them into BFD. */ + +/* Regular expressions for a version. */ + +struct bfd_elf_version_expr +{ + /* Next regular expression for this version. */ + struct bfd_elf_version_expr *next; + /* Regular expression. */ + const char *match; +}; + +/* Version dependencies. */ + +struct bfd_elf_version_deps +{ + /* Next dependency for this version. */ + struct bfd_elf_version_deps *next; + /* The version which this version depends upon. */ + struct bfd_elf_version_tree *version_needed; +}; + +/* A node in the version tree. */ + +struct bfd_elf_version_tree +{ + /* Next version. */ + struct bfd_elf_version_tree *next; + /* Name of this version. */ + const char *name; + /* Version number. */ + unsigned int vernum; + /* Regular expressions for global symbols in this version. */ + struct bfd_elf_version_expr *globals; + /* Regular expressions for local symbols in this version. */ + struct bfd_elf_version_expr *locals; + /* List of versions which this version depends upon. */ + struct bfd_elf_version_deps *deps; + /* Index of the version name. This is used within BFD. */ + unsigned int name_indx; + /* Whether this version tree was used. This is used within BFD. */ + int used; +}; + +#endif diff --git a/oldbinutils/lib/libbfd.a b/oldbinutils/lib/libbfd.a new file mode 100644 index 0000000000..05cfc78248 Binary files /dev/null and b/oldbinutils/lib/libbfd.a differ diff --git a/oldbinutils/lib/libbfd.la b/oldbinutils/lib/libbfd.la new file mode 100644 index 0000000000..76f5db776b --- /dev/null +++ b/oldbinutils/lib/libbfd.la @@ -0,0 +1,22 @@ +# libbfd.la - a libtool library file +# Generated by ltmain.sh - GNU libtool 1.2 + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libbfd.a' + +# Libraries that this one depends upon. +dependency_libs='' + +# Version information for libbfd. +current=0 +age=0 +revision=0 + +# Directory that this library needs to be installed in: +libdir='/opt/cross/lib' diff --git a/oldbinutils/lib/libiberty.a b/oldbinutils/lib/libiberty.a new file mode 100644 index 0000000000..f8f85f4866 Binary files /dev/null and b/oldbinutils/lib/libiberty.a differ diff --git a/oldbinutils/lib/libopcodes.a b/oldbinutils/lib/libopcodes.a new file mode 100644 index 0000000000..74a88f4eb6 Binary files /dev/null and b/oldbinutils/lib/libopcodes.a differ diff --git a/oldbinutils/lib/libopcodes.la b/oldbinutils/lib/libopcodes.la new file mode 100644 index 0000000000..a645c77521 --- /dev/null +++ b/oldbinutils/lib/libopcodes.la @@ -0,0 +1,22 @@ +# libopcodes.la - a libtool library file +# Generated by ltmain.sh - GNU libtool 1.2 + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libopcodes.a' + +# Libraries that this one depends upon. +dependency_libs='' + +# Version information for libopcodes. +current=0 +age=0 +revision=0 + +# Directory that this library needs to be installed in: +libdir='/opt/cross/lib' diff --git a/oldbinutils/man/man1/mips-addr2line.1 b/oldbinutils/man/man1/mips-addr2line.1 new file mode 100644 index 0000000000..87ce103f8e --- /dev/null +++ b/oldbinutils/man/man1/mips-addr2line.1 @@ -0,0 +1,127 @@ +.\" Copyright (c) 1997 Free Software Foundation +.\" See COPYING for conditions for redistribution +.TH addr2line 1 "27 March 1997" "Cygnus Solutions" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +addr2line \- convert addresses into file names and line numbers + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B addr2line +.RB "[\|" "\-b\ "\c +.I bfdname\c +.RB " | " "\-\-target="\c +.I bfdname\c +\&\|] +.RB "[\|" \-C | \-\-demangle "\|]" +.RB "[\|" "\-e\ "\c +.I filename\c +.RB " | " "\-\-exe="\c +.I filename\c +\&\|] +.RB "[\|" \-f | \-\-functions "\|]" +.RB "[\|" \-s | \-\-basenames "\|]" +.RB "[\|" \-H | \-\-help "\|]" +.RB "[\|" \-V | \-\-version "\|]" +.RB "[\|" addr addr ... "\|]" +.ad b +.hy 1 +.SH DESCRIPTION +\c +.B 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 +.B \-e +option. The default is +.B a.out\c +\&. + +.B addr2line +has two modes of operation. + +In the first, hexadecimal addresses are specified on the command line, +and +.B addr2line +displays the file name and line number for each address. + +In the second, +.B addr2line +reads hexadecimal addresses from standard input, and prints the file +name and line number for each address on standard output. In this +mode, +.B 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 +.B \-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, +.B addr2line +will print two question marks in their place. If the line number can +not be determined, +.B addr2line +will print 0. + +.SH OPTIONS +.TP +.BI "\-b " "bfdname"\c +.TP +.BI "\-\-target=" "bfdname" +Specify the object-code format for the object files to be +\c +.I bfdname\c +\&. + +.TP +.B \-C +.TP +.B \-\-demangle +Decode (\fIdemangle\fP) low-level symbol names into user-level names. +Besides removing any initial underscore prepended by the system, this +makes C++ function names readable. + +.TP +.BI "\-e " "filename"\c +.TP +.BI "\-\-exe=" "filename" +Specify the name of the executable for which addresses should be +translated. The default file is +.B a.out\c +\&. + +.TP +.B \-f +.TP +.B \-\-functions +Display function names as well as file and line number information. + +.TP +.B \-s +.TP +.B \-\-basenames +Display only the base of each file name. + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (October 1991). diff --git a/oldbinutils/man/man1/mips-ar.1 b/oldbinutils/man/man1/mips-ar.1 new file mode 100644 index 0000000000..e4e8cff813 --- /dev/null +++ b/oldbinutils/man/man1/mips-ar.1 @@ -0,0 +1,509 @@ +.\" Copyright (c) 1991 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH ar 1 "5 November 1991" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +ar \- create, modify, and extract from archives. + +.SH SYNOPSIS +.hy 0 +.na +.BR ar " [\|" "-" "\|]"\c +.I {dmpqrtx}[abcilosSuvV] \c +[\|\c +.I membername\c +\&\|] \c +.I archive\c +\& \c +.I files\c +\&.\|.\|. + +.ad b +.hy 1 +.SH DESCRIPTION +The GNU \c +.B ar\c +\& program creates, modifies, and extracts from +archives. An \c +.I archive\c +\& is a single file holding a collection of +other files in a structure that makes it possible to retrieve +the original individual files (called \c +.I members\c +\& of the archive). + +The original files' contents, mode (permissions), timestamp, owner, and +group are preserved in the archive, and may be reconstituted on +extraction. + +GNU \c +.B ar\c +\& can maintain archives whose members have names of any +length; however, depending on how \c +.B ar\c +\& 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). + +\c +.B ar\c +\& is considered a binary utility because archives of this sort +are most often used as \c +.I libraries\c +\& holding commonly needed +subroutines. + +\c +.B ar\c +\& will create an index to the symbols defined in relocatable +object modules in the archive when you specify the modifier `\|\c +.B s\c +\|'. +Once created, this index is updated in the archive whenever \c +.B ar\c +\& +makes a change to its contents (save for the `\|\c +.B q\c +\|' 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 `\|\c +.B nm \-s\c +\|' or `\|\c +.B nm \-\-print\-armap\c +\|' to list this index +table. If an archive lacks the table, another form of \c +.B ar\c +\& called +\c +.B ranlib\c +\& can be used to add just the table. + +\c +.B ar\c +\& insists on at least two arguments to execute: one +keyletter specifying the \c +.I operation\c +\& (optionally accompanied by other +keyletters specifying \c +.I modifiers\c +\&), and the archive name to act on. + +Most operations can also accept further \c +.I files\c +\& arguments, +specifying particular files to operate on. + +.SH OPTIONS +GNU \c +.B ar\c +\& allows you to mix the operation code \c +.I p\c +\& and modifier +flags \c +.I mod\c +\& in any order, within the first command-line argument. + +If you wish, you may begin the first command-line argument with a +dash. + +The \c +.I p\c +\& keyletter specifies what operation to execute; it may be +any of the following, but you must specify only one of them: + +.TP +.B d +\c +.I Delete\c +\& modules from the archive. Specify the names of modules to +be deleted as \c +.I files\c +\&; the archive is untouched if you +specify no files to delete. + +If you specify the `\|\c +.B v\c +\|' modifier, \c +.B ar\c +\& will list each module +as it is deleted. + +.TP +.B m +Use this operation to \c +.I move\c +\& 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 \c +.B m\c +\&, any members you name in the +\c +.I files\c +\& arguments are moved to the \c +.I end\c +\& of the archive; +you can use the `\|\c +.B a\c +\|', `\|\c +.B b\c +\|', or `\|\c +.B i\c +\|' modifiers to move them to a +specified place instead. + +.TP +.B p +\c +.I Print\c +\& the specified members of the archive, to the standard +output file. If the `\|\c +.B v\c +\|' modifier is specified, show the member +name before copying its contents to standard output. + +If you specify no \c +.I files\c +\&, all the files in the archive are printed. + +.TP +.B q +\c +.I Quick append\c +\&; add \c +.I files\c +\& to the end of \c +.I archive\c +\&, +without checking for replacement. + +The modifiers `\|\c +.B a\c +\|', `\|\c +.B b\c +\|', and `\|\c +.B i\c +\|' do \c +.I not\c +\& affect this +operation; new members are always placed at the end of the archive. + +The modifier `\|\c +.B v\c +\|' makes \c +.B ar\c +\& 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 `\|\c +.B ar s\c +\|' or +\c +.B ranlib\c +\& explicitly to update the symbol table index. + +However, too many different systems assume quick append rebuilds the +index, so GNU +.B ar +implements `\|\c +.B q\c +\|' as a synonym for `\|\c +.B r\c +\|'. + +.TP +.B r +Insert \c +.I files\c +\& into \c +.I archive\c +\& (with \c +.I replacement\c +\&). This +operation differs from `\|\c +.B q\c +\|' in that any previously existing members +are deleted if their names match those being added. + +If one of the files named in \c +.I files\c +\& doesn't exist, \c +.B ar\c +\& +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 `\|\c +.B a\c +\|', `\|\c +.B b\c +\|', or `\|\c +.B i\c +\|' to request +placement relative to some existing member. + +The modifier `\|\c +.B v\c +\|' used with this operation elicits a line of +output for each file inserted, along with one of the letters `\|\c +.B a\c +\|' or +`\|\c +.B r\c +\|' to indicate whether the file was appended (no old member +deleted) or replaced. + +.TP +.B t +Display a \c +.I table\c +\& listing the contents of \c +.I archive\c +\&, or those +of the files listed in \c +.I files\c +\& 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 `\|\c +.B v\c +\|' modifier. + +If you do not specify any \c +.I files\c +\&, all files in the archive +are listed. + +If there is more than one file with the same name (say, `\|\c +.B fie\c +\|') in +an archive (say `\|\c +.B b.a\c +\|'), `\|\c +.B ar t b.a fie\c +\|' will list only the +first instance; to see them all, you must ask for a complete +listing\(em\&in our example, `\|\c +.B ar t b.a\c +\|'. + +.TP +.B x +\c +.I Extract\c +\& members (named \c +.I files\c +\&) from the archive. You can +use the `\|\c +.B v\c +\|' modifier with this operation, to request that +\c +.B ar\c +\& list each name as it extracts it. + +If you do not specify any \c +.I files\c +\&, all files in the archive +are extracted. + +.PP + +A number of modifiers (\c +.I mod\c +\&) may immediately follow the \c +.I p\c +\& +keyletter, to specify variations on an operation's behavior: + +.TP +.B a +Add new files \c +.I after\c +\& an existing member of the +archive. If you use the modifier \c +.B a\c +\&, the name of an existing archive +member must be present as the \c +.I membername\c +\& argument, before the +\c +.I archive\c +\& specification. + +.TP +.B b +Add new files \c +.I before\c +\& an existing member of the +archive. If you use the modifier \c +.B b\c +\&, the name of an existing archive +member must be present as the \c +.I membername\c +\& argument, before the +\c +.I archive\c +\& specification. (same as `\|\c +.B i\c +\|'). + +.TP +.B c +\c +.I Create\c +\& the archive. The specified \c +.I archive\c +\& is always +created if it didn't 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. + +.TP +.B f +Truncate names in the archive. +.B ar +will normally permit file names of any length. This will cause it to +create archives which are not compatible with the native +.B ar +program on some systems. If this is a concern, the +.B f +modifier may be used to truncate file names when putting them in the +archive. + +.TP +.B i +Insert new files \c +.I before\c +\& an existing member of the +archive. If you use the modifier \c +.B i\c +\&, the name of an existing archive +member must be present as the \c +.I membername\c +\& argument, before the +\c +.I archive\c +\& specification. (same as `\|\c +.B b\c +\|'). + +.TP +.B l +This modifier is accepted but not used. + +.TP +.B o +Preserve the \c +.I original\c +\& dates of members when extracting them. If +you do not specify this modifier, files extracted from the archive +will be stamped with the time of extraction. + +.TP +.B 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 `\|\c +.B ar s\c +\|' on an +archive is equivalent to running `\|\c +.B ranlib\c +\|' on it. + +.TP +.B 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 +`\|\c +.B S\c +\|' modifier on the last execution of `\|\c +.B ar\c +\|', or you must run `\|\c +.B ranlib\c +\|' on the archive. + +.TP +.B u +Normally, \c +.B ar r\c +\&.\|.\|. inserts all files +listed into the archive. If you would like to insert \c +.I only\c +\& those +of the files you list that are newer than existing members of the same +names, use this modifier. The `\|\c +.B u\c +\|' modifier is allowed only for the +operation `\|\c +.B r\c +\|' (replace). In particular, the combination `\|\c +.B qu\c +\|' is +not allowed, since checking the timestamps would lose any speed +advantage from the operation `\|\c +.B q\c +\|'. + +.TP +.B v +This modifier requests the \c +.I verbose\c +\& version of an operation. Many +operations display additional information, such as filenames processed, +when the modifier `\|\c +.B v\c +\|' is appended. + +.TP +.B V +This modifier shows the version number of +.BR ar . + +.PP + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +, Roland H. Pesch (October 1991). +.BR nm ( 1 )\c +\&, +.BR ranlib ( 1 )\c +\&. + +.SH COPYING +Copyright (c) 1991 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-as.1 b/oldbinutils/man/man1/mips-as.1 new file mode 100644 index 0000000000..adf28868ea --- /dev/null +++ b/oldbinutils/man/man1/mips-as.1 @@ -0,0 +1,302 @@ +.\" Copyright (c) 1991, 1992, 1996, 1997, 1998 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH as 1 "29 March 1996" "cygnus support" "GNU Development Tools" + +.SH NAME +GNU as \- the portable GNU assembler. + +.SH SYNOPSIS +.na +.B as +.RB "[\|" \-a "[\|" dhlns "\|]" \c +\&\[\|\=\c +.I file\c +\&\|]\|] +.RB "[\|" \-D "\|]" +.RB "[\|" \-\-defsym\ SYM=VAL "\|]" +.RB "[\|" \-f "\|]" +.RB "[\|" \-\-gstabs "\|]" +.RB "[\|" \-I +.I path\c +\&\|] +.RB "[\|" \-K "\|]" +.RB "[\|" \-L "\|]" +.RB "[\|" \-M\ |\ \-\-mri "\|]" +.RB "[\|" \-o +.I objfile\c +\&\|] +.RB "[\|" \-R "\|]" +.RB "[\|" \-\-traditional\-format "\|]" +.RB "[\|" \-v "\|]" +.RB "[\|" \-w "\|]" +.RB "[\|" \-\^\- "\ |\ " \c +.I files\c +\&\|.\|.\|.\|] + +.I i960-only options: +.br +.RB "[\|" \-ACA "\||\|" \-ACA_A "\||\|" \-ACB\c +.RB "\||\|" \-ACC "\||\|" \-AKA "\||\|" \-AKB\c +.RB "\||\|" \-AKC "\||\|" \-AMC "\|]" +.RB "[\|" \-b "\|]" +.RB "[\|" \-no-relax "\|]" + +.I m680x0-only options: +.br +.RB "[\|" \-l "\|]" +.RB "[\|" \-mc68000 "\||\|" \-mc68010 "\||\|" \-mc68020 "\|]" +.ad b + +.SH DESCRIPTION +GNU \c +.B as\c +\& 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 +\c +.I pseudo-ops)\c +\& and assembler syntax. + +For information on the syntax and pseudo-ops used by GNU \c +.B as\c +\&, see `\|\c +.B as\c +\|' entry in \c +.B info \c +(or the manual \c +.I +.I +Using as: The GNU Assembler\c +\&). + +\c +.B as\c +\& is primarily intended to assemble the output of the GNU C +compiler \c +.B gcc\c +\& for use by the linker \c +.B ld\c +\&. Nevertheless, +we've tried to make \c +.B as\c +\& assemble correctly everything that the native +assembler would. +This doesn't mean \c +.B as\c +\& 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. + +Each time you run \c +.B as\c +\& it assembles exactly one source +program. The source program is made up of one or more files. +(The standard input is also a file.) + +If \c +.B as\c +\& is given no file names it attempts to read one input file +from the \c +.B as\c +\& standard input, which is normally your terminal. You +may have to type \c +.B ctl-D\c +\& to tell \c +.B as\c +\& there is no more program +to assemble. Use `\|\c +.B \-\^\-\c +\|' if you need to explicitly name the standard input file +in your command line. + +.B as\c +\& may write warnings and error messages to the standard error +file (usually your terminal). This should not happen when \c +.B as\c +\& is +run automatically by a compiler. Warnings report an assumption made so +that \c +.B as\c +\& could keep assembling a flawed program; errors report a +grave problem that stops the assembly. + +.SH OPTIONS +.TP +.BR \-a +Turn on assembly listings. There are various suboptions. +.B d +omits debugging directives. +.B h +includes the high level source code; this is only available if the +source file can be found, and the code was compiled with +.B \-g. +.B l +includes an assembly listing. +.B n +omits forms processing. +.B s +includes a symbol listing. +.B = +.I file +sets the listing file name; this must be the last suboption. +The default suboptions are +.B hls. +.TP +.B \-D +This option is accepted only for script compatibility with calls to +other assemblers; it has no effect on \c +.B as\c +\&. +.TP +.B \-\-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. +.TP +.B \-f +``fast''--skip preprocessing (assume source is compiler output). +.TP +.BI "\-I\ " path +Add +.I path +to the search list for +.B .include +directives. +.TP +.B \-\-gstabs +Generate stabs debugging information for each assembler line. This +may help debugging assembler code, if the debugger can handle it. +.TP +.B \-K +Issue warnings when difference tables altered for long displacements. +.TP +.B \-L +Keep (in symbol table) local symbols, starting with `\|\c +.B L\c +\|' +.TP +.B \-M, \-\-mri +Assemble in MRI compatibility mode. +.TP +.BI "\-o\ " objfile +Name the object-file output from \c +.B as +.TP +.B \-R +Fold data section into text section +.TP +.B \-\-traditional\-format +Use same format as native assembler, when possible. +.TP +.B \-v +Announce \c +.B as\c +\& version +.TP +.B \-W +Suppress warning messages +.TP +.IR "\-\^\-" "\ |\ " "files\|.\|.\|." +Source files to assemble, or standard input (\c +.BR "\-\^\-" ")" +.TP +.BI \-A var +.I +(When configured for Intel 960.) +Specify which variant of the 960 architecture is the target. +.TP +.B \-b +.I +(When configured for Intel 960.) +Add code to collect statistics about branches taken. +.TP +.B \-no-relax +.I +(When configured for Intel 960.) +Do not alter compare-and-branch instructions for long displacements; +error if necessary. +.TP +.B \-l +.I +(When configured for Motorola 68000). +.br +Shorten references to undefined symbols, to one word instead of two. +.TP +.BR "\-mc68000" "\||\|" "\-mc68010" "\||\|" "\-mc68020" +.I +(When configured for Motorola 68000). +.br +Specify what processor in the 68000 family is the target (default 68020) + +.PP +Options may be in any order, and may be +before, after, or between file names. The order of file names is +significant. + +`\|\c +.B \-\^\-\c +\|' (two hyphens) by itself names the standard input file +explicitly, as one of the files for \c +.B as\c +\& to assemble. + +Except for `\|\c +.B \-\^\-\c +\|' any command line argument that begins with a +hyphen (`\|\c +.B \-\c +\|') is an option. Each option changes the behavior of +\c +.B as\c +\&. No option changes the way another option works. An +option is a `\|\c +.B \-\c +\|' followed by one or more letters; the case of +the letter is important. All options are optional. + +The `\|\c +.B \-o\c +\|' option expects exactly one file name to follow. 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: +.br +.B +as\ \ \-o\ \ my\-object\-file.o\ \ mumble.s +.br +.B +as\ \ \-omy\-object\-file.o\ \ mumble.s + +.SH "SEE ALSO" +.RB "`\|" as "\|'" +entry in +.B +info\c +\&; +.I +Using as: The GNU Assembler\c +\&; +.BR gcc "(" 1 ")," +.BR ld "(" 1 ")." + +.SH COPYING +Copyright (c) 1991, 1992 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-c++filt.1 b/oldbinutils/man/man1/mips-c++filt.1 new file mode 100644 index 0000000000..3132ac9c67 --- /dev/null +++ b/oldbinutils/man/man1/mips-c++filt.1 @@ -0,0 +1,114 @@ +.\" Copyright (c) 1991 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH c++filt 1 "June 1993" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +c++filt \- demangle C++ symbols + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B c++filt +.RB "[\|" \-_ | \-\-strip-underscores "\|]" +.RB "[\|" "\-s {gnu,lucid,arm} " | " \-\-format={gnu,lucid,arm}" "\|]" +.RB "[\|" \-\-help "\|]" +.RB "[\|" \-\-version "\|]" +.RB "[\|" symbol "...\|]" +.SH DESCRIPTION +The C++ language provides function overloading, which means that you can +write many functions with the same name (providing each takes parameters +of different types). All C++ function names are encoded into a +low-level assembly label (this process is known as +.I mangling\c +). The +.B c++filt +program does the inverse mapping: it decodes (\fIdemangles\fR) +low-level names into user-level names so that the linker can keep +these overloaded functions from clashing. +.PP +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. +.PP +You can use +.B c++filt +to decipher individual symbols by specifying these symbols on the +command line. +.PP +If no +.B symbol +arguments are given, +.B 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. +.SH OPTIONS +.TP +.B \-_ +.TP +.B \-\-strip\-underscores +On some systems, both the C and C++ compilers put an +underscore in front of every name. For example, the C name +.B foo +gets the low-level name +.BR _foo . +This option removes the leading underscore. + +.TP +.B "\-s {gnu,lucid,arm}" +.TP +.B \-\-format={gnu,lucid,arm} +GNU +.B nm +can decode three different methods of mangling, used by different C++ +compilers. This option selects which method it uses: the one used by +the GNU compiler, the one used by the Lucid compiler, or the one +specified by the C++ Annotated Reference Manual. The default is the +GNU style. + +.TP +.B \-\-help +Print a summary of the options to +.B c++filt +and exit. + +.TP +.B \-\-version +Print the version number of +.B c++filt +and exit. + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (June 1993). + +.SH COPYING +Copyright (c) 1993 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-ld.1 b/oldbinutils/man/man1/mips-ld.1 new file mode 100644 index 0000000000..79c9f102c0 --- /dev/null +++ b/oldbinutils/man/man1/mips-ld.1 @@ -0,0 +1,1083 @@ +.\" Copyright (c) 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH ld 1 "17 August 1992" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +ld \- the GNU linker + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B ld +.RB "[\|" \-o " +.I output\c +\&\|] \c +.I objfile\c +\&.\|.\|. +.br +.RB "[\|" \-A\c +.I architecture\c +\&\|] +.RB "[\|" "\-b\ "\c +.I input-format\c +\&\|] +.RB "[\|" \-Bstatic "\|]" +.RB "[\|" \-Bdynamic "\|]" +.RB "[\|" \-Bsymbolic "\|]" +.RB "[\|" "\-c\ "\c +.I commandfile\c +\&\|] +.RB "[\|" \-\-cref "\|]" +.RB "[\|" \-d | \-dc | \-dp\c +\|] +.br +.RB "[\|" "\-defsym\ "\c +.I symbol\c +\& = \c +.I expression\c +\&\|] +.RB "[\|" "\-e\ "\c +.I entry\c +\&\|] +.RB "[\|" \-embedded\-relocs "\|]" +.RB "[\|" \-E "\|]" +.RB "[\|" \-export\-dynamic "\|]" +.RB "[\|" "\-f\ "\c +.I name\c +\&\|] +.RB "[\|" "\-\-auxiliary\ "\c +.I name\c +\&\|] +.RB "[\|" "\-F\ "\c +.I name\c +\&\|] +.RB "[\|" "\-\-filter\ "\c +.I name\c +\&\|] +.RB "[\|" "\-format\ "\c +.I input-format\c +\&\|] +.RB "[\|" \-g "\|]" +.RB "[\|" \-G +.I size\c +\&\|] +.RB "[\|" "\-h\ "\c +.I name\c +\&\|] +.RB "[\|" "\-soname\ "\c +.I name\c +\&\|] +.RB "[\|" \-\-help "\|]" +.RB "[\|" \-i "\|]" +.RB "[\|" \-l\c +.I ar\c +\&\|] +.RB "[\|" \-L\c +.I searchdir\c +\&\|] +.RB "[\|" \-M "\|]" +.RB "[\|" \-Map +.I mapfile\c +\&\|] +.RB "[\|" \-m +.I emulation\c +\&\|] +.RB "[\|" \-n | \-N "\|]" +.RB "[\|" \-noinhibit-exec "\|]" +.RB "[\|" \-no\-keep\-memory "\|]" +.RB "[\|" \-no\-warn\-mismatch "\|]" +.RB "[\|" "\-oformat\ "\c +.I output-format\c +\&\|] +.RB "[\|" "\-R\ "\c +.I filename\c +\&\|] +.RB "[\|" \-relax "\|]" +.RB "[\|" \-r | \-Ur "\|]" +.RB "[\|" "\-rpath\ "\c +.I directory\c +\&\|] +.RB "[\|" "\-rpath\-link\ "\c +.I directory\c +\&\|] +.RB "[\|" \-S "\|]" +.RB "[\|" \-s "\|]" +.RB "[\|" \-shared "\|]" +.RB "[\|" \-sort\-common "\|]" +.RB "[\|" "\-split\-by\-reloc\ "\c +.I count\c +\&\|] +.RB "[\|" \-split\-by\-file "\|]" +.RB "[\|" "\-T\ "\c +.I commandfile\c +\&\|] +.RB "[\|" "\-Ttext\ "\c +.I textorg\c +\&\|] +.RB "[\|" "\-Tdata\ "\c +.I dataorg\c +\&\|] +.RB "[\|" "\-Tbss\ "\c +.I bssorg\c +\&\|] +.RB "[\|" \-t "\|]" +.RB "[\|" "\-u\ "\c +.I sym\c +\&] +.RB "[\|" \-V "\|]" +.RB "[\|" \-v "\|]" +.RB "[\|" \-\-verbose "\|]" +.RB "[\|" \-\-version "\|]" +.RB "[\|" \-warn\-common "\|]" +.RB "[\|" \-warn\-constructors "\|]" +.RB "[\|" \-warn\-multiple\-gp "\|]" +.RB "[\|" \-warn\-once "\|]" +.RB "[\|" \-warn\-section\-align "\|]" +.RB "[\|" \-\-whole\-archive "\|]" +.RB "[\|" \-\-no\-whole\-archive "\|]" +.RB "[\|" "\-\-wrap\ "\c +.I symbol\c +\&\|] +.RB "[\|" \-X "\|]" +.RB "[\|" \-x "\|]" +.ad b +.hy 1 +.SH DESCRIPTION +\c +.B ld\c +\& combines a number of object and archive files, relocates +their data and ties up symbol references. Often the last step in +building a new compiled program to run is a call to \c +.B ld\c +\&. + +\c +.B ld\c +\& accepts Linker Command Language files +to provide explicit and total control over the linking process. +This man page does not describe the command language; see the `\|\c +.B ld\c +\|' entry in `\|\c +.B info\c +\|', or the manual +.I +ld: the GNU linker +\&, for full details on the command language and on other aspects of +the GNU linker. + +This version of \c +.B ld\c +\& uses the general purpose BFD libraries +to operate on object files. This allows \c +.B ld\c +\& to read, combine, and +write object files in many different formats\(em\&for example, COFF or +\c +.B a.out\c +\&. Different formats may be linked together to produce any +available kind of object file. You can use `\|\c +.B objdump \-i\c +\|' to get a list of formats supported on various architectures; see +.BR objdump ( 1 ). + +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, +\c +.B ld\c +\& continues executing, allowing you to identify other errors +(or, in some cases, to get an output file in spite of the error). + +The GNU linker \c +.B ld\c +\& 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 through the command line, +and through environment variables. + +.SH OPTIONS +The plethora of command-line options may seem intimidating, but in +actual practice few of them are used in any particular context. +For instance, a frequent use of \c +.B ld\c +\& is to link standard Unix +object files on a standard, supported Unix system. On such a system, to +link a file \c +.B hello.o\c +\&: +.sp +.br +$\ ld\ \-o\ output\ /lib/crt0.o\ hello.o\ \-lc +.br +.sp +This tells \c +.B ld\c +\& to produce a file called \c +.B output\c +\& as the +result of linking the file \c +.B /lib/crt0.o\c +\& with \c +.B hello.o\c +\& and +the library \c +.B libc.a\c +\& which will come from the standard search +directories. + +The command-line options to \c +.B ld\c +\& may be specified in any order, and +may be repeated at will. For the most part, repeating an option with a +different argument will either have no further effect, or override prior +occurrences (those further to the left on the command line) of an +option. + +The exceptions\(em\&which may meaningfully be used more than once\(em\&are +\c +.B \-A\c +\&, \c +.B \-b\c +\& (or its synonym \c +.B \-format\c +\&), \c +.B \-defsym\c +\&, +\c +.B \-L\c +\&, \c +.B \-l\c +\&, \c +.B \-R\c +\&, and \c +.B \-u\c +\&. + +The list of object files to be linked together, shown as \c +.I objfile\c +\&, +may follow, precede, or be mixed in with command-line options; save that +an \c +.I objfile\c +\& argument may not be placed between an option flag and +its argument. + +Usually the linker is invoked with at least one object file, but other +forms of binary input files can also be specified with \c +.B \-l\c +\&, +\c +.B \-R\c +\&, and the script command language. If \c +.I no\c +\& binary input +files at all are specified, the linker does not produce any output, and +issues the message `\|\c +.B No input files\c +\|'. + +Option arguments must either follow the option letter without intervening +whitespace, or be given as separate arguments immediately following the +option that requires them. + +.TP +.BI "-A" "architecture" +In the current release of \c +.B ld\c +\&, this option is useful only for the +Intel 960 family of architectures. In that \c +.B ld\c +\& configuration, the +\c +.I architecture\c +\& argument is 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 \c +.B ld\c +\& command line included `\|\c +.B \-ACA\c +\|' as +well as `\|\c +.B \-ltry\c +\|', the linker would look (in its built-in search +paths, and in any paths you specify with \c +.B \-L\c +\&) for a library with +the names +.sp +.br +try +.br +libtry.a +.br +tryca +.br +libtryca.a +.br +.sp + +The first two possibilities would be considered in any event; the last +two are due to the use of `\|\c +.B \-ACA\c +\|'. + +Future releases of \c +.B ld\c +\& may support similar functionality for +other architecture families. + +You can meaningfully use \c +.B \-A\c +\& more than once on a command line, if +an architecture family allows combination of target architectures; each +use will add another pair of name variants to search for when \c +.B \-l +specifies a library. + +.TP +.BI "\-b " "input-format" +Specify the binary format for input object files that follow this option +on the command line. You don't usually need to specify this, as +\c +.B ld\c +\& is configured to expect as a default input format the most +usual format on each machine. \c +.I input-format\c +\& is a text string, the +name of a particular format supported by the BFD libraries. +\c +.B \-format \c +.I input-format\c +\&\c +\& has the same effect, as does the script command +.BR TARGET . + +You may want to use this option if you are linking files with an unusual +binary format. You can also use \c +.B \-b\c +\& to switch formats explicitly (when +linking object files of different formats), by including +\c +.B \-b \c +.I input-format\c +\&\c +\& before each group of object files in a +particular format. + +The default format is taken from the environment variable +.B GNUTARGET\c +\&. You can also define the input +format from a script, using the command \c +.B TARGET\c +\&. + +.TP +.B \-Bstatic +Do not link against shared libraries. This is only meaningful on +platforms for which shared libraries are supported. + +.TP +.B \-Bdynamic +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. + +.TP +.B \-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. + +.TP +.BI "\-c " "commandfile" +Directs \c +.B ld\c +\& to read link commands from the file +\c +.I commandfile\c +\&. These commands will completely override \c +.B ld\c +\&'s +default link format (rather than adding to it); \c +.I commandfile\c +\& must +specify everything necessary to describe the target format. + + +You may also include a script of link commands directly in the command +line by bracketing it between `\|\c +.B {\c +\|' and `\|\c +.B }\c +\|' characters. + +.TP +.B \-\-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. + +.TP +.B \-d +.TP +.B \-dc +.TP +.B \-dp +These three options are equivalent; multiple forms are supported for +compatibility with other linkers. Use any of them to make \c +.B ld +assign space to common symbols even if a relocatable output file is +specified (\c +.B \-r\c +\&). The script command +\c +.B FORCE_COMMON_ALLOCATION\c +\& has the same effect. + +.TP +.BI "-defsym " "symbol" "\fR = \fP" expression +Create a global symbol in the output file, containing the absolute +address given by \c +.I expression\c +\&. 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 \c +.I expression\c +\& in this +context: you may give a hexadecimal constant or the name of an existing +symbol, or use \c +.B +\c +\& and \c +.B \-\c +\& to add or subtract hexadecimal +constants or symbols. If you need more elaborate expressions, consider +using the linker command language from a script. + +.TP +.BI "-e " "entry"\c +\& +Use \c +.I entry\c +\& as the explicit symbol for beginning execution of your +program, rather than the default entry point. for a +discussion of defaults and other ways of specifying the +entry point. + +.TP +.B \-embedded\-relocs +This option is only meaningful when linking MIPS embedded PIC code, +generated by the +.B \-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. + +.TP +.B \-E +.TP +.B \-export\-dynamic +When creating an ELF file, add all symbols to the dynamic symbol table. +Normally, the dynamic symbol table contains only symbols which are used +by a dynamic object. This option is needed for some uses of +.I dlopen. + +.TP +.BI "-f " "name" +.TP +.BI "--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 +.I name. + +.TP +.BI "-F " "name" +.TP +.BI "--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 should be used as a filter on the symbol table of +the shared object +.I name. + +.TP +.BI "\-format " "input\-format" +Synonym for \c +.B \-b\c +\& \c +.I input\-format\c +\&. + +.TP +.B \-g +Accepted, but ignored; provided for compatibility with other tools. + +.TP +.BI "\-G " "size"\c +Set the maximum size of objects to be optimized using the GP register +to +.I size +under MIPS ECOFF. Ignored for other object file formats. + +.TP +.BI "-h " "name" +.TP +.BI "-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. + +.TP +.B \-\-help +Print a summary of the command-line options on the standard output and exit. +This option and +.B \-\-version +begin with two dashes instead of one +for compatibility with other GNU programs. The other options start with +only one dash for compatibility with other linkers. + +.TP +.B \-i +Perform an incremental link (same as option \c +.B \-r\c +\&). + +.TP +.BI "\-l" "ar"\c +\& +Add an archive file \c +.I ar\c +\& to the list of files to link. This +option may be used any number of times. \c +.B ld\c +\& will search its +path-list for occurrences of \c +.B lib\c +.I ar\c +\&.a\c +\& for every \c +.I ar +specified. + +.TP +.BI "\-L" "searchdir" +This command adds path \c +.I searchdir\c +\& to the list of paths that +\c +.B ld\c +\& will search for archive libraries. You may use this option +any number of times. + +The default set of paths searched (without being specified with +\c +.B \-L\c +\&) depends on what emulation mode \c +.B ld\c +\& is using, and in +some cases also on how it was configured. The +paths can also be specified in a link script with the \c +.B SEARCH_DIR +command. + +.TP +.B \-M +Print (to the standard output file) a link map\(em\&diagnostic information +about where symbols are mapped by \c +.B ld\c +\&, and information on global +common storage allocation. + +.TP +.BI "\-Map " "mapfile"\c +Print to the file +.I mapfile +a link map\(em\&diagnostic information +about where symbols are mapped by \c +.B ld\c +\&, and information on global +common storage allocation. + +.TP +.BI "\-m " "emulation"\c +Emulate the +.I emulation +linker. You can list the available emulations with the +.I \-\-verbose +or +.I \-V +options. This option overrides the compiled-in default, which is the +system for which you configured +.BR ld . + +.TP +.B \-N +specifies readable and writable \c +.B text\c +\& and \c +.B data\c +\& sections. If +the output format supports Unix style magic numbers, the output is +marked as \c +.B OMAGIC\c +\&. + +When you use the `\|\c +.B \-N\c +\&\|' option, the linker does not page-align the +data segment. + +.TP +.B \-n +sets the text segment to be read only, and \c +.B NMAGIC\c +\& is written +if possible. + +.TP +.B \-noinhibit\-exec +Normally, the linker will not produce an output file if it encounters +errors during the link process. With this flag, you can specify that +you wish the output file retained even after non-fatal errors. + +.TP +.B \-no\-keep\-memory +The linker normally optimizes for speed over memory usage by caching +the symbol tables of input files in memory. This option tells the +linker to instead optimize for memory usage, by rereading the symbol +tables as necessary. This may be required if the linker runs out of +memory space while linking a large executable. + +.TP +.B \-no\-warn\-mismatch +Normally the linker 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 the linker 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. + +.TP +.BI "\-o " "output" +.I output\c +\& is a name for the program produced by \c +.B ld\c +\&; if this +option is not specified, the name `\|\c +.B a.out\c +\|' is used by default. The +script command \c +.B OUTPUT\c +\& can also specify the output file name. + +.TP +.BI "\-oformat " "output\-format" +Specify the binary format for the output object file. +You don't usually need to specify this, as +\c +.B ld\c +\& is configured to produce as a default output format the most +usual format on each machine. \c +.I output-format\c +\& is a text string, the +name of a particular format supported by the BFD libraries. +The script command +.B OUTPUT_FORMAT +can also specify the output format, but this option overrides it. + +.TP +.BI "\-R " "filename" +Read symbol names and their addresses from \c +.I filename\c +\&, 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. + +.TP +.B \-relax +An option with machine dependent effects. Currently this option is only +supported on the H8/300. + +On some platforms, use this option to perform global optimizations that +become possible when the linker resolves addressing in your program, such +as relaxing address modes and synthesizing new instructions in the +output object file. + +On platforms where this is not supported, `\|\c +.B \-relax\c +\&\|' is accepted, but has no effect. + +.TP +.B \-r +Generates relocatable output\(em\&i.e., generate an output file that can in +turn serve as input to \c +.B ld\c +\&. This is often called \c +.I partial +linking\c +\&. As a side effect, in environments that support standard Unix +magic numbers, this option also sets the output file's magic number to +\c +.B OMAGIC\c +\&. +If this option is not specified, an absolute file is produced. When +linking C++ programs, this option \c +.I will not\c +\& resolve references to +constructors; \c +.B \-Ur\c +\& is an alternative. + +This option does the same as \c +.B \-i\c +\&. + +.TP +.B \-rpath\ \fIdirectory +Add a directory to the runtime library search path. This is used when +linking an ELF executable with shared objects. All +.B \-rpath +arguments are concatenated and passed to the runtime linker, which uses +them to locate shared objects at runtime. The +.B \-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 +.B \-rpath\-link +option. If +.B \-rpath +is not used when linking an ELF executable, the contents of the +environment variable +.B LD_RUN_PATH +will be used if it is defined. + +The +.B \-rpath +option may also be used on SunOS. By default, on SunOS, the linker +will form a runtime search patch out of all the +.B \-L +options it is given. If a +.B \-rpath +option is used, the runtime search path will be formed exclusively +using the +.B \-rpath +options, ignoring +the +.B \-L +options. This can be useful when using gcc, which adds many +.B \-L +options which may be on NFS mounted filesystems. + +.TP +.B \-rpath\-link\ \fIdirectory +When using ELF or SunOS, one shared library may require another. This +happens when an +.B 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-relocateable 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 +.B \-rpath\-link +option specifies the first set of directories to search. The +.B \-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. + +If the required shared library is not found, the linker will issue a +warning and continue with the link. + +.TP +.B \-S +Omits debugger symbol information (but not all symbols) from the output file. + +.TP +.B \-s +Omits all symbol information from the output file. + +.TP +.B \-shared +Create a shared library. This is currently only supported on ELF and +SunOS platforms (on SunOS it is not required, as the linker will +automatically create a shared library when there are undefined symbols +and the +.B \-e +option is not used). + +.TP +.B \-sort\-common +Normally, when +.B ld +places the global common symbols in the appropriate output sections, +it sorts them by size. 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. This option disables that sorting. + +.TP +.B \-split\-by\-reloc\ \fIcount +Trys to creates extra sections in the output file so that no single +output section in the file contains more than +.I 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 +.I count +relocations one output section will contain that many relocations. + +.TP +.B \-split\-by\-file +Similar to +.B \-split\-by\-reloc +but creates a new output section for each input file. + +.TP +.BI "\-Tbss " "org"\c +.TP +.BI "\-Tdata " "org"\c +.TP +.BI "\-Ttext " "org"\c +Use \c +.I org\c +\& as the starting address for\(em\&respectively\(em\&the +\c +.B bss\c +\&, \c +.B data\c +\&, or the \c +.B text\c +\& segment of the output file. +\c +.I textorg\c +\& must be a hexadecimal integer. + +.TP +.BI "\-T " "commandfile" +Equivalent to \c +.B \-c \c +.I commandfile\c +\&\c +\&; supported for compatibility with +other tools. + +.TP +.B \-t +Prints names of input files as \c +.B ld\c +\& processes them. + +.TP +.BI "\-u " "sym" +Forces \c +.I sym\c +\& to be entered in the output file as an undefined symbol. +This may, for example, trigger linking of additional modules from +standard libraries. \c +.B \-u\c +\& may be repeated with different option +arguments to enter additional undefined symbols. + +.TP +.B \-Ur +For anything other than C++ programs, this option is equivalent to +\c +.B \-r\c +\&: it generates relocatable output\(em\&i.e., an output file that can in +turn serve as input to \c +.B ld\c +\&. When linking C++ programs, \c +.B \-Ur +.I will\c +\& resolve references to constructors, unlike \c +.B \-r\c +\&. + +.TP +.B \-\-verbose +Display the version number for \c +.B ld +and list the supported emulations. +Display which input files can and can not be opened. + +.TP +.B \-v, \-V +Display the version number for \c +.B ld\c +\&. +The +.B \-V +option also lists the supported emulations. + +.TP +.B \-\-version +Display the version number for \c +.B ld +and exit. + +.TP +.B \-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. + +.TP +.B \-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. + +.TP +.B \-warn\-multiple\-gp +Warn if the output file requires multiple global-pointer values. This +option is only meaningful for certain processors, such as the Alpha. + +.TP +.B \-warn\-once +Only warn once for each undefined symbol, rather than once per module +which refers to it. + +.TP +.B \-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. + +.TP +.B \-\-whole\-archive +For each archive mentioned on the command line after the +.B \-\-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. + +.TP +.B \-\-no\-whole\-archive +Turn off the effect of the +.B \-\-whole\-archive +option for archives which appear later on the command line. + +.TP +.BI "--wrap " "symbol" +Use a wrapper function for +.I symbol. +Any undefined reference to +.I symbol +will be resolved to +.BI "__wrap_" "symbol". +Any undefined reference to +.BI "__real_" "symbol" +will be resolved to +.I symbol. + +.TP +.B \-X +Delete all temporary local symbols. For most targets, this is all local +symbols whose names begin with `\|\c +.B L\c +\|'. + +.TP +.B \-x +Delete all local symbols. + +.PP + +.SH ENVIRONMENT +\c +You can change the behavior of +.B ld\c +\& with the environment variable \c +.B GNUTARGET\c +\&. + +\c +.B GNUTARGET\c +\& determines the input-file object format if you don't +use \c +.B \-b\c +\& (or its synonym \c +.B \-format\c +\&). Its value should be one +of the BFD names for an input format. If there is no +\c +.B GNUTARGET\c +\& in the environment, \c +.B ld\c +\& uses the natural format +of the host. If \c +.B GNUTARGET\c +\& is set to \c +.B default\c +\& 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 flag 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. + +.PP + +.SH "SEE ALSO" + +.BR objdump ( 1 ) +.br +.br +.RB "`\|" ld "\|' and `\|" binutils "\|'" +entries in +.B info\c +.br +.I +ld: the GNU linker\c +, Steve Chamberlain and Roland Pesch; +.I +The GNU Binary Utilities\c +, Roland H. Pesch. + +.SH COPYING +Copyright (c) 1991, 1992 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-nlmconv.1 b/oldbinutils/man/man1/mips-nlmconv.1 new file mode 100644 index 0000000000..cbc3aedd10 --- /dev/null +++ b/oldbinutils/man/man1/mips-nlmconv.1 @@ -0,0 +1,110 @@ +.\" Copyright (c) 1991, 1996 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH nlmconv 1 "March 1996" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +nlmconv \- converts object code into an NLM + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B nlmconv +.RB "[\|" \-I\ \fIbfdname\fB\ |\ \-\-input\-target=\fIbfdname\fR "\|]" +.RB "[\|" \-O\ \fIbfdname\fB\ |\ \-\-output\-target=\fIbfdname\fR "\|]" +.RB "[\|" \-T\ \fIheaderfile\fB\ |\ \-\-header\-file=\fIheaderfile\fR "\|]" +.RB "[\|" \-V\ |\ \-\-version\fR "\|]" +.RB "[\|" \-\-help\fR "\|]" +.B infile +.B outfile +.SH DESCRIPTION +.B nlmconv +converts the relocatable object file +.B infile +into the NetWare Loadable Module +.BR outfile , +optionally reading +.I headerfile +for NLM header information. For instructions on writing the NLM +command file language used in header files, see +.IR "The NetWare Tool Maker Specification Manual" , +available from Novell, Inc. +.B nlmconv +currently works with i386 object files in +.BR COFF , +.BR ELF , +or +.B a.out +format, and with SPARC object files in +.B ELF +or +.B a.out +format. +.br +.B nlmconv +uses the GNU Binary File Descriptor library to read +.IR infile . +.SH OPTIONS +.TP +.B \-I \fIbfdname\fR, \fB\-\-input\-target=\fIbfdname +Consider the source file's object format to be +.IR bfdname , +rather than attempting to deduce it. +.TP +.B \-O \fIbfdname\fR, \fB\-\-output\-target=\fIbfdname +Write the output file using the object format +.IR bfdname . +.B nlmconv +infers the output format based on the input format, e.g. for an i386 +input file the output format is +.IR nlm32\-i386 . +.TP +.B \-T \fIheaderfile\fR, \fB\-\-header\-file=\fIheaderfile +Reads +.I headerfile +for NLM header information. For instructions on writing the NLM +command file language used in header files, see +.IR "The NetWare Tool Maker Specification Manual" , +available from Novell, Inc. +.TP +.B \-V\fR, \fB\-\-version +Show the version number of +.B nlmconv +and exit. +.TP +.B \-h\fR, \fB\-\-help +Show a summary of the options to +.B nlmconv +and exit. +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (June 1993). + +.SH COPYING +Copyright (c) 1993 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-nm.1 b/oldbinutils/man/man1/mips-nm.1 new file mode 100644 index 0000000000..c2ad99e559 --- /dev/null +++ b/oldbinutils/man/man1/mips-nm.1 @@ -0,0 +1,230 @@ +.\" Copyright (c) 1991 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH nm 1 "5 November 1991" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +nm \- list symbols from object files. + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B nm +.RB "[\|" \-a | \-\-debug\-syms "\|]" +.RB "[\|" \-g | \-\-extern\-only "\|]" +.RB "[\|" \-B "\|]" +.RB "[\|" \-C | \-\-demangle "\|]" +.RB "[\|" \-D | \-\-dynamic "\|]" +.RB "[\|" \-s | \-\-print\-armap "\|]" +.RB "[\|" \-o | \-\-print\-file\-name "\|]" +.RB "[\|" \-n | \-\-numeric\-sort "\|]" +.RB "[\|" \-p | \-\-no\-sort "\|]" +.RB "[\|" \-r | \-\-reverse\-sort "\|]" +.RB "[\|" \-\-size\-sort "\|]" +.RB "[\|" \-u | \-\-undefined\-only "\|]" +.RB "[\|" \-l | \-\-line\-numbers "\|]" +.RB "[\|" \-\-help "\|]" +.RB "[\|" \-\-version "\|]" +.RB "[\|" "\-t \fIradix" | \-\-radix=\fIradix "\|]" +.RB "[\|" \-P | --portability "\|]" +.RB "[\|" "\-f \fIformat" | \-\-format=\fIformat "\|]" +.RB "[\|" "\-\-target=\fIbfdname" "\|]" +.RB "[\|" \c +.I objfile\c +\&.\|.\|.\|] +.ad b +.hy 1 +.SH DESCRIPTION +GNU \c +.B nm\c +\& lists the symbols from object files \c +.I objfile\c +\&. If no object files are given as arguments, \c +.B nm\c +\& assumes `\|\c +.B a.out\c +\|'. + +.SH OPTIONS +The long and short forms of options, shown here as alternatives, are +equivalent. + +.TP +.B \-A +.TP +.B \-o +.TP +.B \-\-print\-file\-name +Precede each symbol by the name of the input file where it was found, +rather than identifying the input file once only before all of its +symbols. + +.TP +.B \-a +.TP +.B \-\-debug\-syms +Display debugger-only symbols; normally these are not listed. + +.TP +.B \-B +The same as +.B \-\-format=bsd +(for compatibility with the MIPS \fBnm\fP). + +.TP +.B \-C +.TP +.B \-\-demangle +Decode (\fIdemangle\fP) low-level symbol names into user-level names. +Besides removing any initial underscore prepended by the system, this +makes C++ function names readable. + +.TP +.B \-D +.TP +.B \-\-dynamic +Display the dynamic symbols rather than the normal symbols. This is +only meaningful for dynamic objects, such as certain types of shared +libraries. + +.TP +.B "\-f \fIformat" +Use the output format \fIformat\fP, which can be ``bsd'', +``sysv'', or ``posix''. The default is ``bsd''. +Only the first character of \fIformat\fP is significant; it can be +either upper or lower case. + +.TP +.B \-g +.TP +.B \-\-extern\-only +Display only external symbols. + +.TP +.B \-n +.TP +.B \-v +.TP +.B \-\-numeric\-sort +Sort symbols numerically by their addresses, not alphabetically by their +names. + +.TP +.B \-p +.TP +.B \-\-no\-sort +Don't bother to sort the symbols in any order; just print them in the +order encountered. + +.TP +.B \-P +.TP +.B \-\-portability +Use the POSIX.2 standard output format instead of the default format. +Equivalent to ``\-f posix''. + +.TP +.B \-s +.TP +.B \-\-print\-armap +When listing symbols from archive members, include the index: a mapping +(stored in the archive by \c +.B ar\c +\& or \c +.B ranlib\c +\&) of what modules +contain definitions for what names. + +.TP +.B \-r +.TP +.B \-\-reverse\-sort +Reverse the sense of the sort (whether numeric or alphabetic); let the +last come first. + +.TP +.B \-\-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. + +.TP +.B "\-t \fIradix" +.TP +.B "\-\-radix=\fIradix" +Use \fIradix\fP as the radix for printing the symbol values. It must be +``d'' for decimal, ``o'' for octal, or ``x'' for hexadecimal. + +.TP +.BI "\-\-target=" "bfdname" +Specify an object code format other than your system's default format. +See +.BR objdump ( 1 ), +for information on listing available formats. + +.TP +.B \-u +.TP +.B \-\-undefined\-only +Display only undefined symbols (those external to each object file). + +.TP +.B \-l +.TP +.B \-\-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. + +.TP +.B \-V +.TP +.B \-\-version +Show the version number of +.B nm +and exit. + +.TP +.B \-\-help +Show a summary of the options to +.B nm +and exit. + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (October 1991); +.BR ar "(" 1 ")," +.BR objdump ( 1 ), +.BR ranlib "(" 1 ")." + + +.SH COPYING +Copyright (c) 1991 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-objcopy.1 b/oldbinutils/man/man1/mips-objcopy.1 new file mode 100644 index 0000000000..6c98df8d32 --- /dev/null +++ b/oldbinutils/man/man1/mips-objcopy.1 @@ -0,0 +1,301 @@ +.\" Copyright (c) 1991, 93, 94, 95, 96, 1997 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH objcopy 1 "October 1994" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +objcopy \- copy and translate object files + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B objcopy +.RB "[\|" \-F\ \fIbfdname\fR\ |\ \fB\-\-target=\fIbfdname\fR "\|]" +.RB "[\|" \-I\ \fIbfdname\fR\ |\ \fB\-\-input\-target=\fIbfdname\fR "\|]" +.RB "[\|" \-O\ \fIbfdname\fR\ |\ \fB\-\-output\-target=\fIbfdname\fR "\|]" +.RB "[\|" \-R\ \fIsectionname\fR\ |\ \fB\-\-remove\-section=\fIsectionname\fR "\|]" +.RB "[\|" \-S\fR\ |\ \fB\-\-strip\-all\fR "\|]" +.RB "[\|" \-g\fR\ |\ \fB\-\-strip\-debug\fR "\|]" +.RB "[\|" \-\-strip\-unneeded\fR "\|]" +.RB "[\|" \-K\ \fIsymbolname\fR\ |\ \fB\-\-keep\-symbol=\fIsymbolname\fR "\|]" +.RB "[\|" \-N\ \fIsymbolname\fR\ |\ \fB\-\-strip\-symbol=\fIsymbolname\fR "\|]" +.RB "[\|" \-L\ \fIsymbolname\fR\ |\ \fB\-\-localize\-symbol=\fIsymbolname\fR "\|]" +.RB "[\|" \-W\ \fIsymbolname\fR\ |\ \fB\-\-weaken\-symbol=\fIsymbolname\fR "\|]" +.RB "[\|" \-x\fR\ |\ \fB\-\-discard\-all\fR "\|]" +.RB "[\|" \-X\fR\ |\ \fB\-\-discard\-locals\fR "\|]" +.RB "[\|" \-b\ \fIbyte\fR\ |\ \fB\-\-byte=\fIbyte\fR "\|]" +.RB "[\|" \-i\ \fIinterleave\fR\ |\ \fB\-\-interleave=\fIinterleave\fR "\|]" +.RB "[\|" \-p\fR\ |\ \fB\-\-preserve\-dates\fR "\|]" +.RB "[\|" \-\-debugging "\|]" +.RB "[\|" \-\-gap\-fill=\fIval\fR "\|]" +.RB "[\|" \-\-pad\-to=\fIaddress\fR "\|]" +.RB "[\|" \-\-set\-start=\fIval\fR "\|]" +.RB "[\|" \-\-adjust\-start=\fIincr\fR "\|]" +.RB "[\|" \-\-adjust\-vma=\fIincr\fR "\|]" +.RB "[\|" \-\-adjust\-section\-vma=\fIsection{=,+,-}val\fR "\|]" +.RB "[\|" \-\-adjust\-warnings\fR "\|]" +.RB "[\|" \-\-no\-adjust\-warnings\fR "\|]" +.RB "[\|" \-\-set\-section\-flags=\fIsection=flags\fR "\|]" +.RB "[\|" \-\-add\-section=\fIsectionname=filename\fR "\|]" +.RB "[\|" \-\-change\-leading\-char\fR "\|]" +.RB "[\|" \-\-remove\-leading\-char\fR "\|]" +.RB "[\|" \-\-weaken\fR "\|]" +.RB "[\|" \-v\ |\ \-\-verbose\fR "\|]" +.RB "[\|" \-V\ |\ \-\-version\fR "\|]" +.RB "[\|" \-\-help\fR "\|]" +.B infile +.RB "[\|" outfile\fR "\|]" +.SH DESCRIPTION +The GNU +.B objcopy +utility copies the contents of an object file to another. +.B 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 +.B objcopy +is controlled by command-line options. +.PP +.B objcopy +creates temporary files to do its translations and deletes them +afterward. +.B objcopy +uses BFD to do all its translation work; it knows about all the +formats BFD knows about, and thus is able to recognize most formats +without being told explicitly. +.PP +.B objcopy +can be used to generate S-records by using an output target of +.B srec +(e.g., use +.B -O srec). +.PP +.B objcopy +can be used to generate a raw binary file by using an output target of +.B binary +(e.g., use +.B -O binary). +When +.B 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 +virtual address of the lowest section copied into the output file. +.PP +When generating an S-record or a raw binary file, it may be helpful to +use +.B -S +to remove sections containing debugging information. In some cases +.B -R +will be useful to remove sections which contain information which is +not needed by the binary file. +.PP +.I infile +and +.I outfile +are the source and output files respectively. If you do not specify +.IR outfile , +.B objcopy +creates a temporary file and destructively renames the result with the +name of the input file. + +.SH OPTIONS +.TP +.B \-I \fIbfdname\fR, \fB\-\-input\-target=\fIbfdname +Consider the source file's object format to be +.IR bfdname , +rather than attempting to deduce it. +.TP +.B \-O \fIbfdname\fR, \fB\-\-output\-target=\fIbfdname +Write the output file using the object format +.IR bfdname . +.TP +.B \-F \fIbfdname\fR, \fB\-\-target=\fIbfdname +Use +.I 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. +.TP +.B \-R \fIsectionname\fR, \fB\-\-remove-section=\fIsectionname +Remove the named section from the file. This option may be given more +than once. Note that using this option inappropriately may make the +output file unusable. +.TP +.B \-S\fR, \fB\-\-strip\-all +Do not copy relocation and symbol information from the source file. +.TP +.B \-g\fR, \fB\-\-strip\-debug +Do not copy debugging symbols from the source file. +.TP +.B \-\-strip\-unneeded +Strip all symbols that are not needed for relocation processing. +.TP +.B \-K \fIsymbolname\fR, \fB\-\-keep\-symbol=\fIsymbolname +Copy only symbol \fIsymbolname\fP from the source file. This option +may be given more than once. +.TP +.B \-N \fIsymbolname\fR, \fB\-\-strip\-symbol=\fIsymbolname +Do not copy symbol \fIsymbolname\fP from the source file. This option +may be given more than once. +.TP +.B \-L \fIsymbolname\fR, \fB\-\-localize\-symbol=\fIsymbolname +Make symbol \fIsymbolname\fP local to the file, so that it is not +visible externally. This option may be given more than once. +.TP +.B \-W \fIsymbolname\fR, \fB\-\-weaken\-symbol=\fIsymbolname +Make symbol \fIsymbolname\fP weak. This option may be given more than once. +.TP +.B \-x\fR, \fB \-\-discard\-all +Do not copy non-global symbols from the source file. +.TP +.B \-X\fR, \fB\-\-discard\-locals +Do not copy compiler-generated local symbols. (These usually start +with "L" or "."). +.TP +.B \-b \fIbyte\fR, \fB\-\-byte=\fIbyte +Keep only every \fIbyte\fPth byte of the input file (header data is +not affected). \fIbyte\fP can be in the range from 0 to the +interleave-1. This option is useful for creating files to program +ROMs. It is typically used with an srec output target. +.TP +.B \-i \fIinterleave\fR, \fB\-\-interleave=\fIinterleave +Only copy one out of every \fIinterleave\fP bytes. Which one to copy is +selected by the \fB\-b\fP or \fB\-\-byte\fP option. The default is 4. +The interleave is ignored if neither \fB\-b\fP nor \fB\-\-byte\fP is given. +.TP +.B \-p\fR, \fB\-\-preserve\-dates +Set the access and modification dates of the output file to be the same +as those of the input file. +.TP +.B \-\-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. +.TP +.B \-\-gap\-fill=\fIval +Fill gaps between sections with \fIval\fP. This operation applies to +the \fIload address\fP (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 \fIval\fP. +.TP +.B \-\-pad\-to=\fIaddress +Pad the output file up to the load address \fIaddress\fP. This is +done by increasing the size of the last section. The extra space is +filled in with the value specified by \fB\-\-gap\-fill\fP (default +zero). +.TP +.B \fB\-\-set\-start=\fIval +Set the start address of the new file to \fIval\fP. Not all object +file formats support setting the start address. +.TP +.B \fB\-\-adjust\-start=\fIincr +Adjust the start address by adding \fIincr\fP. Not all object file +formats support setting the start address. +.TP +.B \fB\-\-adjust\-vma=\fIincr +Adjust the address of all sections, as well as the start address, by +adding \fIincr\fP. 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. +.TP +.B \fB\-\-adjust\-section\-vma=\fIsection{=,+,-}val +Set or adjust the address of the named \fIsection\fP. If \fI=\fP is +used, the section address is set to \fIval\fP. Otherwise, \fIval\fP +is added to or subtracted from the section address. See the comments +under \fB\-\-adjust\-vma\fP, above. If \fIsection\fP does not exist +in the input file, a warning will be issued, unless +\fB\-\-no\-adjust\-warnings\fP is used. +.TP +.B \fB\-\-adjust\-warnings +If \fB\-\-adjust\-section\-vma\fP is used, and the named section does +not exist, issue a warning. This is the default. +.TP +.B \fB\-\-no\-adjust\-warnings +Do not issue a warning if \fB\-\-adjust\-section\-vma\fP is used, even +if the named section does not exist. +.TP +.B \fB\-\-set\-section\-flags=\fIsection=flags +Set the flags for the named section. The \fIflags\fP argument is a +comma separated string of flag names. The recognized names are +\fIalloc\fP, \fIload\fP, \fIreadonly\fP, \fIcode\fP, \fIdata\fP, and +\fIrom\fP. Not all flags are meaningful for all object file +formats. +.TP +.B \fB\-\-add\-section=\fIsectionname=filename +Add a new section named \fIsectionname\fR while copying the file. The +contents of the new section are taken from the file \fIfilename\fR. +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. +.TP +.B \-\-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 +.B 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. +.TP +.B \-\-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 +@code{--change-leading-char} because it always changes the symbol name +when appropriate, regardless of the object file format of the output +.TP +.B \-\-weaken +Change all global symbols in the file to be weak. +.TP +.B \-v\fR, \fB\-\-verbose +Verbose output: list all object files modified. In the case of +archives, "\fBobjcopy \-V\fR" lists all members of the archive. +.TP +.B \-V\fR, \fB\-\-version +Show the version number of +.B objcopy +and exit. +.TP +.B \-\-help +Show a summary of the options to +.B objcopy +and exit. +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (June 1993). + +.SH COPYING +Copyright (c) 1993, 94, 95, 96, 1997 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-objdump.1 b/oldbinutils/man/man1/mips-objdump.1 new file mode 100644 index 0000000000..69217b9d41 --- /dev/null +++ b/oldbinutils/man/man1/mips-objdump.1 @@ -0,0 +1,402 @@ +.\" Copyright (c) 1991, 1996, 1997 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH objdump 1 "5 November 1991" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +objdump \- display information from object files. + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B objdump +.RB "[\|" \-a | \-\-archive\-headers "\|]" +.RB "[\|" "\-b\ "\c +.I bfdname\c +.RB " | " "\-\-target="\c +.I bfdname\c +\&\|] +.RB "[\|" \-C | \-\-demangle "\|]" +.RB "[\|" \-\-debugging "\|]" +.RB "[\|" \-d | \-\-disassemble "\|]" +.RB "[\|" \-D | \-\-disassemble-all "\|]" +.RB "[\|" \-\-disassemble\-zeroes "\|]" +.RB "[\|" \-EB | \-EL | \-\-endian=\c +.I {big|little}\c +\&\|] +.RB "[\|" \-f | \-\-file\-headers "\|]" +.RB "[\|" \-h | \-\-section\-headers +.RB "| " \-\-headers "\|]" +.RB "[\|" \-i | \-\-info "\|]" +.RB "[\|" "\-j\ "\c +.I section\c +.RB " | " "\-\-section="\c +.I section\c +\&\|] +.RB "[\|" \-l | \-\-line\-numbers "\|]" +.RB "[\|" "\-m\ "\c +.I machine\c +.RB " | " "\-\-architecture="\c +.I machine\c +\&\|] +.RB "[\|" \-\-prefix\-addresses "\|]" +.RB "[\|" \-r | \-\-reloc "\|]" +.RB "[\|" \-R | \-\-dynamic\-reloc "\|]" +.RB "[\|" \-s | \-\-full\-contents "\|]" +.RB "[\|" \-S | \-\-source "\|]" +.RB "[\|" \-\-[no\-]show\-raw\-insn "\|]" +.RB "[\|" \-\-stabs "\|]" +.RB "[\|" \-t | \-\-syms "\|]" +.RB "[\|" \-T | \-\-dynamic\-syms "\|]" +.RB "[\|" \-x | \-\-all\-headers "\|]" +.RB "[\|" "\-\-start\-address="\c +.I address\c +\&\|] +.RB "[\|" "\-\-stop\-address="\c +.I address\c +\&\|] +.RB "[\|" "\-\-adjust\-vma="\c +.I offset\c +\&\|] +.RB "[\|" \-\-version "\|]" +.RB "[\|" \-\-help "\|]" +.I objfile\c +\&.\|.\|. +.ad b +.hy 1 +.SH DESCRIPTION +\c +.B objdump\c +\& 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. +.PP +.IR "objfile" .\|.\|. +are the object files to be examined. When you specify archives, +\c +.B objdump\c +\& shows information on each of the member object files. + +.SH OPTIONS +Where long and short forms of an option are shown together, they are +equivalent. At least one option besides +.B \-l +(\fB\-\-line\-numbers\fP) must be given. + +.TP +.B \-a +.TP +.B \-\-archive\-headers +If any files from \c +.I objfile\c +\& are archives, display the archive +header information (in a format similar to `\|\c +.B ls \-l\c +\|'). Besides the +information you could list with `\|\c +.B ar tv\c +\|', `\|\c +.B objdump \-a\c +\|' shows +the object file format of each archive member. + +.TP +.BI "\-\-adjust\-vma=" "offset" +When dumping information, first add +.I 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. + +.TP +.BI "\-b " "bfdname"\c +.TP +.BI "\-\-target=" "bfdname" +Specify the object-code format for the object files to be +\c +.I bfdname\c +\&. This may not be necessary; \c +.I objdump\c +\& can +automatically recognize many formats. For example, +.sp +.br +objdump\ \-b\ oasys\ \-m\ vax\ \-h\ fu.o +.br +.sp +display summary information from the section headers (`\|\c +.B \-h\c +\|') of +`\|\c +.B fu.o\c +\|', which is explicitly identified (`\|\c +.B \-m\c +\|') as a Vax object +file in the format produced by Oasys compilers. You can list the +formats available with the `\|\c +.B \-i\c +\|' option. + +.TP +.B \-C +.TP +.B \-\-demangle +Decode (\fIdemangle\fP) low-level symbol names into user-level names. +Besides removing any initial underscore prepended by the system, this +makes C++ function names readable. + +.TP +.B \-\-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. + +.TP +.B \-d +.TP +.B \-\-disassemble +Display the assembler mnemonics for the machine +instructions from \c +.I objfile\c +\&. +This option only disassembles those sections which are +expected to contain instructions. + +.TP +.B \-D +.TP +.B \-\-disassemble-all +Like \fB\-d\fP, but disassemble the contents of all sections, not just +those expected to contain instructions. + +.TP +.B \-\-prefix\-addresses +When disassembling, print the complete address on each line. This is +the older disassembly format. + +.TP +.B \-\-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. + +.TP +.B \-EB +.TP +.B \-EL +.TP +.BI "\-\-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. + +.TP +.B \-f +.TP +.B \-\-file\-headers +Display summary information from the overall header of +each file in \c +.I objfile\c +\&. + +.TP +.B \-h +.TP +.B \-\-section\-headers +.TP +.B \-\-headers +Display summary information from the section headers of the +object file. + +.TP +.B \-\-help +Print a summary of the options to +.B objdump +and exit. + +.TP +.B \-i +.TP +.B \-\-info +Display a list showing all architectures and object formats available +for specification with \c +.B \-b\c +\& or \c +.B \-m\c +\&. + +.TP +.BI "\-j " "name"\c +.TP +.BI "\-\-section=" "name" +Display information only for section \c +.I name\c +\&. + +.TP +.B \-l +.TP +.B \-\-line\-numbers +Label the display (using debugging information) with the filename +and source line numbers corresponding to the object code shown. +Only useful with \fB\-d\fP, \fB\-D\fP, or \fB\-r\fP. + +.TP +.BI "\-m " "machine"\c +.TP +.BI "\-\-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 \fB\-i\fP option. + +.TP +.B \-r +.TP +.B \-\-reloc +Print the relocation entries of the file. If used with \fB\-d\fP or +\fB\-d\fP, the relocations are printed interspersed with the +disassembly. + +.TP +.B \-R +.TP +.B \-\-dynamic\-reloc +Print the dynamic relocation entries of the file. This is only +meaningful for dynamic objects, such as certain types of shared +libraries. + +.TP +.B \-s +.TP +.B \-\-full\-contents +Display the full contents of any sections requested. + +.TP +.B \-S +.TP +.B \-\-source +Display source code intermixed with disassembly, if possible. Implies +\fB-d\fP. + +.TP +.B \-\-show\-raw\-insn +When disassembling instructions, print the instruction in hex as well as +in symbolic form. This is the default except when +.B \-\-prefix\-addresses +is used. + +.TP +.B \-\-no\-show\-raw\-insn +When disassembling instructions, do not print the instruction bytes. +This is the default when +.B \-\-prefix\-addresses +is used. + +.TP +.B \-\-stabs +Display the contents of the .stab, .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. + +.TP +.BI "\-\-start\-address=" "address" +Start displaying data at the specified address. This affects the output +of the +.B \-d\c +, +.B \-r +and +.B \-s +options. + +.TP +.BI "\-\-stop\-address=" "address" +Stop displaying data at the specified address. This affects the output +of the +.B \-d\c +, +.B \-r +and +.B \-s +options. + +.TP +.B \-t +.TP +.B \-\-syms +Symbol Table. Print the symbol table entries of the file. +This is similar to the information provided by the `\|\c +.B nm\c +\|' program. + +.TP +.B \-T +.TP +.B \-\-dynamic\-syms +Dynamic Symbol Table. 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 `\|\c +.B nm\c +\|' program when given the +.B \-D (\-\-dynamic) +option. + +.TP +.B \-\-version +Print the version number of +.B objdump +and exit. + +.TP +.B \-x +.TP +.B \-\-all\-headers +Display all available header information, including the symbol table and +relocation entries. Using `\|\c +.B \-x\c +\|' is equivalent to specifying all of +`\|\c +.B \-a \-f \-h \-r \-t\c +\|'. + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (October 1991); +.BR nm "(" 1 ")." + +.SH COPYING +Copyright (c) 1991, 92, 93, 94, 95, 1996 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-ranlib.1 b/oldbinutils/man/man1/mips-ranlib.1 new file mode 100644 index 0000000000..7efb5c8e85 --- /dev/null +++ b/oldbinutils/man/man1/mips-ranlib.1 @@ -0,0 +1,83 @@ +.\" Copyright (c) 1991 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH ranlib 1 "5 November 1991" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +ranlib \- generate index to archive. + +.SH SYNOPSIS +.hy 0 +.na +.B ranlib \c +.RB "[\|" \-v | \-V "\|]" +.I archive\c +\& +.ad b +.hy 1 +.SH DESCRIPTION +.B 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. +.PP +You may use +.RB ` "nm \-s" ' +or +.RB ` "nm \-\-print-armap" ' +to list this index. +.PP +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. +.PP +The GNU +.B ranlib +program is another form of GNU +.BR ar ; +running +.B ranlib +is completely equivalent to executing +.RB ` "ar \-s" '. + +.SH OPTIONS +.TP +.B \-v +Print the version number of +.B ranlib +and exit. + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (October 1991); +.BR ar "(" 1 ")," +.BR nm "(" 1 ")." + + +.SH COPYING +Copyright (c) 1991 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-size.1 b/oldbinutils/man/man1/mips-size.1 new file mode 100644 index 0000000000..3b19bd2593 --- /dev/null +++ b/oldbinutils/man/man1/mips-size.1 @@ -0,0 +1,161 @@ +.\" Copyright (c) 1991 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH size 1 "5 November 1991" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +size \- list section sizes and total size. + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B size +.RB "[\|" \-A \||\| \-B \||\| \c +.BI "\-\-format=" compatibility\c +\&\|] +.RB "[\|" \-\-help "\|]" +.RB "[\|" \-d \||\| \-o \||\| \-x\c +\||\|\c +.BI "\-\-radix=" number\c +\&\|] +.RB "[\|" \c +.BI "\-\-target=" bfdname\c +\&\|] +.RB "[\|" \-V \||\| \-\-version "\|]" +.I objfile\c +\&.\|.\|. +.ad b +.hy 1 +.SH DESCRIPTION +The GNU \c +.B size\c +\& utility lists the section sizes\(em\&and the total +size\(em\&for each of the object files +.I objfile +in its argument list. +By default, one line of output is generated for each object file or each +module in an archive. + +.SH OPTIONS +.TP +.B \-A +.TP +.B \-B +.TP +.BI "\-\-format " "compatibility" +Using one of these options, you can choose whether the output from GNU +\c +.B size\c +\& resembles output from System V \c +.B size\c +\& (using `\|\c +.B \-A\c +\|', +or `\|\c +.B \-\-format=sysv\c +\|'), or Berkeley \c +.B size\c +\& (using `\|\c +.B \-B\c +\|', or +`\|\c +.B \-\-format=berkeley\c +\|'). The default is the one-line format similar to +Berkeley's. + +.TP +.B \-\-help +Show a summary of acceptable arguments and options. + +.TP +.B \-d +.TP +.B \-o +.TP +.B \-x +.TP +.BI "\-\-radix " "number" +Using one of these options, you can control whether the size of each +section is given in decimal (`\|\c +.B \-d\c +\|', or `\|\c +.B \-\-radix 10\c +\|'); octal +(`\|\c +.B \-o\c +\|', or `\|\c +.B \-\-radix 8\c +\|'); or hexadecimal (`\|\c +.B \-x\c +\|', or +`\|\c +.B \-\-radix 16\c +\|'). In `\|\c +.B \-\-radix \c +.I number\c +\&\c +\|', only the three +values (8, 10, 16) are supported. The total size is always given in two +radices; decimal and hexadecimal for `\|\c +.B \-d\c +\|' or `\|\c +.B \-x\c +\|' output, or +octal and hexadecimal if you're using `\|\c +.B \-o\c +\|'. + +.TP +.BI "\-\-target " "bfdname" +You can specify a particular object-code format for \c +.I objfile\c +\& as +\c +.I bfdname\c +\&. This may not be necessary; \c +.I size\c +\& can +automatically recognize many formats. See +.BR objdump ( 1 ) +for information +on listing available formats. + +.TP +.B \-V +.TP +.B \-\-version +Display version number information on \c +.B size\c +\& itself. + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.BR info ; +.IR "The GNU Binary Utilities" , + Roland H. Pesch (October 1991); +.BR ar "(" 1 ")," +.BR objdump ( 1 ). + +.SH COPYING +Copyright (c) 1991 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-strings.1 b/oldbinutils/man/man1/mips-strings.1 new file mode 100644 index 0000000000..408de29400 --- /dev/null +++ b/oldbinutils/man/man1/mips-strings.1 @@ -0,0 +1,151 @@ +.\" Copyright (c) 1993 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH strings 1 "25 June 1993" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +strings \- print the strings of printable characters in files + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B strings +.RB "[\|" \-a | \-\c +.RB | \-\-all "\|]" +.RB "[\|" \-f | \-\-print\-file\-name "\|]" +.RB "[\|" \-o "\|]" +.RB "[\|" \-\-help "\|]" +.RB "[\|" \-v | \-\-version "\|]" +.RB "[\|" \-n +.I min\-len\c +.RI | \-min\-len\c +.RB | "\-\-bytes="\c +.I min\-len\c +\&\|] +.RB "[\|" \-t +.I {o,x,d}\c +.RB "[\|" "\-\-target=\fIbfdname" "\|]" +.RB | "\-\-radix="\c +.I {o,x,d}\c +\&\|] +.I file\c +.ad b +.hy 1 +.SH DESCRIPTION +For each +.I file +given, GNU \c +.B 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. + +.PP +.B strings +is mainly useful for determining the contents of non-text files. + +.SH OPTIONS +The long and short forms of options, shown here as alternatives, are +equivalent. + +.TP +.B \-a +.TP +.B \-\-all +.TP +.B \- +Do not scan only the initialized and loaded sections of object files; +scan the whole files. + +.TP +.B \-f +.TP +.B \-\-print\-file\-name +Print the name of the file before each string. + +.TP +.B \-\-help +Print a summary of the options to +.B strings +on the standard output and exit. + +.TP +.B \-v +.TP +.B \-\-version +Print the version number +of +.B strings +on the standard output and exit. + +.TP +.B "\-n \fImin\-len\fP" +.TP +.B "\-\fImin\-len\fP" +.TP +.B "\-bytes=\fImin\-len\fP" +Print sequences of characters that are at least +.I min\-len +characters long, instead of the default 4. + +.TP +.BR "\-t " {o,x,d} +.TP +.BR "\-\-radix=" {o,x,d} +Print the offset within the file before each string. The single +character argument specifies the radix of the offset\(emoctal, +hexadecimal, or decimal. + +.TP +.BI "\-\-target=" "bfdname" +Specify an object code format other than your system's default format. +See +.BR objdump ( 1 ), +for information on listing available formats. + +.TP +.B \-o +Like +.BR "\-t o" . + +.PP + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.B +info\c +\&; +.I +The GNU Binary Utilities\c +\&, Roland H. Pesch (October 1991); +.BR ar ( 1 ), +.BR nm ( 1 ), +.BR objdump ( 1 ), +.BR ranlib ( 1 ). + + +.SH COPYING +Copyright (c) 1993 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/man/man1/mips-strip.1 b/oldbinutils/man/man1/mips-strip.1 new file mode 100644 index 0000000000..7974612194 --- /dev/null +++ b/oldbinutils/man/man1/mips-strip.1 @@ -0,0 +1,185 @@ +.\" Copyright (c) 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation +.\" See section COPYING for conditions for redistribution +.TH strip 1 "5 November 1991" "cygnus support" "GNU Development Tools" +.de BP +.sp +.ti \-.2i +\(** +.. + +.SH NAME +strip \- Discard symbols from object files. + +.SH SYNOPSIS +.hy 0 +.na +.TP +.B strip +.RB "[\|" \-F\ \fIbfdname\fR\ |\ \fB\-\-target=\fIbfdname\fP "\|]" +.RB "[\|" \-I\ \fIbfdname\fR\ |\ \fB\-\-input\-target=\fIbfdname\fP "\|]" +.RB "[\|" \-O\ \fIbfdname\fR\ |\ \fB\-\-output\-target=\fIbfdname\fP "\|]" +.RB "[\|" \-R\ \fIsectionname\fR\ |\ \fB\-\-remove\-section=\fIsectionname\fP "\|]" +.RB "[\|" \-s\fR\ |\ \fB\-\-strip\-all "\|]" +.RB "[\|" \-S\fR\ |\ \fB\-g\fR\ |\ \fB\-\-strip\-debug "\|]" +.RB "[\|" \-\-strip\-unneeded\fR "\|]" +.RB "[\|" \-x\fR\ |\ \fB\-\-discard\-all "\|]" +.RB "[\|" \-X\fR\ |\ \fB\-\-discard\-locals "\|]" +.RB "[\|" \-K\ \fIsymbolname\fR\ |\ \fB\-\-keep\-symbol=\fIsymbolname\fR "\|]" +.RB "[\|" \-N\ \fIsymbolname\fR\ |\ \fB\-\-strip\-symbol=\fIsymbolname\fR "\|]" +.RB "[\|" \-o\ \fIfile\f\R "\|]" +.RB "[\|" \-p\fR\ |\ \fB\-\-preserve\-dates "\|]" +.RB "[\|" \-v\fR\ |\ \fB\-\-verbose "\|]" +.RB "[\|" \-V\fR\ |\ \fB\-\-version "\|]" +.RB "[\|" \-V\fR\ |\ \fB\-\-help "\|]" +.I objfile\c +\&.\|.\|. + +.SH DESCRIPTION +GNU +.B strip +discards all symbols from the object files +.IR objfile . +The list of object files may include archives. +At least one object file must be given. + +.P +.B strip +modifies the files named in its argument, +rather than writing modified copies under different names. + +.SH OPTIONS +.TP +.B "\-F \fIbfdname" +.TP +.B "\-\-target=\fIbfdname" +Treat the original \fIobjfile\fP as a file with the object +code format \fIbfdname\fP, and rewrite it in the same format. + +.TP +.B \-\-help +Show a summary of the options to +.B strip +and exit. + +.TP +.B "\-I \fIbfdname +.TP +.B "\-\-input\-target=\fIbfdname" +Treat the original \fIobjfile\fP as a file with the object +code format \fIbfdname\fP. + +.TP +.B "\-O \fIbfdname\fP" +.TP +.B "\-\-output\-target=\fIbfdname" +Replace \fIobjfile\fP with a file in the output format \fIbfdname\fP. + +.TP +.B "\-R \fIsectionname\fP" +.TP +.B "\-\-remove\-section=\fIsectionname" +Remove the named section from the file. This option may be given more +than once. Note that using this option inappropriately may make the +object file unusable. + +.TP +.B \-s +.TP +.B \-\-strip\-all +Remove all symbols. + +.TP +.B \-S +.TP +.B \-g +.TP +.B \-\-strip\-debug +Remove debugging symbols only. + +.TP +.B \-\-strip\-unneeded +Strip all symbols that are not needed for relocation processing. + +.TP +.B \-N \fIsymbolname\fR +.TP +.B \-\-strip\-symbol=\fIsymbolname +Remove symbol \fIsymbolname\fP from the source file. This option +may be given more than once, and may be combined with other strip +options. + +.TP +.B \-o \fIfile\fR +Put the stripped output in \fIfile\fR, rather than replacing the +existing file. When this argument is used, only one \fIobjfile\fR +argument may be specified. + +.TP +.B \-p +.TP +.B \-\-preserve-dates +Preserve the access and modification dates of the file. + +.TP +.B \-x +.TP +.B \-\-discard\-all +Remove non-global symbols. + +.TP +.B \-X +.TP +.B \-\-discard\-locals +Remove compiler-generated local symbols. +(These usually start with ``L'' or ``.''.) + +.TP +.B \-K \fIsymbolname\fR, \fB\-\-keep\-symbol=\fIsymbolname +Copy only symbol \fIsymbolname\fP from the source file. This option +may be given more than once. + +.TP +.B \-N \fIsymbolname\fR, \fB\-\-strip\-symbol=\fIsymbolname +Do not copy symbol \fIsymbolname\fP from the source file. This option +may be given more than once, and may be combined with strip options +other than \fB\-K\fR. + +.TP +.B \-v +.TP +.B \-\-verbose +Verbose output: list all object files modified. In the case of +archives, +.B "strip \-V" +lists all members of the archive. + +.TP +.B \-V +.TP +.B \-\-version +Show the version number for \fBstrip\fP and exit. + +.SH "SEE ALSO" +.RB "`\|" binutils "\|'" +entry in +.BR info ; +.IR "The GNU Binary Utilities" , +Roland H. Pesch (October 1991). + +.SH COPYING +Copyright (c) 1991 Free Software Foundation, Inc. +.PP +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. +.PP +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. +.PP +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 included in +translations approved by the Free Software Foundation instead of in +the original English. diff --git a/oldbinutils/mips/bin/ar b/oldbinutils/mips/bin/ar new file mode 100755 index 0000000000..1b148076d6 Binary files /dev/null and b/oldbinutils/mips/bin/ar differ diff --git a/oldbinutils/mips/bin/as b/oldbinutils/mips/bin/as new file mode 100755 index 0000000000..d1fd3722d6 Binary files /dev/null and b/oldbinutils/mips/bin/as differ diff --git a/oldbinutils/mips/bin/ld b/oldbinutils/mips/bin/ld new file mode 100755 index 0000000000..91d95d733b Binary files /dev/null and b/oldbinutils/mips/bin/ld differ diff --git a/oldbinutils/mips/bin/nm b/oldbinutils/mips/bin/nm new file mode 100755 index 0000000000..53ea7806cc Binary files /dev/null and b/oldbinutils/mips/bin/nm differ diff --git a/oldbinutils/mips/bin/ranlib b/oldbinutils/mips/bin/ranlib new file mode 100755 index 0000000000..69d26a5927 Binary files /dev/null and b/oldbinutils/mips/bin/ranlib differ diff --git a/oldbinutils/mips/bin/strip b/oldbinutils/mips/bin/strip new file mode 100755 index 0000000000..6c8ab7cbee Binary files /dev/null and b/oldbinutils/mips/bin/strip differ diff --git a/oldbinutils/mips/lib/ldscripts/elf32ebmip.x b/oldbinutils/mips/lib/ldscripts/elf32ebmip.x new file mode 100644 index 0000000000..b255dc739c --- /dev/null +++ b/oldbinutils/mips/lib/ldscripts/elf32ebmip.x @@ -0,0 +1,141 @@ +OUTPUT_FORMAT("elf32-bigmips", "elf32-bigmips", + "elf32-littlemips") +OUTPUT_ARCH(mips) +ENTRY(_start) + SEARCH_DIR(/opt/cross/mips/lib); +/* Do we need any of these for elf? + __DYNAMIC = 0; */ +SECTIONS +{ + /* Read-only sections, merged into text segment: */ + . = 0x0400000; + .interp : { *(.interp) } + .reginfo : { *(.reginfo) } + .hash : { *(.hash) } + .dynsym : { *(.dynsym) } + .dynstr : { *(.dynstr) } + .gnu.version : { *(.gnu.version) } + .gnu.version_d : { *(.gnu.version_d) } + .gnu.version_r : { *(.gnu.version_r) } + .rel.text : + { *(.rel.text) *(.rel.gnu.linkonce.t*) } + .rela.text : + { *(.rela.text) *(.rela.gnu.linkonce.t*) } + .rel.data : + { *(.rel.data) *(.rel.gnu.linkonce.d*) } + .rela.data : + { *(.rela.data) *(.rela.gnu.linkonce.d*) } + .rel.rodata : + { *(.rel.rodata) *(.rel.gnu.linkonce.r*) } + .rela.rodata : + { *(.rela.rodata) *(.rela.gnu.linkonce.r*) } + .rel.got : { *(.rel.got) } + .rela.got : { *(.rela.got) } + .rel.ctors : { *(.rel.ctors) } + .rela.ctors : { *(.rela.ctors) } + .rel.dtors : { *(.rel.dtors) } + .rela.dtors : { *(.rela.dtors) } + .rel.init : { *(.rel.init) } + .rela.init : { *(.rela.init) } + .rel.fini : { *(.rel.fini) } + .rela.fini : { *(.rela.fini) } + .rel.bss : { *(.rel.bss) } + .rela.bss : { *(.rela.bss) } + .rel.plt : { *(.rel.plt) } + .rela.plt : { *(.rela.plt) } + .init : { *(.init) } =0 + .plt : { *(.plt) } + .text : + { + _ftext = . ; + *(.text) + *(.stub) + /* .gnu.warning sections are handled specially by elf32.em. */ + *(.gnu.warning) + *(.gnu.linkonce.t*) + *(.mips16.fn.*) *(.mips16.call.*) + } =0 + _etext = .; + PROVIDE (etext = .); + .fini : { *(.fini) } =0 + .rodata : { *(.rodata) *(.gnu.linkonce.r*) } + .rodata1 : { *(.rodata1) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + . = ALIGN(0x40000) + (. & (0x40000 - 1)); + .data : + { + _fdata = . ; + *(.data) + *(.gnu.linkonce.d*) + CONSTRUCTORS + } + .data1 : { *(.data1) } + .ctors : + { + *(.ctors) + } + .dtors : + { + *(.dtors) + } + _gp = ALIGN(16) + 0x7ff0; + .got : { *(.got.plt) *(.got) } + .dynamic : { *(.dynamic) } + /* We want the small data sections together, so single-instruction offsets + can access them all, and initialized data all before uninitialized, so + we can shorten the on-disk segment size. */ + .sdata : { *(.sdata) } + .lit8 : { *(.lit8) } + .lit4 : { *(.lit4) } + _edata = .; + PROVIDE (edata = .); + __bss_start = .; + _fbss = .; + .sbss : { *(.sbss) *(.scommon) } + .bss : + { + *(.dynbss) + *(.bss) + *(COMMON) + } + . = ALIGN(32 / 8); + _end = . ; + PROVIDE (end = .); + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + /* SGI/MIPS DWARF 2 extensions */ + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + /* These must appear regardless of . */ + .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) } + .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) } +} diff --git a/oldbinutils/mips/lib/ldscripts/elf32ebmip.xbn b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xbn new file mode 100644 index 0000000000..ccd1b5800b --- /dev/null +++ b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xbn @@ -0,0 +1,141 @@ +OUTPUT_FORMAT("elf32-bigmips", "elf32-bigmips", + "elf32-littlemips") +OUTPUT_ARCH(mips) +ENTRY(_start) + SEARCH_DIR(/opt/cross/mips/lib); +/* Do we need any of these for elf? + __DYNAMIC = 0; */ +SECTIONS +{ + /* Read-only sections, merged into text segment: */ + . = 0x0400000; + .interp : { *(.interp) } + .reginfo : { *(.reginfo) } + .hash : { *(.hash) } + .dynsym : { *(.dynsym) } + .dynstr : { *(.dynstr) } + .gnu.version : { *(.gnu.version) } + .gnu.version_d : { *(.gnu.version_d) } + .gnu.version_r : { *(.gnu.version_r) } + .rel.text : + { *(.rel.text) *(.rel.gnu.linkonce.t*) } + .rela.text : + { *(.rela.text) *(.rela.gnu.linkonce.t*) } + .rel.data : + { *(.rel.data) *(.rel.gnu.linkonce.d*) } + .rela.data : + { *(.rela.data) *(.rela.gnu.linkonce.d*) } + .rel.rodata : + { *(.rel.rodata) *(.rel.gnu.linkonce.r*) } + .rela.rodata : + { *(.rela.rodata) *(.rela.gnu.linkonce.r*) } + .rel.got : { *(.rel.got) } + .rela.got : { *(.rela.got) } + .rel.ctors : { *(.rel.ctors) } + .rela.ctors : { *(.rela.ctors) } + .rel.dtors : { *(.rel.dtors) } + .rela.dtors : { *(.rela.dtors) } + .rel.init : { *(.rel.init) } + .rela.init : { *(.rela.init) } + .rel.fini : { *(.rel.fini) } + .rela.fini : { *(.rela.fini) } + .rel.bss : { *(.rel.bss) } + .rela.bss : { *(.rela.bss) } + .rel.plt : { *(.rel.plt) } + .rela.plt : { *(.rela.plt) } + .init : { *(.init) } =0 + .plt : { *(.plt) } + .text : + { + _ftext = . ; + *(.text) + *(.stub) + /* .gnu.warning sections are handled specially by elf32.em. */ + *(.gnu.warning) + *(.gnu.linkonce.t*) + *(.mips16.fn.*) *(.mips16.call.*) + } =0 + _etext = .; + PROVIDE (etext = .); + .fini : { *(.fini) } =0 + .rodata : { *(.rodata) *(.gnu.linkonce.r*) } + .rodata1 : { *(.rodata1) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + . = .; + .data : + { + _fdata = . ; + *(.data) + *(.gnu.linkonce.d*) + CONSTRUCTORS + } + .data1 : { *(.data1) } + .ctors : + { + *(.ctors) + } + .dtors : + { + *(.dtors) + } + _gp = ALIGN(16) + 0x7ff0; + .got : { *(.got.plt) *(.got) } + .dynamic : { *(.dynamic) } + /* We want the small data sections together, so single-instruction offsets + can access them all, and initialized data all before uninitialized, so + we can shorten the on-disk segment size. */ + .sdata : { *(.sdata) } + .lit8 : { *(.lit8) } + .lit4 : { *(.lit4) } + _edata = .; + PROVIDE (edata = .); + __bss_start = .; + _fbss = .; + .sbss : { *(.sbss) *(.scommon) } + .bss : + { + *(.dynbss) + *(.bss) + *(COMMON) + } + . = ALIGN(32 / 8); + _end = . ; + PROVIDE (end = .); + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + /* SGI/MIPS DWARF 2 extensions */ + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + /* These must appear regardless of . */ + .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) } + .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) } +} diff --git a/oldbinutils/mips/lib/ldscripts/elf32ebmip.xn b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xn new file mode 100644 index 0000000000..b255dc739c --- /dev/null +++ b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xn @@ -0,0 +1,141 @@ +OUTPUT_FORMAT("elf32-bigmips", "elf32-bigmips", + "elf32-littlemips") +OUTPUT_ARCH(mips) +ENTRY(_start) + SEARCH_DIR(/opt/cross/mips/lib); +/* Do we need any of these for elf? + __DYNAMIC = 0; */ +SECTIONS +{ + /* Read-only sections, merged into text segment: */ + . = 0x0400000; + .interp : { *(.interp) } + .reginfo : { *(.reginfo) } + .hash : { *(.hash) } + .dynsym : { *(.dynsym) } + .dynstr : { *(.dynstr) } + .gnu.version : { *(.gnu.version) } + .gnu.version_d : { *(.gnu.version_d) } + .gnu.version_r : { *(.gnu.version_r) } + .rel.text : + { *(.rel.text) *(.rel.gnu.linkonce.t*) } + .rela.text : + { *(.rela.text) *(.rela.gnu.linkonce.t*) } + .rel.data : + { *(.rel.data) *(.rel.gnu.linkonce.d*) } + .rela.data : + { *(.rela.data) *(.rela.gnu.linkonce.d*) } + .rel.rodata : + { *(.rel.rodata) *(.rel.gnu.linkonce.r*) } + .rela.rodata : + { *(.rela.rodata) *(.rela.gnu.linkonce.r*) } + .rel.got : { *(.rel.got) } + .rela.got : { *(.rela.got) } + .rel.ctors : { *(.rel.ctors) } + .rela.ctors : { *(.rela.ctors) } + .rel.dtors : { *(.rel.dtors) } + .rela.dtors : { *(.rela.dtors) } + .rel.init : { *(.rel.init) } + .rela.init : { *(.rela.init) } + .rel.fini : { *(.rel.fini) } + .rela.fini : { *(.rela.fini) } + .rel.bss : { *(.rel.bss) } + .rela.bss : { *(.rela.bss) } + .rel.plt : { *(.rel.plt) } + .rela.plt : { *(.rela.plt) } + .init : { *(.init) } =0 + .plt : { *(.plt) } + .text : + { + _ftext = . ; + *(.text) + *(.stub) + /* .gnu.warning sections are handled specially by elf32.em. */ + *(.gnu.warning) + *(.gnu.linkonce.t*) + *(.mips16.fn.*) *(.mips16.call.*) + } =0 + _etext = .; + PROVIDE (etext = .); + .fini : { *(.fini) } =0 + .rodata : { *(.rodata) *(.gnu.linkonce.r*) } + .rodata1 : { *(.rodata1) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + . = ALIGN(0x40000) + (. & (0x40000 - 1)); + .data : + { + _fdata = . ; + *(.data) + *(.gnu.linkonce.d*) + CONSTRUCTORS + } + .data1 : { *(.data1) } + .ctors : + { + *(.ctors) + } + .dtors : + { + *(.dtors) + } + _gp = ALIGN(16) + 0x7ff0; + .got : { *(.got.plt) *(.got) } + .dynamic : { *(.dynamic) } + /* We want the small data sections together, so single-instruction offsets + can access them all, and initialized data all before uninitialized, so + we can shorten the on-disk segment size. */ + .sdata : { *(.sdata) } + .lit8 : { *(.lit8) } + .lit4 : { *(.lit4) } + _edata = .; + PROVIDE (edata = .); + __bss_start = .; + _fbss = .; + .sbss : { *(.sbss) *(.scommon) } + .bss : + { + *(.dynbss) + *(.bss) + *(COMMON) + } + . = ALIGN(32 / 8); + _end = . ; + PROVIDE (end = .); + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + /* SGI/MIPS DWARF 2 extensions */ + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + /* These must appear regardless of . */ + .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) } + .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) } +} diff --git a/oldbinutils/mips/lib/ldscripts/elf32ebmip.xr b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xr new file mode 100644 index 0000000000..f693bffb7e --- /dev/null +++ b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xr @@ -0,0 +1,122 @@ +OUTPUT_FORMAT("elf32-bigmips", "elf32-bigmips", + "elf32-littlemips") +OUTPUT_ARCH(mips) +ENTRY(_start) + /* For some reason, the Solaris linker makes bad executables + if gld -r is used and the intermediate file has sections starting + at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld + bug. But for now assigning the zero vmas works. */ +SECTIONS +{ + /* Read-only sections, merged into text segment: */ + .interp 0 : { *(.interp) } + .reginfo : { *(.reginfo) } + .hash 0 : { *(.hash) } + .dynsym 0 : { *(.dynsym) } + .dynstr 0 : { *(.dynstr) } + .gnu.version 0 : { *(.gnu.version) } + .gnu.version_d 0 : { *(.gnu.version_d) } + .gnu.version_r 0 : { *(.gnu.version_r) } + .rel.text 0 : + { *(.rel.text) } + .rela.text 0 : + { *(.rela.text) } + .rel.data 0 : + { *(.rel.data) } + .rela.data 0 : + { *(.rela.data) } + .rel.rodata 0 : + { *(.rel.rodata) } + .rela.rodata 0 : + { *(.rela.rodata) } + .rel.got 0 : { *(.rel.got) } + .rela.got 0 : { *(.rela.got) } + .rel.ctors 0 : { *(.rel.ctors) } + .rela.ctors 0 : { *(.rela.ctors) } + .rel.dtors 0 : { *(.rel.dtors) } + .rela.dtors 0 : { *(.rela.dtors) } + .rel.init 0 : { *(.rel.init) } + .rela.init 0 : { *(.rela.init) } + .rel.fini 0 : { *(.rel.fini) } + .rela.fini 0 : { *(.rela.fini) } + .rel.bss 0 : { *(.rel.bss) } + .rela.bss 0 : { *(.rela.bss) } + .rel.plt 0 : { *(.rel.plt) } + .rela.plt 0 : { *(.rela.plt) } + .init 0 : { *(.init) } =0 + .plt 0 : { *(.plt) } + .text 0 : + { + *(.text) + *(.stub) + /* .gnu.warning sections are handled specially by elf32.em. */ + *(.gnu.warning) + } =0 + .fini 0 : { *(.fini) } =0 + .rodata 0 : { *(.rodata) } + .rodata1 0 : { *(.rodata1) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + .data 0 : + { + *(.data) + } + .data1 0 : { *(.data1) } + .ctors 0 : + { + *(.ctors) + } + .dtors 0 : + { + *(.dtors) + } + .got 0 : { *(.got.plt) *(.got) } + .dynamic 0 : { *(.dynamic) } + /* We want the small data sections together, so single-instruction offsets + can access them all, and initialized data all before uninitialized, so + we can shorten the on-disk segment size. */ + .sdata 0 : { *(.sdata) } + .sbss 0 : { *(.sbss) *(.scommon) } + .bss 0 : + { + *(.dynbss) + *(.bss) + *(COMMON) + } + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + /* SGI/MIPS DWARF 2 extensions */ + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + /* These must appear regardless of . */ + .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) } + .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) } +} diff --git a/oldbinutils/mips/lib/ldscripts/elf32ebmip.xs b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xs new file mode 100644 index 0000000000..0a1df6571c --- /dev/null +++ b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xs @@ -0,0 +1,140 @@ +OUTPUT_FORMAT("elf32-bigmips", "elf32-bigmips", + "elf32-littlemips") +OUTPUT_ARCH(mips) +ENTRY(_start) + SEARCH_DIR(/opt/cross/mips/lib); +/* Do we need any of these for elf? + __DYNAMIC = 0; */ +SECTIONS +{ + /* Read-only sections, merged into text segment: */ + . = 0x5ffe0000 + SIZEOF_HEADERS; + .reginfo : { *(.reginfo) } + .hash : { *(.hash) } + .dynsym : { *(.dynsym) } + .dynstr : { *(.dynstr) } + .gnu.version : { *(.gnu.version) } + .gnu.version_d : { *(.gnu.version_d) } + .gnu.version_r : { *(.gnu.version_r) } + .rel.text : + { *(.rel.text) *(.rel.gnu.linkonce.t*) } + .rela.text : + { *(.rela.text) *(.rela.gnu.linkonce.t*) } + .rel.data : + { *(.rel.data) *(.rel.gnu.linkonce.d*) } + .rela.data : + { *(.rela.data) *(.rela.gnu.linkonce.d*) } + .rel.rodata : + { *(.rel.rodata) *(.rel.gnu.linkonce.r*) } + .rela.rodata : + { *(.rela.rodata) *(.rela.gnu.linkonce.r*) } + .rel.got : { *(.rel.got) } + .rela.got : { *(.rela.got) } + .rel.ctors : { *(.rel.ctors) } + .rela.ctors : { *(.rela.ctors) } + .rel.dtors : { *(.rel.dtors) } + .rela.dtors : { *(.rela.dtors) } + .rel.init : { *(.rel.init) } + .rela.init : { *(.rela.init) } + .rel.fini : { *(.rel.fini) } + .rela.fini : { *(.rela.fini) } + .rel.bss : { *(.rel.bss) } + .rela.bss : { *(.rela.bss) } + .rel.plt : { *(.rel.plt) } + .rela.plt : { *(.rela.plt) } + .init : { *(.init) } =0 + .plt : { *(.plt) } + .text : + { + _ftext = . ; + *(.text) + *(.stub) + /* .gnu.warning sections are handled specially by elf32.em. */ + *(.gnu.warning) + *(.gnu.linkonce.t*) + *(.mips16.fn.*) *(.mips16.call.*) + } =0 + _etext = .; + PROVIDE (etext = .); + .fini : { *(.fini) } =0 + .rodata : { *(.rodata) *(.gnu.linkonce.r*) } + .rodata1 : { *(.rodata1) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + . = ALIGN(0x40000) + (. & (0x40000 - 1)); + .data : + { + _fdata = . ; + *(.data) + *(.gnu.linkonce.d*) + CONSTRUCTORS + } + .data1 : { *(.data1) } + .ctors : + { + *(.ctors) + } + .dtors : + { + *(.dtors) + } + _gp = ALIGN(16) + 0x7ff0; + .got : { *(.got.plt) *(.got) } + .dynamic : { *(.dynamic) } + /* We want the small data sections together, so single-instruction offsets + can access them all, and initialized data all before uninitialized, so + we can shorten the on-disk segment size. */ + .sdata : { *(.sdata) } + .lit8 : { *(.lit8) } + .lit4 : { *(.lit4) } + _edata = .; + PROVIDE (edata = .); + __bss_start = .; + _fbss = .; + .sbss : { *(.sbss) *(.scommon) } + .bss : + { + *(.dynbss) + *(.bss) + *(COMMON) + } + . = ALIGN(32 / 8); + _end = . ; + PROVIDE (end = .); + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + /* SGI/MIPS DWARF 2 extensions */ + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + /* These must appear regardless of . */ + .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) } + .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) } +} diff --git a/oldbinutils/mips/lib/ldscripts/elf32ebmip.xu b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xu new file mode 100644 index 0000000000..2dc5132e5a --- /dev/null +++ b/oldbinutils/mips/lib/ldscripts/elf32ebmip.xu @@ -0,0 +1,123 @@ +OUTPUT_FORMAT("elf32-bigmips", "elf32-bigmips", + "elf32-littlemips") +OUTPUT_ARCH(mips) +ENTRY(_start) + /* For some reason, the Solaris linker makes bad executables + if gld -r is used and the intermediate file has sections starting + at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld + bug. But for now assigning the zero vmas works. */ +SECTIONS +{ + /* Read-only sections, merged into text segment: */ + .interp 0 : { *(.interp) } + .reginfo : { *(.reginfo) } + .hash 0 : { *(.hash) } + .dynsym 0 : { *(.dynsym) } + .dynstr 0 : { *(.dynstr) } + .gnu.version 0 : { *(.gnu.version) } + .gnu.version_d 0 : { *(.gnu.version_d) } + .gnu.version_r 0 : { *(.gnu.version_r) } + .rel.text 0 : + { *(.rel.text) } + .rela.text 0 : + { *(.rela.text) } + .rel.data 0 : + { *(.rel.data) } + .rela.data 0 : + { *(.rela.data) } + .rel.rodata 0 : + { *(.rel.rodata) } + .rela.rodata 0 : + { *(.rela.rodata) } + .rel.got 0 : { *(.rel.got) } + .rela.got 0 : { *(.rela.got) } + .rel.ctors 0 : { *(.rel.ctors) } + .rela.ctors 0 : { *(.rela.ctors) } + .rel.dtors 0 : { *(.rel.dtors) } + .rela.dtors 0 : { *(.rela.dtors) } + .rel.init 0 : { *(.rel.init) } + .rela.init 0 : { *(.rela.init) } + .rel.fini 0 : { *(.rel.fini) } + .rela.fini 0 : { *(.rela.fini) } + .rel.bss 0 : { *(.rel.bss) } + .rela.bss 0 : { *(.rela.bss) } + .rel.plt 0 : { *(.rel.plt) } + .rela.plt 0 : { *(.rela.plt) } + .init 0 : { *(.init) } =0 + .plt 0 : { *(.plt) } + .text 0 : + { + *(.text) + *(.stub) + /* .gnu.warning sections are handled specially by elf32.em. */ + *(.gnu.warning) + } =0 + .fini 0 : { *(.fini) } =0 + .rodata 0 : { *(.rodata) } + .rodata1 0 : { *(.rodata1) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + .data 0 : + { + *(.data) + CONSTRUCTORS + } + .data1 0 : { *(.data1) } + .ctors 0 : + { + *(.ctors) + } + .dtors 0 : + { + *(.dtors) + } + .got 0 : { *(.got.plt) *(.got) } + .dynamic 0 : { *(.dynamic) } + /* We want the small data sections together, so single-instruction offsets + can access them all, and initialized data all before uninitialized, so + we can shorten the on-disk segment size. */ + .sdata 0 : { *(.sdata) } + .sbss 0 : { *(.sbss) *(.scommon) } + .bss 0 : + { + *(.dynbss) + *(.bss) + *(COMMON) + } + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + /* SGI/MIPS DWARF 2 extensions */ + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + /* These must appear regardless of . */ + .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) } + .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) } +} diff --git a/papermario/Makefile b/papermario/Makefile index 5a1b750094..dae007480f 100644 --- a/papermario/Makefile +++ b/papermario/Makefile @@ -7,13 +7,13 @@ BUILD_DIR = build ##################### Compiler Options ####################### CROSS = mips-linux-gnu- -AS = $(CROSS)as +AS = ../oldbinutils/bin/mips-nintendo-nu64-as CC = $(CROSS)gcc -LD = $(CROSS)ld -OBJDUMP = $(CROSS)objdump -OBJCOPY = $(CROSS)objcopy +LD = ../oldbinutils/bin/mips-ld +OBJDUMP = ../oldbinutils/bin/mips-objdump +OBJCOPY = ../oldbinutils/bin/mips-objcopy -ASFLAGS = -EB -mtune=vr4300 -march=vr4300 +ASFLAGS = -EB -mcpu=vr4300 CFLAGS = -Wall -O2 -mtune=vr4300 -march=vr4300 -G 0 -c LDFLAGS = -T undefined_syms.txt -T $(LD_SCRIPT) -Map $(BUILD_DIR)/sm64.map diff --git a/papermario/fix_asm.py b/papermario/fix_asm.py new file mode 100755 index 0000000000..79e5eb887f --- /dev/null +++ b/papermario/fix_asm.py @@ -0,0 +1,23 @@ +#!/usr/bin/python3 + +import os +import re + +script_dir = os.path.dirname(os.path.realpath(__file__)) +asm_dir = script_dir + "/asm/" + +regs = ["zero", "at", "v0", "v1", "a0", "a1", "a2", "a3", "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "s0", + "s1", "s2", "s3", "s4", "s5", "s6", "s7", "t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra"] + +for root, dirs, files in os.walk(asm_dir): + for file in files: + if file.endswith(".s"): + with open(os.path.join(root, file)) as f: + file_text_orig = f.read() + file_text = file_text_orig + for reg in regs: + regex = re.compile("\\$" + reg) + file_text = re.sub(regex, "$" + str(regs.index(reg)), file_text) + if file_text != file_text_orig: + with open(os.path.join(root, file), "w") as f: + f.write(file_text) \ No newline at end of file