bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994 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 Most of this hacked by  Steve Chamberlain,
  23                         sac@cygnus.com
  24 */
  25 /*
  26
  27 SECTION
  28         coff backends
  29
  30         BFD supports a number of different flavours of coff format.
  31         The major differences between formats are the sizes and
  32         alignments of fields in structures on disk, and the occasional
  33         extra field.
  34
  35         Coff in all its varieties is implemented with a few common
  36         files and a number of implementation specific files. For
  37         example, The 88k bcs coff format is implemented in the file
  38         @file{coff-m88k.c}. This file @code{#include}s
  39         @file{coff/m88k.h} which defines the external structure of the
  40         coff format for the 88k, and @file{coff/internal.h} which
  41         defines the internal structure. @file{coff-m88k.c} also
  42         defines the relocations used by the 88k format
  43         @xref{Relocations}.
  44
  45         The Intel i960 processor version of coff is implemented in
  46         @file{coff-i960.c}. This file has the same structure as
  47         @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
  48         rather than @file{coff-m88k.h}.
  49
  50 SUBSECTION
  51         Porting to a new version of coff
  52
  53         The recommended method is to select from the existing
  54         implementations the version of coff which is most like the one
  55         you want to use.  For example, we'll say that i386 coff is
  56         the one you select, and that your coff flavour is called foo.
  57         Copy @file{i386coff.c} to @file{foocoff.c}, copy
  58         @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
  59         and add the lines to @file{targets.c} and @file{Makefile.in}
  60         so that your new back end is used. Alter the shapes of the
  61         structures in @file{../include/coff/foo.h} so that they match
  62         what you need. You will probably also have to add
  63         @code{#ifdef}s to the code in @file{coff/internal.h} and
  64         @file{coffcode.h} if your version of coff is too wild.
  65
  66         You can verify that your new BFD backend works quite simply by
  67         building @file{objdump} from the @file{binutils} directory,
  68         and making sure that its version of what's going on and your
  69         host system's idea (assuming it has the pretty standard coff
  70         dump utility, usually called @code{att-dump} or just
  71         @code{dump}) are the same.  Then clean up your code, and send
  72         what you've done to Cygnus. Then your stuff will be in the
  73         next release, and you won't have to keep integrating it.
  74
  75 SUBSECTION
  76         How the coff backend works
  77
  78 SUBSUBSECTION
  79         File layout
  80
  81         The Coff backend is split into generic routines that are
  82         applicable to any Coff target and routines that are specific
  83         to a particular target.  The target-specific routines are
  84         further split into ones which are basically the same for all
  85         Coff targets except that they use the external symbol format
  86         or use different values for certain constants.
  87
  88         The generic routines are in @file{coffgen.c}.  These routines
  89         work for any Coff target.  They use some hooks into the target
  90         specific code; the hooks are in a @code{bfd_coff_backend_data}
  91         structure, one of which exists for each target.
  92
  93         The essentially similar target-specific routines are in
  94         @file{coffcode.h}.  This header file includes executable C code.
  95         The various Coff targets first include the appropriate Coff
  96         header file, make any special defines that are needed, and
  97         then include @file{coffcode.h}.
  98
  99         Some of the Coff targets then also have additional routines in
 100         the target source file itself.
 101
 102         For example, @file{coff-i960.c} includes
 103         @file{coff/internal.h} and @file{coff/i960.h}.  It then
 104         defines a few constants, such as @code{I960}, and includes
 105         @file{coffcode.h}.  Since the i960 has complex relocation
 106         types, @file{coff-i960.c} also includes some code to
 107         manipulate the i960 relocs.  This code is not in
 108         @file{coffcode.h} because it would not be used by any other
 109         target.
 110
 111 SUBSUBSECTION
 112         Bit twiddling
 113
 114         Each flavour of coff supported in BFD has its own header file
 115         describing the external layout of the structures. There is also
 116         an internal description of the coff layout, in
 117         @file{coff/internal.h}. A major function of the
 118         coff backend is swapping the bytes and twiddling the bits to
 119         translate the external form of the structures into the normal
 120         internal form. This is all performed in the
 121         @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
 122         elements are different sizes between different versions of
 123         coff; it is the duty of the coff version specific include file
 124         to override the definitions of various packing routines in
 125         @file{coffcode.h}. E.g., the size of line number entry in coff is
 126         sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
 127         @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
 128         correct one. No doubt, some day someone will find a version of
 129         coff which has a varying field size not catered to at the
 130         moment. To port BFD, that person will have to add more @code{#defines}.
 131         Three of the bit twiddling routines are exported to
 132         @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
 133         and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
 134         table on its own, but uses BFD to fix things up.  More of the
 135         bit twiddlers are exported for @code{gas};
 136         @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
 137         @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
 138         @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
 139         @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
 140         of all the symbol table and reloc drudgery itself, thereby
 141         saving the internal BFD overhead, but uses BFD to swap things
 142         on the way out, making cross ports much safer.  Doing so also
 143         allows BFD (and thus the linker) to use the same header files
 144         as @code{gas}, which makes one avenue to disaster disappear.
 145
 146 SUBSUBSECTION
 147         Symbol reading
 148
 149         The simple canonical form for symbols used by BFD is not rich
 150         enough to keep all the information available in a coff symbol
 151         table. The back end gets around this problem by keeping the original
 152         symbol table around, "behind the scenes".
 153
 154         When a symbol table is requested (through a call to
 155         @code{bfd_canonicalize_symtab}), a request gets through to
 156         @code{coff_get_normalized_symtab}. This reads the symbol table from
 157         the coff file and swaps all the structures inside into the
 158         internal form. It also fixes up all the pointers in the table
 159         (represented in the file by offsets from the first symbol in
 160         the table) into physical pointers to elements in the new
 161         internal table. This involves some work since the meanings of
 162         fields change depending upon context: a field that is a
 163         pointer to another structure in the symbol table at one moment
 164         may be the size in bytes of a structure at the next.  Another
 165         pass is made over the table. All symbols which mark file names
 166         (<<C_FILE>> symbols) are modified so that the internal
 167         string points to the value in the auxent (the real filename)
 168         rather than the normal text associated with the symbol
 169         (@code{".file"}).
 170
 171         At this time the symbol names are moved around. Coff stores
 172         all symbols less than nine characters long physically
 173         within the symbol table; longer strings are kept at the end of
 174         the file in the string  table. This pass moves all strings
 175         into memory and replaces them with pointers to the strings.
 176
 177
 178         The symbol table is massaged once again, this time to create
 179         the canonical table used by the BFD application. Each symbol
 180         is inspected in turn, and a decision made (using the
 181         @code{sclass} field) about the various flags to set in the
 182         @code{asymbol}.  @xref{Symbols}. The generated canonical table
 183         shares strings with the hidden internal symbol table.
 184
 185         Any linenumbers are read from the coff file too, and attached
 186         to the symbols which own the functions the linenumbers belong to.
 187
 188 SUBSUBSECTION
 189         Symbol writing
 190
 191         Writing a symbol to a coff file which didn't come from a coff
 192         file will lose any debugging information. The @code{asymbol}
 193         structure remembers the BFD from which the symbol was taken, and on
 194         output the back end makes sure that the same destination target as
 195         source target is present.
 196
 197         When the symbols have come from a coff file then all the
 198         debugging information is preserved.
 199
 200         Symbol tables are provided for writing to the back end in a
 201         vector of pointers to pointers. This allows applications like
 202         the linker to accumulate and output large symbol tables
 203         without having to do too much byte copying.
 204
 205         This function runs through the provided symbol table and
 206         patches each symbol marked as a file place holder
 207         (@code{C_FILE}) to point to the next file place holder in the
 208         list. It also marks each @code{offset} field in the list with
 209         the offset from the first symbol of the current symbol.
 210
 211         Another function of this procedure is to turn the canonical
 212         value form of BFD into the form used by coff. Internally, BFD
 213         expects symbol values to be offsets from a section base; so a
 214         symbol physically at 0x120, but in a section starting at
 215         0x100, would have the value 0x20. Coff expects symbols to
 216         contain their final value, so symbols have their values
 217         changed at this point to reflect their sum with their owning
 218         section.  This transformation uses the
 219         <<output_section>> field of the @code{asymbol}'s
 220         @code{asection} @xref{Sections}.
 221
 222         o <<coff_mangle_symbols>>
 223
 224         This routine runs though the provided symbol table and uses
 225         the offsets generated by the previous pass and the pointers
 226         generated when the symbol table was read in to create the
 227         structured hierachy required by coff. It changes each pointer
 228         to a symbol into the index into the symbol table of the asymbol.
 229
 230         o <<coff_write_symbols>>
 231
 232         This routine runs through the symbol table and patches up the
 233         symbols from their internal form into the coff way, calls the
 234         bit twiddlers, and writes out the table to the file.
 235
 236 */
 237
 238 /*
 239 INTERNAL_DEFINITION
 240         coff_symbol_type
 241
 242 DESCRIPTION
 243         The hidden information for an <<asymbol>> is described in a
 244         <<combined_entry_type>>:
 245
 246 CODE_FRAGMENT
 247 .
 248 .typedef struct coff_ptr_struct
 249 .{
 250 .
 251 .       {* Remembers the offset from the first symbol in the file for
 252 .          this symbol. Generated by coff_renumber_symbols. *}
 253 .unsigned int offset;
 254 .
 255 .       {* Should the value of this symbol be renumbered.  Used for
 256 .          XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
 257 .unsigned int fix_value : 1;
 258 .
 259 .       {* Should the tag field of this symbol be renumbered.
 260 .          Created by coff_pointerize_aux. *}
 261 .unsigned int fix_tag : 1;
 262 .
 263 .       {* Should the endidx field of this symbol be renumbered.
 264 .          Created by coff_pointerize_aux. *}
 265 .unsigned int fix_end : 1;
 266 .
 267 .       {* Should the x_csect.x_scnlen field be renumbered.
 268 .          Created by coff_slurp_symbol_table. *}
 269 .unsigned int fix_scnlen : 1;
 270 .
 271 .       {* The container for the symbol structure as read and translated
 272 .           from the file. *}
 273 .
 274 .union {
 275 .   union internal_auxent auxent;
 276 .   struct internal_syment syment;
 277 . } u;
 278 .} combined_entry_type;
 279 .
 280 .
 281 .{* Each canonical asymbol really looks like this: *}
 282 .
 283 .typedef struct coff_symbol_struct
 284 .{
 285 .   {* The actual symbol which the rest of BFD works with *}
 286 .asymbol symbol;
 287 .
 288 .   {* A pointer to the hidden information for this symbol *}
 289 .combined_entry_type *native;
 290 .
 291 .   {* A pointer to the linenumber information for this symbol *}
 292 .struct lineno_cache_entry *lineno;
 293 .
 294 .   {* Have the line numbers been relocated yet ? *}
 295 .boolean done_lineno;
 296 .} coff_symbol_type;
 297
 298
 299 */
 300
 301 #include "coffswap.h"
 302 \f
 303 /* void warning(); */
 304
 305 /*
 306  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 307  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 308  * NOTE: If you add to/change this routine, you should mirror the changes
 309  *      in styp_to_sec_flags().
 310  */
 311 static long
 312 sec_to_styp_flags (sec_name, sec_flags)
 313      CONST char *sec_name;
 314      flagword sec_flags;
 315 {
 316   long styp_flags = 0;
 317
 318   if (!strcmp (sec_name, _TEXT))
 319     {
 320       styp_flags = STYP_TEXT;
 321     }
 322   else if (!strcmp (sec_name, _DATA))
 323     {
 324       styp_flags = STYP_DATA;
 325 #ifdef TWO_DATA_SECS
 326     }
 327   else if (!strcmp (sec_name, ".data2"))
 328     {
 329       styp_flags = STYP_DATA;
 330 #endif /* TWO_DATA_SECS */
 331     }
 332   else if (!strcmp (sec_name, _BSS))
 333     {
 334       styp_flags = STYP_BSS;
 335 #ifdef _COMMENT
 336     }
 337   else if (!strcmp (sec_name, _COMMENT))
 338     {
 339       styp_flags = STYP_INFO;
 340 #endif /* _COMMENT */
 341 #ifdef _LIB
 342     }
 343   else if (!strcmp (sec_name, _LIB))
 344     {
 345       styp_flags = STYP_LIB;
 346 #endif /* _LIB */
 347 #ifdef _LIT
 348     }
 349   else if (!strcmp (sec_name, _LIT))
 350     {
 351       styp_flags = STYP_LIT;
 352 #endif /* _LIT */
 353     }
 354   else if (!strcmp (sec_name, ".debug"))
 355     {
 356 #ifdef STYP_DEBUG
 357       styp_flags = STYP_DEBUG;
 358 #else
 359       styp_flags = STYP_INFO;
 360 #endif
 361     }
 362   else if (!strcmp (sec_name, ".stab")
 363            || !strncmp (sec_name, ".stabstr", 8))
 364     {
 365       styp_flags = STYP_INFO;
 366     }
 367   /* Try and figure out what it should be */
 368   else if (sec_flags & SEC_CODE)
 369     {
 370       styp_flags = STYP_TEXT;
 371     }
 372   else if (sec_flags & SEC_DATA)
 373     {
 374       styp_flags = STYP_DATA;
 375     }
 376   else if (sec_flags & SEC_READONLY)
 377     {
 378 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 379       styp_flags = STYP_LIT;
 380 #else
 381       styp_flags = STYP_TEXT;
 382 #endif /* STYP_LIT */
 383     }
 384   else if (sec_flags & SEC_LOAD)
 385     {
 386       styp_flags = STYP_TEXT;
 387     }
 388   else if (sec_flags & SEC_ALLOC)
 389     {
 390       styp_flags = STYP_BSS;
 391     }
 392
 393 #ifdef STYP_NOLOAD
 394   if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
 395     styp_flags |= STYP_NOLOAD;
 396 #endif
 397
 398   return (styp_flags);
 399 }
 400 /*
 401  * Return a word with SEC_* flags set to represent the incoming
 402  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 403  * function is sec_to_styp_flags().
 404  * NOTE: If you add to/change this routine, you should mirror the changes
 405  *      in sec_to_styp_flags().
 406  */
 407 static flagword
 408 styp_to_sec_flags (abfd, hdr, name)
 409      bfd *abfd;
 410      PTR hdr;
 411      const char *name;
 412 {
 413   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 414   long styp_flags = internal_s->s_flags;
 415   flagword sec_flags = 0;
 416
 417 #ifdef STYP_NOLOAD
 418   if (styp_flags & STYP_NOLOAD)
 419     {
 420       sec_flags |= SEC_NEVER_LOAD;
 421     }
 422 #endif /* STYP_NOLOAD */
 423
 424   /* For 386 COFF, at least, an unloadable text or data section is
 425      actually a shared library section.  */
 426   if (styp_flags & STYP_TEXT)
 427     {
 428       if (sec_flags & SEC_NEVER_LOAD)
 429         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 430       else
 431         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 432     }
 433   else if (styp_flags & STYP_DATA)
 434     {
 435       if (sec_flags & SEC_NEVER_LOAD)
 436         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 437       else
 438         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 439     }
 440   else if (styp_flags & STYP_BSS)
 441     {
 442 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 443       if (sec_flags & SEC_NEVER_LOAD)
 444         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 445       else
 446 #endif
 447         sec_flags |= SEC_ALLOC;
 448     }
 449   else if (styp_flags & STYP_INFO)
 450     {
 451       /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
 452          defined.  coff_compute_section_file_positions uses
 453          COFF_PAGE_SIZE to ensure that the low order bits of the
 454          section VMA and the file offset match.  If we don't know
 455          COFF_PAGE_SIZE, we can't ensure the correct correspondence,
 456          and demand page loading of the file will fail.  */
 457 #ifdef COFF_PAGE_SIZE
 458       sec_flags |= SEC_DEBUGGING;
 459 #endif
 460     }
 461   else if (strcmp (name, _TEXT) == 0)
 462     {
 463       if (sec_flags & SEC_NEVER_LOAD)
 464         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 465       else
 466         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 467     }
 468   else if (strcmp (name, _DATA) == 0
 469 #ifdef TWO_DATA_SECS
 470            || strcmp (name, ".data2") == 0
 471 #endif
 472            )
 473     {
 474       if (sec_flags & SEC_NEVER_LOAD)
 475         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 476       else
 477         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 478     }
 479   else if (strcmp (name, _BSS) == 0)
 480     {
 481 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 482       if (sec_flags & SEC_NEVER_LOAD)
 483         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 484       else
 485 #endif
 486         sec_flags |= SEC_ALLOC;
 487     }
 488   else if (strcmp (name, ".debug") == 0
 489 #ifdef _COMMENT
 490            || strcmp (name, _COMMENT) == 0
 491 #endif
 492            || strcmp (name, ".stab") == 0
 493            || strcmp (name, ".stabstr") == 0)
 494     {
 495 #ifdef COFF_PAGE_SIZE
 496       sec_flags |= SEC_DEBUGGING;
 497 #endif
 498     }
 499 #ifdef _LIB
 500   else if (strcmp (name, _LIB) == 0)
 501     ;
 502 #endif
 503 #ifdef _LIT
 504   else if (strcmp (name, _LIT) == 0)
 505     {
 506       sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
 507     }
 508 #endif
 509   else
 510     {
 511       sec_flags |= SEC_ALLOC | SEC_LOAD;
 512     }
 513
 514 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 515   if ((styp_flags & STYP_LIT) == STYP_LIT)
 516     {
 517       sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 518     }
 519 #endif /* STYP_LIT */
 520 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 521   if (styp_flags & STYP_OTHER_LOAD)
 522     {
 523       sec_flags = (SEC_LOAD | SEC_ALLOC);
 524     }
 525 #endif /* STYP_SDATA */
 526
 527   return (sec_flags);
 528 }
 529
 530 #define get_index(symbol)       ((long) (symbol)->udata)
 531
 532 /*
 533 INTERNAL_DEFINITION
 534         bfd_coff_backend_data
 535
 536 CODE_FRAGMENT
 537
 538 Special entry points for gdb to swap in coff symbol table parts:
 539 .typedef struct
 540 .{
 541 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 542 .       bfd            *abfd,
 543 .       PTR             ext,
 544 .       int             type,
 545 .       int             class,
 546 .       int             indaux,
 547 .       int             numaux,
 548 .       PTR             in));
 549 .
 550 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 551 .       bfd            *abfd ,
 552 .       PTR             ext,
 553 .       PTR             in));
 554 .
 555 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 556 .       bfd            *abfd,
 557 .       PTR            ext,
 558 .       PTR             in));
 559 .
 560
 561 Special entry points for gas to swap out coff parts:
 562
 563 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 564 .       bfd     *abfd,
 565 .       PTR     in,
 566 .       int     type,
 567 .       int     class,
 568 .       int     indaux,
 569 .       int     numaux,
 570 .       PTR     ext));
 571 .
 572 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 573 .      bfd      *abfd,
 574 .      PTR      in,
 575 .      PTR      ext));
 576 .
 577 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 578 .       bfd     *abfd,
 579 .       PTR     in,
 580 .       PTR     ext));
 581 .
 582 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 583 .       bfd     *abfd,
 584 .       PTR     src,
 585 .       PTR     dst));
 586 .
 587 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 588 .       bfd     *abfd,
 589 .       PTR     in,
 590 .       PTR     out));
 591 .
 592 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 593 .       bfd     *abfd,
 594 .       PTR     in,
 595 .       PTR     out));
 596 .
 597 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 598 .       bfd     *abfd,
 599 .       PTR     in,
 600 .       PTR     out));
 601 .
 602
 603 Special entry points for generic COFF routines to call target
 604 dependent COFF routines:
 605
 606 . unsigned int _bfd_filhsz;
 607 . unsigned int _bfd_aoutsz;
 608 . unsigned int _bfd_scnhsz;
 609 . unsigned int _bfd_symesz;
 610 . unsigned int _bfd_auxesz;
 611 . unsigned int _bfd_relsz;
 612 . unsigned int _bfd_linesz;
 613 . boolean _bfd_coff_long_filenames;
 614 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 615 .       bfd     *abfd,
 616 .       PTR     ext,
 617 .       PTR     in));
 618 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 619 .       bfd     *abfd,
 620 .       PTR     ext,
 621 .       PTR     in));
 622 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 623 .       bfd     *abfd,
 624 .       PTR     ext,
 625 .       PTR     in));
 626 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
 627 .       bfd     *abfd,
 628 .       PTR     ext,
 629 .       PTR     in));
 630 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 631 .       bfd     *abfd,
 632 .       PTR     internal_filehdr));
 633 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 634 .       bfd     *abfd,
 635 .       PTR     internal_filehdr));
 636 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 637 .       bfd     *abfd,
 638 .       PTR     internal_filehdr,
 639 .       PTR     internal_aouthdr));
 640 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 641 .       bfd     *abfd,
 642 .       PTR     internal_scnhdr,
 643 .       const char *name));
 644 . asection *(*_bfd_make_section_hook) PARAMS ((
 645 .       bfd     *abfd,
 646 .       char    *name));
 647 . void (*_bfd_set_alignment_hook) PARAMS ((
 648 .       bfd     *abfd,
 649 .       asection *sec,
 650 .       PTR     internal_scnhdr));
 651 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 652 .       bfd     *abfd));
 653 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 654 .       bfd     *abfd,
 655 .       struct internal_syment *sym));
 656 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 657 .       bfd     *abfd,
 658 .       struct bfd_link_info *link_info,
 659 .       struct bfd_link_order *link_order,
 660 .       arelent *reloc,
 661 .       bfd_byte *data,
 662 .       unsigned int *src_ptr,
 663 .       unsigned int *dst_ptr));
 664 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
 665 .       bfd *abfd,
 666 .       asection *input_section,
 667 .       arelent *r,
 668 .       unsigned int shrink,
 669 .       struct bfd_link_info *link_info));
 670 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
 671 .       bfd *abfd,
 672 .       struct internal_syment *));
 673 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
 674 .       bfd *abfd));
 675 . boolean (*_bfd_coff_relocate_section) PARAMS ((
 676 .       bfd *output_bfd,
 677 .       struct bfd_link_info *info,
 678 .       bfd *input_bfd,
 679 .       asection *input_section,
 680 .       bfd_byte *contents,
 681 .       struct internal_reloc *relocs,
 682 .       struct internal_syment *syms,
 683 .       asection **sections));
 684 .
 685 .} bfd_coff_backend_data;
 686 .
 687 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 688 .
 689 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
 690 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
 691 .
 692 .#define bfd_coff_swap_sym_in(a,e,i) \
 693 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 694 .
 695 .#define bfd_coff_swap_lineno_in(a,e,i) \
 696 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 697 .
 698 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 699 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 700 .
 701 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 702 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 703 .
 704 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
 705 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
 706 .
 707 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 708 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 709 .
 710 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 711 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 712 .
 713 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 714 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 715 .
 716 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 717 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 718 .
 719 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 720 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 721 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 722 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 723 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 724 .#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
 725 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 726 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 727 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 728 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 729 .
 730 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 731 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 732 .
 733 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 734 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 735 .
 736 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
 737 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
 738 .
 739 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 740 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 741 .
 742 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 743 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 744 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
 745 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
 746 .
 747 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
 748 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
 749 .
 750 .#define bfd_coff_make_section_hook(abfd, name)\
 751 .        ((coff_backend_info (abfd)->_bfd_make_section_hook) (abfd, name))
 752 .
 753 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 754 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 755 .
 756 .#define bfd_coff_slurp_symbol_table(abfd)\
 757 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 758 .
 759 .#define bfd_coff_symname_in_debug(abfd, sym)\
 760 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 761 .
 762 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
 763 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 764 .         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
 765 .
 766 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
 767 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 768 .         (abfd, section, reloc, shrink, link_info))
 769 .
 770 .#define bfd_coff_sym_is_global(abfd, sym)\
 771 .        ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
 772 .         (abfd, sym))
 773 .
 774 .#define bfd_coff_compute_section_file_positions(abfd)\
 775 .        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
 776 .         (abfd))
 777 .
 778 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
 779 .        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
 780 .         (obfd, info, ibfd, o, con, rel, isyms, secs))
 781 .
 782 */
 783
 784 /* See whether the magic number matches.  */
 785
 786 static boolean
 787 coff_bad_format_hook (abfd, filehdr)
 788      bfd * abfd;
 789      PTR filehdr;
 790 {
 791   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 792
 793   if (BADMAG (*internal_f))
 794     return false;
 795
 796   /* if the optional header is NULL or not the correct size then
 797      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
 798      and Intel 960 readwrite headers (I960WRMAGIC) is that the
 799      optional header is of a different size.
 800
 801      But the mips keeps extra stuff in it's opthdr, so dont check
 802      when doing that
 803      */
 804
 805 #if defined(M88) || defined(I960)
 806   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
 807     return false;
 808 #endif
 809
 810   return true;
 811 }
 812
 813 static asection *
 814 coff_make_section_hook (abfd, name)
 815      bfd * abfd;
 816      char *name;
 817 {
 818 #ifdef TWO_DATA_SECS
 819   /* FIXME: This predates the call to bfd_make_section_anyway
 820      in make_a_section_from_file, and can probably go away.  */
 821   /* On SCO a file created by the Microsoft assembler can have two
 822      .data sections.  We use .data2 for the second one.  */
 823   if (strcmp (name, _DATA) == 0)
 824     return bfd_make_section (abfd, ".data2");
 825 #endif
 826   return (asection *) NULL;
 827 }
 828
 829 /*
 830    initialize a section structure with information peculiar to this
 831    particular implementation of coff
 832 */
 833
 834 static boolean
 835 coff_new_section_hook (abfd, section)
 836      bfd * abfd;
 837      asection * section;
 838 {
 839   section->alignment_power = abfd->xvec->align_power_min;
 840   /* Allocate aux records for section symbols, to store size and
 841      related info.
 842
 843      @@ Shouldn't use constant multiplier here!  */
 844   coffsymbol (section->symbol)->native =
 845     (combined_entry_type *) bfd_zalloc (abfd,
 846                                         sizeof (combined_entry_type) * 10);
 847
 848 #ifdef COFF_SPARC
 849   /* This is to allow double-word operations on addresses in data or bss. */
 850   if (strcmp (section->name, ".data") == 0
 851       || strcmp (section->name, ".bss") == 0)
 852     section->alignment_power = 3;
 853 #endif /* COFF_SPARC */
 854
 855   return true;
 856 }
 857
 858
 859 #ifdef I960
 860
 861 /* Set the alignment of a BFD section.  */
 862
 863 static void
 864 coff_set_alignment_hook (abfd, section, scnhdr)
 865      bfd * abfd;
 866      asection * section;
 867      PTR scnhdr;
 868 {
 869   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 870   unsigned int i;
 871
 872   for (i = 0; i < 32; i++)
 873     if ((1 << i) >= hdr->s_align)
 874       break;
 875   section->alignment_power = i;
 876 }
 877
 878 #else /* ! I960 */
 879
 880 #define coff_set_alignment_hook \
 881   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
 882
 883 #endif /* ! I960 */
 884
 885 static boolean
 886 coff_mkobject (abfd)
 887      bfd * abfd;
 888 {
 889   coff_data_type *coff;
 890
 891   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
 892   if (abfd->tdata.coff_obj_data == 0)
 893     {
 894       bfd_set_error (bfd_error_no_memory);
 895       return false;
 896     }
 897   coff = coff_data (abfd);
 898   coff->symbols = (coff_symbol_type *) NULL;
 899   coff->conversion_table = (unsigned int *) NULL;
 900   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 901   coff->relocbase = 0;
 902 /*  make_abs_section(abfd);*/
 903   return true;
 904 }
 905
 906 /* Create the COFF backend specific information.  */
 907
 908 static PTR
 909 coff_mkobject_hook (abfd, filehdr, aouthdr)
 910      bfd * abfd;
 911      PTR filehdr;
 912      PTR aouthdr;
 913 {
 914   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 915   coff_data_type *coff;
 916
 917   if (coff_mkobject (abfd) == false)
 918     return NULL;
 919
 920   coff = coff_data (abfd);
 921
 922   coff->sym_filepos = internal_f->f_symptr;
 923
 924   /* These members communicate important constants about the symbol
 925      table to GDB's symbol-reading code.  These `constants'
 926      unfortunately vary among coff implementations...  */
 927   coff->local_n_btmask = N_BTMASK;
 928   coff->local_n_btshft = N_BTSHFT;
 929   coff->local_n_tmask = N_TMASK;
 930   coff->local_n_tshift = N_TSHIFT;
 931   coff->local_symesz = SYMESZ;
 932   coff->local_auxesz = AUXESZ;
 933   coff->local_linesz = LINESZ;
 934
 935   obj_raw_syment_count (abfd) =
 936     obj_conv_table_size (abfd) =
 937       internal_f->f_nsyms;
 938
 939   return (PTR) coff;
 940 }
 941
 942 /* Determine the machine architecture and type.  FIXME: This is target
 943    dependent because the magic numbers are defined in the target
 944    dependent header files.  But there is no particular need for this.
 945    If the magic numbers were moved to a separate file, this function
 946    would be target independent and would also be much more successful
 947    at linking together COFF files for different architectures.  */
 948
 949 static boolean
 950 coff_set_arch_mach_hook (abfd, filehdr)
 951      bfd *abfd;
 952      PTR filehdr;
 953 {
 954   long machine;
 955   enum bfd_architecture arch;
 956   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 957
 958   machine = 0;
 959   switch (internal_f->f_magic)
 960     {
 961 #ifdef I386MAGIC
 962     case I386MAGIC:
 963     case I386PTXMAGIC:
 964     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
 965     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
 966       arch = bfd_arch_i386;
 967       machine = 0;
 968       break;
 969 #endif
 970
 971 #ifdef A29K_MAGIC_BIG
 972     case A29K_MAGIC_BIG:
 973     case A29K_MAGIC_LITTLE:
 974       arch = bfd_arch_a29k;
 975       machine = 0;
 976       break;
 977 #endif
 978
 979 #ifdef MC68MAGIC
 980     case MC68MAGIC:
 981     case M68MAGIC:
 982 #ifdef MC68KBCSMAGIC
 983     case MC68KBCSMAGIC:
 984 #endif
 985 #ifdef APOLLOM68KMAGIC
 986     case APOLLOM68KMAGIC:
 987 #endif
 988 #ifdef LYNXCOFFMAGIC
 989     case LYNXCOFFMAGIC:
 990 #endif
 991       arch = bfd_arch_m68k;
 992       machine = 68020;
 993       break;
 994 #endif
 995 #ifdef MC88MAGIC
 996     case MC88MAGIC:
 997     case MC88DMAGIC:
 998     case MC88OMAGIC:
 999       arch = bfd_arch_m88k;
1000       machine = 88100;
1001       break;
1002 #endif
1003 #ifdef Z8KMAGIC
1004     case Z8KMAGIC:
1005       arch = bfd_arch_z8k;
1006       switch (internal_f->f_flags & F_MACHMASK)
1007         {
1008         case F_Z8001:
1009           machine = bfd_mach_z8001;
1010           break;
1011         case F_Z8002:
1012           machine = bfd_mach_z8002;
1013           break;
1014         default:
1015           return false;
1016         }
1017       break;
1018 #endif
1019 #ifdef I960
1020 #ifdef I960ROMAGIC
1021     case I960ROMAGIC:
1022     case I960RWMAGIC:
1023       arch = bfd_arch_i960;
1024       switch (F_I960TYPE & internal_f->f_flags)
1025         {
1026         default:
1027         case F_I960CORE:
1028           machine = bfd_mach_i960_core;
1029           break;
1030         case F_I960KB:
1031           machine = bfd_mach_i960_kb_sb;
1032           break;
1033         case F_I960MC:
1034           machine = bfd_mach_i960_mc;
1035           break;
1036         case F_I960XA:
1037           machine = bfd_mach_i960_xa;
1038           break;
1039         case F_I960CA:
1040           machine = bfd_mach_i960_ca;
1041           break;
1042         case F_I960KA:
1043           machine = bfd_mach_i960_ka_sa;
1044           break;
1045           /* start-sanitize-i960xl */
1046         case F_I960XL:
1047           machine = bfd_mach_i960_xl;
1048           break;
1049           /* end-sanitize-i960xl */
1050         }
1051       break;
1052 #endif
1053 #endif
1054
1055 #ifdef U802ROMAGIC
1056     case U802ROMAGIC:
1057     case U802WRMAGIC:
1058     case U802TOCMAGIC:
1059       arch = bfd_arch_rs6000;
1060       machine = 6000;
1061       break;
1062 #endif
1063
1064 #ifdef WE32KMAGIC
1065     case WE32KMAGIC:
1066       arch = bfd_arch_we32k;
1067       machine = 0;
1068       break;
1069 #endif
1070
1071 #ifdef H8300MAGIC
1072     case H8300MAGIC:
1073       arch = bfd_arch_h8300;
1074       machine = bfd_mach_h8300;
1075       /* !! FIXME this probably isn't the right place for this */
1076       abfd->flags |= BFD_IS_RELAXABLE;
1077       break;
1078 #endif
1079
1080 #ifdef H8300HMAGIC
1081     case H8300HMAGIC:
1082       arch = bfd_arch_h8300;
1083       machine = bfd_mach_h8300h;
1084       /* !! FIXME this probably isn't the right place for this */
1085       abfd->flags |= BFD_IS_RELAXABLE;
1086       break;
1087 #endif
1088
1089 #ifdef SH_ARCH_MAGIC
1090     case SH_ARCH_MAGIC:
1091       arch = bfd_arch_sh;
1092       machine = 0;
1093       break;
1094 #endif
1095
1096 #ifdef H8500MAGIC
1097     case H8500MAGIC:
1098       arch = bfd_arch_h8500;
1099       machine = 0;
1100       break;
1101 #endif
1102
1103 #ifdef SPARCMAGIC
1104     case SPARCMAGIC:
1105 #ifdef LYNXCOFFMAGIC
1106     case LYNXCOFFMAGIC:
1107 #endif
1108       arch = bfd_arch_sparc;
1109       machine = 0;
1110       break;
1111 #endif
1112
1113     default:                    /* Unreadable input file type */
1114       arch = bfd_arch_obscure;
1115       break;
1116     }
1117
1118   bfd_default_set_arch_mach (abfd, arch, machine);
1119   return true;
1120 }
1121
1122 #ifdef SYMNAME_IN_DEBUG
1123
1124 static boolean
1125 symname_in_debug_hook (abfd, sym)
1126      bfd * abfd;
1127      struct internal_syment *sym;
1128 {
1129   return SYMNAME_IN_DEBUG (sym) ? true : false;
1130 }
1131
1132 #else
1133
1134 #define symname_in_debug_hook \
1135   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1136
1137 #endif
1138
1139 /*
1140 SUBSUBSECTION
1141         Writing relocations
1142
1143         To write relocations, the back end steps though the
1144         canonical relocation table and create an
1145         @code{internal_reloc}. The symbol index to use is removed from
1146         the @code{offset} field in the symbol table supplied.  The
1147         address comes directly from the sum of the section base
1148         address and the relocation offset; the type is dug directly
1149         from the howto field.  Then the @code{internal_reloc} is
1150         swapped into the shape of an @code{external_reloc} and written
1151         out to disk.
1152
1153 */
1154
1155 static boolean
1156 coff_write_relocs (abfd)
1157      bfd * abfd;
1158 {
1159   asection *s;
1160   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1161     {
1162       unsigned int i;
1163       struct external_reloc dst;
1164
1165       arelent **p = s->orelocation;
1166       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1167         return false;
1168       for (i = 0; i < s->reloc_count; i++)
1169         {
1170           struct internal_reloc n;
1171           arelent *q = p[i];
1172           memset ((PTR) & n, 0, sizeof (n));
1173
1174           n.r_vaddr = q->address + s->vma;
1175
1176 #ifdef R_IHCONST
1177           /* The 29k const/consth reloc pair is a real kludge.  The consth
1178          part doesn't have a symbol; it has an offset.  So rebuilt
1179          that here.  */
1180           if (q->howto->type == R_IHCONST)
1181             n.r_symndx = q->addend;
1182           else
1183 #endif
1184           if (q->sym_ptr_ptr)
1185             {
1186               if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1187                 /* This is a relocation relative to the absolute symbol.  */
1188                 n.r_symndx = -1;
1189               else
1190                 {
1191                   n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1192                   /* Take notice if the symbol reloc points to a symbol
1193                    we don't have in our symbol table.  What should we
1194                    do for this??  */
1195                   if (n.r_symndx > obj_conv_table_size (abfd))
1196                     abort ();
1197                 }
1198             }
1199
1200 #ifdef SWAP_OUT_RELOC_OFFSET
1201           n.r_offset = q->addend;
1202 #endif
1203
1204 #ifdef SELECT_RELOC
1205           /* Work out reloc type from what is required */
1206           SELECT_RELOC (n, q->howto);
1207 #else
1208           n.r_type = q->howto->type;
1209 #endif
1210           coff_swap_reloc_out (abfd, &n, &dst);
1211           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1212             return false;
1213         }
1214     }
1215
1216   return true;
1217 }
1218
1219 /* Set flags and magic number of a coff file from architecture and machine
1220    type.  Result is true if we can represent the arch&type, false if not.  */
1221
1222 static boolean
1223 coff_set_flags (abfd, magicp, flagsp)
1224      bfd * abfd;
1225      unsigned *magicp;
1226      unsigned short *flagsp;
1227 {
1228   switch (bfd_get_arch (abfd))
1229     {
1230 #ifdef Z8KMAGIC
1231     case bfd_arch_z8k:
1232       *magicp = Z8KMAGIC;
1233       switch (bfd_get_mach (abfd))
1234         {
1235         case bfd_mach_z8001:
1236           *flagsp = F_Z8001;
1237           break;
1238         case bfd_mach_z8002:
1239           *flagsp = F_Z8002;
1240           break;
1241         default:
1242           return false;
1243         }
1244       return true;
1245 #endif
1246 #ifdef I960ROMAGIC
1247
1248     case bfd_arch_i960:
1249
1250       {
1251         unsigned flags;
1252         *magicp = I960ROMAGIC;
1253         /*
1254           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1255           I960RWMAGIC);   FIXME???
1256           */
1257         switch (bfd_get_mach (abfd))
1258           {
1259           case bfd_mach_i960_core:
1260             flags = F_I960CORE;
1261             break;
1262           case bfd_mach_i960_kb_sb:
1263             flags = F_I960KB;
1264             break;
1265           case bfd_mach_i960_mc:
1266             flags = F_I960MC;
1267             break;
1268           case bfd_mach_i960_xa:
1269             flags = F_I960XA;
1270             break;
1271           case bfd_mach_i960_ca:
1272             flags = F_I960CA;
1273             break;
1274           case bfd_mach_i960_ka_sa:
1275             flags = F_I960KA;
1276             break;
1277             /* start-sanitize-i960xl */
1278           case bfd_mach_i960_xl:
1279             flags = F_I960XL;
1280             break;
1281             /* end-sanitize-i960xl */
1282           default:
1283             return false;
1284           }
1285         *flagsp = flags;
1286         return true;
1287       }
1288       break;
1289 #endif
1290 #ifdef I386MAGIC
1291     case bfd_arch_i386:
1292       *magicp = I386MAGIC;
1293 #ifdef LYNXOS
1294       /* Just overwrite the usual value if we're doing Lynx. */
1295       *magicp = LYNXCOFFMAGIC;
1296 #endif
1297       return true;
1298       break;
1299 #endif
1300 #ifdef MC68MAGIC
1301     case bfd_arch_m68k:
1302 #ifdef APOLLOM68KMAGIC
1303       *magicp = APOLLO_COFF_VERSION_NUMBER;
1304 #else
1305       *magicp = MC68MAGIC;
1306 #endif
1307 #ifdef LYNXOS
1308       /* Just overwrite the usual value if we're doing Lynx. */
1309       *magicp = LYNXCOFFMAGIC;
1310 #endif
1311       return true;
1312       break;
1313 #endif
1314
1315 #ifdef MC88MAGIC
1316     case bfd_arch_m88k:
1317       *magicp = MC88OMAGIC;
1318       return true;
1319       break;
1320 #endif
1321 #ifdef H8300MAGIC
1322     case bfd_arch_h8300:
1323       switch (bfd_get_mach (abfd))
1324         {
1325         case bfd_mach_h8300:
1326           *magicp = H8300MAGIC;
1327           return true;
1328         case bfd_mach_h8300h:
1329           *magicp = H8300HMAGIC;
1330           return true;
1331         }
1332       break;
1333 #endif
1334
1335 #ifdef SH_ARCH_MAGIC
1336     case bfd_arch_sh:
1337       *magicp = SH_ARCH_MAGIC;
1338       return true;
1339       break;
1340 #endif
1341
1342 #ifdef SPARCMAGIC
1343     case bfd_arch_sparc:
1344       *magicp = SPARCMAGIC;
1345 #ifdef LYNXOS
1346       /* Just overwrite the usual value if we're doing Lynx. */
1347       *magicp = LYNXCOFFMAGIC;
1348 #endif
1349       return true;
1350       break;
1351 #endif
1352
1353 #ifdef H8500MAGIC
1354     case bfd_arch_h8500:
1355       *magicp = H8500MAGIC;
1356       return true;
1357       break;
1358 #endif
1359 #ifdef A29K_MAGIC_BIG
1360     case bfd_arch_a29k:
1361       if (abfd->xvec->byteorder_big_p)
1362         *magicp = A29K_MAGIC_BIG;
1363       else
1364         *magicp = A29K_MAGIC_LITTLE;
1365       return true;
1366       break;
1367 #endif
1368
1369 #ifdef WE32KMAGIC
1370     case bfd_arch_we32k:
1371       *magicp = WE32KMAGIC;
1372       return true;
1373       break;
1374 #endif
1375
1376 #ifdef U802TOCMAGIC
1377     case bfd_arch_rs6000:
1378     case bfd_arch_powerpc:
1379       *magicp = U802TOCMAGIC;
1380       return true;
1381       break;
1382 #endif
1383
1384     default:                    /* Unknown architecture */
1385       /* return false;  -- fall through to "return false" below, to avoid
1386        "statement never reached" errors on the one below. */
1387       break;
1388     }
1389
1390   return false;
1391 }
1392
1393
1394 static boolean
1395 coff_set_arch_mach (abfd, arch, machine)
1396      bfd * abfd;
1397      enum bfd_architecture arch;
1398      unsigned long machine;
1399 {
1400   unsigned dummy1;
1401   unsigned short dummy2;
1402
1403   if (! bfd_default_set_arch_mach (abfd, arch, machine))
1404     return false;
1405
1406   if (arch != bfd_arch_unknown &&
1407       coff_set_flags (abfd, &dummy1, &dummy2) != true)
1408     return false;               /* We can't represent this type */
1409
1410   return true;                  /* We're easy ... */
1411 }
1412
1413
1414 /* Calculate the file position for each section. */
1415
1416 static void
1417 coff_compute_section_file_positions (abfd)
1418      bfd * abfd;
1419 {
1420   asection *current;
1421   asection *previous = (asection *) NULL;
1422   file_ptr sofar = FILHSZ;
1423 #ifndef I960
1424   file_ptr old_sofar;
1425 #endif
1426   unsigned int count;
1427
1428   if (bfd_get_start_address (abfd))
1429     {
1430       /*  A start address may have been added to the original file. In this
1431         case it will need an optional header to record it.  */
1432       abfd->flags |= EXEC_P;
1433     }
1434
1435   if (abfd->flags & EXEC_P)
1436     sofar += AOUTSZ;
1437
1438   sofar += abfd->section_count * SCNHSZ;
1439   for (current = abfd->sections, count = 1;
1440        current != (asection *) NULL;
1441        current = current->next, ++count)
1442     {
1443       current->target_index = count;
1444
1445       /* Only deal with sections which have contents */
1446       if (!(current->flags & SEC_HAS_CONTENTS))
1447         continue;
1448
1449       /* Align the sections in the file to the same boundary on
1450          which they are aligned in virtual memory.  I960 doesn't
1451          do this (FIXME) so we can stay in sync with Intel.  960
1452          doesn't yet page from files... */
1453 #ifndef I960
1454       {
1455         /* make sure this section is aligned on the right boundary - by
1456          padding the previous section up if necessary */
1457
1458         old_sofar = sofar;
1459         sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1460         if (previous != (asection *) NULL)
1461           {
1462             previous->_raw_size += sofar - old_sofar;
1463           }
1464       }
1465
1466 #endif
1467
1468 #ifdef COFF_PAGE_SIZE
1469       /* In demand paged files the low order bits of the file offset
1470          must match the low order bits of the virtual address.  */
1471       if ((abfd->flags & D_PAGED) != 0
1472           && (current->flags & SEC_ALLOC) != 0)
1473         sofar += (current->vma - sofar) % COFF_PAGE_SIZE;
1474 #endif
1475
1476       current->filepos = sofar;
1477
1478       sofar += current->_raw_size;
1479 #ifndef I960
1480       /* make sure that this section is of the right size too */
1481       old_sofar = sofar;
1482       sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1483       current->_raw_size += sofar - old_sofar;
1484 #endif
1485
1486 #ifdef _LIB
1487       /* Force .lib sections to start at zero.  The vma is then
1488          incremented in coff_set_section_contents.  This is right for
1489          SVR3.2.  */
1490       if (strcmp (current->name, _LIB) == 0)
1491         bfd_set_section_vma (abfd, current, 0);
1492 #endif
1493
1494       previous = current;
1495     }
1496   obj_relocbase (abfd) = sofar;
1497   abfd->output_has_begun = true;
1498 }
1499
1500 #ifndef RS6000COFF_C
1501
1502 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1503 /* @@ Should we only be adding missing symbols, or overriding the aux
1504    values for existing section symbols?  */
1505 static boolean
1506 coff_add_missing_symbols (abfd)
1507      bfd *abfd;
1508 {
1509   unsigned int nsyms = bfd_get_symcount (abfd);
1510   asymbol **sympp = abfd->outsymbols;
1511   asymbol **sympp2;
1512   unsigned int i;
1513   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1514
1515   for (i = 0; i < nsyms; i++)
1516     {
1517       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1518       CONST char *name;
1519       if (csym)
1520         {
1521           /* only do this if there is a coff representation of the input
1522            symbol */
1523           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1524             {
1525               need_file = 0;
1526               continue;
1527             }
1528           name = csym->symbol.name;
1529           if (!name)
1530             continue;
1531           if (!strcmp (name, _TEXT))
1532             need_text = 0;
1533 #ifdef APOLLO_M68
1534           else if (!strcmp (name, ".wtext"))
1535             need_text = 0;
1536 #endif
1537           else if (!strcmp (name, _DATA))
1538             need_data = 0;
1539           else if (!strcmp (name, _BSS))
1540             need_bss = 0;
1541         }
1542     }
1543   /* Now i == bfd_get_symcount (abfd).  */
1544   /* @@ For now, don't deal with .file symbol.  */
1545   need_file = 0;
1546
1547   if (!need_text && !need_data && !need_bss && !need_file)
1548     return true;
1549   nsyms += need_text + need_data + need_bss + need_file;
1550   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1551   if (!sympp2)
1552     {
1553       bfd_set_error (bfd_error_no_memory);
1554       return false;
1555     }
1556   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1557   if (need_file)
1558     {
1559       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1560       abort ();
1561     }
1562   if (need_text)
1563     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1564   if (need_data)
1565     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1566   if (need_bss)
1567     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1568   BFD_ASSERT (i == nsyms);
1569   bfd_set_symtab (abfd, sympp2, nsyms);
1570   return true;
1571 }
1572
1573 #endif /* ! defined (RS6000COFF_C) */
1574
1575 /* SUPPRESS 558 */
1576 /* SUPPRESS 529 */
1577 static boolean
1578 coff_write_object_contents (abfd)
1579      bfd * abfd;
1580 {
1581   asection *current;
1582   boolean hasrelocs = false;
1583   boolean haslinno = false;
1584   file_ptr reloc_base;
1585   file_ptr lineno_base;
1586   file_ptr sym_base;
1587   unsigned long reloc_size = 0;
1588   unsigned long lnno_size = 0;
1589   asection *text_sec = NULL;
1590   asection *data_sec = NULL;
1591   asection *bss_sec = NULL;
1592
1593   struct internal_filehdr internal_f;
1594   struct internal_aouthdr internal_a;
1595
1596
1597   bfd_set_error (bfd_error_system_call);
1598
1599   if (abfd->output_has_begun == false)
1600     coff_compute_section_file_positions (abfd);
1601
1602   reloc_base = obj_relocbase (abfd);
1603
1604   /* Make a pass through the symbol table to count line number entries and
1605      put them into the correct asections */
1606
1607   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
1608
1609   /* Work out the size of the reloc and linno areas */
1610
1611   for (current = abfd->sections; current != NULL; current =
1612        current->next)
1613     reloc_size += current->reloc_count * RELSZ;
1614
1615   lineno_base = reloc_base + reloc_size;
1616   sym_base = lineno_base + lnno_size;
1617
1618   /* Indicate in each section->line_filepos its actual file address */
1619   for (current = abfd->sections; current != NULL; current =
1620        current->next)
1621     {
1622       if (current->lineno_count)
1623         {
1624           current->line_filepos = lineno_base;
1625           current->moving_line_filepos = lineno_base;
1626           lineno_base += current->lineno_count * LINESZ;
1627         }
1628       else
1629         {
1630           current->line_filepos = 0;
1631         }
1632       if (current->reloc_count)
1633         {
1634           current->rel_filepos = reloc_base;
1635           reloc_base += current->reloc_count * RELSZ;
1636         }
1637       else
1638         {
1639           current->rel_filepos = 0;
1640         }
1641     }
1642
1643   /* Write section headers to the file.  */
1644   internal_f.f_nscns = 0;
1645   if (bfd_seek (abfd,
1646                 (file_ptr) ((abfd->flags & EXEC_P) ?
1647                             (FILHSZ + AOUTSZ) : FILHSZ),
1648                 SEEK_SET)
1649       != 0)
1650     return false;
1651
1652   {
1653     for (current = abfd->sections;
1654          current != NULL;
1655          current = current->next)
1656       {
1657         struct internal_scnhdr section;
1658
1659         internal_f.f_nscns++;
1660         strncpy (&(section.s_name[0]), current->name, 8);
1661 #ifdef _LIB
1662         /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
1663            Ian Taylor <ian@cygnus.com>.  */
1664         if (strcmp (current->name, _LIB) == 0)
1665           section.s_vaddr = 0;
1666         else
1667 #endif
1668           section.s_vaddr = current->lma;
1669         section.s_paddr = current->lma;
1670         section.s_size = current->_raw_size;
1671         /*
1672            If this section has no size or is unloadable then the scnptr
1673            will be 0 too
1674            */
1675         if (current->_raw_size == 0 ||
1676             (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1677           {
1678             section.s_scnptr = 0;
1679           }
1680         else
1681           {
1682             section.s_scnptr = current->filepos;
1683           }
1684         section.s_relptr = current->rel_filepos;
1685         section.s_lnnoptr = current->line_filepos;
1686         section.s_nreloc = current->reloc_count;
1687         section.s_nlnno = current->lineno_count;
1688         if (current->reloc_count != 0)
1689           hasrelocs = true;
1690         if (current->lineno_count != 0)
1691           haslinno = true;
1692
1693         section.s_flags = sec_to_styp_flags (current->name, current->flags);
1694
1695         if (!strcmp (current->name, _TEXT))
1696           {
1697             text_sec = current;
1698           }
1699         else if (!strcmp (current->name, _DATA))
1700           {
1701             data_sec = current;
1702 #ifdef TWO_DATA_SECS
1703           }
1704         else if (!strcmp (current->name, ".data2"))
1705           {
1706             data_sec = current;
1707 #endif /* TWO_DATA_SECS */
1708           }
1709         else if (!strcmp (current->name, _BSS))
1710           {
1711             bss_sec = current;
1712           }
1713
1714 #ifdef I960
1715         section.s_align = (current->alignment_power
1716                            ? 1 << current->alignment_power
1717                            : 0);
1718
1719 #endif
1720         {
1721           SCNHDR buff;
1722
1723           coff_swap_scnhdr_out (abfd, &section, &buff);
1724           if (bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
1725             return false;
1726
1727         }
1728       }
1729   }
1730
1731
1732   /* OK, now set up the filehdr... */
1733
1734   /* Don't include the internal abs section in the section count */
1735
1736   /*
1737     We will NOT put a fucking timestamp in the header here. Every time you
1738     put it back, I will come in and take it out again.  I'm sorry.  This
1739     field does not belong here.  We fill it with a 0 so it compares the
1740     same but is not a reasonable time. -- gnu@cygnus.com
1741     */
1742   internal_f.f_timdat = 0;
1743
1744   internal_f.f_flags = 0;
1745
1746   if (abfd->flags & EXEC_P)
1747     internal_f.f_opthdr = AOUTSZ;
1748   else
1749     internal_f.f_opthdr = 0;
1750
1751   if (!hasrelocs)
1752     internal_f.f_flags |= F_RELFLG;
1753   if (!haslinno)
1754     internal_f.f_flags |= F_LNNO;
1755   if (abfd->flags & EXEC_P)
1756     internal_f.f_flags |= F_EXEC;
1757
1758   if (!abfd->xvec->byteorder_big_p)
1759     internal_f.f_flags |= F_AR32WR;
1760   else
1761     internal_f.f_flags |= F_AR32W;
1762
1763   /*
1764     FIXME, should do something about the other byte orders and
1765     architectures.
1766     */
1767
1768   memset (&internal_a, 0, sizeof internal_a);
1769
1770   /* Set up architecture-dependent stuff */
1771
1772   {
1773     unsigned int magic = 0;
1774     unsigned short flags = 0;
1775     coff_set_flags (abfd, &magic, &flags);
1776     internal_f.f_magic = magic;
1777     internal_f.f_flags |= flags;
1778     /* ...and the "opt"hdr... */
1779
1780 #ifdef A29K
1781 #ifdef ULTRA3                   /* NYU's machine */
1782     /* FIXME: This is a bogus check.  I really want to see if there
1783    * is a .shbss or a .shdata section, if so then set the magic
1784    * number to indicate a shared data executable.
1785    */
1786     if (internal_f.f_nscns >= 7)
1787       internal_a.magic = SHMAGIC;       /* Shared magic */
1788     else
1789 #endif /* ULTRA3 */
1790       internal_a.magic = NMAGIC;/* Assume separate i/d */
1791 #define __A_MAGIC_SET__
1792 #endif /* A29K */
1793 #ifdef I960
1794     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
1795 #define __A_MAGIC_SET__
1796 #endif /* I960 */
1797 #if M88
1798 #define __A_MAGIC_SET__
1799     internal_a.magic = PAGEMAGICBCS;
1800 #endif /* M88 */
1801
1802 #if APOLLO_M68
1803 #define __A_MAGIC_SET__
1804     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
1805 #endif
1806
1807 #if defined(M68) || defined(WE32K) || defined(M68K)
1808 #define __A_MAGIC_SET__
1809 #if defined(LYNXOS)
1810     internal_a.magic = LYNXCOFFMAGIC;
1811 #endif                          /* LYNXOS */
1812 #endif                          /* M68 || WE32K || M68K */
1813
1814 #if defined(I386)
1815 #define __A_MAGIC_SET__
1816 #if defined(LYNXOS)
1817     internal_a.magic = LYNXCOFFMAGIC;
1818 #else                           /* LYNXOS */
1819     internal_a.magic = ZMAGIC;
1820 #endif /* LYNXOS */
1821 #endif /* I386 */
1822
1823 #if defined(SPARC)
1824 #define __A_MAGIC_SET__
1825 #if defined(LYNXOS)
1826   internal_a.magic = LYNXCOFFMAGIC;
1827 #endif                          /* LYNXOS */
1828 #endif                          /* SPARC */
1829
1830 #if RS6000COFF_C
1831 #define __A_MAGIC_SET__
1832     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
1833       (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
1834       RS6K_AOUTHDR_OMAGIC;
1835 #endif
1836
1837 #ifndef __A_MAGIC_SET__
1838 #include "Your aouthdr magic number is not being set!"
1839 #else
1840 #undef __A_MAGIC_SET__
1841 #endif
1842   }
1843   /* Now should write relocs, strings, syms */
1844   obj_sym_filepos (abfd) = sym_base;
1845
1846   if (bfd_get_symcount (abfd) != 0)
1847     {
1848 #ifndef RS6000COFF_C
1849       if (!coff_add_missing_symbols (abfd))
1850         return false;
1851 #endif
1852       if (!coff_renumber_symbols (abfd))
1853         return false;
1854       coff_mangle_symbols (abfd);
1855       if (! coff_write_symbols (abfd))
1856         return false;
1857       if (! coff_write_linenumbers (abfd))
1858         return false;
1859       if (! coff_write_relocs (abfd))
1860         return false;
1861     }
1862
1863   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
1864      backend linker, and obj_raw_syment_count is not valid until after
1865      coff_write_symbols is called.  */
1866   if (obj_raw_syment_count (abfd) != 0)
1867     internal_f.f_symptr = sym_base;
1868   else
1869     {
1870       internal_f.f_symptr = 0;
1871       internal_f.f_flags |= F_LSYMS;
1872     }
1873
1874   if (text_sec)
1875     {
1876       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
1877       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
1878     }
1879   if (data_sec)
1880     {
1881       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
1882       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
1883     }
1884   if (bss_sec)
1885     {
1886       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
1887     }
1888
1889   internal_a.entry = bfd_get_start_address (abfd);
1890   internal_f.f_nsyms = obj_raw_syment_count (abfd);
1891
1892   /* now write them */
1893   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1894     return false;
1895   {
1896     FILHDR buff;
1897     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
1898     if (bfd_write ((PTR) & buff, 1, FILHSZ, abfd) != FILHSZ)
1899       return false;
1900   }
1901   if (abfd->flags & EXEC_P)
1902     {
1903       AOUTHDR buff;
1904       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
1905       if (bfd_write ((PTR) & buff, 1, AOUTSZ, abfd) != AOUTSZ)
1906         return false;
1907     }
1908   return true;
1909 }
1910
1911 static boolean
1912 coff_set_section_contents (abfd, section, location, offset, count)
1913      bfd * abfd;
1914      sec_ptr section;
1915      PTR location;
1916      file_ptr offset;
1917      bfd_size_type count;
1918 {
1919   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
1920     coff_compute_section_file_positions (abfd);
1921
1922 #ifdef _LIB
1923   /* If this is a .lib section, bump the vma address so that it
1924        winds up being the number of .lib sections output.  This is
1925        right for SVR3.2.  Shared libraries should probably get more
1926        generic support.  Ian Taylor <ian@cygnus.com>.  */
1927   if (strcmp (section->name, _LIB) == 0)
1928     ++section->lma;
1929 #endif
1930
1931   /* Don't write out bss sections - one way to do this is to
1932        see if the filepos has not been set. */
1933   if (section->filepos == 0)
1934     return true;
1935
1936   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
1937     return false;
1938
1939   if (count != 0)
1940     {
1941       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
1942     }
1943   return true;
1944 }
1945 #if 0
1946 static boolean
1947 coff_close_and_cleanup (abfd)
1948      bfd *abfd;
1949 {
1950   if (!bfd_read_p (abfd))
1951     switch (abfd->format)
1952       {
1953       case bfd_archive:
1954         if (!_bfd_write_archive_contents (abfd))
1955           return false;
1956         break;
1957       case bfd_object:
1958         if (!coff_write_object_contents (abfd))
1959           return false;
1960         break;
1961       default:
1962         bfd_set_error (bfd_error_invalid_operation);
1963         return false;
1964       }
1965
1966   /* We depend on bfd_close to free all the memory on the obstack.  */
1967   /* FIXME if bfd_release is not using obstacks! */
1968   return true;
1969 }
1970
1971 #endif
1972
1973 static PTR
1974 buy_and_read (abfd, where, seek_direction, size)
1975      bfd *abfd;
1976      file_ptr where;
1977      int seek_direction;
1978      size_t size;
1979 {
1980   PTR area = (PTR) bfd_alloc (abfd, size);
1981   if (!area)
1982     {
1983       bfd_set_error (bfd_error_no_memory);
1984       return (NULL);
1985     }
1986   if (bfd_seek (abfd, where, seek_direction) != 0
1987       || bfd_read (area, 1, size, abfd) != size)
1988     return (NULL);
1989   return (area);
1990 }                               /* buy_and_read() */
1991
1992 /*
1993 SUBSUBSECTION
1994         Reading linenumbers
1995
1996         Creating the linenumber table is done by reading in the entire
1997         coff linenumber table, and creating another table for internal use.
1998
1999         A coff linenumber table is structured so that each function
2000         is marked as having a line number of 0. Each line within the
2001         function is an offset from the first line in the function. The
2002         base of the line number information for the table is stored in
2003         the symbol associated with the function.
2004
2005         The information is copied from the external to the internal
2006         table, and each symbol which marks a function is marked by
2007         pointing its...
2008
2009         How does this work ?
2010
2011 */
2012
2013 static boolean
2014 coff_slurp_line_table (abfd, asect)
2015      bfd *abfd;
2016      asection *asect;
2017 {
2018   LINENO *native_lineno;
2019   alent *lineno_cache;
2020
2021   BFD_ASSERT (asect->lineno == (alent *) NULL);
2022
2023   native_lineno = (LINENO *) buy_and_read (abfd,
2024                                            asect->line_filepos,
2025                                            SEEK_SET,
2026                                            (size_t) (LINESZ *
2027                                                      asect->lineno_count));
2028   lineno_cache =
2029     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
2030   if (lineno_cache == NULL)
2031     {
2032       bfd_set_error (bfd_error_no_memory);
2033       return false;
2034     }
2035   else
2036     {
2037       unsigned int counter = 0;
2038       alent *cache_ptr = lineno_cache;
2039       LINENO *src = native_lineno;
2040
2041       while (counter < asect->lineno_count)
2042         {
2043           struct internal_lineno dst;
2044           coff_swap_lineno_in (abfd, src, &dst);
2045           cache_ptr->line_number = dst.l_lnno;
2046
2047           if (cache_ptr->line_number == 0)
2048             {
2049               coff_symbol_type *sym =
2050               (coff_symbol_type *) (dst.l_addr.l_symndx
2051                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
2052               cache_ptr->u.sym = (asymbol *) sym;
2053               sym->lineno = cache_ptr;
2054             }
2055           else
2056             {
2057               cache_ptr->u.offset = dst.l_addr.l_paddr
2058                 - bfd_section_vma (abfd, asect);
2059             }                   /* If no linenumber expect a symbol index */
2060
2061           cache_ptr++;
2062           src++;
2063           counter++;
2064         }
2065       cache_ptr->line_number = 0;
2066
2067     }
2068   asect->lineno = lineno_cache;
2069   /* FIXME, free native_lineno here, or use alloca or something. */
2070   return true;
2071 }
2072
2073 static boolean
2074 coff_slurp_symbol_table (abfd)
2075      bfd * abfd;
2076 {
2077   combined_entry_type *native_symbols;
2078   coff_symbol_type *cached_area;
2079   unsigned int *table_ptr;
2080
2081   unsigned int number_of_symbols = 0;
2082   if (obj_symbols (abfd))
2083     return true;
2084   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
2085     return false;
2086
2087   /* Read in the symbol table */
2088   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
2089     {
2090       return (false);
2091     }                           /* on error */
2092
2093   /* Allocate enough room for all the symbols in cached form */
2094   cached_area = ((coff_symbol_type *)
2095                  bfd_alloc (abfd,
2096                             (obj_raw_syment_count (abfd)
2097                              * sizeof (coff_symbol_type))));
2098
2099   if (cached_area == NULL)
2100     {
2101       bfd_set_error (bfd_error_no_memory);
2102       return false;
2103     }                           /* on error */
2104   table_ptr = ((unsigned int *)
2105                bfd_alloc (abfd,
2106                           (obj_raw_syment_count (abfd)
2107                            * sizeof (unsigned int))));
2108
2109   if (table_ptr == NULL)
2110     {
2111       bfd_set_error (bfd_error_no_memory);
2112       return false;
2113     }
2114   else
2115     {
2116       coff_symbol_type *dst = cached_area;
2117       unsigned int last_native_index = obj_raw_syment_count (abfd);
2118       unsigned int this_index = 0;
2119       while (this_index < last_native_index)
2120         {
2121           combined_entry_type *src = native_symbols + this_index;
2122           table_ptr[this_index] = number_of_symbols;
2123           dst->symbol.the_bfd = abfd;
2124
2125           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
2126           /* We use the native name field to point to the cached field.  */
2127           src->u.syment._n._n_n._n_zeroes = (long) dst;
2128           dst->symbol.section = coff_section_from_bfd_index (abfd,
2129                                                      src->u.syment.n_scnum);
2130           dst->symbol.flags = 0;
2131           dst->done_lineno = false;
2132
2133           switch (src->u.syment.n_sclass)
2134             {
2135 #ifdef I960
2136             case C_LEAFEXT:
2137 #if 0
2138               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2139               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2140               dst->symbol.flags |= BSF_NOT_AT_END;
2141 #endif
2142               /* Fall through to next case */
2143
2144 #endif
2145
2146             case C_EXT:
2147 #ifdef RS6000COFF_C
2148             case C_HIDEXT:
2149 #endif
2150               if ((src->u.syment.n_scnum) == 0)
2151                 {
2152                   if ((src->u.syment.n_value) == 0)
2153                     {
2154                       dst->symbol.section = bfd_und_section_ptr;
2155                       dst->symbol.value = 0;
2156                     }
2157                   else
2158                     {
2159                       dst->symbol.section = bfd_com_section_ptr;
2160                       dst->symbol.value = (src->u.syment.n_value);
2161                     }
2162                 }
2163               else
2164                 {
2165                   /*
2166             Base the value as an index from the base of the
2167             section
2168             */
2169
2170                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2171                   dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2172
2173                   if (ISFCN ((src->u.syment.n_type)))
2174                     {
2175                       /*
2176               A function ext does not go at the end of a file
2177               */
2178                       dst->symbol.flags |= BSF_NOT_AT_END;
2179                     }
2180                 }
2181
2182 #ifdef RS6000COFF_C
2183               /* If this symbol has a csect aux of type LD, the scnlen field
2184            is actually the index of the containing csect symbol.  We
2185            need to pointerize it.  */
2186               if (src->u.syment.n_numaux > 0)
2187                 {
2188                   combined_entry_type *aux;
2189
2190                   aux = src + src->u.syment.n_numaux - 1;
2191                   if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2192                     {
2193                       aux->u.auxent.x_csect.x_scnlen.p =
2194                         native_symbols + aux->u.auxent.x_csect.x_scnlen.l;
2195                       aux->fix_scnlen = 1;
2196                     }
2197                 }
2198 #endif
2199
2200               break;
2201
2202             case C_STAT:        /* static                        */
2203 #ifdef I960
2204             case C_LEAFSTAT:    /* static leaf procedure        */
2205 #endif
2206             case C_LABEL:       /* label                         */
2207               if (src->u.syment.n_scnum == -2)
2208                 dst->symbol.flags = BSF_DEBUGGING;
2209               else
2210                 dst->symbol.flags = BSF_LOCAL;
2211               /*
2212           Base the value as an index from the base of the section, if
2213           there is one
2214           */
2215               if (dst->symbol.section)
2216                 dst->symbol.value = (src->u.syment.n_value) -
2217                   dst->symbol.section->vma;
2218               else
2219                 dst->symbol.value = (src->u.syment.n_value);
2220               break;
2221
2222             case C_MOS: /* member of structure   */
2223             case C_EOS: /* end of structure              */
2224 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
2225 #ifdef C_GLBLREG
2226             case C_GLBLREG:     /* A29k-specific storage class */
2227 #endif
2228 #endif
2229             case C_REGPARM:     /* register parameter            */
2230             case C_REG: /* register variable             */
2231 #ifdef C_AUTOARG
2232             case C_AUTOARG:     /* 960-specific storage class */
2233 #endif
2234             case C_TPDEF:       /* type definition               */
2235             case C_ARG:
2236             case C_AUTO:        /* automatic variable */
2237             case C_FIELD:       /* bit field */
2238             case C_ENTAG:       /* enumeration tag               */
2239             case C_MOE: /* member of enumeration         */
2240             case C_MOU: /* member of union               */
2241             case C_UNTAG:       /* union tag                     */
2242               dst->symbol.flags = BSF_DEBUGGING;
2243               dst->symbol.value = (src->u.syment.n_value);
2244               break;
2245
2246             case C_FILE:        /* file name                     */
2247             case C_STRTAG:      /* structure tag                 */
2248 #ifdef RS6000COFF_C
2249             case C_BINCL:       /* beginning of include file     */
2250             case C_EINCL:       /* ending of include file        */
2251             case C_GSYM:
2252             case C_LSYM:
2253             case C_PSYM:
2254             case C_RSYM:
2255             case C_RPSYM:
2256             case C_STSYM:
2257             case C_DECL:
2258             case C_ENTRY:
2259             case C_FUN:
2260             case C_ESTAT:
2261 #endif
2262               dst->symbol.flags = BSF_DEBUGGING;
2263               dst->symbol.value = (src->u.syment.n_value);
2264               break;
2265
2266 #ifdef RS6000COFF_C
2267             case C_BSTAT:
2268               dst->symbol.flags = BSF_DEBUGGING;
2269               dst->symbol.value = src->u.syment.n_value;
2270
2271               /* The value is actually a symbol index.  Save a pointer to
2272            the symbol instead of the index.  FIXME: This should use a
2273            union.  */
2274               src->u.syment.n_value =
2275                 (long) (native_symbols + src->u.syment.n_value);
2276               src->fix_value = 1;
2277               break;
2278 #endif
2279
2280             case C_BLOCK:       /* ".bb" or ".eb"                */
2281             case C_FCN: /* ".bf" or ".ef"                */
2282             case C_EFCN:        /* physical end of function      */
2283               dst->symbol.flags = BSF_LOCAL;
2284               /*
2285           Base the value as an index from the base of the section
2286           */
2287               dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
2288               break;
2289
2290             case C_NULL:
2291             case C_EXTDEF:      /* external definition           */
2292             case C_ULABEL:      /* undefined label               */
2293             case C_USTATIC:     /* undefined static              */
2294             case C_LINE:        /* line # reformatted as symbol table entry */
2295             case C_ALIAS:       /* duplicate tag                 */
2296             case C_HIDDEN:      /* ext symbol in dmert public lib */
2297             default:
2298
2299               fprintf (stderr, "Unrecognized storage class %d (assuming debugging)\n  for %s symbol `%s'\n",
2300                        src->u.syment.n_sclass, dst->symbol.section->name,
2301                        dst->symbol.name);
2302 /*      abort();*/
2303               dst->symbol.flags = BSF_DEBUGGING;
2304               dst->symbol.value = (src->u.syment.n_value);
2305               break;
2306             }
2307
2308 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
2309
2310           dst->native = src;
2311
2312           dst->symbol.udata = 0;
2313           dst->lineno = (alent *) NULL;
2314           this_index += (src->u.syment.n_numaux) + 1;
2315           dst++;
2316           number_of_symbols++;
2317         }                       /* walk the native symtab */
2318     }                           /* bfdize the native symtab */
2319
2320   obj_symbols (abfd) = cached_area;
2321   obj_raw_syments (abfd) = native_symbols;
2322
2323   bfd_get_symcount (abfd) = number_of_symbols;
2324   obj_convert (abfd) = table_ptr;
2325   /* Slurp the line tables for each section too */
2326   {
2327     asection *p;
2328     p = abfd->sections;
2329     while (p)
2330       {
2331         coff_slurp_line_table (abfd, p);
2332         p = p->next;
2333       }
2334   }
2335   return true;
2336 }                               /* coff_slurp_symbol_table() */
2337
2338 /* Check whether a symbol is globally visible.  This is used by the
2339    COFF backend linker code in cofflink.c, since a couple of targets
2340    have globally visible symbols which are not class C_EXT.  This
2341    function need not handle the case of n_class == C_EXT.  */
2342
2343 #undef OTHER_GLOBAL_CLASS
2344
2345 #ifdef I960
2346 #define OTHER_GLOBAL_CLASS C_LEAFEXT
2347 #endif
2348
2349 #ifdef RS6000COFF_C
2350 #define OTHER_GLOBAL_CLASS C_HIDEXT
2351 #endif
2352
2353 #ifdef OTHER_GLOBAL_CLASS
2354
2355 static boolean
2356 coff_sym_is_global (abfd, syment)
2357      bfd *abfd;
2358      struct internal_syment *syment;
2359 {
2360   if (syment->n_sclass == OTHER_GLOBAL_CLASS)
2361     return true;
2362   return false;
2363 }
2364
2365 #undef OTHER_GLOBAL_CLASS
2366
2367 #else /* ! defined (OTHER_GLOBAL_CLASS) */
2368
2369 /* sym_is_global should not be defined if it has nothing to do.  */
2370
2371 #define coff_sym_is_global 0
2372
2373 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
2374
2375 /*
2376 SUBSUBSECTION
2377         Reading relocations
2378
2379         Coff relocations are easily transformed into the internal BFD form
2380         (@code{arelent}).
2381
2382         Reading a coff relocation table is done in the following stages:
2383
2384         o Read the entire coff relocation table into memory.
2385
2386         o Process each relocation in turn; first swap it from the
2387         external to the internal form.
2388
2389         o Turn the symbol referenced in the relocation's symbol index
2390         into a pointer into the canonical symbol table.
2391         This table is the same as the one returned by a call to
2392         @code{bfd_canonicalize_symtab}. The back end will call that
2393         routine and save the result if a canonicalization hasn't been done.
2394
2395         o The reloc index is turned into a pointer to a howto
2396         structure, in a back end specific way. For instance, the 386
2397         and 960 use the @code{r_type} to directly produce an index
2398         into a howto table vector; the 88k subtracts a number from the
2399         @code{r_type} field and creates an addend field.
2400
2401
2402 */
2403
2404 #ifndef CALC_ADDEND
2405 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
2406   {                                                             \
2407     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
2408     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
2409       coffsym = (obj_symbols (abfd)                             \
2410                  + (cache_ptr->sym_ptr_ptr - symbols));         \
2411     else if (ptr)                                               \
2412       coffsym = coff_symbol_from (abfd, ptr);                   \
2413     if (coffsym != (coff_symbol_type *) NULL                    \
2414         && coffsym->native->u.syment.n_scnum == 0)              \
2415       cache_ptr->addend = 0;                                    \
2416     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
2417              && ptr->section != (asection *) NULL)              \
2418       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
2419     else                                                        \
2420       cache_ptr->addend = 0;                                    \
2421   }
2422 #endif
2423
2424 static boolean
2425 coff_slurp_reloc_table (abfd, asect, symbols)
2426      bfd * abfd;
2427      sec_ptr asect;
2428      asymbol ** symbols;
2429 {
2430   RELOC *native_relocs;
2431   arelent *reloc_cache;
2432   arelent *cache_ptr;
2433
2434   unsigned int idx;
2435
2436   if (asect->relocation)
2437     return true;
2438   if (asect->reloc_count == 0)
2439     return true;
2440   if (asect->flags & SEC_CONSTRUCTOR)
2441     return true;
2442   if (!coff_slurp_symbol_table (abfd))
2443     return false;
2444   native_relocs =
2445     (RELOC *) buy_and_read (abfd,
2446                             asect->rel_filepos,
2447                             SEEK_SET,
2448                             (size_t) (RELSZ *
2449                                       asect->reloc_count));
2450   reloc_cache = (arelent *)
2451     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2452
2453   if (reloc_cache == NULL)
2454     {
2455       bfd_set_error (bfd_error_no_memory);
2456       return false;
2457     }
2458
2459
2460   for (idx = 0; idx < asect->reloc_count; idx++)
2461     {
2462 #ifdef RELOC_PROCESSING
2463       struct internal_reloc dst;
2464       struct external_reloc *src;
2465
2466       cache_ptr = reloc_cache + idx;
2467       src = native_relocs + idx;
2468       coff_swap_reloc_in (abfd, src, &dst);
2469
2470       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2471 #else
2472       struct internal_reloc dst;
2473       asymbol *ptr;
2474       struct external_reloc *src;
2475
2476       cache_ptr = reloc_cache + idx;
2477       src = native_relocs + idx;
2478
2479       coff_swap_reloc_in (abfd, src, &dst);
2480
2481
2482       cache_ptr->address = dst.r_vaddr;
2483
2484       if (dst.r_symndx != -1)
2485         {
2486           /* @@ Should never be greater than count of symbols!  */
2487           if (dst.r_symndx >= obj_conv_table_size (abfd))
2488             abort ();
2489           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
2490           ptr = *(cache_ptr->sym_ptr_ptr);
2491         }
2492       else
2493         {
2494           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2495           ptr = 0;
2496         }
2497
2498       /* The symbols definitions that we have read in have been
2499          relocated as if their sections started at 0. But the offsets
2500          refering to the symbols in the raw data have not been
2501          modified, so we have to have a negative addend to compensate.
2502
2503          Note that symbols which used to be common must be left alone */
2504
2505       /* Calculate any reloc addend by looking at the symbol */
2506       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
2507
2508       cache_ptr->address -= asect->vma;
2509 /* !!     cache_ptr->section = (asection *) NULL;*/
2510
2511       /* Fill in the cache_ptr->howto field from dst.r_type */
2512       RTYPE2HOWTO (cache_ptr, &dst);
2513 #endif
2514
2515     }
2516
2517   asect->relocation = reloc_cache;
2518   return true;
2519 }
2520
2521
2522 /* This is stupid.  This function should be a boolean predicate.  */
2523 static long
2524 coff_canonicalize_reloc (abfd, section, relptr, symbols)
2525      bfd * abfd;
2526      sec_ptr section;
2527      arelent ** relptr;
2528      asymbol ** symbols;
2529 {
2530   arelent *tblptr = section->relocation;
2531   unsigned int count = 0;
2532
2533
2534   if (section->flags & SEC_CONSTRUCTOR)
2535     {
2536       /* this section has relocs made up by us, they are not in the
2537        file, so take them out of their chain and place them into
2538        the data area provided */
2539       arelent_chain *chain = section->constructor_chain;
2540       for (count = 0; count < section->reloc_count; count++)
2541         {
2542           *relptr++ = &chain->relent;
2543           chain = chain->next;
2544         }
2545
2546     }
2547   else
2548     {
2549       if (! coff_slurp_reloc_table (abfd, section, symbols))
2550         return -1;
2551
2552       tblptr = section->relocation;
2553
2554       for (; count++ < section->reloc_count;)
2555         *relptr++ = tblptr++;
2556
2557
2558     }
2559   *relptr = 0;
2560   return section->reloc_count;
2561 }
2562
2563 #ifdef GNU960
2564 file_ptr
2565 coff_sym_filepos (abfd)
2566      bfd *abfd;
2567 {
2568   return obj_sym_filepos (abfd);
2569 }
2570 #endif
2571
2572 #ifndef coff_reloc16_estimate
2573 #define coff_reloc16_estimate dummy_reloc16_estimate
2574
2575 static int
2576 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
2577      bfd *abfd;
2578      asection *input_section;
2579      arelent *reloc;
2580      unsigned int shrink;
2581      struct bfd_link_info *link_info;
2582 {
2583   abort ();
2584 }
2585
2586 #endif
2587
2588 #ifndef coff_reloc16_extra_cases
2589 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
2590 /* This works even if abort is not declared in any header file.  */
2591 static void
2592 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
2593                            dst_ptr)
2594      bfd *abfd;
2595      struct bfd_link_info *link_info;
2596      struct bfd_link_order *link_order;
2597      arelent *reloc;
2598      bfd_byte *data;
2599      unsigned int *src_ptr;
2600      unsigned int *dst_ptr;
2601 {
2602   fprintf (stderr, "%s\n", reloc->howto->name);
2603   abort ();
2604 }
2605 #endif
2606
2607 /* If coff_relocate_section is defined, we can use the optimized COFF
2608    backend linker.  Otherwise we must continue to use the old linker.  */
2609 #ifdef coff_relocate_section
2610 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
2611 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
2612 #define coff_bfd_final_link _bfd_coff_final_link
2613 #else /* ! defined (coff_relocate_section) */
2614 #define coff_relocate_section NULL
2615 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
2616 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
2617 #define coff_bfd_final_link _bfd_generic_final_link
2618 #endif /* ! defined (coff_relocate_section) */
2619
2620 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
2621 {
2622   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
2623   coff_swap_aux_out, coff_swap_sym_out,
2624   coff_swap_lineno_out, coff_swap_reloc_out,
2625   coff_swap_filehdr_out, coff_swap_aouthdr_out,
2626   coff_swap_scnhdr_out,
2627   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
2628 #ifdef COFF_LONG_FILENAMES
2629   true,
2630 #else
2631   false,
2632 #endif
2633   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
2634   coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
2635   coff_mkobject_hook, styp_to_sec_flags, coff_make_section_hook,
2636   coff_set_alignment_hook, coff_slurp_symbol_table, symname_in_debug_hook,
2637   coff_reloc16_extra_cases, coff_reloc16_estimate,
2638   coff_sym_is_global, coff_compute_section_file_positions,
2639   coff_relocate_section
2640 };
2641
2642 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
2643 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
2644 #define coff_get_section_contents _bfd_generic_get_section_contents
2645
2646 #define coff_bfd_copy_private_section_data \
2647   _bfd_generic_bfd_copy_private_section_data
2648 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
2649
2650 #ifndef coff_bfd_is_local_label
2651 #define coff_bfd_is_local_label bfd_generic_is_local_label
2652 #endif
2653
2654 /* The reloc lookup routine must be supplied by each individual COFF
2655    backend.  */
2656 #ifndef coff_bfd_reloc_type_lookup
2657 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
2658 #endif
2659
2660 #define coff_bfd_get_relocated_section_contents \
2661   bfd_generic_get_relocated_section_contents
2662 #define coff_bfd_relax_section bfd_generic_relax_section