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 static void
1091 error_handler_internal (const char *fmt, va_list ap)
1092 {
1093   unsigned int i, arg_count;
1094   union _bfd_doprnt_args args[9];
1095
1096   for (i = 0; i < sizeof (args) / sizeof (args[0]); i++)
1097     args[i].type = Bad;
1098
1099   arg_count = _bfd_doprnt_scan (fmt, args);
1100   for (i = 0; i < arg_count; i++)
1101     {
1102       switch (args[i].type)
1103         {
1104         case Int:
1105           args[i].i = va_arg (ap, int);
1106           break;
1107         case Long:
1108           args[i].l = va_arg (ap, long);
1109           break;
1110         case LongLong:
1111           args[i].ll = va_arg (ap, long long);
1112           break;
1113         case Double:
1114           args[i].d = va_arg (ap, double);
1115           break;
1116         case LongDouble:
1117           args[i].ld = va_arg (ap, long double);
1118           break;
1119         case Ptr:
1120           args[i].p = va_arg (ap, void *);
1121           break;
1122         default:
1123           abort ();
1124         }
1125     }
1126
1127   /* PR 4992: Don't interrupt output being sent to stdout.  */
1128   fflush (stdout);
1129
1130   if (_bfd_error_program_name != NULL)
1131     fprintf (stderr, "%s: ", _bfd_error_program_name);
1132   else
1133     fprintf (stderr, "BFD: ");
1134
1135   _bfd_doprnt (stderr, fmt, args);
1136
1137   /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
1138      warning, so use the fputc function to avoid it.  */
1139   fputc ('\n', stderr);
1140   fflush (stderr);
1141 }
1142
1143 /* This is a function pointer to the routine which should handle BFD
1144    error messages.  It is called when a BFD routine encounters an
1145    error for which it wants to print a message.  Going through a
1146    function pointer permits a program linked against BFD to intercept
1147    the messages and deal with them itself.  */
1148
1149 static bfd_error_handler_type _bfd_error_internal = error_handler_internal;
1150
1151 /*
1152 FUNCTION
1153         _bfd_error_handler
1154
1155 SYNOPSIS
1156         void _bfd_error_handler (const char *fmt, ...) ATTRIBUTE_PRINTF_1;
1157
1158 DESCRIPTION
1159         This is the default routine to handle BFD error messages.
1160         Like fprintf (stderr, ...), but also handles some extra format
1161         specifiers.
1162
1163         %pA section name from section.  For group components, prints
1164         group name too.
1165         %pB file name from bfd.  For archive components, prints
1166         archive too.
1167
1168         Beware: Only supports a maximum of 9 format arguments.
1169 */
1170
1171 void
1172 _bfd_error_handler (const char *fmt, ...)
1173 {
1174   va_list ap;
1175
1176   va_start (ap, fmt);
1177   _bfd_error_internal (fmt, ap);
1178   va_end (ap);
1179 }
1180
1181 /*
1182 FUNCTION
1183         bfd_set_error_handler
1184
1185 SYNOPSIS
1186         bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
1187
1188 DESCRIPTION
1189         Set the BFD error handler function.  Returns the previous
1190         function.
1191 */
1192
1193 bfd_error_handler_type
1194 bfd_set_error_handler (bfd_error_handler_type pnew)
1195 {
1196   bfd_error_handler_type pold;
1197
1198   pold = _bfd_error_internal;
1199   _bfd_error_internal = pnew;
1200   return pold;
1201 }
1202
1203 /*
1204 FUNCTION
1205         bfd_set_error_program_name
1206
1207 SYNOPSIS
1208         void bfd_set_error_program_name (const char *);
1209
1210 DESCRIPTION
1211         Set the program name to use when printing a BFD error.  This
1212         is printed before the error message followed by a colon and
1213         space.  The string must not be changed after it is passed to
1214         this function.
1215 */
1216
1217 void
1218 bfd_set_error_program_name (const char *name)
1219 {
1220   _bfd_error_program_name = name;
1221 }
1222
1223 /*
1224 SUBSECTION
1225         BFD assert handler
1226
1227         If BFD finds an internal inconsistency, the bfd assert
1228         handler is called with information on the BFD version, BFD
1229         source file and line.  If this happens, most programs linked
1230         against BFD are expected to want to exit with an error, or mark
1231         the current BFD operation as failed, so it is recommended to
1232         override the default handler, which just calls
1233         _bfd_error_handler and continues.
1234
1235 CODE_FRAGMENT
1236 .
1237 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,
1238 .                                         const char *bfd_version,
1239 .                                         const char *bfd_file,
1240 .                                         int bfd_line);
1241 .
1242 */
1243
1244 /* Note the use of bfd_ prefix on the parameter names above: we want to
1245    show which one is the message and which is the version by naming the
1246    parameters, but avoid polluting the program-using-bfd namespace as
1247    the typedef is visible in the exported headers that the program
1248    includes.  Below, it's just for consistency.  */
1249
1250 static void
1251 _bfd_default_assert_handler (const char *bfd_formatmsg,
1252                              const char *bfd_version,
1253                              const char *bfd_file,
1254                              int bfd_line)
1255
1256 {
1257   _bfd_error_handler (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
1258 }
1259
1260 /* Similar to _bfd_error_handler, a program can decide to exit on an
1261    internal BFD error.  We use a non-variadic type to simplify passing
1262    on parameters to other functions, e.g. _bfd_error_handler.  */
1263
1264 static bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler;
1265
1266 /*
1267 FUNCTION
1268         bfd_set_assert_handler
1269
1270 SYNOPSIS
1271         bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type);
1272
1273 DESCRIPTION
1274         Set the BFD assert handler function.  Returns the previous
1275         function.
1276 */
1277
1278 bfd_assert_handler_type
1279 bfd_set_assert_handler (bfd_assert_handler_type pnew)
1280 {
1281   bfd_assert_handler_type pold;
1282
1283   pold = _bfd_assert_handler;
1284   _bfd_assert_handler = pnew;
1285   return pold;
1286 }
1287 \f
1288 /*
1289 INODE
1290 Miscellaneous, Memory Usage, Error reporting, BFD front end
1291
1292 SECTION
1293         Miscellaneous
1294
1295 SUBSECTION
1296         Miscellaneous functions
1297 */
1298
1299 /*
1300 FUNCTION
1301         bfd_get_reloc_upper_bound
1302
1303 SYNOPSIS
1304         long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
1305
1306 DESCRIPTION
1307         Return the number of bytes required to store the
1308         relocation information associated with section @var{sect}
1309         attached to bfd @var{abfd}.  If an error occurs, return -1.
1310
1311 */
1312
1313 long
1314 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
1315 {
1316   if (abfd->format != bfd_object)
1317     {
1318       bfd_set_error (bfd_error_invalid_operation);
1319       return -1;
1320     }
1321
1322   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
1323 }
1324
1325 /*
1326 FUNCTION
1327         bfd_canonicalize_reloc
1328
1329 SYNOPSIS
1330         long bfd_canonicalize_reloc
1331           (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
1332
1333 DESCRIPTION
1334         Call the back end associated with the open BFD
1335         @var{abfd} and translate the external form of the relocation
1336         information attached to @var{sec} into the internal canonical
1337         form.  Place the table into memory at @var{loc}, which has
1338         been preallocated, usually by a call to
1339         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
1340         -1 on error.
1341
1342         The @var{syms} table is also needed for horrible internal magic
1343         reasons.
1344
1345 */
1346 long
1347 bfd_canonicalize_reloc (bfd *abfd,
1348                         sec_ptr asect,
1349                         arelent **location,
1350                         asymbol **symbols)
1351 {
1352   if (abfd->format != bfd_object)
1353     {
1354       bfd_set_error (bfd_error_invalid_operation);
1355       return -1;
1356     }
1357
1358   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
1359                    (abfd, asect, location, symbols));
1360 }
1361
1362 /*
1363 FUNCTION
1364         bfd_set_reloc
1365
1366 SYNOPSIS
1367         void bfd_set_reloc
1368           (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
1369
1370 DESCRIPTION
1371         Set the relocation pointer and count within
1372         section @var{sec} to the values @var{rel} and @var{count}.
1373         The argument @var{abfd} is ignored.
1374
1375 .#define bfd_set_reloc(abfd, asect, location, count) \
1376 .       BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count))
1377 */
1378
1379 /*
1380 FUNCTION
1381         bfd_set_file_flags
1382
1383 SYNOPSIS
1384         bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
1385
1386 DESCRIPTION
1387         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
1388
1389         Possible errors are:
1390         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
1391         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
1392         o <<bfd_error_invalid_operation>> -
1393         The flag word contained a bit which was not applicable to the
1394         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
1395         on a BFD format which does not support demand paging.
1396
1397 */
1398
1399 bfd_boolean
1400 bfd_set_file_flags (bfd *abfd, flagword flags)
1401 {
1402   if (abfd->format != bfd_object)
1403     {
1404       bfd_set_error (bfd_error_wrong_format);
1405       return FALSE;
1406     }
1407
1408   if (bfd_read_p (abfd))
1409     {
1410       bfd_set_error (bfd_error_invalid_operation);
1411       return FALSE;
1412     }
1413
1414   bfd_get_file_flags (abfd) = flags;
1415   if ((flags & bfd_applicable_file_flags (abfd)) != flags)
1416     {
1417       bfd_set_error (bfd_error_invalid_operation);
1418       return FALSE;
1419     }
1420
1421   return TRUE;
1422 }
1423
1424 void
1425 bfd_assert (const char *file, int line)
1426 {
1427   /* xgettext:c-format */
1428   (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"),
1429                           BFD_VERSION_STRING, file, line);
1430 }
1431
1432 /* A more or less friendly abort message.  In libbfd.h abort is
1433    defined to call this function.  */
1434
1435 void
1436 _bfd_abort (const char *file, int line, const char *fn)
1437 {
1438   if (fn != NULL)
1439     _bfd_error_handler
1440       /* xgettext:c-format */
1441       (_("BFD %s internal error, aborting at %s:%d in %s\n"),
1442        BFD_VERSION_STRING, file, line, fn);
1443   else
1444     _bfd_error_handler
1445       /* xgettext:c-format */
1446       (_("BFD %s internal error, aborting at %s:%d\n"),
1447        BFD_VERSION_STRING, file, line);
1448   _bfd_error_handler (_("Please report this bug.\n"));
1449   _exit (EXIT_FAILURE);
1450 }
1451
1452 /*
1453 FUNCTION
1454         bfd_get_arch_size
1455
1456 SYNOPSIS
1457         int bfd_get_arch_size (bfd *abfd);
1458
1459 DESCRIPTION
1460         Returns the normalized architecture address size, in bits, as
1461         determined by the object file's format.  By normalized, we mean
1462         either 32 or 64.  For ELF, this information is included in the
1463         header.  Use bfd_arch_bits_per_address for number of bits in
1464         the architecture address.
1465
1466 RETURNS
1467         Returns the arch size in bits if known, <<-1>> otherwise.
1468 */
1469
1470 int
1471 bfd_get_arch_size (bfd *abfd)
1472 {
1473   if (abfd->xvec->flavour == bfd_target_elf_flavour)
1474     return get_elf_backend_data (abfd)->s->arch_size;
1475
1476   return bfd_arch_bits_per_address (abfd) > 32 ? 64 : 32;
1477 }
1478
1479 /*
1480 FUNCTION
1481         bfd_get_sign_extend_vma
1482
1483 SYNOPSIS
1484         int bfd_get_sign_extend_vma (bfd *abfd);
1485
1486 DESCRIPTION
1487         Indicates if the target architecture "naturally" sign extends
1488         an address.  Some architectures implicitly sign extend address
1489         values when they are converted to types larger than the size
1490         of an address.  For instance, bfd_get_start_address() will
1491         return an address sign extended to fill a bfd_vma when this is
1492         the case.
1493
1494 RETURNS
1495         Returns <<1>> if the target architecture is known to sign
1496         extend addresses, <<0>> if the target architecture is known to
1497         not sign extend addresses, and <<-1>> otherwise.
1498 */
1499
1500 int
1501 bfd_get_sign_extend_vma (bfd *abfd)
1502 {
1503   char *name;
1504
1505   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1506     return get_elf_backend_data (abfd)->sign_extend_vma;
1507
1508   name = bfd_get_target (abfd);
1509
1510   /* Return a proper value for DJGPP & PE COFF.
1511      This function is required for DWARF2 support, but there is
1512      no place to store this information in the COFF back end.
1513      Should enough other COFF targets add support for DWARF2,
1514      a place will have to be found.  Until then, this hack will do.  */
1515   if (CONST_STRNEQ (name, "coff-go32")
1516       || strcmp (name, "pe-i386") == 0
1517       || strcmp (name, "pei-i386") == 0
1518       || strcmp (name, "pe-x86-64") == 0
1519       || strcmp (name, "pei-x86-64") == 0
1520       || strcmp (name, "pe-arm-wince-little") == 0
1521       || strcmp (name, "pei-arm-wince-little") == 0
1522       || strcmp (name, "aixcoff-rs6000") == 0
1523       || strcmp (name, "aix5coff64-rs6000") == 0)
1524     return 1;
1525
1526   if (CONST_STRNEQ (name, "mach-o"))
1527     return 0;
1528
1529   bfd_set_error (bfd_error_wrong_format);
1530   return -1;
1531 }
1532
1533 /*
1534 FUNCTION
1535         bfd_set_start_address
1536
1537 SYNOPSIS
1538         bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
1539
1540 DESCRIPTION
1541         Make @var{vma} the entry point of output BFD @var{abfd}.
1542
1543 RETURNS
1544         Returns <<TRUE>> on success, <<FALSE>> otherwise.
1545 */
1546
1547 bfd_boolean
1548 bfd_set_start_address (bfd *abfd, bfd_vma vma)
1549 {
1550   abfd->start_address = vma;
1551   return TRUE;
1552 }
1553
1554 /*
1555 FUNCTION
1556         bfd_get_gp_size
1557
1558 SYNOPSIS
1559         unsigned int bfd_get_gp_size (bfd *abfd);
1560
1561 DESCRIPTION
1562         Return the maximum size of objects to be optimized using the GP
1563         register under MIPS ECOFF.  This is typically set by the <<-G>>
1564         argument to the compiler, assembler or linker.
1565 */
1566
1567 unsigned int
1568 bfd_get_gp_size (bfd *abfd)
1569 {
1570   if (abfd->format == bfd_object)
1571     {
1572       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1573         return ecoff_data (abfd)->gp_size;
1574       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1575         return elf_gp_size (abfd);
1576     }
1577   return 0;
1578 }
1579
1580 /*
1581 FUNCTION
1582         bfd_set_gp_size
1583
1584 SYNOPSIS
1585         void bfd_set_gp_size (bfd *abfd, unsigned int i);
1586
1587 DESCRIPTION
1588         Set the maximum size of objects to be optimized using the GP
1589         register under ECOFF or MIPS ELF.  This is typically set by
1590         the <<-G>> argument to the compiler, assembler or linker.
1591 */
1592
1593 void
1594 bfd_set_gp_size (bfd *abfd, unsigned int i)
1595 {
1596   /* Don't try to set GP size on an archive or core file!  */
1597   if (abfd->format != bfd_object)
1598     return;
1599
1600   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1601     ecoff_data (abfd)->gp_size = i;
1602   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1603     elf_gp_size (abfd) = i;
1604 }
1605
1606 /* Get the GP value.  This is an internal function used by some of the
1607    relocation special_function routines on targets which support a GP
1608    register.  */
1609
1610 bfd_vma
1611 _bfd_get_gp_value (bfd *abfd)
1612 {
1613   if (! abfd)
1614     return 0;
1615   if (abfd->format != bfd_object)
1616     return 0;
1617
1618   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1619     return ecoff_data (abfd)->gp;
1620   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1621     return elf_gp (abfd);
1622
1623   return 0;
1624 }
1625
1626 /* Set the GP value.  */
1627
1628 void
1629 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
1630 {
1631   if (! abfd)
1632     abort ();
1633   if (abfd->format != bfd_object)
1634     return;
1635
1636   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1637     ecoff_data (abfd)->gp = v;
1638   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1639     elf_gp (abfd) = v;
1640 }
1641
1642 /*
1643 FUNCTION
1644         bfd_scan_vma
1645
1646 SYNOPSIS
1647         bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1648
1649 DESCRIPTION
1650         Convert, like <<strtoul>>, a numerical expression
1651         @var{string} into a <<bfd_vma>> integer, and return that integer.
1652         (Though without as many bells and whistles as <<strtoul>>.)
1653         The expression is assumed to be unsigned (i.e., positive).
1654         If given a @var{base}, it is used as the base for conversion.
1655         A base of 0 causes the function to interpret the string
1656         in hex if a leading "0x" or "0X" is found, otherwise
1657         in octal if a leading zero is found, otherwise in decimal.
1658
1659         If the value would overflow, the maximum <<bfd_vma>> value is
1660         returned.
1661 */
1662
1663 bfd_vma
1664 bfd_scan_vma (const char *string, const char **end, int base)
1665 {
1666   bfd_vma value;
1667   bfd_vma cutoff;
1668   unsigned int cutlim;
1669   int overflow;
1670
1671   /* Let the host do it if possible.  */
1672   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1673     return strtoul (string, (char **) end, base);
1674
1675 #if defined (HAVE_STRTOULL) && defined (HAVE_LONG_LONG)
1676   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1677     return strtoull (string, (char **) end, base);
1678 #endif
1679
1680   if (base == 0)
1681     {
1682       if (string[0] == '0')
1683         {
1684           if ((string[1] == 'x') || (string[1] == 'X'))
1685             base = 16;
1686           else
1687             base = 8;
1688         }
1689     }
1690
1691   if ((base < 2) || (base > 36))
1692     base = 10;
1693
1694   if (base == 16
1695       && string[0] == '0'
1696       && (string[1] == 'x' || string[1] == 'X')
1697       && ISXDIGIT (string[2]))
1698     {
1699       string += 2;
1700     }
1701
1702   cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1703   cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1704   value = 0;
1705   overflow = 0;
1706   while (1)
1707     {
1708       unsigned int digit;
1709
1710       digit = *string;
1711       if (ISDIGIT (digit))
1712         digit = digit - '0';
1713       else if (ISALPHA (digit))
1714         digit = TOUPPER (digit) - 'A' + 10;
1715       else
1716         break;
1717       if (digit >= (unsigned int) base)
1718         break;
1719       if (value > cutoff || (value == cutoff && digit > cutlim))
1720         overflow = 1;
1721       value = value * base + digit;
1722       ++string;
1723     }
1724
1725   if (overflow)
1726     value = ~ (bfd_vma) 0;
1727
1728   if (end != NULL)
1729     *end = string;
1730
1731   return value;
1732 }
1733
1734 /*
1735 FUNCTION
1736         bfd_copy_private_header_data
1737
1738 SYNOPSIS
1739         bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1740
1741 DESCRIPTION
1742         Copy private BFD header information from the BFD @var{ibfd} to the
1743         the BFD @var{obfd}.  This copies information that may require
1744         sections to exist, but does not require symbol tables.  Return
1745         <<true>> on success, <<false>> on error.
1746         Possible error returns are:
1747
1748         o <<bfd_error_no_memory>> -
1749         Not enough memory exists to create private data for @var{obfd}.
1750
1751 .#define bfd_copy_private_header_data(ibfd, obfd) \
1752 .       BFD_SEND (obfd, _bfd_copy_private_header_data, \
1753 .                 (ibfd, obfd))
1754
1755 */
1756
1757 /*
1758 FUNCTION
1759         bfd_copy_private_bfd_data
1760
1761 SYNOPSIS
1762         bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1763
1764 DESCRIPTION
1765         Copy private BFD information from the BFD @var{ibfd} to the
1766         the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
1767         Possible error returns are:
1768
1769         o <<bfd_error_no_memory>> -
1770         Not enough memory exists to create private data for @var{obfd}.
1771
1772 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1773 .       BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1774 .                 (ibfd, obfd))
1775
1776 */
1777
1778 /*
1779 FUNCTION
1780         bfd_set_private_flags
1781
1782 SYNOPSIS
1783         bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1784
1785 DESCRIPTION
1786         Set private BFD flag information in the BFD @var{abfd}.
1787         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1788         returns are:
1789
1790         o <<bfd_error_no_memory>> -
1791         Not enough memory exists to create private data for @var{obfd}.
1792
1793 .#define bfd_set_private_flags(abfd, flags) \
1794 .       BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1795
1796 */
1797
1798 /*
1799 FUNCTION
1800         Other functions
1801
1802 DESCRIPTION
1803         The following functions exist but have not yet been documented.
1804
1805 .#define bfd_sizeof_headers(abfd, info) \
1806 .       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
1807 .
1808 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1809 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1810 .                 (abfd, syms, sec, off, file, func, line, NULL))
1811 .
1812 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
1813 .                                           line, disc) \
1814 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1815 .                 (abfd, syms, sec, off, file, func, line, disc))
1816 .
1817 .#define bfd_find_line(abfd, syms, sym, file, line) \
1818 .       BFD_SEND (abfd, _bfd_find_line, \
1819 .                 (abfd, syms, sym, file, line))
1820 .
1821 .#define bfd_find_inliner_info(abfd, file, func, line) \
1822 .       BFD_SEND (abfd, _bfd_find_inliner_info, \
1823 .                 (abfd, file, func, line))
1824 .
1825 .#define bfd_debug_info_start(abfd) \
1826 .       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1827 .
1828 .#define bfd_debug_info_end(abfd) \
1829 .       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1830 .
1831 .#define bfd_debug_info_accumulate(abfd, section) \
1832 .       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1833 .
1834 .#define bfd_stat_arch_elt(abfd, stat) \
1835 .       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1836 .
1837 .#define bfd_update_armap_timestamp(abfd) \
1838 .       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1839 .
1840 .#define bfd_set_arch_mach(abfd, arch, mach)\
1841 .       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1842 .
1843 .#define bfd_relax_section(abfd, section, link_info, again) \
1844 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1845 .
1846 .#define bfd_gc_sections(abfd, link_info) \
1847 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1848 .
1849 .#define bfd_lookup_section_flags(link_info, flag_info, section) \
1850 .       BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section))
1851 .
1852 .#define bfd_merge_sections(abfd, link_info) \
1853 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1854 .
1855 .#define bfd_is_group_section(abfd, sec) \
1856 .       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1857 .
1858 .#define bfd_discard_group(abfd, sec) \
1859 .       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1860 .
1861 .#define bfd_link_hash_table_create(abfd) \
1862 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1863 .
1864 .#define bfd_link_add_symbols(abfd, info) \
1865 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1866 .
1867 .#define bfd_link_just_syms(abfd, sec, info) \
1868 .       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1869 .
1870 .#define bfd_final_link(abfd, info) \
1871 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1872 .
1873 .#define bfd_free_cached_info(abfd) \
1874 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1875 .
1876 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1877 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1878 .
1879 .#define bfd_print_private_bfd_data(abfd, file)\
1880 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1881 .
1882 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1883 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1884 .
1885 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1886 .       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1887 .                                                   dyncount, dynsyms, ret))
1888 .
1889 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1890 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1891 .
1892 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1893 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1894 .
1895 .extern bfd_byte *bfd_get_relocated_section_contents
1896 .  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1897 .   bfd_boolean, asymbol **);
1898 .
1899
1900 */
1901
1902 bfd_byte *
1903 bfd_get_relocated_section_contents (bfd *abfd,
1904                                     struct bfd_link_info *link_info,
1905                                     struct bfd_link_order *link_order,
1906                                     bfd_byte *data,
1907                                     bfd_boolean relocatable,
1908                                     asymbol **symbols)
1909 {
1910   bfd *abfd2;
1911   bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1912                    bfd_byte *, bfd_boolean, asymbol **);
1913
1914   if (link_order->type == bfd_indirect_link_order)
1915     {
1916       abfd2 = link_order->u.indirect.section->owner;
1917       if (abfd2 == NULL)
1918         abfd2 = abfd;
1919     }
1920   else
1921     abfd2 = abfd;
1922
1923   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1924
1925   return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1926 }
1927
1928 /* Record information about an ELF program header.  */
1929
1930 bfd_boolean
1931 bfd_record_phdr (bfd *abfd,
1932                  unsigned long type,
1933                  bfd_boolean flags_valid,
1934                  flagword flags,
1935                  bfd_boolean at_valid,
1936                  bfd_vma at,
1937                  bfd_boolean includes_filehdr,
1938                  bfd_boolean includes_phdrs,
1939                  unsigned int count,
1940                  asection **secs)
1941 {
1942   struct elf_segment_map *m, **pm;
1943   bfd_size_type amt;
1944
1945   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1946     return TRUE;
1947
1948   amt = sizeof (struct elf_segment_map);
1949   amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1950   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
1951   if (m == NULL)
1952     return FALSE;
1953
1954   m->p_type = type;
1955   m->p_flags = flags;
1956   m->p_paddr = at;
1957   m->p_flags_valid = flags_valid;
1958   m->p_paddr_valid = at_valid;
1959   m->includes_filehdr = includes_filehdr;
1960   m->includes_phdrs = includes_phdrs;
1961   m->count = count;
1962   if (count > 0)
1963     memcpy (m->sections, secs, count * sizeof (asection *));
1964
1965   for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
1966     ;
1967   *pm = m;
1968
1969   return TRUE;
1970 }
1971
1972 #ifdef BFD64
1973 /* Return true iff this target is 32-bit.  */
1974
1975 static bfd_boolean
1976 is32bit (bfd *abfd)
1977 {
1978   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1979     {
1980       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1981       return bed->s->elfclass == ELFCLASS32;
1982     }
1983
1984   /* For non-ELF targets, use architecture information.  */
1985   return bfd_arch_bits_per_address (abfd) <= 32;
1986 }
1987 #endif
1988
1989 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1990    target's address size.  */
1991
1992 void
1993 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
1994 {
1995 #ifdef BFD64
1996   if (is32bit (abfd))
1997     {
1998       sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
1999       return;
2000     }
2001 #endif
2002   sprintf_vma (buf, value);
2003 }
2004
2005 void
2006 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
2007 {
2008 #ifdef BFD64
2009   if (is32bit (abfd))
2010     {
2011       fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
2012       return;
2013     }
2014 #endif
2015   fprintf_vma ((FILE *) stream, value);
2016 }
2017
2018 /*
2019 FUNCTION
2020         bfd_alt_mach_code
2021
2022 SYNOPSIS
2023         bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
2024
2025 DESCRIPTION
2026
2027         When more than one machine code number is available for the
2028         same machine type, this function can be used to switch between
2029         the preferred one (alternative == 0) and any others.  Currently,
2030         only ELF supports this feature, with up to two alternate
2031         machine codes.
2032 */
2033
2034 bfd_boolean
2035 bfd_alt_mach_code (bfd *abfd, int alternative)
2036 {
2037   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2038     {
2039       int code;
2040
2041       switch (alternative)
2042         {
2043         case 0:
2044           code = get_elf_backend_data (abfd)->elf_machine_code;
2045           break;
2046
2047         case 1:
2048           code = get_elf_backend_data (abfd)->elf_machine_alt1;
2049           if (code == 0)
2050             return FALSE;
2051           break;
2052
2053         case 2:
2054           code = get_elf_backend_data (abfd)->elf_machine_alt2;
2055           if (code == 0)
2056             return FALSE;
2057           break;
2058
2059         default:
2060           return FALSE;
2061         }
2062
2063       elf_elfheader (abfd)->e_machine = code;
2064
2065       return TRUE;
2066     }
2067
2068   return FALSE;
2069 }
2070
2071 /*
2072 FUNCTION
2073         bfd_emul_get_maxpagesize
2074
2075 SYNOPSIS
2076         bfd_vma bfd_emul_get_maxpagesize (const char *);
2077
2078 DESCRIPTION
2079         Returns the maximum page size, in bytes, as determined by
2080         emulation.
2081
2082 RETURNS
2083         Returns the maximum page size in bytes for ELF, 0 otherwise.
2084 */
2085
2086 bfd_vma
2087 bfd_emul_get_maxpagesize (const char *emul)
2088 {
2089   const bfd_target *target;
2090
2091   target = bfd_find_target (emul, NULL);
2092   if (target != NULL
2093       && target->flavour == bfd_target_elf_flavour)
2094     return xvec_get_elf_backend_data (target)->maxpagesize;
2095
2096   return 0;
2097 }
2098
2099 static void
2100 bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
2101                       int offset, const bfd_target *orig_target)
2102 {
2103   if (target->flavour == bfd_target_elf_flavour)
2104     {
2105       const struct elf_backend_data *bed;
2106
2107       bed = xvec_get_elf_backend_data (target);
2108       *((bfd_vma *) ((char *) bed + offset)) = size;
2109     }
2110
2111   if (target->alternative_target
2112       && target->alternative_target != orig_target)
2113     bfd_elf_set_pagesize (target->alternative_target, size, offset,
2114                           orig_target);
2115 }
2116
2117 /*
2118 FUNCTION
2119         bfd_emul_set_maxpagesize
2120
2121 SYNOPSIS
2122         void bfd_emul_set_maxpagesize (const char *, bfd_vma);
2123
2124 DESCRIPTION
2125         For ELF, set the maximum page size for the emulation.  It is
2126         a no-op for other formats.
2127
2128 */
2129
2130 void
2131 bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
2132 {
2133   const bfd_target *target;
2134
2135   target = bfd_find_target (emul, NULL);
2136   if (target)
2137     bfd_elf_set_pagesize (target, size,
2138                           offsetof (struct elf_backend_data,
2139                                     maxpagesize), target);
2140 }
2141
2142 /*
2143 FUNCTION
2144         bfd_emul_get_commonpagesize
2145
2146 SYNOPSIS
2147         bfd_vma bfd_emul_get_commonpagesize (const char *, bfd_boolean);
2148
2149 DESCRIPTION
2150         Returns the common page size, in bytes, as determined by
2151         emulation.
2152
2153 RETURNS
2154         Returns the common page size in bytes for ELF, 0 otherwise.
2155 */
2156
2157 bfd_vma
2158 bfd_emul_get_commonpagesize (const char *emul, bfd_boolean relro)
2159 {
2160   const bfd_target *target;
2161
2162   target = bfd_find_target (emul, NULL);
2163   if (target != NULL
2164       && target->flavour == bfd_target_elf_flavour)
2165     {
2166       const struct elf_backend_data *bed;
2167
2168       bed = xvec_get_elf_backend_data (target);
2169       if (relro)
2170         return bed->relropagesize;
2171       else
2172         return bed->commonpagesize;
2173     }
2174   return 0;
2175 }
2176
2177 /*
2178 FUNCTION
2179         bfd_emul_set_commonpagesize
2180
2181 SYNOPSIS
2182         void bfd_emul_set_commonpagesize (const char *, bfd_vma);
2183
2184 DESCRIPTION
2185         For ELF, set the common page size for the emulation.  It is
2186         a no-op for other formats.
2187
2188 */
2189
2190 void
2191 bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
2192 {
2193   const bfd_target *target;
2194
2195   target = bfd_find_target (emul, NULL);
2196   if (target)
2197     bfd_elf_set_pagesize (target, size,
2198                           offsetof (struct elf_backend_data,
2199                                     commonpagesize), target);
2200 }
2201
2202 /*
2203 FUNCTION
2204         bfd_demangle
2205
2206 SYNOPSIS
2207         char *bfd_demangle (bfd *, const char *, int);
2208
2209 DESCRIPTION
2210         Wrapper around cplus_demangle.  Strips leading underscores and
2211         other such chars that would otherwise confuse the demangler.
2212         If passed a g++ v3 ABI mangled name, returns a buffer allocated
2213         with malloc holding the demangled name.  Returns NULL otherwise
2214         and on memory alloc failure.
2215 */
2216
2217 char *
2218 bfd_demangle (bfd *abfd, const char *name, int options)
2219 {
2220   char *res, *alloc;
2221   const char *pre, *suf;
2222   size_t pre_len;
2223   bfd_boolean skip_lead;
2224
2225   skip_lead = (abfd != NULL
2226                && *name != '\0'
2227                && bfd_get_symbol_leading_char (abfd) == *name);
2228   if (skip_lead)
2229     ++name;
2230
2231   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
2232      or the MS PE format.  These formats have a number of leading '.'s
2233      on at least some symbols, so we remove all dots to avoid
2234      confusing the demangler.  */
2235   pre = name;
2236   while (*name == '.' || *name == '$')
2237     ++name;
2238   pre_len = name - pre;
2239
2240   /* Strip off @plt and suchlike too.  */
2241   alloc = NULL;
2242   suf = strchr (name, '@');
2243   if (suf != NULL)
2244     {
2245       alloc = (char *) bfd_malloc (suf - name + 1);
2246       if (alloc == NULL)
2247         return NULL;
2248       memcpy (alloc, name, suf - name);
2249       alloc[suf - name] = '\0';
2250       name = alloc;
2251     }
2252
2253   res = cplus_demangle (name, options);
2254
2255   if (alloc != NULL)
2256     free (alloc);
2257
2258   if (res == NULL)
2259     {
2260       if (skip_lead)
2261         {
2262           size_t len = strlen (pre) + 1;
2263           alloc = (char *) bfd_malloc (len);
2264           if (alloc == NULL)
2265             return NULL;
2266           memcpy (alloc, pre, len);
2267           return alloc;
2268         }
2269       return NULL;
2270     }
2271
2272   /* Put back any prefix or suffix.  */
2273   if (pre_len != 0 || suf != NULL)
2274     {
2275       size_t len;
2276       size_t suf_len;
2277       char *final;
2278
2279       len = strlen (res);
2280       if (suf == NULL)
2281         suf = res + len;
2282       suf_len = strlen (suf) + 1;
2283       final = (char *) bfd_malloc (pre_len + len + suf_len);
2284       if (final != NULL)
2285         {
2286           memcpy (final, pre, pre_len);
2287           memcpy (final + pre_len, res, len);
2288           memcpy (final + pre_len + len, suf, suf_len);
2289         }
2290       free (res);
2291       res = final;
2292     }
2293
2294   return res;
2295 }
2296
2297 /*
2298 FUNCTION
2299         bfd_update_compression_header
2300
2301 SYNOPSIS
2302         void bfd_update_compression_header
2303           (bfd *abfd, bfd_byte *contents, asection *sec);
2304
2305 DESCRIPTION
2306         Set the compression header at CONTENTS of SEC in ABFD and update
2307         elf_section_flags for compression.
2308 */
2309
2310 void
2311 bfd_update_compression_header (bfd *abfd, bfd_byte *contents,
2312                                asection *sec)
2313 {
2314   if ((abfd->flags & BFD_COMPRESS) != 0)
2315     {
2316       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2317         {
2318           if ((abfd->flags & BFD_COMPRESS_GABI) != 0)
2319             {
2320               const struct elf_backend_data *bed
2321                 = get_elf_backend_data (abfd);
2322
2323               /* Set the SHF_COMPRESSED bit.  */
2324               elf_section_flags (sec) |= SHF_COMPRESSED;
2325
2326               if (bed->s->elfclass == ELFCLASS32)
2327                 {
2328                   Elf32_External_Chdr *echdr
2329                     = (Elf32_External_Chdr *) contents;
2330                   bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2331                   bfd_put_32 (abfd, sec->size, &echdr->ch_size);
2332                   bfd_put_32 (abfd, 1 << sec->alignment_power,
2333                               &echdr->ch_addralign);
2334                 }
2335               else
2336                 {
2337                   Elf64_External_Chdr *echdr
2338                     = (Elf64_External_Chdr *) contents;
2339                   bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2340                   bfd_put_32 (abfd, 0, &echdr->ch_reserved);
2341                   bfd_put_64 (abfd, sec->size, &echdr->ch_size);
2342                   bfd_put_64 (abfd, 1 << sec->alignment_power,
2343                               &echdr->ch_addralign);
2344                 }
2345             }
2346           else
2347             {
2348               /* Clear the SHF_COMPRESSED bit.  */
2349               elf_section_flags (sec) &= ~SHF_COMPRESSED;
2350
2351               /* Write the zlib header.  It should be "ZLIB" followed by
2352                  the uncompressed section size, 8 bytes in big-endian
2353                  order.  */
2354               memcpy (contents, "ZLIB", 4);
2355               bfd_putb64 (sec->size, contents + 4);
2356             }
2357         }
2358     }
2359   else
2360     abort ();
2361 }
2362
2363 /*
2364    FUNCTION
2365    bfd_check_compression_header
2366
2367    SYNOPSIS
2368         bfd_boolean bfd_check_compression_header
2369           (bfd *abfd, bfd_byte *contents, asection *sec,
2370           bfd_size_type *uncompressed_size);
2371
2372 DESCRIPTION
2373         Check the compression header at CONTENTS of SEC in ABFD and
2374         store the uncompressed size in UNCOMPRESSED_SIZE if the
2375         compression header is valid.
2376
2377 RETURNS
2378         Return TRUE if the compression header is valid.
2379 */
2380
2381 bfd_boolean
2382 bfd_check_compression_header (bfd *abfd, bfd_byte *contents,
2383                               asection *sec,
2384                               bfd_size_type *uncompressed_size)
2385 {
2386   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2387       && (elf_section_flags (sec) & SHF_COMPRESSED) != 0)
2388     {
2389       Elf_Internal_Chdr chdr;
2390       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2391       if (bed->s->elfclass == ELFCLASS32)
2392         {
2393           Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2394           chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type);
2395           chdr.ch_size = bfd_get_32 (abfd, &echdr->ch_size);
2396           chdr.ch_addralign = bfd_get_32 (abfd, &echdr->ch_addralign);
2397         }
2398       else
2399         {
2400           Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2401           chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type);
2402           chdr.ch_size = bfd_get_64 (abfd, &echdr->ch_size);
2403           chdr.ch_addralign = bfd_get_64 (abfd, &echdr->ch_addralign);
2404         }
2405       if (chdr.ch_type == ELFCOMPRESS_ZLIB
2406           && chdr.ch_addralign == 1U << sec->alignment_power)
2407         {
2408           *uncompressed_size = chdr.ch_size;
2409           return TRUE;
2410         }
2411     }
2412
2413   return FALSE;
2414 }
2415
2416 /*
2417 FUNCTION
2418         bfd_get_compression_header_size
2419
2420 SYNOPSIS
2421         int bfd_get_compression_header_size (bfd *abfd, asection *sec);
2422
2423 DESCRIPTION
2424         Return the size of the compression header of SEC in ABFD.
2425
2426 RETURNS
2427         Return the size of the compression header in bytes.
2428 */
2429
2430 int
2431 bfd_get_compression_header_size (bfd *abfd, asection *sec)
2432 {
2433   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2434     {
2435       if (sec == NULL)
2436         {
2437           if (!(abfd->flags & BFD_COMPRESS_GABI))
2438             return 0;
2439         }
2440       else if (!(elf_section_flags (sec) & SHF_COMPRESSED))
2441         return 0;
2442
2443       if (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS32)
2444         return sizeof (Elf32_External_Chdr);
2445       else
2446         return sizeof (Elf64_External_Chdr);
2447     }
2448
2449   return 0;
2450 }
2451
2452 /*
2453 FUNCTION
2454         bfd_convert_section_size
2455
2456 SYNOPSIS
2457         bfd_size_type bfd_convert_section_size
2458           (bfd *ibfd, asection *isec, bfd *obfd, bfd_size_type size);
2459
2460 DESCRIPTION
2461         Convert the size @var{size} of the section @var{isec} in input
2462         BFD @var{ibfd} to the section size in output BFD @var{obfd}.
2463 */
2464
2465 bfd_size_type
2466 bfd_convert_section_size (bfd *ibfd, sec_ptr isec, bfd *obfd,
2467                           bfd_size_type size)
2468 {
2469   bfd_size_type hdr_size;
2470
2471   /* Do nothing if input file will be decompressed.  */
2472   if ((ibfd->flags & BFD_DECOMPRESS))
2473     return size;
2474
2475   /* Do nothing if either input or output aren't ELF.  */
2476   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2477       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2478     return size;
2479
2480   /* Do nothing if ELF classes of input and output are the same. */
2481   if (get_elf_backend_data (ibfd)->s->elfclass
2482       == get_elf_backend_data (obfd)->s->elfclass)
2483     return size;
2484
2485   /* Do nothing if the input section isn't a SHF_COMPRESSED section. */
2486   hdr_size = bfd_get_compression_header_size (ibfd, isec);
2487   if (hdr_size == 0)
2488     return size;
2489
2490   /* Adjust the size of the output SHF_COMPRESSED section.  */
2491   if (hdr_size == sizeof (Elf32_External_Chdr))
2492     return (size - sizeof (Elf32_External_Chdr)
2493             + sizeof (Elf64_External_Chdr));
2494   else
2495     return (size - sizeof (Elf64_External_Chdr)
2496             + sizeof (Elf32_External_Chdr));
2497 }
2498
2499 /*
2500 FUNCTION
2501         bfd_convert_section_contents
2502
2503 SYNOPSIS
2504         bfd_boolean bfd_convert_section_contents
2505           (bfd *ibfd, asection *isec, bfd *obfd,
2506            bfd_byte **ptr, bfd_size_type *ptr_size);
2507
2508 DESCRIPTION
2509         Convert the contents, stored in @var{*ptr}, of the section
2510         @var{isec} in input BFD @var{ibfd} to output BFD @var{obfd}
2511         if needed.  The original buffer pointed to by @var{*ptr} may
2512         be freed and @var{*ptr} is returned with memory malloc'd by this
2513         function, and the new size written to @var{ptr_size}.
2514 */
2515
2516 bfd_boolean
2517 bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
2518                               bfd_byte **ptr, bfd_size_type *ptr_size)
2519 {
2520   bfd_byte *contents;
2521   bfd_size_type ihdr_size, ohdr_size, size;
2522   Elf_Internal_Chdr chdr;
2523   bfd_boolean use_memmove;
2524
2525   /* Do nothing if input file will be decompressed.  */
2526   if ((ibfd->flags & BFD_DECOMPRESS))
2527     return TRUE;
2528
2529   /* Do nothing if either input or output aren't ELF.  */
2530   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2531       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2532     return TRUE;
2533
2534   /* Do nothing if ELF classes of input and output are the same. */
2535   if (get_elf_backend_data (ibfd)->s->elfclass
2536       == get_elf_backend_data (obfd)->s->elfclass)
2537     return TRUE;
2538
2539   /* Do nothing if the input section isn't a SHF_COMPRESSED section. */
2540   ihdr_size = bfd_get_compression_header_size (ibfd, isec);
2541   if (ihdr_size == 0)
2542     return TRUE;
2543
2544   contents = *ptr;
2545
2546   /* Convert the contents of the input SHF_COMPRESSED section to
2547      output.  Get the input compression header and the size of the
2548      output compression header.  */
2549   if (ihdr_size == sizeof (Elf32_External_Chdr))
2550     {
2551       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2552       chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type);
2553       chdr.ch_size = bfd_get_32 (ibfd, &echdr->ch_size);
2554       chdr.ch_addralign = bfd_get_32 (ibfd, &echdr->ch_addralign);
2555
2556       ohdr_size = sizeof (Elf64_External_Chdr);
2557
2558       use_memmove = FALSE;
2559     }
2560   else
2561     {
2562       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2563       chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type);
2564       chdr.ch_size = bfd_get_64 (ibfd, &echdr->ch_size);
2565       chdr.ch_addralign = bfd_get_64 (ibfd, &echdr->ch_addralign);
2566
2567       ohdr_size = sizeof (Elf32_External_Chdr);
2568       use_memmove = TRUE;
2569     }
2570
2571   size = bfd_get_section_size (isec) - ihdr_size + ohdr_size;
2572   if (!use_memmove)
2573     {
2574       contents = (bfd_byte *) bfd_malloc (size);
2575       if (contents == NULL)
2576         return FALSE;
2577     }
2578
2579   /* Write out the output compression header.  */
2580   if (ohdr_size == sizeof (Elf32_External_Chdr))
2581     {
2582       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2583       bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2584       bfd_put_32 (obfd, chdr.ch_size, &echdr->ch_size);
2585       bfd_put_32 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
2586     }
2587   else
2588     {
2589       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2590       bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2591       bfd_put_32 (obfd, 0, &echdr->ch_reserved);
2592       bfd_put_64 (obfd, chdr.ch_size, &echdr->ch_size);
2593       bfd_put_64 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
2594     }
2595
2596   /* Copy the compressed contents.  */
2597   if (use_memmove)
2598     memmove (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size);
2599   else
2600     {
2601       memcpy (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size);
2602       free (*ptr);
2603       *ptr = contents;
2604     }
2605
2606   *ptr_size = size;
2607   return TRUE;
2608 }