bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
   3    Free Software Foundation, Inc.
   4    Written by Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23 Most of this hacked by  Steve Chamberlain,
  24                         [email protected]
  25 */
  26 /*
  27
  28 SECTION
  29         coff backends
  30
  31         BFD supports a number of different flavours of coff format.
  32         The major differences between formats are the sizes and
  33         alignments of fields in structures on disk, and the occasional
  34         extra field.
  35
  36         Coff in all its varieties is implemented with a few common
  37         files and a number of implementation specific files. For
  38         example, The 88k bcs coff format is implemented in the file
  39         @file{coff-m88k.c}. This file @code{#include}s
  40         @file{coff/m88k.h} which defines the external structure of the
  41         coff format for the 88k, and @file{coff/internal.h} which
  42         defines the internal structure. @file{coff-m88k.c} also
  43         defines the relocations used by the 88k format
  44         @xref{Relocations}.
  45
  46         The Intel i960 processor version of coff is implemented in
  47         @file{coff-i960.c}. This file has the same structure as
  48         @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
  49         rather than @file{coff-m88k.h}.
  50
  51 SUBSECTION
  52         Porting to a new version of coff
  53
  54         The recommended method is to select from the existing
  55         implementations the version of coff which is most like the one
  56         you want to use.  For example, we'll say that i386 coff is
  57         the one you select, and that your coff flavour is called foo.
  58         Copy @file{i386coff.c} to @file{foocoff.c}, copy
  59         @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
  60         and add the lines to @file{targets.c} and @file{Makefile.in}
  61         so that your new back end is used. Alter the shapes of the
  62         structures in @file{../include/coff/foo.h} so that they match
  63         what you need. You will probably also have to add
  64         @code{#ifdef}s to the code in @file{coff/internal.h} and
  65         @file{coffcode.h} if your version of coff is too wild.
  66
  67         You can verify that your new BFD backend works quite simply by
  68         building @file{objdump} from the @file{binutils} directory,
  69         and making sure that its version of what's going on and your
  70         host system's idea (assuming it has the pretty standard coff
  71         dump utility, usually called @code{att-dump} or just
  72         @code{dump}) are the same.  Then clean up your code, and send
  73         what you've done to Cygnus. Then your stuff will be in the
  74         next release, and you won't have to keep integrating it.
  75
  76 SUBSECTION
  77         How the coff backend works
  78
  79 SUBSUBSECTION
  80         File layout
  81
  82         The Coff backend is split into generic routines that are
  83         applicable to any Coff target and routines that are specific
  84         to a particular target.  The target-specific routines are
  85         further split into ones which are basically the same for all
  86         Coff targets except that they use the external symbol format
  87         or use different values for certain constants.
  88
  89         The generic routines are in @file{coffgen.c}.  These routines
  90         work for any Coff target.  They use some hooks into the target
  91         specific code; the hooks are in a @code{bfd_coff_backend_data}
  92         structure, one of which exists for each target.
  93
  94         The essentially similar target-specific routines are in
  95         @file{coffcode.h}.  This header file includes executable C code.
  96         The various Coff targets first include the appropriate Coff
  97         header file, make any special defines that are needed, and
  98         then include @file{coffcode.h}.
  99
 100         Some of the Coff targets then also have additional routines in
 101         the target source file itself.
 102
 103         For example, @file{coff-i960.c} includes
 104         @file{coff/internal.h} and @file{coff/i960.h}.  It then
 105         defines a few constants, such as @code{I960}, and includes
 106         @file{coffcode.h}.  Since the i960 has complex relocation
 107         types, @file{coff-i960.c} also includes some code to
 108         manipulate the i960 relocs.  This code is not in
 109         @file{coffcode.h} because it would not be used by any other
 110         target.
 111
 112 SUBSUBSECTION
 113         Bit twiddling
 114
 115         Each flavour of coff supported in BFD has its own header file
 116         describing the external layout of the structures. There is also
 117         an internal description of the coff layout, in
 118         @file{coff/internal.h}. A major function of the
 119         coff backend is swapping the bytes and twiddling the bits to
 120         translate the external form of the structures into the normal
 121         internal form. This is all performed in the
 122         @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
 123         elements are different sizes between different versions of
 124         coff; it is the duty of the coff version specific include file
 125         to override the definitions of various packing routines in
 126         @file{coffcode.h}. E.g., the size of line number entry in coff is
 127         sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
 128         @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
 129         correct one. No doubt, some day someone will find a version of
 130         coff which has a varying field size not catered to at the
 131         moment. To port BFD, that person will have to add more @code{#defines}.
 132         Three of the bit twiddling routines are exported to
 133         @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
 134         and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
 135         table on its own, but uses BFD to fix things up.  More of the
 136         bit twiddlers are exported for @code{gas};
 137         @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
 138         @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
 139         @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
 140         @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
 141         of all the symbol table and reloc drudgery itself, thereby
 142         saving the internal BFD overhead, but uses BFD to swap things
 143         on the way out, making cross ports much safer.  Doing so also
 144         allows BFD (and thus the linker) to use the same header files
 145         as @code{gas}, which makes one avenue to disaster disappear.
 146
 147 SUBSUBSECTION
 148         Symbol reading
 149
 150         The simple canonical form for symbols used by BFD is not rich
 151         enough to keep all the information available in a coff symbol
 152         table. The back end gets around this problem by keeping the original
 153         symbol table around, "behind the scenes".
 154
 155         When a symbol table is requested (through a call to
 156         @code{bfd_canonicalize_symtab}), a request gets through to
 157         @code{coff_get_normalized_symtab}. This reads the symbol table from
 158         the coff file and swaps all the structures inside into the
 159         internal form. It also fixes up all the pointers in the table
 160         (represented in the file by offsets from the first symbol in
 161         the table) into physical pointers to elements in the new
 162         internal table. This involves some work since the meanings of
 163         fields change depending upon context: a field that is a
 164         pointer to another structure in the symbol table at one moment
 165         may be the size in bytes of a structure at the next.  Another
 166         pass is made over the table. All symbols which mark file names
 167         (<<C_FILE>> symbols) are modified so that the internal
 168         string points to the value in the auxent (the real filename)
 169         rather than the normal text associated with the symbol
 170         (@code{".file"}).
 171
 172         At this time the symbol names are moved around. Coff stores
 173         all symbols less than nine characters long physically
 174         within the symbol table; longer strings are kept at the end of
 175         the file in the string  table. This pass moves all strings
 176         into memory and replaces them with pointers to the strings.
 177
 178
 179         The symbol table is massaged once again, this time to create
 180         the canonical table used by the BFD application. Each symbol
 181         is inspected in turn, and a decision made (using the
 182         @code{sclass} field) about the various flags to set in the
 183         @code{asymbol}.  @xref{Symbols}. The generated canonical table
 184         shares strings with the hidden internal symbol table.
 185
 186         Any linenumbers are read from the coff file too, and attached
 187         to the symbols which own the functions the linenumbers belong to.
 188
 189 SUBSUBSECTION
 190         Symbol writing
 191
 192         Writing a symbol to a coff file which didn't come from a coff
 193         file will lose any debugging information. The @code{asymbol}
 194         structure remembers the BFD from which the symbol was taken, and on
 195         output the back end makes sure that the same destination target as
 196         source target is present.
 197
 198         When the symbols have come from a coff file then all the
 199         debugging information is preserved.
 200
 201         Symbol tables are provided for writing to the back end in a
 202         vector of pointers to pointers. This allows applications like
 203         the linker to accumulate and output large symbol tables
 204         without having to do too much byte copying.
 205
 206         This function runs through the provided symbol table and
 207         patches each symbol marked as a file place holder
 208         (@code{C_FILE}) to point to the next file place holder in the
 209         list. It also marks each @code{offset} field in the list with
 210         the offset from the first symbol of the current symbol.
 211
 212         Another function of this procedure is to turn the canonical
 213         value form of BFD into the form used by coff. Internally, BFD
 214         expects symbol values to be offsets from a section base; so a
 215         symbol physically at 0x120, but in a section starting at
 216         0x100, would have the value 0x20. Coff expects symbols to
 217         contain their final value, so symbols have their values
 218         changed at this point to reflect their sum with their owning
 219         section.  This transformation uses the
 220         <<output_section>> field of the @code{asymbol}'s
 221         @code{asection} @xref{Sections}.
 222
 223         o <<coff_mangle_symbols>>
 224
 225         This routine runs though the provided symbol table and uses
 226         the offsets generated by the previous pass and the pointers
 227         generated when the symbol table was read in to create the
 228         structured hierachy required by coff. It changes each pointer
 229         to a symbol into the index into the symbol table of the asymbol.
 230
 231         o <<coff_write_symbols>>
 232
 233         This routine runs through the symbol table and patches up the
 234         symbols from their internal form into the coff way, calls the
 235         bit twiddlers, and writes out the table to the file.
 236
 237 */
 238
 239 /*
 240 INTERNAL_DEFINITION
 241         coff_symbol_type
 242
 243 DESCRIPTION
 244         The hidden information for an <<asymbol>> is described in a
 245         <<combined_entry_type>>:
 246
 247 CODE_FRAGMENT
 248 .
 249 .typedef struct coff_ptr_struct
 250 .{
 251 .
 252 .       {* Remembers the offset from the first symbol in the file for
 253 .          this symbol. Generated by coff_renumber_symbols. *}
 254 .unsigned int offset;
 255 .
 256 .       {* Should the value of this symbol be renumbered.  Used for
 257 .          XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
 258 .unsigned int fix_value : 1;
 259 .
 260 .       {* Should the tag field of this symbol be renumbered.
 261 .          Created by coff_pointerize_aux. *}
 262 .unsigned int fix_tag : 1;
 263 .
 264 .       {* Should the endidx field of this symbol be renumbered.
 265 .          Created by coff_pointerize_aux. *}
 266 .unsigned int fix_end : 1;
 267 .
 268 .       {* Should the x_csect.x_scnlen field be renumbered.
 269 .          Created by coff_pointerize_aux. *}
 270 .unsigned int fix_scnlen : 1;
 271 .
 272 .       {* Fix up an XCOFF C_BINCL/C_EINCL symbol.  The value is the
 273 .          index into the line number entries.  Set by
 274 .          coff_slurp_symbol_table.  *}
 275 .unsigned int fix_line : 1;
 276 .
 277 .       {* The container for the symbol structure as read and translated
 278 .           from the file. *}
 279 .
 280 .union {
 281 .   union internal_auxent auxent;
 282 .   struct internal_syment syment;
 283 . } u;
 284 .} combined_entry_type;
 285 .
 286 .
 287 .{* Each canonical asymbol really looks like this: *}
 288 .
 289 .typedef struct coff_symbol_struct
 290 .{
 291 .   {* The actual symbol which the rest of BFD works with *}
 292 .asymbol symbol;
 293 .
 294 .   {* A pointer to the hidden information for this symbol *}
 295 .combined_entry_type *native;
 296 .
 297 .   {* A pointer to the linenumber information for this symbol *}
 298 .struct lineno_cache_entry *lineno;
 299 .
 300 .   {* Have the line numbers been relocated yet ? *}
 301 .boolean done_lineno;
 302 .} coff_symbol_type;
 303
 304
 305 */
 306
 307 #ifdef COFF_WITH_PE
 308 #include "peicode.h"
 309 #else
 310 #include "coffswap.h"
 311 #endif
 312
 313 #define STRING_SIZE_SIZE (4)
 314
 315 static long sec_to_styp_flags PARAMS ((const char *, flagword));
 316 static flagword styp_to_sec_flags PARAMS ((bfd *, PTR, const char *));
 317 static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
 318 static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
 319 static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
 320 static boolean coff_write_relocs PARAMS ((bfd *, int));
 321 static boolean coff_set_flags
 322   PARAMS ((bfd *, unsigned int *, unsigned short *));
 323 static boolean coff_set_arch_mach
 324   PARAMS ((bfd *, enum bfd_architecture, unsigned long));
 325 static boolean coff_compute_section_file_positions PARAMS ((bfd *));
 326 static boolean coff_write_object_contents PARAMS ((bfd *));
 327 static boolean coff_set_section_contents
 328   PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
 329 static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t));
 330 static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
 331 static boolean coff_slurp_symbol_table PARAMS ((bfd *));
 332 static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
 333 static long coff_canonicalize_reloc
 334   PARAMS ((bfd *, asection *, arelent **, asymbol **));
 335 #ifndef coff_mkobject_hook
 336 static PTR coff_mkobject_hook PARAMS ((bfd *, PTR,  PTR));
 337 #endif
 338 \f
 339 /* void warning(); */
 340
 341 /*
 342  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 343  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 344  * NOTE: If you add to/change this routine, you should mirror the changes
 345  *      in styp_to_sec_flags().
 346  */
 347 static long
 348 sec_to_styp_flags (sec_name, sec_flags)
 349      CONST char *sec_name;
 350      flagword sec_flags;
 351 {
 352   long styp_flags = 0;
 353
 354   if (!strcmp (sec_name, _TEXT))
 355     {
 356       styp_flags = STYP_TEXT;
 357     }
 358   else if (!strcmp (sec_name, _DATA))
 359     {
 360       styp_flags = STYP_DATA;
 361     }
 362   else if (!strcmp (sec_name, _BSS))
 363     {
 364       styp_flags = STYP_BSS;
 365 #ifdef _COMMENT
 366     }
 367   else if (!strcmp (sec_name, _COMMENT))
 368     {
 369       styp_flags = STYP_INFO;
 370 #endif /* _COMMENT */
 371 #ifdef _LIB
 372     }
 373   else if (!strcmp (sec_name, _LIB))
 374     {
 375       styp_flags = STYP_LIB;
 376 #endif /* _LIB */
 377 #ifdef _LIT
 378     }
 379   else if (!strcmp (sec_name, _LIT))
 380     {
 381       styp_flags = STYP_LIT;
 382 #endif /* _LIT */
 383     }
 384   else if (!strcmp (sec_name, ".debug"))
 385     {
 386 #ifdef STYP_DEBUG
 387       styp_flags = STYP_DEBUG;
 388 #else
 389       styp_flags = STYP_INFO;
 390 #endif
 391     }
 392   else if (!strncmp (sec_name, ".stab", 5))
 393     {
 394       styp_flags = STYP_INFO;
 395     }
 396 #ifdef COFF_WITH_PE
 397   else if (!strcmp (sec_name, ".edata"))
 398     {
 399       styp_flags = STYP_DATA;
 400     }
 401 #endif
 402 #ifdef RS6000COFF_C
 403   else if (!strcmp (sec_name, _PAD))
 404     {
 405       styp_flags = STYP_PAD;
 406     }
 407   else if (!strcmp (sec_name, _LOADER))
 408     {
 409       styp_flags = STYP_LOADER;
 410     }
 411 #endif
 412   /* Try and figure out what it should be */
 413   else if (sec_flags & SEC_CODE)
 414     {
 415       styp_flags = STYP_TEXT;
 416     }
 417   else if (sec_flags & SEC_DATA)
 418     {
 419       styp_flags = STYP_DATA;
 420     }
 421   else if (sec_flags & SEC_READONLY)
 422     {
 423 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 424       styp_flags = STYP_LIT;
 425 #else
 426       styp_flags = STYP_TEXT;
 427 #endif /* STYP_LIT */
 428     }
 429   else if (sec_flags & SEC_LOAD)
 430     {
 431       styp_flags = STYP_TEXT;
 432     }
 433   else if (sec_flags & SEC_ALLOC)
 434     {
 435       styp_flags = STYP_BSS;
 436     }
 437
 438 #ifdef STYP_NOLOAD
 439   if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
 440     styp_flags |= STYP_NOLOAD;
 441 #endif
 442
 443 #ifdef COFF_WITH_PE
 444   if (sec_flags & SEC_LINK_ONCE)
 445     styp_flags |= IMAGE_SCN_LNK_COMDAT;
 446 #endif
 447
 448   return (styp_flags);
 449 }
 450 /*
 451  * Return a word with SEC_* flags set to represent the incoming
 452  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 453  * function is sec_to_styp_flags().
 454  * NOTE: If you add to/change this routine, you should mirror the changes
 455  *      in sec_to_styp_flags().
 456  */
 457 static flagword
 458 styp_to_sec_flags (abfd, hdr, name)
 459      bfd *abfd ATTRIBUTE_UNUSED;
 460      PTR hdr;
 461      const char *name;
 462 {
 463   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 464   long styp_flags = internal_s->s_flags;
 465   flagword sec_flags = 0;
 466
 467 #ifdef STYP_NOLOAD
 468   if (styp_flags & STYP_NOLOAD)
 469     {
 470       sec_flags |= SEC_NEVER_LOAD;
 471     }
 472 #endif /* STYP_NOLOAD */
 473
 474   /* For 386 COFF, at least, an unloadable text or data section is
 475      actually a shared library section.  */
 476   if (styp_flags & STYP_TEXT)
 477     {
 478       if (sec_flags & SEC_NEVER_LOAD)
 479         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 480       else
 481         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 482     }
 483   else if (styp_flags & STYP_DATA)
 484     {
 485       if (sec_flags & SEC_NEVER_LOAD)
 486         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 487       else
 488         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 489     }
 490   else if (styp_flags & STYP_BSS)
 491     {
 492 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 493       if (sec_flags & SEC_NEVER_LOAD)
 494         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 495       else
 496 #endif
 497         sec_flags |= SEC_ALLOC;
 498     }
 499   else if (styp_flags & STYP_INFO)
 500     {
 501       /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
 502          defined.  coff_compute_section_file_positions uses
 503          COFF_PAGE_SIZE to ensure that the low order bits of the
 504          section VMA and the file offset match.  If we don't know
 505          COFF_PAGE_SIZE, we can't ensure the correct correspondence,
 506          and demand page loading of the file will fail.  */
 507 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
 508       sec_flags |= SEC_DEBUGGING;
 509 #endif
 510     }
 511   else if (styp_flags & STYP_PAD)
 512     {
 513       sec_flags = 0;
 514     }
 515   else if (strcmp (name, _TEXT) == 0)
 516     {
 517       if (sec_flags & SEC_NEVER_LOAD)
 518         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 519       else
 520         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 521     }
 522   else if (strcmp (name, _DATA) == 0)
 523     {
 524       if (sec_flags & SEC_NEVER_LOAD)
 525         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 526       else
 527         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 528     }
 529   else if (strcmp (name, _BSS) == 0)
 530     {
 531 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 532       if (sec_flags & SEC_NEVER_LOAD)
 533         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 534       else
 535 #endif
 536         sec_flags |= SEC_ALLOC;
 537     }
 538   else if (strcmp (name, ".debug") == 0
 539 #ifdef _COMMENT
 540            || strcmp (name, _COMMENT) == 0
 541 #endif
 542            || strncmp (name, ".stab", 5) == 0)
 543     {
 544 #ifdef COFF_PAGE_SIZE
 545       sec_flags |= SEC_DEBUGGING;
 546 #endif
 547     }
 548 #ifdef _LIB
 549   else if (strcmp (name, _LIB) == 0)
 550     ;
 551 #endif
 552 #ifdef _LIT
 553   else if (strcmp (name, _LIT) == 0)
 554     {
 555       sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
 556     }
 557 #endif
 558   else
 559     {
 560       sec_flags |= SEC_ALLOC | SEC_LOAD;
 561     }
 562
 563 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 564   if ((styp_flags & STYP_LIT) == STYP_LIT)
 565     {
 566       sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 567     }
 568 #endif /* STYP_LIT */
 569 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 570   if (styp_flags & STYP_OTHER_LOAD)
 571     {
 572       sec_flags = (SEC_LOAD | SEC_ALLOC);
 573     }
 574 #endif /* STYP_SDATA */
 575
 576 #ifdef COFF_WITH_PE
 577   if (styp_flags & IMAGE_SCN_LNK_REMOVE)
 578     sec_flags |= SEC_EXCLUDE;
 579
 580   if (styp_flags & IMAGE_SCN_LNK_COMDAT)
 581     {
 582       sec_flags |= SEC_LINK_ONCE;
 583
 584       /* Unfortunately, the PE format stores essential information in
 585          the symbol table, of all places.  We need to extract that
 586          information now, so that objdump and the linker will know how
 587          to handle the section without worrying about the symbols.  We
 588          can't call slurp_symtab, because the linker doesn't want the
 589          swapped symbols.  */
 590
 591       /* COMDAT sections are special.  The first symbol is the section
 592          symbol, which tells what kind of COMDAT section it is.  The
 593          *second* symbol is the "comdat symbol" - the one with the
 594          unique name.  GNU uses the section symbol for the unique
 595          name; MS uses ".text" for every comdat section.  Sigh.  - DJ */
 596
 597       if (_bfd_coff_get_external_symbols (abfd))
 598         {
 599           bfd_byte *esym, *esymend;
 600
 601           esym = (bfd_byte *) obj_coff_external_syms (abfd);
 602           esymend = esym + obj_raw_syment_count (abfd) * SYMESZ;
 603
 604           while (esym < esymend)
 605             {
 606               struct internal_syment isym;
 607
 608               bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
 609
 610               if (sizeof (internal_s->s_name) > SYMNMLEN)
 611                 {
 612                   /* This case implies that the matching symbol name
 613                      will be in the string table.  */
 614                   abort ();
 615                 }
 616
 617               if (isym.n_sclass == C_STAT
 618                   && isym.n_type == T_NULL
 619                   && isym.n_numaux == 1)
 620                 {
 621                   char buf[SYMNMLEN + 1];
 622                   const char *symname;
 623
 624                   symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
 625                   if (symname == NULL)
 626                     abort ();
 627
 628                   if (strcmp (name, symname) == 0)
 629                     {
 630                       union internal_auxent aux;
 631
 632                       /* This is the section symbol.  */
 633
 634                       bfd_coff_swap_aux_in (abfd, (PTR) (esym + SYMESZ),
 635                                             isym.n_type, isym.n_sclass,
 636                                             0, isym.n_numaux, (PTR) &aux);
 637
 638                       /* FIXME: Microsoft uses NODUPLICATES and
 639                          ASSOCIATIVE, but gnu uses ANY and SAME_SIZE.
 640                          Unfortunately, gnu doesn't do the comdat
 641                          symbols right.  So, until we can fix it to do
 642                          the right thing, we are temporarily disabling
 643                          comdats for the MS types (they're used in
 644                          DLLs and C++, but we don't support *their*
 645                          C++ libraries anyway - DJ */
 646
 647                       switch (aux.x_scn.x_comdat)
 648                         {
 649                         case IMAGE_COMDAT_SELECT_NODUPLICATES:
 650 #if 0
 651                           sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
 652 #else
 653                           sec_flags &= ~SEC_LINK_ONCE;
 654 #endif
 655                           break;
 656
 657                         default:
 658                         case IMAGE_COMDAT_SELECT_ANY:
 659                           sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
 660                           break;
 661
 662                         case IMAGE_COMDAT_SELECT_SAME_SIZE:
 663                           sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
 664                           break;
 665
 666                         case IMAGE_COMDAT_SELECT_EXACT_MATCH:
 667                           sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
 668                           break;
 669
 670                         case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
 671 #if 0
 672                           /* FIXME: This is not currently implemented.  */
 673                           sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
 674 #else
 675                           sec_flags &= ~SEC_LINK_ONCE;
 676 #endif
 677                           break;
 678                         }
 679
 680                       break;
 681                     }
 682                 }
 683
 684               esym += (isym.n_numaux + 1) * SYMESZ;
 685             }
 686         }
 687     }
 688 #endif
 689
 690 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
 691   /* As a GNU extension, if the name begins with .gnu.linkonce, we
 692      only link a single copy of the section.  This is used to support
 693      g++.  g++ will emit each template expansion in its own section.
 694      The symbols will be defined as weak, so that multiple definitions
 695      are permitted.  The GNU linker extension is to actually discard
 696      all but one of the sections.  */
 697   if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
 698     sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 699 #endif
 700
 701   return (sec_flags);
 702 }
 703
 704 #define get_index(symbol)       ((symbol)->udata.i)
 705
 706 /*
 707 INTERNAL_DEFINITION
 708         bfd_coff_backend_data
 709
 710 CODE_FRAGMENT
 711
 712 Special entry points for gdb to swap in coff symbol table parts:
 713 .typedef struct
 714 .{
 715 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 716 .       bfd            *abfd,
 717 .       PTR             ext,
 718 .       int             type,
 719 .       int             class,
 720 .       int             indaux,
 721 .       int             numaux,
 722 .       PTR             in));
 723 .
 724 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 725 .       bfd            *abfd ,
 726 .       PTR             ext,
 727 .       PTR             in));
 728 .
 729 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 730 .       bfd            *abfd,
 731 .       PTR            ext,
 732 .       PTR             in));
 733 .
 734
 735 Special entry points for gas to swap out coff parts:
 736
 737 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 738 .       bfd     *abfd,
 739 .       PTR     in,
 740 .       int     type,
 741 .       int     class,
 742 .       int     indaux,
 743 .       int     numaux,
 744 .       PTR     ext));
 745 .
 746 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 747 .      bfd      *abfd,
 748 .      PTR      in,
 749 .      PTR      ext));
 750 .
 751 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 752 .       bfd     *abfd,
 753 .       PTR     in,
 754 .       PTR     ext));
 755 .
 756 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 757 .       bfd     *abfd,
 758 .       PTR     src,
 759 .       PTR     dst));
 760 .
 761 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 762 .       bfd     *abfd,
 763 .       PTR     in,
 764 .       PTR     out));
 765 .
 766 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 767 .       bfd     *abfd,
 768 .       PTR     in,
 769 .       PTR     out));
 770 .
 771 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 772 .       bfd     *abfd,
 773 .       PTR     in,
 774 .       PTR     out));
 775 .
 776
 777 Special entry points for generic COFF routines to call target
 778 dependent COFF routines:
 779
 780 . unsigned int _bfd_filhsz;
 781 . unsigned int _bfd_aoutsz;
 782 . unsigned int _bfd_scnhsz;
 783 . unsigned int _bfd_symesz;
 784 . unsigned int _bfd_auxesz;
 785 . unsigned int _bfd_relsz;
 786 . unsigned int _bfd_linesz;
 787 . boolean _bfd_coff_long_filenames;
 788 . boolean _bfd_coff_long_section_names;
 789 . unsigned int _bfd_coff_default_section_alignment_power;
 790 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 791 .       bfd     *abfd,
 792 .       PTR     ext,
 793 .       PTR     in));
 794 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 795 .       bfd     *abfd,
 796 .       PTR     ext,
 797 .       PTR     in));
 798 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 799 .       bfd     *abfd,
 800 .       PTR     ext,
 801 .       PTR     in));
 802 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
 803 .       bfd     *abfd,
 804 .       PTR     ext,
 805 .       PTR     in));
 806 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 807 .       bfd     *abfd,
 808 .       PTR     internal_filehdr));
 809 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 810 .       bfd     *abfd,
 811 .       PTR     internal_filehdr));
 812 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 813 .       bfd     *abfd,
 814 .       PTR     internal_filehdr,
 815 .       PTR     internal_aouthdr));
 816 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 817 .       bfd     *abfd,
 818 .       PTR     internal_scnhdr,
 819 .       const char *name));
 820 . void (*_bfd_set_alignment_hook) PARAMS ((
 821 .       bfd     *abfd,
 822 .       asection *sec,
 823 .       PTR     internal_scnhdr));
 824 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 825 .       bfd     *abfd));
 826 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 827 .       bfd     *abfd,
 828 .       struct internal_syment *sym));
 829 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
 830 .       bfd *abfd,
 831 .       combined_entry_type *table_base,
 832 .       combined_entry_type *symbol,
 833 .       unsigned int indaux,
 834 .       combined_entry_type *aux));
 835 . boolean (*_bfd_coff_print_aux) PARAMS ((
 836 .       bfd *abfd,
 837 .       FILE *file,
 838 .       combined_entry_type *table_base,
 839 .       combined_entry_type *symbol,
 840 .       combined_entry_type *aux,
 841 .       unsigned int indaux));
 842 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 843 .       bfd     *abfd,
 844 .       struct bfd_link_info *link_info,
 845 .       struct bfd_link_order *link_order,
 846 .       arelent *reloc,
 847 .       bfd_byte *data,
 848 .       unsigned int *src_ptr,
 849 .       unsigned int *dst_ptr));
 850 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
 851 .       bfd *abfd,
 852 .       asection *input_section,
 853 .       arelent *r,
 854 .       unsigned int shrink,
 855 .       struct bfd_link_info *link_info));
 856 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
 857 .       bfd *abfd,
 858 .       struct internal_syment *));
 859 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
 860 .       bfd *abfd));
 861 . boolean (*_bfd_coff_start_final_link) PARAMS ((
 862 .       bfd *output_bfd,
 863 .       struct bfd_link_info *info));
 864 . boolean (*_bfd_coff_relocate_section) PARAMS ((
 865 .       bfd *output_bfd,
 866 .       struct bfd_link_info *info,
 867 .       bfd *input_bfd,
 868 .       asection *input_section,
 869 .       bfd_byte *contents,
 870 .       struct internal_reloc *relocs,
 871 .       struct internal_syment *syms,
 872 .       asection **sections));
 873 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
 874 .       bfd *abfd,
 875 .       asection *sec,
 876 .       struct internal_reloc *rel,
 877 .       struct coff_link_hash_entry *h,
 878 .       struct internal_syment *sym,
 879 .       bfd_vma *addendp));
 880 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
 881 .       bfd *obfd,
 882 .       struct bfd_link_info *info,
 883 .       bfd *ibfd,
 884 .       asection *sec,
 885 .       struct internal_reloc *reloc,
 886 .       boolean *adjustedp));
 887 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
 888 .       struct bfd_link_info *info,
 889 .       bfd *abfd,
 890 .       const char *name,
 891 .       flagword flags,
 892 .       asection *section,
 893 .       bfd_vma value,
 894 .       const char *string,
 895 .       boolean copy,
 896 .       boolean collect,
 897 .       struct bfd_link_hash_entry **hashp));
 898 .
 899 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
 900 .       bfd * abfd,
 901 .       struct coff_final_link_info * pfinfo));
 902 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
 903 .       bfd * abfd,
 904 .       struct coff_final_link_info * pfinfo));
 905 .
 906 .} bfd_coff_backend_data;
 907 .
 908 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 909 .
 910 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
 911 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
 912 .
 913 .#define bfd_coff_swap_sym_in(a,e,i) \
 914 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 915 .
 916 .#define bfd_coff_swap_lineno_in(a,e,i) \
 917 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 918 .
 919 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 920 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 921 .
 922 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 923 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 924 .
 925 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
 926 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
 927 .
 928 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 929 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 930 .
 931 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 932 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 933 .
 934 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 935 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 936 .
 937 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 938 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 939 .
 940 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 941 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 942 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 943 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 944 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 945 .#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
 946 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 947 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 948 .#define bfd_coff_long_section_names(abfd) \
 949 .        (coff_backend_info (abfd)->_bfd_coff_long_section_names)
 950 .#define bfd_coff_default_section_alignment_power(abfd) \
 951 .        (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
 952 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 953 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 954 .
 955 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 956 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 957 .
 958 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 959 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 960 .
 961 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
 962 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
 963 .
 964 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 965 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 966 .
 967 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 968 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 969 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
 970 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
 971 .
 972 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
 973 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
 974 .
 975 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 976 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 977 .
 978 .#define bfd_coff_slurp_symbol_table(abfd)\
 979 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 980 .
 981 .#define bfd_coff_symname_in_debug(abfd, sym)\
 982 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 983 .
 984 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
 985 .        ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
 986 .         (abfd, file, base, symbol, aux, indaux))
 987 .
 988 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
 989 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 990 .         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
 991 .
 992 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
 993 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 994 .         (abfd, section, reloc, shrink, link_info))
 995 .
 996 .#define bfd_coff_sym_is_global(abfd, sym)\
 997 .        ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
 998 .         (abfd, sym))
 999 .
1000 .#define bfd_coff_compute_section_file_positions(abfd)\
1001 .        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1002 .         (abfd))
1003 .
1004 .#define bfd_coff_start_final_link(obfd, info)\
1005 .        ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1006 .         (obfd, info))
1007 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1008 .        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1009 .         (obfd, info, ibfd, o, con, rel, isyms, secs))
1010 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1011 .        ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1012 .         (abfd, sec, rel, h, sym, addendp))
1013 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1014 .        ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1015 .         (obfd, info, ibfd, sec, rel, adjustedp))
1016 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1017 .        ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1018 .         (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1019 .
1020 .#define bfd_coff_link_output_has_begun(a,p) \
1021 .        ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1022 .#define bfd_coff_final_link_postscript(a,p) \
1023 .        ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1024 .
1025 */
1026
1027 /* See whether the magic number matches.  */
1028
1029 static boolean
1030 coff_bad_format_hook (abfd, filehdr)
1031      bfd * abfd ATTRIBUTE_UNUSED;
1032      PTR filehdr;
1033 {
1034   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1035
1036   if (BADMAG (*internal_f))
1037     return false;
1038
1039   /* if the optional header is NULL or not the correct size then
1040      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1041      and Intel 960 readwrite headers (I960WRMAGIC) is that the
1042      optional header is of a different size.
1043
1044      But the mips keeps extra stuff in it's opthdr, so dont check
1045      when doing that
1046      */
1047
1048 #if defined(M88) || defined(I960)
1049   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
1050     return false;
1051 #endif
1052
1053   return true;
1054 }
1055
1056 /*
1057    initialize a section structure with information peculiar to this
1058    particular implementation of coff
1059 */
1060
1061 static boolean
1062 coff_new_section_hook (abfd, section)
1063      bfd * abfd;
1064      asection * section;
1065 {
1066   combined_entry_type *native;
1067
1068   section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1069
1070 #ifdef RS6000COFF_C
1071   if (xcoff_data (abfd)->text_align_power != 0
1072       && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1073     section->alignment_power = xcoff_data (abfd)->text_align_power;
1074   if (xcoff_data (abfd)->data_align_power != 0
1075       && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1076     section->alignment_power = xcoff_data (abfd)->data_align_power;
1077 #endif
1078
1079   /* Allocate aux records for section symbols, to store size and
1080      related info.
1081
1082      @@ The 10 is a guess at a plausible maximum number of aux entries
1083      (but shouldn't be a constant).  */
1084   native = ((combined_entry_type *)
1085             bfd_zalloc (abfd, sizeof (combined_entry_type) * 10));
1086   if (native == NULL)
1087     return false;
1088
1089   /* We don't need to set up n_name, n_value, or n_scnum in the native
1090      symbol information, since they'll be overriden by the BFD symbol
1091      anyhow.  However, we do need to set the type and storage class,
1092      in case this symbol winds up getting written out.  The value 0
1093      for n_numaux is already correct.  */
1094
1095   native->u.syment.n_type = T_NULL;
1096   native->u.syment.n_sclass = C_STAT;
1097
1098   coffsymbol (section->symbol)->native = native;
1099
1100   /* The .stab section must be aligned to 2**2 at most, because
1101      otherwise there may be gaps in the section which gdb will not
1102      know how to interpret.  Examining the section name is a hack, but
1103      that is also how gdb locates the section.
1104      We need to handle the .ctors and .dtors sections similarly, to
1105      avoid introducing null words in the tables.  */
1106   if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2
1107       && (strncmp (section->name, ".stab", 5) == 0
1108           || strcmp (section->name, ".ctors") == 0
1109           || strcmp (section->name, ".dtors") == 0))
1110     section->alignment_power = 2;
1111
1112   /* Similarly, the .stabstr section must be aligned to 2**0 at most.  */
1113   if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 0
1114       && strncmp (section->name, ".stabstr", 8) == 0)
1115     section->alignment_power = 0;
1116
1117   return true;
1118 }
1119
1120 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1121
1122 /* Set the alignment of a BFD section.  */
1123
1124 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1125
1126 static void
1127 coff_set_alignment_hook (abfd, section, scnhdr)
1128      bfd * abfd ATTRIBUTE_UNUSED;
1129      asection * section;
1130      PTR scnhdr;
1131 {
1132   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1133   unsigned int i;
1134
1135 #ifdef I960
1136   /* Extract ALIGN from 2**ALIGN stored in section header */
1137   for (i = 0; i < 32; i++)
1138     if ((1 << i) >= hdr->s_align)
1139       break;
1140 #endif
1141 #ifdef TIC80COFF
1142   /* TI tools hijack bits 8-11 for the alignment */
1143   i = (hdr->s_flags >> 8) & 0xF ;
1144 #endif
1145   section->alignment_power = i;
1146 }
1147
1148 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1149 #ifdef COFF_WITH_PE
1150
1151 /* a couple of macros to help setting the alignment power field */
1152 #define ALIGN_SET(field,x,y) \
1153   if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1154   {\
1155      section->alignment_power = y;\
1156   }
1157
1158 #define ELIFALIGN_SET(field,x,y) \
1159   else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1160   {\
1161      section->alignment_power = y;\
1162   }
1163
1164 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1165
1166 static void
1167 coff_set_alignment_hook (abfd, section, scnhdr)
1168      bfd * abfd ATTRIBUTE_UNUSED;
1169      asection * section;
1170      PTR scnhdr;
1171 {
1172   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1173
1174   ALIGN_SET     (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1175   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1176   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1177   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES,  3)
1178   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES,  2)
1179   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES,  1)
1180   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES,  0)
1181
1182 #ifdef POWERPC_LE_PE
1183   if (strcmp (section->name, ".idata$2") == 0)
1184     {
1185       section->alignment_power = 0;
1186     }
1187   else if (strcmp (section->name, ".idata$3") == 0)
1188     {
1189       section->alignment_power = 0;
1190     }
1191   else if (strcmp (section->name, ".idata$4") == 0)
1192     {
1193       section->alignment_power = 2;
1194     }
1195   else if (strcmp (section->name, ".idata$5") == 0)
1196     {
1197       section->alignment_power = 2;
1198     }
1199   else if (strcmp (section->name, ".idata$6") == 0)
1200     {
1201       section->alignment_power = 1;
1202     }
1203   else if (strcmp (section->name, ".reloc") == 0)
1204     {
1205       section->alignment_power = 1;
1206     }
1207   else if (strncmp (section->name, ".stab", 5) == 0)
1208     {
1209       section->alignment_power = 2;
1210     }
1211 #endif
1212
1213 #ifdef COFF_IMAGE_WITH_PE
1214   /* In a PE image file, the s_paddr field holds the virtual size of a
1215      section, while the s_size field holds the raw size.  */
1216   if (hdr->s_paddr != 0)
1217     {
1218       if (coff_section_data (abfd, section) == NULL)
1219         {
1220           section->used_by_bfd =
1221             (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
1222           if (section->used_by_bfd == NULL)
1223             {
1224               /* FIXME: Return error.  */
1225               abort ();
1226             }
1227         }
1228       if (pei_section_data (abfd, section) == NULL)
1229         {
1230           coff_section_data (abfd, section)->tdata =
1231             (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
1232           if (coff_section_data (abfd, section)->tdata == NULL)
1233             {
1234               /* FIXME: Return error.  */
1235               abort ();
1236             }
1237         }
1238       pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1239     }
1240 #endif
1241
1242 #ifdef COFF_WITH_PE
1243   section->lma = hdr->s_vaddr;
1244 #endif
1245 }
1246 #undef ALIGN_SET
1247 #undef ELIFALIGN_SET
1248
1249 #else /* ! COFF_WITH_PE */
1250 #ifdef RS6000COFF_C
1251
1252 /* We grossly abuse this function to handle XCOFF overflow headers.
1253    When we see one, we correct the reloc and line number counts in the
1254    real header, and remove the section we just created.  */
1255
1256 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1257
1258 static void
1259 coff_set_alignment_hook (abfd, section, scnhdr)
1260      bfd *abfd;
1261      asection *section;
1262      PTR scnhdr;
1263 {
1264   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1265   asection *real_sec;
1266   asection **ps;
1267
1268   if ((hdr->s_flags & STYP_OVRFLO) == 0)
1269     return;
1270
1271   real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1272   if (real_sec == NULL)
1273     return;
1274
1275   real_sec->reloc_count = hdr->s_paddr;
1276   real_sec->lineno_count = hdr->s_vaddr;
1277
1278   for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1279     {
1280       if (*ps == section)
1281         {
1282           *ps = (*ps)->next;
1283           --abfd->section_count;
1284           break;
1285         }
1286     }
1287 }
1288
1289 #else /* ! RS6000COFF_C */
1290
1291 #define coff_set_alignment_hook \
1292   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1293
1294 #endif /* ! RS6000COFF_C */
1295 #endif /* ! COFF_WITH_PE */
1296 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1297
1298 #ifndef coff_mkobject
1299
1300 static boolean coff_mkobject PARAMS ((bfd *));
1301
1302 static boolean
1303 coff_mkobject (abfd)
1304      bfd * abfd;
1305 {
1306   coff_data_type *coff;
1307
1308   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1309   if (abfd->tdata.coff_obj_data == 0)
1310     return false;
1311   coff = coff_data (abfd);
1312   coff->symbols = (coff_symbol_type *) NULL;
1313   coff->conversion_table = (unsigned int *) NULL;
1314   coff->raw_syments = (struct coff_ptr_struct *) NULL;
1315   coff->relocbase = 0;
1316   coff->local_toc_sym_map = 0;
1317
1318 /*  make_abs_section(abfd);*/
1319
1320   return true;
1321 }
1322 #endif
1323
1324 /* Create the COFF backend specific information.  */
1325 #ifndef coff_mkobject_hook
1326 static PTR
1327 coff_mkobject_hook (abfd, filehdr, aouthdr)
1328      bfd * abfd;
1329      PTR filehdr;
1330      PTR aouthdr ATTRIBUTE_UNUSED;
1331 {
1332   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1333   coff_data_type *coff;
1334
1335   if (coff_mkobject (abfd) == false)
1336     return NULL;
1337
1338   coff = coff_data (abfd);
1339
1340   coff->sym_filepos = internal_f->f_symptr;
1341
1342   /* These members communicate important constants about the symbol
1343      table to GDB's symbol-reading code.  These `constants'
1344      unfortunately vary among coff implementations...  */
1345   coff->local_n_btmask = N_BTMASK;
1346   coff->local_n_btshft = N_BTSHFT;
1347   coff->local_n_tmask = N_TMASK;
1348   coff->local_n_tshift = N_TSHIFT;
1349   coff->local_symesz = SYMESZ;
1350   coff->local_auxesz = AUXESZ;
1351   coff->local_linesz = LINESZ;
1352
1353   obj_raw_syment_count (abfd) =
1354     obj_conv_table_size (abfd) =
1355       internal_f->f_nsyms;
1356
1357 #ifdef RS6000COFF_C
1358   if ((internal_f->f_flags & F_SHROBJ) != 0)
1359     abfd->flags |= DYNAMIC;
1360   if (aouthdr != NULL && internal_f->f_opthdr >= AOUTSZ)
1361     {
1362       struct internal_aouthdr *internal_a =
1363         (struct internal_aouthdr *) aouthdr;
1364       struct xcoff_tdata *xcoff;
1365
1366       xcoff = xcoff_data (abfd);
1367       xcoff->full_aouthdr = true;
1368       xcoff->toc = internal_a->o_toc;
1369       xcoff->sntoc = internal_a->o_sntoc;
1370       xcoff->snentry = internal_a->o_snentry;
1371       xcoff->text_align_power = internal_a->o_algntext;
1372       xcoff->data_align_power = internal_a->o_algndata;
1373       xcoff->modtype = internal_a->o_modtype;
1374       xcoff->cputype = internal_a->o_cputype;
1375       xcoff->maxdata = internal_a->o_maxdata;
1376       xcoff->maxstack = internal_a->o_maxstack;
1377     }
1378 #endif
1379
1380 #ifdef ARM
1381   /* Set the flags field from the COFF header read in */
1382   if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1383     coff->flags = 0;
1384 #endif
1385
1386   return (PTR) coff;
1387 }
1388 #endif
1389
1390 /* Determine the machine architecture and type.  FIXME: This is target
1391    dependent because the magic numbers are defined in the target
1392    dependent header files.  But there is no particular need for this.
1393    If the magic numbers were moved to a separate file, this function
1394    would be target independent and would also be much more successful
1395    at linking together COFF files for different architectures.  */
1396
1397 static boolean
1398 coff_set_arch_mach_hook (abfd, filehdr)
1399      bfd *abfd;
1400      PTR filehdr;
1401 {
1402   long machine;
1403   enum bfd_architecture arch;
1404   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1405
1406   machine = 0;
1407   switch (internal_f->f_magic)
1408     {
1409 #ifdef PPCMAGIC
1410     case PPCMAGIC:
1411       arch = bfd_arch_powerpc;
1412       machine = 0; /* what does this mean? (krk) */
1413       break;
1414 #endif
1415 #ifdef I386MAGIC
1416     case I386MAGIC:
1417     case I386PTXMAGIC:
1418     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1419     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1420       arch = bfd_arch_i386;
1421       machine = 0;
1422       break;
1423 #endif
1424 #ifdef A29K_MAGIC_BIG
1425     case A29K_MAGIC_BIG:
1426     case A29K_MAGIC_LITTLE:
1427       arch = bfd_arch_a29k;
1428       machine = 0;
1429       break;
1430 #endif
1431 #ifdef ARMMAGIC
1432     case ARMMAGIC:
1433       arch = bfd_arch_arm;
1434       switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1435         {
1436         case F_ARM_2:  machine = bfd_mach_arm_2;  break;
1437         case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1438         case F_ARM_3:  machine = bfd_mach_arm_3;  break;
1439         default:
1440         case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1441         case F_ARM_4:  machine = bfd_mach_arm_4;  break;
1442         case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1443         case F_ARM_5:  machine = bfd_mach_arm_5;  break;
1444         }
1445       break;
1446 #endif
1447 #ifdef MC68MAGIC
1448     case MC68MAGIC:
1449     case M68MAGIC:
1450 #ifdef MC68KBCSMAGIC
1451     case MC68KBCSMAGIC:
1452 #endif
1453 #ifdef APOLLOM68KMAGIC
1454     case APOLLOM68KMAGIC:
1455 #endif
1456 #ifdef LYNXCOFFMAGIC
1457     case LYNXCOFFMAGIC:
1458 #endif
1459       arch = bfd_arch_m68k;
1460       machine = bfd_mach_m68020;
1461       break;
1462 #endif
1463 #ifdef MC88MAGIC
1464     case MC88MAGIC:
1465     case MC88DMAGIC:
1466     case MC88OMAGIC:
1467       arch = bfd_arch_m88k;
1468       machine = 88100;
1469       break;
1470 #endif
1471 #ifdef Z8KMAGIC
1472     case Z8KMAGIC:
1473       arch = bfd_arch_z8k;
1474       switch (internal_f->f_flags & F_MACHMASK)
1475         {
1476         case F_Z8001:
1477           machine = bfd_mach_z8001;
1478           break;
1479         case F_Z8002:
1480           machine = bfd_mach_z8002;
1481           break;
1482         default:
1483           return false;
1484         }
1485       break;
1486 #endif
1487 #ifdef I860
1488     case I860MAGIC:
1489       arch = bfd_arch_i860;
1490       break;
1491 #endif
1492 #ifdef I960
1493 #ifdef I960ROMAGIC
1494     case I960ROMAGIC:
1495     case I960RWMAGIC:
1496       arch = bfd_arch_i960;
1497       switch (F_I960TYPE & internal_f->f_flags)
1498         {
1499         default:
1500         case F_I960CORE:
1501           machine = bfd_mach_i960_core;
1502           break;
1503         case F_I960KB:
1504           machine = bfd_mach_i960_kb_sb;
1505           break;
1506         case F_I960MC:
1507           machine = bfd_mach_i960_mc;
1508           break;
1509         case F_I960XA:
1510           machine = bfd_mach_i960_xa;
1511           break;
1512         case F_I960CA:
1513           machine = bfd_mach_i960_ca;
1514           break;
1515         case F_I960KA:
1516           machine = bfd_mach_i960_ka_sa;
1517           break;
1518         case F_I960JX:
1519           machine = bfd_mach_i960_jx;
1520           break;
1521         case F_I960HX:
1522           machine = bfd_mach_i960_hx;
1523           break;
1524         }
1525       break;
1526 #endif
1527 #endif
1528
1529 #ifdef RS6000COFF_C
1530     case U802ROMAGIC:
1531     case U802WRMAGIC:
1532     case U802TOCMAGIC:
1533       {
1534         int cputype;
1535
1536         if (xcoff_data (abfd)->cputype != -1)
1537           cputype = xcoff_data (abfd)->cputype & 0xff;
1538         else
1539           {
1540             /* We did not get a value from the a.out header.  If the
1541                file has not been stripped, we may be able to get the
1542                architecture information from the first symbol, if it
1543                is a .file symbol.  */
1544             if (obj_raw_syment_count (abfd) == 0)
1545               cputype = 0;
1546             else
1547               {
1548                 bfd_byte buf[SYMESZ];
1549                 struct internal_syment sym;
1550
1551                 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1552                     || bfd_read (buf, 1, SYMESZ, abfd) != SYMESZ)
1553                   return false;
1554                 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1555                 if (sym.n_sclass == C_FILE)
1556                   cputype = sym.n_type & 0xff;
1557                 else
1558                   cputype = 0;
1559               }
1560           }
1561
1562         /* FIXME: We don't handle all cases here.  */
1563         switch (cputype)
1564           {
1565           default:
1566           case 0:
1567 #ifdef POWERMAC
1568             /* PowerPC Macs use the same magic numbers as RS/6000
1569                (because that's how they were bootstrapped originally),
1570                but they are always PowerPC architecture.  */
1571             arch = bfd_arch_powerpc;
1572             machine = 0;
1573 #else
1574             arch = bfd_arch_rs6000;
1575             machine = 6000;
1576 #endif /* POWERMAC */
1577             break;
1578
1579           case 1:
1580             arch = bfd_arch_powerpc;
1581             machine = 601;
1582             break;
1583           case 2: /* 64 bit PowerPC */
1584             arch = bfd_arch_powerpc;
1585             machine = 620;
1586             break;
1587           case 3:
1588             arch = bfd_arch_powerpc;
1589             machine = 0;
1590             break;
1591           case 4:
1592             arch = bfd_arch_rs6000;
1593             machine = 6000;
1594             break;
1595           }
1596       }
1597       break;
1598 #endif
1599
1600 #ifdef WE32KMAGIC
1601     case WE32KMAGIC:
1602       arch = bfd_arch_we32k;
1603       machine = 0;
1604       break;
1605 #endif
1606
1607 #ifdef H8300MAGIC
1608     case H8300MAGIC:
1609       arch = bfd_arch_h8300;
1610       machine = bfd_mach_h8300;
1611       /* !! FIXME this probably isn't the right place for this */
1612       abfd->flags |= BFD_IS_RELAXABLE;
1613       break;
1614 #endif
1615
1616 #ifdef H8300HMAGIC
1617     case H8300HMAGIC:
1618       arch = bfd_arch_h8300;
1619       machine = bfd_mach_h8300h;
1620       /* !! FIXME this probably isn't the right place for this */
1621       abfd->flags |= BFD_IS_RELAXABLE;
1622       break;
1623 #endif
1624
1625 #ifdef H8300SMAGIC
1626     case H8300SMAGIC:
1627       arch = bfd_arch_h8300;
1628       machine = bfd_mach_h8300s;
1629       /* !! FIXME this probably isn't the right place for this */
1630       abfd->flags |= BFD_IS_RELAXABLE;
1631       break;
1632 #endif
1633
1634 #ifdef SH_ARCH_MAGIC_BIG
1635     case SH_ARCH_MAGIC_BIG:
1636     case SH_ARCH_MAGIC_LITTLE:
1637       arch = bfd_arch_sh;
1638       machine = 0;
1639       break;
1640 #endif
1641
1642 #ifdef H8500MAGIC
1643     case H8500MAGIC:
1644       arch = bfd_arch_h8500;
1645       machine = 0;
1646       break;
1647 #endif
1648
1649 #ifdef SPARCMAGIC
1650     case SPARCMAGIC:
1651 #ifdef LYNXCOFFMAGIC
1652     case LYNXCOFFMAGIC:
1653 #endif
1654       arch = bfd_arch_sparc;
1655       machine = 0;
1656       break;
1657 #endif
1658
1659 #ifdef TIC30MAGIC
1660     case TIC30MAGIC:
1661       arch = bfd_arch_tic30;
1662       break;
1663 #endif
1664
1665 #ifdef TIC80_ARCH_MAGIC
1666     case TIC80_ARCH_MAGIC:
1667       arch = bfd_arch_tic80;
1668       break;
1669 #endif
1670
1671 #ifdef MCOREMAGIC
1672     case MCOREMAGIC:
1673       arch = bfd_arch_mcore;
1674       break;
1675 #endif
1676     default:                    /* Unreadable input file type */
1677       arch = bfd_arch_obscure;
1678       break;
1679     }
1680
1681   bfd_default_set_arch_mach (abfd, arch, machine);
1682   return true;
1683 }
1684
1685 #ifdef SYMNAME_IN_DEBUG
1686
1687 static boolean symname_in_debug_hook
1688   PARAMS ((bfd *, struct internal_syment *));
1689
1690 static boolean
1691 symname_in_debug_hook (abfd, sym)
1692      bfd * abfd ATTRIBUTE_UNUSED;
1693      struct internal_syment *sym;
1694 {
1695   return SYMNAME_IN_DEBUG (sym) ? true : false;
1696 }
1697
1698 #else
1699
1700 #define symname_in_debug_hook \
1701   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1702
1703 #endif
1704
1705 #ifdef RS6000COFF_C
1706
1707 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
1708
1709 static boolean coff_pointerize_aux_hook
1710   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1711            unsigned int, combined_entry_type *));
1712
1713 /*ARGSUSED*/
1714 static boolean
1715 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1716      bfd *abfd ATTRIBUTE_UNUSED;
1717      combined_entry_type *table_base;
1718      combined_entry_type *symbol;
1719      unsigned int indaux;
1720      combined_entry_type *aux;
1721 {
1722   int class = symbol->u.syment.n_sclass;
1723
1724   if ((class == C_EXT || class == C_HIDEXT)
1725       && indaux + 1 == symbol->u.syment.n_numaux)
1726     {
1727       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
1728         {
1729           aux->u.auxent.x_csect.x_scnlen.p =
1730             table_base + aux->u.auxent.x_csect.x_scnlen.l;
1731           aux->fix_scnlen = 1;
1732         }
1733
1734       /* Return true to indicate that the caller should not do any
1735          further work on this auxent.  */
1736       return true;
1737     }
1738
1739   /* Return false to indicate that this auxent should be handled by
1740      the caller.  */
1741   return false;
1742 }
1743
1744 #else
1745 #ifdef I960
1746
1747 /* We don't want to pointerize bal entries.  */
1748
1749 static boolean coff_pointerize_aux_hook
1750   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1751            unsigned int, combined_entry_type *));
1752
1753 /*ARGSUSED*/
1754 static boolean
1755 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1756      bfd *abfd ATTRIBUTE_UNUSED;
1757      combined_entry_type *table_base ATTRIBUTE_UNUSED;
1758      combined_entry_type *symbol;
1759      unsigned int indaux;
1760      combined_entry_type *aux ATTRIBUTE_UNUSED;
1761 {
1762   /* Return true if we don't want to pointerize this aux entry, which
1763      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
1764   return (indaux == 1
1765           && (symbol->u.syment.n_sclass == C_LEAFPROC
1766               || symbol->u.syment.n_sclass == C_LEAFSTAT
1767               || symbol->u.syment.n_sclass == C_LEAFEXT));
1768 }
1769
1770 #else /* ! I960 */
1771
1772 #define coff_pointerize_aux_hook 0
1773
1774 #endif /* ! I960 */
1775 #endif /* ! RS6000COFF_C */
1776
1777 /* Print an aux entry.  This returns true if it has printed it.  */
1778
1779 static boolean coff_print_aux
1780   PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1781            combined_entry_type *, unsigned int));
1782
1783 static boolean
1784 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
1785      bfd *abfd ATTRIBUTE_UNUSED;
1786      FILE *file ATTRIBUTE_UNUSED;
1787      combined_entry_type *table_base ATTRIBUTE_UNUSED;
1788      combined_entry_type *symbol ATTRIBUTE_UNUSED;
1789      combined_entry_type *aux ATTRIBUTE_UNUSED;
1790      unsigned int indaux ATTRIBUTE_UNUSED;
1791 {
1792 #ifdef RS6000COFF_C
1793   if ((symbol->u.syment.n_sclass == C_EXT
1794        || symbol->u.syment.n_sclass == C_HIDEXT)
1795       && indaux + 1 == symbol->u.syment.n_numaux)
1796     {
1797       /* This is a csect entry.  */
1798       fprintf (file, "AUX ");
1799       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
1800         {
1801           BFD_ASSERT (! aux->fix_scnlen);
1802           fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
1803         }
1804       else
1805         {
1806           fprintf (file, "indx ");
1807           if (! aux->fix_scnlen)
1808             fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
1809           else
1810             fprintf (file, "%4ld",
1811                      (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
1812         }
1813       fprintf (file,
1814                " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1815                aux->u.auxent.x_csect.x_parmhash,
1816                (unsigned int) aux->u.auxent.x_csect.x_snhash,
1817                SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
1818                SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
1819                (unsigned int) aux->u.auxent.x_csect.x_smclas,
1820                aux->u.auxent.x_csect.x_stab,
1821                (unsigned int) aux->u.auxent.x_csect.x_snstab);
1822       return true;
1823     }
1824 #endif
1825
1826   /* Return false to indicate that no special action was taken.  */
1827   return false;
1828 }
1829
1830 /*
1831 SUBSUBSECTION
1832         Writing relocations
1833
1834         To write relocations, the back end steps though the
1835         canonical relocation table and create an
1836         @code{internal_reloc}. The symbol index to use is removed from
1837         the @code{offset} field in the symbol table supplied.  The
1838         address comes directly from the sum of the section base
1839         address and the relocation offset; the type is dug directly
1840         from the howto field.  Then the @code{internal_reloc} is
1841         swapped into the shape of an @code{external_reloc} and written
1842         out to disk.
1843
1844 */
1845
1846 #ifdef TARG_AUX
1847
1848 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
1849
1850 /* AUX's ld wants relocations to be sorted */
1851 static int
1852 compare_arelent_ptr (x, y)
1853      const PTR x;
1854      const PTR y;
1855 {
1856   const arelent **a = (const arelent **) x;
1857   const arelent **b = (const arelent **) y;
1858   bfd_size_type aadr = (*a)->address;
1859   bfd_size_type badr = (*b)->address;
1860
1861   return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1862 }
1863
1864 #endif /* TARG_AUX */
1865
1866 static boolean
1867 coff_write_relocs (abfd, first_undef)
1868      bfd * abfd;
1869      int first_undef;
1870 {
1871   asection *s;
1872
1873   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1874     {
1875       unsigned int i;
1876       struct external_reloc dst;
1877       arelent **p;
1878
1879 #ifndef TARG_AUX
1880       p = s->orelocation;
1881 #else
1882       /* sort relocations before we write them out */
1883       p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
1884       if (p == NULL && s->reloc_count > 0)
1885         return false;
1886       memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
1887       qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
1888 #endif
1889
1890       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1891         return false;
1892       for (i = 0; i < s->reloc_count; i++)
1893         {
1894           struct internal_reloc n;
1895           arelent *q = p[i];
1896           memset ((PTR) & n, 0, sizeof (n));
1897
1898           /* Now we've renumbered the symbols we know where the
1899              undefined symbols live in the table.  Check the reloc
1900              entries for symbols who's output bfd isn't the right one.
1901              This is because the symbol was undefined (which means
1902              that all the pointers are never made to point to the same
1903              place). This is a bad thing,'cause the symbols attached
1904              to the output bfd are indexed, so that the relocation
1905              entries know which symbol index they point to.  So we
1906              have to look up the output symbol here. */
1907
1908           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1909             {
1910               int i;
1911               const char *sname = q->sym_ptr_ptr[0]->name;
1912               asymbol **outsyms = abfd->outsymbols;
1913               for (i = first_undef; outsyms[i]; i++)
1914                 {
1915                   const char *intable = outsyms[i]->name;
1916                   if (strcmp (intable, sname) == 0) {
1917                     /* got a hit, so repoint the reloc */
1918                     q->sym_ptr_ptr = outsyms + i;
1919                     break;
1920                   }
1921                 }
1922             }
1923
1924           n.r_vaddr = q->address + s->vma;
1925
1926 #ifdef R_IHCONST
1927           /* The 29k const/consth reloc pair is a real kludge.  The consth
1928              part doesn't have a symbol; it has an offset.  So rebuilt
1929              that here.  */
1930           if (q->howto->type == R_IHCONST)
1931             n.r_symndx = q->addend;
1932           else
1933 #endif
1934             if (q->sym_ptr_ptr)
1935               {
1936                 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1937                   /* This is a relocation relative to the absolute symbol.  */
1938                   n.r_symndx = -1;
1939                 else
1940                   {
1941                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1942                     /* Take notice if the symbol reloc points to a symbol
1943                        we don't have in our symbol table.  What should we
1944                        do for this??  */
1945                     if (n.r_symndx > obj_conv_table_size (abfd))
1946                       abort ();
1947                   }
1948               }
1949
1950 #ifdef SWAP_OUT_RELOC_OFFSET
1951           n.r_offset = q->addend;
1952 #endif
1953
1954 #ifdef SELECT_RELOC
1955           /* Work out reloc type from what is required */
1956           SELECT_RELOC (n, q->howto);
1957 #else
1958           n.r_type = q->howto->type;
1959 #endif
1960           coff_swap_reloc_out (abfd, &n, &dst);
1961           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1962             return false;
1963         }
1964
1965 #ifdef TARG_AUX
1966       if (p != NULL)
1967         free (p);
1968 #endif
1969     }
1970
1971   return true;
1972 }
1973
1974 /* Set flags and magic number of a coff file from architecture and machine
1975    type.  Result is true if we can represent the arch&type, false if not.  */
1976
1977 static boolean
1978 coff_set_flags (abfd, magicp, flagsp)
1979      bfd * abfd;
1980      unsigned int *magicp ATTRIBUTE_UNUSED;
1981      unsigned short *flagsp ATTRIBUTE_UNUSED;
1982 {
1983   switch (bfd_get_arch (abfd))
1984     {
1985 #ifdef Z8KMAGIC
1986     case bfd_arch_z8k:
1987       *magicp = Z8KMAGIC;
1988       switch (bfd_get_mach (abfd))
1989         {
1990         case bfd_mach_z8001:
1991           *flagsp = F_Z8001;
1992           break;
1993         case bfd_mach_z8002:
1994           *flagsp = F_Z8002;
1995           break;
1996         default:
1997           return false;
1998         }
1999       return true;
2000 #endif
2001 #ifdef I960ROMAGIC
2002
2003     case bfd_arch_i960:
2004
2005       {
2006         unsigned flags;
2007         *magicp = I960ROMAGIC;
2008         /*
2009           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2010           I960RWMAGIC);   FIXME???
2011           */
2012         switch (bfd_get_mach (abfd))
2013           {
2014           case bfd_mach_i960_core:
2015             flags = F_I960CORE;
2016             break;
2017           case bfd_mach_i960_kb_sb:
2018             flags = F_I960KB;
2019             break;
2020           case bfd_mach_i960_mc:
2021             flags = F_I960MC;
2022             break;
2023           case bfd_mach_i960_xa:
2024             flags = F_I960XA;
2025             break;
2026           case bfd_mach_i960_ca:
2027             flags = F_I960CA;
2028             break;
2029           case bfd_mach_i960_ka_sa:
2030             flags = F_I960KA;
2031             break;
2032           case bfd_mach_i960_jx:
2033             flags = F_I960JX;
2034             break;
2035           case bfd_mach_i960_hx:
2036             flags = F_I960HX;
2037             break;
2038           default:
2039             return false;
2040           }
2041         *flagsp = flags;
2042         return true;
2043       }
2044       break;
2045 #endif
2046
2047 #ifdef TIC30MAGIC
2048     case bfd_arch_tic30:
2049       *magicp = TIC30MAGIC;
2050       return true;
2051 #endif
2052 #ifdef TIC80_ARCH_MAGIC
2053     case bfd_arch_tic80:
2054       *magicp = TIC80_ARCH_MAGIC;
2055       return true;
2056 #endif
2057 #ifdef ARMMAGIC
2058     case bfd_arch_arm:
2059       * magicp = ARMMAGIC;
2060       * flagsp = 0;
2061       if (APCS_SET (abfd))
2062         {
2063           if (APCS_26_FLAG (abfd))
2064             * flagsp |= F_APCS26;
2065
2066           if (APCS_FLOAT_FLAG (abfd))
2067             * flagsp |= F_APCS_FLOAT;
2068
2069           if (PIC_FLAG (abfd))
2070             * flagsp |= F_PIC;
2071         }
2072       if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2073         * flagsp |= F_INTERWORK;
2074       switch (bfd_get_mach (abfd))
2075         {
2076         case bfd_mach_arm_2:  * flagsp |= F_ARM_2;  break;
2077         case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2078         case bfd_mach_arm_3:  * flagsp |= F_ARM_3;  break;
2079         case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2080         case bfd_mach_arm_4:  * flagsp |= F_ARM_4;  break;
2081         case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2082         case bfd_mach_arm_5:  * flagsp |= F_ARM_5;  break;
2083         case bfd_mach_arm_5T: * flagsp |= F_ARM_5;  break; /* XXX - we do not have an F_ARM_5T */
2084         }
2085       return true;
2086 #endif
2087 #ifdef PPCMAGIC
2088     case bfd_arch_powerpc:
2089       *magicp = PPCMAGIC;
2090       return true;
2091       break;
2092 #endif
2093 #ifdef I386MAGIC
2094     case bfd_arch_i386:
2095       *magicp = I386MAGIC;
2096 #ifdef LYNXOS
2097       /* Just overwrite the usual value if we're doing Lynx. */
2098       *magicp = LYNXCOFFMAGIC;
2099 #endif
2100       return true;
2101       break;
2102 #endif
2103 #ifdef I860MAGIC
2104     case bfd_arch_i860:
2105       *magicp = I860MAGIC;
2106       return true;
2107       break;
2108 #endif
2109 #ifdef MC68MAGIC
2110     case bfd_arch_m68k:
2111 #ifdef APOLLOM68KMAGIC
2112       *magicp = APOLLO_COFF_VERSION_NUMBER;
2113 #else
2114       /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c.  */
2115 #ifdef NAMES_HAVE_UNDERSCORE
2116       *magicp = MC68KBCSMAGIC;
2117 #else
2118       *magicp = MC68MAGIC;
2119 #endif
2120 #endif
2121 #ifdef LYNXOS
2122       /* Just overwrite the usual value if we're doing Lynx. */
2123       *magicp = LYNXCOFFMAGIC;
2124 #endif
2125       return true;
2126       break;
2127 #endif
2128
2129 #ifdef MC88MAGIC
2130     case bfd_arch_m88k:
2131       *magicp = MC88OMAGIC;
2132       return true;
2133       break;
2134 #endif
2135 #ifdef H8300MAGIC
2136     case bfd_arch_h8300:
2137       switch (bfd_get_mach (abfd))
2138         {
2139         case bfd_mach_h8300:
2140           *magicp = H8300MAGIC;
2141           return true;
2142         case bfd_mach_h8300h:
2143           *magicp = H8300HMAGIC;
2144           return true;
2145         case bfd_mach_h8300s:
2146           *magicp = H8300SMAGIC;
2147           return true;
2148         }
2149       break;
2150 #endif
2151
2152 #ifdef SH_ARCH_MAGIC_BIG
2153     case bfd_arch_sh:
2154       if (bfd_big_endian (abfd))
2155         *magicp = SH_ARCH_MAGIC_BIG;
2156       else
2157         *magicp = SH_ARCH_MAGIC_LITTLE;
2158       return true;
2159       break;
2160 #endif
2161
2162 #ifdef SPARCMAGIC
2163     case bfd_arch_sparc:
2164       *magicp = SPARCMAGIC;
2165 #ifdef LYNXOS
2166       /* Just overwrite the usual value if we're doing Lynx. */
2167       *magicp = LYNXCOFFMAGIC;
2168 #endif
2169       return true;
2170       break;
2171 #endif
2172
2173 #ifdef H8500MAGIC
2174     case bfd_arch_h8500:
2175       *magicp = H8500MAGIC;
2176       return true;
2177       break;
2178 #endif
2179 #ifdef A29K_MAGIC_BIG
2180     case bfd_arch_a29k:
2181       if (bfd_big_endian (abfd))
2182         *magicp = A29K_MAGIC_BIG;
2183       else
2184         *magicp = A29K_MAGIC_LITTLE;
2185       return true;
2186       break;
2187 #endif
2188
2189 #ifdef WE32KMAGIC
2190     case bfd_arch_we32k:
2191       *magicp = WE32KMAGIC;
2192       return true;
2193       break;
2194 #endif
2195
2196 #ifdef U802TOCMAGIC
2197     case bfd_arch_rs6000:
2198 #ifndef PPCMAGIC
2199     case bfd_arch_powerpc:
2200 #endif
2201       *magicp = U802TOCMAGIC;
2202       return true;
2203       break;
2204 #endif
2205
2206 #ifdef MCOREMAGIC
2207     case bfd_arch_mcore:
2208       * magicp = MCOREMAGIC;
2209       return true;
2210 #endif
2211
2212     default:                    /* Unknown architecture */
2213       /* return false;  -- fall through to "return false" below, to avoid
2214        "statement never reached" errors on the one below. */
2215       break;
2216     }
2217
2218   return false;
2219 }
2220
2221
2222 static boolean
2223 coff_set_arch_mach (abfd, arch, machine)
2224      bfd * abfd;
2225      enum bfd_architecture arch;
2226      unsigned long machine;
2227 {
2228   unsigned dummy1;
2229   unsigned short dummy2;
2230
2231   if (! bfd_default_set_arch_mach (abfd, arch, machine))
2232     return false;
2233
2234   if (arch != bfd_arch_unknown &&
2235       coff_set_flags (abfd, &dummy1, &dummy2) != true)
2236     return false;               /* We can't represent this type */
2237
2238   return true;                  /* We're easy ... */
2239 }
2240
2241
2242 /* Calculate the file position for each section. */
2243
2244 #ifndef I960
2245 #define ALIGN_SECTIONS_IN_FILE
2246 #endif
2247 #ifdef TIC80COFF
2248 #undef ALIGN_SECTIONS_IN_FILE
2249 #endif
2250
2251 static boolean
2252 coff_compute_section_file_positions (abfd)
2253      bfd * abfd;
2254 {
2255   asection *current;
2256   asection *previous = (asection *) NULL;
2257   file_ptr sofar = FILHSZ;
2258   boolean align_adjust;
2259   unsigned int count;
2260 #ifdef ALIGN_SECTIONS_IN_FILE
2261   file_ptr old_sofar;
2262 #endif
2263
2264 #ifdef RS6000COFF_C
2265   /* On XCOFF, if we have symbols, set up the .debug section.  */
2266   if (bfd_get_symcount (abfd) > 0)
2267     {
2268       bfd_size_type sz;
2269       bfd_size_type i, symcount;
2270       asymbol **symp;
2271
2272       sz = 0;
2273       symcount = bfd_get_symcount (abfd);
2274       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2275         {
2276           coff_symbol_type *cf;
2277
2278           cf = coff_symbol_from (abfd, *symp);
2279           if (cf != NULL
2280               && cf->native != NULL
2281               && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2282             {
2283               size_t len;
2284
2285               len = strlen (bfd_asymbol_name (*symp));
2286               if (len > SYMNMLEN)
2287                 sz += len + 3;
2288             }
2289         }
2290       if (sz > 0)
2291         {
2292           asection *dsec;
2293
2294           dsec = bfd_make_section_old_way (abfd, ".debug");
2295           if (dsec == NULL)
2296             abort ();
2297           dsec->_raw_size = sz;
2298           dsec->flags |= SEC_HAS_CONTENTS;
2299         }
2300     }
2301 #endif
2302
2303 #ifdef COFF_IMAGE_WITH_PE
2304   int page_size;
2305   if (coff_data (abfd)->link_info)
2306     {
2307       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2308     }
2309   else
2310     page_size = PE_DEF_FILE_ALIGNMENT;
2311 #else
2312 #ifdef COFF_PAGE_SIZE
2313   int page_size = COFF_PAGE_SIZE;
2314 #endif
2315 #endif
2316
2317   if (bfd_get_start_address (abfd))
2318     {
2319       /*  A start address may have been added to the original file. In this
2320           case it will need an optional header to record it.  */
2321       abfd->flags |= EXEC_P;
2322     }
2323
2324   if (abfd->flags & EXEC_P)
2325     sofar += AOUTSZ;
2326 #ifdef RS6000COFF_C
2327   else if (xcoff_data (abfd)->full_aouthdr)
2328     sofar += AOUTSZ;
2329   else
2330     sofar += SMALL_AOUTSZ;
2331 #endif
2332
2333   sofar += abfd->section_count * SCNHSZ;
2334
2335 #ifdef RS6000COFF_C
2336   /* XCOFF handles overflows in the reloc and line number count fields
2337      by allocating a new section header to hold the correct counts.  */
2338   for (current = abfd->sections; current != NULL; current = current->next)
2339     if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2340       sofar += SCNHSZ;
2341 #endif
2342
2343   align_adjust = false;
2344   for (current = abfd->sections, count = 1;
2345        current != (asection *) NULL;
2346        current = current->next, ++count)
2347     {
2348 #ifdef COFF_IMAGE_WITH_PE
2349       /* The NT loader does not want empty section headers, so we omit
2350          them.  We don't actually remove the section from the BFD,
2351          although we probably should.  This matches code in
2352          coff_write_object_contents.  */
2353       if (current->_raw_size == 0)
2354         {
2355           current->target_index = -1;
2356           --count;
2357           continue;
2358         }
2359 #endif
2360
2361       current->target_index = count;
2362
2363       /* Only deal with sections which have contents */
2364       if (!(current->flags & SEC_HAS_CONTENTS))
2365         continue;
2366
2367       /* Align the sections in the file to the same boundary on
2368          which they are aligned in virtual memory.  I960 doesn't
2369          do this (FIXME) so we can stay in sync with Intel.  960
2370          doesn't yet page from files... */
2371 #ifdef ALIGN_SECTIONS_IN_FILE
2372       if ((abfd->flags & EXEC_P) != 0)
2373         {
2374           /* make sure this section is aligned on the right boundary - by
2375              padding the previous section up if necessary */
2376
2377           old_sofar = sofar;
2378           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2379           if (previous != (asection *) NULL)
2380             {
2381               previous->_raw_size += sofar - old_sofar;
2382             }
2383         }
2384
2385 #endif
2386
2387       /* In demand paged files the low order bits of the file offset
2388          must match the low order bits of the virtual address.  */
2389 #ifdef COFF_PAGE_SIZE
2390       if ((abfd->flags & D_PAGED) != 0
2391           && (current->flags & SEC_ALLOC) != 0)
2392         sofar += (current->vma - sofar) % page_size;
2393 #endif
2394       current->filepos = sofar;
2395
2396 #ifdef COFF_IMAGE_WITH_PE
2397       /* With PE we have to pad each section to be a multiple of its
2398          page size too, and remember both sizes.  */
2399
2400       if (coff_section_data (abfd, current) == NULL)
2401         {
2402           current->used_by_bfd =
2403             (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
2404           if (current->used_by_bfd == NULL)
2405             return false;
2406         }
2407       if (pei_section_data (abfd, current) == NULL)
2408         {
2409           coff_section_data (abfd, current)->tdata =
2410             (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
2411           if (coff_section_data (abfd, current)->tdata == NULL)
2412             return false;
2413         }
2414       if (pei_section_data (abfd, current)->virt_size == 0)
2415         pei_section_data (abfd, current)->virt_size = current->_raw_size;
2416
2417       current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2418 #endif
2419
2420       sofar += current->_raw_size;
2421
2422 #ifdef ALIGN_SECTIONS_IN_FILE
2423       /* make sure that this section is of the right size too */
2424       if ((abfd->flags & EXEC_P) == 0)
2425         {
2426           bfd_size_type old_size;
2427
2428           old_size = current->_raw_size;
2429           current->_raw_size = BFD_ALIGN (current->_raw_size,
2430                                           1 << current->alignment_power);
2431           align_adjust = current->_raw_size != old_size;
2432           sofar += current->_raw_size - old_size;
2433         }
2434       else
2435         {
2436           old_sofar = sofar;
2437           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2438           align_adjust = sofar != old_sofar;
2439           current->_raw_size += sofar - old_sofar;
2440         }
2441 #endif
2442
2443 #ifdef COFF_IMAGE_WITH_PE
2444       /* For PE we need to make sure we pad out to the aligned
2445          _raw_size, in case the caller only writes out data to the
2446          unaligned _raw_size.  */
2447       if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
2448         align_adjust = true;
2449 #endif
2450
2451 #ifdef _LIB
2452       /* Force .lib sections to start at zero.  The vma is then
2453          incremented in coff_set_section_contents.  This is right for
2454          SVR3.2.  */
2455       if (strcmp (current->name, _LIB) == 0)
2456         bfd_set_section_vma (abfd, current, 0);
2457 #endif
2458
2459       previous = current;
2460     }
2461
2462   /* It is now safe to write to the output file.  If we needed an
2463      alignment adjustment for the last section, then make sure that
2464      there is a byte at offset sofar.  If there are no symbols and no
2465      relocs, then nothing follows the last section.  If we don't force
2466      the last byte out, then the file may appear to be truncated.  */
2467   if (align_adjust)
2468     {
2469       bfd_byte b;
2470
2471       b = 0;
2472       if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
2473           || bfd_write (&b, 1, 1, abfd) != 1)
2474         return false;
2475     }
2476
2477   /* Make sure the relocations are aligned.  We don't need to make
2478      sure that this byte exists, because it will only matter if there
2479      really are relocs.  */
2480   sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
2481
2482   obj_relocbase (abfd) = sofar;
2483   abfd->output_has_begun = true;
2484
2485   return true;
2486 }
2487
2488 #if 0
2489
2490 /* This can never work, because it is called too late--after the
2491    section positions have been set.  I can't figure out what it is
2492    for, so I am going to disable it--Ian Taylor 20 March 1996.  */
2493
2494 /* If .file, .text, .data, .bss symbols are missing, add them.  */
2495 /* @@ Should we only be adding missing symbols, or overriding the aux
2496    values for existing section symbols?  */
2497 static boolean
2498 coff_add_missing_symbols (abfd)
2499      bfd *abfd;
2500 {
2501   unsigned int nsyms = bfd_get_symcount (abfd);
2502   asymbol **sympp = abfd->outsymbols;
2503   asymbol **sympp2;
2504   unsigned int i;
2505   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
2506
2507   for (i = 0; i < nsyms; i++)
2508     {
2509       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
2510       CONST char *name;
2511       if (csym)
2512         {
2513           /* only do this if there is a coff representation of the input
2514            symbol */
2515           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
2516             {
2517               need_file = 0;
2518               continue;
2519             }
2520           name = csym->symbol.name;
2521           if (!name)
2522             continue;
2523           if (!strcmp (name, _TEXT))
2524             need_text = 0;
2525 #ifdef APOLLO_M68
2526           else if (!strcmp (name, ".wtext"))
2527             need_text = 0;
2528 #endif
2529           else if (!strcmp (name, _DATA))
2530             need_data = 0;
2531           else if (!strcmp (name, _BSS))
2532             need_bss = 0;
2533         }
2534     }
2535   /* Now i == bfd_get_symcount (abfd).  */
2536   /* @@ For now, don't deal with .file symbol.  */
2537   need_file = 0;
2538
2539   if (!need_text && !need_data && !need_bss && !need_file)
2540     return true;
2541   nsyms += need_text + need_data + need_bss + need_file;
2542   sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
2543   if (!sympp2)
2544     return false;
2545   memcpy (sympp2, sympp, i * sizeof (asymbol *));
2546   if (need_file)
2547     {
2548       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
2549       abort ();
2550     }
2551   if (need_text)
2552     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
2553   if (need_data)
2554     sympp2[i++] = coff_section_symbol (abfd, _DATA);
2555   if (need_bss)
2556     sympp2[i++] = coff_section_symbol (abfd, _BSS);
2557   BFD_ASSERT (i == nsyms);
2558   bfd_set_symtab (abfd, sympp2, nsyms);
2559   return true;
2560 }
2561
2562 #endif /* 0 */
2563
2564 /* SUPPRESS 558 */
2565 /* SUPPRESS 529 */
2566 static boolean
2567 coff_write_object_contents (abfd)
2568      bfd * abfd;
2569 {
2570   asection *current;
2571   boolean hasrelocs = false;
2572   boolean haslinno = false;
2573   file_ptr scn_base;
2574   file_ptr reloc_base;
2575   file_ptr lineno_base;
2576   file_ptr sym_base;
2577   unsigned long reloc_size = 0;
2578   unsigned long lnno_size = 0;
2579   boolean long_section_names;
2580   asection *text_sec = NULL;
2581   asection *data_sec = NULL;
2582   asection *bss_sec = NULL;
2583   struct internal_filehdr internal_f;
2584   struct internal_aouthdr internal_a;
2585 #ifdef COFF_LONG_SECTION_NAMES
2586   size_t string_size = STRING_SIZE_SIZE;
2587 #endif
2588
2589   bfd_set_error (bfd_error_system_call);
2590
2591   /* Make a pass through the symbol table to count line number entries and
2592      put them into the correct asections */
2593
2594   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
2595
2596   if (abfd->output_has_begun == false)
2597     {
2598       if (! coff_compute_section_file_positions (abfd))
2599         return false;
2600     }
2601
2602   reloc_base = obj_relocbase (abfd);
2603
2604   /* Work out the size of the reloc and linno areas */
2605
2606   for (current = abfd->sections; current != NULL; current =
2607        current->next)
2608     reloc_size += current->reloc_count * RELSZ;
2609
2610   lineno_base = reloc_base + reloc_size;
2611   sym_base = lineno_base + lnno_size;
2612
2613   /* Indicate in each section->line_filepos its actual file address */
2614   for (current = abfd->sections; current != NULL; current =
2615        current->next)
2616     {
2617       if (current->lineno_count)
2618         {
2619           current->line_filepos = lineno_base;
2620           current->moving_line_filepos = lineno_base;
2621           lineno_base += current->lineno_count * LINESZ;
2622         }
2623       else
2624         {
2625           current->line_filepos = 0;
2626         }
2627       if (current->reloc_count)
2628         {
2629           current->rel_filepos = reloc_base;
2630           reloc_base += current->reloc_count * RELSZ;
2631         }
2632       else
2633         {
2634           current->rel_filepos = 0;
2635         }
2636     }
2637
2638   /* Write section headers to the file.  */
2639   internal_f.f_nscns = 0;
2640
2641   if ((abfd->flags & EXEC_P) != 0)
2642     scn_base = FILHSZ + AOUTSZ;
2643   else
2644     {
2645       scn_base = FILHSZ;
2646 #ifdef RS6000COFF_C
2647       if (xcoff_data (abfd)->full_aouthdr)
2648         scn_base += AOUTSZ;
2649       else
2650         scn_base += SMALL_AOUTSZ;
2651 #endif
2652     }
2653
2654   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
2655     return false;
2656
2657   long_section_names = false;
2658   for (current = abfd->sections;
2659        current != NULL;
2660        current = current->next)
2661     {
2662       struct internal_scnhdr section;
2663
2664 #ifdef COFF_WITH_PE
2665       /* If we've got a .reloc section, remember. */
2666
2667 #ifdef COFF_IMAGE_WITH_PE
2668       if (strcmp (current->name, ".reloc") == 0)
2669         {
2670           pe_data (abfd)->has_reloc_section = 1;
2671         }
2672 #endif
2673
2674 #endif
2675       internal_f.f_nscns++;
2676
2677       strncpy (section.s_name, current->name, SCNNMLEN);
2678
2679 #ifdef COFF_LONG_SECTION_NAMES
2680       /* Handle long section names as in PE.  This must be compatible
2681          with the code in coff_write_symbols.  */
2682       {
2683         size_t len;
2684
2685         len = strlen (current->name);
2686         if (len > SCNNMLEN)
2687           {
2688             memset (section.s_name, 0, SCNNMLEN);
2689             sprintf (section.s_name, "/%lu", (unsigned long) string_size);
2690             string_size += len + 1;
2691             long_section_names = true;
2692           }
2693       }
2694 #endif
2695
2696 #ifdef _LIB
2697       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
2698          Ian Taylor <[email protected]>.  */
2699       if (strcmp (current->name, _LIB) == 0)
2700         section.s_vaddr = 0;
2701       else
2702 #endif
2703       section.s_vaddr = current->vma;
2704       section.s_paddr = current->lma;
2705       section.s_size =  current->_raw_size;
2706
2707 #ifdef COFF_WITH_PE
2708       section.s_paddr = 0;
2709 #endif
2710 #ifdef COFF_IMAGE_WITH_PE
2711       /* Reminder: s_paddr holds the virtual size of the section.  */
2712       if (coff_section_data (abfd, current) != NULL
2713           && pei_section_data (abfd, current) != NULL)
2714         section.s_paddr = pei_section_data (abfd, current)->virt_size;
2715       else
2716         section.s_paddr = 0;
2717 #endif
2718
2719       /*
2720          If this section has no size or is unloadable then the scnptr
2721          will be 0 too
2722          */
2723       if (current->_raw_size == 0 ||
2724           (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2725         {
2726           section.s_scnptr = 0;
2727         }
2728       else
2729         {
2730           section.s_scnptr = current->filepos;
2731         }
2732       section.s_relptr = current->rel_filepos;
2733       section.s_lnnoptr = current->line_filepos;
2734       section.s_nreloc = current->reloc_count;
2735       section.s_nlnno = current->lineno_count;
2736       if (current->reloc_count != 0)
2737         hasrelocs = true;
2738       if (current->lineno_count != 0)
2739         haslinno = true;
2740
2741 #ifdef RS6000COFF_C
2742       /* Indicate the use of an XCOFF overflow section header.  */
2743       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2744         {
2745           section.s_nreloc = 0xffff;
2746           section.s_nlnno = 0xffff;
2747         }
2748 #endif
2749
2750       section.s_flags = sec_to_styp_flags (current->name, current->flags);
2751
2752       if (!strcmp (current->name, _TEXT))
2753         {
2754           text_sec = current;
2755         }
2756       else if (!strcmp (current->name, _DATA))
2757         {
2758           data_sec = current;
2759         }
2760       else if (!strcmp (current->name, _BSS))
2761         {
2762           bss_sec = current;
2763         }
2764
2765 #ifdef I960
2766       section.s_align = (current->alignment_power
2767                          ? 1 << current->alignment_power
2768                          : 0);
2769 #else
2770 #ifdef TIC80COFF
2771       section.s_flags |= (current->alignment_power & 0xF) << 8;
2772 #endif
2773 #endif
2774
2775 #ifdef COFF_IMAGE_WITH_PE
2776       /* suppress output of the sections if they are null.  ld includes
2777          the bss and data sections even if there is no size assigned
2778          to them.  NT loader doesn't like it if these section headers are
2779          included if the sections themselves are not needed */
2780       if (section.s_size == 0)
2781         internal_f.f_nscns--;
2782       else
2783 #endif
2784         {
2785           SCNHDR buff;
2786           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2787               || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2788             return false;
2789         }
2790
2791 #ifdef COFF_WITH_PE
2792       /* PE stores COMDAT section information in the symbol table.  If
2793          this section is supposed to have some COMDAT info, track down
2794          the symbol in the symbol table and modify it.  */
2795       if ((current->flags & SEC_LINK_ONCE) != 0)
2796         {
2797           unsigned int i, count;
2798           asymbol **psym;
2799           coff_symbol_type *csym = NULL;
2800           asymbol **psymsec;
2801
2802           psymsec = NULL;
2803           count = bfd_get_symcount (abfd);
2804           for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
2805             {
2806               if ((*psym)->section != current)
2807                 continue;
2808
2809               /* Remember the location of the first symbol in this
2810                  section.  */
2811               if (psymsec == NULL)
2812                 psymsec = psym;
2813
2814               /* See if this is the section symbol.  */
2815               if (strcmp ((*psym)->name, current->name) == 0)
2816                 {
2817                   csym = coff_symbol_from (abfd, *psym);
2818                   if (csym == NULL
2819                       || csym->native == NULL
2820                       || csym->native->u.syment.n_numaux < 1
2821                       || csym->native->u.syment.n_sclass != C_STAT
2822                       || csym->native->u.syment.n_type != T_NULL)
2823                     continue;
2824
2825                   /* Here *PSYM is the section symbol for CURRENT.  */
2826
2827                   break;
2828                 }
2829             }
2830
2831           /* Did we find it?
2832              Note that we might not if we're converting the file from
2833              some other object file format.  */
2834           if (i < count)
2835             {
2836               combined_entry_type *aux;
2837
2838               /* We don't touch the x_checksum field.  The
2839                  x_associated field is not currently supported.  */
2840
2841               aux = csym->native + 1;
2842               switch (current->flags & SEC_LINK_DUPLICATES)
2843                 {
2844                 case SEC_LINK_DUPLICATES_DISCARD:
2845                   aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
2846                   break;
2847
2848                 case SEC_LINK_DUPLICATES_ONE_ONLY:
2849                   aux->u.auxent.x_scn.x_comdat =
2850                     IMAGE_COMDAT_SELECT_NODUPLICATES;
2851                   break;
2852
2853                 case SEC_LINK_DUPLICATES_SAME_SIZE:
2854                   aux->u.auxent.x_scn.x_comdat =
2855                     IMAGE_COMDAT_SELECT_SAME_SIZE;
2856                   break;
2857
2858                 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
2859                   aux->u.auxent.x_scn.x_comdat =
2860                     IMAGE_COMDAT_SELECT_EXACT_MATCH;
2861                   break;
2862                 }
2863
2864               /* The COMDAT symbol must be the first symbol from this
2865                  section in the symbol table.  In order to make this
2866                  work, we move the COMDAT symbol before the first
2867                  symbol we found in the search above.  It's OK to
2868                  rearrange the symbol table at this point, because
2869                  coff_renumber_symbols is going to rearrange it
2870                  further and fix up all the aux entries.  */
2871               if (psym != psymsec)
2872                 {
2873                   asymbol *hold;
2874                   asymbol **pcopy;
2875
2876                   hold = *psym;
2877                   for (pcopy = psym; pcopy > psymsec; pcopy--)
2878                     pcopy[0] = pcopy[-1];
2879                   *psymsec = hold;
2880                 }
2881             }
2882         }
2883 #endif /* COFF_WITH_PE */
2884     }
2885
2886 #ifdef RS6000COFF_C
2887   /* XCOFF handles overflows in the reloc and line number count fields
2888      by creating a new section header to hold the correct values.  */
2889   for (current = abfd->sections; current != NULL; current = current->next)
2890     {
2891       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2892         {
2893           struct internal_scnhdr scnhdr;
2894           SCNHDR buff;
2895
2896           internal_f.f_nscns++;
2897           strncpy (&(scnhdr.s_name[0]), current->name, 8);
2898           scnhdr.s_paddr = current->reloc_count;
2899           scnhdr.s_vaddr = current->lineno_count;
2900           scnhdr.s_size = 0;
2901           scnhdr.s_scnptr = 0;
2902           scnhdr.s_relptr = current->rel_filepos;
2903           scnhdr.s_lnnoptr = current->line_filepos;
2904           scnhdr.s_nreloc = current->target_index;
2905           scnhdr.s_nlnno = current->target_index;
2906           scnhdr.s_flags = STYP_OVRFLO;
2907           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
2908               || bfd_write ((PTR) &buff, 1, SCNHSZ, abfd) != SCNHSZ)
2909             return false;
2910         }
2911     }
2912 #endif
2913
2914   /* OK, now set up the filehdr... */
2915
2916   /* Don't include the internal abs section in the section count */
2917
2918   /*
2919      We will NOT put a fucking timestamp in the header here. Every time you
2920      put it back, I will come in and take it out again.  I'm sorry.  This
2921      field does not belong here.  We fill it with a 0 so it compares the
2922      same but is not a reasonable time. -- [email protected]
2923      */
2924   internal_f.f_timdat = 0;
2925
2926   internal_f.f_flags = 0;
2927
2928   if (abfd->flags & EXEC_P)
2929     internal_f.f_opthdr = AOUTSZ;
2930   else
2931     {
2932       internal_f.f_opthdr = 0;
2933 #ifdef RS6000COFF_C
2934       if (xcoff_data (abfd)->full_aouthdr)
2935         internal_f.f_opthdr = AOUTSZ;
2936       else
2937         internal_f.f_opthdr = SMALL_AOUTSZ;
2938 #endif
2939     }
2940
2941   if (!hasrelocs)
2942     internal_f.f_flags |= F_RELFLG;
2943   if (!haslinno)
2944     internal_f.f_flags |= F_LNNO;
2945   if (abfd->flags & EXEC_P)
2946     internal_f.f_flags |= F_EXEC;
2947
2948   /* FIXME: this is wrong for PPC_PE! */
2949   if (bfd_little_endian (abfd))
2950     internal_f.f_flags |= F_AR32WR;
2951   else
2952     internal_f.f_flags |= F_AR32W;
2953
2954 #ifdef TIC80_TARGET_ID
2955   internal_f.f_target_id = TIC80_TARGET_ID;
2956 #endif
2957
2958   /*
2959      FIXME, should do something about the other byte orders and
2960      architectures.
2961      */
2962
2963 #ifdef RS6000COFF_C
2964   if ((abfd->flags & DYNAMIC) != 0)
2965     internal_f.f_flags |= F_SHROBJ;
2966   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
2967     internal_f.f_flags |= F_DYNLOAD;
2968 #endif
2969
2970   memset (&internal_a, 0, sizeof internal_a);
2971
2972   /* Set up architecture-dependent stuff */
2973
2974   {
2975     unsigned int magic = 0;
2976     unsigned short flags = 0;
2977     coff_set_flags (abfd, &magic, &flags);
2978     internal_f.f_magic = magic;
2979     internal_f.f_flags |= flags;
2980     /* ...and the "opt"hdr... */
2981
2982 #ifdef A29K
2983 #ifdef ULTRA3                   /* NYU's machine */
2984     /* FIXME: This is a bogus check.  I really want to see if there
2985      * is a .shbss or a .shdata section, if so then set the magic
2986      * number to indicate a shared data executable.
2987      */
2988     if (internal_f.f_nscns >= 7)
2989       internal_a.magic = SHMAGIC; /* Shared magic */
2990     else
2991 #endif /* ULTRA3 */
2992       internal_a.magic = NMAGIC; /* Assume separate i/d */
2993 #define __A_MAGIC_SET__
2994 #endif /* A29K */
2995 #ifdef TIC80COFF
2996     internal_a.magic = TIC80_ARCH_MAGIC;
2997 #define __A_MAGIC_SET__
2998 #endif /* TIC80 */
2999 #ifdef I860
3000     /* FIXME: What are the a.out magic numbers for the i860?  */
3001     internal_a.magic = 0;
3002 #define __A_MAGIC_SET__
3003 #endif /* I860 */
3004 #ifdef I960
3005     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3006 #define __A_MAGIC_SET__
3007 #endif /* I960 */
3008 #if M88
3009 #define __A_MAGIC_SET__
3010     internal_a.magic = PAGEMAGICBCS;
3011 #endif /* M88 */
3012
3013 #if APOLLO_M68
3014 #define __A_MAGIC_SET__
3015     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3016 #endif
3017
3018 #if defined(M68) || defined(WE32K) || defined(M68K)
3019 #define __A_MAGIC_SET__
3020 #if defined(LYNXOS)
3021     internal_a.magic = LYNXCOFFMAGIC;
3022 #else
3023 #if defined(TARG_AUX)
3024     internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3025                         abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3026                         PAGEMAGICEXECSWAPPED);
3027 #else
3028 #if defined (PAGEMAGICPEXECPAGED)
3029     internal_a.magic = PAGEMAGICPEXECPAGED;
3030 #endif
3031 #endif /* TARG_AUX */
3032 #endif /* LYNXOS */
3033 #endif /* M68 || WE32K || M68K */
3034
3035 #if defined(ARM)
3036 #define __A_MAGIC_SET__
3037     internal_a.magic = ZMAGIC;
3038 #endif
3039
3040 #if defined(PPC_PE)
3041 #define __A_MAGIC_SET__
3042     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3043 #endif
3044
3045 #if defined MCORE_PE
3046 #define __A_MAGIC_SET__
3047     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3048 #endif
3049
3050 #if defined(I386)
3051 #define __A_MAGIC_SET__
3052 #if defined(LYNXOS)
3053     internal_a.magic = LYNXCOFFMAGIC;
3054 #else  /* LYNXOS */
3055     internal_a.magic = ZMAGIC;
3056 #endif /* LYNXOS */
3057 #endif /* I386 */
3058
3059 #if defined(SPARC)
3060 #define __A_MAGIC_SET__
3061 #if defined(LYNXOS)
3062     internal_a.magic = LYNXCOFFMAGIC;
3063 #endif /* LYNXOS */
3064 #endif /* SPARC */
3065
3066 #ifdef RS6000COFF_C
3067 #define __A_MAGIC_SET__
3068     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3069     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3070     RS6K_AOUTHDR_OMAGIC;
3071 #endif
3072
3073 #ifndef __A_MAGIC_SET__
3074 #include "Your aouthdr magic number is not being set!"
3075 #else
3076 #undef __A_MAGIC_SET__
3077 #endif
3078   }
3079
3080   /* FIXME: Does anybody ever set this to another value?  */
3081   internal_a.vstamp = 0;
3082
3083   /* Now should write relocs, strings, syms */
3084   obj_sym_filepos (abfd) = sym_base;
3085
3086   if (bfd_get_symcount (abfd) != 0)
3087     {
3088       int firstundef;
3089 #if 0
3090       if (!coff_add_missing_symbols (abfd))
3091         return false;
3092 #endif
3093       if (!coff_renumber_symbols (abfd, &firstundef))
3094         return false;
3095       coff_mangle_symbols (abfd);
3096       if (! coff_write_symbols (abfd))
3097         return false;
3098       if (! coff_write_linenumbers (abfd))
3099         return false;
3100       if (! coff_write_relocs (abfd, firstundef))
3101         return false;
3102     }
3103 #ifdef COFF_LONG_SECTION_NAMES
3104   else if (long_section_names)
3105     {
3106       /* If we have long section names we have to write out the string
3107          table even if there are no symbols.  */
3108       if (! coff_write_symbols (abfd))
3109         return false;
3110     }
3111 #endif
3112 #ifdef COFF_IMAGE_WITH_PE
3113 #ifdef PPC_PE
3114   else if ((abfd->flags & EXEC_P) != 0)
3115     {
3116       bfd_byte b;
3117
3118       /* PowerPC PE appears to require that all executable files be
3119          rounded up to the page size.  */
3120       b = 0;
3121       if (bfd_seek (abfd,
3122                     BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3123                     SEEK_SET) != 0
3124           || bfd_write (&b, 1, 1, abfd) != 1)
3125         return false;
3126     }
3127 #endif
3128 #endif
3129
3130   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3131      backend linker, and obj_raw_syment_count is not valid until after
3132      coff_write_symbols is called.  */
3133   if (obj_raw_syment_count (abfd) != 0)
3134     {
3135       internal_f.f_symptr = sym_base;
3136 #ifdef RS6000COFF_C
3137       /* AIX appears to require that F_RELFLG not be set if there are
3138          local symbols but no relocations.  */
3139       internal_f.f_flags &=~ F_RELFLG;
3140 #endif
3141     }
3142   else
3143     {
3144       if (long_section_names)
3145         internal_f.f_symptr = sym_base;
3146       else
3147         internal_f.f_symptr = 0;
3148       internal_f.f_flags |= F_LSYMS;
3149     }
3150
3151   if (text_sec)
3152     {
3153       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3154       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3155     }
3156   if (data_sec)
3157     {
3158       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3159       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3160     }
3161   if (bss_sec)
3162     {
3163       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3164       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3165         internal_a.data_start = bss_sec->vma;
3166     }
3167
3168   internal_a.entry = bfd_get_start_address (abfd);
3169   internal_f.f_nsyms = obj_raw_syment_count (abfd);
3170
3171 #ifdef RS6000COFF_C
3172   if (xcoff_data (abfd)->full_aouthdr)
3173     {
3174       bfd_vma toc;
3175       asection *loader_sec;
3176
3177       internal_a.vstamp = 1;
3178
3179       internal_a.o_snentry = xcoff_data (abfd)->snentry;
3180       if (internal_a.o_snentry == 0)
3181         internal_a.entry = (bfd_vma) -1;
3182
3183       if (text_sec != NULL)
3184         {
3185           internal_a.o_sntext = text_sec->target_index;
3186           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3187         }
3188       else
3189         {
3190           internal_a.o_sntext = 0;
3191           internal_a.o_algntext = 0;
3192         }
3193       if (data_sec != NULL)
3194         {
3195           internal_a.o_sndata = data_sec->target_index;
3196           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3197         }
3198       else
3199         {
3200           internal_a.o_sndata = 0;
3201           internal_a.o_algndata = 0;
3202         }
3203       loader_sec = bfd_get_section_by_name (abfd, ".loader");
3204       if (loader_sec != NULL)
3205         internal_a.o_snloader = loader_sec->target_index;
3206       else
3207         internal_a.o_snloader = 0;
3208       if (bss_sec != NULL)
3209         internal_a.o_snbss = bss_sec->target_index;
3210       else
3211         internal_a.o_snbss = 0;
3212
3213       toc = xcoff_data (abfd)->toc;
3214       internal_a.o_toc = toc;
3215       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3216
3217       internal_a.o_modtype = xcoff_data (abfd)->modtype;
3218       if (xcoff_data (abfd)->cputype != -1)
3219         internal_a.o_cputype = xcoff_data (abfd)->cputype;
3220       else
3221         {
3222           switch (bfd_get_arch (abfd))
3223             {
3224             case bfd_arch_rs6000:
3225               internal_a.o_cputype = 4;
3226               break;
3227             case bfd_arch_powerpc:
3228               if (bfd_get_mach (abfd) == 0)
3229                 internal_a.o_cputype = 3;
3230               else
3231                 internal_a.o_cputype = 1;
3232               break;
3233             default:
3234               abort ();
3235             }
3236         }
3237       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3238       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3239     }
3240 #endif
3241
3242   /* now write them */
3243   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3244     return false;
3245   {
3246     char buff[FILHSZ];
3247     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
3248     if (bfd_write ((PTR) buff, 1, FILHSZ, abfd) != FILHSZ)
3249       return false;
3250   }
3251   if (abfd->flags & EXEC_P)
3252     {
3253       /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3254          include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3255       char buff[AOUTSZ];
3256       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
3257       if (bfd_write ((PTR) buff, 1, AOUTSZ, abfd) != AOUTSZ)
3258         return false;
3259     }
3260 #ifdef RS6000COFF_C
3261   else
3262     {
3263       AOUTHDR buff;
3264       size_t size;
3265
3266       /* XCOFF seems to always write at least a small a.out header.  */
3267       coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
3268       if (xcoff_data (abfd)->full_aouthdr)
3269         size = AOUTSZ;
3270       else
3271         size = SMALL_AOUTSZ;
3272       if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
3273         return false;
3274     }
3275 #endif
3276
3277   return true;
3278 }
3279
3280 static boolean
3281 coff_set_section_contents (abfd, section, location, offset, count)
3282      bfd * abfd;
3283      sec_ptr section;
3284      PTR location;
3285      file_ptr offset;
3286      bfd_size_type count;
3287 {
3288   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
3289     {
3290       if (! coff_compute_section_file_positions (abfd))
3291         return false;
3292     }
3293
3294 #if defined(_LIB) && !defined(TARG_AUX)
3295
3296    /* The physical address field of a .lib section is used to hold the
3297       number of shared libraries in the section.  This code counts the
3298       number of sections being written, and increments the lma field
3299       with the number.
3300
3301       I have found no documentation on the contents of this section.
3302       Experimentation indicates that the section contains zero or more
3303       records, each of which has the following structure:
3304
3305       - a (four byte) word holding the length of this record, in words,
3306       - a word that always seems to be set to "2",
3307       - the path to a shared library, null-terminated and then padded
3308         to a whole word boundary.
3309
3310       bfd_assert calls have been added to alert if an attempt is made
3311       to write a section which doesn't follow these assumptions.  The
3312       code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3313       <[email protected]> (Thanks!).
3314
3315       Gvran Uddeborg <[email protected]> */
3316
3317     if (strcmp (section->name, _LIB) == 0)
3318       {
3319         bfd_byte *rec, *recend;
3320
3321         rec = (bfd_byte *) location;
3322         recend = rec + count;
3323         while (rec < recend)
3324           {
3325             ++section->lma;
3326             rec += bfd_get_32 (abfd, rec) * 4;
3327           }
3328
3329         BFD_ASSERT (rec == recend);
3330       }
3331
3332 #endif
3333
3334   /* Don't write out bss sections - one way to do this is to
3335        see if the filepos has not been set. */
3336   if (section->filepos == 0)
3337     return true;
3338
3339   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
3340     return false;
3341
3342   if (count != 0)
3343     {
3344       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3345     }
3346   return true;
3347 }
3348 #if 0
3349 static boolean
3350 coff_close_and_cleanup (abfd)
3351      bfd *abfd;
3352 {
3353   if (!bfd_read_p (abfd))
3354     switch (abfd->format)
3355       {
3356       case bfd_archive:
3357         if (!_bfd_write_archive_contents (abfd))
3358           return false;
3359         break;
3360       case bfd_object:
3361         if (!coff_write_object_contents (abfd))
3362           return false;
3363         break;
3364       default:
3365         bfd_set_error (bfd_error_invalid_operation);
3366         return false;
3367       }
3368
3369   /* We depend on bfd_close to free all the memory on the objalloc.  */
3370   return true;
3371 }
3372
3373 #endif
3374
3375 static PTR
3376 buy_and_read (abfd, where, seek_direction, size)
3377      bfd *abfd;
3378      file_ptr where;
3379      int seek_direction;
3380      size_t size;
3381 {
3382   PTR area = (PTR) bfd_alloc (abfd, size);
3383   if (!area)
3384     return (NULL);
3385   if (bfd_seek (abfd, where, seek_direction) != 0
3386       || bfd_read (area, 1, size, abfd) != size)
3387     return (NULL);
3388   return (area);
3389 }                               /* buy_and_read() */
3390
3391 /*
3392 SUBSUBSECTION
3393         Reading linenumbers
3394
3395         Creating the linenumber table is done by reading in the entire
3396         coff linenumber table, and creating another table for internal use.
3397
3398         A coff linenumber table is structured so that each function
3399         is marked as having a line number of 0. Each line within the
3400         function is an offset from the first line in the function. The
3401         base of the line number information for the table is stored in
3402         the symbol associated with the function.
3403
3404         The information is copied from the external to the internal
3405         table, and each symbol which marks a function is marked by
3406         pointing its...
3407
3408         How does this work ?
3409
3410 */
3411
3412 static boolean
3413 coff_slurp_line_table (abfd, asect)
3414      bfd *abfd;
3415      asection *asect;
3416 {
3417   LINENO *native_lineno;
3418   alent *lineno_cache;
3419
3420   BFD_ASSERT (asect->lineno == (alent *) NULL);
3421
3422   native_lineno = (LINENO *) buy_and_read (abfd,
3423                                            asect->line_filepos,
3424                                            SEEK_SET,
3425                                            (size_t) (LINESZ *
3426                                                      asect->lineno_count));
3427   lineno_cache =
3428     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
3429   if (lineno_cache == NULL)
3430     return false;
3431   else
3432     {
3433       unsigned int counter = 0;
3434       alent *cache_ptr = lineno_cache;
3435       LINENO *src = native_lineno;
3436
3437       while (counter < asect->lineno_count)
3438         {
3439           struct internal_lineno dst;
3440           coff_swap_lineno_in (abfd, src, &dst);
3441           cache_ptr->line_number = dst.l_lnno;
3442
3443           if (cache_ptr->line_number == 0)
3444             {
3445               boolean warned;
3446               long symndx;
3447               coff_symbol_type *sym;
3448
3449               warned = false;
3450               symndx = dst.l_addr.l_symndx;
3451               if (symndx < 0
3452                   || (unsigned long) symndx >= obj_raw_syment_count (abfd))
3453                 {
3454                   (*_bfd_error_handler)
3455                     (_("%s: warning: illegal symbol index %ld in line numbers"),
3456                      bfd_get_filename (abfd), dst.l_addr.l_symndx);
3457                   symndx = 0;
3458                   warned = true;
3459                 }
3460               /* FIXME: We should not be casting between ints and
3461                  pointers like this.  */
3462               sym = ((coff_symbol_type *)
3463                      ((symndx + obj_raw_syments (abfd))
3464                       ->u.syment._n._n_n._n_zeroes));
3465               cache_ptr->u.sym = (asymbol *) sym;
3466               if (sym->lineno != NULL && ! warned)
3467                 {
3468                   (*_bfd_error_handler)
3469                     (_("%s: warning: duplicate line number information for `%s'"),
3470                      bfd_get_filename (abfd),
3471                      bfd_asymbol_name (&sym->symbol));
3472                 }
3473               sym->lineno = cache_ptr;
3474             }
3475           else
3476             {
3477               cache_ptr->u.offset = dst.l_addr.l_paddr
3478                 - bfd_section_vma (abfd, asect);
3479             }                   /* If no linenumber expect a symbol index */
3480
3481           cache_ptr++;
3482           src++;
3483           counter++;
3484         }
3485       cache_ptr->line_number = 0;
3486
3487     }
3488   asect->lineno = lineno_cache;
3489   /* FIXME, free native_lineno here, or use alloca or something. */
3490   return true;
3491 }
3492
3493 static boolean
3494 coff_slurp_symbol_table (abfd)
3495      bfd * abfd;
3496 {
3497   combined_entry_type *native_symbols;
3498   coff_symbol_type *cached_area;
3499   unsigned int *table_ptr;
3500
3501   unsigned int number_of_symbols = 0;
3502
3503   if (obj_symbols (abfd))
3504     return true;
3505
3506   /* Read in the symbol table */
3507   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
3508     {
3509       return (false);
3510     }                           /* on error */
3511
3512   /* Allocate enough room for all the symbols in cached form */
3513   cached_area = ((coff_symbol_type *)
3514                  bfd_alloc (abfd,
3515                             (obj_raw_syment_count (abfd)
3516                              * sizeof (coff_symbol_type))));
3517
3518   if (cached_area == NULL)
3519     return false;
3520   table_ptr = ((unsigned int *)
3521                bfd_alloc (abfd,
3522                           (obj_raw_syment_count (abfd)
3523                            * sizeof (unsigned int))));
3524
3525   if (table_ptr == NULL)
3526     return false;
3527   else
3528     {
3529       coff_symbol_type *dst = cached_area;
3530       unsigned int last_native_index = obj_raw_syment_count (abfd);
3531       unsigned int this_index = 0;
3532       while (this_index < last_native_index)
3533         {
3534           combined_entry_type *src = native_symbols + this_index;
3535           table_ptr[this_index] = number_of_symbols;
3536           dst->symbol.the_bfd = abfd;
3537
3538           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
3539           /* We use the native name field to point to the cached field.  */
3540           src->u.syment._n._n_n._n_zeroes = (long) dst;
3541           dst->symbol.section = coff_section_from_bfd_index (abfd,
3542                                                      src->u.syment.n_scnum);
3543           dst->symbol.flags = 0;
3544           dst->done_lineno = false;
3545
3546           switch (src->u.syment.n_sclass)
3547             {
3548 #ifdef I960
3549             case C_LEAFEXT:
3550 #if 0
3551               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
3552               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3553               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3554 #endif
3555               /* Fall through to next case */
3556
3557 #endif
3558
3559             case C_EXT:
3560             case C_WEAKEXT:
3561 #if defined ARM
3562             case C_THUMBEXT:
3563             case C_THUMBEXTFUNC:
3564 #endif
3565 #ifdef RS6000COFF_C
3566             case C_HIDEXT:
3567 #endif
3568 #ifdef C_SYSTEM
3569             case C_SYSTEM:      /* System Wide variable */
3570 #endif
3571 #ifdef COFF_WITH_PE
3572             /* PE uses storage class 0x68 to denote a section symbol */
3573             case C_SECTION:
3574             /* PE uses storage class 0x69 for a weak external symbol.  */
3575             case C_NT_WEAK:
3576 #endif
3577               if ((src->u.syment.n_scnum) == 0)
3578                 {
3579                   if ((src->u.syment.n_value) == 0)
3580                     {
3581                       dst->symbol.section = bfd_und_section_ptr;
3582                       dst->symbol.value = 0;
3583                     }
3584                   else
3585                     {
3586                       dst->symbol.section = bfd_com_section_ptr;
3587                       dst->symbol.value = (src->u.syment.n_value);
3588                     }
3589                 }
3590               else
3591                 {
3592                   /* Base the value as an index from the base of the
3593                      section */
3594
3595                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3596
3597 #if defined COFF_WITH_PE
3598                   /* PE sets the symbol to a value relative to the
3599                      start of the section.  */
3600                   dst->symbol.value = src->u.syment.n_value;
3601 #else
3602                   dst->symbol.value = (src->u.syment.n_value
3603                                        - dst->symbol.section->vma);
3604 #endif
3605
3606                   if (ISFCN ((src->u.syment.n_type)))
3607                     {
3608                       /* A function ext does not go at the end of a
3609                          file.  */
3610                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3611                     }
3612                 }
3613
3614 #ifdef RS6000COFF_C
3615               /* A C_HIDEXT symbol is not global.  */
3616               if (src->u.syment.n_sclass == C_HIDEXT)
3617                 dst->symbol.flags = BSF_LOCAL;
3618               /* A symbol with a csect entry should not go at the end.  */
3619               if (src->u.syment.n_numaux > 0)
3620                 dst->symbol.flags |= BSF_NOT_AT_END;
3621 #endif
3622
3623 #ifdef COFF_WITH_PE
3624               if (src->u.syment.n_sclass == C_NT_WEAK)
3625                 dst->symbol.flags = BSF_WEAK;
3626               if (src->u.syment.n_sclass == C_SECTION
3627                   && src->u.syment.n_scnum > 0)
3628                 {
3629                   dst->symbol.flags = BSF_LOCAL;
3630                 }
3631 #endif
3632
3633               if (src->u.syment.n_sclass == C_WEAKEXT)
3634                 dst->symbol.flags = BSF_WEAK;
3635
3636               break;
3637
3638             case C_STAT:        /* static                        */
3639 #ifdef I960
3640             case C_LEAFSTAT:    /* static leaf procedure        */
3641 #endif
3642 #if defined ARM
3643             case C_THUMBSTAT:   /* Thumb static                  */
3644             case C_THUMBLABEL:  /* Thumb label                   */
3645             case C_THUMBSTATFUNC:/* Thumb static function        */
3646 #endif
3647             case C_LABEL:       /* label                         */
3648               if (src->u.syment.n_scnum == -2)
3649                 dst->symbol.flags = BSF_DEBUGGING;
3650               else
3651                 dst->symbol.flags = BSF_LOCAL;
3652
3653               /* Base the value as an index from the base of the
3654                  section, if there is one.  */
3655               if (dst->symbol.section)
3656                 {
3657 #if defined COFF_WITH_PE
3658                   /* PE sets the symbol to a value relative to the
3659                      start of the section.  */
3660                   dst->symbol.value = src->u.syment.n_value;
3661 #else
3662                   dst->symbol.value = (src->u.syment.n_value
3663                                        - dst->symbol.section->vma);
3664 #endif
3665                 }
3666               else
3667                 dst->symbol.value = src->u.syment.n_value;
3668               break;
3669
3670             case C_MOS: /* member of structure   */
3671             case C_EOS: /* end of structure              */
3672 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
3673 #ifdef C_GLBLREG
3674             case C_GLBLREG:     /* A29k-specific storage class */
3675 #endif
3676 #endif
3677             case C_REGPARM:     /* register parameter            */
3678             case C_REG: /* register variable             */
3679 #ifndef TIC80COFF
3680 #ifdef C_AUTOARG
3681             case C_AUTOARG:     /* 960-specific storage class */
3682 #endif
3683 #endif
3684             case C_TPDEF:       /* type definition               */
3685             case C_ARG:
3686             case C_AUTO:        /* automatic variable */
3687             case C_FIELD:       /* bit field */
3688             case C_ENTAG:       /* enumeration tag               */
3689             case C_MOE: /* member of enumeration         */
3690             case C_MOU: /* member of union               */
3691             case C_UNTAG:       /* union tag                     */
3692               dst->symbol.flags = BSF_DEBUGGING;
3693               dst->symbol.value = (src->u.syment.n_value);
3694               break;
3695
3696             case C_FILE:        /* file name                     */
3697             case C_STRTAG:      /* structure tag                 */
3698 #ifdef RS6000COFF_C
3699             case C_GSYM:
3700             case C_LSYM:
3701             case C_PSYM:
3702             case C_RSYM:
3703             case C_RPSYM:
3704             case C_STSYM:
3705             case C_BCOMM:
3706             case C_ECOMM:
3707             case C_DECL:
3708             case C_ENTRY:
3709             case C_FUN:
3710             case C_ESTAT:
3711 #endif
3712               dst->symbol.flags = BSF_DEBUGGING;
3713               dst->symbol.value = (src->u.syment.n_value);
3714               break;
3715
3716 #ifdef RS6000COFF_C
3717             case C_BINCL:       /* beginning of include file     */
3718             case C_EINCL:       /* ending of include file        */
3719               /* The value is actually a pointer into the line numbers
3720                  of the file.  We locate the line number entry, and
3721                  set the section to the section which contains it, and
3722                  the value to the index in that section.  */
3723               {
3724                 asection *sec;
3725
3726                 dst->symbol.flags = BSF_DEBUGGING;
3727                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3728                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
3729                       && ((file_ptr) (sec->line_filepos
3730                                       + sec->lineno_count * LINESZ)
3731                           > (file_ptr) src->u.syment.n_value))
3732                     break;
3733                 if (sec == NULL)
3734                   dst->symbol.value = 0;
3735                 else
3736                   {
3737                     dst->symbol.section = sec;
3738                     dst->symbol.value = ((src->u.syment.n_value
3739                                           - sec->line_filepos)
3740                                          / LINESZ);
3741                     src->fix_line = 1;
3742                   }
3743               }
3744               break;
3745
3746             case C_BSTAT:
3747               dst->symbol.flags = BSF_DEBUGGING;
3748
3749               /* The value is actually a symbol index.  Save a pointer
3750                  to the symbol instead of the index.  FIXME: This
3751                  should use a union.  */
3752               src->u.syment.n_value =
3753                 (long) (native_symbols + src->u.syment.n_value);
3754               dst->symbol.value = src->u.syment.n_value;
3755               src->fix_value = 1;
3756               break;
3757 #endif
3758
3759             case C_BLOCK:       /* ".bb" or ".eb"                */
3760             case C_FCN:         /* ".bf" or ".ef"                */
3761             case C_EFCN:        /* physical end of function      */
3762               dst->symbol.flags = BSF_LOCAL;
3763 #if defined COFF_WITH_PE
3764               /* PE sets the symbol to a value relative to the start
3765                  of the section.  */
3766               dst->symbol.value = src->u.syment.n_value;
3767 #else
3768               /* Base the value as an index from the base of the
3769                  section.  */
3770               dst->symbol.value = (src->u.syment.n_value
3771                                    - dst->symbol.section->vma);
3772 #endif
3773               break;
3774
3775             case C_NULL:
3776             case C_EXTDEF:      /* external definition           */
3777             case C_ULABEL:      /* undefined label               */
3778             case C_USTATIC:     /* undefined static              */
3779 #ifndef COFF_WITH_PE
3780             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
3781                class to represent a section symbol */
3782             case C_LINE:        /* line # reformatted as symbol table entry */
3783               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
3784             case C_ALIAS:       /* duplicate tag                 */
3785 #endif
3786               /* New storage classes for TIc80 */
3787 #ifdef TIC80COFF
3788             case C_UEXT:        /* Tentative external definition */
3789 #endif
3790             case C_STATLAB:     /* Static load time label */
3791             case C_EXTLAB:      /* External load time label */
3792             case C_HIDDEN:      /* ext symbol in dmert public lib */
3793             default:
3794               (*_bfd_error_handler)
3795                 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
3796                  bfd_get_filename (abfd), src->u.syment.n_sclass,
3797                  dst->symbol.section->name, dst->symbol.name);
3798               dst->symbol.flags = BSF_DEBUGGING;
3799               dst->symbol.value = (src->u.syment.n_value);
3800               break;
3801             }
3802
3803 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
3804
3805           dst->native = src;
3806
3807           dst->symbol.udata.i = 0;
3808           dst->lineno = (alent *) NULL;
3809           this_index += (src->u.syment.n_numaux) + 1;
3810           dst++;
3811           number_of_symbols++;
3812         }                       /* walk the native symtab */
3813     }                           /* bfdize the native symtab */
3814
3815   obj_symbols (abfd) = cached_area;
3816   obj_raw_syments (abfd) = native_symbols;
3817
3818   bfd_get_symcount (abfd) = number_of_symbols;
3819   obj_convert (abfd) = table_ptr;
3820   /* Slurp the line tables for each section too */
3821   {
3822     asection *p;
3823     p = abfd->sections;
3824     while (p)
3825       {
3826         coff_slurp_line_table (abfd, p);
3827         p = p->next;
3828       }
3829   }
3830   return true;
3831 }                               /* coff_slurp_symbol_table() */
3832
3833 /* Check whether a symbol is globally visible.  This is used by the
3834    COFF backend linker code in cofflink.c, since a couple of targets
3835    have globally visible symbols which are not class C_EXT.  This
3836    function need not handle the case of n_class == C_EXT.  */
3837
3838 #undef OTHER_GLOBAL_CLASS
3839
3840 #ifdef I960
3841 #define OTHER_GLOBAL_CLASS C_LEAFEXT
3842 #endif
3843
3844 #ifdef COFFARM
3845 #define OTHER_GLOBAL_CLASS C_THUMBEXT || syment->n_sclass == C_THUMBEXTFUNC
3846 #else
3847 #ifdef COFF_WITH_PE
3848 #define OTHER_GLOBAL_CLASS C_SECTION
3849 #endif
3850 #endif
3851
3852 #ifdef OTHER_GLOBAL_CLASS
3853
3854 static boolean coff_sym_is_global PARAMS ((bfd *, struct internal_syment *));
3855
3856 static boolean
3857 coff_sym_is_global (abfd, syment)
3858      bfd * abfd ATTRIBUTE_UNUSED;
3859      struct internal_syment * syment;
3860 {
3861   return (syment->n_sclass == OTHER_GLOBAL_CLASS);
3862 }
3863
3864 #undef OTHER_GLOBAL_CLASS
3865
3866 #else /* ! defined (OTHER_GLOBAL_CLASS) */
3867
3868 /* sym_is_global should not be defined if it has nothing to do.  */
3869
3870 #define coff_sym_is_global 0
3871
3872 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
3873
3874 /*
3875 SUBSUBSECTION
3876         Reading relocations
3877
3878         Coff relocations are easily transformed into the internal BFD form
3879         (@code{arelent}).
3880
3881         Reading a coff relocation table is done in the following stages:
3882
3883         o Read the entire coff relocation table into memory.
3884
3885         o Process each relocation in turn; first swap it from the
3886         external to the internal form.
3887
3888         o Turn the symbol referenced in the relocation's symbol index
3889         into a pointer into the canonical symbol table.
3890         This table is the same as the one returned by a call to
3891         @code{bfd_canonicalize_symtab}. The back end will call that
3892         routine and save the result if a canonicalization hasn't been done.
3893
3894         o The reloc index is turned into a pointer to a howto
3895         structure, in a back end specific way. For instance, the 386
3896         and 960 use the @code{r_type} to directly produce an index
3897         into a howto table vector; the 88k subtracts a number from the
3898         @code{r_type} field and creates an addend field.
3899
3900
3901 */
3902
3903 #ifndef CALC_ADDEND
3904 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
3905   {                                                             \
3906     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
3907     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
3908       coffsym = (obj_symbols (abfd)                             \
3909                  + (cache_ptr->sym_ptr_ptr - symbols));         \
3910     else if (ptr)                                               \
3911       coffsym = coff_symbol_from (abfd, ptr);                   \
3912     if (coffsym != (coff_symbol_type *) NULL                    \
3913         && coffsym->native->u.syment.n_scnum == 0)              \
3914       cache_ptr->addend = 0;                                    \
3915     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
3916              && ptr->section != (asection *) NULL)              \
3917       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
3918     else                                                        \
3919       cache_ptr->addend = 0;                                    \
3920   }
3921 #endif
3922
3923 static boolean
3924 coff_slurp_reloc_table (abfd, asect, symbols)
3925      bfd * abfd;
3926      sec_ptr asect;
3927      asymbol ** symbols;
3928 {
3929   RELOC *native_relocs;
3930   arelent *reloc_cache;
3931   arelent *cache_ptr;
3932
3933   unsigned int idx;
3934
3935   if (asect->relocation)
3936     return true;
3937   if (asect->reloc_count == 0)
3938     return true;
3939   if (asect->flags & SEC_CONSTRUCTOR)
3940     return true;
3941   if (!coff_slurp_symbol_table (abfd))
3942     return false;
3943   native_relocs =
3944     (RELOC *) buy_and_read (abfd,
3945                             asect->rel_filepos,
3946                             SEEK_SET,
3947                             (size_t) (RELSZ *
3948                                       asect->reloc_count));
3949   reloc_cache = (arelent *)
3950     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
3951
3952   if (reloc_cache == NULL)
3953     return false;
3954
3955
3956   for (idx = 0; idx < asect->reloc_count; idx++)
3957     {
3958       struct internal_reloc dst;
3959       struct external_reloc *src;
3960 #ifndef RELOC_PROCESSING
3961       asymbol *ptr;
3962 #endif
3963
3964       cache_ptr = reloc_cache + idx;
3965       src = native_relocs + idx;
3966
3967       coff_swap_reloc_in (abfd, src, &dst);
3968
3969 #ifdef RELOC_PROCESSING
3970       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
3971 #else
3972       cache_ptr->address = dst.r_vaddr;
3973
3974       if (dst.r_symndx != -1)
3975         {
3976           if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
3977             {
3978               (*_bfd_error_handler)
3979                 (_("%s: warning: illegal symbol index %ld in relocs"),
3980                  bfd_get_filename (abfd), dst.r_symndx);
3981               cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3982               ptr = NULL;
3983             }
3984           else
3985             {
3986               cache_ptr->sym_ptr_ptr = (symbols
3987                                         + obj_convert (abfd)[dst.r_symndx]);
3988               ptr = *(cache_ptr->sym_ptr_ptr);
3989             }
3990         }
3991       else
3992         {
3993           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3994           ptr = NULL;
3995         }
3996
3997       /* The symbols definitions that we have read in have been
3998          relocated as if their sections started at 0. But the offsets
3999          refering to the symbols in the raw data have not been
4000          modified, so we have to have a negative addend to compensate.
4001
4002          Note that symbols which used to be common must be left alone */
4003
4004       /* Calculate any reloc addend by looking at the symbol */
4005       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4006
4007       cache_ptr->address -= asect->vma;
4008 /* !!     cache_ptr->section = (asection *) NULL;*/
4009
4010       /* Fill in the cache_ptr->howto field from dst.r_type */
4011       RTYPE2HOWTO (cache_ptr, &dst);
4012 #endif  /* RELOC_PROCESSING */
4013
4014       if (cache_ptr->howto == NULL)
4015         {
4016           (*_bfd_error_handler)
4017             (_("%s: illegal relocation type %d at address 0x%lx"),
4018              bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4019           bfd_set_error (bfd_error_bad_value);
4020           return false;
4021         }
4022     }
4023
4024   asect->relocation = reloc_cache;
4025   return true;
4026 }
4027
4028 #ifndef coff_rtype_to_howto
4029 #ifdef RTYPE2HOWTO
4030
4031 /* Get the howto structure for a reloc.  This is only used if the file
4032    including this one defines coff_relocate_section to be
4033    _bfd_coff_generic_relocate_section, so it is OK if it does not
4034    always work.  It is the responsibility of the including file to
4035    make sure it is reasonable if it is needed.  */
4036
4037 static reloc_howto_type *coff_rtype_to_howto
4038   PARAMS ((bfd *, asection *, struct internal_reloc *,
4039            struct coff_link_hash_entry *, struct internal_syment *,
4040            bfd_vma *));
4041
4042 /*ARGSUSED*/
4043 static reloc_howto_type *
4044 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
4045      bfd *abfd ATTRIBUTE_UNUSED;
4046      asection *sec ATTRIBUTE_UNUSED;
4047      struct internal_reloc *rel;
4048      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4049      struct internal_syment *sym ATTRIBUTE_UNUSED;
4050      bfd_vma *addendp ATTRIBUTE_UNUSED;
4051 {
4052   arelent genrel;
4053
4054   RTYPE2HOWTO (&genrel, rel);
4055   return genrel.howto;
4056 }
4057
4058 #else /* ! defined (RTYPE2HOWTO) */
4059
4060 #define coff_rtype_to_howto NULL
4061
4062 #endif /* ! defined (RTYPE2HOWTO) */
4063 #endif /* ! defined (coff_rtype_to_howto) */
4064
4065 /* This is stupid.  This function should be a boolean predicate.  */
4066 static long
4067 coff_canonicalize_reloc (abfd, section, relptr, symbols)
4068      bfd * abfd;
4069      sec_ptr section;
4070      arelent ** relptr;
4071      asymbol ** symbols;
4072 {
4073   arelent *tblptr = section->relocation;
4074   unsigned int count = 0;
4075
4076
4077   if (section->flags & SEC_CONSTRUCTOR)
4078     {
4079       /* this section has relocs made up by us, they are not in the
4080        file, so take them out of their chain and place them into
4081        the data area provided */
4082       arelent_chain *chain = section->constructor_chain;
4083       for (count = 0; count < section->reloc_count; count++)
4084         {
4085           *relptr++ = &chain->relent;
4086           chain = chain->next;
4087         }
4088
4089     }
4090   else
4091     {
4092       if (! coff_slurp_reloc_table (abfd, section, symbols))
4093         return -1;
4094
4095       tblptr = section->relocation;
4096
4097       for (; count++ < section->reloc_count;)
4098         *relptr++ = tblptr++;
4099
4100
4101     }
4102   *relptr = 0;
4103   return section->reloc_count;
4104 }
4105
4106 #ifdef GNU960
4107 file_ptr
4108 coff_sym_filepos (abfd)
4109      bfd *abfd;
4110 {
4111   return obj_sym_filepos (abfd);
4112 }
4113 #endif
4114
4115 #ifndef coff_reloc16_estimate
4116 #define coff_reloc16_estimate dummy_reloc16_estimate
4117
4118 static int dummy_reloc16_estimate
4119   PARAMS ((bfd *, asection *, arelent *, unsigned int,
4120            struct bfd_link_info *));
4121
4122 static int
4123 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
4124      bfd *abfd ATTRIBUTE_UNUSED;
4125      asection *input_section ATTRIBUTE_UNUSED;
4126      arelent *reloc ATTRIBUTE_UNUSED;
4127      unsigned int shrink ATTRIBUTE_UNUSED;
4128      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4129 {
4130   abort ();
4131 }
4132
4133 #endif
4134
4135 #ifndef coff_reloc16_extra_cases
4136
4137 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4138
4139 /* This works even if abort is not declared in any header file.  */
4140
4141 static void dummy_reloc16_extra_cases
4142   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
4143            bfd_byte *, unsigned int *, unsigned int *));
4144
4145 static void
4146 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4147                            dst_ptr)
4148      bfd *abfd ATTRIBUTE_UNUSED;
4149      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4150      struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
4151      arelent *reloc ATTRIBUTE_UNUSED;
4152      bfd_byte *data ATTRIBUTE_UNUSED;
4153      unsigned int *src_ptr ATTRIBUTE_UNUSED;
4154      unsigned int *dst_ptr ATTRIBUTE_UNUSED;
4155 {
4156   abort ();
4157 }
4158 #endif
4159
4160 /* If coff_relocate_section is defined, we can use the optimized COFF
4161    backend linker.  Otherwise we must continue to use the old linker.  */
4162 #ifdef coff_relocate_section
4163 #ifndef coff_bfd_link_hash_table_create
4164 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4165 #endif
4166 #ifndef coff_bfd_link_add_symbols
4167 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4168 #endif
4169 #ifndef coff_bfd_final_link
4170 #define coff_bfd_final_link _bfd_coff_final_link
4171 #endif
4172 #else /* ! defined (coff_relocate_section) */
4173 #define coff_relocate_section NULL
4174 #ifndef coff_bfd_link_hash_table_create
4175 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4176 #endif
4177 #ifndef coff_bfd_link_add_symbols
4178 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4179 #endif
4180 #define coff_bfd_final_link _bfd_generic_final_link
4181 #endif /* ! defined (coff_relocate_section) */
4182
4183 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
4184
4185 #ifndef coff_start_final_link
4186 #define coff_start_final_link NULL
4187 #endif
4188
4189 #ifndef coff_adjust_symndx
4190 #define coff_adjust_symndx NULL
4191 #endif
4192
4193 #ifndef coff_link_add_one_symbol
4194 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4195 #endif
4196
4197 #ifndef coff_link_output_has_begun
4198
4199 static boolean coff_link_output_has_begun
4200   PARAMS ((bfd *, struct coff_final_link_info *));
4201
4202 static boolean
4203 coff_link_output_has_begun (abfd, info)
4204      bfd * abfd;
4205      struct coff_final_link_info * info ATTRIBUTE_UNUSED;
4206 {
4207   return abfd->output_has_begun;
4208 }
4209 #endif
4210
4211 #ifndef coff_final_link_postscript
4212
4213 static boolean coff_final_link_postscript
4214   PARAMS ((bfd *, struct coff_final_link_info *));
4215
4216 static boolean
4217 coff_final_link_postscript (abfd, pfinfo)
4218      bfd * abfd ATTRIBUTE_UNUSED;
4219      struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
4220 {
4221   return true;
4222 }
4223 #endif
4224
4225 #ifndef coff_SWAP_aux_in
4226 #define coff_SWAP_aux_in coff_swap_aux_in
4227 #endif
4228 #ifndef coff_SWAP_sym_in
4229 #define coff_SWAP_sym_in coff_swap_sym_in
4230 #endif
4231 #ifndef coff_SWAP_lineno_in
4232 #define coff_SWAP_lineno_in coff_swap_lineno_in
4233 #endif
4234 #ifndef coff_SWAP_aux_out
4235 #define coff_SWAP_aux_out coff_swap_aux_out
4236 #endif
4237 #ifndef coff_SWAP_sym_out
4238 #define coff_SWAP_sym_out coff_swap_sym_out
4239 #endif
4240 #ifndef coff_SWAP_lineno_out
4241 #define coff_SWAP_lineno_out coff_swap_lineno_out
4242 #endif
4243 #ifndef coff_SWAP_reloc_out
4244 #define coff_SWAP_reloc_out coff_swap_reloc_out
4245 #endif
4246 #ifndef coff_SWAP_filehdr_out
4247 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4248 #endif
4249 #ifndef coff_SWAP_aouthdr_out
4250 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4251 #endif
4252 #ifndef coff_SWAP_scnhdr_out
4253 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4254 #endif
4255 #ifndef coff_SWAP_reloc_in
4256 #define coff_SWAP_reloc_in coff_swap_reloc_in
4257 #endif
4258 #ifndef coff_SWAP_filehdr_in
4259 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4260 #endif
4261 #ifndef coff_SWAP_aouthdr_in
4262 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4263 #endif
4264 #ifndef coff_SWAP_scnhdr_in
4265 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4266 #endif
4267
4268
4269
4270 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
4271 {
4272   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
4273   coff_SWAP_aux_out, coff_SWAP_sym_out,
4274   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
4275   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
4276   coff_SWAP_scnhdr_out,
4277   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
4278 #ifdef COFF_LONG_FILENAMES
4279   true,
4280 #else
4281   false,
4282 #endif
4283 #ifdef COFF_LONG_SECTION_NAMES
4284   true,
4285 #else
4286   false,
4287 #endif
4288   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
4289   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
4290   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
4291   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
4292   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
4293   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
4294   coff_sym_is_global, coff_compute_section_file_positions,
4295   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
4296   coff_adjust_symndx, coff_link_add_one_symbol,
4297   coff_link_output_has_begun, coff_final_link_postscript
4298 };
4299
4300 #ifndef coff_close_and_cleanup
4301 #define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
4302 #endif
4303
4304 #ifndef coff_bfd_free_cached_info
4305 #define coff_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
4306 #endif
4307
4308 #ifndef coff_get_section_contents
4309 #define coff_get_section_contents           _bfd_generic_get_section_contents
4310 #endif
4311
4312 #ifndef coff_bfd_copy_private_symbol_data
4313 #define coff_bfd_copy_private_symbol_data   _bfd_generic_bfd_copy_private_symbol_data
4314 #endif
4315
4316 #ifndef coff_bfd_copy_private_section_data
4317 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
4318 #endif
4319
4320 #ifndef coff_bfd_copy_private_bfd_data
4321 #define coff_bfd_copy_private_bfd_data      _bfd_generic_bfd_copy_private_bfd_data
4322 #endif
4323
4324 #ifndef coff_bfd_merge_private_bfd_data
4325 #define coff_bfd_merge_private_bfd_data     _bfd_generic_bfd_merge_private_bfd_data
4326 #endif
4327
4328 #ifndef coff_bfd_set_private_flags
4329 #define coff_bfd_set_private_flags          _bfd_generic_bfd_set_private_flags
4330 #endif
4331
4332 #ifndef coff_bfd_print_private_bfd_data
4333 #define coff_bfd_print_private_bfd_data     _bfd_generic_bfd_print_private_bfd_data
4334 #endif
4335
4336 #ifndef coff_bfd_is_local_label_name
4337 #define coff_bfd_is_local_label_name        _bfd_coff_is_local_label_name
4338 #endif
4339
4340 #ifndef coff_read_minisymbols
4341 #define coff_read_minisymbols               _bfd_generic_read_minisymbols
4342 #endif
4343
4344 #ifndef coff_minisymbol_to_symbol
4345 #define coff_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
4346 #endif
4347
4348 /* The reloc lookup routine must be supplied by each individual COFF
4349    backend.  */
4350 #ifndef coff_bfd_reloc_type_lookup
4351 #define coff_bfd_reloc_type_lookup          _bfd_norelocs_bfd_reloc_type_lookup
4352 #endif
4353
4354 #ifndef coff_bfd_get_relocated_section_contents
4355 #define coff_bfd_get_relocated_section_contents \
4356   bfd_generic_get_relocated_section_contents
4357 #endif
4358
4359 #ifndef coff_bfd_relax_section
4360 #define coff_bfd_relax_section              bfd_generic_relax_section
4361 #endif
4362
4363 #ifndef coff_bfd_gc_sections
4364 #define coff_bfd_gc_sections                bfd_generic_gc_sections
4365 #endif
4366
4367 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4368 const bfd_target VAR =                                                                          \
4369 {                                                                                               \
4370   NAME ,                                                                                        \
4371   bfd_target_coff_flavour,                                                                      \
4372   BFD_ENDIAN_BIG,               /* data byte order is big */                                    \
4373   BFD_ENDIAN_BIG,               /* header byte order is big */                                  \
4374   /* object flags */                                                                            \
4375   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                                                \
4376    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                                            \
4377   /* section flags */                                                                           \
4378   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),                        \
4379   UNDER,                        /* leading symbol underscore */                                 \
4380   '/',                          /* ar_pad_char */                                               \
4381   15,                           /* ar_max_namelen */                                            \
4382                                                                                                 \
4383   /* Data conversion functions.  */                                                             \
4384   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                                                   \
4385   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                                                   \
4386   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                                                   \
4387                                                                                                 \
4388   /* Header conversion functions.  */                                                           \
4389   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                                                   \
4390   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                                                   \
4391   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                                                   \
4392                                                                                                 \
4393         /* bfd_check_format */                                                                  \
4394   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target },               \
4395         /* bfd_set_format */                                                                    \
4396   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },                              \
4397         /* bfd_write_contents */                                                                \
4398   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false },            \
4399                                                                                                 \
4400   BFD_JUMP_TABLE_GENERIC (coff),                                                                \
4401   BFD_JUMP_TABLE_COPY (coff),                                                                   \
4402   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                                            \
4403   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                                                   \
4404   BFD_JUMP_TABLE_SYMBOLS (coff),                                                                \
4405   BFD_JUMP_TABLE_RELOCS (coff),                                                                 \
4406   BFD_JUMP_TABLE_WRITE (coff),                                                                  \
4407   BFD_JUMP_TABLE_LINK (coff),                                                                   \
4408   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                                                      \
4409                                                                                                 \
4410   ALTERNATIVE,                                                                                  \
4411                                                                                                 \
4412   COFF_SWAP_TABLE                                                                               \
4413 };
4414
4415 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE)      \
4416 const bfd_target VAR =                                                                          \
4417 {                                                                                               \
4418   NAME ,                                                                                        \
4419   bfd_target_coff_flavour,                                                                      \
4420   BFD_ENDIAN_LITTLE,            /* data byte order is little */                                 \
4421   BFD_ENDIAN_LITTLE,            /* header byte order is little */                               \
4422         /* object flags */                                                                      \
4423   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                                                \
4424    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                                            \
4425         /* section flags */                                                                     \
4426   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),                        \
4427   UNDER,                        /* leading symbol underscore */                                 \
4428   '/',                          /* ar_pad_char */                                               \
4429   15,                           /* ar_max_namelen */                                            \
4430                                                                                                 \
4431   /* Data conversion functions.  */                                                             \
4432   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                                                   \
4433   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                                                   \
4434   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                                                   \
4435   /* Header conversion functions.  */                                                           \
4436   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                                                   \
4437   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                                                   \
4438   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                                                   \
4439         /* bfd_check_format */                                                                  \
4440   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target },               \
4441        /* bfd_set_format */                                                                     \
4442   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },                              \
4443         /* bfd_write_contents */                                                                \
4444   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false },            \
4445                                                                                                 \
4446   BFD_JUMP_TABLE_GENERIC (coff),                                                                \
4447   BFD_JUMP_TABLE_COPY (coff),                                                                   \
4448   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                                            \
4449   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                                                   \
4450   BFD_JUMP_TABLE_SYMBOLS (coff),                                                                \
4451   BFD_JUMP_TABLE_RELOCS (coff),                                                                 \
4452   BFD_JUMP_TABLE_WRITE (coff),                                                                  \
4453   BFD_JUMP_TABLE_LINK (coff),                                                                   \
4454   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                                                      \
4455                                                                                                 \
4456   ALTERNATIVE,                                                                                  \
4457                                                                                                 \
4458   COFF_SWAP_TABLE                                                                               \
4459 };