bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /*
  22 Most of this hacked by  Steve Chamberlain,
  23                         [email protected]
  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_pointerize_aux. *}
 269 .unsigned int fix_scnlen : 1;
 270 .
 271 .       {* Fix up an XCOFF C_BINCL/C_EINCL symbol.  The value is the
 272 .          index into the line number entries.  Set by
 273 .          coff_slurp_symbol_table.  *}
 274 .unsigned int fix_line : 1;
 275 .
 276 .       {* The container for the symbol structure as read and translated
 277 .           from the file. *}
 278 .
 279 .union {
 280 .   union internal_auxent auxent;
 281 .   struct internal_syment syment;
 282 . } u;
 283 .} combined_entry_type;
 284 .
 285 .
 286 .{* Each canonical asymbol really looks like this: *}
 287 .
 288 .typedef struct coff_symbol_struct
 289 .{
 290 .   {* The actual symbol which the rest of BFD works with *}
 291 .asymbol symbol;
 292 .
 293 .   {* A pointer to the hidden information for this symbol *}
 294 .combined_entry_type *native;
 295 .
 296 .   {* A pointer to the linenumber information for this symbol *}
 297 .struct lineno_cache_entry *lineno;
 298 .
 299 .   {* Have the line numbers been relocated yet ? *}
 300 .boolean done_lineno;
 301 .} coff_symbol_type;
 302
 303
 304 */
 305
 306 #ifdef COFF_WITH_PE
 307 #include "peicode.h"
 308 #else
 309 #include "coffswap.h"
 310 #endif
 311
 312 \f
 313 /* void warning(); */
 314
 315 /*
 316  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 317  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 318  * NOTE: If you add to/change this routine, you should mirror the changes
 319  *      in styp_to_sec_flags().
 320  */
 321 static long
 322 sec_to_styp_flags (sec_name, sec_flags)
 323      CONST char *sec_name;
 324      flagword sec_flags;
 325 {
 326   long styp_flags = 0;
 327
 328   if (!strcmp (sec_name, _TEXT))
 329     {
 330       styp_flags = STYP_TEXT;
 331     }
 332   else if (!strcmp (sec_name, _DATA))
 333     {
 334       styp_flags = STYP_DATA;
 335     }
 336   else if (!strcmp (sec_name, _BSS))
 337     {
 338       styp_flags = STYP_BSS;
 339 #ifdef _COMMENT
 340     }
 341   else if (!strcmp (sec_name, _COMMENT))
 342     {
 343       styp_flags = STYP_INFO;
 344 #endif /* _COMMENT */
 345 #ifdef _LIB
 346     }
 347   else if (!strcmp (sec_name, _LIB))
 348     {
 349       styp_flags = STYP_LIB;
 350 #endif /* _LIB */
 351 #ifdef _LIT
 352     }
 353   else if (!strcmp (sec_name, _LIT))
 354     {
 355       styp_flags = STYP_LIT;
 356 #endif /* _LIT */
 357     }
 358   else if (!strcmp (sec_name, ".debug"))
 359     {
 360 #ifdef STYP_DEBUG
 361       styp_flags = STYP_DEBUG;
 362 #else
 363       styp_flags = STYP_INFO;
 364 #endif
 365     }
 366   else if (!strncmp (sec_name, ".stab", 5))
 367     {
 368       styp_flags = STYP_INFO;
 369     }
 370 #ifdef COFF_WITH_PE
 371   else if (!strcmp (sec_name, ".edata"))
 372     {
 373       styp_flags = STYP_DATA;
 374     }
 375 #endif
 376 #ifdef RS6000COFF_C
 377   else if (!strcmp (sec_name, _PAD))
 378     {
 379       styp_flags = STYP_PAD;
 380     }
 381   else if (!strcmp (sec_name, _LOADER))
 382     {
 383       styp_flags = STYP_LOADER;
 384     }
 385 #endif
 386   /* Try and figure out what it should be */
 387   else if (sec_flags & SEC_CODE)
 388     {
 389       styp_flags = STYP_TEXT;
 390     }
 391   else if (sec_flags & SEC_DATA)
 392     {
 393       styp_flags = STYP_DATA;
 394     }
 395   else if (sec_flags & SEC_READONLY)
 396     {
 397 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 398       styp_flags = STYP_LIT;
 399 #else
 400       styp_flags = STYP_TEXT;
 401 #endif /* STYP_LIT */
 402     }
 403   else if (sec_flags & SEC_LOAD)
 404     {
 405       styp_flags = STYP_TEXT;
 406     }
 407   else if (sec_flags & SEC_ALLOC)
 408     {
 409       styp_flags = STYP_BSS;
 410     }
 411
 412 #ifdef STYP_NOLOAD
 413   if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
 414     styp_flags |= STYP_NOLOAD;
 415 #endif
 416
 417   return (styp_flags);
 418 }
 419 /*
 420  * Return a word with SEC_* flags set to represent the incoming
 421  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 422  * function is sec_to_styp_flags().
 423  * NOTE: If you add to/change this routine, you should mirror the changes
 424  *      in sec_to_styp_flags().
 425  */
 426 static flagword
 427 styp_to_sec_flags (abfd, hdr, name)
 428      bfd *abfd;
 429      PTR hdr;
 430      const char *name;
 431 {
 432   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 433   long styp_flags = internal_s->s_flags;
 434   flagword sec_flags = 0;
 435
 436 #ifdef STYP_NOLOAD
 437   if (styp_flags & STYP_NOLOAD)
 438     {
 439       sec_flags |= SEC_NEVER_LOAD;
 440     }
 441 #endif /* STYP_NOLOAD */
 442
 443   /* For 386 COFF, at least, an unloadable text or data section is
 444      actually a shared library section.  */
 445   if (styp_flags & STYP_TEXT)
 446     {
 447       if (sec_flags & SEC_NEVER_LOAD)
 448         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 449       else
 450         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 451     }
 452   else if (styp_flags & STYP_DATA)
 453     {
 454       if (sec_flags & SEC_NEVER_LOAD)
 455         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 456       else
 457         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 458     }
 459   else if (styp_flags & STYP_BSS)
 460     {
 461 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 462       if (sec_flags & SEC_NEVER_LOAD)
 463         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 464       else
 465 #endif
 466         sec_flags |= SEC_ALLOC;
 467     }
 468   else if (styp_flags & STYP_INFO)
 469     {
 470       /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
 471          defined.  coff_compute_section_file_positions uses
 472          COFF_PAGE_SIZE to ensure that the low order bits of the
 473          section VMA and the file offset match.  If we don't know
 474          COFF_PAGE_SIZE, we can't ensure the correct correspondence,
 475          and demand page loading of the file will fail.  */
 476 #ifdef COFF_PAGE_SIZE
 477       sec_flags |= SEC_DEBUGGING;
 478 #endif
 479     }
 480   else if (styp_flags & STYP_PAD)
 481     {
 482       sec_flags = 0;
 483     }
 484   else if (strcmp (name, _TEXT) == 0)
 485     {
 486       if (sec_flags & SEC_NEVER_LOAD)
 487         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 488       else
 489         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 490     }
 491   else if (strcmp (name, _DATA) == 0)
 492     {
 493       if (sec_flags & SEC_NEVER_LOAD)
 494         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 495       else
 496         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 497     }
 498   else if (strcmp (name, _BSS) == 0)
 499     {
 500 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 501       if (sec_flags & SEC_NEVER_LOAD)
 502         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 503       else
 504 #endif
 505         sec_flags |= SEC_ALLOC;
 506     }
 507   else if (strcmp (name, ".debug") == 0
 508 #ifdef _COMMENT
 509            || strcmp (name, _COMMENT) == 0
 510 #endif
 511            || strncmp (name, ".stab", 5) == 0)
 512     {
 513 #ifdef COFF_PAGE_SIZE
 514       sec_flags |= SEC_DEBUGGING;
 515 #endif
 516     }
 517 #ifdef _LIB
 518   else if (strcmp (name, _LIB) == 0)
 519     ;
 520 #endif
 521 #ifdef _LIT
 522   else if (strcmp (name, _LIT) == 0)
 523     {
 524       sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
 525     }
 526 #endif
 527   else
 528     {
 529       sec_flags |= SEC_ALLOC | SEC_LOAD;
 530     }
 531
 532 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 533   if ((styp_flags & STYP_LIT) == STYP_LIT)
 534     {
 535       sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 536     }
 537 #endif /* STYP_LIT */
 538 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 539   if (styp_flags & STYP_OTHER_LOAD)
 540     {
 541       sec_flags = (SEC_LOAD | SEC_ALLOC);
 542     }
 543 #endif /* STYP_SDATA */
 544
 545   return (sec_flags);
 546 }
 547
 548 #define get_index(symbol)       ((symbol)->udata.i)
 549
 550 /*
 551 INTERNAL_DEFINITION
 552         bfd_coff_backend_data
 553
 554 CODE_FRAGMENT
 555
 556 Special entry points for gdb to swap in coff symbol table parts:
 557 .typedef struct
 558 .{
 559 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 560 .       bfd            *abfd,
 561 .       PTR             ext,
 562 .       int             type,
 563 .       int             class,
 564 .       int             indaux,
 565 .       int             numaux,
 566 .       PTR             in));
 567 .
 568 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 569 .       bfd            *abfd ,
 570 .       PTR             ext,
 571 .       PTR             in));
 572 .
 573 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 574 .       bfd            *abfd,
 575 .       PTR            ext,
 576 .       PTR             in));
 577 .
 578
 579 Special entry points for gas to swap out coff parts:
 580
 581 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 582 .       bfd     *abfd,
 583 .       PTR     in,
 584 .       int     type,
 585 .       int     class,
 586 .       int     indaux,
 587 .       int     numaux,
 588 .       PTR     ext));
 589 .
 590 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 591 .      bfd      *abfd,
 592 .      PTR      in,
 593 .      PTR      ext));
 594 .
 595 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 596 .       bfd     *abfd,
 597 .       PTR     in,
 598 .       PTR     ext));
 599 .
 600 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 601 .       bfd     *abfd,
 602 .       PTR     src,
 603 .       PTR     dst));
 604 .
 605 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 606 .       bfd     *abfd,
 607 .       PTR     in,
 608 .       PTR     out));
 609 .
 610 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 611 .       bfd     *abfd,
 612 .       PTR     in,
 613 .       PTR     out));
 614 .
 615 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 616 .       bfd     *abfd,
 617 .       PTR     in,
 618 .       PTR     out));
 619 .
 620
 621 Special entry points for generic COFF routines to call target
 622 dependent COFF routines:
 623
 624 . unsigned int _bfd_filhsz;
 625 . unsigned int _bfd_aoutsz;
 626 . unsigned int _bfd_scnhsz;
 627 . unsigned int _bfd_symesz;
 628 . unsigned int _bfd_auxesz;
 629 . unsigned int _bfd_relsz;
 630 . unsigned int _bfd_linesz;
 631 . boolean _bfd_coff_long_filenames;
 632 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 633 .       bfd     *abfd,
 634 .       PTR     ext,
 635 .       PTR     in));
 636 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 637 .       bfd     *abfd,
 638 .       PTR     ext,
 639 .       PTR     in));
 640 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 641 .       bfd     *abfd,
 642 .       PTR     ext,
 643 .       PTR     in));
 644 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
 645 .       bfd     *abfd,
 646 .       PTR     ext,
 647 .       PTR     in));
 648 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 649 .       bfd     *abfd,
 650 .       PTR     internal_filehdr));
 651 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 652 .       bfd     *abfd,
 653 .       PTR     internal_filehdr));
 654 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 655 .       bfd     *abfd,
 656 .       PTR     internal_filehdr,
 657 .       PTR     internal_aouthdr));
 658 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 659 .       bfd     *abfd,
 660 .       PTR     internal_scnhdr,
 661 .       const char *name));
 662 . void (*_bfd_set_alignment_hook) PARAMS ((
 663 .       bfd     *abfd,
 664 .       asection *sec,
 665 .       PTR     internal_scnhdr));
 666 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 667 .       bfd     *abfd));
 668 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 669 .       bfd     *abfd,
 670 .       struct internal_syment *sym));
 671 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
 672 .       bfd *abfd,
 673 .       combined_entry_type *table_base,
 674 .       combined_entry_type *symbol,
 675 .       unsigned int indaux,
 676 .       combined_entry_type *aux));
 677 . boolean (*_bfd_coff_print_aux) PARAMS ((
 678 .       bfd *abfd,
 679 .       FILE *file,
 680 .       combined_entry_type *table_base,
 681 .       combined_entry_type *symbol,
 682 .       combined_entry_type *aux,
 683 .       unsigned int indaux));
 684 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 685 .       bfd     *abfd,
 686 .       struct bfd_link_info *link_info,
 687 .       struct bfd_link_order *link_order,
 688 .       arelent *reloc,
 689 .       bfd_byte *data,
 690 .       unsigned int *src_ptr,
 691 .       unsigned int *dst_ptr));
 692 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
 693 .       bfd *abfd,
 694 .       asection *input_section,
 695 .       arelent *r,
 696 .       unsigned int shrink,
 697 .       struct bfd_link_info *link_info));
 698 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
 699 .       bfd *abfd,
 700 .       struct internal_syment *));
 701 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
 702 .       bfd *abfd));
 703 . boolean (*_bfd_coff_start_final_link) PARAMS ((
 704 .       bfd *output_bfd,
 705 .       struct bfd_link_info *info));
 706 . boolean (*_bfd_coff_relocate_section) PARAMS ((
 707 .       bfd *output_bfd,
 708 .       struct bfd_link_info *info,
 709 .       bfd *input_bfd,
 710 .       asection *input_section,
 711 .       bfd_byte *contents,
 712 .       struct internal_reloc *relocs,
 713 .       struct internal_syment *syms,
 714 .       asection **sections));
 715 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
 716 .       bfd *abfd,
 717 .       asection *sec,
 718 .       struct internal_reloc *rel,
 719 .       struct coff_link_hash_entry *h,
 720 .       struct internal_syment *sym,
 721 .       bfd_vma *addendp));
 722 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
 723 .       bfd *obfd,
 724 .       struct bfd_link_info *info,
 725 .       bfd *ibfd,
 726 .       asection *sec,
 727 .       struct internal_reloc *reloc,
 728 .       boolean *adjustedp));
 729 .
 730 .} bfd_coff_backend_data;
 731 .
 732 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 733 .
 734 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
 735 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
 736 .
 737 .#define bfd_coff_swap_sym_in(a,e,i) \
 738 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 739 .
 740 .#define bfd_coff_swap_lineno_in(a,e,i) \
 741 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 742 .
 743 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 744 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 745 .
 746 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 747 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 748 .
 749 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
 750 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
 751 .
 752 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 753 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 754 .
 755 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 756 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 757 .
 758 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 759 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 760 .
 761 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 762 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 763 .
 764 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 765 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 766 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 767 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 768 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 769 .#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
 770 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 771 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 772 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 773 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 774 .
 775 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 776 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 777 .
 778 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 779 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 780 .
 781 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
 782 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
 783 .
 784 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 785 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 786 .
 787 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 788 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 789 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
 790 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
 791 .
 792 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
 793 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
 794 .
 795 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 796 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 797 .
 798 .#define bfd_coff_slurp_symbol_table(abfd)\
 799 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 800 .
 801 .#define bfd_coff_symname_in_debug(abfd, sym)\
 802 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 803 .
 804 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
 805 .        ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
 806 .         (abfd, file, base, symbol, aux, indaux))
 807 .
 808 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
 809 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 810 .         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
 811 .
 812 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
 813 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 814 .         (abfd, section, reloc, shrink, link_info))
 815 .
 816 .#define bfd_coff_sym_is_global(abfd, sym)\
 817 .        ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
 818 .         (abfd, sym))
 819 .
 820 .#define bfd_coff_compute_section_file_positions(abfd)\
 821 .        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
 822 .         (abfd))
 823 .
 824 .#define bfd_coff_start_final_link(obfd, info)\
 825 .        ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
 826 .         (obfd, info))
 827 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
 828 .        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
 829 .         (obfd, info, ibfd, o, con, rel, isyms, secs))
 830 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
 831 .        ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
 832 .         (abfd, sec, rel, h, sym, addendp))
 833 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
 834 .        ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
 835 .         (obfd, info, ibfd, sec, rel, adjustedp))
 836 .
 837 */
 838
 839 /* See whether the magic number matches.  */
 840
 841 static boolean
 842 coff_bad_format_hook (abfd, filehdr)
 843      bfd * abfd;
 844      PTR filehdr;
 845 {
 846   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 847
 848   if (BADMAG (*internal_f))
 849     return false;
 850
 851   /* if the optional header is NULL or not the correct size then
 852      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
 853      and Intel 960 readwrite headers (I960WRMAGIC) is that the
 854      optional header is of a different size.
 855
 856      But the mips keeps extra stuff in it's opthdr, so dont check
 857      when doing that
 858      */
 859
 860 #if defined(M88) || defined(I960)
 861   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
 862     return false;
 863 #endif
 864
 865   return true;
 866 }
 867
 868 /*
 869    initialize a section structure with information peculiar to this
 870    particular implementation of coff
 871 */
 872
 873 static boolean
 874 coff_new_section_hook (abfd, section)
 875      bfd * abfd;
 876      asection * section;
 877 {
 878   section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
 879
 880 #ifdef RS6000COFF_C
 881   if (xcoff_data (abfd)->text_align_power != 0
 882       && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
 883     section->alignment_power = xcoff_data (abfd)->text_align_power;
 884   if (xcoff_data (abfd)->data_align_power != 0
 885       && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
 886     section->alignment_power = xcoff_data (abfd)->data_align_power;
 887 #endif
 888
 889   /* Allocate aux records for section symbols, to store size and
 890      related info.
 891
 892      @@ Shouldn't use constant multiplier here!  */
 893   coffsymbol (section->symbol)->native =
 894     (combined_entry_type *) bfd_zalloc (abfd,
 895                                         sizeof (combined_entry_type) * 10);
 896
 897   /* The .stab section must be aligned to 2**2 at most, because
 898      otherwise there may be gaps in the section which gdb will not
 899      know how to interpret.  Examining the section name is a hack, but
 900      that is also how gdb locates the section.
 901      We need to handle the .ctors and .dtors sections similarly, to
 902      avoid introducing null words in the tables.  */
 903   if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2
 904       && (strncmp (section->name, ".stab", 5) == 0
 905           || strcmp (section->name, ".ctors") == 0
 906           || strcmp (section->name, ".dtors") == 0))
 907     section->alignment_power = 2;
 908
 909   return true;
 910 }
 911
 912 #ifdef I960
 913
 914 /* Set the alignment of a BFD section.  */
 915
 916 static void
 917 coff_set_alignment_hook (abfd, section, scnhdr)
 918      bfd * abfd;
 919      asection * section;
 920      PTR scnhdr;
 921 {
 922   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 923   unsigned int i;
 924
 925   for (i = 0; i < 32; i++)
 926     if ((1 << i) >= hdr->s_align)
 927       break;
 928   section->alignment_power = i;
 929 }
 930
 931 #else /* ! I960 */
 932
 933 #define coff_set_alignment_hook \
 934   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
 935
 936 #endif /* ! I960 */
 937
 938 #ifndef coff_mkobject
 939 static boolean
 940 coff_mkobject (abfd)
 941      bfd * abfd;
 942 {
 943   coff_data_type *coff;
 944
 945   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
 946   if (abfd->tdata.coff_obj_data == 0)
 947     {
 948       bfd_set_error (bfd_error_no_memory);
 949       return false;
 950     }
 951   coff = coff_data (abfd);
 952   coff->symbols = (coff_symbol_type *) NULL;
 953   coff->conversion_table = (unsigned int *) NULL;
 954   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 955   coff->relocbase = 0;
 956 /*  make_abs_section(abfd);*/
 957
 958   return true;
 959 }
 960 #endif
 961
 962 /* Create the COFF backend specific information.  */
 963 #ifndef coff_mkobject_hook
 964 static PTR
 965 coff_mkobject_hook (abfd, filehdr, aouthdr)
 966      bfd * abfd;
 967      PTR filehdr;
 968      PTR aouthdr;
 969 {
 970   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 971   coff_data_type *coff;
 972
 973   if (coff_mkobject (abfd) == false)
 974     return NULL;
 975
 976   coff = coff_data (abfd);
 977
 978   coff->sym_filepos = internal_f->f_symptr;
 979
 980   /* These members communicate important constants about the symbol
 981      table to GDB's symbol-reading code.  These `constants'
 982      unfortunately vary among coff implementations...  */
 983   coff->local_n_btmask = N_BTMASK;
 984   coff->local_n_btshft = N_BTSHFT;
 985   coff->local_n_tmask = N_TMASK;
 986   coff->local_n_tshift = N_TSHIFT;
 987   coff->local_symesz = SYMESZ;
 988   coff->local_auxesz = AUXESZ;
 989   coff->local_linesz = LINESZ;
 990
 991   obj_raw_syment_count (abfd) =
 992     obj_conv_table_size (abfd) =
 993       internal_f->f_nsyms;
 994
 995 #ifdef RS6000COFF_C
 996   if ((internal_f->f_flags & F_SHROBJ) != 0)
 997     abfd->flags |= DYNAMIC;
 998   if (aouthdr != NULL && internal_f->f_opthdr >= AOUTSZ)
 999     {
1000       struct internal_aouthdr *internal_a =
1001         (struct internal_aouthdr *) aouthdr;
1002       struct xcoff_tdata *xcoff;
1003
1004       xcoff = xcoff_data (abfd);
1005       xcoff->full_aouthdr = true;
1006       xcoff->toc = internal_a->o_toc;
1007       if (internal_a->o_sntoc == 0)
1008         xcoff->toc_section = NULL;
1009       else
1010         xcoff->toc_section =
1011           coff_section_from_bfd_index (abfd, internal_a->o_sntoc);
1012       if (internal_a->o_snentry == 0)
1013         xcoff->entry_section = NULL;
1014       else
1015         xcoff->entry_section =
1016           coff_section_from_bfd_index (abfd, internal_a->o_snentry);
1017       xcoff->text_align_power = internal_a->o_algntext;
1018       xcoff->data_align_power = internal_a->o_algndata;
1019       xcoff->modtype = internal_a->o_modtype;
1020       xcoff->cputype = internal_a->o_cputype;
1021       xcoff->maxdata = internal_a->o_maxdata;
1022       xcoff->maxstack = internal_a->o_maxstack;
1023     }
1024 #endif
1025
1026   return (PTR) coff;
1027 }
1028 #endif
1029
1030 /* Determine the machine architecture and type.  FIXME: This is target
1031    dependent because the magic numbers are defined in the target
1032    dependent header files.  But there is no particular need for this.
1033    If the magic numbers were moved to a separate file, this function
1034    would be target independent and would also be much more successful
1035    at linking together COFF files for different architectures.  */
1036
1037 static boolean
1038 coff_set_arch_mach_hook (abfd, filehdr)
1039      bfd *abfd;
1040      PTR filehdr;
1041 {
1042   long machine;
1043   enum bfd_architecture arch;
1044   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1045
1046   machine = 0;
1047   switch (internal_f->f_magic)
1048     {
1049 #ifdef PPCMAGIC
1050     case PPCMAGIC:
1051       arch = bfd_arch_powerpc;
1052       machine = 0; /* what does this mean? (krk) */
1053       break;
1054 #endif
1055 #ifdef I386MAGIC
1056     case I386MAGIC:
1057     case I386PTXMAGIC:
1058     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1059     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1060       arch = bfd_arch_i386;
1061       machine = 0;
1062       break;
1063 #endif
1064 #ifdef A29K_MAGIC_BIG
1065     case A29K_MAGIC_BIG:
1066     case A29K_MAGIC_LITTLE:
1067       arch = bfd_arch_a29k;
1068       machine = 0;
1069       break;
1070 #endif
1071 #ifdef ARMMAGIC
1072     case ARMMAGIC:
1073       arch = bfd_arch_arm;
1074       machine =0;
1075       break;
1076 #endif
1077 #ifdef MC68MAGIC
1078     case MC68MAGIC:
1079     case M68MAGIC:
1080 #ifdef MC68KBCSMAGIC
1081     case MC68KBCSMAGIC:
1082 #endif
1083 #ifdef APOLLOM68KMAGIC
1084     case APOLLOM68KMAGIC:
1085 #endif
1086 #ifdef LYNXCOFFMAGIC
1087     case LYNXCOFFMAGIC:
1088 #endif
1089       arch = bfd_arch_m68k;
1090       machine = 68020;
1091       break;
1092 #endif
1093 #ifdef MC88MAGIC
1094     case MC88MAGIC:
1095     case MC88DMAGIC:
1096     case MC88OMAGIC:
1097       arch = bfd_arch_m88k;
1098       machine = 88100;
1099       break;
1100 #endif
1101 #ifdef Z8KMAGIC
1102     case Z8KMAGIC:
1103       arch = bfd_arch_z8k;
1104       switch (internal_f->f_flags & F_MACHMASK)
1105         {
1106         case F_Z8001:
1107           machine = bfd_mach_z8001;
1108           break;
1109         case F_Z8002:
1110           machine = bfd_mach_z8002;
1111           break;
1112         default:
1113           return false;
1114         }
1115       break;
1116 #endif
1117 #ifdef I960
1118 #ifdef I960ROMAGIC
1119     case I960ROMAGIC:
1120     case I960RWMAGIC:
1121       arch = bfd_arch_i960;
1122       switch (F_I960TYPE & internal_f->f_flags)
1123         {
1124         default:
1125         case F_I960CORE:
1126           machine = bfd_mach_i960_core;
1127           break;
1128         case F_I960KB:
1129           machine = bfd_mach_i960_kb_sb;
1130           break;
1131         case F_I960MC:
1132           machine = bfd_mach_i960_mc;
1133           break;
1134         case F_I960XA:
1135           machine = bfd_mach_i960_xa;
1136           break;
1137         case F_I960CA:
1138           machine = bfd_mach_i960_ca;
1139           break;
1140         case F_I960KA:
1141           machine = bfd_mach_i960_ka_sa;
1142           break;
1143           /* start-sanitize-i960xl */
1144         case F_I960XL:
1145           machine = bfd_mach_i960_xl;
1146           break;
1147           /* end-sanitize-i960xl */
1148         }
1149       break;
1150 #endif
1151 #endif
1152
1153 #ifdef RS6000COFF_C
1154     case U802ROMAGIC:
1155     case U802WRMAGIC:
1156     case U802TOCMAGIC:
1157       {
1158         int cputype;
1159
1160         if (xcoff_data (abfd)->cputype != -1)
1161           cputype = xcoff_data (abfd)->cputype & 0xff;
1162         else
1163           {
1164             /* We did not get a value from the a.out header.  If the
1165                file has not been stripped, we may be able to get the
1166                architecture information from the first symbol, if it
1167                is a .file symbol.  */
1168             if (obj_raw_syment_count (abfd) == 0)
1169               cputype = 0;
1170             else
1171               {
1172                 bfd_byte buf[SYMESZ];
1173                 struct internal_syment sym;
1174
1175                 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1176                     || bfd_read (buf, 1, SYMESZ, abfd) != SYMESZ)
1177                   return false;
1178                 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1179                 if (sym.n_sclass == C_FILE)
1180                   cputype = sym.n_type & 0xff;
1181                 else
1182                   cputype = 0;
1183               }
1184           }
1185
1186         /* FIXME: We don't handle all cases here.  */
1187         switch (cputype)
1188           {
1189           default:
1190           case 0:
1191 #ifdef POWERMAC
1192             /* PowerPC Macs use the same magic numbers as RS/6000
1193                (because that's how they were bootstrapped originally),
1194                but they are always PowerPC architecture.  */
1195             arch = bfd_arch_powerpc;
1196             machine = 601;
1197 #else
1198             arch = bfd_arch_rs6000;
1199             machine = 6000;
1200 #endif /* POWERMAC */
1201             break;
1202
1203           case 1:
1204             arch = bfd_arch_powerpc;
1205             machine = 601;
1206             break;
1207           case 2: /* 64 bit PowerPC */
1208             arch = bfd_arch_powerpc;
1209             machine = 620;
1210             break;
1211           case 3:
1212             arch = bfd_arch_powerpc;
1213             machine = 0;
1214             break;
1215           case 4:
1216             arch = bfd_arch_rs6000;
1217             machine = 6000;
1218             break;
1219           }
1220       }
1221       break;
1222 #endif
1223
1224 #ifdef WE32KMAGIC
1225     case WE32KMAGIC:
1226       arch = bfd_arch_we32k;
1227       machine = 0;
1228       break;
1229 #endif
1230
1231 #ifdef H8300MAGIC
1232     case H8300MAGIC:
1233       arch = bfd_arch_h8300;
1234       machine = bfd_mach_h8300;
1235       /* !! FIXME this probably isn't the right place for this */
1236       abfd->flags |= BFD_IS_RELAXABLE;
1237       break;
1238 #endif
1239
1240 #ifdef H8300HMAGIC
1241     case H8300HMAGIC:
1242       arch = bfd_arch_h8300;
1243       machine = bfd_mach_h8300h;
1244       /* !! FIXME this probably isn't the right place for this */
1245       abfd->flags |= BFD_IS_RELAXABLE;
1246       break;
1247 #endif
1248
1249 #ifdef SH_ARCH_MAGIC_BIG
1250     case SH_ARCH_MAGIC_BIG:
1251     case SH_ARCH_MAGIC_LITTLE:
1252       arch = bfd_arch_sh;
1253       machine = 0;
1254       break;
1255 #endif
1256
1257 #ifdef H8500MAGIC
1258     case H8500MAGIC:
1259       arch = bfd_arch_h8500;
1260       machine = 0;
1261       break;
1262 #endif
1263
1264 #ifdef SPARCMAGIC
1265     case SPARCMAGIC:
1266 #ifdef LYNXCOFFMAGIC
1267     case LYNXCOFFMAGIC:
1268 #endif
1269       arch = bfd_arch_sparc;
1270       machine = 0;
1271       break;
1272 #endif
1273
1274     default:                    /* Unreadable input file type */
1275       arch = bfd_arch_obscure;
1276       break;
1277     }
1278
1279   bfd_default_set_arch_mach (abfd, arch, machine);
1280   return true;
1281 }
1282
1283 #ifdef SYMNAME_IN_DEBUG
1284
1285 static boolean
1286 symname_in_debug_hook (abfd, sym)
1287      bfd * abfd;
1288      struct internal_syment *sym;
1289 {
1290   return SYMNAME_IN_DEBUG (sym) ? true : false;
1291 }
1292
1293 #else
1294
1295 #define symname_in_debug_hook \
1296   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1297
1298 #endif
1299
1300 #ifdef RS6000COFF_C
1301
1302 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
1303
1304 static boolean coff_pointerize_aux_hook
1305   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1306            unsigned int, combined_entry_type *));
1307
1308 /*ARGSUSED*/
1309 static boolean
1310 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1311      bfd *abfd;
1312      combined_entry_type *table_base;
1313      combined_entry_type *symbol;
1314      unsigned int indaux;
1315      combined_entry_type *aux;
1316 {
1317   int class = symbol->u.syment.n_sclass;
1318
1319   if ((class == C_EXT || class == C_HIDEXT)
1320       && indaux + 1 == symbol->u.syment.n_numaux)
1321     {
1322       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
1323         {
1324           aux->u.auxent.x_csect.x_scnlen.p =
1325             table_base + aux->u.auxent.x_csect.x_scnlen.l;
1326           aux->fix_scnlen = 1;
1327         }
1328
1329       /* Return true to indicate that the caller should not do any
1330          further work on this auxent.  */
1331       return true;
1332     }
1333
1334   /* Return false to indicate that this auxent should be handled by
1335      the caller.  */
1336   return false;
1337 }
1338
1339 #else
1340 #ifdef I960
1341
1342 /* We don't want to pointerize bal entries.  */
1343
1344 static boolean coff_pointerize_aux_hook
1345   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1346            unsigned int, combined_entry_type *));
1347
1348 /*ARGSUSED*/
1349 static boolean
1350 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1351      bfd *abfd;
1352      combined_entry_type *table_base;
1353      combined_entry_type *symbol;
1354      unsigned int indaux;
1355      combined_entry_type *aux;
1356 {
1357   /* Return true if we don't want to pointerize this aux entry, which
1358      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
1359   return indaux == 1 && symbol->u.syment.n_sclass == C_LEAFPROC;
1360 }
1361
1362 #else /* ! I960 */
1363
1364 #define coff_pointerize_aux_hook 0
1365
1366 #endif /* ! I960 */
1367 #endif /* ! RS6000COFF_C */
1368
1369 /* Print an aux entry.  This returns true if it has printed it.  */
1370
1371 static boolean coff_print_aux
1372   PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1373            combined_entry_type *, unsigned int));
1374
1375 static boolean
1376 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
1377      bfd *abfd;
1378      FILE *file;
1379      combined_entry_type *table_base;
1380      combined_entry_type *symbol;
1381      combined_entry_type *aux;
1382      unsigned int indaux;
1383 {
1384 #ifdef RS6000COFF_C
1385   if ((symbol->u.syment.n_sclass == C_EXT
1386        || symbol->u.syment.n_sclass == C_HIDEXT)
1387       && indaux + 1 == symbol->u.syment.n_numaux)
1388     {
1389       /* This is a csect entry.  */
1390       fprintf (file, "AUX ");
1391       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
1392         {
1393           BFD_ASSERT (! aux->fix_scnlen);
1394           fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
1395         }
1396       else
1397         {
1398           fprintf (file, "indx ");
1399           if (! aux->fix_scnlen)
1400             fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
1401           else
1402             fprintf (file, "%4ld",
1403                      (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
1404         }
1405       fprintf (file,
1406                " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1407                aux->u.auxent.x_csect.x_parmhash,
1408                (unsigned int) aux->u.auxent.x_csect.x_snhash,
1409                SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
1410                SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
1411                (unsigned int) aux->u.auxent.x_csect.x_smclas,
1412                aux->u.auxent.x_csect.x_stab,
1413                (unsigned int) aux->u.auxent.x_csect.x_snstab);
1414       return true;
1415     }
1416 #endif
1417
1418   /* Return false to indicate that no special action was taken.  */
1419   return false;
1420 }
1421
1422 /*
1423 SUBSUBSECTION
1424         Writing relocations
1425
1426         To write relocations, the back end steps though the
1427         canonical relocation table and create an
1428         @code{internal_reloc}. The symbol index to use is removed from
1429         the @code{offset} field in the symbol table supplied.  The
1430         address comes directly from the sum of the section base
1431         address and the relocation offset; the type is dug directly
1432         from the howto field.  Then the @code{internal_reloc} is
1433         swapped into the shape of an @code{external_reloc} and written
1434         out to disk.
1435
1436 */
1437
1438 static boolean
1439 coff_write_relocs (abfd, first_undef)
1440      bfd * abfd;
1441      int first_undef;
1442 {
1443   asection *s;
1444   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1445     {
1446       unsigned int i;
1447       struct external_reloc dst;
1448
1449       arelent **p = s->orelocation;
1450       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1451         return false;
1452       for (i = 0; i < s->reloc_count; i++)
1453         {
1454           struct internal_reloc n;
1455           arelent *q = p[i];
1456           memset ((PTR) & n, 0, sizeof (n));
1457
1458           /* Now we've renumbered the symbols we know where the
1459              undefined symbols live in the table.  Check the reloc
1460              entries for symbols who's output bfd isn't the right one.
1461              This is because the symbol was undefined (which means
1462              that all the pointers are never made to point to the same
1463              place). This is a bad thing,'cause the symbols attached
1464              to the output bfd are indexed, so that the relocation
1465              entries know which symbol index they point to.  So we
1466              have to look up the output symbol here. */
1467
1468           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1469             {
1470               int i;
1471               const char *sname = q->sym_ptr_ptr[0]->name;
1472               asymbol **outsyms = abfd->outsymbols;
1473               for (i = first_undef; outsyms[i]; i++)
1474                 {
1475                   const char *intable = outsyms[i]->name;
1476                   if (strcmp (intable, sname) == 0) {
1477                     /* got a hit, so repoint the reloc */
1478                     q->sym_ptr_ptr = outsyms + i;
1479                     break;
1480                   }
1481                 }
1482             }
1483
1484           n.r_vaddr = q->address + s->vma;
1485
1486 #ifdef R_IHCONST
1487           /* The 29k const/consth reloc pair is a real kludge.  The consth
1488              part doesn't have a symbol; it has an offset.  So rebuilt
1489              that here.  */
1490           if (q->howto->type == R_IHCONST)
1491             n.r_symndx = q->addend;
1492           else
1493 #endif
1494             if (q->sym_ptr_ptr)
1495               {
1496                 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1497                   /* This is a relocation relative to the absolute symbol.  */
1498                   n.r_symndx = -1;
1499                 else
1500                   {
1501                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1502                     /* Take notice if the symbol reloc points to a symbol
1503                        we don't have in our symbol table.  What should we
1504                        do for this??  */
1505                     if (n.r_symndx > obj_conv_table_size (abfd))
1506                       abort ();
1507                   }
1508               }
1509
1510 #ifdef SWAP_OUT_RELOC_OFFSET
1511           n.r_offset = q->addend;
1512 #endif
1513
1514 #ifdef SELECT_RELOC
1515           /* Work out reloc type from what is required */
1516           SELECT_RELOC (n, q->howto);
1517 #else
1518           n.r_type = q->howto->type;
1519 #endif
1520           coff_swap_reloc_out (abfd, &n, &dst);
1521           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1522             return false;
1523         }
1524     }
1525
1526   return true;
1527 }
1528
1529 /* Set flags and magic number of a coff file from architecture and machine
1530    type.  Result is true if we can represent the arch&type, false if not.  */
1531
1532 static boolean
1533 coff_set_flags (abfd, magicp, flagsp)
1534      bfd * abfd;
1535      unsigned *magicp;
1536      unsigned short *flagsp;
1537 {
1538   switch (bfd_get_arch (abfd))
1539     {
1540 #ifdef Z8KMAGIC
1541     case bfd_arch_z8k:
1542       *magicp = Z8KMAGIC;
1543       switch (bfd_get_mach (abfd))
1544         {
1545         case bfd_mach_z8001:
1546           *flagsp = F_Z8001;
1547           break;
1548         case bfd_mach_z8002:
1549           *flagsp = F_Z8002;
1550           break;
1551         default:
1552           return false;
1553         }
1554       return true;
1555 #endif
1556 #ifdef I960ROMAGIC
1557
1558     case bfd_arch_i960:
1559
1560       {
1561         unsigned flags;
1562         *magicp = I960ROMAGIC;
1563         /*
1564           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1565           I960RWMAGIC);   FIXME???
1566           */
1567         switch (bfd_get_mach (abfd))
1568           {
1569           case bfd_mach_i960_core:
1570             flags = F_I960CORE;
1571             break;
1572           case bfd_mach_i960_kb_sb:
1573             flags = F_I960KB;
1574             break;
1575           case bfd_mach_i960_mc:
1576             flags = F_I960MC;
1577             break;
1578           case bfd_mach_i960_xa:
1579             flags = F_I960XA;
1580             break;
1581           case bfd_mach_i960_ca:
1582             flags = F_I960CA;
1583             break;
1584           case bfd_mach_i960_ka_sa:
1585             flags = F_I960KA;
1586             break;
1587             /* start-sanitize-i960xl */
1588           case bfd_mach_i960_xl:
1589             flags = F_I960XL;
1590             break;
1591             /* end-sanitize-i960xl */
1592           default:
1593             return false;
1594           }
1595         *flagsp = flags;
1596         return true;
1597       }
1598       break;
1599 #endif
1600 #ifdef ARMMAGIC
1601     case bfd_arch_arm:
1602       *magicp = ARMMAGIC;
1603       return true;
1604 #endif
1605 #ifdef PPCMAGIC
1606     case bfd_arch_powerpc:
1607       *magicp = PPCMAGIC;
1608       return true;
1609       break;
1610 #endif
1611 #ifdef I386MAGIC
1612     case bfd_arch_i386:
1613       *magicp = I386MAGIC;
1614 #ifdef LYNXOS
1615       /* Just overwrite the usual value if we're doing Lynx. */
1616       *magicp = LYNXCOFFMAGIC;
1617 #endif
1618       return true;
1619       break;
1620 #endif
1621 #ifdef MC68MAGIC
1622     case bfd_arch_m68k:
1623 #ifdef APOLLOM68KMAGIC
1624       *magicp = APOLLO_COFF_VERSION_NUMBER;
1625 #else
1626       *magicp = MC68MAGIC;
1627 #endif
1628 #ifdef LYNXOS
1629       /* Just overwrite the usual value if we're doing Lynx. */
1630       *magicp = LYNXCOFFMAGIC;
1631 #endif
1632       return true;
1633       break;
1634 #endif
1635
1636 #ifdef MC88MAGIC
1637     case bfd_arch_m88k:
1638       *magicp = MC88OMAGIC;
1639       return true;
1640       break;
1641 #endif
1642 #ifdef H8300MAGIC
1643     case bfd_arch_h8300:
1644       switch (bfd_get_mach (abfd))
1645         {
1646         case bfd_mach_h8300:
1647           *magicp = H8300MAGIC;
1648           return true;
1649         case bfd_mach_h8300h:
1650           *magicp = H8300HMAGIC;
1651           return true;
1652         }
1653       break;
1654 #endif
1655
1656 #ifdef SH_ARCH_MAGIC_BIG
1657     case bfd_arch_sh:
1658       if (abfd->xvec->byteorder_big_p)
1659         *magicp = SH_ARCH_MAGIC_BIG;
1660       else
1661         *magicp = SH_ARCH_MAGIC_LITTLE;
1662       return true;
1663       break;
1664 #endif
1665
1666 #ifdef SPARCMAGIC
1667     case bfd_arch_sparc:
1668       *magicp = SPARCMAGIC;
1669 #ifdef LYNXOS
1670       /* Just overwrite the usual value if we're doing Lynx. */
1671       *magicp = LYNXCOFFMAGIC;
1672 #endif
1673       return true;
1674       break;
1675 #endif
1676
1677 #ifdef H8500MAGIC
1678     case bfd_arch_h8500:
1679       *magicp = H8500MAGIC;
1680       return true;
1681       break;
1682 #endif
1683 #ifdef A29K_MAGIC_BIG
1684     case bfd_arch_a29k:
1685       if (abfd->xvec->byteorder_big_p)
1686         *magicp = A29K_MAGIC_BIG;
1687       else
1688         *magicp = A29K_MAGIC_LITTLE;
1689       return true;
1690       break;
1691 #endif
1692
1693 #ifdef WE32KMAGIC
1694     case bfd_arch_we32k:
1695       *magicp = WE32KMAGIC;
1696       return true;
1697       break;
1698 #endif
1699
1700 #ifdef U802TOCMAGIC
1701     case bfd_arch_rs6000:
1702 #ifndef PPCMAGIC
1703     case bfd_arch_powerpc:
1704 #endif
1705       *magicp = U802TOCMAGIC;
1706       return true;
1707       break;
1708 #endif
1709
1710     default:                    /* Unknown architecture */
1711       /* return false;  -- fall through to "return false" below, to avoid
1712        "statement never reached" errors on the one below. */
1713       break;
1714     }
1715
1716   return false;
1717 }
1718
1719
1720 static boolean
1721 coff_set_arch_mach (abfd, arch, machine)
1722      bfd * abfd;
1723      enum bfd_architecture arch;
1724      unsigned long machine;
1725 {
1726   unsigned dummy1;
1727   unsigned short dummy2;
1728
1729   if (! bfd_default_set_arch_mach (abfd, arch, machine))
1730     return false;
1731
1732   if (arch != bfd_arch_unknown &&
1733       coff_set_flags (abfd, &dummy1, &dummy2) != true)
1734     return false;               /* We can't represent this type */
1735
1736   return true;                  /* We're easy ... */
1737 }
1738
1739
1740 /* Calculate the file position for each section. */
1741
1742 static void
1743 coff_compute_section_file_positions (abfd)
1744      bfd * abfd;
1745 {
1746   asection *current;
1747   asection *previous = (asection *) NULL;
1748   file_ptr sofar = FILHSZ;
1749
1750 #ifndef I960
1751   file_ptr old_sofar;
1752 #endif
1753   unsigned int count;
1754
1755
1756 #ifdef COFF_IMAGE_WITH_PE
1757   int page_size;
1758   if (coff_data (abfd)->link_info)
1759     {
1760       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
1761     }
1762   else
1763     page_size = PE_DEF_FILE_ALIGNMENT;
1764 #elif defined (COFF_PAGE_SIZE)
1765   int page_size = COFF_PAGE_SIZE;
1766 #endif
1767
1768   if (bfd_get_start_address (abfd))
1769     {
1770       /*  A start address may have been added to the original file. In this
1771           case it will need an optional header to record it.  */
1772       abfd->flags |= EXEC_P;
1773     }
1774
1775   if (abfd->flags & EXEC_P)
1776     sofar += AOUTSZ;
1777 #ifdef RS6000COFF_C
1778   else if (xcoff_data (abfd)->full_aouthdr)
1779     sofar += AOUTSZ;
1780   else
1781     sofar += SMALL_AOUTSZ;
1782 #endif
1783
1784   sofar += abfd->section_count * SCNHSZ;
1785   for (current = abfd->sections, count = 1;
1786        current != (asection *) NULL;
1787        current = current->next, ++count)
1788     {
1789       current->target_index = count;
1790
1791       /* Only deal with sections which have contents */
1792       if (!(current->flags & SEC_HAS_CONTENTS))
1793         continue;
1794
1795 #ifdef COFF_WITH_PE
1796       /* Do not include the .junk section.  This is where we collect section
1797          data which we don't need.  This is mainly the MS .debug$ data which
1798          stores codeview debug data. */
1799       if (strcmp (current->name, ".junk") == 0)
1800         {
1801           continue;
1802         }
1803 #endif
1804
1805       /* Align the sections in the file to the same boundary on
1806          which they are aligned in virtual memory.  I960 doesn't
1807          do this (FIXME) so we can stay in sync with Intel.  960
1808          doesn't yet page from files... */
1809 #ifndef I960
1810       {
1811         /* make sure this section is aligned on the right boundary - by
1812            padding the previous section up if necessary */
1813
1814         old_sofar = sofar;
1815         sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1816         if (previous != (asection *) NULL)
1817           {
1818             previous->_raw_size += sofar - old_sofar;
1819           }
1820       }
1821
1822 #endif
1823
1824       /* In demand paged files the low order bits of the file offset
1825          must match the low order bits of the virtual address.  */
1826 #ifdef COFF_PAGE_SIZE
1827       if ((abfd->flags & D_PAGED) != 0
1828           && (current->flags & SEC_ALLOC) != 0)
1829         sofar += (current->vma - sofar) % page_size;
1830 #endif
1831       current->filepos = sofar;
1832
1833 #ifdef COFF_IMAGE_WITH_PE
1834       /* With PE we have to pad each section to be a multiple of its page size
1835          too, and remember both sizes. Cooked_size becomes very useful. */
1836       current->_cooked_size = current->_raw_size;
1837       current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
1838 #endif
1839
1840       sofar += current->_raw_size;
1841
1842 #ifndef I960
1843       /* make sure that this section is of the right size too */
1844       old_sofar = sofar;
1845       sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1846       current->_raw_size += sofar - old_sofar;
1847 #endif
1848
1849 #ifdef _LIB
1850       /* Force .lib sections to start at zero.  The vma is then
1851          incremented in coff_set_section_contents.  This is right for
1852          SVR3.2.  */
1853       if (strcmp (current->name, _LIB) == 0)
1854         bfd_set_section_vma (abfd, current, 0);
1855 #endif
1856
1857       previous = current;
1858     }
1859
1860   obj_relocbase (abfd) = sofar;
1861   abfd->output_has_begun = true;
1862
1863 }
1864
1865 #ifndef RS6000COFF_C
1866
1867 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1868 /* @@ Should we only be adding missing symbols, or overriding the aux
1869    values for existing section symbols?  */
1870 static boolean
1871 coff_add_missing_symbols (abfd)
1872      bfd *abfd;
1873 {
1874   unsigned int nsyms = bfd_get_symcount (abfd);
1875   asymbol **sympp = abfd->outsymbols;
1876   asymbol **sympp2;
1877   unsigned int i;
1878   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1879
1880   for (i = 0; i < nsyms; i++)
1881     {
1882       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1883       CONST char *name;
1884       if (csym)
1885         {
1886           /* only do this if there is a coff representation of the input
1887            symbol */
1888           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1889             {
1890               need_file = 0;
1891               continue;
1892             }
1893           name = csym->symbol.name;
1894           if (!name)
1895             continue;
1896           if (!strcmp (name, _TEXT))
1897             need_text = 0;
1898 #ifdef APOLLO_M68
1899           else if (!strcmp (name, ".wtext"))
1900             need_text = 0;
1901 #endif
1902           else if (!strcmp (name, _DATA))
1903             need_data = 0;
1904           else if (!strcmp (name, _BSS))
1905             need_bss = 0;
1906         }
1907     }
1908   /* Now i == bfd_get_symcount (abfd).  */
1909   /* @@ For now, don't deal with .file symbol.  */
1910   need_file = 0;
1911
1912   if (!need_text && !need_data && !need_bss && !need_file)
1913     return true;
1914   nsyms += need_text + need_data + need_bss + need_file;
1915   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1916   if (!sympp2)
1917     {
1918       bfd_set_error (bfd_error_no_memory);
1919       return false;
1920     }
1921   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1922   if (need_file)
1923     {
1924       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1925       abort ();
1926     }
1927   if (need_text)
1928     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1929   if (need_data)
1930     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1931   if (need_bss)
1932     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1933   BFD_ASSERT (i == nsyms);
1934   bfd_set_symtab (abfd, sympp2, nsyms);
1935   return true;
1936 }
1937
1938 #endif /* ! defined (RS6000COFF_C) */
1939
1940
1941
1942 /* SUPPRESS 558 */
1943 /* SUPPRESS 529 */
1944 static boolean
1945 coff_write_object_contents (abfd)
1946      bfd * abfd;
1947 {
1948   asection *current;
1949   boolean hasrelocs = false;
1950   boolean haslinno = false;
1951   file_ptr scn_base;
1952   file_ptr reloc_base;
1953   file_ptr lineno_base;
1954   file_ptr sym_base;
1955   unsigned long reloc_size = 0;
1956   unsigned long lnno_size = 0;
1957   asection *text_sec = NULL;
1958   asection *data_sec = NULL;
1959   asection *bss_sec = NULL;
1960
1961   struct internal_filehdr internal_f;
1962   struct internal_aouthdr internal_a;
1963
1964   bfd_set_error (bfd_error_system_call);
1965
1966   if (abfd->output_has_begun == false)
1967     coff_compute_section_file_positions (abfd);
1968
1969   reloc_base = obj_relocbase (abfd);
1970
1971   /* Make a pass through the symbol table to count line number entries and
1972      put them into the correct asections */
1973
1974   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
1975
1976   /* Work out the size of the reloc and linno areas */
1977
1978   for (current = abfd->sections; current != NULL; current =
1979        current->next)
1980     reloc_size += current->reloc_count * RELSZ;
1981
1982   lineno_base = reloc_base + reloc_size;
1983   sym_base = lineno_base + lnno_size;
1984
1985   /* Indicate in each section->line_filepos its actual file address */
1986   for (current = abfd->sections; current != NULL; current =
1987        current->next)
1988     {
1989       if (current->lineno_count)
1990         {
1991           current->line_filepos = lineno_base;
1992           current->moving_line_filepos = lineno_base;
1993           lineno_base += current->lineno_count * LINESZ;
1994         }
1995       else
1996         {
1997           current->line_filepos = 0;
1998         }
1999       if (current->reloc_count)
2000         {
2001           current->rel_filepos = reloc_base;
2002           reloc_base += current->reloc_count * RELSZ;
2003         }
2004       else
2005         {
2006           current->rel_filepos = 0;
2007         }
2008     }
2009
2010   /* Write section headers to the file.  */
2011   internal_f.f_nscns = 0;
2012
2013   if ((abfd->flags & EXEC_P) != 0)
2014     scn_base = FILHSZ + AOUTSZ;
2015   else
2016     {
2017       scn_base = FILHSZ;
2018 #ifdef RS6000COFF_C
2019       if (xcoff_data (abfd)->full_aouthdr)
2020         scn_base += AOUTSZ;
2021       else
2022         scn_base += SMALL_AOUTSZ;
2023 #endif
2024     }
2025
2026   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
2027     return false;
2028
2029   for (current = abfd->sections;
2030        current != NULL;
2031        current = current->next)
2032     {
2033       struct internal_scnhdr section;
2034
2035 #ifdef COFF_WITH_PE
2036       /* Do not include the .junk section.  This is where we collect section
2037          data which we don't need.  This is mainly the MS .debug$ data which
2038          stores codeview debug data. */
2039       if (strcmp (current->name, ".junk") == 0)
2040         {
2041           continue;
2042         }
2043
2044       /* If we've got a .reloc section, remember. */
2045
2046 #ifdef COFF_IMAGE_WITH_PE
2047       if (strcmp (current->name, ".reloc") == 0)
2048         {
2049           pe_data (abfd)->has_reloc_section = 1;
2050         }
2051 #endif
2052
2053 #endif
2054       internal_f.f_nscns++;
2055       strncpy (&(section.s_name[0]), current->name, 8);
2056 #ifdef _LIB
2057       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
2058          Ian Taylor <[email protected]>.  */
2059       if (strcmp (current->name, _LIB) == 0)
2060         section.s_vaddr = 0;
2061       else
2062 #endif
2063       section.s_vaddr = current->lma;
2064       section.s_paddr = current->lma;
2065       section.s_size =  current->_raw_size;
2066
2067 #ifdef COFF_WITH_PE
2068       section.s_paddr = current->_cooked_size;
2069 #endif
2070
2071       /*
2072          If this section has no size or is unloadable then the scnptr
2073          will be 0 too
2074          */
2075       if (current->_raw_size == 0 ||
2076           (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2077         {
2078           section.s_scnptr = 0;
2079         }
2080       else
2081         {
2082           section.s_scnptr = current->filepos;
2083         }
2084       section.s_relptr = current->rel_filepos;
2085       section.s_lnnoptr = current->line_filepos;
2086       section.s_nreloc = current->reloc_count;
2087       section.s_nlnno = current->lineno_count;
2088       if (current->reloc_count != 0)
2089         hasrelocs = true;
2090       if (current->lineno_count != 0)
2091         haslinno = true;
2092
2093       section.s_flags = sec_to_styp_flags (current->name, current->flags);
2094
2095       if (!strcmp (current->name, _TEXT))
2096         {
2097           text_sec = current;
2098         }
2099       else if (!strcmp (current->name, _DATA))
2100         {
2101           data_sec = current;
2102         }
2103       else if (!strcmp (current->name, _BSS))
2104         {
2105           bss_sec = current;
2106         }
2107
2108 #ifdef I960
2109       section.s_align = (current->alignment_power
2110                          ? 1 << current->alignment_power
2111                          : 0);
2112
2113 #endif
2114
2115 #ifdef COFF_IMAGE_WITH_PE
2116       /* suppress output of the sections if they are null.  ld includes
2117          the bss and data sections even if there is no size assigned
2118          to them.  NT loader doesn't like it if these section headers are
2119          included if the sections themselves are not needed */
2120       if (section.s_size == 0)
2121         internal_f.f_nscns--;
2122       else
2123 #endif
2124         {
2125           SCNHDR buff;
2126           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2127               || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2128             return false;
2129         }
2130     }
2131
2132
2133
2134   /* OK, now set up the filehdr... */
2135
2136   /* Don't include the internal abs section in the section count */
2137
2138   /*
2139      We will NOT put a fucking timestamp in the header here. Every time you
2140      put it back, I will come in and take it out again.  I'm sorry.  This
2141      field does not belong here.  We fill it with a 0 so it compares the
2142      same but is not a reasonable time. -- [email protected]
2143      */
2144   internal_f.f_timdat = 0;
2145
2146   internal_f.f_flags = 0;
2147
2148   if (abfd->flags & EXEC_P)
2149     internal_f.f_opthdr = AOUTSZ;
2150   else
2151     {
2152       internal_f.f_opthdr = 0;
2153 #ifdef RS6000COFF_C
2154       if (xcoff_data (abfd)->full_aouthdr)
2155         internal_f.f_opthdr = AOUTSZ;
2156       else
2157         internal_f.f_opthdr = SMALL_AOUTSZ;
2158 #endif
2159     }
2160
2161   if (!hasrelocs)
2162     internal_f.f_flags |= F_RELFLG;
2163   if (!haslinno)
2164     internal_f.f_flags |= F_LNNO;
2165   if (abfd->flags & EXEC_P)
2166     internal_f.f_flags |= F_EXEC;
2167
2168   if (!abfd->xvec->byteorder_big_p)
2169     internal_f.f_flags |= F_AR32WR;
2170   else
2171     internal_f.f_flags |= F_AR32W;
2172
2173   /*
2174      FIXME, should do something about the other byte orders and
2175      architectures.
2176      */
2177
2178 #ifdef RS6000COFF_C
2179   if ((abfd->flags & DYNAMIC) != 0)
2180     internal_f.f_flags |= F_SHROBJ;
2181   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
2182     internal_f.f_flags |= F_DYNLOAD;
2183 #endif
2184
2185   memset (&internal_a, 0, sizeof internal_a);
2186
2187   /* Set up architecture-dependent stuff */
2188
2189   {
2190     unsigned int magic = 0;
2191     unsigned short flags = 0;
2192     coff_set_flags (abfd, &magic, &flags);
2193     internal_f.f_magic = magic;
2194     internal_f.f_flags |= flags;
2195     /* ...and the "opt"hdr... */
2196
2197 #ifdef A29K
2198 #ifdef ULTRA3                   /* NYU's machine */
2199     /* FIXME: This is a bogus check.  I really want to see if there
2200      * is a .shbss or a .shdata section, if so then set the magic
2201      * number to indicate a shared data executable.
2202      */
2203     if (internal_f.f_nscns >= 7)
2204       internal_a.magic = SHMAGIC; /* Shared magic */
2205     else
2206 #endif /* ULTRA3 */
2207       internal_a.magic = NMAGIC; /* Assume separate i/d */
2208 #define __A_MAGIC_SET__
2209 #endif /* A29K */
2210 #ifdef I960
2211     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
2212 #define __A_MAGIC_SET__
2213 #endif /* I960 */
2214 #if M88
2215 #define __A_MAGIC_SET__
2216     internal_a.magic = PAGEMAGICBCS;
2217 #endif /* M88 */
2218
2219 #if APOLLO_M68
2220 #define __A_MAGIC_SET__
2221     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
2222 #endif
2223
2224 #if defined(M68) || defined(WE32K) || defined(M68K)
2225 #define __A_MAGIC_SET__
2226 #if defined(LYNXOS)
2227     internal_a.magic = LYNXCOFFMAGIC;
2228 #endif /* LYNXOS */
2229 #endif /* M68 || WE32K || M68K */
2230
2231 #if defined(ARM)
2232 #define __A_MAGIC_SET__
2233     internal_a.magic = ZMAGIC;
2234 #endif
2235 #if defined(PPC)
2236 #define __A_MAGIC_SET__
2237     internal_a.magic = PPCMAGIC;
2238 #endif
2239 #if defined(I386)
2240 #define __A_MAGIC_SET__
2241 #if defined(LYNXOS)
2242     internal_a.magic = LYNXCOFFMAGIC;
2243 #else  /* LYNXOS */
2244     internal_a.magic = ZMAGIC;
2245 #endif /* LYNXOS */
2246 #endif /* I386 */
2247
2248 #if defined(SPARC)
2249 #define __A_MAGIC_SET__
2250 #if defined(LYNXOS)
2251     internal_a.magic = LYNXCOFFMAGIC;
2252 #endif /* LYNXOS */
2253 #endif /* SPARC */
2254
2255 #if RS6000COFF_C
2256 #define __A_MAGIC_SET__
2257     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
2258     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
2259     RS6K_AOUTHDR_OMAGIC;
2260 #endif
2261
2262 #ifndef __A_MAGIC_SET__
2263 #include "Your aouthdr magic number is not being set!"
2264 #else
2265 #undef __A_MAGIC_SET__
2266 #endif
2267   }
2268
2269   /* FIXME: Does anybody ever set this to another value?  */
2270   internal_a.vstamp = 0;
2271
2272   /* Now should write relocs, strings, syms */
2273   obj_sym_filepos (abfd) = sym_base;
2274
2275   if (bfd_get_symcount (abfd) != 0)
2276     {
2277       int firstundef;
2278 #ifndef RS6000COFF_C
2279       if (!coff_add_missing_symbols (abfd))
2280         return false;
2281 #endif
2282       if (!coff_renumber_symbols (abfd, &firstundef))
2283         return false;
2284       coff_mangle_symbols (abfd);
2285       if (! coff_write_symbols (abfd))
2286         return false;
2287       if (! coff_write_linenumbers (abfd))
2288         return false;
2289       if (! coff_write_relocs (abfd, firstundef))
2290         return false;
2291     }
2292
2293   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2294      backend linker, and obj_raw_syment_count is not valid until after
2295      coff_write_symbols is called.  */
2296   if (obj_raw_syment_count (abfd) != 0)
2297     {
2298       internal_f.f_symptr = sym_base;
2299 #ifdef RS6000COFF_C
2300       /* AIX appears to require that F_RELFLG not be set if there are
2301          local symbols but no relocations.  */
2302       internal_f.f_flags &=~ F_RELFLG;
2303 #endif
2304     }
2305   else
2306     {
2307       internal_f.f_symptr = 0;
2308       internal_f.f_flags |= F_LSYMS;
2309     }
2310
2311   if (text_sec)
2312     {
2313       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
2314       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
2315     }
2316   if (data_sec)
2317     {
2318       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
2319       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
2320     }
2321   if (bss_sec)
2322     {
2323       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
2324       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
2325         internal_a.data_start = bss_sec->vma;
2326     }
2327
2328   internal_a.entry = bfd_get_start_address (abfd);
2329   internal_f.f_nsyms = obj_raw_syment_count (abfd);
2330
2331 #ifdef RS6000COFF_C
2332   if (xcoff_data (abfd)->full_aouthdr)
2333     {
2334       bfd_vma toc;
2335       asection *loader_sec;
2336
2337       if (xcoff_data (abfd)->entry_section != NULL)
2338         internal_a.o_snentry = xcoff_data (abfd)->entry_section->target_index;
2339       else
2340         {
2341           internal_a.o_snentry = 0;
2342           if (internal_a.entry == 0)
2343             internal_a.entry = (bfd_vma) -1;
2344         }
2345
2346       if (text_sec != NULL)
2347         {
2348           internal_a.o_sntext = text_sec->target_index;
2349           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
2350         }
2351       else
2352         {
2353           internal_a.o_sntext = 0;
2354           internal_a.o_algntext = 0;
2355         }
2356       if (data_sec != NULL)
2357         {
2358           internal_a.o_sndata = data_sec->target_index;
2359           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
2360         }
2361       else
2362         {
2363           internal_a.o_sndata = 0;
2364           internal_a.o_algndata = 0;
2365         }
2366       loader_sec = bfd_get_section_by_name (abfd, ".loader");
2367       if (loader_sec != NULL)
2368         internal_a.o_snloader = loader_sec->target_index;
2369       else
2370         internal_a.o_snloader = 0;
2371       if (bss_sec != NULL)
2372         internal_a.o_snbss = bss_sec->target_index;
2373       else
2374         internal_a.o_snbss = 0;
2375
2376       toc = xcoff_data (abfd)->toc;
2377       internal_a.o_toc = toc;
2378       if (xcoff_data (abfd)->toc_section == NULL)
2379         internal_a.o_sntoc = 0;
2380       else
2381         internal_a.o_sntoc = xcoff_data (abfd)->toc_section->target_index;
2382
2383       internal_a.o_modtype = xcoff_data (abfd)->modtype;
2384       if (xcoff_data (abfd)->cputype != -1)
2385         internal_a.o_cputype = xcoff_data (abfd)->cputype;
2386       else
2387         {
2388           switch (bfd_get_arch (abfd))
2389             {
2390             case bfd_arch_rs6000:
2391               internal_a.o_cputype = 4;
2392               break;
2393             case bfd_arch_powerpc:
2394               if (bfd_get_mach (abfd) == 0)
2395                 internal_a.o_cputype = 3;
2396               else
2397                 internal_a.o_cputype = 1;
2398               break;
2399             default:
2400               abort ();
2401             }
2402         }
2403       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
2404       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
2405     }
2406 #endif
2407
2408   /* now write them */
2409   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2410     return false;
2411   {
2412     FILHDR buff;
2413     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
2414     if (bfd_write ((PTR) & buff, 1, FILHSZ, abfd) != FILHSZ)
2415       return false;
2416   }
2417   if (abfd->flags & EXEC_P)
2418     {
2419       AOUTHDR buff;
2420       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
2421       if (bfd_write ((PTR) & buff, 1, AOUTSZ, abfd) != AOUTSZ)
2422         return false;
2423     }
2424 #ifdef RS6000COFF_C
2425   else
2426     {
2427       AOUTHDR buff;
2428       size_t size;
2429
2430       /* XCOFF seems to always write at least a small a.out header.  */
2431       coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
2432       if (xcoff_data (abfd)->full_aouthdr)
2433         size = AOUTSZ;
2434       else
2435         size = SMALL_AOUTSZ;
2436       if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
2437         return false;
2438     }
2439 #endif
2440
2441   return true;
2442 }
2443
2444 static boolean
2445 coff_set_section_contents (abfd, section, location, offset, count)
2446      bfd * abfd;
2447      sec_ptr section;
2448      PTR location;
2449      file_ptr offset;
2450      bfd_size_type count;
2451 {
2452   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
2453     coff_compute_section_file_positions (abfd);
2454
2455 #ifdef _LIB
2456   /* If this is a .lib section, bump the vma address so that it
2457        winds up being the number of .lib sections output.  This is
2458        right for SVR3.2.  Shared libraries should probably get more
2459        generic support.  Ian Taylor <[email protected]>.  */
2460   if (strcmp (section->name, _LIB) == 0)
2461     ++section->lma;
2462 #endif
2463
2464   /* Don't write out bss sections - one way to do this is to
2465        see if the filepos has not been set. */
2466   if (section->filepos == 0)
2467     return true;
2468
2469   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
2470     return false;
2471
2472   if (count != 0)
2473     {
2474       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
2475     }
2476   return true;
2477 }
2478 #if 0
2479 static boolean
2480 coff_close_and_cleanup (abfd)
2481      bfd *abfd;
2482 {
2483   if (!bfd_read_p (abfd))
2484     switch (abfd->format)
2485       {
2486       case bfd_archive:
2487         if (!_bfd_write_archive_contents (abfd))
2488           return false;
2489         break;
2490       case bfd_object:
2491         if (!coff_write_object_contents (abfd))
2492           return false;
2493         break;
2494       default:
2495         bfd_set_error (bfd_error_invalid_operation);
2496         return false;
2497       }
2498
2499   /* We depend on bfd_close to free all the memory on the obstack.  */
2500   /* FIXME if bfd_release is not using obstacks! */
2501   return true;
2502 }
2503
2504 #endif
2505
2506 static PTR
2507 buy_and_read (abfd, where, seek_direction, size)
2508      bfd *abfd;
2509      file_ptr where;
2510      int seek_direction;
2511      size_t size;
2512 {
2513   PTR area = (PTR) bfd_alloc (abfd, size);
2514   if (!area)
2515     {
2516       bfd_set_error (bfd_error_no_memory);
2517       return (NULL);
2518     }
2519   if (bfd_seek (abfd, where, seek_direction) != 0
2520       || bfd_read (area, 1, size, abfd) != size)
2521     return (NULL);
2522   return (area);
2523 }                               /* buy_and_read() */
2524
2525 /*
2526 SUBSUBSECTION
2527         Reading linenumbers
2528
2529         Creating the linenumber table is done by reading in the entire
2530         coff linenumber table, and creating another table for internal use.
2531
2532         A coff linenumber table is structured so that each function
2533         is marked as having a line number of 0. Each line within the
2534         function is an offset from the first line in the function. The
2535         base of the line number information for the table is stored in
2536         the symbol associated with the function.
2537
2538         The information is copied from the external to the internal
2539         table, and each symbol which marks a function is marked by
2540         pointing its...
2541
2542         How does this work ?
2543
2544 */
2545
2546 static boolean
2547 coff_slurp_line_table (abfd, asect)
2548      bfd *abfd;
2549      asection *asect;
2550 {
2551   LINENO *native_lineno;
2552   alent *lineno_cache;
2553
2554   BFD_ASSERT (asect->lineno == (alent *) NULL);
2555
2556   native_lineno = (LINENO *) buy_and_read (abfd,
2557                                            asect->line_filepos,
2558                                            SEEK_SET,
2559                                            (size_t) (LINESZ *
2560                                                      asect->lineno_count));
2561   lineno_cache =
2562     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
2563   if (lineno_cache == NULL)
2564     {
2565       bfd_set_error (bfd_error_no_memory);
2566       return false;
2567     }
2568   else
2569     {
2570       unsigned int counter = 0;
2571       alent *cache_ptr = lineno_cache;
2572       LINENO *src = native_lineno;
2573
2574       while (counter < asect->lineno_count)
2575         {
2576           struct internal_lineno dst;
2577           coff_swap_lineno_in (abfd, src, &dst);
2578           cache_ptr->line_number = dst.l_lnno;
2579
2580           if (cache_ptr->line_number == 0)
2581             {
2582               coff_symbol_type *sym =
2583               (coff_symbol_type *) (dst.l_addr.l_symndx
2584                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
2585               cache_ptr->u.sym = (asymbol *) sym;
2586               if (sym->lineno != NULL)
2587                 {
2588                   (*_bfd_error_handler)
2589                     ("%s: warning: duplicate line number information for `%s'",
2590                      bfd_get_filename (abfd),
2591                      bfd_asymbol_name (&sym->symbol));
2592                 }
2593               sym->lineno = cache_ptr;
2594             }
2595           else
2596             {
2597               cache_ptr->u.offset = dst.l_addr.l_paddr
2598                 - bfd_section_vma (abfd, asect);
2599             }                   /* If no linenumber expect a symbol index */
2600
2601           cache_ptr++;
2602           src++;
2603           counter++;
2604         }
2605       cache_ptr->line_number = 0;
2606
2607     }
2608   asect->lineno = lineno_cache;
2609   /* FIXME, free native_lineno here, or use alloca or something. */
2610   return true;
2611 }
2612
2613 static boolean
2614 coff_slurp_symbol_table (abfd)
2615      bfd * abfd;
2616 {
2617   combined_entry_type *native_symbols;
2618   coff_symbol_type *cached_area;
2619   unsigned int *table_ptr;
2620
2621   unsigned int number_of_symbols = 0;
2622
2623   if (obj_symbols (abfd))
2624     return true;
2625
2626   /* Read in the symbol table */
2627   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
2628     {
2629       return (false);
2630     }                           /* on error */
2631
2632   /* Allocate enough room for all the symbols in cached form */
2633   cached_area = ((coff_symbol_type *)
2634                  bfd_alloc (abfd,
2635                             (obj_raw_syment_count (abfd)
2636                              * sizeof (coff_symbol_type))));
2637
2638   if (cached_area == NULL)
2639     {
2640       bfd_set_error (bfd_error_no_memory);
2641       return false;
2642     }                           /* on error */
2643   table_ptr = ((unsigned int *)
2644                bfd_alloc (abfd,
2645                           (obj_raw_syment_count (abfd)
2646                            * sizeof (unsigned int))));
2647
2648   if (table_ptr == NULL)
2649     {
2650       bfd_set_error (bfd_error_no_memory);
2651       return false;
2652     }
2653   else
2654     {
2655       coff_symbol_type *dst = cached_area;
2656       unsigned int last_native_index = obj_raw_syment_count (abfd);
2657       unsigned int this_index = 0;
2658       while (this_index < last_native_index)
2659         {
2660           combined_entry_type *src = native_symbols + this_index;
2661           table_ptr[this_index] = number_of_symbols;
2662           dst->symbol.the_bfd = abfd;
2663
2664           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
2665           /* We use the native name field to point to the cached field.  */
2666           src->u.syment._n._n_n._n_zeroes = (long) dst;
2667           dst->symbol.section = coff_section_from_bfd_index (abfd,
2668                                                      src->u.syment.n_scnum);
2669           dst->symbol.flags = 0;
2670           dst->done_lineno = false;
2671
2672           switch (src->u.syment.n_sclass)
2673             {
2674 #ifdef I960
2675             case C_LEAFEXT:
2676 #if 0
2677               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2678               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2679               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2680 #endif
2681               /* Fall through to next case */
2682
2683 #endif
2684
2685             case C_EXT:
2686 #ifdef RS6000COFF_C
2687             case C_HIDEXT:
2688 #endif
2689 #ifdef COFF_WITH_PE
2690             /* PE uses storage class 0x68 to denote a section symbol */
2691             case C_SECTION:
2692 #endif
2693               if ((src->u.syment.n_scnum) == 0)
2694                 {
2695                   if ((src->u.syment.n_value) == 0)
2696                     {
2697                       dst->symbol.section = bfd_und_section_ptr;
2698                       dst->symbol.value = 0;
2699                     }
2700                   else
2701                     {
2702                       dst->symbol.section = bfd_com_section_ptr;
2703                       dst->symbol.value = (src->u.syment.n_value);
2704                     }
2705                 }
2706               else
2707                 {
2708                   /* Base the value as an index from the base of the
2709                      section */
2710
2711                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2712                   dst->symbol.value = (src->u.syment.n_value
2713                                        - dst->symbol.section->vma);
2714
2715                   if (ISFCN ((src->u.syment.n_type)))
2716                     {
2717                       /* A function ext does not go at the end of a
2718                          file.  */
2719                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2720                     }
2721                 }
2722
2723 #ifdef RS6000COFF_C
2724               /* A C_HIDEXT symbol is not global.  */
2725               if (src->u.syment.n_sclass == C_HIDEXT)
2726                 dst->symbol.flags = BSF_LOCAL;
2727               /* A symbol with a csect entry should not go at the end.  */
2728               if (src->u.syment.n_numaux > 0)
2729                 dst->symbol.flags |= BSF_NOT_AT_END;
2730 #endif
2731
2732               break;
2733
2734             case C_STAT:        /* static                        */
2735 #ifdef I960
2736             case C_LEAFSTAT:    /* static leaf procedure        */
2737 #endif
2738             case C_LABEL:       /* label                         */
2739               if (src->u.syment.n_scnum == -2)
2740                 dst->symbol.flags = BSF_DEBUGGING;
2741               else
2742                 dst->symbol.flags = BSF_LOCAL;
2743               /*
2744           Base the value as an index from the base of the section, if
2745           there is one
2746           */
2747               if (dst->symbol.section)
2748                 dst->symbol.value = (src->u.syment.n_value) -
2749                   dst->symbol.section->vma;
2750               else
2751                 dst->symbol.value = (src->u.syment.n_value);
2752               break;
2753
2754             case C_MOS: /* member of structure   */
2755             case C_EOS: /* end of structure              */
2756 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
2757 #ifdef C_GLBLREG
2758             case C_GLBLREG:     /* A29k-specific storage class */
2759 #endif
2760 #endif
2761             case C_REGPARM:     /* register parameter            */
2762             case C_REG: /* register variable             */
2763 #ifdef C_AUTOARG
2764             case C_AUTOARG:     /* 960-specific storage class */
2765 #endif
2766             case C_TPDEF:       /* type definition               */
2767             case C_ARG:
2768             case C_AUTO:        /* automatic variable */
2769             case C_FIELD:       /* bit field */
2770             case C_ENTAG:       /* enumeration tag               */
2771             case C_MOE: /* member of enumeration         */
2772             case C_MOU: /* member of union               */
2773             case C_UNTAG:       /* union tag                     */
2774               dst->symbol.flags = BSF_DEBUGGING;
2775               dst->symbol.value = (src->u.syment.n_value);
2776               break;
2777
2778             case C_FILE:        /* file name                     */
2779             case C_STRTAG:      /* structure tag                 */
2780 #ifdef RS6000COFF_C
2781             case C_GSYM:
2782             case C_LSYM:
2783             case C_PSYM:
2784             case C_RSYM:
2785             case C_RPSYM:
2786             case C_STSYM:
2787             case C_DECL:
2788             case C_ENTRY:
2789             case C_FUN:
2790             case C_ESTAT:
2791 #endif
2792               dst->symbol.flags = BSF_DEBUGGING;
2793               dst->symbol.value = (src->u.syment.n_value);
2794               break;
2795
2796 #ifdef RS6000COFF_C
2797             case C_BINCL:       /* beginning of include file     */
2798             case C_EINCL:       /* ending of include file        */
2799               /* The value is actually a pointer into the line numbers
2800                  of the file.  We locate the line number entry, and
2801                  set the section to the section which contains it, and
2802                  the value to the index in that section.  */
2803               {
2804                 asection *sec;
2805
2806                 dst->symbol.flags = BSF_DEBUGGING;
2807                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2808                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
2809                       && ((file_ptr) (sec->line_filepos
2810                                       + sec->lineno_count * LINESZ)
2811                           > (file_ptr) src->u.syment.n_value))
2812                     break;
2813                 if (sec == NULL)
2814                   dst->symbol.value = 0;
2815                 else
2816                   {
2817                     dst->symbol.section = sec;
2818                     dst->symbol.value = ((src->u.syment.n_value
2819                                           - sec->line_filepos)
2820                                          / LINESZ);
2821                     src->fix_line = 1;
2822                   }
2823               }
2824               break;
2825
2826             case C_BSTAT:
2827               dst->symbol.flags = BSF_DEBUGGING;
2828
2829               /* The value is actually a symbol index.  Save a pointer
2830                  to the symbol instead of the index.  FIXME: This
2831                  should use a union.  */
2832               src->u.syment.n_value =
2833                 (long) (native_symbols + src->u.syment.n_value);
2834               dst->symbol.value = src->u.syment.n_value;
2835               src->fix_value = 1;
2836               break;
2837 #endif
2838
2839             case C_BLOCK:       /* ".bb" or ".eb"                */
2840             case C_FCN: /* ".bf" or ".ef"                */
2841             case C_EFCN:        /* physical end of function      */
2842               dst->symbol.flags = BSF_LOCAL;
2843               /*
2844           Base the value as an index from the base of the section
2845           */
2846               dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
2847               break;
2848
2849             case C_NULL:
2850             case C_EXTDEF:      /* external definition           */
2851             case C_ULABEL:      /* undefined label               */
2852             case C_USTATIC:     /* undefined static              */
2853 #ifndef COFF_WITH_PE
2854             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
2855                class to represent a section symbol */
2856             case C_LINE:        /* line # reformatted as symbol table entry */
2857 #endif
2858             case C_ALIAS:       /* duplicate tag                 */
2859             case C_HIDDEN:      /* ext symbol in dmert public lib */
2860             default:
2861               (*_bfd_error_handler)
2862                 ("%s: Unrecognized storage class %d for %s symbol `%s'",
2863                  bfd_get_filename (abfd), src->u.syment.n_sclass,
2864                  dst->symbol.section->name, dst->symbol.name);
2865               dst->symbol.flags = BSF_DEBUGGING;
2866               dst->symbol.value = (src->u.syment.n_value);
2867               break;
2868             }
2869
2870 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
2871
2872           dst->native = src;
2873
2874           dst->symbol.udata.i = 0;
2875           dst->lineno = (alent *) NULL;
2876           this_index += (src->u.syment.n_numaux) + 1;
2877           dst++;
2878           number_of_symbols++;
2879         }                       /* walk the native symtab */
2880     }                           /* bfdize the native symtab */
2881
2882   obj_symbols (abfd) = cached_area;
2883   obj_raw_syments (abfd) = native_symbols;
2884
2885   bfd_get_symcount (abfd) = number_of_symbols;
2886   obj_convert (abfd) = table_ptr;
2887   /* Slurp the line tables for each section too */
2888   {
2889     asection *p;
2890     p = abfd->sections;
2891     while (p)
2892       {
2893         coff_slurp_line_table (abfd, p);
2894         p = p->next;
2895       }
2896   }
2897   return true;
2898 }                               /* coff_slurp_symbol_table() */
2899
2900 /* Check whether a symbol is globally visible.  This is used by the
2901    COFF backend linker code in cofflink.c, since a couple of targets
2902    have globally visible symbols which are not class C_EXT.  This
2903    function need not handle the case of n_class == C_EXT.  */
2904
2905 #undef OTHER_GLOBAL_CLASS
2906
2907 #ifdef I960
2908 #define OTHER_GLOBAL_CLASS C_LEAFEXT
2909 #endif
2910
2911 #ifdef COFF_WITH_PE
2912 #define OTHER_GLOBAL_CLASS C_SECTION
2913 #endif
2914
2915 #ifdef OTHER_GLOBAL_CLASS
2916
2917 static boolean
2918 coff_sym_is_global (abfd, syment)
2919      bfd *abfd;
2920      struct internal_syment *syment;
2921 {
2922   if (syment->n_sclass == OTHER_GLOBAL_CLASS)
2923     return true;
2924   return false;
2925 }
2926
2927 #undef OTHER_GLOBAL_CLASS
2928
2929 #else /* ! defined (OTHER_GLOBAL_CLASS) */
2930
2931 /* sym_is_global should not be defined if it has nothing to do.  */
2932
2933 #define coff_sym_is_global 0
2934
2935 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
2936
2937 /*
2938 SUBSUBSECTION
2939         Reading relocations
2940
2941         Coff relocations are easily transformed into the internal BFD form
2942         (@code{arelent}).
2943
2944         Reading a coff relocation table is done in the following stages:
2945
2946         o Read the entire coff relocation table into memory.
2947
2948         o Process each relocation in turn; first swap it from the
2949         external to the internal form.
2950
2951         o Turn the symbol referenced in the relocation's symbol index
2952         into a pointer into the canonical symbol table.
2953         This table is the same as the one returned by a call to
2954         @code{bfd_canonicalize_symtab}. The back end will call that
2955         routine and save the result if a canonicalization hasn't been done.
2956
2957         o The reloc index is turned into a pointer to a howto
2958         structure, in a back end specific way. For instance, the 386
2959         and 960 use the @code{r_type} to directly produce an index
2960         into a howto table vector; the 88k subtracts a number from the
2961         @code{r_type} field and creates an addend field.
2962
2963
2964 */
2965
2966 #ifndef CALC_ADDEND
2967 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
2968   {                                                             \
2969     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
2970     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
2971       coffsym = (obj_symbols (abfd)                             \
2972                  + (cache_ptr->sym_ptr_ptr - symbols));         \
2973     else if (ptr)                                               \
2974       coffsym = coff_symbol_from (abfd, ptr);                   \
2975     if (coffsym != (coff_symbol_type *) NULL                    \
2976         && coffsym->native->u.syment.n_scnum == 0)              \
2977       cache_ptr->addend = 0;                                    \
2978     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
2979              && ptr->section != (asection *) NULL)              \
2980       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
2981     else                                                        \
2982       cache_ptr->addend = 0;                                    \
2983   }
2984 #endif
2985
2986 static boolean
2987 coff_slurp_reloc_table (abfd, asect, symbols)
2988      bfd * abfd;
2989      sec_ptr asect;
2990      asymbol ** symbols;
2991 {
2992   RELOC *native_relocs;
2993   arelent *reloc_cache;
2994   arelent *cache_ptr;
2995
2996   unsigned int idx;
2997
2998   if (asect->relocation)
2999     return true;
3000   if (asect->reloc_count == 0)
3001     return true;
3002   if (asect->flags & SEC_CONSTRUCTOR)
3003     return true;
3004   if (!coff_slurp_symbol_table (abfd))
3005     return false;
3006   native_relocs =
3007     (RELOC *) buy_and_read (abfd,
3008                             asect->rel_filepos,
3009                             SEEK_SET,
3010                             (size_t) (RELSZ *
3011                                       asect->reloc_count));
3012   reloc_cache = (arelent *)
3013     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
3014
3015   if (reloc_cache == NULL)
3016     {
3017       bfd_set_error (bfd_error_no_memory);
3018       return false;
3019     }
3020
3021
3022   for (idx = 0; idx < asect->reloc_count; idx++)
3023     {
3024 #ifdef RELOC_PROCESSING
3025       struct internal_reloc dst;
3026       struct external_reloc *src;
3027
3028       cache_ptr = reloc_cache + idx;
3029       src = native_relocs + idx;
3030       coff_swap_reloc_in (abfd, src, &dst);
3031
3032       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
3033 #else
3034       struct internal_reloc dst;
3035       asymbol *ptr;
3036       struct external_reloc *src;
3037
3038       cache_ptr = reloc_cache + idx;
3039       src = native_relocs + idx;
3040
3041       coff_swap_reloc_in (abfd, src, &dst);
3042
3043
3044       cache_ptr->address = dst.r_vaddr;
3045
3046       if (dst.r_symndx != -1)
3047         {
3048           /* @@ Should never be greater than count of symbols!  */
3049           if (dst.r_symndx >= obj_conv_table_size (abfd))
3050             abort ();
3051           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
3052           ptr = *(cache_ptr->sym_ptr_ptr);
3053         }
3054       else
3055         {
3056           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3057           ptr = 0;
3058         }
3059
3060       /* The symbols definitions that we have read in have been
3061          relocated as if their sections started at 0. But the offsets
3062          refering to the symbols in the raw data have not been
3063          modified, so we have to have a negative addend to compensate.
3064
3065          Note that symbols which used to be common must be left alone */
3066
3067       /* Calculate any reloc addend by looking at the symbol */
3068       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
3069
3070       cache_ptr->address -= asect->vma;
3071 /* !!     cache_ptr->section = (asection *) NULL;*/
3072
3073       /* Fill in the cache_ptr->howto field from dst.r_type */
3074       RTYPE2HOWTO (cache_ptr, &dst);
3075 #endif
3076
3077     }
3078
3079   asect->relocation = reloc_cache;
3080   return true;
3081 }
3082
3083 #ifndef coff_rtype_to_howto
3084 #ifdef RTYPE2HOWTO
3085
3086 /* Get the howto structure for a reloc.  This is only used if the file
3087    including this one defines coff_relocate_section to be
3088    _bfd_coff_generic_relocate_section, so it is OK if it does not
3089    always work.  It is the responsibility of the including file to
3090    make sure it is reasonable if it is needed.  */
3091
3092 static reloc_howto_type *coff_rtype_to_howto
3093   PARAMS ((bfd *, asection *, struct internal_reloc *,
3094            struct coff_link_hash_entry *, struct internal_syment *,
3095            bfd_vma *));
3096
3097 /*ARGSUSED*/
3098 static reloc_howto_type *
3099 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
3100      bfd *abfd;
3101      asection *sec;
3102      struct internal_reloc *rel;
3103      struct coff_link_hash_entry *h;
3104      struct internal_syment *sym;
3105      bfd_vma *addendp;
3106 {
3107   arelent genrel;
3108
3109   RTYPE2HOWTO (&genrel, rel);
3110   return genrel.howto;
3111 }
3112
3113 #else /* ! defined (RTYPE2HOWTO) */
3114
3115 #define coff_rtype_to_howto NULL
3116
3117 #endif /* ! defined (RTYPE2HOWTO) */
3118 #endif /* ! defined (coff_rtype_to_howto) */
3119
3120 /* This is stupid.  This function should be a boolean predicate.  */
3121 static long
3122 coff_canonicalize_reloc (abfd, section, relptr, symbols)
3123      bfd * abfd;
3124      sec_ptr section;
3125      arelent ** relptr;
3126      asymbol ** symbols;
3127 {
3128   arelent *tblptr = section->relocation;
3129   unsigned int count = 0;
3130
3131
3132   if (section->flags & SEC_CONSTRUCTOR)
3133     {
3134       /* this section has relocs made up by us, they are not in the
3135        file, so take them out of their chain and place them into
3136        the data area provided */
3137       arelent_chain *chain = section->constructor_chain;
3138       for (count = 0; count < section->reloc_count; count++)
3139         {
3140           *relptr++ = &chain->relent;
3141           chain = chain->next;
3142         }
3143
3144     }
3145   else
3146     {
3147       if (! coff_slurp_reloc_table (abfd, section, symbols))
3148         return -1;
3149
3150       tblptr = section->relocation;
3151
3152       for (; count++ < section->reloc_count;)
3153         *relptr++ = tblptr++;
3154
3155
3156     }
3157   *relptr = 0;
3158   return section->reloc_count;
3159 }
3160
3161 #ifdef GNU960
3162 file_ptr
3163 coff_sym_filepos (abfd)
3164      bfd *abfd;
3165 {
3166   return obj_sym_filepos (abfd);
3167 }
3168 #endif
3169
3170 #ifndef coff_reloc16_estimate
3171 #define coff_reloc16_estimate dummy_reloc16_estimate
3172
3173 static int
3174 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
3175      bfd *abfd;
3176      asection *input_section;
3177      arelent *reloc;
3178      unsigned int shrink;
3179      struct bfd_link_info *link_info;
3180 {
3181   abort ();
3182 }
3183
3184 #endif
3185
3186 #ifndef coff_reloc16_extra_cases
3187 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
3188 /* This works even if abort is not declared in any header file.  */
3189 static void
3190 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
3191                            dst_ptr)
3192      bfd *abfd;
3193      struct bfd_link_info *link_info;
3194      struct bfd_link_order *link_order;
3195      arelent *reloc;
3196      bfd_byte *data;
3197      unsigned int *src_ptr;
3198      unsigned int *dst_ptr;
3199 {
3200   abort ();
3201 }
3202 #endif
3203
3204 /* If coff_relocate_section is defined, we can use the optimized COFF
3205    backend linker.  Otherwise we must continue to use the old linker.  */
3206 #ifdef coff_relocate_section
3207 #ifndef coff_bfd_link_hash_table_create
3208 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
3209 #endif
3210 #ifndef coff_bfd_link_add_symbols
3211 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
3212 #endif
3213 #ifndef coff_bfd_final_link
3214 #define coff_bfd_final_link _bfd_coff_final_link
3215 #endif
3216 #else /* ! defined (coff_relocate_section) */
3217 #define coff_relocate_section NULL
3218 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3219 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
3220 #define coff_bfd_final_link _bfd_generic_final_link
3221 #endif /* ! defined (coff_relocate_section) */
3222 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
3223
3224 #ifndef coff_start_final_link
3225 #define coff_start_final_link NULL
3226 #endif
3227
3228 #ifndef coff_adjust_symndx
3229 #define coff_adjust_symndx NULL
3230 #endif
3231
3232 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
3233 {
3234   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
3235   coff_swap_aux_out, coff_swap_sym_out,
3236   coff_swap_lineno_out, coff_swap_reloc_out,
3237   coff_swap_filehdr_out, coff_swap_aouthdr_out,
3238   coff_swap_scnhdr_out,
3239   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
3240 #ifdef COFF_LONG_FILENAMES
3241   true,
3242 #else
3243   false,
3244 #endif
3245   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
3246   coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
3247   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
3248   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
3249   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
3250   coff_sym_is_global, coff_compute_section_file_positions,
3251   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
3252   coff_adjust_symndx
3253 };
3254
3255 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
3256 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3257 #define coff_get_section_contents _bfd_generic_get_section_contents
3258
3259 #ifndef coff_bfd_copy_private_symbol_data
3260 #define coff_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data
3261 #endif
3262
3263 #ifndef coff_bfd_copy_private_section_data
3264 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
3265 #endif
3266
3267 #ifndef coff_bfd_copy_private_bfd_data
3268 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
3269 #endif
3270
3271 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3272 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3273
3274 #ifndef coff_bfd_print_private_bfd_data
3275 #define coff_bfd_print_private_bfd_data  _bfd_generic_bfd_print_private_bfd_data
3276 #endif
3277
3278 #ifndef coff_bfd_is_local_label
3279 #define coff_bfd_is_local_label bfd_generic_is_local_label
3280 #endif
3281 #ifndef coff_read_minisymbols
3282 #define coff_read_minisymbols _bfd_generic_read_minisymbols
3283 #endif
3284 #ifndef coff_minisymbol_to_symbol
3285 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3286 #endif
3287
3288 /* The reloc lookup routine must be supplied by each individual COFF
3289    backend.  */
3290 #ifndef coff_bfd_reloc_type_lookup
3291 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3292 #endif
3293
3294 #ifndef coff_bfd_get_relocated_section_contents
3295 #define coff_bfd_get_relocated_section_contents \
3296   bfd_generic_get_relocated_section_contents
3297 #endif
3298 #ifndef coff_bfd_relax_section
3299 #define coff_bfd_relax_section bfd_generic_relax_section
3300 #endif