bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 95, 1996 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                         sac@cygnus.com
  24 */
  25 /*
  26
  27 SECTION
  28         coff backends
  29
  30         BFD supports a number of different flavours of coff format.
  31         The major differences between formats are the sizes and
  32         alignments of fields in structures on disk, and the occasional
  33         extra field.
  34
  35         Coff in all its varieties is implemented with a few common
  36         files and a number of implementation specific files. For
  37         example, The 88k bcs coff format is implemented in the file
  38         @file{coff-m88k.c}. This file @code{#include}s
  39         @file{coff/m88k.h} which defines the external structure of the
  40         coff format for the 88k, and @file{coff/internal.h} which
  41         defines the internal structure. @file{coff-m88k.c} also
  42         defines the relocations used by the 88k format
  43         @xref{Relocations}.
  44
  45         The Intel i960 processor version of coff is implemented in
  46         @file{coff-i960.c}. This file has the same structure as
  47         @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
  48         rather than @file{coff-m88k.h}.
  49
  50 SUBSECTION
  51         Porting to a new version of coff
  52
  53         The recommended method is to select from the existing
  54         implementations the version of coff which is most like the one
  55         you want to use.  For example, we'll say that i386 coff is
  56         the one you select, and that your coff flavour is called foo.
  57         Copy @file{i386coff.c} to @file{foocoff.c}, copy
  58         @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
  59         and add the lines to @file{targets.c} and @file{Makefile.in}
  60         so that your new back end is used. Alter the shapes of the
  61         structures in @file{../include/coff/foo.h} so that they match
  62         what you need. You will probably also have to add
  63         @code{#ifdef}s to the code in @file{coff/internal.h} and
  64         @file{coffcode.h} if your version of coff is too wild.
  65
  66         You can verify that your new BFD backend works quite simply by
  67         building @file{objdump} from the @file{binutils} directory,
  68         and making sure that its version of what's going on and your
  69         host system's idea (assuming it has the pretty standard coff
  70         dump utility, usually called @code{att-dump} or just
  71         @code{dump}) are the same.  Then clean up your code, and send
  72         what you've done to Cygnus. Then your stuff will be in the
  73         next release, and you won't have to keep integrating it.
  74
  75 SUBSECTION
  76         How the coff backend works
  77
  78 SUBSUBSECTION
  79         File layout
  80
  81         The Coff backend is split into generic routines that are
  82         applicable to any Coff target and routines that are specific
  83         to a particular target.  The target-specific routines are
  84         further split into ones which are basically the same for all
  85         Coff targets except that they use the external symbol format
  86         or use different values for certain constants.
  87
  88         The generic routines are in @file{coffgen.c}.  These routines
  89         work for any Coff target.  They use some hooks into the target
  90         specific code; the hooks are in a @code{bfd_coff_backend_data}
  91         structure, one of which exists for each target.
  92
  93         The essentially similar target-specific routines are in
  94         @file{coffcode.h}.  This header file includes executable C code.
  95         The various Coff targets first include the appropriate Coff
  96         header file, make any special defines that are needed, and
  97         then include @file{coffcode.h}.
  98
  99         Some of the Coff targets then also have additional routines in
 100         the target source file itself.
 101
 102         For example, @file{coff-i960.c} includes
 103         @file{coff/internal.h} and @file{coff/i960.h}.  It then
 104         defines a few constants, such as @code{I960}, and includes
 105         @file{coffcode.h}.  Since the i960 has complex relocation
 106         types, @file{coff-i960.c} also includes some code to
 107         manipulate the i960 relocs.  This code is not in
 108         @file{coffcode.h} because it would not be used by any other
 109         target.
 110
 111 SUBSUBSECTION
 112         Bit twiddling
 113
 114         Each flavour of coff supported in BFD has its own header file
 115         describing the external layout of the structures. There is also
 116         an internal description of the coff layout, in
 117         @file{coff/internal.h}. A major function of the
 118         coff backend is swapping the bytes and twiddling the bits to
 119         translate the external form of the structures into the normal
 120         internal form. This is all performed in the
 121         @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
 122         elements are different sizes between different versions of
 123         coff; it is the duty of the coff version specific include file
 124         to override the definitions of various packing routines in
 125         @file{coffcode.h}. E.g., the size of line number entry in coff is
 126         sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
 127         @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
 128         correct one. No doubt, some day someone will find a version of
 129         coff which has a varying field size not catered to at the
 130         moment. To port BFD, that person will have to add more @code{#defines}.
 131         Three of the bit twiddling routines are exported to
 132         @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
 133         and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
 134         table on its own, but uses BFD to fix things up.  More of the
 135         bit twiddlers are exported for @code{gas};
 136         @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
 137         @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
 138         @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
 139         @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
 140         of all the symbol table and reloc drudgery itself, thereby
 141         saving the internal BFD overhead, but uses BFD to swap things
 142         on the way out, making cross ports much safer.  Doing so also
 143         allows BFD (and thus the linker) to use the same header files
 144         as @code{gas}, which makes one avenue to disaster disappear.
 145
 146 SUBSUBSECTION
 147         Symbol reading
 148
 149         The simple canonical form for symbols used by BFD is not rich
 150         enough to keep all the information available in a coff symbol
 151         table. The back end gets around this problem by keeping the original
 152         symbol table around, "behind the scenes".
 153
 154         When a symbol table is requested (through a call to
 155         @code{bfd_canonicalize_symtab}), a request gets through to
 156         @code{coff_get_normalized_symtab}. This reads the symbol table from
 157         the coff file and swaps all the structures inside into the
 158         internal form. It also fixes up all the pointers in the table
 159         (represented in the file by offsets from the first symbol in
 160         the table) into physical pointers to elements in the new
 161         internal table. This involves some work since the meanings of
 162         fields change depending upon context: a field that is a
 163         pointer to another structure in the symbol table at one moment
 164         may be the size in bytes of a structure at the next.  Another
 165         pass is made over the table. All symbols which mark file names
 166         (<<C_FILE>> symbols) are modified so that the internal
 167         string points to the value in the auxent (the real filename)
 168         rather than the normal text associated with the symbol
 169         (@code{".file"}).
 170
 171         At this time the symbol names are moved around. Coff stores
 172         all symbols less than nine characters long physically
 173         within the symbol table; longer strings are kept at the end of
 174         the file in the string  table. This pass moves all strings
 175         into memory and replaces them with pointers to the strings.
 176
 177
 178         The symbol table is massaged once again, this time to create
 179         the canonical table used by the BFD application. Each symbol
 180         is inspected in turn, and a decision made (using the
 181         @code{sclass} field) about the various flags to set in the
 182         @code{asymbol}.  @xref{Symbols}. The generated canonical table
 183         shares strings with the hidden internal symbol table.
 184
 185         Any linenumbers are read from the coff file too, and attached
 186         to the symbols which own the functions the linenumbers belong to.
 187
 188 SUBSUBSECTION
 189         Symbol writing
 190
 191         Writing a symbol to a coff file which didn't come from a coff
 192         file will lose any debugging information. The @code{asymbol}
 193         structure remembers the BFD from which the symbol was taken, and on
 194         output the back end makes sure that the same destination target as
 195         source target is present.
 196
 197         When the symbols have come from a coff file then all the
 198         debugging information is preserved.
 199
 200         Symbol tables are provided for writing to the back end in a
 201         vector of pointers to pointers. This allows applications like
 202         the linker to accumulate and output large symbol tables
 203         without having to do too much byte copying.
 204
 205         This function runs through the provided symbol table and
 206         patches each symbol marked as a file place holder
 207         (@code{C_FILE}) to point to the next file place holder in the
 208         list. It also marks each @code{offset} field in the list with
 209         the offset from the first symbol of the current symbol.
 210
 211         Another function of this procedure is to turn the canonical
 212         value form of BFD into the form used by coff. Internally, BFD
 213         expects symbol values to be offsets from a section base; so a
 214         symbol physically at 0x120, but in a section starting at
 215         0x100, would have the value 0x20. Coff expects symbols to
 216         contain their final value, so symbols have their values
 217         changed at this point to reflect their sum with their owning
 218         section.  This transformation uses the
 219         <<output_section>> field of the @code{asymbol}'s
 220         @code{asection} @xref{Sections}.
 221
 222         o <<coff_mangle_symbols>>
 223
 224         This routine runs though the provided symbol table and uses
 225         the offsets generated by the previous pass and the pointers
 226         generated when the symbol table was read in to create the
 227         structured hierachy required by coff. It changes each pointer
 228         to a symbol into the index into the symbol table of the asymbol.
 229
 230         o <<coff_write_symbols>>
 231
 232         This routine runs through the symbol table and patches up the
 233         symbols from their internal form into the coff way, calls the
 234         bit twiddlers, and writes out the table to the file.
 235
 236 */
 237
 238 /*
 239 INTERNAL_DEFINITION
 240         coff_symbol_type
 241
 242 DESCRIPTION
 243         The hidden information for an <<asymbol>> is described in a
 244         <<combined_entry_type>>:
 245
 246 CODE_FRAGMENT
 247 .
 248 .typedef struct coff_ptr_struct
 249 .{
 250 .
 251 .       {* Remembers the offset from the first symbol in the file for
 252 .          this symbol. Generated by coff_renumber_symbols. *}
 253 .unsigned int offset;
 254 .
 255 .       {* Should the value of this symbol be renumbered.  Used for
 256 .          XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
 257 .unsigned int fix_value : 1;
 258 .
 259 .       {* Should the tag field of this symbol be renumbered.
 260 .          Created by coff_pointerize_aux. *}
 261 .unsigned int fix_tag : 1;
 262 .
 263 .       {* Should the endidx field of this symbol be renumbered.
 264 .          Created by coff_pointerize_aux. *}
 265 .unsigned int fix_end : 1;
 266 .
 267 .       {* Should the x_csect.x_scnlen field be renumbered.
 268 .          Created by coff_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 #ifdef COFF_WITH_PE
 933
 934 /* a couple of macros to help setting the alignment power field */
 935 #define ALIGN_SET(field,x,y) \
 936   if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
 937   {\
 938      section->alignment_power = y;\
 939   }
 940
 941 #define ELIFALIGN_SET(field,x,y) \
 942   else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
 943   {\
 944      section->alignment_power = y;\
 945   }
 946
 947 static void
 948 coff_set_alignment_hook (abfd, section, scnhdr)
 949      bfd * abfd;
 950      asection * section;
 951      PTR scnhdr;
 952 {
 953   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 954
 955   ALIGN_SET     (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
 956   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
 957   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
 958   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES,  3)
 959   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES,  2)
 960   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES,  1)
 961   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES,  0)
 962
 963 #ifdef POWERPC_LE_PE
 964   if (strcmp (section->name, ".idata$2") == 0)
 965     {
 966       section->alignment_power = 0;
 967     }
 968   else if (strcmp (section->name, ".idata$3") == 0)
 969     {
 970       section->alignment_power = 0;
 971     }
 972   else if (strcmp (section->name, ".idata$4") == 0)
 973     {
 974       section->alignment_power = 2;
 975     }
 976   else if (strcmp (section->name, ".idata$5") == 0)
 977     {
 978       section->alignment_power = 2;
 979     }
 980   else if (strcmp (section->name, ".idata$6") == 0)
 981     {
 982       section->alignment_power = 1;
 983     }
 984   else if (strcmp (section->name, ".reloc") == 0)
 985     {
 986       section->alignment_power = 1;
 987     }
 988 #endif
 989 }
 990 #undef ALIGN_SET
 991 #undef ELIFALIGN_SET
 992
 993 #else /* ! COFF_WITH_PE */
 994 #ifdef RS6000COFF_C
 995
 996 /* We grossly abuse this function to handle XCOFF overflow headers.
 997    When we see one, we correct the reloc and line number counts in the
 998    real header, and remove the section we just created.  */
 999
