bfd/bfd.c

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