bfd/bfd.c

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