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)
 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 A29K_MAGIC_BIG
1892     case A29K_MAGIC_BIG:
1893     case A29K_MAGIC_LITTLE:
1894       arch = bfd_arch_a29k;
1895       break;
1896 #endif
1897 #ifdef ARMMAGIC
1898     case ARMMAGIC:
1899     case ARMPEMAGIC:
1900     case THUMBPEMAGIC:
1901       arch = bfd_arch_arm;
1902       machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
1903       if (machine == bfd_mach_arm_unknown)
1904         {
1905           switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1906             {
1907             case F_ARM_2:  machine = bfd_mach_arm_2;  break;
1908             case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1909             case F_ARM_3:  machine = bfd_mach_arm_3;  break;
1910             default:
1911             case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1912             case F_ARM_4:  machine = bfd_mach_arm_4;  break;
1913             case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1914               /* The COFF header does not have enough bits available
1915                  to cover all the different ARM architectures.  So
1916                  we interpret F_ARM_5, the highest flag value to mean
1917                  "the highest ARM architecture known to BFD" which is
1918                  currently the XScale.  */
1919             case F_ARM_5:  machine = bfd_mach_arm_XScale;  break;
1920             }
1921         }
1922       break;
1923 #endif
1924 #ifdef MC68MAGIC
1925     case MC68MAGIC:
1926     case M68MAGIC:
1927 #ifdef MC68KBCSMAGIC
1928     case MC68KBCSMAGIC:
1929 #endif
1930 #ifdef APOLLOM68KMAGIC
1931     case APOLLOM68KMAGIC:
1932 #endif
1933 #ifdef LYNXCOFFMAGIC
1934     case LYNXCOFFMAGIC:
1935 #endif
1936       arch = bfd_arch_m68k;
1937       machine = bfd_mach_m68020;
1938       break;
1939 #endif
1940 #ifdef MAXQ20MAGIC
1941     case MAXQ20MAGIC:
1942       arch = bfd_arch_maxq;
1943       switch (internal_f->f_flags & F_MACHMASK)
1944         {
1945         case F_MAXQ10:
1946           machine = bfd_mach_maxq10;
1947           break;
1948         case F_MAXQ20:
1949           machine = bfd_mach_maxq20;
1950           break;
1951         default:
1952           return FALSE;
1953         }
1954       break;
1955 #endif
1956 #ifdef MC88MAGIC
1957     case MC88MAGIC:
1958     case MC88DMAGIC:
1959     case MC88OMAGIC:
1960       arch = bfd_arch_m88k;
1961       machine = 88100;
1962       break;
1963 #endif
1964 #ifdef Z8KMAGIC
1965     case Z8KMAGIC:
1966       arch = bfd_arch_z8k;
1967       switch (internal_f->f_flags & F_MACHMASK)
1968         {
1969         case F_Z8001:
1970           machine = bfd_mach_z8001;
1971           break;
1972         case F_Z8002:
1973           machine = bfd_mach_z8002;
1974           break;
1975         default:
1976           return FALSE;
1977         }
1978       break;
1979 #endif
1980 #ifdef I860
1981     case I860MAGIC:
1982       arch = bfd_arch_i860;
1983       break;
1984 #endif
1985 #ifdef I960
1986 #ifdef I960ROMAGIC
1987     case I960ROMAGIC:
1988     case I960RWMAGIC:
1989       arch = bfd_arch_i960;
1990       switch (F_I960TYPE & internal_f->f_flags)
1991         {
1992         default:
1993         case F_I960CORE:
1994           machine = bfd_mach_i960_core;
1995           break;
1996         case F_I960KB:
1997           machine = bfd_mach_i960_kb_sb;
1998           break;
1999         case F_I960MC:
2000           machine = bfd_mach_i960_mc;
2001           break;
2002         case F_I960XA:
2003           machine = bfd_mach_i960_xa;
2004           break;
2005         case F_I960CA:
2006           machine = bfd_mach_i960_ca;
2007           break;
2008         case F_I960KA:
2009           machine = bfd_mach_i960_ka_sa;
2010           break;
2011         case F_I960JX:
2012           machine = bfd_mach_i960_jx;
2013           break;
2014         case F_I960HX:
2015           machine = bfd_mach_i960_hx;
2016           break;
2017         }
2018       break;
2019 #endif
2020 #endif
2021
2022 #ifdef RS6000COFF_C
2023 #ifdef XCOFF64
2024     case U64_TOCMAGIC:
2025     case U803XTOCMAGIC:
2026 #else
2027     case U802ROMAGIC:
2028     case U802WRMAGIC:
2029     case U802TOCMAGIC:
2030 #endif
2031       {
2032         int cputype;
2033
2034         if (xcoff_data (abfd)->cputype != -1)
2035           cputype = xcoff_data (abfd)->cputype & 0xff;
2036         else
2037           {
2038             /* We did not get a value from the a.out header.  If the
2039                file has not been stripped, we may be able to get the
2040                architecture information from the first symbol, if it
2041                is a .file symbol.  */
2042             if (obj_raw_syment_count (abfd) == 0)
2043               cputype = 0;
2044             else
2045               {
2046                 bfd_byte *buf;
2047                 struct internal_syment sym;
2048                 bfd_size_type amt = bfd_coff_symesz (abfd);
2049
2050                 buf = bfd_malloc (amt);
2051                 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2052                     || bfd_bread (buf, amt, abfd) != amt)
2053                   {
2054                     free (buf);
2055                     return FALSE;
2056                   }
2057                 bfd_coff_swap_sym_in (abfd, buf, & sym);
2058                 if (sym.n_sclass == C_FILE)
2059                   cputype = sym.n_type & 0xff;
2060                 else
2061                   cputype = 0;
2062                 free (buf);
2063               }
2064           }
2065
2066         /* FIXME: We don't handle all cases here.  */
2067         switch (cputype)
2068           {
2069           default:
2070           case 0:
2071             arch = bfd_xcoff_architecture (abfd);
2072             machine = bfd_xcoff_machine (abfd);
2073             break;
2074
2075           case 1:
2076             arch = bfd_arch_powerpc;
2077             machine = bfd_mach_ppc_601;
2078             break;
2079           case 2: /* 64 bit PowerPC */
2080             arch = bfd_arch_powerpc;
2081             machine = bfd_mach_ppc_620;
2082             break;
2083           case 3:
2084             arch = bfd_arch_powerpc;
2085             machine = bfd_mach_ppc;
2086             break;
2087           case 4:
2088             arch = bfd_arch_rs6000;
2089             machine = bfd_mach_rs6k;
2090             break;
2091           }
2092       }
2093       break;
2094 #endif
2095
2096 #ifdef WE32KMAGIC
2097     case WE32KMAGIC:
2098       arch = bfd_arch_we32k;
2099       break;
2100 #endif
2101
2102 #ifdef H8300MAGIC
2103     case H8300MAGIC:
2104       arch = bfd_arch_h8300;
2105       machine = bfd_mach_h8300;
2106       /* !! FIXME this probably isn't the right place for this.  */
2107       abfd->flags |= BFD_IS_RELAXABLE;
2108       break;
2109 #endif
2110
2111 #ifdef H8300HMAGIC
2112     case H8300HMAGIC:
2113       arch = bfd_arch_h8300;
2114       machine = bfd_mach_h8300h;
2115       /* !! FIXME this probably isn't the right place for this.  */
2116       abfd->flags |= BFD_IS_RELAXABLE;
2117       break;
2118 #endif
2119
2120 #ifdef H8300SMAGIC
2121     case H8300SMAGIC:
2122       arch = bfd_arch_h8300;
2123       machine = bfd_mach_h8300s;
2124       /* !! FIXME this probably isn't the right place for this.  */
2125       abfd->flags |= BFD_IS_RELAXABLE;
2126       break;
2127 #endif
2128
2129 #ifdef H8300HNMAGIC
2130     case H8300HNMAGIC:
2131       arch = bfd_arch_h8300;
2132       machine = bfd_mach_h8300hn;
2133       /* !! FIXME this probably isn't the right place for this.  */
2134       abfd->flags |= BFD_IS_RELAXABLE;
2135       break;
2136 #endif
2137
2138 #ifdef H8300SNMAGIC
2139     case H8300SNMAGIC:
2140       arch = bfd_arch_h8300;
2141       machine = bfd_mach_h8300sn;
2142       /* !! FIXME this probably isn't the right place for this.  */
2143       abfd->flags |= BFD_IS_RELAXABLE;
2144       break;
2145 #endif
2146
2147 #ifdef SH_ARCH_MAGIC_BIG
2148     case SH_ARCH_MAGIC_BIG:
2149     case SH_ARCH_MAGIC_LITTLE:
2150 #ifdef COFF_WITH_PE
2151     case SH_ARCH_MAGIC_WINCE:
2152 #endif
2153       arch = bfd_arch_sh;
2154       break;
2155 #endif
2156
2157 #ifdef MIPS_ARCH_MAGIC_WINCE
2158     case MIPS_ARCH_MAGIC_WINCE:
2159       arch = bfd_arch_mips;
2160       break;
2161 #endif
2162
2163 #ifdef H8500MAGIC
2164     case H8500MAGIC:
2165       arch = bfd_arch_h8500;
2166       break;
2167 #endif
2168
2169 #ifdef SPARCMAGIC
2170     case SPARCMAGIC:
2171 #ifdef LYNXCOFFMAGIC
2172     case LYNXCOFFMAGIC:
2173 #endif
2174       arch = bfd_arch_sparc;
2175       break;
2176 #endif
2177
2178 #ifdef TIC30MAGIC
2179     case TIC30MAGIC:
2180       arch = bfd_arch_tic30;
2181       break;
2182 #endif
2183
2184 #ifdef TICOFF0MAGIC
2185 #ifdef TICOFF_TARGET_ARCH
2186       /* This TI COFF section should be used by all new TI COFF v0 targets.  */
2187     case TICOFF0MAGIC:
2188       arch = TICOFF_TARGET_ARCH;
2189       machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2190       break;
2191 #endif
2192 #endif
2193
2194 #ifdef TICOFF1MAGIC
2195       /* This TI COFF section should be used by all new TI COFF v1/2 targets.  */
2196       /* TI COFF1 and COFF2 use the target_id field to specify which arch.  */
2197     case TICOFF1MAGIC:
2198     case TICOFF2MAGIC:
2199       switch (internal_f->f_target_id)
2200         {
2201 #ifdef TI_TARGET_ID
2202         case TI_TARGET_ID:
2203           arch = TICOFF_TARGET_ARCH;
2204           machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2205           break;
2206 #endif
2207         default:
2208           arch = bfd_arch_obscure;
2209           (*_bfd_error_handler)
2210             (_("Unrecognized TI COFF target id '0x%x'"),
2211              internal_f->f_target_id);
2212           break;
2213         }
2214       break;
2215 #endif
2216
2217 #ifdef TIC80_ARCH_MAGIC
2218     case TIC80_ARCH_MAGIC:
2219       arch = bfd_arch_tic80;
2220       break;
2221 #endif
2222
2223 #ifdef MCOREMAGIC
2224     case MCOREMAGIC:
2225       arch = bfd_arch_mcore;
2226       break;
2227 #endif
2228
2229 #ifdef W65MAGIC
2230     case W65MAGIC:
2231       arch = bfd_arch_w65;
2232       break;
2233 #endif
2234
2235     default:                    /* Unreadable input file type.  */
2236       arch = bfd_arch_obscure;
2237       break;
2238     }
2239
2240   bfd_default_set_arch_mach (abfd, arch, machine);
2241   return TRUE;
2242 }
2243
2244 #ifdef SYMNAME_IN_DEBUG
2245
2246 static bfd_boolean
2247 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym)
2248 {
2249   return SYMNAME_IN_DEBUG (sym) != 0;
2250 }
2251
2252 #else
2253
2254 #define symname_in_debug_hook \
2255   (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2256
2257 #endif
2258
2259 #ifdef RS6000COFF_C
2260
2261 #ifdef XCOFF64
2262 #define FORCE_SYMNAMES_IN_STRINGS
2263 #endif
2264
2265 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
2266
2267 static bfd_boolean
2268 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2269                           combined_entry_type *table_base,
2270                           combined_entry_type *symbol,
2271                           unsigned int indaux,
2272                           combined_entry_type *aux)
2273 {
2274   int class = symbol->u.syment.n_sclass;
2275
2276   if ((class == C_EXT || class == C_HIDEXT)
2277       && indaux + 1 == symbol->u.syment.n_numaux)
2278     {
2279       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2280         {
2281           aux->u.auxent.x_csect.x_scnlen.p =
2282             table_base + aux->u.auxent.x_csect.x_scnlen.l;
2283           aux->fix_scnlen = 1;
2284         }
2285
2286       /* Return TRUE to indicate that the caller should not do any
2287          further work on this auxent.  */
2288       return TRUE;
2289     }
2290
2291   /* Return FALSE to indicate that this auxent should be handled by
2292      the caller.  */
2293   return FALSE;
2294 }
2295
2296 #else
2297 #ifdef I960
2298
2299 /* We don't want to pointerize bal entries.  */
2300
2301 static bfd_boolean
2302 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2303                           combined_entry_type *table_base ATTRIBUTE_UNUSED,
2304                           combined_entry_type *symbol,
2305                           unsigned int indaux,
2306                           combined_entry_type *aux ATTRIBUTE_UNUSED)
2307 {
2308   /* Return TRUE if we don't want to pointerize this aux entry, which
2309      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
2310   return (indaux == 1
2311           && (symbol->u.syment.n_sclass == C_LEAFPROC
2312               || symbol->u.syment.n_sclass == C_LEAFSTAT
2313               || symbol->u.syment.n_sclass == C_LEAFEXT));
2314 }
2315
2316 #else /* ! I960 */
2317
2318 #define coff_pointerize_aux_hook 0
2319
2320 #endif /* ! I960 */
2321 #endif /* ! RS6000COFF_C */
2322
2323 /* Print an aux entry.  This returns TRUE if it has printed it.  */
2324
2325 static bfd_boolean
2326 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
2327                 FILE *file ATTRIBUTE_UNUSED,
2328                 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2329                 combined_entry_type *symbol ATTRIBUTE_UNUSED,
2330                 combined_entry_type *aux ATTRIBUTE_UNUSED,
2331                 unsigned int indaux ATTRIBUTE_UNUSED)
2332 {
2333 #ifdef RS6000COFF_C
2334   if ((symbol->u.syment.n_sclass == C_EXT
2335        || symbol->u.syment.n_sclass == C_HIDEXT)
2336       && indaux + 1 == symbol->u.syment.n_numaux)
2337     {
2338       /* This is a csect entry.  */
2339       fprintf (file, "AUX ");
2340       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2341         {
2342           BFD_ASSERT (! aux->fix_scnlen);
2343 #ifdef XCOFF64
2344           fprintf (file, "val %5lld",
2345                    (long long) aux->u.auxent.x_csect.x_scnlen.l);
2346 #else
2347           fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2348 #endif
2349         }
2350       else
2351         {
2352           fprintf (file, "indx ");
2353           if (! aux->fix_scnlen)
2354 #ifdef XCOFF64
2355             fprintf (file, "%4lld",
2356                      (long long) aux->u.auxent.x_csect.x_scnlen.l);
2357 #else
2358             fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2359 #endif
2360           else
2361             fprintf (file, "%4ld",
2362                      (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2363         }
2364       fprintf (file,
2365                " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2366                aux->u.auxent.x_csect.x_parmhash,
2367                (unsigned int) aux->u.auxent.x_csect.x_snhash,
2368                SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2369                SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2370                (unsigned int) aux->u.auxent.x_csect.x_smclas,
2371                aux->u.auxent.x_csect.x_stab,
2372                (unsigned int) aux->u.auxent.x_csect.x_snstab);
2373       return TRUE;
2374     }
2375 #endif
2376
2377   /* Return FALSE to indicate that no special action was taken.  */
2378   return FALSE;
2379 }
2380
2381 /*
2382 SUBSUBSECTION
2383         Writing relocations
2384
2385         To write relocations, the back end steps though the
2386         canonical relocation table and create an
2387         @code{internal_reloc}. The symbol index to use is removed from
2388         the @code{offset} field in the symbol table supplied.  The
2389         address comes directly from the sum of the section base
2390         address and the relocation offset; the type is dug directly
2391         from the howto field.  Then the @code{internal_reloc} is
2392         swapped into the shape of an @code{external_reloc} and written
2393         out to disk.
2394
2395 */
2396
2397 #ifdef TARG_AUX
2398
2399
2400 /* AUX's ld wants relocations to be sorted.  */
2401 static int
2402 compare_arelent_ptr (const void * x, const void * y)
2403 {
2404   const arelent **a = (const arelent **) x;
2405   const arelent **b = (const arelent **) y;
2406   bfd_size_type aadr = (*a)->address;
2407   bfd_size_type badr = (*b)->address;
2408
2409   return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2410 }
2411
2412 #endif /* TARG_AUX */
2413
2414 static bfd_boolean
2415 coff_write_relocs (bfd * abfd, int first_undef)
2416 {
2417   asection *s;
2418
2419   for (s = abfd->sections; s != NULL; s = s->next)
2420     {
2421       unsigned int i;
2422       struct external_reloc dst;
2423       arelent **p;
2424
2425 #ifndef TARG_AUX
2426       p = s->orelocation;
2427 #else
2428       {
2429         /* Sort relocations before we write them out.  */
2430         bfd_size_type amt;
2431
2432         amt = s->reloc_count;
2433         amt *= sizeof (arelent *);
2434         p = bfd_malloc (amt);
2435         if (p == NULL && s->reloc_count > 0)
2436           return FALSE;
2437         memcpy (p, s->orelocation, (size_t) amt);
2438         qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2439       }
2440 #endif
2441
2442       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2443         return FALSE;
2444
2445 #ifdef COFF_WITH_PE
2446       if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2447         {
2448           /* Encode real count here as first reloc.  */
2449           struct internal_reloc n;
2450
2451           memset (& n, 0, sizeof (n));
2452           /* Add one to count *this* reloc (grr).  */
2453           n.r_vaddr = s->reloc_count + 1;
2454           coff_swap_reloc_out (abfd, &n, &dst);
2455           if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2456                           abfd) != bfd_coff_relsz (abfd))
2457             return FALSE;
2458         }
2459 #endif
2460
2461       for (i = 0; i < s->reloc_count; i++)
2462         {
2463           struct internal_reloc n;
2464           arelent *q = p[i];
2465
2466           memset (& n, 0, sizeof (n));
2467
2468           /* Now we've renumbered the symbols we know where the
2469              undefined symbols live in the table.  Check the reloc
2470              entries for symbols who's output bfd isn't the right one.
2471              This is because the symbol was undefined (which means
2472              that all the pointers are never made to point to the same
2473              place). This is a bad thing,'cause the symbols attached
2474              to the output bfd are indexed, so that the relocation
2475              entries know which symbol index they point to.  So we
2476              have to look up the output symbol here.  */
2477
2478           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2479             {
2480               int j;
2481               const char *sname = q->sym_ptr_ptr[0]->name;
2482               asymbol **outsyms = abfd->outsymbols;
2483
2484               for (j = first_undef; outsyms[j]; j++)
2485                 {
2486                   const char *intable = outsyms[j]->name;
2487
2488                   if (strcmp (intable, sname) == 0)
2489                     {
2490                       /* Got a hit, so repoint the reloc.  */
2491                       q->sym_ptr_ptr = outsyms + j;
2492                       break;
2493                     }
2494                 }
2495             }
2496
2497           n.r_vaddr = q->address + s->vma;
2498
2499 #ifdef R_IHCONST
2500           /* The 29k const/consth reloc pair is a real kludge.  The consth
2501              part doesn't have a symbol; it has an offset.  So rebuilt
2502              that here.  */
2503           if (q->howto->type == R_IHCONST)
2504             n.r_symndx = q->addend;
2505           else
2506 #endif
2507             if (q->sym_ptr_ptr)
2508               {
2509 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2510                 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
2511 #else
2512                 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2513                     && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2514 #endif
2515                   /* This is a relocation relative to the absolute symbol.  */
2516                   n.r_symndx = -1;
2517                 else
2518                   {
2519                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2520                     /* Take notice if the symbol reloc points to a symbol
2521                        we don't have in our symbol table.  What should we
2522                        do for this??  */
2523                     if (n.r_symndx > obj_conv_table_size (abfd))
2524                       abort ();
2525                   }
2526               }
2527
2528 #ifdef SWAP_OUT_RELOC_OFFSET
2529           n.r_offset = q->addend;
2530 #endif
2531
2532 #ifdef SELECT_RELOC
2533           /* Work out reloc type from what is required.  */
2534           SELECT_RELOC (n, q->howto);
2535 #else
2536           n.r_type = q->howto->type;
2537 #endif
2538           coff_swap_reloc_out (abfd, &n, &dst);
2539
2540           if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2541                          abfd) != bfd_coff_relsz (abfd))
2542             return FALSE;
2543         }
2544
2545 #ifdef TARG_AUX
2546       if (p != NULL)
2547         free (p);
2548 #endif
2549     }
2550
2551   return TRUE;
2552 }
2553
2554 /* Set flags and magic number of a coff file from architecture and machine
2555    type.  Result is TRUE if we can represent the arch&type, FALSE if not.  */
2556
2557 static bfd_boolean
2558 coff_set_flags (bfd * abfd,
2559                 unsigned int *magicp ATTRIBUTE_UNUSED,
2560                 unsigned short *flagsp ATTRIBUTE_UNUSED)
2561 {
2562   switch (bfd_get_arch (abfd))
2563     {
2564 #ifdef Z8KMAGIC
2565     case bfd_arch_z8k:
2566       *magicp = Z8KMAGIC;
2567
2568       switch (bfd_get_mach (abfd))
2569         {
2570         case bfd_mach_z8001: *flagsp = F_Z8001; break;
2571         case bfd_mach_z8002: *flagsp = F_Z8002; break;
2572         default:             return FALSE;
2573         }
2574       return TRUE;
2575 #endif
2576
2577 #ifdef I960ROMAGIC
2578     case bfd_arch_i960:
2579
2580       {
2581         unsigned flags;
2582
2583         *magicp = I960ROMAGIC;
2584
2585         switch (bfd_get_mach (abfd))
2586           {
2587           case bfd_mach_i960_core:  flags = F_I960CORE; break;
2588           case bfd_mach_i960_kb_sb: flags = F_I960KB;   break;
2589           case bfd_mach_i960_mc:    flags = F_I960MC;   break;
2590           case bfd_mach_i960_xa:    flags = F_I960XA;   break;
2591           case bfd_mach_i960_ca:    flags = F_I960CA;   break;
2592           case bfd_mach_i960_ka_sa: flags = F_I960KA;   break;
2593           case bfd_mach_i960_jx:    flags = F_I960JX;   break;
2594           case bfd_mach_i960_hx:    flags = F_I960HX;   break;
2595           default:                  return FALSE;
2596           }
2597         *flagsp = flags;
2598         return TRUE;
2599       }
2600       break;
2601 #endif
2602
2603 #ifdef TIC30MAGIC
2604     case bfd_arch_tic30:
2605       *magicp = TIC30MAGIC;
2606       return TRUE;
2607 #endif
2608
2609 #ifdef TICOFF_DEFAULT_MAGIC
2610     case TICOFF_TARGET_ARCH:
2611       /* If there's no indication of which version we want, use the default.  */
2612       if (!abfd->xvec )
2613         *magicp = TICOFF_DEFAULT_MAGIC;
2614       else
2615         {
2616           /* We may want to output in a different COFF version.  */
2617           switch (abfd->xvec->name[4])
2618             {
2619             case '0':
2620               *magicp = TICOFF0MAGIC;
2621               break;
2622             case '1':
2623               *magicp = TICOFF1MAGIC;
2624               break;
2625             case '2':
2626               *magicp = TICOFF2MAGIC;
2627               break;
2628             default:
2629               return FALSE;
2630             }
2631         }
2632       TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2633       return TRUE;
2634 #endif
2635
2636 #ifdef TIC80_ARCH_MAGIC
2637     case bfd_arch_tic80:
2638       *magicp = TIC80_ARCH_MAGIC;
2639       return TRUE;
2640 #endif
2641
2642 #ifdef ARMMAGIC
2643     case bfd_arch_arm:
2644 #ifdef ARM_WINCE
2645       * magicp = ARMPEMAGIC;
2646 #else
2647       * magicp = ARMMAGIC;
2648 #endif
2649       * flagsp = 0;
2650       if (APCS_SET (abfd))
2651         {
2652           if (APCS_26_FLAG (abfd))
2653             * flagsp |= F_APCS26;
2654
2655           if (APCS_FLOAT_FLAG (abfd))
2656             * flagsp |= F_APCS_FLOAT;
2657
2658           if (PIC_FLAG (abfd))
2659             * flagsp |= F_PIC;
2660         }
2661       if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2662         * flagsp |= F_INTERWORK;
2663       switch (bfd_get_mach (abfd))
2664         {
2665         case bfd_mach_arm_2:  * flagsp |= F_ARM_2;  break;
2666         case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2667         case bfd_mach_arm_3:  * flagsp |= F_ARM_3;  break;
2668         case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2669         case bfd_mach_arm_4:  * flagsp |= F_ARM_4;  break;
2670         case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2671         case bfd_mach_arm_5:  * flagsp |= F_ARM_5;  break;
2672           /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2673              See also the comment in coff_set_arch_mach_hook().  */
2674         case bfd_mach_arm_5T: * flagsp |= F_ARM_5;  break;
2675         case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2676         case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2677         }
2678       return TRUE;
2679 #endif
2680
2681 #ifdef PPCMAGIC
2682     case bfd_arch_powerpc:
2683       *magicp = PPCMAGIC;
2684       return TRUE;
2685 #endif
2686
2687 #ifdef I386MAGIC
2688     case bfd_arch_i386:
2689       *magicp = I386MAGIC;
2690 #ifdef LYNXOS
2691       /* Just overwrite the usual value if we're doing Lynx.  */
2692       *magicp = LYNXCOFFMAGIC;
2693 #endif
2694       return TRUE;
2695 #endif
2696
2697 #ifdef I860MAGIC
2698     case bfd_arch_i860:
2699       *magicp = I860MAGIC;
2700       return TRUE;
2701 #endif
2702
2703 #ifdef IA64MAGIC
2704     case bfd_arch_ia64:
2705       *magicp = IA64MAGIC;
2706       return TRUE;
2707 #endif
2708
2709 #ifdef MC68MAGIC
2710     case bfd_arch_m68k:
2711 #ifdef APOLLOM68KMAGIC
2712       *magicp = APOLLO_COFF_VERSION_NUMBER;
2713 #else
2714       /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c.  */
2715 #ifdef NAMES_HAVE_UNDERSCORE
2716       *magicp = MC68KBCSMAGIC;
2717 #else
2718       *magicp = MC68MAGIC;
2719 #endif
2720 #endif
2721 #ifdef LYNXOS
2722       /* Just overwrite the usual value if we're doing Lynx.  */
2723       *magicp = LYNXCOFFMAGIC;
2724 #endif
2725       return TRUE;
2726 #endif
2727
2728 #ifdef MC88MAGIC
2729     case bfd_arch_m88k:
2730       *magicp = MC88OMAGIC;
2731       return TRUE;
2732 #endif
2733
2734 #ifdef H8300MAGIC
2735     case bfd_arch_h8300:
2736       switch (bfd_get_mach (abfd))
2737         {
2738         case bfd_mach_h8300:   *magicp = H8300MAGIC;   return TRUE;
2739         case bfd_mach_h8300h:  *magicp = H8300HMAGIC;  return TRUE;
2740         case bfd_mach_h8300s:  *magicp = H8300SMAGIC;  return TRUE;
2741         case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE;
2742         case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE;
2743         default: break;
2744         }
2745       break;
2746 #endif
2747
2748 #ifdef SH_ARCH_MAGIC_BIG
2749     case bfd_arch_sh:
2750 #ifdef COFF_IMAGE_WITH_PE
2751       *magicp = SH_ARCH_MAGIC_WINCE;
2752 #else
2753       if (bfd_big_endian (abfd))
2754         *magicp = SH_ARCH_MAGIC_BIG;
2755       else
2756         *magicp = SH_ARCH_MAGIC_LITTLE;
2757 #endif
2758       return TRUE;
2759 #endif
2760
2761 #ifdef MIPS_ARCH_MAGIC_WINCE
2762     case bfd_arch_mips:
2763       *magicp = MIPS_ARCH_MAGIC_WINCE;
2764       return TRUE;
2765 #endif
2766
2767 #ifdef SPARCMAGIC
2768     case bfd_arch_sparc:
2769       *magicp = SPARCMAGIC;
2770 #ifdef LYNXOS
2771       /* Just overwrite the usual value if we're doing Lynx.  */
2772       *magicp = LYNXCOFFMAGIC;
2773 #endif
2774       return TRUE;
2775 #endif
2776
2777 #ifdef H8500MAGIC
2778     case bfd_arch_h8500:
2779       *magicp = H8500MAGIC;
2780       return TRUE;
2781       break;
2782 #endif
2783
2784 #ifdef A29K_MAGIC_BIG
2785     case bfd_arch_a29k:
2786       if (bfd_big_endian (abfd))
2787         *magicp = A29K_MAGIC_BIG;
2788       else
2789         *magicp = A29K_MAGIC_LITTLE;
2790       return TRUE;
2791 #endif
2792
2793 #ifdef WE32KMAGIC
2794     case bfd_arch_we32k:
2795       *magicp = WE32KMAGIC;
2796       return TRUE;
2797 #endif
2798
2799 #ifdef RS6000COFF_C
2800     case bfd_arch_rs6000:
2801 #ifndef PPCMAGIC
2802     case bfd_arch_powerpc:
2803 #endif
2804       BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2805       *magicp = bfd_xcoff_magic_number (abfd);
2806       return TRUE;
2807 #endif
2808
2809 #ifdef MCOREMAGIC
2810     case bfd_arch_mcore:
2811       * magicp = MCOREMAGIC;
2812       return TRUE;
2813 #endif
2814
2815 #ifdef W65MAGIC
2816     case bfd_arch_w65:
2817       *magicp = W65MAGIC;
2818       return TRUE;
2819 #endif
2820
2821 #ifdef OR32_MAGIC_BIG
2822     case bfd_arch_or32:
2823       if (bfd_big_endian (abfd))
2824         * magicp = OR32_MAGIC_BIG;
2825       else
2826         * magicp = OR32_MAGIC_LITTLE;
2827       return TRUE;
2828 #endif
2829
2830 #ifdef MAXQ20MAGIC
2831     case bfd_arch_maxq:
2832       * magicp = MAXQ20MAGIC;
2833       switch (bfd_get_mach (abfd))
2834         {
2835         case bfd_mach_maxq10: * flagsp = F_MAXQ10; return TRUE;
2836         case bfd_mach_maxq20: * flagsp = F_MAXQ20; return TRUE;
2837         default:              return FALSE;
2838         }
2839 #endif
2840
2841     default:                    /* Unknown architecture.  */
2842       /* Fall through to "return FALSE" below, to avoid
2843          "statement never reached" errors on the one below.  */
2844       break;
2845     }
2846
2847   return FALSE;
2848 }
2849
2850 static bfd_boolean
2851 coff_set_arch_mach (bfd * abfd,
2852                     enum bfd_architecture arch,
2853                     unsigned long machine)
2854 {
2855   unsigned dummy1;
2856   unsigned short dummy2;
2857
2858   if (! bfd_default_set_arch_mach (abfd, arch, machine))
2859     return FALSE;
2860
2861   if (arch != bfd_arch_unknown
2862       && ! coff_set_flags (abfd, &dummy1, &dummy2))
2863     return FALSE;               /* We can't represent this type.  */
2864
2865   return TRUE;                  /* We're easy...  */
2866 }
2867
2868 #ifdef COFF_IMAGE_WITH_PE
2869
2870 /* This is used to sort sections by VMA, as required by PE image
2871    files.  */
2872
2873 static int
2874 sort_by_secaddr (const void * arg1, const void * arg2)
2875 {
2876   const asection *a = *(const asection **) arg1;
2877   const asection *b = *(const asection **) arg2;
2878
2879   if (a->vma < b->vma)
2880     return -1;
2881   else if (a->vma > b->vma)
2882     return 1;
2883
2884   return 0;
2885 }
2886
2887 #endif /* COFF_IMAGE_WITH_PE */
2888
2889 /* Calculate the file position for each section.  */
2890
2891 #ifndef I960
2892 #define ALIGN_SECTIONS_IN_FILE
2893 #endif
2894 #if defined(TIC80COFF) || defined(TICOFF)
2895 #undef ALIGN_SECTIONS_IN_FILE
2896 #endif
2897
2898 static bfd_boolean
2899 coff_compute_section_file_positions (bfd * abfd)
2900 {
2901   asection *current;
2902   asection *previous = NULL;
2903   file_ptr sofar = bfd_coff_filhsz (abfd);
2904   bfd_boolean align_adjust;
2905 #ifdef ALIGN_SECTIONS_IN_FILE
2906   file_ptr old_sofar;
2907 #endif
2908
2909 #ifdef RS6000COFF_C
2910   /* On XCOFF, if we have symbols, set up the .debug section.  */
2911   if (bfd_get_symcount (abfd) > 0)
2912     {
2913       bfd_size_type sz;
2914       bfd_size_type i, symcount;
2915       asymbol **symp;
2916
2917       sz = 0;
2918       symcount = bfd_get_symcount (abfd);
2919       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2920         {
2921           coff_symbol_type *cf;
2922
2923           cf = coff_symbol_from (abfd, *symp);
2924           if (cf != NULL
2925               && cf->native != NULL
2926               && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2927             {
2928               size_t len;
2929
2930               len = strlen (bfd_asymbol_name (*symp));
2931               if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2932                 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
2933             }
2934         }
2935       if (sz > 0)
2936         {
2937           asection *dsec;
2938
2939           dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
2940           if (dsec == NULL)
2941             abort ();
2942           dsec->size = sz;
2943           dsec->flags |= SEC_HAS_CONTENTS;
2944         }
2945     }
2946 #endif
2947
2948 #ifdef COFF_IMAGE_WITH_PE
2949   int page_size;
2950
2951   if (coff_data (abfd)->link_info)
2952     {
2953       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2954
2955       /* If no file alignment has been set, default to one.
2956          This repairs 'ld -r' for arm-wince-pe target.  */
2957       if (page_size == 0)
2958         page_size = 1;
2959     }
2960   else
2961     page_size = PE_DEF_FILE_ALIGNMENT;
2962 #else
2963 #ifdef COFF_PAGE_SIZE
2964   int page_size = COFF_PAGE_SIZE;
2965 #endif
2966 #endif
2967
2968   if (bfd_get_start_address (abfd))
2969     /*  A start address may have been added to the original file. In this
2970         case it will need an optional header to record it.  */
2971     abfd->flags |= EXEC_P;
2972
2973   if (abfd->flags & EXEC_P)
2974     sofar += bfd_coff_aoutsz (abfd);
2975 #ifdef RS6000COFF_C
2976   else if (xcoff_data (abfd)->full_aouthdr)
2977     sofar += bfd_coff_aoutsz (abfd);
2978   else
2979     sofar += SMALL_AOUTSZ;
2980 #endif
2981
2982   sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2983
2984 #ifdef RS6000COFF_C
2985   /* XCOFF handles overflows in the reloc and line number count fields
2986      by allocating a new section header to hold the correct counts.  */
2987   for (current = abfd->sections; current != NULL; current = current->next)
2988     if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2989       sofar += bfd_coff_scnhsz (abfd);
2990 #endif
2991
2992 #ifdef COFF_IMAGE_WITH_PE
2993   {
2994     /* PE requires the sections to be in memory order when listed in
2995        the section headers.  It also does not like empty loadable
2996        sections.  The sections apparently do not have to be in the
2997        right order in the image file itself, but we do need to get the
2998        target_index values right.  */
2999
3000     unsigned int count;
3001     asection **section_list;
3002     unsigned int i;
3003     int target_index;
3004     bfd_size_type amt;
3005
3006     count = 0;
3007     for (current = abfd->sections; current != NULL; current = current->next)
3008       ++count;
3009
3010     /* We allocate an extra cell to simplify the final loop.  */
3011     amt = sizeof (struct asection *) * (count + 1);
3012     section_list = bfd_malloc (amt);
3013     if (section_list == NULL)
3014       return FALSE;
3015
3016     i = 0;
3017     for (current = abfd->sections; current != NULL; current = current->next)
3018       {
3019         section_list[i] = current;
3020         ++i;
3021       }
3022     section_list[i] = NULL;
3023
3024     qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3025
3026     /* Rethread the linked list into sorted order; at the same time,
3027        assign target_index values.  */
3028     target_index = 1;
3029     abfd->sections = NULL;
3030     abfd->section_last = NULL;
3031     for (i = 0; i < count; i++)
3032       {
3033         current = section_list[i];
3034         bfd_section_list_append (abfd, current);
3035
3036         /* Later, if the section has zero size, we'll be throwing it
3037            away, so we don't want to number it now.  Note that having
3038            a zero size and having real contents are different
3039            concepts: .bss has no contents, but (usually) non-zero
3040            size.  */
3041         if (current->size == 0)
3042           {
3043             /* Discard.  However, it still might have (valid) symbols
3044                in it, so arbitrarily set it to section 1 (indexing is
3045                1-based here; usually .text).  __end__ and other
3046                contents of .endsection really have this happen.
3047                FIXME: This seems somewhat dubious.  */
3048             current->target_index = 1;
3049           }
3050         else
3051           current->target_index = target_index++;
3052       }
3053
3054     free (section_list);
3055   }
3056 #else /* ! COFF_IMAGE_WITH_PE */
3057   {
3058     /* Set the target_index field.  */
3059     int target_index;
3060
3061     target_index = 1;
3062     for (current = abfd->sections; current != NULL; current = current->next)
3063       current->target_index = target_index++;
3064   }
3065 #endif /* ! COFF_IMAGE_WITH_PE */
3066
3067   align_adjust = FALSE;
3068   for (current = abfd->sections;
3069        current != NULL;
3070        current = current->next)
3071     {
3072 #ifdef COFF_IMAGE_WITH_PE
3073       /* With PE we have to pad each section to be a multiple of its
3074          page size too, and remember both sizes.  */
3075       if (coff_section_data (abfd, current) == NULL)
3076         {
3077           bfd_size_type amt = sizeof (struct coff_section_tdata);
3078
3079           current->used_by_bfd = bfd_zalloc (abfd, amt);
3080           if (current->used_by_bfd == NULL)
3081             return FALSE;
3082         }
3083       if (pei_section_data (abfd, current) == NULL)
3084         {
3085           bfd_size_type amt = sizeof (struct pei_section_tdata);
3086
3087           coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
3088           if (coff_section_data (abfd, current)->tdata == NULL)
3089             return FALSE;
3090         }
3091       if (pei_section_data (abfd, current)->virt_size == 0)
3092         pei_section_data (abfd, current)->virt_size = current->size;
3093 #endif
3094
3095       /* Only deal with sections which have contents.  */
3096       if (!(current->flags & SEC_HAS_CONTENTS))
3097         continue;
3098
3099 #ifdef COFF_IMAGE_WITH_PE
3100       /* Make sure we skip empty sections in a PE image.  */
3101       if (current->size == 0)
3102         continue;
3103 #endif
3104
3105       /* Align the sections in the file to the same boundary on
3106          which they are aligned in virtual memory.  I960 doesn't
3107          do this (FIXME) so we can stay in sync with Intel.  960
3108          doesn't yet page from files...  */
3109 #ifdef ALIGN_SECTIONS_IN_FILE
3110       if ((abfd->flags & EXEC_P) != 0)
3111         {
3112           /* Make sure this section is aligned on the right boundary - by
3113              padding the previous section up if necessary.  */
3114           old_sofar = sofar;
3115
3116 #ifdef RS6000COFF_C
3117           /* AIX loader checks the text section alignment of (vma - filepos)
3118              So even though the filepos may be aligned wrt the o_algntext, for
3119              AIX executables, this check fails. This shows up when a native
3120              AIX executable is stripped with gnu strip because the default vma
3121              of native is 0x10000150 but default for gnu is 0x10000140.  Gnu
3122              stripped gnu excutable passes this check because the filepos is
3123              0x0140.  This problem also show up with 64 bit shared objects. The
3124              data section must also be aligned.  */
3125           if (!strcmp (current->name, _TEXT)
3126               || !strcmp (current->name, _DATA))
3127             {
3128               bfd_vma pad;
3129               bfd_vma align;
3130
3131               sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3132
3133               align = 1 << current->alignment_power;
3134               pad = abs (current->vma - sofar) % align;
3135
3136               if (pad)
3137                 {
3138                   pad = align - pad;
3139                   sofar += pad;
3140                 }
3141             }
3142           else
3143 #else
3144             {
3145               sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3146             }
3147 #endif
3148           if (previous != NULL)
3149             previous->size += sofar - old_sofar;
3150         }
3151
3152 #endif
3153
3154       /* In demand paged files the low order bits of the file offset
3155          must match the low order bits of the virtual address.  */
3156 #ifdef COFF_PAGE_SIZE
3157       if ((abfd->flags & D_PAGED) != 0
3158           && (current->flags & SEC_ALLOC) != 0)
3159         sofar += (current->vma - (bfd_vma) sofar) % page_size;
3160 #endif
3161       current->filepos = sofar;
3162
3163 #ifdef COFF_IMAGE_WITH_PE
3164       /* Set the padded size.  */
3165       current->size = (current->size + page_size -1) & -page_size;
3166 #endif
3167
3168       sofar += current->size;
3169
3170 #ifdef ALIGN_SECTIONS_IN_FILE
3171       /* Make sure that this section is of the right size too.  */
3172       if ((abfd->flags & EXEC_P) == 0)
3173         {
3174           bfd_size_type old_size;
3175
3176           old_size = current->size;
3177           current->size = BFD_ALIGN (current->size,
3178                                      1 << current->alignment_power);
3179           align_adjust = current->size != old_size;
3180           sofar += current->size - old_size;
3181         }
3182       else
3183         {
3184           old_sofar = sofar;
3185           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3186           align_adjust = sofar != old_sofar;
3187           current->size += sofar - old_sofar;
3188         }
3189 #endif
3190
3191 #ifdef COFF_IMAGE_WITH_PE
3192       /* For PE we need to make sure we pad out to the aligned
3193          size, in case the caller only writes out data to the
3194          unaligned size.  */
3195       if (pei_section_data (abfd, current)->virt_size < current->size)
3196         align_adjust = TRUE;
3197 #endif
3198
3199 #ifdef _LIB
3200       /* Force .lib sections to start at zero.  The vma is then
3201          incremented in coff_set_section_contents.  This is right for
3202          SVR3.2.  */
3203       if (strcmp (current->name, _LIB) == 0)
3204         bfd_set_section_vma (abfd, current, 0);
3205 #endif
3206
3207       previous = current;
3208     }
3209
3210   /* It is now safe to write to the output file.  If we needed an
3211      alignment adjustment for the last section, then make sure that
3212      there is a byte at offset sofar.  If there are no symbols and no
3213      relocs, then nothing follows the last section.  If we don't force
3214      the last byte out, then the file may appear to be truncated.  */
3215   if (align_adjust)
3216     {
3217       bfd_byte b;
3218
3219       b = 0;
3220       if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3221           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3222         return FALSE;
3223     }
3224
3225   /* Make sure the relocations are aligned.  We don't need to make
3226      sure that this byte exists, because it will only matter if there
3227      really are relocs.  */
3228   sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3229
3230   obj_relocbase (abfd) = sofar;
3231   abfd->output_has_begun = TRUE;
3232
3233   return TRUE;
3234 }
3235
3236 #ifdef COFF_IMAGE_WITH_PE
3237
3238 static unsigned int pelength;
3239 static unsigned int peheader;
3240
3241 static bfd_boolean
3242 coff_read_word (bfd *abfd, unsigned int *value)
3243 {
3244   unsigned char b[2];
3245   int status;
3246
3247   status = bfd_bread (b, (bfd_size_type) 2, abfd);
3248   if (status < 1)
3249     {
3250       *value = 0;
3251       return FALSE;
3252     }
3253
3254   if (status == 1)
3255     *value = (unsigned int) b[0];
3256   else
3257     *value = (unsigned int) (b[0] + (b[1] << 8));
3258
3259   pelength += (unsigned int) status;
3260
3261   return TRUE;
3262 }
3263
3264 static unsigned int
3265 coff_compute_checksum (bfd *abfd)
3266 {
3267   bfd_boolean more_data;
3268   file_ptr filepos;
3269   unsigned int value;
3270   unsigned int total;
3271
3272   total = 0;
3273   pelength = 0;
3274   filepos = (file_ptr) 0;
3275
3276   do
3277     {
3278       if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3279         return 0;
3280
3281       more_data = coff_read_word (abfd, &value);
3282       total += value;
3283       total = 0xffff & (total + (total >> 0x10));
3284       filepos += 2;
3285     }
3286   while (more_data);
3287
3288   return (0xffff & (total + (total >> 0x10)));
3289 }
3290
3291 static bfd_boolean
3292 coff_apply_checksum (bfd *abfd)
3293 {
3294   unsigned int computed;
3295   unsigned int checksum = 0;
3296
3297   if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3298     return FALSE;
3299
3300   if (!coff_read_word (abfd, &peheader))
3301     return FALSE;
3302
3303   if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3304     return FALSE;
3305
3306   checksum = 0;
3307   bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3308
3309   if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3310     return FALSE;
3311
3312   computed = coff_compute_checksum (abfd);
3313
3314   checksum = computed + pelength;
3315
3316   if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3317     return FALSE;
3318
3319   bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3320
3321   return TRUE;
3322 }
3323
3324 #endif /* COFF_IMAGE_WITH_PE */
3325
3326 static bfd_boolean
3327 coff_write_object_contents (bfd * abfd)
3328 {
3329   asection *current;
3330   bfd_boolean hasrelocs = FALSE;
3331   bfd_boolean haslinno = FALSE;
3332   bfd_boolean hasdebug = FALSE;
3333   file_ptr scn_base;
3334   file_ptr reloc_base;
3335   file_ptr lineno_base;
3336   file_ptr sym_base;
3337   unsigned long reloc_size = 0, reloc_count = 0;
3338   unsigned long lnno_size = 0;
3339   bfd_boolean long_section_names;
3340   asection *text_sec = NULL;
3341   asection *data_sec = NULL;
3342   asection *bss_sec = NULL;
3343   struct internal_filehdr internal_f;
3344   struct internal_aouthdr internal_a;
3345 #ifdef COFF_LONG_SECTION_NAMES
3346   size_t string_size = STRING_SIZE_SIZE;
3347 #endif
3348
3349   bfd_set_error (bfd_error_system_call);
3350
3351   /* Make a pass through the symbol table to count line number entries and
3352      put them into the correct asections.  */
3353   lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3354
3355   if (! abfd->output_has_begun)
3356     {
3357       if (! coff_compute_section_file_positions (abfd))
3358         return FALSE;
3359     }
3360
3361   reloc_base = obj_relocbase (abfd);
3362
3363   /* Work out the size of the reloc and linno areas.  */
3364
3365   for (current = abfd->sections; current != NULL; current =
3366        current->next)
3367     {
3368 #ifdef COFF_WITH_PE
3369       /* We store the actual reloc count in the first reloc's addr.  */
3370       if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3371         reloc_count ++;
3372 #endif
3373       reloc_count += current->reloc_count;
3374     }
3375
3376   reloc_size = reloc_count * bfd_coff_relsz (abfd);
3377
3378   lineno_base = reloc_base + reloc_size;
3379   sym_base = lineno_base + lnno_size;
3380
3381   /* Indicate in each section->line_filepos its actual file address.  */
3382   for (current = abfd->sections; current != NULL; current =
3383        current->next)
3384     {
3385       if (current->lineno_count)
3386         {
3387           current->line_filepos = lineno_base;
3388           current->moving_line_filepos = lineno_base;
3389           lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3390         }
3391       else
3392         current->line_filepos = 0;
3393
3394       if (current->reloc_count)
3395         {
3396           current->rel_filepos = reloc_base;
3397           reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3398 #ifdef COFF_WITH_PE
3399           /* Extra reloc to hold real count.  */
3400           if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3401             reloc_base += bfd_coff_relsz (abfd);
3402 #endif
3403         }
3404       else
3405         current->rel_filepos = 0;
3406     }
3407
3408   /* Write section headers to the file.  */
3409   internal_f.f_nscns = 0;
3410
3411   if ((abfd->flags & EXEC_P) != 0)
3412     scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3413   else
3414     {
3415       scn_base = bfd_coff_filhsz (abfd);
3416 #ifdef RS6000COFF_C
3417 #ifndef XCOFF64
3418       if (xcoff_data (abfd)->full_aouthdr)
3419         scn_base += bfd_coff_aoutsz (abfd);
3420       else
3421         scn_base += SMALL_AOUTSZ;
3422 #endif
3423 #endif
3424     }
3425
3426   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3427     return FALSE;
3428
3429   long_section_names = FALSE;
3430   for (current = abfd->sections;
3431        current != NULL;
3432        current = current->next)
3433     {
3434       struct internal_scnhdr section;
3435       bfd_boolean is_reloc_section = FALSE;
3436
3437 #ifdef COFF_IMAGE_WITH_PE
3438       if (strcmp (current->name, ".reloc") == 0)
3439         {
3440           is_reloc_section = TRUE;
3441           hasrelocs = TRUE;
3442           pe_data (abfd)->has_reloc_section = 1;
3443         }
3444 #endif
3445
3446       internal_f.f_nscns++;
3447
3448       strncpy (section.s_name, current->name, SCNNMLEN);
3449
3450 #ifdef COFF_LONG_SECTION_NAMES
3451       /* Handle long section names as in PE.  This must be compatible
3452          with the code in coff_write_symbols and _bfd_coff_final_link.  */
3453       {
3454         size_t len;
3455
3456         len = strlen (current->name);
3457         if (len > SCNNMLEN)
3458           {
3459             memset (section.s_name, 0, SCNNMLEN);
3460             sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3461             string_size += len + 1;
3462             long_section_names = TRUE;
3463           }
3464       }
3465 #endif
3466
3467 #ifdef _LIB
3468       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
3469          Ian Taylor <ian@cygnus.com>.  */
3470       if (strcmp (current->name, _LIB) == 0)
3471         section.s_vaddr = 0;
3472       else
3473 #endif
3474       section.s_vaddr = current->vma;
3475       section.s_paddr = current->lma;
3476       section.s_size =  current->size;
3477 #ifdef coff_get_section_load_page
3478       section.s_page = coff_get_section_load_page (current);
3479 #endif
3480
3481 #ifdef COFF_WITH_PE
3482       section.s_paddr = 0;
3483 #endif
3484 #ifdef COFF_IMAGE_WITH_PE
3485       /* Reminder: s_paddr holds the virtual size of the section.  */
3486       if (coff_section_data (abfd, current) != NULL
3487           && pei_section_data (abfd, current) != NULL)
3488         section.s_paddr = pei_section_data (abfd, current)->virt_size;
3489       else
3490         section.s_paddr = 0;
3491 #endif
3492
3493       /* If this section has no size or is unloadable then the scnptr
3494          will be 0 too.  */
3495       if (current->size == 0
3496           || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3497         section.s_scnptr = 0;
3498       else
3499         section.s_scnptr = current->filepos;
3500
3501       section.s_relptr = current->rel_filepos;
3502       section.s_lnnoptr = current->line_filepos;
3503       section.s_nreloc = current->reloc_count;
3504       section.s_nlnno = current->lineno_count;
3505 #ifndef COFF_IMAGE_WITH_PE
3506       /* In PEI, relocs come in the .reloc section.  */
3507       if (current->reloc_count != 0)
3508         hasrelocs = TRUE;
3509 #endif
3510       if (current->lineno_count != 0)
3511         haslinno = TRUE;
3512       if ((current->flags & SEC_DEBUGGING) != 0
3513           && ! is_reloc_section)
3514         hasdebug = TRUE;
3515
3516 #ifdef RS6000COFF_C
3517 #ifndef XCOFF64
3518       /* Indicate the use of an XCOFF overflow section header.  */
3519       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3520         {
3521           section.s_nreloc = 0xffff;
3522           section.s_nlnno = 0xffff;
3523         }
3524 #endif
3525 #endif
3526
3527       section.s_flags = sec_to_styp_flags (current->name, current->flags);
3528
3529       if (!strcmp (current->name, _TEXT))
3530         text_sec = current;
3531       else if (!strcmp (current->name, _DATA))
3532         data_sec = current;
3533       else if (!strcmp (current->name, _BSS))
3534         bss_sec = current;
3535
3536 #ifdef I960
3537       section.s_align = (current->alignment_power
3538                          ? 1 << current->alignment_power
3539                          : 0);
3540 #endif
3541 #ifdef TIC80COFF
3542       /* TI COFF puts the alignment power in bits 8-11 of the flags.  */
3543       section.s_flags |= (current->alignment_power & 0xF) << 8;
3544 #endif
3545 #ifdef COFF_ENCODE_ALIGNMENT
3546       COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3547 #endif
3548
3549 #ifdef COFF_IMAGE_WITH_PE
3550       /* Suppress output of the sections if they are null.  ld
3551          includes the bss and data sections even if there is no size
3552          assigned to them.  NT loader doesn't like it if these section
3553          headers are included if the sections themselves are not
3554          needed.  See also coff_compute_section_file_positions.  */
3555       if (section.s_size == 0)
3556         internal_f.f_nscns--;
3557       else
3558 #endif
3559         {
3560           SCNHDR buff;
3561           bfd_size_type amt = bfd_coff_scnhsz (abfd);
3562
3563           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3564               || bfd_bwrite (& buff, amt, abfd) != amt)
3565             return FALSE;
3566         }
3567
3568 #ifdef COFF_WITH_PE
3569       /* PE stores COMDAT section information in the symbol table.  If
3570          this section is supposed to have some COMDAT info, track down
3571          the symbol in the symbol table and modify it.  */
3572       if ((current->flags & SEC_LINK_ONCE) != 0)
3573         {
3574           unsigned int i, count;
3575           asymbol **psym;
3576           coff_symbol_type *csym = NULL;
3577           asymbol **psymsec;
3578
3579           psymsec = NULL;
3580           count = bfd_get_symcount (abfd);
3581           for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3582             {
3583               if ((*psym)->section != current)
3584                 continue;
3585
3586               /* Remember the location of the first symbol in this
3587                  section.  */
3588               if (psymsec == NULL)
3589                 psymsec = psym;
3590
3591               /* See if this is the section symbol.  */
3592               if (strcmp ((*psym)->name, current->name) == 0)
3593                 {
3594                   csym = coff_symbol_from (abfd, *psym);
3595                   if (csym == NULL
3596                       || csym->native == NULL
3597                       || csym->native->u.syment.n_numaux < 1
3598                       || csym->native->u.syment.n_sclass != C_STAT
3599                       || csym->native->u.syment.n_type != T_NULL)
3600                     continue;
3601
3602                   /* Here *PSYM is the section symbol for CURRENT.  */
3603
3604                   break;
3605                 }
3606             }
3607
3608           /* Did we find it?
3609              Note that we might not if we're converting the file from
3610              some other object file format.  */
3611           if (i < count)
3612             {
3613               combined_entry_type *aux;
3614
3615               /* We don't touch the x_checksum field.  The
3616                  x_associated field is not currently supported.  */
3617
3618               aux = csym->native + 1;
3619               switch (current->flags & SEC_LINK_DUPLICATES)
3620                 {
3621                 case SEC_LINK_DUPLICATES_DISCARD:
3622                   aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3623                   break;
3624
3625                 case SEC_LINK_DUPLICATES_ONE_ONLY:
3626                   aux->u.auxent.x_scn.x_comdat =
3627                     IMAGE_COMDAT_SELECT_NODUPLICATES;
3628                   break;
3629
3630                 case SEC_LINK_DUPLICATES_SAME_SIZE:
3631                   aux->u.auxent.x_scn.x_comdat =
3632                     IMAGE_COMDAT_SELECT_SAME_SIZE;
3633                   break;
3634
3635                 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3636                   aux->u.auxent.x_scn.x_comdat =
3637                     IMAGE_COMDAT_SELECT_EXACT_MATCH;
3638                   break;
3639                 }
3640
3641               /* The COMDAT symbol must be the first symbol from this
3642                  section in the symbol table.  In order to make this
3643                  work, we move the COMDAT symbol before the first
3644                  symbol we found in the search above.  It's OK to
3645                  rearrange the symbol table at this point, because
3646                  coff_renumber_symbols is going to rearrange it
3647                  further and fix up all the aux entries.  */
3648               if (psym != psymsec)
3649                 {
3650                   asymbol *hold;
3651                   asymbol **pcopy;
3652
3653                   hold = *psym;
3654                   for (pcopy = psym; pcopy > psymsec; pcopy--)
3655                     pcopy[0] = pcopy[-1];
3656                   *psymsec = hold;
3657                 }
3658             }
3659         }
3660 #endif /* COFF_WITH_PE */
3661     }
3662
3663 #ifdef RS6000COFF_C
3664 #ifndef XCOFF64
3665   /* XCOFF handles overflows in the reloc and line number count fields
3666      by creating a new section header to hold the correct values.  */
3667   for (current = abfd->sections; current != NULL; current = current->next)
3668     {
3669       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3670         {
3671           struct internal_scnhdr scnhdr;
3672           SCNHDR buff;
3673           bfd_size_type amt;
3674
3675           internal_f.f_nscns++;
3676           strncpy (&(scnhdr.s_name[0]), current->name, 8);
3677           scnhdr.s_paddr = current->reloc_count;
3678           scnhdr.s_vaddr = current->lineno_count;
3679           scnhdr.s_size = 0;
3680           scnhdr.s_scnptr = 0;
3681           scnhdr.s_relptr = current->rel_filepos;
3682           scnhdr.s_lnnoptr = current->line_filepos;
3683           scnhdr.s_nreloc = current->target_index;
3684           scnhdr.s_nlnno = current->target_index;
3685           scnhdr.s_flags = STYP_OVRFLO;
3686           amt = bfd_coff_scnhsz (abfd);
3687           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3688               || bfd_bwrite (& buff, amt, abfd) != amt)
3689             return FALSE;
3690         }
3691     }
3692 #endif
3693 #endif
3694
3695   /* OK, now set up the filehdr...  */
3696
3697   /* Don't include the internal abs section in the section count */
3698
3699   /* We will NOT put a fucking timestamp in the header here. Every time you
3700      put it back, I will come in and take it out again.  I'm sorry.  This
3701      field does not belong here.  We fill it with a 0 so it compares the
3702      same but is not a reasonable time. -- gnu@cygnus.com  */
3703   internal_f.f_timdat = 0;
3704   internal_f.f_flags = 0;
3705
3706   if (abfd->flags & EXEC_P)
3707     internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3708   else
3709     {
3710       internal_f.f_opthdr = 0;
3711 #ifdef RS6000COFF_C
3712 #ifndef XCOFF64
3713       if (xcoff_data (abfd)->full_aouthdr)
3714         internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3715       else
3716         internal_f.f_opthdr = SMALL_AOUTSZ;
3717 #endif
3718 #endif
3719     }
3720
3721   if (!hasrelocs)
3722     internal_f.f_flags |= F_RELFLG;
3723   if (!haslinno)
3724     internal_f.f_flags |= F_LNNO;
3725   if (abfd->flags & EXEC_P)
3726     internal_f.f_flags |= F_EXEC;
3727 #ifdef COFF_IMAGE_WITH_PE
3728   if (! hasdebug)
3729     internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3730   if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
3731     internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
3732 #endif
3733
3734 #ifdef COFF_WITH_PE
3735   internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3736 #else
3737   if (bfd_little_endian (abfd))
3738     internal_f.f_flags |= F_AR32WR;
3739   else
3740     internal_f.f_flags |= F_AR32W;
3741 #endif
3742
3743 #ifdef TI_TARGET_ID
3744   /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3745      but it doesn't hurt to set it internally.  */
3746   internal_f.f_target_id = TI_TARGET_ID;
3747 #endif
3748 #ifdef TIC80_TARGET_ID
3749   internal_f.f_target_id = TIC80_TARGET_ID;
3750 #endif
3751
3752   /* FIXME, should do something about the other byte orders and
3753      architectures.  */
3754
3755 #ifdef RS6000COFF_C
3756   if ((abfd->flags & DYNAMIC) != 0)
3757     internal_f.f_flags |= F_SHROBJ;
3758   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3759     internal_f.f_flags |= F_DYNLOAD;
3760 #endif
3761
3762   memset (&internal_a, 0, sizeof internal_a);
3763
3764   /* Set up architecture-dependent stuff.  */
3765   {
3766     unsigned int magic = 0;
3767     unsigned short flags = 0;
3768
3769     coff_set_flags (abfd, &magic, &flags);
3770     internal_f.f_magic = magic;
3771     internal_f.f_flags |= flags;
3772     /* ...and the "opt"hdr...  */
3773
3774 #ifdef A29K
3775 #ifdef ULTRA3                   /* NYU's machine */
3776     /* FIXME: This is a bogus check.  I really want to see if there
3777        is a .shbss or a .shdata section, if so then set the magic
3778        number to indicate a shared data executable.  */
3779     if (internal_f.f_nscns >= 7)
3780       internal_a.magic = SHMAGIC; /* Shared magic.  */
3781     else
3782 #endif /* ULTRA3 */
3783       internal_a.magic = NMAGIC; /* Assume separate i/d.  */
3784 #define __A_MAGIC_SET__
3785 #endif /* A29K */
3786 #ifdef TICOFF_AOUT_MAGIC
3787     internal_a.magic = TICOFF_AOUT_MAGIC;
3788 #define __A_MAGIC_SET__
3789 #endif
3790 #ifdef TIC80COFF
3791     internal_a.magic = TIC80_ARCH_MAGIC;
3792 #define __A_MAGIC_SET__
3793 #endif /* TIC80 */
3794 #ifdef I860
3795     /* FIXME: What are the a.out magic numbers for the i860?  */
3796     internal_a.magic = 0;
3797 #define __A_MAGIC_SET__
3798 #endif /* I860 */
3799 #ifdef I960
3800     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3801 #define __A_MAGIC_SET__
3802 #endif /* I960 */
3803 #if M88
3804 #define __A_MAGIC_SET__
3805     internal_a.magic = PAGEMAGICBCS;
3806 #endif /* M88 */
3807
3808 #if APOLLO_M68
3809 #define __A_MAGIC_SET__
3810     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3811 #endif
3812
3813 #if defined(M68) || defined(WE32K) || defined(M68K)
3814 #define __A_MAGIC_SET__
3815 #if defined(LYNXOS)
3816     internal_a.magic = LYNXCOFFMAGIC;
3817 #else
3818 #if defined(TARG_AUX)
3819     internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3820                         abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3821                         PAGEMAGICEXECSWAPPED);
3822 #else
3823 #if defined (PAGEMAGICPEXECPAGED)
3824     internal_a.magic = PAGEMAGICPEXECPAGED;
3825 #endif
3826 #endif /* TARG_AUX */
3827 #endif /* LYNXOS */
3828 #endif /* M68 || WE32K || M68K */
3829
3830 #if defined(ARM)
3831 #define __A_MAGIC_SET__
3832     internal_a.magic = ZMAGIC;
3833 #endif
3834
3835 #if defined(PPC_PE)
3836 #define __A_MAGIC_SET__
3837     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3838 #endif
3839
3840 #if defined MCORE_PE
3841 #define __A_MAGIC_SET__
3842     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3843 #endif
3844
3845 #if defined(I386)
3846 #define __A_MAGIC_SET__
3847 #if defined(LYNXOS)
3848     internal_a.magic = LYNXCOFFMAGIC;
3849 #else  /* LYNXOS */
3850     internal_a.magic = ZMAGIC;
3851 #endif /* LYNXOS */
3852 #endif /* I386 */
3853
3854 #if defined(IA64)
3855 #define __A_MAGIC_SET__
3856     internal_a.magic = ZMAGIC;
3857 #endif /* IA64 */
3858
3859 #if defined(SPARC)
3860 #define __A_MAGIC_SET__
3861 #if defined(LYNXOS)
3862     internal_a.magic = LYNXCOFFMAGIC;
3863 #endif /* LYNXOS */
3864 #endif /* SPARC */
3865
3866 #ifdef RS6000COFF_C
3867 #define __A_MAGIC_SET__
3868     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3869     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3870     RS6K_AOUTHDR_OMAGIC;
3871 #endif
3872
3873 #if defined(SH) && defined(COFF_WITH_PE)
3874 #define __A_MAGIC_SET__
3875     internal_a.magic = SH_PE_MAGIC;
3876 #endif
3877
3878 #if defined(MIPS) && defined(COFF_WITH_PE)
3879 #define __A_MAGIC_SET__
3880     internal_a.magic = MIPS_PE_MAGIC;
3881 #endif
3882
3883 #ifdef OR32
3884 #define __A_MAGIC_SET__
3885     internal_a.magic = NMAGIC; /* Assume separate i/d.  */
3886 #endif
3887
3888 #ifdef MAXQ20MAGIC
3889 #define __A_MAGIC_SET__
3890       internal_a.magic = MAXQ20MAGIC;
3891 #endif
3892
3893 #ifndef __A_MAGIC_SET__
3894 #include "Your aouthdr magic number is not being set!"
3895 #else
3896 #undef __A_MAGIC_SET__
3897 #endif
3898   }
3899
3900   /* FIXME: Does anybody ever set this to another value?  */
3901   internal_a.vstamp = 0;
3902
3903   /* Now should write relocs, strings, syms.  */
3904   obj_sym_filepos (abfd) = sym_base;
3905
3906   if (bfd_get_symcount (abfd) != 0)
3907     {
3908       int firstundef;
3909
3910       if (!coff_renumber_symbols (abfd, &firstundef))
3911         return FALSE;
3912       coff_mangle_symbols (abfd);
3913       if (! coff_write_symbols (abfd))
3914         return FALSE;
3915       if (! coff_write_linenumbers (abfd))
3916         return FALSE;
3917       if (! coff_write_relocs (abfd, firstundef))
3918         return FALSE;
3919     }
3920 #ifdef COFF_LONG_SECTION_NAMES
3921   else if (long_section_names && ! obj_coff_strings_written (abfd))
3922     {
3923       /* If we have long section names we have to write out the string
3924          table even if there are no symbols.  */
3925       if (! coff_write_symbols (abfd))
3926         return FALSE;
3927     }
3928 #endif
3929 #ifdef COFF_IMAGE_WITH_PE
3930 #ifdef PPC_PE
3931   else if ((abfd->flags & EXEC_P) != 0)
3932     {
3933       bfd_byte b;
3934
3935       /* PowerPC PE appears to require that all executable files be
3936          rounded up to the page size.  */
3937       b = 0;
3938       if (bfd_seek (abfd,
3939                     (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3940                     SEEK_SET) != 0
3941           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3942         return FALSE;
3943     }
3944 #endif
3945 #endif
3946
3947   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3948      backend linker, and obj_raw_syment_count is not valid until after
3949      coff_write_symbols is called.  */
3950   if (obj_raw_syment_count (abfd) != 0)
3951     {
3952       internal_f.f_symptr = sym_base;
3953 #ifdef RS6000COFF_C
3954       /* AIX appears to require that F_RELFLG not be set if there are
3955          local symbols but no relocations.  */
3956       internal_f.f_flags &=~ F_RELFLG;
3957 #endif
3958     }
3959   else
3960     {
3961       if (long_section_names)
3962         internal_f.f_symptr = sym_base;
3963       else
3964         internal_f.f_symptr = 0;
3965       internal_f.f_flags |= F_LSYMS;
3966     }
3967
3968   if (text_sec)
3969     {
3970       internal_a.tsize = text_sec->size;
3971       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3972     }
3973   if (data_sec)
3974     {
3975       internal_a.dsize = data_sec->size;
3976       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3977     }
3978   if (bss_sec)
3979     {
3980       internal_a.bsize = bss_sec->size;
3981       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3982         internal_a.data_start = bss_sec->vma;
3983     }
3984
3985   internal_a.entry = bfd_get_start_address (abfd);
3986   internal_f.f_nsyms = obj_raw_syment_count (abfd);
3987
3988 #ifdef RS6000COFF_C
3989   if (xcoff_data (abfd)->full_aouthdr)
3990     {
3991       bfd_vma toc;
3992       asection *loader_sec;
3993
3994       internal_a.vstamp = 1;
3995
3996       internal_a.o_snentry = xcoff_data (abfd)->snentry;
3997       if (internal_a.o_snentry == 0)
3998         internal_a.entry = (bfd_vma) -1;
3999
4000       if (text_sec != NULL)
4001         {
4002           internal_a.o_sntext = text_sec->target_index;
4003           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4004         }
4005       else
4006         {
4007           internal_a.o_sntext = 0;
4008           internal_a.o_algntext = 0;
4009         }
4010       if (data_sec != NULL)
4011         {
4012           internal_a.o_sndata = data_sec->target_index;
4013           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4014         }
4015       else
4016         {
4017           internal_a.o_sndata = 0;
4018           internal_a.o_algndata = 0;
4019         }
4020       loader_sec = bfd_get_section_by_name (abfd, ".loader");
4021       if (loader_sec != NULL)
4022         internal_a.o_snloader = loader_sec->target_index;
4023       else
4024         internal_a.o_snloader = 0;
4025       if (bss_sec != NULL)
4026         internal_a.o_snbss = bss_sec->target_index;
4027       else
4028         internal_a.o_snbss = 0;
4029
4030       toc = xcoff_data (abfd)->toc;
4031       internal_a.o_toc = toc;
4032       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4033
4034       internal_a.o_modtype = xcoff_data (abfd)->modtype;
4035       if (xcoff_data (abfd)->cputype != -1)
4036         internal_a.o_cputype = xcoff_data (abfd)->cputype;
4037       else
4038         {
4039           switch (bfd_get_arch (abfd))
4040             {
4041             case bfd_arch_rs6000:
4042               internal_a.o_cputype = 4;
4043               break;
4044             case bfd_arch_powerpc:
4045               if (bfd_get_mach (abfd) == bfd_mach_ppc)
4046                 internal_a.o_cputype = 3;
4047               else
4048                 internal_a.o_cputype = 1;
4049               break;
4050             default:
4051               abort ();
4052             }
4053         }
4054       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4055       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4056     }
4057 #endif
4058
4059   /* Now write them.  */
4060   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4061     return FALSE;
4062
4063   {
4064     char * buff;
4065     bfd_size_type amount = bfd_coff_filhsz (abfd);
4066
4067     buff = bfd_malloc (amount);
4068     if (buff == NULL)
4069       return FALSE;
4070
4071     bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4072     amount = bfd_bwrite (buff, amount, abfd);
4073
4074     free (buff);
4075
4076     if (amount != bfd_coff_filhsz (abfd))
4077       return FALSE;
4078   }
4079
4080   if (abfd->flags & EXEC_P)
4081     {
4082       /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4083          include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)).  */
4084       char * buff;
4085       bfd_size_type amount = bfd_coff_aoutsz (abfd);
4086
4087       buff = bfd_malloc (amount);
4088       if (buff == NULL)
4089         return FALSE;
4090
4091       coff_swap_aouthdr_out (abfd, & internal_a, buff);
4092       amount = bfd_bwrite (buff, amount, abfd);
4093
4094       free (buff);
4095
4096       if (amount != bfd_coff_aoutsz (abfd))
4097         return FALSE;
4098
4099 #ifdef COFF_IMAGE_WITH_PE
4100       if (! coff_apply_checksum (abfd))
4101         return FALSE;
4102 #endif
4103     }
4104 #ifdef RS6000COFF_C
4105   else
4106     {
4107       AOUTHDR buff;
4108       size_t size;
4109
4110       /* XCOFF seems to always write at least a small a.out header.  */
4111       coff_swap_aouthdr_out (abfd, & internal_a, & buff);
4112       if (xcoff_data (abfd)->full_aouthdr)
4113         size = bfd_coff_aoutsz (abfd);
4114       else
4115         size = SMALL_AOUTSZ;
4116       if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
4117         return FALSE;
4118     }
4119 #endif
4120
4121   return TRUE;
4122 }
4123
4124 static bfd_boolean
4125 coff_set_section_contents (bfd * abfd,
4126                            sec_ptr section,
4127                            const void * location,
4128                            file_ptr offset,
4129                            bfd_size_type count)
4130 {
4131   if (! abfd->output_has_begun) /* Set by bfd.c handler.  */
4132     {
4133       if (! coff_compute_section_file_positions (abfd))
4134         return FALSE;
4135     }
4136
4137 #if defined(_LIB) && !defined(TARG_AUX)
4138    /* The physical address field of a .lib section is used to hold the
4139       number of shared libraries in the section.  This code counts the
4140       number of sections being written, and increments the lma field
4141       with the number.
4142
4143       I have found no documentation on the contents of this section.
4144       Experimentation indicates that the section contains zero or more
4145       records, each of which has the following structure:
4146
4147       - a (four byte) word holding the length of this record, in words,
4148       - a word that always seems to be set to "2",
4149       - the path to a shared library, null-terminated and then padded
4150         to a whole word boundary.
4151
4152       bfd_assert calls have been added to alert if an attempt is made
4153       to write a section which doesn't follow these assumptions.  The
4154       code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4155       <robertl@arnet.com> (Thanks!).
4156
4157       Gvran Uddeborg <gvran@uddeborg.pp.se>.  */
4158     if (strcmp (section->name, _LIB) == 0)
4159       {
4160         bfd_byte *rec, *recend;
4161
4162         rec = (bfd_byte *) location;
4163         recend = rec + count;
4164         while (rec < recend)
4165           {
4166             ++section->lma;
4167             rec += bfd_get_32 (abfd, rec) * 4;
4168           }
4169
4170         BFD_ASSERT (rec == recend);
4171       }
4172 #endif
4173
4174   /* Don't write out bss sections - one way to do this is to
4175        see if the filepos has not been set.  */
4176   if (section->filepos == 0)
4177     return TRUE;
4178
4179   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4180     return FALSE;
4181
4182   if (count == 0)
4183     return TRUE;
4184
4185   return bfd_bwrite (location, count, abfd) == count;
4186 }
4187
4188 static void *
4189 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
4190 {
4191   void * area = bfd_alloc (abfd, size);
4192
4193   if (!area)
4194     return (NULL);
4195   if (bfd_seek (abfd, where, SEEK_SET) != 0
4196       || bfd_bread (area, size, abfd) != size)
4197     return (NULL);
4198   return (area);
4199 }
4200
4201 /*
4202 SUBSUBSECTION
4203         Reading linenumbers
4204
4205         Creating the linenumber table is done by reading in the entire
4206         coff linenumber table, and creating another table for internal use.
4207
4208         A coff linenumber table is structured so that each function
4209         is marked as having a line number of 0. Each line within the
4210         function is an offset from the first line in the function. The
4211         base of the line number information for the table is stored in
4212         the symbol associated with the function.
4213
4214         Note: The PE format uses line number 0 for a flag indicating a
4215         new source file.
4216
4217         The information is copied from the external to the internal
4218         table, and each symbol which marks a function is marked by
4219         pointing its...
4220
4221         How does this work ?
4222 */
4223
4224 static bfd_boolean
4225 coff_slurp_line_table (bfd *abfd, asection *asect)
4226 {
4227   LINENO *native_lineno;
4228   alent *lineno_cache;
4229   bfd_size_type amt;
4230
4231   BFD_ASSERT (asect->lineno == NULL);
4232
4233   amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4234   native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4235   if (native_lineno == NULL)
4236     {
4237       (*_bfd_error_handler)
4238         (_("%B: warning: line number table read failed"), abfd);
4239       return FALSE;
4240     }
4241   amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4242   lineno_cache = bfd_alloc (abfd, amt);
4243   if (lineno_cache == NULL)
4244     return FALSE;
4245   else
4246     {
4247       unsigned int counter = 0;
4248       alent *cache_ptr = lineno_cache;
4249       LINENO *src = native_lineno;
4250
4251       while (counter < asect->lineno_count)
4252         {
4253           struct internal_lineno dst;
4254
4255           bfd_coff_swap_lineno_in (abfd, src, &dst);
4256           cache_ptr->line_number = dst.l_lnno;
4257
4258           if (cache_ptr->line_number == 0)
4259             {
4260               bfd_boolean warned;
4261               bfd_signed_vma symndx;
4262               coff_symbol_type *sym;
4263
4264               warned = FALSE;
4265               symndx = dst.l_addr.l_symndx;
4266               if (symndx < 0
4267                   || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4268                 {
4269                   (*_bfd_error_handler)
4270                     (_("%B: warning: illegal symbol index %ld in line numbers"),
4271                      abfd, dst.l_addr.l_symndx);
4272                   symndx = 0;
4273                   warned = TRUE;
4274                 }
4275               /* FIXME: We should not be casting between ints and
4276                  pointers like this.  */
4277               sym = ((coff_symbol_type *)
4278                      ((symndx + obj_raw_syments (abfd))
4279                       ->u.syment._n._n_n._n_zeroes));
4280               cache_ptr->u.sym = (asymbol *) sym;
4281               if (sym->lineno != NULL && ! warned)
4282                 {
4283                   (*_bfd_error_handler)
4284                     (_("%B: warning: duplicate line number information for `%s'"),
4285                      abfd, bfd_asymbol_name (&sym->symbol));
4286                 }
4287               sym->lineno = cache_ptr;
4288             }
4289           else
4290             cache_ptr->u.offset = dst.l_addr.l_paddr
4291               - bfd_section_vma (abfd, asect);
4292
4293           cache_ptr++;
4294           src++;
4295           counter++;
4296         }
4297       cache_ptr->line_number = 0;
4298
4299     }
4300   asect->lineno = lineno_cache;
4301   /* FIXME, free native_lineno here, or use alloca or something.  */
4302   return TRUE;
4303 }
4304
4305 /* Slurp in the symbol table, converting it to generic form.  Note
4306    that if coff_relocate_section is defined, the linker will read
4307    symbols via coff_link_add_symbols, rather than via this routine.  */
4308
4309 static bfd_boolean
4310 coff_slurp_symbol_table (bfd * abfd)
4311 {
4312   combined_entry_type *native_symbols;
4313   coff_symbol_type *cached_area;
4314   unsigned int *table_ptr;
4315   bfd_size_type amt;
4316   unsigned int number_of_symbols = 0;
4317
4318   if (obj_symbols (abfd))
4319     return TRUE;
4320
4321   /* Read in the symbol table.  */
4322   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4323     return FALSE;
4324
4325   /* Allocate enough room for all the symbols in cached form.  */
4326   amt = obj_raw_syment_count (abfd);
4327   amt *= sizeof (coff_symbol_type);
4328   cached_area = bfd_alloc (abfd, amt);
4329   if (cached_area == NULL)
4330     return FALSE;
4331
4332   amt = obj_raw_syment_count (abfd);
4333   amt *= sizeof (unsigned int);
4334   table_ptr = bfd_alloc (abfd, amt);
4335
4336   if (table_ptr == NULL)
4337     return FALSE;
4338   else
4339     {
4340       coff_symbol_type *dst = cached_area;
4341       unsigned int last_native_index = obj_raw_syment_count (abfd);
4342       unsigned int this_index = 0;
4343
4344       while (this_index < last_native_index)
4345         {
4346           combined_entry_type *src = native_symbols + this_index;
4347           table_ptr[this_index] = number_of_symbols;
4348           dst->symbol.the_bfd = abfd;
4349
4350           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4351           /* We use the native name field to point to the cached field.  */
4352           src->u.syment._n._n_n._n_zeroes = (long) dst;
4353           dst->symbol.section = coff_section_from_bfd_index (abfd,
4354                                                      src->u.syment.n_scnum);
4355           dst->symbol.flags = 0;
4356           dst->done_lineno = FALSE;
4357
4358           switch (src->u.syment.n_sclass)
4359             {
4360 #ifdef I960
4361             case C_LEAFEXT:
4362               /* Fall through to next case.  */
4363 #endif
4364
4365             case C_EXT:
4366             case C_WEAKEXT:
4367 #if defined ARM
4368             case C_THUMBEXT:
4369             case C_THUMBEXTFUNC:
4370 #endif
4371 #ifdef RS6000COFF_C
4372             case C_HIDEXT:
4373 #endif
4374 #ifdef C_SYSTEM
4375             case C_SYSTEM:      /* System Wide variable.  */
4376 #endif
4377 #ifdef COFF_WITH_PE
4378             /* In PE, 0x68 (104) denotes a section symbol.  */
4379             case C_SECTION:
4380             /* In PE, 0x69 (105) denotes a weak external symbol.  */
4381             case C_NT_WEAK:
4382 #endif
4383               switch (coff_classify_symbol (abfd, &src->u.syment))
4384                 {
4385                 case COFF_SYMBOL_GLOBAL:
4386                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4387 #if defined COFF_WITH_PE
4388                   /* PE sets the symbol to a value relative to the
4389                      start of the section.  */
4390                   dst->symbol.value = src->u.syment.n_value;
4391 #else
4392                   dst->symbol.value = (src->u.syment.n_value
4393                                        - dst->symbol.section->vma);
4394 #endif
4395                   if (ISFCN ((src->u.syment.n_type)))
4396                     /* A function ext does not go at the end of a
4397                        file.  */
4398                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4399                   break;
4400
4401                 case COFF_SYMBOL_COMMON:
4402                   dst->symbol.section = bfd_com_section_ptr;
4403                   dst->symbol.value = src->u.syment.n_value;
4404                   break;
4405
4406                 case COFF_SYMBOL_UNDEFINED:
4407                   dst->symbol.section = bfd_und_section_ptr;
4408                   dst->symbol.value = 0;
4409                   break;
4410
4411                 case COFF_SYMBOL_PE_SECTION:
4412                   dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4413                   dst->symbol.value = 0;
4414                   break;
4415
4416                 case COFF_SYMBOL_LOCAL:
4417                   dst->symbol.flags = BSF_LOCAL;
4418 #if defined COFF_WITH_PE
4419                   /* PE sets the symbol to a value relative to the
4420                      start of the section.  */
4421                   dst->symbol.value = src->u.syment.n_value;
4422 #else
4423                   dst->symbol.value = (src->u.syment.n_value
4424                                        - dst->symbol.section->vma);
4425 #endif
4426                   if (ISFCN ((src->u.syment.n_type)))
4427                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4428                   break;
4429                 }
4430
4431 #ifdef RS6000COFF_C
4432               /* A symbol with a csect entry should not go at the end.  */
4433               if (src->u.syment.n_numaux > 0)
4434                 dst->symbol.flags |= BSF_NOT_AT_END;
4435 #endif
4436
4437 #ifdef COFF_WITH_PE
4438               if (src->u.syment.n_sclass == C_NT_WEAK)
4439                 dst->symbol.flags |= BSF_WEAK;
4440
4441               if (src->u.syment.n_sclass == C_SECTION
4442                   && src->u.syment.n_scnum > 0)
4443                 dst->symbol.flags = BSF_LOCAL;
4444 #endif
4445               if (src->u.syment.n_sclass == C_WEAKEXT)
4446                 dst->symbol.flags |= BSF_WEAK;
4447
4448               break;
4449
4450             case C_STAT:         /* Static.  */
4451 #ifdef I960
4452             case C_LEAFSTAT:     /* Static leaf procedure.  */
4453 #endif
4454 #if defined ARM
4455             case C_THUMBSTAT:    /* Thumb static.  */
4456             case C_THUMBLABEL:   /* Thumb label.  */
4457             case C_THUMBSTATFUNC:/* Thumb static function.  */
4458 #endif
4459             case C_LABEL:        /* Label.  */
4460               if (src->u.syment.n_scnum == N_DEBUG)
4461                 dst->symbol.flags = BSF_DEBUGGING;
4462               else
4463                 dst->symbol.flags = BSF_LOCAL;
4464
4465               /* Base the value as an index from the base of the
4466                  section, if there is one.  */
4467               if (dst->symbol.section)
4468                 {
4469 #if defined COFF_WITH_PE
4470                   /* PE sets the symbol to a value relative to the
4471                      start of the section.  */
4472                   dst->symbol.value = src->u.syment.n_value;
4473 #else
4474                   dst->symbol.value = (src->u.syment.n_value
4475                                        - dst->symbol.section->vma);
4476 #endif
4477                 }
4478               else
4479                 dst->symbol.value = src->u.syment.n_value;
4480               break;
4481
4482             case C_MOS:         /* Member of structure.  */
4483             case C_EOS:         /* End of structure.  */
4484 #ifdef NOTDEF                   /* C_AUTOARG has the same value.  */
4485 #ifdef C_GLBLREG
4486             case C_GLBLREG:     /* A29k-specific storage class.  */
4487 #endif
4488 #endif
4489             case C_REGPARM:     /* Register parameter.  */
4490             case C_REG:         /* register variable.  */
4491               /* C_AUTOARG conflicts with TI COFF C_UEXT.  */
4492 #if !defined (TIC80COFF) && !defined (TICOFF)
4493 #ifdef C_AUTOARG
4494             case C_AUTOARG:     /* 960-specific storage class.  */
4495 #endif
4496 #endif
4497             case C_TPDEF:       /* Type definition.  */
4498             case C_ARG:
4499             case C_AUTO:        /* Automatic variable.  */
4500             case C_FIELD:       /* Bit field.  */
4501             case C_ENTAG:       /* Enumeration tag.  */
4502             case C_MOE:         /* Member of enumeration.  */
4503             case C_MOU:         /* Member of union.  */
4504             case C_UNTAG:       /* Union tag.  */
4505               dst->symbol.flags = BSF_DEBUGGING;
4506               dst->symbol.value = (src->u.syment.n_value);
4507               break;
4508
4509             case C_FILE:        /* File name.  */
4510             case C_STRTAG:      /* Structure tag.  */
4511 #ifdef RS6000COFF_C
4512             case C_GSYM:
4513             case C_LSYM:
4514             case C_PSYM:
4515             case C_RSYM:
4516             case C_RPSYM:
4517             case C_STSYM:
4518             case C_TCSYM:
4519             case C_BCOMM:
4520             case C_ECOML:
4521             case C_ECOMM:
4522             case C_DECL:
4523             case C_ENTRY:
4524             case C_FUN:
4525             case C_ESTAT:
4526 #endif
4527               dst->symbol.flags = BSF_DEBUGGING;
4528               dst->symbol.value = (src->u.syment.n_value);
4529               break;
4530
4531 #ifdef RS6000COFF_C
4532             case C_BINCL:       /* Beginning of include file.  */
4533             case C_EINCL:       /* Ending of include file.  */
4534               /* The value is actually a pointer into the line numbers
4535                  of the file.  We locate the line number entry, and
4536                  set the section to the section which contains it, and
4537                  the value to the index in that section.  */
4538               {
4539                 asection *sec;
4540
4541                 dst->symbol.flags = BSF_DEBUGGING;
4542                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4543                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4544                       && ((file_ptr) (sec->line_filepos
4545                                       + sec->lineno_count * bfd_coff_linesz (abfd))
4546                           > (file_ptr) src->u.syment.n_value))
4547                     break;
4548                 if (sec == NULL)
4549                   dst->symbol.value = 0;
4550                 else
4551                   {
4552                     dst->symbol.section = sec;
4553                     dst->symbol.value = ((src->u.syment.n_value
4554                                           - sec->line_filepos)
4555                                          / bfd_coff_linesz (abfd));
4556                     src->fix_line = 1;
4557                   }
4558               }
4559               break;
4560
4561             case C_BSTAT:
4562               dst->symbol.flags = BSF_DEBUGGING;
4563
4564               /* The value is actually a symbol index.  Save a pointer
4565                  to the symbol instead of the index.  FIXME: This
4566                  should use a union.  */
4567               src->u.syment.n_value =
4568                 (long) (native_symbols + src->u.syment.n_value);
4569               dst->symbol.value = src->u.syment.n_value;
4570               src->fix_value = 1;
4571               break;
4572 #endif
4573
4574             case C_BLOCK:       /* ".bb" or ".eb".  */
4575             case C_FCN:         /* ".bf" or ".ef" (or PE ".lf").  */
4576             case C_EFCN:        /* Physical end of function.  */
4577 #if defined COFF_WITH_PE
4578               /* PE sets the symbol to a value relative to the start
4579                  of the section.  */
4580               dst->symbol.value = src->u.syment.n_value;
4581               if (strcmp (dst->symbol.name, ".bf") != 0)
4582                 {
4583                   /* PE uses funny values for .ef and .lf; don't
4584                      relocate them.  */
4585                   dst->symbol.flags = BSF_DEBUGGING;
4586                 }
4587               else
4588                 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4589 #else
4590               /* Base the value as an index from the base of the
4591                  section.  */
4592               dst->symbol.flags = BSF_LOCAL;
4593               dst->symbol.value = (src->u.syment.n_value
4594                                    - dst->symbol.section->vma);
4595 #endif
4596               break;
4597
4598             case C_STATLAB:     /* Static load time label.  */
4599               dst->symbol.value = src->u.syment.n_value;
4600               dst->symbol.flags = BSF_GLOBAL;
4601               break;
4602
4603             case C_NULL:
4604               /* PE DLLs sometimes have zeroed out symbols for some
4605                  reason.  Just ignore them without a warning.  */
4606               if (src->u.syment.n_type == 0
4607                   && src->u.syment.n_value == 0
4608                   && src->u.syment.n_scnum == 0)
4609                 break;
4610               /* Fall through.  */
4611             case C_EXTDEF:      /* External definition.  */
4612             case C_ULABEL:      /* Undefined label.  */
4613             case C_USTATIC:     /* Undefined static.  */
4614 #ifndef COFF_WITH_PE
4615             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
4616                class to represent a section symbol.  */
4617             case C_LINE:        /* line # reformatted as symbol table entry.  */
4618               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
4619             case C_ALIAS:       /* Duplicate tag.  */
4620 #endif
4621               /* New storage classes for TI COFF.  */
4622 #if defined(TIC80COFF) || defined(TICOFF)
4623             case C_UEXT:        /* Tentative external definition.  */
4624 #endif
4625             case C_EXTLAB:      /* External load time label.  */
4626             case C_HIDDEN:      /* Ext symbol in dmert public lib.  */
4627             default:
4628               (*_bfd_error_handler)
4629                 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4630                  abfd, src->u.syment.n_sclass,
4631                  dst->symbol.section->name, dst->symbol.name);
4632               dst->symbol.flags = BSF_DEBUGGING;
4633               dst->symbol.value = (src->u.syment.n_value);
4634               break;
4635             }
4636
4637           dst->native = src;
4638
4639           dst->symbol.udata.i = 0;
4640           dst->lineno = NULL;
4641           this_index += (src->u.syment.n_numaux) + 1;
4642           dst++;
4643           number_of_symbols++;
4644         }
4645     }
4646
4647   obj_symbols (abfd) = cached_area;
4648   obj_raw_syments (abfd) = native_symbols;
4649
4650   bfd_get_symcount (abfd) = number_of_symbols;
4651   obj_convert (abfd) = table_ptr;
4652   /* Slurp the line tables for each section too.  */
4653   {
4654     asection *p;
4655
4656     p = abfd->sections;
4657     while (p)
4658       {
4659         coff_slurp_line_table (abfd, p);
4660         p = p->next;
4661       }
4662   }
4663
4664   return TRUE;
4665 }
4666
4667 /* Classify a COFF symbol.  A couple of targets have globally visible
4668    symbols which are not class C_EXT, and this handles those.  It also
4669    recognizes some special PE cases.  */
4670
4671 static enum coff_symbol_classification
4672 coff_classify_symbol (bfd *abfd,
4673                       struct internal_syment *syment)
4674 {
4675   /* FIXME: This partially duplicates the switch in
4676      coff_slurp_symbol_table.  */
4677   switch (syment->n_sclass)
4678     {
4679     case C_EXT:
4680     case C_WEAKEXT:
4681 #ifdef I960
4682     case C_LEAFEXT:
4683 #endif
4684 #ifdef ARM
4685     case C_THUMBEXT:
4686     case C_THUMBEXTFUNC:
4687 #endif
4688 #ifdef C_SYSTEM
4689     case C_SYSTEM:
4690 #endif
4691 #ifdef COFF_WITH_PE
4692     case C_NT_WEAK:
4693 #endif
4694       if (syment->n_scnum == 0)
4695         {
4696           if (syment->n_value == 0)
4697             return COFF_SYMBOL_UNDEFINED;
4698           else
4699             return COFF_SYMBOL_COMMON;
4700         }
4701       return COFF_SYMBOL_GLOBAL;
4702
4703     default:
4704       break;
4705     }
4706
4707 #ifdef COFF_WITH_PE
4708   if (syment->n_sclass == C_STAT)
4709     {
4710       if (syment->n_scnum == 0)
4711         /* The Microsoft compiler sometimes generates these if a
4712            small static function is inlined every time it is used.
4713            The function is discarded, but the symbol table entry
4714            remains.  */
4715         return COFF_SYMBOL_LOCAL;
4716
4717 #ifdef STRICT_PE_FORMAT
4718       /* This is correct for Microsoft generated objects, but it
4719          breaks gas generated objects.  */
4720       if (syment->n_value == 0)
4721         {
4722           asection *sec;
4723           char buf[SYMNMLEN + 1];
4724
4725           sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4726           if (sec != NULL
4727               && (strcmp (bfd_get_section_name (abfd, sec),
4728                           _bfd_coff_internal_syment_name (abfd, syment, buf))
4729                   == 0))
4730             return COFF_SYMBOL_PE_SECTION;
4731         }
4732 #endif
4733
4734       return COFF_SYMBOL_LOCAL;
4735     }
4736
4737   if (syment->n_sclass == C_SECTION)
4738     {
4739       /* In some cases in a DLL generated by the Microsoft linker, the
4740          n_value field will contain garbage.  FIXME: This should
4741          probably be handled by the swapping function instead.  */
4742       syment->n_value = 0;
4743       if (syment->n_scnum == 0)
4744         return COFF_SYMBOL_UNDEFINED;
4745       return COFF_SYMBOL_PE_SECTION;
4746     }
4747 #endif /* COFF_WITH_PE */
4748
4749   /* If it is not a global symbol, we presume it is a local symbol.  */
4750   if (syment->n_scnum == 0)
4751     {
4752       char buf[SYMNMLEN + 1];
4753
4754       (*_bfd_error_handler)
4755         (_("warning: %B: local symbol `%s' has no section"),
4756          abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
4757     }
4758
4759   return COFF_SYMBOL_LOCAL;
4760 }
4761
4762 /*
4763 SUBSUBSECTION
4764         Reading relocations
4765
4766         Coff relocations are easily transformed into the internal BFD form
4767         (@code{arelent}).
4768
4769         Reading a coff relocation table is done in the following stages:
4770
4771         o Read the entire coff relocation table into memory.
4772
4773         o Process each relocation in turn; first swap it from the
4774         external to the internal form.
4775
4776         o Turn the symbol referenced in the relocation's symbol index
4777         into a pointer into the canonical symbol table.
4778         This table is the same as the one returned by a call to
4779         @code{bfd_canonicalize_symtab}. The back end will call that
4780         routine and save the result if a canonicalization hasn't been done.
4781
4782         o The reloc index is turned into a pointer to a howto
4783         structure, in a back end specific way. For instance, the 386
4784         and 960 use the @code{r_type} to directly produce an index
4785         into a howto table vector; the 88k subtracts a number from the
4786         @code{r_type} field and creates an addend field.
4787 */
4788
4789 #ifndef CALC_ADDEND
4790 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
4791   {                                                             \
4792     coff_symbol_type *coffsym = NULL;                           \
4793                                                                 \
4794     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
4795       coffsym = (obj_symbols (abfd)                             \
4796                  + (cache_ptr->sym_ptr_ptr - symbols));         \
4797     else if (ptr)                                               \
4798       coffsym = coff_symbol_from (abfd, ptr);                   \
4799     if (coffsym != NULL                                         \
4800         && coffsym->native->u.syment.n_scnum == 0)              \
4801       cache_ptr->addend = 0;                                    \
4802     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
4803              && ptr->section != NULL)                           \
4804       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
4805     else                                                        \
4806       cache_ptr->addend = 0;                                    \
4807   }
4808 #endif
4809
4810 static bfd_boolean
4811 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
4812 {
4813   RELOC *native_relocs;
4814   arelent *reloc_cache;
4815   arelent *cache_ptr;
4816   unsigned int idx;
4817   bfd_size_type amt;
4818
4819   if (asect->relocation)
4820     return TRUE;
4821   if (asect->reloc_count == 0)
4822     return TRUE;
4823   if (asect->flags & SEC_CONSTRUCTOR)
4824     return TRUE;
4825   if (!coff_slurp_symbol_table (abfd))
4826     return FALSE;
4827
4828   amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
4829   native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
4830   amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
4831   reloc_cache = bfd_alloc (abfd, amt);
4832
4833   if (reloc_cache == NULL)
4834     return FALSE;
4835
4836   for (idx = 0; idx < asect->reloc_count; idx++)
4837     {
4838       struct internal_reloc dst;
4839       struct external_reloc *src;
4840 #ifndef RELOC_PROCESSING
4841       asymbol *ptr;
4842 #endif
4843
4844       cache_ptr = reloc_cache + idx;
4845       src = native_relocs + idx;
4846
4847       coff_swap_reloc_in (abfd, src, &dst);
4848
4849 #ifdef RELOC_PROCESSING
4850       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4851 #else
4852       cache_ptr->address = dst.r_vaddr;
4853
4854       if (dst.r_symndx != -1)
4855         {
4856           if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4857             {
4858               (*_bfd_error_handler)
4859                 (_("%B: warning: illegal symbol index %ld in relocs"),
4860                  abfd, dst.r_symndx);
4861               cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4862               ptr = NULL;
4863             }
4864           else
4865             {
4866               cache_ptr->sym_ptr_ptr = (symbols
4867                                         + obj_convert (abfd)[dst.r_symndx]);
4868               ptr = *(cache_ptr->sym_ptr_ptr);
4869             }
4870         }
4871       else
4872         {
4873           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4874           ptr = NULL;
4875         }
4876
4877       /* The symbols definitions that we have read in have been
4878          relocated as if their sections started at 0. But the offsets
4879          refering to the symbols in the raw data have not been
4880          modified, so we have to have a negative addend to compensate.
4881
4882          Note that symbols which used to be common must be left alone.  */
4883
4884       /* Calculate any reloc addend by looking at the symbol.  */
4885       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4886
4887       cache_ptr->address -= asect->vma;
4888       /* !! cache_ptr->section = NULL;*/
4889
4890       /* Fill in the cache_ptr->howto field from dst.r_type.  */
4891       RTYPE2HOWTO (cache_ptr, &dst);
4892 #endif  /* RELOC_PROCESSING */
4893
4894       if (cache_ptr->howto == NULL)
4895         {
4896           (*_bfd_error_handler)
4897             (_("%B: illegal relocation type %d at address 0x%lx"),
4898              abfd, dst.r_type, (long) dst.r_vaddr);
4899           bfd_set_error (bfd_error_bad_value);
4900           return FALSE;
4901         }
4902     }
4903
4904   asect->relocation = reloc_cache;
4905   return TRUE;
4906 }
4907
4908 #ifndef coff_rtype_to_howto
4909 #ifdef RTYPE2HOWTO
4910
4911 /* Get the howto structure for a reloc.  This is only used if the file
4912    including this one defines coff_relocate_section to be
4913    _bfd_coff_generic_relocate_section, so it is OK if it does not
4914    always work.  It is the responsibility of the including file to
4915    make sure it is reasonable if it is needed.  */
4916
4917 static reloc_howto_type *
4918 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
4919                      asection *sec ATTRIBUTE_UNUSED,
4920                      struct internal_reloc *rel,
4921                      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
4922                      struct internal_syment *sym ATTRIBUTE_UNUSED,
4923                      bfd_vma *addendp ATTRIBUTE_UNUSED)
4924 {
4925   arelent genrel;
4926
4927   RTYPE2HOWTO (&genrel, rel);
4928   return genrel.howto;
4929 }
4930
4931 #else /* ! defined (RTYPE2HOWTO) */
4932
4933 #define coff_rtype_to_howto NULL
4934
4935 #endif /* ! defined (RTYPE2HOWTO) */
4936 #endif /* ! defined (coff_rtype_to_howto) */
4937
4938 /* This is stupid.  This function should be a boolean predicate.  */
4939
4940 static long
4941 coff_canonicalize_reloc (bfd * abfd,
4942                          sec_ptr section,
4943                          arelent ** relptr,
4944                          asymbol ** symbols)
4945 {
4946   arelent *tblptr = section->relocation;
4947   unsigned int count = 0;
4948
4949   if (section->flags & SEC_CONSTRUCTOR)
4950     {
4951       /* This section has relocs made up by us, they are not in the
4952          file, so take them out of their chain and place them into
4953          the data area provided.  */
4954       arelent_chain *chain = section->constructor_chain;
4955
4956       for (count = 0; count < section->reloc_count; count++)
4957         {
4958           *relptr++ = &chain->relent;
4959           chain = chain->next;
4960         }
4961     }
4962   else
4963     {
4964       if (! coff_slurp_reloc_table (abfd, section, symbols))
4965         return -1;
4966
4967       tblptr = section->relocation;
4968
4969       for (; count++ < section->reloc_count;)
4970         *relptr++ = tblptr++;
4971     }
4972   *relptr = 0;
4973   return section->reloc_count;
4974 }
4975
4976 #ifndef coff_reloc16_estimate
4977 #define coff_reloc16_estimate dummy_reloc16_estimate
4978
4979 static int
4980 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
4981                         asection *input_section ATTRIBUTE_UNUSED,
4982                         arelent *reloc ATTRIBUTE_UNUSED,
4983                         unsigned int shrink ATTRIBUTE_UNUSED,
4984                         struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
4985 {
4986   abort ();
4987   return 0;
4988 }
4989
4990 #endif
4991
4992 #ifndef coff_reloc16_extra_cases
4993
4994 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4995
4996 /* This works even if abort is not declared in any header file.  */
4997
4998 static void
4999 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5000                            struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5001                            struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5002                            arelent *reloc ATTRIBUTE_UNUSED,
5003                            bfd_byte *data ATTRIBUTE_UNUSED,
5004                            unsigned int *src_ptr ATTRIBUTE_UNUSED,
5005                            unsigned int *dst_ptr ATTRIBUTE_UNUSED)
5006 {
5007   abort ();
5008 }
5009 #endif
5010
5011 #ifndef coff_bfd_link_hash_table_free
5012 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5013 #endif
5014
5015 /* If coff_relocate_section is defined, we can use the optimized COFF
5016    backend linker.  Otherwise we must continue to use the old linker.  */
5017
5018 #ifdef coff_relocate_section
5019
5020 #ifndef coff_bfd_link_hash_table_create
5021 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5022 #endif
5023 #ifndef coff_bfd_link_add_symbols
5024 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5025 #endif
5026 #ifndef coff_bfd_final_link
5027 #define coff_bfd_final_link _bfd_coff_final_link
5028 #endif
5029
5030 #else /* ! defined (coff_relocate_section) */
5031
5032 #define coff_relocate_section NULL
5033 #ifndef coff_bfd_link_hash_table_create
5034 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5035 #endif
5036 #ifndef coff_bfd_link_add_symbols
5037 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5038 #endif
5039 #define coff_bfd_final_link _bfd_generic_final_link
5040
5041 #endif /* ! defined (coff_relocate_section) */
5042
5043 #define coff_bfd_link_just_syms      _bfd_generic_link_just_syms
5044 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
5045
5046 #ifndef coff_start_final_link
5047 #define coff_start_final_link NULL
5048 #endif
5049
5050 #ifndef coff_adjust_symndx
5051 #define coff_adjust_symndx NULL
5052 #endif
5053
5054 #ifndef coff_link_add_one_symbol
5055 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5056 #endif
5057
5058 #ifndef coff_link_output_has_begun
5059
5060 static bfd_boolean
5061 coff_link_output_has_begun (bfd * abfd,
5062                             struct coff_final_link_info * info ATTRIBUTE_UNUSED)
5063 {
5064   return abfd->output_has_begun;
5065 }
5066 #endif
5067
5068 #ifndef coff_final_link_postscript
5069
5070 static bfd_boolean
5071 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5072                             struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
5073 {
5074   return TRUE;
5075 }
5076 #endif
5077
5078 #ifndef coff_SWAP_aux_in
5079 #define coff_SWAP_aux_in coff_swap_aux_in
5080 #endif
5081 #ifndef coff_SWAP_sym_in
5082 #define coff_SWAP_sym_in coff_swap_sym_in
5083 #endif
5084 #ifndef coff_SWAP_lineno_in
5085 #define coff_SWAP_lineno_in coff_swap_lineno_in
5086 #endif
5087 #ifndef coff_SWAP_aux_out
5088 #define coff_SWAP_aux_out coff_swap_aux_out
5089 #endif
5090 #ifndef coff_SWAP_sym_out
5091 #define coff_SWAP_sym_out coff_swap_sym_out
5092 #endif
5093 #ifndef coff_SWAP_lineno_out
5094 #define coff_SWAP_lineno_out coff_swap_lineno_out
5095 #endif
5096 #ifndef coff_SWAP_reloc_out
5097 #define coff_SWAP_reloc_out coff_swap_reloc_out
5098 #endif
5099 #ifndef coff_SWAP_filehdr_out
5100 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5101 #endif
5102 #ifndef coff_SWAP_aouthdr_out
5103 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5104 #endif
5105 #ifndef coff_SWAP_scnhdr_out
5106 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5107 #endif
5108 #ifndef coff_SWAP_reloc_in
5109 #define coff_SWAP_reloc_in coff_swap_reloc_in
5110 #endif
5111 #ifndef coff_SWAP_filehdr_in
5112 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5113 #endif
5114 #ifndef coff_SWAP_aouthdr_in
5115 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5116 #endif
5117 #ifndef coff_SWAP_scnhdr_in
5118 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5119 #endif
5120
5121 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
5122 {
5123   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5124   coff_SWAP_aux_out, coff_SWAP_sym_out,
5125   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5126   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5127   coff_SWAP_scnhdr_out,
5128   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5129 #ifdef COFF_LONG_FILENAMES
5130   TRUE,
5131 #else
5132   FALSE,
5133 #endif
5134 #ifdef COFF_LONG_SECTION_NAMES
5135   TRUE,
5136 #else
5137   FALSE,
5138 #endif
5139   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5140 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5141   TRUE,
5142 #else
5143   FALSE,
5144 #endif
5145 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5146   4,
5147 #else
5148   2,
5149 #endif
5150   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5151   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5152   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5153   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5154   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5155   coff_classify_symbol, coff_compute_section_file_positions,
5156   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5157   coff_adjust_symndx, coff_link_add_one_symbol,
5158   coff_link_output_has_begun, coff_final_link_postscript
5159 };
5160
5161 #ifdef TICOFF
5162 /* COFF0 differs in file/section header size and relocation entry size.  */
5163
5164 static const bfd_coff_backend_data ticoff0_swap_table =
5165 {
5166   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5167   coff_SWAP_aux_out, coff_SWAP_sym_out,
5168   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5169   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5170   coff_SWAP_scnhdr_out,
5171   FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5172 #ifdef COFF_LONG_FILENAMES
5173   TRUE,
5174 #else
5175   FALSE,
5176 #endif
5177 #ifdef COFF_LONG_SECTION_NAMES
5178   TRUE,
5179 #else
5180   FALSE,
5181 #endif
5182   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5183 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5184   TRUE,
5185 #else
5186   FALSE,
5187 #endif
5188 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5189   4,
5190 #else
5191   2,
5192 #endif
5193   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5194   coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5195   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5196   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5197   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5198   coff_classify_symbol, coff_compute_section_file_positions,
5199   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5200   coff_adjust_symndx, coff_link_add_one_symbol,
5201   coff_link_output_has_begun, coff_final_link_postscript
5202 };
5203 #endif
5204
5205 #ifdef TICOFF
5206 /* COFF1 differs in section header size.  */
5207
5208 static const bfd_coff_backend_data ticoff1_swap_table =
5209 {
5210   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5211   coff_SWAP_aux_out, coff_SWAP_sym_out,
5212   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5213   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5214   coff_SWAP_scnhdr_out,
5215   FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5216 #ifdef COFF_LONG_FILENAMES
5217   TRUE,
5218 #else
5219   FALSE,
5220 #endif
5221 #ifdef COFF_LONG_SECTION_NAMES
5222   TRUE,
5223 #else
5224   FALSE,
5225 #endif
5226   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5227 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5228   TRUE,
5229 #else
5230   FALSE,
5231 #endif
5232 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5233   4,
5234 #else
5235   2,
5236 #endif
5237   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5238   coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5239   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5240   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5241   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5242   coff_classify_symbol, coff_compute_section_file_positions,
5243   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5244   coff_adjust_symndx, coff_link_add_one_symbol,
5245   coff_link_output_has_begun, coff_final_link_postscript
5246 };
5247 #endif
5248
5249 #ifndef coff_close_and_cleanup
5250 #define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
5251 #endif
5252
5253 #ifndef coff_bfd_free_cached_info
5254 #define coff_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
5255 #endif
5256
5257 #ifndef coff_get_section_contents
5258 #define coff_get_section_contents           _bfd_generic_get_section_contents
5259 #endif
5260
5261 #ifndef coff_bfd_copy_private_symbol_data
5262 #define coff_bfd_copy_private_symbol_data   _bfd_generic_bfd_copy_private_symbol_data
5263 #endif
5264
5265 #ifndef coff_bfd_copy_private_header_data
5266 #define coff_bfd_copy_private_header_data   _bfd_generic_bfd_copy_private_header_data
5267 #endif
5268
5269 #ifndef coff_bfd_copy_private_section_data
5270 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
5271 #endif
5272
5273 #ifndef coff_bfd_copy_private_bfd_data
5274 #define coff_bfd_copy_private_bfd_data      _bfd_generic_bfd_copy_private_bfd_data
5275 #endif
5276
5277 #ifndef coff_bfd_merge_private_bfd_data
5278 #define coff_bfd_merge_private_bfd_data     _bfd_generic_bfd_merge_private_bfd_data
5279 #endif
5280
5281 #ifndef coff_bfd_set_private_flags
5282 #define coff_bfd_set_private_flags          _bfd_generic_bfd_set_private_flags
5283 #endif
5284
5285 #ifndef coff_bfd_print_private_bfd_data
5286 #define coff_bfd_print_private_bfd_data     _bfd_generic_bfd_print_private_bfd_data
5287 #endif
5288
5289 #ifndef coff_bfd_is_local_label_name
5290 #define coff_bfd_is_local_label_name        _bfd_coff_is_local_label_name
5291 #endif
5292
5293 #ifndef coff_bfd_is_target_special_symbol
5294 #define coff_bfd_is_target_special_symbol   ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5295 #endif
5296
5297 #ifndef coff_read_minisymbols
5298 #define coff_read_minisymbols               _bfd_generic_read_minisymbols
5299 #endif
5300
5301 #ifndef coff_minisymbol_to_symbol
5302 #define coff_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
5303 #endif
5304
5305 /* The reloc lookup routine must be supplied by each individual COFF
5306    backend.  */
5307 #ifndef coff_bfd_reloc_type_lookup
5308 #define coff_bfd_reloc_type_lookup          _bfd_norelocs_bfd_reloc_type_lookup
5309 #endif
5310
5311 #ifndef coff_bfd_get_relocated_section_contents
5312 #define coff_bfd_get_relocated_section_contents \
5313   bfd_generic_get_relocated_section_contents
5314 #endif
5315
5316 #ifndef coff_bfd_relax_section
5317 #define coff_bfd_relax_section              bfd_generic_relax_section
5318 #endif
5319
5320 #ifndef coff_bfd_gc_sections
5321 #define coff_bfd_gc_sections                bfd_generic_gc_sections
5322 #endif
5323
5324 #ifndef coff_bfd_merge_sections
5325 #define coff_bfd_merge_sections             bfd_generic_merge_sections
5326 #endif
5327
5328 #ifndef coff_bfd_is_group_section
5329 #define coff_bfd_is_group_section           bfd_generic_is_group_section
5330 #endif
5331
5332 #ifndef coff_bfd_discard_group
5333 #define coff_bfd_discard_group              bfd_generic_discard_group
5334 #endif
5335
5336 #ifndef coff_section_already_linked
5337 #define coff_section_already_linked \
5338   _bfd_generic_section_already_linked
5339 #endif
5340
5341 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)     \
5342 const bfd_target VAR =                                                  \
5343 {                                                                       \
5344   NAME ,                                                                \
5345   bfd_target_coff_flavour,                                              \
5346   BFD_ENDIAN_BIG,               /* Data byte order is big.  */          \
5347   BFD_ENDIAN_BIG,               /* Header byte order is big.  */        \
5348   /* object flags */                                                    \
5349   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5350    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5351   /* section flags */                                                   \
5352   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5353   UNDER,                        /* Leading symbol underscore.  */       \
5354   '/',                          /* AR_pad_char.  */                     \
5355   15,                           /* AR_max_namelen.  */                  \
5356                                                                         \
5357   /* Data conversion functions.  */                                     \
5358   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5359   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5360   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5361                                                                         \
5362   /* Header conversion functions.  */                                   \
5363   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5364   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5365   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5366                                                                         \
5367         /* bfd_check_format.  */                                        \
5368   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5369     _bfd_dummy_target },                                                \
5370         /* bfd_set_format.  */                                          \
5371   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5372         /* bfd_write_contents.  */                                      \
5373   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5374     bfd_false },                                                        \
5375                                                                         \
5376   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5377   BFD_JUMP_TABLE_COPY (coff),                                           \
5378   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5379   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5380   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5381   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5382   BFD_JUMP_TABLE_WRITE (coff),                                          \
5383   BFD_JUMP_TABLE_LINK (coff),                                           \
5384   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5385                                                                         \
5386   ALTERNATIVE,                                                          \
5387                                                                         \
5388   SWAP_TABLE                                                            \
5389 };
5390
5391 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)  \
5392 const bfd_target VAR =                                                  \
5393 {                                                                       \
5394   NAME ,                                                                \
5395   bfd_target_coff_flavour,                                              \
5396   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */       \
5397   BFD_ENDIAN_BIG,               /* Header byte order is big.  */        \
5398   /* object flags */                                                    \
5399   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5400    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5401   /* section flags */                                                   \
5402   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5403   UNDER,                        /* Leading symbol underscore.  */       \
5404   '/',                          /* AR_pad_char.  */                     \
5405   15,                           /* AR_max_namelen.  */                  \
5406                                                                         \
5407   /* Data conversion functions.  */                                     \
5408   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5409   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5410   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5411                                                                         \
5412   /* Header conversion functions.  */                                   \
5413   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5414   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5415   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5416                                                                         \
5417         /* bfd_check_format.  */                                        \
5418   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5419     _bfd_dummy_target },                                                \
5420         /* bfd_set_format.  */                                          \
5421   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5422         /* bfd_write_contents.  */                                      \
5423   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5424     bfd_false },                                                        \
5425                                                                         \
5426   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5427   BFD_JUMP_TABLE_COPY (coff),                                           \
5428   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5429   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5430   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5431   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5432   BFD_JUMP_TABLE_WRITE (coff),                                          \
5433   BFD_JUMP_TABLE_LINK (coff),                                           \
5434   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5435                                                                         \
5436   ALTERNATIVE,                                                          \
5437                                                                         \
5438   SWAP_TABLE                                                            \
5439 };
5440
5441 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)  \
5442 const bfd_target VAR =                                                  \
5443 {                                                                       \
5444   NAME ,                                                                \
5445   bfd_target_coff_flavour,                                              \
5446   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */       \
5447   BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */     \
5448         /* object flags */                                              \
5449   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5450    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5451         /* section flags */                                             \
5452   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5453   UNDER,                        /* Leading symbol underscore.  */       \
5454   '/',                          /* AR_pad_char.  */                     \
5455   15,                           /* AR_max_namelen.  */                  \
5456                                                                         \
5457   /* Data conversion functions.  */                                     \
5458   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5459   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5460   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5461   /* Header conversion functions.  */                                   \
5462   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5463   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5464   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5465         /* bfd_check_format.  */                                        \
5466   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5467     _bfd_dummy_target },                                                \
5468        /* bfd_set_format.  */                                           \
5469   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5470         /* bfd_write_contents.  */                                      \
5471   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5472     bfd_false },                                                        \
5473                                                                         \
5474   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5475   BFD_JUMP_TABLE_COPY (coff),                                           \
5476   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5477   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5478   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5479   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5480   BFD_JUMP_TABLE_WRITE (coff),                                          \
5481   BFD_JUMP_TABLE_LINK (coff),                                           \
5482   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5483                                                                         \
5484   ALTERNATIVE,                                                          \
5485                                                                         \
5486   SWAP_TABLE                                                            \
5487 };