bfd/coffcode.h

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