/* ldwrite.c -- write out the linked file
- Copyright (C) 1993 Free Software Foundation, Inc.
+ Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2002
+ Free Software Foundation, Inc.
Written by Steve Chamberlain sac@cygnus.com
This file is part of GLD, the Gnu Linker.
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. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
+#include "libiberty.h"
#include "ld.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldwrite.h"
#include "ldmisc.h"
-#include "ldgram.h"
+#include <ldgram.h>
#include "ldmain.h"
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));
+static asection *clone_section PARAMS ((bfd *, asection *, const char *, int *));
+static void split_sections PARAMS ((bfd *, struct bfd_link_info *));
/* Build link_order structures for the BFD linker. */
switch (statement->header.type)
{
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[LONG_SIZE];
- unsigned int size = 0;
- asection *output_section = statement->data_statement.output_section;
+ asection *output_section;
+ struct bfd_link_order *link_order;
+ bfd_vma value;
+ bfd_boolean big_endian = FALSE;
+
+ output_section = statement->data_statement.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\n"));
+
+ link_order->type = bfd_data_link_order;
+ link_order->offset = statement->data_statement.output_vma;
+ link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE);
+
+ value = statement->data_statement.value;
+
+ /* If the endianness of the output BFD is not known, then we
+ base the endianness of the data on the first input file.
+ By convention, the bfd_put routines for an unknown
+ endianness are big endian, so we must swap here if the
+ input file is little endian. */
+ if (bfd_big_endian (output_bfd))
+ big_endian = TRUE;
+ else if (bfd_little_endian (output_bfd))
+ big_endian = FALSE;
+ else
+ {
+ bfd_boolean swap;
+
+ swap = FALSE;
+ if (command_line.endian == ENDIAN_BIG)
+ big_endian = TRUE;
+ else if (command_line.endian == ENDIAN_LITTLE)
+ {
+ big_endian = FALSE;
+ swap = TRUE;
+ }
+ else if (command_line.endian == ENDIAN_UNSET)
+ {
+ big_endian = TRUE;
+ {
+ LANG_FOR_EACH_INPUT_STATEMENT (s)
+ {
+ if (s->the_bfd != NULL)
+ {
+ if (bfd_little_endian (s->the_bfd))
+ {
+ big_endian = FALSE;
+ swap = TRUE;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ if (swap)
+ {
+ bfd_byte buffer[8];
+
+ switch (statement->data_statement.type)
+ {
+ case QUAD:
+ case SQUAD:
+ if (sizeof (bfd_vma) >= QUAD_SIZE)
+ {
+ bfd_putl64 (value, buffer);
+ value = bfd_getb64 (buffer);
+ break;
+ }
+ /* Fall through. */
+ case LONG:
+ bfd_putl32 (value, buffer);
+ value = bfd_getb32 (buffer);
+ break;
+ case SHORT:
+ bfd_putl16 (value, buffer);
+ value = bfd_getb16 (buffer);
+ break;
+ case BYTE:
+ break;
+ default:
+ abort ();
+ }
+ }
+ }
ASSERT (output_section->owner == output_bfd);
switch (statement->data_statement.type)
{
+ case QUAD:
+ case SQUAD:
+ if (sizeof (bfd_vma) >= QUAD_SIZE)
+ bfd_put_64 (output_bfd, value, link_order->u.data.contents);
+ else
+ {
+ bfd_vma high;
+
+ if (statement->data_statement.type == QUAD)
+ high = 0;
+ else if ((value & 0x80000000) == 0)
+ high = 0;
+ else
+ high = (bfd_vma) -1;
+ bfd_put_32 (output_bfd, high,
+ (link_order->u.data.contents
+ + (big_endian ? 0 : 4)));
+ bfd_put_32 (output_bfd, value,
+ (link_order->u.data.contents
+ + (big_endian ? 4 : 0)));
+ }
+ link_order->size = QUAD_SIZE;
+ break;
case LONG:
- bfd_put_32 (output_bfd, value, play_area);
- size = LONG_SIZE;
+ bfd_put_32 (output_bfd, value, link_order->u.data.contents);
+ link_order->size = LONG_SIZE;
break;
case SHORT:
- bfd_put_16 (output_bfd, value, play_area);
- size = SHORT_SIZE;
+ bfd_put_16 (output_bfd, value, link_order->u.data.contents);
+ link_order->size = SHORT_SIZE;
break;
case BYTE:
- bfd_put_8 (output_bfd, value, play_area);
- size = BYTE_SIZE;
+ bfd_put_8 (output_bfd, value, link_order->u.data.contents);
+ link_order->size = BYTE_SIZE;
break;
default:
abort ();
}
+ }
+ 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\n"));
+
+ 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 (! bfd_set_section_contents (output_bfd, output_section,
- play_area,
- statement->data_statement.output_vma,
- size))
- einfo ("%P%X: writing data failed: %E\n");
+ if (rs->name == 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
+ {
+ 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)
+ if (!statement->input_section.ifile->just_syms_flag)
{
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)
+ if ((output_section->flags & SEC_HAS_CONTENTS) != 0
+ || ((output_section->flags & SEC_LOAD) != 0
+ && (output_section->flags & SEC_THREAD_LOCAL)))
{
struct bfd_link_order *link_order;
{
/* 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;
+ fill. */
+ link_order->type = bfd_data_link_order;
+ link_order->u.data.contents = "";
+ link_order->u.data.size = 1;
}
else
{
link_order->u.indirect.section = i;
ASSERT (i->output_section == output_section);
}
- link_order->size = bfd_section_size (i->owner, i);
+ 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;
}
}
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->type = bfd_data_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;
+ link_order->u.data.contents = statement->padding_statement.fill->data;
+ link_order->u.data.size = statement->padding_statement.fill->size;
}
}
break;
/* Call BFD to write out the linked file. */
-void
-ldwrite ()
+/**********************************************************************/
+
+/* Wander around the input sections, make sure that
+ we'll never try and create an output section with more relocs
+ than will fit.. Do this by always assuming the worst case, and
+ creating new output sections with all the right bits. */
+#define TESTIT 1
+static asection *
+clone_section (abfd, s, name, count)
+ bfd *abfd;
+ asection *s;
+ const char *name;
+ int *count;
{
- lang_for_each_statement (build_link_order);
-
- if (! bfd_final_link (output_bfd, &link_info))
- einfo ("%F%P: %B: %E\n", output_bfd);
-
- if (config.map_file)
+ char templ[6];
+ char *sname;
+ asection *n;
+ struct bfd_link_hash_entry *h;
+
+ /* Invent a section name from the first five chars of the base
+ section name and a digit suffix. */
+ strncpy (templ, name, sizeof (templ) - 1);
+ templ[sizeof (templ) - 1] = '\0';
+ if ((sname = bfd_get_unique_section_name (abfd, templ, count)) == NULL
+ || (n = bfd_make_section_anyway (abfd, sname)) == NULL
+ || (h = bfd_link_hash_lookup (link_info.hash,
+ sname, TRUE, TRUE, FALSE)) == NULL)
{
- print_symbol_table ();
- lang_map ();
+ einfo (_("%F%P: clone section failed: %E\n"));
+ /* Silence gcc warnings. einfo exits, so we never reach here. */
+ return NULL;
}
-}
-/* Print the symbol table. */
+ /* Set up section symbol. */
+ h->type = bfd_link_hash_defined;
+ h->u.def.value = 0;
+ h->u.def.section = n;
+
+ n->flags = s->flags;
+ n->vma = s->vma;
+ n->user_set_vma = s->user_set_vma;
+ n->lma = s->lma;
+ n->_cooked_size = 0;
+ n->_raw_size = 0;
+ n->output_offset = s->output_offset;
+ n->output_section = n;
+ n->orelocation = 0;
+ n->reloc_count = 0;
+ n->alignment_power = s->alignment_power;
+ return n;
+}
+#if TESTING
static void
-print_symbol_table ()
+ds (s)
+ asection *s;
{
- 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);
+ struct bfd_link_order *l = s->link_order_head;
+ printf ("vma %x size %x\n", s->vma, s->_raw_size);
+ while (l)
+ {
+ if (l->type == bfd_indirect_link_order)
+ {
+ printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
+ }
+ else
+ {
+ printf (_("%8x something else\n"), l->offset);
+ }
+ l = l->next;
+ }
+ printf ("\n");
}
-/* Print information about a file. */
+dump (s, a1, a2)
+ char *s;
+ asection *a1;
+ asection *a2;
+{
+ printf ("%s\n", s);
+ ds (a1);
+ ds (a2);
+}
static void
-print_file_stuff (f)
- lang_input_statement_type * f;
+sanity_check (abfd)
+ bfd *abfd;
{
- fprintf (config.map_file, " %s\n", f->filename);
- if (f->just_syms_flag)
+ asection *s;
+ for (s = abfd->sections; s; s = s->next)
{
- fprintf (config.map_file, " symbols only\n");
+ struct bfd_link_order *p;
+ bfd_vma prev = 0;
+ for (p = s->link_order_head; p; p = p->next)
+ {
+ if (p->offset > 100000)
+ abort ();
+ if (p->offset < prev)
+ abort ();
+ prev = p->offset;
+ }
}
- else
+}
+#else
+#define sanity_check(a)
+#define dump(a, b, c)
+#endif
+
+static void
+split_sections (abfd, info)
+ bfd *abfd;
+ struct bfd_link_info *info;
+{
+ asection *original_sec;
+ int nsecs = abfd->section_count;
+ sanity_check (abfd);
+ /* Look through all the original sections. */
+ for (original_sec = abfd->sections;
+ original_sec && nsecs;
+ original_sec = original_sec->next, nsecs--)
{
- asection *s;
- if (true)
+ int count = 0;
+ unsigned int lines = 0;
+ unsigned int relocs = 0;
+ bfd_size_type sec_size = 0;
+ struct bfd_link_order *l;
+ struct bfd_link_order *p;
+ bfd_vma vma = original_sec->vma;
+ asection *cursor = original_sec;
+
+ /* Count up the relocations and line entries to see if anything
+ would be too big to fit. Accumulate section size too. */
+ for (l = NULL, p = cursor->link_order_head; p != NULL; p = l->next)
{
- for (s = f->the_bfd->sections;
- s != (asection *) NULL;
- s = s->next)
+ unsigned int thislines = 0;
+ unsigned int thisrelocs = 0;
+ bfd_size_type thissize = 0;
+ if (p->type == bfd_indirect_link_order)
+ {
+ asection *sec;
+
+ sec = p->u.indirect.section;
+
+ if (info->strip == strip_none
+ || info->strip == strip_some)
+ thislines = sec->lineno_count;
+
+ if (info->relocateable)
+ thisrelocs = sec->reloc_count;
+
+ if (sec->_cooked_size != 0)
+ thissize = sec->_cooked_size;
+ else
+ thissize = sec->_raw_size;
+
+ }
+ else if (info->relocateable
+ && (p->type == bfd_section_reloc_link_order
+ || p->type == bfd_symbol_reloc_link_order))
+ thisrelocs++;
+
+ if (l != NULL
+ && (thisrelocs + relocs >= config.split_by_reloc
+ || thislines + lines >= config.split_by_reloc
+ || thissize + sec_size >= config.split_by_file))
{
- print_address (s->output_offset);
- if (s->reloc_done)
+ /* Create a new section and put this link order and the
+ following link orders into it. */
+ bfd_vma shift_offset;
+ asection *n;
+
+ n = clone_section (abfd, cursor, original_sec->name, &count);
+
+ /* Attach the link orders to the new section and snip
+ them off from the old section. */
+ n->link_order_head = p;
+ n->link_order_tail = cursor->link_order_tail;
+ cursor->link_order_tail = l;
+ l->next = NULL;
+ l = p;
+
+ /* Change the size of the original section and
+ update the vma of the new one. */
+
+ dump ("before snip", cursor, n);
+
+ shift_offset = p->offset;
+ if (cursor->_cooked_size != 0)
{
- fprintf (config.map_file, " %08x 2**%2ud %s\n",
- (unsigned) bfd_get_section_size_after_reloc (s),
- s->alignment_power, s->name);
+ n->_cooked_size = cursor->_cooked_size - shift_offset;
+ cursor->_cooked_size = shift_offset;
}
+ n->_raw_size = cursor->_raw_size - shift_offset;
+ cursor->_raw_size = shift_offset;
- else
+ vma += shift_offset;
+ n->lma = n->vma = vma;
+
+ /* Run down the chain and change the output section to
+ the right one, update the offsets too. */
+ do
{
- fprintf (config.map_file, " %08x 2**%2ud %s\n",
- (unsigned) bfd_get_section_size_before_reloc (s),
- s->alignment_power, s->name);
+ p->offset -= shift_offset;
+ if (p->type == bfd_indirect_link_order)
+ {
+ p->u.indirect.section->output_section = n;
+ p->u.indirect.section->output_offset = p->offset;
+ }
+ p = p->next;
}
+ while (p);
+
+ dump ("after snip", cursor, n);
+ cursor = n;
+ relocs = thisrelocs;
+ lines = thislines;
+ sec_size = thissize;
}
- }
- else
- {
- for (s = f->the_bfd->sections;
- s != (asection *) NULL;
- s = s->next)
+ else
{
- 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));
+ l = p;
+ relocs += thisrelocs;
+ lines += thislines;
+ sec_size += thissize;
}
- fprintf (config.map_file, "hex \n");
}
}
- print_nl ();
+ sanity_check (abfd);
}
-/* Print a symbol. */
+/**********************************************************************/
-static boolean
-print_symbol (p, ignore)
- struct bfd_link_hash_entry *p;
- PTR ignore;
+void
+ldwrite ()
{
- while (p->type == bfd_link_hash_indirect
- || p->type == bfd_link_hash_warning)
- p = p->u.i.link;
+ /* Reset error indicator, which can typically something like invalid
+ format from opening up the .o files. */
+ bfd_set_error (bfd_error_no_error);
+ lang_for_each_statement (build_link_order);
- switch (p->type)
+ if (config.split_by_reloc != (unsigned) -1
+ || config.split_by_file != (bfd_size_type) -1)
+ split_sections (output_bfd, &link_info);
+ if (!bfd_final_link (output_bfd, &link_info))
{
- 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;
+ /* If there was an error recorded, print it out. Otherwise assume
+ an appropriate error message like unknown symbol was printed
+ out. */
- default:
- abort ();
+ if (bfd_get_error () != bfd_error_no_error)
+ einfo (_("%F%P: final link failed: %E\n"));
+ else
+ xexit (1);
}
-
- return true;
}
projects / binutils-gdb.git / blobdiff