bfd/coffcode.h

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