3698 lines
91 KiB
C
3698 lines
91 KiB
C
/*-
|
|
* This code is derived from software copyrighted by the Free Software
|
|
* Foundation.
|
|
*
|
|
* Modified 1991 by Donn Seeley at UUNET Technologies, Inc.
|
|
*
|
|
* Modified 1993 by Paul Kranenburg, Erasmus University
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)ld.c 6.10 (Berkeley) 5/22/91";
|
|
#endif /* not lint */
|
|
|
|
/* Linker `ld' for GNU
|
|
Copyright (C) 1988 Free Software Foundation, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 1, or (at your option)
|
|
any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 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. */
|
|
|
|
/*
|
|
* $Id: ld.c,v 1.26 1995/03/10 19:41:50 davidg Exp $
|
|
*/
|
|
|
|
/* Define how to initialize system-dependent header fields. */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/file.h>
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <err.h>
|
|
#include <fcntl.h>
|
|
#include <ar.h>
|
|
#include <ranlib.h>
|
|
#include <a.out.h>
|
|
#include <stab.h>
|
|
#include <string.h>
|
|
|
|
#include "ld.h"
|
|
|
|
/* 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;
|
|
int number_of_files;
|
|
|
|
/* 1 => write relocation into output file so can re-input it later. */
|
|
int relocatable_output;
|
|
|
|
/* 1 => building a shared object, set by `-Bshareable'. */
|
|
int building_shared_object;
|
|
|
|
/* 1 => create the output executable. */
|
|
int make_executable;
|
|
|
|
/* Force the executable to be output, even if there are non-fatal errors */
|
|
int force_executable;
|
|
|
|
/* 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;
|
|
|
|
/* 1 => some files contain PIC code, affects relocation bits
|
|
if `relocatable_output'. */
|
|
int pic_code_seen;
|
|
|
|
/* 1 => segments must be page aligned (ZMAGIC, QMAGIC) */
|
|
int page_align_segments;
|
|
|
|
/* 1 => data segment must be page aligned, even if `-n' or `-N' */
|
|
int page_align_data;
|
|
|
|
/* 1 => do not use standard library search path */
|
|
int nostdlib;
|
|
|
|
/* Version number to put in __DYNAMIC (set by -V) */
|
|
int soversion;
|
|
|
|
int text_size; /* total size of text. */
|
|
int text_start; /* start of text */
|
|
int text_pad; /* clear space between text and data */
|
|
int data_size; /* total size of data. */
|
|
int data_start; /* start of data */
|
|
int data_pad; /* part of bss segment as part of data */
|
|
|
|
int bss_size; /* total size of bss. */
|
|
int bss_start; /* start of bss */
|
|
|
|
int text_reloc_size; /* total size of text relocation. */
|
|
int data_reloc_size; /* total size of data relocation. */
|
|
|
|
int rrs_section_type; /* What's in the RRS section */
|
|
int rrs_text_size; /* Size of RRS text additions */
|
|
int rrs_text_start; /* Location of above */
|
|
int rrs_data_size; /* Size of RRS data additions */
|
|
int rrs_data_start; /* Location of above */
|
|
|
|
/* Specifications of start and length of the area reserved at the end
|
|
of the data segment for the set vectors. Computed in 'digest_symbols' */
|
|
int set_sect_start; /* start of set element vectors */
|
|
int set_sect_size; /* size of above */
|
|
|
|
int link_mode; /* Current link mode */
|
|
|
|
/*
|
|
* When loading the text and data, we can avoid doing a close
|
|
* and another open between members of the same library.
|
|
*
|
|
* These two variables remember the file that is currently open.
|
|
* Both are zero if no file is open.
|
|
*
|
|
* See `each_file' and `file_close'.
|
|
*/
|
|
struct file_entry *input_file;
|
|
int input_desc;
|
|
|
|
/* The name of the file to write; "a.out" by default. */
|
|
char *output_filename; /* Output file name. */
|
|
FILE *outstream; /* Output file descriptor. */
|
|
struct exec outheader; /* Output file header. */
|
|
int magic; /* Output file magic. */
|
|
int oldmagic;
|
|
int relocatable_output; /* `-r'-ed output */
|
|
|
|
symbol *entry_symbol; /* specified by `-e' */
|
|
int entry_offset; /* program entry if no `-e' given */
|
|
|
|
int page_size; /* Size of a page (machine dependent) */
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
symbol **cmdline_references;
|
|
int cl_refs_allocated;
|
|
|
|
/*
|
|
* Which symbols should be stripped (omitted from the output): none, all, or
|
|
* debugger symbols.
|
|
*/
|
|
enum {
|
|
STRIP_NONE, STRIP_ALL, STRIP_DEBUGGER
|
|
} strip_symbols;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
int global_sym_count; /* # of nlist entries for global symbols */
|
|
int size_sym_count; /* # of N_SIZE nlist entries for output
|
|
(relocatable_output only) */
|
|
int local_sym_count; /* # of nlist entries for local symbols. */
|
|
int non_L_local_sym_count; /* # of nlist entries for non-L symbols */
|
|
int debugger_sym_count; /* # of nlist entries for debugger info. */
|
|
int undefined_global_sym_count; /* # of global symbols referenced and
|
|
not defined. */
|
|
int undefined_shobj_sym_count; /* # of undefined symbols referenced
|
|
by shared objects */
|
|
int multiple_def_count; /* # of multiply defined symbols. */
|
|
int defined_global_sym_count; /* # of defined global symbols. */
|
|
int common_defined_global_count; /* # of common symbols. */
|
|
int undefined_weak_sym_count; /* # of weak symbols referenced and
|
|
not defined. */
|
|
|
|
#if notused
|
|
int special_sym_count; /* # of linker defined symbols. */
|
|
/* XXX - Currently, only __DYNAMIC and _G_O_T_ go here if required,
|
|
* perhaps _etext, _edata and _end should go here too.
|
|
*/
|
|
#endif
|
|
int global_alias_count; /* # of aliased symbols */
|
|
int set_symbol_count; /* # of N_SET* symbols. */
|
|
int set_vector_count; /* # of set vectors in output. */
|
|
int warn_sym_count; /* # of warning symbols encountered. */
|
|
int list_warning_symbols; /* 1 => warning symbols referenced */
|
|
|
|
struct string_list_element *set_element_prefixes;
|
|
|
|
int trace_files; /* print names of input files as processed (`-t'). */
|
|
int write_map; /* write a load map (`-M') */
|
|
|
|
/*
|
|
* `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;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
long *set_vectors;
|
|
int setv_fill_count;
|
|
|
|
static void decode_option __P((char *, char *));
|
|
static void decode_command __P((int, char **));
|
|
static int classify_arg __P((char *));
|
|
static void load_symbols __P((void));
|
|
static void enter_global_ref __P((struct localsymbol *,
|
|
char *, struct file_entry *));
|
|
static void digest_symbols __P((void));
|
|
static void digest_pass1 __P((void)), digest_pass2 __P((void));
|
|
static void consider_file_section_lengths __P((struct file_entry *));
|
|
static void relocate_file_addresses __P((struct file_entry *));
|
|
static void consider_relocation __P((struct file_entry *, int));
|
|
static void consider_local_symbols __P((struct file_entry *));
|
|
static void perform_relocation __P((char *, int,
|
|
struct relocation_info *, int,
|
|
struct file_entry *, int));
|
|
static void copy_text __P((struct file_entry *));
|
|
static void copy_data __P((struct file_entry *));
|
|
static void coptxtrel __P((struct file_entry *));
|
|
static void copdatrel __P((struct file_entry *));
|
|
static void write_output __P((void));
|
|
static void write_header __P((void));
|
|
static void write_text __P((void));
|
|
static void write_data __P((void));
|
|
static void write_rel __P((void));
|
|
static void write_syms __P((void));
|
|
static void assign_symbolnums __P((struct file_entry *, int *));
|
|
static void cleanup __P((void));
|
|
static int parse __P((char *, char *, char *));
|
|
|
|
|
|
int
|
|
main(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
|
|
/* 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. */
|
|
if (getrlimit(RLIMIT_STACK, &rlim) != 0)
|
|
warn("getrlimit");
|
|
else {
|
|
rlim.rlim_cur = rlim.rlim_max;
|
|
if (setrlimit(RLIMIT_STACK, &rlim) != 0)
|
|
warn("setrlimit");
|
|
}
|
|
}
|
|
#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;
|
|
|
|
data_pad = 0;
|
|
text_pad = 0;
|
|
page_align_segments = 0;
|
|
page_align_data = 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;
|
|
link_mode = DYNAMIC;
|
|
#ifdef SUNOS4
|
|
link_mode |= SILLYARCHIVE;
|
|
#endif
|
|
soversion = DEFAULT_SOVERSION;
|
|
|
|
/* 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;
|
|
warn_sym_count = 0;
|
|
list_warning_symbols = 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 = (symbol **)
|
|
xmalloc(cl_refs_allocated * sizeof(symbol *));
|
|
*cmdline_references = 0;
|
|
|
|
/* Completely decode ARGV. */
|
|
decode_command(argc, argv);
|
|
|
|
building_shared_object =
|
|
(!relocatable_output && (link_mode & SHAREABLE));
|
|
|
|
if (building_shared_object && entry_symbol) {
|
|
errx(1,"`-Bshareable' and `-e' options are mutually exclusive");
|
|
}
|
|
|
|
/* Create the symbols `etext', `edata' and `end'. */
|
|
symtab_init(relocatable_output);
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
if (magic == ZMAGIC || magic == QMAGIC)
|
|
page_align_segments = 1;
|
|
|
|
md_init_header(&outheader, magic, 0);
|
|
|
|
text_size = sizeof(struct exec);
|
|
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
|
|
*/
|
|
make_executable &= do_warnings(stderr);
|
|
|
|
/* Print a map, if requested. */
|
|
if (write_map)
|
|
print_symbols(stdout);
|
|
|
|
/* Write the output file. */
|
|
if (make_executable || force_executable)
|
|
write_output();
|
|
|
|
exit(!make_executable);
|
|
}
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
static 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;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Process the command arguments, setting up file_table with an entry for
|
|
* each input file, and setting variables according to the options.
|
|
*/
|
|
|
|
static void
|
|
decode_command(argc, argv)
|
|
int argc;
|
|
char **argv;
|
|
{
|
|
register int i;
|
|
register struct file_entry *p;
|
|
|
|
number_of_files = 0;
|
|
output_filename = "a.out";
|
|
|
|
/*
|
|
* 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)
|
|
errx(1, "no argument following %s", argv[i]);
|
|
|
|
decode_option(argv[i], argv[i + 1]);
|
|
|
|
if (argv[i][1] == 'l' || argv[i][1] == 'A')
|
|
number_of_files++;
|
|
|
|
i += code - 1;
|
|
} else
|
|
number_of_files++;
|
|
}
|
|
|
|
if (!number_of_files)
|
|
errx(1, "no input files");
|
|
|
|
p = file_table = (struct file_entry *)
|
|
xmalloc(number_of_files * sizeof(struct file_entry));
|
|
bzero(p, number_of_files * sizeof(struct file_entry));
|
|
|
|
/* Now scan again and fill in file_table. */
|
|
/* All options except -A and -l are ignored here. */
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
char *string;
|
|
register int code = classify_arg(argv[i]);
|
|
|
|
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;
|
|
#ifdef SUN_COMPAT
|
|
else if (strcmp(string, "silly") == 0)
|
|
link_mode |= SILLYARCHIVE;
|
|
else if (strcmp(string, "~silly") == 0)
|
|
link_mode &= ~SILLYARCHIVE;
|
|
#endif
|
|
}
|
|
if (argv[i][1] == 'A') {
|
|
if (p != file_table)
|
|
errx(1, "-A specified before an input file other than the first");
|
|
p->filename = string;
|
|
p->local_sym_name = string;
|
|
p->flags |= E_JUST_SYMS;
|
|
link_mode &= ~DYNAMIC;
|
|
p++;
|
|
}
|
|
if (argv[i][1] == 'l') {
|
|
p->filename = string;
|
|
p->local_sym_name = concat("-l", string, "");
|
|
p->flags |= E_SEARCH_DIRS;
|
|
if (link_mode & DYNAMIC && !relocatable_output)
|
|
p->flags |= E_SEARCH_DYNAMIC;
|
|
p++;
|
|
}
|
|
i += code - 1;
|
|
}
|
|
|
|
/* Now check some option settings for consistency. */
|
|
|
|
if (page_align_segments &&
|
|
(text_start - text_start_alignment) & (page_size - 1))
|
|
errx(1, "incorrect alignment of text start address");
|
|
|
|
/* Append the standard search directories to the user-specified ones. */
|
|
add_search_path(getenv("LD_LIBRARY_PATH"));
|
|
if (!nostdlib && getenv("LD_NOSTD_PATH") == NULL)
|
|
std_search_path();
|
|
}
|
|
|
|
void
|
|
add_cmdline_ref(sp)
|
|
symbol *sp;
|
|
{
|
|
symbol **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 = (symbol **)
|
|
xrealloc(cmdline_references,
|
|
cl_refs_allocated * sizeof(symbol *));
|
|
ptr = cmdline_references + diff;
|
|
}
|
|
*ptr++ = sp;
|
|
*ptr = (symbol *)0;
|
|
}
|
|
|
|
int
|
|
set_element_prefixed_p(name)
|
|
char *name;
|
|
{
|
|
struct string_list_element *p;
|
|
int i;
|
|
|
|
for (p = set_element_prefixes; p; p = p->next) {
|
|
|
|
for (i = 0; p->str[i] != '\0' && (p->str[i] == name[i]); i++);
|
|
if (p->str[i] == '\0')
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
static void
|
|
decode_option(swt, arg)
|
|
register char *swt, *arg;
|
|
{
|
|
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;
|
|
#ifdef SUN_COMPAT
|
|
if (!strcmp(swt + 1, "Bsilly"))
|
|
return;
|
|
#endif
|
|
if (!strcmp(swt + 1, "Ttext")) {
|
|
text_start = parse(arg, "%x", "invalid argument to -Ttext");
|
|
T_flag_specified = 1;
|
|
return;
|
|
}
|
|
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 (!strcmp(swt + 1, "nostdlib")) {
|
|
nostdlib = 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 (swt[2] == 0 || *arg == 'c')
|
|
force_common_definition = 1;
|
|
else if (*arg == 'p')
|
|
force_alias_definition = 1;
|
|
else
|
|
errx(1, "-d option takes 'c' or 'p' argument");
|
|
return;
|
|
|
|
case 'e':
|
|
entry_symbol = getsym(arg);
|
|
if (!entry_symbol->defined &&
|
|
!(entry_symbol->flags & GS_REFERENCED))
|
|
undefined_global_sym_count++;
|
|
entry_symbol->flags |= GS_REFERENCED;
|
|
add_cmdline_ref(entry_symbol);
|
|
return;
|
|
|
|
case 'l':
|
|
return;
|
|
|
|
case 'L':
|
|
add_search_dir(arg);
|
|
return;
|
|
|
|
case 'M':
|
|
write_map = 1;
|
|
return;
|
|
|
|
case 'N':
|
|
magic = OMAGIC;
|
|
return;
|
|
|
|
case 'n':
|
|
magic = NMAGIC;
|
|
return;
|
|
|
|
case 'o':
|
|
output_filename = arg;
|
|
return;
|
|
|
|
case 'p':
|
|
page_align_data = 1;
|
|
return;
|
|
|
|
#ifdef QMAGIC
|
|
case 'Q':
|
|
magic = QMAGIC;
|
|
return;
|
|
#endif
|
|
|
|
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->flags & GS_REFERENCED))
|
|
undefined_global_sym_count++;
|
|
sp->flags |= GS_REFERENCED;
|
|
add_cmdline_ref(sp);
|
|
}
|
|
return;
|
|
|
|
#if 1
|
|
case 'V':
|
|
soversion = parse(arg, "%d", "invalid argument to -V");
|
|
return;
|
|
#endif
|
|
|
|
case 'X':
|
|
discard_locals = DISCARD_L;
|
|
return;
|
|
|
|
case 'x':
|
|
discard_locals = DISCARD_ALL;
|
|
return;
|
|
|
|
case 'y':
|
|
{
|
|
register symbol *sp = getsym(&swt[2]);
|
|
sp->flags |= GS_TRACE;
|
|
}
|
|
return;
|
|
|
|
case 'z':
|
|
magic = ZMAGIC;
|
|
oldmagic = 0;
|
|
#ifdef __FreeBSD__
|
|
netzmagic = 1;
|
|
#endif
|
|
return;
|
|
|
|
case 'Z':
|
|
magic = oldmagic = ZMAGIC;
|
|
#ifdef __FreeBSD__
|
|
netzmagic = 0;
|
|
#endif
|
|
return;
|
|
|
|
default:
|
|
errx(1, "invalid command option `%s'", swt);
|
|
}
|
|
}
|
|
|
|
/* Convenient functions for operating on one or all files being loaded. */
|
|
|
|
/*
|
|
* 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 void *arg;
|
|
{
|
|
register int i;
|
|
|
|
for (i = 0; i < number_of_files; i++) {
|
|
register struct file_entry *entry = &file_table[i];
|
|
register struct file_entry *subentry;
|
|
|
|
if (entry->flags & E_SCRAPPED)
|
|
continue;
|
|
|
|
if (!(entry->flags & E_IS_LIBRARY))
|
|
(*function)(entry, arg);
|
|
|
|
subentry = entry->subfiles;
|
|
for (; subentry; subentry = subentry->chain) {
|
|
if (subentry->flags & E_SCRAPPED)
|
|
continue;
|
|
(*function)(subentry, arg);
|
|
}
|
|
|
|
#ifdef SUN_COMPAT
|
|
if (entry->silly_archive) {
|
|
|
|
if (!(entry->flags & E_DYNAMIC))
|
|
warnx("Silly");
|
|
|
|
if (!(entry->silly_archive->flags & E_IS_LIBRARY))
|
|
warnx("Sillier");
|
|
|
|
subentry = entry->silly_archive->subfiles;
|
|
for (; subentry; subentry = subentry->chain) {
|
|
if (subentry->flags & E_SCRAPPED)
|
|
continue;
|
|
(*function)(subentry, arg);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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 void *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->flags & E_SCRAPPED)
|
|
continue;
|
|
if (entry->flags & E_IS_LIBRARY) {
|
|
register struct file_entry *subentry = entry->subfiles;
|
|
for (; subentry; subentry = subentry->chain) {
|
|
if (subentry->flags & E_SCRAPPED)
|
|
continue;
|
|
if (return_val = (*function)(subentry, arg))
|
|
return return_val;
|
|
}
|
|
} else if (return_val = (*function)(entry, arg))
|
|
return return_val;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Like `each_file' but ignore files that were just for symbol definitions. */
|
|
|
|
void
|
|
each_full_file(function, arg)
|
|
register void (*function)();
|
|
register void *arg;
|
|
{
|
|
register int i;
|
|
|
|
for (i = 0; i < number_of_files; i++) {
|
|
register struct file_entry *entry = &file_table[i];
|
|
register struct file_entry *subentry;
|
|
|
|
if (entry->flags & (E_SCRAPPED | E_JUST_SYMS))
|
|
continue;
|
|
|
|
#ifdef SUN_COMPAT
|
|
if (entry->silly_archive) {
|
|
|
|
if (!(entry->flags & E_DYNAMIC))
|
|
warnx("Silly");
|
|
|
|
if (!(entry->silly_archive->flags & E_IS_LIBRARY))
|
|
warnx("Sillier");
|
|
|
|
subentry = entry->silly_archive->subfiles;
|
|
for (; subentry; subentry = subentry->chain) {
|
|
if (subentry->flags & E_SCRAPPED)
|
|
continue;
|
|
(*function)(subentry, arg);
|
|
}
|
|
}
|
|
#endif
|
|
if (entry->flags & E_DYNAMIC)
|
|
continue;
|
|
|
|
if (!(entry->flags & E_IS_LIBRARY))
|
|
(*function)(entry, arg);
|
|
|
|
subentry = entry->subfiles;
|
|
for (; subentry; subentry = subentry->chain) {
|
|
if (subentry->flags & E_SCRAPPED)
|
|
continue;
|
|
(*function)(subentry, arg);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/* Close the input file that is now open. */
|
|
|
|
void
|
|
file_close()
|
|
{
|
|
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.
|
|
*/
|
|
int
|
|
file_open(entry)
|
|
register struct file_entry *entry;
|
|
{
|
|
register int fd;
|
|
|
|
if (entry->superfile && (entry->superfile->flags & E_IS_LIBRARY))
|
|
return file_open(entry->superfile);
|
|
|
|
if (entry == input_file)
|
|
return input_desc;
|
|
|
|
if (input_file)
|
|
file_close();
|
|
|
|
if (entry->flags & E_SEARCH_DIRS) {
|
|
fd = findlib(entry);
|
|
} else
|
|
fd = open(entry->filename, O_RDONLY, 0);
|
|
|
|
if (fd > 0) {
|
|
input_file = entry;
|
|
input_desc = fd;
|
|
return fd;
|
|
}
|
|
|
|
if (entry->flags & E_SEARCH_DIRS)
|
|
errx(1, "%s: no match", entry->local_sym_name);
|
|
else
|
|
err(1, "%s", entry->filename);
|
|
return fd;
|
|
}
|
|
|
|
int
|
|
text_offset(entry)
|
|
struct file_entry *entry;
|
|
{
|
|
return entry->starting_offset + N_TXTOFF (entry->header);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
* Read a file's header into the proper place in the file_entry. FD is the
|
|
* descriptor on which the file is open. ENTRY is the file's entry.
|
|
*/
|
|
void
|
|
read_header(fd, entry)
|
|
int fd;
|
|
struct file_entry *entry;
|
|
{
|
|
register int len;
|
|
|
|
if (lseek(fd, entry->starting_offset, L_SET) !=
|
|
entry->starting_offset)
|
|
err(1, "%s: read_header: lseek", get_file_name(entry));
|
|
|
|
len = read(fd, &entry->header, sizeof(struct exec));
|
|
if (len != sizeof (struct exec))
|
|
err(1, "%s: read_header: read", get_file_name(entry));
|
|
|
|
md_swapin_exec_hdr(&entry->header);
|
|
|
|
if (N_BADMAG (entry->header))
|
|
errx(1, "%s: bad magic", get_file_name(entry));
|
|
|
|
if (N_BADMID(entry->header))
|
|
errx(1, "%s: non-native input file", get_file_name(entry));
|
|
|
|
entry->flags |= E_HEADER_VALID;
|
|
}
|
|
|
|
/*
|
|
* Read the symbols of file ENTRY into core. Assume it is already open, on
|
|
* descriptor FD. 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(fd, entry)
|
|
struct file_entry *entry;
|
|
int fd;
|
|
{
|
|
int str_size;
|
|
struct nlist *np;
|
|
int i;
|
|
|
|
if (!(entry->flags & E_HEADER_VALID))
|
|
read_header(fd, entry);
|
|
|
|
np = (struct nlist *)alloca(entry->header.a_syms);
|
|
entry->nsymbols = entry->header.a_syms / sizeof(struct nlist);
|
|
if (entry->nsymbols == 0)
|
|
return;
|
|
|
|
entry->symbols = (struct localsymbol *)
|
|
xmalloc(entry->nsymbols * sizeof(struct localsymbol));
|
|
|
|
if (lseek(fd, N_SYMOFF(entry->header) + entry->starting_offset, L_SET)
|
|
!= N_SYMOFF(entry->header) + entry->starting_offset)
|
|
err(1, "%s: read_symbols: lseek(syms)", get_file_name(entry));
|
|
|
|
if (entry->header.a_syms != read(fd, np, entry->header.a_syms))
|
|
errx(1, "%s: read_symbols: premature end of file in symbols",
|
|
get_file_name(entry));
|
|
|
|
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].entry = entry;
|
|
entry->symbols[i].gotslot_offset = -1;
|
|
entry->symbols[i].flags = 0;
|
|
}
|
|
|
|
entry->strings_offset = N_STROFF(entry->header) +
|
|
entry->starting_offset;
|
|
if (lseek(fd, entry->strings_offset, 0) == (off_t)-1)
|
|
err(1, "%s: read_symbols: lseek(strings)",
|
|
get_file_name(entry));
|
|
if (sizeof str_size != read(fd, &str_size, sizeof str_size))
|
|
errx(1, "%s: read_symbols: cannot read string table size",
|
|
get_file_name(entry));
|
|
|
|
entry->string_size = md_swap_long(str_size);
|
|
}
|
|
|
|
/*
|
|
* Read the string table of file ENTRY open on descriptor FD, into core.
|
|
*/
|
|
void
|
|
read_entry_strings(fd, entry)
|
|
struct file_entry *entry;
|
|
int fd;
|
|
{
|
|
|
|
if (entry->string_size == 0)
|
|
return;
|
|
|
|
if (!(entry->flags & E_HEADER_VALID) || !entry->strings_offset)
|
|
errx(1, "%s: read_strings: string table unavailable",
|
|
get_file_name(entry));
|
|
|
|
if (lseek(fd, entry->strings_offset, L_SET) !=
|
|
entry->strings_offset)
|
|
err(1, "%s: read_strings: lseek",
|
|
get_file_name(entry));
|
|
|
|
if (read(fd, entry->strings, entry->string_size) !=
|
|
entry->string_size)
|
|
errx(1, "%s: read_strings: premature end of file in strings",
|
|
get_file_name(entry));
|
|
|
|
return;
|
|
}
|
|
|
|
/* Read in the relocation sections of ENTRY if necessary */
|
|
|
|
void
|
|
read_entry_relocation(fd, entry)
|
|
int fd;
|
|
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(fd, pos, L_SET) != pos)
|
|
err(1, "%s: read_reloc(text): lseek",
|
|
get_file_name(entry));
|
|
|
|
if (read(fd, reloc, entry->header.a_trsize) !=
|
|
entry->header.a_trsize)
|
|
errx(1, "%s: read_reloc(text): premature EOF",
|
|
get_file_name(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(fd, pos, L_SET) != pos)
|
|
err(1, "%s: read_reloc(data): lseek",
|
|
get_file_name(entry));
|
|
|
|
if (read(fd, reloc, entry->header.a_drsize) !=
|
|
entry->header.a_drsize)
|
|
errx(1, "%s: read_reloc(data): premature EOF",
|
|
get_file_name(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.
|
|
*/
|
|
static void
|
|
load_symbols()
|
|
{
|
|
register int i;
|
|
|
|
if (trace_files)
|
|
fprintf(stderr, "Loading symbols:\n\n");
|
|
|
|
for (i = 0; i < number_of_files; i++)
|
|
read_file_symbols(&file_table[i]);
|
|
|
|
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).
|
|
*/
|
|
|
|
void
|
|
read_file_symbols(entry)
|
|
register struct file_entry *entry;
|
|
{
|
|
register int fd;
|
|
register int len;
|
|
struct exec hdr;
|
|
|
|
fd = file_open(entry);
|
|
|
|
len = read(fd, &hdr, sizeof hdr);
|
|
if (len != sizeof hdr)
|
|
errx(1, "%s: read_file_symbols(header): premature EOF",
|
|
get_file_name(entry));
|
|
|
|
md_swapin_exec_hdr(&hdr);
|
|
|
|
if (!N_BADMAG (hdr)) {
|
|
if (N_IS_DYNAMIC(hdr) && !(entry->flags & E_JUST_SYMS)) {
|
|
if (relocatable_output) {
|
|
errx(1,
|
|
"%s: -r and shared objects currently not supported",
|
|
get_file_name(entry));
|
|
return;
|
|
}
|
|
#if notyet /* Compatibility */
|
|
if (!(N_GETFLAG(hdr) & EX_PIC))
|
|
warnx("%s: EX_PIC not set",
|
|
get_file_name(entry));
|
|
#endif
|
|
entry->flags |= E_DYNAMIC;
|
|
if (entry->superfile || rrs_add_shobj(entry))
|
|
read_shared_object(fd, entry);
|
|
else
|
|
entry->flags |= E_SCRAPPED;
|
|
} else {
|
|
if (N_GETFLAG(hdr) & EX_PIC)
|
|
pic_code_seen = 1;
|
|
read_entry_symbols(fd, entry);
|
|
entry->strings = (char *)alloca(entry->string_size);
|
|
read_entry_strings(fd, entry);
|
|
read_entry_relocation(fd, entry);
|
|
enter_file_symbols(entry);
|
|
entry->strings = 0;
|
|
}
|
|
} else {
|
|
char armag[SARMAG];
|
|
|
|
lseek (fd, 0, 0);
|
|
if (SARMAG != read(fd, armag, SARMAG) ||
|
|
strncmp (armag, ARMAG, SARMAG))
|
|
errx(1,
|
|
"%s: malformed input file (not rel or archive)",
|
|
get_file_name(entry));
|
|
entry->flags |= E_IS_LIBRARY;
|
|
search_library(fd, entry);
|
|
}
|
|
|
|
file_close();
|
|
}
|
|
|
|
|
|
/*
|
|
* Enter the external symbol defs and refs of ENTRY in the hash table.
|
|
*/
|
|
|
|
void
|
|
enter_file_symbols(entry)
|
|
struct file_entry *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 *msg = p->n_un.n_strx + entry->strings;
|
|
|
|
/* Grab the next entry. */
|
|
lsp++;
|
|
p = &lsp->nzlist.nlist;
|
|
if (p->n_type != (N_UNDF | N_EXT)) {
|
|
warnx(
|
|
"%s: Warning symbol without external reference following.",
|
|
get_file_name(entry));
|
|
make_executable = 0;
|
|
lsp--; /* Process normally. */
|
|
} else {
|
|
symbol *sp;
|
|
char *name = p->n_un.n_strx + entry->strings;
|
|
/* Deal with the warning symbol. */
|
|
lsp->flags |= LS_WARNING;
|
|
enter_global_ref(lsp, name, entry);
|
|
sp = getsym(name);
|
|
if (sp->warning == NULL) {
|
|
sp->warning = (char *)
|
|
xmalloc(strlen(msg)+1);
|
|
strcpy(sp->warning, msg);
|
|
warn_sym_count++;
|
|
} else if (strcmp(sp->warning, msg))
|
|
warnx(
|
|
"%s: multiple definitions for warning symbol `%s'",
|
|
get_file_name(entry), sp->name);
|
|
}
|
|
} 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_un.n_strx + entry->strings)[0] == LPREFIX)
|
|
lsp->flags |= LS_L_SYMBOL;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* 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 `soref'. 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.
|
|
*
|
|
*/
|
|
|
|
static void
|
|
enter_global_ref(lsp, name, entry)
|
|
struct localsymbol *lsp;
|
|
char *name;
|
|
struct file_entry *entry;
|
|
{
|
|
register struct nzlist *nzp = &lsp->nzlist;
|
|
register symbol *sp = getsym(name);
|
|
register int type = nzp->nz_type;
|
|
int oldref = (sp->flags & GS_REFERENCED);
|
|
int olddef = sp->defined;
|
|
int com = sp->defined && sp->common_size;
|
|
|
|
if (type == (N_INDR | N_EXT) && !olddef) {
|
|
sp->alias = getsym(entry->strings + (lsp + 1)->nzlist.nz_strx);
|
|
if (sp == sp->alias) {
|
|
warnx("%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++;
|
|
}
|
|
#if 0
|
|
if (sp->flags & GS_REFERENCED)
|
|
sp->alias->flags |= GS_REFERENCED;
|
|
#endif
|
|
}
|
|
|
|
if (entry->flags & E_DYNAMIC) {
|
|
lsp->next = sp->sorefs;
|
|
sp->sorefs = lsp;
|
|
lsp->symbol = sp;
|
|
|
|
/*
|
|
* 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->common_size = nzp->nz_value;
|
|
sp->defined = N_UNDF | N_EXT;
|
|
} else if (com && sp->common_size < nzp->nz_value) {
|
|
sp->common_size = nzp->nz_value;
|
|
}
|
|
} else if (type != (N_UNDF | N_EXT) && !oldref) {
|
|
/*
|
|
* This is an ex common...
|
|
*/
|
|
if (com)
|
|
common_defined_global_count--;
|
|
sp->common_size = 0;
|
|
sp->defined = 0;
|
|
}
|
|
|
|
/*
|
|
* Handle size information in shared objects.
|
|
*/
|
|
if (nzp->nz_size > sp->size)
|
|
sp->size = nzp->nz_size;
|
|
|
|
if ((lsp->flags & LS_WARNING) && (sp->flags & GS_REFERENCED))
|
|
/*
|
|
* Prevent warning symbols from getting
|
|
* gratuitously referenced.
|
|
*/
|
|
list_warning_symbols = 1;
|
|
return;
|
|
}
|
|
|
|
lsp->next = sp->refs;
|
|
sp->refs = lsp;
|
|
lsp->symbol = sp;
|
|
|
|
if (lsp->flags & LS_WARNING) {
|
|
/*
|
|
* Prevent warning symbols from getting
|
|
* gratuitously referenced.
|
|
*/
|
|
if (sp->flags & GS_REFERENCED)
|
|
list_warning_symbols = 1;
|
|
return;
|
|
}
|
|
|
|
if (sp->warning)
|
|
list_warning_symbols = 1;
|
|
|
|
sp->flags |= GS_REFERENCED;
|
|
|
|
if (sp == dynamic_symbol || sp == got_symbol) {
|
|
if (type != (N_UNDF | N_EXT) && !(entry->flags & E_JUST_SYMS))
|
|
errx(1,"Linker reserved symbol %s defined as type %x ",
|
|
name, type);
|
|
return;
|
|
}
|
|
|
|
if (olddef && N_ISWEAK(&nzp->nlist) && !(sp->flags & GS_WEAK)) {
|
|
#ifdef DEBUG
|
|
printf("%s: not overridden by weak symbol from %s\n",
|
|
sp->name, get_file_name(entry));
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (type == (N_SIZE | N_EXT)) {
|
|
|
|
if (relocatable_output && nzp->nz_value != 0 && sp->size == 0)
|
|
size_sym_count++;
|
|
if (sp->size < nzp->nz_value)
|
|
sp->size = nzp->nz_value;
|
|
|
|
} else 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 ((sp->flags & GS_WEAK) && !N_ISWEAK(&nzp->nlist)) {
|
|
/*
|
|
* Upgrade an existing weak definition.
|
|
* We fake it by pretending the symbol is undefined;
|
|
* must undo any common fiddling, however.
|
|
*/
|
|
if (!oldref)
|
|
errx(1, "internal error: enter_glob_ref: "
|
|
"weak symbol not referenced");
|
|
if (!olddef && !com)
|
|
undefined_weak_sym_count--;
|
|
undefined_global_sym_count++;
|
|
sp->defined = type;
|
|
sp->flags &= ~GS_WEAK;
|
|
olddef = 0;
|
|
if (com)
|
|
common_defined_global_count--;
|
|
com = 0;
|
|
sp->common_size = 0;
|
|
}
|
|
if (oldref && !olddef) {
|
|
/*
|
|
* It used to be undefined and we're defining it.
|
|
*/
|
|
undefined_global_sym_count--;
|
|
if (sp->flags & GS_WEAK)
|
|
/* Used to be a weak reference */
|
|
undefined_weak_sym_count--;
|
|
if (undefined_global_sym_count < 0 ||
|
|
undefined_weak_sym_count < 0)
|
|
errx(1, "internal error: enter_glob_ref: "
|
|
"undefined_global_sym_count = %d, "
|
|
"undefined_weak_sym_count = %d",
|
|
undefined_global_sym_count,
|
|
undefined_weak_sym_count);
|
|
|
|
}
|
|
|
|
if (N_ISWEAK(&nzp->nlist))
|
|
/* The definition is weak */
|
|
sp->flags |= GS_WEAK;
|
|
|
|
if (!olddef && type == (N_UNDF | N_EXT) && nzp->nz_value) {
|
|
/*
|
|
* First definition and it's common.
|
|
*/
|
|
common_defined_global_count++;
|
|
sp->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->common_size = 0;
|
|
} else if (com && type == (N_UNDF | N_EXT) &&
|
|
sp->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->common_size = nzp->nz_value;
|
|
|
|
if (SET_ELEMENT_P(type) && (!olddef || com))
|
|
set_vector_count++;
|
|
|
|
} else if (!oldref && !com) {
|
|
/*
|
|
* An unreferenced symbol can already be defined
|
|
* as common by shared objects.
|
|
*/
|
|
undefined_global_sym_count++;
|
|
if (N_ISWEAK(&nzp->nlist)) {
|
|
/* The reference is weak */
|
|
sp->flags |= GS_WEAK;
|
|
undefined_weak_sym_count++;
|
|
}
|
|
}
|
|
|
|
if (sp == end_symbol && (entry->flags & E_JUST_SYMS) &&
|
|
!T_flag_specified)
|
|
text_start = nzp->nz_value;
|
|
|
|
if (sp->flags & GS_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;
|
|
|
|
case N_INDR:
|
|
reftype = "alias";
|
|
break;
|
|
|
|
case N_SIZE:
|
|
reftype = "size spec";
|
|
break;
|
|
|
|
default:
|
|
reftype = "I don't know this type";
|
|
break;
|
|
}
|
|
|
|
fprintf(stderr, "symbol %s %s%s in ", sp->name,
|
|
(N_ISWEAK(&nzp->nlist))?"weakly ":"", reftype);
|
|
print_file_name (entry, stderr);
|
|
fprintf(stderr, "\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This returns 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, np)
|
|
struct file_entry *entry;
|
|
register struct nlist *np;
|
|
{
|
|
if (np >= &entry->symbols->nzlist.nlist &&
|
|
np < &(entry->symbols + entry->nsymbols)->nzlist.nlist)
|
|
return (unsigned long) entry;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* 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 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.
|
|
*
|
|
*/
|
|
|
|
static void
|
|
digest_symbols()
|
|
{
|
|
|
|
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 = (set_symbol_count + 2 * set_vector_count) *
|
|
sizeof (unsigned long);
|
|
set_vectors = (long *)xmalloc (set_sect_size);
|
|
setv_fill_count = 0;
|
|
}
|
|
|
|
/* Pass 1: check and define symbols */
|
|
defined_global_sym_count = 0;
|
|
digest_pass1();
|
|
|
|
each_full_file(consider_relocation, (void *)0); /* Text */
|
|
each_full_file(consider_relocation, (void *)1); /* Data */
|
|
|
|
each_file(consider_local_symbols, (void *)0);
|
|
|
|
/*
|
|
* 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 (page_align_segments || page_align_data) {
|
|
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;
|
|
|
|
/*
|
|
* Make the data segment address start in memory on a suitable
|
|
* boundary.
|
|
*/
|
|
|
|
if (!Tdata_flag_specified)
|
|
rrs_data_start = text_start +
|
|
DATA_START(outheader) - TEXT_START(outheader);
|
|
|
|
data_start = rrs_data_start + rrs_data_size;
|
|
if (!relocatable_output) {
|
|
set_sect_start = rrs_data_start + data_size;
|
|
data_size += MALIGN(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);
|
|
printf("set_sect_start = %#x, set_sect_size = %#x\n",
|
|
set_sect_start, set_sect_size);
|
|
#endif
|
|
|
|
/* Compute start addresses of each file's sections and symbols. */
|
|
|
|
each_full_file(relocate_file_addresses, 0);
|
|
relocate_rrs_addresses();
|
|
|
|
/* Pass 2: assign values to symbols */
|
|
digest_pass2();
|
|
|
|
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;
|
|
}
|
|
/*
|
|
* 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 (page_align_segments)
|
|
data_pad = PALIGN(data_pad + data_size, page_size) - data_size;
|
|
|
|
bss_size -= data_pad;
|
|
if (bss_size < 0)
|
|
bss_size = 0;
|
|
|
|
data_size += data_pad;
|
|
|
|
/*
|
|
* Calculate total number of symbols that will go into
|
|
* the output symbol table (barring DISCARD_* settings).
|
|
*/
|
|
global_sym_count = defined_global_sym_count +
|
|
undefined_global_sym_count;
|
|
|
|
if (dynamic_symbol->flags & GS_REFERENCED)
|
|
global_sym_count++;
|
|
|
|
if (got_symbol->flags & GS_REFERENCED)
|
|
global_sym_count++;
|
|
|
|
if (relocatable_output || building_shared_object) {
|
|
/* For each alias we write out two struct nlists */
|
|
global_sym_count += global_alias_count;
|
|
/* Propagate warning symbols; costs two extra struct nlists */
|
|
global_sym_count += 2 * warn_sym_count;
|
|
}
|
|
|
|
if (relocatable_output)
|
|
/* We write out the original N_SIZE symbols */
|
|
global_sym_count += size_sym_count;
|
|
|
|
#ifdef DEBUG
|
|
printf(
|
|
"global symbols %d "
|
|
"(defined %d, undefined %d, weak %d, aliases %d, warnings 2 * %d, "
|
|
"size symbols %d)\ncommons %d, locals: %d, debug symbols: %d, set_symbols %d\n",
|
|
global_sym_count,
|
|
defined_global_sym_count, undefined_global_sym_count,
|
|
undefined_weak_sym_count,
|
|
global_alias_count, warn_sym_count, size_sym_count,
|
|
common_defined_global_count, local_sym_count,
|
|
debugger_sym_count, set_symbol_count);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Determine the definition of each global symbol.
|
|
*/
|
|
static void
|
|
digest_pass1()
|
|
{
|
|
|
|
/*
|
|
* 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) {
|
|
symbol *spsave;
|
|
struct localsymbol *lsp;
|
|
int defs = 0;
|
|
|
|
if (!(sp->flags & GS_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
|
|
|
|
/* Superfluous symbol from shared object */
|
|
continue;
|
|
}
|
|
if (sp->so_defined)
|
|
/* Already examined; must have been an alias */
|
|
continue;
|
|
|
|
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)
|
|
errx(1,
|
|
"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->mult_defs = 1;
|
|
multiple_def_count++;
|
|
}
|
|
/* Keep count and remember symbol */
|
|
sp->setv_count++;
|
|
set_vectors[setv_fill_count++] = (long)p;
|
|
if (building_shared_object) {
|
|
struct relocation_info reloc;
|
|
|
|
/*
|
|
* Make sure to relocate the contents
|
|
* of this set vector.
|
|
*/
|
|
bzero(&reloc, sizeof(reloc));
|
|
RELOC_INIT_SEGMENT_RELOC(&reloc);
|
|
RELOC_ADDRESS(&reloc) =
|
|
setv_fill_count * sizeof(long);
|
|
alloc_rrs_segment_reloc(NULL, &reloc);
|
|
}
|
|
|
|
} else if ((type & N_EXT) && type != (N_UNDF | N_EXT)
|
|
&& (type & N_TYPE) != N_FN
|
|
&& (type & N_TYPE) != N_SIZE) {
|
|
/* non-common definition */
|
|
if (!N_ISWEAK(p))
|
|
++defs;
|
|
if (defs > 1) {
|
|
sp->mult_defs = 1;
|
|
multiple_def_count++;
|
|
} else if (!N_ISWEAK(p) ||
|
|
(!sp->def_lsp && !sp->common_size)) {
|
|
sp->def_lsp = lsp;
|
|
lsp->entry->flags |= E_SYMBOLS_USED;
|
|
sp->defined = type;
|
|
sp->aux = N_AUX(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sp->defined) {
|
|
if ((sp->defined & N_TYPE) == N_SETV)
|
|
/* Allocate zero entry in set vector */
|
|
setv_fill_count++;
|
|
/*
|
|
* At this stage, we do not know whether an alias
|
|
* is going to be defined for real here, or whether
|
|
* it refers to a shared object symbol. The decision
|
|
* is deferred until digest_pass2().
|
|
*/
|
|
if (!sp->alias)
|
|
defined_global_sym_count++;
|
|
continue;
|
|
}
|
|
|
|
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--;
|
|
if (undefined_global_sym_count < 0)
|
|
errx(1,
|
|
"internal error: digest_pass1,1: %s: undefined_global_sym_count = %d",
|
|
sp->name, undefined_global_sym_count);
|
|
continue;
|
|
}
|
|
|
|
spsave=sp;
|
|
again:
|
|
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_lsp = lsp;
|
|
sp->so_defined = type;
|
|
sp->aux = N_AUX(p);
|
|
if (lsp->entry->flags & E_SECONDCLASS)
|
|
/* Keep looking for something better */
|
|
continue;
|
|
if (N_ISWEAK(p))
|
|
/* Keep looking for something better */
|
|
continue;
|
|
break;
|
|
}
|
|
}
|
|
if (sp->def_lsp) {
|
|
#ifdef DEBUG
|
|
printf("pass1: SO definition for %s, type %x in %s at %#x\n",
|
|
sp->name, sp->so_defined, get_file_name(sp->def_lsp->entry),
|
|
sp->def_lsp->nzlist.nz_value);
|
|
#endif
|
|
sp->def_lsp->entry->flags |= E_SYMBOLS_USED;
|
|
if (sp->flags & GS_REFERENCED)
|
|
undefined_global_sym_count--;
|
|
else
|
|
sp->flags |= GS_REFERENCED;
|
|
if (undefined_global_sym_count < 0)
|
|
errx(1, "internal error: digest_pass1,2: "
|
|
"%s: undefined_global_sym_count = %d",
|
|
sp->name, undefined_global_sym_count);
|
|
if (sp->alias &&
|
|
!(sp->alias->flags & GS_REFERENCED)) {
|
|
sp = sp->alias;
|
|
goto again;
|
|
}
|
|
}
|
|
sp=spsave;
|
|
} END_EACH_SYMBOL;
|
|
|
|
if (setv_fill_count != set_sect_size/sizeof(long))
|
|
errx(1, "internal error: allocated set symbol space (%d) "
|
|
"doesn't match actual (%d)",
|
|
set_sect_size/sizeof(long), setv_fill_count);
|
|
}
|
|
|
|
|
|
/*
|
|
* Scan relocation info in ENTRY for contributions to the RRS section
|
|
* of the output file.
|
|
*/
|
|
static 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;
|
|
}
|
|
|
|
for (; reloc < end; reloc++) {
|
|
|
|
if (relocatable_output) {
|
|
lsp = &entry->symbols[reloc->r_symbolnum];
|
|
if (RELOC_BASEREL_P(reloc)) {
|
|
pic_code_seen = 1; /* Compatibility */
|
|
if (!RELOC_EXTERN_P(reloc))
|
|
lsp->flags |= LS_RENAME;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
if (sp->flags & GS_TRACE) {
|
|
fprintf(stderr, "symbol %s has jmpslot in %s\n",
|
|
sp->name, get_file_name(entry));
|
|
}
|
|
alloc_rrs_jmpslot(entry, sp);
|
|
|
|
} else if (RELOC_BASEREL_P(reloc)) {
|
|
|
|
lsp = &entry->symbols[reloc->r_symbolnum];
|
|
alloc_rrs_gotslot(entry, 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)
|
|
errx(1, "%s: bogus relocation record",
|
|
get_file_name(entry));
|
|
|
|
if (sp->alias)
|
|
sp = sp->alias;
|
|
|
|
/*
|
|
* Skip refs to _GLOBAL_OFFSET_TABLE_ and __DYNAMIC
|
|
*/
|
|
if (sp == got_symbol) {
|
|
if (!CHECK_GOT_RELOC(reloc))
|
|
errx(1,
|
|
"%s: Unexpected relocation type for GOT symbol",
|
|
get_file_name(entry));
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* This symbol gives rise to a RRS entry
|
|
*/
|
|
|
|
if (building_shared_object) {
|
|
if (sp->flags & GS_TRACE) {
|
|
fprintf(stderr,
|
|
"symbol %s RRS entry in %s\n",
|
|
sp->name, get_file_name(entry));
|
|
}
|
|
alloc_rrs_reloc(entry, sp);
|
|
continue;
|
|
}
|
|
|
|
if (force_alias_definition && sp->so_defined &&
|
|
sp->aux == AUX_FUNC) {
|
|
|
|
/* Call to shared library procedure */
|
|
alloc_rrs_jmpslot(entry, sp);
|
|
|
|
} else if (sp->size && sp->so_defined &&
|
|
sp->aux == AUX_OBJECT) {
|
|
|
|
/* Reference to shared library data */
|
|
alloc_rrs_cpy_reloc(entry, sp);
|
|
sp->defined = N_SIZE;
|
|
|
|
} else if (!sp->defined && sp->common_size == 0 &&
|
|
sp->so_defined)
|
|
alloc_rrs_reloc(entry, sp);
|
|
|
|
} else {
|
|
/*
|
|
* Segment relocation.
|
|
* Prepare an RRS relocation as these are load
|
|
* address dependent.
|
|
*/
|
|
if (building_shared_object && !RELOC_PCREL_P(reloc)) {
|
|
alloc_rrs_segment_reloc(entry, reloc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Determine the disposition of each local symbol.
|
|
*/
|
|
static void
|
|
consider_local_symbols(entry)
|
|
register struct file_entry *entry;
|
|
{
|
|
register struct localsymbol *lsp, *lspend;
|
|
|
|
if (entry->flags & E_DYNAMIC)
|
|
return;
|
|
|
|
lspend = entry->symbols + entry->nsymbols;
|
|
|
|
/*
|
|
* For each symbol determine whether it should go
|
|
* in the output symbol table.
|
|
*/
|
|
|
|
for (lsp = entry->symbols; lsp < lspend; lsp++) {
|
|
register struct nlist *p = &lsp->nzlist.nlist;
|
|
register int type = p->n_type;
|
|
|
|
if (type == N_WARNING)
|
|
continue;
|
|
|
|
if (SET_ELEMENT_P (type)) {
|
|
/*
|
|
* This occurs even if global. These types of
|
|
* symbols are never written globally, though
|
|
* they are stored globally.
|
|
*/
|
|
if (relocatable_output)
|
|
lsp->flags |= LS_WRITE;
|
|
|
|
} else if (!(type & (N_STAB | N_EXT))) {
|
|
|
|
/*
|
|
* Ordinary local symbol
|
|
*/
|
|
if ((lsp->flags & LS_RENAME) || (
|
|
discard_locals != DISCARD_ALL &&
|
|
!(discard_locals == DISCARD_L &&
|
|
(lsp->flags & LS_L_SYMBOL))) ) {
|
|
|
|
lsp->flags |= LS_WRITE;
|
|
local_sym_count++;
|
|
}
|
|
|
|
} else if (!(type & N_EXT)) {
|
|
|
|
/*
|
|
* Debugger symbol
|
|
*/
|
|
if (strip_symbols == STRIP_NONE) {
|
|
lsp->flags |= LS_WRITE;
|
|
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.
|
|
*/
|
|
if (discard_locals != DISCARD_ALL)
|
|
local_sym_count++;
|
|
}
|
|
|
|
/*
|
|
* Accumulate the section sizes of input file ENTRY into the section sizes of
|
|
* the output file.
|
|
*/
|
|
static void
|
|
consider_file_section_lengths(entry)
|
|
register struct file_entry *entry;
|
|
{
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
static void
|
|
relocate_file_addresses(entry)
|
|
register struct file_entry *entry;
|
|
{
|
|
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
|
|
|
|
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;
|
|
|
|
/*
|
|
* If this belongs to a section, update it
|
|
* by the section's start address
|
|
*/
|
|
|
|
switch (type & N_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;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Assign a value to each global symbol.
|
|
*/
|
|
static void
|
|
digest_pass2()
|
|
{
|
|
FOR_EACH_SYMBOL(i, sp) {
|
|
int size;
|
|
int align = sizeof(int);
|
|
|
|
if (!(sp->flags & GS_REFERENCED))
|
|
continue;
|
|
|
|
if (sp->alias &&
|
|
(relocatable_output || building_shared_object ||
|
|
(sp->alias->defined && !sp->alias->so_defined))) {
|
|
/*
|
|
* The alias points at a defined symbol, so it
|
|
* must itself be counted as one too, in order to
|
|
* compute the correct number of symbol table entries.
|
|
*/
|
|
if (!sp->defined) {
|
|
/*
|
|
* Change aliased symbol's definition too.
|
|
* These things happen if shared object commons
|
|
* or data is going into our symbol table.
|
|
*/
|
|
if (sp->so_defined != (N_INDR+N_EXT))
|
|
warnx( "pass2: %s: alias isn't",
|
|
sp->name);
|
|
sp->defined = sp->so_defined;
|
|
sp->so_defined = 0;
|
|
}
|
|
defined_global_sym_count++;
|
|
}
|
|
|
|
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, *p, *q;
|
|
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;
|
|
if (building_shared_object) {
|
|
struct relocation_info reloc;
|
|
|
|
bzero(&reloc, sizeof(reloc));
|
|
RELOC_INIT_SEGMENT_RELOC(&reloc);
|
|
RELOC_ADDRESS(&reloc) =
|
|
(1 + i + length_word_index) *
|
|
sizeof(long)
|
|
+ set_sect_start;
|
|
RELOC_TYPE(&reloc) =
|
|
(p->n_type - (N_SETA - N_ABS)) & N_TYPE;
|
|
claim_rrs_segment_reloc(NULL, &reloc);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Reverse the vector.
|
|
*/
|
|
p = &set_vectors[length_word_index + 1];
|
|
q = &set_vectors[length_word_index + sp->setv_count];
|
|
while (p < q) {
|
|
unsigned long tmp = *p;
|
|
*p++ = *q;
|
|
*q-- = tmp;
|
|
}
|
|
|
|
/* Clear terminating entry */
|
|
set_vectors[length_word_index + sp->setv_count + 1] = 0;
|
|
continue;
|
|
}
|
|
|
|
if (sp->def_lsp) {
|
|
if (sp->defined && (sp->defined & ~N_EXT) != N_SETV)
|
|
sp->value = sp->def_lsp->nzlist.nz_value;
|
|
if (sp->so_defined &&
|
|
(sp->def_lsp->entry->flags & E_SECONDCLASS))
|
|
/* Flag second-hand definitions */
|
|
undefined_global_sym_count++;
|
|
if (sp->flags & GS_TRACE)
|
|
printf("symbol %s assigned to location %#x\n",
|
|
sp->name, sp->value);
|
|
}
|
|
|
|
/*
|
|
* If not -r'ing, allocate common symbols in the BSS section.
|
|
*/
|
|
if (building_shared_object && !(link_mode & SYMBOLIC))
|
|
/* No common allocation in shared objects */
|
|
continue;
|
|
|
|
if ((size = sp->common_size) != 0) {
|
|
/*
|
|
* It's a common.
|
|
*/
|
|
if (sp->defined != (N_UNDF + N_EXT))
|
|
errx(1, "%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)
|
|
errx(1, "%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;
|
|
}
|
|
|
|
/*
|
|
* 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).
|
|
*/
|
|
|
|
size = PALIGN(size, sizeof(int));
|
|
|
|
while (align < MAX_ALIGNMENT && !(size & align))
|
|
align <<= 1;
|
|
|
|
bss_size = PALIGN(bss_size + data_size + rrs_data_start, align)
|
|
- (data_size + rrs_data_start);
|
|
|
|
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);
|
|
|
|
} END_EACH_SYMBOL;
|
|
}
|
|
|
|
|
|
/* -------------------------------------------------------------------*/
|
|
|
|
/* Write the output file */
|
|
void
|
|
write_output()
|
|
{
|
|
struct stat statbuf;
|
|
int filemode;
|
|
|
|
if (lstat(output_filename, &statbuf) == 0) {
|
|
if (S_ISREG(statbuf.st_mode))
|
|
(void)unlink(output_filename);
|
|
}
|
|
|
|
outstream = fopen(output_filename, "w");
|
|
if (outstream == NULL)
|
|
err(1, "open: %s", output_filename);
|
|
|
|
if (atexit(cleanup))
|
|
err(1, "atexit");
|
|
|
|
if (fstat(fileno(outstream), &statbuf) < 0)
|
|
err(1, "fstat: %s", output_filename);
|
|
|
|
filemode = statbuf.st_mode;
|
|
|
|
if (S_ISREG(statbuf.st_mode) &&
|
|
chmod(output_filename, filemode & ~0111) == -1)
|
|
err(1, "chmod: %s", output_filename);
|
|
|
|
/* Output the a.out header. */
|
|
write_header();
|
|
|
|
/* 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 symbol table (both globals and locals). */
|
|
write_syms();
|
|
|
|
/* Output the RSS section */
|
|
write_rrs();
|
|
|
|
if (chmod (output_filename, filemode | 0111) == -1)
|
|
err(1, "chmod: %s", output_filename);
|
|
|
|
fflush(outstream);
|
|
/* Report I/O error such as disk full. */
|
|
if (ferror(outstream) || fclose(outstream) != 0)
|
|
err(1, "write_output: %s", output_filename);
|
|
outstream = 0;
|
|
}
|
|
|
|
/* Total number of symbols to be written in the output file. */
|
|
static int nsyms;
|
|
|
|
void
|
|
write_header()
|
|
{
|
|
int flags;
|
|
|
|
if (link_mode & SHAREABLE)
|
|
/* Output is shared object */
|
|
flags = EX_DYNAMIC | EX_PIC;
|
|
else if (relocatable_output && pic_code_seen)
|
|
/* Output is relocatable and contains PIC code */
|
|
flags = EX_PIC;
|
|
else if (rrs_section_type == RRS_FULL)
|
|
/* Output is a dynamic executable */
|
|
flags = EX_DYNAMIC;
|
|
else
|
|
/*
|
|
* Output is a static executable
|
|
* or a non-PIC relocatable object
|
|
*/
|
|
flags = 0;
|
|
|
|
if (oldmagic && (flags & EX_DPMASK))
|
|
warnx("Cannot set flag in old magic headers\n");
|
|
|
|
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 = global_sym_count + local_sym_count + debugger_sym_count;
|
|
|
|
if (relocatable_output)
|
|
nsyms += set_symbol_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;
|
|
}
|
|
|
|
md_swapout_exec_hdr(&outheader);
|
|
mywrite(&outheader, sizeof (struct exec), 1, outstream);
|
|
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, outstream);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Relocate the text segment of each input file
|
|
* and write to the output file.
|
|
*/
|
|
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, "\n");
|
|
|
|
padfile(text_pad, outstream);
|
|
}
|
|
|
|
/*
|
|
* 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 fd;
|
|
|
|
if (trace_files)
|
|
prline_file_name(entry, stderr);
|
|
|
|
fd = file_open(entry);
|
|
|
|
/* Allocate space for the file's text section */
|
|
bytes = (char *)alloca(entry->header.a_text);
|
|
|
|
/* Deal with relocation information however is appropriate */
|
|
if (entry->textrel == NULL)
|
|
errx(1, "%s: no text relocation", get_file_name(entry));
|
|
|
|
/* Read the text section into core. */
|
|
if (lseek(fd, text_offset(entry), L_SET) == (off_t)-1)
|
|
err(1, "%s: copy_text: lseek", get_file_name(entry));
|
|
if (entry->header.a_text != read(fd, bytes, entry->header.a_text))
|
|
errx(1, "%s: copy_text: premature EOF", get_file_name(entry));
|
|
|
|
/* Relocate the text according to the text relocation. */
|
|
perform_relocation (bytes, entry->header.a_text,
|
|
entry->textrel, entry->ntextrel, entry, 0);
|
|
|
|
/* Write the relocated text to the output file. */
|
|
mywrite(bytes, 1, entry->header.a_text, outstream);
|
|
}
|
|
|
|
/*
|
|
* Relocate the data segment of each input file
|
|
* and write to the output file.
|
|
*/
|
|
|
|
void
|
|
write_data()
|
|
{
|
|
off_t pos;
|
|
|
|
if (trace_files)
|
|
fprintf(stderr, "Copying and relocating data:\n\n");
|
|
|
|
pos = N_DATOFF(outheader) + data_start - rrs_data_start;
|
|
if (fseek(outstream, pos, SEEK_SET) != 0)
|
|
errx(1, "write_data: fseek");
|
|
|
|
each_full_file(copy_data, 0);
|
|
file_close();
|
|
|
|
/*
|
|
* Write out the set element vectors. See digest symbols for
|
|
* description of length of the set vector section.
|
|
*/
|
|
|
|
if (set_vector_count) {
|
|
swap_longs(set_vectors, set_symbol_count + 2*set_vector_count);
|
|
mywrite(set_vectors, set_symbol_count + 2*set_vector_count,
|
|
sizeof (unsigned long), outstream);
|
|
}
|
|
|
|
if (trace_files)
|
|
fprintf(stderr, "\n");
|
|
|
|
padfile(data_pad, outstream);
|
|
}
|
|
|
|
/*
|
|
* 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 char *bytes;
|
|
register int fd;
|
|
|
|
if (trace_files)
|
|
prline_file_name (entry, stderr);
|
|
|
|
fd = file_open(entry);
|
|
|
|
bytes = (char *)alloca(entry->header.a_data);
|
|
|
|
if (entry->datarel == NULL)
|
|
errx(1, "%s: no data relocation", get_file_name(entry));
|
|
|
|
if (lseek(fd, text_offset(entry) + entry->header.a_text, L_SET) ==
|
|
(off_t)-1)
|
|
err(1, "%s: copy_data: lseek", get_file_name(entry));
|
|
if (entry->header.a_data != read(fd, bytes, entry->header.a_data))
|
|
errx(1, "%s: copy_data: premature EOF", get_file_name(entry));
|
|
|
|
perform_relocation(bytes, entry->header.a_data,
|
|
entry->datarel, entry->ndatarel, entry, 1);
|
|
|
|
mywrite(bytes, 1, entry->header.a_data, outstream);
|
|
}
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
/* HACK: md.c may need access to this */
|
|
int pc_relocation;
|
|
|
|
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;
|
|
|
|
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;
|
|
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)
|
|
errx(1, "%s: relocation address out of range",
|
|
get_file_name(entry));
|
|
|
|
if (RELOC_JMPTAB_P(r)) {
|
|
|
|
int symindex = RELOC_SYMBOL(r);
|
|
struct localsymbol *lsp = &entry->symbols[symindex];
|
|
symbol *sp;
|
|
|
|
if (symindex >= entry->nsymbols)
|
|
errx(1, "%s: relocation symbolnum out of range",
|
|
get_file_name(entry));
|
|
|
|
sp = lsp->symbol;
|
|
if (sp == NULL)
|
|
errx(1, "%s: bogus relocation record",
|
|
get_file_name(entry));
|
|
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(entry, r, sp, addend);
|
|
|
|
} else if (RELOC_BASEREL_P(r)) {
|
|
|
|
int symindex = RELOC_SYMBOL(r);
|
|
struct localsymbol *lsp = &entry->symbols[symindex];
|
|
|
|
if (symindex >= entry->nsymbols)
|
|
errx(1, "%s: relocation symbolnum out of range",
|
|
get_file_name(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(
|
|
entry, r, lsp, addend);
|
|
|
|
} else if (RELOC_EXTERN_P(r)) {
|
|
|
|
int symindex = RELOC_SYMBOL(r);
|
|
symbol *sp;
|
|
|
|
if (symindex >= entry->nsymbols)
|
|
errx(1, "%s: relocation symbolnum out of range",
|
|
get_file_name(entry));
|
|
|
|
sp = entry->symbols[symindex].symbol;
|
|
if (sp == NULL)
|
|
errx(1, "%s: bogus relocation record",
|
|
get_file_name(entry));
|
|
if (sp->alias)
|
|
sp = sp->alias;
|
|
|
|
if (relocatable_output) {
|
|
relocation = addend;
|
|
/*
|
|
* In PIC code, we keep the reference to the
|
|
* external symbol, even if defined now.
|
|
*/
|
|
if (!pic_code_seen)
|
|
relocation += sp->value;
|
|
} else if (sp->defined) {
|
|
if (sp->flags & GS_TRACE) {
|
|
fprintf(stderr,
|
|
"symbol %s defined as %x in %s\n",
|
|
sp->name, sp->defined,
|
|
get_file_name(entry) );
|
|
}
|
|
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(
|
|
entry, r, sp, &relocation))
|
|
continue;
|
|
} else if (sp->defined == N_SIZE) {
|
|
/*
|
|
* If size is known, arrange a
|
|
* run-time copy.
|
|
*/
|
|
if (!sp->size)
|
|
errx(1, "Copy item isn't: %s",
|
|
sp->name);
|
|
|
|
relocation = addend + sp->value;
|
|
r->r_address = sp->value;
|
|
claim_rrs_cpy_reloc(entry, 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.
|
|
*/
|
|
if (sp->flags & GS_TRACE) {
|
|
fprintf(stderr,
|
|
"symbol %s claims RRS in %s%s\n",
|
|
sp->name, get_file_name(entry),
|
|
(sp->so_defined == (N_TEXT+N_EXT) &&
|
|
sp->flags & GS_HASJMPSLOT)?
|
|
" (JMPSLOT)":"");
|
|
}
|
|
if (sp->so_defined == (N_TEXT+N_EXT) &&
|
|
sp->flags & GS_HASJMPSLOT) {
|
|
/*
|
|
* Claim a jmpslot if one was allocated.
|
|
*
|
|
* At this point, a jmpslot can only
|
|
* result from a shared object reference
|
|
* while `force_alias' is in effect.
|
|
*/
|
|
relocation = addend +
|
|
claim_rrs_jmpslot(
|
|
entry, r, sp, addend);
|
|
} else {
|
|
r->r_address += dataseg?
|
|
entry->data_start_address:
|
|
entry->text_start_address;
|
|
relocation = addend;
|
|
if ((building_shared_object ||
|
|
sp->so_defined) &&
|
|
claim_rrs_reloc(entry, r, sp,
|
|
&relocation))
|
|
continue;
|
|
}
|
|
}
|
|
|
|
} 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:
|
|
errx(1, "%s: nonexternal relocation invalid",
|
|
get_file_name(entry));
|
|
}
|
|
|
|
/*
|
|
* When building a shared object, these segment
|
|
* relocations need a "load address relative"
|
|
* RRS fixup.
|
|
*/
|
|
if (building_shared_object && !RELOC_PCREL_P(r)) {
|
|
r->r_address += dataseg?
|
|
entry->data_start_address:
|
|
entry->text_start_address;
|
|
claim_rrs_segment_reloc(entry, r);
|
|
}
|
|
}
|
|
|
|
if (RELOC_PCREL_P(r))
|
|
relocation -= pc_relocation;
|
|
|
|
md_relocate(r, relocation, data+addr, relocatable_output);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* For relocatable_output only: write out the relocation,
|
|
* relocating the addresses-to-be-relocated.
|
|
*/
|
|
void
|
|
write_rel()
|
|
{
|
|
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->flags & GS_REFERENCED)
|
|
dynamic_symbol->symbolnum = count++;
|
|
FOR_EACH_SYMBOL(i, sp) {
|
|
if (sp == dynamic_symbol)
|
|
continue;
|
|
if (sp->warning)
|
|
count += 2;
|
|
if (!(sp->flags & GS_REFERENCED))
|
|
continue;
|
|
sp->symbolnum = count++;
|
|
if (sp->size)
|
|
count++;
|
|
if (sp->alias)
|
|
count++;
|
|
} END_EACH_SYMBOL;
|
|
|
|
if (count != global_sym_count)
|
|
errx(1, "internal error: write_rel: count = %d", count);
|
|
|
|
each_full_file(assign_symbolnums, &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");
|
|
}
|
|
|
|
|
|
/*
|
|
* Assign symbol ordinal numbers to local symbols in each entry.
|
|
*/
|
|
static void
|
|
assign_symbolnums(entry, countp)
|
|
struct file_entry *entry;
|
|
int *countp;
|
|
{
|
|
struct localsymbol *lsp, *lspend;
|
|
int n = *countp;
|
|
|
|
lspend = entry->symbols + entry->nsymbols;
|
|
|
|
if (discard_locals != DISCARD_ALL)
|
|
/* Count the N_FN symbol for this entry */
|
|
n++;
|
|
|
|
for (lsp = entry->symbols; lsp < lspend; lsp++) {
|
|
if (lsp->flags & LS_WRITE)
|
|
lsp->symbolnum = n++;
|
|
}
|
|
*countp = n;
|
|
}
|
|
|
|
static void
|
|
coptxtrel(entry)
|
|
struct file_entry *entry;
|
|
{
|
|
register struct relocation_info *r, *end;
|
|
register int reloc = entry->text_start_address;
|
|
|
|
r = entry->textrel;
|
|
end = r + entry->ntextrel;
|
|
|
|
for (; r < end; r++) {
|
|
register int symindex;
|
|
struct localsymbol *lsp;
|
|
symbol *sp;
|
|
|
|
RELOC_ADDRESS(r) += reloc;
|
|
|
|
symindex = RELOC_SYMBOL(r);
|
|
lsp = &entry->symbols[symindex];
|
|
|
|
if (!RELOC_EXTERN_P(r)) {
|
|
if (!pic_code_seen)
|
|
continue;
|
|
if (RELOC_BASEREL_P(r))
|
|
RELOC_SYMBOL(r) = lsp->symbolnum;
|
|
continue;
|
|
}
|
|
|
|
if (symindex >= entry->nsymbols)
|
|
errx(1, "%s: relocation symbolnum out of range",
|
|
get_file_name(entry));
|
|
|
|
sp = lsp->symbol;
|
|
|
|
#ifdef N_INDR
|
|
/* Resolve indirection. */
|
|
if ((sp->defined & ~N_EXT) == N_INDR) {
|
|
if (sp->alias == NULL)
|
|
errx(1, "internal error: alias in hyperspace");
|
|
sp = sp->alias;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* If the symbol is now defined, change the external
|
|
* relocation to an internal one.
|
|
*/
|
|
|
|
if (sp->defined) {
|
|
if (!pic_code_seen) {
|
|
RELOC_EXTERN_P(r) = 0;
|
|
RELOC_SYMBOL(r) = (sp->defined & N_TYPE);
|
|
} else
|
|
RELOC_SYMBOL(r) = sp->symbolnum;
|
|
#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, unless the symbol remains
|
|
* external in our output. Otherwise the work we
|
|
* did in this pass is lost.
|
|
*/
|
|
if (!RELOC_MEMORY_ADD_P(r) && !RELOC_EXTERN_P(r))
|
|
RELOC_ADD_EXTRA(r) += sp->value;
|
|
#endif
|
|
} else
|
|
/*
|
|
* Global symbols come first.
|
|
*/
|
|
RELOC_SYMBOL(r) = sp->symbolnum;
|
|
}
|
|
md_swapout_reloc(entry->textrel, entry->ntextrel);
|
|
mywrite(entry->textrel, entry->ntextrel,
|
|
sizeof(struct relocation_info), outstream);
|
|
}
|
|
|
|
static void
|
|
copdatrel(entry)
|
|
struct file_entry *entry;
|
|
{
|
|
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;
|
|
|
|
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)) {
|
|
if (RELOC_BASEREL_P(r))
|
|
errx(1, "%s: Unsupported relocation type",
|
|
get_file_name(entry));
|
|
continue;
|
|
}
|
|
|
|
symindex = RELOC_SYMBOL(r);
|
|
sp = entry->symbols[symindex].symbol;
|
|
|
|
if (symindex >= entry->header.a_syms)
|
|
errx(1, "%s: relocation symbolnum out of range",
|
|
get_file_name(entry));
|
|
|
|
#ifdef N_INDR
|
|
/* Resolve indirection. */
|
|
if ((sp->defined & ~N_EXT) == N_INDR) {
|
|
if (sp->alias == NULL)
|
|
errx(1, "internal error: alias in hyperspace");
|
|
sp = sp->alias;
|
|
}
|
|
#endif
|
|
|
|
symtype = sp->defined & N_TYPE;
|
|
|
|
if (!pic_code_seen && ( symtype == N_BSS ||
|
|
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;
|
|
}
|
|
md_swapout_reloc(entry->datarel, entry->ndatarel);
|
|
mywrite(entry->datarel, entry->ndatarel,
|
|
sizeof(struct relocation_info), outstream);
|
|
}
|
|
|
|
void write_file_syms __P((struct file_entry *, int *));
|
|
void write_string_table __P((void));
|
|
|
|
/* Offsets and current lengths of symbol and string tables in output file. */
|
|
|
|
static int symtab_offset;
|
|
static int symtab_len;
|
|
|
|
/* Address in output file where string table starts. */
|
|
static int strtab_offset;
|
|
|
|
/* Offset within string table
|
|
where the strings in `strtab_vector' should be written. */
|
|
static int strtab_len;
|
|
|
|
/* Total size of string table strings allocated so far,
|
|
including strings in `strtab_vector'. */
|
|
static int strtab_size;
|
|
|
|
/* Vector whose elements are strings to be added to the string table. */
|
|
static char **strtab_vector;
|
|
|
|
/* Vector whose elements are the lengths of those strings. */
|
|
static int *strtab_lens;
|
|
|
|
/* Index in `strtab_vector' at which the next string will be stored. */
|
|
static 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.
|
|
*/
|
|
|
|
static int
|
|
assign_string_table_index(name)
|
|
char *name;
|
|
{
|
|
register int index = strtab_size;
|
|
register int len = strlen(name) + 1;
|
|
|
|
strtab_size += len;
|
|
strtab_vector[strtab_index] = name;
|
|
strtab_lens[strtab_index++] = len;
|
|
|
|
return index;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
|
|
if (fseek(outstream, strtab_offset + strtab_len, SEEK_SET) != 0)
|
|
err(1, "write_string_table: %s: fseek", output_filename);
|
|
|
|
for (i = 0; i < strtab_index; i++) {
|
|
mywrite(strtab_vector[i], 1, strtab_lens[i], outstream);
|
|
strtab_len += strtab_lens[i];
|
|
}
|
|
}
|
|
|
|
/* Write the symbol table and string table of the output file. */
|
|
|
|
void
|
|
write_syms()
|
|
{
|
|
/* Number of symbols written so far. */
|
|
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(global_sym_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;
|
|
|
|
symtab_offset = N_SYMOFF(outheader);
|
|
symtab_len = 0;
|
|
strtab_offset = N_STROFF(outheader);
|
|
strtab_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((global_sym_count) * sizeof(char *));
|
|
strtab_lens = (int *)alloca((global_sym_count) * 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->flags & GS_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 &= ~N_EXT;
|
|
nl.n_value = dynamic_symbol->value;
|
|
nl.n_un.n_strx = assign_string_table_index(dynamic_symbol->name);
|
|
*bufp++ = nl;
|
|
syms_written++;
|
|
}
|
|
|
|
/* Scan the symbol hash table, bucket by bucket. */
|
|
|
|
FOR_EACH_SYMBOL(i, sp) {
|
|
|
|
if (sp == dynamic_symbol)
|
|
/* Already dealt with above */
|
|
continue;
|
|
|
|
/*
|
|
* Propagate N_WARNING symbols.
|
|
*/
|
|
if ((relocatable_output || building_shared_object)
|
|
&& sp->warning) {
|
|
nl.n_type = N_WARNING;
|
|
nl.n_un.n_strx = assign_string_table_index(sp->warning);
|
|
nl.n_value = 0;
|
|
nl.n_other = 0;
|
|
nl.n_desc = 0;
|
|
*bufp++ = nl;
|
|
syms_written++;
|
|
|
|
nl.n_type = N_UNDF + N_EXT;
|
|
nl.n_un.n_strx = assign_string_table_index(sp->name);
|
|
nl.n_value = 0;
|
|
nl.n_other = 0;
|
|
nl.n_desc = 0;
|
|
*bufp++ = nl;
|
|
syms_written++;
|
|
}
|
|
|
|
if (!(sp->flags & GS_REFERENCED))
|
|
/* Came from shared object but was not used */
|
|
continue;
|
|
|
|
if (sp->so_defined || (sp->alias && sp->alias->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)
|
|
continue;
|
|
if (!(sp->flags & GS_WEAK))
|
|
warnx("symbol %s remains undefined", sp->name);
|
|
}
|
|
|
|
if (syms_written >= global_sym_count)
|
|
errx(1,
|
|
"internal error: number of symbols exceeds alloc'd %d",
|
|
global_sym_count);
|
|
|
|
/*
|
|
* Construct a `struct nlist' for the symbol.
|
|
*/
|
|
nl.n_other = 0;
|
|
nl.n_desc = 0;
|
|
|
|
if (sp->defined > 1) {
|
|
/*
|
|
* defined with known type
|
|
*/
|
|
if (!relocatable_output && !building_shared_object &&
|
|
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_value = sp->alias->value;
|
|
nl.n_other = N_OTHER(0, sp->alias->aux);
|
|
} else {
|
|
int bind = 0;
|
|
|
|
if (sp->defined == N_SIZE)
|
|
nl.n_type = N_DATA | N_EXT;
|
|
else
|
|
nl.n_type = sp->defined;
|
|
if (nl.n_type == (N_INDR|N_EXT) &&
|
|
sp->value != 0)
|
|
errx(1, "%s: N_INDR has value %#x",
|
|
sp->name, sp->value);
|
|
nl.n_value = sp->value;
|
|
if (sp->def_lsp)
|
|
bind = N_BIND(&sp->def_lsp->nzlist.nlist);
|
|
nl.n_other = N_OTHER(bind, sp->aux);
|
|
}
|
|
|
|
} else if (sp->common_size) {
|
|
/*
|
|
* defined as common but not allocated,
|
|
* happens only with -r and not -d, write out
|
|
* a common definition.
|
|
*
|
|
* common condition needs to be before undefined
|
|
* condition because unallocated commons are set
|
|
* undefined in digest_symbols.
|
|
*/
|
|
nl.n_type = N_UNDF | N_EXT;
|
|
nl.n_value = sp->common_size;
|
|
} else if (!sp->defined) {
|
|
/* undefined -- legit only if -r */
|
|
nl.n_type = N_UNDF | N_EXT;
|
|
nl.n_value = 0;
|
|
} else
|
|
errx(1,
|
|
"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++;
|
|
|
|
/*
|
|
* Write second symbol of an alias pair.
|
|
*/
|
|
if (nl.n_type == N_INDR + N_EXT) {
|
|
if (sp->alias == NULL)
|
|
errx(1, "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;
|
|
nl.n_other = 0;
|
|
nl.n_desc = 0;
|
|
*bufp++ = nl;
|
|
syms_written++;
|
|
}
|
|
|
|
/*
|
|
* Write N_SIZE symbol for a symbol with a known size.
|
|
*/
|
|
if (relocatable_output && sp->size) {
|
|
nl.n_type = N_SIZE + N_EXT;
|
|
nl.n_un.n_strx = assign_string_table_index(sp->name);
|
|
nl.n_value = sp->size;
|
|
nl.n_other = 0;
|
|
nl.n_desc = 0;
|
|
*bufp++ = nl;
|
|
syms_written++;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printf("writesym(#%d): %s, type %x\n", syms_written, sp->name, sp->defined);
|
|
#endif
|
|
} END_EACH_SYMBOL;
|
|
|
|
if (syms_written != strtab_index || strtab_index != global_sym_count)
|
|
errx(1, "internal error: wrong number (%d) of global symbols "
|
|
"written into output file, should be %d",
|
|
syms_written, global_sym_count);
|
|
|
|
/* Output the buffer full of `struct nlist's. */
|
|
|
|
if (fseek(outstream, symtab_offset + symtab_len, SEEK_SET) != 0)
|
|
err(1, "write_syms: fseek");
|
|
md_swapout_symbols(buf, bufp - buf);
|
|
mywrite(buf, bufp - buf, sizeof(struct nlist), outstream);
|
|
symtab_len += sizeof(struct nlist) * (bufp - buf);
|
|
|
|
/* Write the strings for the global symbols. */
|
|
write_string_table();
|
|
|
|
/* Write the local symbols defined by the various files. */
|
|
each_file(write_file_syms, (void *)&syms_written);
|
|
file_close();
|
|
|
|
if (syms_written != nsyms)
|
|
errx(1, "internal error: wrong number of symbols (%d) "
|
|
"written into output file, should be %d",
|
|
syms_written, nsyms);
|
|
|
|
if (symtab_offset + symtab_len != strtab_offset)
|
|
errx(1,
|
|
"internal error: inconsistent symbol table length: %d vs %s",
|
|
symtab_offset + symtab_len, strtab_offset);
|
|
|
|
if (fseek(outstream, strtab_offset, SEEK_SET) != 0)
|
|
err(1, "write_syms: fseek");
|
|
strtab_size = md_swap_long(strtab_size);
|
|
mywrite(&strtab_size, sizeof(int), 1, outstream);
|
|
}
|
|
|
|
|
|
/*
|
|
* 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;
|
|
{
|
|
struct localsymbol *lsp, *lspend;
|
|
|
|
/* Upper bound on number of syms to be written here. */
|
|
int max_syms = entry->nsymbols + 1;
|
|
|
|
/*
|
|
* 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));
|
|
|
|
register struct nlist *bufp = buf;
|
|
|
|
if (entry->flags & E_DYNAMIC)
|
|
return;
|
|
|
|
/*
|
|
* 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)++;
|
|
}
|
|
/* 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;
|
|
char *name;
|
|
|
|
if (!(lsp->flags & LS_WRITE))
|
|
continue;
|
|
|
|
if (p->n_un.n_strx == 0)
|
|
name = NULL;
|
|
else if (!(lsp->flags & LS_RENAME))
|
|
name = p->n_un.n_strx + entry->strings;
|
|
else {
|
|
char *cp = p->n_un.n_strx + entry->strings;
|
|
name = (char *)alloca(
|
|
strlen(entry->local_sym_name) +
|
|
strlen(cp) + 2 );
|
|
(void)sprintf(name, "%s.%s", entry->local_sym_name, cp);
|
|
}
|
|
|
|
/*
|
|
* If this symbol has a name, allocate space for it
|
|
* in the output string table.
|
|
*/
|
|
|
|
if (name)
|
|
p->n_un.n_strx = assign_string_table_index(name);
|
|
|
|
/* Output this symbol to the buffer and count it. */
|
|
|
|
*bufp++ = *p;
|
|
(*syms_written_addr)++;
|
|
}
|
|
|
|
/* All the symbols are now in BUF; write them. */
|
|
|
|
if (fseek(outstream, symtab_offset + symtab_len, SEEK_SET) != 0)
|
|
err(1, "write local symbols: fseek");
|
|
md_swapout_symbols(buf, bufp - buf);
|
|
mywrite(buf, bufp - buf, sizeof(struct nlist), outstream);
|
|
symtab_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 disappear anyway. */
|
|
}
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
static int
|
|
parse(arg, format, error)
|
|
char *arg, *format, *error;
|
|
{
|
|
int x;
|
|
|
|
if (1 != sscanf(arg, format, &x))
|
|
errx(1, error, arg);
|
|
return x;
|
|
}
|
|
|
|
/*
|
|
* Output COUNT*ELTSIZE bytes of data at BUF to the descriptor FD.
|
|
*/
|
|
void
|
|
mywrite(buf, count, eltsize, fd)
|
|
void *buf;
|
|
int count;
|
|
int eltsize;
|
|
FILE *fd;
|
|
{
|
|
|
|
if (fwrite(buf, eltsize, count, fd) != count)
|
|
err(1, "write");
|
|
}
|
|
|
|
static void
|
|
cleanup()
|
|
{
|
|
struct stat statbuf;
|
|
|
|
if (outstream == 0)
|
|
return;
|
|
|
|
if (fstat(fileno(outstream), &statbuf) == 0) {
|
|
if (S_ISREG(statbuf.st_mode))
|
|
(void)unlink(output_filename);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Output PADDING zero-bytes to descriptor FD.
|
|
* PADDING may be negative; in that case, do nothing.
|
|
*/
|
|
void
|
|
padfile(padding, fd)
|
|
int padding;
|
|
FILE *fd;
|
|
{
|
|
register char *buf;
|
|
if (padding <= 0)
|
|
return;
|
|
|
|
buf = (char *)alloca(padding);
|
|
bzero(buf, padding);
|
|
mywrite(buf, padding, 1, fd);
|
|
}
|