bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5    Written by Cygnus Support.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23 /* Most of this hacked by  Steve Chamberlain,
  24                         sac@cygnus.com.  */
  25 /*
  26 SECTION
  27         coff backends
  28
  29         BFD supports a number of different flavours of coff format.
  30         The major differences between formats are the sizes and
  31         alignments of fields in structures on disk, and the occasional
  32         extra field.
  33
  34         Coff in all its varieties is implemented with a few common
  35         files and a number of implementation specific files. For
  36         example, The 88k bcs coff format is implemented in the file
  37         @file{coff-m88k.c}. This file @code{#include}s
  38         @file{coff/m88k.h} which defines the external structure of the
  39         coff format for the 88k, and @file{coff/internal.h} which
  40         defines the internal structure. @file{coff-m88k.c} also
  41         defines the relocations used by the 88k format
  42         @xref{Relocations}.
  43
  44         The Intel i960 processor version of coff is implemented in
  45         @file{coff-i960.c}. This file has the same structure as
  46         @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
  47         rather than @file{coff-m88k.h}.
  48
  49 SUBSECTION
  50         Porting to a new version of coff
  51
  52         The recommended method is to select from the existing
  53         implementations the version of coff which is most like the one
  54         you want to use.  For example, we'll say that i386 coff is
  55         the one you select, and that your coff flavour is called foo.
  56         Copy @file{i386coff.c} to @file{foocoff.c}, copy
  57         @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
  58         and add the lines to @file{targets.c} and @file{Makefile.in}
  59         so that your new back end is used. Alter the shapes of the
  60         structures in @file{../include/coff/foo.h} so that they match
  61         what you need. You will probably also have to add
  62         @code{#ifdef}s to the code in @file{coff/internal.h} and
  63         @file{coffcode.h} if your version of coff is too wild.
  64
  65         You can verify that your new BFD backend works quite simply by
  66         building @file{objdump} from the @file{binutils} directory,
  67         and making sure that its version of what's going on and your
  68         host system's idea (assuming it has the pretty standard coff
  69         dump utility, usually called @code{att-dump} or just
  70         @code{dump}) are the same.  Then clean up your code, and send
  71         what you've done to Cygnus. Then your stuff will be in the
  72         next release, and you won't have to keep integrating it.
  73
  74 SUBSECTION
  75         How the coff backend works
  76
  77 SUBSUBSECTION
  78         File layout
  79
  80         The Coff backend is split into generic routines that are
  81         applicable to any Coff target and routines that are specific
  82         to a particular target.  The target-specific routines are
  83         further split into ones which are basically the same for all
  84         Coff targets except that they use the external symbol format
  85         or use different values for certain constants.
  86
  87         The generic routines are in @file{coffgen.c}.  These routines
  88         work for any Coff target.  They use some hooks into the target
  89         specific code; the hooks are in a @code{bfd_coff_backend_data}
  90         structure, one of which exists for each target.
  91
  92         The essentially similar target-specific routines are in
  93         @file{coffcode.h}.  This header file includes executable C code.
  94         The various Coff targets first include the appropriate Coff
  95         header file, make any special defines that are needed, and
  96         then include @file{coffcode.h}.
  97
  98         Some of the Coff targets then also have additional routines in
  99         the target source file itself.
 100
 101         For example, @file{coff-i960.c} includes
 102         @file{coff/internal.h} and @file{coff/i960.h}.  It then
 103         defines a few constants, such as @code{I960}, and includes
 104         @file{coffcode.h}.  Since the i960 has complex relocation
 105         types, @file{coff-i960.c} also includes some code to
 106         manipulate the i960 relocs.  This code is not in
 107         @file{coffcode.h} because it would not be used by any other
 108         target.
 109
 110 SUBSUBSECTION
 111         Bit twiddling
 112
 113         Each flavour of coff supported in BFD has its own header file
 114         describing the external layout of the structures. There is also
 115         an internal description of the coff layout, in
 116         @file{coff/internal.h}. A major function of the
 117         coff backend is swapping the bytes and twiddling the bits to
 118         translate the external form of the structures into the normal
 119         internal form. This is all performed in the
 120         @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
 121         elements are different sizes between different versions of
 122         coff; it is the duty of the coff version specific include file
 123         to override the definitions of various packing routines in
 124         @file{coffcode.h}. E.g., the size of line number entry in coff is
 125         sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
 126         @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
 127         correct one. No doubt, some day someone will find a version of
 128         coff which has a varying field size not catered to at the
 129         moment. To port BFD, that person will have to add more @code{#defines}.
 130         Three of the bit twiddling routines are exported to
 131         @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
 132         and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
 133         table on its own, but uses BFD to fix things up.  More of the
 134         bit twiddlers are exported for @code{gas};
 135         @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
 136         @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
 137         @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
 138         @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
 139         of all the symbol table and reloc drudgery itself, thereby
 140         saving the internal BFD overhead, but uses BFD to swap things
 141         on the way out, making cross ports much safer.  Doing so also
 142         allows BFD (and thus the linker) to use the same header files
 143         as @code{gas}, which makes one avenue to disaster disappear.
 144
 145 SUBSUBSECTION
 146         Symbol reading
 147
 148         The simple canonical form for symbols used by BFD is not rich
 149         enough to keep all the information available in a coff symbol
 150         table. The back end gets around this problem by keeping the original
 151         symbol table around, "behind the scenes".
 152
 153         When a symbol table is requested (through a call to
 154         @code{bfd_canonicalize_symtab}), a request gets through to
 155         @code{coff_get_normalized_symtab}. This reads the symbol table from
 156         the coff file and swaps all the structures inside into the
 157         internal form. It also fixes up all the pointers in the table
 158         (represented in the file by offsets from the first symbol in
 159         the table) into physical pointers to elements in the new
 160         internal table. This involves some work since the meanings of
 161         fields change depending upon context: a field that is a
 162         pointer to another structure in the symbol table at one moment
 163         may be the size in bytes of a structure at the next.  Another
 164         pass is made over the table. All symbols which mark file names
 165         (<<C_FILE>> symbols) are modified so that the internal
 166         string points to the value in the auxent (the real filename)
 167         rather than the normal text associated with the symbol
 168         (@code{".file"}).
 169
 170         At this time the symbol names are moved around. Coff stores
 171         all symbols less than nine characters long physically
 172         within the symbol table; longer strings are kept at the end of
 173         the file in the string  table. This pass moves all strings
 174         into memory and replaces them with pointers to the strings.
 175
 176         The symbol table is massaged once again, this time to create
 177         the canonical table used by the BFD application. Each symbol
 178         is inspected in turn, and a decision made (using the
 179         @code{sclass} field) about the various flags to set in the
 180         @code{asymbol}.  @xref{Symbols}. The generated canonical table
 181         shares strings with the hidden internal symbol table.
 182
 183         Any linenumbers are read from the coff file too, and attached
 184         to the symbols which own the functions the linenumbers belong to.
 185
 186 SUBSUBSECTION
 187         Symbol writing
 188
 189         Writing a symbol to a coff file which didn't come from a coff
 190         file will lose any debugging information. The @code{asymbol}
 191         structure remembers the BFD from which the symbol was taken, and on
 192         output the back end makes sure that the same destination target as
 193         source target is present.
 194
 195         When the symbols have come from a coff file then all the
 196         debugging information is preserved.
 197
 198         Symbol tables are provided for writing to the back end in a
 199         vector of pointers to pointers. This allows applications like
 200         the linker to accumulate and output large symbol tables
 201         without having to do too much byte copying.
 202
 203         This function runs through the provided symbol table and
 204         patches each symbol marked as a file place holder
 205         (@code{C_FILE}) to point to the next file place holder in the
 206         list. It also marks each @code{offset} field in the list with
 207         the offset from the first symbol of the current symbol.
 208
 209         Another function of this procedure is to turn the canonical
 210         value form of BFD into the form used by coff. Internally, BFD
 211         expects symbol values to be offsets from a section base; so a
 212         symbol physically at 0x120, but in a section starting at
 213         0x100, would have the value 0x20. Coff expects symbols to
 214         contain their final value, so symbols have their values
 215         changed at this point to reflect their sum with their owning
 216         section.  This transformation uses the
 217         <<output_section>> field of the @code{asymbol}'s
 218         @code{asection} @xref{Sections}.
 219
 220         o <<coff_mangle_symbols>>
 221
 222         This routine runs though the provided symbol table and uses
 223         the offsets generated by the previous pass and the pointers
 224         generated when the symbol table was read in to create the
 225         structured hierarchy required by coff. It changes each pointer
 226         to a symbol into the index into the symbol table of the asymbol.
 227
 228         o <<coff_write_symbols>>
 229
 230         This routine runs through the symbol table and patches up the
 231         symbols from their internal form into the coff way, calls the
 232         bit twiddlers, and writes out the table to the file.
 233
 234 */
 235
 236 /*
 237 INTERNAL_DEFINITION
 238         coff_symbol_type
 239
 240 DESCRIPTION
 241         The hidden information for an <<asymbol>> is described in a
 242         <<combined_entry_type>>:
 243
 244 CODE_FRAGMENT
 245 .
 246 .typedef struct coff_ptr_struct
 247 .{
 248 .  {* Remembers the offset from the first symbol in the file for
 249 .     this symbol. Generated by coff_renumber_symbols. *}
 250 .  unsigned int offset;
 251 .
 252 .  {* Should the value of this symbol be renumbered.  Used for
 253 .     XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
 254 .  unsigned int fix_value : 1;
 255 .
 256 .  {* Should the tag field of this symbol be renumbered.
 257 .     Created by coff_pointerize_aux. *}
 258 .  unsigned int fix_tag : 1;
 259 .
 260 .  {* Should the endidx field of this symbol be renumbered.
 261 .     Created by coff_pointerize_aux. *}
 262 .  unsigned int fix_end : 1;
 263 .
 264 .  {* Should the x_csect.x_scnlen field be renumbered.
 265 .     Created by coff_pointerize_aux. *}
 266 .  unsigned int fix_scnlen : 1;
 267 .
 268 .  {* Fix up an XCOFF C_BINCL/C_EINCL symbol.  The value is the
 269 .     index into the line number entries.  Set by coff_slurp_symbol_table.  *}
 270 .  unsigned int fix_line : 1;
 271 .
 272 .  {* The container for the symbol structure as read and translated
 273 .     from the file. *}
 274 .  union
 275 .  {
 276 .    union internal_auxent auxent;
 277 .    struct internal_syment syment;
 278 .  } u;
 279 .} combined_entry_type;
 280 .
 281 .
 282 .{* Each canonical asymbol really looks like this: *}
 283 .
 284 .typedef struct coff_symbol_struct
 285 .{
 286 .  {* The actual symbol which the rest of BFD works with *}
 287 .  asymbol symbol;
 288 .
 289 .  {* A pointer to the hidden information for this symbol *}
 290 .  combined_entry_type *native;
 291 .
 292 .  {* A pointer to the linenumber information for this symbol *}
 293 .  struct lineno_cache_entry *lineno;
 294 .
 295 .  {* Have the line numbers been relocated yet ? *}
 296 .  bfd_boolean done_lineno;
 297 .} coff_symbol_type;
 298
 299 */
 300
 301 #ifdef COFF_WITH_PE
 302 #include "peicode.h"
 303 #else
 304 #include "coffswap.h"
 305 #endif
 306
 307 #define STRING_SIZE_SIZE 4
 308
 309 #define DOT_DEBUG       ".debug"
 310 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
 311
 312 static long sec_to_styp_flags
 313   (const char *, flagword);
 314 static bfd_boolean styp_to_sec_flags
 315   (bfd *, void *, const char *, asection *, flagword *);
 316 static bfd_boolean coff_bad_format_hook
 317   (bfd *, void *);
 318 static void coff_set_custom_section_alignment
 319   (bfd *, asection *, const struct coff_section_alignment_entry *,
 320    const unsigned int);
 321 static bfd_boolean coff_new_section_hook
 322   (bfd *, asection *);
 323 static bfd_boolean coff_set_arch_mach_hook
 324   (bfd *, void *);
 325 static bfd_boolean coff_write_relocs
 326   (bfd *, int);
 327 static bfd_boolean coff_set_flags
 328   (bfd *, unsigned int *, unsigned short *);
 329 static bfd_boolean coff_set_arch_mach
 330   (bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED;
 331 static bfd_boolean coff_compute_section_file_positions
 332   (bfd *);
 333 static bfd_boolean coff_write_object_contents
 334   (bfd *) ATTRIBUTE_UNUSED;
 335 static bfd_boolean coff_set_section_contents
 336   (bfd *, asection *, const void *, file_ptr, bfd_size_type);
 337 static void * buy_and_read
 338   (bfd *, file_ptr, bfd_size_type);
 339 static bfd_boolean coff_slurp_line_table
 340   (bfd *, asection *);
 341 static bfd_boolean coff_slurp_symbol_table
 342   (bfd *);
 343 static enum coff_symbol_classification coff_classify_symbol
 344   (bfd *, struct internal_syment *);
 345 static bfd_boolean coff_slurp_reloc_table
 346   (bfd *, asection *, asymbol **);
 347 static long coff_canonicalize_reloc
 348   (bfd *, asection *, arelent **, asymbol **);
 349 #ifndef coff_mkobject_hook
 350 static void * coff_mkobject_hook
 351   (bfd *, void *,  void *);
 352 #endif
 353 #ifdef COFF_WITH_PE
 354 static flagword handle_COMDAT
 355   (bfd *, flagword, void *, const char *, asection *);
 356 #endif
 357 #ifdef COFF_IMAGE_WITH_PE
 358 static bfd_boolean coff_read_word
 359   (bfd *, unsigned int *);
 360 static unsigned int coff_compute_checksum
 361   (bfd *);
 362 static bfd_boolean coff_apply_checksum
 363   (bfd *);
 364 #endif
 365 #ifdef TICOFF
 366 static bfd_boolean ticoff0_bad_format_hook
 367   (bfd *, void * );
 368 static bfd_boolean ticoff1_bad_format_hook
 369   (bfd *, void * );
 370 #endif
 371 \f
 372 /* void warning(); */
 373
 374 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
 375    the incoming SEC_* flags.  The inverse of this function is
 376    styp_to_sec_flags().  NOTE: If you add to/change this routine, you
 377    should probably mirror the changes in styp_to_sec_flags().  */
 378
 379 #ifndef COFF_WITH_PE
 380
 381 /* Macros for setting debugging flags.  */
 382
 383 #ifdef STYP_DEBUG
 384 #define STYP_XCOFF_DEBUG STYP_DEBUG
 385 #else
 386 #define STYP_XCOFF_DEBUG STYP_INFO
 387 #endif
 388
 389 #ifdef COFF_ALIGN_IN_S_FLAGS
 390 #define STYP_DEBUG_INFO STYP_DSECT
 391 #else
 392 #define STYP_DEBUG_INFO STYP_INFO
 393 #endif
 394
 395 static long
 396 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
 397 {
 398   long styp_flags = 0;
 399
 400   if (!strcmp (sec_name, _TEXT))
 401     {
 402       styp_flags = STYP_TEXT;
 403     }
 404   else if (!strcmp (sec_name, _DATA))
 405     {
 406       styp_flags = STYP_DATA;
 407     }
 408   else if (!strcmp (sec_name, _BSS))
 409     {
 410       styp_flags = STYP_BSS;
 411 #ifdef _COMMENT
 412     }
 413   else if (!strcmp (sec_name, _COMMENT))
 414     {
 415       styp_flags = STYP_INFO;
 416 #endif /* _COMMENT */
 417 #ifdef _LIB
 418     }
 419   else if (!strcmp (sec_name, _LIB))
 420     {
 421       styp_flags = STYP_LIB;
 422 #endif /* _LIB */
 423 #ifdef _LIT
 424     }
 425   else if (!strcmp (sec_name, _LIT))
 426     {
 427       styp_flags = STYP_LIT;
 428 #endif /* _LIT */
 429     }
 430   else if (!strncmp (sec_name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1))
 431     {
 432       /* Handle the XCOFF debug section and DWARF2 debug sections.  */
 433       if (!sec_name[6])
 434         styp_flags = STYP_XCOFF_DEBUG;
 435       else
 436         styp_flags = STYP_DEBUG_INFO;
 437     }
 438   else if (!strncmp (sec_name, ".stab", 5))
 439     {
 440       styp_flags = STYP_DEBUG_INFO;
 441     }
 442 #ifdef COFF_LONG_SECTION_NAMES
 443   else if (!strncmp (sec_name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1))
 444     {
 445       styp_flags = STYP_DEBUG_INFO;
 446     }
 447 #endif
 448 #ifdef RS6000COFF_C
 449   else if (!strcmp (sec_name, _PAD))
 450     {
 451       styp_flags = STYP_PAD;
 452     }
 453   else if (!strcmp (sec_name, _LOADER))
 454     {
 455       styp_flags = STYP_LOADER;
 456     }
 457   else if (!strcmp (sec_name, _EXCEPT))
 458     {
 459       styp_flags = STYP_EXCEPT;
 460     }
 461   else if (!strcmp (sec_name, _TYPCHK))
 462     {
 463       styp_flags = STYP_TYPCHK;
 464     }
 465 #endif
 466   /* Try and figure out what it should be */
 467   else if (sec_flags & SEC_CODE)
 468     {
 469       styp_flags = STYP_TEXT;
 470     }
 471   else if (sec_flags & SEC_DATA)
 472     {
 473       styp_flags = STYP_DATA;
 474     }
 475   else if (sec_flags & SEC_READONLY)
 476     {
 477 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 478       styp_flags = STYP_LIT;
 479 #else
 480       styp_flags = STYP_TEXT;
 481 #endif /* STYP_LIT */
 482     }
 483   else if (sec_flags & SEC_LOAD)
 484     {
 485       styp_flags = STYP_TEXT;
 486     }
 487   else if (sec_flags & SEC_ALLOC)
 488     {
 489       styp_flags = STYP_BSS;
 490     }
 491
 492 #ifdef STYP_CLINK
 493   if (sec_flags & SEC_TIC54X_CLINK)
 494     styp_flags |= STYP_CLINK;
 495 #endif
 496
 497 #ifdef STYP_BLOCK
 498   if (sec_flags & SEC_TIC54X_BLOCK)
 499     styp_flags |= STYP_BLOCK;
 500 #endif
 501
 502 #ifdef STYP_NOLOAD
 503   if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
 504     styp_flags |= STYP_NOLOAD;
 505 #endif
 506
 507   return styp_flags;
 508 }
 509
 510 #else /* COFF_WITH_PE */
 511
 512 /* The PE version; see above for the general comments.  The non-PE
 513    case seems to be more guessing, and breaks PE format; specifically,
 514    .rdata is readonly, but it sure ain't text.  Really, all this
 515    should be set up properly in gas (or whatever assembler is in use),
 516    and honor whatever objcopy/strip, etc. sent us as input.  */
 517
 518 static long
 519 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
 520 {
 521   long styp_flags = 0;
 522
 523   /* caution: there are at least three groups of symbols that have
 524      very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
 525      SEC_* are the BFD internal flags, used for generic BFD
 526      information.  STYP_* are the COFF section flags which appear in
 527      COFF files.  IMAGE_SCN_* are the PE section flags which appear in
 528      PE files.  The STYP_* flags and the IMAGE_SCN_* flags overlap,
 529      but there are more IMAGE_SCN_* flags.  */
 530
 531   /* FIXME: There is no gas syntax to specify the debug section flag.  */
 532   if (strncmp (sec_name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1) == 0
 533       || strncmp (sec_name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1) == 0)
 534     sec_flags = SEC_DEBUGGING;
 535
 536   /* skip LOAD */
 537   /* READONLY later */
 538   /* skip RELOC */
 539   if ((sec_flags & SEC_CODE) != 0)
 540     styp_flags |= IMAGE_SCN_CNT_CODE;
 541   if ((sec_flags & SEC_DATA) != 0)
 542     styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
 543   if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
 544     styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA;  /* ==STYP_BSS */
 545   /* skip ROM */
 546   /* skip constRUCTOR */
 547   /* skip CONTENTS */
 548   if ((sec_flags & SEC_IS_COMMON) != 0)
 549     styp_flags |= IMAGE_SCN_LNK_COMDAT;
 550   if ((sec_flags & SEC_DEBUGGING) != 0)
 551     styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
 552   if ((sec_flags & SEC_EXCLUDE) != 0)
 553     styp_flags |= IMAGE_SCN_LNK_REMOVE;
 554   if ((sec_flags & SEC_NEVER_LOAD) != 0)
 555     styp_flags |= IMAGE_SCN_LNK_REMOVE;
 556   /* skip IN_MEMORY */
 557   /* skip SORT */
 558   if (sec_flags & SEC_LINK_ONCE)
 559     styp_flags |= IMAGE_SCN_LNK_COMDAT;
 560   /* skip LINK_DUPLICATES */
 561   /* skip LINKER_CREATED */
 562
 563   if (sec_flags & (SEC_ALLOC | SEC_LOAD))
 564     {
 565       /* For now, the read/write bits are mapped onto SEC_READONLY, even
 566          though the semantics don't quite match.  The bits from the input
 567          are retained in pei_section_data(abfd, section)->pe_flags.  */
 568       styp_flags |= IMAGE_SCN_MEM_READ;       /* Always readable.  */
 569       if ((sec_flags & SEC_READONLY) == 0)
 570         styp_flags |= IMAGE_SCN_MEM_WRITE;    /* Invert READONLY for write.  */
 571       if (sec_flags & SEC_CODE)
 572         styp_flags |= IMAGE_SCN_MEM_EXECUTE;  /* CODE->EXECUTE.  */
 573       if (sec_flags & SEC_COFF_SHARED)
 574         styp_flags |= IMAGE_SCN_MEM_SHARED;   /* Shared remains meaningful.  */
 575     }
 576
 577   return styp_flags;
 578 }
 579
 580 #endif /* COFF_WITH_PE */
 581
 582 /* Return a word with SEC_* flags set to represent the incoming STYP_*
 583    flags (from scnhdr.s_flags).  The inverse of this function is
 584    sec_to_styp_flags().  NOTE: If you add to/change this routine, you
 585    should probably mirror the changes in sec_to_styp_flags().  */
 586
 587 #ifndef COFF_WITH_PE
 588
 589 static bfd_boolean
 590 styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
 591                    void * hdr,
 592                    const char *name,
 593                    asection *section ATTRIBUTE_UNUSED,
 594                    flagword *flags_ptr)
 595 {
 596   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 597   long styp_flags = internal_s->s_flags;
 598   flagword sec_flags = 0;
 599
 600 #ifdef STYP_BLOCK
 601   if (styp_flags & STYP_BLOCK)
 602     sec_flags |= SEC_TIC54X_BLOCK;
 603 #endif
 604
 605 #ifdef STYP_CLINK
 606   if (styp_flags & STYP_CLINK)
 607     sec_flags |= SEC_TIC54X_CLINK;
 608 #endif
 609
 610 #ifdef STYP_NOLOAD
 611   if (styp_flags & STYP_NOLOAD)
 612     sec_flags |= SEC_NEVER_LOAD;
 613 #endif /* STYP_NOLOAD */
 614
 615   /* For 386 COFF, at least, an unloadable text or data section is
 616      actually a shared library section.  */
 617   if (styp_flags & STYP_TEXT)
 618     {
 619       if (sec_flags & SEC_NEVER_LOAD)
 620         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 621       else
 622         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 623     }
 624   else if (styp_flags & STYP_DATA)
 625     {
 626       if (sec_flags & SEC_NEVER_LOAD)
 627         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 628       else
 629         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 630     }
 631   else if (styp_flags & STYP_BSS)
 632     {
 633 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 634       if (sec_flags & SEC_NEVER_LOAD)
 635         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 636       else
 637 #endif
 638         sec_flags |= SEC_ALLOC;
 639     }
 640   else if (styp_flags & STYP_INFO)
 641     {
 642       /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
 643          defined.  coff_compute_section_file_positions uses
 644          COFF_PAGE_SIZE to ensure that the low order bits of the
 645          section VMA and the file offset match.  If we don't know
 646          COFF_PAGE_SIZE, we can't ensure the correct correspondence,
 647          and demand page loading of the file will fail.  */
 648 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
 649       sec_flags |= SEC_DEBUGGING;
 650 #endif
 651     }
 652   else if (styp_flags & STYP_PAD)
 653     sec_flags = 0;
 654   else if (strcmp (name, _TEXT) == 0)
 655     {
 656       if (sec_flags & SEC_NEVER_LOAD)
 657         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 658       else
 659         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 660     }
 661   else if (strcmp (name, _DATA) == 0)
 662     {
 663       if (sec_flags & SEC_NEVER_LOAD)
 664         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 665       else
 666         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 667     }
 668   else if (strcmp (name, _BSS) == 0)
 669     {
 670 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 671       if (sec_flags & SEC_NEVER_LOAD)
 672         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 673       else
 674 #endif
 675         sec_flags |= SEC_ALLOC;
 676     }
 677   else if (strncmp (name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1) == 0
 678 #ifdef _COMMENT
 679            || strcmp (name, _COMMENT) == 0
 680 #endif
 681 #ifdef COFF_LONG_SECTION_NAMES
 682            || strncmp (name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1) == 0
 683 #endif
 684            || strncmp (name, ".stab", 5) == 0)
 685     {
 686 #ifdef COFF_PAGE_SIZE
 687       sec_flags |= SEC_DEBUGGING;
 688 #endif
 689     }
 690 #ifdef _LIB
 691   else if (strcmp (name, _LIB) == 0)
 692     ;
 693 #endif
 694 #ifdef _LIT
 695   else if (strcmp (name, _LIT) == 0)
 696     sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
 697 #endif
 698   else
 699     sec_flags |= SEC_ALLOC | SEC_LOAD;
 700
 701 #ifdef STYP_LIT                 /* A29k readonly text/data section type.  */
 702   if ((styp_flags & STYP_LIT) == STYP_LIT)
 703     sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 704 #endif /* STYP_LIT */
 705
 706 #ifdef STYP_OTHER_LOAD          /* Other loaded sections.  */
 707   if (styp_flags & STYP_OTHER_LOAD)
 708     sec_flags = (SEC_LOAD | SEC_ALLOC);
 709 #endif /* STYP_SDATA */
 710
 711 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
 712   /* As a GNU extension, if the name begins with .gnu.linkonce, we
 713      only link a single copy of the section.  This is used to support
 714      g++.  g++ will emit each template expansion in its own section.
 715      The symbols will be defined as weak, so that multiple definitions
 716      are permitted.  The GNU linker extension is to actually discard
 717      all but one of the sections.  */
 718   if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
 719     sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 720 #endif
 721
 722   if (flags_ptr == NULL)
 723     return FALSE;
 724
 725   * flags_ptr = sec_flags;
 726   return TRUE;
 727 }
 728
 729 #else /* COFF_WITH_PE */
 730
 731 static flagword
 732 handle_COMDAT (bfd * abfd,
 733                flagword sec_flags,
 734                void * hdr,
 735                const char *name,
 736                asection *section)
 737 {
 738   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 739   bfd_byte *esymstart, *esym, *esymend;
 740   int seen_state = 0;
 741   char *target_name = NULL;
 742
 743   sec_flags |= SEC_LINK_ONCE;
 744
 745   /* Unfortunately, the PE format stores essential information in
 746      the symbol table, of all places.  We need to extract that
 747      information now, so that objdump and the linker will know how
 748      to handle the section without worrying about the symbols.  We
 749      can't call slurp_symtab, because the linker doesn't want the
 750      swapped symbols.  */
 751
 752   /* COMDAT sections are special.  The first symbol is the section
 753      symbol, which tells what kind of COMDAT section it is.  The
 754      second symbol is the "comdat symbol" - the one with the
 755      unique name.  GNU uses the section symbol for the unique
 756      name; MS uses ".text" for every comdat section.  Sigh.  - DJ */
 757
 758   /* This is not mirrored in sec_to_styp_flags(), but there
 759      doesn't seem to be a need to, either, and it would at best be
 760      rather messy.  */
 761
 762   if (! _bfd_coff_get_external_symbols (abfd))
 763     return sec_flags;
 764
 765   esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
 766   esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
 767
 768   while (esym < esymend)
 769     {
 770       struct internal_syment isym;
 771       char buf[SYMNMLEN + 1];
 772       const char *symname;
 773
 774       bfd_coff_swap_sym_in (abfd, esym, & isym);
 775
 776       if (sizeof (internal_s->s_name) > SYMNMLEN)
 777         {
 778           /* This case implies that the matching
 779              symbol name will be in the string table.  */
 780           abort ();
 781         }
 782
 783       if (isym.n_scnum == section->target_index)
 784         {
 785           /* According to the MSVC documentation, the first
 786              TWO entries with the section # are both of
 787              interest to us.  The first one is the "section
 788              symbol" (section name).  The second is the comdat
 789              symbol name.  Here, we've found the first
 790              qualifying entry; we distinguish it from the
 791              second with a state flag.
 792
 793              In the case of gas-generated (at least until that
 794              is fixed) .o files, it isn't necessarily the
 795              second one.  It may be some other later symbol.
 796
 797              Since gas also doesn't follow MS conventions and
 798              emits the section similar to .text$<name>, where
 799              <something> is the name we're looking for, we
 800              distinguish the two as follows:
 801
 802              If the section name is simply a section name (no
 803              $) we presume it's MS-generated, and look at
 804              precisely the second symbol for the comdat name.
 805              If the section name has a $, we assume it's
 806              gas-generated, and look for <something> (whatever
 807              follows the $) as the comdat symbol.  */
 808
 809           /* All 3 branches use this.  */
 810           symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
 811
 812           if (symname == NULL)
 813             abort ();
 814
 815           switch (seen_state)
 816             {
 817             case 0:
 818               {
 819                 /* The first time we've seen the symbol.  */
 820                 union internal_auxent aux;
 821
 822                 /* If it isn't the stuff we're expecting, die;
 823                    The MS documentation is vague, but it
 824                    appears that the second entry serves BOTH
 825                    as the comdat symbol and the defining
 826                    symbol record (either C_STAT or C_EXT,
 827                    possibly with an aux entry with debug
 828                    information if it's a function.)  It
 829                    appears the only way to find the second one
 830                    is to count.  (On Intel, they appear to be
 831                    adjacent, but on Alpha, they have been
 832                    found separated.)
 833
 834                    Here, we think we've found the first one,
 835                    but there's some checking we can do to be
 836                    sure.  */
 837
 838                 if (! (isym.n_sclass == C_STAT
 839                        && isym.n_type == T_NULL
 840                        && isym.n_value == 0))
 841                   abort ();
 842
 843                 /* FIXME LATER: MSVC generates section names
 844                    like .text for comdats.  Gas generates
 845                    names like .text$foo__Fv (in the case of a
 846                    function).  See comment above for more.  */
 847
 848                 if (strcmp (name, symname) != 0)
 849                   _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
 850                                       abfd, symname, name);
 851
 852                 seen_state = 1;
 853
 854                 /* This is the section symbol.  */
 855                 bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)),
 856                                       isym.n_type, isym.n_sclass,
 857                                       0, isym.n_numaux, & aux);
 858
 859                 target_name = strchr (name, '$');
 860                 if (target_name != NULL)
 861                   {
 862                     /* Gas mode.  */
 863                     seen_state = 2;
 864                     /* Skip the `$'.  */
 865                     target_name += 1;
 866                   }
 867
 868                 /* FIXME: Microsoft uses NODUPLICATES and
 869                    ASSOCIATIVE, but gnu uses ANY and
 870                    SAME_SIZE.  Unfortunately, gnu doesn't do
 871                    the comdat symbols right.  So, until we can
 872                    fix it to do the right thing, we are
 873                    temporarily disabling comdats for the MS
 874                    types (they're used in DLLs and C++, but we
 875                    don't support *their* C++ libraries anyway
 876                    - DJ.  */
 877
 878                 /* Cygwin does not follow the MS style, and
 879                    uses ANY and SAME_SIZE where NODUPLICATES
 880                    and ASSOCIATIVE should be used.  For
 881                    Interix, we just do the right thing up
 882                    front.  */
 883
 884                 switch (aux.x_scn.x_comdat)
 885                   {
 886                   case IMAGE_COMDAT_SELECT_NODUPLICATES:
 887 #ifdef STRICT_PE_FORMAT
 888                     sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
 889 #else
 890                     sec_flags &= ~SEC_LINK_ONCE;
 891 #endif
 892                     break;
 893
 894                   case IMAGE_COMDAT_SELECT_ANY:
 895                     sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
 896                     break;
 897
 898                   case IMAGE_COMDAT_SELECT_SAME_SIZE:
 899                     sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
 900                     break;
 901
 902                   case IMAGE_COMDAT_SELECT_EXACT_MATCH:
 903                     /* Not yet fully implemented ??? */
 904                     sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
 905                     break;
 906
 907                     /* debug$S gets this case; other
 908                        implications ??? */
 909
 910                     /* There may be no symbol... we'll search
 911                        the whole table... Is this the right
 912                        place to play this game? Or should we do
 913                        it when reading it in.  */
 914                   case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
 915 #ifdef STRICT_PE_FORMAT
 916                     /* FIXME: This is not currently implemented.  */
 917                     sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
 918 #else
 919                     sec_flags &= ~SEC_LINK_ONCE;
 920 #endif
 921                     break;
 922
 923                   default:  /* 0 means "no symbol" */
 924                     /* debug$F gets this case; other
 925                        implications ??? */
 926                     sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
 927                     break;
 928                   }
 929               }
 930               break;
 931
 932             case 2:
 933               /* Gas mode: the first matching on partial name.  */
 934
 935 #ifndef TARGET_UNDERSCORE
 936 #define TARGET_UNDERSCORE 0
 937 #endif
 938               /* Is this the name we're looking for ?  */
 939               if (strcmp (target_name,
 940                           symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
 941                 {
 942                   /* Not the name we're looking for */
 943                   esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
 944                   continue;
 945                 }
 946               /* Fall through.  */
 947             case 1:
 948               /* MSVC mode: the lexically second symbol (or
 949                  drop through from the above).  */
 950               {
 951                 char *newname;
 952                 bfd_size_type amt;
 953
 954                 /* This must the second symbol with the
 955                    section #.  It is the actual symbol name.
 956                    Intel puts the two adjacent, but Alpha (at
 957                    least) spreads them out.  */
 958
 959                 amt = sizeof (struct coff_comdat_info);
 960                 coff_section_data (abfd, section)->comdat
 961                   = bfd_alloc (abfd, amt);
 962                 if (coff_section_data (abfd, section)->comdat == NULL)
 963                   abort ();
 964
 965                 coff_section_data (abfd, section)->comdat->symbol =
 966                   (esym - esymstart) / bfd_coff_symesz (abfd);
 967
 968                 amt = strlen (symname) + 1;
 969                 newname = bfd_alloc (abfd, amt);
 970                 if (newname == NULL)
 971                   abort ();
 972
 973                 strcpy (newname, symname);
 974                 coff_section_data (abfd, section)->comdat->name
 975                   = newname;
 976               }
 977
 978               goto breakloop;
 979             }
 980         }
 981
 982       esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
 983     }
 984
 985  breakloop:
 986   return sec_flags;
 987 }
 988
 989
 990 /* The PE version; see above for the general comments.
 991
 992    Since to set the SEC_LINK_ONCE and associated flags, we have to
 993    look at the symbol table anyway, we return the symbol table index
 994    of the symbol being used as the COMDAT symbol.  This is admittedly
 995    ugly, but there's really nowhere else that we have access to the
 996    required information.  FIXME: Is the COMDAT symbol index used for
 997    any purpose other than objdump?  */
 998
 999 static bfd_boolean
