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