bfd/simple.c

   1 /* simple.c -- BFD simple client routines
   2    Copyright 2002, 2003, 2004, 2005
   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 static bfd_boolean
  83 simple_dummy_multiple_definition (struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
  84                                   const char *name ATTRIBUTE_UNUSED,
  85                                   bfd *obfd ATTRIBUTE_UNUSED,
  86                                   asection *osec ATTRIBUTE_UNUSED,
  87                                   bfd_vma oval ATTRIBUTE_UNUSED,
  88                                   bfd *nbfd ATTRIBUTE_UNUSED,
  89                                   asection *nsec ATTRIBUTE_UNUSED,
  90                                   bfd_vma nval ATTRIBUTE_UNUSED)
  91 {
  92   return TRUE;
  93 }
  94
  95 struct saved_output_info
  96 {
  97   bfd_vma offset;
  98   asection *section;
  99 };
 100
 101 static void
 102 simple_save_output_info (bfd *abfd ATTRIBUTE_UNUSED,
 103                          asection *section,
 104                          void *ptr)
 105 {
 106   struct saved_output_info *output_info = ptr;
 107   output_info[section->index].offset = section->output_offset;
 108   output_info[section->index].section = section->output_section;
 109   if ((section->flags & SEC_DEBUGGING) != 0
 110       || section->output_section == NULL)
 111     {
 112       section->output_offset = 0;
 113       section->output_section = section;
 114     }
 115 }
 116
 117 static void
 118 simple_restore_output_info (bfd *abfd ATTRIBUTE_UNUSED,
 119                             asection *section,
 120                             void *ptr)
 121 {
 122   struct saved_output_info *output_info = ptr;
 123   section->output_offset = output_info[section->index].offset;
 124   section->output_section = output_info[section->index].section;
 125 }
 126
 127 /*
 128 FUNCTION
 129         bfd_simple_relocate_secton
 130
 131 SYNOPSIS
 132         bfd_byte *bfd_simple_get_relocated_section_contents
 133           (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table);
 134
 135 DESCRIPTION
 136         Returns the relocated contents of section @var{sec}.  The symbols in
 137         @var{symbol_table} will be used, or the symbols from @var{abfd} if
 138         @var{symbol_table} is NULL.  The output offsets for debug sections will
 139         be temporarily reset to 0.  The result will be stored at @var{outbuf}
 140         or allocated with @code{bfd_malloc} if @var{outbuf} is @code{NULL}.
 141
 142         Returns @code{NULL} on a fatal error; ignores errors applying
 143         particular relocations.
 144 */
 145
 146 bfd_byte *
 147 bfd_simple_get_relocated_section_contents (bfd *abfd,
 148                                            asection *sec,
 149                                            bfd_byte *outbuf,
 150                                            asymbol **symbol_table)
 151 {
 152   struct bfd_link_info link_info;
 153   struct bfd_link_order link_order;
 154   struct bfd_link_callbacks callbacks;
 155   bfd_byte *contents, *data;
 156   int storage_needed;
 157   void *saved_offsets;
 158
 159   if (! (sec->flags & SEC_RELOC))
 160     {
 161       bfd_size_type amt = sec->rawsize > sec->size ? sec->rawsize : sec->size;
 162       bfd_size_type size = sec->rawsize ? sec->rawsize : sec->size;
 163
 164       if (outbuf == NULL)
 165         contents = bfd_malloc (amt);
 166       else
 167         contents = outbuf;
 168
 169       if (contents)
 170         bfd_get_section_contents (abfd, sec, contents, 0, size);
 171
 172       return contents;
 173     }
 174
 175   /* In order to use bfd_get_relocated_section_contents, we need
 176      to forge some data structures that it expects.  */
 177
 178   /* Fill in the bare minimum number of fields for our purposes.  */
 179   memset (&link_info, 0, sizeof (link_info));
 180   link_info.input_bfds = abfd;
 181
 182   link_info.hash = _bfd_generic_link_hash_table_create (abfd);
 183   link_info.callbacks = &callbacks;
 184   callbacks.warning = simple_dummy_warning;
 185   callbacks.undefined_symbol = simple_dummy_undefined_symbol;
 186   callbacks.reloc_overflow = simple_dummy_reloc_overflow;
 187   callbacks.reloc_dangerous = simple_dummy_reloc_dangerous;
 188   callbacks.unattached_reloc = simple_dummy_unattached_reloc;
 189   callbacks.multiple_definition = simple_dummy_multiple_definition;
 190
 191   memset (&link_order, 0, sizeof (link_order));
 192   link_order.next = NULL;
 193   link_order.type = bfd_indirect_link_order;
 194   link_order.offset = 0;
 195   link_order.size = sec->size;
 196   link_order.u.indirect.section = sec;
 197
 198   data = NULL;
 199   if (outbuf == NULL)
 200     {
 201       data = bfd_malloc (sec->size);
 202       if (data == NULL)
 203         return NULL;
 204       outbuf = data;
 205     }
 206
 207   /* The sections in ABFD may already have output sections and offsets set.
 208      Because this function is primarily for debug sections, and GCC uses the
 209      knowledge that debug sections will generally have VMA 0 when emitting
 210      relocations between DWARF-2 sections (which are supposed to be
 211      section-relative offsets anyway), we need to reset the output offsets
 212      to zero.  We also need to arrange for section->output_section->vma plus
 213      section->output_offset to equal section->vma, which we do by setting
 214      section->output_section to point back to section.  Save the original
 215      output offset and output section to restore later.  */
 216   saved_offsets = malloc (sizeof (struct saved_output_info)
 217                           * abfd->section_count);
 218   if (saved_offsets == NULL)
 219     {
 220       if (data)
 221         free (data);
 222       return NULL;
 223     }
 224   bfd_map_over_sections (abfd, simple_save_output_info, saved_offsets);
 225
 226   if (symbol_table == NULL)
 227     {
 228       _bfd_generic_link_add_symbols (abfd, &link_info);
 229
 230       storage_needed = bfd_get_symtab_upper_bound (abfd);
 231       symbol_table = bfd_malloc (storage_needed);
 232       bfd_canonicalize_symtab (abfd, symbol_table);
 233     }
 234   else
 235     storage_needed = 0;
 236
 237   contents = bfd_get_relocated_section_contents (abfd,
 238                                                  &link_info,
 239                                                  &link_order,
 240                                                  outbuf,
 241                                                  0,
 242                                                  symbol_table);
 243   if (contents == NULL && data != NULL)
 244     free (data);
 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   return contents;
 251 }