bfd/bfd.c

   1 /* Generic BFD library interface and support routines.
   2    Copyright (C) 1990-2021 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 /*
  23 INODE
  24 typedef bfd, Error reporting, BFD front end, BFD front end
  25
  26 SECTION
  27         <<typedef bfd>>
  28
  29         A BFD has type <<bfd>>; objects of this type are the
  30         cornerstone of any application using BFD. Using BFD
  31         consists of making references though the BFD and to data in the BFD.
  32
  33         Here is the structure that defines the type <<bfd>>.  It
  34         contains the major data about the file and pointers
  35         to the rest of the data.
  36
  37 CODE_FRAGMENT
  38 .
  39 .enum bfd_direction
  40 .  {
  41 .    no_direction = 0,
  42 .    read_direction = 1,
  43 .    write_direction = 2,
  44 .    both_direction = 3
  45 .  };
  46 .
  47 .enum bfd_plugin_format
  48 .  {
  49 .    bfd_plugin_unknown = 0,
  50 .    bfd_plugin_yes = 1,
  51 .    bfd_plugin_no = 2
  52 .  };
  53 .
  54 .struct bfd_build_id
  55 .  {
  56 .    bfd_size_type size;
  57 .    bfd_byte data[1];
  58 .  };
  59 .
  60 .struct bfd
  61 .{
  62 .  {* The filename the application opened the BFD with.  *}
  63 .  const char *filename;
  64 .
  65 .  {* A pointer to the target jump table.  *}
  66 .  const struct bfd_target *xvec;
  67 .
  68 .  {* The IOSTREAM, and corresponding IO vector that provide access
  69 .     to the file backing the BFD.  *}
  70 .  void *iostream;
  71 .  const struct bfd_iovec *iovec;
  72 .
  73 .  {* The caching routines use these to maintain a
  74 .     least-recently-used list of BFDs.  *}
  75 .  struct bfd *lru_prev, *lru_next;
  76 .
  77 .  {* Track current file position (or current buffer offset for
  78 .     in-memory BFDs).  When a file is closed by the caching routines,
  79 .     BFD retains state information on the file here.  *}
  80 .  ufile_ptr where;
  81 .
  82 .  {* File modified time, if mtime_set is TRUE.  *}
  83 .  long mtime;
  84 .
  85 .  {* A unique identifier of the BFD  *}
  86 .  unsigned int id;
  87 .
  88 .  {* Format_specific flags.  *}
  89 .  flagword flags;
  90 .
  91 .  {* Values that may appear in the flags field of a BFD.  These also
  92 .     appear in the object_flags field of the bfd_target structure, where
  93 .     they indicate the set of flags used by that backend (not all flags
  94 .     are meaningful for all object file formats) (FIXME: at the moment,
  95 .     the object_flags values have mostly just been copied from backend
  96 .     to another, and are not necessarily correct).  *}
  97 .
  98 .#define BFD_NO_FLAGS                0x0
  99 .
 100 .  {* BFD contains relocation entries.  *}
 101 .#define HAS_RELOC                   0x1
 102 .
 103 .  {* BFD is directly executable.  *}
 104 .#define EXEC_P                      0x2
 105 .
 106 .  {* BFD has line number information (basically used for F_LNNO in a
 107 .     COFF header).  *}
 108 .#define HAS_LINENO                  0x4
 109 .
 110 .  {* BFD has debugging information.  *}
 111 .#define HAS_DEBUG                  0x08
 112 .
 113 .  {* BFD has symbols.  *}
 114 .#define HAS_SYMS                   0x10
 115 .
 116 .  {* BFD has local symbols (basically used for F_LSYMS in a COFF
 117 .     header).  *}
 118 .#define HAS_LOCALS                 0x20
 119 .
 120 .  {* BFD is a dynamic object.  *}
 121 .#define DYNAMIC                    0x40
 122 .
 123 .  {* Text section is write protected (if D_PAGED is not set, this is
 124 .     like an a.out NMAGIC file) (the linker sets this by default, but
 125 .     clears it for -r or -N).  *}
 126 .#define WP_TEXT                    0x80
 127 .
 128 .  {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 129 .     linker sets this by default, but clears it for -r or -n or -N).  *}
 130 .#define D_PAGED                   0x100
 131 .
 132 .  {* BFD is relaxable (this means that bfd_relax_section may be able to
 133 .     do something) (sometimes bfd_relax_section can do something even if
 134 .     this is not set).  *}
 135 .#define BFD_IS_RELAXABLE          0x200
 136 .
 137 .  {* This may be set before writing out a BFD to request using a
 138 .     traditional format.  For example, this is used to request that when
 139 .     writing out an a.out object the symbols not be hashed to eliminate
 140 .     duplicates.  *}
 141 .#define BFD_TRADITIONAL_FORMAT    0x400
 142 .
 143 .  {* This flag indicates that the BFD contents are actually cached
 144 .     in memory.  If this is set, iostream points to a bfd_in_memory
 145 .     struct.  *}
 146 .#define BFD_IN_MEMORY             0x800
 147 .
 148 .  {* This BFD has been created by the linker and doesn't correspond
 149 .     to any input file.  *}
 150 .#define BFD_LINKER_CREATED       0x1000
 151 .
 152 .  {* This may be set before writing out a BFD to request that it
 153 .     be written using values for UIDs, GIDs, timestamps, etc. that
 154 .     will be consistent from run to run.  *}
 155 .#define BFD_DETERMINISTIC_OUTPUT 0x2000
 156 .
 157 .  {* Compress sections in this BFD.  *}
 158 .#define BFD_COMPRESS             0x4000
 159 .
 160 .  {* Decompress sections in this BFD.  *}
 161 .#define BFD_DECOMPRESS           0x8000
 162 .
 163 .  {* BFD is a dummy, for plugins.  *}
 164 .#define BFD_PLUGIN              0x10000
 165 .
 166 .  {* Compress sections in this BFD with SHF_COMPRESSED from gABI.  *}
 167 .#define BFD_COMPRESS_GABI       0x20000
 168 .
 169 .  {* Convert ELF common symbol type to STT_COMMON or STT_OBJECT in this
 170 .     BFD.  *}
 171 .#define BFD_CONVERT_ELF_COMMON  0x40000
 172 .
 173 .  {* Use the ELF STT_COMMON type in this BFD.  *}
 174 .#define BFD_USE_ELF_STT_COMMON  0x80000
 175 .
 176 .  {* Put pathnames into archives (non-POSIX).  *}
 177 .#define BFD_ARCHIVE_FULL_PATH  0x100000
 178 .
 179 .  {* Flags bits to be saved in bfd_preserve_save.  *}
 180 .#define BFD_FLAGS_SAVED \
 181 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
 182 .   | BFD_PLUGIN | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON \
 183 .   | BFD_USE_ELF_STT_COMMON)
 184 .
 185 .  {* Flags bits which are for BFD use only.  *}
 186 .#define BFD_FLAGS_FOR_BFD_USE_MASK \
 187 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
 188 .   | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT \
 189 .   | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON)
 190 .
 191 .  {* The format which belongs to the BFD. (object, core, etc.)  *}
 192 .  ENUM_BITFIELD (bfd_format) format : 3;
 193 .
 194 .  {* The direction with which the BFD was opened.  *}
 195 .  ENUM_BITFIELD (bfd_direction) direction : 2;
 196 .
 197 .  {* Is the file descriptor being cached?  That is, can it be closed as
 198 .     needed, and re-opened when accessed later?  *}
 199 .  unsigned int cacheable : 1;
 200 .
 201 .  {* Marks whether there was a default target specified when the
 202 .     BFD was opened. This is used to select which matching algorithm
 203 .     to use to choose the back end.  *}
 204 .  unsigned int target_defaulted : 1;
 205 .
 206 .  {* ... and here: (``once'' means at least once).  *}
 207 .  unsigned int opened_once : 1;
 208 .
 209 .  {* Set if we have a locally maintained mtime value, rather than
 210 .     getting it from the file each time.  *}
 211 .  unsigned int mtime_set : 1;
 212 .
 213 .  {* Flag set if symbols from this BFD should not be exported.  *}
 214 .  unsigned int no_export : 1;
 215 .
 216 .  {* Remember when output has begun, to stop strange things
 217 .     from happening.  *}
 218 .  unsigned int output_has_begun : 1;
 219 .
 220 .  {* Have archive map.  *}
 221 .  unsigned int has_armap : 1;
 222 .
 223 .  {* Set if this is a thin archive.  *}
 224 .  unsigned int is_thin_archive : 1;
 225 .
 226 .  {* Set if this archive should not cache element positions.  *}
 227 .  unsigned int no_element_cache : 1;
 228 .
 229 .  {* Set if only required symbols should be added in the link hash table for
 230 .     this object.  Used by VMS linkers.  *}
 231 .  unsigned int selective_search : 1;
 232 .
 233 .  {* Set if this is the linker output BFD.  *}
 234 .  unsigned int is_linker_output : 1;
 235 .
 236 .  {* Set if this is the linker input BFD.  *}
 237 .  unsigned int is_linker_input : 1;
 238 .
 239 .  {* If this is an input for a compiler plug-in library.  *}
 240 .  ENUM_BITFIELD (bfd_plugin_format) plugin_format : 2;
 241 .
 242 .  {* Set if this is a plugin output file.  *}
 243 .  unsigned int lto_output : 1;
 244 .
 245 .  {* Set if this is a slim LTO object not loaded with a compiler plugin.  *}
 246 .  unsigned int lto_slim_object : 1;
 247 .
 248 .  {* Do not attempt to modify this file.  Set when detecting errors
 249 .     that BFD is not prepared to handle for objcopy/strip.  *}
 250 .  unsigned int read_only : 1;
 251 .
 252 .  {* Set to dummy BFD created when claimed by a compiler plug-in
 253 .     library.  *}
 254 .  bfd *plugin_dummy_bfd;
 255 .
 256 .  {* The offset of this bfd in the file, typically 0 if it is not
 257 .     contained in an archive.  *}
 258 .  ufile_ptr origin;
 259 .
 260 .  {* The origin in the archive of the proxy entry.  This will
 261 .     normally be the same as origin, except for thin archives,
 262 .     when it will contain the current offset of the proxy in the
 263 .     thin archive rather than the offset of the bfd in its actual
 264 .     container.  *}
 265 .  ufile_ptr proxy_origin;
 266 .
 267 .  {* A hash table for section names.  *}
 268 .  struct bfd_hash_table section_htab;
 269 .
 270 .  {* Pointer to linked list of sections.  *}
 271 .  struct bfd_section *sections;
 272 .
 273 .  {* The last section on the section list.  *}
 274 .  struct bfd_section *section_last;
 275 .
 276 .  {* The number of sections.  *}
 277 .  unsigned int section_count;
 278 .
 279 .  {* A field used by _bfd_generic_link_add_archive_symbols.  This will
 280 .     be used only for archive elements.  *}
 281 .  int archive_pass;
 282 .
 283 .  {* Stuff only useful for object files:
 284 .     The start address.  *}
 285 .  bfd_vma start_address;
 286 .
 287 .  {* Symbol table for output BFD (with symcount entries).
 288 .     Also used by the linker to cache input BFD symbols.  *}
 289 .  struct bfd_symbol **outsymbols;
 290 .
 291 .  {* Used for input and output.  *}
 292 .  unsigned int symcount;
 293 .
 294 .  {* Used for slurped dynamic symbol tables.  *}
 295 .  unsigned int dynsymcount;
 296 .
 297 .  {* Pointer to structure which contains architecture information.  *}
 298 .  const struct bfd_arch_info *arch_info;
 299 .
 300 .  {* Cached length of file for bfd_get_size.  0 until bfd_get_size is
 301 .     called, 1 if stat returns an error or the file size is too large to
 302 .     return in ufile_ptr.  Both 0 and 1 should be treated as "unknown".  *}
 303 .  ufile_ptr size;
 304 .
 305 .  {* Stuff only useful for archives.  *}
 306 .  void *arelt_data;
 307 .  struct bfd *my_archive;      {* The containing archive BFD.  *}
 308 .  struct bfd *archive_next;    {* The next BFD in the archive.  *}
 309 .  struct bfd *archive_head;    {* The first BFD in the archive.  *}
 310 .  struct bfd *nested_archives; {* List of nested archive in a flattened
 311 .                                  thin archive.  *}
 312 .
 313 .  union {
 314 .    {* For input BFDs, a chain of BFDs involved in a link.  *}
 315 .    struct bfd *next;
 316 .    {* For output BFD, the linker hash table.  *}
 317 .    struct bfd_link_hash_table *hash;
 318 .  } link;
 319 .
 320 .  {* Used by the back end to hold private data.  *}
 321 .  union
 322 .    {
 323 .      struct aout_data_struct *aout_data;
 324 .      struct artdata *aout_ar_data;
 325 .      struct coff_tdata *coff_obj_data;
 326 .      struct pe_tdata *pe_obj_data;
 327 .      struct xcoff_tdata *xcoff_obj_data;
 328 .      struct ecoff_tdata *ecoff_obj_data;
 329 .      struct srec_data_struct *srec_data;
 330 .      struct verilog_data_struct *verilog_data;
 331 .      struct ihex_data_struct *ihex_data;
 332 .      struct tekhex_data_struct *tekhex_data;
 333 .      struct elf_obj_tdata *elf_obj_data;
 334 .      struct mmo_data_struct *mmo_data;
 335 .      struct sun_core_struct *sun_core_data;
 336 .      struct sco5_core_struct *sco5_core_data;
 337 .      struct trad_core_struct *trad_core_data;
 338 .      struct som_data_struct *som_data;
 339 .      struct hpux_core_struct *hpux_core_data;
 340 .      struct hppabsd_core_struct *hppabsd_core_data;
 341 .      struct sgi_core_struct *sgi_core_data;
 342 .      struct lynx_core_struct *lynx_core_data;
 343 .      struct osf_core_struct *osf_core_data;
 344 .      struct cisco_core_struct *cisco_core_data;
 345 .      struct versados_data_struct *versados_data;
 346 .      struct netbsd_core_struct *netbsd_core_data;
 347 .      struct mach_o_data_struct *mach_o_data;
 348 .      struct mach_o_fat_data_struct *mach_o_fat_data;
 349 .      struct plugin_data_struct *plugin_data;
 350 .      struct bfd_pef_data_struct *pef_data;
 351 .      struct bfd_pef_xlib_data_struct *pef_xlib_data;
 352 .      struct bfd_sym_data_struct *sym_data;
 353 .      void *any;
 354 .    }
 355 .  tdata;
 356 .
 357 .  {* Used by the application to hold private data.  *}
 358 .  void *usrdata;
 359 .
 360 .  {* Where all the allocated stuff under this BFD goes.  This is a
 361 .     struct objalloc *, but we use void * to avoid requiring the inclusion
 362 .     of objalloc.h.  *}
 363 .  void *memory;
 364 .
 365 .  {* For input BFDs, the build ID, if the object has one. *}
 366 .  const struct bfd_build_id *build_id;
 367 .};
 368 .
 369 .static inline const char *
 370 .bfd_get_filename (const bfd *abfd)
 371 .{
 372 .  return abfd->filename;
 373 .}
 374 .
 375 .static inline bfd_boolean
 376 .bfd_get_cacheable (const bfd *abfd)
 377 .{
 378 .  return abfd->cacheable;
 379 .}
 380 .
 381 .static inline enum bfd_format
 382 .bfd_get_format (const bfd *abfd)
 383 .{
 384 .  return abfd->format;
 385 .}
 386 .
 387 .static inline flagword
 388 .bfd_get_file_flags (const bfd *abfd)
 389 .{
 390 .  return abfd->flags;
 391 .}
 392 .
 393 .static inline bfd_vma
 394 .bfd_get_start_address (const bfd *abfd)
 395 .{
 396 .  return abfd->start_address;
 397 .}
 398 .
 399 .static inline unsigned int
 400 .bfd_get_symcount (const bfd *abfd)
 401 .{
 402 .  return abfd->symcount;
 403 .}
 404 .
 405 .static inline unsigned int
 406 .bfd_get_dynamic_symcount (const bfd *abfd)
 407 .{
 408 .  return abfd->dynsymcount;
 409 .}
 410 .
 411 .static inline struct bfd_symbol **
 412 .bfd_get_outsymbols (const bfd *abfd)
 413 .{
 414 .  return abfd->outsymbols;
 415 .}
 416 .
 417 .static inline unsigned int
 418 .bfd_count_sections (const bfd *abfd)
 419 .{
 420 .  return abfd->section_count;
 421 .}
 422 .
 423 .static inline bfd_boolean
 424 .bfd_has_map (const bfd *abfd)
 425 .{
 426 .  return abfd->has_armap;
 427 .}
 428 .
 429 .static inline bfd_boolean
 430 .bfd_is_thin_archive (const bfd *abfd)
 431 .{
 432 .  return abfd->is_thin_archive;
 433 .}
 434 .
 435 .static inline void *
 436 .bfd_usrdata (const bfd *abfd)
 437 .{
 438 .  return abfd->usrdata;
 439 .}
 440 .
 441 .{* See note beside bfd_set_section_userdata.  *}
 442 .static inline bfd_boolean
 443 .bfd_set_cacheable (bfd * abfd, bfd_boolean val)
 444 .{
 445 .  abfd->cacheable = val;
 446 .  return TRUE;
 447 .}
 448 .
 449 .static inline void
 450 .bfd_set_thin_archive (bfd *abfd, bfd_boolean val)
 451 .{
 452 .  abfd->is_thin_archive = val;
 453 .}
 454 .
 455 .static inline void
 456 .bfd_set_usrdata (bfd *abfd, void *val)
 457 .{
 458 .  abfd->usrdata = val;
 459 .}
 460 .
 461 .static inline asection *
 462 .bfd_asymbol_section (const asymbol *sy)
 463 .{
 464 .  return sy->section;
 465 .}
 466 .
 467 .static inline bfd_vma
 468 .bfd_asymbol_value (const asymbol *sy)
 469 .{
 470 .  return sy->section->vma + sy->value;
 471 .}
 472 .
 473 .static inline const char *
 474 .bfd_asymbol_name (const asymbol *sy)
 475 .{
 476 .  return sy->name;
 477 .}
 478 .
 479 .static inline struct bfd *
 480 .bfd_asymbol_bfd (const asymbol *sy)
 481 .{
 482 .  return sy->the_bfd;
 483 .}
 484 .
 485 .static inline void
 486 .bfd_set_asymbol_name (asymbol *sy, const char *name)
 487 .{
 488 .  sy->name = name;
 489 .}
 490 .
 491 .static inline bfd_size_type
 492 .bfd_get_section_limit_octets (const bfd *abfd, const asection *sec)
 493 .{
 494 .  if (abfd->direction != write_direction && sec->rawsize != 0)
 495 .    return sec->rawsize;
 496 .  return sec->size;
 497 .}
 498 .
 499 .{* Find the address one past the end of SEC.  *}
 500 .static inline bfd_size_type
 501 .bfd_get_section_limit (const bfd *abfd, const asection *sec)
 502 .{
 503 .  return (bfd_get_section_limit_octets (abfd, sec)
 504 .          / bfd_octets_per_byte (abfd, sec));
 505 .}
 506 .
 507 .{* Functions to handle insertion and deletion of a bfd's sections.  These
 508 .   only handle the list pointers, ie. do not adjust section_count,
 509 .   target_index etc.  *}
 510 .static inline void
 511 .bfd_section_list_remove (bfd *abfd, asection *s)
 512 .{
 513 .  asection *next = s->next;
 514 .  asection *prev = s->prev;
 515 .  if (prev)
 516 .    prev->next = next;
 517 .  else
 518 .    abfd->sections = next;
 519 .  if (next)
 520 .    next->prev = prev;
 521 .  else
 522 .    abfd->section_last = prev;
 523 .}
 524 .
 525 .static inline void
 526 .bfd_section_list_append (bfd *abfd, asection *s)
 527 .{
 528 .  s->next = 0;
 529 .  if (abfd->section_last)
 530 .    {
 531 .      s->prev = abfd->section_last;
 532 .      abfd->section_last->next = s;
 533 .    }
 534 .  else
 535 .    {
 536 .      s->prev = 0;
 537 .      abfd->sections = s;
 538 .    }
 539 .  abfd->section_last = s;
 540 .}
 541 .
 542 .static inline void
 543 .bfd_section_list_prepend (bfd *abfd, asection *s)
 544 .{
 545 .  s->prev = 0;
 546 .  if (abfd->sections)
 547 .    {
 548 .      s->next = abfd->sections;
 549 .      abfd->sections->prev = s;
 550 .    }
 551 .  else
 552 .    {
 553 .      s->next = 0;
 554 .      abfd->section_last = s;
 555 .    }
 556 .  abfd->sections = s;
 557 .}
 558 .
 559 .static inline void
 560 .bfd_section_list_insert_after (bfd *abfd, asection *a, asection *s)
 561 .{
 562 .  asection *next = a->next;
 563 .  s->next = next;
 564 .  s->prev = a;
 565 .  a->next = s;
 566 .  if (next)
 567 .    next->prev = s;
 568 .  else
 569 .    abfd->section_last = s;
 570 .}
 571 .
 572 .static inline void
 573 .bfd_section_list_insert_before (bfd *abfd, asection *b, asection *s)
 574 .{
 575 .  asection *prev = b->prev;
 576 .  s->prev = prev;
 577 .  s->next = b;
 578 .  b->prev = s;
 579 .  if (prev)
 580 .    prev->next = s;
 581 .  else
 582 .    abfd->sections = s;
 583 .}
 584 .
 585 .static inline bfd_boolean
 586 .bfd_section_removed_from_list (const bfd *abfd, const asection *s)
 587 .{
 588 .  return s->next ? s->next->prev != s : abfd->section_last != s;
 589 .}
 590 .
 591 */
 592
 593 #include "sysdep.h"
 594 #include <stdarg.h>
 595 #include "bfd.h"
 596 #include "bfdver.h"
 597 #include "libiberty.h"
 598 #include "demangle.h"
 599 #include "safe-ctype.h"
 600 #include "bfdlink.h"
 601 #include "libbfd.h"
 602 #include "coff/internal.h"
 603 #include "coff/sym.h"
 604 #include "libcoff.h"
 605 #include "libecoff.h"
 606 #undef obj_symbols
 607 #include "elf-bfd.h"
 608
 609 #ifndef EXIT_FAILURE
 610 #define EXIT_FAILURE 1
 611 #endif
 612
 613 \f
 614 /* provide storage for subsystem, stack and heap data which may have been
 615    passed in on the command line.  Ld puts this data into a bfd_link_info
 616    struct which ultimately gets passed in to the bfd.  When it arrives, copy
 617    it to the following struct so that the data will be available in coffcode.h
 618    where it is needed.  The typedef's used are defined in bfd.h */
 619 \f
 620 /*
 621 INODE
 622 Error reporting, Miscellaneous, typedef bfd, BFD front end
 623
 624 SECTION
 625         Error reporting
 626
 627         Most BFD functions return nonzero on success (check their
 628         individual documentation for precise semantics).  On an error,
 629         they call <<bfd_set_error>> to set an error condition that callers
 630         can check by calling <<bfd_get_error>>.
 631         If that returns <<bfd_error_system_call>>, then check
 632         <<errno>>.
 633
 634         The easiest way to report a BFD error to the user is to
 635         use <<bfd_perror>>.
 636
 637 SUBSECTION
 638         Type <<bfd_error_type>>
 639
 640         The values returned by <<bfd_get_error>> are defined by the
 641         enumerated type <<bfd_error_type>>.
 642
 643 CODE_FRAGMENT
 644 .
 645 .typedef enum bfd_error
 646 .{
 647 .  bfd_error_no_error = 0,
 648 .  bfd_error_system_call,
 649 .  bfd_error_invalid_target,
 650 .  bfd_error_wrong_format,
 651 .  bfd_error_wrong_object_format,
 652 .  bfd_error_invalid_operation,
 653 .  bfd_error_no_memory,
 654 .  bfd_error_no_symbols,
 655 .  bfd_error_no_armap,
 656 .  bfd_error_no_more_archived_files,
 657 .  bfd_error_malformed_archive,
 658 .  bfd_error_missing_dso,
 659 .  bfd_error_file_not_recognized,
 660 .  bfd_error_file_ambiguously_recognized,
 661 .  bfd_error_no_contents,
 662 .  bfd_error_nonrepresentable_section,
 663 .  bfd_error_no_debug_section,
 664 .  bfd_error_bad_value,
 665 .  bfd_error_file_truncated,
 666 .  bfd_error_file_too_big,
 667 .  bfd_error_sorry,
 668 .  bfd_error_on_input,
 669 .  bfd_error_invalid_error_code
 670 .}
 671 .bfd_error_type;
 672 .
 673 */
 674
 675 static bfd_error_type bfd_error = bfd_error_no_error;
 676 static bfd *input_bfd = NULL;
 677 static bfd_error_type input_error = bfd_error_no_error;
 678
 679 const char *const bfd_errmsgs[] =
 680 {
 681   N_("no error"),
 682   N_("system call error"),
 683   N_("invalid bfd target"),
 684   N_("file in wrong format"),
 685   N_("archive object file in wrong format"),
 686   N_("invalid operation"),
 687   N_("memory exhausted"),
 688   N_("no symbols"),
 689   N_("archive has no index; run ranlib to add one"),
 690   N_("no more archived files"),
 691   N_("malformed archive"),
 692   N_("DSO missing from command line"),
 693   N_("file format not recognized"),
 694   N_("file format is ambiguous"),
 695   N_("section has no contents"),
 696   N_("nonrepresentable section on output"),
 697   N_("symbol needs debug section which does not exist"),
 698   N_("bad value"),
 699   N_("file truncated"),
 700   N_("file too big"),
 701   N_("sorry, cannot handle this file"),
 702   N_("error reading %s: %s"),
 703   N_("#<invalid error code>")
 704 };
 705
 706 /*
 707 FUNCTION
 708         bfd_get_error
 709
 710 SYNOPSIS
 711         bfd_error_type bfd_get_error (void);
 712
 713 DESCRIPTION
 714         Return the current BFD error condition.
 715 */
 716
 717 bfd_error_type
 718 bfd_get_error (void)
 719 {
 720   return bfd_error;
 721 }
 722
 723 /*
 724 FUNCTION
 725         bfd_set_error
 726
 727 SYNOPSIS
 728         void bfd_set_error (bfd_error_type error_tag);
 729
 730 DESCRIPTION
 731         Set the BFD error condition to be @var{error_tag}.
 732
 733         @var{error_tag} must not be bfd_error_on_input.  Use
 734         bfd_set_input_error for input errors instead.
 735 */
 736
 737 void
 738 bfd_set_error (bfd_error_type error_tag)
 739 {
 740   bfd_error = error_tag;
 741   if (bfd_error >= bfd_error_on_input)
 742     abort ();
 743 }
 744
 745 /*
 746 FUNCTION
 747         bfd_set_input_error
 748
 749 SYNOPSIS
 750         void bfd_set_input_error (bfd *input, bfd_error_type error_tag);
 751
 752 DESCRIPTION
 753
 754         Set the BFD error condition to be bfd_error_on_input.
 755         @var{input} is the input bfd where the error occurred, and
 756         @var{error_tag} the bfd_error_type error.
 757 */
 758
 759 void
 760 bfd_set_input_error (bfd *input, bfd_error_type error_tag)
 761 {
 762   /* This is an error that occurred during bfd_close when writing an
 763      archive, but on one of the input files.  */
 764   bfd_error = bfd_error_on_input;
 765   input_bfd = input;
 766   input_error = error_tag;
 767   if (input_error >= bfd_error_on_input)
 768     abort ();
 769 }
 770
 771 /*
 772 FUNCTION
 773         bfd_errmsg
 774
 775 SYNOPSIS
 776         const char *bfd_errmsg (bfd_error_type error_tag);
 777
 778 DESCRIPTION
 779         Return a string describing the error @var{error_tag}, or
 780         the system error if @var{error_tag} is <<bfd_error_system_call>>.
 781 */
 782
 783 const char *
 784 bfd_errmsg (bfd_error_type error_tag)
 785 {
 786 #ifndef errno
 787   extern int errno;
 788 #endif
 789   if (error_tag == bfd_error_on_input)
 790     {
 791       char *buf;
 792       const char *msg = bfd_errmsg (input_error);
 793
 794       if (asprintf (&buf, _(bfd_errmsgs [error_tag]),
 795                     bfd_get_filename (input_bfd), msg) != -1)
 796         return buf;
 797
 798       /* Ick, what to do on out of memory?  */
 799       return msg;
 800     }
 801
 802   if (error_tag == bfd_error_system_call)
 803     return xstrerror (errno);
 804
 805   if (error_tag > bfd_error_invalid_error_code)
 806     error_tag = bfd_error_invalid_error_code;   /* sanity check */
 807
 808   return _(bfd_errmsgs [error_tag]);
 809 }
 810
 811 /*
 812 FUNCTION
 813         bfd_perror
 814
 815 SYNOPSIS
 816         void bfd_perror (const char *message);
 817
 818 DESCRIPTION
 819         Print to the standard error stream a string describing the
 820         last BFD error that occurred, or the last system error if
 821         the last BFD error was a system call failure.  If @var{message}
 822         is non-NULL and non-empty, the error string printed is preceded
 823         by @var{message}, a colon, and a space.  It is followed by a newline.
 824 */
 825
 826 void
 827 bfd_perror (const char *message)
 828 {
 829   fflush (stdout);
 830   if (message == NULL || *message == '\0')
 831     fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
 832   else
 833     fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
 834   fflush (stderr);
 835 }
 836
 837 /*
 838 SUBSECTION
 839         BFD error handler
 840
 841         Some BFD functions want to print messages describing the
 842         problem.  They call a BFD error handler function.  This
 843         function may be overridden by the program.
 844
 845         The BFD error handler acts like vprintf.
 846
 847 CODE_FRAGMENT
 848 .
 849 .typedef void (*bfd_error_handler_type) (const char *, va_list);
 850 .
 851 */
 852
 853 /* The program name used when printing BFD error messages.  */
 854
 855 static const char *_bfd_error_program_name;
 856
 857 /* Support for positional parameters.  */
 858
 859 union _bfd_doprnt_args
 860 {
 861   int i;
 862   long l;
 863   long long ll;
 864   double d;
 865   long double ld;
 866   void *p;
 867   enum
 868   {
 869     Bad,
 870     Int,
 871     Long,
 872     LongLong,
 873     Double,
 874     LongDouble,
 875     Ptr
 876   } type;
 877 };
 878
 879 /* This macro and _bfd_doprnt taken from libiberty _doprnt.c, tidied a
 880    little and extended to handle '%pA', '%pB' and positional parameters.  */
 881
 882 #define PRINT_TYPE(TYPE, FIELD) \
 883   do                                                            \
 884     {                                                           \
 885       TYPE value = (TYPE) args[arg_no].FIELD;                   \
 886       result = fprintf (stream, specifier, value);              \
 887     } while (0)
 888
 889 static int
 890 _bfd_doprnt (FILE *stream, const char *format, union _bfd_doprnt_args *args)
 891 {
 892   const char *ptr = format;
 893   char specifier[128];
 894   int total_printed = 0;
 895   unsigned int arg_count = 0;
 896
 897   while (*ptr != '\0')
 898     {
 899       int result;
 900
 901       if (*ptr != '%')
 902         {
 903           /* While we have regular characters, print them.  */
 904           char *end = strchr (ptr, '%');
 905           if (end != NULL)
 906             result = fprintf (stream, "%.*s", (int) (end - ptr), ptr);
 907           else
 908             result = fprintf (stream, "%s", ptr);
 909           ptr += result;
 910         }
 911       else if (ptr[1] == '%')
 912         {
 913           fputc ('%', stream);
 914           result = 1;
 915           ptr += 2;
 916         }
 917       else
 918         {
 919           /* We have a format specifier!  */
 920           char *sptr = specifier;
 921           int wide_width = 0, short_width = 0;
 922           unsigned int arg_no;
 923
 924           /* Copy the % and move forward.  */
 925           *sptr++ = *ptr++;
 926
 927           /* Check for a positional parameter.  */
 928           arg_no = -1u;
 929           if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
 930             {
 931               arg_no = *ptr - '1';
 932               ptr += 2;
 933             }
 934
 935           /* Move past flags.  */
 936           while (strchr ("-+ #0'I", *ptr))
 937             *sptr++ = *ptr++;
 938
 939           if (*ptr == '*')
 940             {
 941               int value;
 942               unsigned int arg_index;
 943
 944               ptr++;
 945               arg_index = arg_count;
 946               if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
 947                 {
 948                   arg_index = *ptr - '1';
 949                   ptr += 2;
 950                 }
 951               value = abs (args[arg_index].i);
 952               arg_count++;
 953               sptr += sprintf (sptr, "%d", value);
 954             }
 955           else
 956             /* Handle explicit numeric value.  */
 957             while (ISDIGIT (*ptr))
 958               *sptr++ = *ptr++;
 959
 960           /* Precision.  */
 961           if (*ptr == '.')
 962             {
 963               /* Copy and go past the period.  */
 964               *sptr++ = *ptr++;
 965               if (*ptr == '*')
 966                 {
 967                   int value;
 968                   unsigned int arg_index;
 969
 970                   ptr++;
 971                   arg_index = arg_count;
 972                   if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
 973                     {
 974                       arg_index = *ptr - '1';
 975                       ptr += 2;
 976                     }
 977                   value = abs (args[arg_index].i);
 978                   arg_count++;
 979                   sptr += sprintf (sptr, "%d", value);
 980                 }
 981               else
 982                 /* Handle explicit numeric value.  */
 983                 while (ISDIGIT (*ptr))
 984                   *sptr++ = *ptr++;
 985             }
 986           while (strchr ("hlL", *ptr))
 987             {
 988               switch (*ptr)
 989                 {
 990                 case 'h':
 991                   short_width = 1;
 992                   break;
 993                 case 'l':
 994                   wide_width++;
 995                   break;
 996                 case 'L':
 997                   wide_width = 2;
 998                   break;
 999                 default:
1000                   abort();
1001                 }
1002               *sptr++ = *ptr++;
1003             }
1004
1005           /* Copy the type specifier, and NULL terminate.  */
1006           *sptr++ = *ptr++;
1007           *sptr = '\0';
1008           if ((int) arg_no < 0)
1009             arg_no = arg_count;
1010
1011           switch (ptr[-1])
1012             {
1013             case 'd':
1014             case 'i':
1015             case 'o':
1016             case 'u':
1017             case 'x':
1018             case 'X':
1019             case 'c':
1020               {
1021                 /* Short values are promoted to int, so just copy it
1022                    as an int and trust the C library printf to cast it
1023                    to the right width.  */
1024                 if (short_width)
1025                   PRINT_TYPE (int, i);
1026                 else
1027                   {
1028                     switch (wide_width)
1029                       {
1030                       case 0:
1031                         PRINT_TYPE (int, i);
1032                         break;
1033                       case 1:
1034                         PRINT_TYPE (long, l);
1035                         break;
1036                       case 2:
1037                       default:
1038 #if defined (__MSVCRT__)
1039                         sptr[-3] = 'I';
1040                         sptr[-2] = '6';
1041                         sptr[-1] = '4';
1042                         *sptr++ = ptr[-1];
1043                         *sptr = '\0';
1044 #endif
1045 #if defined (__GNUC__) || defined (HAVE_LONG_LONG)
1046                         PRINT_TYPE (long long, ll);
1047 #else
1048                         /* Fake it and hope for the best.  */
1049                         PRINT_TYPE (long, l);
1050 #endif
1051                         break;
1052                       }
1053                   }
1054               }
1055               break;
1056             case 'f':
1057             case 'e':
1058             case 'E':
1059             case 'g':
1060             case 'G':
1061               {
1062                 if (wide_width == 0)
1063                   PRINT_TYPE (double, d);
1064                 else
1065                   {
1066 #if defined (__GNUC__) || defined (HAVE_LONG_DOUBLE)
1067                     PRINT_TYPE (long double, ld);
1068 #else
1069                     /* Fake it and hope for the best.  */
1070                     PRINT_TYPE (double, d);
1071 #endif
1072                   }
1073               }
1074               break;
1075             case 's':
1076               PRINT_TYPE (char *, p);
1077               break;
1078             case 'p':
1079               if (*ptr == 'A')
1080                 {
1081                   asection *sec;
1082                   bfd *abfd;
1083                   const char *group = NULL;
1084                   struct coff_comdat_info *ci;
1085
1086                   ptr++;
1087                   sec = (asection *) args[arg_no].p;
1088                   if (sec == NULL)
1089                     /* Invoking %pA with a null section pointer is an
1090                        internal error.  */
1091                     abort ();
1092                   abfd = sec->owner;
1093                   if (abfd != NULL
1094                       && bfd_get_flavour (abfd) == bfd_target_elf_flavour
1095                       && elf_next_in_group (sec) != NULL
1096                       && (sec->flags & SEC_GROUP) == 0)
1097                     group = elf_group_name (sec);
1098                   else if (abfd != NULL
1099                            && bfd_get_flavour (abfd) == bfd_target_coff_flavour
1100                            && (ci = bfd_coff_get_comdat_section (sec->owner,
1101                                                                  sec)) != NULL)
1102                     group = ci->name;
1103                   if (group != NULL)
1104                     result = fprintf (stream, "%s[%s]", sec->name, group);
1105                   else
1106                     result = fprintf (stream, "%s", sec->name);
1107                 }
1108               else if (*ptr == 'B')
1109                 {
1110                   bfd *abfd;
1111
1112                   ptr++;
1113                   abfd = (bfd *) args[arg_no].p;
1114                   if (abfd == NULL)
1115                     /* Invoking %pB with a null bfd pointer is an
1116                        internal error.  */
1117                     abort ();
1118                   else if (abfd->my_archive
1119                            && !bfd_is_thin_archive (abfd->my_archive))
1120                     result = fprintf (stream, "%s(%s)",
1121                                       bfd_get_filename (abfd->my_archive),
1122                                       bfd_get_filename (abfd));
1123                   else
1124                     result = fprintf (stream, "%s", bfd_get_filename (abfd));
1125                 }
1126               else
1127                 PRINT_TYPE (void *, p);
1128               break;
1129             default:
1130               abort();
1131             }
1132           arg_count++;
1133         }
1134       if (result == -1)
1135         return -1;
1136       total_printed += result;
1137     }
1138
1139   return total_printed;
1140 }
1141
1142 /* First pass over FORMAT to gather ARGS.  Returns number of args.  */
1143
1144 static unsigned int
1145 _bfd_doprnt_scan (const char *format, union _bfd_doprnt_args *args)
1146 {
1147   const char *ptr = format;
1148   unsigned int arg_count = 0;
1149
1150   while (*ptr != '\0')
1151     {
1152       if (*ptr != '%')
1153         {
1154           ptr = strchr (ptr, '%');
1155           if (ptr == NULL)
1156             break;
1157         }
1158       else if (ptr[1] == '%')
1159         ptr += 2;
1160       else
1161         {
1162           int wide_width = 0, short_width = 0;
1163           unsigned int arg_no;
1164           int arg_type;
1165
1166           ptr++;
1167
1168           /* Check for a positional parameter.  */
1169           arg_no = -1u;
1170           if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
1171             {
1172               arg_no = *ptr - '1';
1173               ptr += 2;
1174             }
1175
1176           /* Move past flags.  */
1177           while (strchr ("-+ #0'I", *ptr))
1178             ptr++;
1179
1180           if (*ptr == '*')
1181             {
1182               unsigned int arg_index;
1183
1184               ptr++;
1185               arg_index = arg_count;
1186               if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
1187                 {
1188                   arg_index = *ptr - '1';
1189                   ptr += 2;
1190                 }
1191               if (arg_index >= 9)
1192                 abort ();
1193               args[arg_index].type = Int;
1194               arg_count++;
1195             }
1196           else
1197             /* Handle explicit numeric value.  */
1198             while (ISDIGIT (*ptr))
1199               ptr++;
1200
1201           /* Precision.  */
1202           if (*ptr == '.')
1203             {
1204               ptr++;
1205               if (*ptr == '*')
1206                 {
1207                   unsigned int arg_index;
1208
1209                   ptr++;
1210                   arg_index = arg_count;
1211                   if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
1212                     {
1213                       arg_index = *ptr - '1';
1214                       ptr += 2;
1215                     }
1216                   if (arg_index >= 9)
1217                     abort ();
1218                   args[arg_index].type = Int;
1219                   arg_count++;
1220                 }
1221               else
1222                 /* Handle explicit numeric value.  */
1223                 while (ISDIGIT (*ptr))
1224                   ptr++;
1225             }
1226           while (strchr ("hlL", *ptr))
1227             {
1228               switch (*ptr)
1229                 {
1230                 case 'h':
1231                   short_width = 1;
1232                   break;
1233                 case 'l':
1234                   wide_width++;
1235                   break;
1236                 case 'L':
1237                   wide_width = 2;
1238                   break;
1239                 default:
1240                   abort();
1241                 }
1242               ptr++;
1243             }
1244
1245           ptr++;
1246           if ((int) arg_no < 0)
1247             arg_no = arg_count;
1248
1249           arg_type = Bad;
1250           switch (ptr[-1])
1251             {
1252             case 'd':
1253             case 'i':
1254             case 'o':
1255             case 'u':
1256             case 'x':
1257             case 'X':
1258             case 'c':
1259               {
1260                 if (short_width)
1261                   arg_type = Int;
1262                 else
1263                   {
1264                     switch (wide_width)
1265                       {
1266                       case 0:
1267                         arg_type = Int;
1268                         break;
1269                       case 1:
1270                         arg_type = Long;
1271                         break;
1272                       case 2:
1273                       default:
1274 #if defined (__GNUC__) || defined (HAVE_LONG_LONG)
1275                         arg_type = LongLong;
1276 #else
1277                         arg_type = Long;
1278 #endif
1279                         break;
1280                       }
1281                   }
1282               }
1283               break;
1284             case 'f':
1285             case 'e':
1286             case 'E':
1287             case 'g':
1288             case 'G':
1289               {
1290                 if (wide_width == 0)
1291                   arg_type = Double;
1292                 else
1293                   {
1294 #if defined (__GNUC__) || defined (HAVE_LONG_DOUBLE)
1295                     arg_type = LongDouble;
1296 #else
1297                     arg_type = Double;
1298 #endif
1299                   }
1300               }
1301               break;
1302             case 's':
1303               arg_type = Ptr;
1304               break;
1305             case 'p':
1306               if (*ptr == 'A' || *ptr == 'B')
1307                 ptr++;
1308               arg_type = Ptr;
1309               break;
1310             default:
1311               abort();
1312             }
1313
1314           if (arg_no >= 9)
1315             abort ();
1316           args[arg_no].type = arg_type;
1317           arg_count++;
1318         }
1319     }
1320
1321   return arg_count;
1322 }
1323
1324 static void
1325 error_handler_internal (const char *fmt, va_list ap)
1326 {
1327   unsigned int i, arg_count;
1328   union _bfd_doprnt_args args[9];
1329
1330   for (i = 0; i < sizeof (args) / sizeof (args[0]); i++)
1331     args[i].type = Bad;
1332
1333   arg_count = _bfd_doprnt_scan (fmt, args);
1334   for (i = 0; i < arg_count; i++)
1335     {
1336       switch (args[i].type)
1337         {
1338         case Int:
1339           args[i].i = va_arg (ap, int);
1340           break;
1341         case Long:
1342           args[i].l = va_arg (ap, long);
1343           break;
1344         case LongLong:
1345           args[i].ll = va_arg (ap, long long);
1346           break;
1347         case Double:
1348           args[i].d = va_arg (ap, double);
1349           break;
1350         case LongDouble:
1351           args[i].ld = va_arg (ap, long double);
1352           break;
1353         case Ptr:
1354           args[i].p = va_arg (ap, void *);
1355           break;
1356         default:
1357           abort ();
1358         }
1359     }
1360
1361   /* PR 4992: Don't interrupt output being sent to stdout.  */
1362   fflush (stdout);
1363
1364   if (_bfd_error_program_name != NULL)
1365     fprintf (stderr, "%s: ", _bfd_error_program_name);
1366   else
1367     fprintf (stderr, "BFD: ");
1368
1369   _bfd_doprnt (stderr, fmt, args);
1370
1371   /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
1372      warning, so use the fputc function to avoid it.  */
1373   fputc ('\n', stderr);
1374   fflush (stderr);
1375 }
1376
1377 /* This is a function pointer to the routine which should handle BFD
1378    error messages.  It is called when a BFD routine encounters an
1379    error for which it wants to print a message.  Going through a
1380    function pointer permits a program linked against BFD to intercept
1381    the messages and deal with them itself.  */
1382
1383 static bfd_error_handler_type _bfd_error_internal = error_handler_internal;
1384
1385 /*
1386 FUNCTION
1387         _bfd_error_handler
1388
1389 SYNOPSIS
1390         void _bfd_error_handler (const char *fmt, ...) ATTRIBUTE_PRINTF_1;
1391
1392 DESCRIPTION
1393         This is the default routine to handle BFD error messages.
1394         Like fprintf (stderr, ...), but also handles some extra format
1395         specifiers.
1396
1397         %pA section name from section.  For group components, prints
1398         group name too.
1399         %pB file name from bfd.  For archive components, prints
1400         archive too.
1401
1402         Beware: Only supports a maximum of 9 format arguments.
1403 */
1404
1405 void
1406 _bfd_error_handler (const char *fmt, ...)
1407 {
1408   va_list ap;
1409
1410   va_start (ap, fmt);
1411   _bfd_error_internal (fmt, ap);
1412   va_end (ap);
1413 }
1414
1415 /*
1416 FUNCTION
1417         bfd_set_error_handler
1418
1419 SYNOPSIS
1420         bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
1421
1422 DESCRIPTION
1423         Set the BFD error handler function.  Returns the previous
1424         function.
1425 */
1426
1427 bfd_error_handler_type
1428 bfd_set_error_handler (bfd_error_handler_type pnew)
1429 {
1430   bfd_error_handler_type pold;
1431
1432   pold = _bfd_error_internal;
1433   _bfd_error_internal = pnew;
1434   return pold;
1435 }
1436
1437 /*
1438 FUNCTION
1439         bfd_set_error_program_name
1440
1441 SYNOPSIS
1442         void bfd_set_error_program_name (const char *);
1443
1444 DESCRIPTION
1445         Set the program name to use when printing a BFD error.  This
1446         is printed before the error message followed by a colon and
1447         space.  The string must not be changed after it is passed to
1448         this function.
1449 */
1450
1451 void
1452 bfd_set_error_program_name (const char *name)
1453 {
1454   _bfd_error_program_name = name;
1455 }
1456
1457 /*
1458 SUBSECTION
1459         BFD assert handler
1460
1461         If BFD finds an internal inconsistency, the bfd assert
1462         handler is called with information on the BFD version, BFD
1463         source file and line.  If this happens, most programs linked
1464         against BFD are expected to want to exit with an error, or mark
1465         the current BFD operation as failed, so it is recommended to
1466         override the default handler, which just calls
1467         _bfd_error_handler and continues.
1468
1469 CODE_FRAGMENT
1470 .
1471 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,
1472 .                                         const char *bfd_version,
1473 .                                         const char *bfd_file,
1474 .                                         int bfd_line);
1475 .
1476 */
1477
1478 /* Note the use of bfd_ prefix on the parameter names above: we want to
1479    show which one is the message and which is the version by naming the
1480    parameters, but avoid polluting the program-using-bfd namespace as
1481    the typedef is visible in the exported headers that the program
1482    includes.  Below, it's just for consistency.  */
1483
1484 static void
1485 _bfd_default_assert_handler (const char *bfd_formatmsg,
1486                              const char *bfd_version,
1487                              const char *bfd_file,
1488                              int bfd_line)
1489
1490 {
1491   _bfd_error_handler (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
1492 }
1493
1494 /* Similar to _bfd_error_handler, a program can decide to exit on an
1495    internal BFD error.  We use a non-variadic type to simplify passing
1496    on parameters to other functions, e.g. _bfd_error_handler.  */
1497
1498 static bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler;
1499
1500 /*
1501 FUNCTION
1502         bfd_set_assert_handler
1503
1504 SYNOPSIS
1505         bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type);
1506
1507 DESCRIPTION
1508         Set the BFD assert handler function.  Returns the previous
1509         function.
1510 */
1511
1512 bfd_assert_handler_type
1513 bfd_set_assert_handler (bfd_assert_handler_type pnew)
1514 {
1515   bfd_assert_handler_type pold;
1516
1517   pold = _bfd_assert_handler;
1518   _bfd_assert_handler = pnew;
1519   return pold;
1520 }
1521 \f
1522 /*
1523 INODE
1524 Miscellaneous, Memory Usage, Error reporting, BFD front end
1525
1526 SECTION
1527         Miscellaneous
1528
1529 SUBSECTION
1530         Miscellaneous functions
1531 */
1532
1533 /*
1534 FUNCTION
1535         bfd_get_reloc_upper_bound
1536
1537 SYNOPSIS
1538         long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
1539
1540 DESCRIPTION
1541         Return the number of bytes required to store the
1542         relocation information associated with section @var{sect}
1543         attached to bfd @var{abfd}.  If an error occurs, return -1.
1544
1545 */
1546
1547 long
1548 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
1549 {
1550   if (abfd->format != bfd_object)
1551     {
1552       bfd_set_error (bfd_error_invalid_operation);
1553       return -1;
1554     }
1555
1556   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
1557 }
1558
1559 /*
1560 FUNCTION
1561         bfd_canonicalize_reloc
1562
1563 SYNOPSIS
1564         long bfd_canonicalize_reloc
1565           (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
1566
1567 DESCRIPTION
1568         Call the back end associated with the open BFD
1569         @var{abfd} and translate the external form of the relocation
1570         information attached to @var{sec} into the internal canonical
1571         form.  Place the table into memory at @var{loc}, which has
1572         been preallocated, usually by a call to
1573         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
1574         -1 on error.
1575
1576         The @var{syms} table is also needed for horrible internal magic
1577         reasons.
1578
1579 */
1580 long
1581 bfd_canonicalize_reloc (bfd *abfd,
1582                         sec_ptr asect,
1583                         arelent **location,
1584                         asymbol **symbols)
1585 {
1586   if (abfd->format != bfd_object)
1587     {
1588       bfd_set_error (bfd_error_invalid_operation);
1589       return -1;
1590     }
1591
1592   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
1593                    (abfd, asect, location, symbols));
1594 }
1595
1596 /*
1597 FUNCTION
1598         bfd_set_reloc
1599
1600 SYNOPSIS
1601         void bfd_set_reloc
1602           (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
1603
1604 DESCRIPTION
1605         Set the relocation pointer and count within
1606         section @var{sec} to the values @var{rel} and @var{count}.
1607         The argument @var{abfd} is ignored.
1608
1609 .#define bfd_set_reloc(abfd, asect, location, count) \
1610 .       BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count))
1611 */
1612
1613 /*
1614 FUNCTION
1615         bfd_set_file_flags
1616
1617 SYNOPSIS
1618         bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
1619
1620 DESCRIPTION
1621         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
1622
1623         Possible errors are:
1624         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
1625         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
1626         o <<bfd_error_invalid_operation>> -
1627         The flag word contained a bit which was not applicable to the
1628         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
1629         on a BFD format which does not support demand paging.
1630
1631 */
1632
1633 bfd_boolean
1634 bfd_set_file_flags (bfd *abfd, flagword flags)
1635 {
1636   if (abfd->format != bfd_object)
1637     {
1638       bfd_set_error (bfd_error_wrong_format);
1639       return FALSE;
1640     }
1641
1642   if (bfd_read_p (abfd))
1643     {
1644       bfd_set_error (bfd_error_invalid_operation);
1645       return FALSE;
1646     }
1647
1648   abfd->flags = flags;
1649   if ((flags & bfd_applicable_file_flags (abfd)) != flags)
1650     {
1651       bfd_set_error (bfd_error_invalid_operation);
1652       return FALSE;
1653     }
1654
1655   return TRUE;
1656 }
1657
1658 void
1659 bfd_assert (const char *file, int line)
1660 {
1661   /* xgettext:c-format */
1662   (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"),
1663                           BFD_VERSION_STRING, file, line);
1664 }
1665
1666 /* A more or less friendly abort message.  In libbfd.h abort is
1667    defined to call this function.  */
1668
1669 void
1670 _bfd_abort (const char *file, int line, const char *fn)
1671 {
1672   if (fn != NULL)
1673     _bfd_error_handler
1674       /* xgettext:c-format */
1675       (_("BFD %s internal error, aborting at %s:%d in %s\n"),
1676        BFD_VERSION_STRING, file, line, fn);
1677   else
1678     _bfd_error_handler
1679       /* xgettext:c-format */
1680       (_("BFD %s internal error, aborting at %s:%d\n"),
1681        BFD_VERSION_STRING, file, line);
1682   _bfd_error_handler (_("Please report this bug.\n"));
1683   _exit (EXIT_FAILURE);
1684 }
1685
1686 /*
1687 FUNCTION
1688         bfd_get_arch_size
1689
1690 SYNOPSIS
1691         int bfd_get_arch_size (bfd *abfd);
1692
1693 DESCRIPTION
1694         Returns the normalized architecture address size, in bits, as
1695         determined by the object file's format.  By normalized, we mean
1696         either 32 or 64.  For ELF, this information is included in the
1697         header.  Use bfd_arch_bits_per_address for number of bits in
1698         the architecture address.
1699
1700 RETURNS
1701         Returns the arch size in bits if known, <<-1>> otherwise.
1702 */
1703
1704 int
1705 bfd_get_arch_size (bfd *abfd)
1706 {
1707   if (abfd->xvec->flavour == bfd_target_elf_flavour)
1708     return get_elf_backend_data (abfd)->s->arch_size;
1709
1710   return bfd_arch_bits_per_address (abfd) > 32 ? 64 : 32;
1711 }
1712
1713 /*
1714 FUNCTION
1715         bfd_get_sign_extend_vma
1716
1717 SYNOPSIS
1718         int bfd_get_sign_extend_vma (bfd *abfd);
1719
1720 DESCRIPTION
1721         Indicates if the target architecture "naturally" sign extends
1722         an address.  Some architectures implicitly sign extend address
1723         values when they are converted to types larger than the size
1724         of an address.  For instance, bfd_get_start_address() will
1725         return an address sign extended to fill a bfd_vma when this is
1726         the case.
1727
1728 RETURNS
1729         Returns <<1>> if the target architecture is known to sign
1730         extend addresses, <<0>> if the target architecture is known to
1731         not sign extend addresses, and <<-1>> otherwise.
1732 */
1733
1734 int
1735 bfd_get_sign_extend_vma (bfd *abfd)
1736 {
1737   const char *name;
1738
1739   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1740     return get_elf_backend_data (abfd)->sign_extend_vma;
1741
1742   name = bfd_get_target (abfd);
1743
1744   /* Return a proper value for DJGPP & PE COFF.
1745      This function is required for DWARF2 support, but there is
1746      no place to store this information in the COFF back end.
1747      Should enough other COFF targets add support for DWARF2,
1748      a place will have to be found.  Until then, this hack will do.  */
1749   if (CONST_STRNEQ (name, "coff-go32")
1750       || strcmp (name, "pe-i386") == 0
1751       || strcmp (name, "pei-i386") == 0
1752       || strcmp (name, "pe-x86-64") == 0
1753       || strcmp (name, "pei-x86-64") == 0
1754       || strcmp (name, "pe-arm-wince-little") == 0
1755       || strcmp (name, "pei-arm-wince-little") == 0
1756       || strcmp (name, "aixcoff-rs6000") == 0
1757       || strcmp (name, "aix5coff64-rs6000") == 0)
1758     return 1;
1759
1760   if (CONST_STRNEQ (name, "mach-o"))
1761     return 0;
1762
1763   bfd_set_error (bfd_error_wrong_format);
1764   return -1;
1765 }
1766
1767 /*
1768 FUNCTION
1769         bfd_set_start_address
1770
1771 SYNOPSIS
1772         bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
1773
1774 DESCRIPTION
1775         Make @var{vma} the entry point of output BFD @var{abfd}.
1776
1777 RETURNS
1778         Returns <<TRUE>> on success, <<FALSE>> otherwise.
1779 */
1780
1781 bfd_boolean
1782 bfd_set_start_address (bfd *abfd, bfd_vma vma)
1783 {
1784   abfd->start_address = vma;
1785   return TRUE;
1786 }
1787
1788 /*
1789 FUNCTION
1790         bfd_get_gp_size
1791
1792 SYNOPSIS
1793         unsigned int bfd_get_gp_size (bfd *abfd);
1794
1795 DESCRIPTION
1796         Return the maximum size of objects to be optimized using the GP
1797         register under MIPS ECOFF.  This is typically set by the <<-G>>
1798         argument to the compiler, assembler or linker.
1799 */
1800
1801 unsigned int
1802 bfd_get_gp_size (bfd *abfd)
1803 {
1804   if (abfd->format == bfd_object)
1805     {
1806       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1807         return ecoff_data (abfd)->gp_size;
1808       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1809         return elf_gp_size (abfd);
1810     }
1811   return 0;
1812 }
1813
1814 /*
1815 FUNCTION
1816         bfd_set_gp_size
1817
1818 SYNOPSIS
1819         void bfd_set_gp_size (bfd *abfd, unsigned int i);
1820
1821 DESCRIPTION
1822         Set the maximum size of objects to be optimized using the GP
1823         register under ECOFF or MIPS ELF.  This is typically set by
1824         the <<-G>> argument to the compiler, assembler or linker.
1825 */
1826
1827 void
1828 bfd_set_gp_size (bfd *abfd, unsigned int i)
1829 {
1830   /* Don't try to set GP size on an archive or core file!  */
1831   if (abfd->format != bfd_object)
1832     return;
1833
1834   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1835     ecoff_data (abfd)->gp_size = i;
1836   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1837     elf_gp_size (abfd) = i;
1838 }
1839
1840 /* Get the GP value.  This is an internal function used by some of the
1841    relocation special_function routines on targets which support a GP
1842    register.  */
1843
1844 bfd_vma
1845 _bfd_get_gp_value (bfd *abfd)
1846 {
1847   if (! abfd)
1848     return 0;
1849   if (abfd->format != bfd_object)
1850     return 0;
1851
1852   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1853     return ecoff_data (abfd)->gp;
1854   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1855     return elf_gp (abfd);
1856
1857   return 0;
1858 }
1859
1860 /* Set the GP value.  */
1861
1862 void
1863 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
1864 {
1865   if (! abfd)
1866     abort ();
1867   if (abfd->format != bfd_object)
1868     return;
1869
1870   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1871     ecoff_data (abfd)->gp = v;
1872   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1873     elf_gp (abfd) = v;
1874 }
1875
1876 /*
1877 FUNCTION
1878         bfd_scan_vma
1879
1880 SYNOPSIS
1881         bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1882
1883 DESCRIPTION
1884         Convert, like <<strtoul>>, a numerical expression
1885         @var{string} into a <<bfd_vma>> integer, and return that integer.
1886         (Though without as many bells and whistles as <<strtoul>>.)
1887         The expression is assumed to be unsigned (i.e., positive).
1888         If given a @var{base}, it is used as the base for conversion.
1889         A base of 0 causes the function to interpret the string
1890         in hex if a leading "0x" or "0X" is found, otherwise
1891         in octal if a leading zero is found, otherwise in decimal.
1892
1893         If the value would overflow, the maximum <<bfd_vma>> value is
1894         returned.
1895 */
1896
1897 bfd_vma
1898 bfd_scan_vma (const char *string, const char **end, int base)
1899 {
1900   bfd_vma value;
1901   bfd_vma cutoff;
1902   unsigned int cutlim;
1903   int overflow;
1904
1905   /* Let the host do it if possible.  */
1906   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1907     return strtoul (string, (char **) end, base);
1908
1909 #if defined (HAVE_STRTOULL) && defined (HAVE_LONG_LONG)
1910   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1911     return strtoull (string, (char **) end, base);
1912 #endif
1913
1914   if (base == 0)
1915     {
1916       if (string[0] == '0')
1917         {
1918           if ((string[1] == 'x') || (string[1] == 'X'))
1919             base = 16;
1920           else
1921             base = 8;
1922         }
1923     }
1924
1925   if ((base < 2) || (base > 36))
1926     base = 10;
1927
1928   if (base == 16
1929       && string[0] == '0'
1930       && (string[1] == 'x' || string[1] == 'X')
1931       && ISXDIGIT (string[2]))
1932     {
1933       string += 2;
1934     }
1935
1936   cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1937   cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1938   value = 0;
1939   overflow = 0;
1940   while (1)
1941     {
1942       unsigned int digit;
1943
1944       digit = *string;
1945       if (ISDIGIT (digit))
1946         digit = digit - '0';
1947       else if (ISALPHA (digit))
1948         digit = TOUPPER (digit) - 'A' + 10;
1949       else
1950         break;
1951       if (digit >= (unsigned int) base)
1952         break;
1953       if (value > cutoff || (value == cutoff && digit > cutlim))
1954         overflow = 1;
1955       value = value * base + digit;
1956       ++string;
1957     }
1958
1959   if (overflow)
1960     value = ~ (bfd_vma) 0;
1961
1962   if (end != NULL)
1963     *end = string;
1964
1965   return value;
1966 }
1967
1968 /*
1969 FUNCTION
1970         bfd_copy_private_header_data
1971
1972 SYNOPSIS
1973         bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1974
1975 DESCRIPTION
1976         Copy private BFD header information from the BFD @var{ibfd} to the
1977         the BFD @var{obfd}.  This copies information that may require
1978         sections to exist, but does not require symbol tables.  Return
1979         <<true>> on success, <<false>> on error.
1980         Possible error returns are:
1981
1982         o <<bfd_error_no_memory>> -
1983         Not enough memory exists to create private data for @var{obfd}.
1984
1985 .#define bfd_copy_private_header_data(ibfd, obfd) \
1986 .       BFD_SEND (obfd, _bfd_copy_private_header_data, \
1987 .                 (ibfd, obfd))
1988
1989 */
1990
1991 /*
1992 FUNCTION
1993         bfd_copy_private_bfd_data
1994
1995 SYNOPSIS
1996         bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1997
1998 DESCRIPTION
1999         Copy private BFD information from the BFD @var{ibfd} to the
2000         the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
2001         Possible error returns are:
2002
2003         o <<bfd_error_no_memory>> -
2004         Not enough memory exists to create private data for @var{obfd}.
2005
2006 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
2007 .       BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
2008 .                 (ibfd, obfd))
2009
2010 */
2011
2012 /*
2013 FUNCTION
2014         bfd_set_private_flags
2015
2016 SYNOPSIS
2017         bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
2018
2019 DESCRIPTION
2020         Set private BFD flag information in the BFD @var{abfd}.
2021         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
2022         returns are:
2023
2024         o <<bfd_error_no_memory>> -
2025         Not enough memory exists to create private data for @var{obfd}.
2026
2027 .#define bfd_set_private_flags(abfd, flags) \
2028 .       BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
2029
2030 */
2031
2032 /*
2033 FUNCTION
2034         Other functions
2035
2036 DESCRIPTION
2037         The following functions exist but have not yet been documented.
2038
2039 .#define bfd_sizeof_headers(abfd, info) \
2040 .       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
2041 .
2042 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
2043 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
2044 .                 (abfd, syms, sec, off, file, func, line, NULL))
2045 .
2046 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
2047 .                                           line, disc) \
2048 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
2049 .                 (abfd, syms, sec, off, file, func, line, disc))
2050 .
2051 .#define bfd_find_line(abfd, syms, sym, file, line) \
2052 .       BFD_SEND (abfd, _bfd_find_line, \
2053 .                 (abfd, syms, sym, file, line))
2054 .
2055 .#define bfd_find_inliner_info(abfd, file, func, line) \
2056 .       BFD_SEND (abfd, _bfd_find_inliner_info, \
2057 .                 (abfd, file, func, line))
2058 .
2059 .#define bfd_debug_info_start(abfd) \
2060 .       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
2061 .
2062 .#define bfd_debug_info_end(abfd) \
2063 .       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
2064 .
2065 .#define bfd_debug_info_accumulate(abfd, section) \
2066 .       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
2067 .
2068 .#define bfd_stat_arch_elt(abfd, stat) \
2069 .       BFD_SEND (abfd->my_archive ? abfd->my_archive : abfd, \
2070 .                 _bfd_stat_arch_elt, (abfd, stat))
2071 .
2072 .#define bfd_update_armap_timestamp(abfd) \
2073 .       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
2074 .
2075 .#define bfd_set_arch_mach(abfd, arch, mach)\
2076 .       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
2077 .
2078 .#define bfd_relax_section(abfd, section, link_info, again) \
2079 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
2080 .
2081 .#define bfd_gc_sections(abfd, link_info) \
2082 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
2083 .
2084 .#define bfd_lookup_section_flags(link_info, flag_info, section) \
2085 .       BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section))
2086 .
2087 .#define bfd_merge_sections(abfd, link_info) \
2088 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
2089 .
2090 .#define bfd_is_group_section(abfd, sec) \
2091 .       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
2092 .
2093 .#define bfd_group_name(abfd, sec) \
2094 .       BFD_SEND (abfd, _bfd_group_name, (abfd, sec))
2095 .
2096 .#define bfd_discard_group(abfd, sec) \
2097 .       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
2098 .
2099 .#define bfd_link_hash_table_create(abfd) \
2100 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
2101 .
2102 .#define bfd_link_add_symbols(abfd, info) \
2103 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
2104 .
2105 .#define bfd_link_just_syms(abfd, sec, info) \
2106 .       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
2107 .
2108 .#define bfd_final_link(abfd, info) \
2109 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
2110 .
2111 .#define bfd_free_cached_info(abfd) \
2112 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
2113 .
2114 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
2115 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
2116 .
2117 .#define bfd_print_private_bfd_data(abfd, file)\
2118 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
2119 .
2120 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
2121 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
2122 .
2123 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
2124 .       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
2125 .                                                   dyncount, dynsyms, ret))
2126 .
2127 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
2128 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
2129 .
2130 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
2131 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
2132 .
2133 .extern bfd_byte *bfd_get_relocated_section_contents
2134 .  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
2135 .   bfd_boolean, asymbol **);
2136 .
2137
2138 */
2139
2140 bfd_byte *
2141 bfd_get_relocated_section_contents (bfd *abfd,
2142                                     struct bfd_link_info *link_info,
2143                                     struct bfd_link_order *link_order,
2144                                     bfd_byte *data,
2145                                     bfd_boolean relocatable,
2146                                     asymbol **symbols)
2147 {
2148   bfd *abfd2;
2149   bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
2150                    bfd_byte *, bfd_boolean, asymbol **);
2151
2152   if (link_order->type == bfd_indirect_link_order)
2153     {
2154       abfd2 = link_order->u.indirect.section->owner;
2155       if (abfd2 == NULL)
2156         abfd2 = abfd;
2157     }
2158   else
2159     abfd2 = abfd;
2160
2161   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
2162
2163   return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
2164 }
2165
2166 /* Record information about an ELF program header.  */
2167
2168 bfd_boolean
2169 bfd_record_phdr (bfd *abfd,
2170                  unsigned long type,
2171                  bfd_boolean flags_valid,
2172                  flagword flags,
2173                  bfd_boolean at_valid,
2174                  bfd_vma at,  /* Bytes.  */
2175                  bfd_boolean includes_filehdr,
2176                  bfd_boolean includes_phdrs,
2177                  unsigned int count,
2178                  asection **secs)
2179 {
2180   struct elf_segment_map *m, **pm;
2181   size_t amt;
2182   unsigned int opb = bfd_octets_per_byte (abfd, NULL);
2183
2184   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
2185     return TRUE;
2186
2187   amt = sizeof (struct elf_segment_map);
2188   amt += ((bfd_size_type) count - 1) * sizeof (asection *);
2189   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2190   if (m == NULL)
2191     return FALSE;
2192
2193   m->p_type = type;
2194   m->p_flags = flags;
2195   m->p_paddr = at * opb;
2196   m->p_flags_valid = flags_valid;
2197   m->p_paddr_valid = at_valid;
2198   m->includes_filehdr = includes_filehdr;
2199   m->includes_phdrs = includes_phdrs;
2200   m->count = count;
2201   if (count > 0)
2202     memcpy (m->sections, secs, count * sizeof (asection *));
2203
2204   for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
2205     ;
2206   *pm = m;
2207
2208   return TRUE;
2209 }
2210
2211 #ifdef BFD64
2212 /* Return true iff this target is 32-bit.  */
2213
2214 static bfd_boolean
2215 is32bit (bfd *abfd)
2216 {
2217   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2218     {
2219       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2220       return bed->s->elfclass == ELFCLASS32;
2221     }
2222
2223   /* For non-ELF targets, use architecture information.  */
2224   return bfd_arch_bits_per_address (abfd) <= 32;
2225 }
2226 #endif
2227
2228 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
2229    target's address size.  */
2230
2231 void
2232 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
2233 {
2234 #ifdef BFD64
2235   if (is32bit (abfd))
2236     {
2237       sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
2238       return;
2239     }
2240 #endif
2241   sprintf_vma (buf, value);
2242 }
2243
2244 void
2245 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
2246 {
2247 #ifdef BFD64
2248   if (is32bit (abfd))
2249     {
2250       fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
2251       return;
2252     }
2253 #endif
2254   fprintf_vma ((FILE *) stream, value);
2255 }
2256
2257 /*
2258 FUNCTION
2259         bfd_alt_mach_code
2260
2261 SYNOPSIS
2262         bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
2263
2264 DESCRIPTION
2265
2266         When more than one machine code number is available for the
2267         same machine type, this function can be used to switch between
2268         the preferred one (alternative == 0) and any others.  Currently,
2269         only ELF supports this feature, with up to two alternate
2270         machine codes.
2271 */
2272
2273 bfd_boolean
2274 bfd_alt_mach_code (bfd *abfd, int alternative)
2275 {
2276   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2277     {
2278       int code;
2279
2280       switch (alternative)
2281         {
2282         case 0:
2283           code = get_elf_backend_data (abfd)->elf_machine_code;
2284           break;
2285
2286         case 1:
2287           code = get_elf_backend_data (abfd)->elf_machine_alt1;
2288           if (code == 0)
2289             return FALSE;
2290           break;
2291
2292         case 2:
2293           code = get_elf_backend_data (abfd)->elf_machine_alt2;
2294           if (code == 0)
2295             return FALSE;
2296           break;
2297
2298         default:
2299           return FALSE;
2300         }
2301
2302       elf_elfheader (abfd)->e_machine = code;
2303
2304       return TRUE;
2305     }
2306
2307   return FALSE;
2308 }
2309
2310 /*
2311 FUNCTION
2312         bfd_emul_get_maxpagesize
2313
2314 SYNOPSIS
2315         bfd_vma bfd_emul_get_maxpagesize (const char *);
2316
2317 DESCRIPTION
2318         Returns the maximum page size, in bytes, as determined by
2319         emulation.
2320
2321 RETURNS
2322         Returns the maximum page size in bytes for ELF, 0 otherwise.
2323 */
2324
2325 bfd_vma
2326 bfd_emul_get_maxpagesize (const char *emul)
2327 {
2328   const bfd_target *target;
2329
2330   target = bfd_find_target (emul, NULL);
2331   if (target != NULL
2332       && target->flavour == bfd_target_elf_flavour)
2333     return xvec_get_elf_backend_data (target)->maxpagesize;
2334
2335   return 0;
2336 }
2337
2338 /*
2339 FUNCTION
2340         bfd_emul_get_commonpagesize
2341
2342 SYNOPSIS
2343         bfd_vma bfd_emul_get_commonpagesize (const char *, bfd_boolean);
2344
2345 DESCRIPTION
2346         Returns the common page size, in bytes, as determined by
2347         emulation.
2348
2349 RETURNS
2350         Returns the common page size in bytes for ELF, 0 otherwise.
2351 */
2352
2353 bfd_vma
2354 bfd_emul_get_commonpagesize (const char *emul, bfd_boolean relro)
2355 {
2356   const bfd_target *target;
2357
2358   target = bfd_find_target (emul, NULL);
2359   if (target != NULL
2360       && target->flavour == bfd_target_elf_flavour)
2361     {
2362       const struct elf_backend_data *bed;
2363
2364       bed = xvec_get_elf_backend_data (target);
2365       if (relro)
2366         return bed->relropagesize;
2367       else
2368         return bed->commonpagesize;
2369     }
2370   return 0;
2371 }
2372
2373 /*
2374 FUNCTION
2375         bfd_demangle
2376
2377 SYNOPSIS
2378         char *bfd_demangle (bfd *, const char *, int);
2379
2380 DESCRIPTION
2381         Wrapper around cplus_demangle.  Strips leading underscores and
2382         other such chars that would otherwise confuse the demangler.
2383         If passed a g++ v3 ABI mangled name, returns a buffer allocated
2384         with malloc holding the demangled name.  Returns NULL otherwise
2385         and on memory alloc failure.
2386 */
2387
2388 char *
2389 bfd_demangle (bfd *abfd, const char *name, int options)
2390 {
2391   char *res, *alloc;
2392   const char *pre, *suf;
2393   size_t pre_len;
2394   bfd_boolean skip_lead;
2395
2396   skip_lead = (abfd != NULL
2397                && *name != '\0'
2398                && bfd_get_symbol_leading_char (abfd) == *name);
2399   if (skip_lead)
2400     ++name;
2401
2402   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
2403      or the MS PE format.  These formats have a number of leading '.'s
2404      on at least some symbols, so we remove all dots to avoid
2405      confusing the demangler.  */
2406   pre = name;
2407   while (*name == '.' || *name == '$')
2408     ++name;
2409   pre_len = name - pre;
2410
2411   /* Strip off @plt and suchlike too.  */
2412   alloc = NULL;
2413   suf = strchr (name, '@');
2414   if (suf != NULL)
2415     {
2416       alloc = (char *) bfd_malloc (suf - name + 1);
2417       if (alloc == NULL)
2418         return NULL;
2419       memcpy (alloc, name, suf - name);
2420       alloc[suf - name] = '\0';
2421       name = alloc;
2422     }
2423
2424   res = cplus_demangle (name, options);
2425
2426   free (alloc);
2427
2428   if (res == NULL)
2429     {
2430       if (skip_lead)
2431         {
2432           size_t len = strlen (pre) + 1;
2433           alloc = (char *) bfd_malloc (len);
2434           if (alloc == NULL)
2435             return NULL;
2436           memcpy (alloc, pre, len);
2437           return alloc;
2438         }
2439       return NULL;
2440     }
2441
2442   /* Put back any prefix or suffix.  */
2443   if (pre_len != 0 || suf != NULL)
2444     {
2445       size_t len;
2446       size_t suf_len;
2447       char *final;
2448
2449       len = strlen (res);
2450       if (suf == NULL)
2451         suf = res + len;
2452       suf_len = strlen (suf) + 1;
2453       final = (char *) bfd_malloc (pre_len + len + suf_len);
2454       if (final != NULL)
2455         {
2456           memcpy (final, pre, pre_len);
2457           memcpy (final + pre_len, res, len);
2458           memcpy (final + pre_len + len, suf, suf_len);
2459         }
2460       free (res);
2461       res = final;
2462     }
2463
2464   return res;
2465 }
2466
2467 /*
2468 FUNCTION
2469         bfd_update_compression_header
2470
2471 SYNOPSIS
2472         void bfd_update_compression_header
2473           (bfd *abfd, bfd_byte *contents, asection *sec);
2474
2475 DESCRIPTION
2476         Set the compression header at CONTENTS of SEC in ABFD and update
2477         elf_section_flags for compression.
2478 */
2479
2480 void
2481 bfd_update_compression_header (bfd *abfd, bfd_byte *contents,
2482                                asection *sec)
2483 {
2484   if ((abfd->flags & BFD_COMPRESS) == 0)
2485     abort ();
2486
2487   switch (bfd_get_flavour (abfd))
2488     {
2489     case bfd_target_elf_flavour:
2490       if ((abfd->flags & BFD_COMPRESS_GABI) != 0)
2491         {
2492           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2493           struct bfd_elf_section_data * esd = elf_section_data (sec);
2494
2495           /* Set the SHF_COMPRESSED bit.  */
2496           elf_section_flags (sec) |= SHF_COMPRESSED;
2497
2498           if (bed->s->elfclass == ELFCLASS32)
2499             {
2500               Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2501               bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2502               bfd_put_32 (abfd, sec->size, &echdr->ch_size);
2503               bfd_put_32 (abfd, 1 << sec->alignment_power,
2504                           &echdr->ch_addralign);
2505               /* bfd_log2 (alignof (Elf32_Chdr)) */
2506               bfd_set_section_alignment (sec, 2);
2507               esd->this_hdr.sh_addralign = 4;
2508             }
2509           else
2510             {
2511               Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2512               bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2513               bfd_put_32 (abfd, 0, &echdr->ch_reserved);
2514               bfd_put_64 (abfd, sec->size, &echdr->ch_size);
2515               bfd_put_64 (abfd, 1 << sec->alignment_power,
2516                           &echdr->ch_addralign);
2517               /* bfd_log2 (alignof (Elf64_Chdr)) */
2518               bfd_set_section_alignment (sec, 3);
2519               esd->this_hdr.sh_addralign = 8;
2520             }
2521           break;
2522         }
2523
2524       /* Clear the SHF_COMPRESSED bit.  */
2525       elf_section_flags (sec) &= ~SHF_COMPRESSED;
2526       /* Fall through.  */
2527
2528     default:
2529       /* Write the zlib header.  It should be "ZLIB" followed by
2530          the uncompressed section size, 8 bytes in big-endian
2531          order.  */
2532       memcpy (contents, "ZLIB", 4);
2533       bfd_putb64 (sec->size, contents + 4);
2534       /* No way to keep the original alignment, just use 1 always. */
2535       bfd_set_section_alignment (sec, 0);
2536       break;
2537     }
2538 }
2539
2540 /*
2541    FUNCTION
2542    bfd_check_compression_header
2543
2544    SYNOPSIS
2545         bfd_boolean bfd_check_compression_header
2546           (bfd *abfd, bfd_byte *contents, asection *sec,
2547           bfd_size_type *uncompressed_size,
2548           unsigned int *uncompressed_alignment_power);
2549
2550 DESCRIPTION
2551         Check the compression header at CONTENTS of SEC in ABFD and
2552         store the uncompressed size in UNCOMPRESSED_SIZE and the
2553         uncompressed data alignment in UNCOMPRESSED_ALIGNMENT_POWER
2554         if the compression header is valid.
2555
2556 RETURNS
2557         Return TRUE if the compression header is valid.
2558 */
2559
2560 bfd_boolean
2561 bfd_check_compression_header (bfd *abfd, bfd_byte *contents,
2562                               asection *sec,
2563                               bfd_size_type *uncompressed_size,
2564                               unsigned int *uncompressed_alignment_power)
2565 {
2566   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2567       && (elf_section_flags (sec) & SHF_COMPRESSED) != 0)
2568     {
2569       Elf_Internal_Chdr chdr;
2570       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2571       if (bed->s->elfclass == ELFCLASS32)
2572         {
2573           Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2574           chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type);
2575           chdr.ch_size = bfd_get_32 (abfd, &echdr->ch_size);
2576           chdr.ch_addralign = bfd_get_32 (abfd, &echdr->ch_addralign);
2577         }
2578       else
2579         {
2580           Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2581           chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type);
2582           chdr.ch_size = bfd_get_64 (abfd, &echdr->ch_size);
2583           chdr.ch_addralign = bfd_get_64 (abfd, &echdr->ch_addralign);
2584         }
2585       if (chdr.ch_type == ELFCOMPRESS_ZLIB
2586           && chdr.ch_addralign == (chdr.ch_addralign & -chdr.ch_addralign))
2587         {
2588           *uncompressed_size = chdr.ch_size;
2589           *uncompressed_alignment_power = bfd_log2 (chdr.ch_addralign);
2590           return TRUE;
2591         }
2592     }
2593
2594   return FALSE;
2595 }
2596
2597 /*
2598 FUNCTION
2599         bfd_get_compression_header_size
2600
2601 SYNOPSIS
2602         int bfd_get_compression_header_size (bfd *abfd, asection *sec);
2603
2604 DESCRIPTION
2605         Return the size of the compression header of SEC in ABFD.
2606
2607 RETURNS
2608         Return the size of the compression header in bytes.
2609 */
2610
2611 int
2612 bfd_get_compression_header_size (bfd *abfd, asection *sec)
2613 {
2614   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2615     {
2616       if (sec == NULL)
2617         {
2618           if (!(abfd->flags & BFD_COMPRESS_GABI))
2619             return 0;
2620         }
2621       else if (!(elf_section_flags (sec) & SHF_COMPRESSED))
2622         return 0;
2623
2624       if (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS32)
2625         return sizeof (Elf32_External_Chdr);
2626       else
2627         return sizeof (Elf64_External_Chdr);
2628     }
2629
2630   return 0;
2631 }
2632
2633 /*
2634 FUNCTION
2635         bfd_convert_section_size
2636
2637 SYNOPSIS
2638         bfd_size_type bfd_convert_section_size
2639           (bfd *ibfd, asection *isec, bfd *obfd, bfd_size_type size);
2640
2641 DESCRIPTION
2642         Convert the size @var{size} of the section @var{isec} in input
2643         BFD @var{ibfd} to the section size in output BFD @var{obfd}.
2644 */
2645
2646 bfd_size_type
2647 bfd_convert_section_size (bfd *ibfd, sec_ptr isec, bfd *obfd,
2648                           bfd_size_type size)
2649 {
2650   bfd_size_type hdr_size;
2651
2652   /* Do nothing if either input or output aren't ELF.  */
2653   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2654       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2655     return size;
2656
2657   /* Do nothing if ELF classes of input and output are the same. */
2658   if (get_elf_backend_data (ibfd)->s->elfclass
2659       == get_elf_backend_data (obfd)->s->elfclass)
2660     return size;
2661
2662   /* Convert GNU property size.  */
2663   if (CONST_STRNEQ (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
2664     return _bfd_elf_convert_gnu_property_size (ibfd, obfd);
2665
2666   /* Do nothing if input file will be decompressed.  */
2667   if ((ibfd->flags & BFD_DECOMPRESS))
2668     return size;
2669
2670   /* Do nothing if the input section isn't a SHF_COMPRESSED section. */
2671   hdr_size = bfd_get_compression_header_size (ibfd, isec);
2672   if (hdr_size == 0)
2673     return size;
2674
2675   /* Adjust the size of the output SHF_COMPRESSED section.  */
2676   if (hdr_size == sizeof (Elf32_External_Chdr))
2677     return (size - sizeof (Elf32_External_Chdr)
2678             + sizeof (Elf64_External_Chdr));
2679   else
2680     return (size - sizeof (Elf64_External_Chdr)
2681             + sizeof (Elf32_External_Chdr));
2682 }
2683
2684 /*
2685 FUNCTION
2686         bfd_convert_section_contents
2687
2688 SYNOPSIS
2689         bfd_boolean bfd_convert_section_contents
2690           (bfd *ibfd, asection *isec, bfd *obfd,
2691            bfd_byte **ptr, bfd_size_type *ptr_size);
2692
2693 DESCRIPTION
2694         Convert the contents, stored in @var{*ptr}, of the section
2695         @var{isec} in input BFD @var{ibfd} to output BFD @var{obfd}
2696         if needed.  The original buffer pointed to by @var{*ptr} may
2697         be freed and @var{*ptr} is returned with memory malloc'd by this
2698         function, and the new size written to @var{ptr_size}.
2699 */
2700
2701 bfd_boolean
2702 bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
2703                               bfd_byte **ptr, bfd_size_type *ptr_size)
2704 {
2705   bfd_byte *contents;
2706   bfd_size_type ihdr_size, ohdr_size, size;
2707   Elf_Internal_Chdr chdr;
2708   bfd_boolean use_memmove;
2709
2710   /* Do nothing if either input or output aren't ELF.  */
2711   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2712       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2713     return TRUE;
2714
2715   /* Do nothing if ELF classes of input and output are the same.  */
2716   if (get_elf_backend_data (ibfd)->s->elfclass
2717       == get_elf_backend_data (obfd)->s->elfclass)
2718     return TRUE;
2719
2720   /* Convert GNU properties.  */
2721   if (CONST_STRNEQ (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
2722     return _bfd_elf_convert_gnu_properties (ibfd, isec, obfd, ptr,
2723                                             ptr_size);
2724
2725   /* Do nothing if input file will be decompressed.  */
2726   if ((ibfd->flags & BFD_DECOMPRESS))
2727     return TRUE;
2728
2729   /* Do nothing if the input section isn't a SHF_COMPRESSED section.  */
2730   ihdr_size = bfd_get_compression_header_size (ibfd, isec);
2731   if (ihdr_size == 0)
2732     return TRUE;
2733
2734   /* PR 25221.  Check for corrupt input sections.  */
2735   if (ihdr_size > bfd_get_section_limit (ibfd, isec))
2736     /* FIXME: Issue a warning about a corrupt
2737        compression header size field ?  */
2738     return FALSE;
2739
2740   contents = *ptr;
2741
2742   /* Convert the contents of the input SHF_COMPRESSED section to
2743      output.  Get the input compression header and the size of the
2744      output compression header.  */
2745   if (ihdr_size == sizeof (Elf32_External_Chdr))
2746     {
2747       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2748       chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type);
2749       chdr.ch_size = bfd_get_32 (ibfd, &echdr->ch_size);
2750       chdr.ch_addralign = bfd_get_32 (ibfd, &echdr->ch_addralign);
2751
2752       ohdr_size = sizeof (Elf64_External_Chdr);
2753
2754       use_memmove = FALSE;
2755     }
2756   else if (ihdr_size != sizeof (Elf64_External_Chdr))
2757     {
2758       /* FIXME: Issue a warning about a corrupt
2759          compression header size field ?  */
2760       return FALSE;
2761     }
2762   else
2763     {
2764       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2765       chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type);
2766       chdr.ch_size = bfd_get_64 (ibfd, &echdr->ch_size);
2767       chdr.ch_addralign = bfd_get_64 (ibfd, &echdr->ch_addralign);
2768
2769       ohdr_size = sizeof (Elf32_External_Chdr);
2770       use_memmove = TRUE;
2771     }
2772
2773   size = bfd_section_size (isec) - ihdr_size + ohdr_size;
2774   if (!use_memmove)
2775     {
2776       contents = (bfd_byte *) bfd_malloc (size);
2777       if (contents == NULL)
2778         return FALSE;
2779     }
2780
2781   /* Write out the output compression header.  */
2782   if (ohdr_size == sizeof (Elf32_External_Chdr))
2783     {
2784       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2785       bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2786       bfd_put_32 (obfd, chdr.ch_size, &echdr->ch_size);
2787       bfd_put_32 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
2788     }
2789   else
2790     {
2791       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2792       bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2793       bfd_put_32 (obfd, 0, &echdr->ch_reserved);
2794       bfd_put_64 (obfd, chdr.ch_size, &echdr->ch_size);
2795       bfd_put_64 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
2796     }
2797
2798   /* Copy the compressed contents.  */
2799   if (use_memmove)
2800     memmove (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size);
2801   else
2802     {
2803       memcpy (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size);
2804       free (*ptr);
2805       *ptr = contents;
2806     }
2807
2808   *ptr_size = size;
2809   return TRUE;
2810 }
2811
2812 /* Get the linker information.  */
2813
2814 struct bfd_link_info *
2815 _bfd_get_link_info (bfd *abfd)
2816 {
2817   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
2818     return NULL;
2819
2820   return elf_link_info (abfd);
2821 }