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