bfd/coffcode.h

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