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