bfd/coffcode.h

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