bfd/coffcode.h

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