bfd/bfd.c

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