1991-03-21 21:29:06 +00:00
|
|
|
/* Copyright (C) 1991 Free Software Foundation, Inc.
|
|
|
|
|
|
|
|
This file is part of GLD, the Gnu Linker.
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
This program is free software; you can redistribute it and/or modify
|
1991-03-21 21:29:06 +00:00
|
|
|
it under the terms of the GNU General Public License as published by
|
1992-01-24 22:34:34 +00:00
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
1991-03-21 21:29:06 +00:00
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
This program is distributed in the hope that it will be useful,
|
1991-03-21 21:29:06 +00:00
|
|
|
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
|
1992-01-24 22:34:34 +00:00
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
1991-03-21 21:29:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* $Id$
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
This module writes out the final image by reading sections from the
|
|
|
|
input files, relocating them and writing them out
|
|
|
|
|
|
|
|
There are two main paths through this module, one for normal
|
|
|
|
operation and one for partial linking.
|
|
|
|
|
|
|
|
During normal operation, raw section data is read along with the
|
|
|
|
associated relocation information, the relocation info applied and
|
|
|
|
the section data written out on a section by section basis.
|
|
|
|
|
|
|
|
When partially linking, all the relocation records are read to work
|
|
|
|
out how big the output relocation vector will be. Then raw data is
|
|
|
|
read, relocated and written section by section.
|
|
|
|
|
|
|
|
Written by Steve Chamberlain steve@cygnus.com
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include "bfd.h"
|
1992-01-24 22:34:34 +00:00
|
|
|
#include "sysdep.h"
|
1991-03-21 21:29:06 +00:00
|
|
|
|
|
|
|
#include "ldlang.h"
|
|
|
|
#include "ld.h"
|
|
|
|
#include "ldwrite.h"
|
|
|
|
#include "ldmisc.h"
|
|
|
|
#include "ldsym.h"
|
1992-01-24 22:34:34 +00:00
|
|
|
#include "ldgram.h"
|
|
|
|
|
1991-03-21 21:29:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Static vars for do_warnings and subroutines of it */
|
|
|
|
int list_unresolved_refs; /* List unresolved refs */
|
|
|
|
int list_warning_symbols; /* List warning syms */
|
|
|
|
int list_multiple_defs; /* List multiple definitions */
|
|
|
|
extern int errno;
|
|
|
|
extern char *sys_errlist[];
|
|
|
|
|
|
|
|
extern unsigned int undefined_global_sym_count;
|
|
|
|
|
|
|
|
extern bfd *output_bfd;
|
|
|
|
|
|
|
|
extern struct lang_output_section_statement_struct * create_object_symbols;
|
|
|
|
|
|
|
|
extern char lprefix;
|
|
|
|
|
|
|
|
#ifdef __STDC__
|
|
|
|
void lang_for_each_statement(void (*func)());
|
|
|
|
#else /* __STDC__ */
|
|
|
|
void lang_for_each_statement();
|
|
|
|
#endif /* __STDC__ */
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
extern bfd_size_type largest_section;
|
1991-03-21 21:29:06 +00:00
|
|
|
ld_config_type config;
|
|
|
|
|
|
|
|
extern unsigned int global_symbol_count;
|
|
|
|
|
|
|
|
boolean trace_files;
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
static void
|
|
|
|
DEFUN(perform_relocation,(input_bfd,
|
|
|
|
input_section,
|
|
|
|
data,
|
|
|
|
symbols),
|
|
|
|
bfd *input_bfd AND
|
|
|
|
asection *input_section AND
|
|
|
|
PTR data AND
|
|
|
|
asymbol **symbols)
|
1991-03-21 21:29:06 +00:00
|
|
|
{
|
|
|
|
static asymbol *error_symbol = (asymbol *)NULL;
|
|
|
|
static unsigned int error_count = 0;
|
|
|
|
#define MAX_ERRORS_IN_A_ROW 5
|
1992-01-24 22:34:34 +00:00
|
|
|
bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd, input_section);
|
1991-03-21 21:29:06 +00:00
|
|
|
|
|
|
|
arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
|
|
|
|
arelent **parent;
|
|
|
|
bfd *ob = output_bfd;
|
|
|
|
asection *os = input_section->output_section;
|
|
|
|
if (config.relocateable_output == false) ob = (bfd *)NULL;
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
input_section->_cooked_size = input_section->_raw_size;
|
|
|
|
input_section->reloc_done = 1;
|
|
|
|
|
1991-03-21 21:29:06 +00:00
|
|
|
if (bfd_canonicalize_reloc(input_bfd,
|
|
|
|
input_section,
|
|
|
|
reloc_vector,
|
|
|
|
symbols) )
|
|
|
|
{
|
|
|
|
for (parent = reloc_vector; *parent; parent++)
|
|
|
|
{
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
bfd_reloc_status_type r=
|
1991-03-21 21:29:06 +00:00
|
|
|
bfd_perform_relocation(input_bfd,
|
|
|
|
*parent,
|
|
|
|
data,
|
|
|
|
input_section,
|
|
|
|
ob);
|
|
|
|
|
|
|
|
if (r == bfd_reloc_ok) {
|
|
|
|
if (ob != (bfd *)NULL) {
|
|
|
|
/* A parital link, so keep the relocs */
|
1992-01-24 22:34:34 +00:00
|
|
|
|
|
|
|
/* Add to each relocation the offset of where it lives
|
|
|
|
in the output section */
|
|
|
|
/* (*parent)->address += input_section->output_offset;*/
|
|
|
|
|
1991-03-21 21:29:06 +00:00
|
|
|
os->orelocation[os->reloc_count] = *parent;
|
|
|
|
os->reloc_count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
asymbol *s;
|
|
|
|
arelent *p = *parent;
|
|
|
|
|
|
|
|
if (ob != (bfd *)NULL) {
|
|
|
|
/* A parital link, so keep the relocs */
|
|
|
|
os->orelocation[os->reloc_count] = *parent;
|
|
|
|
os->reloc_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p->sym_ptr_ptr != (asymbol **)NULL) {
|
|
|
|
s = *(p->sym_ptr_ptr);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
s = (asymbol *)NULL;
|
|
|
|
}
|
|
|
|
switch (r)
|
|
|
|
{
|
|
|
|
case bfd_reloc_undefined:
|
|
|
|
/* We remember the symbol, and never print more than
|
|
|
|
a reasonable number of them in a row */
|
|
|
|
if (s == error_symbol) {
|
|
|
|
error_count++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
error_count = 0;
|
|
|
|
error_symbol = s;
|
|
|
|
}
|
|
|
|
if (error_count < MAX_ERRORS_IN_A_ROW) {
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%C: undefined reference to `%T'\n",
|
|
|
|
input_bfd, input_section, symbols,
|
|
|
|
(*parent)->address, s);
|
1991-03-21 21:29:06 +00:00
|
|
|
config.make_executable = false;
|
|
|
|
}
|
|
|
|
else if (error_count == MAX_ERRORS_IN_A_ROW) {
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%C: more undefined references to `%T' follow\n",
|
|
|
|
input_bfd, input_section,
|
|
|
|
symbols, (*parent)->address, s);
|
1991-03-21 21:29:06 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Don't print any more */
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case bfd_reloc_dangerous:
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%B: relocation may be wrong `%T'\n",
|
|
|
|
input_bfd, s);
|
1991-03-21 21:29:06 +00:00
|
|
|
break;
|
|
|
|
case bfd_reloc_outofrange:
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%B:%s relocation address out of range %T (%V)\n",
|
|
|
|
input_bfd, input_section->name, s, p->address);
|
1991-03-21 21:29:06 +00:00
|
|
|
break;
|
|
|
|
case bfd_reloc_overflow:
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%B:%s relocation overflow in %T reloc type %d\n",
|
|
|
|
input_bfd, input_section->name, s, p->howto->type);
|
1991-03-21 21:29:06 +00:00
|
|
|
break;
|
|
|
|
default:
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%F%B: relocation error, symbol `%T'\n",
|
|
|
|
input_bfd, s);
|
1991-03-21 21:29:06 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free((char *)reloc_vector);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1991-04-15 15:27:15 +00:00
|
|
|
PTR data_area;
|
1991-03-21 21:29:06 +00:00
|
|
|
|
|
|
|
static void
|
1992-01-24 22:34:34 +00:00
|
|
|
DEFUN(copy_and_relocate,(statement),
|
|
|
|
lang_statement_union_type *statement)
|
1991-03-21 21:29:06 +00:00
|
|
|
{
|
|
|
|
switch (statement->header.type) {
|
|
|
|
case lang_fill_statement_enum:
|
1991-04-14 03:22:42 +00:00
|
|
|
{
|
1991-03-21 21:29:06 +00:00
|
|
|
#if 0
|
1991-04-15 15:27:15 +00:00
|
|
|
bfd_byte play_area[SHORT_SIZE];
|
|
|
|
unsigned int i;
|
|
|
|
bfd_putshort(output_bfd, statement->fill_statement.fill, play_area);
|
|
|
|
/* Write out all entire shorts */
|
|
|
|
for (i = 0;
|
|
|
|
i < statement->fill_statement.size - SHORT_SIZE + 1;
|
|
|
|
i+= SHORT_SIZE)
|
|
|
|
{
|
|
|
|
bfd_set_section_contents(output_bfd,
|
|
|
|
statement->fill_statement.output_section,
|
|
|
|
play_area,
|
|
|
|
statement->data_statement.output_offset +i,
|
|
|
|
SHORT_SIZE);
|
1991-03-21 21:29:06 +00:00
|
|
|
|
1991-04-15 15:27:15 +00:00
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
|
1991-04-15 15:27:15 +00:00
|
|
|
/* Now write any remaining byte */
|
|
|
|
if (i < statement->fill_statement.size)
|
|
|
|
{
|
|
|
|
bfd_set_section_contents(output_bfd,
|
|
|
|
statement->fill_statement.output_section,
|
|
|
|
play_area,
|
|
|
|
statement->data_statement.output_offset +i,
|
|
|
|
1);
|
1991-03-21 21:29:06 +00:00
|
|
|
|
1991-04-15 15:27:15 +00:00
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
#endif
|
1991-04-15 15:27:15 +00:00
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
break;
|
|
|
|
case lang_data_statement_enum:
|
1991-04-15 15:27:15 +00:00
|
|
|
{
|
|
|
|
bfd_vma value = statement->data_statement.value;
|
|
|
|
bfd_byte play_area[LONG_SIZE];
|
1992-01-24 22:34:34 +00:00
|
|
|
unsigned int size = 0;
|
1991-04-15 15:27:15 +00:00
|
|
|
switch (statement->data_statement.type) {
|
|
|
|
case LONG:
|
1992-01-24 22:34:34 +00:00
|
|
|
bfd_put_32(output_bfd, value, play_area);
|
1991-04-15 15:27:15 +00:00
|
|
|
size = LONG_SIZE;
|
|
|
|
break;
|
|
|
|
case SHORT:
|
1992-01-24 22:34:34 +00:00
|
|
|
bfd_put_16(output_bfd, value, play_area);
|
1991-04-15 15:27:15 +00:00
|
|
|
size = SHORT_SIZE;
|
|
|
|
break;
|
|
|
|
case BYTE:
|
1992-01-24 22:34:34 +00:00
|
|
|
bfd_put_8(output_bfd, value, play_area);
|
1991-04-15 15:27:15 +00:00
|
|
|
size = BYTE_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
|
1991-04-15 15:27:15 +00:00
|
|
|
bfd_set_section_contents(output_bfd,
|
|
|
|
statement->data_statement.output_section,
|
|
|
|
play_area,
|
|
|
|
statement->data_statement.output_vma,
|
|
|
|
size);
|
1991-03-21 21:29:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1991-04-15 15:27:15 +00:00
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
break;
|
|
|
|
case lang_input_section_enum:
|
1991-04-14 03:22:42 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
asection *i = statement->input_section.section;
|
|
|
|
asection *output_section = i->output_section;
|
|
|
|
lang_input_statement_type *ifile =
|
|
|
|
statement->input_section.ifile;
|
|
|
|
if (ifile->just_syms_flag == false) {
|
|
|
|
bfd *inbfd = ifile->the_bfd;
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
if (output_section->flags & SEC_LOAD &&
|
|
|
|
output_section->flags & SEC_ALLOC
|
|
|
|
&& bfd_get_section_size_before_reloc(i) != 0)
|
1991-04-14 03:22:42 +00:00
|
|
|
{
|
|
|
|
if(bfd_get_section_contents(inbfd,
|
|
|
|
i,
|
|
|
|
data_area,
|
1992-01-24 22:34:34 +00:00
|
|
|
(file_ptr)0,
|
|
|
|
bfd_get_section_size_before_reloc(i)) == false)
|
1991-04-14 03:22:42 +00:00
|
|
|
{
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%F%B error reading section contents %E\n", inbfd);
|
1991-04-14 03:22:42 +00:00
|
|
|
}
|
1992-01-24 22:34:34 +00:00
|
|
|
/* Set the reloc bit */
|
1991-04-14 03:22:42 +00:00
|
|
|
perform_relocation (inbfd, i, data_area, ifile->asymbols);
|
|
|
|
|
|
|
|
|
|
|
|
if(bfd_set_section_contents(output_bfd,
|
|
|
|
output_section,
|
|
|
|
data_area,
|
|
|
|
(file_ptr)i->output_offset,
|
1992-01-24 22:34:34 +00:00
|
|
|
bfd_get_section_size_after_reloc(i)) == false)
|
1991-04-14 03:22:42 +00:00
|
|
|
{
|
1992-01-24 22:34:34 +00:00
|
|
|
einfo("%F%B error writing section contents of %E\n",
|
|
|
|
output_bfd);
|
1991-04-14 03:22:42 +00:00
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
|
1991-04-14 03:22:42 +00:00
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
}
|
1991-04-14 03:22:42 +00:00
|
|
|
|
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
break;
|
|
|
|
|
1991-04-14 03:22:42 +00:00
|
|
|
default:
|
1991-03-21 21:29:06 +00:00
|
|
|
/* All the other ones fall through */
|
|
|
|
;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1992-01-24 22:34:34 +00:00
|
|
|
DEFUN_VOID(write_norel)
|
1991-03-21 21:29:06 +00:00
|
|
|
{
|
|
|
|
/* Output the text and data segments, relocating as we go. */
|
|
|
|
lang_for_each_statement(copy_and_relocate);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
static void
|
|
|
|
DEFUN(read_relocs,(abfd, section, symbols),
|
|
|
|
bfd *abfd AND
|
|
|
|
asection *section AND
|
|
|
|
asymbol **symbols)
|
1991-03-21 21:29:06 +00:00
|
|
|
{
|
|
|
|
/* Work out the output section ascociated with this input section */
|
|
|
|
asection *output_section = section->output_section;
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
bfd_size_type reloc_size = bfd_get_reloc_upper_bound(abfd, section);
|
1991-03-21 21:29:06 +00:00
|
|
|
arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
|
|
|
|
|
|
|
|
if (bfd_canonicalize_reloc(abfd,
|
|
|
|
section,
|
|
|
|
reloc_vector,
|
|
|
|
symbols)) {
|
|
|
|
output_section->reloc_count += section->reloc_count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1992-01-24 22:34:34 +00:00
|
|
|
static void
|
|
|
|
DEFUN_VOID(write_rel)
|
1991-03-21 21:29:06 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
Run through each section of each file and work work out the total
|
|
|
|
number of relocation records which will finally be in each output
|
|
|
|
section
|
|
|
|
*/
|
|
|
|
|
|
|
|
LANG_FOR_EACH_INPUT_SECTION
|
|
|
|
(statement, abfd, section,
|
|
|
|
(read_relocs(abfd, section, statement->asymbols)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Now run though all the output sections and allocate the space for
|
|
|
|
all the relocations
|
|
|
|
*/
|
|
|
|
LANG_FOR_EACH_OUTPUT_SECTION
|
|
|
|
(section,
|
|
|
|
(section->orelocation =
|
1992-01-24 22:34:34 +00:00
|
|
|
(arelent **)ldmalloc((bfd_size_type)(sizeof(arelent **)*
|
1991-03-21 21:29:06 +00:00
|
|
|
section->reloc_count)),
|
|
|
|
section->reloc_count = 0,
|
|
|
|
section->flags |= SEC_HAS_CONTENTS));
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Copy the data, relocating as we go
|
|
|
|
*/
|
|
|
|
lang_for_each_statement(copy_and_relocate);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1992-01-24 23:44:10 +00:00
|
|
|
DEFUN_VOID(ldwrite)
|
1991-03-21 21:29:06 +00:00
|
|
|
{
|
1991-04-15 15:27:15 +00:00
|
|
|
data_area = (PTR) ldmalloc(largest_section);
|
1991-03-21 21:29:06 +00:00
|
|
|
if (config.relocateable_output == true)
|
1992-01-24 22:34:34 +00:00
|
|
|
{
|
|
|
|
write_rel();
|
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
else
|
1992-01-24 22:34:34 +00:00
|
|
|
{
|
|
|
|
write_relaxnorel(output_bfd);
|
|
|
|
}
|
1991-03-21 21:29:06 +00:00
|
|
|
free(data_area);
|
|
|
|
/* Output the symbol table (both globals and locals). */
|
1992-01-24 22:34:34 +00:00
|
|
|
|
|
|
|
/* Print a map, if requested. */
|
|
|
|
|
1992-01-24 23:44:10 +00:00
|
|
|
if (config.map_file) {
|
1992-01-24 22:34:34 +00:00
|
|
|
ldsym_print_symbol_table ();
|
1992-01-24 23:44:10 +00:00
|
|
|
lang_map();
|
1992-01-24 22:34:34 +00:00
|
|
|
}
|
|
|
|
|
1991-03-21 21:29:06 +00:00
|
|
|
ldsym_write ();
|
|
|
|
|
|
|
|
}
|
|
|
|
|