1000 styp_to_sec_flags (bfd *abfd,
1001                    void * hdr,
1002                    const char *name,
1003                    asection *section,
1004                    flagword *flags_ptr)
1005 {
1006   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1007   long styp_flags = internal_s->s_flags;
1008   flagword sec_flags;
1009   bfd_boolean result = TRUE;
1010
1011   /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified.  */
1012   sec_flags = SEC_READONLY;
1013
1014   /* Process each flag bit in styp_flags in turn.  */
1015   while (styp_flags)
1016     {
1017       long flag = styp_flags & - styp_flags;
1018       char * unhandled = NULL;
1019
1020       styp_flags &= ~ flag;
1021
1022       /* We infer from the distinct read/write/execute bits the settings
1023          of some of the bfd flags; the actual values, should we need them,
1024          are also in pei_section_data (abfd, section)->pe_flags.  */
1025
1026       switch (flag)
1027         {
1028         case STYP_DSECT:
1029           unhandled = "STYP_DSECT";
1030           break;
1031         case STYP_GROUP:
1032           unhandled = "STYP_GROUP";
1033           break;
1034         case STYP_COPY:
1035           unhandled = "STYP_COPY";
1036           break;
1037         case STYP_OVER:
1038           unhandled = "STYP_OVER";
1039           break;
1040 #ifdef SEC_NEVER_LOAD
1041         case STYP_NOLOAD:
1042           sec_flags |= SEC_NEVER_LOAD;
1043           break;
1044 #endif
1045         case IMAGE_SCN_MEM_READ:
1046           /* Ignored, assume it always to be true.  */
1047           break;
1048         case IMAGE_SCN_TYPE_NO_PAD:
1049           /* Skip.  */
1050           break;
1051         case IMAGE_SCN_LNK_OTHER:
1052           unhandled = "IMAGE_SCN_LNK_OTHER";
1053           break;
1054         case IMAGE_SCN_MEM_NOT_CACHED:
1055           unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1056           break;
1057         case IMAGE_SCN_MEM_NOT_PAGED:
1058           /* Generate a warning message rather using the 'unhandled'
1059              variable as this will allow some .sys files generate by
1060              other toolchains to be processed.  See bugzilla issue 196.  */
1061           _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1062                               abfd, name);
1063           break;
1064         case IMAGE_SCN_MEM_EXECUTE:
1065           sec_flags |= SEC_CODE;
1066           break;
1067         case IMAGE_SCN_MEM_WRITE:
1068           sec_flags &= ~ SEC_READONLY;
1069           break;
1070         case IMAGE_SCN_MEM_DISCARDABLE:
1071           /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
1072              but we do not want them to be labelled as debug section, since
1073              then strip would remove them.  */
1074           if (strncmp (name, ".reloc", sizeof ".reloc" - 1) != 0)
1075             sec_flags |= SEC_DEBUGGING;
1076           break;
1077         case IMAGE_SCN_MEM_SHARED:
1078           sec_flags |= SEC_COFF_SHARED;
1079           break;
1080         case IMAGE_SCN_LNK_REMOVE:
1081           sec_flags |= SEC_EXCLUDE;
1082           break;
1083         case IMAGE_SCN_CNT_CODE:
1084           sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1085           break;
1086         case IMAGE_SCN_CNT_INITIALIZED_DATA:
1087           sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1088           break;
1089         case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1090           sec_flags |= SEC_ALLOC;
1091           break;
1092         case IMAGE_SCN_LNK_INFO:
1093           /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1094              defined.  coff_compute_section_file_positions uses
1095              COFF_PAGE_SIZE to ensure that the low order bits of the
1096              section VMA and the file offset match.  If we don't know
1097              COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1098              and demand page loading of the file will fail.  */
1099 #ifdef COFF_PAGE_SIZE
1100           sec_flags |= SEC_DEBUGGING;
1101 #endif
1102           break;
1103         case IMAGE_SCN_LNK_COMDAT:
1104           /* COMDAT gets very special treatment.  */
1105           sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1106           break;
1107         default:
1108           /* Silently ignore for now.  */
1109           break;
1110         }
1111
1112       /* If the section flag was not handled, report it here.  */
1113       if (unhandled != NULL)
1114         {
1115           (*_bfd_error_handler)
1116             (_("%B (%s): Section flag %s (0x%x) ignored"),
1117              abfd, name, unhandled, flag);
1118           result = FALSE;
1119         }
1120     }
1121
1122 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1123   /* As a GNU extension, if the name begins with .gnu.linkonce, we
1124      only link a single copy of the section.  This is used to support
1125      g++.  g++ will emit each template expansion in its own section.
1126      The symbols will be defined as weak, so that multiple definitions
1127      are permitted.  The GNU linker extension is to actually discard
1128      all but one of the sections.  */
1129   if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1130     sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1131 #endif
1132
1133   if (flags_ptr)
1134     * flags_ptr = sec_flags;
1135
1136   return result;
1137 }
1138
1139 #endif /* COFF_WITH_PE */
1140
1141 #define get_index(symbol)       ((symbol)->udata.i)
1142
1143 /*
1144 INTERNAL_DEFINITION
1145         bfd_coff_backend_data
1146
1147 CODE_FRAGMENT
1148
1149 .{* COFF symbol classifications.  *}
1150 .
1151 .enum coff_symbol_classification
1152 .{
1153 .  {* Global symbol.  *}
1154 .  COFF_SYMBOL_GLOBAL,
1155 .  {* Common symbol.  *}
1156 .  COFF_SYMBOL_COMMON,
1157 .  {* Undefined symbol.  *}
1158 .  COFF_SYMBOL_UNDEFINED,
1159 .  {* Local symbol.  *}
1160 .  COFF_SYMBOL_LOCAL,
1161 .  {* PE section symbol.  *}
1162 .  COFF_SYMBOL_PE_SECTION
1163 .};
1164 .
1165 Special entry points for gdb to swap in coff symbol table parts:
1166 .typedef struct
1167 .{
1168 .  void (*_bfd_coff_swap_aux_in)
1169 .    (bfd *, void *, int, int, int, int, void *);
1170 .
1171 .  void (*_bfd_coff_swap_sym_in)
1172 .    (bfd *, void *, void *);
1173 .
1174 .  void (*_bfd_coff_swap_lineno_in)
1175 .    (bfd *, void *, void *);
1176 .
1177 .  unsigned int (*_bfd_coff_swap_aux_out)
1178 .    (bfd *, void *, int, int, int, int, void *);
1179 .
1180 .  unsigned int (*_bfd_coff_swap_sym_out)
1181 .    (bfd *, void *, void *);
1182 .
1183 .  unsigned int (*_bfd_coff_swap_lineno_out)
1184 .    (bfd *, void *, void *);
1185 .
1186 .  unsigned int (*_bfd_coff_swap_reloc_out)
1187 .    (bfd *, void *, void *);
1188 .
1189 .  unsigned int (*_bfd_coff_swap_filehdr_out)
1190 .    (bfd *, void *, void *);
1191 .
1192 .  unsigned int (*_bfd_coff_swap_aouthdr_out)
1193 .    (bfd *, void *, void *);
1194 .
1195 .  unsigned int (*_bfd_coff_swap_scnhdr_out)
1196 .    (bfd *, void *, void *);
1197 .
1198 .  unsigned int _bfd_filhsz;
1199 .  unsigned int _bfd_aoutsz;
1200 .  unsigned int _bfd_scnhsz;
1201 .  unsigned int _bfd_symesz;
1202 .  unsigned int _bfd_auxesz;
1203 .  unsigned int _bfd_relsz;
1204 .  unsigned int _bfd_linesz;
1205 .  unsigned int _bfd_filnmlen;
1206 .  bfd_boolean _bfd_coff_long_filenames;
1207 .  bfd_boolean _bfd_coff_long_section_names;
1208 .  unsigned int _bfd_coff_default_section_alignment_power;
1209 .  bfd_boolean _bfd_coff_force_symnames_in_strings;
1210 .  unsigned int _bfd_coff_debug_string_prefix_length;
1211 .
1212 .  void (*_bfd_coff_swap_filehdr_in)
1213 .    (bfd *, void *, void *);
1214 .
1215 .  void (*_bfd_coff_swap_aouthdr_in)
1216 .    (bfd *, void *, void *);
1217 .
1218 .  void (*_bfd_coff_swap_scnhdr_in)
1219 .    (bfd *, void *, void *);
1220 .
1221 .  void (*_bfd_coff_swap_reloc_in)
1222 .    (bfd *abfd, void *, void *);
1223 .
1224 .  bfd_boolean (*_bfd_coff_bad_format_hook)
1225 .    (bfd *, void *);
1226 .
1227 .  bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1228 .    (bfd *, void *);
1229 .
1230 .  void * (*_bfd_coff_mkobject_hook)
1231 .    (bfd *, void *, void *);
1232 .
1233 .  bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1234 .    (bfd *, void *, const char *, asection *, flagword *);
1235 .
1236 .  void (*_bfd_set_alignment_hook)
1237 .    (bfd *, asection *, void *);
1238 .
1239 .  bfd_boolean (*_bfd_coff_slurp_symbol_table)
1240 .    (bfd *);
1241 .
1242 .  bfd_boolean (*_bfd_coff_symname_in_debug)
1243 .    (bfd *, struct internal_syment *);
1244 .
1245 .  bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1246 .    (bfd *, combined_entry_type *, combined_entry_type *,
1247 .            unsigned int, combined_entry_type *);
1248 .
1249 .  bfd_boolean (*_bfd_coff_print_aux)
1250 .    (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1251 .            combined_entry_type *, unsigned int);
1252 .
1253 .  void (*_bfd_coff_reloc16_extra_cases)
1254 .    (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1255 .           bfd_byte *, unsigned int *, unsigned int *);
1256 .
1257 .  int (*_bfd_coff_reloc16_estimate)
1258 .    (bfd *, asection *, arelent *, unsigned int,
1259 .            struct bfd_link_info *);
1260 .
1261 .  enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1262 .    (bfd *, struct internal_syment *);
1263 .
1264 .  bfd_boolean (*_bfd_coff_compute_section_file_positions)
1265 .    (bfd *);
1266 .
1267 .  bfd_boolean (*_bfd_coff_start_final_link)
1268 .    (bfd *, struct bfd_link_info *);
1269 .
1270 .  bfd_boolean (*_bfd_coff_relocate_section)
1271 .    (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1272 .            struct internal_reloc *, struct internal_syment *, asection **);
1273 .
1274 .  reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1275 .    (bfd *, asection *, struct internal_reloc *,
1276 .            struct coff_link_hash_entry *, struct internal_syment *,
1277 .            bfd_vma *);
1278 .
1279 .  bfd_boolean (*_bfd_coff_adjust_symndx)
1280 .    (bfd *, struct bfd_link_info *, bfd *, asection *,
1281 .            struct internal_reloc *, bfd_boolean *);
1282 .
1283 .  bfd_boolean (*_bfd_coff_link_add_one_symbol)
1284 .    (struct bfd_link_info *, bfd *, const char *, flagword,
1285 .            asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1286 .            struct bfd_link_hash_entry **);
1287 .
1288 .  bfd_boolean (*_bfd_coff_link_output_has_begun)
1289 .    (bfd *, struct coff_final_link_info *);
1290 .
1291 .  bfd_boolean (*_bfd_coff_final_link_postscript)
1292 .    (bfd *, struct coff_final_link_info *);
1293 .
1294 .} bfd_coff_backend_data;
1295 .
1296 .#define coff_backend_info(abfd) \
1297 .  ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1298 .
1299 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1300 .  ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1301 .
1302 .#define bfd_coff_swap_sym_in(a,e,i) \
1303 .  ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1304 .
1305 .#define bfd_coff_swap_lineno_in(a,e,i) \
1306 .  ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1307 .
1308 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1309 .  ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1310 .
1311 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1312 .  ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1313 .
1314 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1315 .  ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1316 .
1317 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1318 .  ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1319 .
1320 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1321 .  ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1322 .
1323 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1324 .  ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1325 .
1326 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1327 .  ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1328 .
1329 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1330 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1331 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1332 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1333 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1334 .#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
1335 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1336 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1337 .#define bfd_coff_long_filenames(abfd) \
1338 .  (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1339 .#define bfd_coff_long_section_names(abfd) \
1340 .  (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1341 .#define bfd_coff_default_section_alignment_power(abfd) \
1342 .  (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1343 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1344 .  ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1345 .
1346 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1347 .  ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1348 .
1349 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1350 .  ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1351 .
1352 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1353 .  ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1354 .
1355 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1356 .  ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1357 .
1358 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1359 .  ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1360 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1361 .  ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1362 .   (abfd, filehdr, aouthdr))
1363 .
1364 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1365 .  ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1366 .   (abfd, scnhdr, name, section, flags_ptr))
1367 .
1368 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1369 .  ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1370 .
1371 .#define bfd_coff_slurp_symbol_table(abfd)\
1372 .  ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1373 .
1374 .#define bfd_coff_symname_in_debug(abfd, sym)\
1375 .  ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1376 .
1377 .#define bfd_coff_force_symnames_in_strings(abfd)\
1378 .  (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1379 .
1380 .#define bfd_coff_debug_string_prefix_length(abfd)\
1381 .  (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1382 .
1383 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1384 .  ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1385 .   (abfd, file, base, symbol, aux, indaux))
1386 .
1387 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1388 .                                     reloc, data, src_ptr, dst_ptr)\
1389 .  ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1390 .   (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1391 .
1392 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1393 .  ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1394 .   (abfd, section, reloc, shrink, link_info))
1395 .
1396 .#define bfd_coff_classify_symbol(abfd, sym)\
1397 .  ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1398 .   (abfd, sym))
1399 .
1400 .#define bfd_coff_compute_section_file_positions(abfd)\
1401 .  ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1402 .   (abfd))
1403 .
1404 .#define bfd_coff_start_final_link(obfd, info)\
1405 .  ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1406 .   (obfd, info))
1407 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1408 .  ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1409 .   (obfd, info, ibfd, o, con, rel, isyms, secs))
1410 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1411 .  ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1412 .   (abfd, sec, rel, h, sym, addendp))
1413 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1414 .  ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1415 .   (obfd, info, ibfd, sec, rel, adjustedp))
1416 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1417 .                                     value, string, cp, coll, hashp)\
1418 .  ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1419 .   (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1420 .
1421 .#define bfd_coff_link_output_has_begun(a,p) \
1422 .  ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1423 .#define bfd_coff_final_link_postscript(a,p) \
1424 .  ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1425 .
1426 */
1427
1428 /* See whether the magic number matches.  */
1429
1430 static bfd_boolean
1431 coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
1432 {
1433   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1434
1435   if (BADMAG (*internal_f))
1436     return FALSE;
1437
1438   /* If the optional header is NULL or not the correct size then
1439      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1440      and Intel 960 readwrite headers (I960WRMAGIC) is that the
1441      optional header is of a different size.
1442
1443      But the mips keeps extra stuff in it's opthdr, so dont check
1444      when doing that.  */
1445
1446 #if defined(M88) || defined(I960)
1447   if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1448     return FALSE;
1449 #endif
1450
1451   return TRUE;
1452 }
1453
1454 #ifdef TICOFF
1455 static bfd_boolean
1456 ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1457 {
1458   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1459
1460   if (COFF0_BADMAG (*internal_f))
1461     return FALSE;
1462
1463   return TRUE;
1464 }
1465 #endif
1466
1467 #ifdef TICOFF
1468 static bfd_boolean
1469 ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1470 {
1471   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1472
1473   if (COFF1_BADMAG (*internal_f))
1474     return FALSE;
1475
1476   return TRUE;
1477 }
1478 #endif
1479
1480 /* Check whether this section uses an alignment other than the
1481    default.  */
1482
1483 static void
1484 coff_set_custom_section_alignment (bfd *abfd ATTRIBUTE_UNUSED,
1485                                    asection *section,
1486                                    const struct coff_section_alignment_entry *alignment_table,
1487                                    const unsigned int table_size)
1488 {
1489   const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1490   unsigned int i;
1491
1492   for (i = 0; i < table_size; ++i)
1493     {
1494       const char *secname = bfd_get_section_name (abfd, section);
1495
1496       if (alignment_table[i].comparison_length == (unsigned int) -1
1497           ? strcmp (alignment_table[i].name, secname) == 0
1498           : strncmp (alignment_table[i].name, secname,
1499                      alignment_table[i].comparison_length) == 0)
1500         break;
1501     }
1502   if (i >= table_size)
1503     return;
1504
1505   if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1506       && default_alignment < alignment_table[i].default_alignment_min)
1507     return;
1508
1509   if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1510 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1511       && default_alignment > alignment_table[i].default_alignment_max
1512 #endif
1513       )
1514     return;
1515
1516   section->alignment_power = alignment_table[i].alignment_power;
1517 }
1518
1519 /* Custom section alignment records.  */
1520
1521 static const struct coff_section_alignment_entry
1522 coff_section_alignment_table[] =
1523 {
1524 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1525   COFF_SECTION_ALIGNMENT_ENTRIES,
1526 #endif
1527   /* There must not be any gaps between .stabstr sections.  */
1528   { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1529     1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1530   /* The .stab section must be aligned to 2**2 at most, to avoid gaps.  */
1531   { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1532     3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1533   /* Similarly for the .ctors and .dtors sections.  */
1534   { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1535     3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1536   { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1537     3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1538 };
1539
1540 static const unsigned int coff_section_alignment_table_size =
1541   sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1542
1543 /* Initialize a section structure with information peculiar to this
1544    particular implementation of COFF.  */
1545
1546 static bfd_boolean
1547 coff_new_section_hook (bfd * abfd, asection * section)
1548 {
1549   combined_entry_type *native;
1550   bfd_size_type amt;
1551
1552   section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1553
1554 #ifdef RS6000COFF_C
1555   if (bfd_xcoff_text_align_power (abfd) != 0
1556       && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1557     section->alignment_power = bfd_xcoff_text_align_power (abfd);
1558   if (bfd_xcoff_data_align_power (abfd) != 0
1559       && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1560     section->alignment_power = bfd_xcoff_data_align_power (abfd);
1561 #endif
1562
1563   /* Allocate aux records for section symbols, to store size and
1564      related info.
1565
1566      @@ The 10 is a guess at a plausible maximum number of aux entries
1567      (but shouldn't be a constant).  */
1568   amt = sizeof (combined_entry_type) * 10;
1569   native = bfd_zalloc (abfd, amt);
1570   if (native == NULL)
1571     return FALSE;
1572
1573   /* We don't need to set up n_name, n_value, or n_scnum in the native
1574      symbol information, since they'll be overridden by the BFD symbol
1575      anyhow.  However, we do need to set the type and storage class,
1576      in case this symbol winds up getting written out.  The value 0
1577      for n_numaux is already correct.  */
1578
1579   native->u.syment.n_type = T_NULL;
1580   native->u.syment.n_sclass = C_STAT;
1581
1582   coffsymbol (section->symbol)->native = native;
1583
1584   coff_set_custom_section_alignment (abfd, section,
1585                                      coff_section_alignment_table,
1586                                      coff_section_alignment_table_size);
1587
1588   return TRUE;
1589 }
1590
1591 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1592
1593 /* Set the alignment of a BFD section.  */
1594
1595 static void
1596 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1597                          asection * section,
1598                          void * scnhdr)
1599 {
1600   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1601   unsigned int i;
1602
1603 #ifdef I960
1604   /* Extract ALIGN from 2**ALIGN stored in section header.  */
1605   for (i = 0; i < 32; i++)
1606     if ((1 << i) >= hdr->s_align)
1607       break;
1608 #endif
1609 #ifdef TIC80COFF
1610   /* TI tools puts the alignment power in bits 8-11.  */
1611   i = (hdr->s_flags >> 8) & 0xF ;
1612 #endif
1613 #ifdef COFF_DECODE_ALIGNMENT
1614   i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1615 #endif
1616   section->alignment_power = i;
1617
1618 #ifdef coff_set_section_load_page
1619   coff_set_section_load_page (section, hdr->s_page);
1620 #endif
1621 }
1622
1623 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1624 #ifdef COFF_WITH_PE
1625
1626 /* A couple of macros to help setting the alignment power field.  */
1627 #define ALIGN_SET(field, x, y) \
1628   if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x)\
1629     {\
1630       section->alignment_power = y;\
1631     }
1632
1633 #define ELIFALIGN_SET(field, x, y) \
1634   else if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x) \
1635     {\
1636       section->alignment_power = y;\
1637     }
1638
1639 static void
1640 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1641                          asection * section,
1642                          void * scnhdr)
1643 {
1644   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1645   bfd_size_type amt;
1646
1647   ALIGN_SET     (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1648   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1649   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1650   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES,  3)
1651   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES,  2)
1652   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES,  1)
1653   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES,  0)
1654
1655   /* In a PE image file, the s_paddr field holds the virtual size of a
1656      section, while the s_size field holds the raw size.  We also keep
1657      the original section flag value, since not every bit can be
1658      mapped onto a generic BFD section bit.  */
1659   if (coff_section_data (abfd, section) == NULL)
1660     {
1661       amt = sizeof (struct coff_section_tdata);
1662       section->used_by_bfd = bfd_zalloc (abfd, amt);
1663       if (section->used_by_bfd == NULL)
1664         /* FIXME: Return error.  */
1665         abort ();
1666     }
1667
1668   if (pei_section_data (abfd, section) == NULL)
1669     {
1670       amt = sizeof (struct pei_section_tdata);
1671       coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt);
1672       if (coff_section_data (abfd, section)->tdata == NULL)
1673         /* FIXME: Return error.  */
1674         abort ();
1675     }
1676   pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1677   pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1678
1679   section->lma = hdr->s_vaddr;
1680
1681   /* Check for extended relocs.  */
1682   if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1683     {
1684       struct external_reloc dst;
1685       struct internal_reloc n;
1686       file_ptr oldpos = bfd_tell (abfd);
1687       bfd_size_type relsz = bfd_coff_relsz (abfd);
1688
1689       bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1690       if (bfd_bread (& dst, relsz, abfd) != relsz)
1691         return;
1692
1693       coff_swap_reloc_in (abfd, &dst, &n);
1694       bfd_seek (abfd, oldpos, 0);
1695       section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1696       section->rel_filepos += relsz;
1697     }
1698   else if (hdr->s_nreloc == 0xffff)
1699     (*_bfd_error_handler)
1700       ("%s: warning: claims to have 0xffff relocs, without overflow",
1701        bfd_get_filename (abfd));
1702 }
1703 #undef ALIGN_SET
1704 #undef ELIFALIGN_SET
1705
1706 #else /* ! COFF_WITH_PE */
1707 #ifdef RS6000COFF_C
1708
1709 /* We grossly abuse this function to handle XCOFF overflow headers.
1710    When we see one, we correct the reloc and line number counts in the
1711    real header, and remove the section we just created.  */
1712
1713 static void
1714 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr)
1715 {
1716   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1717   asection *real_sec;
1718
1719   if ((hdr->s_flags & STYP_OVRFLO) == 0)
1720     return;
1721
1722   real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1723   if (real_sec == NULL)
1724     return;
1725
1726   real_sec->reloc_count = hdr->s_paddr;
1727   real_sec->lineno_count = hdr->s_vaddr;
1728
1729   if (!bfd_section_removed_from_list (abfd, section))
1730     {
1731       bfd_section_list_remove (abfd, section);
1732       --abfd->section_count;
1733     }
1734 }
1735
1736 #else /* ! RS6000COFF_C */
1737
1738 #define coff_set_alignment_hook \
1739   ((void (*) (bfd *, asection *, void *)) bfd_void)
1740
1741 #endif /* ! RS6000COFF_C */
1742 #endif /* ! COFF_WITH_PE */
1743 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1744
1745 #ifndef coff_mkobject
1746
1747 static bfd_boolean
1748 coff_mkobject (bfd * abfd)
1749 {
1750   coff_data_type *coff;
1751   bfd_size_type amt = sizeof (coff_data_type);
1752
1753   abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
1754   if (abfd->tdata.coff_obj_data == NULL)
1755     return FALSE;
1756   coff = coff_data (abfd);
1757   coff->symbols = NULL;
1758   coff->conversion_table = NULL;
1759   coff->raw_syments = NULL;
1760   coff->relocbase = 0;
1761   coff->local_toc_sym_map = 0;
1762
1763 /*  make_abs_section(abfd);*/
1764
1765   return TRUE;
1766 }
1767 #endif
1768
1769 /* Create the COFF backend specific information.  */
1770
1771 #ifndef coff_mkobject_hook
1772 static void *
1773 coff_mkobject_hook (bfd * abfd,
1774                     void * filehdr,
1775                     void * aouthdr ATTRIBUTE_UNUSED)
1776 {
1777   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1778   coff_data_type *coff;
1779
1780   if (! coff_mkobject (abfd))
1781     return NULL;
1782
1783   coff = coff_data (abfd);
1784
1785   coff->sym_filepos = internal_f->f_symptr;
1786
1787   /* These members communicate important constants about the symbol
1788      table to GDB's symbol-reading code.  These `constants'
1789      unfortunately vary among coff implementations...  */
1790   coff->local_n_btmask = N_BTMASK;
1791   coff->local_n_btshft = N_BTSHFT;
1792   coff->local_n_tmask = N_TMASK;
1793   coff->local_n_tshift = N_TSHIFT;
1794   coff->local_symesz = bfd_coff_symesz (abfd);
1795   coff->local_auxesz = bfd_coff_auxesz (abfd);
1796   coff->local_linesz = bfd_coff_linesz (abfd);
1797
1798   coff->timestamp = internal_f->f_timdat;
1799
1800   obj_raw_syment_count (abfd) =
1801     obj_conv_table_size (abfd) =
1802       internal_f->f_nsyms;
1803
1804 #ifdef RS6000COFF_C
1805   if ((internal_f->f_flags & F_SHROBJ) != 0)
1806     abfd->flags |= DYNAMIC;
1807   if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1808     {
1809       struct internal_aouthdr *internal_a =
1810         (struct internal_aouthdr *) aouthdr;
1811       struct xcoff_tdata *xcoff;
1812
1813       xcoff = xcoff_data (abfd);
1814 # ifdef U803XTOCMAGIC
1815       xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1816 # else
1817       xcoff->xcoff64 = 0;
1818 # endif
1819       xcoff->full_aouthdr = TRUE;
1820       xcoff->toc = internal_a->o_toc;
1821       xcoff->sntoc = internal_a->o_sntoc;
1822       xcoff->snentry = internal_a->o_snentry;
1823       bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1824       bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1825       xcoff->modtype = internal_a->o_modtype;
1826       xcoff->cputype = internal_a->o_cputype;
1827       xcoff->maxdata = internal_a->o_maxdata;
1828       xcoff->maxstack = internal_a->o_maxstack;
1829     }
1830 #endif
1831
1832 #ifdef ARM
1833   /* Set the flags field from the COFF header read in.  */
1834   if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1835     coff->flags = 0;
1836 #endif
1837
1838 #ifdef COFF_WITH_PE
1839   /* FIXME: I'm not sure this is ever executed, since peicode.h
1840      defines coff_mkobject_hook.  */
1841   if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1842     abfd->flags |= HAS_DEBUG;
1843 #endif
1844
1845   return coff;
1846 }
1847 #endif
1848
1849 /* Determine the machine architecture and type.  FIXME: This is target
1850    dependent because the magic numbers are defined in the target
1851    dependent header files.  But there is no particular need for this.
1852    If the magic numbers were moved to a separate file, this function
1853    would be target independent and would also be much more successful
1854    at linking together COFF files for different architectures.  */
1855
1856 static bfd_boolean
1857 coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
1858 {
1859   unsigned long machine;
1860   enum bfd_architecture arch;
1861   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1862
1863   /* Zero selects the default machine for an arch.  */
1864   machine = 0;
1865   switch (internal_f->f_magic)
1866     {
1867 #ifdef OR32_MAGIC_BIG
1868     case OR32_MAGIC_BIG:
1869     case OR32_MAGIC_LITTLE:
1870       arch = bfd_arch_or32;
1871       break;
1872 #endif
1873 #ifdef PPCMAGIC
1874     case PPCMAGIC:
1875       arch = bfd_arch_powerpc;
1876       break;
1877 #endif
1878 #ifdef I386MAGIC
1879     case I386MAGIC:
1880     case I386PTXMAGIC:
1881     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1882     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1883       arch = bfd_arch_i386;
1884       break;
1885 #endif
1886 #ifdef IA64MAGIC
1887     case IA64MAGIC:
1888       arch = bfd_arch_ia64;
1889       break;
1890 #endif
1891 #ifdef ARMMAGIC
1892     case ARMMAGIC:
1893     case ARMPEMAGIC:
1894     case THUMBPEMAGIC:
1895       arch = bfd_arch_arm;
1896       machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
1897       if (machine == bfd_mach_arm_unknown)
1898         {
1899           switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1900             {
1901             case F_ARM_2:  machine = bfd_mach_arm_2;  break;
1902             case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1903             case F_ARM_3:  machine = bfd_mach_arm_3;  break;
1904             default:
1905             case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1906             case F_ARM_4:  machine = bfd_mach_arm_4;  break;
1907             case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1908               /* The COFF header does not have enough bits available
1909                  to cover all the different ARM architectures.  So
1910                  we interpret F_ARM_5, the highest flag value to mean
1911                  "the highest ARM architecture known to BFD" which is
1912                  currently the XScale.  */
1913             case F_ARM_5:  machine = bfd_mach_arm_XScale;  break;
1914             }
1915         }
1916       break;
1917 #endif
1918 #ifdef MC68MAGIC
1919     case MC68MAGIC:
1920     case M68MAGIC:
1921 #ifdef MC68KBCSMAGIC
1922     case MC68KBCSMAGIC:
1923 #endif
1924 #ifdef APOLLOM68KMAGIC
1925     case APOLLOM68KMAGIC:
1926 #endif
1927 #ifdef LYNXCOFFMAGIC
1928     case LYNXCOFFMAGIC:
1929 #endif
1930       arch = bfd_arch_m68k;
1931       machine = bfd_mach_m68020;
1932       break;
1933 #endif
1934 #ifdef MAXQ20MAGIC
1935     case MAXQ20MAGIC:
1936       arch = bfd_arch_maxq;
1937       switch (internal_f->f_flags & F_MACHMASK)
1938         {
1939         case F_MAXQ10:
1940           machine = bfd_mach_maxq10;
1941           break;
1942         case F_MAXQ20:
1943           machine = bfd_mach_maxq20;
1944           break;
1945         default:
1946           return FALSE;
1947         }
1948       break;
1949 #endif
1950 #ifdef MC88MAGIC
1951     case MC88MAGIC:
1952     case MC88DMAGIC:
1953     case MC88OMAGIC:
1954       arch = bfd_arch_m88k;
1955       machine = 88100;
1956       break;
1957 #endif
1958 #ifdef Z80MAGIC
1959     case Z80MAGIC:
1960       arch = bfd_arch_z80;
1961       switch (internal_f->f_flags & F_MACHMASK)
1962         {
1963         case 0:
1964         case bfd_mach_z80strict << 12:
1965         case bfd_mach_z80 << 12:
1966         case bfd_mach_z80full << 12:
1967         case bfd_mach_r800 << 12:
1968           machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
1969           break;
1970         default:
1971           return FALSE;
1972         }
1973       break;
1974 #endif
1975 #ifdef Z8KMAGIC
1976     case Z8KMAGIC:
1977       arch = bfd_arch_z8k;
1978       switch (internal_f->f_flags & F_MACHMASK)
1979         {
1980         case F_Z8001:
1981           machine = bfd_mach_z8001;
1982           break;
1983         case F_Z8002:
1984           machine = bfd_mach_z8002;
1985           break;
1986         default:
1987           return FALSE;
1988         }
1989       break;
1990 #endif
1991 #ifdef I860
1992     case I860MAGIC:
1993       arch = bfd_arch_i860;
1994       break;
1995 #endif
1996 #ifdef I960
1997 #ifdef I960ROMAGIC
1998     case I960ROMAGIC:
1999     case I960RWMAGIC:
2000       arch = bfd_arch_i960;
2001       switch (F_I960TYPE & internal_f->f_flags)
2002         {
2003         default:
2004         case F_I960CORE:
2005           machine = bfd_mach_i960_core;
2006           break;
2007         case F_I960KB:
2008           machine = bfd_mach_i960_kb_sb;
2009           break;
2010         case F_I960MC:
2011           machine = bfd_mach_i960_mc;
2012           break;
2013         case F_I960XA:
2014           machine = bfd_mach_i960_xa;
2015           break;
2016         case F_I960CA:
2017           machine = bfd_mach_i960_ca;
2018           break;
2019         case F_I960KA:
2020           machine = bfd_mach_i960_ka_sa;
2021           break;
2022         case F_I960JX:
2023           machine = bfd_mach_i960_jx;
2024           break;
2025         case F_I960HX:
2026           machine = bfd_mach_i960_hx;
2027           break;
2028         }
2029       break;
2030 #endif
2031 #endif
2032
2033 #ifdef RS6000COFF_C
2034 #ifdef XCOFF64
2035     case U64_TOCMAGIC:
2036     case U803XTOCMAGIC:
2037 #else
2038     case U802ROMAGIC:
2039     case U802WRMAGIC:
2040     case U802TOCMAGIC:
2041 #endif
2042       {
2043         int cputype;
2044
2045         if (xcoff_data (abfd)->cputype != -1)
2046           cputype = xcoff_data (abfd)->cputype & 0xff;
2047         else
2048           {
2049             /* We did not get a value from the a.out header.  If the
2050                file has not been stripped, we may be able to get the
2051                architecture information from the first symbol, if it
2052                is a .file symbol.  */
2053             if (obj_raw_syment_count (abfd) == 0)
2054               cputype = 0;
2055             else
2056               {
2057                 bfd_byte *buf;
2058                 struct internal_syment sym;
2059                 bfd_size_type amt = bfd_coff_symesz (abfd);
2060
2061                 buf = bfd_malloc (amt);
2062                 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2063                     || bfd_bread (buf, amt, abfd) != amt)
2064                   {
2065                     free (buf);
2066                     return FALSE;
2067                   }
2068                 bfd_coff_swap_sym_in (abfd, buf, & sym);
2069                 if (sym.n_sclass == C_FILE)
2070                   cputype = sym.n_type & 0xff;
2071                 else
2072                   cputype = 0;
2073                 free (buf);
2074               }
2075           }
2076
2077         /* FIXME: We don't handle all cases here.  */
2078         switch (cputype)
2079           {
2080           default:
2081           case 0:
2082             arch = bfd_xcoff_architecture (abfd);
2083             machine = bfd_xcoff_machine (abfd);
2084             break;
2085
2086           case 1:
2087             arch = bfd_arch_powerpc;
2088             machine = bfd_mach_ppc_601;
2089             break;
2090           case 2: /* 64 bit PowerPC */
2091             arch = bfd_arch_powerpc;
2092             machine = bfd_mach_ppc_620;
2093             break;
2094           case 3:
2095             arch = bfd_arch_powerpc;
2096             machine = bfd_mach_ppc;
2097             break;
2098           case 4:
2099             arch = bfd_arch_rs6000;
2100             machine = bfd_mach_rs6k;
2101             break;
2102           }
2103       }
2104       break;
2105 #endif
2106
2107 #ifdef WE32KMAGIC
2108     case WE32KMAGIC:
2109       arch = bfd_arch_we32k;
2110       break;
2111 #endif
2112
2113 #ifdef H8300MAGIC
2114     case H8300MAGIC:
2115       arch = bfd_arch_h8300;
2116       machine = bfd_mach_h8300;
2117       /* !! FIXME this probably isn't the right place for this.  */
2118       abfd->flags |= BFD_IS_RELAXABLE;
2119       break;
2120 #endif
2121
2122 #ifdef H8300HMAGIC
2123     case H8300HMAGIC:
2124       arch = bfd_arch_h8300;
2125       machine = bfd_mach_h8300h;
2126       /* !! FIXME this probably isn't the right place for this.  */
2127       abfd->flags |= BFD_IS_RELAXABLE;
2128       break;
2129 #endif
2130
2131 #ifdef H8300SMAGIC
2132     case H8300SMAGIC:
2133       arch = bfd_arch_h8300;
2134       machine = bfd_mach_h8300s;
2135       /* !! FIXME this probably isn't the right place for this.  */
2136       abfd->flags |= BFD_IS_RELAXABLE;
2137       break;
2138 #endif
2139
2140 #ifdef H8300HNMAGIC
2141     case H8300HNMAGIC:
2142       arch = bfd_arch_h8300;
2143       machine = bfd_mach_h8300hn;
2144       /* !! FIXME this probably isn't the right place for this.  */
2145       abfd->flags |= BFD_IS_RELAXABLE;
2146       break;
2147 #endif
2148
2149 #ifdef H8300SNMAGIC
2150     case H8300SNMAGIC:
2151       arch = bfd_arch_h8300;
2152       machine = bfd_mach_h8300sn;
2153       /* !! FIXME this probably isn't the right place for this.  */
2154       abfd->flags |= BFD_IS_RELAXABLE;
2155       break;
2156 #endif
2157
2158 #ifdef SH_ARCH_MAGIC_BIG
2159     case SH_ARCH_MAGIC_BIG:
2160     case SH_ARCH_MAGIC_LITTLE:
2161 #ifdef COFF_WITH_PE
2162     case SH_ARCH_MAGIC_WINCE:
2163 #endif
2164       arch = bfd_arch_sh;
2165       break;
2166 #endif
2167
2168 #ifdef MIPS_ARCH_MAGIC_WINCE
2169     case MIPS_ARCH_MAGIC_WINCE:
2170       arch = bfd_arch_mips;
2171       break;
2172 #endif
2173
2174 #ifdef H8500MAGIC
2175     case H8500MAGIC:
2176       arch = bfd_arch_h8500;
2177       break;
2178 #endif
2179
2180 #ifdef SPARCMAGIC
2181     case SPARCMAGIC:
2182 #ifdef LYNXCOFFMAGIC
2183     case LYNXCOFFMAGIC:
2184 #endif
2185       arch = bfd_arch_sparc;
2186       break;
2187 #endif
2188
2189 #ifdef TIC30MAGIC
2190     case TIC30MAGIC:
2191       arch = bfd_arch_tic30;
2192       break;
2193 #endif
2194
2195 #ifdef TICOFF0MAGIC
2196 #ifdef TICOFF_TARGET_ARCH
2197       /* This TI COFF section should be used by all new TI COFF v0 targets.  */
2198     case TICOFF0MAGIC:
2199       arch = TICOFF_TARGET_ARCH;
2200       machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2201       break;
2202 #endif
2203 #endif
2204
2205 #ifdef TICOFF1MAGIC
2206       /* This TI COFF section should be used by all new TI COFF v1/2 targets.  */
2207       /* TI COFF1 and COFF2 use the target_id field to specify which arch.  */
2208     case TICOFF1MAGIC:
2209     case TICOFF2MAGIC:
2210       switch (internal_f->f_target_id)
2211         {
2212 #ifdef TI_TARGET_ID
2213         case TI_TARGET_ID:
2214           arch = TICOFF_TARGET_ARCH;
2215           machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2216           break;
2217 #endif
2218         default:
2219           arch = bfd_arch_obscure;
2220           (*_bfd_error_handler)
2221             (_("Unrecognized TI COFF target id '0x%x'"),
2222              internal_f->f_target_id);
2223           break;
2224         }
2225       break;
2226 #endif
2227
2228 #ifdef TIC80_ARCH_MAGIC
2229     case TIC80_ARCH_MAGIC:
2230       arch = bfd_arch_tic80;
2231       break;
2232 #endif
2233
2234 #ifdef MCOREMAGIC
2235     case MCOREMAGIC:
2236       arch = bfd_arch_mcore;
2237       break;
2238 #endif
2239
2240 #ifdef W65MAGIC
2241     case W65MAGIC:
2242       arch = bfd_arch_w65;
2243       break;
2244 #endif
2245
2246     default:                    /* Unreadable input file type.  */
2247       arch = bfd_arch_obscure;
2248       break;
2249     }
2250
2251   bfd_default_set_arch_mach (abfd, arch, machine);
2252   return TRUE;
2253 }
2254
2255 #ifdef SYMNAME_IN_DEBUG
2256
2257 static bfd_boolean
2258 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym)
2259 {
2260   return SYMNAME_IN_DEBUG (sym) != 0;
2261 }
2262
2263 #else
2264
2265 #define symname_in_debug_hook \
2266   (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2267
2268 #endif
2269
2270 #ifdef RS6000COFF_C
2271
2272 #ifdef XCOFF64
2273 #define FORCE_SYMNAMES_IN_STRINGS
2274 #endif
2275
2276 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
2277
2278 static bfd_boolean
2279 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2280                           combined_entry_type *table_base,
2281                           combined_entry_type *symbol,
2282                           unsigned int indaux,
2283                           combined_entry_type *aux)
2284 {
2285   int class = symbol->u.syment.n_sclass;
2286
2287   if ((class == C_EXT || class == C_HIDEXT)
2288       && indaux + 1 == symbol->u.syment.n_numaux)
2289     {
2290       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2291         {
2292           aux->u.auxent.x_csect.x_scnlen.p =
2293             table_base + aux->u.auxent.x_csect.x_scnlen.l;
2294           aux->fix_scnlen = 1;
2295         }
2296
2297       /* Return TRUE to indicate that the caller should not do any
2298          further work on this auxent.  */
2299       return TRUE;
2300     }
2301
2302   /* Return FALSE to indicate that this auxent should be handled by
2303      the caller.  */
2304   return FALSE;
2305 }
2306
2307 #else
2308 #ifdef I960
2309
2310 /* We don't want to pointerize bal entries.  */
2311
2312 static bfd_boolean
2313 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2314                           combined_entry_type *table_base ATTRIBUTE_UNUSED,
2315                           combined_entry_type *symbol,
2316                           unsigned int indaux,
2317                           combined_entry_type *aux ATTRIBUTE_UNUSED)
2318 {
2319   /* Return TRUE if we don't want to pointerize this aux entry, which
2320      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
2321   return (indaux == 1
2322           && (symbol->u.syment.n_sclass == C_LEAFPROC
2323               || symbol->u.syment.n_sclass == C_LEAFSTAT
2324               || symbol->u.syment.n_sclass == C_LEAFEXT));
2325 }
2326
2327 #else /* ! I960 */
2328
2329 #define coff_pointerize_aux_hook 0
2330
2331 #endif /* ! I960 */
2332 #endif /* ! RS6000COFF_C */
2333
2334 /* Print an aux entry.  This returns TRUE if it has printed it.  */
2335
2336 static bfd_boolean
2337 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
2338                 FILE *file ATTRIBUTE_UNUSED,
2339                 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2340                 combined_entry_type *symbol ATTRIBUTE_UNUSED,
2341                 combined_entry_type *aux ATTRIBUTE_UNUSED,
2342                 unsigned int indaux ATTRIBUTE_UNUSED)
2343 {
2344 #ifdef RS6000COFF_C
2345   if ((symbol->u.syment.n_sclass == C_EXT
2346        || symbol->u.syment.n_sclass == C_HIDEXT)
2347       && indaux + 1 == symbol->u.syment.n_numaux)
2348     {
2349       /* This is a csect entry.  */
2350       fprintf (file, "AUX ");
2351       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2352         {
2353           BFD_ASSERT (! aux->fix_scnlen);
2354 #ifdef XCOFF64
2355           fprintf (file, "val %5lld",
2356                    (long long) aux->u.auxent.x_csect.x_scnlen.l);
2357 #else
2358           fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2359 #endif
2360         }
2361       else
2362         {
2363           fprintf (file, "indx ");
2364           if (! aux->fix_scnlen)
2365 #ifdef XCOFF64
2366             fprintf (file, "%4lld",
2367                      (long long) aux->u.auxent.x_csect.x_scnlen.l);
2368 #else
2369             fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2370 #endif
2371           else
2372             fprintf (file, "%4ld",
2373                      (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2374         }
2375       fprintf (file,
2376                " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2377                aux->u.auxent.x_csect.x_parmhash,
2378                (unsigned int) aux->u.auxent.x_csect.x_snhash,
2379                SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2380                SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2381                (unsigned int) aux->u.auxent.x_csect.x_smclas,
2382                aux->u.auxent.x_csect.x_stab,
2383                (unsigned int) aux->u.auxent.x_csect.x_snstab);
2384       return TRUE;
2385     }
2386 #endif
2387
2388   /* Return FALSE to indicate that no special action was taken.  */
2389   return FALSE;
2390 }
2391
2392 /*
2393 SUBSUBSECTION
2394         Writing relocations
2395
2396         To write relocations, the back end steps though the
2397         canonical relocation table and create an
2398         @code{internal_reloc}. The symbol index to use is removed from
2399         the @code{offset} field in the symbol table supplied.  The
2400         address comes directly from the sum of the section base
2401         address and the relocation offset; the type is dug directly
2402         from the howto field.  Then the @code{internal_reloc} is
2403         swapped into the shape of an @code{external_reloc} and written
2404         out to disk.
2405
2406 */
2407
2408 #ifdef TARG_AUX
2409
2410
2411 /* AUX's ld wants relocations to be sorted.  */
2412 static int
2413 compare_arelent_ptr (const void * x, const void * y)
2414 {
2415   const arelent **a = (const arelent **) x;
2416   const arelent **b = (const arelent **) y;
2417   bfd_size_type aadr = (*a)->address;
2418   bfd_size_type badr = (*b)->address;
2419
2420   return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2421 }
2422
2423 #endif /* TARG_AUX */
2424
2425 static bfd_boolean
2426 coff_write_relocs (bfd * abfd, int first_undef)
2427 {
2428   asection *s;
2429
2430   for (s = abfd->sections; s != NULL; s = s->next)
2431     {
2432       unsigned int i;
2433       struct external_reloc dst;
2434       arelent **p;
2435
2436 #ifndef TARG_AUX
2437       p = s->orelocation;
2438 #else
2439       {
2440         /* Sort relocations before we write them out.  */
2441         bfd_size_type amt;
2442
2443         amt = s->reloc_count;
2444         amt *= sizeof (arelent *);
2445         p = bfd_malloc (amt);
2446         if (p == NULL && s->reloc_count > 0)
2447           return FALSE;
2448         memcpy (p, s->orelocation, (size_t) amt);
2449         qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2450       }
2451 #endif
2452
2453       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2454         return FALSE;
2455
2456 #ifdef COFF_WITH_PE
2457       if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2458         {
2459           /* Encode real count here as first reloc.  */
2460           struct internal_reloc n;
2461
2462           memset (& n, 0, sizeof (n));
2463           /* Add one to count *this* reloc (grr).  */
2464           n.r_vaddr = s->reloc_count + 1;
2465           coff_swap_reloc_out (abfd, &n, &dst);
2466           if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2467                           abfd) != bfd_coff_relsz (abfd))
2468             return FALSE;
2469         }
2470 #endif
2471
2472       for (i = 0; i < s->reloc_count; i++)
2473         {
2474           struct internal_reloc n;
2475           arelent *q = p[i];
2476
2477           memset (& n, 0, sizeof (n));
2478
2479           /* Now we've renumbered the symbols we know where the
2480              undefined symbols live in the table.  Check the reloc
2481              entries for symbols who's output bfd isn't the right one.
2482              This is because the symbol was undefined (which means
2483              that all the pointers are never made to point to the same
2484              place). This is a bad thing,'cause the symbols attached
2485              to the output bfd are indexed, so that the relocation
2486              entries know which symbol index they point to.  So we
2487              have to look up the output symbol here.  */
2488
2489           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2490             {
2491               int j;
2492               const char *sname = q->sym_ptr_ptr[0]->name;
2493               asymbol **outsyms = abfd->outsymbols;
2494
2495               for (j = first_undef; outsyms[j]; j++)
2496                 {
2497                   const char *intable = outsyms[j]->name;
2498
2499                   if (strcmp (intable, sname) == 0)
2500                     {
2501                       /* Got a hit, so repoint the reloc.  */
2502                       q->sym_ptr_ptr = outsyms + j;
2503                       break;
2504                     }
2505                 }
2506             }
2507
2508           n.r_vaddr = q->address + s->vma;
2509
2510 #ifdef R_IHCONST
2511           /* The 29k const/consth reloc pair is a real kludge.  The consth
2512              part doesn't have a symbol; it has an offset.  So rebuilt
2513              that here.  */
2514           if (q->howto->type == R_IHCONST)
2515             n.r_symndx = q->addend;
2516           else
2517 #endif
2518             if (q->sym_ptr_ptr)
2519               {
2520 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2521                 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
2522 #else
2523                 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2524                     && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2525 #endif
2526                   /* This is a relocation relative to the absolute symbol.  */
2527                   n.r_symndx = -1;
2528                 else
2529                   {
2530                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2531                     /* Take notice if the symbol reloc points to a symbol
2532                        we don't have in our symbol table.  What should we
2533                        do for this??  */
2534                     if (n.r_symndx > obj_conv_table_size (abfd))
2535                       abort ();
2536                   }
2537               }
2538
2539 #ifdef SWAP_OUT_RELOC_OFFSET
2540           n.r_offset = q->addend;
2541 #endif
2542
2543 #ifdef SELECT_RELOC
2544           /* Work out reloc type from what is required.  */
2545           SELECT_RELOC (n, q->howto);
2546 #else
2547           n.r_type = q->howto->type;
2548 #endif
2549           coff_swap_reloc_out (abfd, &n, &dst);
2550
2551           if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2552                          abfd) != bfd_coff_relsz (abfd))
2553             return FALSE;
2554         }
2555
2556 #ifdef TARG_AUX
2557       if (p != NULL)
2558         free (p);
2559 #endif
2560     }
2561
2562   return TRUE;
2563 }
2564
2565 /* Set flags and magic number of a coff file from architecture and machine
2566    type.  Result is TRUE if we can represent the arch&type, FALSE if not.  */
2567
2568 static bfd_boolean
2569 coff_set_flags (bfd * abfd,
2570                 unsigned int *magicp ATTRIBUTE_UNUSED,
2571                 unsigned short *flagsp ATTRIBUTE_UNUSED)
2572 {
2573   switch (bfd_get_arch (abfd))
2574     {
2575 #ifdef Z80MAGIC
2576     case bfd_arch_z80:
2577       *magicp = Z80MAGIC;
2578       switch (bfd_get_mach (abfd))
2579         {
2580         case 0:
2581         case bfd_mach_z80strict:
2582         case bfd_mach_z80:
2583         case bfd_mach_z80full:
2584         case bfd_mach_r800:
2585           *flagsp = bfd_get_mach (abfd) << 12;
2586           break;
2587         default:
2588           return FALSE;
2589         }
2590       return TRUE;
2591 #endif
2592
2593 #ifdef Z8KMAGIC
2594     case bfd_arch_z8k:
2595       *magicp = Z8KMAGIC;
2596
2597       switch (bfd_get_mach (abfd))
2598         {
2599         case bfd_mach_z8001: *flagsp = F_Z8001; break;
2600         case bfd_mach_z8002: *flagsp = F_Z8002; break;
2601         default:             return FALSE;
2602         }
2603       return TRUE;
2604 #endif
2605
2606 #ifdef I960ROMAGIC
2607     case bfd_arch_i960:
2608
2609       {
2610         unsigned flags;
2611
2612         *magicp = I960ROMAGIC;
2613
2614         switch (bfd_get_mach (abfd))
2615           {
2616           case bfd_mach_i960_core:  flags = F_I960CORE; break;
2617           case bfd_mach_i960_kb_sb: flags = F_I960KB;   break;
2618           case bfd_mach_i960_mc:    flags = F_I960MC;   break;
2619           case bfd_mach_i960_xa:    flags = F_I960XA;   break;
2620           case bfd_mach_i960_ca:    flags = F_I960CA;   break;
2621           case bfd_mach_i960_ka_sa: flags = F_I960KA;   break;
2622           case bfd_mach_i960_jx:    flags = F_I960JX;   break;
2623           case bfd_mach_i960_hx:    flags = F_I960HX;   break;
2624           default:                  return FALSE;
2625           }
2626         *flagsp = flags;
2627         return TRUE;
2628       }
2629       break;
2630 #endif
2631
2632 #ifdef TIC30MAGIC
2633     case bfd_arch_tic30:
2634       *magicp = TIC30MAGIC;
2635       return TRUE;
2636 #endif
2637
2638 #ifdef TICOFF_DEFAULT_MAGIC
2639     case TICOFF_TARGET_ARCH:
2640       /* If there's no indication of which version we want, use the default.  */
2641       if (!abfd->xvec )
2642         *magicp = TICOFF_DEFAULT_MAGIC;
2643       else
2644         {
2645           /* We may want to output in a different COFF version.  */
2646           switch (abfd->xvec->name[4])
2647             {
2648             case '0':
2649               *magicp = TICOFF0MAGIC;
2650               break;
2651             case '1':
2652               *magicp = TICOFF1MAGIC;
2653               break;
2654             case '2':
2655               *magicp = TICOFF2MAGIC;
2656               break;
2657             default:
2658               return FALSE;
2659             }
2660         }
2661       TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2662       return TRUE;
2663 #endif
2664
2665 #ifdef TIC80_ARCH_MAGIC
2666     case bfd_arch_tic80:
2667       *magicp = TIC80_ARCH_MAGIC;
2668       return TRUE;
2669 #endif
2670
2671 #ifdef ARMMAGIC
2672     case bfd_arch_arm:
2673 #ifdef ARM_WINCE
2674       * magicp = ARMPEMAGIC;
2675 #else
2676       * magicp = ARMMAGIC;
2677 #endif
2678       * flagsp = 0;
2679       if (APCS_SET (abfd))
2680         {
2681           if (APCS_26_FLAG (abfd))
2682             * flagsp |= F_APCS26;
2683
2684           if (APCS_FLOAT_FLAG (abfd))
2685             * flagsp |= F_APCS_FLOAT;
2686
2687           if (PIC_FLAG (abfd))
2688             * flagsp |= F_PIC;
2689         }
2690       if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2691         * flagsp |= F_INTERWORK;
2692       switch (bfd_get_mach (abfd))
2693         {
2694         case bfd_mach_arm_2:  * flagsp |= F_ARM_2;  break;
2695         case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2696         case bfd_mach_arm_3:  * flagsp |= F_ARM_3;  break;
2697         case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2698         case bfd_mach_arm_4:  * flagsp |= F_ARM_4;  break;
2699         case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2700         case bfd_mach_arm_5:  * flagsp |= F_ARM_5;  break;
2701           /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2702              See also the comment in coff_set_arch_mach_hook().  */
2703         case bfd_mach_arm_5T: * flagsp |= F_ARM_5;  break;
2704         case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2705         case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2706         }
2707       return TRUE;
2708 #endif
2709
2710 #ifdef PPCMAGIC
2711     case bfd_arch_powerpc:
2712       *magicp = PPCMAGIC;
2713       return TRUE;
2714 #endif
2715
2716 #ifdef I386MAGIC
2717     case bfd_arch_i386:
2718       *magicp = I386MAGIC;
2719 #ifdef LYNXOS
2720       /* Just overwrite the usual value if we're doing Lynx.  */
2721       *magicp = LYNXCOFFMAGIC;
2722 #endif
2723       return TRUE;
2724 #endif
2725
2726 #ifdef I860MAGIC
2727     case bfd_arch_i860:
2728       *magicp = I860MAGIC;
2729       return TRUE;
2730 #endif
2731
2732 #ifdef IA64MAGIC
2733     case bfd_arch_ia64:
2734       *magicp = IA64MAGIC;
2735       return TRUE;
2736 #endif
2737
2738 #ifdef MC68MAGIC
2739     case bfd_arch_m68k:
2740 #ifdef APOLLOM68KMAGIC
2741       *magicp = APOLLO_COFF_VERSION_NUMBER;
2742 #else
2743       /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c.  */
2744 #ifdef NAMES_HAVE_UNDERSCORE
2745       *magicp = MC68KBCSMAGIC;
2746 #else
2747       *magicp = MC68MAGIC;
2748 #endif
2749 #endif
2750 #ifdef LYNXOS
2751       /* Just overwrite the usual value if we're doing Lynx.  */
2752       *magicp = LYNXCOFFMAGIC;
2753 #endif
2754       return TRUE;
2755 #endif
2756
2757 #ifdef MC88MAGIC
2758     case bfd_arch_m88k:
2759       *magicp = MC88OMAGIC;
2760       return TRUE;
2761 #endif
2762
2763 #ifdef H8300MAGIC
2764     case bfd_arch_h8300:
2765       switch (bfd_get_mach (abfd))
2766         {
2767         case bfd_mach_h8300:   *magicp = H8300MAGIC;   return TRUE;
2768         case bfd_mach_h8300h:  *magicp = H8300HMAGIC;  return TRUE;
2769         case bfd_mach_h8300s:  *magicp = H8300SMAGIC;  return TRUE;
2770         case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE;
2771         case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE;
2772         default: break;
2773         }
2774       break;
2775 #endif
2776
2777 #ifdef SH_ARCH_MAGIC_BIG
2778     case bfd_arch_sh:
2779 #ifdef COFF_IMAGE_WITH_PE
2780       *magicp = SH_ARCH_MAGIC_WINCE;
2781 #else
2782       if (bfd_big_endian (abfd))
2783         *magicp = SH_ARCH_MAGIC_BIG;
2784       else
2785         *magicp = SH_ARCH_MAGIC_LITTLE;
2786 #endif
2787       return TRUE;
2788 #endif
2789
2790 #ifdef MIPS_ARCH_MAGIC_WINCE
2791     case bfd_arch_mips:
2792       *magicp = MIPS_ARCH_MAGIC_WINCE;
2793       return TRUE;
2794 #endif
2795
2796 #ifdef SPARCMAGIC
2797     case bfd_arch_sparc:
2798       *magicp = SPARCMAGIC;
2799 #ifdef LYNXOS
2800       /* Just overwrite the usual value if we're doing Lynx.  */
2801       *magicp = LYNXCOFFMAGIC;
2802 #endif
2803       return TRUE;
2804 #endif
2805
2806 #ifdef H8500MAGIC
2807     case bfd_arch_h8500:
2808       *magicp = H8500MAGIC;
2809       return TRUE;
2810       break;
2811 #endif
2812
2813 #ifdef WE32KMAGIC
2814     case bfd_arch_we32k:
2815       *magicp = WE32KMAGIC;
2816       return TRUE;
2817 #endif
2818
2819 #ifdef RS6000COFF_C
2820     case bfd_arch_rs6000:
2821 #ifndef PPCMAGIC
2822     case bfd_arch_powerpc:
2823 #endif
2824       BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2825       *magicp = bfd_xcoff_magic_number (abfd);
2826       return TRUE;
2827 #endif
2828
2829 #ifdef MCOREMAGIC
2830     case bfd_arch_mcore:
2831       * magicp = MCOREMAGIC;
2832       return TRUE;
2833 #endif
2834
2835 #ifdef W65MAGIC
2836     case bfd_arch_w65:
2837       *magicp = W65MAGIC;
2838       return TRUE;
2839 #endif
2840
2841 #ifdef OR32_MAGIC_BIG
2842     case bfd_arch_or32:
2843       if (bfd_big_endian (abfd))
2844         * magicp = OR32_MAGIC_BIG;
2845       else
2846         * magicp = OR32_MAGIC_LITTLE;
2847       return TRUE;
2848 #endif
2849
2850 #ifdef MAXQ20MAGIC
2851     case bfd_arch_maxq:
2852       * magicp = MAXQ20MAGIC;
2853       switch (bfd_get_mach (abfd))
2854         {
2855         case bfd_mach_maxq10: * flagsp = F_MAXQ10; return TRUE;
2856         case bfd_mach_maxq20: * flagsp = F_MAXQ20; return TRUE;
2857         default:              return FALSE;
2858         }
2859 #endif
2860
2861     default:                    /* Unknown architecture.  */
2862       /* Fall through to "return FALSE" below, to avoid
2863          "statement never reached" errors on the one below.  */
2864       break;
2865     }
2866
2867   return FALSE;
2868 }
2869
2870 static bfd_boolean
2871 coff_set_arch_mach (bfd * abfd,
2872                     enum bfd_architecture arch,
2873                     unsigned long machine)
2874 {
2875   unsigned dummy1;
2876   unsigned short dummy2;
2877
2878   if (! bfd_default_set_arch_mach (abfd, arch, machine))
2879     return FALSE;
2880
2881   if (arch != bfd_arch_unknown
2882       && ! coff_set_flags (abfd, &dummy1, &dummy2))
2883     return FALSE;               /* We can't represent this type.  */
2884
2885   return TRUE;                  /* We're easy...  */
2886 }
2887
2888 #ifdef COFF_IMAGE_WITH_PE
2889
2890 /* This is used to sort sections by VMA, as required by PE image
2891    files.  */
2892
2893 static int
2894 sort_by_secaddr (const void * arg1, const void * arg2)
2895 {
2896   const asection *a = *(const asection **) arg1;
2897   const asection *b = *(const asection **) arg2;
2898
2899   if (a->vma < b->vma)
2900     return -1;
2901   else if (a->vma > b->vma)
2902     return 1;
2903
2904   return 0;
2905 }
2906
2907 #endif /* COFF_IMAGE_WITH_PE */
2908
2909 /* Calculate the file position for each section.  */
2910
2911 #ifndef I960
2912 #define ALIGN_SECTIONS_IN_FILE
2913 #endif
2914 #if defined(TIC80COFF) || defined(TICOFF)
2915 #undef ALIGN_SECTIONS_IN_FILE
2916 #endif
2917
2918 static bfd_boolean
2919 coff_compute_section_file_positions (bfd * abfd)
2920 {
2921   asection *current;
2922   asection *previous = NULL;
2923   file_ptr sofar = bfd_coff_filhsz (abfd);
2924   bfd_boolean align_adjust;
2925 #ifdef ALIGN_SECTIONS_IN_FILE
2926   file_ptr old_sofar;
2927 #endif
2928
2929 #ifdef RS6000COFF_C
2930   /* On XCOFF, if we have symbols, set up the .debug section.  */
2931   if (bfd_get_symcount (abfd) > 0)
2932     {
2933       bfd_size_type sz;
2934       bfd_size_type i, symcount;
2935       asymbol **symp;
2936
2937       sz = 0;
2938       symcount = bfd_get_symcount (abfd);
2939       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2940         {
2941           coff_symbol_type *cf;
2942
2943           cf = coff_symbol_from (abfd, *symp);
2944           if (cf != NULL
2945               && cf->native != NULL
2946               && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2947             {
2948               size_t len;
2949
2950               len = strlen (bfd_asymbol_name (*symp));
2951               if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2952                 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
2953             }
2954         }
2955       if (sz > 0)
2956         {
2957           asection *dsec;
2958
2959           dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
2960           if (dsec == NULL)
2961             abort ();
2962           dsec->size = sz;
2963           dsec->flags |= SEC_HAS_CONTENTS;
2964         }
2965     }
2966 #endif
2967
2968 #ifdef COFF_IMAGE_WITH_PE
2969   int page_size;
2970
2971   if (coff_data (abfd)->link_info)
2972     {
2973       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2974
2975       /* If no file alignment has been set, default to one.
2976          This repairs 'ld -r' for arm-wince-pe target.  */
2977       if (page_size == 0)
2978         page_size = 1;
2979     }
2980   else
2981     page_size = PE_DEF_FILE_ALIGNMENT;
2982 #else
2983 #ifdef COFF_PAGE_SIZE
2984   int page_size = COFF_PAGE_SIZE;
2985 #endif
2986 #endif
2987
2988   if (bfd_get_start_address (abfd))
2989     /*  A start address may have been added to the original file. In this
2990         case it will need an optional header to record it.  */
2991     abfd->flags |= EXEC_P;
2992
2993   if (abfd->flags & EXEC_P)
2994     sofar += bfd_coff_aoutsz (abfd);
2995 #ifdef RS6000COFF_C
2996   else if (xcoff_data (abfd)->full_aouthdr)
2997     sofar += bfd_coff_aoutsz (abfd);
2998   else
2999     sofar += SMALL_AOUTSZ;
3000 #endif
3001
3002   sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3003
3004 #ifdef RS6000COFF_C
3005   /* XCOFF handles overflows in the reloc and line number count fields
3006      by allocating a new section header to hold the correct counts.  */
3007   for (current = abfd->sections; current != NULL; current = current->next)
3008     if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3009       sofar += bfd_coff_scnhsz (abfd);
3010 #endif
3011
3012 #ifdef COFF_IMAGE_WITH_PE
3013   {
3014     /* PE requires the sections to be in memory order when listed in
3015        the section headers.  It also does not like empty loadable
3016        sections.  The sections apparently do not have to be in the
3017        right order in the image file itself, but we do need to get the
3018        target_index values right.  */
3019
3020     unsigned int count;
3021     asection **section_list;
3022     unsigned int i;
3023     int target_index;
3024     bfd_size_type amt;
3025
3026     count = 0;
3027     for (current = abfd->sections; current != NULL; current = current->next)
3028       ++count;
3029
3030     /* We allocate an extra cell to simplify the final loop.  */
3031     amt = sizeof (struct asection *) * (count + 1);
3032     section_list = bfd_malloc (amt);
3033     if (section_list == NULL)
3034       return FALSE;
3035
3036     i = 0;
3037     for (current = abfd->sections; current != NULL; current = current->next)
3038       {
3039         section_list[i] = current;
3040         ++i;
3041       }
3042     section_list[i] = NULL;
3043
3044     qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3045
3046     /* Rethread the linked list into sorted order; at the same time,
3047        assign target_index values.  */
3048     target_index = 1;
3049     abfd->sections = NULL;
3050     abfd->section_last = NULL;
3051     for (i = 0; i < count; i++)
3052       {
3053         current = section_list[i];
3054         bfd_section_list_append (abfd, current);
3055
3056         /* Later, if the section has zero size, we'll be throwing it
3057            away, so we don't want to number it now.  Note that having
3058            a zero size and having real contents are different
3059            concepts: .bss has no contents, but (usually) non-zero
3060            size.  */
3061         if (current->size == 0)
3062           {
3063             /* Discard.  However, it still might have (valid) symbols
3064                in it, so arbitrarily set it to section 1 (indexing is
3065                1-based here; usually .text).  __end__ and other
3066                contents of .endsection really have this happen.
3067                FIXME: This seems somewhat dubious.  */
3068             current->target_index = 1;
3069           }
3070         else
3071           current->target_index = target_index++;
3072       }
3073
3074     free (section_list);
3075   }
3076 #else /* ! COFF_IMAGE_WITH_PE */
3077   {
3078     /* Set the target_index field.  */
3079     int target_index;
3080
3081     target_index = 1;
3082     for (current = abfd->sections; current != NULL; current = current->next)
3083       current->target_index = target_index++;
3084   }
3085 #endif /* ! COFF_IMAGE_WITH_PE */
3086
3087   align_adjust = FALSE;
3088   for (current = abfd->sections;
3089        current != NULL;
3090        current = current->next)
3091     {
3092 #ifdef COFF_IMAGE_WITH_PE
3093       /* With PE we have to pad each section to be a multiple of its
3094          page size too, and remember both sizes.  */
3095       if (coff_section_data (abfd, current) == NULL)
3096         {
3097           bfd_size_type amt = sizeof (struct coff_section_tdata);
3098
3099           current->used_by_bfd = bfd_zalloc (abfd, amt);
3100           if (current->used_by_bfd == NULL)
3101             return FALSE;
3102         }
3103       if (pei_section_data (abfd, current) == NULL)
3104         {
3105           bfd_size_type amt = sizeof (struct pei_section_tdata);
3106
3107           coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
3108           if (coff_section_data (abfd, current)->tdata == NULL)
3109             return FALSE;
3110         }
3111       if (pei_section_data (abfd, current)->virt_size == 0)
3112         pei_section_data (abfd, current)->virt_size = current->size;
3113 #endif
3114
3115       /* Only deal with sections which have contents.  */
3116       if (!(current->flags & SEC_HAS_CONTENTS))
3117         continue;
3118
3119 #ifdef COFF_IMAGE_WITH_PE
3120       /* Make sure we skip empty sections in a PE image.  */
3121       if (current->size == 0)
3122         continue;
3123 #endif
3124
3125       /* Align the sections in the file to the same boundary on
3126          which they are aligned in virtual memory.  I960 doesn't
3127          do this (FIXME) so we can stay in sync with Intel.  960
3128          doesn't yet page from files...  */
3129 #ifdef ALIGN_SECTIONS_IN_FILE
3130       if ((abfd->flags & EXEC_P) != 0)
3131         {
3132           /* Make sure this section is aligned on the right boundary - by
3133              padding the previous section up if necessary.  */
3134           old_sofar = sofar;
3135
3136 #ifdef RS6000COFF_C
3137           /* AIX loader checks the text section alignment of (vma - filepos)
3138              So even though the filepos may be aligned wrt the o_algntext, for
3139              AIX executables, this check fails. This shows up when a native
3140              AIX executable is stripped with gnu strip because the default vma
3141              of native is 0x10000150 but default for gnu is 0x10000140.  Gnu
3142              stripped gnu excutable passes this check because the filepos is
3143              0x0140.  This problem also show up with 64 bit shared objects. The
3144              data section must also be aligned.  */
3145           if (!strcmp (current->name, _TEXT)
3146               || !strcmp (current->name, _DATA))
3147             {
3148               bfd_vma pad;
3149               bfd_vma align;
3150
3151               sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3152
3153               align = 1 << current->alignment_power;
3154               pad = abs (current->vma - sofar) % align;
3155
3156               if (pad)
3157                 {
3158                   pad = align - pad;
3159                   sofar += pad;
3160                 }
3161             }
3162           else
3163 #else
3164             {
3165               sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3166             }
3167 #endif
3168           if (previous != NULL)
3169             previous->size += sofar - old_sofar;
3170         }
3171
3172 #endif
3173
3174       /* In demand paged files the low order bits of the file offset
3175          must match the low order bits of the virtual address.  */
3176 #ifdef COFF_PAGE_SIZE
3177       if ((abfd->flags & D_PAGED) != 0
3178           && (current->flags & SEC_ALLOC) != 0)
3179         sofar += (current->vma - (bfd_vma) sofar) % page_size;
3180 #endif
3181       current->filepos = sofar;
3182
3183 #ifdef COFF_IMAGE_WITH_PE
3184       /* Set the padded size.  */
3185       current->size = (current->size + page_size -1) & -page_size;
3186 #endif
3187
3188       sofar += current->size;
3189
3190 #ifdef ALIGN_SECTIONS_IN_FILE
3191       /* Make sure that this section is of the right size too.  */
3192       if ((abfd->flags & EXEC_P) == 0)
3193         {
3194           bfd_size_type old_size;
3195
3196           old_size = current->size;
3197           current->size = BFD_ALIGN (current->size,
3198                                      1 << current->alignment_power);
3199           align_adjust = current->size != old_size;
3200           sofar += current->size - old_size;
3201         }
3202       else
3203         {
3204           old_sofar = sofar;
3205           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3206           align_adjust = sofar != old_sofar;
3207           current->size += sofar - old_sofar;
3208         }
3209 #endif
3210
3211 #ifdef COFF_IMAGE_WITH_PE
3212       /* For PE we need to make sure we pad out to the aligned
3213          size, in case the caller only writes out data to the
3214          unaligned size.  */
3215       if (pei_section_data (abfd, current)->virt_size < current->size)
3216         align_adjust = TRUE;
3217 #endif
3218
3219 #ifdef _LIB
3220       /* Force .lib sections to start at zero.  The vma is then
3221          incremented in coff_set_section_contents.  This is right for
3222          SVR3.2.  */
3223       if (strcmp (current->name, _LIB) == 0)
3224         bfd_set_section_vma (abfd, current, 0);
3225 #endif
3226
3227       previous = current;
3228     }
3229
3230   /* It is now safe to write to the output file.  If we needed an
3231      alignment adjustment for the last section, then make sure that
3232      there is a byte at offset sofar.  If there are no symbols and no
3233      relocs, then nothing follows the last section.  If we don't force
3234      the last byte out, then the file may appear to be truncated.  */
3235   if (align_adjust)
3236     {
3237       bfd_byte b;
3238
3239       b = 0;
3240       if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3241           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3242         return FALSE;
3243     }
3244
3245   /* Make sure the relocations are aligned.  We don't need to make
3246      sure that this byte exists, because it will only matter if there
3247      really are relocs.  */
3248   sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3249
3250   obj_relocbase (abfd) = sofar;
3251   abfd->output_has_begun = TRUE;
3252
3253   return TRUE;
3254 }
3255
3256 #ifdef COFF_IMAGE_WITH_PE
3257
3258 static unsigned int pelength;
3259 static unsigned int peheader;
3260
3261 static bfd_boolean
3262 coff_read_word (bfd *abfd, unsigned int *value)
3263 {
3264   unsigned char b[2];
3265   int status;
3266
3267   status = bfd_bread (b, (bfd_size_type) 2, abfd);
3268   if (status < 1)
3269     {
3270       *value = 0;
3271       return FALSE;
3272     }
3273
3274   if (status == 1)
3275     *value = (unsigned int) b[0];
3276   else
3277     *value = (unsigned int) (b[0] + (b[1] << 8));
3278
3279   pelength += (unsigned int) status;
3280
3281   return TRUE;
3282 }
3283
3284 static unsigned int
3285 coff_compute_checksum (bfd *abfd)
3286 {
3287   bfd_boolean more_data;
3288   file_ptr filepos;
3289   unsigned int value;
3290   unsigned int total;
3291
3292   total = 0;
3293   pelength = 0;
3294   filepos = (file_ptr) 0;
3295
3296   do
3297     {
3298       if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3299         return 0;
3300
3301       more_data = coff_read_word (abfd, &value);
3302       total += value;
3303       total = 0xffff & (total + (total >> 0x10));
3304       filepos += 2;
3305     }
3306   while (more_data);
3307
3308   return (0xffff & (total + (total >> 0x10)));
3309 }
3310
3311 static bfd_boolean
3312 coff_apply_checksum (bfd *abfd)
3313 {
3314   unsigned int computed;
3315   unsigned int checksum = 0;
3316
3317   if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3318     return FALSE;
3319
3320   if (!coff_read_word (abfd, &peheader))
3321     return FALSE;
3322
3323   if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3324     return FALSE;
3325
3326   checksum = 0;
3327   bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3328
3329   if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3330     return FALSE;
3331
3332   computed = coff_compute_checksum (abfd);
3333
3334   checksum = computed + pelength;
3335
3336   if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3337     return FALSE;
3338
3339   bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3340
3341   return TRUE;
3342 }
3343
3344 #endif /* COFF_IMAGE_WITH_PE */
3345
3346 static bfd_boolean
3347 coff_write_object_contents (bfd * abfd)
3348 {
3349   asection *current;
3350   bfd_boolean hasrelocs = FALSE;
3351   bfd_boolean haslinno = FALSE;
3352   bfd_boolean hasdebug = FALSE;
3353   file_ptr scn_base;
3354   file_ptr reloc_base;
3355   file_ptr lineno_base;
3356   file_ptr sym_base;
3357   unsigned long reloc_size = 0, reloc_count = 0;
3358   unsigned long lnno_size = 0;
3359   bfd_boolean long_section_names;
3360   asection *text_sec = NULL;
3361   asection *data_sec = NULL;
3362   asection *bss_sec = NULL;
3363   struct internal_filehdr internal_f;
3364   struct internal_aouthdr internal_a;
3365 #ifdef COFF_LONG_SECTION_NAMES
3366   size_t string_size = STRING_SIZE_SIZE;
3367 #endif
3368
3369   bfd_set_error (bfd_error_system_call);
3370
3371   /* Make a pass through the symbol table to count line number entries and
3372      put them into the correct asections.  */
3373   lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3374
3375   if (! abfd->output_has_begun)
3376     {
3377       if (! coff_compute_section_file_positions (abfd))
3378         return FALSE;
3379     }
3380
3381   reloc_base = obj_relocbase (abfd);
3382
3383   /* Work out the size of the reloc and linno areas.  */
3384
3385   for (current = abfd->sections; current != NULL; current =
3386        current->next)
3387     {
3388 #ifdef COFF_WITH_PE
3389       /* We store the actual reloc count in the first reloc's addr.  */
3390       if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3391         reloc_count ++;
3392 #endif
3393       reloc_count += current->reloc_count;
3394     }
3395
3396   reloc_size = reloc_count * bfd_coff_relsz (abfd);
3397
3398   lineno_base = reloc_base + reloc_size;
3399   sym_base = lineno_base + lnno_size;
3400
3401   /* Indicate in each section->line_filepos its actual file address.  */
3402   for (current = abfd->sections; current != NULL; current =
3403        current->next)
3404     {
3405       if (current->lineno_count)
3406         {
3407           current->line_filepos = lineno_base;
3408           current->moving_line_filepos = lineno_base;
3409           lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3410         }
3411       else
3412         current->line_filepos = 0;
3413
3414       if (current->reloc_count)
3415         {
3416           current->rel_filepos = reloc_base;
3417           reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3418 #ifdef COFF_WITH_PE
3419           /* Extra reloc to hold real count.  */
3420           if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3421             reloc_base += bfd_coff_relsz (abfd);
3422 #endif
3423         }
3424       else
3425         current->rel_filepos = 0;
3426     }
3427
3428   /* Write section headers to the file.  */
3429   internal_f.f_nscns = 0;
3430
3431   if ((abfd->flags & EXEC_P) != 0)
3432     scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3433   else
3434     {
3435       scn_base = bfd_coff_filhsz (abfd);
3436 #ifdef RS6000COFF_C
3437 #ifndef XCOFF64
3438       if (xcoff_data (abfd)->full_aouthdr)
3439         scn_base += bfd_coff_aoutsz (abfd);
3440       else
3441         scn_base += SMALL_AOUTSZ;
3442 #endif
3443 #endif
3444     }
3445
3446   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3447     return FALSE;
3448
3449   long_section_names = FALSE;
3450   for (current = abfd->sections;
3451        current != NULL;
3452        current = current->next)
3453     {
3454       struct internal_scnhdr section;
3455       bfd_boolean is_reloc_section = FALSE;
3456
3457 #ifdef COFF_IMAGE_WITH_PE
3458       if (strcmp (current->name, ".reloc") == 0)
3459         {
3460           is_reloc_section = TRUE;
3461           hasrelocs = TRUE;
3462           pe_data (abfd)->has_reloc_section = 1;
3463         }
3464 #endif
3465
3466       internal_f.f_nscns++;
3467
3468       strncpy (section.s_name, current->name, SCNNMLEN);
3469
3470 #ifdef COFF_LONG_SECTION_NAMES
3471       /* Handle long section names as in PE.  This must be compatible
3472          with the code in coff_write_symbols and _bfd_coff_final_link.  */
3473       {
3474         size_t len;
3475
3476         len = strlen (current->name);
3477         if (len > SCNNMLEN)
3478           {
3479             memset (section.s_name, 0, SCNNMLEN);
3480             sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3481             string_size += len + 1;
3482             long_section_names = TRUE;
3483           }
3484       }
3485 #endif
3486
3487 #ifdef _LIB
3488       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
3489          Ian Taylor <ian@cygnus.com>.  */
3490       if (strcmp (current->name, _LIB) == 0)
3491         section.s_vaddr = 0;
3492       else
3493 #endif
3494       section.s_vaddr = current->vma;
3495       section.s_paddr = current->lma;
3496       section.s_size =  current->size;
3497 #ifdef coff_get_section_load_page
3498       section.s_page = coff_get_section_load_page (current);
3499 #endif
3500
3501 #ifdef COFF_WITH_PE
3502       section.s_paddr = 0;
3503 #endif
3504 #ifdef COFF_IMAGE_WITH_PE
3505       /* Reminder: s_paddr holds the virtual size of the section.  */
3506       if (coff_section_data (abfd, current) != NULL
3507           && pei_section_data (abfd, current) != NULL)
3508         section.s_paddr = pei_section_data (abfd, current)->virt_size;
3509       else
3510         section.s_paddr = 0;
3511 #endif
3512
3513       /* If this section has no size or is unloadable then the scnptr
3514          will be 0 too.  */
3515       if (current->size == 0
3516           || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3517         section.s_scnptr = 0;
3518       else
3519         section.s_scnptr = current->filepos;
3520
3521       section.s_relptr = current->rel_filepos;
3522       section.s_lnnoptr = current->line_filepos;
3523       section.s_nreloc = current->reloc_count;
3524       section.s_nlnno = current->lineno_count;
3525 #ifndef COFF_IMAGE_WITH_PE
3526       /* In PEI, relocs come in the .reloc section.  */
3527       if (current->reloc_count != 0)
3528         hasrelocs = TRUE;
3529 #endif
3530       if (current->lineno_count != 0)
3531         haslinno = TRUE;
3532       if ((current->flags & SEC_DEBUGGING) != 0
3533           && ! is_reloc_section)
3534         hasdebug = TRUE;
3535
3536 #ifdef RS6000COFF_C
3537 #ifndef XCOFF64
3538       /* Indicate the use of an XCOFF overflow section header.  */
3539       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3540         {
3541           section.s_nreloc = 0xffff;
3542           section.s_nlnno = 0xffff;
3543         }
3544 #endif
3545 #endif
3546
3547       section.s_flags = sec_to_styp_flags (current->name, current->flags);
3548
3549       if (!strcmp (current->name, _TEXT))
3550         text_sec = current;
3551       else if (!strcmp (current->name, _DATA))
3552         data_sec = current;
3553       else if (!strcmp (current->name, _BSS))
3554         bss_sec = current;
3555
3556 #ifdef I960
3557       section.s_align = (current->alignment_power
3558                          ? 1 << current->alignment_power
3559                          : 0);
3560 #endif
3561 #ifdef TIC80COFF
3562       /* TI COFF puts the alignment power in bits 8-11 of the flags.  */
3563       section.s_flags |= (current->alignment_power & 0xF) << 8;
3564 #endif
3565 #ifdef COFF_ENCODE_ALIGNMENT
3566       COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3567 #endif
3568
3569 #ifdef COFF_IMAGE_WITH_PE
3570       /* Suppress output of the sections if they are null.  ld
3571          includes the bss and data sections even if there is no size
3572          assigned to them.  NT loader doesn't like it if these section
3573          headers are included if the sections themselves are not
3574          needed.  See also coff_compute_section_file_positions.  */
3575       if (section.s_size == 0)
3576         internal_f.f_nscns--;
3577       else
3578 #endif
3579         {
3580           SCNHDR buff;
3581           bfd_size_type amt = bfd_coff_scnhsz (abfd);
3582
3583           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3584               || bfd_bwrite (& buff, amt, abfd) != amt)
3585             return FALSE;
3586         }
3587
3588 #ifdef COFF_WITH_PE
3589       /* PE stores COMDAT section information in the symbol table.  If
3590          this section is supposed to have some COMDAT info, track down
3591          the symbol in the symbol table and modify it.  */
3592       if ((current->flags & SEC_LINK_ONCE) != 0)
3593         {
3594           unsigned int i, count;
3595           asymbol **psym;
3596           coff_symbol_type *csym = NULL;
3597           asymbol **psymsec;
3598
3599           psymsec = NULL;
3600           count = bfd_get_symcount (abfd);
3601           for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3602             {
3603               if ((*psym)->section != current)
3604                 continue;
3605
3606               /* Remember the location of the first symbol in this
3607                  section.  */
3608               if (psymsec == NULL)
3609                 psymsec = psym;
3610
3611               /* See if this is the section symbol.  */
3612               if (strcmp ((*psym)->name, current->name) == 0)
3613                 {
3614                   csym = coff_symbol_from (abfd, *psym);
3615                   if (csym == NULL
3616                       || csym->native == NULL
3617                       || csym->native->u.syment.n_numaux < 1
3618                       || csym->native->u.syment.n_sclass != C_STAT
3619                       || csym->native->u.syment.n_type != T_NULL)
3620                     continue;
3621
3622                   /* Here *PSYM is the section symbol for CURRENT.  */
3623
3624                   break;
3625                 }
3626             }
3627
3628           /* Did we find it?
3629              Note that we might not if we're converting the file from
3630              some other object file format.  */
3631           if (i < count)
3632             {
3633               combined_entry_type *aux;
3634
3635               /* We don't touch the x_checksum field.  The
3636                  x_associated field is not currently supported.  */
3637
3638               aux = csym->native + 1;
3639               switch (current->flags & SEC_LINK_DUPLICATES)
3640                 {
3641                 case SEC_LINK_DUPLICATES_DISCARD:
3642                   aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3643                   break;
3644
3645                 case SEC_LINK_DUPLICATES_ONE_ONLY:
3646                   aux->u.auxent.x_scn.x_comdat =
3647                     IMAGE_COMDAT_SELECT_NODUPLICATES;
3648                   break;
3649
3650                 case SEC_LINK_DUPLICATES_SAME_SIZE:
3651                   aux->u.auxent.x_scn.x_comdat =
3652                     IMAGE_COMDAT_SELECT_SAME_SIZE;
3653                   break;
3654
3655                 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3656                   aux->u.auxent.x_scn.x_comdat =
3657                     IMAGE_COMDAT_SELECT_EXACT_MATCH;
3658                   break;
3659                 }
3660
3661               /* The COMDAT symbol must be the first symbol from this
3662                  section in the symbol table.  In order to make this
3663                  work, we move the COMDAT symbol before the first
3664                  symbol we found in the search above.  It's OK to
3665                  rearrange the symbol table at this point, because
3666                  coff_renumber_symbols is going to rearrange it
3667                  further and fix up all the aux entries.  */
3668               if (psym != psymsec)
3669                 {
3670                   asymbol *hold;
3671                   asymbol **pcopy;
3672
3673                   hold = *psym;
3674                   for (pcopy = psym; pcopy > psymsec; pcopy--)
3675                     pcopy[0] = pcopy[-1];
3676                   *psymsec = hold;
3677                 }
3678             }
3679         }
3680 #endif /* COFF_WITH_PE */
3681     }
3682
3683 #ifdef RS6000COFF_C
3684 #ifndef XCOFF64
3685   /* XCOFF handles overflows in the reloc and line number count fields
3686      by creating a new section header to hold the correct values.  */
3687   for (current = abfd->sections; current != NULL; current = current->next)
3688     {
3689       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3690         {
3691           struct internal_scnhdr scnhdr;
3692           SCNHDR buff;
3693           bfd_size_type amt;
3694
3695           internal_f.f_nscns++;
3696           strncpy (&(scnhdr.s_name[0]), current->name, 8);
3697           scnhdr.s_paddr = current->reloc_count;
3698           scnhdr.s_vaddr = current->lineno_count;
3699           scnhdr.s_size = 0;
3700           scnhdr.s_scnptr = 0;
3701           scnhdr.s_relptr = current->rel_filepos;
3702           scnhdr.s_lnnoptr = current->line_filepos;
3703           scnhdr.s_nreloc = current->target_index;
3704           scnhdr.s_nlnno = current->target_index;
3705           scnhdr.s_flags = STYP_OVRFLO;
3706           amt = bfd_coff_scnhsz (abfd);
3707           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3708               || bfd_bwrite (& buff, amt, abfd) != amt)
3709             return FALSE;
3710         }
3711     }
3712 #endif
3713 #endif
3714
3715   /* OK, now set up the filehdr...  */
3716
3717   /* Don't include the internal abs section in the section count */
3718
3719   /* We will NOT put a fucking timestamp in the header here. Every time you
3720      put it back, I will come in and take it out again.  I'm sorry.  This
3721      field does not belong here.  We fill it with a 0 so it compares the
3722      same but is not a reasonable time. -- gnu@cygnus.com  */
3723   internal_f.f_timdat = 0;
3724   internal_f.f_flags = 0;
3725
3726   if (abfd->flags & EXEC_P)
3727     internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3728   else
3729     {
3730       internal_f.f_opthdr = 0;
3731 #ifdef RS6000COFF_C
3732 #ifndef XCOFF64
3733       if (xcoff_data (abfd)->full_aouthdr)
3734         internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3735       else
3736         internal_f.f_opthdr = SMALL_AOUTSZ;
3737 #endif
3738 #endif
3739     }
3740
3741   if (!hasrelocs)
3742     internal_f.f_flags |= F_RELFLG;
3743   if (!haslinno)
3744     internal_f.f_flags |= F_LNNO;
3745   if (abfd->flags & EXEC_P)
3746     internal_f.f_flags |= F_EXEC;
3747 #ifdef COFF_IMAGE_WITH_PE
3748   if (! hasdebug)
3749     internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3750   if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
3751     internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
3752 #endif
3753
3754 #ifdef COFF_WITH_PE
3755   internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3756 #else
3757   if (bfd_little_endian (abfd))
3758     internal_f.f_flags |= F_AR32WR;
3759   else
3760     internal_f.f_flags |= F_AR32W;
3761 #endif
3762
3763 #ifdef TI_TARGET_ID
3764   /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3765      but it doesn't hurt to set it internally.  */
3766   internal_f.f_target_id = TI_TARGET_ID;
3767 #endif
3768 #ifdef TIC80_TARGET_ID
3769   internal_f.f_target_id = TIC80_TARGET_ID;
3770 #endif
3771
3772   /* FIXME, should do something about the other byte orders and
3773      architectures.  */
3774
3775 #ifdef RS6000COFF_C
3776   if ((abfd->flags & DYNAMIC) != 0)
3777     internal_f.f_flags |= F_SHROBJ;
3778   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3779     internal_f.f_flags |= F_DYNLOAD;
3780 #endif
3781
3782   memset (&internal_a, 0, sizeof internal_a);
3783
3784   /* Set up architecture-dependent stuff.  */
3785   {
3786     unsigned int magic = 0;
3787     unsigned short flags = 0;
3788
3789     coff_set_flags (abfd, &magic, &flags);
3790     internal_f.f_magic = magic;
3791     internal_f.f_flags |= flags;
3792     /* ...and the "opt"hdr...  */
3793
3794 #ifdef TICOFF_AOUT_MAGIC
3795     internal_a.magic = TICOFF_AOUT_MAGIC;
3796 #define __A_MAGIC_SET__
3797 #endif
3798 #ifdef TIC80COFF
3799     internal_a.magic = TIC80_ARCH_MAGIC;
3800 #define __A_MAGIC_SET__
3801 #endif /* TIC80 */
3802 #ifdef I860
3803     /* FIXME: What are the a.out magic numbers for the i860?  */
3804     internal_a.magic = 0;
3805 #define __A_MAGIC_SET__
3806 #endif /* I860 */
3807 #ifdef I960
3808     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3809 #define __A_MAGIC_SET__
3810 #endif /* I960 */
3811 #if M88
3812 #define __A_MAGIC_SET__
3813     internal_a.magic = PAGEMAGICBCS;
3814 #endif /* M88 */
3815
3816 #if APOLLO_M68
3817 #define __A_MAGIC_SET__
3818     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3819 #endif
3820
3821 #if defined(M68) || defined(WE32K) || defined(M68K)
3822 #define __A_MAGIC_SET__
3823 #if defined(LYNXOS)
3824     internal_a.magic = LYNXCOFFMAGIC;
3825 #else
3826 #if defined(TARG_AUX)
3827     internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3828                         abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3829                         PAGEMAGICEXECSWAPPED);
3830 #else
3831 #if defined (PAGEMAGICPEXECPAGED)
3832     internal_a.magic = PAGEMAGICPEXECPAGED;
3833 #endif
3834 #endif /* TARG_AUX */
3835 #endif /* LYNXOS */
3836 #endif /* M68 || WE32K || M68K */
3837
3838 #if defined(ARM)
3839 #define __A_MAGIC_SET__
3840     internal_a.magic = ZMAGIC;
3841 #endif
3842
3843 #if defined(PPC_PE)
3844 #define __A_MAGIC_SET__
3845     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3846 #endif
3847
3848 #if defined MCORE_PE
3849 #define __A_MAGIC_SET__
3850     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3851 #endif
3852
3853 #if defined(I386)
3854 #define __A_MAGIC_SET__
3855 #if defined(LYNXOS)
3856     internal_a.magic = LYNXCOFFMAGIC;
3857 #else  /* LYNXOS */
3858     internal_a.magic = ZMAGIC;
3859 #endif /* LYNXOS */
3860 #endif /* I386 */
3861
3862 #if defined(IA64)
3863 #define __A_MAGIC_SET__
3864     internal_a.magic = ZMAGIC;
3865 #endif /* IA64 */
3866
3867 #if defined(SPARC)
3868 #define __A_MAGIC_SET__
3869 #if defined(LYNXOS)
3870     internal_a.magic = LYNXCOFFMAGIC;
3871 #endif /* LYNXOS */
3872 #endif /* SPARC */
3873
3874 #ifdef RS6000COFF_C
3875 #define __A_MAGIC_SET__
3876     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3877     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3878     RS6K_AOUTHDR_OMAGIC;
3879 #endif
3880
3881 #if defined(SH) && defined(COFF_WITH_PE)
3882 #define __A_MAGIC_SET__
3883     internal_a.magic = SH_PE_MAGIC;
3884 #endif
3885
3886 #if defined(MIPS) && defined(COFF_WITH_PE)
3887 #define __A_MAGIC_SET__
3888     internal_a.magic = MIPS_PE_MAGIC;
3889 #endif
3890
3891 #ifdef OR32
3892 #define __A_MAGIC_SET__
3893     internal_a.magic = NMAGIC; /* Assume separate i/d.  */
3894 #endif
3895
3896 #ifdef MAXQ20MAGIC
3897 #define __A_MAGIC_SET__
3898       internal_a.magic = MAXQ20MAGIC;
3899 #endif
3900
3901 #ifndef __A_MAGIC_SET__
3902 #include "Your aouthdr magic number is not being set!"
3903 #else
3904 #undef __A_MAGIC_SET__
3905 #endif
3906   }
3907
3908   /* FIXME: Does anybody ever set this to another value?  */
3909   internal_a.vstamp = 0;
3910
3911   /* Now should write relocs, strings, syms.  */
3912   obj_sym_filepos (abfd) = sym_base;
3913
3914   if (bfd_get_symcount (abfd) != 0)
3915     {
3916       int firstundef;
3917
3918       if (!coff_renumber_symbols (abfd, &firstundef))
3919         return FALSE;
3920       coff_mangle_symbols (abfd);
3921       if (! coff_write_symbols (abfd))
3922         return FALSE;
3923       if (! coff_write_linenumbers (abfd))
3924         return FALSE;
3925       if (! coff_write_relocs (abfd, firstundef))
3926         return FALSE;
3927     }
3928 #ifdef COFF_LONG_SECTION_NAMES
3929   else if (long_section_names && ! obj_coff_strings_written (abfd))
3930     {
3931       /* If we have long section names we have to write out the string
3932          table even if there are no symbols.  */
3933       if (! coff_write_symbols (abfd))
3934         return FALSE;
3935     }
3936 #endif
3937 #ifdef COFF_IMAGE_WITH_PE
3938 #ifdef PPC_PE
3939   else if ((abfd->flags & EXEC_P) != 0)
3940     {
3941       bfd_byte b;
3942
3943       /* PowerPC PE appears to require that all executable files be
3944          rounded up to the page size.  */
3945       b = 0;
3946       if (bfd_seek (abfd,
3947                     (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3948                     SEEK_SET) != 0
3949           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3950         return FALSE;
3951     }
3952 #endif
3953 #endif
3954
3955   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3956      backend linker, and obj_raw_syment_count is not valid until after
3957      coff_write_symbols is called.  */
3958   if (obj_raw_syment_count (abfd) != 0)
3959     {
3960       internal_f.f_symptr = sym_base;
3961 #ifdef RS6000COFF_C
3962       /* AIX appears to require that F_RELFLG not be set if there are
3963          local symbols but no relocations.  */
3964       internal_f.f_flags &=~ F_RELFLG;
3965 #endif
3966     }
3967   else
3968     {
3969       if (long_section_names)
3970         internal_f.f_symptr = sym_base;
3971       else
3972         internal_f.f_symptr = 0;
3973       internal_f.f_flags |= F_LSYMS;
3974     }
3975
3976   if (text_sec)
3977     {
3978       internal_a.tsize = text_sec->size;
3979       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3980     }
3981   if (data_sec)
3982     {
3983       internal_a.dsize = data_sec->size;
3984       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3985     }
3986   if (bss_sec)
3987     {
3988       internal_a.bsize = bss_sec->size;
3989       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3990         internal_a.data_start = bss_sec->vma;
3991     }
3992
3993   internal_a.entry = bfd_get_start_address (abfd);
3994   internal_f.f_nsyms = obj_raw_syment_count (abfd);
3995
3996 #ifdef RS6000COFF_C
3997   if (xcoff_data (abfd)->full_aouthdr)
3998     {
3999       bfd_vma toc;
4000       asection *loader_sec;
4001
4002       internal_a.vstamp = 1;
4003
4004       internal_a.o_snentry = xcoff_data (abfd)->snentry;
4005       if (internal_a.o_snentry == 0)
4006         internal_a.entry = (bfd_vma) -1;
4007
4008       if (text_sec != NULL)
4009         {
4010           internal_a.o_sntext = text_sec->target_index;
4011           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4012         }
4013       else
4014         {
4015           internal_a.o_sntext = 0;
4016           internal_a.o_algntext = 0;
4017         }
4018       if (data_sec != NULL)
4019         {
4020           internal_a.o_sndata = data_sec->target_index;
4021           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4022         }
4023       else
4024         {
4025           internal_a.o_sndata = 0;
4026           internal_a.o_algndata = 0;
4027         }
4028       loader_sec = bfd_get_section_by_name (abfd, ".loader");
4029       if (loader_sec != NULL)
4030         internal_a.o_snloader = loader_sec->target_index;
4031       else
4032         internal_a.o_snloader = 0;
4033       if (bss_sec != NULL)
4034         internal_a.o_snbss = bss_sec->target_index;
4035       else
4036         internal_a.o_snbss = 0;
4037
4038       toc = xcoff_data (abfd)->toc;
4039       internal_a.o_toc = toc;
4040       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4041
4042       internal_a.o_modtype = xcoff_data (abfd)->modtype;
4043       if (xcoff_data (abfd)->cputype != -1)
4044         internal_a.o_cputype = xcoff_data (abfd)->cputype;
4045       else
4046         {
4047           switch (bfd_get_arch (abfd))
4048             {
4049             case bfd_arch_rs6000:
4050               internal_a.o_cputype = 4;
4051               break;
4052             case bfd_arch_powerpc:
4053               if (bfd_get_mach (abfd) == bfd_mach_ppc)
4054                 internal_a.o_cputype = 3;
4055               else
4056                 internal_a.o_cputype = 1;
4057               break;
4058             default:
4059               abort ();
4060             }
4061         }
4062       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4063       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4064     }
4065 #endif
4066
4067   /* Now write them.  */
4068   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4069     return FALSE;
4070
4071   {
4072     char * buff;
4073     bfd_size_type amount = bfd_coff_filhsz (abfd);
4074
4075     buff = bfd_malloc (amount);
4076     if (buff == NULL)
4077       return FALSE;
4078
4079     bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4080     amount = bfd_bwrite (buff, amount, abfd);
4081
4082     free (buff);
4083
4084     if (amount != bfd_coff_filhsz (abfd))
4085       return FALSE;
4086   }
4087
4088   if (abfd->flags & EXEC_P)
4089     {
4090       /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4091          include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)).  */
4092       char * buff;
4093       bfd_size_type amount = bfd_coff_aoutsz (abfd);
4094
4095       buff = bfd_malloc (amount);
4096       if (buff == NULL)
4097         return FALSE;
4098
4099       coff_swap_aouthdr_out (abfd, & internal_a, buff);
4100       amount = bfd_bwrite (buff, amount, abfd);
4101
4102       free (buff);
4103
4104       if (amount != bfd_coff_aoutsz (abfd))
4105         return FALSE;
4106
4107 #ifdef COFF_IMAGE_WITH_PE
4108       if (! coff_apply_checksum (abfd))
4109         return FALSE;
4110 #endif
4111     }
4112 #ifdef RS6000COFF_C
4113   else
4114     {
4115       AOUTHDR buff;
4116       size_t size;
4117
4118       /* XCOFF seems to always write at least a small a.out header.  */
4119       coff_swap_aouthdr_out (abfd, & internal_a, & buff);
4120       if (xcoff_data (abfd)->full_aouthdr)
4121         size = bfd_coff_aoutsz (abfd);
4122       else
4123         size = SMALL_AOUTSZ;
4124       if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
4125         return FALSE;
4126     }
4127 #endif
4128
4129   return TRUE;
4130 }
4131
4132 static bfd_boolean
4133 coff_set_section_contents (bfd * abfd,
4134                            sec_ptr section,
4135                            const void * location,
4136                            file_ptr offset,
4137                            bfd_size_type count)
4138 {
4139   if (! abfd->output_has_begun) /* Set by bfd.c handler.  */
4140     {
4141       if (! coff_compute_section_file_positions (abfd))
4142         return FALSE;
4143     }
4144
4145 #if defined(_LIB) && !defined(TARG_AUX)
4146    /* The physical address field of a .lib section is used to hold the
4147       number of shared libraries in the section.  This code counts the
4148       number of sections being written, and increments the lma field
4149       with the number.
4150
4151       I have found no documentation on the contents of this section.
4152       Experimentation indicates that the section contains zero or more
4153       records, each of which has the following structure:
4154
4155       - a (four byte) word holding the length of this record, in words,
4156       - a word that always seems to be set to "2",
4157       - the path to a shared library, null-terminated and then padded
4158         to a whole word boundary.
4159
4160       bfd_assert calls have been added to alert if an attempt is made
4161       to write a section which doesn't follow these assumptions.  The
4162       code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4163       <robertl@arnet.com> (Thanks!).
4164
4165       Gvran Uddeborg <gvran@uddeborg.pp.se>.  */
4166     if (strcmp (section->name, _LIB) == 0)
4167       {
4168         bfd_byte *rec, *recend;
4169
4170         rec = (bfd_byte *) location;
4171         recend = rec + count;
4172         while (rec < recend)
4173           {
4174             ++section->lma;
4175             rec += bfd_get_32 (abfd, rec) * 4;
4176           }
4177
4178         BFD_ASSERT (rec == recend);
4179       }
4180 #endif
4181
4182   /* Don't write out bss sections - one way to do this is to
4183        see if the filepos has not been set.  */
4184   if (section->filepos == 0)
4185     return TRUE;
4186
4187   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4188     return FALSE;
4189
4190   if (count == 0)
4191     return TRUE;
4192
4193   return bfd_bwrite (location, count, abfd) == count;
4194 }
4195
4196 static void *
4197 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
4198 {
4199   void * area = bfd_alloc (abfd, size);
4200
4201   if (!area)
4202     return (NULL);
4203   if (bfd_seek (abfd, where, SEEK_SET) != 0
4204       || bfd_bread (area, size, abfd) != size)
4205     return (NULL);
4206   return (area);
4207 }
4208
4209 /*
4210 SUBSUBSECTION
4211         Reading linenumbers
4212
4213         Creating the linenumber table is done by reading in the entire
4214         coff linenumber table, and creating another table for internal use.
4215
4216         A coff linenumber table is structured so that each function
4217         is marked as having a line number of 0. Each line within the
4218         function is an offset from the first line in the function. The
4219         base of the line number information for the table is stored in
4220         the symbol associated with the function.
4221
4222         Note: The PE format uses line number 0 for a flag indicating a
4223         new source file.
4224
4225         The information is copied from the external to the internal
4226         table, and each symbol which marks a function is marked by
4227         pointing its...
4228
4229         How does this work ?
4230 */
4231
4232 static bfd_boolean
4233 coff_slurp_line_table (bfd *abfd, asection *asect)
4234 {
4235   LINENO *native_lineno;
4236   alent *lineno_cache;
4237   bfd_size_type amt;
4238
4239   BFD_ASSERT (asect->lineno == NULL);
4240
4241   amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4242   native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4243   if (native_lineno == NULL)
4244     {
4245       (*_bfd_error_handler)
4246         (_("%B: warning: line number table read failed"), abfd);
4247       return FALSE;
4248     }
4249   amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4250   lineno_cache = bfd_alloc (abfd, amt);
4251   if (lineno_cache == NULL)
4252     return FALSE;
4253   else
4254     {
4255       unsigned int counter = 0;
4256       alent *cache_ptr = lineno_cache;
4257       LINENO *src = native_lineno;
4258
4259       while (counter < asect->lineno_count)
4260         {
4261           struct internal_lineno dst;
4262
4263           bfd_coff_swap_lineno_in (abfd, src, &dst);
4264           cache_ptr->line_number = dst.l_lnno;
4265
4266           if (cache_ptr->line_number == 0)
4267             {
4268               bfd_boolean warned;
4269               bfd_signed_vma symndx;
4270               coff_symbol_type *sym;
4271
4272               warned = FALSE;
4273               symndx = dst.l_addr.l_symndx;
4274               if (symndx < 0
4275                   || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4276                 {
4277                   (*_bfd_error_handler)
4278                     (_("%B: warning: illegal symbol index %ld in line numbers"),
4279                      abfd, dst.l_addr.l_symndx);
4280                   symndx = 0;
4281                   warned = TRUE;
4282                 }
4283               /* FIXME: We should not be casting between ints and
4284                  pointers like this.  */
4285               sym = ((coff_symbol_type *)
4286                      ((symndx + obj_raw_syments (abfd))
4287                       ->u.syment._n._n_n._n_zeroes));
4288               cache_ptr->u.sym = (asymbol *) sym;
4289               if (sym->lineno != NULL && ! warned)
4290                 {
4291                   (*_bfd_error_handler)
4292                     (_("%B: warning: duplicate line number information for `%s'"),
4293                      abfd, bfd_asymbol_name (&sym->symbol));
4294                 }
4295               sym->lineno = cache_ptr;
4296             }
4297           else
4298             cache_ptr->u.offset = dst.l_addr.l_paddr
4299               - bfd_section_vma (abfd, asect);
4300
4301           cache_ptr++;
4302           src++;
4303           counter++;
4304         }
4305       cache_ptr->line_number = 0;
4306
4307     }
4308   asect->lineno = lineno_cache;
4309   /* FIXME, free native_lineno here, or use alloca or something.  */
4310   return TRUE;
4311 }
4312
4313 /* Slurp in the symbol table, converting it to generic form.  Note
4314    that if coff_relocate_section is defined, the linker will read
4315    symbols via coff_link_add_symbols, rather than via this routine.  */
4316
4317 static bfd_boolean
4318 coff_slurp_symbol_table (bfd * abfd)
4319 {
4320   combined_entry_type *native_symbols;
4321   coff_symbol_type *cached_area;
4322   unsigned int *table_ptr;
4323   bfd_size_type amt;
4324   unsigned int number_of_symbols = 0;
4325
4326   if (obj_symbols (abfd))
4327     return TRUE;
4328
4329   /* Read in the symbol table.  */
4330   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4331     return FALSE;
4332
4333   /* Allocate enough room for all the symbols in cached form.  */
4334   amt = obj_raw_syment_count (abfd);
4335   amt *= sizeof (coff_symbol_type);
4336   cached_area = bfd_alloc (abfd, amt);
4337   if (cached_area == NULL)
4338     return FALSE;
4339
4340   amt = obj_raw_syment_count (abfd);
4341   amt *= sizeof (unsigned int);
4342   table_ptr = bfd_alloc (abfd, amt);
4343
4344   if (table_ptr == NULL)
4345     return FALSE;
4346   else
4347     {
4348       coff_symbol_type *dst = cached_area;
4349       unsigned int last_native_index = obj_raw_syment_count (abfd);
4350       unsigned int this_index = 0;
4351
4352       while (this_index < last_native_index)
4353         {
4354           combined_entry_type *src = native_symbols + this_index;
4355           table_ptr[this_index] = number_of_symbols;
4356           dst->symbol.the_bfd = abfd;
4357
4358           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4359           /* We use the native name field to point to the cached field.  */
4360           src->u.syment._n._n_n._n_zeroes = (long) dst;
4361           dst->symbol.section = coff_section_from_bfd_index (abfd,
4362                                                      src->u.syment.n_scnum);
4363           dst->symbol.flags = 0;
4364           dst->done_lineno = FALSE;
4365
4366           switch (src->u.syment.n_sclass)
4367             {
4368 #ifdef I960
4369             case C_LEAFEXT:
4370               /* Fall through to next case.  */
4371 #endif
4372
4373             case C_EXT:
4374             case C_WEAKEXT:
4375 #if defined ARM
4376             case C_THUMBEXT:
4377             case C_THUMBEXTFUNC:
4378 #endif
4379 #ifdef RS6000COFF_C
4380             case C_HIDEXT:
4381 #endif
4382 #ifdef C_SYSTEM
4383             case C_SYSTEM:      /* System Wide variable.  */
4384 #endif
4385 #ifdef COFF_WITH_PE
4386             /* In PE, 0x68 (104) denotes a section symbol.  */
4387             case C_SECTION:
4388             /* In PE, 0x69 (105) denotes a weak external symbol.  */
4389             case C_NT_WEAK:
4390 #endif
4391               switch (coff_classify_symbol (abfd, &src->u.syment))
4392                 {
4393                 case COFF_SYMBOL_GLOBAL:
4394                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4395 #if defined COFF_WITH_PE
4396                   /* PE sets the symbol to a value relative to the
4397                      start of the section.  */
4398                   dst->symbol.value = src->u.syment.n_value;
4399 #else
4400                   dst->symbol.value = (src->u.syment.n_value
4401                                        - dst->symbol.section->vma);
4402 #endif
4403                   if (ISFCN ((src->u.syment.n_type)))
4404                     /* A function ext does not go at the end of a
4405                        file.  */
4406                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4407                   break;
4408
4409                 case COFF_SYMBOL_COMMON:
4410                   dst->symbol.section = bfd_com_section_ptr;
4411                   dst->symbol.value = src->u.syment.n_value;
4412                   break;
4413
4414                 case COFF_SYMBOL_UNDEFINED:
4415                   dst->symbol.section = bfd_und_section_ptr;
4416                   dst->symbol.value = 0;
4417                   break;
4418
4419                 case COFF_SYMBOL_PE_SECTION:
4420                   dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4421                   dst->symbol.value = 0;
4422                   break;
4423
4424                 case COFF_SYMBOL_LOCAL:
4425                   dst->symbol.flags = BSF_LOCAL;
4426 #if defined COFF_WITH_PE
4427                   /* PE sets the symbol to a value relative to the
4428                      start of the section.  */
4429                   dst->symbol.value = src->u.syment.n_value;
4430 #else
4431                   dst->symbol.value = (src->u.syment.n_value
4432                                        - dst->symbol.section->vma);
4433 #endif
4434                   if (ISFCN ((src->u.syment.n_type)))
4435                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4436                   break;
4437                 }
4438
4439 #ifdef RS6000COFF_C
4440               /* A symbol with a csect entry should not go at the end.  */
4441               if (src->u.syment.n_numaux > 0)
4442                 dst->symbol.flags |= BSF_NOT_AT_END;
4443 #endif
4444
4445 #ifdef COFF_WITH_PE
4446               if (src->u.syment.n_sclass == C_NT_WEAK)
4447                 dst->symbol.flags |= BSF_WEAK;
4448
4449               if (src->u.syment.n_sclass == C_SECTION
4450                   && src->u.syment.n_scnum > 0)
4451                 dst->symbol.flags = BSF_LOCAL;
4452 #endif
4453               if (src->u.syment.n_sclass == C_WEAKEXT)
4454                 dst->symbol.flags |= BSF_WEAK;
4455
4456               break;
4457
4458             case C_STAT:         /* Static.  */
4459 #ifdef I960
4460             case C_LEAFSTAT:     /* Static leaf procedure.  */
4461 #endif
4462 #if defined ARM
4463             case C_THUMBSTAT:    /* Thumb static.  */
4464             case C_THUMBLABEL:   /* Thumb label.  */
4465             case C_THUMBSTATFUNC:/* Thumb static function.  */
4466 #endif
4467             case C_LABEL:        /* Label.  */
4468               if (src->u.syment.n_scnum == N_DEBUG)
4469                 dst->symbol.flags = BSF_DEBUGGING;
4470               else
4471                 dst->symbol.flags = BSF_LOCAL;
4472
4473               /* Base the value as an index from the base of the
4474                  section, if there is one.  */
4475               if (dst->symbol.section)
4476                 {
4477 #if defined COFF_WITH_PE
4478                   /* PE sets the symbol to a value relative to the
4479                      start of the section.  */
4480                   dst->symbol.value = src->u.syment.n_value;
4481 #else
4482                   dst->symbol.value = (src->u.syment.n_value
4483                                        - dst->symbol.section->vma);
4484 #endif
4485                 }
4486               else
4487                 dst->symbol.value = src->u.syment.n_value;
4488               break;
4489
4490             case C_MOS:         /* Member of structure.  */
4491             case C_EOS:         /* End of structure.  */
4492             case C_REGPARM:     /* Register parameter.  */
4493             case C_REG:         /* register variable.  */
4494               /* C_AUTOARG conflicts with TI COFF C_UEXT.  */
4495 #if !defined (TIC80COFF) && !defined (TICOFF)
4496 #ifdef C_AUTOARG
4497             case C_AUTOARG:     /* 960-specific storage class.  */
4498 #endif
4499 #endif
4500             case C_TPDEF:       /* Type definition.  */
4501             case C_ARG:
4502             case C_AUTO:        /* Automatic variable.  */
4503             case C_FIELD:       /* Bit field.  */
4504             case C_ENTAG:       /* Enumeration tag.  */
4505             case C_MOE:         /* Member of enumeration.  */
4506             case C_MOU:         /* Member of union.  */
4507             case C_UNTAG:       /* Union tag.  */
4508               dst->symbol.flags = BSF_DEBUGGING;
4509               dst->symbol.value = (src->u.syment.n_value);
4510               break;
4511
4512             case C_FILE:        /* File name.  */
4513             case C_STRTAG:      /* Structure tag.  */
4514 #ifdef RS6000COFF_C
4515             case C_GSYM:
4516             case C_LSYM:
4517             case C_PSYM:
4518             case C_RSYM:
4519             case C_RPSYM:
4520             case C_STSYM:
4521             case C_TCSYM:
4522             case C_BCOMM:
4523             case C_ECOML:
4524             case C_ECOMM:
4525             case C_DECL:
4526             case C_ENTRY:
4527             case C_FUN:
4528             case C_ESTAT:
4529 #endif
4530               dst->symbol.flags = BSF_DEBUGGING;
4531               dst->symbol.value = (src->u.syment.n_value);
4532               break;
4533
4534 #ifdef RS6000COFF_C
4535             case C_BINCL:       /* Beginning of include file.  */
4536             case C_EINCL:       /* Ending of include file.  */
4537               /* The value is actually a pointer into the line numbers
4538                  of the file.  We locate the line number entry, and
4539                  set the section to the section which contains it, and
4540                  the value to the index in that section.  */
4541               {
4542                 asection *sec;
4543
4544                 dst->symbol.flags = BSF_DEBUGGING;
4545                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4546                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4547                       && ((file_ptr) (sec->line_filepos
4548                                       + sec->lineno_count * bfd_coff_linesz (abfd))
4549                           > (file_ptr) src->u.syment.n_value))
4550                     break;
4551                 if (sec == NULL)
4552                   dst->symbol.value = 0;
4553                 else
4554                   {
4555                     dst->symbol.section = sec;
4556                     dst->symbol.value = ((src->u.syment.n_value
4557                                           - sec->line_filepos)
4558                                          / bfd_coff_linesz (abfd));
4559                     src->fix_line = 1;
4560                   }
4561               }
4562               break;
4563
4564             case C_BSTAT:
4565               dst->symbol.flags = BSF_DEBUGGING;
4566
4567               /* The value is actually a symbol index.  Save a pointer
4568                  to the symbol instead of the index.  FIXME: This
4569                  should use a union.  */
4570               src->u.syment.n_value =
4571                 (long) (native_symbols + src->u.syment.n_value);
4572               dst->symbol.value = src->u.syment.n_value;
4573               src->fix_value = 1;
4574               break;
4575 #endif
4576
4577             case C_BLOCK:       /* ".bb" or ".eb".  */
4578             case C_FCN:         /* ".bf" or ".ef" (or PE ".lf").  */
4579             case C_EFCN:        /* Physical end of function.  */
4580 #if defined COFF_WITH_PE
4581               /* PE sets the symbol to a value relative to the start
4582                  of the section.  */
4583               dst->symbol.value = src->u.syment.n_value;
4584               if (strcmp (dst->symbol.name, ".bf") != 0)
4585                 {
4586                   /* PE uses funny values for .ef and .lf; don't
4587                      relocate them.  */
4588                   dst->symbol.flags = BSF_DEBUGGING;
4589                 }
4590               else
4591                 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4592 #else
4593               /* Base the value as an index from the base of the
4594                  section.  */
4595               dst->symbol.flags = BSF_LOCAL;
4596               dst->symbol.value = (src->u.syment.n_value
4597                                    - dst->symbol.section->vma);
4598 #endif
4599               break;
4600
4601             case C_STATLAB:     /* Static load time label.  */
4602               dst->symbol.value = src->u.syment.n_value;
4603               dst->symbol.flags = BSF_GLOBAL;
4604               break;
4605
4606             case C_NULL:
4607               /* PE DLLs sometimes have zeroed out symbols for some
4608                  reason.  Just ignore them without a warning.  */
4609               if (src->u.syment.n_type == 0
4610                   && src->u.syment.n_value == 0
4611                   && src->u.syment.n_scnum == 0)
4612                 break;
4613               /* Fall through.  */
4614             case C_EXTDEF:      /* External definition.  */
4615             case C_ULABEL:      /* Undefined label.  */
4616             case C_USTATIC:     /* Undefined static.  */
4617 #ifndef COFF_WITH_PE
4618             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
4619                class to represent a section symbol.  */
4620             case C_LINE:        /* line # reformatted as symbol table entry.  */
4621               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
4622             case C_ALIAS:       /* Duplicate tag.  */
4623 #endif
4624               /* New storage classes for TI COFF.  */
4625 #if defined(TIC80COFF) || defined(TICOFF)
4626             case C_UEXT:        /* Tentative external definition.  */
4627 #endif
4628             case C_EXTLAB:      /* External load time label.  */
4629             case C_HIDDEN:      /* Ext symbol in dmert public lib.  */
4630             default:
4631               (*_bfd_error_handler)
4632                 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4633                  abfd, src->u.syment.n_sclass,
4634                  dst->symbol.section->name, dst->symbol.name);
4635               dst->symbol.flags = BSF_DEBUGGING;
4636               dst->symbol.value = (src->u.syment.n_value);
4637               break;
4638             }
4639
4640           dst->native = src;
4641
4642           dst->symbol.udata.i = 0;
4643           dst->lineno = NULL;
4644           this_index += (src->u.syment.n_numaux) + 1;
4645           dst++;
4646           number_of_symbols++;
4647         }
4648     }
4649
4650   obj_symbols (abfd) = cached_area;
4651   obj_raw_syments (abfd) = native_symbols;
4652
4653   bfd_get_symcount (abfd) = number_of_symbols;
4654   obj_convert (abfd) = table_ptr;
4655   /* Slurp the line tables for each section too.  */
4656   {
4657     asection *p;
4658
4659     p = abfd->sections;
4660     while (p)
4661       {
4662         coff_slurp_line_table (abfd, p);
4663         p = p->next;
4664       }
4665   }
4666
4667   return TRUE;
4668 }
4669
4670 /* Classify a COFF symbol.  A couple of targets have globally visible
4671    symbols which are not class C_EXT, and this handles those.  It also
4672    recognizes some special PE cases.  */
4673
4674 static enum coff_symbol_classification
4675 coff_classify_symbol (bfd *abfd,
4676                       struct internal_syment *syment)
4677 {
4678   /* FIXME: This partially duplicates the switch in
4679      coff_slurp_symbol_table.  */
4680   switch (syment->n_sclass)
4681     {
4682     case C_EXT:
4683     case C_WEAKEXT:
4684 #ifdef I960
4685     case C_LEAFEXT:
4686 #endif
4687 #ifdef ARM
4688     case C_THUMBEXT:
4689     case C_THUMBEXTFUNC:
4690 #endif
4691 #ifdef C_SYSTEM
4692     case C_SYSTEM:
4693 #endif
4694 #ifdef COFF_WITH_PE
4695     case C_NT_WEAK:
4696 #endif
4697       if (syment->n_scnum == 0)
4698         {
4699           if (syment->n_value == 0)
4700             return COFF_SYMBOL_UNDEFINED;
4701           else
4702             return COFF_SYMBOL_COMMON;
4703         }
4704       return COFF_SYMBOL_GLOBAL;
4705
4706     default:
4707       break;
4708     }
4709
4710 #ifdef COFF_WITH_PE
4711   if (syment->n_sclass == C_STAT)
4712     {
4713       if (syment->n_scnum == 0)
4714         /* The Microsoft compiler sometimes generates these if a
4715            small static function is inlined every time it is used.
4716            The function is discarded, but the symbol table entry
4717            remains.  */
4718         return COFF_SYMBOL_LOCAL;
4719
4720 #ifdef STRICT_PE_FORMAT
4721       /* This is correct for Microsoft generated objects, but it
4722          breaks gas generated objects.  */
4723       if (syment->n_value == 0)
4724         {
4725           asection *sec;
4726           char buf[SYMNMLEN + 1];
4727
4728           sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4729           if (sec != NULL
4730               && (strcmp (bfd_get_section_name (abfd, sec),
4731                           _bfd_coff_internal_syment_name (abfd, syment, buf))
4732                   == 0))
4733             return COFF_SYMBOL_PE_SECTION;
4734         }
4735 #endif
4736
4737       return COFF_SYMBOL_LOCAL;
4738     }
4739
4740   if (syment->n_sclass == C_SECTION)
4741     {
4742       /* In some cases in a DLL generated by the Microsoft linker, the
4743          n_value field will contain garbage.  FIXME: This should
4744          probably be handled by the swapping function instead.  */
4745       syment->n_value = 0;
4746       if (syment->n_scnum == 0)
4747         return COFF_SYMBOL_UNDEFINED;
4748       return COFF_SYMBOL_PE_SECTION;
4749     }
4750 #endif /* COFF_WITH_PE */
4751
4752   /* If it is not a global symbol, we presume it is a local symbol.  */
4753   if (syment->n_scnum == 0)
4754     {
4755       char buf[SYMNMLEN + 1];
4756
4757       (*_bfd_error_handler)
4758         (_("warning: %B: local symbol `%s' has no section"),
4759          abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
4760     }
4761
4762   return COFF_SYMBOL_LOCAL;
4763 }
4764
4765 /*
4766 SUBSUBSECTION
4767         Reading relocations
4768
4769         Coff relocations are easily transformed into the internal BFD form
4770         (@code{arelent}).
4771
4772         Reading a coff relocation table is done in the following stages:
4773
4774         o Read the entire coff relocation table into memory.
4775
4776         o Process each relocation in turn; first swap it from the
4777         external to the internal form.
4778
4779         o Turn the symbol referenced in the relocation's symbol index
4780         into a pointer into the canonical symbol table.
4781         This table is the same as the one returned by a call to
4782         @code{bfd_canonicalize_symtab}. The back end will call that
4783         routine and save the result if a canonicalization hasn't been done.
4784
4785         o The reloc index is turned into a pointer to a howto
4786         structure, in a back end specific way. For instance, the 386
4787         and 960 use the @code{r_type} to directly produce an index
4788         into a howto table vector; the 88k subtracts a number from the
4789         @code{r_type} field and creates an addend field.
4790 */
4791
4792 #ifndef CALC_ADDEND
4793 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
4794   {                                                             \
4795     coff_symbol_type *coffsym = NULL;                           \
4796                                                                 \
4797     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
4798       coffsym = (obj_symbols (abfd)                             \
4799                  + (cache_ptr->sym_ptr_ptr - symbols));         \
4800     else if (ptr)                                               \
4801       coffsym = coff_symbol_from (abfd, ptr);                   \
4802     if (coffsym != NULL                                         \
4803         && coffsym->native->u.syment.n_scnum == 0)              \
4804       cache_ptr->addend = 0;                                    \
4805     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
4806              && ptr->section != NULL)                           \
4807       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
4808     else                                                        \
4809       cache_ptr->addend = 0;                                    \
4810   }
4811 #endif
4812
4813 static bfd_boolean
4814 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
4815 {
4816   RELOC *native_relocs;
4817   arelent *reloc_cache;
4818   arelent *cache_ptr;
4819   unsigned int idx;
4820   bfd_size_type amt;
4821
4822   if (asect->relocation)
4823     return TRUE;
4824   if (asect->reloc_count == 0)
4825     return TRUE;
4826   if (asect->flags & SEC_CONSTRUCTOR)
4827     return TRUE;
4828   if (!coff_slurp_symbol_table (abfd))
4829     return FALSE;
4830
4831   amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
4832   native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
4833   amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
4834   reloc_cache = bfd_alloc (abfd, amt);
4835
4836   if (reloc_cache == NULL || native_relocs == NULL)
4837     return FALSE;
4838
4839   for (idx = 0; idx < asect->reloc_count; idx++)
4840     {
4841       struct internal_reloc dst;
4842       struct external_reloc *src;
4843 #ifndef RELOC_PROCESSING
4844       asymbol *ptr;
4845 #endif
4846
4847       cache_ptr = reloc_cache + idx;
4848       src = native_relocs + idx;
4849
4850       coff_swap_reloc_in (abfd, src, &dst);
4851
4852 #ifdef RELOC_PROCESSING
4853       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4854 #else
4855       cache_ptr->address = dst.r_vaddr;
4856
4857       if (dst.r_symndx != -1)
4858         {
4859           if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4860             {
4861               (*_bfd_error_handler)
4862                 (_("%B: warning: illegal symbol index %ld in relocs"),
4863                  abfd, dst.r_symndx);
4864               cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4865               ptr = NULL;
4866             }
4867           else
4868             {
4869               cache_ptr->sym_ptr_ptr = (symbols
4870                                         + obj_convert (abfd)[dst.r_symndx]);
4871               ptr = *(cache_ptr->sym_ptr_ptr);
4872             }
4873         }
4874       else
4875         {
4876           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4877           ptr = NULL;
4878         }
4879
4880       /* The symbols definitions that we have read in have been
4881          relocated as if their sections started at 0. But the offsets
4882          refering to the symbols in the raw data have not been
4883          modified, so we have to have a negative addend to compensate.
4884
4885          Note that symbols which used to be common must be left alone.  */
4886
4887       /* Calculate any reloc addend by looking at the symbol.  */
4888       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4889
4890       cache_ptr->address -= asect->vma;
4891       /* !! cache_ptr->section = NULL;*/
4892
4893       /* Fill in the cache_ptr->howto field from dst.r_type.  */
4894       RTYPE2HOWTO (cache_ptr, &dst);
4895 #endif  /* RELOC_PROCESSING */
4896
4897       if (cache_ptr->howto == NULL)
4898         {
4899           (*_bfd_error_handler)
4900             (_("%B: illegal relocation type %d at address 0x%lx"),
4901              abfd, dst.r_type, (long) dst.r_vaddr);
4902           bfd_set_error (bfd_error_bad_value);
4903           return FALSE;
4904         }
4905     }
4906
4907   asect->relocation = reloc_cache;
4908   return TRUE;
4909 }
4910
4911 #ifndef coff_rtype_to_howto
4912 #ifdef RTYPE2HOWTO
4913
4914 /* Get the howto structure for a reloc.  This is only used if the file
4915    including this one defines coff_relocate_section to be
4916    _bfd_coff_generic_relocate_section, so it is OK if it does not
4917    always work.  It is the responsibility of the including file to
4918    make sure it is reasonable if it is needed.  */
4919
4920 static reloc_howto_type *
4921 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
4922                      asection *sec ATTRIBUTE_UNUSED,
4923                      struct internal_reloc *rel,
4924                      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
4925                      struct internal_syment *sym ATTRIBUTE_UNUSED,
4926                      bfd_vma *addendp ATTRIBUTE_UNUSED)
4927 {
4928   arelent genrel;
4929
4930   RTYPE2HOWTO (&genrel, rel);
4931   return genrel.howto;
4932 }
4933
4934 #else /* ! defined (RTYPE2HOWTO) */
4935
4936 #define coff_rtype_to_howto NULL
4937
4938 #endif /* ! defined (RTYPE2HOWTO) */
4939 #endif /* ! defined (coff_rtype_to_howto) */
4940
4941 /* This is stupid.  This function should be a boolean predicate.  */
4942
4943 static long
4944 coff_canonicalize_reloc (bfd * abfd,
4945                          sec_ptr section,
4946                          arelent ** relptr,
4947                          asymbol ** symbols)
4948 {
4949   arelent *tblptr = section->relocation;
4950   unsigned int count = 0;
4951
4952   if (section->flags & SEC_CONSTRUCTOR)
4953     {
4954       /* This section has relocs made up by us, they are not in the
4955          file, so take them out of their chain and place them into
4956          the data area provided.  */
4957       arelent_chain *chain = section->constructor_chain;
4958
4959       for (count = 0; count < section->reloc_count; count++)
4960         {
4961           *relptr++ = &chain->relent;
4962           chain = chain->next;
4963         }
4964     }
4965   else
4966     {
4967       if (! coff_slurp_reloc_table (abfd, section, symbols))
4968         return -1;
4969
4970       tblptr = section->relocation;
4971
4972       for (; count++ < section->reloc_count;)
4973         *relptr++ = tblptr++;
4974     }
4975   *relptr = 0;
4976   return section->reloc_count;
4977 }
4978
4979 #ifndef coff_reloc16_estimate
4980 #define coff_reloc16_estimate dummy_reloc16_estimate
4981
4982 static int
4983 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
4984                         asection *input_section ATTRIBUTE_UNUSED,
4985                         arelent *reloc ATTRIBUTE_UNUSED,
4986                         unsigned int shrink ATTRIBUTE_UNUSED,
4987                         struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
4988 {
4989   abort ();
4990   return 0;
4991 }
4992
4993 #endif
4994
4995 #ifndef coff_reloc16_extra_cases
4996
4997 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4998
4999 /* This works even if abort is not declared in any header file.  */
5000
5001 static void
5002 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5003                            struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5004                            struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5005                            arelent *reloc ATTRIBUTE_UNUSED,
5006                            bfd_byte *data ATTRIBUTE_UNUSED,
5007                            unsigned int *src_ptr ATTRIBUTE_UNUSED,
5008                            unsigned int *dst_ptr ATTRIBUTE_UNUSED)
5009 {
5010   abort ();
5011 }
5012 #endif
5013
5014 #ifndef coff_bfd_link_hash_table_free
5015 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5016 #endif
5017
5018 /* If coff_relocate_section is defined, we can use the optimized COFF
5019    backend linker.  Otherwise we must continue to use the old linker.  */
5020
5021 #ifdef coff_relocate_section
5022
5023 #ifndef coff_bfd_link_hash_table_create
5024 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5025 #endif
5026 #ifndef coff_bfd_link_add_symbols
5027 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5028 #endif
5029 #ifndef coff_bfd_final_link
5030 #define coff_bfd_final_link _bfd_coff_final_link
5031 #endif
5032
5033 #else /* ! defined (coff_relocate_section) */
5034
5035 #define coff_relocate_section NULL
5036 #ifndef coff_bfd_link_hash_table_create
5037 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5038 #endif
5039 #ifndef coff_bfd_link_add_symbols
5040 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5041 #endif
5042 #define coff_bfd_final_link _bfd_generic_final_link
5043
5044 #endif /* ! defined (coff_relocate_section) */
5045
5046 #define coff_bfd_link_just_syms      _bfd_generic_link_just_syms
5047 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
5048
5049 #ifndef coff_start_final_link
5050 #define coff_start_final_link NULL
5051 #endif
5052
5053 #ifndef coff_adjust_symndx
5054 #define coff_adjust_symndx NULL
5055 #endif
5056
5057 #ifndef coff_link_add_one_symbol
5058 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5059 #endif
5060
5061 #ifndef coff_link_output_has_begun
5062
5063 static bfd_boolean
5064 coff_link_output_has_begun (bfd * abfd,
5065                             struct coff_final_link_info * info ATTRIBUTE_UNUSED)
5066 {
5067   return abfd->output_has_begun;
5068 }
5069 #endif
5070
5071 #ifndef coff_final_link_postscript
5072
5073 static bfd_boolean
5074 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5075                             struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
5076 {
5077   return TRUE;
5078 }
5079 #endif
5080
5081 #ifndef coff_SWAP_aux_in
5082 #define coff_SWAP_aux_in coff_swap_aux_in
5083 #endif
5084 #ifndef coff_SWAP_sym_in
5085 #define coff_SWAP_sym_in coff_swap_sym_in
5086 #endif
5087 #ifndef coff_SWAP_lineno_in
5088 #define coff_SWAP_lineno_in coff_swap_lineno_in
5089 #endif
5090 #ifndef coff_SWAP_aux_out
5091 #define coff_SWAP_aux_out coff_swap_aux_out
5092 #endif
5093 #ifndef coff_SWAP_sym_out
5094 #define coff_SWAP_sym_out coff_swap_sym_out
5095 #endif
5096 #ifndef coff_SWAP_lineno_out
5097 #define coff_SWAP_lineno_out coff_swap_lineno_out
5098 #endif
5099 #ifndef coff_SWAP_reloc_out
5100 #define coff_SWAP_reloc_out coff_swap_reloc_out
5101 #endif
5102 #ifndef coff_SWAP_filehdr_out
5103 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5104 #endif
5105 #ifndef coff_SWAP_aouthdr_out
5106 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5107 #endif
5108 #ifndef coff_SWAP_scnhdr_out
5109 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5110 #endif
5111 #ifndef coff_SWAP_reloc_in
5112 #define coff_SWAP_reloc_in coff_swap_reloc_in
5113 #endif
5114 #ifndef coff_SWAP_filehdr_in
5115 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5116 #endif
5117 #ifndef coff_SWAP_aouthdr_in
5118 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5119 #endif
5120 #ifndef coff_SWAP_scnhdr_in
5121 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5122 #endif
5123
5124 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
5125 {
5126   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5127   coff_SWAP_aux_out, coff_SWAP_sym_out,
5128   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5129   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5130   coff_SWAP_scnhdr_out,
5131   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5132 #ifdef COFF_LONG_FILENAMES
5133   TRUE,
5134 #else
5135   FALSE,
5136 #endif
5137 #ifdef COFF_LONG_SECTION_NAMES
5138   TRUE,
5139 #else
5140   FALSE,
5141 #endif
5142   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5143 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5144   TRUE,
5145 #else
5146   FALSE,
5147 #endif
5148 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5149   4,
5150 #else
5151   2,
5152 #endif
5153   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5154   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5155   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5156   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5157   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5158   coff_classify_symbol, coff_compute_section_file_positions,
5159   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5160   coff_adjust_symndx, coff_link_add_one_symbol,
5161   coff_link_output_has_begun, coff_final_link_postscript
5162 };
5163
5164 #ifdef TICOFF
5165 /* COFF0 differs in file/section header size and relocation entry size.  */
5166
5167 static const bfd_coff_backend_data ticoff0_swap_table =
5168 {
5169   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5170   coff_SWAP_aux_out, coff_SWAP_sym_out,
5171   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5172   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5173   coff_SWAP_scnhdr_out,
5174   FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5175 #ifdef COFF_LONG_FILENAMES
5176   TRUE,
5177 #else
5178   FALSE,
5179 #endif
5180 #ifdef COFF_LONG_SECTION_NAMES
5181   TRUE,
5182 #else
5183   FALSE,
5184 #endif
5185   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5186 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5187   TRUE,
5188 #else
5189   FALSE,
5190 #endif
5191 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5192   4,
5193 #else
5194   2,
5195 #endif
5196   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5197   coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5198   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5199   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5200   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5201   coff_classify_symbol, coff_compute_section_file_positions,
5202   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5203   coff_adjust_symndx, coff_link_add_one_symbol,
5204   coff_link_output_has_begun, coff_final_link_postscript
5205 };
5206 #endif
5207
5208 #ifdef TICOFF
5209 /* COFF1 differs in section header size.  */
5210
5211 static const bfd_coff_backend_data ticoff1_swap_table =
5212 {
5213   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5214   coff_SWAP_aux_out, coff_SWAP_sym_out,
5215   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5216   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5217   coff_SWAP_scnhdr_out,
5218   FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5219 #ifdef COFF_LONG_FILENAMES
5220   TRUE,
5221 #else
5222   FALSE,
5223 #endif
5224 #ifdef COFF_LONG_SECTION_NAMES
5225   TRUE,
5226 #else
5227   FALSE,
5228 #endif
5229   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5230 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5231   TRUE,
5232 #else
5233   FALSE,
5234 #endif
5235 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5236   4,
5237 #else
5238   2,
5239 #endif
5240   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5241   coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5242   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5243   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5244   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5245   coff_classify_symbol, coff_compute_section_file_positions,
5246   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5247   coff_adjust_symndx, coff_link_add_one_symbol,
5248   coff_link_output_has_begun, coff_final_link_postscript
5249 };
5250 #endif
5251
5252 #ifndef coff_close_and_cleanup
5253 #define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
5254 #endif
5255
5256 #ifndef coff_bfd_free_cached_info
5257 #define coff_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
5258 #endif
5259
5260 #ifndef coff_get_section_contents
5261 #define coff_get_section_contents           _bfd_generic_get_section_contents
5262 #endif
5263
5264 #ifndef coff_bfd_copy_private_symbol_data
5265 #define coff_bfd_copy_private_symbol_data   _bfd_generic_bfd_copy_private_symbol_data
5266 #endif
5267
5268 #ifndef coff_bfd_copy_private_header_data
5269 #define coff_bfd_copy_private_header_data   _bfd_generic_bfd_copy_private_header_data
5270 #endif
5271
5272 #ifndef coff_bfd_copy_private_section_data
5273 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
5274 #endif
5275
5276 #ifndef coff_bfd_copy_private_bfd_data
5277 #define coff_bfd_copy_private_bfd_data      _bfd_generic_bfd_copy_private_bfd_data
5278 #endif
5279
5280 #ifndef coff_bfd_merge_private_bfd_data
5281 #define coff_bfd_merge_private_bfd_data     _bfd_generic_bfd_merge_private_bfd_data
5282 #endif
5283
5284 #ifndef coff_bfd_set_private_flags
5285 #define coff_bfd_set_private_flags          _bfd_generic_bfd_set_private_flags
5286 #endif
5287
5288 #ifndef coff_bfd_print_private_bfd_data
5289 #define coff_bfd_print_private_bfd_data     _bfd_generic_bfd_print_private_bfd_data
5290 #endif
5291
5292 #ifndef coff_bfd_is_local_label_name
5293 #define coff_bfd_is_local_label_name        _bfd_coff_is_local_label_name
5294 #endif
5295
5296 #ifndef coff_bfd_is_target_special_symbol
5297 #define coff_bfd_is_target_special_symbol   ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5298 #endif
5299
5300 #ifndef coff_read_minisymbols
5301 #define coff_read_minisymbols               _bfd_generic_read_minisymbols
5302 #endif
5303
5304 #ifndef coff_minisymbol_to_symbol
5305 #define coff_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
5306 #endif
5307
5308 /* The reloc lookup routine must be supplied by each individual COFF
5309    backend.  */
5310 #ifndef coff_bfd_reloc_type_lookup
5311 #define coff_bfd_reloc_type_lookup          _bfd_norelocs_bfd_reloc_type_lookup
5312 #endif
5313
5314 #ifndef coff_bfd_get_relocated_section_contents
5315 #define coff_bfd_get_relocated_section_contents \
5316   bfd_generic_get_relocated_section_contents
5317 #endif
5318
5319 #ifndef coff_bfd_relax_section
5320 #define coff_bfd_relax_section              bfd_generic_relax_section
5321 #endif
5322
5323 #ifndef coff_bfd_gc_sections
5324 #define coff_bfd_gc_sections                bfd_generic_gc_sections
5325 #endif
5326
5327 #ifndef coff_bfd_merge_sections
5328 #define coff_bfd_merge_sections             bfd_generic_merge_sections
5329 #endif
5330
5331 #ifndef coff_bfd_is_group_section
5332 #define coff_bfd_is_group_section           bfd_generic_is_group_section
5333 #endif
5334
5335 #ifndef coff_bfd_discard_group
5336 #define coff_bfd_discard_group              bfd_generic_discard_group
5337 #endif
5338
5339 #ifndef coff_section_already_linked
5340 #define coff_section_already_linked \
5341   _bfd_generic_section_already_linked
5342 #endif
5343
5344 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)     \
5345 const bfd_target VAR =                                                  \
5346 {                                                                       \
5347   NAME ,                                                                \
5348   bfd_target_coff_flavour,                                              \
5349   BFD_ENDIAN_BIG,               /* Data byte order is big.  */          \
5350   BFD_ENDIAN_BIG,               /* Header byte order is big.  */        \
5351   /* object flags */                                                    \
5352   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5353    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5354   /* section flags */                                                   \
5355   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5356   UNDER,                        /* Leading symbol underscore.  */       \
5357   '/',                          /* AR_pad_char.  */                     \
5358   15,                           /* AR_max_namelen.  */                  \
5359                                                                         \
5360   /* Data conversion functions.  */                                     \
5361   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5362   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5363   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5364                                                                         \
5365   /* Header conversion functions.  */                                   \
5366   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5367   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5368   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5369                                                                         \
5370         /* bfd_check_format.  */                                        \
5371   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5372     _bfd_dummy_target },                                                \
5373         /* bfd_set_format.  */                                          \
5374   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5375         /* bfd_write_contents.  */                                      \
5376   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5377     bfd_false },                                                        \
5378                                                                         \
5379   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5380   BFD_JUMP_TABLE_COPY (coff),                                           \
5381   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5382   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5383   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5384   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5385   BFD_JUMP_TABLE_WRITE (coff),                                          \
5386   BFD_JUMP_TABLE_LINK (coff),                                           \
5387   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5388                                                                         \
5389   ALTERNATIVE,                                                          \
5390                                                                         \
5391   SWAP_TABLE                                                            \
5392 };
5393
5394 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)  \
5395 const bfd_target VAR =                                                  \
5396 {                                                                       \
5397   NAME ,                                                                \
5398   bfd_target_coff_flavour,                                              \
5399   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */       \
5400   BFD_ENDIAN_BIG,               /* Header byte order is big.  */        \
5401   /* object flags */                                                    \
5402   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5403    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5404   /* section flags */                                                   \
5405   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5406   UNDER,                        /* Leading symbol underscore.  */       \
5407   '/',                          /* AR_pad_char.  */                     \
5408   15,                           /* AR_max_namelen.  */                  \
5409                                                                         \
5410   /* Data conversion functions.  */                                     \
5411   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5412   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5413   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5414                                                                         \
5415   /* Header conversion functions.  */                                   \
5416   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5417   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5418   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5419                                                                         \
5420         /* bfd_check_format.  */                                        \
5421   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5422     _bfd_dummy_target },                                                \
5423         /* bfd_set_format.  */                                          \
5424   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5425         /* bfd_write_contents.  */                                      \
5426   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5427     bfd_false },                                                        \
5428                                                                         \
5429   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5430   BFD_JUMP_TABLE_COPY (coff),                                           \
5431   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5432   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5433   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5434   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5435   BFD_JUMP_TABLE_WRITE (coff),                                          \
5436   BFD_JUMP_TABLE_LINK (coff),                                           \
5437   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5438                                                                         \
5439   ALTERNATIVE,                                                          \
5440                                                                         \
5441   SWAP_TABLE                                                            \
5442 };
5443
5444 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)  \
5445 const bfd_target VAR =                                                  \
5446 {                                                                       \
5447   NAME ,                                                                \
5448   bfd_target_coff_flavour,                                              \
5449   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */       \
5450   BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */     \
5451         /* object flags */                                              \
5452   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5453    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5454         /* section flags */                                             \
5455   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5456   UNDER,                        /* Leading symbol underscore.  */       \
5457   '/',                          /* AR_pad_char.  */                     \
5458   15,                           /* AR_max_namelen.  */                  \
5459                                                                         \
5460   /* Data conversion functions.  */                                     \
5461   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5462   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5463   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5464   /* Header conversion functions.  */                                   \
5465   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5466   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5467   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5468         /* bfd_check_format.  */                                        \
5469   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5470     _bfd_dummy_target },                                                \
5471        /* bfd_set_format.  */                                           \
5472   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5473         /* bfd_write_contents.  */                                      \
5474   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5475     bfd_false },                                                        \
5476                                                                         \
5477   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5478   BFD_JUMP_TABLE_COPY (coff),                                           \
5479   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5480   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5481   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5482   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5483   BFD_JUMP_TABLE_WRITE (coff),                                          \
5484   BFD_JUMP_TABLE_LINK (coff),                                           \
5485   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5486                                                                         \
5487   ALTERNATIVE,                                                          \
5488                                                                         \
5489   SWAP_TABLE                                                            \
5490 };