From 66fdbc00cfad3be604d07da78b916f4c04f96dbc Mon Sep 17 00:00:00 2001 From: paul Date: Wed, 3 Nov 1993 23:41:59 +0000 Subject: Imported NetBSD's ld for shared libs. --- gnu/usr.bin/ld/ld.c | 6562 +++++++++++++++++++-------------------------------- 1 file changed, 2404 insertions(+), 4158 deletions(-) (limited to 'gnu/usr.bin/ld/ld.c') diff --git a/gnu/usr.bin/ld/ld.c b/gnu/usr.bin/ld/ld.c index f871f00..a22d256 100644 --- a/gnu/usr.bin/ld/ld.c +++ b/gnu/usr.bin/ld/ld.c @@ -3,6 +3,8 @@ * Foundation. * * Modified 1991 by Donn Seeley at UUNET Technologies, Inc. + * + * Modified 1993 by Paul Kranenburg, Erasmus University */ #ifndef lint @@ -27,1643 +29,969 @@ static char sccsid[] = "@(#)ld.c 6.10 (Berkeley) 5/22/91"; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by Richard Stallman with some help from Eric Albert. - Set, indirect, and warning symbol features added by Randy Smith. */ + Set, indirect, and warning symbol features added by Randy Smith. + + NOTE: Set and indirect symbols are no longer supported by this + version. (pk) */ + +/* + * $Id: ld.c,v 1.10 1993/11/01 16:26:13 pk Exp $ + */ /* Define how to initialize system-dependent header fields. */ -#include +#include #include +#include #include #include #include #include #include #include +#include +#include #include #include #include +#include -/* symseg.h defines the obsolete GNU debugging format; we should nuke it. */ -#define CORE_ADDR unsigned long /* For symseg.h */ -#include "symseg.h" - -#define N_SET_MAGIC(exec, val) ((exec).a_magic = val) +#include "ld.h" -/* If compiled with GNU C, use the built-in alloca */ -#ifdef __GNUC__ -#define alloca __builtin_alloca -#endif - -#define min(a,b) ((a) < (b) ? (a) : (b)) +int building_shared_object; -/* Macro to control the number of undefined references printed */ -#define MAX_UREFS_PRINTED 10 +/* 1 => write relocation into output file so can re-input it later. */ +int relocatable_output; -/* Size of a page; obtained from the operating system. */ +/* Non zero means to create the output executable. */ +/* Cleared by nonfatal errors. */ +int make_executable; -int page_size; +/* Force the executable to be output, even if there are non-fatal errors */ +int force_executable; -/* Name this program was invoked by. */ +/* 1 => assign space to common symbols even if `relocatable_output'. */ +int force_common_definition; + +/* 1 => assign jmp slots to text symbols in shared objects even if non-PIC */ +int force_alias_definition; -char *progname; - -/* System dependencies */ +/* + * Which symbols should be stripped (omitted from the output): none, all, or + * debugger symbols. + */ +enum { + STRIP_NONE, STRIP_ALL, STRIP_DEBUGGER +} strip_symbols; -/* Define this to specify the default executable format. */ +/* + * Which local symbols should be omitted: none, all, or those starting with L. + * This is irrelevant if STRIP_NONE. + */ +enum { + DISCARD_NONE, DISCARD_ALL, DISCARD_L +} discard_locals; -#ifndef DEFAULT_MAGIC -#define DEFAULT_MAGIC ZMAGIC -#endif +/* Nonzero means print names of input files as processed. */ +int trace_files; -#ifdef hp300 -#define INITIALIZE_HEADER outheader.a_mid = MID_HP300 -#endif +/* Magic number to use for the output file, set by switch. */ +int magic; /* - * Ok. Following are the relocation information macros. If your - * system should not be able to use the default set (below), you must - * define the following: - - * relocation_info: This must be typedef'd (or #define'd) to the type - * of structure that is stored in the relocation info section of your - * a.out files. Often this is defined in the a.out.h for your system. - * - * RELOC_ADDRESS (rval): Offset into the current section of the - * to be relocated. *Must be an lvalue*. - * - * RELOC_EXTERN_P (rval): Is this relocation entry based on an - * external symbol (1), or was it fully resolved upon entering the - * loader (0) in which case some combination of the value in memory - * (if RELOC_MEMORY_ADD_P) and the extra (if RELOC_ADD_EXTRA) contains - * what the value of the relocation actually was. *Must be an lvalue*. - * - * RELOC_TYPE (rval): If this entry was fully resolved upon - * entering the loader, what type should it be relocated as? - * - * RELOC_SYMBOL (rval): If this entry was not fully resolved upon - * entering the loader, what is the index of it's symbol in the symbol - * table? *Must be a lvalue*. - * - * RELOC_MEMORY_ADD_P (rval): This should return true if the final - * relocation value output here should be added to memory, or if the - * section of memory described should simply be set to the relocation - * value. - * - * RELOC_ADD_EXTRA (rval): (Optional) This macro, if defined, gives - * an extra value to be added to the relocation value based on the - * individual relocation entry. *Must be an lvalue if defined*. - * - * RELOC_PCREL_P (rval): True if the relocation value described is - * pc relative. - * - * RELOC_VALUE_RIGHTSHIFT (rval): Number of bits right to shift the - * final relocation value before putting it where it belongs. - * - * RELOC_TARGET_SIZE (rval): log to the base 2 of the number of - * bytes of size this relocation entry describes; 1 byte == 0; 2 bytes - * == 1; 4 bytes == 2, and etc. This is somewhat redundant (we could - * do everything in terms of the bit operators below), but having this - * macro could end up producing better code on machines without fancy - * bit twiddling. Also, it's easier to understand/code big/little - * endian distinctions with this macro. - * - * RELOC_TARGET_BITPOS (rval): The starting bit position within the - * object described in RELOC_TARGET_SIZE in which the relocation value - * will go. - * - * RELOC_TARGET_BITSIZE (rval): How many bits are to be replaced - * with the bits of the relocation value. It may be assumed by the - * code that the relocation value will fit into this many bits. This - * may be larger than RELOC_TARGET_SIZE if such be useful. - * - * - * Things I haven't implemented - * ---------------------------- - * - * Values for RELOC_TARGET_SIZE other than 0, 1, or 2. - * - * Pc relative relocation for External references. - * - * + * `text-start' address is normally this much plus a page boundary. + * This is not a user option; it is fixed for each system. */ +int text_start_alignment; -/* The following #if has been modifed for cross compilation */ -/* It originally read: #if defined(sun) && defined(sparc) */ -/* Marc Ullman, Stanford University Nov. 1 1989 */ -#if defined(sun) && (TARGET == SUN4) -/* Sparc (Sun 4) macros */ -#undef relocation_info -#define relocation_info reloc_info_sparc -#define RELOC_ADDRESS(r) ((r)->r_address) -#define RELOC_EXTERN_P(r) ((r)->r_extern) -#define RELOC_TYPE(r) ((r)->r_index) -#define RELOC_SYMBOL(r) ((r)->r_index) -#define RELOC_MEMORY_SUB_P(r) 0 -#define RELOC_MEMORY_ADD_P(r) 0 -#define RELOC_ADD_EXTRA(r) ((r)->r_addend) -#define RELOC_PCREL_P(r) \ - ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22) -#define RELOC_VALUE_RIGHTSHIFT(r) (reloc_target_rightshift[(r)->r_type]) -#define RELOC_TARGET_SIZE(r) (reloc_target_size[(r)->r_type]) -#define RELOC_TARGET_BITPOS(r) 0 -#define RELOC_TARGET_BITSIZE(r) (reloc_target_bitsize[(r)->r_type]) - -/* Note that these are very dependent on the order of the enums in - enum reloc_type (in a.out.h); if they change the following must be - changed */ -/* Also note that the last few may be incorrect; I have no information */ -static int reloc_target_rightshift[] = { - 0, 0, 0, 0, 0, 0, 2, 2, 10, 0, 0, 0, 0, 0, 0, -}; -static int reloc_target_size[] = { - 0, 1, 2, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -}; -static int reloc_target_bitsize[] = { - 8, 16, 32, 8, 16, 32, 30, 22, 22, 22, 13, 10, 32, 32, 16, -}; - -#define MAX_ALIGNMENT (sizeof (double)) -#endif - -/* Default macros */ -#ifndef RELOC_ADDRESS -#define RELOC_ADDRESS(r) ((r)->r_address) -#define RELOC_EXTERN_P(r) ((r)->r_extern) -#define RELOC_TYPE(r) ((r)->r_symbolnum) -#define RELOC_SYMBOL(r) ((r)->r_symbolnum) -#define RELOC_MEMORY_SUB_P(r) 0 -#define RELOC_MEMORY_ADD_P(r) 1 -#undef RELOC_ADD_EXTRA -#define RELOC_PCREL_P(r) ((r)->r_pcrel) -#define RELOC_VALUE_RIGHTSHIFT(r) 0 -#define RELOC_TARGET_SIZE(r) ((r)->r_length) -#define RELOC_TARGET_BITPOS(r) 0 -#define RELOC_TARGET_BITSIZE(r) 32 -#endif +/* + * Nonzero if -T was specified in the command line. + * This prevents text_start from being set later to default values. + */ +int T_flag_specified; + +/* + * Nonzero if -Tdata was specified in the command line. + * This prevents data_start from being set later to default values. + */ +int Tdata_flag_specified; -#ifndef MAX_ALIGNMENT -#define MAX_ALIGNMENT (sizeof (int)) -#endif +/* + * Size to pad data section up to. + * We simply increase the size of the data section, padding with zeros, + * and reduce the size of the bss section to match. + */ +int specified_data_size; -#ifdef nounderscore -#define LPREFIX '.' -#else -#define LPREFIX 'L' -#endif +long *set_vectors; +int setv_fill_count; -#ifndef TEXT_START -#define TEXT_START(x) N_TXTADDR(x) -#endif - -/* Special global symbol types understood by GNU LD. */ +int +main(argc, argv) + char **argv; + int argc; +{ -/* The following type indicates the definition of a symbol as being - an indirect reference to another symbol. The other symbol - appears as an undefined reference, immediately following this symbol. + if ((progname = strrchr(argv[0], '/')) == NULL) + progname = argv[0]; + else + progname++; - Indirection is asymmetrical. The other symbol's value will be used - to satisfy requests for the indirect symbol, but not vice versa. - If the other symbol does not have a definition, libraries will - be searched to find a definition. + /* Added this to stop ld core-dumping on very large .o files. */ +#ifdef RLIMIT_STACK + /* Get rid of any avoidable limit on stack size. */ + { + struct rlimit rlim; - So, for example, the following two lines placed in an assembler - input file would result in an object file which would direct gnu ld - to resolve all references to symbol "foo" as references to symbol - "bar". + /* Set the stack limit huge so that alloca does not fail. */ + getrlimit(RLIMIT_STACK, &rlim); + rlim.rlim_cur = rlim.rlim_max; + setrlimit(RLIMIT_STACK, &rlim); + } +#endif /* RLIMIT_STACK */ + + page_size = PAGSIZ; + + /* Clear the cumulative info on the output file. */ + + text_size = 0; + data_size = 0; + bss_size = 0; + text_reloc_size = 0; + data_reloc_size = 0; - .stabs "_foo",11,0,0,0 - .stabs "_bar",1,0,0,0 + data_pad = 0; + text_pad = 0; - Note that (11 == (N_INDR | N_EXT)) and (1 == (N_UNDF | N_EXT)). */ + /* Initialize the data about options. */ -#ifndef N_INDR -#define N_INDR 0xa -#endif + specified_data_size = 0; + strip_symbols = STRIP_NONE; + trace_files = 0; + discard_locals = DISCARD_NONE; + entry_symbol = 0; + write_map = 0; + relocatable_output = 0; + force_common_definition = 0; + T_flag_specified = 0; + Tdata_flag_specified = 0; + magic = DEFAULT_MAGIC; + make_executable = 1; + force_executable = 0; + link_mode = DYNAMIC; + soversion = LD_VERSION_BSD; -/* The following symbols refer to set elements. These are expected - only in input to the loader; they should not appear in loader - output (unless relocatable output is requested). To be recognized - by the loader, the input symbols must have their N_EXT bit set. - All the N_SET[ATDB] symbols with the same name form one set. The - loader collects all of these elements at load time and outputs a - vector for each name. - Space (an array of 32 bit words) is allocated for the set in the - data section, and the n_value field of each set element value is - stored into one word of the array. - The first word of the array is the length of the set (number of - elements). The last word of the vector is set to zero for possible - use by incremental loaders. The array is ordered by the linkage - order; the first symbols which the linker encounters will be first - in the array. - - In C syntax this looks like: - - struct set_vector { - unsigned int length; - unsigned int vector[length]; - unsigned int always_zero; - }; - - Before being placed into the array, each element is relocated - according to its type. This allows the loader to create an array - of pointers to objects automatically. N_SETA type symbols will not - be relocated. - - The address of the set is made into an N_SETV symbol - whose name is the same as the name of the set. - This symbol acts like a N_DATA global symbol - in that it can satisfy undefined external references. - - For the purposes of determining whether or not to load in a library - file, set element definitions are not considered "real - definitions"; they will not cause the loading of a library - member. - - If relocatable output is requested, none of this processing is - done. The symbols are simply relocated and passed through to the - output file. - - So, for example, the following three lines of assembler code - (whether in one file or scattered between several different ones) - will produce a three element vector (total length is five words; - see above), referenced by the symbol "_xyzzy", which will have the - addresses of the routines _init1, _init2, and _init3. - - *NOTE*: If symbolic addresses are used in the n_value field of the - defining .stabs, those symbols must be defined in the same file as - that containing the .stabs. - - .stabs "_xyzzy",23,0,0,_init1 - .stabs "_xyzzy",23,0,0,_init2 - .stabs "_xyzzy",23,0,0,_init3 - - Note that (23 == (N_SETT | N_EXT)). */ - -#ifndef N_SETA -#define N_SETA 0x14 /* Absolute set element symbol */ -#endif /* This is input to LD, in a .o file. */ - -#ifndef N_SETT -#define N_SETT 0x16 /* Text set element symbol */ -#endif /* This is input to LD, in a .o file. */ - -#ifndef N_SETD -#define N_SETD 0x18 /* Data set element symbol */ -#endif /* This is input to LD, in a .o file. */ - -#ifndef N_SETB -#define N_SETB 0x1A /* Bss set element symbol */ -#endif /* This is input to LD, in a .o file. */ - -/* Macros dealing with the set element symbols defined in a.out.h */ -#define SET_ELEMENT_P(x) ((x)>=N_SETA&&(x)<=(N_SETB|N_EXT)) -#define TYPE_OF_SET_ELEMENT(x) ((x)-N_SETA+N_ABS) - -#ifndef N_SETV -#define N_SETV 0x1C /* Pointer to set vector in data area. */ -#endif /* This is output from LD. */ - -/* If a this type of symbol is encountered, its name is a warning - message to print each time the symbol referenced by the next symbol - table entry is referenced. - - This feature may be used to allow backwards compatibility with - certain functions (eg. gets) but to discourage programmers from - their use. - - So if, for example, you wanted to have ld print a warning whenever - the function "gets" was used in their C program, you would add the - following to the assembler file in which gets is defined: - - .stabs "Obsolete function \"gets\" referenced",30,0,0,0 - .stabs "_gets",1,0,0,0 - - These .stabs do not necessarily have to be in the same file as the - gets function, they simply must exist somewhere in the compilation. */ - -#ifndef N_WARNING -#define N_WARNING 0x1E /* Warning message to print if symbol - included */ -#endif /* This is input to ld */ - -#ifndef __GNU_STAB__ - -/* Line number for the data section. This is to be used to describe - the source location of a variable declaration. */ -#ifndef N_DSLINE -#define N_DSLINE (N_SLINE+N_DATA-N_TEXT) -#endif + /* Initialize the cumulative counts of symbols. */ -/* Line number for the bss section. This is to be used to describe - the source location of a variable declaration. */ -#ifndef N_BSLINE -#define N_BSLINE (N_SLINE+N_BSS-N_TEXT) -#endif + local_sym_count = 0; + non_L_local_sym_count = 0; + debugger_sym_count = 0; + undefined_global_sym_count = 0; + warning_count = 0; + multiple_def_count = 0; + common_defined_global_count = 0; -#endif /* not __GNU_STAB__ */ - -/* Symbol table */ - -/* Global symbol data is recorded in these structures, - one for each global symbol. - They are found via hashing in 'symtab', which points to a vector of buckets. - Each bucket is a chain of these structures through the link field. */ - -typedef - struct glosym - { - /* Pointer to next symbol in this symbol's hash bucket. */ - struct glosym *link; - /* Name of this symbol. */ - char *name; - /* Value of this symbol as a global symbol. */ - long value; - /* Chain of external 'nlist's in files for this symbol, both defs - and refs. */ - struct nlist *refs; - /* Any warning message that might be associated with this symbol - from an N_WARNING symbol encountered. */ - char *warning; - /* Nonzero means definitions of this symbol as common have been seen, - and the value here is the largest size specified by any of them. */ - int max_common_size; - /* For relocatable_output, records the index of this global sym in the - symbol table to be written, with the first global sym given index 0.*/ - int def_count; - /* Nonzero means a definition of this global symbol is known to exist. - Library members should not be loaded on its account. */ - char defined; - /* Nonzero means a reference to this global symbol has been seen - in a file that is surely being loaded. - A value higher than 1 is the n_type code for the symbol's - definition. */ - char referenced; - /* A count of the number of undefined references printed for a - specific symbol. If a symbol is unresolved at the end of - digest_symbols (and the loading run is supposed to produce - relocatable output) do_file_warnings keeps track of how many - unresolved reference error messages have been printed for - each symbol here. When the number hits MAX_UREFS_PRINTED, - messages stop. */ - unsigned char undef_refs; - /* 1 means that this symbol has multiple definitions. 2 means - that it has multiple definitions, and some of them are set - elements, one of which has been printed out already. */ - unsigned char multiply_defined; - /* Nonzero means print a message at all refs or defs of this symbol */ - char trace; - } - symbol; - -/* Demangler for C++. */ -extern char *cplus_demangle (); - -/* Demangler function to use. */ -char *(*demangler)() = NULL; - -/* Number of buckets in symbol hash table */ -#define TABSIZE 1009 - -/* The symbol hash table: a vector of TABSIZE pointers to struct glosym. */ -symbol *symtab[TABSIZE]; - -/* Number of symbols in symbol hash table. */ -int num_hash_tab_syms = 0; - -/* Count the number of nlist entries that are for local symbols. - This count and the three following counts - are incremented as as symbols are entered in the symbol table. */ -int local_sym_count; - -/* Count number of nlist entries that are for local symbols - whose names don't start with L. */ -int non_L_local_sym_count; - -/* Count the number of nlist entries for debugger info. */ -int debugger_sym_count; - -/* Count the number of global symbols referenced and not defined. */ -int undefined_global_sym_count; - -/* Count the number of global symbols multiply defined. */ -int multiple_def_count; - -/* Count the number of defined global symbols. - Each symbol is counted only once - regardless of how many different nlist entries refer to it, - since the output file will need only one nlist entry for it. - This count is computed by `digest_symbols'; - it is undefined while symbols are being loaded. */ -int defined_global_sym_count; - -/* Count the number of symbols defined through common declarations. - This count is kept in symdef_library, linear_library, and - enter_global_ref. It is incremented when the defined flag is set - in a symbol because of a common definition, and decremented when - the symbol is defined "for real" (ie. by something besides a common - definition). */ -int common_defined_global_count; - -/* Count the number of set element type symbols and the number of - separate vectors which these symbols will fit into. See the - GNU a.out.h for more info. - This count is computed by 'enter_file_symbols' */ -int set_symbol_count; -int set_vector_count; - -/* Define a linked list of strings which define symbols which should - be treated as set elements even though they aren't. Any symbol - with a prefix matching one of these should be treated as a set - element. - - This is to make up for deficiencies in many assemblers which aren't - willing to pass any stabs through to the loader which they don't - understand. */ -struct string_list_element { - char *str; - struct string_list_element *next; -}; - -struct string_list_element *set_element_prefixes; - -/* Count the number of definitions done indirectly (ie. done relative - to the value of some other symbol. */ -int global_indirect_count; - -/* Count the number of warning symbols encountered. */ -int warning_count; - -/* Total number of symbols to be written in the output file. - Computed by digest_symbols from the variables above. */ -int nsyms; - - -/* Nonzero means ptr to symbol entry for symbol to use as start addr. - -e sets this. */ -symbol *entry_symbol; - -symbol *edata_symbol; /* the symbol _edata */ -symbol *etext_symbol; /* the symbol _etext */ -symbol *end_symbol; /* the symbol _end */ - -/* Each input file, and each library member ("subfile") being loaded, - has a `file_entry' structure for it. - - For files specified by command args, these are contained in the vector - which `file_table' points to. - - For library members, they are dynamically allocated, - and chained through the `chain' field. - The chain is found in the `subfiles' field of the `file_entry'. - The `file_entry' objects for the members have `superfile' fields pointing - to the one for the library. */ - -struct file_entry { - /* Name of this file. */ - char *filename; - /* Name to use for the symbol giving address of text start */ - /* Usually the same as filename, but for a file spec'd with -l - this is the -l switch itself rather than the filename. */ - char *local_sym_name; - - /* Describe the layout of the contents of the file */ - - /* The file's a.out header. */ - struct exec header; - /* Offset in file of GDB symbol segment, or 0 if there is none. */ - int symseg_offset; - - /* Describe data from the file loaded into core */ - - /* Symbol table of the file. */ - struct nlist *symbols; - /* Size in bytes of string table. */ - int string_size; - /* Pointer to the string table. - The string table is not kept in core all the time, - but when it is in core, its address is here. */ - char *strings; - - /* Next two used only if `relocatable_output' or if needed for */ - /* output of undefined reference line numbers. */ - - /* Text reloc info saved by `write_text' for `coptxtrel'. */ - struct relocation_info *textrel; - /* Data reloc info saved by `write_data' for `copdatrel'. */ - struct relocation_info *datarel; - - /* Relation of this file's segments to the output file */ - - /* Start of this file's text seg in the output file core image. */ - int text_start_address; - /* Start of this file's data seg in the output file core image. */ - int data_start_address; - /* Start of this file's bss seg in the output file core image. */ - int bss_start_address; - /* Offset in bytes in the output file symbol table - of the first local symbol for this file. Set by `write_file_symbols'. */ - int local_syms_offset; - - /* For library members only */ - - /* For a library, points to chain of entries for the library members. */ - struct file_entry *subfiles; - /* For a library member, offset of the member within the archive. - Zero for files that are not library members. */ - int starting_offset; - /* Size of contents of this file, if library member. */ - int total_size; - /* For library member, points to the library's own entry. */ - struct file_entry *superfile; - /* For library member, points to next entry for next member. */ - struct file_entry *chain; - - /* 1 if file is a library. */ - char library_flag; - - /* 1 if file's header has been read into this structure. */ - char header_read_flag; - - /* 1 means search a set of directories for this file. */ - char search_dirs_flag; - - /* 1 means this is base file of incremental load. - Do not load this file's text or data. - Also default text_start to after this file's bss. */ - char just_syms_flag; -}; - -/* Vector of entries for input files specified by arguments. - These are all the input files except for members of specified libraries. */ -struct file_entry *file_table; - -/* Length of that vector. */ -int number_of_files; - -/* When loading the text and data, we can avoid doing a close - and another open between members of the same library. + /* Keep a list of symbols referenced from the command line */ + cl_refs_allocated = 10; + cmdline_references + = (struct glosym **) xmalloc(cl_refs_allocated + * sizeof(struct glosym *)); + *cmdline_references = 0; - These two variables remember the file that is currently open. - Both are zero if no file is open. + /* Completely decode ARGV. */ + decode_command(argc, argv); - See `each_file' and `file_close'. */ + building_shared_object = + (!relocatable_output && (link_mode & SHAREABLE)); -struct file_entry *input_file; -int input_desc; + /* Create the symbols `etext', `edata' and `end'. */ + symtab_init(relocatable_output); -/* The name of the file to write; "a.out" by default. */ + /* Prepare for the run-time linking support. */ + init_rrs(); -char *output_filename; + /* + * Determine whether to count the header as part of the text size, + * and initialize the text size accordingly. This depends on the kind + * of system and on the output format selected. + */ -/* Descriptor for writing that file with `mywrite'. */ + md_init_header(&outheader, magic, 0); -int outdesc; + text_size = sizeof(struct exec); + text_size -= N_TXTOFF(outheader); -/* Header for that file (filled in by `write_header'). */ + if (text_size < 0) + text_size = 0; + entry_offset = text_size; -struct exec outheader; + if (!T_flag_specified && !relocatable_output) + text_start = TEXT_START(outheader); -#ifdef COFF_ENCAPSULATE -struct coffheader coffheader; -int need_coff_header; -#endif + /* The text-start address is normally this far past a page boundary. */ + text_start_alignment = text_start % page_size; -/* The following are computed by `digest_symbols'. */ + /* + * Load symbols of all input files. Also search all libraries and + * decide which library members to load. + */ + load_symbols(); -int text_size; /* total size of text of all input files. */ -int data_size; /* total size of data of all input files. */ -int bss_size; /* total size of bss of all input files. */ -int text_reloc_size; /* total size of text relocation of all input files. */ -int data_reloc_size; /* total size of data relocation of all input */ - /* files. */ + /* Compute where each file's sections go, and relocate symbols. */ + digest_symbols(); -/* Specifications of start and length of the area reserved at the end - of the text segment for the set vectors. Computed in 'digest_symbols' */ -int set_sect_start; -int set_sect_size; + /* + * Print error messages for any missing symbols, for any warning + * symbols, and possibly multiple definitions + */ + make_executable = do_warnings(stderr); -/* Pointer for in core storage for the above vectors, before they are - written. */ -unsigned long *set_vectors; + /* Print a map, if requested. */ + if (write_map) + print_symbols(stdout); -/* Amount of cleared space to leave between the text and data segments. */ + /* Write the output file. */ + if (make_executable || force_executable) + write_output(); -int text_pad; + exit(!make_executable); +} -/* Amount of bss segment to include as part of the data segment. */ +void decode_option(); -int data_pad; +/* + * Analyze a command line argument. Return 0 if the argument is a filename. + * Return 1 if the argument is a option complete in itself. Return 2 if the + * argument is a option which uses an argument. + * + * Thus, the value is the number of consecutive arguments that are part of + * options. + */ -/* Format of __.SYMDEF: - First, a longword containing the size of the 'symdef' data that follows. - Second, zero or more 'symdef' structures. - Third, a longword containing the length of symbol name strings. - Fourth, zero or more symbol name strings (each followed by a null). */ +int +classify_arg(arg) + register char *arg; +{ + if (*arg != '-') + return 0; + switch (arg[1]) { + case 'a': + if (!strcmp(&arg[2], "ssert")) + return 2; + case 'A': + case 'D': + case 'e': + case 'L': + case 'l': + case 'o': + case 'u': + case 'V': + case 'y': + if (arg[2]) + return 1; + return 2; + + case 'B': + if (!strcmp(&arg[2], "static")) + return 1; + if (!strcmp(&arg[2], "dynamic")) + return 1; + + case 'T': + if (arg[2] == 0) + return 2; + if (!strcmp(&arg[2], "text")) + return 2; + if (!strcmp(&arg[2], "data")) + return 2; + return 1; + } -struct symdef { - int symbol_name_string_index; - int library_member_offset; -}; - -/* Record most of the command options. */ + return 1; +} -/* Address we assume the text section will be loaded at. - We relocate symbols and text and data for this, but we do not - write any padding in the output file for it. */ -int text_start; +/* + * Process the command arguments, setting up file_table with an entry for + * each input file, and setting variables according to the options. + */ -/* Offset of default entry-pc within the text section. */ -int entry_offset; +void +decode_command(argc, argv) + char **argv; + int argc; +{ + register int i; + register struct file_entry *p; + char *cp; -/* Address we decide the data section will be loaded at. */ -int data_start; + number_of_files = 0; + output_filename = "a.out"; -/* `text-start' address is normally this much plus a page boundary. - This is not a user option; it is fixed for each system. */ -int text_start_alignment; + /* + * First compute number_of_files so we know how long to make + * file_table. + * Also process most options completely. + */ -/* Nonzero if -T was specified in the command line. - This prevents text_start from being set later to default values. */ -int T_flag_specified; + for (i = 1; i < argc; i++) { + register int code = classify_arg(argv[i]); + if (code) { + if (i + code > argc) + fatal("no argument following %s\n", argv[i]); -/* Nonzero if -Tdata was specified in the command line. - This prevents data_start from being set later to default values. */ -int Tdata_flag_specified; + decode_option(argv[i], argv[i + 1]); -/* Size to pad data section up to. - We simply increase the size of the data section, padding with zeros, - and reduce the size of the bss section to match. */ -int specified_data_size; + if (argv[i][1] == 'l' || argv[i][1] == 'A') + number_of_files++; -/* Magic number to use for the output file, set by switch. */ -int magic; + i += code - 1; + } else + number_of_files++; + } -/* Nonzero means print names of input files as processed. */ -int trace_files; + if (!number_of_files) + fatal("no input files"); -/* Which symbols should be stripped (omitted from the output): - none, all, or debugger symbols. */ -enum { STRIP_NONE, STRIP_ALL, STRIP_DEBUGGER } strip_symbols; + p = file_table = (struct file_entry *) + xmalloc(number_of_files * sizeof(struct file_entry)); + bzero(p, number_of_files * sizeof(struct file_entry)); -/* Which local symbols should be omitted: - none, all, or those starting with L. - This is irrelevant if STRIP_NONE. */ -enum { DISCARD_NONE, DISCARD_ALL, DISCARD_L } discard_locals; + /* Now scan again and fill in file_table. */ + /* All options except -A and -l are ignored here. */ -/* 1 => write load map. */ -int write_map; + for (i = 1; i < argc; i++) { + char *string; + register int code = classify_arg(argv[i]); -/* 1 => write relocation into output file so can re-input it later. */ -int relocatable_output; + if (code == 0) { + p->filename = argv[i]; + p->local_sym_name = argv[i]; + p++; + continue; + } + if (code == 2) + string = argv[i + 1]; + else + string = &argv[i][2]; + + if (argv[i][1] == 'B') { + if (strcmp(string, "static") == 0) + link_mode &= ~DYNAMIC; + else if (strcmp(string, "dynamic") == 0) + link_mode |= DYNAMIC; + else if (strcmp(string, "symbolic") == 0) + link_mode |= SYMBOLIC; + else if (strcmp(string, "forcearchive") == 0) + link_mode |= FORCEARCHIVE; + else if (strcmp(string, "shareable") == 0) + link_mode |= SHAREABLE; + } + if (argv[i][1] == 'A') { + if (p != file_table) + fatal("-A specified before an input file other than the first"); + p->filename = string; + p->local_sym_name = string; + p->just_syms_flag = 1; + p++; + } + if (argv[i][1] == 'l') { + p->filename = string; + p->local_sym_name = concat("-l", string, ""); + p->search_dirs_flag = 1; + if (link_mode & DYNAMIC && !relocatable_output) + p->search_dynamic_flag = 1; + p++; + } + i += code - 1; + } -/* 1 => assign space to common symbols even if `relocatable_output'. */ -int force_common_definition; - -/* Standard directories to search for files specified by -l. */ -char *standard_search_dirs[] = -#ifdef STANDARD_SEARCH_DIRS - {STANDARD_SEARCH_DIRS}; -#else -#ifdef NON_NATIVE - {"/usr/local/lib/gnu"}; -#else - {"/lib", "/usr/lib", "/usr/local/lib"}; -#endif -#endif + /* Now check some option settings for consistency. */ -/* Actual vector of directories to search; - this contains those specified with -L plus the standard ones. */ -char **search_dirs; + if ((magic != OMAGIC) + && (text_start - text_start_alignment) & (page_size - 1)) + fatal("-T argument not multiple of page size, with sharable output"); -/* Length of the vector `search_dirs'. */ -int n_search_dirs; + /* Append the standard search directories to the user-specified ones. */ + std_search_dirs(getenv("LD_LIBRARY_PATH")); +} -/* Non zero means to create the output executable. */ -/* Cleared by nonfatal errors. */ -int make_executable; - -/* Force the executable to be output, even if there are non-fatal - errors */ -int force_executable; - -/* Keep a list of any symbols referenced from the command line (so - that error messages for these guys can be generated). This list is - zero terminated. */ -struct glosym **cmdline_references; -int cl_refs_allocated; - -void bcopy (), bzero (); -int malloc (), realloc (); -#ifndef alloca -int alloca (); -#endif -int free (); - -int xmalloc (); -int xrealloc (); -void fatal (); -void fatal_with_file (); -void perror_name (); -void perror_file (); -void error (); - -void digest_symbols (); -void print_symbols (); -void load_symbols (); -void decode_command (); -void list_undefined_symbols (); -void list_unresolved_references (); -void write_output (); -void write_header (); -void write_text (); -void read_file_relocation (); -void write_data (); -void write_rel (); -void write_syms (); -void write_symsegs (); -void mywrite (); -void symtab_init (); -void padfile (); -char *concat (); -char *get_file_name (); -symbol *getsym (), *getsym_soft (); - -int -main (argc, argv) - char **argv; - int argc; +void +add_cmdline_ref(sp) + struct glosym *sp; { -/* Added this to stop ld core-dumping on very large .o files. */ -#ifdef RLIMIT_STACK - /* Get rid of any avoidable limit on stack size. */ - { - struct rlimit rlim; - - /* Set the stack limit huge so that alloca does not fail. */ - getrlimit (RLIMIT_STACK, &rlim); - rlim.rlim_cur = rlim.rlim_max; - setrlimit (RLIMIT_STACK, &rlim); - } -#endif /* RLIMIT_STACK */ - - page_size = getpagesize (); - progname = argv[0]; - - /* Clear the cumulative info on the output file. */ - - text_size = 0; - data_size = 0; - bss_size = 0; - text_reloc_size = 0; - data_reloc_size = 0; - - data_pad = 0; - text_pad = 0; - - /* Initialize the data about options. */ - - specified_data_size = 0; - strip_symbols = STRIP_NONE; - trace_files = 0; - discard_locals = DISCARD_NONE; - entry_symbol = 0; - write_map = 0; - relocatable_output = 0; - force_common_definition = 0; - T_flag_specified = 0; - Tdata_flag_specified = 0; - magic = DEFAULT_MAGIC; - make_executable = 1; - force_executable = 0; - set_element_prefixes = 0; - - /* Initialize the cumulative counts of symbols. */ - - local_sym_count = 0; - non_L_local_sym_count = 0; - debugger_sym_count = 0; - undefined_global_sym_count = 0; - set_symbol_count = 0; - set_vector_count = 0; - global_indirect_count = 0; - warning_count = 0; - multiple_def_count = 0; - common_defined_global_count = 0; - - /* Keep a list of symbols referenced from the command line */ - cl_refs_allocated = 10; - cmdline_references - = (struct glosym **) xmalloc (cl_refs_allocated - * sizeof(struct glosym *)); - *cmdline_references = 0; - - /* Completely decode ARGV. */ - - decode_command (argc, argv); - - /* Create the symbols `etext', `edata' and `end'. */ - - if (!relocatable_output) - symtab_init (); - - /* Determine whether to count the header as part of - the text size, and initialize the text size accordingly. - This depends on the kind of system and on the output format selected. */ - - N_SET_MAGIC (outheader, magic); -#ifdef INITIALIZE_HEADER - INITIALIZE_HEADER; -#endif - - text_size = sizeof (struct exec); -#ifdef COFF_ENCAPSULATE - if (relocatable_output == 0 && file_table[0].just_syms_flag == 0) - { - need_coff_header = 1; - /* set this flag now, since it will change the values of N_TXTOFF, etc */ - N_SET_FLAGS (outheader, N_FLAGS_COFF_ENCAPSULATE); - text_size += sizeof (struct coffheader); - } -#endif - - text_size -= N_TXTOFF (outheader); - - if (text_size < 0) - text_size = 0; - entry_offset = text_size; - - if (!T_flag_specified && !relocatable_output) - text_start = TEXT_START (outheader); - - /* The text-start address is normally this far past a page boundary. */ - text_start_alignment = text_start % page_size; - - /* Load symbols of all input files. - Also search all libraries and decide which library members to load. */ - - load_symbols (); - - /* Compute where each file's sections go, and relocate symbols. */ - - digest_symbols (); - - /* Print error messages for any missing symbols, for any warning - symbols, and possibly multiple definitions */ - - do_warnings (stderr); + struct glosym **ptr; - /* Print a map, if requested. */ + for (ptr = cmdline_references; + ptr < cmdline_references + cl_refs_allocated && *ptr; + ptr++); - if (write_map) print_symbols (stdout); + if (ptr >= cmdline_references + cl_refs_allocated - 1) { + int diff = ptr - cmdline_references; - /* Write the output file. */ - - if (make_executable || force_executable) - write_output (); - - exit (!make_executable); + cl_refs_allocated *= 2; + cmdline_references = (struct glosym **) + xrealloc(cmdline_references, + cl_refs_allocated * sizeof(struct glosym *)); + ptr = cmdline_references + diff; + } + *ptr++ = sp; + *ptr = (struct glosym *) 0; } - -void decode_option (); - -/* Analyze a command line argument. - Return 0 if the argument is a filename. - Return 1 if the argument is a option complete in itself. - Return 2 if the argument is a option which uses an argument. - - Thus, the value is the number of consecutive arguments - that are part of options. */ int -classify_arg (arg) - register char *arg; +set_element_prefixed_p(name) + char *name; { - if (*arg != '-') return 0; - switch (arg[1]) - { - case 'A': - case 'D': - case 'e': - case 'L': - case 'l': - case 'o': - case 'u': - case 'V': - case 'y': - if (arg[2]) - return 1; - return 2; + struct string_list_element *p; + int i; - case 'B': - if (! strcmp (&arg[2], "static")) - return 1; + for (p = set_element_prefixes; p; p = p->next) { - case 'T': - if (arg[2] == 0) - return 2; - if (! strcmp (&arg[2], "text")) - return 2; - if (! strcmp (&arg[2], "data")) - return 2; - return 1; - } - - return 1; + for (i = 0; p->str[i] != '\0' && (p->str[i] == name[i]); i++); + if (p->str[i] == '\0') + return 1; + } + return 0; } -/* Process the command arguments, - setting up file_table with an entry for each input file, - and setting variables according to the options. */ +/* + * Record an option and arrange to act on it later. ARG should be the + * following command argument, which may or may not be used by this option. + * + * The `l' and `A' options are ignored here since they actually specify input + * files. + */ void -decode_command (argc, argv) - char **argv; - int argc; -{ - register int i; - register struct file_entry *p; - char *cp; - - number_of_files = 0; - output_filename = "a.out"; - - n_search_dirs = 0; - search_dirs = (char **) xmalloc (sizeof (char *)); - - /* First compute number_of_files so we know how long to make file_table. */ - /* Also process most options completely. */ - - for (i = 1; i < argc; i++) - { - register int code = classify_arg (argv[i]); - if (code) - { - if (i + code > argc) - fatal ("no argument following %s\n", argv[i]); - - decode_option (argv[i], argv[i+1]); - - if (argv[i][1] == 'l' || argv[i][1] == 'A') - number_of_files++; - - i += code - 1; +decode_option(swt, arg) + register char *swt, *arg; +{ + /* We get Bstatic from gcc on suns. */ + if (!strcmp(swt + 1, "Bstatic")) + return; + if (!strcmp(swt + 1, "Bdynamic")) + return; + if (!strcmp(swt + 1, "Bsymbolic")) + return; + if (!strcmp(swt + 1, "Bforcearchive")) + return; + if (!strcmp(swt + 1, "Bshareable")) + return; + if (!strcmp(swt + 1, "assert")) + return; + if (!strcmp(swt + 1, "Ttext")) { + text_start = parse(arg, "%x", "invalid argument to -Ttext"); + T_flag_specified = 1; + return; } - else - number_of_files++; - } - - if (!number_of_files) - fatal ("no input files", 0); + if (!strcmp(swt + 1, "Tdata")) { + rrs_data_start = parse(arg, "%x", "invalid argument to -Tdata"); + Tdata_flag_specified = 1; + return; + } + if (!strcmp(swt + 1, "noinhibit-exec")) { + force_executable = 1; + return; + } + if (swt[2] != 0) + arg = &swt[2]; + + switch (swt[1]) { + case 'A': + return; + + case 'D': + specified_data_size = parse(arg, "%x", "invalid argument to -D"); + return; + + case 'd': + if (*arg == 'c') + force_common_definition = 1; + else if (*arg == 'p') + force_alias_definition = 1; + else + fatal("-d option takes 'c' or 'p' argument"); + return; - p = file_table - = (struct file_entry *) xmalloc (number_of_files * sizeof (struct file_entry)); - bzero (p, number_of_files * sizeof (struct file_entry)); + case 'e': + entry_symbol = getsym(arg); + if (!entry_symbol->defined && !entry_symbol->referenced) + undefined_global_sym_count++; + entry_symbol->referenced = 1; + add_cmdline_ref(entry_symbol); + return; - /* Now scan again and fill in file_table. */ - /* All options except -A and -l are ignored here. */ + case 'l': + return; - for (i = 1; i < argc; i++) - { - register int code = classify_arg (argv[i]); + case 'L': + add_search_dir(arg); + return; - if (code) - { - char *string; - if (code == 2) - string = argv[i+1]; - else - string = &argv[i][2]; - - if (argv[i][1] == 'A') - { - if (p != file_table) - fatal ("-A specified before an input file other than the first"); - - p->filename = string; - p->local_sym_name = string; - p->just_syms_flag = 1; - p++; - } - if (argv[i][1] == 'l') - { - if (cp = rindex(string, '/')) - { - *cp++ = '\0'; - cp = concat (string, "/lib", cp); - p->filename = concat (cp, ".a", ""); - } - else - p->filename = concat ("lib", string, ".a"); - - p->local_sym_name = concat ("-l", string, ""); - p->search_dirs_flag = 1; - p++; - } - i += code - 1; - } - else - { - p->filename = argv[i]; - p->local_sym_name = argv[i]; - p++; - } - } + case 'M': + write_map = 1; + return; - /* Now check some option settings for consistency. */ + case 'N': + magic = OMAGIC; + return; #ifdef NMAGIC - if ((magic == ZMAGIC || magic == NMAGIC) -#else - if ((magic == ZMAGIC) + case 'n': + magic = NMAGIC; + return; #endif - && (text_start - text_start_alignment) & (page_size - 1)) - fatal ("-T argument not multiple of page size, with sharable output", 0); - - /* Append the standard search directories to the user-specified ones. */ - { - int n = sizeof standard_search_dirs / sizeof standard_search_dirs[0]; - n_search_dirs += n; - search_dirs - = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *)); - bcopy (standard_search_dirs, &search_dirs[n_search_dirs - n], - n * sizeof (char *)); - } -} - -void -add_cmdline_ref (sp) - struct glosym *sp; -{ - struct glosym **ptr; - - for (ptr = cmdline_references; - ptr < cmdline_references + cl_refs_allocated && *ptr; - ptr++) - ; - - if (ptr >= cmdline_references + cl_refs_allocated - 1) - { - int diff = ptr - cmdline_references; - - cl_refs_allocated *= 2; - cmdline_references = (struct glosym **) - xrealloc (cmdline_references, - cl_refs_allocated * sizeof (struct glosym *)); - ptr = cmdline_references + diff; - } - - *ptr++ = sp; - *ptr = (struct glosym *) 0; -} +#ifdef QMAGIC + case 'Q': + magic = oldmagic = QMAGIC; + return; + case 'Z': + magic = oldmagic = ZMAGIC; + return; +#endif -int -set_element_prefixed_p (name) - char *name; -{ - struct string_list_element *p; - int i; + case 'o': + output_filename = arg; + return; - for (p = set_element_prefixes; p; p = p->next) - { - for (i = 0; p->str[i] != '\0' && (p->str[i] == name[i]); i++) - ; + case 'r': + relocatable_output = 1; + magic = OMAGIC; + text_start = 0; + return; - if (p->str[i] == '\0') - return 1; - } - return 0; -} + case 'S': + strip_symbols = STRIP_DEBUGGER; + return; -int parse (); + case 's': + strip_symbols = STRIP_ALL; + return; -/* Record an option and arrange to act on it later. - ARG should be the following command argument, - which may or may not be used by this option. + case 'T': + text_start = parse(arg, "%x", "invalid argument to -T"); + T_flag_specified = 1; + return; - The `l' and `A' options are ignored here since they actually - specify input files. */ + case 't': + trace_files = 1; + return; -void -decode_option (swt, arg) - register char *swt, *arg; -{ - /* We get Bstatic from gcc on suns. */ - if (! strcmp (swt + 1, "Bstatic")) - return; - if (! strcmp (swt + 1, "Ttext")) - { - text_start = parse (arg, "%x", "invalid argument to -Ttext"); - T_flag_specified = 1; - return; - } - if (! strcmp (swt + 1, "Tdata")) - { - data_start = parse (arg, "%x", "invalid argument to -Tdata"); - Tdata_flag_specified = 1; - return; - } - if (! strcmp (swt + 1, "noinhibit-exec")) - { - force_executable = 1; - return; - } - - if (swt[2] != 0) - arg = &swt[2]; - - switch (swt[1]) - { - case 'A': - return; - - case 'D': - specified_data_size = parse (arg, "%x", "invalid argument to -D"); - return; - - case 'd': - force_common_definition = 1; - return; - - case 'e': - entry_symbol = getsym (arg); - if (!entry_symbol->defined && !entry_symbol->referenced) - undefined_global_sym_count++; - entry_symbol->referenced = 1; - add_cmdline_ref (entry_symbol); - return; - - case 'l': - /* If linking with libg++, use the C++ demangler. */ - if (arg != NULL && strcmp (arg, "g++") == 0) - demangler = cplus_demangle; - return; - magic = OMAGIC; - - case 'L': - n_search_dirs++; - search_dirs - = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *)); - search_dirs[n_search_dirs - 1] = arg; - return; - - case 'M': - write_map = 1; - return; - - case 'N': - magic = OMAGIC; - return; + case 'u': + { + register symbol *sp = getsym(arg); -#ifdef NMAGIC - case 'n': - magic = NMAGIC; - return; + if (!sp->defined && !sp->referenced) + undefined_global_sym_count++; + sp->referenced = 1; + add_cmdline_ref(sp); + } + return; + +#if 1 + case 'V': + soversion = parse(arg, "%d", "invalid argument to -V"); + return; #endif - case 'o': - output_filename = arg; - return; + case 'X': + discard_locals = DISCARD_L; + return; -#ifdef QMAGIC - case 'q': - magic = QMAGIC; - return; -#endif + case 'x': + discard_locals = DISCARD_ALL; + return; - case 'r': - relocatable_output = 1; - magic = OMAGIC; - text_start = 0; - return; - - case 'S': - strip_symbols = STRIP_DEBUGGER; - return; - - case 's': - strip_symbols = STRIP_ALL; - return; - - case 'T': - text_start = parse (arg, "%x", "invalid argument to -T"); - T_flag_specified = 1; - return; - - case 't': - trace_files = 1; - return; - - case 'u': - { - register symbol *sp = getsym (arg); - if (!sp->defined && !sp->referenced) - undefined_global_sym_count++; - sp->referenced = 1; - add_cmdline_ref (sp); - } - return; - - case 'V': - { - struct string_list_element *new - = (struct string_list_element *) - xmalloc (sizeof (struct string_list_element)); - - new->str = arg; - new->next = set_element_prefixes; - set_element_prefixes = new; - return; - } - - case 'X': - discard_locals = DISCARD_L; - return; - - case 'x': - discard_locals = DISCARD_ALL; - return; - - case 'y': - { - register symbol *sp = getsym (&swt[2]); - sp->trace = 1; - } - return; - - case 'z': - magic = ZMAGIC; - return; - - default: - fatal ("invalid command option `%s'", swt); - } + case 'y': + { + register symbol *sp = getsym(&swt[2]); + sp->trace = 1; + } + return; + + case 'z': + magic = ZMAGIC; + return; + + default: + fatal("invalid command option `%s'", swt); + } } -/** Convenient functions for operating on one or all files being */ - /** loaded. */ -void print_file_name (); - -/* Call FUNCTION on each input file entry. - Do not call for entries for libraries; - instead, call once for each library member that is being loaded. +/* Convenient functions for operating on one or all files being loaded. */ - FUNCTION receives two arguments: the entry, and ARG. */ +/* + * Call FUNCTION on each input file entry. Do not call for entries for + * libraries; instead, call once for each library member that is being + * loaded. + * + * FUNCTION receives two arguments: the entry, and ARG. + */ void -each_file (function, arg) - register void (*function)(); - register int arg; -{ - register int i; - - for (i = 0; i < number_of_files; i++) - { - register struct file_entry *entry = &file_table[i]; - if (entry->library_flag) - { - register struct file_entry *subentry = entry->subfiles; - for (; subentry; subentry = subentry->chain) - (*function) (subentry, arg); +each_file(function, arg) + register void (*function) (); + register int arg; +{ + register int i; + + for (i = 0; i < number_of_files; i++) { + register struct file_entry *entry = &file_table[i]; + if (entry->library_flag) { + register struct file_entry *subentry = entry->subfiles; + for (; subentry; subentry = subentry->chain) + (*function) (subentry, arg); + } else + (*function) (entry, arg); } - else - (*function) (entry, arg); - } } -/* Call FUNCTION on each input file entry until it returns a non-zero - value. Return this value. - Do not call for entries for libraries; - instead, call once for each library member that is being loaded. - - FUNCTION receives two arguments: the entry, and ARG. It must be a - function returning unsigned long (though this can probably be fudged). */ +/* + * Call FUNCTION on each input file entry until it returns a non-zero value. + * Return this value. Do not call for entries for libraries; instead, call + * once for each library member that is being loaded. + * + * FUNCTION receives two arguments: the entry, and ARG. It must be a function + * returning unsigned long (though this can probably be fudged). + */ unsigned long -check_each_file (function, arg) - register unsigned long (*function)(); - register int arg; -{ - register int i; - register unsigned long return_val; - - for (i = 0; i < number_of_files; i++) - { - register struct file_entry *entry = &file_table[i]; - if (entry->library_flag) - { - register struct file_entry *subentry = entry->subfiles; - for (; subentry; subentry = subentry->chain) - if (return_val = (*function) (subentry, arg)) - return return_val; +check_each_file(function, arg) + register unsigned long (*function) (); + register int arg; +{ + register int i; + register unsigned long return_val; + + for (i = 0; i < number_of_files; i++) { + register struct file_entry *entry = &file_table[i]; + if (entry->library_flag) { + register struct file_entry *subentry = entry->subfiles; + for (; subentry; subentry = subentry->chain) + if (return_val = (*function) (subentry, arg)) + return return_val; + } else if (return_val = (*function) (entry, arg)) + return return_val; } - else - if (return_val = (*function) (entry, arg)) - return return_val; - } - return 0; + return 0; } /* Like `each_file' but ignore files that were just for symbol definitions. */ void -each_full_file (function, arg) - register void (*function)(); - register int arg; -{ - register int i; - - for (i = 0; i < number_of_files; i++) - { - register struct file_entry *entry = &file_table[i]; - if (entry->just_syms_flag) - continue; - if (entry->library_flag) - { - register struct file_entry *subentry = entry->subfiles; - for (; subentry; subentry = subentry->chain) - (*function) (subentry, arg); +each_full_file(function, arg) + register void (*function) (); + register int arg; +{ + register int i; + + for (i = 0; i < number_of_files; i++) { + register struct file_entry *entry = &file_table[i]; + if (entry->just_syms_flag || entry->is_dynamic) + continue; + if (entry->library_flag) { + register struct file_entry *subentry = entry->subfiles; + for (; subentry; subentry = subentry->chain) + (*function) (subentry, arg); + } else + (*function) (entry, arg); } - else - (*function) (entry, arg); - } } /* Close the input file that is now open. */ void -file_close () +file_close() { - close (input_desc); - input_desc = 0; - input_file = 0; + close(input_desc); + input_desc = 0; + input_file = 0; } -/* Open the input file specified by 'entry', and return a descriptor. - The open file is remembered; if the same file is opened twice in a row, - a new open is not actually done. */ - +/* + * Open the input file specified by 'entry', and return a descriptor. The + * open file is remembered; if the same file is opened twice in a row, a new + * open is not actually done. + */ int file_open (entry) register struct file_entry *entry; { - register int desc; + register int desc; - if (entry->superfile) - return file_open (entry->superfile); + if (entry->superfile) + return file_open (entry->superfile); - if (entry == input_file) - return input_desc; + if (entry == input_file) + return input_desc; - if (input_file) file_close (); + if (input_file) file_close (); - if (entry->search_dirs_flag) - { - int i; + if (entry->search_dirs_flag) { + desc = findlib(entry); + } else + desc = open (entry->filename, O_RDONLY, 0); - for (i = 0; i < n_search_dirs; i++) - { - register char *string - = concat (search_dirs[i], "/", entry->filename); - desc = open (string, O_RDONLY, 0); - if (desc > 0) - { - entry->filename = string; - entry->search_dirs_flag = 0; - break; - } - free (string); + if (desc > 0) { + input_file = entry; + input_desc = desc; + return desc; } - } - else - desc = open (entry->filename, O_RDONLY, 0); - - if (desc > 0) - { - input_file = entry; - input_desc = desc; - return desc; - } - - perror_file (entry); - /* NOTREACHED */ -} - -/* Print the filename of ENTRY on OUTFILE (a stdio stream), - and then a newline. */ -void -prline_file_name (entry, outfile) - struct file_entry *entry; - FILE *outfile; -{ - print_file_name (entry, outfile); - fprintf (outfile, "\n"); -} - -/* Print the filename of ENTRY on OUTFILE (a stdio stream). */ - -void -print_file_name (entry, outfile) - struct file_entry *entry; - FILE *outfile; -{ - if (entry->superfile) - { - print_file_name (entry->superfile, outfile); - fprintf (outfile, "(%s)", entry->filename); - } - else - fprintf (outfile, "%s", entry->filename); + perror_file (entry); + /* NOTREACHED */ } -/* Return the filename of entry as a string (malloc'd for the purpose) */ - -char * -get_file_name (entry) +int +text_offset (entry) struct file_entry *entry; { - char *result, *supfile; - if (entry->superfile) - { - supfile = get_file_name (entry->superfile); - result = (char *) xmalloc (strlen (supfile) - + strlen (entry->filename) + 3); - sprintf (result, "%s(%s)", supfile, entry->filename); - free (supfile); - } - else - { - result = (char *) xmalloc (strlen (entry->filename) + 1); - strcpy (result, entry->filename); - } - return result; + return entry->starting_offset + N_TXTOFF (entry->header); } /* Medium-level input routines for rel files. */ -/* Read a file's header into the proper place in the file_entry. - DESC is the descriptor on which the file is open. - ENTRY is the file's entry. */ - +/* + * Read a file's header into the proper place in the file_entry. DESC is the + * descriptor on which the file is open. ENTRY is the file's entry. + */ void read_header (desc, entry) int desc; register struct file_entry *entry; { - register int len; - struct exec *loc = (struct exec *) &entry->header; + register int len; + struct exec *loc = (struct exec *) &entry->header; - lseek (desc, entry->starting_offset, 0); -#ifdef COFF_ENCAPSULATE - if (entry->just_syms_flag) - lseek (desc, sizeof(coffheader), 1); -#endif - len = read (desc, loc, sizeof (struct exec)); - if (len != sizeof (struct exec)) - fatal_with_file ("failure reading header of ", entry); - if (N_BADMAG (*loc)) - fatal_with_file ("bad magic number in ", entry); + if (lseek (desc, entry->starting_offset, L_SET) != + entry->starting_offset) + fatal_with_file("read_header: lseek failure ", entry); - entry->header_read_flag = 1; -} + len = read (desc, &entry->header, sizeof (struct exec)); + if (len != sizeof (struct exec)) + fatal_with_file ("failure reading header of ", entry); + + md_swapin_exec_hdr(&entry->header); -/* Read the symbols of file ENTRY into core. - Assume it is already open, on descriptor DESC. - Also read the length of the string table, which follows the symbol table, - but don't read the contents of the string table. */ + if (N_BADMAG (*loc)) + fatal_with_file ("bad magic number in ", entry); + + entry->header_read_flag = 1; +} +/* + * Read the symbols of file ENTRY into core. Assume it is already open, on + * descriptor DESC. Also read the length of the string table, which follows + * the symbol table, but don't read the contents of the string table. + */ void read_entry_symbols (desc, entry) struct file_entry *entry; int desc; { - int str_size; + int str_size; + struct nlist *np; + int i; - if (!entry->header_read_flag) - read_header (desc, entry); + if (!entry->header_read_flag) + read_header (desc, entry); - entry->symbols = (struct nlist *) xmalloc (entry->header.a_syms); + np = (struct nlist *) alloca (entry->header.a_syms); + entry->nsymbols = entry->header.a_syms / sizeof(struct nlist); + entry->symbols = (struct localsymbol *) + xmalloc(entry->nsymbols * sizeof(struct localsymbol)); - lseek (desc, N_SYMOFF (entry->header) + entry->starting_offset, 0); - if (entry->header.a_syms != read (desc, entry->symbols, entry->header.a_syms)) - fatal_with_file ("premature end of file in symbols of ", entry); + if (lseek(desc, N_SYMOFF(entry->header) + entry->starting_offset, L_SET) + != N_SYMOFF(entry->header) + entry->starting_offset) + fatal_with_file ("read_symbols(h): lseek failure ", entry); - lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0); - if (sizeof str_size != read (desc, &str_size, sizeof str_size)) - fatal_with_file ("bad string table size in ", entry); + if (entry->header.a_syms != read (desc, np, entry->header.a_syms)) + fatal_with_file ("premature end of file in symbols of ", entry); - entry->string_size = str_size; -} + md_swapin_symbols(np, entry->header.a_syms / sizeof(struct nlist)); + + for (i = 0; i < entry->nsymbols; i++) { + entry->symbols[i].nzlist.nlist = *np++; + entry->symbols[i].nzlist.nz_size = 0; + entry->symbols[i].symbol = NULL; + entry->symbols[i].next = NULL; + entry->symbols[i].gotslot_offset = -1; + entry->symbols[i].gotslot_claimed = 0; + } + + entry->strings_offset = N_STROFF(entry->header) + + entry->starting_offset; + if (lseek(desc, entry->strings_offset, 0) == (off_t)-1) + fatal_with_file ("read_symbols(s): lseek failure ", entry); + if (sizeof str_size != read (desc, &str_size, sizeof str_size)) + fatal_with_file ("bad string table size in ", entry); -/* Read the string table of file ENTRY into core. - Assume it is already open, on descriptor DESC. - Also record whether a GDB symbol segment follows the string table. */ + entry->string_size = md_swap_long(str_size); +} +/* + * Read the string table of file ENTRY into core. Assume it is already open, + * on descriptor DESC. + */ void read_entry_strings (desc, entry) struct file_entry *entry; int desc; { - int buffer; + int buffer; - if (!entry->header_read_flag) - read_header (desc, entry); + if (!entry->header_read_flag || !entry->strings_offset) + fatal("internal error: %s", "cannot read string table"); - lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0); - if (entry->string_size != read (desc, entry->strings, entry->string_size)) - fatal_with_file ("premature end of file in strings of ", entry); + if (lseek (desc, entry->strings_offset, L_SET) != entry->strings_offset) + fatal_with_file ("read_strings: lseek failure ", entry); + + if (entry->string_size != + read (desc, entry->strings, entry->string_size)) + fatal_with_file ("premature end of file in strings of ", entry); -#if 0 - /* While we are here, see if the file has a symbol segment at the end. - For a separate file, just try reading some more. - For a library member, compare current pos against total size. */ - if (entry->superfile) - { - if (entry->total_size == N_STROFF (entry->header) + entry->string_size) - return; - } - else - { - buffer = read (desc, &buffer, sizeof buffer); - if (buffer == 0) return; - if (buffer != sizeof buffer) - fatal_with_file ("premature end of file in GDB symbol segment of ", entry); - } -#endif - /* Don't try to do anything with symsegs. */ - return; -#if 0 - /* eliminate warning of `statement not reached'. */ - entry->symseg_offset = N_STROFF (entry->header) + entry->string_size; -#endif } + +/* DEAD - Read in all of the relocation information */ + +void +read_relocation () +{ + each_full_file (read_entry_relocation, 0); +} + +/* Read in the relocation sections of ENTRY if necessary */ + +void +read_entry_relocation (desc, entry) + int desc; + struct file_entry *entry; +{ + register struct relocation_info *reloc; + off_t pos; + + if (!entry->textrel) { + + reloc = (struct relocation_info *) + xmalloc(entry->header.a_trsize); + + pos = text_offset(entry) + + entry->header.a_text + entry->header.a_data; + + if (lseek(desc, pos, L_SET) != pos) + fatal_with_file("read_reloc(t): lseek failure ", entry); + + if (entry->header.a_trsize != + read(desc, reloc, entry->header.a_trsize)) { + fatal_with_file ( + "premature eof in text relocation of ", entry); + } + md_swapin_reloc(reloc, entry->header.a_trsize / sizeof(*reloc)); + entry->textrel = reloc; + entry->ntextrel = entry->header.a_trsize / sizeof(*reloc); + + } + + if (!entry->datarel) { + + reloc = (struct relocation_info *) + xmalloc(entry->header.a_drsize); + + pos = text_offset(entry) + entry->header.a_text + + entry->header.a_data + entry->header.a_trsize; + + if (lseek(desc, pos, L_SET) != pos) + fatal_with_file("read_reloc(d): lseek failure ", entry); + + if (entry->header.a_drsize != + read (desc, reloc, entry->header.a_drsize)) { + fatal_with_file ( + "premature eof in data relocation of ", entry); + } + md_swapin_reloc(reloc, entry->header.a_drsize / sizeof(*reloc)); + entry->datarel = reloc; + entry->ndatarel = entry->header.a_drsize / sizeof(*reloc); + + } +} + /* Read in the symbols of all input files. */ void read_file_symbols (), read_entry_symbols (), read_entry_strings (); -void enter_file_symbols (), enter_global_ref (), search_library (); +void enter_file_symbols (), enter_global_ref (); void load_symbols () { - register int i; + register int i; - if (trace_files) fprintf (stderr, "Loading symbols:\n\n"); + if (trace_files) fprintf (stderr, "Loading symbols:\n\n"); - for (i = 0; i < number_of_files; i++) - { - register struct file_entry *entry = &file_table[i]; - read_file_symbols (entry); - } + for (i = 0; i < number_of_files; i++) { + register struct file_entry *entry = &file_table[i]; + read_file_symbols (entry); + } - if (trace_files) fprintf (stderr, "\n"); + if (trace_files) fprintf (stderr, "\n"); } -/* If ENTRY is a rel file, read its symbol and string sections into core. - If it is a library, search it and load the appropriate members - (which means calling this function recursively on those members). */ +/* + * If ENTRY is a rel file, read its symbol and string sections into core. If + * it is a library, search it and load the appropriate members (which means + * calling this function recursively on those members). + */ void read_file_symbols (entry) register struct file_entry *entry; { - register int desc; - register int len; - struct exec hdr; - - desc = file_open (entry); - -#ifdef COFF_ENCAPSULATE - if (entry->just_syms_flag) - lseek (desc, sizeof(coffheader),0); -#endif + register int desc; + register int len; + struct exec hdr; + + desc = file_open (entry); + + len = read (desc, &hdr, sizeof hdr); + if (len != sizeof hdr) + fatal_with_file ("failure reading header of ", entry); + + md_swapin_exec_hdr(&hdr); + + if (!N_BADMAG (hdr)) { + if (N_IS_DYNAMIC(hdr)) { + if (relocatable_output) { + fatal_with_file( + "-r and shared objects currently not supported ", + entry); + return; + } + entry->is_dynamic = 1; + read_shared_object(desc, entry); + rrs_add_shobj(entry); + } else { + read_entry_symbols (desc, entry); + entry->strings = (char *) alloca (entry->string_size); + read_entry_strings (desc, entry); + read_entry_relocation(desc, entry); + enter_file_symbols (entry); + entry->strings = 0; + } + } else { + char armag[SARMAG]; + + lseek (desc, 0, 0); + if (SARMAG != read (desc, armag, SARMAG) || + strncmp (armag, ARMAG, SARMAG)) + fatal_with_file( + "malformed input file (not rel or archive) ", entry); + entry->library_flag = 1; + search_library (desc, entry); + } - len = read (desc, &hdr, sizeof hdr); - if (len != sizeof hdr) - fatal_with_file ("failure reading header of ", entry); - - if (!N_BADMAG (hdr)) - { - read_entry_symbols (desc, entry); - entry->strings = (char *) alloca (entry->string_size); - read_entry_strings (desc, entry); - enter_file_symbols (entry); - entry->strings = 0; - } - else - { - char armag[SARMAG]; - - lseek (desc, 0, 0); - if (SARMAG != read (desc, armag, SARMAG) || strncmp (armag, ARMAG, SARMAG)) - fatal_with_file ("malformed input file (not rel or archive) ", entry); - entry->library_flag = 1; - search_library (desc, entry); - } - - file_close (); + file_close (); } /* Enter the external symbol defs and refs of ENTRY in the hash table. */ @@ -1672,1527 +1000,878 @@ void enter_file_symbols (entry) struct file_entry *entry; { - register struct nlist - *p, - *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist); - - if (trace_files) prline_file_name (entry, stderr); - - for (p = entry->symbols; p < end; p++) - { - if (p->n_type == (N_SETV | N_EXT)) continue; - if (set_element_prefixes - && set_element_prefixed_p (p->n_un.n_strx + entry->strings)) - p->n_type += (N_SETA - N_ABS); - - if (SET_ELEMENT_P (p->n_type)) - { - set_symbol_count++; - if (!relocatable_output) - enter_global_ref (p, p->n_un.n_strx + entry->strings, entry); + struct localsymbol *lsp, *lspend; + + if (trace_files) prline_file_name (entry, stderr); + + lspend = entry->symbols + entry->nsymbols; + + for (lsp = entry->symbols; lsp < lspend; lsp++) { + register struct nlist *p = &lsp->nzlist.nlist; + + if (p->n_type == (N_SETV | N_EXT)) + continue; + + /* + * Turn magically prefixed symbols into set symbols of + * a corresponding type. + */ + if (set_element_prefixes && + set_element_prefixed_p(entry->strings+lsp->nzlist.nz_strx)) + lsp->nzlist.nz_type += (N_SETA - N_ABS); + + if (SET_ELEMENT_P(p->n_type)) { + set_symbol_count++; + if (!relocatable_output) + enter_global_ref(lsp, + p->n_un.n_strx + entry->strings, entry); + } else if (p->n_type == N_WARNING) { + char *name = p->n_un.n_strx + entry->strings; + + /* Grab the next entry. */ + p++; + if (p->n_type != (N_UNDF | N_EXT)) { + error("Warning symbol found in %s without external reference following.", + get_file_name(entry)); + make_executable = 0; + p--; /* Process normally. */ + } else { + symbol *sp; + char *sname = p->n_un.n_strx + entry->strings; + /* Deal with the warning symbol. */ + enter_global_ref(lsp, + p->n_un.n_strx + entry->strings, entry); + sp = getsym (sname); + sp->warning = (char *)xmalloc(strlen(name)+1); + strcpy (sp->warning, name); + warning_count++; + } + } else if (p->n_type & N_EXT) { + enter_global_ref(lsp, + p->n_un.n_strx + entry->strings, entry); + } else if (p->n_un.n_strx && !(p->n_type & (N_STAB | N_EXT)) + && !entry->is_dynamic) { + if ((p->n_un.n_strx + entry->strings)[0] != LPREFIX) + non_L_local_sym_count++; + local_sym_count++; + } else if (!entry->is_dynamic) + debugger_sym_count++; } - else if (p->n_type == N_WARNING) - { - char *name = p->n_un.n_strx + entry->strings; - - /* Grab the next entry. */ - p++; - if (p->n_type != (N_UNDF | N_EXT)) - { - fprintf (stderr, "%s: Warning symbol found in %s without external reference following.\n", - progname, entry->filename); - make_executable = 0; - p--; /* Process normally. */ - } - else - { - symbol *sp; - char *sname = p->n_un.n_strx + entry->strings; - /* Deal with the warning symbol. */ - enter_global_ref (p, p->n_un.n_strx + entry->strings, entry); - sp = getsym (sname); - sp->warning = (char *) xmalloc (strlen(name) + 1); - strcpy (sp->warning, name); - warning_count++; - } - } - else if (p->n_type & N_EXT) - enter_global_ref (p, p->n_un.n_strx + entry->strings, entry); - else if (p->n_un.n_strx && !(p->n_type & (N_STAB | N_EXT))) - { - if ((p->n_un.n_strx + entry->strings)[0] != LPREFIX) - non_L_local_sym_count++; - local_sym_count++; - } - else debugger_sym_count++; - } - /* Count one for the local symbol that we generate, - whose name is the file's name (usually) and whose address - is the start of the file's text. */ + /* + * Count one for the local symbol that we generate, + * whose name is the file's name (usually) and whose address + * is the start of the file's text. + */ - local_sym_count++; - non_L_local_sym_count++; + if (!entry->is_dynamic) { + local_sym_count++; + non_L_local_sym_count++; + } } -/* Enter one global symbol in the hash table. - NLIST_P points to the `struct nlist' read from the file - that describes the global symbol. NAME is the symbol's name. - ENTRY is the file entry for the file the symbol comes from. - - The `struct nlist' is modified by placing it on a chain of - all such structs that refer to the same global symbol. - This chain starts in the `refs' field of the symbol table entry - and is chained through the `n_name'. */ +/* + * Enter one global symbol in the hash table. LSP points to the `struct + * localsymbol' from the file that describes the global symbol. NAME is the + * symbol's name. ENTRY is the file entry for the file the symbol comes from. + * + * LSP is put on the chain of all such structs that refer to the same symbol. + * This chain starts in the `refs' for symbols from relocatable objects. A + * backpointer to the global symbol is kept in LSP. + * + * Symbols from shared objects are linked through `dynref'. For such symbols + * that's all we do at this stage, with the exception of the case where the + * symbol is a common. The `referenced' bit is only set for references from + * relocatable objects. + * + */ void -enter_global_ref (nlist_p, name, entry) - register struct nlist *nlist_p; +enter_global_ref (lsp, name, entry) + struct localsymbol *lsp; char *name; struct file_entry *entry; { - register symbol *sp = getsym (name); - register int type = nlist_p->n_type; - int oldref = sp->referenced; - int olddef = sp->defined; - - nlist_p->n_un.n_name = (char *) sp->refs; - sp->refs = nlist_p; + register struct nzlist *nzp = &lsp->nzlist; + register symbol *sp = getsym (name); + register int type = nzp->nz_type; + int oldref = sp->referenced; + int olddef = sp->defined; + int com = sp->defined && sp->max_common_size; + + if (type == (N_INDR | N_EXT)) { + sp->alias = getsym(entry->strings + (lsp + 1)->nzlist.nz_strx); + if (sp == sp->alias) { + error("%s: %s is alias for itself", + get_file_name(entry), name); + /* Rewrite symbol as global text symbol with value 0 */ + lsp->nzlist.nz_type = N_TEXT|N_EXT; + lsp->nzlist.nz_value = 0; + make_executable = 0; + } else + global_alias_count++; + } - sp->referenced = 1; - if (type != (N_UNDF | N_EXT) || nlist_p->n_value) - { - if (!sp->defined || sp->defined == (N_UNDF | N_EXT)) - sp->defined = type; + if (entry->is_dynamic) { + lsp->next = sp->sorefs; + sp->sorefs = lsp; + + /* + * Handle commons from shared objects: + * 1) If symbol hitherto undefined, turn it into a common. + * 2) If symbol already common, update size if necessary. + */ +/*XXX - look at case where commons are only in shared objects */ + if (type == (N_UNDF | N_EXT) && nzp->nz_value) { + if (!olddef) { + if (oldref) + undefined_global_sym_count--; + common_defined_global_count++; + sp->max_common_size = nzp->nz_value; + sp->defined = N_UNDF | N_EXT; + } else if (com && sp->max_common_size < nzp->nz_value) { + sp->max_common_size = nzp->nz_value; + } + } - if (oldref && !olddef) - /* It used to be undefined and we're defining it. */ - undefined_global_sym_count--; + /* + * Handle size information in shared objects. + */ + if (nzp->nz_size > sp->size) + sp->size = nzp->nz_size; - if (!olddef && type == (N_UNDF | N_EXT) && nlist_p->n_value) - { - /* First definition and it's common. */ - common_defined_global_count++; - sp->max_common_size = nlist_p->n_value; + lsp->symbol = sp; + return; } - else if (olddef && sp->max_common_size && type != (N_UNDF | N_EXT)) - { - /* It used to be common and we're defining it as - something else. */ - common_defined_global_count--; - sp->max_common_size = 0; - } - else if (olddef && sp->max_common_size && type == (N_UNDF | N_EXT) - && sp->max_common_size < nlist_p->n_value) - /* It used to be common and this is a new common entry to - which we need to pay attention. */ - sp->max_common_size = nlist_p->n_value; - - /* Are we defining it as a set element? */ - if (SET_ELEMENT_P (type) - && (!olddef || (olddef && sp->max_common_size))) - set_vector_count++; - /* As an indirection? */ - else if (type == (N_INDR | N_EXT)) - { - /* Indirect symbols value should be modified to point - a symbol being equivalenced to. */ - nlist_p->n_value - = (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx - + entry->strings); - if ((symbol *) nlist_p->n_value == sp) - { - /* Somebody redefined a symbol to be itself. */ - fprintf (stderr, "%s: Symbol %s indirected to itself.\n", - entry->filename, name); - /* Rewrite this symbol as being a global text symbol - with value 0. */ - nlist_p->n_type = sp->defined = N_TEXT | N_EXT; - nlist_p->n_value = 0; - /* Don't make the output executable. */ - make_executable = 0; - } - else - global_indirect_count++; - } - } - else - if (!oldref) -#ifndef DOLLAR_KLUDGE - undefined_global_sym_count++; -#else - { - if (entry->superfile && type == (N_UNDF | N_EXT) && name[1] == '$') - { - /* This is an (ISI?) $-conditional; skip it */ - sp->referenced = 0; - if (sp->trace) - { - fprintf (stderr, "symbol %s is a $-conditional ignored in ", sp->name); - print_file_name (entry, stderr); - fprintf (stderr, "\n"); - } - return; - } - else - undefined_global_sym_count++; - } -#endif - if (sp == end_symbol && entry->just_syms_flag && !T_flag_specified) - text_start = nlist_p->n_value; + lsp->next = sp->refs; + sp->refs = lsp; + lsp->symbol = sp; - if (sp->trace) - { - register char *reftype; - switch (type & N_TYPE) - { - case N_UNDF: - if (nlist_p->n_value) - reftype = "defined as common"; - else reftype = "referenced"; - break; - - case N_ABS: - reftype = "defined as absolute"; - break; - - case N_TEXT: - reftype = "defined in text section"; - break; - - case N_DATA: - reftype = "defined in data section"; - break; - - case N_BSS: - reftype = "defined in BSS section"; - break; - - case N_SETT: - reftype = "is a text set element"; - break; - - case N_SETD: - reftype = "is a data set element"; - break; - - case N_SETB: - reftype = "is a BSS set element"; - break; - - case N_SETA: - reftype = "is an absolute set element"; - break; - - case N_SETV: - reftype = "defined in data section as vector"; - break; - - case N_INDR: - reftype = (char *) alloca (23 - + strlen ((nlist_p + 1)->n_un.n_strx - + entry->strings)); - sprintf (reftype, "defined equivalent to %s", - (nlist_p + 1)->n_un.n_strx + entry->strings); - break; - -#ifdef sequent - case N_SHUNDF: - reftype = "shared undf"; - break; - -/* These conflict with cases above. - case N_SHDATA: - reftype = "shared data"; - break; - - case N_SHBSS: - reftype = "shared BSS"; - break; -*/ - default: - reftype = "I don't know this type"; - break; -#endif + sp->referenced = 1; + + if (sp == dynamic_symbol || sp == got_symbol) { + if (type != (N_UNDF | N_EXT) && !entry->just_syms_flag) + fatal("Linker reserved symbol %s defined as type %x ", + name, type); + return; } - fprintf (stderr, "symbol %s %s in ", sp->name, reftype); - print_file_name (entry, stderr); - fprintf (stderr, "\n"); - } +#ifdef N_SIZE + if (type == (N_SIZE | N_EXT)) { + if (sp->size < nzp->nz_value) + sp->size = nzp->nz_value; + } else +#endif + if (type != (N_UNDF | N_EXT) || nzp->nz_value) { + + /* + * Set `->defined' here, so commons and undefined globals + * can be counted correctly. + */ + if (!sp->defined || sp->defined == (N_UNDF | N_EXT)) + sp->defined = type; + + if (oldref && !olddef) + /* + * It used to be undefined and we're defining it. + */ + undefined_global_sym_count--; + + if (!olddef && type == (N_UNDF | N_EXT) && nzp->nz_value) { + /* + * First definition and it's common. + */ + common_defined_global_count++; + sp->max_common_size = nzp->nz_value; + } else if (com && type != (N_UNDF | N_EXT)) { + /* + * It used to be common and we're defining + * it as something else. + */ + common_defined_global_count--; + sp->max_common_size = 0; + } else if (com && type == (N_UNDF | N_EXT) + && sp->max_common_size < nzp->nz_value) + /* + * It used to be common and this is a new common entry + * to which we need to pay attention. + */ + sp->max_common_size = nzp->nz_value; + + if (SET_ELEMENT_P(type) && (!olddef || com)) + set_vector_count++; + + } else if (!oldref) + undefined_global_sym_count++; + + + if (sp == end_symbol && entry->just_syms_flag && !T_flag_specified) + text_start = nzp->nz_value; + + if (sp->trace) { + register char *reftype; + switch (type & N_TYPE) { + case N_UNDF: + reftype = nzp->nz_value? + "defined as common":"referenced"; + break; + + case N_ABS: + reftype = "defined as absolute"; + break; + + case N_TEXT: + reftype = "defined in text section"; + break; + + case N_DATA: + reftype = "defined in data section"; + break; + + case N_BSS: + reftype = "defined in BSS section"; + break; + + default: + reftype = "I don't know this type"; + break; + } + + fprintf (stderr, "symbol %s %s in ", sp->name, reftype); + print_file_name (entry, stderr); + fprintf (stderr, "\n"); + } } -/* This return 0 if the given file entry's symbol table does *not* - contain the nlist point entry, and it returns the files entry - pointer (cast to unsigned long) if it does. */ +/* + * This return 0 if the given file entry's symbol table does *not* contain + * the nlist point entry, and it returns the files entry pointer (cast to + * unsigned long) if it does. + */ unsigned long -contains_symbol (entry, n_ptr) +contains_symbol (entry, np) struct file_entry *entry; - register struct nlist *n_ptr; + register struct nlist *np; { - if (n_ptr >= entry->symbols && - n_ptr < (entry->symbols - + (entry->header.a_syms / sizeof (struct nlist)))) - return (unsigned long) entry; - return 0; + if (np >= &entry->symbols->nzlist.nlist && + np < &(entry->symbols + entry->nsymbols)->nzlist.nlist) + return (unsigned long) entry; + return 0; } - -/* Searching libraries */ - -struct file_entry *decode_library_subfile (); -void linear_library (), symdef_library (); - -/* Search the library ENTRY, already open on descriptor DESC. - This means deciding which library members to load, - making a chain of `struct file_entry' for those members, - and entering their global symbols in the hash table. */ - -void -search_library (desc, entry) - int desc; - struct file_entry *entry; -{ - int member_length; - register char *name; - register struct file_entry *subentry; - - if (!undefined_global_sym_count) return; - - /* Examine its first member, which starts SARMAG bytes in. */ - subentry = decode_library_subfile (desc, entry, SARMAG, &member_length); - if (!subentry) return; - - name = subentry->filename; - free (subentry); - - /* Search via __.SYMDEF if that exists, else linearly. */ - - if (!strcmp (name, "__.SYMDEF")) - symdef_library (desc, entry, member_length); - else - linear_library (desc, entry); -} -/* Construct and return a file_entry for a library member. - The library's file_entry is library_entry, and the library is open on DESC. - SUBFILE_OFFSET is the byte index in the library of this member's header. - We store the length of the member into *LENGTH_LOC. */ +void consider_file_section_lengths (), relocate_file_addresses (); +void consider_relocation(); -struct file_entry * -decode_library_subfile (desc, library_entry, subfile_offset, length_loc) - int desc; - struct file_entry *library_entry; - int subfile_offset; - int *length_loc; -{ - int bytes_read; - register int namelen; - int member_length; - register char *name; - struct ar_hdr hdr1; - register struct file_entry *subentry; - - lseek (desc, subfile_offset, 0); - - bytes_read = read (desc, &hdr1, sizeof hdr1); - if (!bytes_read) - return 0; /* end of archive */ - - if (sizeof hdr1 != bytes_read) - fatal_with_file ("malformed library archive ", library_entry); - - if (sscanf (hdr1.ar_size, "%d", &member_length) != 1) - fatal_with_file ("malformatted header of archive member in ", library_entry); - - subentry = (struct file_entry *) xmalloc (sizeof (struct file_entry)); - bzero (subentry, sizeof (struct file_entry)); - - for (namelen = 0; - namelen < sizeof hdr1.ar_name - && hdr1.ar_name[namelen] != 0 && hdr1.ar_name[namelen] != ' ' - && hdr1.ar_name[namelen] != '/'; - namelen++); - - name = (char *) xmalloc (namelen+1); - strncpy (name, hdr1.ar_name, namelen); - name[namelen] = 0; - - subentry->filename = name; - subentry->local_sym_name = name; - subentry->symbols = 0; - subentry->strings = 0; - subentry->subfiles = 0; - subentry->starting_offset = subfile_offset + sizeof hdr1; - subentry->superfile = library_entry; - subentry->library_flag = 0; - subentry->header_read_flag = 0; - subentry->just_syms_flag = 0; - subentry->chain = 0; - subentry->total_size = member_length; - - (*length_loc) = member_length; - - return subentry; -} - -int subfile_wanted_p (); +/* + * Having entered all the global symbols and found the sizes of sections of + * all files to be linked, make all appropriate deductions from this data. + * + * We propagate global symbol values from definitions to references. We compute + * the layout of the output file and where each input file's contents fit + * into it. + * + * This is now done in several stages. + * + * 1) All global symbols are examined for definitions in relocatable (.o) + * files. The symbols' type is set according to the definition found, + * but its value can not yet be determined. In stead, we keep a pointer + * to the file entry's localsymbol that bequeathed the global symbol with + * its definition. Also, multiple (incompatible) definitions are checked + * for in this pass. If no definition comes forward, the set of local + * symbols originating from shared objects is searched for a definition. + * + * 2) Then the relocation information of each relocatable file is examined + * for for possible contributions to the RRS section. + * + * 3) When this is done, the sizes and start addresses are set of all segments + * that will appear in the output file (including the RRS segment). + * + * 4) Finally, all symbols are relocated according according to the start + * of the entry they are part of. Then global symbols are assigned their + * final values. Also, space for commons and imported data are allocated + * during this pass, if the link mode in effect so demands. + * + */ -/* Search a library that has a __.SYMDEF member. - DESC is a descriptor on which the library is open. - The file pointer is assumed to point at the __.SYMDEF data. - ENTRY is the library's file_entry. - MEMBER_LENGTH is the length of the __.SYMDEF data. */ +void digest_pass1(), digest_pass2(); void -symdef_library (desc, entry, member_length) - int desc; - struct file_entry *entry; - int member_length; -{ - int *symdef_data = (int *) xmalloc (member_length); - register struct symdef *symdef_base; - char *sym_name_base; - int number_of_symdefs; - int length_of_strings; - int not_finished; - int bytes_read; - register int i; - struct file_entry *prev = 0; - int prev_offset = 0; - - bytes_read = read (desc, symdef_data, member_length); - if (bytes_read != member_length) - fatal_with_file ("malformatted __.SYMDEF in ", entry); - - number_of_symdefs = *symdef_data / sizeof (struct symdef); - if (number_of_symdefs < 0 || - number_of_symdefs * sizeof (struct symdef) + 2 * sizeof (int) > member_length) - fatal_with_file ("malformatted __.SYMDEF in ", entry); - - symdef_base = (struct symdef *) (symdef_data + 1); - length_of_strings = *(int *) (symdef_base + number_of_symdefs); - - if (length_of_strings < 0 - || number_of_symdefs * sizeof (struct symdef) + length_of_strings - + 2 * sizeof (int) > member_length) - fatal_with_file ("malformatted __.SYMDEF in ", entry); - - sym_name_base = sizeof (int) + (char *) (symdef_base + number_of_symdefs); - - /* Check all the string indexes for validity. */ - - for (i = 0; i < number_of_symdefs; i++) - { - register int index = symdef_base[i].symbol_name_string_index; - if (index < 0 || index >= length_of_strings - || (index && *(sym_name_base + index - 1))) - fatal_with_file ("malformatted __.SYMDEF in ", entry); - } - - /* Search the symdef data for members to load. - Do this until one whole pass finds nothing to load. */ - - not_finished = 1; - while (not_finished) - { - not_finished = 0; - - /* Scan all the symbols mentioned in the symdef for ones that we need. - Load the library members that contain such symbols. */ - - for (i = 0; - (i < number_of_symdefs - && (undefined_global_sym_count || common_defined_global_count)); - i++) - if (symdef_base[i].symbol_name_string_index >= 0) - { - register symbol *sp; - - sp = getsym_soft (sym_name_base - + symdef_base[i].symbol_name_string_index); - - /* If we find a symbol that appears to be needed, think carefully - about the archive member that the symbol is in. */ - - if (sp && ((sp->referenced && !sp->defined) - || (sp->defined && sp->max_common_size))) - { - int junk; - register int j; - register int offset = symdef_base[i].library_member_offset; - struct file_entry *subentry; - - /* Don't think carefully about any archive member - more than once in a given pass. */ - - if (prev_offset == offset) - continue; - prev_offset = offset; - - /* Read the symbol table of the archive member. */ - - subentry = decode_library_subfile (desc, entry, offset, &junk); - if (subentry == 0) - fatal ("invalid offset for %s in symbol table of %s", - sym_name_base - + symdef_base[i].symbol_name_string_index, - entry->filename); - read_entry_symbols (desc, subentry); - subentry->strings = (char *) malloc (subentry->string_size); - read_entry_strings (desc, subentry); - - /* Now scan the symbol table and decide whether to load. */ - - if (!subfile_wanted_p (subentry)) - { - free (subentry->symbols); - free (subentry); - } - else - { - /* This member is needed; load it. - Since we are loading something on this pass, - we must make another pass through the symdef data. */ - - not_finished = 1; - - enter_file_symbols (subentry); - - if (prev) - prev->chain = subentry; - else entry->subfiles = subentry; - prev = subentry; - - /* Clear out this member's symbols from the symdef data - so that following passes won't waste time on them. */ - - for (j = 0; j < number_of_symdefs; j++) - { - if (symdef_base[j].library_member_offset == offset) - symdef_base[j].symbol_name_string_index = -1; - } - } - - /* We'll read the strings again if we need them again. */ - free (subentry->strings); - subentry->strings = 0; - } - } - } - - free (symdef_data); -} - -/* Search a library that has no __.SYMDEF. - ENTRY is the library's file_entry. - DESC is the descriptor it is open on. */ - -void -linear_library (desc, entry) - int desc; - struct file_entry *entry; +digest_symbols () { - register struct file_entry *prev = 0; - register int this_subfile_offset = SARMAG; - - while (undefined_global_sym_count || common_defined_global_count) - { - int member_length; - register struct file_entry *subentry; - - subentry = decode_library_subfile (desc, entry, this_subfile_offset, - &member_length); - if (!subentry) return; + if (trace_files) + fprintf(stderr, "Digesting symbol information:\n\n"); + + if (!relocatable_output) { + /* + * The set sector size is the number of set elements + a word + * for each symbol for the length word at the beginning of + * the vector, plus a word for each symbol for a zero at the + * end of the vector (for incremental linking). + */ + set_sect_size = (2 * set_symbol_count + set_vector_count) * + sizeof (unsigned long); + set_vectors = (unsigned long *) xmalloc (set_sect_size); + setv_fill_count = 0; + } - read_entry_symbols (desc, subentry); - subentry->strings = (char *) alloca (subentry->string_size); - read_entry_strings (desc, subentry); + /* Pass 1: check and define symbols */ + defined_global_sym_count = 0; + digest_pass1(); - if (!subfile_wanted_p (subentry)) - { - free (subentry->symbols); - free (subentry); + if (!relocatable_output) { + each_full_file(consider_relocation, 0); /* Text */ + each_full_file(consider_relocation, 1); /* Data */ } - else - { - enter_file_symbols (subentry); - if (prev) - prev->chain = subentry; - else entry->subfiles = subentry; - prev = subentry; - subentry->strings = 0; /* Since space will dissapear on return */ + /* + * Compute total size of sections. + * RRS data is the first output data section, RRS text is the last + * text section. Thus, DATA_START is calculated from RRS_DATA_START + * and RRS_DATA_SIZE, while RRS_TEXT_START is derived from TEXT_START + * and TEXT_SIZE. + */ + consider_rrs_section_lengths(); + each_full_file(consider_file_section_lengths, 0); + rrs_text_start = text_start + text_size; + text_size += rrs_text_size; + data_size += rrs_data_size; + + /* + * If necessary, pad text section to full page in the file. Include + * the padding in the text segment size. + */ + + if (magic == ZMAGIC) { + int text_end = text_size + N_TXTOFF(outheader); + text_pad = PALIGN(text_end, page_size) - text_end; + text_size += text_pad; } + outheader.a_text = text_size; - this_subfile_offset += member_length + sizeof (struct ar_hdr); - if (this_subfile_offset & 1) this_subfile_offset++; - } -} - -/* ENTRY is an entry for a library member. - Its symbols have been read into core, but not entered. - Return nonzero if we ought to load this member. */ - -int -subfile_wanted_p (entry) - struct file_entry *entry; -{ - register struct nlist *p; - register struct nlist *end - = entry->symbols + entry->header.a_syms / sizeof (struct nlist); -#ifdef DOLLAR_KLUDGE - register int dollar_cond = 0; -#endif - - for (p = entry->symbols; p < end; p++) - { - register int type = p->n_type; - register char *name = p->n_un.n_strx + entry->strings; + /* + * Make the data segment address start in memory on a suitable + * boundary. + */ - /* If the symbol has an interesting definition, we could - potentially want it. */ - if (type & N_EXT - && (type != (N_UNDF | N_EXT) || p->n_value + if (!Tdata_flag_specified) + rrs_data_start = text_start + + DATA_START(outheader) - TEXT_START(outheader); -#ifdef DOLLAR_KLUDGE - || name[1] == '$' -#endif - ) - && !SET_ELEMENT_P (type) - && !set_element_prefixed_p (name)) - { - register symbol *sp = getsym_soft (name); - -#ifdef DOLLAR_KLUDGE - if (name[1] == '$') - { - sp = getsym_soft (&name[2]); - dollar_cond = 1; - if (!sp) continue; - if (sp->referenced) - { - if (write_map) - { - print_file_name (entry, stdout); - fprintf (stdout, " needed due to $-conditional %s\n", name); - } - return 1; - } - continue; - } + data_start = rrs_data_start + rrs_data_size; + if (!relocatable_output) { + set_sect_start = rrs_data_start + data_size; + data_size += set_sect_size; + } + bss_start = rrs_data_start + data_size; + +#ifdef DEBUG +printf("textstart = %#x, textsize = %#x, rrs_text_start = %#x, rrs_text_size %#x\n", + text_start, text_size, rrs_text_start, rrs_text_size); +printf("datastart = %#x, datasize = %#x, rrs_data_start %#x, rrs_data_size %#x\n", + data_start, data_size, rrs_data_start, rrs_data_size); +printf("bssstart = %#x, bsssize = %#x\n", + bss_start, bss_size); #endif - /* If this symbol has not been hashed, we can't be looking for it. */ + /* Compute start addresses of each file's sections and symbols. */ - if (!sp) continue; + each_full_file(relocate_file_addresses, 0); + relocate_rrs_addresses(); - if ((sp->referenced && !sp->defined) - || (sp->defined && sp->max_common_size && (type & N_TEXT) == 0)) - { - /* This is a symbol we are looking for. It is either - not yet defined or defined as a common. */ -#ifdef DOLLAR_KLUDGE - if (dollar_cond) continue; -#endif - if (type == (N_UNDF | N_EXT)) - { - /* Symbol being defined as common. - Remember this, but don't load subfile just for this. */ - - /* If it didn't used to be common, up the count of - common symbols. */ - if (!sp->max_common_size) - common_defined_global_count++; - - if (sp->max_common_size < p->n_value) - sp->max_common_size = p->n_value; - if (!sp->defined) - undefined_global_sym_count--; - sp->defined = 1; - continue; - } + /* Pass 2: assign values to symbols */ + digest_pass2(); - if (write_map) - { - print_file_name (entry, stdout); - fprintf (stdout, " needed due to %s\n", sp->name); - } - return 1; - } + if (end_symbol) { /* These are null if -r. */ + etext_symbol->value = text_start + text_size - text_pad; + edata_symbol->value = rrs_data_start + data_size; + end_symbol->value = rrs_data_start + data_size + bss_size; } - } - - return 0; -} - -void consider_file_section_lengths (), relocate_file_addresses (); + /* + * Figure the data_pad now, so that it overlaps with the bss + * addresses. + */ -/* Having entered all the global symbols and found the sizes of sections - of all files to be linked, make all appropriate deductions from this data. + if (specified_data_size && specified_data_size > data_size) + data_pad = specified_data_size - data_size; - We propagate global symbol values from definitions to references. - We compute the layout of the output file and where each input file's - contents fit into it. */ + if (magic == ZMAGIC) + data_pad = PALIGN(data_pad + data_size, page_size) - data_size; -void -digest_symbols () -{ - register int i; - int setv_fill_count; - - if (trace_files) - fprintf (stderr, "Digesting symbol information:\n\n"); - - /* Compute total size of sections */ + bss_size -= data_pad; + if (bss_size < 0) + bss_size = 0; - each_file (consider_file_section_lengths, 0); - - /* If necessary, pad text section to full page in the file. - Include the padding in the text segment size. */ - - if (magic == ZMAGIC || magic == QMAGIC) - { - int text_end = text_size + N_TXTOFF (outheader); - text_pad = ((text_end + page_size - 1) & (- page_size)) - text_end; - text_size += text_pad; - } - -#ifdef _N_BASEADDR - /* SunOS 4.1 N_TXTADDR depends on the value of outheader.a_entry. */ - outheader.a_entry = N_PAGSIZ (outheader); -#endif + data_size += data_pad; +} - outheader.a_text = text_size; -#ifdef sequent - outheader.a_text += N_ADDRADJ (outheader); +void +digest_pass1() +{ + + /* + * Now, for each symbol, verify that it is defined globally at most + * once within relocatable files (except when building a shared lib). + * and set the `defined' field if there is a definition. + * + * Then check the shared object symbol chain for any remaining + * undefined symbols. Set the `so_defined' field for any + * definition find this way. + */ + FOR_EACH_SYMBOL(i, sp) { + struct localsymbol *lsp; + int defs = 0; + + if (!sp->referenced) { +#if 0 + /* Check for undefined symbols in shared objects */ + int type; + for (lsp = sp->sorefs; lsp; lsp = lsp->next) { + type = lsp->nzlist.nlist.n_type; + if ((type & N_EXT) && type != (N_UNDF | N_EXT)) + break; + } + if ((type & N_EXT) && type == (N_UNDF | N_EXT)) + undefined_shobj_sym_count++; #endif - /* Make the data segment address start in memory on a suitable boundary. */ - - if (! Tdata_flag_specified) - data_start = N_DATADDR (outheader) + text_start - TEXT_START (outheader); - - /* Set up the set element vector */ - - if (!relocatable_output) - { - /* The set sector size is the number of set elements + a word - for each symbol for the length word at the beginning of the - vector, plus a word for each symbol for a zero at the end of - the vector (for incremental linking). */ - set_sect_size - = (2 * set_symbol_count + set_vector_count) * sizeof (unsigned long); - set_sect_start = data_start + data_size; - data_size += set_sect_size; - set_vectors = (unsigned long *) xmalloc (set_sect_size); - setv_fill_count = 0; - } - - /* Compute start addresses of each file's sections and symbols. */ - - each_full_file (relocate_file_addresses, 0); - - /* Now, for each symbol, verify that it is defined globally at most once. - Put the global value into the symbol entry. - Common symbols are allocated here, in the BSS section. - Each defined symbol is given a '->defined' field - which is the correct N_ code for its definition, - except in the case of common symbols with -r. - Then make all the references point at the symbol entry - instead of being chained together. */ - - defined_global_sym_count = 0; - - for (i = 0; i < TABSIZE; i++) - { - register symbol *sp; - for (sp = symtab[i]; sp; sp = sp->link) - { - /* For each symbol */ - register struct nlist *p, *next; - int defs = 0, com = sp->max_common_size; - struct nlist *first_definition; - for (p = sp->refs; p; p = next) - { - register int type = p->n_type; - - if (SET_ELEMENT_P (type)) - { - if (relocatable_output) - fatal ("internal: global ref to set element with -r"); - if (!defs++) - { - sp->value = set_sect_start - + setv_fill_count++ * sizeof (unsigned long); - sp->defined = N_SETV | N_EXT; - first_definition = p; - } - else if ((sp->defined & ~N_EXT) != N_SETV) - { - sp->multiply_defined = 1; - multiple_def_count++; - } - set_vectors[setv_fill_count++] = p->n_value; - } - else if ((type & N_EXT) && type != (N_UNDF | N_EXT) - && (type & N_TYPE) != N_FN) - { - /* non-common definition */ - if (defs++ && sp->value != p->n_value) - { - sp->multiply_defined = 1; - multiple_def_count++; - } - sp->value = p->n_value; - sp->defined = type; - first_definition = p; + /* Superfluous symbol from shared object */ + continue; } - next = (struct nlist *) p->n_un.n_name; - p->n_un.n_name = (char *) sp; - } - /* Allocate as common if defined as common and not defined for real */ - if (com && !defs) - { - if (!relocatable_output || force_common_definition) - { - int align = sizeof (int); - /* Round up to nearest sizeof (int). I don't know - whether this is necessary or not (given that - alignment is taken care of later), but it's - traditional, so I'll leave it in. Note that if - this size alignment is ever removed, ALIGN above - will have to be initialized to 1 instead of - sizeof (int). */ - - com = (com + sizeof (int) - 1) & (- sizeof (int)); - - while (!(com & align)) - align <<= 1; - - align = align > MAX_ALIGNMENT ? MAX_ALIGNMENT : align; - - bss_size = ((((bss_size + data_size + data_start) - + (align - 1)) & (- align)) - - data_size - data_start); - - sp->value = data_start + data_size + bss_size; - sp->defined = N_BSS | N_EXT; - bss_size += com; - if (write_map) - printf ("Allocating common %s: %x at %x\n", - sp->name, com, sp->value); - } - else - { - sp->defined = 0; - undefined_global_sym_count++; - } - } - /* Set length word at front of vector and zero byte at end. - Reverse the vector itself to put it in file order. */ - if ((sp->defined & ~N_EXT) == N_SETV) - { - unsigned long length_word_index - = (sp->value - set_sect_start) / sizeof (unsigned long); - unsigned long i, tmp; - - set_vectors[length_word_index] - = setv_fill_count - 1 - length_word_index; - - /* Reverse the vector. */ - for (i = 1; - i < (setv_fill_count - length_word_index - 1) / 2 + 1; - i++) - { - tmp = set_vectors[length_word_index + i]; - set_vectors[length_word_index + i] - = set_vectors[setv_fill_count - i]; - set_vectors[setv_fill_count - i] = tmp; + if (sp == got_symbol || sp == dynamic_symbol) + continue; + + for (lsp = sp->refs; lsp; lsp = lsp->next) { + register struct nlist *p = &lsp->nzlist.nlist; + register int type = p->n_type; + + if (SET_ELEMENT_P(type)) { + if (relocatable_output) + fatal( + "internal error: global ref to set el %s with -r", + sp->name); + if (!defs++) { + sp->defined = N_SETV | N_EXT; + sp->value = + setv_fill_count++ * sizeof(long); + } else if ((sp->defined & N_TYPE) != N_SETV) { + sp->multiply_defined = 1; + multiple_def_count++; + } + /* Keep count and remember symbol */ + sp->setv_count++; + set_vectors[setv_fill_count++] = (long)p; + + } else if ((type & N_EXT) && type != (N_UNDF | N_EXT) + && (type & N_TYPE) != N_FN + && (type & N_TYPE) != N_SIZE) { + /* non-common definition */ + if (defs++ && sp->value != p->n_value + && entry_symbol) { + sp->multiply_defined = 1; + multiple_def_count++; + } + sp->def_nlist = p; + sp->defined = type; + } } - set_vectors[setv_fill_count++] = 0; - } - if (sp->defined) - defined_global_sym_count++; - } - } - - if (end_symbol) /* These are null if -r. */ - { - etext_symbol->value = text_size + text_start; - edata_symbol->value = data_start + data_size; - end_symbol->value = data_start + data_size + bss_size; - } - - /* Figure the data_pad now, so that it overlaps with the bss addresses. */ - - if (specified_data_size && specified_data_size > data_size) - data_pad = specified_data_size - data_size; - - if (magic == ZMAGIC || magic == QMAGIC) - data_pad = ((data_pad + data_size + page_size - 1) & (- page_size)) - - data_size; - - bss_size -= data_pad; - if (bss_size < 0) bss_size = 0; - - data_size += data_pad; -} - -/* Accumulate the section sizes of input file ENTRY - into the section sizes of the output file. */ - -void -consider_file_section_lengths (entry) - register struct file_entry *entry; -{ - if (entry->just_syms_flag) - return; - - entry->text_start_address = text_size; - /* If there were any vectors, we need to chop them off */ - text_size += entry->header.a_text; - entry->data_start_address = data_size; - data_size += entry->header.a_data; - entry->bss_start_address = bss_size; - bss_size += entry->header.a_bss; - - text_reloc_size += entry->header.a_trsize; - data_reloc_size += entry->header.a_drsize; -} + if (sp->defined) { + if ((sp->defined & N_TYPE) == N_SETV) + /* Allocate zero entry in set vector */ + setv_fill_count++; + defined_global_sym_count++; + continue; + } -/* Determine where the sections of ENTRY go into the output file, - whose total section sizes are already known. - Also relocate the addresses of the file's local and debugger symbols. */ + if (relocatable_output) + /* We're done */ + continue; + + /* + * Still undefined, search the shared object symbols for a + * definition. This symbol must go into the RRS. + */ + if (building_shared_object) { + /* Just punt for now */ + undefined_global_sym_count--; + continue; + } -void -relocate_file_addresses (entry) - register struct file_entry *entry; -{ - entry->text_start_address += text_start; - /* Note that `data_start' and `data_size' have not yet been - adjusted for `data_pad'. If they had been, we would get the wrong - results here. */ - entry->data_start_address += data_start; - entry->bss_start_address += data_start + data_size; - - { - register struct nlist *p; - register struct nlist *end - = entry->symbols + entry->header.a_syms / sizeof (struct nlist); - - for (p = entry->symbols; p < end; p++) - { - /* If this belongs to a section, update it by the section's start address */ - register int type = p->n_type & N_TYPE; - - switch (type) - { - case N_TEXT: - case N_SETT: - p->n_value += entry->text_start_address; - break; - case N_DATA: - case N_SETV: - case N_SETD: - /* A symbol whose value is in the data section - is present in the input file as if the data section - started at an address equal to the length of the file's text. */ - p->n_value += entry->data_start_address - entry->header.a_text; - break; - case N_BSS: - case N_SETB: - /* likewise for symbols with value in BSS. */ - p->n_value += entry->bss_start_address - - entry->header.a_text - entry->header.a_data; - break; - } - } - } + for (lsp = sp->sorefs; lsp; lsp = lsp->next) { + register struct nlist *p = &lsp->nzlist.nlist; + register int type = p->n_type; + + if ((type & N_EXT) && type != (N_UNDF | N_EXT) + && (type & N_TYPE) != N_FN) { + /* non-common definition */ + sp->def_nlist = p; + sp->so_defined = type; + undefined_global_sym_count--; +#ifdef DEBUG +printf("shr: %s gets defined to %x with value %x\n", sp->name, type, sp->value); +#endif + break; + } + } + } END_EACH_SYMBOL; } - -void describe_file_sections (), list_file_locals (); - -/* Print a complete or partial map of the output file. */ void -print_symbols (outfile) - FILE *outfile; -{ - register int i; +digest_pass2() +{ + /* + * Assign each symbol its final value. + * If not -r'ing, allocate common symbols in the BSS section. + */ + + FOR_EACH_SYMBOL(i, sp) { + int size; + int align = sizeof(int); + + if (!sp->referenced) + continue; + + if ((sp->defined & N_TYPE) == N_SETV) { + /* + * Set length word at front of vector and zero byte + * at end. Reverse the vector itself to put it in + * file order. + */ + unsigned long i, tmp; + unsigned long length_word_index = + sp->value / sizeof(long); + + /* Relocate symbol value */ + sp->value += set_sect_start; + + set_vectors[length_word_index] = sp->setv_count; + + /* + * Relocate vector to final address. + */ + for (i = 0; i < sp->setv_count; i++) { + struct nlist *p = (struct nlist *) + set_vectors[1+i+length_word_index]; + + set_vectors[1+i+length_word_index] = p->n_value; + } + + /* + * Reverse the vector. + */ + for (i = 1; i < (sp->setv_count - 1)/2 + 1; i++) { + + tmp = set_vectors[length_word_index + i]; + set_vectors[length_word_index + i] = + set_vectors[length_word_index + sp->setv_count + 1 - i]; + set_vectors[length_word_index + sp->setv_count + 1 - i] = tmp; + } + + /* Clear terminating entry */ + set_vectors[length_word_index + sp->setv_count + 1] = 0; + continue; + } - fprintf (outfile, "\nFiles:\n\n"); - each_file (describe_file_sections, outfile); + if (sp->defined && sp->def_nlist && + ((sp->defined & ~N_EXT) != N_SETV)) + sp->value = sp->def_nlist->n_value; + + if (building_shared_object && !(link_mode & SYMBOLIC)) + /* No common allocation in shared objects */ + continue; + + if ((size = sp->max_common_size) != 0) { + /* + * It's a common. + */ + if (sp->defined != (N_UNDF + N_EXT)) + fatal("%s: common isn't", sp->name); + + } else if ((size = sp->size) != 0 && sp->defined == N_SIZE) { + /* + * It's data from shared object with size info. + */ + if (sp->so_defined != (N_DATA + N_EXT)) + fatal("%s: Bogus N_SIZE item", sp->name); + + } else + /* + * It's neither + */ + continue; + + + if (relocatable_output && !force_common_definition) { + sp->defined = 0; + undefined_global_sym_count++; + defined_global_sym_count--; + continue; + } - fprintf (outfile, "\nGlobal symbols:\n\n"); + /* + * Round up to nearest sizeof (int). I don't know whether + * this is necessary or not (given that alignment is taken + * care of later), but it's traditional, so I'll leave it in. + * Note that if this size alignment is ever removed, ALIGN + * above will have to be initialized to 1 instead of sizeof + * (int). + */ - for (i = 0; i < TABSIZE; i++) - { - register symbol *sp; - for (sp = symtab[i]; sp; sp = sp->link) - { - if (sp->defined == 1) - fprintf (outfile, " %s: common, length 0x%x\n", sp->name, sp->max_common_size); - if (sp->defined) - fprintf (outfile, " %s: 0x%x\n", sp->name, sp->value); - else if (sp->referenced) - fprintf (outfile, " %s: undefined\n", sp->name); - } - } + size = PALIGN(size, sizeof(int)); - each_file (list_file_locals, outfile); -} + while (!(size & align)) + align <<= 1; -void -describe_file_sections (entry, outfile) - struct file_entry *entry; - FILE *outfile; -{ - fprintf (outfile, " "); - print_file_name (entry, outfile); - if (entry->just_syms_flag) - fprintf (outfile, " symbols only\n", 0); - else - fprintf (outfile, " text %x(%x), data %x(%x), bss %x(%x) hex\n", - entry->text_start_address, entry->header.a_text, - entry->data_start_address, entry->header.a_data, - entry->bss_start_address, entry->header.a_bss); -} + align = align > MAX_ALIGNMENT ? + MAX_ALIGNMENT : align; -void -list_file_locals (entry, outfile) - struct file_entry *entry; - FILE *outfile; -{ - register struct nlist - *p, - *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist); - - entry->strings = (char *) alloca (entry->string_size); - read_entry_strings (file_open (entry), entry); + bss_size = PALIGN(bss_size + data_size + rrs_data_start, align) + - (data_size + rrs_data_start); - fprintf (outfile, "\nLocal symbols of "); - print_file_name (entry, outfile); - fprintf (outfile, ":\n\n"); - - for (p = entry->symbols; p < end; p++) - /* If this is a definition, - update it if necessary by this file's start address. */ - if (!(p->n_type & (N_STAB | N_EXT))) - fprintf (outfile, " %s: 0x%x\n", - entry->strings + p->n_un.n_strx, p->n_value); + sp->value = rrs_data_start + data_size + bss_size; + if (sp->defined == (N_UNDF | N_EXT)) + sp->defined = N_BSS | N_EXT; + else { + sp->so_defined = 0; + defined_global_sym_count++; + } + bss_size += size; + if (write_map) + printf("Allocating %s %s: %x at %x\n", + sp->defined==(N_BSS|N_EXT)?"common":"data", + sp->name, size, sp->value); - entry->strings = 0; /* All done with them. */ + } END_EACH_SYMBOL; } - -/* Static vars for do_warnings and subroutines of it */ -int list_unresolved_refs; /* List unresolved refs */ -int list_warning_symbols; /* List warning syms */ -int list_multiple_defs; /* List multiple definitions */ - /* - * Structure for communication between do_file_warnings and it's - * helper routines. Will in practice be an array of three of these: - * 0) Current line, 1) Next line, 2) Source file info. + * Scan relocation info in ENTRY for contributions to the dynamic section of + * the output file. */ -struct line_debug_entry -{ - int line; - char *filename; - struct nlist *sym; -}; - -void qsort (); -/* - * Helper routines for do_file_warnings. - */ - -/* Return an integer less than, equal to, or greater than 0 as per the - relation between the two relocation entries. Used by qsort. */ - -int -relocation_entries_relation (rel1, rel2) - struct relocation_info *rel1, *rel2; -{ - return RELOC_ADDRESS(rel1) - RELOC_ADDRESS(rel2); -} - -/* Moves to the next debugging symbol in the file. USE_DATA_SYMBOLS - determines the type of the debugging symbol to look for (DSLINE or - SLINE). STATE_POINTER keeps track of the old and new locatiosn in - the file. It assumes that state_pointer[1] is valid; ie - that it.sym points into some entry in the symbol table. If - state_pointer[1].sym == 0, this routine should not be called. */ - -int -next_debug_entry (use_data_symbols, state_pointer) - register int use_data_symbols; - /* Next must be passed by reference! */ - struct line_debug_entry state_pointer[3]; -{ - register struct line_debug_entry - *current = state_pointer, - *next = state_pointer + 1, - /* Used to store source file */ - *source = state_pointer + 2; - struct file_entry *entry = (struct file_entry *) source->sym; - - current->sym = next->sym; - current->line = next->line; - current->filename = next->filename; - - while (++(next->sym) < (entry->symbols - + entry->header.a_syms/sizeof (struct nlist))) - { - /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so - * may look negative...therefore, must mask to low bits - */ - switch (next->sym->n_type & 0xff) - { - case N_SLINE: - if (use_data_symbols) continue; - next->line = next->sym->n_desc; - return 1; - case N_DSLINE: - if (!use_data_symbols) continue; - next->line = next->sym->n_desc; - return 1; -#ifdef HAVE_SUN_STABS - case N_EINCL: - next->filename = source->filename; - continue; -#endif - case N_SO: - source->filename = next->sym->n_un.n_strx + entry->strings; - source->line++; -#ifdef HAVE_SUN_STABS - case N_BINCL: -#endif - case N_SOL: - next->filename - = next->sym->n_un.n_strx + entry->strings; - default: - continue; +void +consider_relocation (entry, dataseg) + struct file_entry *entry; + int dataseg; +{ + struct relocation_info *reloc, *end; + struct localsymbol *lsp; + symbol *sp; + + if (dataseg == 0) { + /* Text relocations */ + reloc = entry->textrel; + end = entry->textrel + entry->ntextrel; + } else { + /* Data relocations */ + reloc = entry->datarel; + end = entry->datarel + entry->ndatarel; } - } - next->sym = (struct nlist *) 0; - return 0; -} - -/* Create a structure to save the state of a scan through the debug - symbols. USE_DATA_SYMBOLS is set if we should be scanning for - DSLINE's instead of SLINE's. entry is the file entry which points - at the symbols to use. */ -struct line_debug_entry * -init_debug_scan (use_data_symbols, entry) - int use_data_symbols; - struct file_entry *entry; -{ - struct line_debug_entry - *state_pointer - = (struct line_debug_entry *) - xmalloc (3 * sizeof (struct line_debug_entry)); - register struct line_debug_entry - *current = state_pointer, - *next = state_pointer + 1, - *source = state_pointer + 2; /* Used to store source file */ - - struct nlist *tmp; - - for (tmp = entry->symbols; - tmp < (entry->symbols - + entry->header.a_syms/sizeof (struct nlist)); - tmp++) - if (tmp->n_type == (int) N_SO) - break; - - if (tmp >= (entry->symbols - + entry->header.a_syms/sizeof (struct nlist))) - { - /* I believe this translates to "We lose" */ - current->filename = next->filename = entry->filename; - current->line = next->line = -1; - current->sym = next->sym = (struct nlist *) 0; - return state_pointer; - } - - next->line = source->line = 0; - next->filename = source->filename - = (tmp->n_un.n_strx + entry->strings); - source->sym = (struct nlist *) entry; - next->sym = tmp; - - next_debug_entry (use_data_symbols, state_pointer); /* To setup next */ - - if (!next->sym) /* No line numbers for this section; */ - /* setup output results as appropriate */ - { - if (source->line) - { - current->filename = source->filename = entry->filename; - current->line = -1; /* Don't print lineno */ - } - else - { - current->filename = source->filename; - current->line = 0; + for (; reloc < end; reloc++) { + + /* + * First, do the PIC specific relocs. + * r_relative and r_copy should not occur at this point + * (we do output them). The others break down to these + * combinations: + * + * jmptab: extern: needs jmp slot + * !extern: "intersegment" jump/call, + * should get resolved in output + * + * baserel: extern: need GOT entry + * !extern: may need GOT entry, + * machine dependent + * + * baserel's always refer to symbol through `r_symbolnum' + * whether extern or not. Internal baserels refer to statics + * that must be accessed either *through* the GOT table like + * global data, or by means of an offset from the GOT table. + * The macro RELOC_STATICS_THROUGH_GOT_P() determines which + * applies, since this is a machine (compiler?) dependent + * addressing mode. + */ + + if (RELOC_JMPTAB_P(reloc)) { + + if (!RELOC_EXTERN_P(reloc)) + continue; + + lsp = &entry->symbols[reloc->r_symbolnum]; + sp = lsp->symbol; + if (sp->alias) + sp = sp->alias; + alloc_rrs_jmpslot(sp); + + } else if (RELOC_BASEREL_P(reloc)) { + + lsp = &entry->symbols[reloc->r_symbolnum]; + alloc_rrs_gotslot(reloc, lsp); + + } else if (RELOC_EXTERN_P(reloc)) { + + /* + * Non-PIC relocations. + * If the definition comes from a shared object + * we need a relocation entry in RRS. + * + * If the .so definition is N_TEXT a jmpslot is + * allocated. + * + * If it is N_DATA we allocate an address in BSS (?) + * and arrange for the data to be copied at run-time. + * The symbol is temporarily marked with N_SIZE in + * the `defined' field, so we know what to do in + * pass2() and during actual relocation. We convert + * the type back to something real again when writing + * out the symbols. + * + */ + lsp = &entry->symbols[reloc->r_symbolnum]; + sp = lsp->symbol; + if (sp == NULL) + fatal_with_file( + "internal error, sp==NULL", entry); + + if (sp->alias) + sp = sp->alias; + + /* + * Skip refs to _GLOBAL_OFFSET_TABLE_ and __DYNAMIC + */ + if (sp == got_symbol) { + if (!CHECK_GOT_RELOC(reloc)) + fatal_with_file( + "Unexpected relocation type ", entry); + continue; + } + + /* + * This symbol gives rise to a RRS entry + */ + + if (building_shared_object) { + alloc_rrs_reloc(sp); + continue; + } + + if (force_alias_definition && + sp->so_defined == N_TEXT + N_EXT) { + + /* Call to shared library procedure */ + alloc_rrs_jmpslot(sp); + + } else if (sp->size && + sp->so_defined == N_DATA + N_EXT) { + + /* Reference to shared library data */ + alloc_rrs_cpy_reloc(sp); + sp->defined = N_SIZE; + + } else if (!sp->defined && sp->max_common_size == 0) + alloc_rrs_reloc(sp); + + } else { + /* + * Segment relocation. + * Prepare an RRS relocation as these are load + * address dependent. + */ + if (building_shared_object) { + alloc_rrs_segment_reloc(reloc); + } + } } - return state_pointer; - } - - - next_debug_entry (use_data_symbols, state_pointer); /* To setup current */ - - return state_pointer; -} - -/* Takes an ADDRESS (in either text or data space) and a STATE_POINTER - which describes the current location in the implied scan through - the debug symbols within the file which ADDRESS is within, and - returns the source line number which corresponds to ADDRESS. */ - -int -address_to_line (address, state_pointer) - unsigned long address; - /* Next must be passed by reference! */ - struct line_debug_entry state_pointer[3]; -{ - struct line_debug_entry - *current = state_pointer, - *next = state_pointer + 1; - struct line_debug_entry *tmp_pointer; - - int use_data_symbols; - - if (next->sym) - use_data_symbols = (next->sym->n_type & N_TYPE) == N_DATA; - else - return current->line; - - /* Go back to the beginning if we've already passed it. */ - if (current->sym->n_value > address) - { - tmp_pointer = init_debug_scan (use_data_symbols, - (struct file_entry *) - ((state_pointer + 2)->sym)); - state_pointer[0] = tmp_pointer[0]; - state_pointer[1] = tmp_pointer[1]; - state_pointer[2] = tmp_pointer[2]; - free (tmp_pointer); - } - - /* If we're still in a bad way, return -1, meaning invalid line. */ - if (current->sym->n_value > address) - return -1; - - while (next->sym - && next->sym->n_value <= address - && next_debug_entry (use_data_symbols, state_pointer)) - ; - return current->line; } - -/* Macros for manipulating bitvectors. */ -#define BIT_SET_P(bv, index) ((bv)[(index) >> 3] & 1 << ((index) & 0x7)) -#define SET_BIT(bv, index) ((bv)[(index) >> 3] |= 1 << ((index) & 0x7)) - -/* This routine will scan through the relocation data of file ENTRY, - printing out references to undefined symbols and references to - symbols defined in files with N_WARNING symbols. If DATA_SEGMENT - is non-zero, it will scan the data relocation segment (and use - N_DSLINE symbols to track line number); otherwise it will scan the - text relocation segment. Warnings will be printed on the output - stream OUTFILE. Eventually, every nlist symbol mapped through will - be marked in the NLIST_BITVECTOR, so we don't repeat ourselves when - we scan the nlists themselves. */ - -do_relocation_warnings (entry, data_segment, outfile, nlist_bitvector) - struct file_entry *entry; - int data_segment; - FILE *outfile; - unsigned char *nlist_bitvector; +/* + * Accumulate the section sizes of input file ENTRY into the section sizes of + * the output file. + */ +void +consider_file_section_lengths (entry) + register struct file_entry *entry; { - struct relocation_info - *reloc_start = data_segment ? entry->datarel : entry->textrel, - *reloc; - int reloc_size - = ((data_segment ? entry->header.a_drsize : entry->header.a_trsize) - / sizeof (struct relocation_info)); - int start_of_segment - = (data_segment ? entry->data_start_address : entry->text_start_address); - struct nlist *start_of_syms = entry->symbols; - struct line_debug_entry *state_pointer - = init_debug_scan (data_segment != 0, entry); - register struct line_debug_entry - *current = state_pointer; - /* Assigned to generally static values; should not be written into. */ - char *errfmt; - /* Assigned to alloca'd values cand copied into; should be freed - when done. */ - char *errmsg; - int invalidate_line_number; - - /* We need to sort the relocation info here. Sheesh, so much effort - for one lousy error optimization. */ - - qsort (reloc_start, reloc_size, sizeof (struct relocation_info), - relocation_entries_relation); - - for (reloc = reloc_start; - reloc < (reloc_start + reloc_size); - reloc++) - { - register struct nlist *s; - register symbol *g; - - /* If the relocation isn't resolved through a symbol, continue */ - if (!RELOC_EXTERN_P(reloc)) - continue; - - s = &(entry->symbols[RELOC_SYMBOL(reloc)]); - - /* Local symbols shouldn't ever be used by relocation info, so - the next should be safe. - This is, of course, wrong. References to local BSS symbols can be - the targets of relocation info, and they can (must) be - resolved through symbols. However, these must be defined properly, - (the assembler would have caught it otherwise), so we can - ignore these cases. */ - if (!(s->n_type & N_EXT)) - continue; - - g = (symbol *) s->n_un.n_name; - errmsg = 0; - - if (!g->defined && list_unresolved_refs) /* Reference */ - { - /* Mark as being noted by relocation warning pass. */ - SET_BIT (nlist_bitvector, s - start_of_syms); - - if (g->undef_refs >= MAX_UREFS_PRINTED) /* Listed too many */ - continue; - - /* Undefined symbol which we should mention */ - - if (++(g->undef_refs) == MAX_UREFS_PRINTED) - { - errfmt = "More undefined symbol %s refs follow"; - invalidate_line_number = 1; - } - else - { - errfmt = "Undefined symbol %s referenced from %s segment"; - invalidate_line_number = 0; - } - } - else /* Defined */ - { - /* Potential symbol warning here */ - if (!g->warning) continue; - - /* Mark as being noted by relocation warning pass. */ - SET_BIT (nlist_bitvector, s - start_of_syms); - - errfmt = 0; - errmsg = g->warning; - invalidate_line_number = 0; - } - - - /* If errfmt == 0, errmsg has already been defined. */ - if (errfmt != 0) - { - char *nm; - - if (demangler == NULL || (nm = (*demangler)(g->name)) == NULL) - nm = g->name; - errmsg = (char *) xmalloc (strlen (errfmt) + strlen (nm) + 1); - sprintf (errmsg, errfmt, nm, data_segment ? "data" : "text"); - if (nm != g->name) - free (nm); - } - - address_to_line (RELOC_ADDRESS (reloc) + start_of_segment, - state_pointer); + if (entry->just_syms_flag) + return; - if (current->line >=0) - fprintf (outfile, "%s:%d: %s\n", current->filename, - invalidate_line_number ? 0 : current->line, errmsg); - else - fprintf (outfile, "%s: %s\n", current->filename, errmsg); + entry->text_start_address = text_size; + /* If there were any vectors, we need to chop them off */ + text_size += entry->header.a_text; + entry->data_start_address = data_size; + data_size += entry->header.a_data; + entry->bss_start_address = bss_size; + bss_size += entry->header.a_bss; - if (errfmt != 0) - free (errmsg); - } - - free (state_pointer); + text_reloc_size += entry->header.a_trsize; + data_reloc_size += entry->header.a_drsize; } -/* Print on OUTFILE a list of all warnings generated by references - and/or definitions in the file ENTRY. List source file and line - number if possible, just the .o file if not. */ - +/* + * Determine where the sections of ENTRY go into the output file, + * whose total section sizes are already known. + * Also relocate the addresses of the file's local and debugger symbols. + */ void -do_file_warnings (entry, outfile) - struct file_entry *entry; - FILE *outfile; +relocate_file_addresses (entry) + register struct file_entry *entry; { - int number_of_syms = entry->header.a_syms / sizeof (struct nlist); - unsigned char *nlist_bitvector - = (unsigned char *) alloca ((number_of_syms >> 3) + 1); - struct line_debug_entry *text_scan, *data_scan; - int i; - char *errfmt, *file_name; - int line_number; - int dont_allow_symbol_name; - - bzero (nlist_bitvector, (number_of_syms >> 3) + 1); - - /* Read in the files strings if they aren't available */ - if (!entry->strings) - { - int desc; - - entry->strings = (char *) alloca (entry->string_size); - desc = file_open (entry); - read_entry_strings (desc, entry); - } - - read_file_relocation (entry); - - /* Do text warnings based on a scan through the relocation info. */ - do_relocation_warnings (entry, 0, outfile, nlist_bitvector); - - /* Do data warnings based on a scan through the relocation info. */ - do_relocation_warnings (entry, 1, outfile, nlist_bitvector); - - /* Scan through all of the nlist entries in this file and pick up - anything that the scan through the relocation stuff didn't. */ - - text_scan = init_debug_scan (0, entry); - data_scan = init_debug_scan (1, entry); - - for (i = 0; i < number_of_syms; i++) - { - struct nlist *s; - struct glosym *g; - - s = entry->symbols + i; - - if (!(s->n_type & N_EXT)) - continue; - - g = (symbol *) s->n_un.n_name; - dont_allow_symbol_name = 0; - - if (list_multiple_defs && g->multiply_defined) - { - errfmt = "Definition of symbol %s (multiply defined)"; - switch (s->n_type) - { - case N_TEXT | N_EXT: - line_number = address_to_line (s->n_value, text_scan); - file_name = text_scan[0].filename; - break; - case N_DATA | N_EXT: - line_number = address_to_line (s->n_value, data_scan); - file_name = data_scan[0].filename; - break; - case N_SETA | N_EXT: - case N_SETT | N_EXT: - case N_SETD | N_EXT: - case N_SETB | N_EXT: - if (g->multiply_defined == 2) - continue; - errfmt = "First set element definition of symbol %s (multiply defined)"; - break; - default: - continue; /* Don't print out multiple defs - at references. */ - } - } - else if (BIT_SET_P (nlist_bitvector, i)) - continue; - else if (list_unresolved_refs && !g->defined) - { - if (g->undef_refs >= MAX_UREFS_PRINTED) - continue; - - if (++(g->undef_refs) == MAX_UREFS_PRINTED) - errfmt = "More undefined \"%s\" refs follow"; - else - errfmt = "Undefined symbol \"%s\" referenced"; - line_number = -1; - } - else if (g->warning) - { - /* There are two cases in which we don't want to - do this. The first is if this is a definition instead of - a reference. The second is if it's the reference used by - the warning stabs itself. */ - if (s->n_type != (N_EXT | N_UNDF) - || (i && (s-1)->n_type == N_WARNING)) - continue; - - errfmt = g->warning; - line_number = -1; - dont_allow_symbol_name = 1; - } - else - continue; - - if (line_number == -1) - fprintf (outfile, "%s: ", entry->filename); - else - fprintf (outfile, "%s:%d: ", file_name, line_number); + register struct localsymbol *lsp, *lspend; + + entry->text_start_address += text_start; + /* + * Note that `data_start' and `data_size' have not yet been + * adjusted for `data_pad'. If they had been, we would get the wrong + * results here. + */ + entry->data_start_address += data_start; + entry->bss_start_address += bss_start; +#ifdef DEBUG +printf("%s: datastart: %#x, bss %#x\n", get_file_name(entry), + entry->data_start_address, entry->bss_start_address); +#endif - if (dont_allow_symbol_name) - fprintf (outfile, "%s", errfmt); - else - { - char *nm; - if (demangler != NULL && (nm = (*demangler)(g->name)) != NULL) - { - fprintf (outfile, errfmt, nm); - free (nm); - } - else - fprintf (outfile, errfmt, g->name); + lspend = entry->symbols + entry->nsymbols; + + for (lsp = entry->symbols; lsp < lspend; lsp++) { + register struct nlist *p = &lsp->nzlist.nlist; + /* + * If this belongs to a section, update it + * by the section's start address + */ + register int type = p->n_type & N_TYPE; + + switch (type) { + case N_TEXT: + case N_SETT: + p->n_value += entry->text_start_address; + break; + case N_DATA: + case N_SETD: + case N_SETV: + /* + * A symbol whose value is in the data section is + * present in the input file as if the data section + * started at an address equal to the length of the + * file's text. + */ + p->n_value += entry->data_start_address - + entry->header.a_text; + break; + case N_BSS: + case N_SETB: + /* likewise for symbols with value in BSS. */ + p->n_value += entry->bss_start_address + - entry->header.a_text - entry->header.a_data; + break; + } } - - fputc ('\n', outfile); - } - free (text_scan); - free (data_scan); - entry->strings = 0; /* Since it will dissapear anyway. */ -} - -do_warnings (outfile) - FILE *outfile; -{ - list_unresolved_refs = !relocatable_output && undefined_global_sym_count; - list_warning_symbols = warning_count; - list_multiple_defs = multiple_def_count != 0; - - if (!(list_unresolved_refs || - list_warning_symbols || - list_multiple_defs )) - /* No need to run this routine */ - return; - - each_file (do_file_warnings, outfile); - - if (list_unresolved_refs || list_multiple_defs) - make_executable = 0; } /* Write the output file */ @@ -3200,168 +1879,117 @@ do_warnings (outfile) void write_output () { - struct stat statbuf; - int filemode; + struct stat statbuf; + int filemode; + + if (lstat(output_filename, &statbuf) != -1) { + if (!S_ISDIR(statbuf.st_mode)) + (void)unlink(output_filename); + } - (void) unlink (output_filename); - outdesc = open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); - if (outdesc < 0) perror_name (output_filename); + outdesc = open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); + if (outdesc < 0) + perror_name (output_filename); - if (fstat (outdesc, &statbuf) < 0) - perror_name (output_filename); + if (fstat (outdesc, &statbuf) < 0) + perror_name (output_filename); - filemode = statbuf.st_mode; + filemode = statbuf.st_mode; - chmod (output_filename, filemode & ~0111); + chmod (output_filename, filemode & ~0111); - /* Output the a.out header. */ - write_header (); + /* Output the a.out header. */ + write_header (); - /* Output the text and data segments, relocating as we go. */ - write_text (); - write_data (); + /* Output the text and data segments, relocating as we go. */ + write_text (); + write_data (); - /* Output the merged relocation info, if requested with `-r'. */ - if (relocatable_output) - write_rel (); + /* Output the merged relocation info, if requested with `-r'. */ + if (relocatable_output) + write_rel (); - /* Output the symbol table (both globals and locals). */ - write_syms (); + /* Output the symbol table (both globals and locals). */ + write_syms (); - /* Copy any GDB symbol segments from input files. */ - write_symsegs (); + /* Output the RSS section */ + write_rrs (); - close (outdesc); + close (outdesc); - if (chmod (output_filename, filemode | 0111) == -1) - perror_name (output_filename); + if (chmod (output_filename, filemode | 0111) == -1) + perror_name (output_filename); } void modify_location (), perform_relocation (), copy_text (), copy_data (); +/* Total number of symbols to be written in the output file. */ +int nsyms; + void write_header () { - N_SET_MAGIC (outheader, magic); - outheader.a_text = text_size; -#ifdef sequent - outheader.a_text += N_ADDRADJ (outheader); - if (entry_symbol == 0) - entry_symbol = getsym("start"); -#endif - outheader.a_data = data_size; - outheader.a_bss = bss_size; - outheader.a_entry = (entry_symbol ? entry_symbol->value - : text_start + entry_offset); -#ifdef COFF_ENCAPSULATE - if (need_coff_header) - { - /* We are encapsulating BSD format within COFF format. */ - struct coffscn *tp, *dp, *bp; - - tp = &coffheader.scns[0]; - dp = &coffheader.scns[1]; - bp = &coffheader.scns[2]; - - strcpy (tp->s_name, ".text"); - tp->s_paddr = text_start; - tp->s_vaddr = text_start; - tp->s_size = text_size; - tp->s_scnptr = sizeof (struct coffheader) + sizeof (struct exec); - tp->s_relptr = 0; - tp->s_lnnoptr = 0; - tp->s_nreloc = 0; - tp->s_nlnno = 0; - tp->s_flags = 0x20; - strcpy (dp->s_name, ".data"); - dp->s_paddr = data_start; - dp->s_vaddr = data_start; - dp->s_size = data_size; - dp->s_scnptr = tp->s_scnptr + tp->s_size; - dp->s_relptr = 0; - dp->s_lnnoptr = 0; - dp->s_nreloc = 0; - dp->s_nlnno = 0; - dp->s_flags = 0x40; - strcpy (bp->s_name, ".bss"); - bp->s_paddr = dp->s_vaddr + dp->s_size; - bp->s_vaddr = bp->s_paddr; - bp->s_size = bss_size; - bp->s_scnptr = 0; - bp->s_relptr = 0; - bp->s_lnnoptr = 0; - bp->s_nreloc = 0; - bp->s_nlnno = 0; - bp->s_flags = 0x80; - - coffheader.f_magic = COFF_MAGIC; - coffheader.f_nscns = 3; - /* store an unlikely time so programs can - * tell that there is a bsd header - */ - coffheader.f_timdat = 1; - coffheader.f_symptr = 0; - coffheader.f_nsyms = 0; - coffheader.f_opthdr = 28; - coffheader.f_flags = 0x103; - /* aouthdr */ - coffheader.magic = ZMAGIC; - coffheader.vstamp = 0; - coffheader.tsize = tp->s_size; - coffheader.dsize = dp->s_size; - coffheader.bsize = bp->s_size; - coffheader.entry = outheader.a_entry; - coffheader.text_start = tp->s_vaddr; - coffheader.data_start = dp->s_vaddr; - } -#endif + int flags = (rrs_section_type == RRS_FULL) ? EX_DYNAMIC : 0; + + N_SET_FLAG (outheader, flags); + outheader.a_text = text_size; + outheader.a_data = data_size; + outheader.a_bss = bss_size; + outheader.a_entry = (entry_symbol ? entry_symbol->value + : text_start + entry_offset); + + if (strip_symbols == STRIP_ALL) + nsyms = 0; + else { + nsyms = (defined_global_sym_count + undefined_global_sym_count); + if (discard_locals == DISCARD_L) + nsyms += non_L_local_sym_count; + else if (discard_locals == DISCARD_NONE) + nsyms += local_sym_count; + + if (relocatable_output) + /* For each alias we write out two struct nlists */ + nsyms += set_symbol_count + global_alias_count; + + if (dynamic_symbol->referenced) + nsyms++, special_sym_count++; + + if (got_symbol->referenced) + nsyms++, special_sym_count++; + } -#ifdef INITIALIZE_HEADER - INITIALIZE_HEADER; -#endif + if (strip_symbols == STRIP_NONE) + nsyms += debugger_sym_count; - if (strip_symbols == STRIP_ALL) - nsyms = 0; - else - { - nsyms = (defined_global_sym_count - + undefined_global_sym_count); - if (discard_locals == DISCARD_L) - nsyms += non_L_local_sym_count; - else if (discard_locals == DISCARD_NONE) - nsyms += local_sym_count; - /* One extra for following reference on indirects */ - if (relocatable_output) - nsyms += set_symbol_count + global_indirect_count; - } - - if (strip_symbols == STRIP_NONE) - nsyms += debugger_sym_count; - - outheader.a_syms = nsyms * sizeof (struct nlist); - - if (relocatable_output) - { - outheader.a_trsize = text_reloc_size; - outheader.a_drsize = data_reloc_size; - } - else - { - outheader.a_trsize = 0; - outheader.a_drsize = 0; - } - -#ifdef COFF_ENCAPSULATE - if (need_coff_header) - mywrite (&coffheader, sizeof coffheader, 1, outdesc); +#ifdef DEBUG +printf("defined globals: %d, undefined globals %d, locals: %d (non_L: %d), \ +debug symbols: %d, special: %d --> nsyms %d\n", + defined_global_sym_count, undefined_global_sym_count, + local_sym_count, non_L_local_sym_count, debugger_sym_count, + special_sym_count, nsyms); #endif - mywrite (&outheader, sizeof (struct exec), 1, outdesc); - /* Output whatever padding is required in the executable file - between the header and the start of the text. */ + outheader.a_syms = nsyms * sizeof (struct nlist); + + if (relocatable_output) { + outheader.a_trsize = text_reloc_size; + outheader.a_drsize = data_reloc_size; + } else { + outheader.a_trsize = 0; + outheader.a_drsize = 0; + } + + md_swapout_exec_hdr(&outheader); + mywrite (&outheader, sizeof (struct exec), 1, outdesc); + md_swapin_exec_hdr(&outheader); + + /* + * Output whatever padding is required in the executable file + * between the header and the start of the text. + */ #ifndef COFF_ENCAPSULATE - padfile (N_TXTOFF (outheader) - sizeof outheader, outdesc); + padfile (N_TXTOFF(outheader) - sizeof outheader, outdesc); #endif } @@ -3371,125 +1999,55 @@ write_header () void write_text () { - if (trace_files) - fprintf (stderr, "Copying and relocating text:\n\n"); - each_full_file (copy_text, 0); - file_close (); + if (trace_files) + fprintf (stderr, "Copying and relocating text:\n\n"); - if (trace_files) - fprintf (stderr, "\n"); + each_full_file (copy_text, 0); + file_close (); - padfile (text_pad, outdesc); -} - -int -text_offset (entry) - struct file_entry *entry; -{ - return entry->starting_offset + N_TXTOFF (entry->header); -} - -/* Read in all of the relocation information */ - -void -read_relocation () -{ - each_full_file (read_file_relocation, 0); -} - -/* Read in the relocation sections of ENTRY if necessary */ + if (trace_files) + fprintf (stderr, "\n"); -void -read_file_relocation (entry) - struct file_entry *entry; -{ - register struct relocation_info *reloc; - int desc; - int read_return; - - desc = -1; - if (!entry->textrel) - { - reloc = (struct relocation_info *) xmalloc (entry->header.a_trsize); - desc = file_open (entry); - lseek (desc, - text_offset (entry) + entry->header.a_text + entry->header.a_data, - L_SET); - if (entry->header.a_trsize != (read_return = read (desc, reloc, entry->header.a_trsize))) - { - fprintf (stderr, "Return from read: %d\n", read_return); - fatal_with_file ("premature eof in text relocation of ", entry); - } - entry->textrel = reloc; - } - - if (!entry->datarel) - { - reloc = (struct relocation_info *) xmalloc (entry->header.a_drsize); - if (desc == -1) desc = file_open (entry); - lseek (desc, - text_offset (entry) + entry->header.a_text - + entry->header.a_data + entry->header.a_trsize, - L_SET); - if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize)) - fatal_with_file ("premature eof in data relocation of ", entry); - entry->datarel = reloc; - } + padfile (text_pad, outdesc); } -/* Read the text segment contents of ENTRY, relocate them, - and write the result to the output file. - If `-r', save the text relocation for later reuse. */ - +/* + * Read the text segment contents of ENTRY, relocate them, and write the + * result to the output file. If `-r', save the text relocation for later + * reuse. + */ void copy_text (entry) struct file_entry *entry; { - register char *bytes; - register int desc; - register struct relocation_info *reloc; + register char *bytes; + register int desc; - if (trace_files) - prline_file_name (entry, stderr); + if (trace_files) + prline_file_name (entry, stderr); - desc = file_open (entry); + desc = file_open (entry); - /* Allocate space for the file's text section */ + /* Allocate space for the file's text section */ + bytes = (char *) alloca (entry->header.a_text); - bytes = (char *) alloca (entry->header.a_text); + /* Deal with relocation information however is appropriate */ + if (entry->textrel == NULL) + fatal_with_file("no text relocation of ", entry); - /* Deal with relocation information however is appropriate */ + /* Read the text section into core. */ + lseek (desc, text_offset (entry), 0); + if (entry->header.a_text != read (desc, bytes, entry->header.a_text)) + fatal_with_file ("premature eof in text section of ", entry); - if (entry->textrel) reloc = entry->textrel; - else if (relocatable_output) - { - read_file_relocation (entry); - reloc = entry->textrel; - } - else - { - reloc = (struct relocation_info *) alloca (entry->header.a_trsize); - lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0); - if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize)) - fatal_with_file ("premature eof in text relocation of ", entry); - } - /* Read the text section into core. */ + /* Relocate the text according to the text relocation. */ + perform_relocation (bytes, entry->header.a_text, + entry->textrel, entry->ntextrel, entry, 0); - lseek (desc, text_offset (entry), 0); - if (entry->header.a_text != read (desc, bytes, entry->header.a_text)) - fatal_with_file ("premature eof in text section of ", entry); - - - /* Relocate the text according to the text relocation. */ - - perform_relocation (bytes, entry->text_start_address, entry->header.a_text, - reloc, entry->header.a_trsize, entry); - - /* Write the relocated text to the output file. */ - - mywrite (bytes, 1, entry->header.a_text, outdesc); + /* Write the relocated text to the output file. */ + mywrite (bytes, 1, entry->header.a_text, outdesc); } /* Relocate the data segment of each input file @@ -3498,298 +2056,309 @@ copy_text (entry) void write_data () { - if (trace_files) - fprintf (stderr, "Copying and relocating data:\n\n"); + long pos; - each_full_file (copy_data, 0); - file_close (); + if (trace_files) + fprintf (stderr, "Copying and relocating data:\n\n"); - /* Write out the set element vectors. See digest symbols for - description of length of the set vector section. */ + pos = N_DATOFF(outheader) + data_start - rrs_data_start; + if (lseek(outdesc, pos, L_SET) != pos) + fatal("write_data: lseek: cant position data offset"); - if (set_vector_count) - mywrite (set_vectors, 2 * set_symbol_count + set_vector_count, - sizeof (unsigned long), outdesc); + each_full_file (copy_data, 0); + file_close (); - if (trace_files) - fprintf (stderr, "\n"); + /* + * Write out the set element vectors. See digest symbols for + * description of length of the set vector section. + */ - padfile (data_pad, outdesc); -} + if (set_vector_count) { + swap_longs(set_vectors, 2 * set_symbol_count + set_vector_count); + mywrite (set_vectors, 2 * set_symbol_count + set_vector_count, + sizeof (unsigned long), outdesc); + } + + if (trace_files) + fprintf (stderr, "\n"); -/* Read the data segment contents of ENTRY, relocate them, - and write the result to the output file. - If `-r', save the data relocation for later reuse. - See comments in `copy_text'. */ + padfile (data_pad, outdesc); +} +/* + * Read the data segment contents of ENTRY, relocate them, and write the + * result to the output file. If `-r', save the data relocation for later + * reuse. See comments in `copy_text'. + */ void copy_data (entry) struct file_entry *entry; { - register struct relocation_info *reloc; - register char *bytes; - register int desc; - - if (trace_files) - prline_file_name (entry, stderr); - - desc = file_open (entry); - - bytes = (char *) alloca (entry->header.a_data); - - if (entry->datarel) reloc = entry->datarel; - else if (relocatable_output) /* Will need this again */ - { - read_file_relocation (entry); - reloc = entry->datarel; - } - else - { - reloc = (struct relocation_info *) alloca (entry->header.a_drsize); - lseek (desc, text_offset (entry) + entry->header.a_text - + entry->header.a_data + entry->header.a_trsize, - 0); - if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize)) - fatal_with_file ("premature eof in data relocation of ", entry); - } - - lseek (desc, text_offset (entry) + entry->header.a_text, 0); - if (entry->header.a_data != read (desc, bytes, entry->header.a_data)) - fatal_with_file ("premature eof in data section of ", entry); - - perform_relocation (bytes, entry->data_start_address - entry->header.a_text, - entry->header.a_data, reloc, entry->header.a_drsize, entry); - - mywrite (bytes, 1, entry->header.a_data, outdesc); -} - -/* Relocate ENTRY's text or data section contents. - DATA is the address of the contents, in core. - DATA_SIZE is the length of the contents. - PC_RELOCATION is the difference between the address of the contents - in the output file and its address in the input file. - RELOC_INFO is the address of the relocation info, in core. - RELOC_SIZE is its length in bytes. */ -/* This version is about to be severly hacked by Randy. Hope it - works afterwards. */ -void -perform_relocation (data, pc_relocation, data_size, reloc_info, reloc_size, entry) - char *data; - struct relocation_info *reloc_info; - struct file_entry *entry; - int pc_relocation; - int data_size; - int reloc_size; -{ - register struct relocation_info *p = reloc_info; - struct relocation_info *end - = reloc_info + reloc_size / sizeof (struct relocation_info); - int text_relocation = entry->text_start_address; - int data_relocation = entry->data_start_address - entry->header.a_text; - int bss_relocation - = entry->bss_start_address - entry->header.a_text - entry->header.a_data; - - for (; p < end; p++) - { - register int relocation = 0; - register int addr = RELOC_ADDRESS(p); - register unsigned int mask = 0; - - if (addr >= data_size) - fatal_with_file ("relocation address out of range in ", entry); - - if (RELOC_EXTERN_P(p)) - { - int symindex = RELOC_SYMBOL (p) * sizeof (struct nlist); - symbol *sp = ((symbol *) - (((struct nlist *) - (((char *)entry->symbols) + symindex)) - ->n_un.n_name)); - -#ifdef N_INDR - /* Resolve indirection */ - if ((sp->defined & ~N_EXT) == N_INDR) - sp = (symbol *) sp->value; -#endif - - if (symindex >= entry->header.a_syms) - fatal_with_file ("relocation symbolnum out of range in ", entry); + register char *bytes; + register int desc; - /* If the symbol is undefined, leave it at zero. */ - if (! sp->defined) - relocation = 0; - else - relocation = sp->value; - } - else switch (RELOC_TYPE(p)) - { - case N_TEXT: - case N_TEXT | N_EXT: - relocation = text_relocation; - break; - - case N_DATA: - case N_DATA | N_EXT: - /* A word that points to beginning of the the data section - initially contains not 0 but rather the "address" of that section - in the input file, which is the length of the file's text. */ - relocation = data_relocation; - break; - - case N_BSS: - case N_BSS | N_EXT: - /* Similarly, an input word pointing to the beginning of the bss - initially contains the length of text plus data of the file. */ - relocation = bss_relocation; - break; - - case N_ABS: - case N_ABS | N_EXT: - /* Don't know why this code would occur, but apparently it does. */ - break; + if (trace_files) + prline_file_name (entry, stderr); - default: - fatal_with_file ("nonexternal relocation code invalid in ", entry); - } + desc = file_open (entry); -#ifdef RELOC_ADD_EXTRA - relocation += RELOC_ADD_EXTRA(p); - if (relocatable_output) - { - /* Non-PC relative relocations which are absolute - or which have become non-external now have fixed - relocations. Set the ADD_EXTRA of this relocation - to be the relocation we have now determined. */ - if (! RELOC_PCREL_P (p)) - { - if ((int)p->r_type <= RELOC_32 - || RELOC_EXTERN_P (p) == 0) - RELOC_ADD_EXTRA (p) = relocation; - } - /* External PC-relative relocations continue to move around; - update their relocations by the amount they have moved - so far. */ - else if (RELOC_EXTERN_P (p)) - RELOC_ADD_EXTRA (p) -= pc_relocation; - continue; - } -#endif + bytes = (char *)alloca(entry->header.a_data); - if (RELOC_PCREL_P(p)) - relocation -= pc_relocation; + if (entry->datarel == NULL) + fatal_with_file("no data relocation of ", entry); - relocation >>= RELOC_VALUE_RIGHTSHIFT(p); + lseek (desc, text_offset (entry) + entry->header.a_text, 0); + if (entry->header.a_data != read(desc, bytes, entry->header.a_data)) + fatal_with_file ("premature eof in data section of ", entry); - /* Unshifted mask for relocation */ - mask = 1 << RELOC_TARGET_BITSIZE(p) - 1; - mask |= mask - 1; - relocation &= mask; + perform_relocation (bytes, entry->header.a_data, + entry->datarel, entry->ndatarel, entry, 1); - /* Shift everything up to where it's going to be used */ - relocation <<= RELOC_TARGET_BITPOS(p); - mask <<= RELOC_TARGET_BITPOS(p); + mywrite (bytes, 1, entry->header.a_data, outdesc); +} + +/* + * Relocate ENTRY's text or data section contents. DATA is the address of the + * contents, in core. DATA_SIZE is the length of the contents. PC_RELOCATION + * is the difference between the address of the contents in the output file + * and its address in the input file. RELOC is the address of the + * relocation info, in core. NRELOC says how many there are. + */ +void +perform_relocation(data, data_size, reloc, nreloc, entry, dataseg) + char *data; + int data_size; + struct relocation_info *reloc; + int nreloc; + struct file_entry *entry; + int dataseg; +{ + register struct relocation_info *r = reloc; + struct relocation_info *end = reloc + nreloc; + + text_relocation = entry->text_start_address; + data_relocation = entry->data_start_address - entry->header.a_text; + bss_relocation = entry->bss_start_address - + entry->header.a_text - entry->header.a_data; + pc_relocation = dataseg? + entry->data_start_address - entry->header.a_text: + entry->text_start_address; + + for (; r < end; r++) { + int addr = RELOC_ADDRESS(r); + long addend = md_get_addend(r, data+addr); + long relocation; + + /* + * Loop over the relocations again as we did in + * consider_relocation(), claiming the reserved RRS + * relocations. + */ + + if (addr >= data_size) + fatal_with_file( + "relocation address out of range in ", entry); + + if (RELOC_JMPTAB_P(r)) { + + int symindex = RELOC_SYMBOL(r); + struct localsymbol *lsp = &entry->symbols[symindex]; + symbol *sp; + + if (symindex >= entry->nsymbols) + fatal_with_file( + "relocation symbolnum out of range in ", entry); + + sp = lsp->symbol; + if (sp->alias) + sp = sp->alias; + + if (relocatable_output) + relocation = addend; + else if (!RELOC_EXTERN_P(r)) { + relocation = addend + + data_relocation - text_relocation; + } else + relocation = addend + + claim_rrs_jmpslot(r, sp, addend); + + } else if (RELOC_BASEREL_P(r)) { + + int symindex = RELOC_SYMBOL(r); + struct localsymbol *lsp = &entry->symbols[symindex]; + + if (symindex >= entry->nsymbols) + fatal_with_file( + "relocation symbolnum out of range in ", entry); + + if (relocatable_output) + relocation = addend; + else if (!RELOC_EXTERN_P(r)) + relocation = claim_rrs_internal_gotslot(entry, + r, lsp, addend); + else + relocation = claim_rrs_gotslot(r, lsp, addend); + + } else if (RELOC_EXTERN_P(r)) { + + int symindex = RELOC_SYMBOL(r); + symbol *sp; + + if (symindex >= entry->nsymbols) + fatal_with_file( + "relocation symbolnum out of range in ", entry); + + sp = entry->symbols[symindex].symbol; + if (sp->alias) + sp = sp->alias; + + if (relocatable_output) { + relocation = addend + sp->value; + } else if (sp->defined) { + if (sp == got_symbol) { + /* Handle _GOT_ refs */ + relocation = addend + sp->value + + md_got_reloc(r); + } else if (building_shared_object) { + /* + * Normal (non-PIC) relocation needs + * to be converted into an RRS reloc + * when building a shared object. + */ + r->r_address += dataseg? + entry->data_start_address: + entry->text_start_address; + relocation = addend; + if (claim_rrs_reloc(r, sp, &relocation)) + continue; + } else if (sp->defined == N_SIZE) { + /* + * If size is known, arrange a + * run-time copy. + */ + if (!sp->size) + fatal("Copy item isn't: %s", + sp->name); + + relocation = addend + sp->value; + r->r_address = sp->value; + claim_rrs_cpy_reloc(r, sp); + } else + /* Plain old relocation */ + relocation = addend + sp->value; + } else { + /* + * If the symbol is undefined, we relocate it + * in a way similar to -r case. We use an + * RRS relocation to resolve the symbol at + * run-time. The r_address field is updated + * to reflect the changed position in the + * output file. + * + * In case the symbol is defined in a shared + * object as N_TEXT or N_DATA, an appropriate + * jmpslot or copy relocation is generated. + */ + switch (sp->so_defined) { + + case N_TEXT+N_EXT: + /* + * Claim a jmpslot if one was + * allocated (dependent on + * `force_alias_flag'). + */ + + if (sp->jmpslot_offset == -1) + goto undefined; + + relocation = addend + + claim_rrs_jmpslot(r, sp, addend); + break; + + case N_DATA+N_EXT: + /*FALLTHROUGH*/ + case 0: + undefined: + r->r_address += dataseg? + entry->data_start_address: + entry->text_start_address; + relocation = addend; + if (claim_rrs_reloc(r, sp, &relocation)) + continue; + break; + + case N_BSS+N_EXT: +printf("%s: BSS found in so_defined\n", sp->name); + /*break;*/ + + default: + fatal("%s: shobj symbol with unknown type %#x", sp->name, sp->so_defined); + break; + } + } + + } else { + + switch (RELOC_TYPE(r)) { + case N_TEXT: + case N_TEXT | N_EXT: + relocation = addend + text_relocation; + break; + + case N_DATA: + case N_DATA | N_EXT: + /* + * A word that points to beginning of the the + * data section initially contains not 0 but + * rather the "address" of that section in + * the input file, which is the length of the + * file's text. + */ + relocation = addend + data_relocation; + break; + + case N_BSS: + case N_BSS | N_EXT: + /* + * Similarly, an input word pointing to the + * beginning of the bss initially contains + * the length of text plus data of the file. + */ + relocation = addend + bss_relocation; + break; + + case N_ABS: + case N_ABS | N_EXT: + /* + * Don't know why this code would occur, but + * apparently it does. + */ + break; + + default: + fatal_with_file( + "nonexternal relocation code invalid in ", entry); + } + + /* + * When building a shared object, these segment + * relocations need a "load address relative" + * RRS fixup. + */ + if (building_shared_object) { + r->r_address += dataseg? + entry->data_start_address: + entry->text_start_address; + claim_rrs_segment_reloc(r); + } + } - switch (RELOC_TARGET_SIZE(p)) - { - case 0: - if (RELOC_MEMORY_SUB_P(p)) - relocation -= mask & *(char *) (data + addr); - else if (RELOC_MEMORY_ADD_P(p)) - relocation += mask & *(char *) (data + addr); - *(char *) (data + addr) &= ~mask; - *(char *) (data + addr) |= relocation; - break; - - case 1: -#ifdef tahoe - if (((int) data + addr & 1) == 0) - { -#endif - if (RELOC_MEMORY_SUB_P(p)) - relocation -= mask & *(short *) (data + addr); - else if (RELOC_MEMORY_ADD_P(p)) - relocation += mask & *(short *) (data + addr); - *(short *) (data + addr) &= ~mask; - *(short *) (data + addr) |= relocation; -#ifdef tahoe - } - /* - * The CCI Power 6 (aka Tahoe) architecture has byte-aligned - * instruction operands but requires data accesses to be aligned. - * Brain-damage... - */ - else - { - unsigned char *da = (unsigned char *) (data + addr); - unsigned short s = da[0] << 8 | da[1]; - - if (RELOC_MEMORY_SUB_P(p)) - relocation -= mask & s; - else if (RELOC_MEMORY_ADD_P(p)) - relocation += mask & s; - s &= ~mask; - s |= relocation; - da[0] = s >> 8; - da[1] = s; - } -#endif - break; + if (RELOC_PCREL_P(r)) + relocation -= pc_relocation; - case 2: -#ifndef _CROSS_TARGET_ARCH -#ifdef tahoe - if (((int) data + addr & 3) == 0) - { -#endif - if (RELOC_MEMORY_SUB_P(p)) - relocation -= mask & *(long *) (data + addr); - else if (RELOC_MEMORY_ADD_P(p)) - relocation += mask & *(long *) (data + addr); - *(long *) (data + addr) &= ~mask; - *(long *) (data + addr) |= relocation; -#ifdef tahoe - } - else - { - unsigned char *da = (unsigned char *) (data + addr); - unsigned long l = da[0] << 24 | da[1] << 16 | da[2] << 8 | da[3]; - - if (RELOC_MEMORY_SUB_P(p)) - relocation -= mask & l; - else if (RELOC_MEMORY_ADD_P(p)) - relocation += mask & l; - l &= ~mask; - l |= relocation; - da[0] = l >> 24; - da[1] = l >> 16; - da[2] = l >> 8; - da[3] = l; - } -#endif -#else - /* Handle long word alignment requirements of SPARC architecture */ - /* WARNING: This fix makes an assumption on byte ordering */ - /* Marc Ullman, Stanford University Nov. 1 1989 */ - if (RELOC_MEMORY_SUB_P(p)) { - relocation -= mask & - ((*(unsigned short *) (data + addr) << 16) | - *(unsigned short *) (data + addr + 2)); - } else if (RELOC_MEMORY_ADD_P(p)) { - relocation += mask & - ((*(unsigned short *) (data + addr) << 16) | - *(unsigned short *) (data + addr + 2)); - } - *(unsigned short *) (data + addr) &= (~mask >> 16); - *(unsigned short *) (data + addr + 2) &= (~mask & 0xffff); - *(unsigned short *) (data + addr) |= (relocation >> 16); - *(unsigned short *) (data + addr + 2) |= (relocation & 0xffff); -#endif - break; + md_relocate(r, relocation, data+addr, relocatable_output); - default: - fatal_with_file ("Unimplemented relocation field length in ", entry); } - } } /* For relocatable_output only: write out the relocation, @@ -3800,164 +2369,170 @@ void coptxtrel (), copdatrel (); void write_rel () { - register int i; - register int count = 0; - - if (trace_files) - fprintf (stderr, "Writing text relocation:\n\n"); - - /* Assign each global symbol a sequence number, giving the order - in which `write_syms' will write it. - This is so we can store the proper symbolnum fields - in relocation entries we write. */ - - for (i = 0; i < TABSIZE; i++) - { - symbol *sp; - for (sp = symtab[i]; sp; sp = sp->link) - if (sp->referenced || sp->defined) - { - sp->def_count = count++; - /* Leave room for the reference required by N_INDR, if - necessary. */ - if ((sp->defined & ~N_EXT) == N_INDR) - count++; - } - } - /* Correct, because if (relocatable_output), we will also be writing - whatever indirect blocks we have. */ - if (count != defined_global_sym_count - + undefined_global_sym_count + global_indirect_count) - fatal ("internal error"); - - /* Write out the relocations of all files, remembered from copy_text. */ - - each_full_file (coptxtrel, 0); - - if (trace_files) - fprintf (stderr, "\nWriting data relocation:\n\n"); - - each_full_file (copdatrel, 0); - - if (trace_files) - fprintf (stderr, "\n"); + register int count = 0; + + if (trace_files) + fprintf (stderr, "Writing text relocation:\n\n"); + + /* + * Assign each global symbol a sequence number, giving the order + * in which `write_syms' will write it. + * This is so we can store the proper symbolnum fields + * in relocation entries we write. + * + + /* BLECH - Assign number 0 to __DYNAMIC (!! Sun compatibility) */ + + if (dynamic_symbol->referenced) + dynamic_symbol->symbolnum = count++; + FOR_EACH_SYMBOL(i, sp) { + if (sp != dynamic_symbol && sp->referenced) { + sp->symbolnum = count++; + } + } END_EACH_SYMBOL; + + /* Correct, because if (relocatable_output), we will also be writing + whatever indirect blocks we have. */ + if (count != defined_global_sym_count + undefined_global_sym_count + + special_sym_count) + fatal ("internal error: write_rel: count = %d", count); + + /* Write out the relocations of all files, remembered from copy_text. */ + each_full_file (coptxtrel, 0); + + if (trace_files) + fprintf (stderr, "\nWriting data relocation:\n\n"); + + each_full_file (copdatrel, 0); + + if (trace_files) + fprintf (stderr, "\n"); } void -coptxtrel (entry) - struct file_entry *entry; +coptxtrel(entry) + struct file_entry *entry; { - register struct relocation_info *p, *end; - register int reloc = entry->text_start_address; - - p = entry->textrel; - end = (struct relocation_info *) (entry->header.a_trsize + (char *) p); - while (p < end) - { - RELOC_ADDRESS(p) += reloc; - if (RELOC_EXTERN_P(p)) - { - register int symindex = RELOC_SYMBOL(p) * sizeof (struct nlist); - symbol *symptr = ((symbol *) - (((struct nlist *) - (((char *)entry->symbols) + symindex)) - ->n_un.n_name)); + register struct relocation_info *r, *end; + register int reloc = entry->text_start_address; - if (symindex >= entry->header.a_syms) - fatal_with_file ("relocation symbolnum out of range in ", entry); + r = entry->textrel; + end = r + entry->ntextrel; + + for (; r < end; r++) { + register int symindex; + symbol *sp; + + RELOC_ADDRESS(r) += reloc; + + if (!RELOC_EXTERN_P(r)) + continue; + + symindex = RELOC_SYMBOL(r); + sp = entry->symbols[symindex].symbol; + + if (symindex >= entry->nsymbols) + fatal_with_file( + "relocation symbolnum out of range in ", entry); #ifdef N_INDR - /* Resolve indirection. */ - if ((symptr->defined & ~N_EXT) == N_INDR) - symptr = (symbol *) symptr->value; + /* Resolve indirection. */ + if ((sp->defined & ~N_EXT) == N_INDR) { + if (sp->alias == NULL) + fatal("internal error: alias in hyperspace"); + sp = sp->alias; + } #endif - /* If the symbol is now defined, change the external relocation - to an internal one. */ + /* + * If the symbol is now defined, change the external + * relocation to an internal one. + */ - if (symptr->defined) - { - RELOC_EXTERN_P(p) = 0; - RELOC_SYMBOL(p) = (symptr->defined & N_TYPE); + if (sp->defined) { + RELOC_EXTERN_P(r) = 0; + RELOC_SYMBOL(r) = (sp->defined & N_TYPE); #ifdef RELOC_ADD_EXTRA - /* If we aren't going to be adding in the value in - memory on the next pass of the loader, then we need - to add it in from the relocation entry. Otherwise - the work we did in this pass is lost. */ - if (!RELOC_MEMORY_ADD_P(p)) - RELOC_ADD_EXTRA (p) += symptr->value; + /* + * If we aren't going to be adding in the + * value in memory on the next pass of the + * loader, then we need to add it in from the + * relocation entry. Otherwise the work we + * did in this pass is lost. + */ + if (!RELOC_MEMORY_ADD_P(r)) + RELOC_ADD_EXTRA(r) += sp->value; #endif - } - else - /* Debugger symbols come first, so have to start this - after them. */ - RELOC_SYMBOL(p) = (symptr->def_count + nsyms - - defined_global_sym_count - - undefined_global_sym_count - - global_indirect_count); + } else + /* + * Global symbols come first. + */ + RELOC_SYMBOL(r) = sp->symbolnum; } - p++; - } - mywrite (entry->textrel, 1, entry->header.a_trsize, outdesc); + md_swapout_reloc(entry->textrel, entry->ntextrel); + mywrite(entry->textrel, entry->ntextrel, + sizeof(struct relocation_info), outdesc); } void -copdatrel (entry) - struct file_entry *entry; +copdatrel(entry) + struct file_entry *entry; { - register struct relocation_info *p, *end; - /* Relocate the address of the relocation. - Old address is relative to start of the input file's data section. - New address is relative to start of the output file's data section. */ - register int reloc = entry->data_start_address - text_size; - - p = entry->datarel; - end = (struct relocation_info *) (entry->header.a_drsize + (char *) p); - while (p < end) - { - RELOC_ADDRESS(p) += reloc; - if (RELOC_EXTERN_P(p)) - { - register int symindex = RELOC_SYMBOL(p) * sizeof (struct nlist); - symbol *symptr = ((symbol *) - (((struct nlist *) - (((char *)entry->symbols) + symindex)) - ->n_un.n_name)); - int symtype; + register struct relocation_info *r, *end; + /* + * Relocate the address of the relocation. Old address is relative to + * start of the input file's data section. New address is relative to + * start of the output file's data section. + */ + register int reloc = entry->data_start_address - text_size; - if (symindex >= entry->header.a_syms) - fatal_with_file ("relocation symbolnum out of range in ", entry); + r = entry->datarel; + end = r + entry->ndatarel; + + for (; r < end; r++) { + register int symindex; + symbol *sp; + int symtype; + + RELOC_ADDRESS(r) += reloc; + + if (!RELOC_EXTERN_P(r)) + continue; + + symindex = RELOC_SYMBOL(r); + sp = entry->symbols[symindex].symbol; + + if (symindex >= entry->header.a_syms) + fatal_with_file( + "relocation symbolnum out of range in ", entry); #ifdef N_INDR - /* Resolve indirection. */ - if ((symptr->defined & ~N_EXT) == N_INDR) - symptr = (symbol *) symptr->value; + /* Resolve indirection. */ + if ((sp->defined & ~N_EXT) == N_INDR) { + if (sp->alias == NULL) + fatal("internal error: alias in hyperspace"); + sp = sp->alias; + } #endif - symtype = symptr->defined & N_TYPE; - - if (force_common_definition - || symtype == N_DATA || symtype == N_TEXT || symtype == N_ABS) - { - RELOC_EXTERN_P(p) = 0; - RELOC_SYMBOL(p) = symtype; - } - else - /* Debugger symbols come first, so have to start this - after them. */ - RELOC_SYMBOL(p) - = (((symbol *) - (((struct nlist *) - (((char *)entry->symbols) + symindex)) - ->n_un.n_name)) - ->def_count - + nsyms - defined_global_sym_count - - undefined_global_sym_count - - global_indirect_count); + symtype = sp->defined & N_TYPE; + + if (force_common_definition || + symtype == N_DATA || + symtype == N_TEXT || + symtype == N_ABS) { + RELOC_EXTERN_P(r) = 0; + RELOC_SYMBOL(r) = symtype; + } else + /* + * Global symbols come first. + */ + RELOC_SYMBOL(r) = + entry->symbols[symindex].symbol->symbolnum; } - p++; - } - mywrite (entry->datarel, 1, entry->header.a_drsize, outdesc); + md_swapout_reloc(entry->datarel, entry->ndatarel); + mywrite(entry->datarel, entry->ndatarel, + sizeof(struct relocation_info), outdesc); } void write_file_syms (); @@ -3988,712 +2563,383 @@ int *strtab_lens; /* Index in `strtab_vector' at which the next string will be stored. */ int strtab_index; -/* Add the string NAME to the output file string table. - Record it in `strtab_vector' to be output later. - Return the index within the string table that this string will have. */ +/* + * Add the string NAME to the output file string table. Record it in + * `strtab_vector' to be output later. Return the index within the string + * table that this string will have. + */ int -assign_string_table_index (name) - char *name; +assign_string_table_index(name) + char *name; { - register int index = strtab_size; - register int len = strlen (name) + 1; + register int index = strtab_size; + register int len = strlen(name) + 1; - strtab_size += len; - strtab_vector[strtab_index] = name; - strtab_lens[strtab_index++] = len; + strtab_size += len; + strtab_vector[strtab_index] = name; + strtab_lens[strtab_index++] = len; - return index; + return index; } -FILE *outstream = (FILE *) 0; - -/* Write the contents of `strtab_vector' into the string table. - This is done once for each file's local&debugger symbols - and once for the global symbols. */ +FILE *outstream = (FILE *) 0; +/* + * Write the contents of `strtab_vector' into the string table. This is done + * once for each file's local&debugger symbols and once for the global + * symbols. + */ void write_string_table () { - register int i; + register int i; - lseek (outdesc, string_table_offset + string_table_len, 0); + lseek (outdesc, string_table_offset + string_table_len, 0); - if (!outstream) - outstream = fdopen (outdesc, "w"); + if (!outstream) + outstream = fdopen (outdesc, "w"); - for (i = 0; i < strtab_index; i++) - { - fwrite (strtab_vector[i], 1, strtab_lens[i], outstream); - string_table_len += strtab_lens[i]; - } + for (i = 0; i < strtab_index; i++) { + fwrite (strtab_vector[i], 1, strtab_lens[i], outstream); + string_table_len += strtab_lens[i]; + } - fflush (outstream); + fflush (outstream); - /* Report I/O error such as disk full. */ - if (ferror (outstream)) - perror_name (output_filename); + /* Report I/O error such as disk full. */ + if (ferror (outstream)) + perror_name (output_filename); } /* Write the symbol table and string table of the output file. */ void -write_syms () -{ - /* Number of symbols written so far. */ - int syms_written = 0; - register int i; - register symbol *sp; - - /* Buffer big enough for all the global symbols. One - extra struct for each indirect symbol to hold the extra reference - following. */ - struct nlist *buf - = (struct nlist *) alloca ((defined_global_sym_count - + undefined_global_sym_count - + global_indirect_count) - * sizeof (struct nlist)); - /* Pointer for storing into BUF. */ - register struct nlist *bufp = buf; - - /* Size of string table includes the bytes that store the size. */ - strtab_size = sizeof strtab_size; - - symbol_table_offset = N_SYMOFF (outheader); - symbol_table_len = 0; - string_table_offset = N_STROFF (outheader); - string_table_len = strtab_size; - - if (strip_symbols == STRIP_ALL) - return; - - /* Write the local symbols defined by the various files. */ - - each_file (write_file_syms, &syms_written); - file_close (); - - /* Now write out the global symbols. */ - - /* Allocate two vectors that record the data to generate the string - table from the global symbols written so far. This must include - extra space for the references following indirect outputs. */ - - strtab_vector = (char **) alloca ((num_hash_tab_syms - + global_indirect_count) * sizeof (char *)); - strtab_lens = (int *) alloca ((num_hash_tab_syms - + global_indirect_count) * sizeof (int)); - strtab_index = 0; - - /* Scan the symbol hash table, bucket by bucket. */ - - for (i = 0; i < TABSIZE; i++) - for (sp = symtab[i]; sp; sp = sp->link) - { - struct nlist nl; - - nl.n_other = 0; - nl.n_desc = 0; - - /* Compute a `struct nlist' for the symbol. */ - - if (sp->defined || sp->referenced) - { - /* common condition needs to be before undefined condition */ - /* because unallocated commons are set undefined in */ - /* digest_symbols */ - if (sp->defined > 1) /* defined with known type */ - { - /* If the target of an indirect symbol has been - defined and we are outputting an executable, - resolve the indirection; it's no longer needed */ - if (!relocatable_output - && ((sp->defined & N_TYPE) == N_INDR) - && (((symbol *) sp->value)->defined > 1)) - { - symbol *newsp = (symbol *) sp->value; - nl.n_type = newsp->defined; - nl.n_value = newsp->value; - } +write_syms() +{ + /* Number of symbols written so far. */ + int non_local_syms = defined_global_sym_count + + undefined_global_sym_count + + global_alias_count + + special_sym_count; + int syms_written = 0; + struct nlist nl; + + /* + * Buffer big enough for all the global symbols. One extra struct + * for each indirect symbol to hold the extra reference following. + */ + struct nlist *buf + = (struct nlist *)alloca(non_local_syms * sizeof(struct nlist)); + /* Pointer for storing into BUF. */ + register struct nlist *bufp = buf; + + /* Size of string table includes the bytes that store the size. */ + strtab_size = sizeof strtab_size; + + symbol_table_offset = N_SYMOFF(outheader); + symbol_table_len = 0; + string_table_offset = N_STROFF(outheader); + string_table_len = strtab_size; + + if (strip_symbols == STRIP_ALL) + return; + + /* First, write out the global symbols. */ + + /* + * Allocate two vectors that record the data to generate the string + * table from the global symbols written so far. This must include + * extra space for the references following indirect outputs. + */ + + strtab_vector = (char **) alloca((non_local_syms) * sizeof(char *)); + strtab_lens = (int *) alloca((non_local_syms) * sizeof(int)); + strtab_index = 0; + + /* + * __DYNAMIC symbol *must* be first for Sun compatibility, as Sun's + * ld.so reads the shared object's first symbol. This means that + * (Sun's) shared libraries cannot be stripped! (We only assume + * that __DYNAMIC is the first item in the data segment) + * + * If defined (ie. not relocatable_output), make it look + * like an internal symbol. + */ + if (dynamic_symbol->referenced) { + nl.n_other = 0; + nl.n_desc = 0; + nl.n_type = dynamic_symbol->defined; + if (nl.n_type == N_UNDF) + nl.n_type |= N_EXT; else - { - nl.n_type = sp->defined; - if (sp->defined != (N_INDR | N_EXT)) - nl.n_value = sp->value; - else - nl.n_value = 0; - } - } - else if (sp->max_common_size) /* defined as common but not allocated. */ - { - /* happens only with -r and not -d */ - /* write out a common definition */ - nl.n_type = N_UNDF | N_EXT; - nl.n_value = sp->max_common_size; - } - else if (!sp->defined) /* undefined -- legit only if -r */ - { - nl.n_type = N_UNDF | N_EXT; - nl.n_value = 0; - } - else - fatal ("internal error: %s defined in mysterious way", sp->name); - - /* Allocate string table space for the symbol name. */ - - nl.n_un.n_strx = assign_string_table_index (sp->name); - - /* Output to the buffer and count it. */ - - *bufp++ = nl; - syms_written++; - if (nl.n_type == (N_INDR | N_EXT)) - { - struct nlist xtra_ref; - xtra_ref.n_type = N_EXT | N_UNDF; - xtra_ref.n_un.n_strx - = assign_string_table_index (((symbol *) sp->value)->name); - xtra_ref.n_other = 0; - xtra_ref.n_desc = 0; - xtra_ref.n_value = 0; - *bufp++ = xtra_ref; + nl.n_type &= ~N_EXT; + nl.n_value = dynamic_symbol->value; + nl.n_un.n_strx = assign_string_table_index(dynamic_symbol->name); + *bufp++ = nl; syms_written++; - } - } - } - - /* Output the buffer full of `struct nlist's. */ - - lseek (outdesc, symbol_table_offset + symbol_table_len, 0); - mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc); - symbol_table_len += sizeof (struct nlist) * (bufp - buf); - - if (syms_written != nsyms) - fatal ("internal error: wrong number of symbols written into output file", 0); - - if (symbol_table_offset + symbol_table_len != string_table_offset) - fatal ("internal error: inconsistent symbol table length", 0); - - /* Now the total string table size is known, so write it. - We are already positioned at the right place in the file. */ - - mywrite (&strtab_size, sizeof (int), 1, outdesc); /* we're at right place */ - - /* Write the strings for the global symbols. */ - - write_string_table (); -} - -/* Write the local and debugger symbols of file ENTRY. - Increment *SYMS_WRITTEN_ADDR for each symbol that is written. */ - -/* Note that we do not combine identical names of local symbols. - dbx or gdb would be confused if we did that. */ - -void -write_file_syms (entry, syms_written_addr) - struct file_entry *entry; - int *syms_written_addr; -{ - register struct nlist *p = entry->symbols; - register struct nlist *end = p + entry->header.a_syms / sizeof (struct nlist); - - /* Buffer to accumulate all the syms before writing them. - It has one extra slot for the local symbol we generate here. */ - struct nlist *buf - = (struct nlist *) alloca (entry->header.a_syms + sizeof (struct nlist)); - register struct nlist *bufp = buf; - - /* Upper bound on number of syms to be written here. */ - int max_syms = (entry->header.a_syms / sizeof (struct nlist)) + 1; - - /* Make tables that record, for each symbol, its name and its name's length. - The elements are filled in by `assign_string_table_index'. */ - - strtab_vector = (char **) alloca (max_syms * sizeof (char *)); - strtab_lens = (int *) alloca (max_syms * sizeof (int)); - strtab_index = 0; - - /* Generate a local symbol for the start of this file's text. */ - - if (discard_locals != DISCARD_ALL) - { - struct nlist nl; - - nl.n_type = N_FN | N_EXT; - nl.n_un.n_strx = assign_string_table_index (entry->local_sym_name); - nl.n_value = entry->text_start_address; - nl.n_desc = 0; - nl.n_other = 0; - *bufp++ = nl; - (*syms_written_addr)++; - entry->local_syms_offset = *syms_written_addr * sizeof (struct nlist); - } - - /* Read the file's string table. */ - - entry->strings = (char *) alloca (entry->string_size); - read_entry_strings (file_open (entry), entry); - - for (; p < end; p++) - { - register int type = p->n_type; - register int write = 0; - - /* WRITE gets 1 for a non-global symbol that should be written. */ - - - if (SET_ELEMENT_P (type)) /* This occurs even if global. These */ - /* types of symbols are never written */ - /* globally, though they are stored */ - /* globally. */ - write = relocatable_output; - else if (!(type & (N_STAB | N_EXT))) - /* ordinary local symbol */ - write = ((discard_locals != DISCARD_ALL) - && !(discard_locals == DISCARD_L && - (p->n_un.n_strx + entry->strings)[0] == LPREFIX) - && type != N_WARNING); - else if (!(type & N_EXT)) - /* debugger symbol */ - write = (strip_symbols == STRIP_NONE); - - if (write) - { - /* If this symbol has a name, - allocate space for it in the output string table. */ - - if (p->n_un.n_strx) - p->n_un.n_strx = assign_string_table_index (p->n_un.n_strx - + entry->strings); - - /* Output this symbol to the buffer and count it. */ - - *bufp++ = *p; - (*syms_written_addr)++; - } - } - - /* All the symbols are now in BUF; write them. */ - - lseek (outdesc, symbol_table_offset + symbol_table_len, 0); - mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc); - symbol_table_len += sizeof (struct nlist) * (bufp - buf); - - /* Write the string-table data for the symbols just written, - using the data in vectors `strtab_vector' and `strtab_lens'. */ - - write_string_table (); - entry->strings = 0; /* Since it will dissapear anyway. */ -} - -/* Copy any GDB symbol segments from the input files to the output file. - The contents of the symbol segment is copied without change - except that we store some information into the beginning of it. */ - -void write_file_symseg (); - -void -write_symsegs () -{ - each_file (write_file_symseg, 0); -} - -void -write_file_symseg (entry) - struct file_entry *entry; -{ - char buffer[4096]; - struct symbol_root root; - int indesc; - int len; - - if (entry->symseg_offset == 0) - return; - - /* This entry has a symbol segment. Read the root of the segment. */ - - indesc = file_open (entry); - lseek (indesc, entry->symseg_offset + entry->starting_offset, 0); - if (sizeof root != read (indesc, &root, sizeof root)) - fatal_with_file ("premature end of file in symbol segment of ", entry); - - /* Store some relocation info into the root. */ - - root.ldsymoff = entry->local_syms_offset; - root.textrel = entry->text_start_address; - root.datarel = entry->data_start_address - entry->header.a_text; - root.bssrel = entry->bss_start_address - - entry->header.a_text - entry->header.a_data; - root.databeg = entry->data_start_address - root.datarel; - root.bssbeg = entry->bss_start_address - root.bssrel; - - /* Write the modified root into the output file. */ - - mywrite (&root, sizeof root, 1, outdesc); - - /* Copy the rest of the symbol segment unchanged. */ - - if (entry->superfile) - { - /* Library member: number of bytes to copy is determined - from the member's total size. */ - - int total = entry->total_size - entry->symseg_offset - sizeof root; - - while (total > 0) - { - len = read (indesc, buffer, min (sizeof buffer, total)); - - if (len != min (sizeof buffer, total)) - fatal_with_file ("premature end of file in symbol segment of ", entry); - total -= len; - mywrite (buffer, len, 1, outdesc); - } - } - else - { - /* A separate file: copy until end of file. */ - - while (len = read (indesc, buffer, sizeof buffer)) - { - mywrite (buffer, len, 1, outdesc); - if (len < sizeof buffer) - break; } - } - file_close (); -} - -/* Create the symbol table entries for `etext', `edata' and `end'. */ + /* Scan the symbol hash table, bucket by bucket. */ + + FOR_EACH_SYMBOL(i, sp) { + if (sp == dynamic_symbol) + /* Already dealt with above */ + continue; + + if (!sp->referenced) + /* Came from shared object but was not used */ + continue; + + if (sp->so_defined) + /* + * Definition came from shared object, + * don't mention it here + */ + continue; + + if (!sp->defined && !relocatable_output) { + /* + * We're building a shared object and there + * are still undefined symbols. Don't output + * these, symbol was discounted in digest_pass1() + * (they are in the RRS symbol table). + */ + if (!building_shared_object) + error("symbol %s remains undefined", sp->name); + continue; + } -void -symtab_init () -{ -#ifndef nounderscore - edata_symbol = getsym ("_edata"); - etext_symbol = getsym ("_etext"); - end_symbol = getsym ("_end"); -#else - edata_symbol = getsym ("edata"); - etext_symbol = getsym ("etext"); - end_symbol = getsym ("end"); -#endif + /* Construct a `struct nlist' for the symbol. */ + + nl.n_other = 0; + nl.n_desc = 0; + + /* + * common condition needs to be before undefined + * condition because unallocated commons are set + * undefined in digest_symbols + */ + if (sp->defined > 1) { + /* defined with known type */ + + if (!relocatable_output && sp->alias && + sp->alias->defined > 1) { + /* + * If the target of an indirect symbol has + * been defined and we are outputting an + * executable, resolve the indirection; it's + * no longer needed + */ + nl.n_type = sp->alias->defined; + nl.n_type = sp->alias->value; + } else if (sp->defined == N_SIZE) + nl.n_type = N_DATA | N_EXT; + else + nl.n_type = sp->defined; + nl.n_value = sp->value; + } else if (sp->max_common_size) { + /* + * defined as common but not allocated, + * happens only with -r and not -d, write out + * a common definition + */ + nl.n_type = N_UNDF | N_EXT; + nl.n_value = sp->max_common_size; + } else if (!sp->defined) { + /* undefined -- legit only if -r */ + nl.n_type = N_UNDF | N_EXT; + nl.n_value = 0; + } else + fatal( + "internal error: %s defined in mysterious way", + sp->name); + + /* + * Allocate string table space for the symbol name. + */ + + nl.n_un.n_strx = assign_string_table_index(sp->name); + + /* Output to the buffer and count it. */ + + if (syms_written >= non_local_syms) + fatal( + "internal error: number of symbols exceeds allocated %d", + non_local_syms); + *bufp++ = nl; + syms_written++; -#ifdef sun - { - symbol *dynamic_symbol = getsym ("__DYNAMIC"); - dynamic_symbol->defined = N_ABS | N_EXT; - dynamic_symbol->referenced = 1; - dynamic_symbol->value = 0; - } -#endif + if (nl.n_type == N_INDR + N_EXT) { + if (sp->alias == NULL) + fatal("internal error: alias in hyperspace"); + nl.n_type = N_UNDF + N_EXT; + nl.n_un.n_strx = + assign_string_table_index(sp->alias->name); + nl.n_value = 0; + *bufp++ = nl; + syms_written++; + } -#ifdef sequent - { - symbol *_387_flt_symbol = getsym ("_387_flt"); - _387_flt_symbol->defined = N_ABS | N_EXT; - _387_flt_symbol->referenced = 1; - _387_flt_symbol->value = 0; - } +#ifdef DEBUG +printf("writesym(#%d): %s, type %x\n", syms_written, sp->name, sp->defined); #endif + } END_EACH_SYMBOL; - edata_symbol->defined = N_DATA | N_EXT; - etext_symbol->defined = N_TEXT | N_EXT; - end_symbol->defined = N_BSS | N_EXT; - - edata_symbol->referenced = 1; - etext_symbol->referenced = 1; - end_symbol->referenced = 1; -} - -/* Compute the hash code for symbol name KEY. */ - -int -hash_string (key) - char *key; -{ - register char *cp; - register int k; - - cp = key; - k = 0; - while (*cp) - k = (((k << 1) + (k >> 14)) ^ (*cp++)) & 0x3fff; - - return k; -} - -/* Get the symbol table entry for the global symbol named KEY. - Create one if there is none. */ - -symbol * -getsym (key) - char *key; -{ - register int hashval; - register symbol *bp; - - /* Determine the proper bucket. */ - - hashval = hash_string (key) % TABSIZE; - - /* Search the bucket. */ - - for (bp = symtab[hashval]; bp; bp = bp->link) - if (! strcmp (key, bp->name)) - return bp; - - /* Nothing was found; create a new symbol table entry. */ - - bp = (symbol *) xmalloc (sizeof (symbol)); - bp->refs = 0; - bp->name = (char *) xmalloc (strlen (key) + 1); - strcpy (bp->name, key); - bp->defined = 0; - bp->referenced = 0; - bp->trace = 0; - bp->value = 0; - bp->max_common_size = 0; - bp->warning = 0; - bp->undef_refs = 0; - bp->multiply_defined = 0; - - /* Add the entry to the bucket. */ - - bp->link = symtab[hashval]; - symtab[hashval] = bp; - - ++num_hash_tab_syms; - - return bp; -} - -/* Like `getsym' but return 0 if the symbol is not already known. */ - -symbol * -getsym_soft (key) - char *key; -{ - register int hashval; - register symbol *bp; - - /* Determine which bucket. */ - - hashval = hash_string (key) % TABSIZE; - - /* Search the bucket. */ - - for (bp = symtab[hashval]; bp; bp = bp->link) - if (! strcmp (key, bp->name)) - return bp; + if (syms_written != strtab_index || strtab_index != non_local_syms) + fatal("internal error:\ +wrong number (%d) of global symbols written into output file, should be %d", + syms_written, non_local_syms); - return 0; -} - -/* Report a fatal error. - STRING is a printf format string and ARG is one arg for it. */ - -void -fatal (string, arg) - char *string, *arg; -{ - fprintf (stderr, "ld: "); - fprintf (stderr, string, arg); - fprintf (stderr, "\n"); - exit (1); -} - -/* Report a fatal error. The error message is STRING - followed by the filename of ENTRY. */ - -void -fatal_with_file (string, entry) - char *string; - struct file_entry *entry; -{ - fprintf (stderr, "ld: "); - fprintf (stderr, string); - print_file_name (entry, stderr); - fprintf (stderr, "\n"); - exit (1); -} + /* Output the buffer full of `struct nlist's. */ -/* Report a fatal error using the message for the last failed system call, - followed by the string NAME. */ + lseek(outdesc, symbol_table_offset + symbol_table_len, 0); + md_swapout_symbols(buf, bufp - buf); + mywrite(buf, bufp - buf, sizeof(struct nlist), outdesc); + symbol_table_len += sizeof(struct nlist) * (bufp - buf); -void -perror_name (name) - char *name; -{ - extern int errno, sys_nerr; - extern char *sys_errlist[]; - char *s; - - if (errno < sys_nerr) - s = concat ("", sys_errlist[errno], " for %s"); - else - s = "cannot open %s"; - fatal (s, name); -} + /* Write the strings for the global symbols. */ + write_string_table(); -/* Report a fatal error using the message for the last failed system call, - followed by the name of file ENTRY. */ + /* Write the local symbols defined by the various files. */ + each_file(write_file_syms, &syms_written); + file_close(); -void -perror_file (entry) - struct file_entry *entry; -{ - extern int errno, sys_nerr; - extern char *sys_errlist[]; - char *s; - - if (errno < sys_nerr) - s = concat ("", sys_errlist[errno], " for "); - else - s = "cannot open "; - fatal_with_file (s, entry); -} + if (syms_written != nsyms) + fatal("internal error:\ +wrong number of symbols (%d) written into output file, should be %d", + syms_written, nsyms); -/* Report a nonfatal error. - STRING is a format for printf, and ARG1 ... ARG3 are args for it. */ + if (symbol_table_offset + symbol_table_len != string_table_offset) + fatal( + "internal error: inconsistent symbol table length: %d vs %s", + symbol_table_offset + symbol_table_len, string_table_offset); -void -error (string, arg1, arg2, arg3) - char *string, *arg1, *arg2, *arg3; -{ - fprintf (stderr, "%s: ", progname); - fprintf (stderr, string, arg1, arg2, arg3); - fprintf (stderr, "\n"); + lseek(outdesc, string_table_offset, 0); + strtab_size = md_swap_long(strtab_size); + mywrite(&strtab_size, sizeof(int), 1, outdesc); } - -/* Output COUNT*ELTSIZE bytes of data at BUF - to the descriptor DESC. */ - -void -mywrite (buf, count, eltsize, desc) - char *buf; - int count; - int eltsize; - int desc; -{ - register int val; - register int bytes = count * eltsize; - - while (bytes > 0) - { - val = write (desc, buf, bytes); - if (val <= 0) - perror_name (output_filename); - buf += val; - bytes -= val; - } -} -/* Output PADDING zero-bytes to descriptor OUTDESC. - PADDING may be negative; in that case, do nothing. */ +/* + * Write the local and debugger symbols of file ENTRY. Increment + * *SYMS_WRITTEN_ADDR for each symbol that is written. + */ +/* + * Note that we do not combine identical names of local symbols. dbx or gdb + * would be confused if we did that. + */ void -padfile (padding, outdesc) - int padding; - int outdesc; +write_file_syms(entry, syms_written_addr) + struct file_entry *entry; + int *syms_written_addr; { - register char *buf; - if (padding <= 0) - return; + struct localsymbol *lsp, *lspend; - buf = (char *) alloca (padding); - bzero (buf, padding); - mywrite (buf, padding, 1, outdesc); -} - -/* Return a newly-allocated string - whose contents concatenate the strings S1, S2, S3. */ - -char * -concat (s1, s2, s3) - char *s1, *s2, *s3; -{ - register int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3); - register char *result = (char *) xmalloc (len1 + len2 + len3 + 1); - - strcpy (result, s1); - strcpy (result + len1, s2); - strcpy (result + len1 + len2, s3); - result[len1 + len2 + len3] = 0; - - return result; -} - -/* Parse the string ARG using scanf format FORMAT, and return the result. - If it does not parse, report fatal error - generating the error message using format string ERROR and ARG as arg. */ + /* Upper bound on number of syms to be written here. */ + int max_syms = entry->nsymbols + 1; -int -parse (arg, format, error) - char *arg, *format; -{ - int x; - if (1 != sscanf (arg, format, &x)) - fatal (error, arg); - return x; -} + /* + * Buffer to accumulate all the syms before writing them. It has one + * extra slot for the local symbol we generate here. + */ + struct nlist *buf = (struct nlist *) + alloca(max_syms * sizeof(struct nlist)); -/* Like malloc but get fatal error if memory is exhausted. */ + register struct nlist *bufp = buf; -int -xmalloc (size) - int size; -{ - register int result = malloc (size); - if (!result) - fatal ("virtual memory exhausted", 0); - return result; -} + if (entry->is_dynamic) + return; -/* Like realloc but get fatal error if memory is exhausted. */ + /* + * Make tables that record, for each symbol, its name and its name's + * length. The elements are filled in by `assign_string_table_index'. + */ -int -xrealloc (ptr, size) - char *ptr; - int size; -{ - register int result = realloc (ptr, size); - if (!result) - fatal ("virtual memory exhausted", 0); - return result; -} - -#ifdef USG + strtab_vector = (char **) alloca(max_syms * sizeof(char *)); + strtab_lens = (int *) alloca(max_syms * sizeof(int)); + strtab_index = 0; -void -bzero (p, n) - char *p; -{ - memset (p, 0, n); -} + /* Generate a local symbol for the start of this file's text. */ -void -bcopy (from, to, n) - char *from, *to; -{ - memcpy (to, from, n); -} + if (discard_locals != DISCARD_ALL) { + struct nlist nl; -getpagesize () -{ - return (4096); -} + nl.n_type = N_FN | N_EXT; + nl.n_un.n_strx = assign_string_table_index(entry->local_sym_name); + nl.n_value = entry->text_start_address; + nl.n_desc = 0; + nl.n_other = 0; + *bufp++ = nl; + (*syms_written_addr)++; + entry->local_syms_offset = *syms_written_addr * sizeof(struct nlist); + } + /* Read the file's string table. */ + + entry->strings = (char *) alloca(entry->string_size); + read_entry_strings(file_open(entry), entry); + + lspend = entry->symbols + entry->nsymbols; + + for (lsp = entry->symbols; lsp < lspend; lsp++) { + register struct nlist *p = &lsp->nzlist.nlist; + register int type = p->n_type; + register int write = 0; + + /* + * WRITE gets 1 for a non-global symbol that should be + * written. + */ + + if (SET_ELEMENT_P (type)) + /* + * This occurs even if global. These types of + * symbols are never written globally, though + * they are stored globally. + */ + write = relocatable_output; + else if (!(type & (N_STAB | N_EXT))) + /* ordinary local symbol */ + write = ((discard_locals != DISCARD_ALL) + && !(discard_locals == DISCARD_L && + (p->n_un.n_strx + entry->strings)[0] == LPREFIX) + && type != N_WARNING); + else if (!(type & N_EXT)) + /* debugger symbol */ + write = (strip_symbols == STRIP_NONE) && + !(discard_locals == DISCARD_L && + (p->n_un.n_strx + entry->strings)[0] == LPREFIX); + + if (write) { + /* + * If this symbol has a name, allocate space for it + * in the output string table. + */ + + if (p->n_un.n_strx) + p->n_un.n_strx = assign_string_table_index( + p->n_un.n_strx + entry->strings); + + /* Output this symbol to the buffer and count it. */ + + *bufp++ = *p; + (*syms_written_addr)++; + } + } -#endif + /* All the symbols are now in BUF; write them. */ -#if defined(sun) && (TARGET == SUN4) + lseek(outdesc, symbol_table_offset + symbol_table_len, 0); + md_swapout_symbols(buf, bufp - buf); + mywrite(buf, bufp - buf, sizeof(struct nlist), outdesc); + symbol_table_len += sizeof(struct nlist) * (bufp - buf); -/* Don't use local pagesize to build for Sparc. */ + /* + * Write the string-table data for the symbols just written, using + * the data in vectors `strtab_vector' and `strtab_lens'. + */ -getpagesize () -{ - return (8192); + write_string_table(); + entry->strings = 0; /* Since it will disappear anyway. */ } -#endif -- cgit v1.1