bfd/bfd.c

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