bfd/bfd.c

   1 /* Generic BFD library interface and support routines.
   2    Copyright (C) 1990-2015 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_uknown = 0,
  50 .    bfd_plugin_yes = 1,
  51 .    bfd_plugin_no = 2
  52 .  };
  53 .
  54 .struct bfd
  55 .{
  56 .  {* The filename the application opened the BFD with.  *}
  57 .  const char *filename;
  58 .
  59 .  {* A pointer to the target jump table.  *}
  60 .  const struct bfd_target *xvec;
  61 .
  62 .  {* The IOSTREAM, and corresponding IO vector that provide access
  63 .     to the file backing the BFD.  *}
  64 .  void *iostream;
  65 .  const struct bfd_iovec *iovec;
  66 .
  67 .  {* The caching routines use these to maintain a
  68 .     least-recently-used list of BFDs.  *}
  69 .  struct bfd *lru_prev, *lru_next;
  70 .
  71 .  {* When a file is closed by the caching routines, BFD retains
  72 .     state information on the file here...  *}
  73 .  ufile_ptr where;
  74 .
  75 .  {* File modified time, if mtime_set is TRUE.  *}
  76 .  long mtime;
  77 .
  78 .  {* A unique identifier of the BFD  *}
  79 .  unsigned int id;
  80 .
  81 .  {* The format which belongs to the BFD. (object, core, etc.)  *}
  82 .  ENUM_BITFIELD (bfd_format) format : 3;
  83 .
  84 .  {* The direction with which the BFD was opened.  *}
  85 .  ENUM_BITFIELD (bfd_direction) direction : 2;
  86 .
  87 .  {* Format_specific flags.  *}
  88 .  flagword flags : 17;
  89 .
  90 .  {* Values that may appear in the flags field of a BFD.  These also
  91 .     appear in the object_flags field of the bfd_target structure, where
  92 .     they indicate the set of flags used by that backend (not all flags
  93 .     are meaningful for all object file formats) (FIXME: at the moment,
  94 .     the object_flags values have mostly just been copied from backend
  95 .     to another, and are not necessarily correct).  *}
  96 .
  97 .#define BFD_NO_FLAGS   0x00
  98 .
  99 .  {* BFD contains relocation entries.  *}
 100 .#define HAS_RELOC      0x01
 101 .
 102 .  {* BFD is directly executable.  *}
 103 .#define EXEC_P         0x02
 104 .
 105 .  {* BFD has line number information (basically used for F_LNNO in a
 106 .     COFF header).  *}
 107 .#define HAS_LINENO     0x04
 108 .
 109 .  {* BFD has debugging information.  *}
 110 .#define HAS_DEBUG      0x08
 111 .
 112 .  {* BFD has symbols.  *}
 113 .#define HAS_SYMS       0x10
 114 .
 115 .  {* BFD has local symbols (basically used for F_LSYMS in a COFF
 116 .     header).  *}
 117 .#define HAS_LOCALS     0x20
 118 .
 119 .  {* BFD is a dynamic object.  *}
 120 .#define DYNAMIC        0x40
 121 .
 122 .  {* Text section is write protected (if D_PAGED is not set, this is
 123 .     like an a.out NMAGIC file) (the linker sets this by default, but
 124 .     clears it for -r or -N).  *}
 125 .#define WP_TEXT        0x80
 126 .
 127 .  {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 128 .     linker sets this by default, but clears it for -r or -n or -N).  *}
 129 .#define D_PAGED        0x100
 130 .
 131 .  {* BFD is relaxable (this means that bfd_relax_section may be able to
 132 .     do something) (sometimes bfd_relax_section can do something even if
 133 .     this is not set).  *}
 134 .#define BFD_IS_RELAXABLE 0x200
 135 .
 136 .  {* This may be set before writing out a BFD to request using a
 137 .     traditional format.  For example, this is used to request that when
 138 .     writing out an a.out object the symbols not be hashed to eliminate
 139 .     duplicates.  *}
 140 .#define BFD_TRADITIONAL_FORMAT 0x400
 141 .
 142 .  {* This flag indicates that the BFD contents are actually cached
 143 .     in memory.  If this is set, iostream points to a bfd_in_memory
 144 .     struct.  *}
 145 .#define BFD_IN_MEMORY 0x800
 146 .
 147 .  {* This BFD has been created by the linker and doesn't correspond
 148 .     to any input file.  *}
 149 .#define BFD_LINKER_CREATED 0x1000
 150 .
 151 .  {* This may be set before writing out a BFD to request that it
 152 .     be written using values for UIDs, GIDs, timestamps, etc. that
 153 .     will be consistent from run to run.  *}
 154 .#define BFD_DETERMINISTIC_OUTPUT 0x2000
 155 .
 156 .  {* Compress sections in this BFD.  *}
 157 .#define BFD_COMPRESS 0x4000
 158 .
 159 .  {* Decompress sections in this BFD.  *}
 160 .#define BFD_DECOMPRESS 0x8000
 161 .
 162 .  {* BFD is a dummy, for plugins.  *}
 163 .#define BFD_PLUGIN 0x10000
 164 .
 165 .  {* Flags bits to be saved in bfd_preserve_save.  *}
 166 .#define BFD_FLAGS_SAVED \
 167 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_PLUGIN)
 168 .
 169 .  {* Flags bits which are for BFD use only.  *}
 170 .#define BFD_FLAGS_FOR_BFD_USE_MASK \
 171 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
 172 .   | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT)
 173 .
 174 .  {* Is the file descriptor being cached?  That is, can it be closed as
 175 .     needed, and re-opened when accessed later?  *}
 176 .  unsigned int cacheable : 1;
 177 .
 178 .  {* Marks whether there was a default target specified when the
 179 .     BFD was opened. This is used to select which matching algorithm
 180 .     to use to choose the back end.  *}
 181 .  unsigned int target_defaulted : 1;
 182 .
 183 .  {* ... and here: (``once'' means at least once).  *}
 184 .  unsigned int opened_once : 1;
 185 .
 186 .  {* Set if we have a locally maintained mtime value, rather than
 187 .     getting it from the file each time.  *}
 188 .  unsigned int mtime_set : 1;
 189 .
 190 .  {* Flag set if symbols from this BFD should not be exported.  *}
 191 .  unsigned int no_export : 1;
 192 .
 193 .  {* Remember when output has begun, to stop strange things
 194 .     from happening.  *}
 195 .  unsigned int output_has_begun : 1;
 196 .
 197 .  {* Have archive map.  *}
 198 .  unsigned int has_armap : 1;
 199 .
 200 .  {* Set if this is a thin archive.  *}
 201 .  unsigned int is_thin_archive : 1;
 202 .
 203 .  {* Set if only required symbols should be added in the link hash table for
 204 .     this object.  Used by VMS linkers.  *}
 205 .  unsigned int selective_search : 1;
 206 .
 207 .  {* Set if this is the linker output BFD.  *}
 208 .  unsigned int is_linker_output : 1;
 209 .
 210 .  {* If this is an input for a compiler plug-in library.  *}
 211 .  ENUM_BITFIELD (bfd_plugin_format) plugin_format : 2;
 212 .
 213 .  {* Set if this is a plugin output file.  *}
 214 .  unsigned int lto_output : 1;
 215 .
 216 .  {* Set to dummy BFD created when claimed by a compiler plug-in
 217 .     library.  *}
 218 .  bfd *plugin_dummy_bfd;
 219 .
 220 .  {* Currently my_archive is tested before adding origin to
 221 .     anything. I believe that this can become always an add of
 222 .     origin, with origin set to 0 for non archive files.  *}
 223 .  ufile_ptr origin;
 224 .
 225 .  {* The origin in the archive of the proxy entry.  This will
 226 .     normally be the same as origin, except for thin archives,
 227 .     when it will contain the current offset of the proxy in the
 228 .     thin archive rather than the offset of the bfd in its actual
 229 .     container.  *}
 230 .  ufile_ptr proxy_origin;
 231 .
 232 .  {* A hash table for section names.  *}
 233 .  struct bfd_hash_table section_htab;
 234 .
 235 .  {* Pointer to linked list of sections.  *}
 236 .  struct bfd_section *sections;
 237 .
 238 .  {* The last section on the section list.  *}
 239 .  struct bfd_section *section_last;
 240 .
 241 .  {* The number of sections.  *}
 242 .  unsigned int section_count;
 243 .
 244 .  {* A field used by _bfd_generic_link_add_archive_symbols.  This will
 245 .     be used only for archive elements.  *}
 246 .  int archive_pass;
 247 .
 248 .  {* Stuff only useful for object files:
 249 .     The start address.  *}
 250 .  bfd_vma start_address;
 251 .
 252 .  {* Symbol table for output BFD (with symcount entries).
 253 .     Also used by the linker to cache input BFD symbols.  *}
 254 .  struct bfd_symbol  **outsymbols;
 255 .
 256 .  {* Used for input and output.  *}
 257 .  unsigned int symcount;
 258 .
 259 .  {* Used for slurped dynamic symbol tables.  *}
 260 .  unsigned int dynsymcount;
 261 .
 262 .  {* Pointer to structure which contains architecture information.  *}
 263 .  const struct bfd_arch_info *arch_info;
 264 .
 265 .  {* Stuff only useful for archives.  *}
 266 .  void *arelt_data;
 267 .  struct bfd *my_archive;      {* The containing archive BFD.  *}
 268 .  struct bfd *archive_next;    {* The next BFD in the archive.  *}
 269 .  struct bfd *archive_head;    {* The first BFD in the archive.  *}
 270 .  struct bfd *nested_archives; {* List of nested archive in a flattened
 271 .                                  thin archive.  *}
 272 .
 273 .  union {
 274 .    {* For input BFDs, a chain of BFDs involved in a link.  *}
 275 .    struct bfd *next;
 276 .    {* For output BFD, the linker hash table.  *}
 277 .    struct bfd_link_hash_table *hash;
 278 .  } link;
 279 .
 280 .  {* Used by the back end to hold private data.  *}
 281 .  union
 282 .    {
 283 .      struct aout_data_struct *aout_data;
 284 .      struct artdata *aout_ar_data;
 285 .      struct _oasys_data *oasys_obj_data;
 286 .      struct _oasys_ar_data *oasys_ar_data;
 287 .      struct coff_tdata *coff_obj_data;
 288 .      struct pe_tdata *pe_obj_data;
 289 .      struct xcoff_tdata *xcoff_obj_data;
 290 .      struct ecoff_tdata *ecoff_obj_data;
 291 .      struct ieee_data_struct *ieee_data;
 292 .      struct ieee_ar_data_struct *ieee_ar_data;
 293 .      struct srec_data_struct *srec_data;
 294 .      struct verilog_data_struct *verilog_data;
 295 .      struct ihex_data_struct *ihex_data;
 296 .      struct tekhex_data_struct *tekhex_data;
 297 .      struct elf_obj_tdata *elf_obj_data;
 298 .      struct nlm_obj_tdata *nlm_obj_data;
 299 .      struct bout_data_struct *bout_data;
 300 .      struct mmo_data_struct *mmo_data;
 301 .      struct sun_core_struct *sun_core_data;
 302 .      struct sco5_core_struct *sco5_core_data;
 303 .      struct trad_core_struct *trad_core_data;
 304 .      struct som_data_struct *som_data;
 305 .      struct hpux_core_struct *hpux_core_data;
 306 .      struct hppabsd_core_struct *hppabsd_core_data;
 307 .      struct sgi_core_struct *sgi_core_data;
 308 .      struct lynx_core_struct *lynx_core_data;
 309 .      struct osf_core_struct *osf_core_data;
 310 .      struct cisco_core_struct *cisco_core_data;
 311 .      struct versados_data_struct *versados_data;
 312 .      struct netbsd_core_struct *netbsd_core_data;
 313 .      struct mach_o_data_struct *mach_o_data;
 314 .      struct mach_o_fat_data_struct *mach_o_fat_data;
 315 .      struct plugin_data_struct *plugin_data;
 316 .      struct bfd_pef_data_struct *pef_data;
 317 .      struct bfd_pef_xlib_data_struct *pef_xlib_data;
 318 .      struct bfd_sym_data_struct *sym_data;
 319 .      void *any;
 320 .    }
 321 .  tdata;
 322 .
 323 .  {* Used by the application to hold private data.  *}
 324 .  void *usrdata;
 325 .
 326 .  {* Where all the allocated stuff under this BFD goes.  This is a
 327 .     struct objalloc *, but we use void * to avoid requiring the inclusion
 328 .     of objalloc.h.  *}
 329 .  void *memory;
 330 .};
 331 .
 332 .{* See note beside bfd_set_section_userdata.  *}
 333 .static inline bfd_boolean
 334 .bfd_set_cacheable (bfd * abfd, bfd_boolean val)
 335 .{
 336 .  abfd->cacheable = val;
 337 .  return TRUE;
 338 .}
 339 .
 340 */
 341
 342 #include "sysdep.h"
 343 #include <stdarg.h>
 344 #include "bfd.h"
 345 #include "bfdver.h"
 346 #include "libiberty.h"
 347 #include "demangle.h"
 348 #include "safe-ctype.h"
 349 #include "bfdlink.h"
 350 #include "libbfd.h"
 351 #include "coff/internal.h"
 352 #include "coff/sym.h"
 353 #include "libcoff.h"
 354 #include "libecoff.h"
 355 #undef obj_symbols
 356 #include "elf-bfd.h"
 357
 358 #ifndef EXIT_FAILURE
 359 #define EXIT_FAILURE 1
 360 #endif
 361
 362 \f
 363 /* provide storage for subsystem, stack and heap data which may have been
 364    passed in on the command line.  Ld puts this data into a bfd_link_info
 365    struct which ultimately gets passed in to the bfd.  When it arrives, copy
 366    it to the following struct so that the data will be available in coffcode.h
 367    where it is needed.  The typedef's used are defined in bfd.h */
 368 \f
 369 /*
 370 INODE
 371 Error reporting, Miscellaneous, typedef bfd, BFD front end
 372
 373 SECTION
 374         Error reporting
 375
 376         Most BFD functions return nonzero on success (check their
 377         individual documentation for precise semantics).  On an error,
 378         they call <<bfd_set_error>> to set an error condition that callers
 379         can check by calling <<bfd_get_error>>.
 380         If that returns <<bfd_error_system_call>>, then check
 381         <<errno>>.
 382
 383         The easiest way to report a BFD error to the user is to
 384         use <<bfd_perror>>.
 385
 386 SUBSECTION
 387         Type <<bfd_error_type>>
 388
 389         The values returned by <<bfd_get_error>> are defined by the
 390         enumerated type <<bfd_error_type>>.
 391
 392 CODE_FRAGMENT
 393 .
 394 .typedef enum bfd_error
 395 .{
 396 .  bfd_error_no_error = 0,
 397 .  bfd_error_system_call,
 398 .  bfd_error_invalid_target,
 399 .  bfd_error_wrong_format,
 400 .  bfd_error_wrong_object_format,
 401 .  bfd_error_invalid_operation,
 402 .  bfd_error_no_memory,
 403 .  bfd_error_no_symbols,
 404 .  bfd_error_no_armap,
 405 .  bfd_error_no_more_archived_files,
 406 .  bfd_error_malformed_archive,
 407 .  bfd_error_missing_dso,
 408 .  bfd_error_file_not_recognized,
 409 .  bfd_error_file_ambiguously_recognized,
 410 .  bfd_error_no_contents,
 411 .  bfd_error_nonrepresentable_section,
 412 .  bfd_error_no_debug_section,
 413 .  bfd_error_bad_value,
 414 .  bfd_error_file_truncated,
 415 .  bfd_error_file_too_big,
 416 .  bfd_error_on_input,
 417 .  bfd_error_invalid_error_code
 418 .}
 419 .bfd_error_type;
 420 .
 421 */
 422
 423 static bfd_error_type bfd_error = bfd_error_no_error;
 424 static bfd *input_bfd = NULL;
 425 static bfd_error_type input_error = bfd_error_no_error;
 426
 427 const char *const bfd_errmsgs[] =
 428 {
 429   N_("No error"),
 430   N_("System call error"),
 431   N_("Invalid bfd target"),
 432   N_("File in wrong format"),
 433   N_("Archive object file in wrong format"),
 434   N_("Invalid operation"),
 435   N_("Memory exhausted"),
 436   N_("No symbols"),
 437   N_("Archive has no index; run ranlib to add one"),
 438   N_("No more archived files"),
 439   N_("Malformed archive"),
 440   N_("DSO missing from command line"),
 441   N_("File format not recognized"),
 442   N_("File format is ambiguous"),
 443   N_("Section has no contents"),
 444   N_("Nonrepresentable section on output"),
 445   N_("Symbol needs debug section which does not exist"),
 446   N_("Bad value"),
 447   N_("File truncated"),
 448   N_("File too big"),
 449   N_("Error reading %s: %s"),
 450   N_("#<Invalid error code>")
 451 };
 452
 453 /*
 454 FUNCTION
 455         bfd_get_error
 456
 457 SYNOPSIS
 458         bfd_error_type bfd_get_error (void);
 459
 460 DESCRIPTION
 461         Return the current BFD error condition.
 462 */
 463
 464 bfd_error_type
 465 bfd_get_error (void)
 466 {
 467   return bfd_error;
 468 }
 469
 470 /*
 471 FUNCTION
 472         bfd_set_error
 473
 474 SYNOPSIS
 475         void bfd_set_error (bfd_error_type error_tag, ...);
 476
 477 DESCRIPTION
 478         Set the BFD error condition to be @var{error_tag}.
 479         If @var{error_tag} is bfd_error_on_input, then this function
 480         takes two more parameters, the input bfd where the error
 481         occurred, and the bfd_error_type error.
 482 */
 483
 484 void
 485 bfd_set_error (bfd_error_type error_tag, ...)
 486 {
 487   bfd_error = error_tag;
 488   if (error_tag == bfd_error_on_input)
 489     {
 490       /* This is an error that occurred during bfd_close when
 491          writing an archive, but on one of the input files.  */
 492       va_list ap;
 493
 494       va_start (ap, error_tag);
 495       input_bfd = va_arg (ap, bfd *);
 496       input_error = (bfd_error_type) va_arg (ap, int);
 497       if (input_error >= bfd_error_on_input)
 498         abort ();
 499       va_end (ap);
 500     }
 501 }
 502
 503 /*
 504 FUNCTION
 505         bfd_errmsg
 506
 507 SYNOPSIS
 508         const char *bfd_errmsg (bfd_error_type error_tag);
 509
 510 DESCRIPTION
 511         Return a string describing the error @var{error_tag}, or
 512         the system error if @var{error_tag} is <<bfd_error_system_call>>.
 513 */
 514
 515 const char *
 516 bfd_errmsg (bfd_error_type error_tag)
 517 {
 518 #ifndef errno
 519   extern int errno;
 520 #endif
 521   if (error_tag == bfd_error_on_input)
 522     {
 523       char *buf;
 524       const char *msg = bfd_errmsg (input_error);
 525
 526       if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg)
 527           != -1)
 528         return buf;
 529
 530       /* Ick, what to do on out of memory?  */
 531       return msg;
 532     }
 533
 534   if (error_tag == bfd_error_system_call)
 535     return xstrerror (errno);
 536
 537   if (error_tag > bfd_error_invalid_error_code)
 538     error_tag = bfd_error_invalid_error_code;   /* sanity check */
 539
 540   return _(bfd_errmsgs [error_tag]);
 541 }
 542
 543 /*
 544 FUNCTION
 545         bfd_perror
 546
 547 SYNOPSIS
 548         void bfd_perror (const char *message);
 549
 550 DESCRIPTION
 551         Print to the standard error stream a string describing the
 552         last BFD error that occurred, or the last system error if
 553         the last BFD error was a system call failure.  If @var{message}
 554         is non-NULL and non-empty, the error string printed is preceded
 555         by @var{message}, a colon, and a space.  It is followed by a newline.
 556 */
 557
 558 void
 559 bfd_perror (const char *message)
 560 {
 561   fflush (stdout);
 562   if (message == NULL || *message == '\0')
 563     fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
 564   else
 565     fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
 566   fflush (stderr);
 567 }
 568
 569 /*
 570 SUBSECTION
 571         BFD error handler
 572
 573         Some BFD functions want to print messages describing the
 574         problem.  They call a BFD error handler function.  This
 575         function may be overridden by the program.
 576
 577         The BFD error handler acts like printf.
 578
 579 CODE_FRAGMENT
 580 .
 581 .typedef void (*bfd_error_handler_type) (const char *, ...);
 582 .
 583 */
 584
 585 /* The program name used when printing BFD error messages.  */
 586
 587 static const char *_bfd_error_program_name;
 588
 589 /* This is the default routine to handle BFD error messages.
 590    Like fprintf (stderr, ...), but also handles some extra format specifiers.
 591
 592    %A section name from section.  For group components, print group name too.
 593    %B file name from bfd.  For archive components, prints archive too.
 594
 595    Note - because these two extra format specifiers require special handling
 596    they are scanned for and processed in this function, before calling
 597    vfprintf.  This means that the *arguments* for these format specifiers
 598    must be the first ones in the variable argument list, regardless of where
 599    the specifiers appear in the format string.  Thus for example calling
 600    this function with a format string of:
 601
 602       "blah %s blah %A blah %d blah %B"
 603
 604    would involve passing the arguments as:
 605
 606       "blah %s blah %A blah %d blah %B",
 607         asection_for_the_%A,
 608         bfd_for_the_%B,
 609         string_for_the_%s,
 610         integer_for_the_%d);
 611  */
 612
 613 void
 614 _bfd_default_error_handler (const char *fmt, ...)
 615 {
 616   va_list ap;
 617   char *bufp;
 618   const char *new_fmt, *p;
 619   size_t avail = 1000;
 620   char buf[1000];
 621
 622   /* PR 4992: Don't interrupt output being sent to stdout.  */
 623   fflush (stdout);
 624
 625   if (_bfd_error_program_name != NULL)
 626     fprintf (stderr, "%s: ", _bfd_error_program_name);
 627   else
 628     fprintf (stderr, "BFD: ");
 629
 630   va_start (ap, fmt);
 631   new_fmt = fmt;
 632   bufp = buf;
 633
 634   /* Reserve enough space for the existing format string.  */
 635   avail -= strlen (fmt) + 1;
 636   if (avail > 1000)
 637     _exit (EXIT_FAILURE);
 638
 639   p = fmt;
 640   while (1)
 641     {
 642       char *q;
 643       size_t len, extra, trim;
 644
 645       p = strchr (p, '%');
 646       if (p == NULL || p[1] == '\0')
 647         {
 648           if (new_fmt == buf)
 649             {
 650               len = strlen (fmt);
 651               memcpy (bufp, fmt, len + 1);
 652             }
 653           break;
 654         }
 655
 656       if (p[1] == 'A' || p[1] == 'B')
 657         {
 658           len = p - fmt;
 659           memcpy (bufp, fmt, len);
 660           bufp += len;
 661           fmt = p + 2;
 662           new_fmt = buf;
 663
 664           /* If we run out of space, tough, you lose your ridiculously
 665              long file or section name.  It's not safe to try to alloc
 666              memory here;  We might be printing an out of memory message.  */
 667           if (avail == 0)
 668             {
 669               *bufp++ = '*';
 670               *bufp++ = '*';
 671               *bufp = '\0';
 672             }
 673           else
 674             {
 675               if (p[1] == 'B')
 676                 {
 677                   bfd *abfd = va_arg (ap, bfd *);
 678
 679                   if (abfd == NULL)
 680                     /* Invoking %B with a null bfd pointer is an internal error.  */
 681                     abort ();
 682                   else if (abfd->my_archive)
 683                     snprintf (bufp, avail, "%s(%s)",
 684                               abfd->my_archive->filename, abfd->filename);
 685                   else
 686                     snprintf (bufp, avail, "%s", abfd->filename);
 687                 }
 688               else
 689                 {
 690                   asection *sec = va_arg (ap, asection *);
 691                   bfd *abfd;
 692                   const char *group = NULL;
 693                   struct coff_comdat_info *ci;
 694
 695                   if (sec == NULL)
 696                     /* Invoking %A with a null section pointer is an internal error.  */
 697                     abort ();
 698                   abfd = sec->owner;
 699                   if (abfd != NULL
 700                       && bfd_get_flavour (abfd) == bfd_target_elf_flavour
 701                       && elf_next_in_group (sec) != NULL
 702                       && (sec->flags & SEC_GROUP) == 0)
 703                     group = elf_group_name (sec);
 704                   else if (abfd != NULL
 705                            && bfd_get_flavour (abfd) == bfd_target_coff_flavour
 706                            && (ci = bfd_coff_get_comdat_section (sec->owner,
 707                                                                  sec)) != NULL)
 708                     group = ci->name;
 709                   if (group != NULL)
 710                     snprintf (bufp, avail, "%s[%s]", sec->name, group);
 711                   else
 712                     snprintf (bufp, avail, "%s", sec->name);
 713                 }
 714               len = strlen (bufp);
 715               avail = avail - len + 2;
 716
 717               /* We need to replace any '%' we printed by "%%".
 718                  First count how many.  */
 719               q = bufp;
 720               bufp += len;
 721               extra = 0;
 722               while ((q = strchr (q, '%')) != NULL)
 723                 {
 724                   ++q;
 725                   ++extra;
 726                 }
 727
 728               /* If there isn't room, trim off the end of the string.  */
 729               q = bufp;
 730               bufp += extra;
 731               if (extra > avail)
 732                 {
 733                   trim = extra - avail;
 734                   bufp -= trim;
 735                   do
 736                     {
 737                       if (*--q == '%')
 738                         --extra;
 739                     }
 740                   while (--trim != 0);
 741                   *q = '\0';
 742                   avail = extra;
 743                 }
 744               avail -= extra;
 745
 746               /* Now double all '%' chars, shuffling the string as we go.  */
 747               while (extra != 0)
 748                 {
 749                   while ((q[extra] = *q) != '%')
 750                     --q;
 751                   q[--extra] = '%';
 752                   --q;
 753                 }
 754             }
 755         }
 756       p = p + 2;
 757     }
 758
 759   vfprintf (stderr, new_fmt, ap);
 760   va_end (ap);
 761
 762   /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
 763      warning, so use the fputc function to avoid it.  */
 764   fputc ('\n', stderr);
 765   fflush (stderr);
 766 }
 767
 768 /* This is a function pointer to the routine which should handle BFD
 769    error messages.  It is called when a BFD routine encounters an
 770    error for which it wants to print a message.  Going through a
 771    function pointer permits a program linked against BFD to intercept
 772    the messages and deal with them itself.  */
 773
 774 bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler;
 775
 776 /*
 777 FUNCTION
 778         bfd_set_error_handler
 779
 780 SYNOPSIS
 781         bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
 782
 783 DESCRIPTION
 784         Set the BFD error handler function.  Returns the previous
 785         function.
 786 */
 787
 788 bfd_error_handler_type
 789 bfd_set_error_handler (bfd_error_handler_type pnew)
 790 {
 791   bfd_error_handler_type pold;
 792
 793   pold = _bfd_error_handler;
 794   _bfd_error_handler = pnew;
 795   return pold;
 796 }
 797
 798 /*
 799 FUNCTION
 800         bfd_set_error_program_name
 801
 802 SYNOPSIS
 803         void bfd_set_error_program_name (const char *);
 804
 805 DESCRIPTION
 806         Set the program name to use when printing a BFD error.  This
 807         is printed before the error message followed by a colon and
 808         space.  The string must not be changed after it is passed to
 809         this function.
 810 */
 811
 812 void
 813 bfd_set_error_program_name (const char *name)
 814 {
 815   _bfd_error_program_name = name;
 816 }
 817
 818 /*
 819 FUNCTION
 820         bfd_get_error_handler
 821
 822 SYNOPSIS
 823         bfd_error_handler_type bfd_get_error_handler (void);
 824
 825 DESCRIPTION
 826         Return the BFD error handler function.
 827 */
 828
 829 bfd_error_handler_type
 830 bfd_get_error_handler (void)
 831 {
 832   return _bfd_error_handler;
 833 }
 834
 835 /*
 836 SUBSECTION
 837         BFD assert handler
 838
 839         If BFD finds an internal inconsistency, the bfd assert
 840         handler is called with information on the BFD version, BFD
 841         source file and line.  If this happens, most programs linked
 842         against BFD are expected to want to exit with an error, or mark
 843         the current BFD operation as failed, so it is recommended to
 844         override the default handler, which just calls
 845         _bfd_error_handler and continues.
 846
 847 CODE_FRAGMENT
 848 .
 849 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,
 850 .                                         const char *bfd_version,
 851 .                                         const char *bfd_file,
 852 .                                         int bfd_line);
 853 .
 854 */
 855
 856 /* Note the use of bfd_ prefix on the parameter names above: we want to
 857    show which one is the message and which is the version by naming the
 858    parameters, but avoid polluting the program-using-bfd namespace as
 859    the typedef is visible in the exported headers that the program
 860    includes.  Below, it's just for consistency.  */
 861
 862 static void
 863 _bfd_default_assert_handler (const char *bfd_formatmsg,
 864                              const char *bfd_version,
 865                              const char *bfd_file,
 866                              int bfd_line)
 867
 868 {
 869   (*_bfd_error_handler) (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
 870 }
 871
 872 /* Similar to _bfd_error_handler, a program can decide to exit on an
 873    internal BFD error.  We use a non-variadic type to simplify passing
 874    on parameters to other functions, e.g. _bfd_error_handler.  */
 875
 876 bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler;
 877
 878 /*
 879 FUNCTION
 880         bfd_set_assert_handler
 881
 882 SYNOPSIS
 883         bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type);
 884
 885 DESCRIPTION
 886         Set the BFD assert handler function.  Returns the previous
 887         function.
 888 */
 889
 890 bfd_assert_handler_type
 891 bfd_set_assert_handler (bfd_assert_handler_type pnew)
 892 {
 893   bfd_assert_handler_type pold;
 894
 895   pold = _bfd_assert_handler;
 896   _bfd_assert_handler = pnew;
 897   return pold;
 898 }
 899
 900 /*
 901 FUNCTION
 902         bfd_get_assert_handler
 903
 904 SYNOPSIS
 905         bfd_assert_handler_type bfd_get_assert_handler (void);
 906
 907 DESCRIPTION
 908         Return the BFD assert handler function.
 909 */
 910
 911 bfd_assert_handler_type
 912 bfd_get_assert_handler (void)
 913 {
 914   return _bfd_assert_handler;
 915 }
 916 \f
 917 /*
 918 INODE
 919 Miscellaneous, Memory Usage, Error reporting, BFD front end
 920
 921 SECTION
 922         Miscellaneous
 923
 924 SUBSECTION
 925         Miscellaneous functions
 926 */
 927
 928 /*
 929 FUNCTION
 930         bfd_get_reloc_upper_bound
 931
 932 SYNOPSIS
 933         long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
 934
 935 DESCRIPTION
 936         Return the number of bytes required to store the
 937         relocation information associated with section @var{sect}
 938         attached to bfd @var{abfd}.  If an error occurs, return -1.
 939
 940 */
 941
 942 long
 943 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
 944 {
 945   if (abfd->format != bfd_object)
 946     {
 947       bfd_set_error (bfd_error_invalid_operation);
 948       return -1;
 949     }
 950
 951   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 952 }
 953
 954 /*
 955 FUNCTION
 956         bfd_canonicalize_reloc
 957
 958 SYNOPSIS
 959         long bfd_canonicalize_reloc
 960           (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
 961
 962 DESCRIPTION
 963         Call the back end associated with the open BFD
 964         @var{abfd} and translate the external form of the relocation
 965         information attached to @var{sec} into the internal canonical
 966         form.  Place the table into memory at @var{loc}, which has
 967         been preallocated, usually by a call to
 968         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
 969         -1 on error.
 970
 971         The @var{syms} table is also needed for horrible internal magic
 972         reasons.
 973
 974 */
 975 long
 976 bfd_canonicalize_reloc (bfd *abfd,
 977                         sec_ptr asect,
 978                         arelent **location,
 979                         asymbol **symbols)
 980 {
 981   if (abfd->format != bfd_object)
 982     {
 983       bfd_set_error (bfd_error_invalid_operation);
 984       return -1;
 985     }
 986
 987   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 988                    (abfd, asect, location, symbols));
 989 }
 990
 991 /*
 992 FUNCTION
 993         bfd_set_reloc
 994
 995 SYNOPSIS
 996         void bfd_set_reloc
 997           (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
 998
 999 DESCRIPTION
1000         Set the relocation pointer and count within
1001         section @var{sec} to the values @var{rel} and @var{count}.
1002         The argument @var{abfd} is ignored.
1003
1004 */
1005
1006 void
1007 bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1008                sec_ptr asect,
1009                arelent **location,
1010                unsigned int count)
1011 {
1012   asect->orelocation = location;
1013   asect->reloc_count = count;
1014 }
1015
1016 /*
1017 FUNCTION
1018         bfd_set_file_flags
1019
1020 SYNOPSIS
1021         bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
1022
1023 DESCRIPTION
1024         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
1025
1026         Possible errors are:
1027         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
1028         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
1029         o <<bfd_error_invalid_operation>> -
1030         The flag word contained a bit which was not applicable to the
1031         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
1032         on a BFD format which does not support demand paging.
1033
1034 */
1035
1036 bfd_boolean
1037 bfd_set_file_flags (bfd *abfd, flagword flags)
1038 {
1039   if (abfd->format != bfd_object)
1040     {
1041       bfd_set_error (bfd_error_wrong_format);
1042       return FALSE;
1043     }
1044
1045   if (bfd_read_p (abfd))
1046     {
1047       bfd_set_error (bfd_error_invalid_operation);
1048       return FALSE;
1049     }
1050
1051   bfd_get_file_flags (abfd) = flags;
1052   if ((flags & bfd_applicable_file_flags (abfd)) != flags)
1053     {
1054       bfd_set_error (bfd_error_invalid_operation);
1055       return FALSE;
1056     }
1057
1058   return TRUE;
1059 }
1060
1061 void
1062 bfd_assert (const char *file, int line)
1063 {
1064   (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"),
1065                           BFD_VERSION_STRING, file, line);
1066 }
1067
1068 /* A more or less friendly abort message.  In libbfd.h abort is
1069    defined to call this function.  */
1070
1071 void
1072 _bfd_abort (const char *file, int line, const char *fn)
1073 {
1074   if (fn != NULL)
1075     (*_bfd_error_handler)
1076       (_("BFD %s internal error, aborting at %s line %d in %s\n"),
1077        BFD_VERSION_STRING, file, line, fn);
1078   else
1079     (*_bfd_error_handler)
1080       (_("BFD %s internal error, aborting at %s line %d\n"),
1081        BFD_VERSION_STRING, file, line);
1082   (*_bfd_error_handler) (_("Please report this bug.\n"));
1083   _exit (EXIT_FAILURE);
1084 }
1085
1086 /*
1087 FUNCTION
1088         bfd_get_arch_size
1089
1090 SYNOPSIS
1091         int bfd_get_arch_size (bfd *abfd);
1092
1093 DESCRIPTION
1094         Returns the normalized architecture address size, in bits, as
1095         determined by the object file's format.  By normalized, we mean
1096         either 32 or 64.  For ELF, this information is included in the
1097         header.  Use bfd_arch_bits_per_address for number of bits in
1098         the architecture address.
1099
1100 RETURNS
1101         Returns the arch size in bits if known, <<-1>> otherwise.
1102 */
1103
1104 int
1105 bfd_get_arch_size (bfd *abfd)
1106 {
1107   if (abfd->xvec->flavour == bfd_target_elf_flavour)
1108     return get_elf_backend_data (abfd)->s->arch_size;
1109
1110   return bfd_arch_bits_per_address (abfd) > 32 ? 64 : 32;
1111 }
1112
1113 /*
1114 FUNCTION
1115         bfd_get_sign_extend_vma
1116
1117 SYNOPSIS
1118         int bfd_get_sign_extend_vma (bfd *abfd);
1119
1120 DESCRIPTION
1121         Indicates if the target architecture "naturally" sign extends
1122         an address.  Some architectures implicitly sign extend address
1123         values when they are converted to types larger than the size
1124         of an address.  For instance, bfd_get_start_address() will
1125         return an address sign extended to fill a bfd_vma when this is
1126         the case.
1127
1128 RETURNS
1129         Returns <<1>> if the target architecture is known to sign
1130         extend addresses, <<0>> if the target architecture is known to
1131         not sign extend addresses, and <<-1>> otherwise.
1132 */
1133
1134 int
1135 bfd_get_sign_extend_vma (bfd *abfd)
1136 {
1137   char *name;
1138
1139   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1140     return get_elf_backend_data (abfd)->sign_extend_vma;
1141
1142   name = bfd_get_target (abfd);
1143
1144   /* Return a proper value for DJGPP & PE COFF.
1145      This function is required for DWARF2 support, but there is
1146      no place to store this information in the COFF back end.
1147      Should enough other COFF targets add support for DWARF2,
1148      a place will have to be found.  Until then, this hack will do.  */
1149   if (CONST_STRNEQ (name, "coff-go32")
1150       || strcmp (name, "pe-i386") == 0
1151       || strcmp (name, "pei-i386") == 0
1152       || strcmp (name, "pe-x86-64") == 0
1153       || strcmp (name, "pei-x86-64") == 0
1154       || strcmp (name, "pe-arm-wince-little") == 0
1155       || strcmp (name, "pei-arm-wince-little") == 0
1156       || strcmp (name, "aixcoff-rs6000") == 0)
1157     return 1;
1158
1159   if (CONST_STRNEQ (name, "mach-o"))
1160     return 0;
1161
1162   bfd_set_error (bfd_error_wrong_format);
1163   return -1;
1164 }
1165
1166 /*
1167 FUNCTION
1168         bfd_set_start_address
1169
1170 SYNOPSIS
1171         bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
1172
1173 DESCRIPTION
1174         Make @var{vma} the entry point of output BFD @var{abfd}.
1175
1176 RETURNS
1177         Returns <<TRUE>> on success, <<FALSE>> otherwise.
1178 */
1179
1180 bfd_boolean
1181 bfd_set_start_address (bfd *abfd, bfd_vma vma)
1182 {
1183   abfd->start_address = vma;
1184   return TRUE;
1185 }
1186
1187 /*
1188 FUNCTION
1189         bfd_get_gp_size
1190
1191 SYNOPSIS
1192         unsigned int bfd_get_gp_size (bfd *abfd);
1193
1194 DESCRIPTION
1195         Return the maximum size of objects to be optimized using the GP
1196         register under MIPS ECOFF.  This is typically set by the <<-G>>
1197         argument to the compiler, assembler or linker.
1198 */
1199
1200 unsigned int
1201 bfd_get_gp_size (bfd *abfd)
1202 {
1203   if (abfd->format == bfd_object)
1204     {
1205       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1206         return ecoff_data (abfd)->gp_size;
1207       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1208         return elf_gp_size (abfd);
1209     }
1210   return 0;
1211 }
1212
1213 /*
1214 FUNCTION
1215         bfd_set_gp_size
1216
1217 SYNOPSIS
1218         void bfd_set_gp_size (bfd *abfd, unsigned int i);
1219
1220 DESCRIPTION
1221         Set the maximum size of objects to be optimized using the GP
1222         register under ECOFF or MIPS ELF.  This is typically set by
1223         the <<-G>> argument to the compiler, assembler or linker.
1224 */
1225
1226 void
1227 bfd_set_gp_size (bfd *abfd, unsigned int i)
1228 {
1229   /* Don't try to set GP size on an archive or core file!  */
1230   if (abfd->format != bfd_object)
1231     return;
1232
1233   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1234     ecoff_data (abfd)->gp_size = i;
1235   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1236     elf_gp_size (abfd) = i;
1237 }
1238
1239 /* Get the GP value.  This is an internal function used by some of the
1240    relocation special_function routines on targets which support a GP
1241    register.  */
1242
1243 bfd_vma
1244 _bfd_get_gp_value (bfd *abfd)
1245 {
1246   if (! abfd)
1247     return 0;
1248   if (abfd->format != bfd_object)
1249     return 0;
1250
1251   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1252     return ecoff_data (abfd)->gp;
1253   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1254     return elf_gp (abfd);
1255
1256   return 0;
1257 }
1258
1259 /* Set the GP value.  */
1260
1261 void
1262 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
1263 {
1264   if (! abfd)
1265     abort ();
1266   if (abfd->format != bfd_object)
1267     return;
1268
1269   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1270     ecoff_data (abfd)->gp = v;
1271   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1272     elf_gp (abfd) = v;
1273 }
1274
1275 /*
1276 FUNCTION
1277         bfd_scan_vma
1278
1279 SYNOPSIS
1280         bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1281
1282 DESCRIPTION
1283         Convert, like <<strtoul>>, a numerical expression
1284         @var{string} into a <<bfd_vma>> integer, and return that integer.
1285         (Though without as many bells and whistles as <<strtoul>>.)
1286         The expression is assumed to be unsigned (i.e., positive).
1287         If given a @var{base}, it is used as the base for conversion.
1288         A base of 0 causes the function to interpret the string
1289         in hex if a leading "0x" or "0X" is found, otherwise
1290         in octal if a leading zero is found, otherwise in decimal.
1291
1292         If the value would overflow, the maximum <<bfd_vma>> value is
1293         returned.
1294 */
1295
1296 bfd_vma
1297 bfd_scan_vma (const char *string, const char **end, int base)
1298 {
1299   bfd_vma value;
1300   bfd_vma cutoff;
1301   unsigned int cutlim;
1302   int overflow;
1303
1304   /* Let the host do it if possible.  */
1305   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1306     return strtoul (string, (char **) end, base);
1307
1308 #ifdef HAVE_STRTOULL
1309   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1310     return strtoull (string, (char **) end, base);
1311 #endif
1312
1313   if (base == 0)
1314     {
1315       if (string[0] == '0')
1316         {
1317           if ((string[1] == 'x') || (string[1] == 'X'))
1318             base = 16;
1319           else
1320             base = 8;
1321         }
1322     }
1323
1324   if ((base < 2) || (base > 36))
1325     base = 10;
1326
1327   if (base == 16
1328       && string[0] == '0'
1329       && (string[1] == 'x' || string[1] == 'X')
1330       && ISXDIGIT (string[2]))
1331     {
1332       string += 2;
1333     }
1334
1335   cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1336   cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1337   value = 0;
1338   overflow = 0;
1339   while (1)
1340     {
1341       unsigned int digit;
1342
1343       digit = *string;
1344       if (ISDIGIT (digit))
1345         digit = digit - '0';
1346       else if (ISALPHA (digit))
1347         digit = TOUPPER (digit) - 'A' + 10;
1348       else
1349         break;
1350       if (digit >= (unsigned int) base)
1351         break;
1352       if (value > cutoff || (value == cutoff && digit > cutlim))
1353         overflow = 1;
1354       value = value * base + digit;
1355       ++string;
1356     }
1357
1358   if (overflow)
1359     value = ~ (bfd_vma) 0;
1360
1361   if (end != NULL)
1362     *end = string;
1363
1364   return value;
1365 }
1366
1367 /*
1368 FUNCTION
1369         bfd_copy_private_header_data
1370
1371 SYNOPSIS
1372         bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1373
1374 DESCRIPTION
1375         Copy private BFD header information from the BFD @var{ibfd} to the
1376         the BFD @var{obfd}.  This copies information that may require
1377         sections to exist, but does not require symbol tables.  Return
1378         <<true>> on success, <<false>> on error.
1379         Possible error returns are:
1380
1381         o <<bfd_error_no_memory>> -
1382         Not enough memory exists to create private data for @var{obfd}.
1383
1384 .#define bfd_copy_private_header_data(ibfd, obfd) \
1385 .     BFD_SEND (obfd, _bfd_copy_private_header_data, \
1386 .               (ibfd, obfd))
1387
1388 */
1389
1390 /*
1391 FUNCTION
1392         bfd_copy_private_bfd_data
1393
1394 SYNOPSIS
1395         bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1396
1397 DESCRIPTION
1398         Copy private BFD information from the BFD @var{ibfd} to the
1399         the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
1400         Possible error returns are:
1401
1402         o <<bfd_error_no_memory>> -
1403         Not enough memory exists to create private data for @var{obfd}.
1404
1405 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1406 .     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1407 .               (ibfd, obfd))
1408
1409 */
1410
1411 /*
1412 FUNCTION
1413         bfd_merge_private_bfd_data
1414
1415 SYNOPSIS
1416         bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
1417
1418 DESCRIPTION
1419         Merge private BFD information from the BFD @var{ibfd} to the
1420         the output file BFD @var{obfd} when linking.  Return <<TRUE>>
1421         on success, <<FALSE>> on error.  Possible error returns are:
1422
1423         o <<bfd_error_no_memory>> -
1424         Not enough memory exists to create private data for @var{obfd}.
1425
1426 .#define bfd_merge_private_bfd_data(ibfd, obfd) \
1427 .     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1428 .               (ibfd, obfd))
1429
1430 */
1431
1432 /*
1433 FUNCTION
1434         bfd_set_private_flags
1435
1436 SYNOPSIS
1437         bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1438
1439 DESCRIPTION
1440         Set private BFD flag information in the BFD @var{abfd}.
1441         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1442         returns are:
1443
1444         o <<bfd_error_no_memory>> -
1445         Not enough memory exists to create private data for @var{obfd}.
1446
1447 .#define bfd_set_private_flags(abfd, flags) \
1448 .     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1449
1450 */
1451
1452 /*
1453 FUNCTION
1454         Other functions
1455
1456 DESCRIPTION
1457         The following functions exist but have not yet been documented.
1458
1459 .#define bfd_sizeof_headers(abfd, info) \
1460 .       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
1461 .
1462 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1463 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1464 .                 (abfd, syms, sec, off, file, func, line, NULL))
1465 .
1466 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
1467 .                                            line, disc) \
1468 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1469 .                 (abfd, syms, sec, off, file, func, line, disc))
1470 .
1471 .#define bfd_find_line(abfd, syms, sym, file, line) \
1472 .       BFD_SEND (abfd, _bfd_find_line, \
1473 .                 (abfd, syms, sym, file, line))
1474 .
1475 .#define bfd_find_inliner_info(abfd, file, func, line) \
1476 .       BFD_SEND (abfd, _bfd_find_inliner_info, \
1477 .                 (abfd, file, func, line))
1478 .
1479 .#define bfd_debug_info_start(abfd) \
1480 .       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1481 .
1482 .#define bfd_debug_info_end(abfd) \
1483 .       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1484 .
1485 .#define bfd_debug_info_accumulate(abfd, section) \
1486 .       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1487 .
1488 .#define bfd_stat_arch_elt(abfd, stat) \
1489 .       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1490 .
1491 .#define bfd_update_armap_timestamp(abfd) \
1492 .       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1493 .
1494 .#define bfd_set_arch_mach(abfd, arch, mach)\
1495 .       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1496 .
1497 .#define bfd_relax_section(abfd, section, link_info, again) \
1498 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1499 .
1500 .#define bfd_gc_sections(abfd, link_info) \
1501 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1502 .
1503 .#define bfd_lookup_section_flags(link_info, flag_info, section) \
1504 .       BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section))
1505 .
1506 .#define bfd_merge_sections(abfd, link_info) \
1507 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1508 .
1509 .#define bfd_is_group_section(abfd, sec) \
1510 .       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1511 .
1512 .#define bfd_discard_group(abfd, sec) \
1513 .       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1514 .
1515 .#define bfd_link_hash_table_create(abfd) \
1516 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1517 .
1518 .#define bfd_link_add_symbols(abfd, info) \
1519 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1520 .
1521 .#define bfd_link_just_syms(abfd, sec, info) \
1522 .       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1523 .
1524 .#define bfd_final_link(abfd, info) \
1525 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1526 .
1527 .#define bfd_free_cached_info(abfd) \
1528 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1529 .
1530 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1531 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1532 .
1533 .#define bfd_print_private_bfd_data(abfd, file)\
1534 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1535 .
1536 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1537 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1538 .
1539 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1540 .       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1541 .                                                   dyncount, dynsyms, ret))
1542 .
1543 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1544 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1545 .
1546 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1547 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1548 .
1549 .extern bfd_byte *bfd_get_relocated_section_contents
1550 .  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1551 .   bfd_boolean, asymbol **);
1552 .
1553
1554 */
1555
1556 bfd_byte *
1557 bfd_get_relocated_section_contents (bfd *abfd,
1558                                     struct bfd_link_info *link_info,
1559                                     struct bfd_link_order *link_order,
1560                                     bfd_byte *data,
1561                                     bfd_boolean relocatable,
1562                                     asymbol **symbols)
1563 {
1564   bfd *abfd2;
1565   bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1566                    bfd_byte *, bfd_boolean, asymbol **);
1567
1568   if (link_order->type == bfd_indirect_link_order)
1569     {
1570       abfd2 = link_order->u.indirect.section->owner;
1571       if (abfd2 == NULL)
1572         abfd2 = abfd;
1573     }
1574   else
1575     abfd2 = abfd;
1576
1577   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1578
1579   return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1580 }
1581
1582 /* Record information about an ELF program header.  */
1583
1584 bfd_boolean
1585 bfd_record_phdr (bfd *abfd,
1586                  unsigned long type,
1587                  bfd_boolean flags_valid,
1588                  flagword flags,
1589                  bfd_boolean at_valid,
1590                  bfd_vma at,
1591                  bfd_boolean includes_filehdr,
1592                  bfd_boolean includes_phdrs,
1593                  unsigned int count,
1594                  asection **secs)
1595 {
1596   struct elf_segment_map *m, **pm;
1597   bfd_size_type amt;
1598
1599   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1600     return TRUE;
1601
1602   amt = sizeof (struct elf_segment_map);
1603   amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1604   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
1605   if (m == NULL)
1606     return FALSE;
1607
1608   m->p_type = type;
1609   m->p_flags = flags;
1610   m->p_paddr = at;
1611   m->p_flags_valid = flags_valid;
1612   m->p_paddr_valid = at_valid;
1613   m->includes_filehdr = includes_filehdr;
1614   m->includes_phdrs = includes_phdrs;
1615   m->count = count;
1616   if (count > 0)
1617     memcpy (m->sections, secs, count * sizeof (asection *));
1618
1619   for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
1620     ;
1621   *pm = m;
1622
1623   return TRUE;
1624 }
1625
1626 #ifdef BFD64
1627 /* Return true iff this target is 32-bit.  */
1628
1629 static bfd_boolean
1630 is32bit (bfd *abfd)
1631 {
1632   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1633     {
1634       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1635       return bed->s->elfclass == ELFCLASS32;
1636     }
1637
1638   /* For non-ELF targets, use architecture information.  */
1639   return bfd_arch_bits_per_address (abfd) <= 32;
1640 }
1641 #endif
1642
1643 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1644    target's address size.  */
1645
1646 void
1647 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
1648 {
1649 #ifdef BFD64
1650   if (is32bit (abfd))
1651     {
1652       sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
1653       return;
1654     }
1655 #endif
1656   sprintf_vma (buf, value);
1657 }
1658
1659 void
1660 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
1661 {
1662 #ifdef BFD64
1663   if (is32bit (abfd))
1664     {
1665       fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
1666       return;
1667     }
1668 #endif
1669   fprintf_vma ((FILE *) stream, value);
1670 }
1671
1672 /*
1673 FUNCTION
1674         bfd_alt_mach_code
1675
1676 SYNOPSIS
1677         bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
1678
1679 DESCRIPTION
1680
1681         When more than one machine code number is available for the
1682         same machine type, this function can be used to switch between
1683         the preferred one (alternative == 0) and any others.  Currently,
1684         only ELF supports this feature, with up to two alternate
1685         machine codes.
1686 */
1687
1688 bfd_boolean
1689 bfd_alt_mach_code (bfd *abfd, int alternative)
1690 {
1691   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1692     {
1693       int code;
1694
1695       switch (alternative)
1696         {
1697         case 0:
1698           code = get_elf_backend_data (abfd)->elf_machine_code;
1699           break;
1700
1701         case 1:
1702           code = get_elf_backend_data (abfd)->elf_machine_alt1;
1703           if (code == 0)
1704             return FALSE;
1705           break;
1706
1707         case 2:
1708           code = get_elf_backend_data (abfd)->elf_machine_alt2;
1709           if (code == 0)
1710             return FALSE;
1711           break;
1712
1713         default:
1714           return FALSE;
1715         }
1716
1717       elf_elfheader (abfd)->e_machine = code;
1718
1719       return TRUE;
1720     }
1721
1722   return FALSE;
1723 }
1724
1725 /*
1726 FUNCTION
1727         bfd_emul_get_maxpagesize
1728
1729 SYNOPSIS
1730         bfd_vma bfd_emul_get_maxpagesize (const char *);
1731
1732 DESCRIPTION
1733         Returns the maximum page size, in bytes, as determined by
1734         emulation.
1735
1736 RETURNS
1737         Returns the maximum page size in bytes for ELF, 0 otherwise.
1738 */
1739
1740 bfd_vma
1741 bfd_emul_get_maxpagesize (const char *emul)
1742 {
1743   const bfd_target *target;
1744
1745   target = bfd_find_target (emul, NULL);
1746   if (target != NULL
1747       && target->flavour == bfd_target_elf_flavour)
1748     return xvec_get_elf_backend_data (target)->maxpagesize;
1749
1750   return 0;
1751 }
1752
1753 static void
1754 bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
1755                       int offset, const bfd_target *orig_target)
1756 {
1757   if (target->flavour == bfd_target_elf_flavour)
1758     {
1759       const struct elf_backend_data *bed;
1760
1761       bed = xvec_get_elf_backend_data (target);
1762       *((bfd_vma *) ((char *) bed + offset)) = size;
1763     }
1764
1765   if (target->alternative_target
1766       && target->alternative_target != orig_target)
1767     bfd_elf_set_pagesize (target->alternative_target, size, offset,
1768                           orig_target);
1769 }
1770
1771 /*
1772 FUNCTION
1773         bfd_emul_set_maxpagesize
1774
1775 SYNOPSIS
1776         void bfd_emul_set_maxpagesize (const char *, bfd_vma);
1777
1778 DESCRIPTION
1779         For ELF, set the maximum page size for the emulation.  It is
1780         a no-op for other formats.
1781
1782 */
1783
1784 void
1785 bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
1786 {
1787   const bfd_target *target;
1788
1789   target = bfd_find_target (emul, NULL);
1790   if (target)
1791     bfd_elf_set_pagesize (target, size,
1792                           offsetof (struct elf_backend_data,
1793                                     maxpagesize), target);
1794 }
1795
1796 /*
1797 FUNCTION
1798         bfd_emul_get_commonpagesize
1799
1800 SYNOPSIS
1801         bfd_vma bfd_emul_get_commonpagesize (const char *);
1802
1803 DESCRIPTION
1804         Returns the common page size, in bytes, as determined by
1805         emulation.
1806
1807 RETURNS
1808         Returns the common page size in bytes for ELF, 0 otherwise.
1809 */
1810
1811 bfd_vma
1812 bfd_emul_get_commonpagesize (const char *emul)
1813 {
1814   const bfd_target *target;
1815
1816   target = bfd_find_target (emul, NULL);
1817   if (target != NULL
1818       && target->flavour == bfd_target_elf_flavour)
1819     return xvec_get_elf_backend_data (target)->commonpagesize;
1820
1821   return 0;
1822 }
1823
1824 /*
1825 FUNCTION
1826         bfd_emul_set_commonpagesize
1827
1828 SYNOPSIS
1829         void bfd_emul_set_commonpagesize (const char *, bfd_vma);
1830
1831 DESCRIPTION
1832         For ELF, set the common page size for the emulation.  It is
1833         a no-op for other formats.
1834
1835 */
1836
1837 void
1838 bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
1839 {
1840   const bfd_target *target;
1841
1842   target = bfd_find_target (emul, NULL);
1843   if (target)
1844     bfd_elf_set_pagesize (target, size,
1845                           offsetof (struct elf_backend_data,
1846                                     commonpagesize), target);
1847 }
1848
1849 /*
1850 FUNCTION
1851         bfd_demangle
1852
1853 SYNOPSIS
1854         char *bfd_demangle (bfd *, const char *, int);
1855
1856 DESCRIPTION
1857         Wrapper around cplus_demangle.  Strips leading underscores and
1858         other such chars that would otherwise confuse the demangler.
1859         If passed a g++ v3 ABI mangled name, returns a buffer allocated
1860         with malloc holding the demangled name.  Returns NULL otherwise
1861         and on memory alloc failure.
1862 */
1863
1864 char *
1865 bfd_demangle (bfd *abfd, const char *name, int options)
1866 {
1867   char *res, *alloc;
1868   const char *pre, *suf;
1869   size_t pre_len;
1870   bfd_boolean skip_lead;
1871
1872   skip_lead = (abfd != NULL
1873                && *name != '\0'
1874                && bfd_get_symbol_leading_char (abfd) == *name);
1875   if (skip_lead)
1876     ++name;
1877
1878   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
1879      or the MS PE format.  These formats have a number of leading '.'s
1880      on at least some symbols, so we remove all dots to avoid
1881      confusing the demangler.  */
1882   pre = name;
1883   while (*name == '.' || *name == '$')
1884     ++name;
1885   pre_len = name - pre;
1886
1887   /* Strip off @plt and suchlike too.  */
1888   alloc = NULL;
1889   suf = strchr (name, '@');
1890   if (suf != NULL)
1891     {
1892       alloc = (char *) bfd_malloc (suf - name + 1);
1893       if (alloc == NULL)
1894         return NULL;
1895       memcpy (alloc, name, suf - name);
1896       alloc[suf - name] = '\0';
1897       name = alloc;
1898     }
1899
1900   res = cplus_demangle (name, options);
1901
1902   if (alloc != NULL)
1903     free (alloc);
1904
1905   if (res == NULL)
1906     {
1907       if (skip_lead)
1908         {
1909           size_t len = strlen (pre) + 1;
1910           alloc = (char *) bfd_malloc (len);
1911           if (alloc == NULL)
1912             return NULL;
1913           memcpy (alloc, pre, len);
1914           return alloc;
1915         }
1916       return NULL;
1917     }
1918
1919   /* Put back any prefix or suffix.  */
1920   if (pre_len != 0 || suf != NULL)
1921     {
1922       size_t len;
1923       size_t suf_len;
1924       char *final;
1925
1926       len = strlen (res);
1927       if (suf == NULL)
1928         suf = res + len;
1929       suf_len = strlen (suf) + 1;
1930       final = (char *) bfd_malloc (pre_len + len + suf_len);
1931       if (final != NULL)
1932         {
1933           memcpy (final, pre, pre_len);
1934           memcpy (final + pre_len, res, len);
1935           memcpy (final + pre_len + len, suf, suf_len);
1936         }
1937       free (res);
1938       res = final;
1939     }
1940
1941   return res;
1942 }