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