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