-/* Copyright (C) 1991 Free Software Foundation, Inc.
-
+/* ldwrite.c -- write out the linked file
+ Copyright (C) 1993 Free Software Foundation, Inc.
+
This file is part of GLD, the Gnu Linker.
-GLD is free software; you can redistribute it and/or modify
+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.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GLD is distributed in the hope that it will be useful,
+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 GLD; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/*
- * $Id$
- *
- * $Log$
- * Revision 1.3 1991/03/22 22:32:22 steve
- * *** empty log message ***
- *
- * Revision 1.2 1991/03/22 22:31:37 steve
- * *** empty log message ***
- *
- * Revision 1.1.1.1 1991/03/21 21:29:05 gumby
- * Back from Intel with Steve
- *
- * Revision 1.1 1991/03/21 21:29:04 gumby
- * Initial revision
- *
- * Revision 1.2 1991/03/15 18:45:55 rich
- * foo
- *
- * Revision 1.1 1991/03/13 00:48:37 chrisb
- * Initial revision
- *
- * Revision 1.7 1991/03/10 19:15:03 sac
- * Took out the abort() which had been put in the wrong place
- * Updated the version #.
- *
- * Revision 1.6 1991/03/10 09:31:41 rich
- * Modified Files:
- * Makefile config.h ld-emul.c ld-emul.h ld-gld.c ld-gld960.c
- * ld-lnk960.c ld.h lddigest.c ldexp.c ldexp.h ldfile.c ldfile.h
- * ldgram.y ldinfo.h ldlang.c ldlang.h ldlex.h ldlex.l ldmain.c
- * ldmain.h ldmisc.c ldmisc.h ldsym.c ldsym.h ldversion.c
- * ldversion.h ldwarn.h ldwrite.c ldwrite.h y.tab.h
- *
- * As of this round of changes, ld now builds on all hosts of (Intel960)
- * interest and copy passes my copy test on big endian hosts again.
- *
- * Revision 1.5 1991/03/09 03:25:08 sac
- * Added support for LONG, SHORT and BYTE keywords in scripts
- *
- * Revision 1.4 1991/03/06 21:59:34 sac
- * Completed G++ support
- *
- * Revision 1.3 1991/03/06 02:29:52 sac
- * Added support for partial linking.
- *
- * Revision 1.2 1991/02/22 17:15:11 sac
- * Added RCS keywords and copyrights
- *
-*/
-
-/*
- 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.
-
-
-*/
-
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include "sysdep.h"
#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
-#include "ldlang.h"
#include "ld.h"
+#include "ldexp.h"
+#include "ldlang.h"
#include "ldwrite.h"
#include "ldmisc.h"
-#include "ldsym.h"
-#include "ldgram.tab.h"
-
-
-
-char *ldmalloc();
-/* 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;
+#include "ldgram.h"
+#include "ldmain.h"
-extern struct lang_output_section_statement_struct * create_object_symbols;
+static void build_link_order PARAMS ((lang_statement_union_type *));
+static void print_symbol_table PARAMS ((void));
+static void print_file_stuff PARAMS ((lang_input_statement_type *));
+static boolean print_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
-extern char lprefix;
+/* Build link_order structures for the BFD linker. */
-#ifdef __STDC__
-void lang_for_each_statement(void (*func)());
-#else /* __STDC__ */
-void lang_for_each_statement();
-#endif /* __STDC__ */
-
-extern size_t largest_section;
-ld_config_type config;
-
-extern unsigned int global_symbol_count;
-
-boolean trace_files;
-
-static void perform_relocation(input_bfd,
- input_section,
- data,
- symbols)
-bfd *input_bfd;
-asection *input_section;
-void *data;
-asymbol **symbols;
+static void
+build_link_order (statement)
+ lang_statement_union_type *statement;
{
- static asymbol *error_symbol = (asymbol *)NULL;
- static unsigned int error_count = 0;
-#define MAX_ERRORS_IN_A_ROW 5
- size_t reloc_size = get_reloc_upper_bound(input_bfd, input_section);
-
- 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;
-
- if (bfd_canonicalize_reloc(input_bfd,
- input_section,
- reloc_vector,
- symbols) )
+ switch (statement->header.type)
{
- for (parent = reloc_vector; *parent; parent++)
- {
+ case lang_data_statement_enum:
+ /* FIXME: This should probably build a link_order, but instead
+ it just does the output directly. */
+ {
+ bfd_vma value = statement->data_statement.value;
+ bfd_byte play_area[QUAD_SIZE];
+ unsigned int size = 0;
+ asection *output_section = statement->data_statement.output_section;
+
+ ASSERT (output_section->owner == output_bfd);
+ switch (statement->data_statement.type)
+ {
+ case QUAD:
+ bfd_put_64 (output_bfd, value, play_area);
+ size = QUAD_SIZE;
+ break;
+ case LONG:
+ bfd_put_32 (output_bfd, value, play_area);
+ size = LONG_SIZE;
+ break;
+ case SHORT:
+ bfd_put_16 (output_bfd, value, play_area);
+ size = SHORT_SIZE;
+ break;
+ case BYTE:
+ bfd_put_8 (output_bfd, value, play_area);
+ size = BYTE_SIZE;
+ break;
+ default:
+ abort ();
+ }
- bfd_reloc_status_enum_type r=
- 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 */
- os->orelocation[os->reloc_count] = *parent;
- os->reloc_count++;
- }
+ if (! bfd_set_section_contents (output_bfd, output_section,
+ play_area,
+ statement->data_statement.output_vma,
+ size))
+ einfo ("%P%X: writing data failed: %E\n");
+ }
+ break;
+
+ case lang_reloc_statement_enum:
+ {
+ lang_reloc_statement_type *rs;
+ asection *output_section;
+ struct bfd_link_order *link_order;
+
+ rs = &statement->reloc_statement;
+
+ output_section = rs->output_section;
+ ASSERT (output_section->owner == output_bfd);
+
+ link_order = bfd_new_link_order (output_bfd, output_section);
+ if (link_order == NULL)
+ einfo ("%P%F: bfd_new_link_order failed");
+
+ link_order->offset = rs->output_vma;
+ link_order->size = bfd_get_reloc_size (rs->howto);
+
+ link_order->u.reloc.p =
+ ((struct bfd_link_order_reloc *)
+ xmalloc (sizeof (struct bfd_link_order_reloc)));
+
+ link_order->u.reloc.p->reloc = rs->reloc;
+ link_order->u.reloc.p->addend = rs->addend_value;
+
+ if (rs->section != (asection *) NULL)
+ {
+ ASSERT (rs->name == (const char *) NULL);
+ link_order->type = bfd_section_reloc_link_order;
+ if (rs->section->owner == output_bfd)
+ link_order->u.reloc.p->u.section = rs->section;
+ else
+ {
+ link_order->u.reloc.p->u.section = rs->section->output_section;
+ link_order->u.reloc.p->addend += rs->section->output_offset;
+ }
}
- else
+ else
+ {
+ ASSERT (rs->name != (const char *) NULL);
+ link_order->type = bfd_symbol_reloc_link_order;
+ link_order->u.reloc.p->u.name = rs->name;
+ }
+ }
+ break;
+
+ case lang_input_section_enum:
+ /* Create a new link_order in the output section with this
+ attached */
+ if (statement->input_section.ifile->just_syms_flag == false)
+ {
+ asection *i = statement->input_section.section;
+ asection *output_section = i->output_section;
+
+ ASSERT (output_section->owner == output_bfd);
+
+ if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
{
- asymbol *s;
- arelent *p = *parent;
+ struct bfd_link_order *link_order;
- if (ob != (bfd *)NULL) {
- /* A parital link, so keep the relocs */
- os->orelocation[os->reloc_count] = *parent;
- os->reloc_count++;
- }
+ link_order = bfd_new_link_order (output_bfd, output_section);
- if (p->sym_ptr_ptr != (asymbol **)NULL) {
- s = *(p->sym_ptr_ptr);
- }
- else {
- s = (asymbol *)NULL;
- }
- switch (r)
+ if (i->flags & SEC_NEVER_LOAD)
+ {
+ /* We've got a never load section inside one which
+ is going to be output, we'll change it into a
+ fill link_order */
+ link_order->type = bfd_fill_link_order;
+ link_order->u.fill.value = 0;
+ }
+ else
{
- 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) {
- info("%C: undefined reference to `%T'\n",
- input_bfd,
- input_section,
- symbols,
- (*parent)->address,
- s);
- config.make_executable = false;
- }
- else if (error_count == MAX_ERRORS_IN_A_ROW) {
- info("%C: more undefined references to `%T' follow\n",
- input_bfd,
- input_section,
- symbols,
- (*parent)->address,
- s);
- }
- else {
- /* Don't print any more */
- }
- break;
- case bfd_reloc_dangerous:
- info("%B: relocation may be wrong `%T'\n",
- input_bfd,
- s);
- break;
- case bfd_reloc_outofrange:
- info("%B:%s relocation address out of range %T (%x)\n",
- input_bfd,
- input_section->name,
- s,
- p->address);
- break;
- case bfd_reloc_overflow:
- info("%B:%s relocation overflow in %T reloc type %d\n",
- input_bfd,
- input_section->name,
- s,
- p->howto->type);
- break;
- default:
- info("%F%B: relocation error, symbol `%T'\n",
- input_bfd,
- s);
- break;
+ link_order->type = bfd_indirect_link_order;
+ link_order->u.indirect.section = i;
+ ASSERT (i->output_section == output_section);
}
+ if (i->_cooked_size)
+ link_order->size = i->_cooked_size;
+ else
+ link_order->size = bfd_get_section_size_before_reloc (i);
+ link_order->offset = i->output_offset;
}
}
+ break;
+
+ case lang_padding_statement_enum:
+ /* Make a new link_order with the right filler */
+ {
+ asection *output_section;
+ struct bfd_link_order *link_order;
+
+ output_section = statement->padding_statement.output_section;
+ ASSERT (statement->padding_statement.output_section->owner
+ == output_bfd);
+ if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
+ {
+ link_order = bfd_new_link_order (output_bfd, output_section);
+ link_order->type = bfd_fill_link_order;
+ link_order->size = statement->padding_statement.size;
+ link_order->offset = statement->padding_statement.output_offset;
+ link_order->u.fill.value = statement->padding_statement.fill;
+ }
+ }
+ break;
+
+ default:
+ /* All the other ones fall through */
+ break;
}
- free((char *)reloc_vector);
}
+/* Call BFD to write out the linked file. */
+void
+ldwrite ()
+{
+ lang_for_each_statement (build_link_order);
+ if (! bfd_final_link (output_bfd, &link_info))
+ einfo ("%F%P: final link failed: %E\n", output_bfd);
+ if (config.map_file)
+ {
+ print_symbol_table ();
+ lang_map ();
+ }
+}
-
-void *data_area;
+/* Print the symbol table. */
static void
-copy_and_relocate(statement)
-lang_statement_union_type *statement;
+print_symbol_table ()
{
- switch (statement->header.type) {
- case lang_fill_statement_enum:
- {
-#if 0
- 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);
+ fprintf (config.map_file, "**FILES**\n\n");
+ lang_for_each_file (print_file_stuff);
- }
+ fprintf (config.map_file, "**GLOBAL SYMBOLS**\n\n");
+ fprintf (config.map_file, "offset section offset symbol\n");
+ bfd_link_hash_traverse (link_info.hash, print_symbol, (PTR) NULL);
+}
- /* 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);
+/* Print information about a file. */
- }
-#endif
- }
- break;
- case lang_data_statement_enum:
+static void
+print_file_stuff (f)
+ lang_input_statement_type * f;
+{
+ fprintf (config.map_file, " %s\n", f->filename);
+ if (f->just_syms_flag)
{
- bfd_vma value = statement->data_statement.value;
- bfd_byte play_area[LONG_SIZE];
- unsigned int size;
- switch (statement->data_statement.type) {
- case LONG:
- bfd_putlong(output_bfd, value, play_area);
- size = LONG_SIZE;
- break;
- case SHORT:
- bfd_putshort(output_bfd, value, play_area);
- size = SHORT_SIZE;
- break;
- case BYTE:
- bfd_putchar(output_bfd, value, play_area);
- size = BYTE_SIZE;
- break;
- }
-
- bfd_set_section_contents(output_bfd,
- statement->data_statement.output_section,
- play_area,
- statement->data_statement.output_vma,
- size);
-
-
-
-
+ fprintf (config.map_file, " symbols only\n");
}
- break;
- case lang_input_section_enum:
+ else
{
-
- asection *i = statement->input_section.section;
- asection *output_section = i->output_section;
- lang_input_statement_type *ifile = statement->input_section.ifile;
- bfd *inbfd = ifile->the_bfd;
- if (output_section->flags & SEC_LOAD && i->size != 0)
+ asection *s;
+ if (true)
{
- if(bfd_get_section_contents(inbfd,
- i,
- data_area,
- 0L,
- i->size) == false)
+ for (s = f->the_bfd->sections;
+ s != (asection *) NULL;
+ s = s->next)
{
- info("%F%B error reading section contents %E\n",
- inbfd);
- }
- perform_relocation (inbfd, i, data_area, ifile->asymbols);
-
+ print_address (s->output_offset);
+ if (s->reloc_done)
+ {
+ fprintf (config.map_file, " %08x 2**%2ud %s\n",
+ (unsigned) bfd_get_section_size_after_reloc (s),
+ s->alignment_power, s->name);
+ }
- if(bfd_set_section_contents(output_bfd,
- output_section,
- data_area,
- (file_ptr)i->output_offset,
- i->size) == false)
+ else
+ {
+ fprintf (config.map_file, " %08x 2**%2ud %s\n",
+ (unsigned) bfd_get_section_size_before_reloc (s),
+ s->alignment_power, s->name);
+ }
+ }
+ }
+ else
+ {
+ for (s = f->the_bfd->sections;
+ s != (asection *) NULL;
+ s = s->next)
{
- info("%F%B error writing section contents of %E\n",
- output_bfd);
+ fprintf (config.map_file, "%s ", s->name);
+ print_address (s->output_offset);
+ fprintf (config.map_file, "(%x)",
+ (unsigned) bfd_get_section_size_after_reloc (s));
}
-
+ fprintf (config.map_file, "hex \n");
}
}
- break;
-
- default:
- /* All the other ones fall through */
- ;
-
- }
-}
-
-void
-write_norel()
-{
- /* Output the text and data segments, relocating as we go. */
- lang_for_each_statement(copy_and_relocate);
-}
-
-
-static void read_relocs(abfd, section, symbols)
-bfd *abfd;
-asection *section;
-asymbol **symbols;
-{
- /* Work out the output section ascociated with this input section */
- asection *output_section = section->output_section;
-
- size_t reloc_size = get_reloc_upper_bound(abfd, section);
- arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
-
- if (bfd_canonicalize_reloc(abfd,
- section,
- reloc_vector,
- symbols)) {
- output_section->reloc_count += section->reloc_count;
- }
+ print_nl ();
}
+/* Print a symbol. */
-static void
-write_rel()
+/*ARGSUSED*/
+static boolean
+print_symbol (p, ignore)
+ struct bfd_link_hash_entry *p;
+ PTR ignore;
{
- /*
- 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 =
- (arelent **)ldmalloc((size_t)(sizeof(arelent **)*
- 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);
-}
+ while (p->type == bfd_link_hash_indirect
+ || p->type == bfd_link_hash_warning)
+ p = p->u.i.link;
-void
-ldwrite ()
-{
- data_area = (void*) ldmalloc(largest_section);
- if (config.relocateable_output == true)
+ switch (p->type)
{
- write_rel();
+ case bfd_link_hash_new:
+ abort ();
+
+ case bfd_link_hash_undefined:
+ fprintf (config.map_file, "undefined ");
+ fprintf (config.map_file, "%s ", p->root.string);
+ print_nl ();
+ break;
+
+ case bfd_link_hash_weak:
+ fprintf (config.map_file, "weak ");
+ fprintf (config.map_file, "%s ", p->root.string);
+ print_nl ();
+ break;
+
+ case bfd_link_hash_defined:
+ {
+ asection *defsec = p->u.def.section;
+
+ print_address (p->u.def.value);
+ if (defsec)
+ {
+ fprintf (config.map_file, " %-10s",
+ bfd_section_name (output_bfd, defsec));
+ print_space ();
+ print_address (p->u.def.value + defsec->vma);
+ }
+ else
+ {
+ fprintf (config.map_file, " .......");
+ }
+ fprintf (config.map_file, " %s ", p->root.string);
+ }
+ print_nl ();
+ break;
+
+ case bfd_link_hash_common:
+ fprintf (config.map_file, "common ");
+ print_address (p->u.c.size);
+ fprintf (config.map_file, " %s ", p->root.string);
+ print_nl ();
+ break;
+
+ default:
+ abort ();
}
- else
- {
- write_norel();
- }
- free(data_area);
- /* Output the symbol table (both globals and locals). */
- ldsym_write ();
+ return true;
}
-
projects / binutils.git / blobdiff