contrib/binutils-2.25/bfd/bfd.c

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