1000 static void
1001 coff_set_alignment_hook (abfd, section, scnhdr)
1002      bfd *abfd;
1003      asection *section;
1004      PTR scnhdr;
1005 {
1006   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1007   asection *real_sec;
1008   asection **ps;
1009
1010   if ((hdr->s_flags & STYP_OVRFLO) == 0)
1011     return;
1012
1013   real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1014   if (real_sec == NULL)
1015     return;
1016
1017   real_sec->reloc_count = hdr->s_paddr;
1018   real_sec->lineno_count = hdr->s_vaddr;
1019
1020   for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1021     {
1022       if (*ps == section)
1023         {
1024           *ps = (*ps)->next;
1025           --abfd->section_count;
1026           break;
1027         }
1028     }
1029 }
1030
1031 #else /* ! RS6000COFF_C */
1032
1033 #define coff_set_alignment_hook \
1034   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1035
1036 #endif /* ! RS6000COFF_C */
1037 #endif /* ! COFF_WITH_PE */
1038 #endif /* ! I960 */
1039
1040 #ifndef coff_mkobject
1041 static boolean
1042 coff_mkobject (abfd)
1043      bfd * abfd;
1044 {
1045   coff_data_type *coff;
1046
1047   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1048   if (abfd->tdata.coff_obj_data == 0)
1049     return false;
1050   coff = coff_data (abfd);
1051   coff->symbols = (coff_symbol_type *) NULL;
1052   coff->conversion_table = (unsigned int *) NULL;
1053   coff->raw_syments = (struct coff_ptr_struct *) NULL;
1054   coff->relocbase = 0;
1055   coff->local_toc_sym_map = 0;
1056
1057 /*  make_abs_section(abfd);*/
1058
1059   return true;
1060 }
1061 #endif
1062
1063 /* Create the COFF backend specific information.  */
1064 #ifndef coff_mkobject_hook
1065 static PTR
1066 coff_mkobject_hook (abfd, filehdr, aouthdr)
1067      bfd * abfd;
1068      PTR filehdr;
1069      PTR aouthdr;
1070 {
1071   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1072   coff_data_type *coff;
1073
1074   if (coff_mkobject (abfd) == false)
1075     return NULL;
1076
1077   coff = coff_data (abfd);
1078
1079   coff->sym_filepos = internal_f->f_symptr;
1080
1081   /* These members communicate important constants about the symbol
1082      table to GDB's symbol-reading code.  These `constants'
1083      unfortunately vary among coff implementations...  */
1084   coff->local_n_btmask = N_BTMASK;
1085   coff->local_n_btshft = N_BTSHFT;
1086   coff->local_n_tmask = N_TMASK;
1087   coff->local_n_tshift = N_TSHIFT;
1088   coff->local_symesz = SYMESZ;
1089   coff->local_auxesz = AUXESZ;
1090   coff->local_linesz = LINESZ;
1091
1092   obj_raw_syment_count (abfd) =
1093     obj_conv_table_size (abfd) =
1094       internal_f->f_nsyms;
1095
1096 #ifdef RS6000COFF_C
1097   if ((internal_f->f_flags & F_SHROBJ) != 0)
1098     abfd->flags |= DYNAMIC;
1099   if (aouthdr != NULL && internal_f->f_opthdr >= AOUTSZ)
1100     {
1101       struct internal_aouthdr *internal_a =
1102         (struct internal_aouthdr *) aouthdr;
1103       struct xcoff_tdata *xcoff;
1104
1105       xcoff = xcoff_data (abfd);
1106       xcoff->full_aouthdr = true;
1107       xcoff->toc = internal_a->o_toc;
1108       if (internal_a->o_sntoc == 0)
1109         xcoff->toc_section = NULL;
1110       else
1111         xcoff->toc_section =
1112           coff_section_from_bfd_index (abfd, internal_a->o_sntoc);
1113       if (internal_a->o_snentry == 0)
1114         xcoff->entry_section = NULL;
1115       else
1116         xcoff->entry_section =
1117           coff_section_from_bfd_index (abfd, internal_a->o_snentry);
1118       xcoff->text_align_power = internal_a->o_algntext;
1119       xcoff->data_align_power = internal_a->o_algndata;
1120       xcoff->modtype = internal_a->o_modtype;
1121       xcoff->cputype = internal_a->o_cputype;
1122       xcoff->maxdata = internal_a->o_maxdata;
1123       xcoff->maxstack = internal_a->o_maxstack;
1124     }
1125 #endif
1126
1127   return (PTR) coff;
1128 }
1129 #endif
1130
1131 /* Determine the machine architecture and type.  FIXME: This is target
1132    dependent because the magic numbers are defined in the target
1133    dependent header files.  But there is no particular need for this.
1134    If the magic numbers were moved to a separate file, this function
1135    would be target independent and would also be much more successful
1136    at linking together COFF files for different architectures.  */
1137
1138 static boolean
1139 coff_set_arch_mach_hook (abfd, filehdr)
1140      bfd *abfd;
1141      PTR filehdr;
1142 {
1143   long machine;
1144   enum bfd_architecture arch;
1145   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1146
1147   machine = 0;
1148   switch (internal_f->f_magic)
1149     {
1150 #ifdef PPCMAGIC
1151     case PPCMAGIC:
1152       arch = bfd_arch_powerpc;
1153       machine = 0; /* what does this mean? (krk) */
1154       break;
1155 #endif
1156 #ifdef I386MAGIC
1157     case I386MAGIC:
1158     case I386PTXMAGIC:
1159     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1160     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1161       arch = bfd_arch_i386;
1162       machine = 0;
1163       break;
1164 #endif
1165 #ifdef A29K_MAGIC_BIG
1166     case A29K_MAGIC_BIG:
1167     case A29K_MAGIC_LITTLE:
1168       arch = bfd_arch_a29k;
1169       machine = 0;
1170       break;
1171 #endif
1172 #ifdef ARMMAGIC
1173     case ARMMAGIC:
1174       arch = bfd_arch_arm;
1175       machine =0;
1176       break;
1177 #endif
1178 #ifdef MC68MAGIC
1179     case MC68MAGIC:
1180     case M68MAGIC:
1181 #ifdef MC68KBCSMAGIC
1182     case MC68KBCSMAGIC:
1183 #endif
1184 #ifdef APOLLOM68KMAGIC
1185     case APOLLOM68KMAGIC:
1186 #endif
1187 #ifdef LYNXCOFFMAGIC
1188     case LYNXCOFFMAGIC:
1189 #endif
1190       arch = bfd_arch_m68k;
1191       machine = 68020;
1192       break;
1193 #endif
1194 #ifdef MC88MAGIC
1195     case MC88MAGIC:
1196     case MC88DMAGIC:
1197     case MC88OMAGIC:
1198       arch = bfd_arch_m88k;
1199       machine = 88100;
1200       break;
1201 #endif
1202 #ifdef Z8KMAGIC
1203     case Z8KMAGIC:
1204       arch = bfd_arch_z8k;
1205       switch (internal_f->f_flags & F_MACHMASK)
1206         {
1207         case F_Z8001:
1208           machine = bfd_mach_z8001;
1209           break;
1210         case F_Z8002:
1211           machine = bfd_mach_z8002;
1212           break;
1213         default:
1214           return false;
1215         }
1216       break;
1217 #endif
1218 #ifdef I860
1219     case I860MAGIC:
1220       arch = bfd_arch_i860;
1221       break;
1222 #endif
1223 #ifdef I960
1224 #ifdef I960ROMAGIC
1225     case I960ROMAGIC:
1226     case I960RWMAGIC:
1227       arch = bfd_arch_i960;
1228       switch (F_I960TYPE & internal_f->f_flags)
1229         {
1230         default:
1231         case F_I960CORE:
1232           machine = bfd_mach_i960_core;
1233           break;
1234         case F_I960KB:
1235           machine = bfd_mach_i960_kb_sb;
1236           break;
1237         case F_I960MC:
1238           machine = bfd_mach_i960_mc;
1239           break;
1240         case F_I960XA:
1241           machine = bfd_mach_i960_xa;
1242           break;
1243         case F_I960CA:
1244           machine = bfd_mach_i960_ca;
1245           break;
1246         case F_I960KA:
1247           machine = bfd_mach_i960_ka_sa;
1248           break;
1249           /* start-sanitize-i960xl */
1250         case F_I960XL:
1251           machine = bfd_mach_i960_xl;
1252           break;
1253           /* end-sanitize-i960xl */
1254         }
1255       break;
1256 #endif
1257 #endif
1258
1259 #ifdef RS6000COFF_C
1260     case U802ROMAGIC:
1261     case U802WRMAGIC:
1262     case U802TOCMAGIC:
1263       {
1264         int cputype;
1265
1266         if (xcoff_data (abfd)->cputype != -1)
1267           cputype = xcoff_data (abfd)->cputype & 0xff;
1268         else
1269           {
1270             /* We did not get a value from the a.out header.  If the
1271                file has not been stripped, we may be able to get the
1272                architecture information from the first symbol, if it
1273                is a .file symbol.  */
1274             if (obj_raw_syment_count (abfd) == 0)
1275               cputype = 0;
1276             else
1277               {
1278                 bfd_byte buf[SYMESZ];
1279                 struct internal_syment sym;
1280
1281                 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1282                     || bfd_read (buf, 1, SYMESZ, abfd) != SYMESZ)
1283                   return false;
1284                 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1285                 if (sym.n_sclass == C_FILE)
1286                   cputype = sym.n_type & 0xff;
1287                 else
1288                   cputype = 0;
1289               }
1290           }
1291
1292         /* FIXME: We don't handle all cases here.  */
1293         switch (cputype)
1294           {
1295           default:
1296           case 0:
1297 #ifdef POWERMAC
1298             /* PowerPC Macs use the same magic numbers as RS/6000
1299                (because that's how they were bootstrapped originally),
1300                but they are always PowerPC architecture.  */
1301             arch = bfd_arch_powerpc;
1302             machine = 0;
1303 #else
1304             arch = bfd_arch_rs6000;
1305             machine = 6000;
1306 #endif /* POWERMAC */
1307             break;
1308
1309           case 1:
1310             arch = bfd_arch_powerpc;
1311             machine = 601;
1312             break;
1313           case 2: /* 64 bit PowerPC */
1314             arch = bfd_arch_powerpc;
1315             machine = 620;
1316             break;
1317           case 3:
1318             arch = bfd_arch_powerpc;
1319             machine = 0;
1320             break;
1321           case 4:
1322             arch = bfd_arch_rs6000;
1323             machine = 6000;
1324             break;
1325           }
1326       }
1327       break;
1328 #endif
1329
1330 #ifdef WE32KMAGIC
1331     case WE32KMAGIC:
1332       arch = bfd_arch_we32k;
1333       machine = 0;
1334       break;
1335 #endif
1336
1337 #ifdef H8300MAGIC
1338     case H8300MAGIC:
1339       arch = bfd_arch_h8300;
1340       machine = bfd_mach_h8300;
1341       /* !! FIXME this probably isn't the right place for this */
1342       abfd->flags |= BFD_IS_RELAXABLE;
1343       break;
1344 #endif
1345
1346 #ifdef H8300HMAGIC
1347     case H8300HMAGIC:
1348       arch = bfd_arch_h8300;
1349       machine = bfd_mach_h8300h;
1350       /* !! FIXME this probably isn't the right place for this */
1351       abfd->flags |= BFD_IS_RELAXABLE;
1352       break;
1353 #endif
1354
1355 #ifdef SH_ARCH_MAGIC_BIG
1356     case SH_ARCH_MAGIC_BIG:
1357     case SH_ARCH_MAGIC_LITTLE:
1358       arch = bfd_arch_sh;
1359       machine = 0;
1360       break;
1361 #endif
1362
1363 #ifdef H8500MAGIC
1364     case H8500MAGIC:
1365       arch = bfd_arch_h8500;
1366       machine = 0;
1367       break;
1368 #endif
1369
1370 #ifdef SPARCMAGIC
1371     case SPARCMAGIC:
1372 #ifdef LYNXCOFFMAGIC
1373     case LYNXCOFFMAGIC:
1374 #endif
1375       arch = bfd_arch_sparc;
1376       machine = 0;
1377       break;
1378 #endif
1379
1380     default:                    /* Unreadable input file type */
1381       arch = bfd_arch_obscure;
1382       break;
1383     }
1384
1385   bfd_default_set_arch_mach (abfd, arch, machine);
1386   return true;
1387 }
1388
1389 #ifdef SYMNAME_IN_DEBUG
1390
1391 static boolean
1392 symname_in_debug_hook (abfd, sym)
1393      bfd * abfd;
1394      struct internal_syment *sym;
1395 {
1396   return SYMNAME_IN_DEBUG (sym) ? true : false;
1397 }
1398
1399 #else
1400
1401 #define symname_in_debug_hook \
1402   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1403
1404 #endif
1405
1406 #ifdef RS6000COFF_C
1407
1408 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
1409
1410 static boolean coff_pointerize_aux_hook
1411   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1412            unsigned int, combined_entry_type *));
1413
1414 /*ARGSUSED*/
1415 static boolean
1416 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1417      bfd *abfd;
1418      combined_entry_type *table_base;
1419      combined_entry_type *symbol;
1420      unsigned int indaux;
1421      combined_entry_type *aux;
1422 {
1423   int class = symbol->u.syment.n_sclass;
1424
1425   if ((class == C_EXT || class == C_HIDEXT)
1426       && indaux + 1 == symbol->u.syment.n_numaux)
1427     {
1428       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
1429         {
1430           aux->u.auxent.x_csect.x_scnlen.p =
1431             table_base + aux->u.auxent.x_csect.x_scnlen.l;
1432           aux->fix_scnlen = 1;
1433         }
1434
1435       /* Return true to indicate that the caller should not do any
1436          further work on this auxent.  */
1437       return true;
1438     }
1439
1440   /* Return false to indicate that this auxent should be handled by
1441      the caller.  */
1442   return false;
1443 }
1444
1445 #else
1446 #ifdef I960
1447
1448 /* We don't want to pointerize bal entries.  */
1449
1450 static boolean coff_pointerize_aux_hook
1451   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1452            unsigned int, combined_entry_type *));
1453
1454 /*ARGSUSED*/
1455 static boolean
1456 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1457      bfd *abfd;
1458      combined_entry_type *table_base;
1459      combined_entry_type *symbol;
1460      unsigned int indaux;
1461      combined_entry_type *aux;
1462 {
1463   /* Return true if we don't want to pointerize this aux entry, which
1464      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
1465   return (indaux == 1
1466           && (symbol->u.syment.n_sclass == C_LEAFPROC
1467               || symbol->u.syment.n_sclass == C_LEAFSTAT
1468               || symbol->u.syment.n_sclass == C_LEAFEXT));
1469 }
1470
1471 #else /* ! I960 */
1472
1473 #define coff_pointerize_aux_hook 0
1474
1475 #endif /* ! I960 */
1476 #endif /* ! RS6000COFF_C */
1477
1478 /* Print an aux entry.  This returns true if it has printed it.  */
1479
1480 static boolean coff_print_aux
1481   PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1482            combined_entry_type *, unsigned int));
1483
1484 static boolean
1485 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
1486      bfd *abfd;
1487      FILE *file;
1488      combined_entry_type *table_base;
1489      combined_entry_type *symbol;
1490      combined_entry_type *aux;
1491      unsigned int indaux;
1492 {
1493 #ifdef RS6000COFF_C
1494   if ((symbol->u.syment.n_sclass == C_EXT
1495        || symbol->u.syment.n_sclass == C_HIDEXT)
1496       && indaux + 1 == symbol->u.syment.n_numaux)
1497     {
1498       /* This is a csect entry.  */
1499       fprintf (file, "AUX ");
1500       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
1501         {
1502           BFD_ASSERT (! aux->fix_scnlen);
1503           fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
1504         }
1505       else
1506         {
1507           fprintf (file, "indx ");
1508           if (! aux->fix_scnlen)
1509             fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
1510           else
1511             fprintf (file, "%4ld",
1512                      (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
1513         }
1514       fprintf (file,
1515                " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1516                aux->u.auxent.x_csect.x_parmhash,
1517                (unsigned int) aux->u.auxent.x_csect.x_snhash,
1518                SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
1519                SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
1520                (unsigned int) aux->u.auxent.x_csect.x_smclas,
1521                aux->u.auxent.x_csect.x_stab,
1522                (unsigned int) aux->u.auxent.x_csect.x_snstab);
1523       return true;
1524     }
1525 #endif
1526
1527   /* Return false to indicate that no special action was taken.  */
1528   return false;
1529 }
1530
1531 /*
1532 SUBSUBSECTION
1533         Writing relocations
1534
1535         To write relocations, the back end steps though the
1536         canonical relocation table and create an
1537         @code{internal_reloc}. The symbol index to use is removed from
1538         the @code{offset} field in the symbol table supplied.  The
1539         address comes directly from the sum of the section base
1540         address and the relocation offset; the type is dug directly
1541         from the howto field.  Then the @code{internal_reloc} is
1542         swapped into the shape of an @code{external_reloc} and written
1543         out to disk.
1544
1545 */
1546
1547 static boolean
1548 coff_write_relocs (abfd, first_undef)
1549      bfd * abfd;
1550      int first_undef;
1551 {
1552   asection *s;
1553   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1554     {
1555       unsigned int i;
1556       struct external_reloc dst;
1557
1558       arelent **p = s->orelocation;
1559       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1560         return false;
1561       for (i = 0; i < s->reloc_count; i++)
1562         {
1563           struct internal_reloc n;
1564           arelent *q = p[i];
1565           memset ((PTR) & n, 0, sizeof (n));
1566
1567           /* Now we've renumbered the symbols we know where the
1568              undefined symbols live in the table.  Check the reloc
1569              entries for symbols who's output bfd isn't the right one.
1570              This is because the symbol was undefined (which means
1571              that all the pointers are never made to point to the same
1572              place). This is a bad thing,'cause the symbols attached
1573              to the output bfd are indexed, so that the relocation
1574              entries know which symbol index they point to.  So we
1575              have to look up the output symbol here. */
1576
1577           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1578             {
1579               int i;
1580               const char *sname = q->sym_ptr_ptr[0]->name;
1581               asymbol **outsyms = abfd->outsymbols;
1582               for (i = first_undef; outsyms[i]; i++)
1583                 {
1584                   const char *intable = outsyms[i]->name;
1585                   if (strcmp (intable, sname) == 0) {
1586                     /* got a hit, so repoint the reloc */
1587                     q->sym_ptr_ptr = outsyms + i;
1588                     break;
1589                   }
1590                 }
1591             }
1592
1593           n.r_vaddr = q->address + s->vma;
1594
1595 #ifdef R_IHCONST
1596           /* The 29k const/consth reloc pair is a real kludge.  The consth
1597              part doesn't have a symbol; it has an offset.  So rebuilt
1598              that here.  */
1599           if (q->howto->type == R_IHCONST)
1600             n.r_symndx = q->addend;
1601           else
1602 #endif
1603             if (q->sym_ptr_ptr)
1604               {
1605                 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1606                   /* This is a relocation relative to the absolute symbol.  */
1607                   n.r_symndx = -1;
1608                 else
1609                   {
1610                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1611                     /* Take notice if the symbol reloc points to a symbol
1612                        we don't have in our symbol table.  What should we
1613                        do for this??  */
1614                     if (n.r_symndx > obj_conv_table_size (abfd))
1615                       abort ();
1616                   }
1617               }
1618
1619 #ifdef SWAP_OUT_RELOC_OFFSET
1620           n.r_offset = q->addend;
1621 #endif
1622
1623 #ifdef SELECT_RELOC
1624           /* Work out reloc type from what is required */
1625           SELECT_RELOC (n, q->howto);
1626 #else
1627           n.r_type = q->howto->type;
1628 #endif
1629           coff_swap_reloc_out (abfd, &n, &dst);
1630           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1631             return false;
1632         }
1633     }
1634
1635   return true;
1636 }
1637
1638 /* Set flags and magic number of a coff file from architecture and machine
1639    type.  Result is true if we can represent the arch&type, false if not.  */
1640
1641 static boolean
1642 coff_set_flags (abfd, magicp, flagsp)
1643      bfd * abfd;
1644      unsigned *magicp;
1645      unsigned short *flagsp;
1646 {
1647   switch (bfd_get_arch (abfd))
1648     {
1649 #ifdef Z8KMAGIC
1650     case bfd_arch_z8k:
1651       *magicp = Z8KMAGIC;
1652       switch (bfd_get_mach (abfd))
1653         {
1654         case bfd_mach_z8001:
1655           *flagsp = F_Z8001;
1656           break;
1657         case bfd_mach_z8002:
1658           *flagsp = F_Z8002;
1659           break;
1660         default:
1661           return false;
1662         }
1663       return true;
1664 #endif
1665 #ifdef I960ROMAGIC
1666
1667     case bfd_arch_i960:
1668
1669       {
1670         unsigned flags;
1671         *magicp = I960ROMAGIC;
1672         /*
1673           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1674           I960RWMAGIC);   FIXME???
1675           */
1676         switch (bfd_get_mach (abfd))
1677           {
1678           case bfd_mach_i960_core:
1679             flags = F_I960CORE;
1680             break;
1681           case bfd_mach_i960_kb_sb:
1682             flags = F_I960KB;
1683             break;
1684           case bfd_mach_i960_mc:
1685             flags = F_I960MC;
1686             break;
1687           case bfd_mach_i960_xa:
1688             flags = F_I960XA;
1689             break;
1690           case bfd_mach_i960_ca:
1691             flags = F_I960CA;
1692             break;
1693           case bfd_mach_i960_ka_sa:
1694             flags = F_I960KA;
1695             break;
1696             /* start-sanitize-i960xl */
1697           case bfd_mach_i960_xl:
1698             flags = F_I960XL;
1699             break;
1700             /* end-sanitize-i960xl */
1701           default:
1702             return false;
1703           }
1704         *flagsp = flags;
1705         return true;
1706       }
1707       break;
1708 #endif
1709 #ifdef ARMMAGIC
1710     case bfd_arch_arm:
1711       *magicp = ARMMAGIC;
1712       return true;
1713 #endif
1714 #ifdef PPCMAGIC
1715     case bfd_arch_powerpc:
1716       *magicp = PPCMAGIC;
1717       return true;
1718       break;
1719 #endif
1720 #ifdef I386MAGIC
1721     case bfd_arch_i386:
1722       *magicp = I386MAGIC;
1723 #ifdef LYNXOS
1724       /* Just overwrite the usual value if we're doing Lynx. */
1725       *magicp = LYNXCOFFMAGIC;
1726 #endif
1727       return true;
1728       break;
1729 #endif
1730 #ifdef I860MAGIC
1731     case bfd_arch_i860:
1732       *magicp = I860MAGIC;
1733       return true;
1734       break;
1735 #endif
1736 #ifdef MC68MAGIC
1737     case bfd_arch_m68k:
1738 #ifdef APOLLOM68KMAGIC
1739       *magicp = APOLLO_COFF_VERSION_NUMBER;
1740 #else
1741       *magicp = MC68MAGIC;
1742 #endif
1743 #ifdef LYNXOS
1744       /* Just overwrite the usual value if we're doing Lynx. */
1745       *magicp = LYNXCOFFMAGIC;
1746 #endif
1747       return true;
1748       break;
1749 #endif
1750
1751 #ifdef MC88MAGIC
1752     case bfd_arch_m88k:
1753       *magicp = MC88OMAGIC;
1754       return true;
1755       break;
1756 #endif
1757 #ifdef H8300MAGIC
1758     case bfd_arch_h8300:
1759       switch (bfd_get_mach (abfd))
1760         {
1761         case bfd_mach_h8300:
1762           *magicp = H8300MAGIC;
1763           return true;
1764         case bfd_mach_h8300h:
1765           *magicp = H8300HMAGIC;
1766           return true;
1767         }
1768       break;
1769 #endif
1770
1771 #ifdef SH_ARCH_MAGIC_BIG
1772     case bfd_arch_sh:
1773       if (bfd_big_endian (abfd))
1774         *magicp = SH_ARCH_MAGIC_BIG;
1775       else
1776         *magicp = SH_ARCH_MAGIC_LITTLE;
1777       return true;
1778       break;
1779 #endif
1780
1781 #ifdef SPARCMAGIC
1782     case bfd_arch_sparc:
1783       *magicp = SPARCMAGIC;
1784 #ifdef LYNXOS
1785       /* Just overwrite the usual value if we're doing Lynx. */
1786       *magicp = LYNXCOFFMAGIC;
1787 #endif
1788       return true;
1789       break;
1790 #endif
1791
1792 #ifdef H8500MAGIC
1793     case bfd_arch_h8500:
1794       *magicp = H8500MAGIC;
1795       return true;
1796       break;
1797 #endif
1798 #ifdef A29K_MAGIC_BIG
1799     case bfd_arch_a29k:
1800       if (bfd_big_endian (abfd))
1801         *magicp = A29K_MAGIC_BIG;
1802       else
1803         *magicp = A29K_MAGIC_LITTLE;
1804       return true;
1805       break;
1806 #endif
1807
1808 #ifdef WE32KMAGIC
1809     case bfd_arch_we32k:
1810       *magicp = WE32KMAGIC;
1811       return true;
1812       break;
1813 #endif
1814
1815 #ifdef U802TOCMAGIC
1816     case bfd_arch_rs6000:
1817 #ifndef PPCMAGIC
1818     case bfd_arch_powerpc:
1819 #endif
1820       *magicp = U802TOCMAGIC;
1821       return true;
1822       break;
1823 #endif
1824
1825     default:                    /* Unknown architecture */
1826       /* return false;  -- fall through to "return false" below, to avoid
1827        "statement never reached" errors on the one below. */
1828       break;
1829     }
1830
1831   return false;
1832 }
1833
1834
1835 static boolean
1836 coff_set_arch_mach (abfd, arch, machine)
1837      bfd * abfd;
1838      enum bfd_architecture arch;
1839      unsigned long machine;
1840 {
1841   unsigned dummy1;
1842   unsigned short dummy2;
1843
1844   if (! bfd_default_set_arch_mach (abfd, arch, machine))
1845     return false;
1846
1847   if (arch != bfd_arch_unknown &&
1848       coff_set_flags (abfd, &dummy1, &dummy2) != true)
1849     return false;               /* We can't represent this type */
1850
1851   return true;                  /* We're easy ... */
1852 }
1853
1854
1855 /* Calculate the file position for each section. */
1856
1857 static void
1858 coff_compute_section_file_positions (abfd)
1859      bfd * abfd;
1860 {
1861   asection *current;
1862   asection *previous = (asection *) NULL;
1863   file_ptr sofar = FILHSZ;
1864
1865 #ifndef I960
1866   file_ptr old_sofar;
1867 #endif
1868   unsigned int count;
1869
1870 #ifdef RS6000COFF_C
1871   /* On XCOFF, if we have symbols, set up the .debug section.  */
1872   if (bfd_get_symcount (abfd) > 0)
1873     {
1874       bfd_size_type sz;
1875       bfd_size_type i, symcount;
1876       asymbol **symp;
1877
1878       sz = 0;
1879       symcount = bfd_get_symcount (abfd);
1880       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
1881         {
1882           coff_symbol_type *cf;
1883
1884           cf = coff_symbol_from (abfd, *symp);
1885           if (cf != NULL
1886               && cf->native != NULL
1887               && SYMNAME_IN_DEBUG (&cf->native->u.syment))
1888             {
1889               size_t len;
1890
1891               len = strlen (bfd_asymbol_name (*symp));
1892               if (len > SYMNMLEN)
1893                 sz += len + 3;
1894             }
1895         }
1896       if (sz > 0)
1897         {
1898           asection *dsec;
1899
1900           dsec = bfd_make_section_old_way (abfd, ".debug");
1901           if (dsec == NULL)
1902             abort ();
1903           dsec->_raw_size = sz;
1904           dsec->flags |= SEC_HAS_CONTENTS;
1905         }
1906     }
1907 #endif
1908
1909 #ifdef COFF_IMAGE_WITH_PE
1910   int page_size;
1911   if (coff_data (abfd)->link_info)
1912     {
1913       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
1914     }
1915   else
1916     page_size = PE_DEF_FILE_ALIGNMENT;
1917 #else
1918 #ifdef COFF_PAGE_SIZE
1919   int page_size = COFF_PAGE_SIZE;
1920 #endif
1921 #endif
1922
1923   if (bfd_get_start_address (abfd))
1924     {
1925       /*  A start address may have been added to the original file. In this
1926           case it will need an optional header to record it.  */
1927       abfd->flags |= EXEC_P;
1928     }
1929
1930   if (abfd->flags & EXEC_P)
1931     sofar += AOUTSZ;
1932 #ifdef RS6000COFF_C
1933   else if (xcoff_data (abfd)->full_aouthdr)
1934     sofar += AOUTSZ;
1935   else
1936     sofar += SMALL_AOUTSZ;
1937 #endif
1938
1939   sofar += abfd->section_count * SCNHSZ;
1940
1941 #ifdef RS6000COFF_C
1942   /* XCOFF handles overflows in the reloc and line number count fields
1943      by allocating a new section header to hold the correct counts.  */
1944   for (current = abfd->sections; current != NULL; current = current->next)
1945     if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
1946       sofar += SCNHSZ;
1947 #endif
1948
1949   for (current = abfd->sections, count = 1;
1950        current != (asection *) NULL;
1951        current = current->next, ++count)
1952     {
1953       current->target_index = count;
1954
1955       /* Only deal with sections which have contents */
1956       if (!(current->flags & SEC_HAS_CONTENTS))
1957         continue;
1958
1959 #ifdef COFF_WITH_PE
1960       /* Do not include the .junk section.  This is where we collect section
1961          data which we don't need.  This is mainly the MS .debug$ data which
1962          stores codeview debug data. */
1963       if (strcmp (current->name, ".junk") == 0)
1964         {
1965           continue;
1966         }
1967 #endif
1968
1969       /* Align the sections in the file to the same boundary on
1970          which they are aligned in virtual memory.  I960 doesn't
1971          do this (FIXME) so we can stay in sync with Intel.  960
1972          doesn't yet page from files... */
1973 #ifndef I960
1974       if ((abfd->flags & EXEC_P) != 0)
1975         {
1976           /* make sure this section is aligned on the right boundary - by
1977              padding the previous section up if necessary */
1978
1979           old_sofar = sofar;
1980           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1981           if (previous != (asection *) NULL)
1982             {
1983               previous->_raw_size += sofar - old_sofar;
1984             }
1985         }
1986
1987 #endif
1988
1989       /* In demand paged files the low order bits of the file offset
1990          must match the low order bits of the virtual address.  */
1991 #ifdef COFF_PAGE_SIZE
1992       if ((abfd->flags & D_PAGED) != 0
1993           && (current->flags & SEC_ALLOC) != 0)
1994         sofar += (current->vma - sofar) % page_size;
1995 #endif
1996       current->filepos = sofar;
1997
1998 #ifdef COFF_IMAGE_WITH_PE
1999       /* With PE we have to pad each section to be a multiple of its page size
2000          too, and remember both sizes. Cooked_size becomes very useful. */
2001       current->_cooked_size = current->_raw_size;
2002       current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2003 #endif
2004
2005       sofar += current->_raw_size;
2006
2007 #ifndef I960
2008       /* make sure that this section is of the right size too */
2009       old_sofar = sofar;
2010       sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2011       current->_raw_size += sofar - old_sofar;
2012 #endif
2013
2014 #ifdef _LIB
2015       /* Force .lib sections to start at zero.  The vma is then
2016          incremented in coff_set_section_contents.  This is right for
2017          SVR3.2.  */
2018       if (strcmp (current->name, _LIB) == 0)
2019         bfd_set_section_vma (abfd, current, 0);
2020 #endif
2021
2022       previous = current;
2023     }
2024
2025   obj_relocbase (abfd) = sofar;
2026   abfd->output_has_begun = true;
2027
2028 }
2029
2030 #ifndef RS6000COFF_C
2031
2032 /* If .file, .text, .data, .bss symbols are missing, add them.  */
2033 /* @@ Should we only be adding missing symbols, or overriding the aux
2034    values for existing section symbols?  */
2035 static boolean
2036 coff_add_missing_symbols (abfd)
2037      bfd *abfd;
2038 {
2039   unsigned int nsyms = bfd_get_symcount (abfd);
2040   asymbol **sympp = abfd->outsymbols;
2041   asymbol **sympp2;
2042   unsigned int i;
2043   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
2044
2045   for (i = 0; i < nsyms; i++)
2046     {
2047       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
2048       CONST char *name;
2049       if (csym)
2050         {
2051           /* only do this if there is a coff representation of the input
2052            symbol */
2053           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
2054             {
2055               need_file = 0;
2056               continue;
2057             }
2058           name = csym->symbol.name;
2059           if (!name)
2060             continue;
2061           if (!strcmp (name, _TEXT))
2062             need_text = 0;
2063 #ifdef APOLLO_M68
2064           else if (!strcmp (name, ".wtext"))
2065             need_text = 0;
2066 #endif
2067           else if (!strcmp (name, _DATA))
2068             need_data = 0;
2069           else if (!strcmp (name, _BSS))
2070             need_bss = 0;
2071         }
2072     }
2073   /* Now i == bfd_get_symcount (abfd).  */
2074   /* @@ For now, don't deal with .file symbol.  */
2075   need_file = 0;
2076
2077   if (!need_text && !need_data && !need_bss && !need_file)
2078     return true;
2079   nsyms += need_text + need_data + need_bss + need_file;
2080   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
2081   if (!sympp2)
2082     return false;
2083   memcpy (sympp2, sympp, i * sizeof (asymbol *));
2084   if (need_file)
2085     {
2086       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
2087       abort ();
2088     }
2089   if (need_text)
2090     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
2091   if (need_data)
2092     sympp2[i++] = coff_section_symbol (abfd, _DATA);
2093   if (need_bss)
2094     sympp2[i++] = coff_section_symbol (abfd, _BSS);
2095   BFD_ASSERT (i == nsyms);
2096   bfd_set_symtab (abfd, sympp2, nsyms);
2097   return true;
2098 }
2099
2100 #endif /* ! defined (RS6000COFF_C) */
2101
2102
2103
2104 /* SUPPRESS 558 */
2105 /* SUPPRESS 529 */
2106 static boolean
2107 coff_write_object_contents (abfd)
2108      bfd * abfd;
2109 {
2110   asection *current;
2111   boolean hasrelocs = false;
2112   boolean haslinno = false;
2113   file_ptr scn_base;
2114   file_ptr reloc_base;
2115   file_ptr lineno_base;
2116   file_ptr sym_base;
2117   unsigned long reloc_size = 0;
2118   unsigned long lnno_size = 0;
2119   asection *text_sec = NULL;
2120   asection *data_sec = NULL;
2121   asection *bss_sec = NULL;
2122
2123   struct internal_filehdr internal_f;
2124   struct internal_aouthdr internal_a;
2125
2126   bfd_set_error (bfd_error_system_call);
2127
2128   /* Make a pass through the symbol table to count line number entries and
2129      put them into the correct asections */
2130
2131   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
2132
2133   if (abfd->output_has_begun == false)
2134     coff_compute_section_file_positions (abfd);
2135
2136   reloc_base = obj_relocbase (abfd);
2137
2138   /* Work out the size of the reloc and linno areas */
2139
2140   for (current = abfd->sections; current != NULL; current =
2141        current->next)
2142     reloc_size += current->reloc_count * RELSZ;
2143
2144   lineno_base = reloc_base + reloc_size;
2145   sym_base = lineno_base + lnno_size;
2146
2147   /* Indicate in each section->line_filepos its actual file address */
2148   for (current = abfd->sections; current != NULL; current =
2149        current->next)
2150     {
2151       if (current->lineno_count)
2152         {
2153           current->line_filepos = lineno_base;
2154           current->moving_line_filepos = lineno_base;
2155           lineno_base += current->lineno_count * LINESZ;
2156         }
2157       else
2158         {
2159           current->line_filepos = 0;
2160         }
2161       if (current->reloc_count)
2162         {
2163           current->rel_filepos = reloc_base;
2164           reloc_base += current->reloc_count * RELSZ;
2165         }
2166       else
2167         {
2168           current->rel_filepos = 0;
2169         }
2170     }
2171
2172   /* Write section headers to the file.  */
2173   internal_f.f_nscns = 0;
2174
2175   if ((abfd->flags & EXEC_P) != 0)
2176     scn_base = FILHSZ + AOUTSZ;
2177   else
2178     {
2179       scn_base = FILHSZ;
2180 #ifdef RS6000COFF_C
2181       if (xcoff_data (abfd)->full_aouthdr)
2182         scn_base += AOUTSZ;
2183       else
2184         scn_base += SMALL_AOUTSZ;
2185 #endif
2186     }
2187
2188   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
2189     return false;
2190
2191   for (current = abfd->sections;
2192        current != NULL;
2193        current = current->next)
2194     {
2195       struct internal_scnhdr section;
2196
2197 #ifdef COFF_WITH_PE
2198       /* Do not include the .junk section.  This is where we collect section
2199          data which we don't need.  This is mainly the MS .debug$ data which
2200          stores codeview debug data. */
2201       if (strcmp (current->name, ".junk") == 0)
2202         {
2203           continue;
2204         }
2205
2206       /* If we've got a .reloc section, remember. */
2207
2208 #ifdef COFF_IMAGE_WITH_PE
2209       if (strcmp (current->name, ".reloc") == 0)
2210         {
2211           pe_data (abfd)->has_reloc_section = 1;
2212         }
2213 #endif
2214
2215 #endif
2216       internal_f.f_nscns++;
2217       strncpy (&(section.s_name[0]), current->name, 8);
2218 #ifdef _LIB
2219       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
2220          Ian Taylor <ian@cygnus.com>.  */
2221       if (strcmp (current->name, _LIB) == 0)
2222         section.s_vaddr = 0;
2223       else
2224 #endif
2225       section.s_vaddr = current->vma;
2226       section.s_paddr = current->lma;
2227       section.s_size =  current->_raw_size;
2228
2229 #ifdef COFF_WITH_PE
2230       section.s_paddr = current->_cooked_size;
2231 #endif
2232
2233       /*
2234          If this section has no size or is unloadable then the scnptr
2235          will be 0 too
2236          */
2237       if (current->_raw_size == 0 ||
2238           (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2239         {
2240           section.s_scnptr = 0;
2241         }
2242       else
2243         {
2244           section.s_scnptr = current->filepos;
2245         }
2246       section.s_relptr = current->rel_filepos;
2247       section.s_lnnoptr = current->line_filepos;
2248       section.s_nreloc = current->reloc_count;
2249       section.s_nlnno = current->lineno_count;
2250       if (current->reloc_count != 0)
2251         hasrelocs = true;
2252       if (current->lineno_count != 0)
2253         haslinno = true;
2254
2255 #ifdef RS6000COFF_C
2256       /* Indicate the use of an XCOFF overflow section header.  */
2257       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2258         {
2259           section.s_nreloc = 0xffff;
2260           section.s_nlnno = 0xffff;
2261         }
2262 #endif
2263
2264       section.s_flags = sec_to_styp_flags (current->name, current->flags);
2265
2266       if (!strcmp (current->name, _TEXT))
2267         {
2268           text_sec = current;
2269         }
2270       else if (!strcmp (current->name, _DATA))
2271         {
2272           data_sec = current;
2273         }
2274       else if (!strcmp (current->name, _BSS))
2275         {
2276           bss_sec = current;
2277         }
2278
2279 #ifdef I960
2280       section.s_align = (current->alignment_power
2281                          ? 1 << current->alignment_power
2282                          : 0);
2283
2284 #endif
2285
2286 #ifdef COFF_IMAGE_WITH_PE
2287       /* suppress output of the sections if they are null.  ld includes
2288          the bss and data sections even if there is no size assigned
2289          to them.  NT loader doesn't like it if these section headers are
2290          included if the sections themselves are not needed */
2291       if (section.s_size == 0)
2292         internal_f.f_nscns--;
2293       else
2294 #endif
2295         {
2296           SCNHDR buff;
2297           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2298               || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2299             return false;
2300         }
2301     }
2302
2303 #ifdef RS6000COFF_C
2304   /* XCOFF handles overflows in the reloc and line number count fields
2305      by creating a new section header to hold the correct values.  */
2306   for (current = abfd->sections; current != NULL; current = current->next)
2307     {
2308       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2309         {
2310           struct internal_scnhdr scnhdr;
2311           SCNHDR buff;
2312
2313           internal_f.f_nscns++;
2314           strncpy (&(scnhdr.s_name[0]), current->name, 8);
2315           scnhdr.s_paddr = current->reloc_count;
2316           scnhdr.s_vaddr = current->lineno_count;
2317           scnhdr.s_size = 0;
2318           scnhdr.s_scnptr = 0;
2319           scnhdr.s_relptr = current->rel_filepos;
2320           scnhdr.s_lnnoptr = current->line_filepos;
2321           scnhdr.s_nreloc = current->target_index;
2322           scnhdr.s_nlnno = current->target_index;
2323           scnhdr.s_flags = STYP_OVRFLO;
2324           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
2325               || bfd_write ((PTR) &buff, 1, SCNHSZ, abfd) != SCNHSZ)
2326             return false;
2327         }
2328     }
2329 #endif
2330
2331   /* OK, now set up the filehdr... */
2332
2333   /* Don't include the internal abs section in the section count */
2334
2335   /*
2336      We will NOT put a fucking timestamp in the header here. Every time you
2337      put it back, I will come in and take it out again.  I'm sorry.  This
2338      field does not belong here.  We fill it with a 0 so it compares the
2339      same but is not a reasonable time. -- gnu@cygnus.com
2340      */
2341   internal_f.f_timdat = 0;
2342
2343   internal_f.f_flags = 0;
2344
2345   if (abfd->flags & EXEC_P)
2346     internal_f.f_opthdr = AOUTSZ;
2347   else
2348     {
2349       internal_f.f_opthdr = 0;
2350 #ifdef RS6000COFF_C
2351       if (xcoff_data (abfd)->full_aouthdr)
2352         internal_f.f_opthdr = AOUTSZ;
2353       else
2354         internal_f.f_opthdr = SMALL_AOUTSZ;
2355 #endif
2356     }
2357
2358   if (!hasrelocs)
2359     internal_f.f_flags |= F_RELFLG;
2360   if (!haslinno)
2361     internal_f.f_flags |= F_LNNO;
2362   if (abfd->flags & EXEC_P)
2363     internal_f.f_flags |= F_EXEC;
2364
2365   /* FIXME: this is wrong for PPC_PE! */
2366   if (bfd_little_endian (abfd))
2367     internal_f.f_flags |= F_AR32WR;
2368   else
2369     internal_f.f_flags |= F_AR32W;
2370
2371   /*
2372      FIXME, should do something about the other byte orders and
2373      architectures.
2374      */
2375
2376 #ifdef RS6000COFF_C
2377   if ((abfd->flags & DYNAMIC) != 0)
2378     internal_f.f_flags |= F_SHROBJ;
2379   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
2380     internal_f.f_flags |= F_DYNLOAD;
2381 #endif
2382
2383   memset (&internal_a, 0, sizeof internal_a);
2384
2385   /* Set up architecture-dependent stuff */
2386
2387   {
2388     unsigned int magic = 0;
2389     unsigned short flags = 0;
2390     coff_set_flags (abfd, &magic, &flags);
2391     internal_f.f_magic = magic;
2392     internal_f.f_flags |= flags;
2393     /* ...and the "opt"hdr... */
2394
2395 #ifdef A29K
2396 #ifdef ULTRA3                   /* NYU's machine */
2397     /* FIXME: This is a bogus check.  I really want to see if there
2398      * is a .shbss or a .shdata section, if so then set the magic
2399      * number to indicate a shared data executable.
2400      */
2401     if (internal_f.f_nscns >= 7)
2402       internal_a.magic = SHMAGIC; /* Shared magic */
2403     else
2404 #endif /* ULTRA3 */
2405       internal_a.magic = NMAGIC; /* Assume separate i/d */
2406 #define __A_MAGIC_SET__
2407 #endif /* A29K */
2408 #ifdef I860
2409     /* FIXME: What are the a.out magic numbers for the i860?  */
2410     internal_a.magic = 0;
2411 #define __A_MAGIC_SET__
2412 #endif /* I860 */
2413 #ifdef I960
2414     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
2415 #define __A_MAGIC_SET__
2416 #endif /* I960 */
2417 #if M88
2418 #define __A_MAGIC_SET__
2419     internal_a.magic = PAGEMAGICBCS;
2420 #endif /* M88 */
2421
2422 #if APOLLO_M68
2423 #define __A_MAGIC_SET__
2424     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
2425 #endif
2426
2427 #if defined(M68) || defined(WE32K) || defined(M68K)
2428 #define __A_MAGIC_SET__
2429 #if defined(LYNXOS)
2430     internal_a.magic = LYNXCOFFMAGIC;
2431 #else
2432 #if defined (PAGEMAGICPEXECPAGED)
2433     internal_a.magic = PAGEMAGICPEXECPAGED;
2434 #endif
2435 #endif /* LYNXOS */
2436 #endif /* M68 || WE32K || M68K */
2437
2438 #if defined(ARM)
2439 #define __A_MAGIC_SET__
2440     internal_a.magic = ZMAGIC;
2441 #endif
2442 #if defined(PPC)
2443 #define __A_MAGIC_SET__
2444     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
2445 #endif
2446 #if defined(I386)
2447 #define __A_MAGIC_SET__
2448 #if defined(LYNXOS)
2449     internal_a.magic = LYNXCOFFMAGIC;
2450 #else  /* LYNXOS */
2451     internal_a.magic = ZMAGIC;
2452 #endif /* LYNXOS */
2453 #endif /* I386 */
2454
2455 #if defined(SPARC)
2456 #define __A_MAGIC_SET__
2457 #if defined(LYNXOS)
2458     internal_a.magic = LYNXCOFFMAGIC;
2459 #endif /* LYNXOS */
2460 #endif /* SPARC */
2461
2462 #if RS6000COFF_C
2463 #define __A_MAGIC_SET__
2464     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
2465     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
2466     RS6K_AOUTHDR_OMAGIC;
2467 #endif
2468
2469 #ifndef __A_MAGIC_SET__
2470 #include "Your aouthdr magic number is not being set!"
2471 #else
2472 #undef __A_MAGIC_SET__
2473 #endif
2474   }
2475
2476   /* FIXME: Does anybody ever set this to another value?  */
2477   internal_a.vstamp = 0;
2478
2479   /* Now should write relocs, strings, syms */
2480   obj_sym_filepos (abfd) = sym_base;
2481
2482   if (bfd_get_symcount (abfd) != 0)
2483     {
2484       int firstundef;
2485 #ifndef RS6000COFF_C
2486       if (!coff_add_missing_symbols (abfd))
2487         return false;
2488 #endif
2489       if (!coff_renumber_symbols (abfd, &firstundef))
2490         return false;
2491       coff_mangle_symbols (abfd);
2492       if (! coff_write_symbols (abfd))
2493         return false;
2494       if (! coff_write_linenumbers (abfd))
2495         return false;
2496       if (! coff_write_relocs (abfd, firstundef))
2497         return false;
2498     }
2499 #ifdef COFF_IMAGE_WITH_PE
2500 #ifdef PPC
2501   else if ((abfd->flags & EXEC_P) != 0)
2502     {
2503       bfd_byte b;
2504
2505       /* PowerPC PE appears to require that all executable files be
2506          rounded up to the page size.  */
2507       b = 0;
2508       if (bfd_seek (abfd,
2509                     BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
2510                     SEEK_SET) != 0
2511           || bfd_write (&b, 1, 1, abfd) != 1)
2512         return false;
2513     }
2514 #endif
2515 #endif
2516
2517   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2518      backend linker, and obj_raw_syment_count is not valid until after
2519      coff_write_symbols is called.  */
2520   if (obj_raw_syment_count (abfd) != 0)
2521     {
2522       internal_f.f_symptr = sym_base;
2523 #ifdef RS6000COFF_C
2524       /* AIX appears to require that F_RELFLG not be set if there are
2525          local symbols but no relocations.  */
2526       internal_f.f_flags &=~ F_RELFLG;
2527 #endif
2528     }
2529   else
2530     {
2531       internal_f.f_symptr = 0;
2532       internal_f.f_flags |= F_LSYMS;
2533     }
2534
2535   if (text_sec)
2536     {
2537       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
2538       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
2539     }
2540   if (data_sec)
2541     {
2542       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
2543       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
2544     }
2545   if (bss_sec)
2546     {
2547       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
2548       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
2549         internal_a.data_start = bss_sec->vma;
2550     }
2551
2552   internal_a.entry = bfd_get_start_address (abfd);
2553   internal_f.f_nsyms = obj_raw_syment_count (abfd);
2554
2555 #ifdef RS6000COFF_C
2556   if (xcoff_data (abfd)->full_aouthdr)
2557     {
2558       bfd_vma toc;
2559       asection *loader_sec;
2560
2561       internal_a.vstamp = 1;
2562
2563       if (xcoff_data (abfd)->entry_section != NULL)
2564         internal_a.o_snentry = xcoff_data (abfd)->entry_section->target_index;
2565       else
2566         {
2567           internal_a.o_snentry = 0;
2568           internal_a.entry = (bfd_vma) -1;
2569         }
2570
2571       if (text_sec != NULL)
2572         {
2573           internal_a.o_sntext = text_sec->target_index;
2574           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
2575         }
2576       else
2577         {
2578           internal_a.o_sntext = 0;
2579           internal_a.o_algntext = 0;
2580         }
2581       if (data_sec != NULL)
2582         {
2583           internal_a.o_sndata = data_sec->target_index;
2584           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
2585         }
2586       else
2587         {
2588           internal_a.o_sndata = 0;
2589           internal_a.o_algndata = 0;
2590         }
2591       loader_sec = bfd_get_section_by_name (abfd, ".loader");
2592       if (loader_sec != NULL)
2593         internal_a.o_snloader = loader_sec->target_index;
2594       else
2595         internal_a.o_snloader = 0;
2596       if (bss_sec != NULL)
2597         internal_a.o_snbss = bss_sec->target_index;
2598       else
2599         internal_a.o_snbss = 0;
2600
2601       toc = xcoff_data (abfd)->toc;
2602       internal_a.o_toc = toc;
2603       if (xcoff_data (abfd)->toc_section == NULL)
2604         internal_a.o_sntoc = 0;
2605       else
2606         internal_a.o_sntoc = xcoff_data (abfd)->toc_section->target_index;
2607
2608       internal_a.o_modtype = xcoff_data (abfd)->modtype;
2609       if (xcoff_data (abfd)->cputype != -1)
2610         internal_a.o_cputype = xcoff_data (abfd)->cputype;
2611       else
2612         {
2613           switch (bfd_get_arch (abfd))
2614             {
2615             case bfd_arch_rs6000:
2616               internal_a.o_cputype = 4;
2617               break;
2618             case bfd_arch_powerpc:
2619               if (bfd_get_mach (abfd) == 0)
2620                 internal_a.o_cputype = 3;
2621               else
2622                 internal_a.o_cputype = 1;
2623               break;
2624             default:
2625               abort ();
2626             }
2627         }
2628       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
2629       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
2630     }
2631 #endif
2632
2633   /* now write them */
2634   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2635     return false;
2636   {
2637     FILHDR buff;
2638     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
2639     if (bfd_write ((PTR) & buff, 1, FILHSZ, abfd) != FILHSZ)
2640       return false;
2641   }
2642   if (abfd->flags & EXEC_P)
2643     {
2644       AOUTHDR buff;
2645       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
2646       if (bfd_write ((PTR) & buff, 1, AOUTSZ, abfd) != AOUTSZ)
2647         return false;
2648     }
2649 #ifdef RS6000COFF_C
2650   else
2651     {
2652       AOUTHDR buff;
2653       size_t size;
2654
2655       /* XCOFF seems to always write at least a small a.out header.  */
2656       coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
2657       if (xcoff_data (abfd)->full_aouthdr)
2658         size = AOUTSZ;
2659       else
2660         size = SMALL_AOUTSZ;
2661       if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
2662         return false;
2663     }
2664 #endif
2665
2666   return true;
2667 }
2668
2669 static boolean
2670 coff_set_section_contents (abfd, section, location, offset, count)
2671      bfd * abfd;
2672      sec_ptr section;
2673      PTR location;
2674      file_ptr offset;
2675      bfd_size_type count;
2676 {
2677   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
2678     coff_compute_section_file_positions (abfd);
2679
2680 #ifdef _LIB
2681   /* If this is a .lib section, bump the vma address so that it
2682        winds up being the number of .lib sections output.  This is
2683        right for SVR3.2.  Shared libraries should probably get more
2684        generic support.  Ian Taylor <ian@cygnus.com>.  */
2685   if (strcmp (section->name, _LIB) == 0)
2686     ++section->lma;
2687 #endif
2688
2689   /* Don't write out bss sections - one way to do this is to
2690        see if the filepos has not been set. */
2691   if (section->filepos == 0)
2692     return true;
2693
2694   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
2695     return false;
2696
2697   if (count != 0)
2698     {
2699       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
2700     }
2701   return true;
2702 }
2703 #if 0
2704 static boolean
2705 coff_close_and_cleanup (abfd)
2706      bfd *abfd;
2707 {
2708   if (!bfd_read_p (abfd))
2709     switch (abfd->format)
2710       {
2711       case bfd_archive:
2712         if (!_bfd_write_archive_contents (abfd))
2713           return false;
2714         break;
2715       case bfd_object:
2716         if (!coff_write_object_contents (abfd))
2717           return false;
2718         break;
2719       default:
2720         bfd_set_error (bfd_error_invalid_operation);
2721         return false;
2722       }
2723
2724   /* We depend on bfd_close to free all the memory on the obstack.  */
2725   /* FIXME if bfd_release is not using obstacks! */
2726   return true;
2727 }
2728
2729 #endif
2730
2731 static PTR
2732 buy_and_read (abfd, where, seek_direction, size)
2733      bfd *abfd;
2734      file_ptr where;
2735      int seek_direction;
2736      size_t size;
2737 {
2738   PTR area = (PTR) bfd_alloc (abfd, size);
2739   if (!area)
2740     return (NULL);
2741   if (bfd_seek (abfd, where, seek_direction) != 0
2742       || bfd_read (area, 1, size, abfd) != size)
2743     return (NULL);
2744   return (area);
2745 }                               /* buy_and_read() */
2746
2747 /*
2748 SUBSUBSECTION
2749         Reading linenumbers
2750
2751         Creating the linenumber table is done by reading in the entire
2752         coff linenumber table, and creating another table for internal use.
2753
2754         A coff linenumber table is structured so that each function
2755         is marked as having a line number of 0. Each line within the
2756         function is an offset from the first line in the function. The
2757         base of the line number information for the table is stored in
2758         the symbol associated with the function.
2759
2760         The information is copied from the external to the internal
2761         table, and each symbol which marks a function is marked by
2762         pointing its...
2763
2764         How does this work ?
2765
2766 */
2767
2768 static boolean
2769 coff_slurp_line_table (abfd, asect)
2770      bfd *abfd;
2771      asection *asect;
2772 {
2773   LINENO *native_lineno;
2774   alent *lineno_cache;
2775
2776   BFD_ASSERT (asect->lineno == (alent *) NULL);
2777
2778   native_lineno = (LINENO *) buy_and_read (abfd,
2779                                            asect->line_filepos,
2780                                            SEEK_SET,
2781                                            (size_t) (LINESZ *
2782                                                      asect->lineno_count));
2783   lineno_cache =
2784     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
2785   if (lineno_cache == NULL)
2786     return false;
2787   else
2788     {
2789       unsigned int counter = 0;
2790       alent *cache_ptr = lineno_cache;
2791       LINENO *src = native_lineno;
2792
2793       while (counter < asect->lineno_count)
2794         {
2795           struct internal_lineno dst;
2796           coff_swap_lineno_in (abfd, src, &dst);
2797           cache_ptr->line_number = dst.l_lnno;
2798
2799           if (cache_ptr->line_number == 0)
2800             {
2801               coff_symbol_type *sym =
2802               (coff_symbol_type *) (dst.l_addr.l_symndx
2803                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
2804               cache_ptr->u.sym = (asymbol *) sym;
2805               if (sym->lineno != NULL)
2806                 {
2807                   (*_bfd_error_handler)
2808                     ("%s: warning: duplicate line number information for `%s'",
2809                      bfd_get_filename (abfd),
2810                      bfd_asymbol_name (&sym->symbol));
2811                 }
2812               sym->lineno = cache_ptr;
2813             }
2814           else
2815             {
2816               cache_ptr->u.offset = dst.l_addr.l_paddr
2817                 - bfd_section_vma (abfd, asect);
2818             }                   /* If no linenumber expect a symbol index */
2819
2820           cache_ptr++;
2821           src++;
2822           counter++;
2823         }
2824       cache_ptr->line_number = 0;
2825
2826     }
2827   asect->lineno = lineno_cache;
2828   /* FIXME, free native_lineno here, or use alloca or something. */
2829   return true;
2830 }
2831
2832 static boolean
2833 coff_slurp_symbol_table (abfd)
2834      bfd * abfd;
2835 {
2836   combined_entry_type *native_symbols;
2837   coff_symbol_type *cached_area;
2838   unsigned int *table_ptr;
2839
2840   unsigned int number_of_symbols = 0;
2841
2842   if (obj_symbols (abfd))
2843     return true;
2844
2845   /* Read in the symbol table */
2846   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
2847     {
2848       return (false);
2849     }                           /* on error */
2850
2851   /* Allocate enough room for all the symbols in cached form */
2852   cached_area = ((coff_symbol_type *)
2853                  bfd_alloc (abfd,
2854                             (obj_raw_syment_count (abfd)
2855                              * sizeof (coff_symbol_type))));
2856
2857   if (cached_area == NULL)
2858     return false;
2859   table_ptr = ((unsigned int *)
2860                bfd_alloc (abfd,
2861                           (obj_raw_syment_count (abfd)
2862                            * sizeof (unsigned int))));
2863
2864   if (table_ptr == NULL)
2865     return false;
2866   else
2867     {
2868       coff_symbol_type *dst = cached_area;
2869       unsigned int last_native_index = obj_raw_syment_count (abfd);
2870       unsigned int this_index = 0;
2871       while (this_index < last_native_index)
2872         {
2873           combined_entry_type *src = native_symbols + this_index;
2874           table_ptr[this_index] = number_of_symbols;
2875           dst->symbol.the_bfd = abfd;
2876
2877           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
2878           /* We use the native name field to point to the cached field.  */
2879           src->u.syment._n._n_n._n_zeroes = (long) dst;
2880           dst->symbol.section = coff_section_from_bfd_index (abfd,
2881                                                      src->u.syment.n_scnum);
2882           dst->symbol.flags = 0;
2883           dst->done_lineno = false;
2884
2885           switch (src->u.syment.n_sclass)
2886             {
2887 #ifdef I960
2888             case C_LEAFEXT:
2889 #if 0
2890               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2891               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2892               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2893 #endif
2894               /* Fall through to next case */
2895
2896 #endif
2897
2898             case C_EXT:
2899 #ifdef RS6000COFF_C
2900             case C_HIDEXT:
2901 #endif
2902 #ifdef COFF_WITH_PE
2903             /* PE uses storage class 0x68 to denote a section symbol */
2904             case C_SECTION:
2905             /* PE uses storage class 0x67 for a weak external symbol.  */
2906             case C_NT_WEAK:
2907 #endif
2908               if ((src->u.syment.n_scnum) == 0)
2909                 {
2910                   if ((src->u.syment.n_value) == 0)
2911                     {
2912                       dst->symbol.section = bfd_und_section_ptr;
2913                       dst->symbol.value = 0;
2914                     }
2915                   else
2916                     {
2917                       dst->symbol.section = bfd_com_section_ptr;
2918                       dst->symbol.value = (src->u.syment.n_value);
2919                     }
2920                 }
2921               else
2922                 {
2923                   /* Base the value as an index from the base of the
2924                      section */
2925
2926                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2927                   dst->symbol.value = (src->u.syment.n_value
2928                                        - dst->symbol.section->vma);
2929
2930                   if (ISFCN ((src->u.syment.n_type)))
2931                     {
2932                       /* A function ext does not go at the end of a
2933                          file.  */
2934                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2935                     }
2936                 }
2937
2938 #ifdef RS6000COFF_C
2939               /* A C_HIDEXT symbol is not global.  */
2940               if (src->u.syment.n_sclass == C_HIDEXT)
2941                 dst->symbol.flags = BSF_LOCAL;
2942               /* A symbol with a csect entry should not go at the end.  */
2943               if (src->u.syment.n_numaux > 0)
2944                 dst->symbol.flags |= BSF_NOT_AT_END;
2945 #endif
2946
2947 #ifdef COFF_WITH_PE
2948               if (src->u.syment.n_sclass == C_NT_WEAK)
2949                 dst->symbol.flags = BSF_WEAK;
2950 #endif
2951
2952               break;
2953
2954             case C_STAT:        /* static                        */
2955 #ifdef I960
2956             case C_LEAFSTAT:    /* static leaf procedure        */
2957 #endif
2958             case C_LABEL:       /* label                         */
2959               if (src->u.syment.n_scnum == -2)
2960                 dst->symbol.flags = BSF_DEBUGGING;
2961               else
2962                 dst->symbol.flags = BSF_LOCAL;
2963               /*
2964           Base the value as an index from the base of the section, if
2965           there is one
2966           */
2967               if (dst->symbol.section)
2968                 dst->symbol.value = (src->u.syment.n_value) -
2969                   dst->symbol.section->vma;
2970               else
2971                 dst->symbol.value = (src->u.syment.n_value);
2972               break;
2973
2974             case C_MOS: /* member of structure   */
2975             case C_EOS: /* end of structure              */
2976 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
2977 #ifdef C_GLBLREG
2978             case C_GLBLREG:     /* A29k-specific storage class */
2979 #endif
2980 #endif
2981             case C_REGPARM:     /* register parameter            */
2982             case C_REG: /* register variable             */
2983 #ifdef C_AUTOARG
2984             case C_AUTOARG:     /* 960-specific storage class */
2985 #endif
2986             case C_TPDEF:       /* type definition               */
2987             case C_ARG:
2988             case C_AUTO:        /* automatic variable */
2989             case C_FIELD:       /* bit field */
2990             case C_ENTAG:       /* enumeration tag               */
2991             case C_MOE: /* member of enumeration         */
2992             case C_MOU: /* member of union               */
2993             case C_UNTAG:       /* union tag                     */
2994               dst->symbol.flags = BSF_DEBUGGING;
2995               dst->symbol.value = (src->u.syment.n_value);
2996               break;
2997
2998             case C_FILE:        /* file name                     */
2999             case C_STRTAG:      /* structure tag                 */
3000 #ifdef RS6000COFF_C
3001             case C_GSYM:
3002             case C_LSYM:
3003             case C_PSYM:
3004             case C_RSYM:
3005             case C_RPSYM:
3006             case C_STSYM:
3007             case C_BCOMM:
3008             case C_ECOMM:
3009             case C_DECL:
3010             case C_ENTRY:
3011             case C_FUN:
3012             case C_ESTAT:
3013 #endif
3014               dst->symbol.flags = BSF_DEBUGGING;
3015               dst->symbol.value = (src->u.syment.n_value);
3016               break;
3017
3018 #ifdef RS6000COFF_C
3019             case C_BINCL:       /* beginning of include file     */
3020             case C_EINCL:       /* ending of include file        */
3021               /* The value is actually a pointer into the line numbers
3022                  of the file.  We locate the line number entry, and
3023                  set the section to the section which contains it, and
3024                  the value to the index in that section.  */
3025               {
3026                 asection *sec;
3027
3028                 dst->symbol.flags = BSF_DEBUGGING;
3029                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3030                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
3031                       && ((file_ptr) (sec->line_filepos
3032                                       + sec->lineno_count * LINESZ)
3033                           > (file_ptr) src->u.syment.n_value))
3034                     break;
3035                 if (sec == NULL)
3036                   dst->symbol.value = 0;
3037                 else
3038                   {
3039                     dst->symbol.section = sec;
3040                     dst->symbol.value = ((src->u.syment.n_value
3041                                           - sec->line_filepos)
3042                                          / LINESZ);
3043                     src->fix_line = 1;
3044                   }
3045               }
3046               break;
3047
3048             case C_BSTAT:
3049               dst->symbol.flags = BSF_DEBUGGING;
3050
3051               /* The value is actually a symbol index.  Save a pointer
3052                  to the symbol instead of the index.  FIXME: This
3053                  should use a union.  */
3054               src->u.syment.n_value =
3055                 (long) (native_symbols + src->u.syment.n_value);
3056               dst->symbol.value = src->u.syment.n_value;
3057               src->fix_value = 1;
3058               break;
3059 #endif
3060
3061             case C_BLOCK:       /* ".bb" or ".eb"                */
3062             case C_FCN: /* ".bf" or ".ef"                */
3063             case C_EFCN:        /* physical end of function      */
3064               dst->symbol.flags = BSF_LOCAL;
3065               /*
3066           Base the value as an index from the base of the section
3067           */
3068               dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
3069               break;
3070
3071             case C_NULL:
3072             case C_EXTDEF:      /* external definition           */
3073             case C_ULABEL:      /* undefined label               */
3074             case C_USTATIC:     /* undefined static              */
3075 #ifndef COFF_WITH_PE
3076             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
3077                class to represent a section symbol */
3078             case C_LINE:        /* line # reformatted as symbol table entry */
3079               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
3080             case C_ALIAS:       /* duplicate tag                 */
3081 #endif
3082             case C_HIDDEN:      /* ext symbol in dmert public lib */
3083             default:
3084               (*_bfd_error_handler)
3085                 ("%s: Unrecognized storage class %d for %s symbol `%s'",
3086                  bfd_get_filename (abfd), src->u.syment.n_sclass,
3087                  dst->symbol.section->name, dst->symbol.name);
3088               dst->symbol.flags = BSF_DEBUGGING;
3089               dst->symbol.value = (src->u.syment.n_value);
3090               break;
3091             }
3092
3093 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
3094
3095           dst->native = src;
3096
3097           dst->symbol.udata.i = 0;
3098           dst->lineno = (alent *) NULL;
3099           this_index += (src->u.syment.n_numaux) + 1;
3100           dst++;
3101           number_of_symbols++;
3102         }                       /* walk the native symtab */
3103     }                           /* bfdize the native symtab */
3104
3105   obj_symbols (abfd) = cached_area;
3106   obj_raw_syments (abfd) = native_symbols;
3107
3108   bfd_get_symcount (abfd) = number_of_symbols;
3109   obj_convert (abfd) = table_ptr;
3110   /* Slurp the line tables for each section too */
3111   {
3112     asection *p;
3113     p = abfd->sections;
3114     while (p)
3115       {
3116         coff_slurp_line_table (abfd, p);
3117         p = p->next;
3118       }
3119   }
3120   return true;
3121 }                               /* coff_slurp_symbol_table() */
3122
3123 /* Check whether a symbol is globally visible.  This is used by the
3124    COFF backend linker code in cofflink.c, since a couple of targets
3125    have globally visible symbols which are not class C_EXT.  This
3126    function need not handle the case of n_class == C_EXT.  */
3127
3128 #undef OTHER_GLOBAL_CLASS
3129
3130 #ifdef I960
3131 #define OTHER_GLOBAL_CLASS C_LEAFEXT
3132 #endif
3133
3134 #ifdef COFF_WITH_PE
3135 #define OTHER_GLOBAL_CLASS C_SECTION
3136 #endif
3137
3138 #ifdef OTHER_GLOBAL_CLASS
3139
3140 static boolean
3141 coff_sym_is_global (abfd, syment)
3142      bfd *abfd;
3143      struct internal_syment *syment;
3144 {
3145   if (syment->n_sclass == OTHER_GLOBAL_CLASS)
3146     return true;
3147   return false;
3148 }
3149
3150 #undef OTHER_GLOBAL_CLASS
3151
3152 #else /* ! defined (OTHER_GLOBAL_CLASS) */
3153
3154 /* sym_is_global should not be defined if it has nothing to do.  */
3155
3156 #define coff_sym_is_global 0
3157
3158 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
3159
3160 /*
3161 SUBSUBSECTION
3162         Reading relocations
3163
3164         Coff relocations are easily transformed into the internal BFD form
3165         (@code{arelent}).
3166
3167         Reading a coff relocation table is done in the following stages:
3168
3169         o Read the entire coff relocation table into memory.
3170
3171         o Process each relocation in turn; first swap it from the
3172         external to the internal form.
3173
3174         o Turn the symbol referenced in the relocation's symbol index
3175         into a pointer into the canonical symbol table.
3176         This table is the same as the one returned by a call to
3177         @code{bfd_canonicalize_symtab}. The back end will call that
3178         routine and save the result if a canonicalization hasn't been done.
3179
3180         o The reloc index is turned into a pointer to a howto
3181         structure, in a back end specific way. For instance, the 386
3182         and 960 use the @code{r_type} to directly produce an index
3183         into a howto table vector; the 88k subtracts a number from the
3184         @code{r_type} field and creates an addend field.
3185
3186
3187 */
3188
3189 #ifndef CALC_ADDEND
3190 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
3191   {                                                             \
3192     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
3193     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
3194       coffsym = (obj_symbols (abfd)                             \
3195                  + (cache_ptr->sym_ptr_ptr - symbols));         \
3196     else if (ptr)                                               \
3197       coffsym = coff_symbol_from (abfd, ptr);                   \
3198     if (coffsym != (coff_symbol_type *) NULL                    \
3199         && coffsym->native->u.syment.n_scnum == 0)              \
3200       cache_ptr->addend = 0;                                    \
3201     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
3202              && ptr->section != (asection *) NULL)              \
3203       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
3204     else                                                        \
3205       cache_ptr->addend = 0;                                    \
3206   }
3207 #endif
3208
3209 static boolean
3210 coff_slurp_reloc_table (abfd, asect, symbols)
3211      bfd * abfd;
3212      sec_ptr asect;
3213      asymbol ** symbols;
3214 {
3215   RELOC *native_relocs;
3216   arelent *reloc_cache;
3217   arelent *cache_ptr;
3218
3219   unsigned int idx;
3220
3221   if (asect->relocation)
3222     return true;
3223   if (asect->reloc_count == 0)
3224     return true;
3225   if (asect->flags & SEC_CONSTRUCTOR)
3226     return true;
3227   if (!coff_slurp_symbol_table (abfd))
3228     return false;
3229   native_relocs =
3230     (RELOC *) buy_and_read (abfd,
3231                             asect->rel_filepos,
3232                             SEEK_SET,
3233                             (size_t) (RELSZ *
3234                                       asect->reloc_count));
3235   reloc_cache = (arelent *)
3236     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
3237
3238   if (reloc_cache == NULL)
3239     return false;
3240
3241
3242   for (idx = 0; idx < asect->reloc_count; idx++)
3243     {
3244 #ifdef RELOC_PROCESSING
3245       struct internal_reloc dst;
3246       struct external_reloc *src;
3247
3248       cache_ptr = reloc_cache + idx;
3249       src = native_relocs + idx;
3250       coff_swap_reloc_in (abfd, src, &dst);
3251
3252       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
3253 #else
3254       struct internal_reloc dst;
3255       asymbol *ptr;
3256       struct external_reloc *src;
3257
3258       cache_ptr = reloc_cache + idx;
3259       src = native_relocs + idx;
3260
3261       coff_swap_reloc_in (abfd, src, &dst);
3262
3263
3264       cache_ptr->address = dst.r_vaddr;
3265
3266       if (dst.r_symndx != -1)
3267         {
3268           /* @@ Should never be greater than count of symbols!  */
3269           if (dst.r_symndx >= obj_conv_table_size (abfd))
3270             abort ();
3271           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
3272           ptr = *(cache_ptr->sym_ptr_ptr);
3273         }
3274       else
3275         {
3276           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3277           ptr = 0;
3278         }
3279
3280       /* The symbols definitions that we have read in have been
3281          relocated as if their sections started at 0. But the offsets
3282          refering to the symbols in the raw data have not been
3283          modified, so we have to have a negative addend to compensate.
3284
3285          Note that symbols which used to be common must be left alone */
3286
3287       /* Calculate any reloc addend by looking at the symbol */
3288       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
3289
3290       cache_ptr->address -= asect->vma;
3291 /* !!     cache_ptr->section = (asection *) NULL;*/
3292
3293       /* Fill in the cache_ptr->howto field from dst.r_type */
3294       RTYPE2HOWTO (cache_ptr, &dst);
3295 #endif
3296
3297     }
3298
3299   asect->relocation = reloc_cache;
3300   return true;
3301 }
3302
3303 #ifndef coff_rtype_to_howto
3304 #ifdef RTYPE2HOWTO
3305
3306 /* Get the howto structure for a reloc.  This is only used if the file
3307    including this one defines coff_relocate_section to be
3308    _bfd_coff_generic_relocate_section, so it is OK if it does not
3309    always work.  It is the responsibility of the including file to
3310    make sure it is reasonable if it is needed.  */
3311
3312 static reloc_howto_type *coff_rtype_to_howto
3313   PARAMS ((bfd *, asection *, struct internal_reloc *,
3314            struct coff_link_hash_entry *, struct internal_syment *,
3315            bfd_vma *));
3316
3317 /*ARGSUSED*/
3318 static reloc_howto_type *
3319 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
3320      bfd *abfd;
3321      asection *sec;
3322      struct internal_reloc *rel;
3323      struct coff_link_hash_entry *h;
3324      struct internal_syment *sym;
3325      bfd_vma *addendp;
3326 {
3327   arelent genrel;
3328
3329   RTYPE2HOWTO (&genrel, rel);
3330   return genrel.howto;
3331 }
3332
3333 #else /* ! defined (RTYPE2HOWTO) */
3334
3335 #define coff_rtype_to_howto NULL
3336
3337 #endif /* ! defined (RTYPE2HOWTO) */
3338 #endif /* ! defined (coff_rtype_to_howto) */
3339
3340 /* This is stupid.  This function should be a boolean predicate.  */
3341 static long
3342 coff_canonicalize_reloc (abfd, section, relptr, symbols)
3343      bfd * abfd;
3344      sec_ptr section;
3345      arelent ** relptr;
3346      asymbol ** symbols;
3347 {
3348   arelent *tblptr = section->relocation;
3349   unsigned int count = 0;
3350
3351
3352   if (section->flags & SEC_CONSTRUCTOR)
3353     {
3354       /* this section has relocs made up by us, they are not in the
3355        file, so take them out of their chain and place them into
3356        the data area provided */
3357       arelent_chain *chain = section->constructor_chain;
3358       for (count = 0; count < section->reloc_count; count++)
3359         {
3360           *relptr++ = &chain->relent;
3361           chain = chain->next;
3362         }
3363
3364     }
3365   else
3366     {
3367       if (! coff_slurp_reloc_table (abfd, section, symbols))
3368         return -1;
3369
3370       tblptr = section->relocation;
3371
3372       for (; count++ < section->reloc_count;)
3373         *relptr++ = tblptr++;
3374
3375
3376     }
3377   *relptr = 0;
3378   return section->reloc_count;
3379 }
3380
3381 #ifdef GNU960
3382 file_ptr
3383 coff_sym_filepos (abfd)
3384      bfd *abfd;
3385 {
3386   return obj_sym_filepos (abfd);
3387 }
3388 #endif
3389
3390 #ifndef coff_reloc16_estimate
3391 #define coff_reloc16_estimate dummy_reloc16_estimate
3392
3393 static int
3394 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
3395      bfd *abfd;
3396      asection *input_section;
3397      arelent *reloc;
3398      unsigned int shrink;
3399      struct bfd_link_info *link_info;
3400 {
3401   abort ();
3402 }
3403
3404 #endif
3405
3406 #ifndef coff_reloc16_extra_cases
3407 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
3408 /* This works even if abort is not declared in any header file.  */
3409 static void
3410 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
3411                            dst_ptr)
3412      bfd *abfd;
3413      struct bfd_link_info *link_info;
3414      struct bfd_link_order *link_order;
3415      arelent *reloc;
3416      bfd_byte *data;
3417      unsigned int *src_ptr;
3418      unsigned int *dst_ptr;
3419 {
3420   abort ();
3421 }
3422 #endif
3423
3424 /* If coff_relocate_section is defined, we can use the optimized COFF
3425    backend linker.  Otherwise we must continue to use the old linker.  */
3426 #ifdef coff_relocate_section
3427 #ifndef coff_bfd_link_hash_table_create
3428 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
3429 #endif
3430 #ifndef coff_bfd_link_add_symbols
3431 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
3432 #endif
3433 #ifndef coff_bfd_final_link
3434 #define coff_bfd_final_link _bfd_coff_final_link
3435 #endif
3436 #else /* ! defined (coff_relocate_section) */
3437 #define coff_relocate_section NULL
3438 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3439 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
3440 #define coff_bfd_final_link _bfd_generic_final_link
3441 #endif /* ! defined (coff_relocate_section) */
3442 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
3443
3444 #ifndef coff_start_final_link
3445 #define coff_start_final_link NULL
3446 #endif
3447
3448 #ifndef coff_adjust_symndx
3449 #define coff_adjust_symndx NULL
3450 #endif
3451
3452 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
3453 {
3454   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
3455   coff_swap_aux_out, coff_swap_sym_out,
3456   coff_swap_lineno_out, coff_swap_reloc_out,
3457   coff_swap_filehdr_out, coff_swap_aouthdr_out,
3458   coff_swap_scnhdr_out,
3459   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
3460 #ifdef COFF_LONG_FILENAMES
3461   true,
3462 #else
3463   false,
3464 #endif
3465   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
3466   coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
3467   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
3468   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
3469   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
3470   coff_sym_is_global, coff_compute_section_file_positions,
3471   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
3472   coff_adjust_symndx
3473 };
3474
3475 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
3476 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3477 #define coff_get_section_contents _bfd_generic_get_section_contents
3478
3479 #ifndef coff_bfd_copy_private_symbol_data
3480 #define coff_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data
3481 #endif
3482
3483 #ifndef coff_bfd_copy_private_section_data
3484 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
3485 #endif
3486
3487 #ifndef coff_bfd_copy_private_bfd_data
3488 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
3489 #endif
3490
3491 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3492 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3493
3494 #ifndef coff_bfd_print_private_bfd_data
3495 #define coff_bfd_print_private_bfd_data  _bfd_generic_bfd_print_private_bfd_data
3496 #endif
3497
3498 #ifndef coff_bfd_is_local_label
3499 #define coff_bfd_is_local_label bfd_generic_is_local_label
3500 #endif
3501 #ifndef coff_read_minisymbols
3502 #define coff_read_minisymbols _bfd_generic_read_minisymbols
3503 #endif
3504 #ifndef coff_minisymbol_to_symbol
3505 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3506 #endif
3507
3508 /* The reloc lookup routine must be supplied by each individual COFF
3509    backend.  */
3510 #ifndef coff_bfd_reloc_type_lookup
3511 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3512 #endif
3513
3514 #ifndef coff_bfd_get_relocated_section_contents
3515 #define coff_bfd_get_relocated_section_contents \
3516   bfd_generic_get_relocated_section_contents
3517 #endif
3518 #ifndef coff_bfd_relax_section
3519 #define coff_bfd_relax_section bfd_generic_relax_section
3520 #endif