bfd/coffcode.h

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