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