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