bfd/coffcode.h

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