binutils-gdb/ld/ldwrite.c

552 lines
14 KiB
C
Raw Normal View History

1999-05-03 09:29:11 +02:00
/* ldwrite.c -- write out the linked file
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 03:11:05 +01:00
Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2002
1999-05-03 09:29:11 +02:00
Free Software Foundation, Inc.
Written by Steve Chamberlain sac@cygnus.com
This file is part of GLD, the Gnu Linker.
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 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., 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 "ldmain.h"
static void build_link_order PARAMS ((lang_statement_union_type *));
static asection *clone_section PARAMS ((bfd *, asection *, const char *, int *));
1999-05-03 09:29:11 +02:00
static void split_sections PARAMS ((bfd *, struct bfd_link_info *));
/* Build link_order structures for the BFD linker. */
static void
build_link_order (statement)
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;
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
{
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, link_order->u.data.contents);
link_order->size = LONG_SIZE;
break;
case SHORT:
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, 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 (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)
{
asection *i = statement->input_section.section;
asection *output_section = i->output_section;
ASSERT (output_section->owner == output_bfd);
* elf.c (_bfd_elf_make_section_from_shdr): Set SEC_THREAD_LOCAL for symbols from SHF_TLS section. (_bfd_elf_print_private_bfd_data): Add PT_TLS. (elf_fake_sections): Set SHF_TLS for SEC_THREAD_LOCAL sections. (map_sections_to_segments): Build PT_TLS segment if necessary. (assign_file_positions_for_segments): Likewise. (get_program_header_size): Account for PT_TLS segment. (swap_out_syms): Set type of BSF_THREAD_LOCAL symbols and symbols from SEC_THREAD_LOCAL sections to STT_TLS. * reloc.c: Add 386 and IA-64 TLS relocs. * section.c (SEC_THREAD_LOCAL): Define. (SEC_CONSTRUCTOR_TEXT, SEC_CONSTRUCTOR_DATA, SEC_CONSTRUCTOR_BSS): Remove. * elflink.h (elf_link_add_object_symbols): Support .tcommon. (size_dynamic_sections): If DF_STATIC_TLS, set DF_FLAGS unconditionally. (struct elf_final_link_info): Add first_tls_sec. (elf_bfd_final_link): Set first_tls_sec. Compute elf_hash_table (info)->tls_segment. (elf_link_output_extsym): Handle STT_TLS symbols. (elf_link_input_bfd): Likewise. * syms.c (BSF_THREAD_LOCAL): Define. * bfd-in2.h: Rebuilt. * libbfd.h: Rebuilt. * elf32-i386.c (elf_i386_tls_transition, dtpoff_base, tpoff, elf_i386_mkobject, elf_i386_object_p): New functions. (elf_howto_table): Add TLS relocs. (elf_i386_reloc_type_lookup): Support TLS relocs. (elf_i386_info_to_howto_rel): Likewise. (struct elf_i386_link_hash_entry): Add tls_type. (struct elf_i386_obj_tdata): New. (elf_i386_hash_entry, elf_i386_tdata, elf_i386_local_got_tls_type): New macros. (struct elf_i386_link_hash_table): Add tls_ldm_got. (link_hash_newfunc): Clear tls_type. (elf_i386_check_relocs): Support TLS relocs. (elf_i386_gc_sweep_hook): Likewise. (allocate_dynrelocs): Likewise. (elf_i386_size_dynamic_sections): Likewise. (elf_i386_relocate_section): Likewise. (elf_i386_finish_dynamic_symbol): Likewise. (bfd_elf32_mkobject, elf_backend_object_p): Define. * elfxx-ia64.c (struct elfNN_ia64_dyn_sym_info): Add tprel_offset, dtpmod_offset, dtprel_offset, tprel_done, dtpmod_done, dtprel_done, want_tprel, want_dtpmod, want_dtprel. (elfNN_ia64_tprel_base, elfNN_ia64_dtprel_base): New functions. (ia64_howto_table): Add TLS relocs, rename R_IA64_LTOFF_TP22 to R_IA64_LTOFF_TPREL22. (elf_code_to_howto_index): Add TLS relocs. (elfNN_ia64_check_relocs): Support TLS relocs. (allocate_global_data_got): Account for TLS .got data. (allocate_dynrel_entries): Account for TLS dynamic relocations. (elfNN_ia64_install_value): Supprt TLS relocs. (set_got_entry): Support TLS relocs. (elfNN_ia64_relocate_section): Likewise. * config/obj-elf.c (elf_common): Renamed from obj_elf_common. (obj_elf_common): Call elf_common. (obj_elf_tls_common): New function. (elf_pseudo_tab): Support .tls_common. (special_sections): Add .tdata and .tbss. (obj_elf_change_section): Set SEC_THREAD_LOCAL for SHF_TLS sections. (obj_elf_parse_section_letters): Support T in section flags (SHF_TLS). (obj_elf_parse_section_letters): Include T in error message. * config/tc-ppc.c (ppc_section_letter): Likewise. * config/tc-alpha.c (alpha_elf_section_letter): Likewise. (tc_gen_reloc): Handle SEC_THREAD_LOCAL the same way as SEC_MERGE. * config/tc-sparc.c (md_apply_fix3): Likewise. * config/tc-i386.c (tc_i386_fix_adjustable): Add TLS relocs. Define them if not BFD_ASSEMBLER. (lex_got): Support @TLSGD, @TLSLDM, @GOTTPOFF, @TPOFF, @DTPOFF and @NTPOFF. (md_apply_fix3): Add TLS relocs. * config/tc-ia64.c (enum reloc_func): Add FUNC_DTP_MODULE, FUNC_DTP_RELATIVE, FUNC_TP_RELATIVE, FUNC_LT_DTP_MODULE, FUNC_LT_DTP_RELATIVE, FUNC_LT_TP_RELATIVE. (pseudo_func): Support @dtpmod(), @dtprel() and @tprel(). (ia64_elf_section_letter): Include T in error message. (md_begin): Support TLS operators. (md_operand): Likewise. (ia64_gen_real_reloc_type): Support TLS relocs. * testsuite/gas/i386/tlspic.s: New file. * testsuite/gas/i386/tlsd.s: New file. * testsuite/gas/i386/tlsnopic.s: New file. * testsuite/gas/i386/tlsd.d: New file. * testsuite/gas/i386/tlsnopic.d: New file. * testsuite/gas/i386/tlspic.d: New file. * testsuite/gas/i386/i386.exp: Add tlsd, tlsnopic and tlspic tests. * testsuite/gas/ia64/tls.s: New file. * testsuite/gas/ia64/tls.d: New file. * testsuite/gas/ia64/ia64.exp: Add tls test. * write.c (adjust_reloc_syms): Don't change symbols in SEC_THREAD_LOCAL sections to STT_SECTION + addend. * elf/common.h (PT_TLS, SHF_TLS, STT_TLS, DF_STATIC_TLS): Define. * elf/ia64.h (R_IA64_LTOFF_TPREL22): Renamed from R_IA64_LTOFF_TP22. * elf/i386.h: Add TLS relocs. * scripttempl/elf.sc: Add .rel{,a}.t{bss,data}, .tdata and .tbss. * ldlang.c (lang_add_section): Set SEC_THREAD_LOCAL for output section if necessary. Handle .tbss. (lang_size_sections): Clear _raw_size for .tbss section (it allocates space in PT_TLS segment only). * ldwrite.c (build_link_order): Build link order for .tbss too. * readelf.c (get_segment_type): Add PT_TLS. (get_elf_section_flags): Add SHF_TLS. (get_dynamic_flags): Optimize. Add DF_STATIC_TLS. (process_dynamic_segment): Use puts instead of printf. (get_symbol_type): Support STT_TLS. * objdump.c (dump_section_header): Remove SEC_CONSTRUCTOR_TEXT, SEC_CONSTRUCTOR_DATA, SEC_CONSTRUCTOR_BSS. Add SEC_THREAD_LOCAL.
2002-05-23 15:12:53 +02:00
if ((output_section->flags & SEC_HAS_CONTENTS) != 0
|| ((output_section->flags & SEC_LOAD) != 0
&& (output_section->flags & SEC_THREAD_LOCAL)))
1999-05-03 09:29:11 +02:00
{
struct bfd_link_order *link_order;
link_order = bfd_new_link_order (output_bfd, output_section);
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
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 03:11:05 +01:00
fill. */
link_order->type = bfd_data_link_order;
link_order->u.data.contents = "";
link_order->u.data.size = 1;
1999-05-03 09:29:11 +02:00
}
else
{
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);
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 03:11:05 +01:00
link_order->type = bfd_data_link_order;
1999-05-03 09:29:11 +02:00
link_order->size = statement->padding_statement.size;
link_order->offset = statement->padding_statement.output_offset;
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 03:11:05 +01:00
link_order->u.data.contents = statement->padding_statement.fill->data;
link_order->u.data.size = statement->padding_statement.fill->size;
1999-05-03 09:29:11 +02:00
}
}
break;
default:
/* All the other ones fall through */
break;
}
}
/* Call BFD to write out the linked file. */
/**********************************************************************/
/* 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. */
1999-05-03 09:29:11 +02:00
#define TESTIT 1
static asection *
clone_section (abfd, s, name, count)
1999-05-03 09:29:11 +02:00
bfd *abfd;
asection *s;
const char *name;
1999-05-03 09:29:11 +02:00
int *count;
{
2000-09-20 06:20:26 +02:00
char templ[6];
char *sname;
1999-05-03 09:29:11 +02:00
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. */
2000-09-20 06:20:26 +02:00
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)
2000-09-21 16:21:24 +02:00
{
einfo (_("%F%P: clone section failed: %E\n"));
/* Silence gcc warnings. einfo exits, so we never reach here. */
return NULL;
}
2000-09-20 06:20:26 +02:00
/* Set up section symbol. */
1999-05-03 09:29:11 +02:00
h->type = bfd_link_hash_defined;
h->u.def.value = 0;
h->u.def.section = n;
1999-05-03 09:29:11 +02:00
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
1999-05-03 09:29:11 +02:00
ds (s)
asection *s;
{
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");
}
1999-05-03 09:29:11 +02:00
dump (s, a1, a2)
char *s;
asection *a1;
asection *a2;
{
printf ("%s\n", s);
ds (a1);
ds (a2);
}
static void
1999-05-03 09:29:11 +02:00
sanity_check (abfd)
bfd *abfd;
{
asection *s;
for (s = abfd->sections; s; s = s->next)
{
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
#define sanity_check(a)
#define dump(a, b, c)
#endif
static void
1999-05-03 09:29:11 +02:00
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. */
1999-05-03 09:29:11 +02:00
for (original_sec = abfd->sections;
original_sec && nsecs;
original_sec = original_sec->next, nsecs--)
{
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;
1999-05-03 09:29:11 +02:00
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)
1999-05-03 09:29:11 +02:00
{
unsigned int thislines = 0;
unsigned int thisrelocs = 0;
bfd_size_type thissize = 0;
1999-05-03 09:29:11 +02:00
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;
1999-05-03 09:29:11 +02:00
}
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))
1999-05-03 09:29:11 +02:00
{
/* Create a new section and put this link order and the
following link orders into it. */
bfd_vma shift_offset;
asection *n;
1999-05-03 09:29:11 +02:00
n = clone_section (abfd, cursor, original_sec->name, &count);
1999-05-03 09:29:11 +02:00
/* 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;
1999-05-03 09:29:11 +02:00
/* Change the size of the original section and
update the vma of the new one. */
1999-05-03 09:29:11 +02:00
dump ("before snip", cursor, n);
1999-05-03 09:29:11 +02:00
shift_offset = p->offset;
if (cursor->_cooked_size != 0)
{
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;
1999-05-03 09:29:11 +02:00
vma += shift_offset;
n->lma = n->vma = vma;
1999-05-03 09:29:11 +02:00
/* Run down the chain and change the output section to
the right one, update the offsets too. */
do
1999-05-03 09:29:11 +02:00
{
p->offset -= shift_offset;
if (p->type == bfd_indirect_link_order)
1999-05-03 09:29:11 +02:00
{
p->u.indirect.section->output_section = n;
p->u.indirect.section->output_offset = p->offset;
1999-05-03 09:29:11 +02:00
}
p = p->next;
1999-05-03 09:29:11 +02:00
}
while (p);
1999-05-03 09:29:11 +02:00
dump ("after snip", cursor, n);
cursor = n;
relocs = thisrelocs;
lines = thislines;
sec_size = thissize;
1999-05-03 09:29:11 +02:00
}
else
{
l = p;
1999-05-03 09:29:11 +02:00
relocs += thisrelocs;
lines += thislines;
sec_size += thissize;
1999-05-03 09:29:11 +02:00
}
}
}
sanity_check (abfd);
}
1999-05-03 09:29:11 +02:00
/**********************************************************************/
1999-05-03 09:29:11 +02:00
void
ldwrite ()
{
/* Reset error indicator, which can typically something like invalid
format from opening up the .o files. */
1999-05-03 09:29:11 +02:00
bfd_set_error (bfd_error_no_error);
lang_for_each_statement (build_link_order);
if (config.split_by_reloc != (unsigned) -1
|| config.split_by_file != (bfd_size_type) -1)
1999-05-03 09:29:11 +02:00
split_sections (output_bfd, &link_info);
if (!bfd_final_link (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)
2000-09-20 06:20:26 +02:00
einfo (_("%F%P: final link failed: %E\n"));
1999-05-03 09:29:11 +02:00
else
xexit (1);
1999-05-03 09:29:11 +02:00
}
}