bfd/bfd.c

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