bfd/bfd.c

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