bfd/bfd.c

   1 /* Generic BFD library interface and support routines.
   2    Copyright (C) 1990, 91, 92, 93, 94 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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /*
  22 SECTION
  23         <<typedef bfd>>
  24
  25         A BFD has type <<bfd>>; objects of this type are the
  26         cornerstone of any application using BFD. Using BFD
  27         consists of making references though the BFD and to data in the BFD.
  28
  29         Here is the structure that defines the type <<bfd>>.  It
  30         contains the major data about the file and pointers
  31         to the rest of the data.
  32
  33 CODE_FRAGMENT
  34 .
  35 .struct _bfd
  36 .{
  37 .    {* The filename the application opened the BFD with.  *}
  38 .    CONST char *filename;
  39 .
  40 .    {* A pointer to the target jump table.             *}
  41 .    struct bfd_target *xvec;
  42 .
  43 .    {* To avoid dragging too many header files into every file that
  44 .       includes `<<bfd.h>>', IOSTREAM has been declared as a "char
  45 .       *", and MTIME as a "long".  Their correct types, to which they
  46 .       are cast when used, are "FILE *" and "time_t".    The iostream
  47 .       is the result of an fopen on the filename. *}
  48 .    char *iostream;
  49 .
  50 .    {* Is the file descriptor being cached?  That is, can it be closed as
  51 .       needed, and re-opened when accessed later?  *}
  52 .
  53 .    boolean cacheable;
  54 .
  55 .    {* Marks whether there was a default target specified when the
  56 .       BFD was opened. This is used to select which matching algorithm
  57 .       to use to choose the back end. *}
  58 .
  59 .    boolean target_defaulted;
  60 .
  61 .    {* The caching routines use these to maintain a
  62 .       least-recently-used list of BFDs *}
  63 .
  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 .
  69 .    file_ptr where;
  70 .
  71 .    {* and here: (``once'' means at least once) *}
  72 .
  73 .    boolean opened_once;
  74 .
  75 .    {* Set if we have a locally maintained mtime value, rather than
  76 .       getting it from the file each time: *}
  77 .
  78 .    boolean mtime_set;
  79 .
  80 .    {* File modified time, if mtime_set is true: *}
  81 .
  82 .    long mtime;
  83 .
  84 .    {* Reserved for an unimplemented file locking extension.*}
  85 .
  86 .    int ifd;
  87 .
  88 .    {* The format which belongs to the BFD. (object, core, etc.) *}
  89 .
  90 .    bfd_format format;
  91 .
  92 .    {* The direction the BFD was opened with*}
  93 .
  94 .    enum bfd_direction {no_direction = 0,
  95 .                        read_direction = 1,
  96 .                        write_direction = 2,
  97 .                        both_direction = 3} direction;
  98 .
  99 .    {* Format_specific flags*}
 100 .
 101 .    flagword flags;
 102 .
 103 .    {* Currently my_archive is tested before adding origin to
 104 .       anything. I believe that this can become always an add of
 105 .       origin, with origin set to 0 for non archive files.   *}
 106 .
 107 .    file_ptr origin;
 108 .
 109 .    {* Remember when output has begun, to stop strange things
 110 .       from happening. *}
 111 .    boolean output_has_begun;
 112 .
 113 .    {* Pointer to linked list of sections*}
 114 .    struct sec  *sections;
 115 .
 116 .    {* The number of sections *}
 117 .    unsigned int section_count;
 118 .
 119 .    {* Stuff only useful for object files:
 120 .       The start address. *}
 121 .    bfd_vma start_address;
 122 .
 123 .    {* Used for input and output*}
 124 .    unsigned int symcount;
 125 .
 126 .    {* Symbol table for output BFD (with symcount entries) *}
 127 .    struct symbol_cache_entry  **outsymbols;
 128 .
 129 .    {* Pointer to structure which contains architecture information*}
 130 .    struct bfd_arch_info *arch_info;
 131 .
 132 .    {* Stuff only useful for archives:*}
 133 .    PTR arelt_data;
 134 .    struct _bfd *my_archive;     {* The containing archive BFD.  *}
 135 .    struct _bfd *next;           {* The next BFD in the archive.  *}
 136 .    struct _bfd *archive_head;   {* The first BFD in the archive.  *}
 137 .    boolean has_armap;
 138 .
 139 .    {* A chain of BFD structures involved in a link.  *}
 140 .    struct _bfd *link_next;
 141 .
 142 .    {* A field used by _bfd_generic_link_add_archive_symbols.  This will
 143 .       be used only for archive elements.  *}
 144 .    int archive_pass;
 145 .
 146 .    {* Used by the back end to hold private data. *}
 147 .
 148 .    union
 149 .      {
 150 .      struct aout_data_struct *aout_data;
 151 .      struct artdata *aout_ar_data;
 152 .      struct _oasys_data *oasys_obj_data;
 153 .      struct _oasys_ar_data *oasys_ar_data;
 154 .      struct coff_tdata *coff_obj_data;
 155 .      struct ecoff_tdata *ecoff_obj_data;
 156 .      struct ieee_data_struct *ieee_data;
 157 .      struct ieee_ar_data_struct *ieee_ar_data;
 158 .      struct srec_data_struct *srec_data;
 159 .      struct tekhex_data_struct *tekhex_data;
 160 .      struct elf_obj_tdata *elf_obj_data;
 161 .      struct nlm_obj_tdata *nlm_obj_data;
 162 .      struct bout_data_struct *bout_data;
 163 .      struct sun_core_struct *sun_core_data;
 164 .      struct trad_core_struct *trad_core_data;
 165 .      struct som_data_struct *som_data;
 166 .      struct hpux_core_struct *hpux_core_data;
 167 .      struct hppabsd_core_struct *hppabsd_core_data;
 168 .      struct sgi_core_struct *sgi_core_data;
 169 .      struct lynx_core_struct *lynx_core_data;
 170 .      struct osf_core_struct *osf_core_data;
 171 .      struct cisco_core_struct *cisco_core_data;
 172 .      PTR any;
 173 .      } tdata;
 174 .
 175 .    {* Used by the application to hold private data*}
 176 .    PTR usrdata;
 177 .
 178 .    {* Where all the allocated stuff under this BFD goes *}
 179 .    struct obstack memory;
 180 .};
 181 .
 182 */
 183
 184 #include "bfd.h"
 185 #include "sysdep.h"
 186 #include "bfdlink.h"
 187 #include "libbfd.h"
 188 #include "coff/internal.h"
 189 #include "coff/sym.h"
 190 #include "libcoff.h"
 191 #include "libecoff.h"
 192 #undef obj_symbols
 193 #include "libelf.h"
 194
 195 \f
 196 /*
 197 SECTION
 198         Error reporting
 199
 200         Most BFD functions return nonzero on success (check their
 201         individual documentation for precise semantics).  On an error,
 202         they call <<bfd_set_error>> to set an error condition that callers
 203         can check by calling <<bfd_get_error>>.
 204         If that returns <<bfd_error_system_call>>, then check
 205         <<errno>>.
 206
 207         The easiest way to report a BFD error to the user is to
 208         use <<bfd_perror>>.
 209
 210 SUBSECTION
 211         Type <<bfd_error_type>>
 212
 213         The values returned by <<bfd_get_error>> are defined by the
 214         enumerated type <<bfd_error_type>>.
 215
 216 CODE_FRAGMENT
 217 .
 218 .typedef enum bfd_error
 219 .{
 220 .  bfd_error_no_error = 0,
 221 .  bfd_error_system_call,
 222 .  bfd_error_invalid_target,
 223 .  bfd_error_wrong_format,
 224 .  bfd_error_invalid_operation,
 225 .  bfd_error_no_memory,
 226 .  bfd_error_no_symbols,
 227 .  bfd_error_no_more_archived_files,
 228 .  bfd_error_malformed_archive,
 229 .  bfd_error_file_not_recognized,
 230 .  bfd_error_file_ambiguously_recognized,
 231 .  bfd_error_no_contents,
 232 .  bfd_error_nonrepresentable_section,
 233 .  bfd_error_no_debug_section,
 234 .  bfd_error_bad_value,
 235 .  bfd_error_file_truncated,
 236 .  bfd_error_invalid_error_code
 237 .} bfd_error_type;
 238 .
 239 */
 240
 241 #undef strerror
 242 extern char *strerror();
 243
 244 static bfd_error_type bfd_error = bfd_error_no_error;
 245
 246 CONST char *CONST bfd_errmsgs[] = {
 247                         "No error",
 248                         "System call error",
 249                         "Invalid bfd target",
 250                         "File in wrong format",
 251                         "Invalid operation",
 252                         "Memory exhausted",
 253                         "No symbols",
 254                         "No more archived files",
 255                         "Malformed archive",
 256                         "File format not recognized",
 257                         "File format is ambiguous",
 258                         "Section has no contents",
 259                         "Nonrepresentable section on output",
 260                         "Symbol needs debug section which does not exist",
 261                         "Bad value",
 262                         "File truncated",
 263                         "#<Invalid error code>"
 264                        };
 265
 266 /*
 267 FUNCTION
 268         bfd_get_error
 269
 270 SYNOPSIS
 271         bfd_error_type bfd_get_error (void);
 272
 273 DESCRIPTION
 274         Return the current BFD error condition.
 275 */
 276
 277 bfd_error_type
 278 bfd_get_error ()
 279 {
 280   return bfd_error;
 281 }
 282
 283 /*
 284 FUNCTION
 285         bfd_set_error
 286
 287 SYNOPSIS
 288         void bfd_set_error (bfd_error_type error_tag);
 289
 290 DESCRIPTION
 291         Set the BFD error condition to be @var{error_tag}.
 292 */
 293
 294 void
 295 bfd_set_error (error_tag)
 296      bfd_error_type error_tag;
 297 {
 298   bfd_error = error_tag;
 299 }
 300
 301 /*
 302 FUNCTION
 303         bfd_errmsg
 304
 305 SYNOPSIS
 306         CONST char *bfd_errmsg (bfd_error_type error_tag);
 307
 308 DESCRIPTION
 309         Return a string describing the error @var{error_tag}, or
 310         the system error if @var{error_tag} is <<bfd_error_system_call>>.
 311 */
 312
 313 CONST char *
 314 bfd_errmsg (error_tag)
 315      bfd_error_type error_tag;
 316 {
 317 #ifndef errno
 318   extern int errno;
 319 #endif
 320   if (error_tag == bfd_error_system_call)
 321     return strerror (errno);
 322
 323   if ((((int)error_tag <(int) bfd_error_no_error) ||
 324        ((int)error_tag > (int)bfd_error_invalid_error_code)))
 325     error_tag = bfd_error_invalid_error_code;/* sanity check */
 326
 327   return bfd_errmsgs [(int)error_tag];
 328 }
 329
 330 /*
 331 FUNCTION
 332         bfd_perror
 333
 334 SYNOPSIS
 335         void bfd_perror (CONST char *message);
 336
 337 DESCRIPTION
 338         Print to the standard error stream a string describing the
 339         last BFD error that occurred, or the last system error if
 340         the last BFD error was a system call failure.  If @var{message}
 341         is non-NULL and non-empty, the error string printed is preceded
 342         by @var{message}, a colon, and a space.  It is followed by a newline.
 343 */
 344
 345 void
 346 bfd_perror (message)
 347      CONST char *message;
 348 {
 349   if (bfd_get_error () == bfd_error_system_call)
 350     perror((char *)message);            /* must be system error then... */
 351   else {
 352     if (message == NULL || *message == '\0')
 353       fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
 354     else
 355       fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
 356   }
 357 }
 358
 359 \f
 360 /*
 361 SECTION
 362         Symbols
 363 */
 364
 365 /*
 366 FUNCTION
 367         bfd_get_reloc_upper_bound
 368
 369 SYNOPSIS
 370         long bfd_get_reloc_upper_bound(bfd *abfd, asection *sect);
 371
 372 DESCRIPTION
 373         Return the number of bytes required to store the
 374         relocation information associated with section @var{sect}
 375         attached to bfd @var{abfd}.  If an error occurs, return -1.
 376
 377 */
 378
 379
 380 long
 381 bfd_get_reloc_upper_bound (abfd, asect)
 382      bfd *abfd;
 383      sec_ptr asect;
 384 {
 385   if (abfd->format != bfd_object) {
 386     bfd_set_error (bfd_error_invalid_operation);
 387     return -1;
 388   }
 389
 390   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 391 }
 392
 393 /*
 394 FUNCTION
 395         bfd_canonicalize_reloc
 396
 397 SYNOPSIS
 398         long bfd_canonicalize_reloc
 399                 (bfd *abfd,
 400                 asection *sec,
 401                 arelent **loc,
 402                 asymbol **syms);
 403
 404 DESCRIPTION
 405         Call the back end associated with the open BFD
 406         @var{abfd} and translate the external form of the relocation
 407         information attached to @var{sec} into the internal canonical
 408         form.  Place the table into memory at @var{loc}, which has
 409         been preallocated, usually by a call to
 410         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
 411         -1 on error.
 412
 413         The @var{syms} table is also needed for horrible internal magic
 414         reasons.
 415
 416
 417 */
 418 long
 419 bfd_canonicalize_reloc (abfd, asect, location, symbols)
 420      bfd *abfd;
 421      sec_ptr asect;
 422      arelent **location;
 423      asymbol **symbols;
 424 {
 425   if (abfd->format != bfd_object) {
 426     bfd_set_error (bfd_error_invalid_operation);
 427     return -1;
 428   }
 429   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 430                    (abfd, asect, location, symbols));
 431 }
 432
 433 /*
 434 FUNCTION
 435         bfd_set_reloc
 436
 437 SYNOPSIS
 438         void bfd_set_reloc
 439           (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
 440
 441 DESCRIPTION
 442         Set the relocation pointer and count within
 443         section @var{sec} to the values @var{rel} and @var{count}.
 444         The argument @var{abfd} is ignored.
 445
 446 */
 447 /*ARGSUSED*/
 448 void
 449 bfd_set_reloc (ignore_abfd, asect, location, count)
 450      bfd *ignore_abfd;
 451      sec_ptr asect;
 452      arelent **location;
 453      unsigned int count;
 454 {
 455   asect->orelocation  = location;
 456   asect->reloc_count = count;
 457 }
 458
 459 /*
 460 FUNCTION
 461         bfd_set_file_flags
 462
 463 SYNOPSIS
 464         boolean bfd_set_file_flags(bfd *abfd, flagword flags);
 465
 466 DESCRIPTION
 467         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
 468
 469         Possible errors are:
 470         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
 471         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
 472         o <<bfd_error_invalid_operation>> -
 473         The flag word contained a bit which was not applicable to the
 474         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
 475         on a BFD format which does not support demand paging.
 476
 477 */
 478
 479 boolean
 480 bfd_set_file_flags (abfd, flags)
 481      bfd *abfd;
 482      flagword flags;
 483 {
 484   if (abfd->format != bfd_object) {
 485     bfd_set_error (bfd_error_wrong_format);
 486     return false;
 487   }
 488
 489   if (bfd_read_p (abfd)) {
 490     bfd_set_error (bfd_error_invalid_operation);
 491     return false;
 492   }
 493
 494   bfd_get_file_flags (abfd) = flags;
 495   if ((flags & bfd_applicable_file_flags (abfd)) != flags) {
 496     bfd_set_error (bfd_error_invalid_operation);
 497     return false;
 498   }
 499
 500 return true;
 501 }
 502
 503 void
 504 bfd_assert(file, line)
 505 char *file;
 506 int line;
 507 {
 508   fprintf(stderr, "bfd assertion fail %s:%d\n",file,line);
 509 }
 510
 511
 512 /*
 513 FUNCTION
 514         bfd_set_start_address
 515
 516 SYNOPSIS
 517         boolean bfd_set_start_address(bfd *abfd, bfd_vma vma);
 518
 519 DESCRIPTION
 520         Make @var{vma} the entry point of output BFD @var{abfd}.
 521
 522 RETURNS
 523         Returns <<true>> on success, <<false>> otherwise.
 524 */
 525
 526 boolean
 527 bfd_set_start_address(abfd, vma)
 528 bfd *abfd;
 529 bfd_vma vma;
 530 {
 531   abfd->start_address = vma;
 532   return true;
 533 }
 534
 535
 536 /*
 537 FUNCTION
 538         bfd_get_mtime
 539
 540 SYNOPSIS
 541         long bfd_get_mtime(bfd *abfd);
 542
 543 DESCRIPTION
 544         Return the file modification time (as read from the file system, or
 545         from the archive header for archive members).
 546
 547 */
 548
 549 long
 550 bfd_get_mtime (abfd)
 551      bfd *abfd;
 552 {
 553   FILE *fp;
 554   struct stat buf;
 555
 556   if (abfd->mtime_set)
 557     return abfd->mtime;
 558
 559   fp = bfd_cache_lookup (abfd);
 560   if (0 != fstat (fileno (fp), &buf))
 561     return 0;
 562
 563   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 564   return buf.st_mtime;
 565 }
 566
 567 /*
 568 FUNCTION
 569         bfd_get_size
 570
 571 SYNOPSIS
 572         long bfd_get_size(bfd *abfd);
 573
 574 DESCRIPTION
 575         Return the file size (as read from file system) for the file
 576         associated with BFD @var{abfd}.
 577
 578         The initial motivation for, and use of, this routine is not
 579         so we can get the exact size of the object the BFD applies to, since
 580         that might not be generally possible (archive members for example).
 581         It would be ideal if someone could eventually modify
 582         it so that such results were guaranteed.
 583
 584         Instead, we want to ask questions like "is this NNN byte sized
 585         object I'm about to try read from file offset YYY reasonable?"
 586         As as example of where we might do this, some object formats
 587         use string tables for which the first <<sizeof(long)>> bytes of the
 588         table contain the size of the table itself, including the size bytes.
 589         If an application tries to read what it thinks is one of these
 590         string tables, without some way to validate the size, and for
 591         some reason the size is wrong (byte swapping error, wrong location
 592         for the string table, etc.), the only clue is likely to be a read
 593         error when it tries to read the table, or a "virtual memory
 594         exhausted" error when it tries to allocate 15 bazillon bytes
 595         of space for the 15 bazillon byte table it is about to read.
 596         This function at least allows us to answer the quesion, "is the
 597         size reasonable?".
 598 */
 599
 600 long
 601 bfd_get_size (abfd)
 602      bfd *abfd;
 603 {
 604   FILE *fp;
 605   struct stat buf;
 606
 607   fp = bfd_cache_lookup (abfd);
 608   if (0 != fstat (fileno (fp), &buf))
 609     return 0;
 610
 611   return buf.st_size;
 612 }
 613
 614 /*
 615 FUNCTION
 616         bfd_get_gp_size
 617
 618 SYNOPSIS
 619         int bfd_get_gp_size(bfd *abfd);
 620
 621 DESCRIPTION
 622         Return the maximum size of objects to be optimized using the GP
 623         register under MIPS ECOFF.  This is typically set by the <<-G>>
 624         argument to the compiler, assembler or linker.
 625 */
 626
 627 int
 628 bfd_get_gp_size (abfd)
 629      bfd *abfd;
 630 {
 631   if (abfd->format == bfd_object)
 632     {
 633       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 634         return ecoff_data (abfd)->gp_size;
 635       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 636         return elf_gp_size (abfd);
 637     }
 638   return 0;
 639 }
 640
 641 /*
 642 FUNCTION
 643         bfd_set_gp_size
 644
 645 SYNOPSIS
 646         void bfd_set_gp_size(bfd *abfd, int i);
 647
 648 DESCRIPTION
 649         Set the maximum size of objects to be optimized using the GP
 650         register under ECOFF or MIPS ELF.  This is typically set by
 651         the <<-G>> argument to the compiler, assembler or linker.
 652 */
 653
 654 void
 655 bfd_set_gp_size (abfd, i)
 656      bfd *abfd;
 657      int i;
 658 {
 659   /* Don't try to set GP size on an archive or core file! */
 660   if (abfd->format != bfd_object)
 661     return;
 662   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 663     ecoff_data (abfd)->gp_size = i;
 664   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 665     elf_gp_size (abfd) = i;
 666 }
 667
 668 /*
 669 FUNCTION
 670         bfd_scan_vma
 671
 672 SYNOPSIS
 673         bfd_vma bfd_scan_vma(CONST char *string, CONST char **end, int base);
 674
 675 DESCRIPTION
 676         Convert, like <<strtoul>>, a numerical expression
 677         @var{string} into a <<bfd_vma>> integer, and return that integer.
 678         (Though without as many bells and whistles as <<strtoul>>.)
 679         The expression is assumed to be unsigned (i.e., positive).
 680         If given a @var{base}, it is used as the base for conversion.
 681         A base of 0 causes the function to interpret the string
 682         in hex if a leading "0x" or "0X" is found, otherwise
 683         in octal if a leading zero is found, otherwise in decimal.
 684
 685         Overflow is not detected.
 686 */
 687
 688 bfd_vma
 689 bfd_scan_vma (string, end, base)
 690      CONST char *string;
 691      CONST char **end;
 692      int base;
 693 {
 694   bfd_vma value;
 695   int digit;
 696
 697   /* Let the host do it if possible.  */
 698   if (sizeof(bfd_vma) <= sizeof(unsigned long))
 699     return (bfd_vma) strtoul (string, 0, base);
 700
 701   /* A negative base makes no sense, and we only need to go as high as hex.  */
 702   if ((base < 0) || (base > 16))
 703     return (bfd_vma) 0;
 704
 705   if (base == 0)
 706     {
 707       if (string[0] == '0')
 708         {
 709           if ((string[1] == 'x') || (string[1] == 'X'))
 710             base = 16;
 711           /* XXX should we also allow "0b" or "0B" to set base to 2? */
 712           else
 713             base = 8;
 714         }
 715       else
 716         base = 10;
 717     }
 718   if ((base == 16) &&
 719       (string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')))
 720     string += 2;
 721   /* XXX should we also skip over "0b" or "0B" if base is 2? */
 722
 723 /* Speed could be improved with a table like hex_value[] in gas.  */
 724 #define HEX_VALUE(c) \
 725   (isxdigit(c) ?                                \
 726     (isdigit(c) ?                               \
 727       (c - '0') :                               \
 728       (10 + c - (islower(c) ? 'a' : 'A'))) :    \
 729     42)
 730
 731   for (value = 0; (digit = HEX_VALUE(*string)) < base; string++)
 732     {
 733       value = value * base + digit;
 734     }
 735
 736   if (end)
 737     *end = string;
 738
 739   return value;
 740 }
 741
 742 /*
 743 FUNCTION
 744         bfd_copy_private_bfd_data
 745
 746 SYNOPSIS
 747         boolean bfd_copy_private_bfd_data(bfd *ibfd, bfd *obfd);
 748
 749 DESCRIPTION
 750         Copy private BFD information from the BFD @var{ibfd} to the
 751         the BFD @var{obfd}.  Return <<true>> on success, <<false>> on error.
 752         Possible error returns are:
 753
 754         o <<bfd_error_no_memory>> -
 755         Not enough memory exists to create private data for @var{obfd}.
 756
 757 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
 758 .     BFD_SEND (ibfd, _bfd_copy_private_bfd_data, \
 759 .               (ibfd, obfd))
 760
 761 */
 762
 763 /*
 764 FUNCTION
 765         stuff
 766
 767 DESCRIPTION
 768         Stuff which should be documented:
 769
 770 .#define bfd_sizeof_headers(abfd, reloc) \
 771 .     BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
 772 .
 773 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
 774 .     BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
 775 .
 776 .       {* Do these three do anything useful at all, for any back end?  *}
 777 .#define bfd_debug_info_start(abfd) \
 778 .        BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
 779 .
 780 .#define bfd_debug_info_end(abfd) \
 781 .        BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
 782 .
 783 .#define bfd_debug_info_accumulate(abfd, section) \
 784 .        BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
 785 .
 786 .
 787 .#define bfd_stat_arch_elt(abfd, stat) \
 788 .        BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
 789 .
 790 .#define bfd_set_arch_mach(abfd, arch, mach)\
 791 .        BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
 792 .
 793 .#define bfd_get_relocated_section_contents(abfd, link_info, link_order, data, relocateable, symbols) \
 794 .       BFD_SEND (abfd, _bfd_get_relocated_section_contents, \
 795 .                 (abfd, link_info, link_order, data, relocateable, symbols))
 796 .
 797 .#define bfd_relax_section(abfd, section, link_info, again) \
 798 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
 799 .
 800 .#define bfd_link_hash_table_create(abfd) \
 801 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
 802 .
 803 .#define bfd_link_add_symbols(abfd, info) \
 804 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
 805 .
 806 .#define bfd_final_link(abfd, info) \
 807 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
 808 .
 809 .#define bfd_free_cached_info(abfd) \
 810 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
 811 .
 812
 813 */