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