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