X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=ld%2Fldwrite.c;h=5624dfdf4c0a5c22232c9facba346af624efcb45;hb=f1f28025c3ea75d5368ddd3046461648145b89b3;hp=fc7759f3586a019075845e370a48d29cdd8e11ce;hpb=ac5939079f3281f51bb37834c872827938c479c6;p=deliverable%2Fbinutils-gdb.git diff --git a/ld/ldwrite.c b/ld/ldwrite.c index fc7759f358..5624dfdf4c 100644 --- a/ld/ldwrite.c +++ b/ld/ldwrite.c @@ -1,414 +1,556 @@ -/* Copyright (C) 1991 Free Software Foundation, Inc. - -This file is part of GLD, the Gnu Linker. +/* ldwrite.c -- write out the linked file + Copyright (C) 1991-2020 Free Software Foundation, Inc. + Written by Steve Chamberlain sac@cygnus.com -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 2 of the License, or -(at your option) any later version. + This file is part of the GNU Binutils. -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. + 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 3 of the License, or + (at your option) any later version. -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. */ + 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. -/* - * $Id$ -*/ + 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., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ -/* - 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" #include "sysdep.h" +#include "bfd.h" +#include "bfdlink.h" +#include "libiberty.h" +#include "ctf-api.h" +#include "safe-ctype.h" -#include "ldlang.h" #include "ld.h" +#include "ldexp.h" +#include "ldlang.h" #include "ldwrite.h" #include "ldmisc.h" -#include "ldsym.h" -#include "ldgram.h" - - +#include +#include "ldmain.h" +/* Build link_order structures for the BFD linker. */ -/* 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; +static void +build_link_order (lang_statement_union_type *statement) +{ + switch (statement->header.type) + { + case lang_data_statement_enum: + { + asection *output_section; + struct bfd_link_order *link_order; + bfd_vma value; + + output_section = statement->data_statement.output_section; + ASSERT (output_section->owner == link_info.output_bfd); + + if (!((output_section->flags & SEC_HAS_CONTENTS) != 0 + || ((output_section->flags & SEC_LOAD) != 0 + && (output_section->flags & SEC_THREAD_LOCAL)))) + break; + + link_order = bfd_new_link_order (link_info.output_bfd, output_section); + if (link_order == NULL) + einfo (_("%F%P: bfd_new_link_order failed\n")); + + link_order->type = bfd_data_link_order; + link_order->offset = statement->data_statement.output_offset; + link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE); + + value = statement->data_statement.value; + + /* By convention, the bfd_put routines for an unknown + endianness are big endian, so we must swap here if the + input is little endian. */ + if (!bfd_big_endian (link_info.output_bfd) + && !bfd_little_endian (link_info.output_bfd) + && !link_info.big_endian) + { + 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 (); + } + } -extern char lprefix; + ASSERT (output_section->owner == link_info.output_bfd); + switch (statement->data_statement.type) + { + case QUAD: + case SQUAD: + if (sizeof (bfd_vma) >= QUAD_SIZE) + bfd_put_64 (link_info.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 (link_info.output_bfd, high, + (link_order->u.data.contents + + (link_info.big_endian ? 0 : 4))); + bfd_put_32 (link_info.output_bfd, value, + (link_order->u.data.contents + + (link_info.big_endian ? 4 : 0))); + } + link_order->size = QUAD_SIZE; + break; + case LONG: + bfd_put_32 (link_info.output_bfd, value, + link_order->u.data.contents); + link_order->size = LONG_SIZE; + break; + case SHORT: + bfd_put_16 (link_info.output_bfd, value, + link_order->u.data.contents); + link_order->size = SHORT_SIZE; + break; + case BYTE: + bfd_put_8 (link_info.output_bfd, value, + link_order->u.data.contents); + link_order->size = BYTE_SIZE; + break; + default: + abort (); + } + link_order->u.data.size = link_order->size; + } + break; -#ifdef __STDC__ -void lang_for_each_statement(void (*func)()); -#else /* __STDC__ */ -void lang_for_each_statement(); -#endif /* __STDC__ */ + case lang_reloc_statement_enum: + { + lang_reloc_statement_type *rs; + asection *output_section; + struct bfd_link_order *link_order; -extern bfd_size_type largest_section; -ld_config_type config; + rs = &statement->reloc_statement; -extern unsigned int global_symbol_count; + output_section = rs->output_section; + ASSERT (output_section->owner == link_info.output_bfd); -boolean trace_files; + if (!((output_section->flags & SEC_HAS_CONTENTS) != 0 + || ((output_section->flags & SEC_LOAD) != 0 + && (output_section->flags & SEC_THREAD_LOCAL)))) + break; -static void -DEFUN(perform_relocation,(input_bfd, - input_section, - data, - symbols), - bfd *input_bfd AND - asection *input_section AND - PTR data AND - asymbol **symbols) -{ - static asymbol *error_symbol = (asymbol *)NULL; - static unsigned int error_count = 0; -#define MAX_ERRORS_IN_A_ROW 5 - bfd_size_type reloc_size = bfd_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; - - input_section->_cooked_size = input_section->_raw_size; - input_section->reloc_done = 1; - - if (bfd_canonicalize_reloc(input_bfd, - input_section, - reloc_vector, - symbols) ) - { - for (parent = reloc_vector; *parent; parent++) - { + link_order = bfd_new_link_order (link_info.output_bfd, output_section); + if (link_order == NULL) + einfo (_("%F%P: bfd_new_link_order failed\n")); - bfd_reloc_status_type r= - bfd_perform_relocation(input_bfd, - *parent, - data, - input_section, - ob); + link_order->offset = rs->output_offset; + link_order->size = bfd_get_reloc_size (rs->howto); - if (r == bfd_reloc_ok) { - if (ob != (bfd *)NULL) { - /* A parital link, so keep the relocs */ + link_order->u.reloc.p = (struct bfd_link_order_reloc *) + xmalloc (sizeof (struct bfd_link_order_reloc)); - /* Add to each relocation the offset of where it lives - in the output section */ -/* (*parent)->address += input_section->output_offset;*/ + link_order->u.reloc.p->reloc = rs->reloc; + link_order->u.reloc.p->addend = rs->addend_value; - 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 (rs->name == NULL) + { + link_order->type = bfd_section_reloc_link_order; + if (rs->section->owner == link_info.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; - if (p->sym_ptr_ptr != (asymbol **)NULL) { - s = *(p->sym_ptr_ptr); + case lang_input_section_enum: + { + /* Create a new link_order in the output section with this + attached */ + asection *i = statement->input_section.section; + + if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS + && (i->flags & SEC_EXCLUDE) == 0) + { + asection *output_section = i->output_section; + struct bfd_link_order *link_order; + + ASSERT (output_section->owner == link_info.output_bfd); + + if (!((output_section->flags & SEC_HAS_CONTENTS) != 0 + || ((output_section->flags & SEC_LOAD) != 0 + && (output_section->flags & SEC_THREAD_LOCAL)))) + break; + + link_order = bfd_new_link_order (link_info.output_bfd, + output_section); + if (link_order == NULL) + einfo (_("%F%P: bfd_new_link_order failed\n")); + + if ((i->flags & SEC_NEVER_LOAD) != 0 + && (i->flags & SEC_DEBUGGING) == 0) + { + /* We've got a never load section inside one which is + going to be output, we'll change it into a fill. */ + link_order->type = bfd_data_link_order; + link_order->u.data.contents = (unsigned char *) ""; + link_order->u.data.size = 1; } - else { - s = (asymbol *)NULL; + else + { + link_order->type = bfd_indirect_link_order; + link_order->u.indirect.section = i; + ASSERT (i->output_section == output_section); } - 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) { - einfo("%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) { - einfo("%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: - einfo("%B: relocation may be wrong `%T'\n", - input_bfd, s); - break; - case bfd_reloc_outofrange: - einfo("%B:%s relocation address out of range %T (%V)\n", - input_bfd, input_section->name, s, p->address); - break; - case bfd_reloc_overflow: - einfo("%B:%s relocation overflow in %T reloc type %d\n", - input_bfd, input_section->name, s, p->howto->type); - break; - default: - einfo("%F%B: relocation error, symbol `%T'\n", - input_bfd, s); - break; - } - } - } - } - free((char *)reloc_vector); -} + link_order->size = i->size; + 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 + == link_info.output_bfd); + + if (!((output_section->flags & SEC_HAS_CONTENTS) != 0 + || ((output_section->flags & SEC_LOAD) != 0 + && (output_section->flags & SEC_THREAD_LOCAL)))) + break; + + link_order = bfd_new_link_order (link_info.output_bfd, + output_section); + if (link_order == NULL) + einfo (_("%F%P: bfd_new_link_order failed\n")); + 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.data.contents = statement->padding_statement.fill->data; + link_order->u.data.size = statement->padding_statement.fill->size; + } + break; + default: + /* All the other ones fall through */ + break; + } +} +/* Return true if NAME is the name of an unsplittable section. These + are the stabs strings, dwarf strings. */ +static bfd_boolean +unsplittable_name (const char *name) +{ + if (CONST_STRNEQ (name, ".stab")) + { + /* There are several stab like string sections. We pattern match on + ".stab...str" */ + unsigned len = strlen (name); + if (strcmp (&name[len-3], "str") == 0) + return TRUE; + } + else if (strcmp (name, "$GDB_STRINGS$") == 0) + return TRUE; + return FALSE; +} +/* 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 (bfd *abfd, asection *s, const char *name, int *count) +{ + char *tname; + char *sname; + unsigned int len; + asection *n; + struct bfd_link_hash_entry *h; + + /* Invent a section name from the section name and a dotted numeric + suffix. */ + len = strlen (name); + tname = (char *) xmalloc (len + 1); + memcpy (tname, name, len + 1); + /* Remove a dotted number suffix, from a previous split link. */ + while (len && ISDIGIT (tname[len-1])) + len--; + if (len > 1 && tname[len-1] == '.') + /* It was a dotted number. */ + tname[len-1] = 0; + + /* We want to use the whole of the original section name for the + split name, but coff can be restricted to 8 character names. */ + if (bfd_family_coff (abfd) && strlen (tname) > 5) + { + /* Some section names cannot be truncated, as the name is + used to locate some other section. */ + if (CONST_STRNEQ (name, ".stab") + || strcmp (name, "$GDB_SYMBOLS$") == 0) + { + einfo (_ ("%F%P: cannot create split section name for %s\n"), name); + /* Silence gcc warnings. einfo exits, so we never reach here. */ + return NULL; + } + tname[5] = 0; + } -PTR data_area; + if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL + || (n = bfd_make_section_anyway (abfd, sname)) == NULL + || (h = bfd_link_hash_lookup (link_info.hash, + sname, TRUE, TRUE, FALSE)) == NULL) + { + einfo (_("%F%P: clone section failed: %E\n")); + /* Silence gcc warnings. einfo exits, so we never reach here. */ + return NULL; + } + free (tname); + + /* 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->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; + + bfd_copy_private_section_data (abfd, s, abfd, n); + + return n; +} +#if TESTING static void -DEFUN(copy_and_relocate,(statement), - lang_statement_union_type *statement) +ds (asection *s) { - 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); + struct bfd_link_order *l = s->map_head.link_order; + printf ("vma %x size %x\n", s->vma, s->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"); +} - } +dump (char *s, asection *a1, asection *a2) +{ + printf ("%s\n", s); + ds (a1); + ds (a2); +} - /* Now write any remaining byte */ - if (i < statement->fill_statement.size) +static void +sanity_check (bfd *abfd) +{ + asection *s; + for (s = abfd->sections; s; s = s->next) + { + struct bfd_link_order *p; + bfd_vma prev = 0; + for (p = s->map_head.link_order; p; p = p->next) { - bfd_set_section_contents(output_bfd, - statement->fill_statement.output_section, - play_area, - statement->data_statement.output_offset +i, - 1); - + if (p->offset > 100000) + abort (); + if (p->offset < prev) + abort (); + prev = p->offset; } -#endif } - break; - case lang_data_statement_enum: +} +#else +#define sanity_check(a) +#define dump(a, b, c) +#endif + +static void +split_sections (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--) { - bfd_vma value = statement->data_statement.value; - bfd_byte play_area[LONG_SIZE]; - unsigned int size = 0; - switch (statement->data_statement.type) { - 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; - } - - bfd_set_section_contents(output_bfd, - statement->data_statement.output_section, - play_area, - statement->data_statement.output_vma, - size); - - + 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->map_head.link_order; p != NULL; p = l->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; - } - break; - case lang_input_section_enum: - { + if (info->strip == strip_none + || info->strip == strip_some) + thislines = sec->lineno_count; - 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; + if (bfd_link_relocatable (info)) + thisrelocs = sec->reloc_count; - if (output_section->flags & SEC_LOAD && - output_section->flags & SEC_ALLOC - && bfd_get_section_size_before_reloc(i) != 0) - { - if(bfd_get_section_contents(inbfd, - i, - data_area, - (file_ptr)0, - bfd_get_section_size_before_reloc(i)) == false) - { - einfo("%F%B error reading section contents %E\n", inbfd); - } - /* Set the reloc bit */ - perform_relocation (inbfd, i, data_area, ifile->asymbols); + thissize = sec->size; + } + else if (bfd_link_relocatable (info) + && (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)) + && !unsplittable_name (cursor->name)) + { + /* Create a new section and put this link order and the + following link orders into it. */ + bfd_vma shift_offset; + asection *n; - if(bfd_set_section_contents(output_bfd, - output_section, - data_area, - (file_ptr)i->output_offset, - bfd_get_section_size_after_reloc(i)) == false) - { - einfo("%F%B error writing section contents of %E\n", - output_bfd); - } + 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->map_head.link_order = p; + n->map_tail.link_order = cursor->map_tail.link_order; + cursor->map_tail.link_order = l; + l->next = NULL; + l = p; - } - break; + /* Change the size of the original section and + update the vma of the new one. */ - default: - /* All the other ones fall through */ - ; + dump ("before snip", cursor, n); - } -} + shift_offset = p->offset; + n->size = cursor->size - shift_offset; + cursor->size = shift_offset; -void -DEFUN_VOID(write_norel) -{ - /* Output the text and data segments, relocating as we go. */ - lang_for_each_statement(copy_and_relocate); -} + 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 + { + 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); -static void -DEFUN(read_relocs,(abfd, section, symbols), - bfd *abfd AND - asection *section AND - asymbol **symbols) -{ - /* Work out the output section ascociated with this input section */ - asection *output_section = section->output_section; - - bfd_size_type reloc_size = bfd_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; - } + dump ("after snip", cursor, n); + cursor = n; + relocs = thisrelocs; + lines = thislines; + sec_size = thissize; + } + else + { + l = p; + relocs += thisrelocs; + lines += thislines; + sec_size += thissize; + } + } + } + sanity_check (abfd); } - -static void -DEFUN_VOID(write_rel) -{ - /* - 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((bfd_size_type)(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); -} +/* Call BFD to write out the linked file. */ void -DEFUN_VOID(ldwrite) +ldwrite (void) { - data_area = (PTR) ldmalloc(largest_section); - if (config.relocateable_output == true) - { - write_rel(); - } - else - { - write_relaxnorel(output_bfd); - } - free(data_area); - /* Output the symbol table (both globals and locals). */ - - /* Print a map, if requested. */ - - if (config.map_file) { - ldsym_print_symbol_table (); - lang_map(); - } - - ldsym_write (); - + /* Reset error indicator, which can typically something like invalid + format from opening up the .o files. */ + bfd_set_error (bfd_error_no_error); + lang_clear_os_map (); + lang_for_each_statement (build_link_order); + + if (config.split_by_reloc != (unsigned) -1 + || config.split_by_file != (bfd_size_type) -1) + split_sections (link_info.output_bfd, &link_info); + if (!bfd_final_link (link_info.output_bfd, &link_info)) + { + /* If there was an error recorded, print it out. Otherwise assume + an appropriate error message like unknown symbol was printed + out. */ + + if (bfd_get_error () != bfd_error_no_error) + einfo (_("%F%P: final link failed: %E\n")); + else + xexit (1); + } } -