bfd/coffcode.h

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