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