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
1536 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1537 #ifdef COFF_WITH_PE
1538
1539 /* a couple of macros to help setting the alignment power field */
1540 #define ALIGN_SET(field,x,y) \
1541   if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1542   {\
1543      section->alignment_power = y;\
1544   }
1545
1546 #define ELIFALIGN_SET(field,x,y) \
1547   else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1548   {\
1549      section->alignment_power = y;\
1550   }
1551
1552 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1553
1554 static void
1555 coff_set_alignment_hook (abfd, section, scnhdr)
1556      bfd * abfd ATTRIBUTE_UNUSED;
1557      asection * section;
1558      PTR scnhdr;
1559 {
1560   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1561
1562   ALIGN_SET     (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1563   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1564   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1565   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES,  3)
1566   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES,  2)
1567   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES,  1)
1568   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES,  0)
1569
1570   /* In a PE image file, the s_paddr field holds the virtual size of a
1571      section, while the s_size field holds the raw size.  We also keep
1572      the original section flag value, since not every bit can be
1573      mapped onto a generic BFD section bit.  */
1574   if (coff_section_data (abfd, section) == NULL)
1575     {
1576       section->used_by_bfd =
1577         (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
1578       if (section->used_by_bfd == NULL)
1579         {
1580           /* FIXME: Return error.  */
1581           abort ();
1582         }
1583     }
1584   if (pei_section_data (abfd, section) == NULL)
1585     {
1586       coff_section_data (abfd, section)->tdata =
1587         (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
1588       if (coff_section_data (abfd, section)->tdata == NULL)
1589         {
1590           /* FIXME: Return error.  */
1591           abort ();
1592         }
1593     }
1594   pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1595   pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1596
1597   section->lma = hdr->s_vaddr;
1598 }
1599 #undef ALIGN_SET
1600 #undef ELIFALIGN_SET
1601
1602 #else /* ! COFF_WITH_PE */
1603 #ifdef RS6000COFF_C
1604
1605 /* We grossly abuse this function to handle XCOFF overflow headers.
1606    When we see one, we correct the reloc and line number counts in the
1607    real header, and remove the section we just created.  */
1608
1609 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1610
1611 static void
1612 coff_set_alignment_hook (abfd, section, scnhdr)
1613      bfd *abfd;
1614      asection *section;
1615      PTR scnhdr;
1616 {
1617   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1618   asection *real_sec;
1619   asection **ps;
1620
1621   if ((hdr->s_flags & STYP_OVRFLO) == 0)
1622     return;
1623
1624   real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1625   if (real_sec == NULL)
1626     return;
1627
1628   real_sec->reloc_count = hdr->s_paddr;
1629   real_sec->lineno_count = hdr->s_vaddr;
1630
1631   for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1632     {
1633       if (*ps == section)
1634         {
1635           *ps = (*ps)->next;
1636           --abfd->section_count;
1637           break;
1638         }
1639     }
1640 }
1641
1642 #else /* ! RS6000COFF_C */
1643
1644 #define coff_set_alignment_hook \
1645   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1646
1647 #endif /* ! RS6000COFF_C */
1648 #endif /* ! COFF_WITH_PE */
1649 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1650
1651 #ifndef coff_mkobject
1652
1653 static boolean coff_mkobject PARAMS ((bfd *));
1654
1655 static boolean
1656 coff_mkobject (abfd)
1657      bfd * abfd;
1658 {
1659   coff_data_type *coff;
1660
1661   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1662   if (abfd->tdata.coff_obj_data == 0)
1663     return false;
1664   coff = coff_data (abfd);
1665   coff->symbols = (coff_symbol_type *) NULL;
1666   coff->conversion_table = (unsigned int *) NULL;
1667   coff->raw_syments = (struct coff_ptr_struct *) NULL;
1668   coff->relocbase = 0;
1669   coff->local_toc_sym_map = 0;
1670
1671 /*  make_abs_section(abfd);*/
1672
1673   return true;
1674 }
1675 #endif
1676
1677 /* Create the COFF backend specific information.  */
1678 #ifndef coff_mkobject_hook
1679 static PTR
1680 coff_mkobject_hook (abfd, filehdr, aouthdr)
1681      bfd * abfd;
1682      PTR filehdr;
1683      PTR aouthdr ATTRIBUTE_UNUSED;
1684 {
1685   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1686   coff_data_type *coff;
1687
1688   if (coff_mkobject (abfd) == false)
1689     return NULL;
1690
1691   coff = coff_data (abfd);
1692
1693   coff->sym_filepos = internal_f->f_symptr;
1694
1695   /* These members communicate important constants about the symbol
1696      table to GDB's symbol-reading code.  These `constants'
1697      unfortunately vary among coff implementations...  */
1698   coff->local_n_btmask = N_BTMASK;
1699   coff->local_n_btshft = N_BTSHFT;
1700   coff->local_n_tmask = N_TMASK;
1701   coff->local_n_tshift = N_TSHIFT;
1702   coff->local_symesz = bfd_coff_symesz (abfd);
1703   coff->local_auxesz = bfd_coff_auxesz (abfd);
1704   coff->local_linesz = bfd_coff_linesz (abfd);
1705
1706   coff->timestamp = internal_f->f_timdat;
1707
1708   obj_raw_syment_count (abfd) =
1709     obj_conv_table_size (abfd) =
1710       internal_f->f_nsyms;
1711
1712 #ifdef RS6000COFF_C
1713   if ((internal_f->f_flags & F_SHROBJ) != 0)
1714     abfd->flags |= DYNAMIC;
1715   if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1716     {
1717       struct internal_aouthdr *internal_a =
1718         (struct internal_aouthdr *) aouthdr;
1719       struct xcoff_tdata *xcoff;
1720
1721       xcoff = xcoff_data (abfd);
1722       xcoff->full_aouthdr = true;
1723       xcoff->toc = internal_a->o_toc;
1724       xcoff->sntoc = internal_a->o_sntoc;
1725       xcoff->snentry = internal_a->o_snentry;
1726       xcoff->text_align_power = internal_a->o_algntext;
1727       xcoff->data_align_power = internal_a->o_algndata;
1728       xcoff->modtype = internal_a->o_modtype;
1729       xcoff->cputype = internal_a->o_cputype;
1730       xcoff->maxdata = internal_a->o_maxdata;
1731       xcoff->maxstack = internal_a->o_maxstack;
1732     }
1733 #endif
1734
1735 #ifdef ARM
1736   /* Set the flags field from the COFF header read in */
1737   if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1738     coff->flags = 0;
1739 #endif
1740
1741 #ifdef COFF_WITH_PE
1742   /* FIXME: I'm not sure this is ever executed, since peicode.h
1743      defines coff_mkobject_hook.  */
1744   if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1745     abfd->flags |= HAS_DEBUG;
1746 #endif
1747
1748   return (PTR) coff;
1749 }
1750 #endif
1751
1752 /* Determine the machine architecture and type.  FIXME: This is target
1753    dependent because the magic numbers are defined in the target
1754    dependent header files.  But there is no particular need for this.
1755    If the magic numbers were moved to a separate file, this function
1756    would be target independent and would also be much more successful
1757    at linking together COFF files for different architectures.  */
1758
1759 static boolean
1760 coff_set_arch_mach_hook (abfd, filehdr)
1761      bfd *abfd;
1762      PTR filehdr;
1763 {
1764   long machine;
1765   enum bfd_architecture arch;
1766   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1767
1768   machine = 0;
1769   switch (internal_f->f_magic)
1770     {
1771 #ifdef PPCMAGIC
1772     case PPCMAGIC:
1773       arch = bfd_arch_powerpc;
1774       machine = 0; /* what does this mean? (krk) */
1775       break;
1776 #endif
1777 #ifdef I386MAGIC
1778     case I386MAGIC:
1779     case I386PTXMAGIC:
1780     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1781     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1782       arch = bfd_arch_i386;
1783       machine = 0;
1784       break;
1785 #endif
1786 #ifdef A29K_MAGIC_BIG
1787     case A29K_MAGIC_BIG:
1788     case A29K_MAGIC_LITTLE:
1789       arch = bfd_arch_a29k;
1790       machine = 0;
1791       break;
1792 #endif
1793 #ifdef ARMMAGIC
1794     case ARMMAGIC:
1795     case ARMPEMAGIC:
1796     case THUMBPEMAGIC:
1797       arch = bfd_arch_arm;
1798       switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1799         {
1800         case F_ARM_2:  machine = bfd_mach_arm_2;  break;
1801         case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1802         case F_ARM_3:  machine = bfd_mach_arm_3;  break;
1803         default:
1804         case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1805         case F_ARM_4:  machine = bfd_mach_arm_4;  break;
1806         case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1807         case F_ARM_5:  machine = bfd_mach_arm_5;  break;
1808         }
1809       break;
1810 #endif
1811 #ifdef MC68MAGIC
1812     case MC68MAGIC:
1813     case M68MAGIC:
1814 #ifdef MC68KBCSMAGIC
1815     case MC68KBCSMAGIC:
1816 #endif
1817 #ifdef APOLLOM68KMAGIC
1818     case APOLLOM68KMAGIC:
1819 #endif
1820 #ifdef LYNXCOFFMAGIC
1821     case LYNXCOFFMAGIC:
1822 #endif
1823       arch = bfd_arch_m68k;
1824       machine = bfd_mach_m68020;
1825       break;
1826 #endif
1827 #ifdef MC88MAGIC
1828     case MC88MAGIC:
1829     case MC88DMAGIC:
1830     case MC88OMAGIC:
1831       arch = bfd_arch_m88k;
1832       machine = 88100;
1833       break;
1834 #endif
1835 #ifdef Z8KMAGIC
1836     case Z8KMAGIC:
1837       arch = bfd_arch_z8k;
1838       switch (internal_f->f_flags & F_MACHMASK)
1839         {
1840         case F_Z8001:
1841           machine = bfd_mach_z8001;
1842           break;
1843         case F_Z8002:
1844           machine = bfd_mach_z8002;
1845           break;
1846         default:
1847           return false;
1848         }
1849       break;
1850 #endif
1851 #ifdef I860
1852     case I860MAGIC:
1853       arch = bfd_arch_i860;
1854       break;
1855 #endif
1856 #ifdef I960
1857 #ifdef I960ROMAGIC
1858     case I960ROMAGIC:
1859     case I960RWMAGIC:
1860       arch = bfd_arch_i960;
1861       switch (F_I960TYPE & internal_f->f_flags)
1862         {
1863         default:
1864         case F_I960CORE:
1865           machine = bfd_mach_i960_core;
1866           break;
1867         case F_I960KB:
1868           machine = bfd_mach_i960_kb_sb;
1869           break;
1870         case F_I960MC:
1871           machine = bfd_mach_i960_mc;
1872           break;
1873         case F_I960XA:
1874           machine = bfd_mach_i960_xa;
1875           break;
1876         case F_I960CA:
1877           machine = bfd_mach_i960_ca;
1878           break;
1879         case F_I960KA:
1880           machine = bfd_mach_i960_ka_sa;
1881           break;
1882         case F_I960JX:
1883           machine = bfd_mach_i960_jx;
1884           break;
1885         case F_I960HX:
1886           machine = bfd_mach_i960_hx;
1887           break;
1888         }
1889       break;
1890 #endif
1891 #endif
1892
1893 #ifdef RS6000COFF_C
1894     case U802ROMAGIC:
1895     case U802WRMAGIC:
1896     case U802TOCMAGIC:
1897       {
1898         int cputype;
1899
1900         if (xcoff_data (abfd)->cputype != -1)
1901           cputype = xcoff_data (abfd)->cputype & 0xff;
1902         else
1903           {
1904             /* We did not get a value from the a.out header.  If the
1905                file has not been stripped, we may be able to get the
1906                architecture information from the first symbol, if it
1907                is a .file symbol.  */
1908             if (obj_raw_syment_count (abfd) == 0)
1909               cputype = 0;
1910             else
1911               {
1912                 bfd_byte *buf;
1913                 struct internal_syment sym;
1914
1915                 buf = (bfd_byte *) bfd_malloc (bfd_coff_symesz (abfd));
1916                 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1917                     || (bfd_read (buf, 1, bfd_coff_symesz (abfd), abfd)
1918                         != bfd_coff_symesz (abfd)))
1919                   {
1920                     free (buf);
1921                     return false;
1922                   }
1923                 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1924                 if (sym.n_sclass == C_FILE)
1925                   cputype = sym.n_type & 0xff;
1926                 else
1927                   cputype = 0;
1928                 free (buf);
1929               }
1930           }
1931
1932         /* FIXME: We don't handle all cases here.  */
1933         switch (cputype)
1934           {
1935           default:
1936           case 0:
1937 #ifdef POWERMAC
1938             /* PowerPC Macs use the same magic numbers as RS/6000
1939                (because that's how they were bootstrapped originally),
1940                but they are always PowerPC architecture.  */
1941             arch = bfd_arch_powerpc;
1942             machine = 0;
1943 #else
1944             arch = bfd_arch_rs6000;
1945             machine = 6000;
1946 #endif /* POWERMAC */
1947             break;
1948
1949           case 1:
1950             arch = bfd_arch_powerpc;
1951             machine = 601;
1952             break;
1953           case 2: /* 64 bit PowerPC */
1954             arch = bfd_arch_powerpc;
1955             machine = 620;
1956             break;
1957           case 3:
1958             arch = bfd_arch_powerpc;
1959             machine = 0;
1960             break;
1961           case 4:
1962             arch = bfd_arch_rs6000;
1963             machine = 6000;
1964             break;
1965           }
1966       }
1967       break;
1968 #endif
1969
1970 #ifdef WE32KMAGIC
1971     case WE32KMAGIC:
1972       arch = bfd_arch_we32k;
1973       machine = 0;
1974       break;
1975 #endif
1976
1977 #ifdef H8300MAGIC
1978     case H8300MAGIC:
1979       arch = bfd_arch_h8300;
1980       machine = bfd_mach_h8300;
1981       /* !! FIXME this probably isn't the right place for this */
1982       abfd->flags |= BFD_IS_RELAXABLE;
1983       break;
1984 #endif
1985
1986 #ifdef H8300HMAGIC
1987     case H8300HMAGIC:
1988       arch = bfd_arch_h8300;
1989       machine = bfd_mach_h8300h;
1990       /* !! FIXME this probably isn't the right place for this */
1991       abfd->flags |= BFD_IS_RELAXABLE;
1992       break;
1993 #endif
1994
1995 #ifdef H8300SMAGIC
1996     case H8300SMAGIC:
1997       arch = bfd_arch_h8300;
1998       machine = bfd_mach_h8300s;
1999       /* !! FIXME this probably isn't the right place for this */
2000       abfd->flags |= BFD_IS_RELAXABLE;
2001       break;
2002 #endif
2003
2004 #ifdef SH_ARCH_MAGIC_BIG
2005     case SH_ARCH_MAGIC_BIG:
2006     case SH_ARCH_MAGIC_LITTLE:
2007 #ifdef COFF_WITH_PE
2008     case SH_ARCH_MAGIC_WINCE:
2009 #endif
2010       arch = bfd_arch_sh;
2011       machine = 0;
2012       break;
2013 #endif
2014
2015 #ifdef MIPS_ARCH_MAGIC_WINCE
2016     case MIPS_ARCH_MAGIC_WINCE:
2017       arch = bfd_arch_mips;
2018       machine = 0;
2019       break;
2020 #endif
2021
2022 #ifdef H8500MAGIC
2023     case H8500MAGIC:
2024       arch = bfd_arch_h8500;
2025       machine = 0;
2026       break;
2027 #endif
2028
2029 #ifdef SPARCMAGIC
2030     case SPARCMAGIC:
2031 #ifdef LYNXCOFFMAGIC
2032     case LYNXCOFFMAGIC:
2033 #endif
2034       arch = bfd_arch_sparc;
2035       machine = 0;
2036       break;
2037 #endif
2038
2039 #ifdef TIC30MAGIC
2040     case TIC30MAGIC:
2041       arch = bfd_arch_tic30;
2042       break;
2043 #endif
2044
2045 #ifdef TICOFF0MAGIC
2046 #ifdef TICOFF_TARGET_ARCH
2047       /* this TI COFF section should be used by all new TI COFF v0 targets */
2048     case TICOFF0MAGIC:
2049       arch = TICOFF_TARGET_ARCH;
2050       break;
2051 #endif
2052 #endif
2053
2054 #ifdef TICOFF1MAGIC
2055       /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2056       /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2057     case TICOFF1MAGIC:
2058     case TICOFF2MAGIC:
2059       switch (internal_f->f_target_id)
2060         {
2061 #ifdef TI_TARGET_ID
2062         case TI_TARGET_ID:
2063           arch = TICOFF_TARGET_ARCH;
2064           break;
2065 #endif
2066         default:
2067           arch = bfd_arch_obscure;
2068           (*_bfd_error_handler)
2069             (_("Unrecognized TI COFF target id '0x%x'"),
2070              internal_f->f_target_id);
2071           break;
2072         }
2073       break;
2074 #endif
2075
2076 #ifdef TIC80_ARCH_MAGIC
2077     case TIC80_ARCH_MAGIC:
2078       arch = bfd_arch_tic80;
2079       break;
2080 #endif
2081
2082 #ifdef MCOREMAGIC
2083     case MCOREMAGIC:
2084       arch = bfd_arch_mcore;
2085       break;
2086 #endif
2087     default:                    /* Unreadable input file type */
2088       arch = bfd_arch_obscure;
2089       break;
2090     }
2091
2092   bfd_default_set_arch_mach (abfd, arch, machine);
2093   return true;
2094 }
2095
2096 #ifdef SYMNAME_IN_DEBUG
2097
2098 static boolean symname_in_debug_hook
2099   PARAMS ((bfd *, struct internal_syment *));
2100
2101 static boolean
2102 symname_in_debug_hook (abfd, sym)
2103      bfd * abfd ATTRIBUTE_UNUSED;
2104      struct internal_syment *sym;
2105 {
2106   return SYMNAME_IN_DEBUG (sym) ? true : false;
2107 }
2108
2109 #else
2110
2111 #define symname_in_debug_hook \
2112   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2113
2114 #endif
2115
2116 #ifdef RS6000COFF_C
2117
2118 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
2119
2120 static boolean coff_pointerize_aux_hook
2121   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2122            unsigned int, combined_entry_type *));
2123
2124 /*ARGSUSED*/
2125 static boolean
2126 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2127      bfd *abfd ATTRIBUTE_UNUSED;
2128      combined_entry_type *table_base;
2129      combined_entry_type *symbol;
2130      unsigned int indaux;
2131      combined_entry_type *aux;
2132 {
2133   int class = symbol->u.syment.n_sclass;
2134
2135   if ((class == C_EXT || class == C_HIDEXT)
2136       && indaux + 1 == symbol->u.syment.n_numaux)
2137     {
2138       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2139         {
2140           aux->u.auxent.x_csect.x_scnlen.p =
2141             table_base + aux->u.auxent.x_csect.x_scnlen.l;
2142           aux->fix_scnlen = 1;
2143         }
2144
2145       /* Return true to indicate that the caller should not do any
2146          further work on this auxent.  */
2147       return true;
2148     }
2149
2150   /* Return false to indicate that this auxent should be handled by
2151      the caller.  */
2152   return false;
2153 }
2154
2155 #else
2156 #ifdef I960
2157
2158 /* We don't want to pointerize bal entries.  */
2159
2160 static boolean coff_pointerize_aux_hook
2161   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2162            unsigned int, combined_entry_type *));
2163
2164 /*ARGSUSED*/
2165 static boolean
2166 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2167      bfd *abfd ATTRIBUTE_UNUSED;
2168      combined_entry_type *table_base ATTRIBUTE_UNUSED;
2169      combined_entry_type *symbol;
2170      unsigned int indaux;
2171      combined_entry_type *aux ATTRIBUTE_UNUSED;
2172 {
2173   /* Return true if we don't want to pointerize this aux entry, which
2174      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
2175   return (indaux == 1
2176           && (symbol->u.syment.n_sclass == C_LEAFPROC
2177               || symbol->u.syment.n_sclass == C_LEAFSTAT
2178               || symbol->u.syment.n_sclass == C_LEAFEXT));
2179 }
2180
2181 #else /* ! I960 */
2182
2183 #define coff_pointerize_aux_hook 0
2184
2185 #endif /* ! I960 */
2186 #endif /* ! RS6000COFF_C */
2187
2188 /* Print an aux entry.  This returns true if it has printed it.  */
2189
2190 static boolean coff_print_aux
2191   PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2192            combined_entry_type *, unsigned int));
2193
2194 static boolean
2195 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2196      bfd *abfd ATTRIBUTE_UNUSED;
2197      FILE *file ATTRIBUTE_UNUSED;
2198      combined_entry_type *table_base ATTRIBUTE_UNUSED;
2199      combined_entry_type *symbol ATTRIBUTE_UNUSED;
2200      combined_entry_type *aux ATTRIBUTE_UNUSED;
2201      unsigned int indaux ATTRIBUTE_UNUSED;
2202 {
2203 #ifdef RS6000COFF_C
2204   if ((symbol->u.syment.n_sclass == C_EXT
2205        || symbol->u.syment.n_sclass == C_HIDEXT)
2206       && indaux + 1 == symbol->u.syment.n_numaux)
2207     {
2208       /* This is a csect entry.  */
2209       fprintf (file, "AUX ");
2210       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2211         {
2212           BFD_ASSERT (! aux->fix_scnlen);
2213           fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
2214         }
2215       else
2216         {
2217           fprintf (file, "indx ");
2218           if (! aux->fix_scnlen)
2219             fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
2220           else
2221             fprintf (file, "%4ld",
2222                      (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2223         }
2224       fprintf (file,
2225                " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2226                aux->u.auxent.x_csect.x_parmhash,
2227                (unsigned int) aux->u.auxent.x_csect.x_snhash,
2228                SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2229                SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2230                (unsigned int) aux->u.auxent.x_csect.x_smclas,
2231                aux->u.auxent.x_csect.x_stab,
2232                (unsigned int) aux->u.auxent.x_csect.x_snstab);
2233       return true;
2234     }
2235 #endif
2236
2237   /* Return false to indicate that no special action was taken.  */
2238   return false;
2239 }
2240
2241 /*
2242 SUBSUBSECTION
2243         Writing relocations
2244
2245         To write relocations, the back end steps though the
2246         canonical relocation table and create an
2247         @code{internal_reloc}. The symbol index to use is removed from
2248         the @code{offset} field in the symbol table supplied.  The
2249         address comes directly from the sum of the section base
2250         address and the relocation offset; the type is dug directly
2251         from the howto field.  Then the @code{internal_reloc} is
2252         swapped into the shape of an @code{external_reloc} and written
2253         out to disk.
2254
2255 */
2256
2257 #ifdef TARG_AUX
2258
2259 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2260
2261 /* AUX's ld wants relocations to be sorted */
2262 static int
2263 compare_arelent_ptr (x, y)
2264      const PTR x;
2265      const PTR y;
2266 {
2267   const arelent **a = (const arelent **) x;
2268   const arelent **b = (const arelent **) y;
2269   bfd_size_type aadr = (*a)->address;
2270   bfd_size_type badr = (*b)->address;
2271
2272   return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2273 }
2274
2275 #endif /* TARG_AUX */
2276
2277 static boolean
2278 coff_write_relocs (abfd, first_undef)
2279      bfd * abfd;
2280      int first_undef;
2281 {
2282   asection *s;
2283
2284   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2285     {
2286       unsigned int i;
2287       struct external_reloc dst;
2288       arelent **p;
2289
2290 #ifndef TARG_AUX
2291       p = s->orelocation;
2292 #else
2293       /* sort relocations before we write them out */
2294       p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
2295       if (p == NULL && s->reloc_count > 0)
2296         return false;
2297       memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
2298       qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2299 #endif
2300
2301       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2302         return false;
2303       for (i = 0; i < s->reloc_count; i++)
2304         {
2305           struct internal_reloc n;
2306           arelent *q = p[i];
2307           memset ((PTR) & n, 0, sizeof (n));
2308
2309           /* Now we've renumbered the symbols we know where the
2310              undefined symbols live in the table.  Check the reloc
2311              entries for symbols who's output bfd isn't the right one.
2312              This is because the symbol was undefined (which means
2313              that all the pointers are never made to point to the same
2314              place). This is a bad thing,'cause the symbols attached
2315              to the output bfd are indexed, so that the relocation
2316              entries know which symbol index they point to.  So we
2317              have to look up the output symbol here. */
2318
2319           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2320             {
2321               int i;
2322               const char *sname = q->sym_ptr_ptr[0]->name;
2323               asymbol **outsyms = abfd->outsymbols;
2324               for (i = first_undef; outsyms[i]; i++)
2325                 {
2326                   const char *intable = outsyms[i]->name;
2327                   if (strcmp (intable, sname) == 0) {
2328                     /* got a hit, so repoint the reloc */
2329                     q->sym_ptr_ptr = outsyms + i;
2330                     break;
2331                   }
2332                 }
2333             }
2334
2335           n.r_vaddr = q->address + s->vma;
2336
2337 #ifdef R_IHCONST
2338           /* The 29k const/consth reloc pair is a real kludge.  The consth
2339              part doesn't have a symbol; it has an offset.  So rebuilt
2340              that here.  */
2341           if (q->howto->type == R_IHCONST)
2342             n.r_symndx = q->addend;
2343           else
2344 #endif
2345             if (q->sym_ptr_ptr)
2346               {
2347 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2348                 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2349 #else
2350                 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
2351 #endif
2352                   /* This is a relocation relative to the absolute symbol.  */
2353                   n.r_symndx = -1;
2354                 else
2355                   {
2356                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2357                     /* Take notice if the symbol reloc points to a symbol
2358                        we don't have in our symbol table.  What should we
2359                        do for this??  */
2360                     if (n.r_symndx > obj_conv_table_size (abfd))
2361                       abort ();
2362                   }
2363               }
2364
2365 #ifdef SWAP_OUT_RELOC_OFFSET
2366           n.r_offset = q->addend;
2367 #endif
2368
2369 #ifdef SELECT_RELOC
2370           /* Work out reloc type from what is required */
2371           SELECT_RELOC (n, q->howto);
2372 #else
2373           n.r_type = q->howto->type;
2374 #endif
2375           coff_swap_reloc_out (abfd, &n, &dst);
2376           if (bfd_write ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd)
2377               != bfd_coff_relsz (abfd))
2378             return false;
2379         }
2380
2381 #ifdef TARG_AUX
2382       if (p != NULL)
2383         free (p);
2384 #endif
2385     }
2386
2387   return true;
2388 }
2389
2390 /* Set flags and magic number of a coff file from architecture and machine
2391    type.  Result is true if we can represent the arch&type, false if not.  */
2392
2393 static boolean
2394 coff_set_flags (abfd, magicp, flagsp)
2395      bfd * abfd;
2396      unsigned int *magicp ATTRIBUTE_UNUSED;
2397      unsigned short *flagsp ATTRIBUTE_UNUSED;
2398 {
2399   switch (bfd_get_arch (abfd))
2400     {
2401 #ifdef Z8KMAGIC
2402     case bfd_arch_z8k:
2403       *magicp = Z8KMAGIC;
2404       switch (bfd_get_mach (abfd))
2405         {
2406         case bfd_mach_z8001:
2407           *flagsp = F_Z8001;
2408           break;
2409         case bfd_mach_z8002:
2410           *flagsp = F_Z8002;
2411           break;
2412         default:
2413           return false;
2414         }
2415       return true;
2416 #endif
2417 #ifdef I960ROMAGIC
2418
2419     case bfd_arch_i960:
2420
2421       {
2422         unsigned flags;
2423         *magicp = I960ROMAGIC;
2424         /*
2425           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2426           I960RWMAGIC);   FIXME???
2427           */
2428         switch (bfd_get_mach (abfd))
2429           {
2430           case bfd_mach_i960_core:
2431             flags = F_I960CORE;
2432             break;
2433           case bfd_mach_i960_kb_sb:
2434             flags = F_I960KB;
2435             break;
2436           case bfd_mach_i960_mc:
2437             flags = F_I960MC;
2438             break;
2439           case bfd_mach_i960_xa:
2440             flags = F_I960XA;
2441             break;
2442           case bfd_mach_i960_ca:
2443             flags = F_I960CA;
2444             break;
2445           case bfd_mach_i960_ka_sa:
2446             flags = F_I960KA;
2447             break;
2448           case bfd_mach_i960_jx:
2449             flags = F_I960JX;
2450             break;
2451           case bfd_mach_i960_hx:
2452             flags = F_I960HX;
2453             break;
2454           default:
2455             return false;
2456           }
2457         *flagsp = flags;
2458         return true;
2459       }
2460       break;
2461 #endif
2462
2463 #ifdef TIC30MAGIC
2464     case bfd_arch_tic30:
2465       *magicp = TIC30MAGIC;
2466       return true;
2467 #endif
2468
2469 #ifdef TICOFF_DEFAULT_MAGIC
2470     case TICOFF_TARGET_ARCH:
2471       /* if there's no indication of which version we want, use the default */
2472       if (!abfd->xvec )
2473         *magicp = TICOFF_DEFAULT_MAGIC;
2474       else
2475         {
2476           /* we may want to output in a different COFF version */
2477           switch (abfd->xvec->name[4])
2478             {
2479             case '0':
2480               *magicp = TICOFF0MAGIC;
2481               break;
2482             case '1':
2483               *magicp = TICOFF1MAGIC;
2484               break;
2485             case '2':
2486               *magicp = TICOFF2MAGIC;
2487               break;
2488             default:
2489               return false;
2490             }
2491         }
2492       return true;
2493 #endif
2494
2495 #ifdef TIC80_ARCH_MAGIC
2496     case bfd_arch_tic80:
2497       *magicp = TIC80_ARCH_MAGIC;
2498       return true;
2499 #endif
2500 #ifdef ARMMAGIC
2501     case bfd_arch_arm:
2502 #ifdef ARM_WINCE
2503       * magicp = ARMPEMAGIC;
2504 #else
2505       * magicp = ARMMAGIC;
2506 #endif
2507       * flagsp = 0;
2508       if (APCS_SET (abfd))
2509         {
2510           if (APCS_26_FLAG (abfd))
2511             * flagsp |= F_APCS26;
2512
2513           if (APCS_FLOAT_FLAG (abfd))
2514             * flagsp |= F_APCS_FLOAT;
2515
2516           if (PIC_FLAG (abfd))
2517             * flagsp |= F_PIC;
2518         }
2519       if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2520         * flagsp |= F_INTERWORK;
2521       switch (bfd_get_mach (abfd))
2522         {
2523         case bfd_mach_arm_2:  * flagsp |= F_ARM_2;  break;
2524         case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2525         case bfd_mach_arm_3:  * flagsp |= F_ARM_3;  break;
2526         case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2527         case bfd_mach_arm_4:  * flagsp |= F_ARM_4;  break;
2528         case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2529         case bfd_mach_arm_5:  * flagsp |= F_ARM_5;  break;
2530         case bfd_mach_arm_5T: * flagsp |= F_ARM_5;  break; /* XXX - we do not have an F_ARM_5T */
2531         }
2532       return true;
2533 #endif
2534 #ifdef PPCMAGIC
2535     case bfd_arch_powerpc:
2536       *magicp = PPCMAGIC;
2537       return true;
2538       break;
2539 #endif
2540 #ifdef I386MAGIC
2541     case bfd_arch_i386:
2542       *magicp = I386MAGIC;
2543 #ifdef LYNXOS
2544       /* Just overwrite the usual value if we're doing Lynx. */
2545       *magicp = LYNXCOFFMAGIC;
2546 #endif
2547       return true;
2548       break;
2549 #endif
2550 #ifdef I860MAGIC
2551     case bfd_arch_i860:
2552       *magicp = I860MAGIC;
2553       return true;
2554       break;
2555 #endif
2556 #ifdef MC68MAGIC
2557     case bfd_arch_m68k:
2558 #ifdef APOLLOM68KMAGIC
2559       *magicp = APOLLO_COFF_VERSION_NUMBER;
2560 #else
2561       /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c.  */
2562 #ifdef NAMES_HAVE_UNDERSCORE
2563       *magicp = MC68KBCSMAGIC;
2564 #else
2565       *magicp = MC68MAGIC;
2566 #endif
2567 #endif
2568 #ifdef LYNXOS
2569       /* Just overwrite the usual value if we're doing Lynx. */
2570       *magicp = LYNXCOFFMAGIC;
2571 #endif
2572       return true;
2573       break;
2574 #endif
2575
2576 #ifdef MC88MAGIC
2577     case bfd_arch_m88k:
2578       *magicp = MC88OMAGIC;
2579       return true;
2580       break;
2581 #endif
2582 #ifdef H8300MAGIC
2583     case bfd_arch_h8300:
2584       switch (bfd_get_mach (abfd))
2585         {
2586         case bfd_mach_h8300:
2587           *magicp = H8300MAGIC;
2588           return true;
2589         case bfd_mach_h8300h:
2590           *magicp = H8300HMAGIC;
2591           return true;
2592         case bfd_mach_h8300s:
2593           *magicp = H8300SMAGIC;
2594           return true;
2595         }
2596       break;
2597 #endif
2598
2599 #ifdef SH_ARCH_MAGIC_BIG
2600     case bfd_arch_sh:
2601 #ifdef COFF_IMAGE_WITH_PE
2602       *magicp = SH_ARCH_MAGIC_WINCE;
2603 #else
2604       if (bfd_big_endian (abfd))
2605         *magicp = SH_ARCH_MAGIC_BIG;
2606       else
2607         *magicp = SH_ARCH_MAGIC_LITTLE;
2608 #endif
2609       return true;
2610       break;
2611 #endif
2612
2613 #ifdef MIPS_ARCH_MAGIC_WINCE
2614     case bfd_arch_mips:
2615       *magicp = MIPS_ARCH_MAGIC_WINCE;
2616       return true;
2617       break;
2618 #endif
2619
2620 #ifdef SPARCMAGIC
2621     case bfd_arch_sparc:
2622       *magicp = SPARCMAGIC;
2623 #ifdef LYNXOS
2624       /* Just overwrite the usual value if we're doing Lynx. */
2625       *magicp = LYNXCOFFMAGIC;
2626 #endif
2627       return true;
2628       break;
2629 #endif
2630
2631 #ifdef H8500MAGIC
2632     case bfd_arch_h8500:
2633       *magicp = H8500MAGIC;
2634       return true;
2635       break;
2636 #endif
2637 #ifdef A29K_MAGIC_BIG
2638     case bfd_arch_a29k:
2639       if (bfd_big_endian (abfd))
2640         *magicp = A29K_MAGIC_BIG;
2641       else
2642         *magicp = A29K_MAGIC_LITTLE;
2643       return true;
2644       break;
2645 #endif
2646
2647 #ifdef WE32KMAGIC
2648     case bfd_arch_we32k:
2649       *magicp = WE32KMAGIC;
2650       return true;
2651       break;
2652 #endif
2653
2654 #ifdef U802TOCMAGIC
2655     case bfd_arch_rs6000:
2656 #ifndef PPCMAGIC
2657     case bfd_arch_powerpc:
2658 #endif
2659       *magicp = U802TOCMAGIC;
2660       return true;
2661       break;
2662 #endif
2663
2664 #ifdef MCOREMAGIC
2665     case bfd_arch_mcore:
2666       * magicp = MCOREMAGIC;
2667       return true;
2668 #endif
2669
2670     default:                    /* Unknown architecture */
2671       /* return false;  -- fall through to "return false" below, to avoid
2672        "statement never reached" errors on the one below. */
2673       break;
2674     }
2675
2676   return false;
2677 }
2678
2679
2680 static boolean
2681 coff_set_arch_mach (abfd, arch, machine)
2682      bfd * abfd;
2683      enum bfd_architecture arch;
2684      unsigned long machine;
2685 {
2686   unsigned dummy1;
2687   unsigned short dummy2;
2688
2689   if (! bfd_default_set_arch_mach (abfd, arch, machine))
2690     return false;
2691
2692   if (arch != bfd_arch_unknown &&
2693       coff_set_flags (abfd, &dummy1, &dummy2) != true)
2694     return false;               /* We can't represent this type */
2695
2696   return true;                  /* We're easy ... */
2697 }
2698
2699 #ifdef COFF_IMAGE_WITH_PE
2700
2701 /* This is used to sort sections by VMA, as required by PE image
2702    files.  */
2703
2704 static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2705
2706 static int
2707 sort_by_secaddr (arg1, arg2)
2708      const PTR arg1;
2709      const PTR arg2;
2710 {
2711   const asection *a = *(const asection **) arg1;
2712   const asection *b = *(const asection **) arg2;
2713
2714   if (a->vma < b->vma)
2715     return -1;
2716   else if (a->vma > b->vma)
2717     return 1;
2718   else
2719     return 0;
2720 }
2721
2722 #endif /* COFF_IMAGE_WITH_PE */
2723
2724 /* Calculate the file position for each section. */
2725
2726 #ifndef I960
2727 #define ALIGN_SECTIONS_IN_FILE
2728 #endif
2729 #if defined(TIC80COFF) || defined(TICOFF)
2730 #undef ALIGN_SECTIONS_IN_FILE
2731 #endif
2732
2733 static boolean
2734 coff_compute_section_file_positions (abfd)
2735      bfd * abfd;
2736 {
2737   asection *current;
2738   asection *previous = (asection *) NULL;
2739   file_ptr sofar = bfd_coff_filhsz (abfd);
2740   boolean align_adjust;
2741 #ifdef ALIGN_SECTIONS_IN_FILE
2742   file_ptr old_sofar;
2743 #endif
2744
2745 #ifdef RS6000COFF_C
2746   /* On XCOFF, if we have symbols, set up the .debug section.  */
2747   if (bfd_get_symcount (abfd) > 0)
2748     {
2749       bfd_size_type sz;
2750       bfd_size_type i, symcount;
2751       asymbol **symp;
2752
2753       sz = 0;
2754       symcount = bfd_get_symcount (abfd);
2755       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2756         {
2757           coff_symbol_type *cf;
2758
2759           cf = coff_symbol_from (abfd, *symp);
2760           if (cf != NULL
2761               && cf->native != NULL
2762               && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2763             {
2764               size_t len;
2765
2766               len = strlen (bfd_asymbol_name (*symp));
2767               if (len > SYMNMLEN)
2768                 sz += len + 3;
2769             }
2770         }
2771       if (sz > 0)
2772         {
2773           asection *dsec;
2774
2775           dsec = bfd_make_section_old_way (abfd, ".debug");
2776           if (dsec == NULL)
2777             abort ();
2778           dsec->_raw_size = sz;
2779           dsec->flags |= SEC_HAS_CONTENTS;
2780         }
2781     }
2782 #endif
2783
2784 #ifdef COFF_IMAGE_WITH_PE
2785   int page_size;
2786   if (coff_data (abfd)->link_info)
2787     {
2788       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2789     }
2790   else
2791     page_size = PE_DEF_FILE_ALIGNMENT;
2792 #else
2793 #ifdef COFF_PAGE_SIZE
2794   int page_size = COFF_PAGE_SIZE;
2795 #endif
2796 #endif
2797
2798   if (bfd_get_start_address (abfd))
2799     {
2800       /*  A start address may have been added to the original file. In this
2801           case it will need an optional header to record it.  */
2802       abfd->flags |= EXEC_P;
2803     }
2804
2805   if (abfd->flags & EXEC_P)
2806     sofar += bfd_coff_aoutsz (abfd);
2807 #ifdef RS6000COFF_C
2808   else if (xcoff_data (abfd)->full_aouthdr)
2809     sofar += bfd_coff_aoutsz (abfd);
2810   else
2811     sofar += SMALL_AOUTSZ;
2812 #endif
2813
2814   sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2815
2816 #ifdef RS6000COFF_C
2817   /* XCOFF handles overflows in the reloc and line number count fields
2818      by allocating a new section header to hold the correct counts.  */
2819   for (current = abfd->sections; current != NULL; current = current->next)
2820     if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2821       sofar += bfd_coff_scnhsz (abfd);
2822 #endif
2823
2824 #ifdef COFF_IMAGE_WITH_PE
2825   {
2826     /* PE requires the sections to be in memory order when listed in
2827        the section headers.  It also does not like empty loadable
2828        sections.  The sections apparently do not have to be in the
2829        right order in the image file itself, but we do need to get the
2830        target_index values right.  */
2831
2832     int count;
2833     asection **section_list;
2834     int i;
2835     int target_index;
2836
2837     count = 0;
2838     for (current = abfd->sections; current != NULL; current = current->next)
2839       ++count;
2840
2841     /* We allocate an extra cell to simplify the final loop.  */
2842     section_list = bfd_malloc (sizeof (struct asection *) * (count + 1));
2843     if (section_list == NULL)
2844       return false;
2845
2846     i = 0;
2847     for (current = abfd->sections; current != NULL; current = current->next)
2848       {
2849         section_list[i] = current;
2850         ++i;
2851       }
2852     section_list[i] = NULL;
2853
2854     qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
2855
2856     /* Rethread the linked list into sorted order; at the same time,
2857        assign target_index values.  */
2858     target_index = 1;
2859     abfd->sections = section_list[0];
2860     for (i = 0; i < count; i++)
2861       {
2862         current = section_list[i];
2863         current->next = section_list[i + 1];
2864
2865         /* Later, if the section has zero size, we'll be throwing it
2866            away, so we don't want to number it now.  Note that having
2867            a zero size and having real contents are different
2868            concepts: .bss has no contents, but (usually) non-zero
2869            size.  */
2870         if (current->_raw_size == 0)
2871           {
2872             /* Discard.  However, it still might have (valid) symbols
2873                in it, so arbitrarily set it to section 1 (indexing is
2874                1-based here; usually .text).  __end__ and other
2875                contents of .endsection really have this happen.
2876                FIXME: This seems somewhat dubious.  */
2877             current->target_index = 1;
2878           }
2879         else
2880           current->target_index = target_index++;
2881       }
2882
2883     free (section_list);
2884   }
2885 #else /* ! COFF_IMAGE_WITH_PE */
2886   {
2887     /* Set the target_index field.  */
2888     int target_index;
2889
2890     target_index = 1;
2891     for (current = abfd->sections; current != NULL; current = current->next)
2892       current->target_index = target_index++;
2893   }
2894 #endif /* ! COFF_IMAGE_WITH_PE */
2895
2896   align_adjust = false;
2897   for (current = abfd->sections;
2898        current != (asection *) NULL;
2899        current = current->next)
2900     {
2901 #ifdef COFF_IMAGE_WITH_PE
2902       /* With PE we have to pad each section to be a multiple of its
2903          page size too, and remember both sizes.  */
2904       if (coff_section_data (abfd, current) == NULL)
2905         {
2906           current->used_by_bfd =
2907             (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
2908           if (current->used_by_bfd == NULL)
2909             return false;
2910         }
2911       if (pei_section_data (abfd, current) == NULL)
2912         {
2913           coff_section_data (abfd, current)->tdata =
2914             (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
2915           if (coff_section_data (abfd, current)->tdata == NULL)
2916             return false;
2917         }
2918       if (pei_section_data (abfd, current)->virt_size == 0)
2919         pei_section_data (abfd, current)->virt_size = current->_raw_size;
2920 #endif
2921
2922       /* Only deal with sections which have contents.  */
2923       if (!(current->flags & SEC_HAS_CONTENTS))
2924         continue;
2925
2926 #ifdef COFF_IMAGE_WITH_PE
2927       /* Make sure we skip empty sections in a PE image.  */
2928       if (current->_raw_size == 0)
2929         continue;
2930 #endif
2931
2932       /* Align the sections in the file to the same boundary on
2933          which they are aligned in virtual memory.  I960 doesn't
2934          do this (FIXME) so we can stay in sync with Intel.  960
2935          doesn't yet page from files... */
2936 #ifdef ALIGN_SECTIONS_IN_FILE
2937       if ((abfd->flags & EXEC_P) != 0)
2938         {
2939           /* make sure this section is aligned on the right boundary - by
2940              padding the previous section up if necessary */
2941
2942           old_sofar = sofar;
2943           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2944           if (previous != (asection *) NULL)
2945             {
2946               previous->_raw_size += sofar - old_sofar;
2947             }
2948         }
2949
2950 #endif
2951
2952       /* In demand paged files the low order bits of the file offset
2953          must match the low order bits of the virtual address.  */
2954 #ifdef COFF_PAGE_SIZE
2955       if ((abfd->flags & D_PAGED) != 0
2956           && (current->flags & SEC_ALLOC) != 0)
2957         sofar += (current->vma - sofar) % page_size;
2958 #endif
2959       current->filepos = sofar;
2960
2961 #ifdef COFF_IMAGE_WITH_PE
2962       /* Set the padded size.  */
2963       current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2964 #endif
2965
2966       sofar += current->_raw_size;
2967
2968 #ifdef ALIGN_SECTIONS_IN_FILE
2969       /* make sure that this section is of the right size too */
2970       if ((abfd->flags & EXEC_P) == 0)
2971         {
2972           bfd_size_type old_size;
2973
2974           old_size = current->_raw_size;
2975           current->_raw_size = BFD_ALIGN (current->_raw_size,
2976                                           1 << current->alignment_power);
2977           align_adjust = current->_raw_size != old_size;
2978           sofar += current->_raw_size - old_size;
2979         }
2980       else
2981         {
2982           old_sofar = sofar;
2983           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2984           align_adjust = sofar != old_sofar;
2985           current->_raw_size += sofar - old_sofar;
2986         }
2987 #endif
2988
2989 #ifdef COFF_IMAGE_WITH_PE
2990       /* For PE we need to make sure we pad out to the aligned
2991          _raw_size, in case the caller only writes out data to the
2992          unaligned _raw_size.  */
2993       if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
2994         align_adjust = true;
2995 #endif
2996
2997 #ifdef _LIB
2998       /* Force .lib sections to start at zero.  The vma is then
2999          incremented in coff_set_section_contents.  This is right for
3000          SVR3.2.  */
3001       if (strcmp (current->name, _LIB) == 0)
3002         bfd_set_section_vma (abfd, current, 0);
3003 #endif
3004
3005       previous = current;
3006     }
3007
3008   /* It is now safe to write to the output file.  If we needed an
3009      alignment adjustment for the last section, then make sure that
3010      there is a byte at offset sofar.  If there are no symbols and no
3011      relocs, then nothing follows the last section.  If we don't force
3012      the last byte out, then the file may appear to be truncated.  */
3013   if (align_adjust)
3014     {
3015       bfd_byte b;
3016
3017       b = 0;
3018       if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3019           || bfd_write (&b, 1, 1, abfd) != 1)
3020         return false;
3021     }
3022
3023   /* Make sure the relocations are aligned.  We don't need to make
3024      sure that this byte exists, because it will only matter if there
3025      really are relocs.  */
3026   sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3027
3028   obj_relocbase (abfd) = sofar;
3029   abfd->output_has_begun = true;
3030
3031   return true;
3032 }
3033
3034 #if 0
3035
3036 /* This can never work, because it is called too late--after the
3037    section positions have been set.  I can't figure out what it is
3038    for, so I am going to disable it--Ian Taylor 20 March 1996.  */
3039
3040 /* If .file, .text, .data, .bss symbols are missing, add them.  */
3041 /* @@ Should we only be adding missing symbols, or overriding the aux
3042    values for existing section symbols?  */
3043 static boolean
3044 coff_add_missing_symbols (abfd)
3045      bfd *abfd;
3046 {
3047   unsigned int nsyms = bfd_get_symcount (abfd);
3048   asymbol **sympp = abfd->outsymbols;
3049   asymbol **sympp2;
3050   unsigned int i;
3051   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3052
3053   for (i = 0; i < nsyms; i++)
3054     {
3055       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3056       CONST char *name;
3057       if (csym)
3058         {
3059           /* only do this if there is a coff representation of the input
3060            symbol */
3061           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3062             {
3063               need_file = 0;
3064               continue;
3065             }
3066           name = csym->symbol.name;
3067           if (!name)
3068             continue;
3069           if (!strcmp (name, _TEXT))
3070             need_text = 0;
3071 #ifdef APOLLO_M68
3072           else if (!strcmp (name, ".wtext"))
3073             need_text = 0;
3074 #endif
3075           else if (!strcmp (name, _DATA))
3076             need_data = 0;
3077           else if (!strcmp (name, _BSS))
3078             need_bss = 0;
3079         }
3080     }
3081   /* Now i == bfd_get_symcount (abfd).  */
3082   /* @@ For now, don't deal with .file symbol.  */
3083   need_file = 0;
3084
3085   if (!need_text && !need_data && !need_bss && !need_file)
3086     return true;
3087   nsyms += need_text + need_data + need_bss + need_file;
3088   sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
3089   if (!sympp2)
3090     return false;
3091   memcpy (sympp2, sympp, i * sizeof (asymbol *));
3092   if (need_file)
3093     {
3094       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
3095       abort ();
3096     }
3097   if (need_text)
3098     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3099   if (need_data)
3100     sympp2[i++] = coff_section_symbol (abfd, _DATA);
3101   if (need_bss)
3102     sympp2[i++] = coff_section_symbol (abfd, _BSS);
3103   BFD_ASSERT (i == nsyms);
3104   bfd_set_symtab (abfd, sympp2, nsyms);
3105   return true;
3106 }
3107
3108 #endif /* 0 */
3109
3110 /* SUPPRESS 558 */
3111 /* SUPPRESS 529 */
3112 static boolean
3113 coff_write_object_contents (abfd)
3114      bfd * abfd;
3115 {
3116   asection *current;
3117   boolean hasrelocs = false;
3118   boolean haslinno = false;
3119   boolean hasdebug = false;
3120   file_ptr scn_base;
3121   file_ptr reloc_base;
3122   file_ptr lineno_base;
3123   file_ptr sym_base;
3124   unsigned long reloc_size = 0;
3125   unsigned long lnno_size = 0;
3126   boolean long_section_names;
3127   asection *text_sec = NULL;
3128   asection *data_sec = NULL;
3129   asection *bss_sec = NULL;
3130   struct internal_filehdr internal_f;
3131   struct internal_aouthdr internal_a;
3132 #ifdef COFF_LONG_SECTION_NAMES
3133   size_t string_size = STRING_SIZE_SIZE;
3134 #endif
3135
3136   bfd_set_error (bfd_error_system_call);
3137
3138   /* Make a pass through the symbol table to count line number entries and
3139      put them into the correct asections */
3140
3141   lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3142
3143   if (abfd->output_has_begun == false)
3144     {
3145       if (! coff_compute_section_file_positions (abfd))
3146         return false;
3147     }
3148
3149   reloc_base = obj_relocbase (abfd);
3150
3151   /* Work out the size of the reloc and linno areas */
3152
3153   for (current = abfd->sections; current != NULL; current =
3154        current->next)
3155     reloc_size += current->reloc_count * bfd_coff_relsz (abfd);
3156
3157   lineno_base = reloc_base + reloc_size;
3158   sym_base = lineno_base + lnno_size;
3159
3160   /* Indicate in each section->line_filepos its actual file address */
3161   for (current = abfd->sections; current != NULL; current =
3162        current->next)
3163     {
3164       if (current->lineno_count)
3165         {
3166           current->line_filepos = lineno_base;
3167           current->moving_line_filepos = lineno_base;
3168           lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3169         }
3170       else
3171         {
3172           current->line_filepos = 0;
3173         }
3174       if (current->reloc_count)
3175         {
3176           current->rel_filepos = reloc_base;
3177           reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3178         }
3179       else
3180         {
3181           current->rel_filepos = 0;
3182         }
3183     }
3184
3185   /* Write section headers to the file.  */
3186   internal_f.f_nscns = 0;
3187
3188   if ((abfd->flags & EXEC_P) != 0)
3189     scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3190   else
3191     {
3192       scn_base = bfd_coff_filhsz (abfd);
3193 #ifdef RS6000COFF_C
3194       if (xcoff_data (abfd)->full_aouthdr)
3195         scn_base += bfd_coff_aoutsz (abfd);
3196       else
3197         scn_base += SMALL_AOUTSZ;
3198 #endif
3199     }
3200
3201   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3202     return false;
3203
3204   long_section_names = false;
3205   for (current = abfd->sections;
3206        current != NULL;
3207        current = current->next)
3208     {
3209       struct internal_scnhdr section;
3210       boolean is_reloc_section = false;
3211
3212 #ifdef COFF_IMAGE_WITH_PE
3213       if (strcmp (current->name, ".reloc") == 0)
3214         {
3215           is_reloc_section = true;
3216           hasrelocs = true;
3217           pe_data (abfd)->has_reloc_section = 1;
3218         }
3219 #endif
3220
3221       internal_f.f_nscns++;
3222
3223       strncpy (section.s_name, current->name, SCNNMLEN);
3224
3225 #ifdef COFF_LONG_SECTION_NAMES
3226       /* Handle long section names as in PE.  This must be compatible
3227          with the code in coff_write_symbols and _bfd_coff_final_link.  */
3228       {
3229         size_t len;
3230
3231         len = strlen (current->name);
3232         if (len > SCNNMLEN)
3233           {
3234             memset (section.s_name, 0, SCNNMLEN);
3235             sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3236             string_size += len + 1;
3237             long_section_names = true;
3238           }
3239       }
3240 #endif
3241
3242 #ifdef _LIB
3243       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
3244          Ian Taylor <ian@cygnus.com>.  */
3245       if (strcmp (current->name, _LIB) == 0)
3246         section.s_vaddr = 0;
3247       else
3248 #endif
3249       section.s_vaddr = current->vma;
3250       section.s_paddr = current->lma;
3251       section.s_size =  current->_raw_size;
3252
3253 #ifdef COFF_WITH_PE
3254       section.s_paddr = 0;
3255 #endif
3256 #ifdef COFF_IMAGE_WITH_PE
3257       /* Reminder: s_paddr holds the virtual size of the section.  */
3258       if (coff_section_data (abfd, current) != NULL
3259           && pei_section_data (abfd, current) != NULL)
3260         section.s_paddr = pei_section_data (abfd, current)->virt_size;
3261       else
3262         section.s_paddr = 0;
3263 #endif
3264
3265       /*
3266          If this section has no size or is unloadable then the scnptr
3267          will be 0 too
3268          */
3269       if (current->_raw_size == 0 ||
3270           (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3271         {
3272           section.s_scnptr = 0;
3273         }
3274       else
3275         {
3276           section.s_scnptr = current->filepos;
3277         }
3278       section.s_relptr = current->rel_filepos;
3279       section.s_lnnoptr = current->line_filepos;
3280       section.s_nreloc = current->reloc_count;
3281       section.s_nlnno = current->lineno_count;
3282 #ifndef COFF_IMAGE_WITH_PE
3283       /* In PEI, relocs come in the .reloc section.  */
3284       if (current->reloc_count != 0)
3285         hasrelocs = true;
3286 #endif
3287       if (current->lineno_count != 0)
3288         haslinno = true;
3289       if ((current->flags & SEC_DEBUGGING) != 0
3290           && ! is_reloc_section)
3291         hasdebug = true;
3292
3293 #ifdef RS6000COFF_C
3294       /* Indicate the use of an XCOFF overflow section header.  */
3295       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3296         {
3297           section.s_nreloc = 0xffff;
3298           section.s_nlnno = 0xffff;
3299         }
3300 #endif
3301
3302       section.s_flags = sec_to_styp_flags (current->name, current->flags);
3303
3304       if (!strcmp (current->name, _TEXT))
3305         {
3306           text_sec = current;
3307         }
3308       else if (!strcmp (current->name, _DATA))
3309         {
3310           data_sec = current;
3311         }
3312       else if (!strcmp (current->name, _BSS))
3313         {
3314           bss_sec = current;
3315         }
3316
3317 #ifdef I960
3318       section.s_align = (current->alignment_power
3319                          ? 1 << current->alignment_power
3320                          : 0);
3321 #endif
3322 #ifdef TIC80COFF
3323       /* TI COFF puts the alignment power in bits 8-11 of the flags */
3324       section.s_flags |= (current->alignment_power & 0xF) << 8;
3325 #endif
3326 #ifdef COFF_ENCODE_ALIGNMENT
3327       COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3328 #endif
3329
3330 #ifdef COFF_IMAGE_WITH_PE
3331       /* Suppress output of the sections if they are null.  ld
3332          includes the bss and data sections even if there is no size
3333          assigned to them.  NT loader doesn't like it if these section
3334          headers are included if the sections themselves are not
3335          needed.  See also coff_compute_section_file_positions.  */
3336       if (section.s_size == 0)
3337         internal_f.f_nscns--;
3338       else
3339 #endif
3340         {
3341           SCNHDR buff;
3342           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3343               || bfd_write ((PTR) (&buff), 1, bfd_coff_scnhsz (abfd), abfd)
3344                    != bfd_coff_scnhsz (abfd))
3345             return false;
3346         }
3347
3348 #ifdef COFF_WITH_PE
3349       /* PE stores COMDAT section information in the symbol table.  If
3350          this section is supposed to have some COMDAT info, track down
3351          the symbol in the symbol table and modify it.  */
3352       if ((current->flags & SEC_LINK_ONCE) != 0)
3353         {
3354           unsigned int i, count;
3355           asymbol **psym;
3356           coff_symbol_type *csym = NULL;
3357           asymbol **psymsec;
3358
3359           psymsec = NULL;
3360           count = bfd_get_symcount (abfd);
3361           for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3362             {
3363               if ((*psym)->section != current)
3364                 continue;
3365
3366               /* Remember the location of the first symbol in this
3367                  section.  */
3368               if (psymsec == NULL)
3369                 psymsec = psym;
3370
3371               /* See if this is the section symbol.  */
3372               if (strcmp ((*psym)->name, current->name) == 0)
3373                 {
3374                   csym = coff_symbol_from (abfd, *psym);
3375                   if (csym == NULL
3376                       || csym->native == NULL
3377                       || csym->native->u.syment.n_numaux < 1
3378                       || csym->native->u.syment.n_sclass != C_STAT
3379                       || csym->native->u.syment.n_type != T_NULL)
3380                     continue;
3381
3382                   /* Here *PSYM is the section symbol for CURRENT.  */
3383
3384                   break;
3385                 }
3386             }
3387
3388           /* Did we find it?
3389              Note that we might not if we're converting the file from
3390              some other object file format.  */
3391           if (i < count)
3392             {
3393               combined_entry_type *aux;
3394
3395               /* We don't touch the x_checksum field.  The
3396                  x_associated field is not currently supported.  */
3397
3398               aux = csym->native + 1;
3399               switch (current->flags & SEC_LINK_DUPLICATES)
3400                 {
3401                 case SEC_LINK_DUPLICATES_DISCARD:
3402                   aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3403                   break;
3404
3405                 case SEC_LINK_DUPLICATES_ONE_ONLY:
3406                   aux->u.auxent.x_scn.x_comdat =
3407                     IMAGE_COMDAT_SELECT_NODUPLICATES;
3408                   break;
3409
3410                 case SEC_LINK_DUPLICATES_SAME_SIZE:
3411                   aux->u.auxent.x_scn.x_comdat =
3412                     IMAGE_COMDAT_SELECT_SAME_SIZE;
3413                   break;
3414
3415                 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3416                   aux->u.auxent.x_scn.x_comdat =
3417                     IMAGE_COMDAT_SELECT_EXACT_MATCH;
3418                   break;
3419                 }
3420
3421               /* The COMDAT symbol must be the first symbol from this
3422                  section in the symbol table.  In order to make this
3423                  work, we move the COMDAT symbol before the first
3424                  symbol we found in the search above.  It's OK to
3425                  rearrange the symbol table at this point, because
3426                  coff_renumber_symbols is going to rearrange it
3427                  further and fix up all the aux entries.  */
3428               if (psym != psymsec)
3429                 {
3430                   asymbol *hold;
3431                   asymbol **pcopy;
3432
3433                   hold = *psym;
3434                   for (pcopy = psym; pcopy > psymsec; pcopy--)
3435                     pcopy[0] = pcopy[-1];
3436                   *psymsec = hold;
3437                 }
3438             }
3439         }
3440 #endif /* COFF_WITH_PE */
3441     }
3442
3443 #ifdef RS6000COFF_C
3444   /* XCOFF handles overflows in the reloc and line number count fields
3445      by creating a new section header to hold the correct values.  */
3446   for (current = abfd->sections; current != NULL; current = current->next)
3447     {
3448       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3449         {
3450           struct internal_scnhdr scnhdr;
3451           SCNHDR buff;
3452
3453           internal_f.f_nscns++;
3454           strncpy (&(scnhdr.s_name[0]), current->name, 8);
3455           scnhdr.s_paddr = current->reloc_count;
3456           scnhdr.s_vaddr = current->lineno_count;
3457           scnhdr.s_size = 0;
3458           scnhdr.s_scnptr = 0;
3459           scnhdr.s_relptr = current->rel_filepos;
3460           scnhdr.s_lnnoptr = current->line_filepos;
3461           scnhdr.s_nreloc = current->target_index;
3462           scnhdr.s_nlnno = current->target_index;
3463           scnhdr.s_flags = STYP_OVRFLO;
3464           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3465               || bfd_write ((PTR) &buff, 1, bfd_coff_scnhsz (abfd), abfd)
3466                    != bfd_coff_scnhsz (abfd))
3467             return false;
3468         }
3469     }
3470 #endif
3471
3472   /* OK, now set up the filehdr... */
3473
3474   /* Don't include the internal abs section in the section count */
3475
3476   /*
3477      We will NOT put a fucking timestamp in the header here. Every time you
3478      put it back, I will come in and take it out again.  I'm sorry.  This
3479      field does not belong here.  We fill it with a 0 so it compares the
3480      same but is not a reasonable time. -- gnu@cygnus.com
3481      */
3482   internal_f.f_timdat = 0;
3483
3484   internal_f.f_flags = 0;
3485
3486   if (abfd->flags & EXEC_P)
3487     internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3488   else
3489     {
3490       internal_f.f_opthdr = 0;
3491 #ifdef RS6000COFF_C
3492       if (xcoff_data (abfd)->full_aouthdr)
3493         internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3494       else
3495         internal_f.f_opthdr = SMALL_AOUTSZ;
3496 #endif
3497     }
3498
3499   if (!hasrelocs)
3500     internal_f.f_flags |= F_RELFLG;
3501   if (!haslinno)
3502     internal_f.f_flags |= F_LNNO;
3503   if (abfd->flags & EXEC_P)
3504     internal_f.f_flags |= F_EXEC;
3505 #ifdef COFF_IMAGE_WITH_PE
3506   if (! hasdebug)
3507     internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3508 #endif
3509
3510 #ifndef COFF_WITH_PE
3511   if (bfd_little_endian (abfd))
3512     internal_f.f_flags |= F_AR32WR;
3513   else
3514     internal_f.f_flags |= F_AR32W;
3515 #endif
3516
3517 #ifdef TI_TARGET_ID
3518   /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3519      but it doesn't hurt to set it internally */
3520   internal_f.f_target_id = TI_TARGET_ID;
3521 #endif
3522 #ifdef TIC80_TARGET_ID
3523   internal_f.f_target_id = TIC80_TARGET_ID;
3524 #endif
3525
3526   /*
3527      FIXME, should do something about the other byte orders and
3528      architectures.
3529      */
3530
3531 #ifdef RS6000COFF_C
3532   if ((abfd->flags & DYNAMIC) != 0)
3533     internal_f.f_flags |= F_SHROBJ;
3534   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3535     internal_f.f_flags |= F_DYNLOAD;
3536 #endif
3537
3538   memset (&internal_a, 0, sizeof internal_a);
3539
3540   /* Set up architecture-dependent stuff */
3541
3542   {
3543     unsigned int magic = 0;
3544     unsigned short flags = 0;
3545     coff_set_flags (abfd, &magic, &flags);
3546     internal_f.f_magic = magic;
3547     internal_f.f_flags |= flags;
3548     /* ...and the "opt"hdr... */
3549
3550 #ifdef A29K
3551 #ifdef ULTRA3                   /* NYU's machine */
3552     /* FIXME: This is a bogus check.  I really want to see if there
3553      * is a .shbss or a .shdata section, if so then set the magic
3554      * number to indicate a shared data executable.
3555      */
3556     if (internal_f.f_nscns >= 7)
3557       internal_a.magic = SHMAGIC; /* Shared magic */
3558     else
3559 #endif /* ULTRA3 */
3560       internal_a.magic = NMAGIC; /* Assume separate i/d */
3561 #define __A_MAGIC_SET__
3562 #endif /* A29K */
3563 #ifdef TICOFF_AOUT_MAGIC
3564     internal_a.magic = TICOFF_AOUT_MAGIC;
3565 #define __A_MAGIC_SET__
3566 #endif
3567 #ifdef TIC80COFF
3568     internal_a.magic = TIC80_ARCH_MAGIC;
3569 #define __A_MAGIC_SET__
3570 #endif /* TIC80 */
3571 #ifdef I860
3572     /* FIXME: What are the a.out magic numbers for the i860?  */
3573     internal_a.magic = 0;
3574 #define __A_MAGIC_SET__
3575 #endif /* I860 */
3576 #ifdef I960
3577     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3578 #define __A_MAGIC_SET__
3579 #endif /* I960 */
3580 #if M88
3581 #define __A_MAGIC_SET__
3582     internal_a.magic = PAGEMAGICBCS;
3583 #endif /* M88 */
3584
3585 #if APOLLO_M68
3586 #define __A_MAGIC_SET__
3587     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3588 #endif
3589
3590 #if defined(M68) || defined(WE32K) || defined(M68K)
3591 #define __A_MAGIC_SET__
3592 #if defined(LYNXOS)
3593     internal_a.magic = LYNXCOFFMAGIC;
3594 #else
3595 #if defined(TARG_AUX)
3596     internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3597                         abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3598                         PAGEMAGICEXECSWAPPED);
3599 #else
3600 #if defined (PAGEMAGICPEXECPAGED)
3601     internal_a.magic = PAGEMAGICPEXECPAGED;
3602 #endif
3603 #endif /* TARG_AUX */
3604 #endif /* LYNXOS */
3605 #endif /* M68 || WE32K || M68K */
3606
3607 #if defined(ARM)
3608 #define __A_MAGIC_SET__
3609     internal_a.magic = ZMAGIC;
3610 #endif
3611
3612 #if defined(PPC_PE)
3613 #define __A_MAGIC_SET__
3614     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3615 #endif
3616
3617 #if defined MCORE_PE
3618 #define __A_MAGIC_SET__
3619     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3620 #endif
3621
3622 #if defined(I386)
3623 #define __A_MAGIC_SET__
3624 #if defined(LYNXOS)
3625     internal_a.magic = LYNXCOFFMAGIC;
3626 #else  /* LYNXOS */
3627     internal_a.magic = ZMAGIC;
3628 #endif /* LYNXOS */
3629 #endif /* I386 */
3630
3631 #if defined(SPARC)
3632 #define __A_MAGIC_SET__
3633 #if defined(LYNXOS)
3634     internal_a.magic = LYNXCOFFMAGIC;
3635 #endif /* LYNXOS */
3636 #endif /* SPARC */
3637
3638 #ifdef RS6000COFF_C
3639 #define __A_MAGIC_SET__
3640     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3641     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3642     RS6K_AOUTHDR_OMAGIC;
3643 #endif
3644
3645 #if defined(SH) && defined(COFF_WITH_PE)
3646 #define __A_MAGIC_SET__
3647     internal_a.magic = SH_PE_MAGIC;
3648 #endif
3649
3650 #if defined(MIPS) && defined(COFF_WITH_PE)
3651 #define __A_MAGIC_SET__
3652     internal_a.magic = MIPS_PE_MAGIC;
3653 #endif
3654
3655 #ifndef __A_MAGIC_SET__
3656 #include "Your aouthdr magic number is not being set!"
3657 #else
3658 #undef __A_MAGIC_SET__
3659 #endif
3660   }
3661
3662   /* FIXME: Does anybody ever set this to another value?  */
3663   internal_a.vstamp = 0;
3664
3665   /* Now should write relocs, strings, syms */
3666   obj_sym_filepos (abfd) = sym_base;
3667
3668   if (bfd_get_symcount (abfd) != 0)
3669     {
3670       int firstundef;
3671 #if 0
3672       if (!coff_add_missing_symbols (abfd))
3673         return false;
3674 #endif
3675       if (!coff_renumber_symbols (abfd, &firstundef))
3676         return false;
3677       coff_mangle_symbols (abfd);
3678       if (! coff_write_symbols (abfd))
3679         return false;
3680       if (! coff_write_linenumbers (abfd))
3681         return false;
3682       if (! coff_write_relocs (abfd, firstundef))
3683         return false;
3684     }
3685 #ifdef COFF_LONG_SECTION_NAMES
3686   else if (long_section_names)
3687     {
3688       /* If we have long section names we have to write out the string
3689          table even if there are no symbols.  */
3690       if (! coff_write_symbols (abfd))
3691         return false;
3692     }
3693 #endif
3694 #ifdef COFF_IMAGE_WITH_PE
3695 #ifdef PPC_PE
3696   else if ((abfd->flags & EXEC_P) != 0)
3697     {
3698       bfd_byte b;
3699
3700       /* PowerPC PE appears to require that all executable files be
3701          rounded up to the page size.  */
3702       b = 0;
3703       if (bfd_seek (abfd,
3704                     BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3705                     SEEK_SET) != 0
3706           || bfd_write (&b, 1, 1, abfd) != 1)
3707         return false;
3708     }
3709 #endif
3710 #endif
3711
3712   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3713      backend linker, and obj_raw_syment_count is not valid until after
3714      coff_write_symbols is called.  */
3715   if (obj_raw_syment_count (abfd) != 0)
3716     {
3717       internal_f.f_symptr = sym_base;
3718 #ifdef RS6000COFF_C
3719       /* AIX appears to require that F_RELFLG not be set if there are
3720          local symbols but no relocations.  */
3721       internal_f.f_flags &=~ F_RELFLG;
3722 #endif
3723     }
3724   else
3725     {
3726       if (long_section_names)
3727         internal_f.f_symptr = sym_base;
3728       else
3729         internal_f.f_symptr = 0;
3730       internal_f.f_flags |= F_LSYMS;
3731     }
3732
3733   if (text_sec)
3734     {
3735       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3736       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3737     }
3738   if (data_sec)
3739     {
3740       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3741       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3742     }
3743   if (bss_sec)
3744     {
3745       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3746       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3747         internal_a.data_start = bss_sec->vma;
3748     }
3749
3750   internal_a.entry = bfd_get_start_address (abfd);
3751   internal_f.f_nsyms = obj_raw_syment_count (abfd);
3752
3753 #ifdef RS6000COFF_C
3754   if (xcoff_data (abfd)->full_aouthdr)
3755     {
3756       bfd_vma toc;
3757       asection *loader_sec;
3758
3759       internal_a.vstamp = 1;
3760
3761       internal_a.o_snentry = xcoff_data (abfd)->snentry;
3762       if (internal_a.o_snentry == 0)
3763         internal_a.entry = (bfd_vma) -1;
3764
3765       if (text_sec != NULL)
3766         {
3767           internal_a.o_sntext = text_sec->target_index;
3768           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3769         }
3770       else
3771         {
3772           internal_a.o_sntext = 0;
3773           internal_a.o_algntext = 0;
3774         }
3775       if (data_sec != NULL)
3776         {
3777           internal_a.o_sndata = data_sec->target_index;
3778           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3779         }
3780       else
3781         {
3782           internal_a.o_sndata = 0;
3783           internal_a.o_algndata = 0;
3784         }
3785       loader_sec = bfd_get_section_by_name (abfd, ".loader");
3786       if (loader_sec != NULL)
3787         internal_a.o_snloader = loader_sec->target_index;
3788       else
3789         internal_a.o_snloader = 0;
3790       if (bss_sec != NULL)
3791         internal_a.o_snbss = bss_sec->target_index;
3792       else
3793         internal_a.o_snbss = 0;
3794
3795       toc = xcoff_data (abfd)->toc;
3796       internal_a.o_toc = toc;
3797       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3798
3799       internal_a.o_modtype = xcoff_data (abfd)->modtype;
3800       if (xcoff_data (abfd)->cputype != -1)
3801         internal_a.o_cputype = xcoff_data (abfd)->cputype;
3802       else
3803         {
3804           switch (bfd_get_arch (abfd))
3805             {
3806             case bfd_arch_rs6000:
3807               internal_a.o_cputype = 4;
3808               break;
3809             case bfd_arch_powerpc:
3810               if (bfd_get_mach (abfd) == 0)
3811                 internal_a.o_cputype = 3;
3812               else
3813                 internal_a.o_cputype = 1;
3814               break;
3815             default:
3816               abort ();
3817             }
3818         }
3819       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3820       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3821     }
3822 #endif
3823
3824   /* now write them */
3825   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3826     return false;
3827
3828   {
3829     char * buff;
3830     bfd_size_type amount;
3831
3832     buff = bfd_malloc (bfd_coff_filhsz (abfd));
3833     if (buff == NULL)
3834       return false;
3835
3836     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
3837     amount = bfd_write ((PTR) buff, 1, bfd_coff_filhsz (abfd), abfd);
3838
3839     free (buff);
3840
3841     if (amount != bfd_coff_filhsz (abfd))
3842       return false;
3843   }
3844
3845   if (abfd->flags & EXEC_P)
3846     {
3847       /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3848          include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3849       char * buff;
3850       bfd_size_type amount;
3851
3852       buff = bfd_malloc (bfd_coff_aoutsz (abfd));
3853       if (buff == NULL)
3854         return false;
3855
3856       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
3857       amount = bfd_write ((PTR) buff, 1, bfd_coff_aoutsz (abfd), abfd);
3858
3859       free (buff);
3860
3861       if (amount != bfd_coff_aoutsz (abfd))
3862         return false;
3863     }
3864 #ifdef RS6000COFF_C
3865   else
3866     {
3867       AOUTHDR buff;
3868       size_t size;
3869
3870       /* XCOFF seems to always write at least a small a.out header.  */
3871       coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
3872       if (xcoff_data (abfd)->full_aouthdr)
3873         size = bfd_coff_aoutsz (abfd);
3874       else
3875         size = SMALL_AOUTSZ;
3876       if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
3877         return false;
3878     }
3879 #endif
3880
3881   return true;
3882 }
3883
3884 static boolean
3885 coff_set_section_contents (abfd, section, location, offset, count)
3886      bfd * abfd;
3887      sec_ptr section;
3888      PTR location;
3889      file_ptr offset;
3890      bfd_size_type count;
3891 {
3892   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
3893     {
3894       if (! coff_compute_section_file_positions (abfd))
3895         return false;
3896     }
3897
3898 #if defined(_LIB) && !defined(TARG_AUX)
3899
3900    /* The physical address field of a .lib section is used to hold the
3901       number of shared libraries in the section.  This code counts the
3902       number of sections being written, and increments the lma field
3903       with the number.
3904
3905       I have found no documentation on the contents of this section.
3906       Experimentation indicates that the section contains zero or more
3907       records, each of which has the following structure:
3908
3909       - a (four byte) word holding the length of this record, in words,
3910       - a word that always seems to be set to "2",
3911       - the path to a shared library, null-terminated and then padded
3912         to a whole word boundary.
3913
3914       bfd_assert calls have been added to alert if an attempt is made
3915       to write a section which doesn't follow these assumptions.  The
3916       code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3917       <robertl@arnet.com> (Thanks!).
3918
3919       Gvran Uddeborg <gvran@uddeborg.pp.se> */
3920
3921     if (strcmp (section->name, _LIB) == 0)
3922       {
3923         bfd_byte *rec, *recend;
3924
3925         rec = (bfd_byte *) location;
3926         recend = rec + count;
3927         while (rec < recend)
3928           {
3929             ++section->lma;
3930             rec += bfd_get_32 (abfd, rec) * 4;
3931           }
3932
3933         BFD_ASSERT (rec == recend);
3934       }
3935
3936 #endif
3937
3938   /* Don't write out bss sections - one way to do this is to
3939        see if the filepos has not been set. */
3940   if (section->filepos == 0)
3941     return true;
3942
3943   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
3944     return false;
3945
3946   if (count != 0)
3947     {
3948       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3949     }
3950   return true;
3951 }
3952 #if 0
3953 static boolean
3954 coff_close_and_cleanup (abfd)
3955      bfd *abfd;
3956 {
3957   if (!bfd_read_p (abfd))
3958     switch (abfd->format)
3959       {
3960       case bfd_archive:
3961         if (!_bfd_write_archive_contents (abfd))
3962           return false;
3963         break;
3964       case bfd_object:
3965         if (!coff_write_object_contents (abfd))
3966           return false;
3967         break;
3968       default:
3969         bfd_set_error (bfd_error_invalid_operation);
3970         return false;
3971       }
3972
3973   /* We depend on bfd_close to free all the memory on the objalloc.  */
3974   return true;
3975 }
3976
3977 #endif
3978
3979 static PTR
3980 buy_and_read (abfd, where, seek_direction, size)
3981      bfd *abfd;
3982      file_ptr where;
3983      int seek_direction;
3984      size_t size;
3985 {
3986   PTR area = (PTR) bfd_alloc (abfd, size);
3987   if (!area)
3988     return (NULL);
3989   if (bfd_seek (abfd, where, seek_direction) != 0
3990       || bfd_read (area, 1, size, abfd) != size)
3991     return (NULL);
3992   return (area);
3993 }                               /* buy_and_read() */
3994
3995 /*
3996 SUBSUBSECTION
3997         Reading linenumbers
3998
3999         Creating the linenumber table is done by reading in the entire
4000         coff linenumber table, and creating another table for internal use.
4001
4002         A coff linenumber table is structured so that each function
4003         is marked as having a line number of 0. Each line within the
4004         function is an offset from the first line in the function. The
4005         base of the line number information for the table is stored in
4006         the symbol associated with the function.
4007
4008         Note: The PE format uses line number 0 for a flag indicating a
4009         new source file.
4010
4011         The information is copied from the external to the internal
4012         table, and each symbol which marks a function is marked by
4013         pointing its...
4014
4015         How does this work ?
4016
4017 */
4018
4019 static boolean
4020 coff_slurp_line_table (abfd, asect)
4021      bfd *abfd;
4022      asection *asect;
4023 {
4024   LINENO *native_lineno;
4025   alent *lineno_cache;
4026
4027   BFD_ASSERT (asect->lineno == (alent *) NULL);
4028
4029   native_lineno = (LINENO *) buy_and_read (abfd,
4030                                            asect->line_filepos,
4031                                            SEEK_SET,
4032                                            (size_t) (bfd_coff_linesz (abfd) *
4033                                                      asect->lineno_count));
4034   lineno_cache =
4035     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
4036   if (lineno_cache == NULL)
4037     return false;
4038   else
4039     {
4040       unsigned int counter = 0;
4041       alent *cache_ptr = lineno_cache;
4042       LINENO *src = native_lineno;
4043
4044       while (counter < asect->lineno_count)
4045         {
4046           struct internal_lineno dst;
4047           coff_swap_lineno_in (abfd, src, &dst);
4048           cache_ptr->line_number = dst.l_lnno;
4049
4050           if (cache_ptr->line_number == 0)
4051             {
4052               boolean warned;
4053               long symndx;
4054               coff_symbol_type *sym;
4055
4056               warned = false;
4057               symndx = dst.l_addr.l_symndx;
4058               if (symndx < 0
4059                   || (unsigned long) symndx >= obj_raw_syment_count (abfd))
4060                 {
4061                   (*_bfd_error_handler)
4062                     (_("%s: warning: illegal symbol index %ld in line numbers"),
4063                      bfd_get_filename (abfd), dst.l_addr.l_symndx);
4064                   symndx = 0;
4065                   warned = true;
4066                 }
4067               /* FIXME: We should not be casting between ints and
4068                  pointers like this.  */
4069               sym = ((coff_symbol_type *)
4070                      ((symndx + obj_raw_syments (abfd))
4071                       ->u.syment._n._n_n._n_zeroes));
4072               cache_ptr->u.sym = (asymbol *) sym;
4073               if (sym->lineno != NULL && ! warned)
4074                 {
4075                   (*_bfd_error_handler)
4076                     (_("%s: warning: duplicate line number information for `%s'"),
4077                      bfd_get_filename (abfd),
4078                      bfd_asymbol_name (&sym->symbol));
4079                 }
4080               sym->lineno = cache_ptr;
4081             }
4082           else
4083             {
4084               cache_ptr->u.offset = dst.l_addr.l_paddr
4085                 - bfd_section_vma (abfd, asect);
4086             }                   /* If no linenumber expect a symbol index */
4087
4088           cache_ptr++;
4089           src++;
4090           counter++;
4091         }
4092       cache_ptr->line_number = 0;
4093
4094     }
4095   asect->lineno = lineno_cache;
4096   /* FIXME, free native_lineno here, or use alloca or something. */
4097   return true;
4098 }
4099
4100 /* Slurp in the symbol table, converting it to generic form.  Note
4101    that if coff_relocate_section is defined, the linker will read
4102    symbols via coff_link_add_symbols, rather than via this routine.  */
4103
4104 static boolean
4105 coff_slurp_symbol_table (abfd)
4106      bfd * abfd;
4107 {
4108   combined_entry_type *native_symbols;
4109   coff_symbol_type *cached_area;
4110   unsigned int *table_ptr;
4111
4112   unsigned int number_of_symbols = 0;
4113
4114   if (obj_symbols (abfd))
4115     return true;
4116
4117   /* Read in the symbol table */
4118   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4119     {
4120       return (false);
4121     }                           /* on error */
4122
4123   /* Allocate enough room for all the symbols in cached form */
4124   cached_area = ((coff_symbol_type *)
4125                  bfd_alloc (abfd,
4126                             (obj_raw_syment_count (abfd)
4127                              * sizeof (coff_symbol_type))));
4128
4129   if (cached_area == NULL)
4130     return false;
4131   table_ptr = ((unsigned int *)
4132                bfd_alloc (abfd,
4133                           (obj_raw_syment_count (abfd)
4134                            * sizeof (unsigned int))));
4135
4136   if (table_ptr == NULL)
4137     return false;
4138   else
4139     {
4140       coff_symbol_type *dst = cached_area;
4141       unsigned int last_native_index = obj_raw_syment_count (abfd);
4142       unsigned int this_index = 0;
4143       while (this_index < last_native_index)
4144         {
4145           combined_entry_type *src = native_symbols + this_index;
4146           table_ptr[this_index] = number_of_symbols;
4147           dst->symbol.the_bfd = abfd;
4148
4149           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4150           /* We use the native name field to point to the cached field.  */
4151           src->u.syment._n._n_n._n_zeroes = (long) dst;
4152           dst->symbol.section = coff_section_from_bfd_index (abfd,
4153                                                      src->u.syment.n_scnum);
4154           dst->symbol.flags = 0;
4155           dst->done_lineno = false;
4156
4157           switch (src->u.syment.n_sclass)
4158             {
4159 #ifdef I960
4160             case C_LEAFEXT:
4161 #if 0
4162               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4163               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4164               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4165 #endif
4166               /* Fall through to next case */
4167
4168 #endif
4169
4170             case C_EXT:
4171             case C_WEAKEXT:
4172 #if defined ARM
4173             case C_THUMBEXT:
4174             case C_THUMBEXTFUNC:
4175 #endif
4176 #ifdef RS6000COFF_C
4177             case C_HIDEXT:
4178 #endif
4179 #ifdef C_SYSTEM
4180             case C_SYSTEM:      /* System Wide variable */
4181 #endif
4182 #ifdef COFF_WITH_PE
4183             /* In PE, 0x68 (104) denotes a section symbol */
4184             case C_SECTION:
4185             /* In PE, 0x69 (105) denotes a weak external symbol.  */
4186             case C_NT_WEAK:
4187 #endif
4188               switch (coff_classify_symbol (abfd, &src->u.syment))
4189                 {
4190                 case COFF_SYMBOL_GLOBAL:
4191                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4192 #if defined COFF_WITH_PE
4193                   /* PE sets the symbol to a value relative to the
4194                      start of the section.  */
4195                   dst->symbol.value = src->u.syment.n_value;
4196 #else
4197                   dst->symbol.value = (src->u.syment.n_value
4198                                        - dst->symbol.section->vma);
4199 #endif
4200                   if (ISFCN ((src->u.syment.n_type)))
4201                     {
4202                       /* A function ext does not go at the end of a
4203                          file.  */
4204                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4205                     }
4206                   break;
4207
4208                 case COFF_SYMBOL_COMMON:
4209                   dst->symbol.section = bfd_com_section_ptr;
4210                   dst->symbol.value = src->u.syment.n_value;
4211                   break;
4212
4213                 case COFF_SYMBOL_UNDEFINED:
4214                   dst->symbol.section = bfd_und_section_ptr;
4215                   dst->symbol.value = 0;
4216                   break;
4217
4218                 case COFF_SYMBOL_PE_SECTION:
4219                   dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4220                   dst->symbol.value = 0;
4221                   break;
4222
4223                 case COFF_SYMBOL_LOCAL:
4224                   dst->symbol.flags = BSF_LOCAL;
4225 #if defined COFF_WITH_PE
4226                   /* PE sets the symbol to a value relative to the
4227                      start of the section.  */
4228                   dst->symbol.value = src->u.syment.n_value;
4229 #else
4230                   dst->symbol.value = (src->u.syment.n_value
4231                                        - dst->symbol.section->vma);
4232 #endif
4233                   if (ISFCN ((src->u.syment.n_type)))
4234                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4235                   break;
4236                 }
4237
4238 #ifdef RS6000COFF_C
4239               /* A symbol with a csect entry should not go at the end.  */
4240               if (src->u.syment.n_numaux > 0)
4241                 dst->symbol.flags |= BSF_NOT_AT_END;
4242 #endif
4243
4244 #ifdef COFF_WITH_PE
4245               if (src->u.syment.n_sclass == C_NT_WEAK)
4246                 dst->symbol.flags = BSF_WEAK;
4247               if (src->u.syment.n_sclass == C_SECTION
4248                   && src->u.syment.n_scnum > 0)
4249                 {
4250                   dst->symbol.flags = BSF_LOCAL;
4251                 }
4252 #endif
4253
4254               if (src->u.syment.n_sclass == C_WEAKEXT)
4255                 dst->symbol.flags = BSF_WEAK;
4256
4257               break;
4258
4259             case C_STAT:        /* static                        */
4260 #ifdef I960
4261             case C_LEAFSTAT:    /* static leaf procedure        */
4262 #endif
4263 #if defined ARM
4264             case C_THUMBSTAT:   /* Thumb static                  */
4265             case C_THUMBLABEL:  /* Thumb label                   */
4266             case C_THUMBSTATFUNC:/* Thumb static function        */
4267 #endif
4268             case C_LABEL:       /* label                         */
4269               if (src->u.syment.n_scnum == N_DEBUG)
4270                 dst->symbol.flags = BSF_DEBUGGING;
4271               else
4272                 dst->symbol.flags = BSF_LOCAL;
4273
4274               /* Base the value as an index from the base of the
4275                  section, if there is one.  */
4276               if (dst->symbol.section)
4277                 {
4278 #if defined COFF_WITH_PE
4279                   /* PE sets the symbol to a value relative to the
4280                      start of the section.  */
4281                   dst->symbol.value = src->u.syment.n_value;
4282 #else
4283                   dst->symbol.value = (src->u.syment.n_value
4284                                        - dst->symbol.section->vma);
4285 #endif
4286                 }
4287               else
4288                 dst->symbol.value = src->u.syment.n_value;
4289               break;
4290
4291             case C_MOS: /* member of structure   */
4292             case C_EOS: /* end of structure              */
4293 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
4294 #ifdef C_GLBLREG
4295             case C_GLBLREG:     /* A29k-specific storage class */
4296 #endif
4297 #endif
4298             case C_REGPARM:     /* register parameter            */
4299             case C_REG: /* register variable             */
4300               /* C_AUTOARG conflictes with TI COFF C_UEXT */
4301 #if !defined (TIC80COFF) && !defined (TICOFF)
4302 #ifdef C_AUTOARG
4303             case C_AUTOARG:     /* 960-specific storage class */
4304 #endif
4305 #endif
4306             case C_TPDEF:       /* type definition               */
4307             case C_ARG:
4308             case C_AUTO:        /* automatic variable */
4309             case C_FIELD:       /* bit field */
4310             case C_ENTAG:       /* enumeration tag               */
4311             case C_MOE: /* member of enumeration         */
4312             case C_MOU: /* member of union               */
4313             case C_UNTAG:       /* union tag                     */
4314               dst->symbol.flags = BSF_DEBUGGING;
4315               dst->symbol.value = (src->u.syment.n_value);
4316               break;
4317
4318             case C_FILE:        /* file name                     */
4319             case C_STRTAG:      /* structure tag                 */
4320 #ifdef RS6000COFF_C
4321             case C_GSYM:
4322             case C_LSYM:
4323             case C_PSYM:
4324             case C_RSYM:
4325             case C_RPSYM:
4326             case C_STSYM:
4327             case C_BCOMM:
4328             case C_ECOMM:
4329             case C_DECL:
4330             case C_ENTRY:
4331             case C_FUN:
4332             case C_ESTAT:
4333 #endif
4334               dst->symbol.flags = BSF_DEBUGGING;
4335               dst->symbol.value = (src->u.syment.n_value);
4336               break;
4337
4338 #ifdef RS6000COFF_C
4339             case C_BINCL:       /* beginning of include file     */
4340             case C_EINCL:       /* ending of include file        */
4341               /* The value is actually a pointer into the line numbers
4342                  of the file.  We locate the line number entry, and
4343                  set the section to the section which contains it, and
4344                  the value to the index in that section.  */
4345               {
4346                 asection *sec;
4347
4348                 dst->symbol.flags = BSF_DEBUGGING;
4349                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4350                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4351                       && ((file_ptr) (sec->line_filepos
4352                                       + sec->lineno_count * bfd_coff_linesz (abfd))
4353                           > (file_ptr) src->u.syment.n_value))
4354                     break;
4355                 if (sec == NULL)
4356                   dst->symbol.value = 0;
4357                 else
4358                   {
4359                     dst->symbol.section = sec;
4360                     dst->symbol.value = ((src->u.syment.n_value
4361                                           - sec->line_filepos)
4362                                          / bfd_coff_linesz (abfd));
4363                     src->fix_line = 1;
4364                   }
4365               }
4366               break;
4367
4368             case C_BSTAT:
4369               dst->symbol.flags = BSF_DEBUGGING;
4370
4371               /* The value is actually a symbol index.  Save a pointer
4372                  to the symbol instead of the index.  FIXME: This
4373                  should use a union.  */
4374               src->u.syment.n_value =
4375                 (long) (native_symbols + src->u.syment.n_value);
4376               dst->symbol.value = src->u.syment.n_value;
4377               src->fix_value = 1;
4378               break;
4379 #endif
4380
4381             case C_BLOCK:       /* ".bb" or ".eb"                */
4382             case C_FCN:         /* ".bf" or ".ef" (or PE ".lf")  */
4383             case C_EFCN:        /* physical end of function      */
4384 #if defined COFF_WITH_PE
4385               /* PE sets the symbol to a value relative to the start
4386                  of the section.  */
4387               dst->symbol.value = src->u.syment.n_value;
4388               if (strcmp (dst->symbol.name, ".bf") != 0)
4389                 {
4390                   /* PE uses funny values for .ef and .lf; don't
4391                      relocate them.  */
4392                   dst->symbol.flags = BSF_DEBUGGING;
4393                 }
4394               else
4395                 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4396 #else
4397               /* Base the value as an index from the base of the
4398                  section.  */
4399               dst->symbol.flags = BSF_LOCAL;
4400               dst->symbol.value = (src->u.syment.n_value
4401                                    - dst->symbol.section->vma);
4402 #endif
4403               break;
4404
4405             case C_STATLAB:     /* Static load time label */
4406               dst->symbol.value = src->u.syment.n_value;
4407               dst->symbol.flags = BSF_GLOBAL;
4408               break;
4409
4410             case C_NULL:
4411               /* PE DLLs sometimes have zeroed out symbols for some
4412                  reason.  Just ignore them without a warning.  */
4413               if (src->u.syment.n_type == 0
4414                   && src->u.syment.n_value == 0
4415                   && src->u.syment.n_scnum == 0)
4416                 break;
4417               /* Fall through.  */
4418             case C_EXTDEF:      /* external definition           */
4419             case C_ULABEL:      /* undefined label               */
4420             case C_USTATIC:     /* undefined static              */
4421 #ifndef COFF_WITH_PE
4422             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
4423                class to represent a section symbol */
4424             case C_LINE:        /* line # reformatted as symbol table entry */
4425               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
4426             case C_ALIAS:       /* duplicate tag                 */
4427 #endif
4428               /* New storage classes for TI COFF */
4429 #if defined(TIC80COFF) || defined(TICOFF)
4430             case C_UEXT:        /* Tentative external definition */
4431 #endif
4432             case C_EXTLAB:      /* External load time label */
4433             case C_HIDDEN:      /* ext symbol in dmert public lib */
4434             default:
4435               (*_bfd_error_handler)
4436                 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4437                  bfd_get_filename (abfd), src->u.syment.n_sclass,
4438                  dst->symbol.section->name, dst->symbol.name);
4439               dst->symbol.flags = BSF_DEBUGGING;
4440               dst->symbol.value = (src->u.syment.n_value);
4441               break;
4442             }
4443
4444 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
4445
4446           dst->native = src;
4447
4448           dst->symbol.udata.i = 0;
4449           dst->lineno = (alent *) NULL;
4450           this_index += (src->u.syment.n_numaux) + 1;
4451           dst++;
4452           number_of_symbols++;
4453         }                       /* walk the native symtab */
4454     }                           /* bfdize the native symtab */
4455
4456   obj_symbols (abfd) = cached_area;
4457   obj_raw_syments (abfd) = native_symbols;
4458
4459   bfd_get_symcount (abfd) = number_of_symbols;
4460   obj_convert (abfd) = table_ptr;
4461   /* Slurp the line tables for each section too */
4462   {
4463     asection *p;
4464     p = abfd->sections;
4465     while (p)
4466       {
4467         coff_slurp_line_table (abfd, p);
4468         p = p->next;
4469       }
4470   }
4471   return true;
4472 }                               /* coff_slurp_symbol_table() */
4473
4474 /* Classify a COFF symbol.  A couple of targets have globally visible
4475    symbols which are not class C_EXT, and this handles those.  It also
4476    recognizes some special PE cases.  */
4477
4478 static enum coff_symbol_classification
4479 coff_classify_symbol (abfd, syment)
4480      bfd *abfd;
4481      struct internal_syment *syment;
4482 {
4483   /* FIXME: This partially duplicates the switch in
4484      coff_slurp_symbol_table.  */
4485   switch (syment->n_sclass)
4486     {
4487     case C_EXT:
4488     case C_WEAKEXT:
4489 #ifdef I960
4490     case C_LEAFEXT:
4491 #endif
4492 #ifdef ARM
4493     case C_THUMBEXT:
4494     case C_THUMBEXTFUNC:
4495 #endif
4496 #ifdef C_SYSTEM
4497     case C_SYSTEM:
4498 #endif
4499 #ifdef COFF_WITH_PE
4500     case C_NT_WEAK:
4501 #endif
4502       if (syment->n_scnum == 0)
4503         {
4504           if (syment->n_value == 0)
4505             return COFF_SYMBOL_UNDEFINED;
4506           else
4507             return COFF_SYMBOL_COMMON;
4508         }
4509       return COFF_SYMBOL_GLOBAL;
4510
4511     default:
4512       break;
4513     }
4514
4515 #ifdef COFF_WITH_PE
4516   if (syment->n_sclass == C_STAT)
4517     {
4518       if (syment->n_scnum == 0)
4519         {
4520           /* The Microsoft compiler sometimes generates these if a
4521              small static function is inlined every time it is used.
4522              The function is discarded, but the symbol table entry
4523              remains.  */
4524           return COFF_SYMBOL_LOCAL;
4525         }
4526
4527 #ifdef STRICT_PE_FORMAT
4528       /* This is correct for Microsoft generated objects, but it
4529          breaks gas generated objects.  */
4530
4531       if (syment->n_value == 0)
4532         {
4533           asection *sec;
4534           char buf[SYMNMLEN + 1];
4535
4536           sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4537           if (sec != NULL
4538               && (strcmp (bfd_get_section_name (abfd, sec),
4539                           _bfd_coff_internal_syment_name (abfd, syment, buf))
4540                   == 0))
4541             return COFF_SYMBOL_PE_SECTION;
4542         }
4543 #endif
4544
4545       return COFF_SYMBOL_LOCAL;
4546     }
4547
4548   if (syment->n_sclass == C_SECTION)
4549     {
4550       /* In some cases in a DLL generated by the Microsoft linker, the
4551          n_value field will contain garbage.  FIXME: This should
4552          probably be handled by the swapping function instead.  */
4553       syment->n_value = 0;
4554       if (syment->n_scnum == 0)
4555         return COFF_SYMBOL_UNDEFINED;
4556       return COFF_SYMBOL_PE_SECTION;
4557     }
4558 #endif /* COFF_WITH_PE */
4559
4560   /* If it is not a global symbol, we presume it is a local symbol.  */
4561
4562   if (syment->n_scnum == 0)
4563     {
4564       char buf[SYMNMLEN + 1];
4565
4566       (*_bfd_error_handler)
4567         (_("warning: %s: local symbol `%s' has no section"),
4568          bfd_get_filename (abfd),
4569          _bfd_coff_internal_syment_name (abfd, syment, buf));
4570     }
4571
4572   return COFF_SYMBOL_LOCAL;
4573 }
4574
4575 /*
4576 SUBSUBSECTION
4577         Reading relocations
4578
4579         Coff relocations are easily transformed into the internal BFD form
4580         (@code{arelent}).
4581
4582         Reading a coff relocation table is done in the following stages:
4583
4584         o Read the entire coff relocation table into memory.
4585
4586         o Process each relocation in turn; first swap it from the
4587         external to the internal form.
4588
4589         o Turn the symbol referenced in the relocation's symbol index
4590         into a pointer into the canonical symbol table.
4591         This table is the same as the one returned by a call to
4592         @code{bfd_canonicalize_symtab}. The back end will call that
4593         routine and save the result if a canonicalization hasn't been done.
4594
4595         o The reloc index is turned into a pointer to a howto
4596         structure, in a back end specific way. For instance, the 386
4597         and 960 use the @code{r_type} to directly produce an index
4598         into a howto table vector; the 88k subtracts a number from the
4599         @code{r_type} field and creates an addend field.
4600
4601
4602 */
4603
4604 #ifndef CALC_ADDEND
4605 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
4606   {                                                             \
4607     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
4608     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
4609       coffsym = (obj_symbols (abfd)                             \
4610                  + (cache_ptr->sym_ptr_ptr - symbols));         \
4611     else if (ptr)                                               \
4612       coffsym = coff_symbol_from (abfd, ptr);                   \
4613     if (coffsym != (coff_symbol_type *) NULL                    \
4614         && coffsym->native->u.syment.n_scnum == 0)              \
4615       cache_ptr->addend = 0;                                    \
4616     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
4617              && ptr->section != (asection *) NULL)              \
4618       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
4619     else                                                        \
4620       cache_ptr->addend = 0;                                    \
4621   }
4622 #endif
4623
4624 static boolean
4625 coff_slurp_reloc_table (abfd, asect, symbols)
4626      bfd * abfd;
4627      sec_ptr asect;
4628      asymbol ** symbols;
4629 {
4630   RELOC *native_relocs;
4631   arelent *reloc_cache;
4632   arelent *cache_ptr;
4633
4634   unsigned int idx;
4635
4636   if (asect->relocation)
4637     return true;
4638   if (asect->reloc_count == 0)
4639     return true;
4640   if (asect->flags & SEC_CONSTRUCTOR)
4641     return true;
4642   if (!coff_slurp_symbol_table (abfd))
4643     return false;
4644   native_relocs =
4645     (RELOC *) buy_and_read (abfd,
4646                             asect->rel_filepos,
4647                             SEEK_SET,
4648                             (size_t) (bfd_coff_relsz (abfd) *
4649                                       asect->reloc_count));
4650   reloc_cache = (arelent *)
4651     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
4652
4653   if (reloc_cache == NULL)
4654     return false;
4655
4656
4657   for (idx = 0; idx < asect->reloc_count; idx++)
4658     {
4659       struct internal_reloc dst;
4660       struct external_reloc *src;
4661 #ifndef RELOC_PROCESSING
4662       asymbol *ptr;
4663 #endif
4664
4665       cache_ptr = reloc_cache + idx;
4666       src = native_relocs + idx;
4667
4668       coff_swap_reloc_in (abfd, src, &dst);
4669
4670 #ifdef RELOC_PROCESSING
4671       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4672 #else
4673       cache_ptr->address = dst.r_vaddr;
4674
4675       if (dst.r_symndx != -1)
4676         {
4677           if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4678             {
4679               (*_bfd_error_handler)
4680                 (_("%s: warning: illegal symbol index %ld in relocs"),
4681                  bfd_get_filename (abfd), dst.r_symndx);
4682               cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4683               ptr = NULL;
4684             }
4685           else
4686             {
4687               cache_ptr->sym_ptr_ptr = (symbols
4688                                         + obj_convert (abfd)[dst.r_symndx]);
4689               ptr = *(cache_ptr->sym_ptr_ptr);
4690             }
4691         }
4692       else
4693         {
4694           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4695           ptr = NULL;
4696         }
4697
4698       /* The symbols definitions that we have read in have been
4699          relocated as if their sections started at 0. But the offsets
4700          refering to the symbols in the raw data have not been
4701          modified, so we have to have a negative addend to compensate.
4702
4703          Note that symbols which used to be common must be left alone */
4704
4705       /* Calculate any reloc addend by looking at the symbol */
4706       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4707
4708       cache_ptr->address -= asect->vma;
4709 /* !!     cache_ptr->section = (asection *) NULL;*/
4710
4711       /* Fill in the cache_ptr->howto field from dst.r_type */
4712       RTYPE2HOWTO (cache_ptr, &dst);
4713 #endif  /* RELOC_PROCESSING */
4714
4715       if (cache_ptr->howto == NULL)
4716         {
4717           (*_bfd_error_handler)
4718             (_("%s: illegal relocation type %d at address 0x%lx"),
4719              bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4720           bfd_set_error (bfd_error_bad_value);
4721           return false;
4722         }
4723     }
4724
4725   asect->relocation = reloc_cache;
4726   return true;
4727 }
4728
4729 #ifndef coff_rtype_to_howto
4730 #ifdef RTYPE2HOWTO
4731
4732 /* Get the howto structure for a reloc.  This is only used if the file
4733    including this one defines coff_relocate_section to be
4734    _bfd_coff_generic_relocate_section, so it is OK if it does not
4735    always work.  It is the responsibility of the including file to
4736    make sure it is reasonable if it is needed.  */
4737
4738 static reloc_howto_type *coff_rtype_to_howto
4739   PARAMS ((bfd *, asection *, struct internal_reloc *,
4740            struct coff_link_hash_entry *, struct internal_syment *,
4741            bfd_vma *));
4742
4743 /*ARGSUSED*/
4744 static reloc_howto_type *
4745 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
4746      bfd *abfd ATTRIBUTE_UNUSED;
4747      asection *sec ATTRIBUTE_UNUSED;
4748      struct internal_reloc *rel;
4749      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4750      struct internal_syment *sym ATTRIBUTE_UNUSED;
4751      bfd_vma *addendp ATTRIBUTE_UNUSED;
4752 {
4753   arelent genrel;
4754
4755   RTYPE2HOWTO (&genrel, rel);
4756   return genrel.howto;
4757 }
4758
4759 #else /* ! defined (RTYPE2HOWTO) */
4760
4761 #define coff_rtype_to_howto NULL
4762
4763 #endif /* ! defined (RTYPE2HOWTO) */
4764 #endif /* ! defined (coff_rtype_to_howto) */
4765
4766 /* This is stupid.  This function should be a boolean predicate.  */
4767 static long
4768 coff_canonicalize_reloc (abfd, section, relptr, symbols)
4769      bfd * abfd;
4770      sec_ptr section;
4771      arelent ** relptr;
4772      asymbol ** symbols;
4773 {
4774   arelent *tblptr = section->relocation;
4775   unsigned int count = 0;
4776
4777
4778   if (section->flags & SEC_CONSTRUCTOR)
4779     {
4780       /* this section has relocs made up by us, they are not in the
4781        file, so take them out of their chain and place them into
4782        the data area provided */
4783       arelent_chain *chain = section->constructor_chain;
4784       for (count = 0; count < section->reloc_count; count++)
4785         {
4786           *relptr++ = &chain->relent;
4787           chain = chain->next;
4788         }
4789
4790     }
4791   else
4792     {
4793       if (! coff_slurp_reloc_table (abfd, section, symbols))
4794         return -1;
4795
4796       tblptr = section->relocation;
4797
4798       for (; count++ < section->reloc_count;)
4799         *relptr++ = tblptr++;
4800
4801
4802     }
4803   *relptr = 0;
4804   return section->reloc_count;
4805 }
4806
4807 #ifdef GNU960
4808 file_ptr
4809 coff_sym_filepos (abfd)
4810      bfd *abfd;
4811 {
4812   return obj_sym_filepos (abfd);
4813 }
4814 #endif
4815
4816 #ifndef coff_reloc16_estimate
4817 #define coff_reloc16_estimate dummy_reloc16_estimate
4818
4819 static int dummy_reloc16_estimate
4820   PARAMS ((bfd *, asection *, arelent *, unsigned int,
4821            struct bfd_link_info *));
4822
4823 static int
4824 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
4825      bfd *abfd ATTRIBUTE_UNUSED;
4826      asection *input_section ATTRIBUTE_UNUSED;
4827      arelent *reloc ATTRIBUTE_UNUSED;
4828      unsigned int shrink ATTRIBUTE_UNUSED;
4829      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4830 {
4831   abort ();
4832   return 0;
4833 }
4834
4835 #endif
4836
4837 #ifndef coff_reloc16_extra_cases
4838
4839 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4840
4841 /* This works even if abort is not declared in any header file.  */
4842
4843 static void dummy_reloc16_extra_cases
4844   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
4845            bfd_byte *, unsigned int *, unsigned int *));
4846
4847 static void
4848 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4849                            dst_ptr)
4850      bfd *abfd ATTRIBUTE_UNUSED;
4851      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4852      struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
4853      arelent *reloc ATTRIBUTE_UNUSED;
4854      bfd_byte *data ATTRIBUTE_UNUSED;
4855      unsigned int *src_ptr ATTRIBUTE_UNUSED;
4856      unsigned int *dst_ptr ATTRIBUTE_UNUSED;
4857 {
4858   abort ();
4859 }
4860 #endif
4861
4862 /* If coff_relocate_section is defined, we can use the optimized COFF
4863    backend linker.  Otherwise we must continue to use the old linker.  */
4864 #ifdef coff_relocate_section
4865 #ifndef coff_bfd_link_hash_table_create
4866 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4867 #endif
4868 #ifndef coff_bfd_link_add_symbols
4869 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4870 #endif
4871 #ifndef coff_bfd_final_link
4872 #define coff_bfd_final_link _bfd_coff_final_link
4873 #endif
4874 #else /* ! defined (coff_relocate_section) */
4875 #define coff_relocate_section NULL
4876 #ifndef coff_bfd_link_hash_table_create
4877 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4878 #endif
4879 #ifndef coff_bfd_link_add_symbols
4880 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4881 #endif
4882 #define coff_bfd_final_link _bfd_generic_final_link
4883 #endif /* ! defined (coff_relocate_section) */
4884
4885 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
4886
4887 #ifndef coff_start_final_link
4888 #define coff_start_final_link NULL
4889 #endif
4890
4891 #ifndef coff_adjust_symndx
4892 #define coff_adjust_symndx NULL
4893 #endif
4894
4895 #ifndef coff_link_add_one_symbol
4896 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4897 #endif
4898
4899 #ifndef coff_link_output_has_begun
4900
4901 static boolean coff_link_output_has_begun
4902   PARAMS ((bfd *, struct coff_final_link_info *));
4903
4904 static boolean
4905 coff_link_output_has_begun (abfd, info)
4906      bfd * abfd;
4907      struct coff_final_link_info * info ATTRIBUTE_UNUSED;
4908 {
4909   return abfd->output_has_begun;
4910 }
4911 #endif
4912
4913 #ifndef coff_final_link_postscript
4914
4915 static boolean coff_final_link_postscript
4916   PARAMS ((bfd *, struct coff_final_link_info *));
4917
4918 static boolean
4919 coff_final_link_postscript (abfd, pfinfo)
4920      bfd * abfd ATTRIBUTE_UNUSED;
4921      struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
4922 {
4923   return true;
4924 }
4925 #endif
4926
4927 #ifndef coff_SWAP_aux_in
4928 #define coff_SWAP_aux_in coff_swap_aux_in
4929 #endif
4930 #ifndef coff_SWAP_sym_in
4931 #define coff_SWAP_sym_in coff_swap_sym_in
4932 #endif
4933 #ifndef coff_SWAP_lineno_in
4934 #define coff_SWAP_lineno_in coff_swap_lineno_in
4935 #endif
4936 #ifndef coff_SWAP_aux_out
4937 #define coff_SWAP_aux_out coff_swap_aux_out
4938 #endif
4939 #ifndef coff_SWAP_sym_out
4940 #define coff_SWAP_sym_out coff_swap_sym_out
4941 #endif
4942 #ifndef coff_SWAP_lineno_out
4943 #define coff_SWAP_lineno_out coff_swap_lineno_out
4944 #endif
4945 #ifndef coff_SWAP_reloc_out
4946 #define coff_SWAP_reloc_out coff_swap_reloc_out
4947 #endif
4948 #ifndef coff_SWAP_filehdr_out
4949 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4950 #endif
4951 #ifndef coff_SWAP_aouthdr_out
4952 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4953 #endif
4954 #ifndef coff_SWAP_scnhdr_out
4955 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4956 #endif
4957 #ifndef coff_SWAP_reloc_in
4958 #define coff_SWAP_reloc_in coff_swap_reloc_in
4959 #endif
4960 #ifndef coff_SWAP_filehdr_in
4961 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4962 #endif
4963 #ifndef coff_SWAP_aouthdr_in
4964 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4965 #endif
4966 #ifndef coff_SWAP_scnhdr_in
4967 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4968 #endif
4969
4970 static const bfd_coff_backend_data bfd_coff_std_swap_table =
4971 {
4972   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
4973   coff_SWAP_aux_out, coff_SWAP_sym_out,
4974   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
4975   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
4976   coff_SWAP_scnhdr_out,
4977   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
4978 #ifdef COFF_LONG_FILENAMES
4979   true,
4980 #else
4981   false,
4982 #endif
4983 #ifdef COFF_LONG_SECTION_NAMES
4984   true,
4985 #else
4986   false,
4987 #endif
4988   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
4989   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
4990   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
4991   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
4992   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
4993   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
4994   coff_classify_symbol, coff_compute_section_file_positions,
4995   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
4996   coff_adjust_symndx, coff_link_add_one_symbol,
4997   coff_link_output_has_begun, coff_final_link_postscript
4998 };
4999
5000 #ifndef coff_close_and_cleanup
5001 #define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
5002 #endif
5003
5004 #ifndef coff_bfd_free_cached_info
5005 #define coff_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
5006 #endif
5007
5008 #ifndef coff_get_section_contents
5009 #define coff_get_section_contents           _bfd_generic_get_section_contents
5010 #endif
5011
5012 #ifndef coff_bfd_copy_private_symbol_data
5013 #define coff_bfd_copy_private_symbol_data   _bfd_generic_bfd_copy_private_symbol_data
5014 #endif
5015
5016 #ifndef coff_bfd_copy_private_section_data
5017 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
5018 #endif
5019
5020 #ifndef coff_bfd_copy_private_bfd_data
5021 #define coff_bfd_copy_private_bfd_data      _bfd_generic_bfd_copy_private_bfd_data
5022 #endif
5023
5024 #ifndef coff_bfd_merge_private_bfd_data
5025 #define coff_bfd_merge_private_bfd_data     _bfd_generic_bfd_merge_private_bfd_data
5026 #endif
5027
5028 #ifndef coff_bfd_set_private_flags
5029 #define coff_bfd_set_private_flags          _bfd_generic_bfd_set_private_flags
5030 #endif
5031
5032 #ifndef coff_bfd_print_private_bfd_data
5033 #define coff_bfd_print_private_bfd_data     _bfd_generic_bfd_print_private_bfd_data
5034 #endif
5035
5036 #ifndef coff_bfd_is_local_label_name
5037 #define coff_bfd_is_local_label_name        _bfd_coff_is_local_label_name
5038 #endif
5039
5040 #ifndef coff_read_minisymbols
5041 #define coff_read_minisymbols               _bfd_generic_read_minisymbols
5042 #endif
5043
5044 #ifndef coff_minisymbol_to_symbol
5045 #define coff_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
5046 #endif
5047
5048 /* The reloc lookup routine must be supplied by each individual COFF
5049    backend.  */
5050 #ifndef coff_bfd_reloc_type_lookup
5051 #define coff_bfd_reloc_type_lookup          _bfd_norelocs_bfd_reloc_type_lookup
5052 #endif
5053
5054 #ifndef coff_bfd_get_relocated_section_contents
5055 #define coff_bfd_get_relocated_section_contents \
5056   bfd_generic_get_relocated_section_contents
5057 #endif
5058
5059 #ifndef coff_bfd_relax_section
5060 #define coff_bfd_relax_section              bfd_generic_relax_section
5061 #endif
5062
5063 #ifndef coff_bfd_gc_sections
5064 #define coff_bfd_gc_sections                bfd_generic_gc_sections
5065 #endif
5066
5067 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5068 const bfd_target VAR =                                                  \
5069 {                                                                       \
5070   NAME ,                                                                \
5071   bfd_target_coff_flavour,                                              \
5072   BFD_ENDIAN_BIG,               /* data byte order is big */            \
5073   BFD_ENDIAN_BIG,               /* header byte order is big */          \
5074   /* object flags */                                                    \
5075   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5076    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5077   /* section flags */                                                   \
5078   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5079   UNDER,                        /* leading symbol underscore */         \
5080   '/',                          /* ar_pad_char */                       \
5081   15,                           /* ar_max_namelen */                    \
5082                                                                         \
5083   /* Data conversion functions.  */                                     \
5084   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5085   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5086   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5087                                                                         \
5088   /* Header conversion functions.  */                                   \
5089   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5090   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5091   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5092                                                                         \
5093         /* bfd_check_format */                                          \
5094   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5095     _bfd_dummy_target },                                                \
5096         /* bfd_set_format */                                            \
5097   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5098         /* bfd_write_contents */                                        \
5099   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5100     bfd_false },                                                        \
5101                                                                         \
5102   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5103   BFD_JUMP_TABLE_COPY (coff),                                           \
5104   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5105   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5106   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5107   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5108   BFD_JUMP_TABLE_WRITE (coff),                                          \
5109   BFD_JUMP_TABLE_LINK (coff),                                           \
5110   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5111                                                                         \
5112   ALTERNATIVE,                                                          \
5113                                                                         \
5114   COFF_SWAP_TABLE                                                       \
5115 };
5116
5117 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE)      \
5118 const bfd_target VAR =                                                  \
5119 {                                                                       \
5120   NAME ,                                                                \
5121   bfd_target_coff_flavour,                                              \
5122   BFD_ENDIAN_LITTLE,            /* data byte order is little */         \
5123   BFD_ENDIAN_LITTLE,            /* header byte order is little */       \
5124         /* object flags */                                              \
5125   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5126    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5127         /* section flags */                                             \
5128   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5129   UNDER,                        /* leading symbol underscore */         \
5130   '/',                          /* ar_pad_char */                       \
5131   15,                           /* ar_max_namelen */                    \
5132                                                                         \
5133   /* Data conversion functions.  */                                     \
5134   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5135   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5136   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5137   /* Header conversion functions.  */                                   \
5138   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5139   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5140   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5141         /* bfd_check_format */                                          \
5142   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5143     _bfd_dummy_target },                                                \
5144        /* bfd_set_format */                                             \
5145   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5146         /* bfd_write_contents */                                        \
5147   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5148     bfd_false },                                                        \
5149                                                                         \
5150   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5151   BFD_JUMP_TABLE_COPY (coff),                                           \
5152   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5153   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5154   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5155   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5156   BFD_JUMP_TABLE_WRITE (coff),                                          \
5157   BFD_JUMP_TABLE_LINK (coff),                                           \
5158   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5159                                                                         \
5160   ALTERNATIVE,                                                          \
5161                                                                         \
5162   COFF_SWAP_TABLE                                                       \
5163 };