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