bfd/coffcode.h

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