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