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