bfd/coffcode.h

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