bfd/bfd.c

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