bfd/simple.c

   1 /* simple.c -- BFD simple client routines
   2    Copyright 2002, 2003, 2004
   3    Free Software Foundation, Inc.
   4    Contributed by MontaVista Software, Inc.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "libbfd.h"
  25 #include "bfdlink.h"
  26
  27 static bfd_boolean
  28 simple_dummy_warning (struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
  29                       const char *warning ATTRIBUTE_UNUSED,
  30                       const char *symbol ATTRIBUTE_UNUSED,
  31                       bfd *abfd ATTRIBUTE_UNUSED,
  32                       asection *section ATTRIBUTE_UNUSED,
  33                       bfd_vma address ATTRIBUTE_UNUSED)
  34 {
  35   return TRUE;
  36 }
  37
  38 static bfd_boolean
  39 simple_dummy_undefined_symbol (struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
  40                                const char *name ATTRIBUTE_UNUSED,
  41                                bfd *abfd ATTRIBUTE_UNUSED,
  42                                asection *section ATTRIBUTE_UNUSED,
  43                                bfd_vma address ATTRIBUTE_UNUSED,
  44                                bfd_boolean fatal ATTRIBUTE_UNUSED)
  45 {
  46   return TRUE;
  47 }
  48
  49 static bfd_boolean
  50 simple_dummy_reloc_overflow (struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
  51                              struct bfd_link_hash_entry *entry ATTRIBUTE_UNUSED,
  52                              const char *name ATTRIBUTE_UNUSED,
  53                              const char *reloc_name ATTRIBUTE_UNUSED,
  54                              bfd_vma addend ATTRIBUTE_UNUSED,
  55                              bfd *abfd ATTRIBUTE_UNUSED,
  56                              asection *section ATTRIBUTE_UNUSED,
  57                              bfd_vma address ATTRIBUTE_UNUSED)
  58 {
  59   return TRUE;
  60 }
  61
  62 static bfd_boolean
  63 simple_dummy_reloc_dangerous (struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
  64                               const char *message ATTRIBUTE_UNUSED,
  65                               bfd *abfd ATTRIBUTE_UNUSED,
  66                               asection *section ATTRIBUTE_UNUSED,
  67                               bfd_vma address ATTRIBUTE_UNUSED)
  68 {
  69   return TRUE;
  70 }
  71
  72 static bfd_boolean
  73 simple_dummy_unattached_reloc (struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
  74                                const char *name ATTRIBUTE_UNUSED,
  75                                bfd *abfd ATTRIBUTE_UNUSED,
  76                                asection *section ATTRIBUTE_UNUSED,
  77                                bfd_vma address ATTRIBUTE_UNUSED)
  78 {
  79   return TRUE;
  80 }
  81
  82 struct saved_output_info
  83 {
  84   bfd_vma offset;
  85   asection *section;
  86 };
  87
  88 static void
  89 simple_save_output_info (bfd *abfd ATTRIBUTE_UNUSED,
  90                          asection *section,
  91                          void *ptr)
  92 {
  93   struct saved_output_info *output_info = ptr;
  94   output_info[section->index].offset = section->output_offset;
  95   output_info[section->index].section = section->output_section;
  96   if ((section->flags & SEC_DEBUGGING) != 0
  97       || section->output_section == NULL)
  98     {
  99       section->output_offset = 0;
 100       section->output_section = section;
 101     }
 102 }
 103
 104 static void
 105 simple_restore_output_info (bfd *abfd ATTRIBUTE_UNUSED,
 106                             asection *section,
 107                             void *ptr)
 108 {
 109   struct saved_output_info *output_info = ptr;
 110   section->output_offset = output_info[section->index].offset;
 111   section->output_section = output_info[section->index].section;
 112 }
 113
 114 /*
 115 FUNCTION
 116         bfd_simple_relocate_secton
 117
 118 SYNOPSIS
 119         bfd_byte *bfd_simple_get_relocated_section_contents
 120           (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table);
 121
 122 DESCRIPTION
 123         Returns the relocated contents of section @var{sec}.  The symbols in
 124         @var{symbol_table} will be used, or the symbols from @var{abfd} if
 125         @var{symbol_table} is NULL.  The output offsets for debug sections will
 126         be temporarily reset to 0.  The result will be stored at @var{outbuf}
 127         or allocated with @code{bfd_malloc} if @var{outbuf} is @code{NULL}.
 128
 129         Returns @code{NULL} on a fatal error; ignores errors applying
 130         particular relocations.
 131 */
 132
 133 bfd_byte *
 134 bfd_simple_get_relocated_section_contents (bfd *abfd,
 135                                            asection *sec,
 136                                            bfd_byte *outbuf,
 137                                            asymbol **symbol_table)
 138 {
 139   struct bfd_link_info link_info;
 140   struct bfd_link_order link_order;
 141   struct bfd_link_callbacks callbacks;
 142   bfd_byte *contents, *data;
 143   int storage_needed;
 144   void *saved_offsets;
 145
 146   if (! (sec->flags & SEC_RELOC))
 147     {
 148       bfd_size_type amt = sec->rawsize > sec->size ? sec->rawsize : sec->size;
 149       bfd_size_type size = sec->rawsize ? sec->rawsize : sec->size;
 150
 151       if (outbuf == NULL)
 152         contents = bfd_malloc (amt);
 153       else
 154         contents = outbuf;
 155
 156       if (contents)
 157         bfd_get_section_contents (abfd, sec, contents, 0, size);
 158
 159       return contents;
 160     }
 161
 162   /* In order to use bfd_get_relocated_section_contents, we need
 163      to forge some data structures that it expects.  */
 164
 165   /* Fill in the bare minimum number of fields for our purposes.  */
 166   memset (&link_info, 0, sizeof (link_info));
 167   link_info.input_bfds = abfd;
 168
 169   link_info.hash = _bfd_generic_link_hash_table_create (abfd);
 170   link_info.callbacks = &callbacks;
 171   callbacks.warning = simple_dummy_warning;
 172   callbacks.undefined_symbol = simple_dummy_undefined_symbol;
 173   callbacks.reloc_overflow = simple_dummy_reloc_overflow;
 174   callbacks.reloc_dangerous = simple_dummy_reloc_dangerous;
 175   callbacks.unattached_reloc = simple_dummy_unattached_reloc;
 176
 177   memset (&link_order, 0, sizeof (link_order));
 178   link_order.next = NULL;
 179   link_order.type = bfd_indirect_link_order;
 180   link_order.offset = 0;
 181   link_order.size = sec->size;
 182   link_order.u.indirect.section = sec;
 183
 184   data = NULL;
 185   if (outbuf == NULL)
 186     {
 187       data = bfd_malloc (sec->size);
 188       if (data == NULL)
 189         return NULL;
 190       outbuf = data;
 191     }
 192
 193   /* The sections in ABFD may already have output sections and offsets set.
 194      Because this function is primarily for debug sections, and GCC uses the
 195      knowledge that debug sections will generally have VMA 0 when emitting
 196      relocations between DWARF-2 sections (which are supposed to be
 197      section-relative offsets anyway), we need to reset the output offsets
 198      to zero.  We also need to arrange for section->output_section->vma plus
 199      section->output_offset to equal section->vma, which we do by setting
 200      section->output_section to point back to section.  Save the original
 201      output offset and output section to restore later.  */
 202   saved_offsets = malloc (sizeof (struct saved_output_info)
 203                           * abfd->section_count);
 204   if (saved_offsets == NULL)
 205     {
 206       if (data)
 207         free (data);
 208       return NULL;
 209     }
 210   bfd_map_over_sections (abfd, simple_save_output_info, saved_offsets);
 211
 212   if (symbol_table == NULL)
 213     {
 214       _bfd_generic_link_add_symbols (abfd, &link_info);
 215
 216       storage_needed = bfd_get_symtab_upper_bound (abfd);
 217       symbol_table = bfd_malloc (storage_needed);
 218       bfd_canonicalize_symtab (abfd, symbol_table);
 219     }
 220   else
 221     storage_needed = 0;
 222
 223   contents = bfd_get_relocated_section_contents (abfd,
 224                                                  &link_info,
 225                                                  &link_order,
 226                                                  outbuf,
 227                                                  0,
 228                                                  symbol_table);
 229   if (contents == NULL && data != NULL)
 230     free (data);
 231
 232 #if 0
 233   /* NOTE: cagney/2003-04-05: This free, which was introduced on
 234      2003-03-31 to stop a memory leak, caused a memory corruption
 235      between GDB and BFD.  The problem, which is stabs specific, can
 236      be identified by a bunch of failures in relocate.exp vis:
 237
 238        gdb.base/relocate.exp: get address of static_bar
 239
 240      Details of the problem can be found on the binutils@ mailing
 241      list, see the discussion thread: "gdb.mi/mi-cli.exp failures".  */
 242   if (storage_needed != 0)
 243     free (symbol_table);
 244 #endif
 245
 246   bfd_map_over_sections (abfd, simple_restore_output_info, saved_offsets);
 247   free (saved_offsets);
 248
 249   _bfd_generic_link_hash_table_free (link_info.hash);
 250
 251   return contents;
 252 }