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