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