bfd/coffcode.h

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