X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fsimple.c;h=1e320fc391754b758010dc4919fdd6e0cdb20d83;hb=030a2e78acf66c5c12e073ec3887a167da7a7195;hp=30f9be0d22bb169b265db6fcf2cfda15866ec6c2;hpb=5ed6aba41c826194dcc97807392b22a3cefa1d7e;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/simple.c b/bfd/simple.c index 30f9be0d22..1e320fc391 100644 --- a/bfd/simple.c +++ b/bfd/simple.c @@ -1,13 +1,12 @@ /* simple.c -- BFD simple client routines - Copyright 2002, 2003 - Free Software Foundation, Inc. + Copyright (C) 2002-2020 Free Software Foundation, Inc. Contributed by MontaVista Software, Inc. This file is part of BFD, the Binary File Descriptor library. 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 + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,92 +16,139 @@ 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. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "libbfd.h" #include "bfdlink.h" -static bfd_boolean simple_dummy_warning - PARAMS ((struct bfd_link_info *, const char *, const char *, bfd *, - asection *, bfd_vma)); - -static bfd_boolean simple_dummy_undefined_symbol - PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, - bfd_vma, bfd_boolean)); - -static bfd_boolean simple_dummy_reloc_overflow - PARAMS ((struct bfd_link_info *, const char *, const char *, bfd_vma, - bfd *, asection *, bfd_vma)); +static void +simple_dummy_warning (struct bfd_link_info *link_info ATTRIBUTE_UNUSED, + const char *warning ATTRIBUTE_UNUSED, + const char *symbol ATTRIBUTE_UNUSED, + bfd *abfd ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + bfd_vma address ATTRIBUTE_UNUSED) +{ +} -static bfd_boolean simple_dummy_reloc_dangerous - PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma)); +static void +simple_dummy_undefined_symbol (struct bfd_link_info *link_info ATTRIBUTE_UNUSED, + const char *name ATTRIBUTE_UNUSED, + bfd *abfd ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + bfd_vma address ATTRIBUTE_UNUSED, + bfd_boolean fatal ATTRIBUTE_UNUSED) +{ +} -static bfd_boolean simple_dummy_unattached_reloc - PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma)); +static void +simple_dummy_reloc_overflow (struct bfd_link_info *link_info ATTRIBUTE_UNUSED, + struct bfd_link_hash_entry *entry ATTRIBUTE_UNUSED, + const char *name ATTRIBUTE_UNUSED, + const char *reloc_name ATTRIBUTE_UNUSED, + bfd_vma addend ATTRIBUTE_UNUSED, + bfd *abfd ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + bfd_vma address ATTRIBUTE_UNUSED) +{ +} -bfd_byte * bfd_simple_get_relocated_section_contents - PARAMS ((bfd *, asection *, bfd_byte *)); +static void +simple_dummy_reloc_dangerous (struct bfd_link_info *link_info ATTRIBUTE_UNUSED, + const char *message ATTRIBUTE_UNUSED, + bfd *abfd ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + bfd_vma address ATTRIBUTE_UNUSED) +{ +} -static bfd_boolean -simple_dummy_warning (link_info, warning, symbol, abfd, section, address) - struct bfd_link_info *link_info ATTRIBUTE_UNUSED; - const char *warning ATTRIBUTE_UNUSED; - const char *symbol ATTRIBUTE_UNUSED; - bfd *abfd ATTRIBUTE_UNUSED; - asection *section ATTRIBUTE_UNUSED; - bfd_vma address ATTRIBUTE_UNUSED; +static void +simple_dummy_unattached_reloc (struct bfd_link_info *link_info ATTRIBUTE_UNUSED, + const char *name ATTRIBUTE_UNUSED, + bfd *abfd ATTRIBUTE_UNUSED, + asection *section ATTRIBUTE_UNUSED, + bfd_vma address ATTRIBUTE_UNUSED) { - return TRUE; } -static bfd_boolean -simple_dummy_undefined_symbol (link_info, name, abfd, section, address, fatal) - struct bfd_link_info *link_info ATTRIBUTE_UNUSED; - const char *name ATTRIBUTE_UNUSED; - bfd *abfd ATTRIBUTE_UNUSED; - asection *section ATTRIBUTE_UNUSED; - bfd_vma address ATTRIBUTE_UNUSED; - bfd_boolean fatal ATTRIBUTE_UNUSED; +static void +simple_dummy_multiple_definition (struct bfd_link_info *link_info ATTRIBUTE_UNUSED, + struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED, + bfd *nbfd ATTRIBUTE_UNUSED, + asection *nsec ATTRIBUTE_UNUSED, + bfd_vma nval ATTRIBUTE_UNUSED) { - return TRUE; } -static bfd_boolean -simple_dummy_reloc_overflow (link_info, name, reloc_name, addend, abfd, - section, address) - struct bfd_link_info *link_info ATTRIBUTE_UNUSED; - const char *name ATTRIBUTE_UNUSED; - const char *reloc_name ATTRIBUTE_UNUSED; - bfd_vma addend ATTRIBUTE_UNUSED; - bfd *abfd ATTRIBUTE_UNUSED; - asection *section ATTRIBUTE_UNUSED; - bfd_vma address ATTRIBUTE_UNUSED; +static void +simple_dummy_einfo (const char *fmt ATTRIBUTE_UNUSED, ...) { - return TRUE; } -static bfd_boolean -simple_dummy_reloc_dangerous (link_info, message, abfd, section, address) - struct bfd_link_info *link_info ATTRIBUTE_UNUSED; - const char *message ATTRIBUTE_UNUSED; - bfd *abfd ATTRIBUTE_UNUSED; - asection *section ATTRIBUTE_UNUSED; - bfd_vma address ATTRIBUTE_UNUSED; +struct saved_output_info { - return TRUE; + bfd_vma offset; + asection *section; +}; + +struct saved_offsets +{ + unsigned int section_count; + struct saved_output_info *sections; +}; + +/* The sections in ABFD may already have output sections and offsets + set if we are here during linking. + + DWARF-2 specifies offsets into debug sections in many cases and + bfd_simple_get_relocated_section_contents is called to relocate + debug info for a single relocatable object file. So we want + offsets relative to that object file's sections, not offsets in the + output file. For that reason, reset a debug section->output_offset + to zero. + + If not called during linking then set section->output_section to + point back to the input section, because output_section must not be + NULL when calling the relocation routines. + + Save the original output offset and section to restore later. */ + +static void +simple_save_output_info (bfd *abfd ATTRIBUTE_UNUSED, + asection *section, + void *ptr) +{ + struct saved_offsets *saved_offsets = (struct saved_offsets *) ptr; + struct saved_output_info *output_info; + + output_info = &saved_offsets->sections[section->index]; + output_info->offset = section->output_offset; + output_info->section = section->output_section; + if ((section->flags & SEC_DEBUGGING) != 0 + || section->output_section == NULL) + { + section->output_offset = 0; + section->output_section = section; + } } -static bfd_boolean -simple_dummy_unattached_reloc (link_info, name, abfd, section, address) - struct bfd_link_info *link_info ATTRIBUTE_UNUSED; - const char *name ATTRIBUTE_UNUSED; - bfd *abfd ATTRIBUTE_UNUSED; - asection *section ATTRIBUTE_UNUSED; - bfd_vma address ATTRIBUTE_UNUSED; +static void +simple_restore_output_info (bfd *abfd ATTRIBUTE_UNUSED, + asection *section, + void *ptr) { - return TRUE; + struct saved_offsets *saved_offsets = (struct saved_offsets *) ptr; + struct saved_output_info *output_info; + + if (section->index >= saved_offsets->section_count) + return; + + output_info = &saved_offsets->sections[section->index]; + section->output_offset = output_info->offset; + section->output_section = output_info->section; } /* @@ -110,46 +156,42 @@ FUNCTION bfd_simple_relocate_secton SYNOPSIS - bfd_byte *bfd_simple_get_relocated_section_contents (bfd *abfd, asection *sec, bfd_byte *outbuf); + bfd_byte *bfd_simple_get_relocated_section_contents + (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table); DESCRIPTION - Returns the relocated contents of section @var{sec}. Only symbols - from @var{abfd} and the output offsets assigned to sections in - @var{abfd} are used. The result will be stored at @var{outbuf} + Returns the relocated contents of section @var{sec}. The symbols in + @var{symbol_table} will be used, or the symbols from @var{abfd} if + @var{symbol_table} is NULL. The output offsets for debug sections will + be temporarily reset to 0. The result will be stored at @var{outbuf} or allocated with @code{bfd_malloc} if @var{outbuf} is @code{NULL}. - Generally all sections in @var{abfd} should have their - @code{output_section} pointing back to the original section. - Returns @code{NULL} on a fatal error; ignores errors applying particular relocations. */ bfd_byte * -bfd_simple_get_relocated_section_contents (abfd, sec, outbuf) - bfd *abfd; - asection *sec; - bfd_byte *outbuf; +bfd_simple_get_relocated_section_contents (bfd *abfd, + asection *sec, + bfd_byte *outbuf, + asymbol **symbol_table) { struct bfd_link_info link_info; struct bfd_link_order link_order; struct bfd_link_callbacks callbacks; bfd_byte *contents, *data; int storage_needed; - asymbol **symbol_table; + struct saved_offsets saved_offsets; + bfd *link_next; - if (! (sec->flags & SEC_RELOC)) + /* Don't apply relocation on executable and shared library. See + PR 4756. */ + if ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC)) != HAS_RELOC + || ! (sec->flags & SEC_RELOC)) { - bfd_size_type size = bfd_section_size (abfd, sec); - - if (outbuf == NULL) - contents = bfd_malloc (size); - else - contents = outbuf; - - if (contents) - bfd_get_section_contents (abfd, sec, contents, 0, size); - + contents = outbuf; + if (!bfd_get_full_section_contents (abfd, sec, &contents)) + return NULL; return contents; } @@ -158,36 +200,66 @@ bfd_simple_get_relocated_section_contents (abfd, sec, outbuf) /* Fill in the bare minimum number of fields for our purposes. */ memset (&link_info, 0, sizeof (link_info)); + link_info.output_bfd = abfd; link_info.input_bfds = abfd; + link_info.input_bfds_tail = &abfd->link.next; - link_info.hash = bfd_link_hash_table_create (abfd); + link_next = abfd->link.next; + abfd->link.next = NULL; + link_info.hash = _bfd_generic_link_hash_table_create (abfd); link_info.callbacks = &callbacks; callbacks.warning = simple_dummy_warning; callbacks.undefined_symbol = simple_dummy_undefined_symbol; callbacks.reloc_overflow = simple_dummy_reloc_overflow; callbacks.reloc_dangerous = simple_dummy_reloc_dangerous; callbacks.unattached_reloc = simple_dummy_unattached_reloc; + callbacks.multiple_definition = simple_dummy_multiple_definition; + callbacks.einfo = simple_dummy_einfo; memset (&link_order, 0, sizeof (link_order)); link_order.next = NULL; link_order.type = bfd_indirect_link_order; link_order.offset = 0; - link_order.size = bfd_section_size (abfd, sec); + link_order.size = sec->size; link_order.u.indirect.section = sec; data = NULL; if (outbuf == NULL) { - data = bfd_malloc (bfd_section_size (abfd, sec)); + bfd_size_type amt = sec->rawsize > sec->size ? sec->rawsize : sec->size; + data = (bfd_byte *) bfd_malloc (amt); if (data == NULL) - return NULL; + { + _bfd_generic_link_hash_table_free (abfd); + abfd->link.next = link_next; + return NULL; + } outbuf = data; } - bfd_link_add_symbols (abfd, &link_info); - storage_needed = bfd_get_symtab_upper_bound (abfd); - symbol_table = (asymbol **) bfd_malloc (storage_needed); - bfd_canonicalize_symtab (abfd, symbol_table); + saved_offsets.section_count = abfd->section_count; + saved_offsets.sections = malloc (sizeof (*saved_offsets.sections) + * saved_offsets.section_count); + if (saved_offsets.sections == NULL) + { + if (data) + free (data); + _bfd_generic_link_hash_table_free (abfd); + abfd->link.next = link_next; + return NULL; + } + bfd_map_over_sections (abfd, simple_save_output_info, &saved_offsets); + + if (symbol_table == NULL) + { + _bfd_generic_link_add_symbols (abfd, &link_info); + + storage_needed = bfd_get_symtab_upper_bound (abfd); + symbol_table = (asymbol **) bfd_malloc (storage_needed); + bfd_canonicalize_symtab (abfd, symbol_table); + } + else + storage_needed = 0; contents = bfd_get_relocated_section_contents (abfd, &link_info, @@ -198,16 +270,10 @@ bfd_simple_get_relocated_section_contents (abfd, sec, outbuf) if (contents == NULL && data != NULL) free (data); - /* Foul hack to prevent bfd_section_size aborts. This flag only controls - that macro (and the related size macros), selecting between _raw_size - and _cooked_size. Debug sections won't change size while we're only - relocating. There may be trouble here someday if it tries to run - relaxation unexpectedly, so make sure. */ - BFD_ASSERT (sec->_raw_size == sec->_cooked_size); - sec->reloc_done = 0; - - bfd_link_hash_table_free (abfd, link_info.hash); + bfd_map_over_sections (abfd, simple_restore_output_info, &saved_offsets); + free (saved_offsets.sections); - free (symbol_table); + _bfd_generic_link_hash_table_free (abfd); + abfd->link.next = link_next; return contents; }