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