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