contrib/binutils/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     abfd->section_tail = &current->next;
3018
3019     free (section_list);
3020   }
3021 #else /* ! COFF_IMAGE_WITH_PE */
3022   {
3023     /* Set the target_index field.  */
3024     int target_index;
3025
3026     target_index = 1;
3027     for (current = abfd->sections; current != NULL; current = current->next)
3028       current->target_index = target_index++;
3029   }
3030 #endif /* ! COFF_IMAGE_WITH_PE */
3031
3032   align_adjust = false;
3033   for (current = abfd->sections;
3034        current != (asection *) NULL;
3035        current = current->next)
3036     {
3037 #ifdef COFF_IMAGE_WITH_PE
3038       /* With PE we have to pad each section to be a multiple of its
3039          page size too, and remember both sizes.  */
3040       if (coff_section_data (abfd, current) == NULL)
3041         {
3042           bfd_size_type amt = sizeof (struct coff_section_tdata);
3043           current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
3044           if (current->used_by_bfd == NULL)
3045             return false;
3046         }
3047       if (pei_section_data (abfd, current) == NULL)
3048         {
3049           bfd_size_type amt = sizeof (struct pei_section_tdata);
3050           coff_section_data (abfd, current)->tdata
3051             = (PTR) bfd_zalloc (abfd, amt);
3052           if (coff_section_data (abfd, current)->tdata == NULL)
3053             return false;
3054         }
3055       if (pei_section_data (abfd, current)->virt_size == 0)
3056         pei_section_data (abfd, current)->virt_size = current->_raw_size;
3057 #endif
3058
3059       /* Only deal with sections which have contents.  */
3060       if (!(current->flags & SEC_HAS_CONTENTS))
3061         continue;
3062
3063 #ifdef COFF_IMAGE_WITH_PE
3064       /* Make sure we skip empty sections in a PE image.  */
3065       if (current->_raw_size == 0)
3066         continue;
3067 #endif
3068
3069       /* Align the sections in the file to the same boundary on
3070          which they are aligned in virtual memory.  I960 doesn't
3071          do this (FIXME) so we can stay in sync with Intel.  960
3072          doesn't yet page from files...  */
3073 #ifdef ALIGN_SECTIONS_IN_FILE
3074       if ((abfd->flags & EXEC_P) != 0)
3075         {
3076           /* make sure this section is aligned on the right boundary - by
3077              padding the previous section up if necessary */
3078
3079           old_sofar = sofar;
3080 #ifdef RS6000COFF_C
3081           /* AIX loader checks the text section alignment of (vma - filepos)
3082              So even though the filepos may be aligned wrt the o_algntext, for
3083              AIX executables, this check fails. This shows up when an native
3084              AIX executable is stripped with gnu strip because the default vma
3085              of native is 0x10000150 but default for gnu is 0x10000140.  Gnu
3086              stripped gnu excutable passes this check because the filepos is
3087              0x0140. */
3088           if (!strcmp (current->name, _TEXT))
3089             {
3090               bfd_vma pad;
3091               bfd_vma align;
3092
3093               sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3094
3095               align = 1 << current->alignment_power;
3096               pad = abs (current->vma - sofar) % align;
3097
3098               if (pad)
3099                 {
3100                   pad = align - pad;
3101                   sofar += pad;
3102                 }
3103             }
3104           else
3105 #else
3106             {
3107               sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3108             }
3109 #endif
3110           if (previous != (asection *) NULL)
3111             {
3112               previous->_raw_size += sofar - old_sofar;
3113             }
3114         }
3115
3116 #endif
3117
3118       /* In demand paged files the low order bits of the file offset
3119          must match the low order bits of the virtual address.  */
3120 #ifdef COFF_PAGE_SIZE
3121       if ((abfd->flags & D_PAGED) != 0
3122           && (current->flags & SEC_ALLOC) != 0)
3123         sofar += (current->vma - sofar) % page_size;
3124 #endif
3125       current->filepos = sofar;
3126
3127 #ifdef COFF_IMAGE_WITH_PE
3128       /* Set the padded size.  */
3129       current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3130 #endif
3131
3132       sofar += current->_raw_size;
3133
3134 #ifdef ALIGN_SECTIONS_IN_FILE
3135       /* make sure that this section is of the right size too */
3136       if ((abfd->flags & EXEC_P) == 0)
3137         {
3138           bfd_size_type old_size;
3139
3140           old_size = current->_raw_size;
3141           current->_raw_size = BFD_ALIGN (current->_raw_size,
3142                                           1 << current->alignment_power);
3143           align_adjust = current->_raw_size != old_size;
3144           sofar += current->_raw_size - old_size;
3145         }
3146       else
3147         {
3148           old_sofar = sofar;
3149           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3150           align_adjust = sofar != old_sofar;
3151           current->_raw_size += sofar - old_sofar;
3152         }
3153 #endif
3154
3155 #ifdef COFF_IMAGE_WITH_PE
3156       /* For PE we need to make sure we pad out to the aligned
3157          _raw_size, in case the caller only writes out data to the
3158          unaligned _raw_size.  */
3159       if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3160         align_adjust = true;
3161 #endif
3162
3163 #ifdef _LIB
3164       /* Force .lib sections to start at zero.  The vma is then
3165          incremented in coff_set_section_contents.  This is right for
3166          SVR3.2.  */
3167       if (strcmp (current->name, _LIB) == 0)
3168         bfd_set_section_vma (abfd, current, 0);
3169 #endif
3170
3171       previous = current;
3172     }
3173
3174   /* It is now safe to write to the output file.  If we needed an
3175      alignment adjustment for the last section, then make sure that
3176      there is a byte at offset sofar.  If there are no symbols and no
3177      relocs, then nothing follows the last section.  If we don't force
3178      the last byte out, then the file may appear to be truncated.  */
3179   if (align_adjust)
3180     {
3181       bfd_byte b;
3182
3183       b = 0;
3184       if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3185           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3186         return false;
3187     }
3188
3189   /* Make sure the relocations are aligned.  We don't need to make
3190      sure that this byte exists, because it will only matter if there
3191      really are relocs.  */
3192   sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3193
3194   obj_relocbase (abfd) = sofar;
3195   abfd->output_has_begun = true;
3196
3197   return true;
3198 }
3199
3200 #if 0
3201
3202 /* This can never work, because it is called too late--after the
3203    section positions have been set.  I can't figure out what it is
3204    for, so I am going to disable it--Ian Taylor 20 March 1996.  */
3205
3206 /* If .file, .text, .data, .bss symbols are missing, add them.  */
3207 /* @@ Should we only be adding missing symbols, or overriding the aux
3208    values for existing section symbols?  */
3209 static boolean
3210 coff_add_missing_symbols (abfd)
3211      bfd *abfd;
3212 {
3213   unsigned int nsyms = bfd_get_symcount (abfd);
3214   asymbol **sympp = abfd->outsymbols;
3215   asymbol **sympp2;
3216   unsigned int i;
3217   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3218   bfd_size_type amt;
3219
3220   for (i = 0; i < nsyms; i++)
3221     {
3222       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3223       const char *name;
3224       if (csym)
3225         {
3226           /* only do this if there is a coff representation of the input
3227            symbol */
3228           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3229             {
3230               need_file = 0;
3231               continue;
3232             }
3233           name = csym->symbol.name;
3234           if (!name)
3235             continue;
3236           if (!strcmp (name, _TEXT))
3237             need_text = 0;
3238 #ifdef APOLLO_M68
3239           else if (!strcmp (name, ".wtext"))
3240             need_text = 0;
3241 #endif
3242           else if (!strcmp (name, _DATA))
3243             need_data = 0;
3244           else if (!strcmp (name, _BSS))
3245             need_bss = 0;
3246         }
3247     }
3248   /* Now i == bfd_get_symcount (abfd).  */
3249   /* @@ For now, don't deal with .file symbol.  */
3250   need_file = 0;
3251
3252   if (!need_text && !need_data && !need_bss && !need_file)
3253     return true;
3254   nsyms += need_text + need_data + need_bss + need_file;
3255   amt = nsyms;
3256   amt *= sizeof (asymbol *);
3257   sympp2 = (asymbol **) bfd_alloc (abfd, amt);
3258   if (!sympp2)
3259     return false;
3260   memcpy (sympp2, sympp, i * sizeof (asymbol *));
3261   if (need_file)
3262     {
3263       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
3264       abort ();
3265     }
3266   if (need_text)
3267     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3268   if (need_data)
3269     sympp2[i++] = coff_section_symbol (abfd, _DATA);
3270   if (need_bss)
3271     sympp2[i++] = coff_section_symbol (abfd, _BSS);
3272   BFD_ASSERT (i == nsyms);
3273   bfd_set_symtab (abfd, sympp2, nsyms);
3274   return true;
3275 }
3276
3277 #endif /* 0 */
3278
3279 /* SUPPRESS 558 */
3280 /* SUPPRESS 529 */
3281 static boolean
3282 coff_write_object_contents (abfd)
3283      bfd * abfd;
3284 {
3285   asection *current;
3286   boolean hasrelocs = false;
3287   boolean haslinno = false;
3288   boolean hasdebug = false;
3289   file_ptr scn_base;
3290   file_ptr reloc_base;
3291   file_ptr lineno_base;
3292   file_ptr sym_base;
3293   unsigned long reloc_size = 0, reloc_count = 0;
3294   unsigned long lnno_size = 0;
3295   boolean long_section_names;
3296   asection *text_sec = NULL;
3297   asection *data_sec = NULL;
3298   asection *bss_sec = NULL;
3299   struct internal_filehdr internal_f;
3300   struct internal_aouthdr internal_a;
3301 #ifdef COFF_LONG_SECTION_NAMES
3302   size_t string_size = STRING_SIZE_SIZE;
3303 #endif
3304
3305   bfd_set_error (bfd_error_system_call);
3306
3307   /* Make a pass through the symbol table to count line number entries and
3308      put them into the correct asections */
3309
3310   lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3311
3312   if (abfd->output_has_begun == false)
3313     {
3314       if (! coff_compute_section_file_positions (abfd))
3315         return false;
3316     }
3317
3318   reloc_base = obj_relocbase (abfd);
3319
3320   /* Work out the size of the reloc and linno areas */
3321
3322   for (current = abfd->sections; current != NULL; current =
3323        current->next)
3324     {
3325 #ifdef COFF_WITH_PE
3326       /* we store the actual reloc count in the first reloc's addr */
3327       if (current->reloc_count > 0xffff)
3328         reloc_count ++;
3329 #endif
3330       reloc_count += current->reloc_count;
3331     }
3332
3333   reloc_size = reloc_count * bfd_coff_relsz (abfd);
3334
3335   lineno_base = reloc_base + reloc_size;
3336   sym_base = lineno_base + lnno_size;
3337
3338   /* Indicate in each section->line_filepos its actual file address */
3339   for (current = abfd->sections; current != NULL; current =
3340        current->next)
3341     {
3342       if (current->lineno_count)
3343         {
3344           current->line_filepos = lineno_base;
3345           current->moving_line_filepos = lineno_base;
3346           lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3347         }
3348       else
3349         {
3350           current->line_filepos = 0;
3351         }
3352       if (current->reloc_count)
3353         {
3354           current->rel_filepos = reloc_base;
3355           reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3356 #ifdef COFF_WITH_PE
3357           /* extra reloc to hold real count */
3358           if (current->reloc_count > 0xffff)
3359             reloc_base += bfd_coff_relsz (abfd);
3360 #endif
3361         }
3362       else
3363         {
3364           current->rel_filepos = 0;
3365         }
3366     }
3367
3368   /* Write section headers to the file.  */
3369   internal_f.f_nscns = 0;
3370
3371   if ((abfd->flags & EXEC_P) != 0)
3372     scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3373   else
3374     {
3375       scn_base = bfd_coff_filhsz (abfd);
3376 #ifdef RS6000COFF_C
3377 #ifndef XCOFF64
3378       if (xcoff_data (abfd)->full_aouthdr)
3379         scn_base += bfd_coff_aoutsz (abfd);
3380       else
3381         scn_base += SMALL_AOUTSZ;
3382 #endif
3383 #endif
3384     }
3385
3386   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3387     return false;
3388
3389   long_section_names = false;
3390   for (current = abfd->sections;
3391        current != NULL;
3392        current = current->next)
3393     {
3394       struct internal_scnhdr section;
3395       boolean is_reloc_section = false;
3396
3397 #ifdef COFF_IMAGE_WITH_PE
3398       if (strcmp (current->name, ".reloc") == 0)
3399         {
3400           is_reloc_section = true;
3401           hasrelocs = true;
3402           pe_data (abfd)->has_reloc_section = 1;
3403         }
3404 #endif
3405
3406       internal_f.f_nscns++;
3407
3408       strncpy (section.s_name, current->name, SCNNMLEN);
3409
3410 #ifdef COFF_LONG_SECTION_NAMES
3411       /* Handle long section names as in PE.  This must be compatible
3412          with the code in coff_write_symbols and _bfd_coff_final_link.  */
3413       {
3414         size_t len;
3415
3416         len = strlen (current->name);
3417         if (len > SCNNMLEN)
3418           {
3419             memset (section.s_name, 0, SCNNMLEN);
3420             sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3421             string_size += len + 1;
3422             long_section_names = true;
3423           }
3424       }
3425 #endif
3426
3427 #ifdef _LIB
3428       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
3429          Ian Taylor <ian@cygnus.com>.  */
3430       if (strcmp (current->name, _LIB) == 0)
3431         section.s_vaddr = 0;
3432       else
3433 #endif
3434       section.s_vaddr = current->vma;
3435       section.s_paddr = current->lma;
3436       section.s_size =  current->_raw_size;
3437 #ifdef coff_get_section_load_page
3438       section.s_page = coff_get_section_load_page (current);
3439 #endif
3440
3441 #ifdef COFF_WITH_PE
3442       section.s_paddr = 0;
3443 #endif
3444 #ifdef COFF_IMAGE_WITH_PE
3445       /* Reminder: s_paddr holds the virtual size of the section.  */
3446       if (coff_section_data (abfd, current) != NULL
3447           && pei_section_data (abfd, current) != NULL)
3448         section.s_paddr = pei_section_data (abfd, current)->virt_size;
3449       else
3450         section.s_paddr = 0;
3451 #endif
3452
3453       /*
3454          If this section has no size or is unloadable then the scnptr
3455          will be 0 too
3456          */
3457       if (current->_raw_size == 0 ||
3458           (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3459         {
3460           section.s_scnptr = 0;
3461         }
3462       else
3463         {
3464           section.s_scnptr = current->filepos;
3465         }
3466       section.s_relptr = current->rel_filepos;
3467       section.s_lnnoptr = current->line_filepos;
3468       section.s_nreloc = current->reloc_count;
3469       section.s_nlnno = current->lineno_count;
3470 #ifndef COFF_IMAGE_WITH_PE
3471       /* In PEI, relocs come in the .reloc section.  */
3472       if (current->reloc_count != 0)
3473         hasrelocs = true;
3474 #endif
3475       if (current->lineno_count != 0)
3476         haslinno = true;
3477       if ((current->flags & SEC_DEBUGGING) != 0
3478           && ! is_reloc_section)
3479         hasdebug = true;
3480
3481 #ifdef RS6000COFF_C
3482 #ifndef XCOFF64
3483       /* Indicate the use of an XCOFF overflow section header.  */
3484       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3485         {
3486           section.s_nreloc = 0xffff;
3487           section.s_nlnno = 0xffff;
3488         }
3489 #endif
3490 #endif
3491
3492       section.s_flags = sec_to_styp_flags (current->name, current->flags);
3493
3494       if (!strcmp (current->name, _TEXT))
3495         {
3496           text_sec = current;
3497         }
3498       else if (!strcmp (current->name, _DATA))
3499         {
3500           data_sec = current;
3501         }
3502       else if (!strcmp (current->name, _BSS))
3503         {
3504           bss_sec = current;
3505         }
3506
3507 #ifdef I960
3508       section.s_align = (current->alignment_power
3509                          ? 1 << current->alignment_power
3510                          : 0);
3511 #endif
3512 #ifdef TIC80COFF
3513       /* TI COFF puts the alignment power in bits 8-11 of the flags */
3514       section.s_flags |= (current->alignment_power & 0xF) << 8;
3515 #endif
3516 #ifdef COFF_ENCODE_ALIGNMENT
3517       COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3518 #endif
3519
3520 #ifdef COFF_IMAGE_WITH_PE
3521       /* Suppress output of the sections if they are null.  ld
3522          includes the bss and data sections even if there is no size
3523          assigned to them.  NT loader doesn't like it if these section
3524          headers are included if the sections themselves are not
3525          needed.  See also coff_compute_section_file_positions.  */
3526       if (section.s_size == 0)
3527         internal_f.f_nscns--;
3528       else
3529 #endif
3530         {
3531           SCNHDR buff;
3532           bfd_size_type amt = bfd_coff_scnhsz (abfd);
3533
3534           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3535               || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3536             return false;
3537         }
3538
3539 #ifdef COFF_WITH_PE
3540       /* PE stores COMDAT section information in the symbol table.  If
3541          this section is supposed to have some COMDAT info, track down
3542          the symbol in the symbol table and modify it.  */
3543       if ((current->flags & SEC_LINK_ONCE) != 0)
3544         {
3545           unsigned int i, count;
3546           asymbol **psym;
3547           coff_symbol_type *csym = NULL;
3548           asymbol **psymsec;
3549
3550           psymsec = NULL;
3551           count = bfd_get_symcount (abfd);
3552           for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3553             {
3554               if ((*psym)->section != current)
3555                 continue;
3556
3557               /* Remember the location of the first symbol in this
3558                  section.  */
3559               if (psymsec == NULL)
3560                 psymsec = psym;
3561
3562               /* See if this is the section symbol.  */
3563               if (strcmp ((*psym)->name, current->name) == 0)
3564                 {
3565                   csym = coff_symbol_from (abfd, *psym);
3566                   if (csym == NULL
3567                       || csym->native == NULL
3568                       || csym->native->u.syment.n_numaux < 1
3569                       || csym->native->u.syment.n_sclass != C_STAT
3570                       || csym->native->u.syment.n_type != T_NULL)
3571                     continue;
3572
3573                   /* Here *PSYM is the section symbol for CURRENT.  */
3574
3575                   break;
3576                 }
3577             }
3578
3579           /* Did we find it?
3580              Note that we might not if we're converting the file from
3581              some other object file format.  */
3582           if (i < count)
3583             {
3584               combined_entry_type *aux;
3585
3586               /* We don't touch the x_checksum field.  The
3587                  x_associated field is not currently supported.  */
3588
3589               aux = csym->native + 1;
3590               switch (current->flags & SEC_LINK_DUPLICATES)
3591                 {
3592                 case SEC_LINK_DUPLICATES_DISCARD:
3593                   aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3594                   break;
3595
3596                 case SEC_LINK_DUPLICATES_ONE_ONLY:
3597                   aux->u.auxent.x_scn.x_comdat =
3598                     IMAGE_COMDAT_SELECT_NODUPLICATES;
3599                   break;
3600
3601                 case SEC_LINK_DUPLICATES_SAME_SIZE:
3602                   aux->u.auxent.x_scn.x_comdat =
3603                     IMAGE_COMDAT_SELECT_SAME_SIZE;
3604                   break;
3605
3606                 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3607                   aux->u.auxent.x_scn.x_comdat =
3608                     IMAGE_COMDAT_SELECT_EXACT_MATCH;
3609                   break;
3610                 }
3611
3612               /* The COMDAT symbol must be the first symbol from this
3613                  section in the symbol table.  In order to make this
3614                  work, we move the COMDAT symbol before the first
3615                  symbol we found in the search above.  It's OK to
3616                  rearrange the symbol table at this point, because
3617                  coff_renumber_symbols is going to rearrange it
3618                  further and fix up all the aux entries.  */
3619               if (psym != psymsec)
3620                 {
3621                   asymbol *hold;
3622                   asymbol **pcopy;
3623
3624                   hold = *psym;
3625                   for (pcopy = psym; pcopy > psymsec; pcopy--)
3626                     pcopy[0] = pcopy[-1];
3627                   *psymsec = hold;
3628                 }
3629             }
3630         }
3631 #endif /* COFF_WITH_PE */
3632     }
3633
3634 #ifdef RS6000COFF_C
3635 #ifndef XCOFF64
3636   /* XCOFF handles overflows in the reloc and line number count fields
3637      by creating a new section header to hold the correct values.  */
3638   for (current = abfd->sections; current != NULL; current = current->next)
3639     {
3640       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3641         {
3642           struct internal_scnhdr scnhdr;
3643           SCNHDR buff;
3644           bfd_size_type amt;
3645
3646           internal_f.f_nscns++;
3647           strncpy (&(scnhdr.s_name[0]), current->name, 8);
3648           scnhdr.s_paddr = current->reloc_count;
3649           scnhdr.s_vaddr = current->lineno_count;
3650           scnhdr.s_size = 0;
3651           scnhdr.s_scnptr = 0;
3652           scnhdr.s_relptr = current->rel_filepos;
3653           scnhdr.s_lnnoptr = current->line_filepos;
3654           scnhdr.s_nreloc = current->target_index;
3655           scnhdr.s_nlnno = current->target_index;
3656           scnhdr.s_flags = STYP_OVRFLO;
3657           amt = bfd_coff_scnhsz (abfd);
3658           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3659               || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3660             return false;
3661         }
3662     }
3663 #endif
3664 #endif
3665
3666   /* OK, now set up the filehdr...  */
3667
3668   /* Don't include the internal abs section in the section count */
3669
3670   /*
3671      We will NOT put a fucking timestamp in the header here. Every time you
3672      put it back, I will come in and take it out again.  I'm sorry.  This
3673      field does not belong here.  We fill it with a 0 so it compares the
3674      same but is not a reasonable time. -- gnu@cygnus.com
3675      */
3676   internal_f.f_timdat = 0;
3677
3678   internal_f.f_flags = 0;
3679
3680   if (abfd->flags & EXEC_P)
3681     internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3682   else
3683     {
3684       internal_f.f_opthdr = 0;
3685 #ifdef RS6000COFF_C
3686 #ifndef XCOFF64
3687       if (xcoff_data (abfd)->full_aouthdr)
3688         internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3689       else
3690         internal_f.f_opthdr = SMALL_AOUTSZ;
3691 #endif
3692 #endif
3693     }
3694
3695   if (!hasrelocs)
3696     internal_f.f_flags |= F_RELFLG;
3697   if (!haslinno)
3698     internal_f.f_flags |= F_LNNO;
3699   if (abfd->flags & EXEC_P)
3700     internal_f.f_flags |= F_EXEC;
3701 #ifdef COFF_IMAGE_WITH_PE
3702   if (! hasdebug)
3703     internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3704 #endif
3705
3706 #ifndef COFF_WITH_PE
3707   if (bfd_little_endian (abfd))
3708     internal_f.f_flags |= F_AR32WR;
3709   else
3710     internal_f.f_flags |= F_AR32W;
3711 #endif
3712
3713 #ifdef TI_TARGET_ID
3714   /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3715      but it doesn't hurt to set it internally */
3716   internal_f.f_target_id = TI_TARGET_ID;
3717 #endif
3718 #ifdef TIC80_TARGET_ID
3719   internal_f.f_target_id = TIC80_TARGET_ID;
3720 #endif
3721
3722   /*
3723      FIXME, should do something about the other byte orders and
3724      architectures.
3725      */
3726
3727 #ifdef RS6000COFF_C
3728   if ((abfd->flags & DYNAMIC) != 0)
3729     internal_f.f_flags |= F_SHROBJ;
3730   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3731     internal_f.f_flags |= F_DYNLOAD;
3732 #endif
3733
3734   memset (&internal_a, 0, sizeof internal_a);
3735
3736   /* Set up architecture-dependent stuff */
3737
3738   {
3739     unsigned int magic = 0;
3740     unsigned short flags = 0;
3741     coff_set_flags (abfd, &magic, &flags);
3742     internal_f.f_magic = magic;
3743     internal_f.f_flags |= flags;
3744     /* ...and the "opt"hdr...  */
3745
3746 #ifdef A29K
3747 #ifdef ULTRA3                   /* NYU's machine */
3748     /* FIXME: This is a bogus check.  I really want to see if there
3749      * is a .shbss or a .shdata section, if so then set the magic
3750      * number to indicate a shared data executable.
3751      */
3752     if (internal_f.f_nscns >= 7)
3753       internal_a.magic = SHMAGIC; /* Shared magic */
3754     else
3755 #endif /* ULTRA3 */
3756       internal_a.magic = NMAGIC; /* Assume separate i/d */
3757 #define __A_MAGIC_SET__
3758 #endif /* A29K */
3759 #ifdef TICOFF_AOUT_MAGIC
3760     internal_a.magic = TICOFF_AOUT_MAGIC;
3761 #define __A_MAGIC_SET__
3762 #endif
3763 #ifdef TIC80COFF
3764     internal_a.magic = TIC80_ARCH_MAGIC;
3765 #define __A_MAGIC_SET__
3766 #endif /* TIC80 */
3767 #ifdef I860
3768     /* FIXME: What are the a.out magic numbers for the i860?  */
3769     internal_a.magic = 0;
3770 #define __A_MAGIC_SET__
3771 #endif /* I860 */
3772 #ifdef I960
3773     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3774 #define __A_MAGIC_SET__
3775 #endif /* I960 */
3776 #if M88
3777 #define __A_MAGIC_SET__
3778     internal_a.magic = PAGEMAGICBCS;
3779 #endif /* M88 */
3780
3781 #if APOLLO_M68
3782 #define __A_MAGIC_SET__
3783     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3784 #endif
3785
3786 #if defined(M68) || defined(WE32K) || defined(M68K)
3787 #define __A_MAGIC_SET__
3788 #if defined(LYNXOS)
3789     internal_a.magic = LYNXCOFFMAGIC;
3790 #else
3791 #if defined(TARG_AUX)
3792     internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3793                         abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3794                         PAGEMAGICEXECSWAPPED);
3795 #else
3796 #if defined (PAGEMAGICPEXECPAGED)
3797     internal_a.magic = PAGEMAGICPEXECPAGED;
3798 #endif
3799 #endif /* TARG_AUX */
3800 #endif /* LYNXOS */
3801 #endif /* M68 || WE32K || M68K */
3802
3803 #if defined(ARM)
3804 #define __A_MAGIC_SET__
3805     internal_a.magic = ZMAGIC;
3806 #endif
3807
3808 #if defined(PPC_PE)
3809 #define __A_MAGIC_SET__
3810     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3811 #endif
3812
3813 #if defined MCORE_PE
3814 #define __A_MAGIC_SET__
3815     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3816 #endif
3817
3818 #if defined(I386)
3819 #define __A_MAGIC_SET__
3820 #if defined(LYNXOS)
3821     internal_a.magic = LYNXCOFFMAGIC;
3822 #else  /* LYNXOS */
3823     internal_a.magic = ZMAGIC;
3824 #endif /* LYNXOS */
3825 #endif /* I386 */
3826
3827 #if defined(IA64)
3828 #define __A_MAGIC_SET__
3829     internal_a.magic = ZMAGIC;
3830 #endif /* IA64 */
3831
3832 #if defined(SPARC)
3833 #define __A_MAGIC_SET__
3834 #if defined(LYNXOS)
3835     internal_a.magic = LYNXCOFFMAGIC;
3836 #endif /* LYNXOS */
3837 #endif /* SPARC */
3838
3839 #ifdef RS6000COFF_C
3840 #define __A_MAGIC_SET__
3841     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3842     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3843     RS6K_AOUTHDR_OMAGIC;
3844 #endif
3845
3846 #if defined(SH) && defined(COFF_WITH_PE)
3847 #define __A_MAGIC_SET__
3848     internal_a.magic = SH_PE_MAGIC;
3849 #endif
3850
3851 #if defined(MIPS) && defined(COFF_WITH_PE)
3852 #define __A_MAGIC_SET__
3853     internal_a.magic = MIPS_PE_MAGIC;
3854 #endif
3855
3856 #ifdef OR32
3857 #define __A_MAGIC_SET__
3858     internal_a.magic = NMAGIC; /* Assume separate i/d.  */
3859 #endif
3860
3861 #ifndef __A_MAGIC_SET__
3862 #include "Your aouthdr magic number is not being set!"
3863 #else
3864 #undef __A_MAGIC_SET__
3865 #endif
3866   }
3867
3868   /* FIXME: Does anybody ever set this to another value?  */
3869   internal_a.vstamp = 0;
3870
3871   /* Now should write relocs, strings, syms */
3872   obj_sym_filepos (abfd) = sym_base;
3873
3874   if (bfd_get_symcount (abfd) != 0)
3875     {
3876       int firstundef;
3877 #if 0
3878       if (!coff_add_missing_symbols (abfd))
3879         return false;
3880 #endif
3881       if (!coff_renumber_symbols (abfd, &firstundef))
3882         return false;
3883       coff_mangle_symbols (abfd);
3884       if (! coff_write_symbols (abfd))
3885         return false;
3886       if (! coff_write_linenumbers (abfd))
3887         return false;
3888       if (! coff_write_relocs (abfd, firstundef))
3889         return false;
3890     }
3891 #ifdef COFF_LONG_SECTION_NAMES
3892   else if (long_section_names && ! obj_coff_strings_written (abfd))
3893     {
3894       /* If we have long section names we have to write out the string
3895          table even if there are no symbols.  */
3896       if (! coff_write_symbols (abfd))
3897         return false;
3898     }
3899 #endif
3900 #ifdef COFF_IMAGE_WITH_PE
3901 #ifdef PPC_PE
3902   else if ((abfd->flags & EXEC_P) != 0)
3903     {
3904       bfd_byte b;
3905
3906       /* PowerPC PE appears to require that all executable files be
3907          rounded up to the page size.  */
3908       b = 0;
3909       if (bfd_seek (abfd,
3910                     (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3911                     SEEK_SET) != 0
3912           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3913         return false;
3914     }
3915 #endif
3916 #endif
3917
3918   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3919      backend linker, and obj_raw_syment_count is not valid until after
3920      coff_write_symbols is called.  */
3921   if (obj_raw_syment_count (abfd) != 0)
3922     {
3923       internal_f.f_symptr = sym_base;
3924 #ifdef RS6000COFF_C
3925       /* AIX appears to require that F_RELFLG not be set if there are
3926          local symbols but no relocations.  */
3927       internal_f.f_flags &=~ F_RELFLG;
3928 #endif
3929     }
3930   else
3931     {
3932       if (long_section_names)
3933         internal_f.f_symptr = sym_base;
3934       else
3935         internal_f.f_symptr = 0;
3936       internal_f.f_flags |= F_LSYMS;
3937     }
3938
3939   if (text_sec)
3940     {
3941       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3942       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3943     }
3944   if (data_sec)
3945     {
3946       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3947       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3948     }
3949   if (bss_sec)
3950     {
3951       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3952       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3953         internal_a.data_start = bss_sec->vma;
3954     }
3955
3956   internal_a.entry = bfd_get_start_address (abfd);
3957   internal_f.f_nsyms = obj_raw_syment_count (abfd);
3958
3959 #ifdef RS6000COFF_C
3960   if (xcoff_data (abfd)->full_aouthdr)
3961     {
3962       bfd_vma toc;
3963       asection *loader_sec;
3964
3965       internal_a.vstamp = 1;
3966
3967       internal_a.o_snentry = xcoff_data (abfd)->snentry;
3968       if (internal_a.o_snentry == 0)
3969         internal_a.entry = (bfd_vma) -1;
3970
3971       if (text_sec != NULL)
3972         {
3973           internal_a.o_sntext = text_sec->target_index;
3974           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3975         }
3976       else
3977         {
3978           internal_a.o_sntext = 0;
3979           internal_a.o_algntext = 0;
3980         }
3981       if (data_sec != NULL)
3982         {
3983           internal_a.o_sndata = data_sec->target_index;
3984           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3985         }
3986       else
3987         {
3988           internal_a.o_sndata = 0;
3989           internal_a.o_algndata = 0;
3990         }
3991       loader_sec = bfd_get_section_by_name (abfd, ".loader");
3992       if (loader_sec != NULL)
3993         internal_a.o_snloader = loader_sec->target_index;
3994       else
3995         internal_a.o_snloader = 0;
3996       if (bss_sec != NULL)
3997         internal_a.o_snbss = bss_sec->target_index;
3998       else
3999         internal_a.o_snbss = 0;
4000
4001       toc = xcoff_data (abfd)->toc;
4002       internal_a.o_toc = toc;
4003       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4004
4005       internal_a.o_modtype = xcoff_data (abfd)->modtype;
4006       if (xcoff_data (abfd)->cputype != -1)
4007         internal_a.o_cputype = xcoff_data (abfd)->cputype;
4008       else
4009         {
4010           switch (bfd_get_arch (abfd))
4011             {
4012             case bfd_arch_rs6000:
4013               internal_a.o_cputype = 4;
4014               break;
4015             case bfd_arch_powerpc:
4016               if (bfd_get_mach (abfd) == 0)
4017                 internal_a.o_cputype = 3;
4018               else
4019                 internal_a.o_cputype = 1;
4020               break;
4021             default:
4022               abort ();
4023             }
4024         }
4025       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4026       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4027     }
4028 #endif
4029
4030   /* now write them */
4031   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4032     return false;
4033
4034   {
4035     char * buff;
4036     bfd_size_type amount = bfd_coff_filhsz (abfd);
4037
4038     buff = bfd_malloc (amount);
4039     if (buff == NULL)
4040       return false;
4041
4042     bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
4043     amount = bfd_bwrite ((PTR) buff, amount, abfd);
4044
4045     free (buff);
4046
4047     if (amount != bfd_coff_filhsz (abfd))
4048       return false;
4049   }
4050
4051   if (abfd->flags & EXEC_P)
4052     {
4053       /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4054          include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
4055       char * buff;
4056       bfd_size_type amount = bfd_coff_aoutsz (abfd);
4057
4058       buff = bfd_malloc (amount);
4059       if (buff == NULL)
4060         return false;
4061
4062       coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
4063       amount = bfd_bwrite ((PTR) buff, amount, abfd);
4064
4065       free (buff);
4066
4067       if (amount != bfd_coff_aoutsz (abfd))
4068         return false;
4069     }
4070 #ifdef RS6000COFF_C
4071   else
4072     {
4073       AOUTHDR buff;
4074       size_t size;
4075
4076       /* XCOFF seems to always write at least a small a.out header.  */
4077       coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4078       if (xcoff_data (abfd)->full_aouthdr)
4079         size = bfd_coff_aoutsz (abfd);
4080       else
4081         size = SMALL_AOUTSZ;
4082       if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size)
4083         return false;
4084     }
4085 #endif
4086
4087   return true;
4088 }
4089
4090 static boolean
4091 coff_set_section_contents (abfd, section, location, offset, count)
4092      bfd * abfd;
4093      sec_ptr section;
4094      PTR location;
4095      file_ptr offset;
4096      bfd_size_type count;
4097 {
4098   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
4099     {
4100       if (! coff_compute_section_file_positions (abfd))
4101         return false;
4102     }
4103
4104 #if defined(_LIB) && !defined(TARG_AUX)
4105
4106    /* The physical address field of a .lib section is used to hold the
4107       number of shared libraries in the section.  This code counts the
4108       number of sections being written, and increments the lma field
4109       with the number.
4110
4111       I have found no documentation on the contents of this section.
4112       Experimentation indicates that the section contains zero or more
4113       records, each of which has the following structure:
4114
4115       - a (four byte) word holding the length of this record, in words,
4116       - a word that always seems to be set to "2",
4117       - the path to a shared library, null-terminated and then padded
4118         to a whole word boundary.
4119
4120       bfd_assert calls have been added to alert if an attempt is made
4121       to write a section which doesn't follow these assumptions.  The
4122       code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4123       <robertl@arnet.com> (Thanks!).
4124
4125       Gvran Uddeborg <gvran@uddeborg.pp.se> */
4126
4127     if (strcmp (section->name, _LIB) == 0)
4128       {
4129         bfd_byte *rec, *recend;
4130
4131         rec = (bfd_byte *) location;
4132         recend = rec + count;
4133         while (rec < recend)
4134           {
4135             ++section->lma;
4136             rec += bfd_get_32 (abfd, rec) * 4;
4137           }
4138
4139         BFD_ASSERT (rec == recend);
4140       }
4141
4142 #endif
4143
4144   /* Don't write out bss sections - one way to do this is to
4145        see if the filepos has not been set.  */
4146   if (section->filepos == 0)
4147     return true;
4148
4149   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4150     return false;
4151
4152   if (count == 0)
4153     return true;
4154
4155   return bfd_bwrite (location, count, abfd) == count;
4156 }
4157 #if 0
4158 static boolean
4159 coff_close_and_cleanup (abfd)
4160      bfd *abfd;
4161 {
4162   if (!bfd_read_p (abfd))
4163     switch (abfd->format)
4164       {
4165       case bfd_archive:
4166         if (!_bfd_write_archive_contents (abfd))
4167           return false;
4168         break;
4169       case bfd_object:
4170         if (!coff_write_object_contents (abfd))
4171           return false;
4172         break;
4173       default:
4174         bfd_set_error (bfd_error_invalid_operation);
4175         return false;
4176       }
4177
4178   /* We depend on bfd_close to free all the memory on the objalloc.  */
4179   return true;
4180 }
4181
4182 #endif
4183
4184 static PTR
4185 buy_and_read (abfd, where, size)
4186      bfd *abfd;
4187      file_ptr where;
4188      bfd_size_type size;
4189 {
4190   PTR area = (PTR) bfd_alloc (abfd, size);
4191   if (!area)
4192     return (NULL);
4193   if (bfd_seek (abfd, where, SEEK_SET) != 0
4194       || bfd_bread (area, size, abfd) != size)
4195     return (NULL);
4196   return (area);
4197 }                               /* buy_and_read() */
4198
4199 /*
4200 SUBSUBSECTION
4201         Reading linenumbers
4202
4203         Creating the linenumber table is done by reading in the entire
4204         coff linenumber table, and creating another table for internal use.
4205
4206         A coff linenumber table is structured so that each function
4207         is marked as having a line number of 0. Each line within the
4208         function is an offset from the first line in the function. The
4209         base of the line number information for the table is stored in
4210         the symbol associated with the function.
4211
4212         Note: The PE format uses line number 0 for a flag indicating a
4213         new source file.
4214
4215         The information is copied from the external to the internal
4216         table, and each symbol which marks a function is marked by
4217         pointing its...
4218
4219         How does this work ?
4220
4221 */
4222
4223 static boolean
4224 coff_slurp_line_table (abfd, asect)
4225      bfd *abfd;
4226      asection *asect;
4227 {
4228   LINENO *native_lineno;
4229   alent *lineno_cache;
4230   bfd_size_type amt;
4231
4232   BFD_ASSERT (asect->lineno == (alent *) NULL);
4233
4234   amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4235   native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4236   amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4237   lineno_cache = (alent *) bfd_alloc (abfd, amt);
4238   if (lineno_cache == NULL)
4239     return false;
4240   else
4241     {
4242       unsigned int counter = 0;
4243       alent *cache_ptr = lineno_cache;
4244       LINENO *src = native_lineno;
4245
4246       while (counter < asect->lineno_count)
4247         {
4248           struct internal_lineno dst;
4249           bfd_coff_swap_lineno_in (abfd, src, &dst);
4250           cache_ptr->line_number = dst.l_lnno;
4251
4252           if (cache_ptr->line_number == 0)
4253             {
4254               boolean warned;
4255               bfd_signed_vma symndx;
4256               coff_symbol_type *sym;
4257
4258               warned = false;
4259               symndx = dst.l_addr.l_symndx;
4260               if (symndx < 0
4261                   || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4262                 {
4263                   (*_bfd_error_handler)
4264                     (_("%s: warning: illegal symbol index %ld in line numbers"),
4265                      bfd_archive_filename (abfd), dst.l_addr.l_symndx);
4266                   symndx = 0;
4267                   warned = true;
4268                 }
4269               /* FIXME: We should not be casting between ints and
4270                  pointers like this.  */
4271               sym = ((coff_symbol_type *)
4272                      ((symndx + obj_raw_syments (abfd))
4273                       ->u.syment._n._n_n._n_zeroes));
4274               cache_ptr->u.sym = (asymbol *) sym;
4275               if (sym->lineno != NULL && ! warned)
4276                 {
4277                   (*_bfd_error_handler)
4278                     (_("%s: warning: duplicate line number information for `%s'"),
4279                      bfd_archive_filename (abfd),
4280                      bfd_asymbol_name (&sym->symbol));
4281                 }
4282               sym->lineno = cache_ptr;
4283             }
4284           else
4285             {
4286               cache_ptr->u.offset = dst.l_addr.l_paddr
4287                 - bfd_section_vma (abfd, asect);
4288             }                   /* If no linenumber expect a symbol index */
4289
4290           cache_ptr++;
4291           src++;
4292           counter++;
4293         }
4294       cache_ptr->line_number = 0;
4295
4296     }
4297   asect->lineno = lineno_cache;
4298   /* FIXME, free native_lineno here, or use alloca or something.  */
4299   return true;
4300 }
4301
4302 /* Slurp in the symbol table, converting it to generic form.  Note
4303    that if coff_relocate_section is defined, the linker will read
4304    symbols via coff_link_add_symbols, rather than via this routine.  */
4305
4306 static boolean
4307 coff_slurp_symbol_table (abfd)
4308      bfd * abfd;
4309 {
4310   combined_entry_type *native_symbols;
4311   coff_symbol_type *cached_area;
4312   unsigned int *table_ptr;
4313   bfd_size_type amt;
4314
4315   unsigned int number_of_symbols = 0;
4316
4317   if (obj_symbols (abfd))
4318     return true;
4319
4320   /* Read in the symbol table */
4321   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4322     {
4323       return (false);
4324     }                           /* on error */
4325
4326   /* Allocate enough room for all the symbols in cached form */
4327   amt = obj_raw_syment_count (abfd);
4328   amt *= sizeof (coff_symbol_type);
4329   cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4330   if (cached_area == NULL)
4331     return false;
4332
4333   amt = obj_raw_syment_count (abfd);
4334   amt *= sizeof (unsigned int);
4335   table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4336
4337   if (table_ptr == NULL)
4338     return false;
4339   else
4340     {
4341       coff_symbol_type *dst = cached_area;
4342       unsigned int last_native_index = obj_raw_syment_count (abfd);
4343       unsigned int this_index = 0;
4344       while (this_index < last_native_index)
4345         {
4346           combined_entry_type *src = native_symbols + this_index;
4347           table_ptr[this_index] = number_of_symbols;
4348           dst->symbol.the_bfd = abfd;
4349
4350           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4351           /* We use the native name field to point to the cached field.  */
4352           src->u.syment._n._n_n._n_zeroes = (long) dst;
4353           dst->symbol.section = coff_section_from_bfd_index (abfd,
4354                                                      src->u.syment.n_scnum);
4355           dst->symbol.flags = 0;
4356           dst->done_lineno = false;
4357
4358           switch (src->u.syment.n_sclass)
4359             {
4360 #ifdef I960
4361             case C_LEAFEXT:
4362 #if 0
4363               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4364               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4365               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4366 #endif
4367               /* Fall through to next case */
4368
4369 #endif
4370
4371             case C_EXT:
4372             case C_WEAKEXT:
4373 #if defined ARM
4374             case C_THUMBEXT:
4375             case C_THUMBEXTFUNC:
4376 #endif
4377 #ifdef RS6000COFF_C
4378             case C_HIDEXT:
4379 #endif
4380 #ifdef C_SYSTEM
4381             case C_SYSTEM:      /* System Wide variable */
4382 #endif
4383 #ifdef COFF_WITH_PE
4384             /* In PE, 0x68 (104) denotes a section symbol */
4385             case C_SECTION:
4386             /* In PE, 0x69 (105) denotes a weak external symbol.  */
4387             case C_NT_WEAK:
4388 #endif
4389               switch (coff_classify_symbol (abfd, &src->u.syment))
4390                 {
4391                 case COFF_SYMBOL_GLOBAL:
4392                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4393 #if defined COFF_WITH_PE
4394                   /* PE sets the symbol to a value relative to the
4395                      start of the section.  */
4396                   dst->symbol.value = src->u.syment.n_value;
4397 #else
4398                   dst->symbol.value = (src->u.syment.n_value
4399                                        - dst->symbol.section->vma);
4400 #endif
4401                   if (ISFCN ((src->u.syment.n_type)))
4402                     {
4403                       /* A function ext does not go at the end of a
4404                          file.  */
4405                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4406                     }
4407                   break;
4408
4409                 case COFF_SYMBOL_COMMON:
4410                   dst->symbol.section = bfd_com_section_ptr;
4411                   dst->symbol.value = src->u.syment.n_value;
4412                   break;
4413
4414                 case COFF_SYMBOL_UNDEFINED:
4415                   dst->symbol.section = bfd_und_section_ptr;
4416                   dst->symbol.value = 0;
4417                   break;
4418
4419                 case COFF_SYMBOL_PE_SECTION:
4420                   dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4421                   dst->symbol.value = 0;
4422                   break;
4423
4424                 case COFF_SYMBOL_LOCAL:
4425                   dst->symbol.flags = BSF_LOCAL;
4426 #if defined COFF_WITH_PE
4427                   /* PE sets the symbol to a value relative to the
4428                      start of the section.  */
4429                   dst->symbol.value = src->u.syment.n_value;
4430 #else
4431                   dst->symbol.value = (src->u.syment.n_value
4432                                        - dst->symbol.section->vma);
4433 #endif
4434                   if (ISFCN ((src->u.syment.n_type)))
4435                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4436                   break;
4437                 }
4438
4439 #ifdef RS6000COFF_C
4440               /* A symbol with a csect entry should not go at the end.  */
4441               if (src->u.syment.n_numaux > 0)
4442                 dst->symbol.flags |= BSF_NOT_AT_END;
4443 #endif
4444
4445 #ifdef COFF_WITH_PE
4446               if (src->u.syment.n_sclass == C_NT_WEAK)
4447                 dst->symbol.flags |= BSF_WEAK;
4448
4449               if (src->u.syment.n_sclass == C_SECTION
4450                   && src->u.syment.n_scnum > 0)
4451                 dst->symbol.flags = BSF_LOCAL;
4452 #endif
4453               if (src->u.syment.n_sclass == C_WEAKEXT)
4454                 dst->symbol.flags |= BSF_WEAK;
4455
4456               break;
4457
4458             case C_STAT:        /* static                        */
4459 #ifdef I960
4460             case C_LEAFSTAT:    /* static leaf procedure        */
4461 #endif
4462 #if defined ARM
4463             case C_THUMBSTAT:   /* Thumb static                  */
4464             case C_THUMBLABEL:  /* Thumb label                   */
4465             case C_THUMBSTATFUNC:/* Thumb static function        */
4466 #endif
4467             case C_LABEL:       /* label                         */
4468               if (src->u.syment.n_scnum == N_DEBUG)
4469                 dst->symbol.flags = BSF_DEBUGGING;
4470               else
4471                 dst->symbol.flags = BSF_LOCAL;
4472
4473               /* Base the value as an index from the base of the
4474                  section, if there is one.  */
4475               if (dst->symbol.section)
4476                 {
4477 #if defined COFF_WITH_PE
4478                   /* PE sets the symbol to a value relative to the
4479                      start of the section.  */
4480                   dst->symbol.value = src->u.syment.n_value;
4481 #else
4482                   dst->symbol.value = (src->u.syment.n_value
4483                                        - dst->symbol.section->vma);
4484 #endif
4485                 }
4486               else
4487                 dst->symbol.value = src->u.syment.n_value;
4488               break;
4489
4490             case C_MOS: /* member of structure   */
4491             case C_EOS: /* end of structure              */
4492 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
4493 #ifdef C_GLBLREG
4494             case C_GLBLREG:     /* A29k-specific storage class */
4495 #endif
4496 #endif
4497             case C_REGPARM:     /* register parameter            */
4498             case C_REG: /* register variable             */
4499               /* C_AUTOARG conflictes with TI COFF C_UEXT */
4500 #if !defined (TIC80COFF) && !defined (TICOFF)
4501 #ifdef C_AUTOARG
4502             case C_AUTOARG:     /* 960-specific storage class */
4503 #endif
4504 #endif
4505             case C_TPDEF:       /* type definition               */
4506             case C_ARG:
4507             case C_AUTO:        /* automatic variable */
4508             case C_FIELD:       /* bit field */
4509             case C_ENTAG:       /* enumeration tag               */
4510             case C_MOE: /* member of enumeration         */
4511             case C_MOU: /* member of union               */
4512             case C_UNTAG:       /* union tag                     */
4513               dst->symbol.flags = BSF_DEBUGGING;
4514               dst->symbol.value = (src->u.syment.n_value);
4515               break;
4516
4517             case C_FILE:        /* file name                     */
4518             case C_STRTAG:      /* structure tag                 */
4519 #ifdef RS6000COFF_C
4520             case C_GSYM:
4521             case C_LSYM:
4522             case C_PSYM:
4523             case C_RSYM:
4524             case C_RPSYM:
4525             case C_STSYM:
4526             case C_BCOMM:
4527             case C_ECOMM:
4528             case C_DECL:
4529             case C_ENTRY:
4530             case C_FUN:
4531             case C_ESTAT:
4532 #endif
4533               dst->symbol.flags = BSF_DEBUGGING;
4534               dst->symbol.value = (src->u.syment.n_value);
4535               break;
4536
4537 #ifdef RS6000COFF_C
4538             case C_BINCL:       /* beginning of include file     */
4539             case C_EINCL:       /* ending of include file        */
4540               /* The value is actually a pointer into the line numbers
4541                  of the file.  We locate the line number entry, and
4542                  set the section to the section which contains it, and
4543                  the value to the index in that section.  */
4544               {
4545                 asection *sec;
4546
4547                 dst->symbol.flags = BSF_DEBUGGING;
4548                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4549                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4550                       && ((file_ptr) (sec->line_filepos
4551                                       + sec->lineno_count * bfd_coff_linesz (abfd))
4552                           > (file_ptr) src->u.syment.n_value))
4553                     break;
4554                 if (sec == NULL)
4555                   dst->symbol.value = 0;
4556                 else
4557                   {
4558                     dst->symbol.section = sec;
4559                     dst->symbol.value = ((src->u.syment.n_value
4560                                           - sec->line_filepos)
4561                                          / bfd_coff_linesz (abfd));
4562                     src->fix_line = 1;
4563                   }
4564               }
4565               break;
4566
4567             case C_BSTAT:
4568               dst->symbol.flags = BSF_DEBUGGING;
4569
4570               /* The value is actually a symbol index.  Save a pointer
4571                  to the symbol instead of the index.  FIXME: This
4572                  should use a union.  */
4573               src->u.syment.n_value =
4574                 (long) (native_symbols + src->u.syment.n_value);
4575               dst->symbol.value = src->u.syment.n_value;
4576               src->fix_value = 1;
4577               break;
4578 #endif
4579
4580             case C_BLOCK:       /* ".bb" or ".eb"                */
4581             case C_FCN:         /* ".bf" or ".ef" (or PE ".lf")  */
4582             case C_EFCN:        /* physical end of function      */
4583 #if defined COFF_WITH_PE
4584               /* PE sets the symbol to a value relative to the start
4585                  of the section.  */
4586               dst->symbol.value = src->u.syment.n_value;
4587               if (strcmp (dst->symbol.name, ".bf") != 0)
4588                 {
4589                   /* PE uses funny values for .ef and .lf; don't
4590                      relocate them.  */
4591                   dst->symbol.flags = BSF_DEBUGGING;
4592                 }
4593               else
4594                 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4595 #else
4596               /* Base the value as an index from the base of the
4597                  section.  */
4598               dst->symbol.flags = BSF_LOCAL;
4599               dst->symbol.value = (src->u.syment.n_value
4600                                    - dst->symbol.section->vma);
4601 #endif
4602               break;
4603
4604             case C_STATLAB:     /* Static load time label */
4605               dst->symbol.value = src->u.syment.n_value;
4606               dst->symbol.flags = BSF_GLOBAL;
4607               break;
4608
4609             case C_NULL:
4610               /* PE DLLs sometimes have zeroed out symbols for some
4611                  reason.  Just ignore them without a warning.  */
4612               if (src->u.syment.n_type == 0
4613                   && src->u.syment.n_value == 0
4614                   && src->u.syment.n_scnum == 0)
4615                 break;
4616               /* Fall through.  */
4617             case C_EXTDEF:      /* external definition           */
4618             case C_ULABEL:      /* undefined label               */
4619             case C_USTATIC:     /* undefined static              */
4620 #ifndef COFF_WITH_PE
4621             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
4622                class to represent a section symbol */
4623             case C_LINE:        /* line # reformatted as symbol table entry */
4624               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
4625             case C_ALIAS:       /* duplicate tag                 */
4626 #endif
4627               /* New storage classes for TI COFF */
4628 #if defined(TIC80COFF) || defined(TICOFF)
4629             case C_UEXT:        /* Tentative external definition */
4630 #endif
4631             case C_EXTLAB:      /* External load time label */
4632             case C_HIDDEN:      /* ext symbol in dmert public lib */
4633             default:
4634               (*_bfd_error_handler)
4635                 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4636                  bfd_archive_filename (abfd), src->u.syment.n_sclass,
4637                  dst->symbol.section->name, dst->symbol.name);
4638               dst->symbol.flags = BSF_DEBUGGING;
4639               dst->symbol.value = (src->u.syment.n_value);
4640               break;
4641             }
4642
4643 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
4644
4645           dst->native = src;
4646
4647           dst->symbol.udata.i = 0;
4648           dst->lineno = (alent *) NULL;
4649           this_index += (src->u.syment.n_numaux) + 1;
4650           dst++;
4651           number_of_symbols++;
4652         }                       /* walk the native symtab */
4653     }                           /* bfdize the native symtab */
4654
4655   obj_symbols (abfd) = cached_area;
4656   obj_raw_syments (abfd) = native_symbols;
4657
4658   bfd_get_symcount (abfd) = number_of_symbols;
4659   obj_convert (abfd) = table_ptr;
4660   /* Slurp the line tables for each section too */
4661   {
4662     asection *p;
4663     p = abfd->sections;
4664     while (p)
4665       {
4666         coff_slurp_line_table (abfd, p);
4667         p = p->next;
4668       }
4669   }
4670   return true;
4671 }                               /* coff_slurp_symbol_table() */
4672
4673 /* Classify a COFF symbol.  A couple of targets have globally visible
4674    symbols which are not class C_EXT, and this handles those.  It also
4675    recognizes some special PE cases.  */
4676
4677 static enum coff_symbol_classification
4678 coff_classify_symbol (abfd, syment)
4679      bfd *abfd;
4680      struct internal_syment *syment;
4681 {
4682   /* FIXME: This partially duplicates the switch in
4683      coff_slurp_symbol_table.  */
4684   switch (syment->n_sclass)
4685     {
4686     case C_EXT:
4687     case C_WEAKEXT:
4688 #ifdef I960
4689     case C_LEAFEXT:
4690 #endif
4691 #ifdef ARM
4692     case C_THUMBEXT:
4693     case C_THUMBEXTFUNC:
4694 #endif
4695 #ifdef C_SYSTEM
4696     case C_SYSTEM:
4697 #endif
4698 #ifdef COFF_WITH_PE
4699     case C_NT_WEAK:
4700 #endif
4701       if (syment->n_scnum == 0)
4702         {
4703           if (syment->n_value == 0)
4704             return COFF_SYMBOL_UNDEFINED;
4705           else
4706             return COFF_SYMBOL_COMMON;
4707         }
4708       return COFF_SYMBOL_GLOBAL;
4709
4710     default:
4711       break;
4712     }
4713
4714 #ifdef COFF_WITH_PE
4715   if (syment->n_sclass == C_STAT)
4716     {
4717       if (syment->n_scnum == 0)
4718         {
4719           /* The Microsoft compiler sometimes generates these if a
4720              small static function is inlined every time it is used.
4721              The function is discarded, but the symbol table entry
4722              remains.  */
4723           return COFF_SYMBOL_LOCAL;
4724         }
4725
4726 #ifdef STRICT_PE_FORMAT
4727       /* This is correct for Microsoft generated objects, but it
4728          breaks gas generated objects.  */
4729
4730       if (syment->n_value == 0)
4731         {
4732           asection *sec;
4733           char buf[SYMNMLEN + 1];
4734
4735           sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4736           if (sec != NULL
4737               && (strcmp (bfd_get_section_name (abfd, sec),
4738                           _bfd_coff_internal_syment_name (abfd, syment, buf))
4739                   == 0))
4740             return COFF_SYMBOL_PE_SECTION;
4741         }
4742 #endif
4743
4744       return COFF_SYMBOL_LOCAL;
4745     }
4746
4747   if (syment->n_sclass == C_SECTION)
4748     {
4749       /* In some cases in a DLL generated by the Microsoft linker, the
4750          n_value field will contain garbage.  FIXME: This should
4751          probably be handled by the swapping function instead.  */
4752       syment->n_value = 0;
4753       if (syment->n_scnum == 0)
4754         return COFF_SYMBOL_UNDEFINED;
4755       return COFF_SYMBOL_PE_SECTION;
4756     }
4757 #endif /* COFF_WITH_PE */
4758
4759   /* If it is not a global symbol, we presume it is a local symbol.  */
4760
4761   if (syment->n_scnum == 0)
4762     {
4763       char buf[SYMNMLEN + 1];
4764
4765       (*_bfd_error_handler)
4766         (_("warning: %s: local symbol `%s' has no section"),
4767          bfd_archive_filename (abfd),
4768          _bfd_coff_internal_syment_name (abfd, syment, buf));
4769     }
4770
4771   return COFF_SYMBOL_LOCAL;
4772 }
4773
4774 /*
4775 SUBSUBSECTION
4776         Reading relocations
4777
4778         Coff relocations are easily transformed into the internal BFD form
4779         (@code{arelent}).
4780
4781         Reading a coff relocation table is done in the following stages:
4782
4783         o Read the entire coff relocation table into memory.
4784
4785         o Process each relocation in turn; first swap it from the
4786         external to the internal form.
4787
4788         o Turn the symbol referenced in the relocation's symbol index
4789         into a pointer into the canonical symbol table.
4790         This table is the same as the one returned by a call to
4791         @code{bfd_canonicalize_symtab}. The back end will call that
4792         routine and save the result if a canonicalization hasn't been done.
4793
4794         o The reloc index is turned into a pointer to a howto
4795         structure, in a back end specific way. For instance, the 386
4796         and 960 use the @code{r_type} to directly produce an index
4797         into a howto table vector; the 88k subtracts a number from the
4798         @code{r_type} field and creates an addend field.
4799
4800 */
4801
4802 #ifndef CALC_ADDEND
4803 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
4804   {                                                             \
4805     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
4806     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
4807       coffsym = (obj_symbols (abfd)                             \
4808                  + (cache_ptr->sym_ptr_ptr - symbols));         \
4809     else if (ptr)                                               \
4810       coffsym = coff_symbol_from (abfd, ptr);                   \
4811     if (coffsym != (coff_symbol_type *) NULL                    \
4812         && coffsym->native->u.syment.n_scnum == 0)              \
4813       cache_ptr->addend = 0;                                    \
4814     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
4815              && ptr->section != (asection *) NULL)              \
4816       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
4817     else                                                        \
4818       cache_ptr->addend = 0;                                    \
4819   }
4820 #endif
4821
4822 static boolean
4823 coff_slurp_reloc_table (abfd, asect, symbols)
4824      bfd * abfd;
4825      sec_ptr asect;
4826      asymbol ** symbols;
4827 {
4828   RELOC *native_relocs;
4829   arelent *reloc_cache;
4830   arelent *cache_ptr;
4831   unsigned int idx;
4832   bfd_size_type amt;
4833
4834   if (asect->relocation)
4835     return true;
4836   if (asect->reloc_count == 0)
4837     return true;
4838   if (asect->flags & SEC_CONSTRUCTOR)
4839     return true;
4840   if (!coff_slurp_symbol_table (abfd))
4841     return false;
4842   amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
4843   native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
4844   amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
4845   reloc_cache = (arelent *) bfd_alloc (abfd, amt);
4846
4847   if (reloc_cache == NULL)
4848     return false;
4849
4850   for (idx = 0; idx < asect->reloc_count; idx++)
4851     {
4852       struct internal_reloc dst;
4853       struct external_reloc *src;
4854 #ifndef RELOC_PROCESSING
4855       asymbol *ptr;
4856 #endif
4857
4858       cache_ptr = reloc_cache + idx;
4859       src = native_relocs + idx;
4860
4861       coff_swap_reloc_in (abfd, src, &dst);
4862
4863 #ifdef RELOC_PROCESSING
4864       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4865 #else
4866       cache_ptr->address = dst.r_vaddr;
4867
4868       if (dst.r_symndx != -1)
4869         {
4870           if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4871             {
4872               (*_bfd_error_handler)
4873                 (_("%s: warning: illegal symbol index %ld in relocs"),
4874                  bfd_archive_filename (abfd), dst.r_symndx);
4875               cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4876               ptr = NULL;
4877             }
4878           else
4879             {
4880               cache_ptr->sym_ptr_ptr = (symbols
4881                                         + obj_convert (abfd)[dst.r_symndx]);
4882               ptr = *(cache_ptr->sym_ptr_ptr);
4883             }
4884         }
4885       else
4886         {
4887           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4888           ptr = NULL;
4889         }
4890
4891       /* The symbols definitions that we have read in have been
4892          relocated as if their sections started at 0. But the offsets
4893          refering to the symbols in the raw data have not been
4894          modified, so we have to have a negative addend to compensate.
4895
4896          Note that symbols which used to be common must be left alone */
4897
4898       /* Calculate any reloc addend by looking at the symbol */
4899       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4900
4901       cache_ptr->address -= asect->vma;
4902 /* !!     cache_ptr->section = (asection *) NULL;*/
4903
4904       /* Fill in the cache_ptr->howto field from dst.r_type */
4905       RTYPE2HOWTO (cache_ptr, &dst);
4906 #endif  /* RELOC_PROCESSING */
4907
4908       if (cache_ptr->howto == NULL)
4909         {
4910           (*_bfd_error_handler)
4911             (_("%s: illegal relocation type %d at address 0x%lx"),
4912              bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4913           bfd_set_error (bfd_error_bad_value);
4914           return false;
4915         }
4916     }
4917
4918   asect->relocation = reloc_cache;
4919   return true;
4920 }
4921
4922 #ifndef coff_rtype_to_howto
4923 #ifdef RTYPE2HOWTO
4924
4925 /* Get the howto structure for a reloc.  This is only used if the file
4926    including this one defines coff_relocate_section to be
4927    _bfd_coff_generic_relocate_section, so it is OK if it does not
4928    always work.  It is the responsibility of the including file to
4929    make sure it is reasonable if it is needed.  */
4930
4931 static reloc_howto_type *coff_rtype_to_howto
4932   PARAMS ((bfd *, asection *, struct internal_reloc *,
4933            struct coff_link_hash_entry *, struct internal_syment *,
4934            bfd_vma *));
4935
4936 /*ARGSUSED*/
4937 static reloc_howto_type *
4938 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
4939      bfd *abfd ATTRIBUTE_UNUSED;
4940      asection *sec ATTRIBUTE_UNUSED;
4941      struct internal_reloc *rel;
4942      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4943      struct internal_syment *sym ATTRIBUTE_UNUSED;
4944      bfd_vma *addendp ATTRIBUTE_UNUSED;
4945 {
4946   arelent genrel;
4947
4948   RTYPE2HOWTO (&genrel, rel);
4949   return genrel.howto;
4950 }
4951
4952 #else /* ! defined (RTYPE2HOWTO) */
4953
4954 #define coff_rtype_to_howto NULL
4955
4956 #endif /* ! defined (RTYPE2HOWTO) */
4957 #endif /* ! defined (coff_rtype_to_howto) */
4958
4959 /* This is stupid.  This function should be a boolean predicate.  */
4960 static long
4961 coff_canonicalize_reloc (abfd, section, relptr, symbols)
4962      bfd * abfd;
4963      sec_ptr section;
4964      arelent ** relptr;
4965      asymbol ** symbols;
4966 {
4967   arelent *tblptr = section->relocation;
4968   unsigned int count = 0;
4969
4970   if (section->flags & SEC_CONSTRUCTOR)
4971     {
4972       /* this section has relocs made up by us, they are not in the
4973        file, so take them out of their chain and place them into
4974        the data area provided */
4975       arelent_chain *chain = section->constructor_chain;
4976       for (count = 0; count < section->reloc_count; count++)
4977         {
4978           *relptr++ = &chain->relent;
4979           chain = chain->next;
4980         }
4981
4982     }
4983   else
4984     {
4985       if (! coff_slurp_reloc_table (abfd, section, symbols))
4986         return -1;
4987
4988       tblptr = section->relocation;
4989
4990       for (; count++ < section->reloc_count;)
4991         *relptr++ = tblptr++;
4992     }
4993   *relptr = 0;
4994   return section->reloc_count;
4995 }
4996
4997 #ifdef GNU960
4998 file_ptr
4999 coff_sym_filepos (abfd)
5000      bfd *abfd;
5001 {
5002   return obj_sym_filepos (abfd);
5003 }
5004 #endif
5005
5006 #ifndef coff_reloc16_estimate
5007 #define coff_reloc16_estimate dummy_reloc16_estimate
5008
5009 static int dummy_reloc16_estimate
5010   PARAMS ((bfd *, asection *, arelent *, unsigned int,
5011            struct bfd_link_info *));
5012
5013 static int
5014 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5015      bfd *abfd ATTRIBUTE_UNUSED;
5016      asection *input_section ATTRIBUTE_UNUSED;
5017      arelent *reloc ATTRIBUTE_UNUSED;
5018      unsigned int shrink ATTRIBUTE_UNUSED;
5019      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5020 {
5021   abort ();
5022   return 0;
5023 }
5024
5025 #endif
5026
5027 #ifndef coff_reloc16_extra_cases
5028
5029 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5030
5031 /* This works even if abort is not declared in any header file.  */
5032
5033 static void dummy_reloc16_extra_cases
5034   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
5035            bfd_byte *, unsigned int *, unsigned int *));
5036
5037 static void
5038 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5039                            dst_ptr)
5040      bfd *abfd ATTRIBUTE_UNUSED;
5041      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5042      struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
5043      arelent *reloc ATTRIBUTE_UNUSED;
5044      bfd_byte *data ATTRIBUTE_UNUSED;
5045      unsigned int *src_ptr ATTRIBUTE_UNUSED;
5046      unsigned int *dst_ptr ATTRIBUTE_UNUSED;
5047 {
5048   abort ();
5049 }
5050 #endif
5051
5052 /* If coff_relocate_section is defined, we can use the optimized COFF
5053    backend linker.  Otherwise we must continue to use the old linker.  */
5054 #ifdef coff_relocate_section
5055 #ifndef coff_bfd_link_hash_table_create
5056 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5057 #endif
5058 #ifndef coff_bfd_link_add_symbols
5059 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5060 #endif
5061 #ifndef coff_bfd_final_link
5062 #define coff_bfd_final_link _bfd_coff_final_link
5063 #endif
5064 #else /* ! defined (coff_relocate_section) */
5065 #define coff_relocate_section NULL
5066 #ifndef coff_bfd_link_hash_table_create
5067 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5068 #endif
5069 #ifndef coff_bfd_link_add_symbols
5070 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5071 #endif
5072 #define coff_bfd_final_link _bfd_generic_final_link
5073 #endif /* ! defined (coff_relocate_section) */
5074
5075 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
5076
5077 #ifndef coff_start_final_link
5078 #define coff_start_final_link NULL
5079 #endif
5080
5081 #ifndef coff_adjust_symndx
5082 #define coff_adjust_symndx NULL
5083 #endif
5084
5085 #ifndef coff_link_add_one_symbol
5086 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5087 #endif
5088
5089 #ifndef coff_link_output_has_begun
5090
5091 static boolean coff_link_output_has_begun
5092   PARAMS ((bfd *, struct coff_final_link_info *));
5093
5094 static boolean
5095 coff_link_output_has_begun (abfd, info)
5096      bfd * abfd;
5097      struct coff_final_link_info * info ATTRIBUTE_UNUSED;
5098 {
5099   return abfd->output_has_begun;
5100 }
5101 #endif
5102
5103 #ifndef coff_final_link_postscript
5104
5105 static boolean coff_final_link_postscript
5106   PARAMS ((bfd *, struct coff_final_link_info *));
5107
5108 static boolean
5109 coff_final_link_postscript (abfd, pfinfo)
5110      bfd * abfd ATTRIBUTE_UNUSED;
5111      struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
5112 {
5113   return true;
5114 }
5115 #endif
5116
5117 #ifndef coff_SWAP_aux_in
5118 #define coff_SWAP_aux_in coff_swap_aux_in
5119 #endif
5120 #ifndef coff_SWAP_sym_in
5121 #define coff_SWAP_sym_in coff_swap_sym_in
5122 #endif
5123 #ifndef coff_SWAP_lineno_in
5124 #define coff_SWAP_lineno_in coff_swap_lineno_in
5125 #endif
5126 #ifndef coff_SWAP_aux_out
5127 #define coff_SWAP_aux_out coff_swap_aux_out
5128 #endif
5129 #ifndef coff_SWAP_sym_out
5130 #define coff_SWAP_sym_out coff_swap_sym_out
5131 #endif
5132 #ifndef coff_SWAP_lineno_out
5133 #define coff_SWAP_lineno_out coff_swap_lineno_out
5134 #endif
5135 #ifndef coff_SWAP_reloc_out
5136 #define coff_SWAP_reloc_out coff_swap_reloc_out
5137 #endif
5138 #ifndef coff_SWAP_filehdr_out
5139 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5140 #endif
5141 #ifndef coff_SWAP_aouthdr_out
5142 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5143 #endif
5144 #ifndef coff_SWAP_scnhdr_out
5145 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5146 #endif
5147 #ifndef coff_SWAP_reloc_in
5148 #define coff_SWAP_reloc_in coff_swap_reloc_in
5149 #endif
5150 #ifndef coff_SWAP_filehdr_in
5151 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5152 #endif
5153 #ifndef coff_SWAP_aouthdr_in
5154 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5155 #endif
5156 #ifndef coff_SWAP_scnhdr_in
5157 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5158 #endif
5159
5160 static const bfd_coff_backend_data bfd_coff_std_swap_table =
5161 {
5162   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5163   coff_SWAP_aux_out, coff_SWAP_sym_out,
5164   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5165   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5166   coff_SWAP_scnhdr_out,
5167   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5168 #ifdef COFF_LONG_FILENAMES
5169   true,
5170 #else
5171   false,
5172 #endif
5173 #ifdef COFF_LONG_SECTION_NAMES
5174   true,
5175 #else
5176   false,
5177 #endif
5178   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5179 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5180   true,
5181 #else
5182   false,
5183 #endif
5184 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5185   4,
5186 #else
5187   2,
5188 #endif
5189   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5190   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5191   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5192   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5193   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5194   coff_classify_symbol, coff_compute_section_file_positions,
5195   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5196   coff_adjust_symndx, coff_link_add_one_symbol,
5197   coff_link_output_has_begun, coff_final_link_postscript
5198 };
5199
5200 #ifndef coff_close_and_cleanup
5201 #define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
5202 #endif
5203
5204 #ifndef coff_bfd_free_cached_info
5205 #define coff_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
5206 #endif
5207
5208 #ifndef coff_get_section_contents
5209 #define coff_get_section_contents           _bfd_generic_get_section_contents
5210 #endif
5211
5212 #ifndef coff_bfd_copy_private_symbol_data
5213 #define coff_bfd_copy_private_symbol_data   _bfd_generic_bfd_copy_private_symbol_data
5214 #endif
5215
5216 #ifndef coff_bfd_copy_private_section_data
5217 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
5218 #endif
5219
5220 #ifndef coff_bfd_copy_private_bfd_data
5221 #define coff_bfd_copy_private_bfd_data      _bfd_generic_bfd_copy_private_bfd_data
5222 #endif
5223
5224 #ifndef coff_bfd_merge_private_bfd_data
5225 #define coff_bfd_merge_private_bfd_data     _bfd_generic_bfd_merge_private_bfd_data
5226 #endif
5227
5228 #ifndef coff_bfd_set_private_flags
5229 #define coff_bfd_set_private_flags          _bfd_generic_bfd_set_private_flags
5230 #endif
5231
5232 #ifndef coff_bfd_print_private_bfd_data
5233 #define coff_bfd_print_private_bfd_data     _bfd_generic_bfd_print_private_bfd_data
5234 #endif
5235
5236 #ifndef coff_bfd_is_local_label_name
5237 #define coff_bfd_is_local_label_name        _bfd_coff_is_local_label_name
5238 #endif
5239
5240 #ifndef coff_read_minisymbols
5241 #define coff_read_minisymbols               _bfd_generic_read_minisymbols
5242 #endif
5243
5244 #ifndef coff_minisymbol_to_symbol
5245 #define coff_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
5246 #endif
5247
5248 /* The reloc lookup routine must be supplied by each individual COFF
5249    backend.  */
5250 #ifndef coff_bfd_reloc_type_lookup
5251 #define coff_bfd_reloc_type_lookup          _bfd_norelocs_bfd_reloc_type_lookup
5252 #endif
5253
5254 #ifndef coff_bfd_get_relocated_section_contents
5255 #define coff_bfd_get_relocated_section_contents \
5256   bfd_generic_get_relocated_section_contents
5257 #endif
5258
5259 #ifndef coff_bfd_relax_section
5260 #define coff_bfd_relax_section              bfd_generic_relax_section
5261 #endif
5262
5263 #ifndef coff_bfd_gc_sections
5264 #define coff_bfd_gc_sections                bfd_generic_gc_sections
5265 #endif
5266
5267 #ifndef coff_bfd_merge_sections
5268 #define coff_bfd_merge_sections             bfd_generic_merge_sections
5269 #endif
5270
5271 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5272 const bfd_target VAR =                                                  \
5273 {                                                                       \
5274   NAME ,                                                                \
5275   bfd_target_coff_flavour,                                              \
5276   BFD_ENDIAN_BIG,               /* data byte order is big */            \
5277   BFD_ENDIAN_BIG,               /* header byte order is big */          \
5278   /* object flags */                                                    \
5279   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5280    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5281   /* section flags */                                                   \
5282   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5283   UNDER,                        /* leading symbol underscore */         \
5284   '/',                          /* ar_pad_char */                       \
5285   15,                           /* ar_max_namelen */                    \
5286                                                                         \
5287   /* Data conversion functions.  */                                     \
5288   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5289   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5290   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5291                                                                         \
5292   /* Header conversion functions.  */                                   \
5293   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5294   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5295   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5296                                                                         \
5297         /* bfd_check_format */                                          \
5298   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5299     _bfd_dummy_target },                                                \
5300         /* bfd_set_format */                                            \
5301   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5302         /* bfd_write_contents */                                        \
5303   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5304     bfd_false },                                                        \
5305                                                                         \
5306   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5307   BFD_JUMP_TABLE_COPY (coff),                                           \
5308   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5309   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5310   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5311   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5312   BFD_JUMP_TABLE_WRITE (coff),                                          \
5313   BFD_JUMP_TABLE_LINK (coff),                                           \
5314   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5315                                                                         \
5316   ALTERNATIVE,                                                          \
5317                                                                         \
5318   COFF_SWAP_TABLE                                                       \
5319 };
5320
5321 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE)      \
5322 const bfd_target VAR =                                                  \
5323 {                                                                       \
5324   NAME ,                                                                \
5325   bfd_target_coff_flavour,                                              \
5326   BFD_ENDIAN_LITTLE,            /* data byte order is little */         \
5327   BFD_ENDIAN_LITTLE,            /* header byte order is little */       \
5328         /* object flags */                                              \
5329   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5330    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5331         /* section flags */                                             \
5332   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5333   UNDER,                        /* leading symbol underscore */         \
5334   '/',                          /* ar_pad_char */                       \
5335   15,                           /* ar_max_namelen */                    \
5336                                                                         \
5337   /* Data conversion functions.  */                                     \
5338   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5339   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5340   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5341   /* Header conversion functions.  */                                   \
5342   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5343   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5344   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5345         /* bfd_check_format */                                          \
5346   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5347     _bfd_dummy_target },                                                \
5348        /* bfd_set_format */                                             \
5349   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5350         /* bfd_write_contents */                                        \
5351   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5352     bfd_false },                                                        \
5353                                                                         \
5354   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5355   BFD_JUMP_TABLE_COPY (coff),                                           \
5356   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5357   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5358   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5359   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5360   BFD_JUMP_TABLE_WRITE (coff),                                          \
5361   BFD_JUMP_TABLE_LINK (coff),                                           \
5362   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5363                                                                         \
5364   ALTERNATIVE,                                                          \
5365                                                                         \
5366   COFF_SWAP_TABLE                                                       \
5367 };