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 .      PTR any;
 172 .      } tdata;
 173 .
 174 .    {* Used by the application to hold private data*}
 175 .    PTR usrdata;
 176 .
 177 .    {* Where all the allocated stuff under this BFD goes *}
 178 .    struct obstack memory;
 179 .};
 180 .
 181 */
 182
 183 #include "bfd.h"
 184 #include "sysdep.h"
 185 #include "bfdlink.h"
 186 #include "libbfd.h"
 187 #include "coff/internal.h"
 188 #include "coff/sym.h"
 189 #include "libcoff.h"
 190 #include "libecoff.h"
 191 #undef obj_symbols
 192 #include "libelf.h"
 193
 194 \f
 195 /*
 196 SECTION
 197         Error reporting
 198
 199         Most BFD functions return nonzero on success (check their
 200         individual documentation for precise semantics).  On an error,
 201         they call <<bfd_set_error>> to set an error condition that callers
 202         can check by calling <<bfd_get_error>>.
 203         If that returns <<bfd_error_system_call>>, then check
 204         <<errno>>.
 205
 206         The easiest way to report a BFD error to the user is to
 207         use <<bfd_perror>>.
 208
 209 SUBSECTION
 210         Type <<bfd_error_type>>
 211
 212         The values returned by <<bfd_get_error>> are defined by the
 213         enumerated type <<bfd_error_type>>.
 214
 215 CODE_FRAGMENT
 216 .
 217 .typedef enum bfd_error
 218 .{
 219 .  bfd_error_no_error = 0,
 220 .  bfd_error_system_call,
 221 .  bfd_error_invalid_target,
 222 .  bfd_error_wrong_format,
 223 .  bfd_error_invalid_operation,
 224 .  bfd_error_no_memory,
 225 .  bfd_error_no_symbols,
 226 .  bfd_error_no_more_archived_files,
 227 .  bfd_error_malformed_archive,
 228 .  bfd_error_file_not_recognized,
 229 .  bfd_error_file_ambiguously_recognized,
 230 .  bfd_error_no_contents,
 231 .  bfd_error_nonrepresentable_section,
 232 .  bfd_error_no_debug_section,
 233 .  bfd_error_bad_value,
 234 .  bfd_error_file_truncated,
 235 .  bfd_error_invalid_error_code
 236 .} bfd_error_type;
 237 .
 238 */
 239
 240 #undef strerror
 241 extern char *strerror();
 242
 243 static bfd_error_type bfd_error = bfd_error_no_error;
 244
 245 CONST char *CONST bfd_errmsgs[] = {
 246                         "No error",
 247                         "System call error",
 248                         "Invalid bfd target",
 249                         "File in wrong format",
 250                         "Invalid operation",
 251                         "Memory exhausted",
 252                         "No symbols",
 253                         "No more archived files",
 254                         "Malformed archive",
 255                         "File format not recognized",
 256                         "File format is ambiguous",
 257                         "Section has no contents",
 258                         "Nonrepresentable section on output",
 259                         "Symbol needs debug section which does not exist",
 260                         "Bad value",
 261                         "File truncated",
 262                         "#<Invalid error code>"
 263                        };
 264
 265 /*
 266 FUNCTION
 267         bfd_get_error
 268
 269 SYNOPSIS
 270         bfd_error_type bfd_get_error (void);
 271
 272 DESCRIPTION
 273         Return the current BFD error condition.
 274 */
 275
 276 bfd_error_type
 277 bfd_get_error ()
 278 {
 279   return bfd_error;
 280 }
 281
 282 /*
 283 FUNCTION
 284         bfd_set_error
 285
 286 SYNOPSIS
 287         void bfd_set_error (bfd_error_type error_tag);
 288
 289 DESCRIPTION
 290         Set the BFD error condition to be @var{error_tag}.
 291 */
 292
 293 void
 294 bfd_set_error (error_tag)
 295      bfd_error_type error_tag;
 296 {
 297   bfd_error = error_tag;
 298 }
 299
 300 /*
 301 FUNCTION
 302         bfd_errmsg
 303
 304 SYNOPSIS
 305         CONST char *bfd_errmsg (bfd_error_type error_tag);
 306
 307 DESCRIPTION
 308         Return a string describing the error @var{error_tag}, or
 309         the system error if @var{error_tag} is <<bfd_error_system_call>>.
 310 */
 311
 312 CONST char *
 313 bfd_errmsg (error_tag)
 314      bfd_error_type error_tag;
 315 {
 316 #ifndef errno
 317   extern int errno;
 318 #endif
 319   if (error_tag == bfd_error_system_call)
 320     return strerror (errno);
 321
 322   if ((((int)error_tag <(int) bfd_error_no_error) ||
 323        ((int)error_tag > (int)bfd_error_invalid_error_code)))
 324     error_tag = bfd_error_invalid_error_code;/* sanity check */
 325
 326   return bfd_errmsgs [(int)error_tag];
 327 }
 328
 329 /*
 330 FUNCTION
 331         bfd_perror
 332
 333 SYNOPSIS
 334         void bfd_perror (CONST char *message);
 335
 336 DESCRIPTION
 337         Print to the standard error stream a string describing the
 338         last BFD error that occurred, or the last system error if
 339         the last BFD error was a system call failure.  If @var{message}
 340         is non-NULL and non-empty, the error string printed is preceded
 341         by @var{message}, a colon, and a space.  It is followed by a newline.
 342 */
 343
 344 void
 345 bfd_perror (message)
 346      CONST char *message;
 347 {
 348   if (bfd_get_error () == bfd_error_system_call)
 349     perror((char *)message);            /* must be system error then... */
 350   else {
 351     if (message == NULL || *message == '\0')
 352       fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
 353     else
 354       fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
 355   }
 356 }
 357
 358 \f
 359 /*
 360 SECTION
 361         Symbols
 362 */
 363
 364 /*
 365 FUNCTION
 366         bfd_get_reloc_upper_bound
 367
 368 SYNOPSIS
 369         unsigned int bfd_get_reloc_upper_bound(bfd *abfd, asection *sect);
 370
 371 DESCRIPTION
 372         Return the number of bytes required to store the
 373         relocation information associated with section @var{sect}
 374         attached to bfd @var{abfd}.
 375
 376 */
 377
 378
 379 unsigned int
 380 bfd_get_reloc_upper_bound (abfd, asect)
 381      bfd *abfd;
 382      sec_ptr asect;
 383 {
 384   if (abfd->format != bfd_object) {
 385     bfd_set_error (bfd_error_invalid_operation);
 386     return 0;
 387   }
 388
 389   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 390 }
 391
 392 /*
 393 FUNCTION
 394         bfd_canonicalize_reloc
 395
 396 SYNOPSIS
 397         unsigned int bfd_canonicalize_reloc
 398                 (bfd *abfd,
 399                 asection *sec,
 400                 arelent **loc,
 401                 asymbol **syms);
 402
 403 DESCRIPTION
 404         Call the back end associated with the open BFD
 405         @var{abfd} and translate the external form of the relocation
 406         information attached to @var{sec} into the internal canonical
 407         form.  Place the table into memory at @var{loc}, which has
 408         been preallocated, usually by a call to
 409         <<bfd_get_reloc_upper_bound>>.
 410
 411         The @var{syms} table is also needed for horrible internal magic
 412         reasons.
 413
 414
 415 */
 416 unsigned int
 417 bfd_canonicalize_reloc (abfd, asect, location, symbols)
 418      bfd *abfd;
 419      sec_ptr asect;
 420      arelent **location;
 421      asymbol **symbols;
 422 {
 423   if (abfd->format != bfd_object) {
 424     bfd_set_error (bfd_error_invalid_operation);
 425     return 0;
 426   }
 427   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 428                    (abfd, asect, location, symbols));
 429 }
 430
 431 /*
 432 FUNCTION
 433         bfd_set_reloc
 434
 435 SYNOPSIS
 436         void bfd_set_reloc
 437           (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
 438
 439 DESCRIPTION
 440         Set the relocation pointer and count within
 441         section @var{sec} to the values @var{rel} and @var{count}.
 442         The argument @var{abfd} is ignored.
 443
 444 */
 445 /*ARGSUSED*/
 446 void
 447 bfd_set_reloc (ignore_abfd, asect, location, count)
 448      bfd *ignore_abfd;
 449      sec_ptr asect;
 450      arelent **location;
 451      unsigned int count;
 452 {
 453   asect->orelocation  = location;
 454   asect->reloc_count = count;
 455 }
 456
 457 /*
 458 FUNCTION
 459         bfd_set_file_flags
 460
 461 SYNOPSIS
 462         boolean bfd_set_file_flags(bfd *abfd, flagword flags);
 463
 464 DESCRIPTION
 465         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
 466
 467         Possible errors are:
 468         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
 469         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
 470         o <<bfd_error_invalid_operation>> -
 471         The flag word contained a bit which was not applicable to the
 472         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
 473         on a BFD format which does not support demand paging.
 474
 475 */
 476
 477 boolean
 478 bfd_set_file_flags (abfd, flags)
 479      bfd *abfd;
 480      flagword flags;
 481 {
 482   if (abfd->format != bfd_object) {
 483     bfd_set_error (bfd_error_wrong_format);
 484     return false;
 485   }
 486
 487   if (bfd_read_p (abfd)) {
 488     bfd_set_error (bfd_error_invalid_operation);
 489     return false;
 490   }
 491
 492   bfd_get_file_flags (abfd) = flags;
 493   if ((flags & bfd_applicable_file_flags (abfd)) != flags) {
 494     bfd_set_error (bfd_error_invalid_operation);
 495     return false;
 496   }
 497
 498 return true;
 499 }
 500
 501 void
 502 bfd_assert(file, line)
 503 char *file;
 504 int line;
 505 {
 506   fprintf(stderr, "bfd assertion fail %s:%d\n",file,line);
 507 }
 508
 509
 510 /*
 511 FUNCTION
 512         bfd_set_start_address
 513
 514 SYNOPSIS
 515         boolean bfd_set_start_address(bfd *abfd, bfd_vma vma);
 516
 517 DESCRIPTION
 518         Make @var{vma} the entry point of output BFD @var{abfd}.
 519
 520 RETURNS
 521         Returns <<true>> on success, <<false>> otherwise.
 522 */
 523
 524 boolean
 525 bfd_set_start_address(abfd, vma)
 526 bfd *abfd;
 527 bfd_vma vma;
 528 {
 529   abfd->start_address = vma;
 530   return true;
 531 }
 532
 533
 534 /*
 535 FUNCTION
 536         bfd_get_mtime
 537
 538 SYNOPSIS
 539         long bfd_get_mtime(bfd *abfd);
 540
 541 DESCRIPTION
 542         Return the file modification time (as read from the file system, or
 543         from the archive header for archive members).
 544
 545 */
 546
 547 long
 548 bfd_get_mtime (abfd)
 549      bfd *abfd;
 550 {
 551   FILE *fp;
 552   struct stat buf;
 553
 554   if (abfd->mtime_set)
 555     return abfd->mtime;
 556
 557   fp = bfd_cache_lookup (abfd);
 558   if (0 != fstat (fileno (fp), &buf))
 559     return 0;
 560
 561   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 562   return buf.st_mtime;
 563 }
 564
 565 /*
 566 FUNCTION
 567         bfd_get_size
 568
 569 SYNOPSIS
 570         long bfd_get_size(bfd *abfd);
 571
 572 DESCRIPTION
 573         Return the file size (as read from file system) for the file
 574         associated with BFD @var{abfd}.
 575
 576         The initial motivation for, and use of, this routine is not
 577         so we can get the exact size of the object the BFD applies to, since
 578         that might not be generally possible (archive members for example).
 579         It would be ideal if someone could eventually modify
 580         it so that such results were guaranteed.
 581
 582         Instead, we want to ask questions like "is this NNN byte sized
 583         object I'm about to try read from file offset YYY reasonable?"
 584         As as example of where we might do this, some object formats
 585         use string tables for which the first <<sizeof(long)>> bytes of the
 586         table contain the size of the table itself, including the size bytes.
 587         If an application tries to read what it thinks is one of these
 588         string tables, without some way to validate the size, and for
 589         some reason the size is wrong (byte swapping error, wrong location
 590         for the string table, etc.), the only clue is likely to be a read
 591         error when it tries to read the table, or a "virtual memory
 592         exhausted" error when it tries to allocate 15 bazillon bytes
 593         of space for the 15 bazillon byte table it is about to read.
 594         This function at least allows us to answer the quesion, "is the
 595         size reasonable?".
 596 */
 597
 598 long
 599 bfd_get_size (abfd)
 600      bfd *abfd;
 601 {
 602   FILE *fp;
 603   struct stat buf;
 604
 605   fp = bfd_cache_lookup (abfd);
 606   if (0 != fstat (fileno (fp), &buf))
 607     return 0;
 608
 609   return buf.st_size;
 610 }
 611
 612 /*
 613 FUNCTION
 614         bfd_get_gp_size
 615
 616 SYNOPSIS
 617         int bfd_get_gp_size(bfd *abfd);
 618
 619 DESCRIPTION
 620         Return the maximum size of objects to be optimized using the GP
 621         register under MIPS ECOFF.  This is typically set by the <<-G>>
 622         argument to the compiler, assembler or linker.
 623 */
 624
 625 int
 626 bfd_get_gp_size (abfd)
 627      bfd *abfd;
 628 {
 629   if (abfd->format == bfd_object)
 630     {
 631       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 632         return ecoff_data (abfd)->gp_size;
 633       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 634         return elf_gp_size (abfd);
 635     }
 636   return 0;
 637 }
 638
 639 /*
 640 FUNCTION
 641         bfd_set_gp_size
 642
 643 SYNOPSIS
 644         void bfd_set_gp_size(bfd *abfd, int i);
 645
 646 DESCRIPTION
 647         Set the maximum size of objects to be optimized using the GP
 648         register under ECOFF or MIPS ELF.  This is typically set by
 649         the <<-G>> argument to the compiler, assembler or linker.
 650 */
 651
 652 void
 653 bfd_set_gp_size (abfd, i)
 654      bfd *abfd;
 655      int i;
 656 {
 657   /* Don't try to set GP size on an archive or core file! */
 658   if (abfd->format != bfd_object)
 659     return;
 660   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 661     ecoff_data (abfd)->gp_size = i;
 662   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 663     elf_gp_size (abfd) = i;
 664 }
 665
 666 /*
 667 FUNCTION
 668         bfd_scan_vma
 669
 670 SYNOPSIS
 671         bfd_vma bfd_scan_vma(CONST char *string, CONST char **end, int base);
 672
 673 DESCRIPTION
 674         Convert, like <<strtoul>>, a numerical expression
 675         @var{string} into a <<bfd_vma>> integer, and return that integer.
 676         (Though without as many bells and whistles as <<strtoul>>.)
 677         The expression is assumed to be unsigned (i.e., positive).
 678         If given a @var{base}, it is used as the base for conversion.
 679         A base of 0 causes the function to interpret the string
 680         in hex if a leading "0x" or "0X" is found, otherwise
 681         in octal if a leading zero is found, otherwise in decimal.
 682
 683         Overflow is not detected.
 684 */
 685
 686 bfd_vma
 687 bfd_scan_vma (string, end, base)
 688      CONST char *string;
 689      CONST char **end;
 690      int base;
 691 {
 692   bfd_vma value;
 693   int digit;
 694
 695   /* Let the host do it if possible.  */
 696   if (sizeof(bfd_vma) <= sizeof(unsigned long))
 697     return (bfd_vma) strtoul (string, 0, base);
 698
 699   /* A negative base makes no sense, and we only need to go as high as hex.  */
 700   if ((base < 0) || (base > 16))
 701     return (bfd_vma) 0;
 702
 703   if (base == 0)
 704     {
 705       if (string[0] == '0')
 706         {
 707           if ((string[1] == 'x') || (string[1] == 'X'))
 708             base = 16;
 709           /* XXX should we also allow "0b" or "0B" to set base to 2? */
 710           else
 711             base = 8;
 712         }
 713       else
 714         base = 10;
 715     }
 716   if ((base == 16) &&
 717       (string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')))
 718     string += 2;
 719   /* XXX should we also skip over "0b" or "0B" if base is 2? */
 720
 721 /* Speed could be improved with a table like hex_value[] in gas.  */
 722 #define HEX_VALUE(c) \
 723   (isxdigit(c) ?                                \
 724     (isdigit(c) ?                               \
 725       (c - '0') :                               \
 726       (10 + c - (islower(c) ? 'a' : 'A'))) :    \
 727     42)
 728
 729   for (value = 0; (digit = HEX_VALUE(*string)) < base; string++)
 730     {
 731       value = value * base + digit;
 732     }
 733
 734   if (end)
 735     *end = string;
 736
 737   return value;
 738 }
 739
 740 /*
 741 FUNCTION
 742         stuff
 743
 744 DESCRIPTION
 745         Stuff which should be documented:
 746
 747 .#define bfd_sizeof_headers(abfd, reloc) \
 748 .     BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
 749 .
 750 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
 751 .     BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
 752 .
 753 .       {* Do these three do anything useful at all, for any back end?  *}
 754 .#define bfd_debug_info_start(abfd) \
 755 .        BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
 756 .
 757 .#define bfd_debug_info_end(abfd) \
 758 .        BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
 759 .
 760 .#define bfd_debug_info_accumulate(abfd, section) \
 761 .        BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
 762 .
 763 .
 764 .#define bfd_stat_arch_elt(abfd, stat) \
 765 .        BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
 766 .
 767 .#define bfd_set_arch_mach(abfd, arch, mach)\
 768 .        BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
 769 .
 770 .#define bfd_get_relocated_section_contents(abfd, link_info, link_order, data, relocateable, symbols) \
 771 .       BFD_SEND (abfd, _bfd_get_relocated_section_contents, \
 772 .                 (abfd, link_info, link_order, data, relocateable, symbols))
 773 .
 774 .#define bfd_relax_section(abfd, section, link_info, symbols) \
 775 .       BFD_SEND (abfd, _bfd_relax_section, \
 776 .                 (abfd, section, link_info, symbols))
 777 .
 778 .#define bfd_link_hash_table_create(abfd) \
 779 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
 780 .
 781 .#define bfd_link_add_symbols(abfd, info) \
 782 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
 783 .
 784 .#define bfd_final_link(abfd, info) \
 785 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
 786 .
 787
 788 */