bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /*
  22 Most of this hacked by  Steve Chamberlain,
  23                         sac@cygnus.com
  24 */
  25 /*
  26
  27 SECTION
  28         coff backends
  29
  30         BFD supports a number of different flavours of coff format.
  31         The major differences between formats are the sizes and
  32         alignments of fields in structures on disk, and the occasional
  33         extra field.
  34
  35         Coff in all its varieties is implemented with a few common
  36         files and a number of implementation specific files. For
  37         example, The 88k bcs coff format is implemented in the file
  38         @file{coff-m88k.c}. This file @code{#include}s
  39         @file{coff/m88k.h} which defines the external structure of the
  40         coff format for the 88k, and @file{coff/internal.h} which
  41         defines the internal structure. @file{coff-m88k.c} also
  42         defines the relocations used by the 88k format
  43         @xref{Relocations}.
  44
  45         The Intel i960 processor version of coff is implemented in
  46         @file{coff-i960.c}. This file has the same structure as
  47         @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
  48         rather than @file{coff-m88k.h}.
  49
  50 SUBSECTION
  51         Porting to a new version of coff
  52
  53         The recommended method is to select from the existing
  54         implementations the version of coff which is most like the one
  55         you want to use.  For example, we'll say that i386 coff is
  56         the one you select, and that your coff flavour is called foo.
  57         Copy @file{i386coff.c} to @file{foocoff.c}, copy
  58         @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
  59         and add the lines to @file{targets.c} and @file{Makefile.in}
  60         so that your new back end is used. Alter the shapes of the
  61         structures in @file{../include/coff/foo.h} so that they match
  62         what you need. You will probably also have to add
  63         @code{#ifdef}s to the code in @file{coff/internal.h} and
  64         @file{coffcode.h} if your version of coff is too wild.
  65
  66         You can verify that your new BFD backend works quite simply by
  67         building @file{objdump} from the @file{binutils} directory,
  68         and making sure that its version of what's going on and your
  69         host system's idea (assuming it has the pretty standard coff
  70         dump utility, usually called @code{att-dump} or just
  71         @code{dump}) are the same.  Then clean up your code, and send
  72         what you've done to Cygnus. Then your stuff will be in the
  73         next release, and you won't have to keep integrating it.
  74
  75 SUBSECTION
  76         How the coff backend works
  77
  78 SUBSUBSECTION
  79         File layout
  80
  81         The Coff backend is split into generic routines that are
  82         applicable to any Coff target and routines that are specific
  83         to a particular target.  The target-specific routines are
  84         further split into ones which are basically the same for all
  85         Coff targets except that they use the external symbol format
  86         or use different values for certain constants.
  87
  88         The generic routines are in @file{coffgen.c}.  These routines
  89         work for any Coff target.  They use some hooks into the target
  90         specific code; the hooks are in a @code{bfd_coff_backend_data}
  91         structure, one of which exists for each target.
  92
  93         The essentially similar target-specific routines are in
  94         @file{coffcode.h}.  This header file includes executable C code.
  95         The various Coff targets first include the appropriate Coff
  96         header file, make any special defines that are needed, and
  97         then include @file{coffcode.h}.
  98
  99         Some of the Coff targets then also have additional routines in
 100         the target source file itself.
 101
 102         For example, @file{coff-i960.c} includes
 103         @file{coff/internal.h} and @file{coff/i960.h}.  It then
 104         defines a few constants, such as @code{I960}, and includes
 105         @file{coffcode.h}.  Since the i960 has complex relocation
 106         types, @file{coff-i960.c} also includes some code to
 107         manipulate the i960 relocs.  This code is not in
 108         @file{coffcode.h} because it would not be used by any other
 109         target.
 110
 111 SUBSUBSECTION
 112         Bit twiddling
 113
 114         Each flavour of coff supported in BFD has its own header file
 115         describing the external layout of the structures. There is also
 116         an internal description of the coff layout, in
 117         @file{coff/internal.h}. A major function of the
 118         coff backend is swapping the bytes and twiddling the bits to
 119         translate the external form of the structures into the normal
 120         internal form. This is all performed in the
 121         @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
 122         elements are different sizes between different versions of
 123         coff; it is the duty of the coff version specific include file
 124         to override the definitions of various packing routines in
 125         @file{coffcode.h}. E.g., the size of line number entry in coff is
 126         sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
 127         @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
 128         correct one. No doubt, some day someone will find a version of
 129         coff which has a varying field size not catered to at the
 130         moment. To port BFD, that person will have to add more @code{#defines}.
 131         Three of the bit twiddling routines are exported to
 132         @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
 133         and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
 134         table on its own, but uses BFD to fix things up.  More of the
 135         bit twiddlers are exported for @code{gas};
 136         @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
 137         @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
 138         @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
 139         @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
 140         of all the symbol table and reloc drudgery itself, thereby
 141         saving the internal BFD overhead, but uses BFD to swap things
 142         on the way out, making cross ports much safer.  Doing so also
 143         allows BFD (and thus the linker) to use the same header files
 144         as @code{gas}, which makes one avenue to disaster disappear.
 145
 146 SUBSUBSECTION
 147         Symbol reading
 148
 149         The simple canonical form for symbols used by BFD is not rich
 150         enough to keep all the information available in a coff symbol
 151         table. The back end gets around this problem by keeping the original
 152         symbol table around, "behind the scenes".
 153
 154         When a symbol table is requested (through a call to
 155         @code{bfd_canonicalize_symtab}), a request gets through to
 156         @code{coff_get_normalized_symtab}. This reads the symbol table from
 157         the coff file and swaps all the structures inside into the
 158         internal form. It also fixes up all the pointers in the table
 159         (represented in the file by offsets from the first symbol in
 160         the table) into physical pointers to elements in the new
 161         internal table. This involves some work since the meanings of
 162         fields change depending upon context: a field that is a
 163         pointer to another structure in the symbol table at one moment
 164         may be the size in bytes of a structure at the next.  Another
 165         pass is made over the table. All symbols which mark file names
 166         (<<C_FILE>> symbols) are modified so that the internal
 167         string points to the value in the auxent (the real filename)
 168         rather than the normal text associated with the symbol
 169         (@code{".file"}).
 170
 171         At this time the symbol names are moved around. Coff stores
 172         all symbols less than nine characters long physically
 173         within the symbol table; longer strings are kept at the end of
 174         the file in the string  table. This pass moves all strings
 175         into memory and replaces them with pointers to the strings.
 176
 177
 178         The symbol table is massaged once again, this time to create
 179         the canonical table used by the BFD application. Each symbol
 180         is inspected in turn, and a decision made (using the
 181         @code{sclass} field) about the various flags to set in the
 182         @code{asymbol}.  @xref{Symbols}. The generated canonical table
 183         shares strings with the hidden internal symbol table.
 184
 185         Any linenumbers are read from the coff file too, and attached
 186         to the symbols which own the functions the linenumbers belong to.
 187
 188 SUBSUBSECTION
 189         Symbol writing
 190
 191         Writing a symbol to a coff file which didn't come from a coff
 192         file will lose any debugging information. The @code{asymbol}
 193         structure remembers the BFD from which the symbol was taken, and on
 194         output the back end makes sure that the same destination target as
 195         source target is present.
 196
 197         When the symbols have come from a coff file then all the
 198         debugging information is preserved.
 199
 200         Symbol tables are provided for writing to the back end in a
 201         vector of pointers to pointers. This allows applications like
 202         the linker to accumulate and output large symbol tables
 203         without having to do too much byte copying.
 204
 205         This function runs through the provided symbol table and
 206         patches each symbol marked as a file place holder
 207         (@code{C_FILE}) to point to the next file place holder in the
 208         list. It also marks each @code{offset} field in the list with
 209         the offset from the first symbol of the current symbol.
 210
 211         Another function of this procedure is to turn the canonical
 212         value form of BFD into the form used by coff. Internally, BFD
 213         expects symbol values to be offsets from a section base; so a
 214         symbol physically at 0x120, but in a section starting at
 215         0x100, would have the value 0x20. Coff expects symbols to
 216         contain their final value, so symbols have their values
 217         changed at this point to reflect their sum with their owning
 218         section.  This transformation uses the
 219         <<output_section>> field of the @code{asymbol}'s
 220         @code{asection} @xref{Sections}.
 221
 222         o <<coff_mangle_symbols>>
 223
 224         This routine runs though the provided symbol table and uses
 225         the offsets generated by the previous pass and the pointers
 226         generated when the symbol table was read in to create the
 227         structured hierachy required by coff. It changes each pointer
 228         to a symbol into the index into the symbol table of the asymbol.
 229
 230         o <<coff_write_symbols>>
 231
 232         This routine runs through the symbol table and patches up the
 233         symbols from their internal form into the coff way, calls the
 234         bit twiddlers, and writes out the table to the file.
 235
 236 */
 237
 238 /*
 239 INTERNAL_DEFINITION
 240         coff_symbol_type
 241
 242 DESCRIPTION
 243         The hidden information for an <<asymbol>> is described in a
 244         <<combined_entry_type>>:
 245
 246 CODE_FRAGMENT
 247 .
 248 .typedef struct coff_ptr_struct
 249 .{
 250 .
 251 .       {* Remembers the offset from the first symbol in the file for
 252 .          this symbol. Generated by coff_renumber_symbols. *}
 253 .unsigned int offset;
 254 .
 255 .       {* Should the value of this symbol be renumbered.  Used for
 256 .          XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
 257 .unsigned int fix_value : 1;
 258 .
 259 .       {* Should the tag field of this symbol be renumbered.
 260 .          Created by coff_pointerize_aux. *}
 261 .unsigned int fix_tag : 1;
 262 .
 263 .       {* Should the endidx field of this symbol be renumbered.
 264 .          Created by coff_pointerize_aux. *}
 265 .unsigned int fix_end : 1;
 266 .
 267 .       {* Should the x_csect.x_scnlen field be renumbered.
 268 .          Created by coff_pointerize_aux. *}
 269 .unsigned int fix_scnlen : 1;
 270 .
 271 .       {* Fix up an XCOFF C_BINCL/C_EINCL symbol.  The value is the
 272 .          index into the line number entries.  Set by
 273 .          coff_slurp_symbol_table.  *}
 274 .unsigned int fix_line : 1;
 275 .
 276 .       {* The container for the symbol structure as read and translated
 277 .           from the file. *}
 278 .
 279 .union {
 280 .   union internal_auxent auxent;
 281 .   struct internal_syment syment;
 282 . } u;
 283 .} combined_entry_type;
 284 .
 285 .
 286 .{* Each canonical asymbol really looks like this: *}
 287 .
 288 .typedef struct coff_symbol_struct
 289 .{
 290 .   {* The actual symbol which the rest of BFD works with *}
 291 .asymbol symbol;
 292 .
 293 .   {* A pointer to the hidden information for this symbol *}
 294 .combined_entry_type *native;
 295 .
 296 .   {* A pointer to the linenumber information for this symbol *}
 297 .struct lineno_cache_entry *lineno;
 298 .
 299 .   {* Have the line numbers been relocated yet ? *}
 300 .boolean done_lineno;
 301 .} coff_symbol_type;
 302
 303
 304 */
 305
 306 #ifdef COFF_WITH_PE
 307 #include "peicode.h"
 308 #else
 309 #include "coffswap.h"
 310 #endif
 311
 312 #define STRING_SIZE_SIZE (4)
 313 \f
 314 /* void warning(); */
 315
 316 /*
 317  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 318  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 319  * NOTE: If you add to/change this routine, you should mirror the changes
 320  *      in styp_to_sec_flags().
 321  */
 322 static long
 323 sec_to_styp_flags (sec_name, sec_flags)
 324      CONST char *sec_name;
 325      flagword sec_flags;
 326 {
 327   long styp_flags = 0;
 328
 329   if (!strcmp (sec_name, _TEXT))
 330     {
 331       styp_flags = STYP_TEXT;
 332     }
 333   else if (!strcmp (sec_name, _DATA))
 334     {
 335       styp_flags = STYP_DATA;
 336     }
 337   else if (!strcmp (sec_name, _BSS))
 338     {
 339       styp_flags = STYP_BSS;
 340 #ifdef _COMMENT
 341     }
 342   else if (!strcmp (sec_name, _COMMENT))
 343     {
 344       styp_flags = STYP_INFO;
 345 #endif /* _COMMENT */
 346 #ifdef _LIB
 347     }
 348   else if (!strcmp (sec_name, _LIB))
 349     {
 350       styp_flags = STYP_LIB;
 351 #endif /* _LIB */
 352 #ifdef _LIT
 353     }
 354   else if (!strcmp (sec_name, _LIT))
 355     {
 356       styp_flags = STYP_LIT;
 357 #endif /* _LIT */
 358     }
 359   else if (!strcmp (sec_name, ".debug"))
 360     {
 361 #ifdef STYP_DEBUG
 362       styp_flags = STYP_DEBUG;
 363 #else
 364       styp_flags = STYP_INFO;
 365 #endif
 366     }
 367   else if (!strncmp (sec_name, ".stab", 5))
 368     {
 369       styp_flags = STYP_INFO;
 370     }
 371 #ifdef COFF_WITH_PE
 372   else if (!strcmp (sec_name, ".edata"))
 373     {
 374       styp_flags = STYP_DATA;
 375     }
 376 #endif
 377 #ifdef RS6000COFF_C
 378   else if (!strcmp (sec_name, _PAD))
 379     {
 380       styp_flags = STYP_PAD;
 381     }
 382   else if (!strcmp (sec_name, _LOADER))
 383     {
 384       styp_flags = STYP_LOADER;
 385     }
 386 #endif
 387   /* Try and figure out what it should be */
 388   else if (sec_flags & SEC_CODE)
 389     {
 390       styp_flags = STYP_TEXT;
 391     }
 392   else if (sec_flags & SEC_DATA)
 393     {
 394       styp_flags = STYP_DATA;
 395     }
 396   else if (sec_flags & SEC_READONLY)
 397     {
 398 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 399       styp_flags = STYP_LIT;
 400 #else
 401       styp_flags = STYP_TEXT;
 402 #endif /* STYP_LIT */
 403     }
 404   else if (sec_flags & SEC_LOAD)
 405     {
 406       styp_flags = STYP_TEXT;
 407     }
 408   else if (sec_flags & SEC_ALLOC)
 409     {
 410       styp_flags = STYP_BSS;
 411     }
 412
 413 #ifdef STYP_NOLOAD
 414   if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
 415     styp_flags |= STYP_NOLOAD;
 416 #endif
 417
 418 #ifdef COFF_WITH_PE
 419   if (sec_flags & SEC_LINK_ONCE)
 420     styp_flags |= IMAGE_SCN_LNK_COMDAT;
 421 #endif
 422
 423   return (styp_flags);
 424 }
 425 /*
 426  * Return a word with SEC_* flags set to represent the incoming
 427  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 428  * function is sec_to_styp_flags().
 429  * NOTE: If you add to/change this routine, you should mirror the changes
 430  *      in sec_to_styp_flags().
 431  */
 432 static flagword
 433 styp_to_sec_flags (abfd, hdr, name)
 434      bfd *abfd;
 435      PTR hdr;
 436      const char *name;
 437 {
 438   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 439   long styp_flags = internal_s->s_flags;
 440   flagword sec_flags = 0;
 441
 442 #ifdef STYP_NOLOAD
 443   if (styp_flags & STYP_NOLOAD)
 444     {
 445       sec_flags |= SEC_NEVER_LOAD;
 446     }
 447 #endif /* STYP_NOLOAD */
 448
 449   /* For 386 COFF, at least, an unloadable text or data section is
 450      actually a shared library section.  */
 451   if (styp_flags & STYP_TEXT)
 452     {
 453       if (sec_flags & SEC_NEVER_LOAD)
 454         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 455       else
 456         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 457     }
 458   else if (styp_flags & STYP_DATA)
 459     {
 460       if (sec_flags & SEC_NEVER_LOAD)
 461         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 462       else
 463         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 464     }
 465   else if (styp_flags & STYP_BSS)
 466     {
 467 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 468       if (sec_flags & SEC_NEVER_LOAD)
 469         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 470       else
 471 #endif
 472         sec_flags |= SEC_ALLOC;
 473     }
 474   else if (styp_flags & STYP_INFO)
 475     {
 476       /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
 477          defined.  coff_compute_section_file_positions uses
 478          COFF_PAGE_SIZE to ensure that the low order bits of the
 479          section VMA and the file offset match.  If we don't know
 480          COFF_PAGE_SIZE, we can't ensure the correct correspondence,
 481          and demand page loading of the file will fail.  */
 482 #ifdef COFF_PAGE_SIZE
 483       sec_flags |= SEC_DEBUGGING;
 484 #endif
 485     }
 486   else if (styp_flags & STYP_PAD)
 487     {
 488       sec_flags = 0;
 489     }
 490   else if (strcmp (name, _TEXT) == 0)
 491     {
 492       if (sec_flags & SEC_NEVER_LOAD)
 493         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 494       else
 495         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 496     }
 497   else if (strcmp (name, _DATA) == 0)
 498     {
 499       if (sec_flags & SEC_NEVER_LOAD)
 500         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 501       else
 502         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 503     }
 504   else if (strcmp (name, _BSS) == 0)
 505     {
 506 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 507       if (sec_flags & SEC_NEVER_LOAD)
 508         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 509       else
 510 #endif
 511         sec_flags |= SEC_ALLOC;
 512     }
 513   else if (strcmp (name, ".debug") == 0
 514 #ifdef _COMMENT
 515            || strcmp (name, _COMMENT) == 0
 516 #endif
 517            || strncmp (name, ".stab", 5) == 0)
 518     {
 519 #ifdef COFF_PAGE_SIZE
 520       sec_flags |= SEC_DEBUGGING;
 521 #endif
 522     }
 523 #ifdef _LIB
 524   else if (strcmp (name, _LIB) == 0)
 525     ;
 526 #endif
 527 #ifdef _LIT
 528   else if (strcmp (name, _LIT) == 0)
 529     {
 530       sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
 531     }
 532 #endif
 533   else
 534     {
 535       sec_flags |= SEC_ALLOC | SEC_LOAD;
 536     }
 537
 538 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 539   if ((styp_flags & STYP_LIT) == STYP_LIT)
 540     {
 541       sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 542     }
 543 #endif /* STYP_LIT */
 544 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 545   if (styp_flags & STYP_OTHER_LOAD)
 546     {
 547       sec_flags = (SEC_LOAD | SEC_ALLOC);
 548     }
 549 #endif /* STYP_SDATA */
 550
 551 #ifdef COFF_WITH_PE
 552   if (styp_flags & IMAGE_SCN_LNK_REMOVE)
 553     sec_flags |= SEC_EXCLUDE;
 554
 555   if (styp_flags & IMAGE_SCN_LNK_COMDAT)
 556     {
 557       sec_flags |= SEC_LINK_ONCE;
 558
 559       /* Unfortunately, the PE format stores essential information in
 560          the symbol table, of all places.  We need to extract that
 561          information now, so that objdump and the linker will know how
 562          to handle the section without worrying about the symbols.  We
 563          can't call slurp_symtab, because the linker doesn't want the
 564          swapped symbols.  */
 565
 566       if (_bfd_coff_get_external_symbols (abfd))
 567         {
 568           bfd_byte *esym, *esymend;
 569
 570           esym = (bfd_byte *) obj_coff_external_syms (abfd);
 571           esymend = esym + obj_raw_syment_count (abfd) * SYMESZ;
 572
 573           while (esym < esymend)
 574             {
 575               struct internal_syment isym;
 576
 577               bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
 578
 579               if (sizeof (internal_s->s_name) > SYMNMLEN)
 580                 {
 581                   /* This case implies that the matching symbol name
 582                      will be in the string table.  */
 583                   abort ();
 584                 }
 585
 586               if (isym.n_sclass == C_STAT
 587                   && isym.n_type == T_NULL
 588                   && isym.n_numaux == 1)
 589                 {
 590                   char buf[SYMNMLEN + 1];
 591                   const char *symname;
 592
 593                   symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
 594                   if (symname == NULL)
 595                     abort ();
 596
 597                   if (strcmp (name, symname) == 0)
 598                     {
 599                       union internal_auxent aux;
 600
 601                       /* This is the section symbol.  */
 602
 603                       bfd_coff_swap_aux_in (abfd, (PTR) (esym + SYMESZ),
 604                                             isym.n_type, isym.n_sclass,
 605                                             0, isym.n_numaux, (PTR) &aux);
 606
 607                       switch (aux.x_scn.x_comdat)
 608                         {
 609                         case IMAGE_COMDAT_SELECT_NODUPLICATES:
 610                           sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
 611                           break;
 612
 613                         default:
 614                         case IMAGE_COMDAT_SELECT_ANY:
 615                           sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
 616                           break;
 617
 618                         case IMAGE_COMDAT_SELECT_SAME_SIZE:
 619                           sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
 620                           break;
 621
 622                         case IMAGE_COMDAT_SELECT_EXACT_MATCH:
 623                           sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
 624                           break;
 625
 626                         case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
 627                           /* FIXME: This is not currently implemented.  */
 628                           sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
 629                           break;
 630                         }
 631
 632                       break;
 633                     }
 634                 }
 635
 636               esym += (isym.n_numaux + 1) * SYMESZ;
 637             }
 638         }
 639     }
 640 #endif
 641
 642   return (sec_flags);
 643 }
 644
 645 #define get_index(symbol)       ((symbol)->udata.i)
 646
 647 /*
 648 INTERNAL_DEFINITION
 649         bfd_coff_backend_data
 650
 651 CODE_FRAGMENT
 652
 653 Special entry points for gdb to swap in coff symbol table parts:
 654 .typedef struct
 655 .{
 656 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 657 .       bfd            *abfd,
 658 .       PTR             ext,
 659 .       int             type,
 660 .       int             class,
 661 .       int             indaux,
 662 .       int             numaux,
 663 .       PTR             in));
 664 .
 665 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 666 .       bfd            *abfd ,
 667 .       PTR             ext,
 668 .       PTR             in));
 669 .
 670 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 671 .       bfd            *abfd,
 672 .       PTR            ext,
 673 .       PTR             in));
 674 .
 675
 676 Special entry points for gas to swap out coff parts:
 677
 678 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 679 .       bfd     *abfd,
 680 .       PTR     in,
 681 .       int     type,
 682 .       int     class,
 683 .       int     indaux,
 684 .       int     numaux,
 685 .       PTR     ext));
 686 .
 687 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 688 .      bfd      *abfd,
 689 .      PTR      in,
 690 .      PTR      ext));
 691 .
 692 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 693 .       bfd     *abfd,
 694 .       PTR     in,
 695 .       PTR     ext));
 696 .
 697 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 698 .       bfd     *abfd,
 699 .       PTR     src,
 700 .       PTR     dst));
 701 .
 702 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 703 .       bfd     *abfd,
 704 .       PTR     in,
 705 .       PTR     out));
 706 .
 707 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 708 .       bfd     *abfd,
 709 .       PTR     in,
 710 .       PTR     out));
 711 .
 712 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 713 .       bfd     *abfd,
 714 .       PTR     in,
 715 .       PTR     out));
 716 .
 717
 718 Special entry points for generic COFF routines to call target
 719 dependent COFF routines:
 720
 721 . unsigned int _bfd_filhsz;
 722 . unsigned int _bfd_aoutsz;
 723 . unsigned int _bfd_scnhsz;
 724 . unsigned int _bfd_symesz;
 725 . unsigned int _bfd_auxesz;
 726 . unsigned int _bfd_relsz;
 727 . unsigned int _bfd_linesz;
 728 . boolean _bfd_coff_long_filenames;
 729 . boolean _bfd_coff_long_section_names;
 730 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 731 .       bfd     *abfd,
 732 .       PTR     ext,
 733 .       PTR     in));
 734 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 735 .       bfd     *abfd,
 736 .       PTR     ext,
 737 .       PTR     in));
 738 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 739 .       bfd     *abfd,
 740 .       PTR     ext,
 741 .       PTR     in));
 742 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
 743 .       bfd     *abfd,
 744 .       PTR     ext,
 745 .       PTR     in));
 746 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 747 .       bfd     *abfd,
 748 .       PTR     internal_filehdr));
 749 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 750 .       bfd     *abfd,
 751 .       PTR     internal_filehdr));
 752 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 753 .       bfd     *abfd,
 754 .       PTR     internal_filehdr,
 755 .       PTR     internal_aouthdr));
 756 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 757 .       bfd     *abfd,
 758 .       PTR     internal_scnhdr,
 759 .       const char *name));
 760 . void (*_bfd_set_alignment_hook) PARAMS ((
 761 .       bfd     *abfd,
 762 .       asection *sec,
 763 .       PTR     internal_scnhdr));
 764 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 765 .       bfd     *abfd));
 766 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 767 .       bfd     *abfd,
 768 .       struct internal_syment *sym));
 769 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
 770 .       bfd *abfd,
 771 .       combined_entry_type *table_base,
 772 .       combined_entry_type *symbol,
 773 .       unsigned int indaux,
 774 .       combined_entry_type *aux));
 775 . boolean (*_bfd_coff_print_aux) PARAMS ((
 776 .       bfd *abfd,
 777 .       FILE *file,
 778 .       combined_entry_type *table_base,
 779 .       combined_entry_type *symbol,
 780 .       combined_entry_type *aux,
 781 .       unsigned int indaux));
 782 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 783 .       bfd     *abfd,
 784 .       struct bfd_link_info *link_info,
 785 .       struct bfd_link_order *link_order,
 786 .       arelent *reloc,
 787 .       bfd_byte *data,
 788 .       unsigned int *src_ptr,
 789 .       unsigned int *dst_ptr));
 790 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
 791 .       bfd *abfd,
 792 .       asection *input_section,
 793 .       arelent *r,
 794 .       unsigned int shrink,
 795 .       struct bfd_link_info *link_info));
 796 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
 797 .       bfd *abfd,
 798 .       struct internal_syment *));
 799 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
 800 .       bfd *abfd));
 801 . boolean (*_bfd_coff_start_final_link) PARAMS ((
 802 .       bfd *output_bfd,
 803 .       struct bfd_link_info *info));
 804 . boolean (*_bfd_coff_relocate_section) PARAMS ((
 805 .       bfd *output_bfd,
 806 .       struct bfd_link_info *info,
 807 .       bfd *input_bfd,
 808 .       asection *input_section,
 809 .       bfd_byte *contents,
 810 .       struct internal_reloc *relocs,
 811 .       struct internal_syment *syms,
 812 .       asection **sections));
 813 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
 814 .       bfd *abfd,
 815 .       asection *sec,
 816 .       struct internal_reloc *rel,
 817 .       struct coff_link_hash_entry *h,
 818 .       struct internal_syment *sym,
 819 .       bfd_vma *addendp));
 820 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
 821 .       bfd *obfd,
 822 .       struct bfd_link_info *info,
 823 .       bfd *ibfd,
 824 .       asection *sec,
 825 .       struct internal_reloc *reloc,
 826 .       boolean *adjustedp));
 827 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
 828 .       struct bfd_link_info *info,
 829 .       bfd *abfd,
 830 .       const char *name,
 831 .       flagword flags,
 832 .       asection *section,
 833 .       bfd_vma value,
 834 .       const char *string,
 835 .       boolean copy,
 836 .       boolean collect,
 837 .       struct bfd_link_hash_entry **hashp));
 838 .
 839 .} bfd_coff_backend_data;
 840 .
 841 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 842 .
 843 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
 844 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
 845 .
 846 .#define bfd_coff_swap_sym_in(a,e,i) \
 847 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 848 .
 849 .#define bfd_coff_swap_lineno_in(a,e,i) \
 850 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 851 .
 852 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 853 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 854 .
 855 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 856 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 857 .
 858 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
 859 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
 860 .
 861 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 862 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 863 .
 864 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 865 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 866 .
 867 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 868 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 869 .
 870 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 871 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 872 .
 873 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 874 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 875 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 876 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 877 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 878 .#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
 879 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 880 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 881 .#define bfd_coff_long_section_names(abfd) \
 882 .        (coff_backend_info (abfd)->_bfd_coff_long_section_names)
 883 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 884 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 885 .
 886 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 887 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 888 .
 889 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 890 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 891 .
 892 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
 893 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
 894 .
 895 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 896 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 897 .
 898 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 899 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 900 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
 901 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
 902 .
 903 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
 904 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
 905 .
 906 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 907 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 908 .
 909 .#define bfd_coff_slurp_symbol_table(abfd)\
 910 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 911 .
 912 .#define bfd_coff_symname_in_debug(abfd, sym)\
 913 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 914 .
 915 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
 916 .        ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
 917 .         (abfd, file, base, symbol, aux, indaux))
 918 .
 919 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
 920 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 921 .         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
 922 .
 923 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
 924 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 925 .         (abfd, section, reloc, shrink, link_info))
 926 .
 927 .#define bfd_coff_sym_is_global(abfd, sym)\
 928 .        ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
 929 .         (abfd, sym))
 930 .
 931 .#define bfd_coff_compute_section_file_positions(abfd)\
 932 .        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
 933 .         (abfd))
 934 .
 935 .#define bfd_coff_start_final_link(obfd, info)\
 936 .        ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
 937 .         (obfd, info))
 938 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
 939 .        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
 940 .         (obfd, info, ibfd, o, con, rel, isyms, secs))
 941 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
 942 .        ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
 943 .         (abfd, sec, rel, h, sym, addendp))
 944 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
 945 .        ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
 946 .         (obfd, info, ibfd, sec, rel, adjustedp))
 947 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
 948 .        ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
 949 .         (info, abfd, name, flags, section, value, string, cp, coll, hashp))
 950 .
 951 */
 952
 953 /* See whether the magic number matches.  */
 954
 955 static boolean
 956 coff_bad_format_hook (abfd, filehdr)
 957      bfd * abfd;
 958      PTR filehdr;
 959 {
 960   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 961
 962   if (BADMAG (*internal_f))
 963     return false;
 964
 965   /* if the optional header is NULL or not the correct size then
 966      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
 967      and Intel 960 readwrite headers (I960WRMAGIC) is that the
 968      optional header is of a different size.
 969
 970      But the mips keeps extra stuff in it's opthdr, so dont check
 971      when doing that
 972      */
 973
 974 #if defined(M88) || defined(I960)
 975   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
 976     return false;
 977 #endif
 978
 979   return true;
 980 }
 981
 982 /*
 983    initialize a section structure with information peculiar to this
 984    particular implementation of coff
 985 */
 986
 987 static boolean
 988 coff_new_section_hook (abfd, section)
 989      bfd * abfd;
 990      asection * section;
 991 {
 992   section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
 993
 994 #ifdef RS6000COFF_C
 995   if (xcoff_data (abfd)->text_align_power != 0
 996       && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
 997     section->alignment_power = xcoff_data (abfd)->text_align_power;
 998   if (xcoff_data (abfd)->data_align_power != 0
 999       && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1000     section->alignment_power = xcoff_data (abfd)->data_align_power;
1001 #endif
1002
1003   /* Allocate aux records for section symbols, to store size and
1004      related info.
1005
1006      @@ The 10 is a guess at a plausible maximum number of aux entries
1007      (but shouldn't be a constant).  */
1008   coffsymbol (section->symbol)->native =
1009     (combined_entry_type *) bfd_zalloc (abfd,
1010                                         sizeof (combined_entry_type) * 10);
1011
1012   /* The .stab section must be aligned to 2**2 at most, because
1013      otherwise there may be gaps in the section which gdb will not
1014      know how to interpret.  Examining the section name is a hack, but
1015      that is also how gdb locates the section.
1016      We need to handle the .ctors and .dtors sections similarly, to
1017      avoid introducing null words in the tables.  */
1018   if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2
1019       && (strncmp (section->name, ".stab", 5) == 0
1020           || strcmp (section->name, ".ctors") == 0
1021           || strcmp (section->name, ".dtors") == 0))
1022     section->alignment_power = 2;
1023
1024   /* Similarly, the .stabstr section must be aligned to 2**0 at most.  */
1025   if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 0
1026       && strncmp (section->name, ".stabstr", 8) == 0)
1027     section->alignment_power = 0;
1028
1029   return true;
1030 }
1031
1032 #ifdef I960
1033
1034 /* Set the alignment of a BFD section.  */
1035
1036 static void
1037 coff_set_alignment_hook (abfd, section, scnhdr)
1038      bfd * abfd;
1039      asection * section;
1040      PTR scnhdr;
1041 {
1042   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1043   unsigned int i;
1044
1045   for (i = 0; i < 32; i++)
1046     if ((1 << i) >= hdr->s_align)
1047       break;
1048   section->alignment_power = i;
1049 }
1050
1051 #else /* ! I960 */
1052 #ifdef COFF_WITH_PE
1053
1054 /* a couple of macros to help setting the alignment power field */
1055 #define ALIGN_SET(field,x,y) \
1056   if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1057   {\
1058      section->alignment_power = y;\
1059   }
1060
1061 #define ELIFALIGN_SET(field,x,y) \
1062   else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1063   {\
1064      section->alignment_power = y;\
1065   }
1066
1067 static void
1068 coff_set_alignment_hook (abfd, section, scnhdr)
1069      bfd * abfd;
1070      asection * section;
1071      PTR scnhdr;
1072 {
1073   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1074
1075   ALIGN_SET     (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1076   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1077   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1078   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES,  3)
1079   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES,  2)
1080   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES,  1)
1081   ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES,  0)
1082
1083 #ifdef POWERPC_LE_PE
1084   if (strcmp (section->name, ".idata$2") == 0)
1085     {
1086       section->alignment_power = 0;
1087     }
1088   else if (strcmp (section->name, ".idata$3") == 0)
1089     {
1090       section->alignment_power = 0;
1091     }
1092   else if (strcmp (section->name, ".idata$4") == 0)
1093     {
1094       section->alignment_power = 2;
1095     }
1096   else if (strcmp (section->name, ".idata$5") == 0)
1097     {
1098       section->alignment_power = 2;
1099     }
1100   else if (strcmp (section->name, ".idata$6") == 0)
1101     {
1102       section->alignment_power = 1;
1103     }
1104   else if (strcmp (section->name, ".reloc") == 0)
1105     {
1106       section->alignment_power = 1;
1107     }
1108   else if (strncmp (section->name, ".stab", 5) == 0)
1109     {
1110       section->alignment_power = 2;
1111     }
1112 #endif
1113
1114 #ifdef COFF_IMAGE_WITH_PE
1115   /* In a PE image file, the s_paddr field holds the virtual size of a
1116      section, while the s_size field holds the raw size.  */
1117   if (hdr->s_paddr != 0)
1118     {
1119       if (coff_section_data (abfd, section) == NULL)
1120         {
1121           section->used_by_bfd =
1122             (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
1123           if (section->used_by_bfd == NULL)
1124             {
1125               /* FIXME: Return error.  */
1126               abort ();
1127             }
1128         }
1129       if (pei_section_data (abfd, section) == NULL)
1130         {
1131           coff_section_data (abfd, section)->tdata =
1132             (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
1133           if (coff_section_data (abfd, section)->tdata == NULL)
1134             {
1135               /* FIXME: Return error.  */
1136               abort ();
1137             }
1138         }
1139       pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1140     }
1141 #endif
1142
1143 }
1144 #undef ALIGN_SET
1145 #undef ELIFALIGN_SET
1146
1147 #else /* ! COFF_WITH_PE */
1148 #ifdef RS6000COFF_C
1149
1150 /* We grossly abuse this function to handle XCOFF overflow headers.
1151    When we see one, we correct the reloc and line number counts in the
1152    real header, and remove the section we just created.  */
1153
1154 static void
1155 coff_set_alignment_hook (abfd, section, scnhdr)
1156      bfd *abfd;
1157      asection *section;
1158      PTR scnhdr;
1159 {
1160   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1161   asection *real_sec;
1162   asection **ps;
1163
1164   if ((hdr->s_flags & STYP_OVRFLO) == 0)
1165     return;
1166
1167   real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1168   if (real_sec == NULL)
1169     return;
1170
1171   real_sec->reloc_count = hdr->s_paddr;
1172   real_sec->lineno_count = hdr->s_vaddr;
1173
1174   for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1175     {
1176       if (*ps == section)
1177         {
1178           *ps = (*ps)->next;
1179           --abfd->section_count;
1180           break;
1181         }
1182     }
1183 }
1184
1185 #else /* ! RS6000COFF_C */
1186
1187 #define coff_set_alignment_hook \
1188   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1189
1190 #endif /* ! RS6000COFF_C */
1191 #endif /* ! COFF_WITH_PE */
1192 #endif /* ! I960 */
1193
1194 #ifndef coff_mkobject
1195 static boolean
1196 coff_mkobject (abfd)
1197      bfd * abfd;
1198 {
1199   coff_data_type *coff;
1200
1201   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1202   if (abfd->tdata.coff_obj_data == 0)
1203     return false;
1204   coff = coff_data (abfd);
1205   coff->symbols = (coff_symbol_type *) NULL;
1206   coff->conversion_table = (unsigned int *) NULL;
1207   coff->raw_syments = (struct coff_ptr_struct *) NULL;
1208   coff->relocbase = 0;
1209   coff->local_toc_sym_map = 0;
1210
1211 /*  make_abs_section(abfd);*/
1212
1213   return true;
1214 }
1215 #endif
1216
1217 /* Create the COFF backend specific information.  */
1218 #ifndef coff_mkobject_hook
1219 static PTR
1220 coff_mkobject_hook (abfd, filehdr, aouthdr)
1221      bfd * abfd;
1222      PTR filehdr;
1223      PTR aouthdr;
1224 {
1225   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1226   coff_data_type *coff;
1227
1228   if (coff_mkobject (abfd) == false)
1229     return NULL;
1230
1231   coff = coff_data (abfd);
1232
1233   coff->sym_filepos = internal_f->f_symptr;
1234
1235   /* These members communicate important constants about the symbol
1236      table to GDB's symbol-reading code.  These `constants'
1237      unfortunately vary among coff implementations...  */
1238   coff->local_n_btmask = N_BTMASK;
1239   coff->local_n_btshft = N_BTSHFT;
1240   coff->local_n_tmask = N_TMASK;
1241   coff->local_n_tshift = N_TSHIFT;
1242   coff->local_symesz = SYMESZ;
1243   coff->local_auxesz = AUXESZ;
1244   coff->local_linesz = LINESZ;
1245
1246   obj_raw_syment_count (abfd) =
1247     obj_conv_table_size (abfd) =
1248       internal_f->f_nsyms;
1249
1250 #ifdef RS6000COFF_C
1251   if ((internal_f->f_flags & F_SHROBJ) != 0)
1252     abfd->flags |= DYNAMIC;
1253   if (aouthdr != NULL && internal_f->f_opthdr >= AOUTSZ)
1254     {
1255       struct internal_aouthdr *internal_a =
1256         (struct internal_aouthdr *) aouthdr;
1257       struct xcoff_tdata *xcoff;
1258
1259       xcoff = xcoff_data (abfd);
1260       xcoff->full_aouthdr = true;
1261       xcoff->toc = internal_a->o_toc;
1262       xcoff->sntoc = internal_a->o_sntoc;
1263       xcoff->snentry = internal_a->o_snentry;
1264       xcoff->text_align_power = internal_a->o_algntext;
1265       xcoff->data_align_power = internal_a->o_algndata;
1266       xcoff->modtype = internal_a->o_modtype;
1267       xcoff->cputype = internal_a->o_cputype;
1268       xcoff->maxdata = internal_a->o_maxdata;
1269       xcoff->maxstack = internal_a->o_maxstack;
1270     }
1271 #endif
1272
1273   return (PTR) coff;
1274 }
1275 #endif
1276
1277 /* Determine the machine architecture and type.  FIXME: This is target
1278    dependent because the magic numbers are defined in the target
1279    dependent header files.  But there is no particular need for this.
1280    If the magic numbers were moved to a separate file, this function
1281    would be target independent and would also be much more successful
1282    at linking together COFF files for different architectures.  */
1283
1284 static boolean
1285 coff_set_arch_mach_hook (abfd, filehdr)
1286      bfd *abfd;
1287      PTR filehdr;
1288 {
1289   long machine;
1290   enum bfd_architecture arch;
1291   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1292
1293   machine = 0;
1294   switch (internal_f->f_magic)
1295     {
1296 #ifdef PPCMAGIC
1297     case PPCMAGIC:
1298       arch = bfd_arch_powerpc;
1299       machine = 0; /* what does this mean? (krk) */
1300       break;
1301 #endif
1302 #ifdef I386MAGIC
1303     case I386MAGIC:
1304     case I386PTXMAGIC:
1305     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1306     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1307       arch = bfd_arch_i386;
1308       machine = 0;
1309       break;
1310 #endif
1311 #ifdef A29K_MAGIC_BIG
1312     case A29K_MAGIC_BIG:
1313     case A29K_MAGIC_LITTLE:
1314       arch = bfd_arch_a29k;
1315       machine = 0;
1316       break;
1317 #endif
1318 #ifdef ARMMAGIC
1319     case ARMMAGIC:
1320       arch = bfd_arch_arm;
1321       machine =0;
1322       break;
1323 #endif
1324 #ifdef MC68MAGIC
1325     case MC68MAGIC:
1326     case M68MAGIC:
1327 #ifdef MC68KBCSMAGIC
1328     case MC68KBCSMAGIC:
1329 #endif
1330 #ifdef APOLLOM68KMAGIC
1331     case APOLLOM68KMAGIC:
1332 #endif
1333 #ifdef LYNXCOFFMAGIC
1334     case LYNXCOFFMAGIC:
1335 #endif
1336       arch = bfd_arch_m68k;
1337       machine = 68020;
1338       break;
1339 #endif
1340 #ifdef MC88MAGIC
1341     case MC88MAGIC:
1342     case MC88DMAGIC:
1343     case MC88OMAGIC:
1344       arch = bfd_arch_m88k;
1345       machine = 88100;
1346       break;
1347 #endif
1348 #ifdef Z8KMAGIC
1349     case Z8KMAGIC:
1350       arch = bfd_arch_z8k;
1351       switch (internal_f->f_flags & F_MACHMASK)
1352         {
1353         case F_Z8001:
1354           machine = bfd_mach_z8001;
1355           break;
1356         case F_Z8002:
1357           machine = bfd_mach_z8002;
1358           break;
1359         default:
1360           return false;
1361         }
1362       break;
1363 #endif
1364 #ifdef I860
1365     case I860MAGIC:
1366       arch = bfd_arch_i860;
1367       break;
1368 #endif
1369 #ifdef I960
1370 #ifdef I960ROMAGIC
1371     case I960ROMAGIC:
1372     case I960RWMAGIC:
1373       arch = bfd_arch_i960;
1374       switch (F_I960TYPE & internal_f->f_flags)
1375         {
1376         default:
1377         case F_I960CORE:
1378           machine = bfd_mach_i960_core;
1379           break;
1380         case F_I960KB:
1381           machine = bfd_mach_i960_kb_sb;
1382           break;
1383         case F_I960MC:
1384           machine = bfd_mach_i960_mc;
1385           break;
1386         case F_I960XA:
1387           machine = bfd_mach_i960_xa;
1388           break;
1389         case F_I960CA:
1390           machine = bfd_mach_i960_ca;
1391           break;
1392         case F_I960KA:
1393           machine = bfd_mach_i960_ka_sa;
1394           break;
1395         case F_I960JX:
1396           machine = bfd_mach_i960_jx;
1397           break;
1398         case F_I960HX:
1399           machine = bfd_mach_i960_hx;
1400           break;
1401         }
1402       break;
1403 #endif
1404 #endif
1405
1406 #ifdef RS6000COFF_C
1407     case U802ROMAGIC:
1408     case U802WRMAGIC:
1409     case U802TOCMAGIC:
1410       {
1411         int cputype;
1412
1413         if (xcoff_data (abfd)->cputype != -1)
1414           cputype = xcoff_data (abfd)->cputype & 0xff;
1415         else
1416           {
1417             /* We did not get a value from the a.out header.  If the
1418                file has not been stripped, we may be able to get the
1419                architecture information from the first symbol, if it
1420                is a .file symbol.  */
1421             if (obj_raw_syment_count (abfd) == 0)
1422               cputype = 0;
1423             else
1424               {
1425                 bfd_byte buf[SYMESZ];
1426                 struct internal_syment sym;
1427
1428                 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1429                     || bfd_read (buf, 1, SYMESZ, abfd) != SYMESZ)
1430                   return false;
1431                 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1432                 if (sym.n_sclass == C_FILE)
1433                   cputype = sym.n_type & 0xff;
1434                 else
1435                   cputype = 0;
1436               }
1437           }
1438
1439         /* FIXME: We don't handle all cases here.  */
1440         switch (cputype)
1441           {
1442           default:
1443           case 0:
1444 #ifdef POWERMAC
1445             /* PowerPC Macs use the same magic numbers as RS/6000
1446                (because that's how they were bootstrapped originally),
1447                but they are always PowerPC architecture.  */
1448             arch = bfd_arch_powerpc;
1449             machine = 0;
1450 #else
1451             arch = bfd_arch_rs6000;
1452             machine = 6000;
1453 #endif /* POWERMAC */
1454             break;
1455
1456           case 1:
1457             arch = bfd_arch_powerpc;
1458             machine = 601;
1459             break;
1460           case 2: /* 64 bit PowerPC */
1461             arch = bfd_arch_powerpc;
1462             machine = 620;
1463             break;
1464           case 3:
1465             arch = bfd_arch_powerpc;
1466             machine = 0;
1467             break;
1468           case 4:
1469             arch = bfd_arch_rs6000;
1470             machine = 6000;
1471             break;
1472           }
1473       }
1474       break;
1475 #endif
1476
1477 #ifdef WE32KMAGIC
1478     case WE32KMAGIC:
1479       arch = bfd_arch_we32k;
1480       machine = 0;
1481       break;
1482 #endif
1483
1484 #ifdef H8300MAGIC
1485     case H8300MAGIC:
1486       arch = bfd_arch_h8300;
1487       machine = bfd_mach_h8300;
1488       /* !! FIXME this probably isn't the right place for this */
1489       abfd->flags |= BFD_IS_RELAXABLE;
1490       break;
1491 #endif
1492
1493 #ifdef H8300HMAGIC
1494     case H8300HMAGIC:
1495       arch = bfd_arch_h8300;
1496       machine = bfd_mach_h8300h;
1497       /* !! FIXME this probably isn't the right place for this */
1498       abfd->flags |= BFD_IS_RELAXABLE;
1499       break;
1500 #endif
1501
1502 #ifdef H8300SMAGIC
1503     case H8300SMAGIC:
1504       arch = bfd_arch_h8300;
1505       machine = bfd_mach_h8300s;
1506       /* !! FIXME this probably isn't the right place for this */
1507       abfd->flags |= BFD_IS_RELAXABLE;
1508       break;
1509 #endif
1510
1511 #ifdef SH_ARCH_MAGIC_BIG
1512     case SH_ARCH_MAGIC_BIG:
1513     case SH_ARCH_MAGIC_LITTLE:
1514       arch = bfd_arch_sh;
1515       machine = 0;
1516       break;
1517 #endif
1518
1519 #ifdef H8500MAGIC
1520     case H8500MAGIC:
1521       arch = bfd_arch_h8500;
1522       machine = 0;
1523       break;
1524 #endif
1525
1526 #ifdef SPARCMAGIC
1527     case SPARCMAGIC:
1528 #ifdef LYNXCOFFMAGIC
1529     case LYNXCOFFMAGIC:
1530 #endif
1531       arch = bfd_arch_sparc;
1532       machine = 0;
1533       break;
1534 #endif
1535
1536     default:                    /* Unreadable input file type */
1537       arch = bfd_arch_obscure;
1538       break;
1539     }
1540
1541   bfd_default_set_arch_mach (abfd, arch, machine);
1542   return true;
1543 }
1544
1545 #ifdef SYMNAME_IN_DEBUG
1546
1547 static boolean
1548 symname_in_debug_hook (abfd, sym)
1549      bfd * abfd;
1550      struct internal_syment *sym;
1551 {
1552   return SYMNAME_IN_DEBUG (sym) ? true : false;
1553 }
1554
1555 #else
1556
1557 #define symname_in_debug_hook \
1558   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1559
1560 #endif
1561
1562 #ifdef RS6000COFF_C
1563
1564 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
1565
1566 static boolean coff_pointerize_aux_hook
1567   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1568            unsigned int, combined_entry_type *));
1569
1570 /*ARGSUSED*/
1571 static boolean
1572 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1573      bfd *abfd;
1574      combined_entry_type *table_base;
1575      combined_entry_type *symbol;
1576      unsigned int indaux;
1577      combined_entry_type *aux;
1578 {
1579   int class = symbol->u.syment.n_sclass;
1580
1581   if ((class == C_EXT || class == C_HIDEXT)
1582       && indaux + 1 == symbol->u.syment.n_numaux)
1583     {
1584       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
1585         {
1586           aux->u.auxent.x_csect.x_scnlen.p =
1587             table_base + aux->u.auxent.x_csect.x_scnlen.l;
1588           aux->fix_scnlen = 1;
1589         }
1590
1591       /* Return true to indicate that the caller should not do any
1592          further work on this auxent.  */
1593       return true;
1594     }
1595
1596   /* Return false to indicate that this auxent should be handled by
1597      the caller.  */
1598   return false;
1599 }
1600
1601 #else
1602 #ifdef I960
1603
1604 /* We don't want to pointerize bal entries.  */
1605
1606 static boolean coff_pointerize_aux_hook
1607   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1608            unsigned int, combined_entry_type *));
1609
1610 /*ARGSUSED*/
1611 static boolean
1612 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1613      bfd *abfd;
1614      combined_entry_type *table_base;
1615      combined_entry_type *symbol;
1616      unsigned int indaux;
1617      combined_entry_type *aux;
1618 {
1619   /* Return true if we don't want to pointerize this aux entry, which
1620      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
1621   return (indaux == 1
1622           && (symbol->u.syment.n_sclass == C_LEAFPROC
1623               || symbol->u.syment.n_sclass == C_LEAFSTAT
1624               || symbol->u.syment.n_sclass == C_LEAFEXT));
1625 }
1626
1627 #else /* ! I960 */
1628
1629 #define coff_pointerize_aux_hook 0
1630
1631 #endif /* ! I960 */
1632 #endif /* ! RS6000COFF_C */
1633
1634 /* Print an aux entry.  This returns true if it has printed it.  */
1635
1636 static boolean coff_print_aux
1637   PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1638            combined_entry_type *, unsigned int));
1639
1640 static boolean
1641 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
1642      bfd *abfd;
1643      FILE *file;
1644      combined_entry_type *table_base;
1645      combined_entry_type *symbol;
1646      combined_entry_type *aux;
1647      unsigned int indaux;
1648 {
1649 #ifdef RS6000COFF_C
1650   if ((symbol->u.syment.n_sclass == C_EXT
1651        || symbol->u.syment.n_sclass == C_HIDEXT)
1652       && indaux + 1 == symbol->u.syment.n_numaux)
1653     {
1654       /* This is a csect entry.  */
1655       fprintf (file, "AUX ");
1656       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
1657         {
1658           BFD_ASSERT (! aux->fix_scnlen);
1659           fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
1660         }
1661       else
1662         {
1663           fprintf (file, "indx ");
1664           if (! aux->fix_scnlen)
1665             fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
1666           else
1667             fprintf (file, "%4ld",
1668                      (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
1669         }
1670       fprintf (file,
1671                " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1672                aux->u.auxent.x_csect.x_parmhash,
1673                (unsigned int) aux->u.auxent.x_csect.x_snhash,
1674                SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
1675                SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
1676                (unsigned int) aux->u.auxent.x_csect.x_smclas,
1677                aux->u.auxent.x_csect.x_stab,
1678                (unsigned int) aux->u.auxent.x_csect.x_snstab);
1679       return true;
1680     }
1681 #endif
1682
1683   /* Return false to indicate that no special action was taken.  */
1684   return false;
1685 }
1686
1687 /*
1688 SUBSUBSECTION
1689         Writing relocations
1690
1691         To write relocations, the back end steps though the
1692         canonical relocation table and create an
1693         @code{internal_reloc}. The symbol index to use is removed from
1694         the @code{offset} field in the symbol table supplied.  The
1695         address comes directly from the sum of the section base
1696         address and the relocation offset; the type is dug directly
1697         from the howto field.  Then the @code{internal_reloc} is
1698         swapped into the shape of an @code{external_reloc} and written
1699         out to disk.
1700
1701 */
1702
1703 #ifdef TARG_AUX
1704
1705 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
1706
1707 /* AUX's ld wants relocations to be sorted */
1708 static int
1709 compare_arelent_ptr (x, y)
1710      const PTR x;
1711      const PTR y;
1712 {
1713   const arelent **a = (const arelent **) x;
1714   const arelent **b = (const arelent **) y;
1715   bfd_size_type aadr = (*a)->address;
1716   bfd_size_type badr = (*b)->address;
1717
1718   return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1719 }
1720
1721 #endif /* TARG_AUX */
1722
1723 static boolean
1724 coff_write_relocs (abfd, first_undef)
1725      bfd * abfd;
1726      int first_undef;
1727 {
1728   asection *s;
1729
1730   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1731     {
1732       unsigned int i;
1733       struct external_reloc dst;
1734       arelent **p;
1735
1736 #ifndef TARG_AUX
1737       p = s->orelocation;
1738 #else
1739       /* sort relocations before we write them out */
1740       p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
1741       if (p == NULL && s->reloc_count > 0)
1742         return false;
1743       memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
1744       qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
1745 #endif
1746
1747       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1748         return false;
1749       for (i = 0; i < s->reloc_count; i++)
1750         {
1751           struct internal_reloc n;
1752           arelent *q = p[i];
1753           memset ((PTR) & n, 0, sizeof (n));
1754
1755           /* Now we've renumbered the symbols we know where the
1756              undefined symbols live in the table.  Check the reloc
1757              entries for symbols who's output bfd isn't the right one.
1758              This is because the symbol was undefined (which means
1759              that all the pointers are never made to point to the same
1760              place). This is a bad thing,'cause the symbols attached
1761              to the output bfd are indexed, so that the relocation
1762              entries know which symbol index they point to.  So we
1763              have to look up the output symbol here. */
1764
1765           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1766             {
1767               int i;
1768               const char *sname = q->sym_ptr_ptr[0]->name;
1769               asymbol **outsyms = abfd->outsymbols;
1770               for (i = first_undef; outsyms[i]; i++)
1771                 {
1772                   const char *intable = outsyms[i]->name;
1773                   if (strcmp (intable, sname) == 0) {
1774                     /* got a hit, so repoint the reloc */
1775                     q->sym_ptr_ptr = outsyms + i;
1776                     break;
1777                   }
1778                 }
1779             }
1780
1781           n.r_vaddr = q->address + s->vma;
1782
1783 #ifdef R_IHCONST
1784           /* The 29k const/consth reloc pair is a real kludge.  The consth
1785              part doesn't have a symbol; it has an offset.  So rebuilt
1786              that here.  */
1787           if (q->howto->type == R_IHCONST)
1788             n.r_symndx = q->addend;
1789           else
1790 #endif
1791             if (q->sym_ptr_ptr)
1792               {
1793                 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1794                   /* This is a relocation relative to the absolute symbol.  */
1795                   n.r_symndx = -1;
1796                 else
1797                   {
1798                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1799                     /* Take notice if the symbol reloc points to a symbol
1800                        we don't have in our symbol table.  What should we
1801                        do for this??  */
1802                     if (n.r_symndx > obj_conv_table_size (abfd))
1803                       abort ();
1804                   }
1805               }
1806
1807 #ifdef SWAP_OUT_RELOC_OFFSET
1808           n.r_offset = q->addend;
1809 #endif
1810
1811 #ifdef SELECT_RELOC
1812           /* Work out reloc type from what is required */
1813           SELECT_RELOC (n, q->howto);
1814 #else
1815           n.r_type = q->howto->type;
1816 #endif
1817           coff_swap_reloc_out (abfd, &n, &dst);
1818           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1819             return false;
1820         }
1821
1822 #ifdef TARG_AUX
1823       if (p != NULL)
1824         free (p);
1825 #endif
1826     }
1827
1828   return true;
1829 }
1830
1831 /* Set flags and magic number of a coff file from architecture and machine
1832    type.  Result is true if we can represent the arch&type, false if not.  */
1833
1834 static boolean
1835 coff_set_flags (abfd, magicp, flagsp)
1836      bfd * abfd;
1837      unsigned *magicp;
1838      unsigned short *flagsp;
1839 {
1840   switch (bfd_get_arch (abfd))
1841     {
1842 #ifdef Z8KMAGIC
1843     case bfd_arch_z8k:
1844       *magicp = Z8KMAGIC;
1845       switch (bfd_get_mach (abfd))
1846         {
1847         case bfd_mach_z8001:
1848           *flagsp = F_Z8001;
1849           break;
1850         case bfd_mach_z8002:
1851           *flagsp = F_Z8002;
1852           break;
1853         default:
1854           return false;
1855         }
1856       return true;
1857 #endif
1858 #ifdef I960ROMAGIC
1859
1860     case bfd_arch_i960:
1861
1862       {
1863         unsigned flags;
1864         *magicp = I960ROMAGIC;
1865         /*
1866           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1867           I960RWMAGIC);   FIXME???
1868           */
1869         switch (bfd_get_mach (abfd))
1870           {
1871           case bfd_mach_i960_core:
1872             flags = F_I960CORE;
1873             break;
1874           case bfd_mach_i960_kb_sb:
1875             flags = F_I960KB;
1876             break;
1877           case bfd_mach_i960_mc:
1878             flags = F_I960MC;
1879             break;
1880           case bfd_mach_i960_xa:
1881             flags = F_I960XA;
1882             break;
1883           case bfd_mach_i960_ca:
1884             flags = F_I960CA;
1885             break;
1886           case bfd_mach_i960_ka_sa:
1887             flags = F_I960KA;
1888             break;
1889           case bfd_mach_i960_jx:
1890             flags = F_I960JX;
1891             break;
1892           case bfd_mach_i960_hx:
1893             flags = F_I960HX;
1894             break;
1895           default:
1896             return false;
1897           }
1898         *flagsp = flags;
1899         return true;
1900       }
1901       break;
1902 #endif
1903 #ifdef ARMMAGIC
1904     case bfd_arch_arm:
1905       *magicp = ARMMAGIC;
1906       return true;
1907 #endif
1908 #ifdef PPCMAGIC
1909     case bfd_arch_powerpc:
1910       *magicp = PPCMAGIC;
1911       return true;
1912       break;
1913 #endif
1914 #ifdef I386MAGIC
1915     case bfd_arch_i386:
1916       *magicp = I386MAGIC;
1917 #ifdef LYNXOS
1918       /* Just overwrite the usual value if we're doing Lynx. */
1919       *magicp = LYNXCOFFMAGIC;
1920 #endif
1921       return true;
1922       break;
1923 #endif
1924 #ifdef I860MAGIC
1925     case bfd_arch_i860:
1926       *magicp = I860MAGIC;
1927       return true;
1928       break;
1929 #endif
1930 #ifdef MC68MAGIC
1931     case bfd_arch_m68k:
1932 #ifdef APOLLOM68KMAGIC
1933       *magicp = APOLLO_COFF_VERSION_NUMBER;
1934 #else
1935       *magicp = MC68MAGIC;
1936 #endif
1937 #ifdef LYNXOS
1938       /* Just overwrite the usual value if we're doing Lynx. */
1939       *magicp = LYNXCOFFMAGIC;
1940 #endif
1941       return true;
1942       break;
1943 #endif
1944
1945 #ifdef MC88MAGIC
1946     case bfd_arch_m88k:
1947       *magicp = MC88OMAGIC;
1948       return true;
1949       break;
1950 #endif
1951 #ifdef H8300MAGIC
1952     case bfd_arch_h8300:
1953       switch (bfd_get_mach (abfd))
1954         {
1955         case bfd_mach_h8300:
1956           *magicp = H8300MAGIC;
1957           return true;
1958         case bfd_mach_h8300h:
1959           *magicp = H8300HMAGIC;
1960           return true;
1961         case bfd_mach_h8300s:
1962           *magicp = H8300SMAGIC;
1963           return true;
1964         }
1965       break;
1966 #endif
1967
1968 #ifdef SH_ARCH_MAGIC_BIG
1969     case bfd_arch_sh:
1970       if (bfd_big_endian (abfd))
1971         *magicp = SH_ARCH_MAGIC_BIG;
1972       else
1973         *magicp = SH_ARCH_MAGIC_LITTLE;
1974       return true;
1975       break;
1976 #endif
1977
1978 #ifdef SPARCMAGIC
1979     case bfd_arch_sparc:
1980       *magicp = SPARCMAGIC;
1981 #ifdef LYNXOS
1982       /* Just overwrite the usual value if we're doing Lynx. */
1983       *magicp = LYNXCOFFMAGIC;
1984 #endif
1985       return true;
1986       break;
1987 #endif
1988
1989 #ifdef H8500MAGIC
1990     case bfd_arch_h8500:
1991       *magicp = H8500MAGIC;
1992       return true;
1993       break;
1994 #endif
1995 #ifdef A29K_MAGIC_BIG
1996     case bfd_arch_a29k:
1997       if (bfd_big_endian (abfd))
1998         *magicp = A29K_MAGIC_BIG;
1999       else
2000         *magicp = A29K_MAGIC_LITTLE;
2001       return true;
2002       break;
2003 #endif
2004
2005 #ifdef WE32KMAGIC
2006     case bfd_arch_we32k:
2007       *magicp = WE32KMAGIC;
2008       return true;
2009       break;
2010 #endif
2011
2012 #ifdef U802TOCMAGIC
2013     case bfd_arch_rs6000:
2014 #ifndef PPCMAGIC
2015     case bfd_arch_powerpc:
2016 #endif
2017       *magicp = U802TOCMAGIC;
2018       return true;
2019       break;
2020 #endif
2021
2022     default:                    /* Unknown architecture */
2023       /* return false;  -- fall through to "return false" below, to avoid
2024        "statement never reached" errors on the one below. */
2025       break;
2026     }
2027
2028   return false;
2029 }
2030
2031
2032 static boolean
2033 coff_set_arch_mach (abfd, arch, machine)
2034      bfd * abfd;
2035      enum bfd_architecture arch;
2036      unsigned long machine;
2037 {
2038   unsigned dummy1;
2039   unsigned short dummy2;
2040
2041   if (! bfd_default_set_arch_mach (abfd, arch, machine))
2042     return false;
2043
2044   if (arch != bfd_arch_unknown &&
2045       coff_set_flags (abfd, &dummy1, &dummy2) != true)
2046     return false;               /* We can't represent this type */
2047
2048   return true;                  /* We're easy ... */
2049 }
2050
2051
2052 /* Calculate the file position for each section. */
2053
2054 static void
2055 coff_compute_section_file_positions (abfd)
2056      bfd * abfd;
2057 {
2058   asection *current;
2059   asection *previous = (asection *) NULL;
2060   file_ptr sofar = FILHSZ;
2061
2062 #ifndef I960
2063   file_ptr old_sofar;
2064 #endif
2065   unsigned int count;
2066
2067 #ifdef RS6000COFF_C
2068   /* On XCOFF, if we have symbols, set up the .debug section.  */
2069   if (bfd_get_symcount (abfd) > 0)
2070     {
2071       bfd_size_type sz;
2072       bfd_size_type i, symcount;
2073       asymbol **symp;
2074
2075       sz = 0;
2076       symcount = bfd_get_symcount (abfd);
2077       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2078         {
2079           coff_symbol_type *cf;
2080
2081           cf = coff_symbol_from (abfd, *symp);
2082           if (cf != NULL
2083               && cf->native != NULL
2084               && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2085             {
2086               size_t len;
2087
2088               len = strlen (bfd_asymbol_name (*symp));
2089               if (len > SYMNMLEN)
2090                 sz += len + 3;
2091             }
2092         }
2093       if (sz > 0)
2094         {
2095           asection *dsec;
2096
2097           dsec = bfd_make_section_old_way (abfd, ".debug");
2098           if (dsec == NULL)
2099             abort ();
2100           dsec->_raw_size = sz;
2101           dsec->flags |= SEC_HAS_CONTENTS;
2102         }
2103     }
2104 #endif
2105
2106 #ifdef COFF_IMAGE_WITH_PE
2107   int page_size;
2108   if (coff_data (abfd)->link_info)
2109     {
2110       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2111     }
2112   else
2113     page_size = PE_DEF_FILE_ALIGNMENT;
2114 #else
2115 #ifdef COFF_PAGE_SIZE
2116   int page_size = COFF_PAGE_SIZE;
2117 #endif
2118 #endif
2119
2120   if (bfd_get_start_address (abfd))
2121     {
2122       /*  A start address may have been added to the original file. In this
2123           case it will need an optional header to record it.  */
2124       abfd->flags |= EXEC_P;
2125     }
2126
2127   if (abfd->flags & EXEC_P)
2128     sofar += AOUTSZ;
2129 #ifdef RS6000COFF_C
2130   else if (xcoff_data (abfd)->full_aouthdr)
2131     sofar += AOUTSZ;
2132   else
2133     sofar += SMALL_AOUTSZ;
2134 #endif
2135
2136   sofar += abfd->section_count * SCNHSZ;
2137
2138 #ifdef RS6000COFF_C
2139   /* XCOFF handles overflows in the reloc and line number count fields
2140      by allocating a new section header to hold the correct counts.  */
2141   for (current = abfd->sections; current != NULL; current = current->next)
2142     if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2143       sofar += SCNHSZ;
2144 #endif
2145
2146   for (current = abfd->sections, count = 1;
2147        current != (asection *) NULL;
2148        current = current->next, ++count)
2149     {
2150       current->target_index = count;
2151
2152       /* Only deal with sections which have contents */
2153       if (!(current->flags & SEC_HAS_CONTENTS))
2154         continue;
2155
2156       /* Align the sections in the file to the same boundary on
2157          which they are aligned in virtual memory.  I960 doesn't
2158          do this (FIXME) so we can stay in sync with Intel.  960
2159          doesn't yet page from files... */
2160 #ifndef I960
2161       if ((abfd->flags & EXEC_P) != 0)
2162         {
2163           /* make sure this section is aligned on the right boundary - by
2164              padding the previous section up if necessary */
2165
2166           old_sofar = sofar;
2167           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2168           if (previous != (asection *) NULL)
2169             {
2170               previous->_raw_size += sofar - old_sofar;
2171             }
2172         }
2173
2174 #endif
2175
2176       /* In demand paged files the low order bits of the file offset
2177          must match the low order bits of the virtual address.  */
2178 #ifdef COFF_PAGE_SIZE
2179       if ((abfd->flags & D_PAGED) != 0
2180           && (current->flags & SEC_ALLOC) != 0)
2181         sofar += (current->vma - sofar) % page_size;
2182 #endif
2183       current->filepos = sofar;
2184
2185 #ifdef COFF_IMAGE_WITH_PE
2186       /* With PE we have to pad each section to be a multiple of its
2187          page size too, and remember both sizes.  */
2188
2189       if (coff_section_data (abfd, current) == NULL)
2190         {
2191           current->used_by_bfd =
2192             (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
2193           if (current->used_by_bfd == NULL)
2194             {
2195               /* FIXME: Return error.  */
2196               abort ();
2197             }
2198         }
2199       if (pei_section_data (abfd, current) == NULL)
2200         {
2201           coff_section_data (abfd, current)->tdata =
2202             (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
2203           if (coff_section_data (abfd, current)->tdata == NULL)
2204             {
2205               /* FIXME: Return error.  */
2206               abort ();
2207             }
2208         }
2209       if (pei_section_data (abfd, current)->virt_size == 0)
2210         pei_section_data (abfd, current)->virt_size = current->_raw_size;
2211
2212       current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2213 #endif
2214
2215       sofar += current->_raw_size;
2216
2217 #ifndef I960
2218       /* make sure that this section is of the right size too */
2219       if ((abfd->flags & EXEC_P) == 0)
2220         current->_raw_size = BFD_ALIGN (current->_raw_size,
2221                                         1 << current->alignment_power);
2222       else
2223         {
2224           old_sofar = sofar;
2225           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2226           current->_raw_size += sofar - old_sofar;
2227         }
2228 #endif
2229
2230 #ifdef _LIB
2231       /* Force .lib sections to start at zero.  The vma is then
2232          incremented in coff_set_section_contents.  This is right for
2233          SVR3.2.  */
2234       if (strcmp (current->name, _LIB) == 0)
2235         bfd_set_section_vma (abfd, current, 0);
2236 #endif
2237
2238       previous = current;
2239     }
2240
2241   obj_relocbase (abfd) = sofar;
2242   abfd->output_has_begun = true;
2243
2244 }
2245
2246 #if 0
2247
2248 /* This can never work, because it is called too late--after the
2249    section positions have been set.  I can't figure out what it is
2250    for, so I am going to disable it--Ian Taylor 20 March 1996.  */
2251
2252 /* If .file, .text, .data, .bss symbols are missing, add them.  */
2253 /* @@ Should we only be adding missing symbols, or overriding the aux
2254    values for existing section symbols?  */
2255 static boolean
2256 coff_add_missing_symbols (abfd)
2257      bfd *abfd;
2258 {
2259   unsigned int nsyms = bfd_get_symcount (abfd);
2260   asymbol **sympp = abfd->outsymbols;
2261   asymbol **sympp2;
2262   unsigned int i;
2263   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
2264
2265   for (i = 0; i < nsyms; i++)
2266     {
2267       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
2268       CONST char *name;
2269       if (csym)
2270         {
2271           /* only do this if there is a coff representation of the input
2272            symbol */
2273           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
2274             {
2275               need_file = 0;
2276               continue;
2277             }
2278           name = csym->symbol.name;
2279           if (!name)
2280             continue;
2281           if (!strcmp (name, _TEXT))
2282             need_text = 0;
2283 #ifdef APOLLO_M68
2284           else if (!strcmp (name, ".wtext"))
2285             need_text = 0;
2286 #endif
2287           else if (!strcmp (name, _DATA))
2288             need_data = 0;
2289           else if (!strcmp (name, _BSS))
2290             need_bss = 0;
2291         }
2292     }
2293   /* Now i == bfd_get_symcount (abfd).  */
2294   /* @@ For now, don't deal with .file symbol.  */
2295   need_file = 0;
2296
2297   if (!need_text && !need_data && !need_bss && !need_file)
2298     return true;
2299   nsyms += need_text + need_data + need_bss + need_file;
2300   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
2301   if (!sympp2)
2302     return false;
2303   memcpy (sympp2, sympp, i * sizeof (asymbol *));
2304   if (need_file)
2305     {
2306       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
2307       abort ();
2308     }
2309   if (need_text)
2310     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
2311   if (need_data)
2312     sympp2[i++] = coff_section_symbol (abfd, _DATA);
2313   if (need_bss)
2314     sympp2[i++] = coff_section_symbol (abfd, _BSS);
2315   BFD_ASSERT (i == nsyms);
2316   bfd_set_symtab (abfd, sympp2, nsyms);
2317   return true;
2318 }
2319
2320 #endif /* 0 */
2321
2322 /* SUPPRESS 558 */
2323 /* SUPPRESS 529 */
2324 static boolean
2325 coff_write_object_contents (abfd)
2326      bfd * abfd;
2327 {
2328   asection *current;
2329   boolean hasrelocs = false;
2330   boolean haslinno = false;
2331   file_ptr scn_base;
2332   file_ptr reloc_base;
2333   file_ptr lineno_base;
2334   file_ptr sym_base;
2335   unsigned long reloc_size = 0;
2336   unsigned long lnno_size = 0;
2337   boolean long_section_names;
2338   asection *text_sec = NULL;
2339   asection *data_sec = NULL;
2340   asection *bss_sec = NULL;
2341   struct internal_filehdr internal_f;
2342   struct internal_aouthdr internal_a;
2343 #ifdef COFF_LONG_SECTION_NAMES
2344   size_t string_size = STRING_SIZE_SIZE;
2345 #endif
2346
2347   bfd_set_error (bfd_error_system_call);
2348
2349   /* Make a pass through the symbol table to count line number entries and
2350      put them into the correct asections */
2351
2352   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
2353
2354   if (abfd->output_has_begun == false)
2355     coff_compute_section_file_positions (abfd);
2356
2357   reloc_base = obj_relocbase (abfd);
2358
2359   /* Work out the size of the reloc and linno areas */
2360
2361   for (current = abfd->sections; current != NULL; current =
2362        current->next)
2363     reloc_size += current->reloc_count * RELSZ;
2364
2365   lineno_base = reloc_base + reloc_size;
2366   sym_base = lineno_base + lnno_size;
2367
2368   /* Indicate in each section->line_filepos its actual file address */
2369   for (current = abfd->sections; current != NULL; current =
2370        current->next)
2371     {
2372       if (current->lineno_count)
2373         {
2374           current->line_filepos = lineno_base;
2375           current->moving_line_filepos = lineno_base;
2376           lineno_base += current->lineno_count * LINESZ;
2377         }
2378       else
2379         {
2380           current->line_filepos = 0;
2381         }
2382       if (current->reloc_count)
2383         {
2384           current->rel_filepos = reloc_base;
2385           reloc_base += current->reloc_count * RELSZ;
2386         }
2387       else
2388         {
2389           current->rel_filepos = 0;
2390         }
2391     }
2392
2393   /* Write section headers to the file.  */
2394   internal_f.f_nscns = 0;
2395
2396   if ((abfd->flags & EXEC_P) != 0)
2397     scn_base = FILHSZ + AOUTSZ;
2398   else
2399     {
2400       scn_base = FILHSZ;
2401 #ifdef RS6000COFF_C
2402       if (xcoff_data (abfd)->full_aouthdr)
2403         scn_base += AOUTSZ;
2404       else
2405         scn_base += SMALL_AOUTSZ;
2406 #endif
2407     }
2408
2409   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
2410     return false;
2411
2412   long_section_names = false;
2413   for (current = abfd->sections;
2414        current != NULL;
2415        current = current->next)
2416     {
2417       struct internal_scnhdr section;
2418
2419 #ifdef COFF_WITH_PE
2420       /* If we've got a .reloc section, remember. */
2421
2422 #ifdef COFF_IMAGE_WITH_PE
2423       if (strcmp (current->name, ".reloc") == 0)
2424         {
2425           pe_data (abfd)->has_reloc_section = 1;
2426         }
2427 #endif
2428
2429 #endif
2430       internal_f.f_nscns++;
2431
2432       strncpy (section.s_name, current->name, SCNNMLEN);
2433
2434 #ifdef COFF_LONG_SECTION_NAMES
2435       /* Handle long section names as in PE.  This must be compatible
2436          with the code in coff_write_symbols.  */
2437       {
2438         size_t len;
2439
2440         len = strlen (current->name);
2441         if (len > SCNNMLEN)
2442           {
2443             memset (section.s_name, 0, SCNNMLEN);
2444             sprintf (section.s_name, "/%lu", (unsigned long) string_size);
2445             string_size += len + 1;
2446             long_section_names = true;
2447           }
2448       }
2449 #endif
2450
2451 #ifdef _LIB
2452       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
2453          Ian Taylor <ian@cygnus.com>.  */
2454       if (strcmp (current->name, _LIB) == 0)
2455         section.s_vaddr = 0;
2456       else
2457 #endif
2458       section.s_vaddr = current->vma;
2459       section.s_paddr = current->lma;
2460       section.s_size =  current->_raw_size;
2461
2462 #ifdef COFF_WITH_PE
2463       section.s_paddr = 0;
2464 #endif
2465 #ifdef COFF_IMAGE_WITH_PE
2466       /* Reminder: s_paddr holds the virtual size of the section.  */
2467       if (coff_section_data (abfd, current) != NULL
2468           && pei_section_data (abfd, current) != NULL)
2469         section.s_paddr = pei_section_data (abfd, current)->virt_size;
2470       else
2471         section.s_paddr = 0;
2472 #endif
2473
2474       /*
2475          If this section has no size or is unloadable then the scnptr
2476          will be 0 too
2477          */
2478       if (current->_raw_size == 0 ||
2479           (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2480         {
2481           section.s_scnptr = 0;
2482         }
2483       else
2484         {
2485           section.s_scnptr = current->filepos;
2486         }
2487       section.s_relptr = current->rel_filepos;
2488       section.s_lnnoptr = current->line_filepos;
2489       section.s_nreloc = current->reloc_count;
2490       section.s_nlnno = current->lineno_count;
2491       if (current->reloc_count != 0)
2492         hasrelocs = true;
2493       if (current->lineno_count != 0)
2494         haslinno = true;
2495
2496 #ifdef RS6000COFF_C
2497       /* Indicate the use of an XCOFF overflow section header.  */
2498       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2499         {
2500           section.s_nreloc = 0xffff;
2501           section.s_nlnno = 0xffff;
2502         }
2503 #endif
2504
2505       section.s_flags = sec_to_styp_flags (current->name, current->flags);
2506
2507       if (!strcmp (current->name, _TEXT))
2508         {
2509           text_sec = current;
2510         }
2511       else if (!strcmp (current->name, _DATA))
2512         {
2513           data_sec = current;
2514         }
2515       else if (!strcmp (current->name, _BSS))
2516         {
2517           bss_sec = current;
2518         }
2519
2520 #ifdef I960
2521       section.s_align = (current->alignment_power
2522                          ? 1 << current->alignment_power
2523                          : 0);
2524
2525 #endif
2526
2527 #ifdef COFF_IMAGE_WITH_PE
2528       /* suppress output of the sections if they are null.  ld includes
2529          the bss and data sections even if there is no size assigned
2530          to them.  NT loader doesn't like it if these section headers are
2531          included if the sections themselves are not needed */
2532       if (section.s_size == 0)
2533         internal_f.f_nscns--;
2534       else
2535 #endif
2536         {
2537           SCNHDR buff;
2538           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2539               || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2540             return false;
2541         }
2542
2543 #ifdef COFF_WITH_PE
2544       /* PE stores COMDAT section information in the symbol table.  If
2545          this section is supposed to have some COMDAT info, track down
2546          the symbol in the symbol table and modify it.  */
2547       if ((current->flags & SEC_LINK_ONCE) != 0)
2548         {
2549           unsigned int i, count;
2550           asymbol **psym;
2551           coff_symbol_type *csym;
2552
2553           count = bfd_get_symcount (abfd);
2554           for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
2555             {
2556               /* Here *PSYM is the section symbol for CURRENT.  */
2557
2558               if (strcmp ((*psym)->name, current->name) == 0)
2559                 {
2560                   csym = coff_symbol_from (abfd, *psym);
2561                   if (csym == NULL
2562                       || csym->native == NULL
2563                       || csym->native->u.syment.n_numaux < 1
2564                       || csym->native->u.syment.n_sclass != C_STAT
2565                       || csym->native->u.syment.n_type != T_NULL)
2566                     continue;
2567                   break;
2568                 }
2569             }
2570
2571           /* Did we find it?
2572              Note that we might not if we're converting the file from
2573              some other object file format.  */
2574           if (i < count)
2575             {
2576               combined_entry_type *aux;
2577
2578               /* We don't touch the x_checksum field.  The
2579                  x_associated field is not currently supported.  */
2580
2581               aux = csym->native + 1;
2582               switch (current->flags & SEC_LINK_DUPLICATES)
2583                 {
2584                 case SEC_LINK_DUPLICATES_DISCARD:
2585                   aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
2586                   break;
2587
2588                 case SEC_LINK_DUPLICATES_ONE_ONLY:
2589                   aux->u.auxent.x_scn.x_comdat =
2590                     IMAGE_COMDAT_SELECT_NODUPLICATES;
2591                   break;
2592
2593                 case SEC_LINK_DUPLICATES_SAME_SIZE:
2594                   aux->u.auxent.x_scn.x_comdat =
2595                     IMAGE_COMDAT_SELECT_SAME_SIZE;
2596                   break;
2597
2598                 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
2599                   aux->u.auxent.x_scn.x_comdat =
2600                     IMAGE_COMDAT_SELECT_EXACT_MATCH;
2601                   break;
2602                 }
2603             }
2604         }
2605 #endif /* COFF_WITH_PE */
2606     }
2607
2608 #ifdef RS6000COFF_C
2609   /* XCOFF handles overflows in the reloc and line number count fields
2610      by creating a new section header to hold the correct values.  */
2611   for (current = abfd->sections; current != NULL; current = current->next)
2612     {
2613       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2614         {
2615           struct internal_scnhdr scnhdr;
2616           SCNHDR buff;
2617
2618           internal_f.f_nscns++;
2619           strncpy (&(scnhdr.s_name[0]), current->name, 8);
2620           scnhdr.s_paddr = current->reloc_count;
2621           scnhdr.s_vaddr = current->lineno_count;
2622           scnhdr.s_size = 0;
2623           scnhdr.s_scnptr = 0;
2624           scnhdr.s_relptr = current->rel_filepos;
2625           scnhdr.s_lnnoptr = current->line_filepos;
2626           scnhdr.s_nreloc = current->target_index;
2627           scnhdr.s_nlnno = current->target_index;
2628           scnhdr.s_flags = STYP_OVRFLO;
2629           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
2630               || bfd_write ((PTR) &buff, 1, SCNHSZ, abfd) != SCNHSZ)
2631             return false;
2632         }
2633     }
2634 #endif
2635
2636   /* OK, now set up the filehdr... */
2637
2638   /* Don't include the internal abs section in the section count */
2639
2640   /*
2641      We will NOT put a fucking timestamp in the header here. Every time you
2642      put it back, I will come in and take it out again.  I'm sorry.  This
2643      field does not belong here.  We fill it with a 0 so it compares the
2644      same but is not a reasonable time. -- gnu@cygnus.com
2645      */
2646   internal_f.f_timdat = 0;
2647
2648   internal_f.f_flags = 0;
2649
2650   if (abfd->flags & EXEC_P)
2651     internal_f.f_opthdr = AOUTSZ;
2652   else
2653     {
2654       internal_f.f_opthdr = 0;
2655 #ifdef RS6000COFF_C
2656       if (xcoff_data (abfd)->full_aouthdr)
2657         internal_f.f_opthdr = AOUTSZ;
2658       else
2659         internal_f.f_opthdr = SMALL_AOUTSZ;
2660 #endif
2661     }
2662
2663   if (!hasrelocs)
2664     internal_f.f_flags |= F_RELFLG;
2665   if (!haslinno)
2666     internal_f.f_flags |= F_LNNO;
2667   if (abfd->flags & EXEC_P)
2668     internal_f.f_flags |= F_EXEC;
2669
2670   /* FIXME: this is wrong for PPC_PE! */
2671   if (bfd_little_endian (abfd))
2672     internal_f.f_flags |= F_AR32WR;
2673   else
2674     internal_f.f_flags |= F_AR32W;
2675
2676   /*
2677      FIXME, should do something about the other byte orders and
2678      architectures.
2679      */
2680
2681 #ifdef RS6000COFF_C
2682   if ((abfd->flags & DYNAMIC) != 0)
2683     internal_f.f_flags |= F_SHROBJ;
2684   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
2685     internal_f.f_flags |= F_DYNLOAD;
2686 #endif
2687
2688   memset (&internal_a, 0, sizeof internal_a);
2689
2690   /* Set up architecture-dependent stuff */
2691
2692   {
2693     unsigned int magic = 0;
2694     unsigned short flags = 0;
2695     coff_set_flags (abfd, &magic, &flags);
2696     internal_f.f_magic = magic;
2697     internal_f.f_flags |= flags;
2698     /* ...and the "opt"hdr... */
2699
2700 #ifdef A29K
2701 #ifdef ULTRA3                   /* NYU's machine */
2702     /* FIXME: This is a bogus check.  I really want to see if there
2703      * is a .shbss or a .shdata section, if so then set the magic
2704      * number to indicate a shared data executable.
2705      */
2706     if (internal_f.f_nscns >= 7)
2707       internal_a.magic = SHMAGIC; /* Shared magic */
2708     else
2709 #endif /* ULTRA3 */
2710       internal_a.magic = NMAGIC; /* Assume separate i/d */
2711 #define __A_MAGIC_SET__
2712 #endif /* A29K */
2713 #ifdef I860
2714     /* FIXME: What are the a.out magic numbers for the i860?  */
2715     internal_a.magic = 0;
2716 #define __A_MAGIC_SET__
2717 #endif /* I860 */
2718 #ifdef I960
2719     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
2720 #define __A_MAGIC_SET__
2721 #endif /* I960 */
2722 #if M88
2723 #define __A_MAGIC_SET__
2724     internal_a.magic = PAGEMAGICBCS;
2725 #endif /* M88 */
2726
2727 #if APOLLO_M68
2728 #define __A_MAGIC_SET__
2729     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
2730 #endif
2731
2732 #if defined(M68) || defined(WE32K) || defined(M68K)
2733 #define __A_MAGIC_SET__
2734 #if defined(LYNXOS)
2735     internal_a.magic = LYNXCOFFMAGIC;
2736 #else
2737 #if defined(TARG_AUX)
2738     internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
2739                         abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
2740                         PAGEMAGICEXECSWAPPED);
2741 #else
2742 #if defined (PAGEMAGICPEXECPAGED)
2743     internal_a.magic = PAGEMAGICPEXECPAGED;
2744 #endif
2745 #endif /* TARG_AUX */
2746 #endif /* LYNXOS */
2747 #endif /* M68 || WE32K || M68K */
2748
2749 #if defined(ARM)
2750 #define __A_MAGIC_SET__
2751     internal_a.magic = ZMAGIC;
2752 #endif
2753 #if defined(PPC_PE)
2754 #define __A_MAGIC_SET__
2755     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
2756 #endif
2757 #if defined(I386)
2758 #define __A_MAGIC_SET__
2759 #if defined(LYNXOS)
2760     internal_a.magic = LYNXCOFFMAGIC;
2761 #else  /* LYNXOS */
2762     internal_a.magic = ZMAGIC;
2763 #endif /* LYNXOS */
2764 #endif /* I386 */
2765
2766 #if defined(SPARC)
2767 #define __A_MAGIC_SET__
2768 #if defined(LYNXOS)
2769     internal_a.magic = LYNXCOFFMAGIC;
2770 #endif /* LYNXOS */
2771 #endif /* SPARC */
2772
2773 #if RS6000COFF_C
2774 #define __A_MAGIC_SET__
2775     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
2776     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
2777     RS6K_AOUTHDR_OMAGIC;
2778 #endif
2779
2780 #ifndef __A_MAGIC_SET__
2781 #include "Your aouthdr magic number is not being set!"
2782 #else
2783 #undef __A_MAGIC_SET__
2784 #endif
2785   }
2786
2787   /* FIXME: Does anybody ever set this to another value?  */
2788   internal_a.vstamp = 0;
2789
2790   /* Now should write relocs, strings, syms */
2791   obj_sym_filepos (abfd) = sym_base;
2792
2793   if (bfd_get_symcount (abfd) != 0)
2794     {
2795       int firstundef;
2796 #if 0
2797       if (!coff_add_missing_symbols (abfd))
2798         return false;
2799 #endif
2800       if (!coff_renumber_symbols (abfd, &firstundef))
2801         return false;
2802       coff_mangle_symbols (abfd);
2803       if (! coff_write_symbols (abfd))
2804         return false;
2805       if (! coff_write_linenumbers (abfd))
2806         return false;
2807       if (! coff_write_relocs (abfd, firstundef))
2808         return false;
2809     }
2810 #ifdef COFF_IMAGE_WITH_PE
2811 #ifdef PPC_PE
2812   else if ((abfd->flags & EXEC_P) != 0)
2813     {
2814       bfd_byte b;
2815
2816       /* PowerPC PE appears to require that all executable files be
2817          rounded up to the page size.  */
2818       b = 0;
2819       if (bfd_seek (abfd,
2820                     BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
2821                     SEEK_SET) != 0
2822           || bfd_write (&b, 1, 1, abfd) != 1)
2823         return false;
2824     }
2825 #endif
2826 #endif
2827
2828   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2829      backend linker, and obj_raw_syment_count is not valid until after
2830      coff_write_symbols is called.  */
2831   if (obj_raw_syment_count (abfd) != 0)
2832     {
2833       internal_f.f_symptr = sym_base;
2834 #ifdef RS6000COFF_C
2835       /* AIX appears to require that F_RELFLG not be set if there are
2836          local symbols but no relocations.  */
2837       internal_f.f_flags &=~ F_RELFLG;
2838 #endif
2839     }
2840   else
2841     {
2842       if (long_section_names)
2843         internal_f.f_symptr = sym_base;
2844       else
2845         internal_f.f_symptr = 0;
2846       internal_f.f_flags |= F_LSYMS;
2847     }
2848
2849   if (text_sec)
2850     {
2851       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
2852       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
2853     }
2854   if (data_sec)
2855     {
2856       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
2857       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
2858     }
2859   if (bss_sec)
2860     {
2861       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
2862       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
2863         internal_a.data_start = bss_sec->vma;
2864     }
2865
2866   internal_a.entry = bfd_get_start_address (abfd);
2867   internal_f.f_nsyms = obj_raw_syment_count (abfd);
2868
2869 #ifdef RS6000COFF_C
2870   if (xcoff_data (abfd)->full_aouthdr)
2871     {
2872       bfd_vma toc;
2873       asection *loader_sec;
2874
2875       internal_a.vstamp = 1;
2876
2877       internal_a.o_snentry = xcoff_data (abfd)->snentry;
2878       if (internal_a.o_snentry == 0)
2879         internal_a.entry = (bfd_vma) -1;
2880
2881       if (text_sec != NULL)
2882         {
2883           internal_a.o_sntext = text_sec->target_index;
2884           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
2885         }
2886       else
2887         {
2888           internal_a.o_sntext = 0;
2889           internal_a.o_algntext = 0;
2890         }
2891       if (data_sec != NULL)
2892         {
2893           internal_a.o_sndata = data_sec->target_index;
2894           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
2895         }
2896       else
2897         {
2898           internal_a.o_sndata = 0;
2899           internal_a.o_algndata = 0;
2900         }
2901       loader_sec = bfd_get_section_by_name (abfd, ".loader");
2902       if (loader_sec != NULL)
2903         internal_a.o_snloader = loader_sec->target_index;
2904       else
2905         internal_a.o_snloader = 0;
2906       if (bss_sec != NULL)
2907         internal_a.o_snbss = bss_sec->target_index;
2908       else
2909         internal_a.o_snbss = 0;
2910
2911       toc = xcoff_data (abfd)->toc;
2912       internal_a.o_toc = toc;
2913       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
2914
2915       internal_a.o_modtype = xcoff_data (abfd)->modtype;
2916       if (xcoff_data (abfd)->cputype != -1)
2917         internal_a.o_cputype = xcoff_data (abfd)->cputype;
2918       else
2919         {
2920           switch (bfd_get_arch (abfd))
2921             {
2922             case bfd_arch_rs6000:
2923               internal_a.o_cputype = 4;
2924               break;
2925             case bfd_arch_powerpc:
2926               if (bfd_get_mach (abfd) == 0)
2927                 internal_a.o_cputype = 3;
2928               else
2929                 internal_a.o_cputype = 1;
2930               break;
2931             default:
2932               abort ();
2933             }
2934         }
2935       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
2936       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
2937     }
2938 #endif
2939
2940   /* now write them */
2941   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2942     return false;
2943   {
2944     char buff[FILHSZ];
2945     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
2946     if (bfd_write ((PTR) buff, 1, FILHSZ, abfd) != FILHSZ)
2947       return false;
2948   }
2949   if (abfd->flags & EXEC_P)
2950     {
2951       /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
2952          include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
2953       char buff[AOUTSZ];
2954       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
2955       if (bfd_write ((PTR) buff, 1, AOUTSZ, abfd) != AOUTSZ)
2956         return false;
2957     }
2958 #ifdef RS6000COFF_C
2959   else
2960     {
2961       AOUTHDR buff;
2962       size_t size;
2963
2964       /* XCOFF seems to always write at least a small a.out header.  */
2965       coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
2966       if (xcoff_data (abfd)->full_aouthdr)
2967         size = AOUTSZ;
2968       else
2969         size = SMALL_AOUTSZ;
2970       if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
2971         return false;
2972     }
2973 #endif
2974
2975   return true;
2976 }
2977
2978 static boolean
2979 coff_set_section_contents (abfd, section, location, offset, count)
2980      bfd * abfd;
2981      sec_ptr section;
2982      PTR location;
2983      file_ptr offset;
2984      bfd_size_type count;
2985 {
2986   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
2987     coff_compute_section_file_positions (abfd);
2988
2989 #ifdef _LIB
2990
2991    /* The physical address field of a .lib section is used to hold the
2992       number of shared libraries in the section.  This code counts the
2993       number of sections being written, and increments the lma field
2994       with the number.
2995
2996       I have found no documentation on the contents of this section.
2997       Experimentation indicates that the section contains zero or more
2998       records, each of which has the following structure:
2999
3000       - a (four byte) word holding the length of this record, in words,
3001       - a word that always seems to be set to "2",
3002       - the path to a shared library, null-terminated and then padded
3003         to a whole word boundary.
3004
3005       bfd_assert calls have been added to alert if an attempt is made
3006       to write a section which doesn't follow these assumptions.  The
3007       code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3008       <robertl@arnet.com> (Thanks!).
3009
3010       Gvran Uddeborg <gvran@uddeborg.pp.se> */
3011
3012     if (strcmp (section->name, _LIB) == 0)
3013       {
3014         bfd_byte *rec, *recend;
3015
3016         rec = (bfd_byte *) location;
3017         recend = rec + count;
3018         while (rec < recend)
3019           {
3020             ++section->lma;
3021             rec += bfd_get_32 (abfd, rec) * 4;
3022           }
3023
3024         BFD_ASSERT (rec == recend);
3025       }
3026
3027 #endif
3028
3029   /* Don't write out bss sections - one way to do this is to
3030        see if the filepos has not been set. */
3031   if (section->filepos == 0)
3032     return true;
3033
3034   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
3035     return false;
3036
3037   if (count != 0)
3038     {
3039       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3040     }
3041   return true;
3042 }
3043 #if 0
3044 static boolean
3045 coff_close_and_cleanup (abfd)
3046      bfd *abfd;
3047 {
3048   if (!bfd_read_p (abfd))
3049     switch (abfd->format)
3050       {
3051       case bfd_archive:
3052         if (!_bfd_write_archive_contents (abfd))
3053           return false;
3054         break;
3055       case bfd_object:
3056         if (!coff_write_object_contents (abfd))
3057           return false;
3058         break;
3059       default:
3060         bfd_set_error (bfd_error_invalid_operation);
3061         return false;
3062       }
3063
3064   /* We depend on bfd_close to free all the memory on the obstack.  */
3065   /* FIXME if bfd_release is not using obstacks! */
3066   return true;
3067 }
3068
3069 #endif
3070
3071 static PTR
3072 buy_and_read (abfd, where, seek_direction, size)
3073      bfd *abfd;
3074      file_ptr where;
3075      int seek_direction;
3076      size_t size;
3077 {
3078   PTR area = (PTR) bfd_alloc (abfd, size);
3079   if (!area)
3080     return (NULL);
3081   if (bfd_seek (abfd, where, seek_direction) != 0
3082       || bfd_read (area, 1, size, abfd) != size)
3083     return (NULL);
3084   return (area);
3085 }                               /* buy_and_read() */
3086
3087 /*
3088 SUBSUBSECTION
3089         Reading linenumbers
3090
3091         Creating the linenumber table is done by reading in the entire
3092         coff linenumber table, and creating another table for internal use.
3093
3094         A coff linenumber table is structured so that each function
3095         is marked as having a line number of 0. Each line within the
3096         function is an offset from the first line in the function. The
3097         base of the line number information for the table is stored in
3098         the symbol associated with the function.
3099
3100         The information is copied from the external to the internal
3101         table, and each symbol which marks a function is marked by
3102         pointing its...
3103
3104         How does this work ?
3105
3106 */
3107
3108 static boolean
3109 coff_slurp_line_table (abfd, asect)
3110      bfd *abfd;
3111      asection *asect;
3112 {
3113   LINENO *native_lineno;
3114   alent *lineno_cache;
3115
3116   BFD_ASSERT (asect->lineno == (alent *) NULL);
3117
3118   native_lineno = (LINENO *) buy_and_read (abfd,
3119                                            asect->line_filepos,
3120                                            SEEK_SET,
3121                                            (size_t) (LINESZ *
3122                                                      asect->lineno_count));
3123   lineno_cache =
3124     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
3125   if (lineno_cache == NULL)
3126     return false;
3127   else
3128     {
3129       unsigned int counter = 0;
3130       alent *cache_ptr = lineno_cache;
3131       LINENO *src = native_lineno;
3132
3133       while (counter < asect->lineno_count)
3134         {
3135           struct internal_lineno dst;
3136           coff_swap_lineno_in (abfd, src, &dst);
3137           cache_ptr->line_number = dst.l_lnno;
3138
3139           if (cache_ptr->line_number == 0)
3140             {
3141               coff_symbol_type *sym =
3142               (coff_symbol_type *) (dst.l_addr.l_symndx
3143                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
3144               cache_ptr->u.sym = (asymbol *) sym;
3145               if (sym->lineno != NULL)
3146                 {
3147                   (*_bfd_error_handler)
3148                     ("%s: warning: duplicate line number information for `%s'",
3149                      bfd_get_filename (abfd),
3150                      bfd_asymbol_name (&sym->symbol));
3151                 }
3152               sym->lineno = cache_ptr;
3153             }
3154           else
3155             {
3156               cache_ptr->u.offset = dst.l_addr.l_paddr
3157                 - bfd_section_vma (abfd, asect);
3158             }                   /* If no linenumber expect a symbol index */
3159
3160           cache_ptr++;
3161           src++;
3162           counter++;
3163         }
3164       cache_ptr->line_number = 0;
3165
3166     }
3167   asect->lineno = lineno_cache;
3168   /* FIXME, free native_lineno here, or use alloca or something. */
3169   return true;
3170 }
3171
3172 static boolean
3173 coff_slurp_symbol_table (abfd)
3174      bfd * abfd;
3175 {
3176   combined_entry_type *native_symbols;
3177   coff_symbol_type *cached_area;
3178   unsigned int *table_ptr;
3179
3180   unsigned int number_of_symbols = 0;
3181
3182   if (obj_symbols (abfd))
3183     return true;
3184
3185   /* Read in the symbol table */
3186   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
3187     {
3188       return (false);
3189     }                           /* on error */
3190
3191   /* Allocate enough room for all the symbols in cached form */
3192   cached_area = ((coff_symbol_type *)
3193                  bfd_alloc (abfd,
3194                             (obj_raw_syment_count (abfd)
3195                              * sizeof (coff_symbol_type))));
3196
3197   if (cached_area == NULL)
3198     return false;
3199   table_ptr = ((unsigned int *)
3200                bfd_alloc (abfd,
3201                           (obj_raw_syment_count (abfd)
3202                            * sizeof (unsigned int))));
3203
3204   if (table_ptr == NULL)
3205     return false;
3206   else
3207     {
3208       coff_symbol_type *dst = cached_area;
3209       unsigned int last_native_index = obj_raw_syment_count (abfd);
3210       unsigned int this_index = 0;
3211       while (this_index < last_native_index)
3212         {
3213           combined_entry_type *src = native_symbols + this_index;
3214           table_ptr[this_index] = number_of_symbols;
3215           dst->symbol.the_bfd = abfd;
3216
3217           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
3218           /* We use the native name field to point to the cached field.  */
3219           src->u.syment._n._n_n._n_zeroes = (long) dst;
3220           dst->symbol.section = coff_section_from_bfd_index (abfd,
3221                                                      src->u.syment.n_scnum);
3222           dst->symbol.flags = 0;
3223           dst->done_lineno = false;
3224
3225           switch (src->u.syment.n_sclass)
3226             {
3227 #ifdef I960
3228             case C_LEAFEXT:
3229 #if 0
3230               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
3231               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3232               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3233 #endif
3234               /* Fall through to next case */
3235
3236 #endif
3237
3238             case C_EXT:
3239 #ifdef RS6000COFF_C
3240             case C_HIDEXT:
3241 #endif
3242 #ifdef COFF_WITH_PE
3243             /* PE uses storage class 0x68 to denote a section symbol */
3244             case C_SECTION:
3245             /* PE uses storage class 0x67 for a weak external symbol.  */
3246             case C_NT_WEAK:
3247 #endif
3248               if ((src->u.syment.n_scnum) == 0)
3249                 {
3250                   if ((src->u.syment.n_value) == 0)
3251                     {
3252                       dst->symbol.section = bfd_und_section_ptr;
3253                       dst->symbol.value = 0;
3254                     }
3255                   else
3256                     {
3257                       dst->symbol.section = bfd_com_section_ptr;
3258                       dst->symbol.value = (src->u.syment.n_value);
3259                     }
3260                 }
3261               else
3262                 {
3263                   /* Base the value as an index from the base of the
3264                      section */
3265
3266                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3267                   dst->symbol.value = (src->u.syment.n_value
3268                                        - dst->symbol.section->vma);
3269
3270                   if (ISFCN ((src->u.syment.n_type)))
3271                     {
3272                       /* A function ext does not go at the end of a
3273                          file.  */
3274                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3275                     }
3276                 }
3277
3278 #ifdef RS6000COFF_C
3279               /* A C_HIDEXT symbol is not global.  */
3280               if (src->u.syment.n_sclass == C_HIDEXT)
3281                 dst->symbol.flags = BSF_LOCAL;
3282               /* A symbol with a csect entry should not go at the end.  */
3283               if (src->u.syment.n_numaux > 0)
3284                 dst->symbol.flags |= BSF_NOT_AT_END;
3285 #endif
3286
3287 #ifdef COFF_WITH_PE
3288               if (src->u.syment.n_sclass == C_NT_WEAK)
3289                 dst->symbol.flags = BSF_WEAK;
3290 #endif
3291
3292               break;
3293
3294             case C_STAT:        /* static                        */
3295 #ifdef I960
3296             case C_LEAFSTAT:    /* static leaf procedure        */
3297 #endif
3298             case C_LABEL:       /* label                         */
3299               if (src->u.syment.n_scnum == -2)
3300                 dst->symbol.flags = BSF_DEBUGGING;
3301               else
3302                 dst->symbol.flags = BSF_LOCAL;
3303
3304               /* Base the value as an index from the base of the
3305                  section, if there is one.  */
3306               if (dst->symbol.section)
3307                 dst->symbol.value = (src->u.syment.n_value
3308                                      - dst->symbol.section->vma);
3309               else
3310                 dst->symbol.value = src->u.syment.n_value;
3311               break;
3312
3313             case C_MOS: /* member of structure   */
3314             case C_EOS: /* end of structure              */
3315 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
3316 #ifdef C_GLBLREG
3317             case C_GLBLREG:     /* A29k-specific storage class */
3318 #endif
3319 #endif
3320             case C_REGPARM:     /* register parameter            */
3321             case C_REG: /* register variable             */
3322 #ifdef C_AUTOARG
3323             case C_AUTOARG:     /* 960-specific storage class */
3324 #endif
3325             case C_TPDEF:       /* type definition               */
3326             case C_ARG:
3327             case C_AUTO:        /* automatic variable */
3328             case C_FIELD:       /* bit field */
3329             case C_ENTAG:       /* enumeration tag               */
3330             case C_MOE: /* member of enumeration         */
3331             case C_MOU: /* member of union               */
3332             case C_UNTAG:       /* union tag                     */
3333               dst->symbol.flags = BSF_DEBUGGING;
3334               dst->symbol.value = (src->u.syment.n_value);
3335               break;
3336
3337             case C_FILE:        /* file name                     */
3338             case C_STRTAG:      /* structure tag                 */
3339 #ifdef RS6000COFF_C
3340             case C_GSYM:
3341             case C_LSYM:
3342             case C_PSYM:
3343             case C_RSYM:
3344             case C_RPSYM:
3345             case C_STSYM:
3346             case C_BCOMM:
3347             case C_ECOMM:
3348             case C_DECL:
3349             case C_ENTRY:
3350             case C_FUN:
3351             case C_ESTAT:
3352 #endif
3353               dst->symbol.flags = BSF_DEBUGGING;
3354               dst->symbol.value = (src->u.syment.n_value);
3355               break;
3356
3357 #ifdef RS6000COFF_C
3358             case C_BINCL:       /* beginning of include file     */
3359             case C_EINCL:       /* ending of include file        */
3360               /* The value is actually a pointer into the line numbers
3361                  of the file.  We locate the line number entry, and
3362                  set the section to the section which contains it, and
3363                  the value to the index in that section.  */
3364               {
3365                 asection *sec;
3366
3367                 dst->symbol.flags = BSF_DEBUGGING;
3368                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3369                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
3370                       && ((file_ptr) (sec->line_filepos
3371                                       + sec->lineno_count * LINESZ)
3372                           > (file_ptr) src->u.syment.n_value))
3373                     break;
3374                 if (sec == NULL)
3375                   dst->symbol.value = 0;
3376                 else
3377                   {
3378                     dst->symbol.section = sec;
3379                     dst->symbol.value = ((src->u.syment.n_value
3380                                           - sec->line_filepos)
3381                                          / LINESZ);
3382                     src->fix_line = 1;
3383                   }
3384               }
3385               break;
3386
3387             case C_BSTAT:
3388               dst->symbol.flags = BSF_DEBUGGING;
3389
3390               /* The value is actually a symbol index.  Save a pointer
3391                  to the symbol instead of the index.  FIXME: This
3392                  should use a union.  */
3393               src->u.syment.n_value =
3394                 (long) (native_symbols + src->u.syment.n_value);
3395               dst->symbol.value = src->u.syment.n_value;
3396               src->fix_value = 1;
3397               break;
3398 #endif
3399
3400             case C_BLOCK:       /* ".bb" or ".eb"                */
3401             case C_FCN:         /* ".bf" or ".ef"                */
3402             case C_EFCN:        /* physical end of function      */
3403               dst->symbol.flags = BSF_LOCAL;
3404               /* Base the value as an index from the base of the
3405                  section.  */
3406               dst->symbol.value = (src->u.syment.n_value
3407                                    - dst->symbol.section->vma);
3408               break;
3409
3410             case C_NULL:
3411             case C_EXTDEF:      /* external definition           */
3412             case C_ULABEL:      /* undefined label               */
3413             case C_USTATIC:     /* undefined static              */
3414 #ifndef COFF_WITH_PE
3415             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
3416                class to represent a section symbol */
3417             case C_LINE:        /* line # reformatted as symbol table entry */
3418               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
3419             case C_ALIAS:       /* duplicate tag                 */
3420 #endif
3421             case C_HIDDEN:      /* ext symbol in dmert public lib */
3422             default:
3423               (*_bfd_error_handler)
3424                 ("%s: Unrecognized storage class %d for %s symbol `%s'",
3425                  bfd_get_filename (abfd), src->u.syment.n_sclass,
3426                  dst->symbol.section->name, dst->symbol.name);
3427               dst->symbol.flags = BSF_DEBUGGING;
3428               dst->symbol.value = (src->u.syment.n_value);
3429               break;
3430             }
3431
3432 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
3433
3434           dst->native = src;
3435
3436           dst->symbol.udata.i = 0;
3437           dst->lineno = (alent *) NULL;
3438           this_index += (src->u.syment.n_numaux) + 1;
3439           dst++;
3440           number_of_symbols++;
3441         }                       /* walk the native symtab */
3442     }                           /* bfdize the native symtab */
3443
3444   obj_symbols (abfd) = cached_area;
3445   obj_raw_syments (abfd) = native_symbols;
3446
3447   bfd_get_symcount (abfd) = number_of_symbols;
3448   obj_convert (abfd) = table_ptr;
3449   /* Slurp the line tables for each section too */
3450   {
3451     asection *p;
3452     p = abfd->sections;
3453     while (p)
3454       {
3455         coff_slurp_line_table (abfd, p);
3456         p = p->next;
3457       }
3458   }
3459   return true;
3460 }                               /* coff_slurp_symbol_table() */
3461
3462 /* Check whether a symbol is globally visible.  This is used by the
3463    COFF backend linker code in cofflink.c, since a couple of targets
3464    have globally visible symbols which are not class C_EXT.  This
3465    function need not handle the case of n_class == C_EXT.  */
3466
3467 #undef OTHER_GLOBAL_CLASS
3468
3469 #ifdef I960
3470 #define OTHER_GLOBAL_CLASS C_LEAFEXT
3471 #endif
3472
3473 #ifdef COFF_WITH_PE
3474 #define OTHER_GLOBAL_CLASS C_SECTION
3475 #endif
3476
3477 #ifdef OTHER_GLOBAL_CLASS
3478
3479 static boolean
3480 coff_sym_is_global (abfd, syment)
3481      bfd *abfd;
3482      struct internal_syment *syment;
3483 {
3484   if (syment->n_sclass == OTHER_GLOBAL_CLASS)
3485     return true;
3486   return false;
3487 }
3488
3489 #undef OTHER_GLOBAL_CLASS
3490
3491 #else /* ! defined (OTHER_GLOBAL_CLASS) */
3492
3493 /* sym_is_global should not be defined if it has nothing to do.  */
3494
3495 #define coff_sym_is_global 0
3496
3497 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
3498
3499 /*
3500 SUBSUBSECTION
3501         Reading relocations
3502
3503         Coff relocations are easily transformed into the internal BFD form
3504         (@code{arelent}).
3505
3506         Reading a coff relocation table is done in the following stages:
3507
3508         o Read the entire coff relocation table into memory.
3509
3510         o Process each relocation in turn; first swap it from the
3511         external to the internal form.
3512
3513         o Turn the symbol referenced in the relocation's symbol index
3514         into a pointer into the canonical symbol table.
3515         This table is the same as the one returned by a call to
3516         @code{bfd_canonicalize_symtab}. The back end will call that
3517         routine and save the result if a canonicalization hasn't been done.
3518
3519         o The reloc index is turned into a pointer to a howto
3520         structure, in a back end specific way. For instance, the 386
3521         and 960 use the @code{r_type} to directly produce an index
3522         into a howto table vector; the 88k subtracts a number from the
3523         @code{r_type} field and creates an addend field.
3524
3525
3526 */
3527
3528 #ifndef CALC_ADDEND
3529 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
3530   {                                                             \
3531     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
3532     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
3533       coffsym = (obj_symbols (abfd)                             \
3534                  + (cache_ptr->sym_ptr_ptr - symbols));         \
3535     else if (ptr)                                               \
3536       coffsym = coff_symbol_from (abfd, ptr);                   \
3537     if (coffsym != (coff_symbol_type *) NULL                    \
3538         && coffsym->native->u.syment.n_scnum == 0)              \
3539       cache_ptr->addend = 0;                                    \
3540     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
3541              && ptr->section != (asection *) NULL)              \
3542       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
3543     else                                                        \
3544       cache_ptr->addend = 0;                                    \
3545   }
3546 #endif
3547
3548 static boolean
3549 coff_slurp_reloc_table (abfd, asect, symbols)
3550      bfd * abfd;
3551      sec_ptr asect;
3552      asymbol ** symbols;
3553 {
3554   RELOC *native_relocs;
3555   arelent *reloc_cache;
3556   arelent *cache_ptr;
3557
3558   unsigned int idx;
3559
3560   if (asect->relocation)
3561     return true;
3562   if (asect->reloc_count == 0)
3563     return true;
3564   if (asect->flags & SEC_CONSTRUCTOR)
3565     return true;
3566   if (!coff_slurp_symbol_table (abfd))
3567     return false;
3568   native_relocs =
3569     (RELOC *) buy_and_read (abfd,
3570                             asect->rel_filepos,
3571                             SEEK_SET,
3572                             (size_t) (RELSZ *
3573                                       asect->reloc_count));
3574   reloc_cache = (arelent *)
3575     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
3576
3577   if (reloc_cache == NULL)
3578     return false;
3579
3580
3581   for (idx = 0; idx < asect->reloc_count; idx++)
3582     {
3583 #ifdef RELOC_PROCESSING
3584       struct internal_reloc dst;
3585       struct external_reloc *src;
3586
3587       cache_ptr = reloc_cache + idx;
3588       src = native_relocs + idx;
3589       coff_swap_reloc_in (abfd, src, &dst);
3590
3591       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
3592 #else
3593       struct internal_reloc dst;
3594       asymbol *ptr;
3595       struct external_reloc *src;
3596
3597       cache_ptr = reloc_cache + idx;
3598       src = native_relocs + idx;
3599
3600       coff_swap_reloc_in (abfd, src, &dst);
3601
3602
3603       cache_ptr->address = dst.r_vaddr;
3604
3605       if (dst.r_symndx != -1)
3606         {
3607           /* @@ Should never be greater than count of symbols!  */
3608           if (dst.r_symndx >= obj_conv_table_size (abfd))
3609             abort ();
3610           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
3611           ptr = *(cache_ptr->sym_ptr_ptr);
3612         }
3613       else
3614         {
3615           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3616           ptr = 0;
3617         }
3618
3619       /* The symbols definitions that we have read in have been
3620          relocated as if their sections started at 0. But the offsets
3621          refering to the symbols in the raw data have not been
3622          modified, so we have to have a negative addend to compensate.
3623
3624          Note that symbols which used to be common must be left alone */
3625
3626       /* Calculate any reloc addend by looking at the symbol */
3627       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
3628
3629       cache_ptr->address -= asect->vma;
3630 /* !!     cache_ptr->section = (asection *) NULL;*/
3631
3632       /* Fill in the cache_ptr->howto field from dst.r_type */
3633       RTYPE2HOWTO (cache_ptr, &dst);
3634 #endif
3635
3636     }
3637
3638   asect->relocation = reloc_cache;
3639   return true;
3640 }
3641
3642 #ifndef coff_rtype_to_howto
3643 #ifdef RTYPE2HOWTO
3644
3645 /* Get the howto structure for a reloc.  This is only used if the file
3646    including this one defines coff_relocate_section to be
3647    _bfd_coff_generic_relocate_section, so it is OK if it does not
3648    always work.  It is the responsibility of the including file to
3649    make sure it is reasonable if it is needed.  */
3650
3651 static reloc_howto_type *coff_rtype_to_howto
3652   PARAMS ((bfd *, asection *, struct internal_reloc *,
3653            struct coff_link_hash_entry *, struct internal_syment *,
3654            bfd_vma *));
3655
3656 /*ARGSUSED*/
3657 static reloc_howto_type *
3658 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
3659      bfd *abfd;
3660      asection *sec;
3661      struct internal_reloc *rel;
3662      struct coff_link_hash_entry *h;
3663      struct internal_syment *sym;
3664      bfd_vma *addendp;
3665 {
3666   arelent genrel;
3667
3668   RTYPE2HOWTO (&genrel, rel);
3669   return genrel.howto;
3670 }
3671
3672 #else /* ! defined (RTYPE2HOWTO) */
3673
3674 #define coff_rtype_to_howto NULL
3675
3676 #endif /* ! defined (RTYPE2HOWTO) */
3677 #endif /* ! defined (coff_rtype_to_howto) */
3678
3679 /* This is stupid.  This function should be a boolean predicate.  */
3680 static long
3681 coff_canonicalize_reloc (abfd, section, relptr, symbols)
3682      bfd * abfd;
3683      sec_ptr section;
3684      arelent ** relptr;
3685      asymbol ** symbols;
3686 {
3687   arelent *tblptr = section->relocation;
3688   unsigned int count = 0;
3689
3690
3691   if (section->flags & SEC_CONSTRUCTOR)
3692     {
3693       /* this section has relocs made up by us, they are not in the
3694        file, so take them out of their chain and place them into
3695        the data area provided */
3696       arelent_chain *chain = section->constructor_chain;
3697       for (count = 0; count < section->reloc_count; count++)
3698         {
3699           *relptr++ = &chain->relent;
3700           chain = chain->next;
3701         }
3702
3703     }
3704   else
3705     {
3706       if (! coff_slurp_reloc_table (abfd, section, symbols))
3707         return -1;
3708
3709       tblptr = section->relocation;
3710
3711       for (; count++ < section->reloc_count;)
3712         *relptr++ = tblptr++;
3713
3714
3715     }
3716   *relptr = 0;
3717   return section->reloc_count;
3718 }
3719
3720 #ifdef GNU960
3721 file_ptr
3722 coff_sym_filepos (abfd)
3723      bfd *abfd;
3724 {
3725   return obj_sym_filepos (abfd);
3726 }
3727 #endif
3728
3729 #ifndef coff_reloc16_estimate
3730 #define coff_reloc16_estimate dummy_reloc16_estimate
3731
3732 static int
3733 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
3734      bfd *abfd;
3735      asection *input_section;
3736      arelent *reloc;
3737      unsigned int shrink;
3738      struct bfd_link_info *link_info;
3739 {
3740   abort ();
3741 }
3742
3743 #endif
3744
3745 #ifndef coff_reloc16_extra_cases
3746 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
3747 /* This works even if abort is not declared in any header file.  */
3748 static void
3749 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
3750                            dst_ptr)
3751      bfd *abfd;
3752      struct bfd_link_info *link_info;
3753      struct bfd_link_order *link_order;
3754      arelent *reloc;
3755      bfd_byte *data;
3756      unsigned int *src_ptr;
3757      unsigned int *dst_ptr;
3758 {
3759   abort ();
3760 }
3761 #endif
3762
3763 /* If coff_relocate_section is defined, we can use the optimized COFF
3764    backend linker.  Otherwise we must continue to use the old linker.  */
3765 #ifdef coff_relocate_section
3766 #ifndef coff_bfd_link_hash_table_create
3767 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
3768 #endif
3769 #ifndef coff_bfd_link_add_symbols
3770 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
3771 #endif
3772 #ifndef coff_bfd_final_link
3773 #define coff_bfd_final_link _bfd_coff_final_link
3774 #endif
3775 #else /* ! defined (coff_relocate_section) */
3776 #define coff_relocate_section NULL
3777 #ifndef coff_bfd_link_hash_table_create
3778 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3779 #endif
3780 #ifndef coff_bfd_link_add_symbols
3781 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
3782 #endif
3783 #define coff_bfd_final_link _bfd_generic_final_link
3784 #endif /* ! defined (coff_relocate_section) */
3785 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
3786
3787 #ifndef coff_start_final_link
3788 #define coff_start_final_link NULL
3789 #endif
3790
3791 #ifndef coff_adjust_symndx
3792 #define coff_adjust_symndx NULL
3793 #endif
3794
3795 #ifndef coff_link_add_one_symbol
3796 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
3797 #endif
3798
3799 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
3800 {
3801   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
3802   coff_swap_aux_out, coff_swap_sym_out,
3803   coff_swap_lineno_out, coff_swap_reloc_out,
3804   coff_swap_filehdr_out, coff_swap_aouthdr_out,
3805   coff_swap_scnhdr_out,
3806   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
3807 #ifdef COFF_LONG_FILENAMES
3808   true,
3809 #else
3810   false,
3811 #endif
3812 #ifdef COFF_LONG_SECTION_NAMES
3813   true,
3814 #else
3815   false,
3816 #endif
3817   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
3818   coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
3819   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
3820   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
3821   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
3822   coff_sym_is_global, coff_compute_section_file_positions,
3823   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
3824   coff_adjust_symndx, coff_link_add_one_symbol
3825 };
3826
3827 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
3828 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3829 #define coff_get_section_contents _bfd_generic_get_section_contents
3830
3831 #ifndef coff_bfd_copy_private_symbol_data
3832 #define coff_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data
3833 #endif
3834
3835 #ifndef coff_bfd_copy_private_section_data
3836 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
3837 #endif
3838
3839 #ifndef coff_bfd_copy_private_bfd_data
3840 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
3841 #endif
3842
3843 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3844 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3845
3846 #ifndef coff_bfd_print_private_bfd_data
3847 #define coff_bfd_print_private_bfd_data  _bfd_generic_bfd_print_private_bfd_data
3848 #endif
3849
3850 #ifndef coff_bfd_is_local_label
3851 #define coff_bfd_is_local_label bfd_generic_is_local_label
3852 #endif
3853 #ifndef coff_read_minisymbols
3854 #define coff_read_minisymbols _bfd_generic_read_minisymbols
3855 #endif
3856 #ifndef coff_minisymbol_to_symbol
3857 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3858 #endif
3859
3860 /* The reloc lookup routine must be supplied by each individual COFF
3861    backend.  */
3862 #ifndef coff_bfd_reloc_type_lookup
3863 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3864 #endif
3865
3866 #ifndef coff_bfd_get_relocated_section_contents
3867 #define coff_bfd_get_relocated_section_contents \
3868   bfd_generic_get_relocated_section_contents
3869 #endif
3870 #ifndef coff_bfd_relax_section
3871 #define coff_bfd_relax_section bfd_generic_relax_section
3872 #endif