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