bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 1995 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_slurp_symbol_table. *}
 269 .unsigned int fix_scnlen : 1;
 270 .
 271 .       {* The container for the symbol structure as read and translated
 272 .           from the file. *}
 273 .
 274 .union {
 275 .   union internal_auxent auxent;
 276 .   struct internal_syment syment;
 277 . } u;
 278 .} combined_entry_type;
 279 .
 280 .
 281 .{* Each canonical asymbol really looks like this: *}
 282 .
 283 .typedef struct coff_symbol_struct
 284 .{
 285 .   {* The actual symbol which the rest of BFD works with *}
 286 .asymbol symbol;
 287 .
 288 .   {* A pointer to the hidden information for this symbol *}
 289 .combined_entry_type *native;
 290 .
 291 .   {* A pointer to the linenumber information for this symbol *}
 292 .struct lineno_cache_entry *lineno;
 293 .
 294 .   {* Have the line numbers been relocated yet ? *}
 295 .boolean done_lineno;
 296 .} coff_symbol_type;
 297
 298
 299 */
 300
 301 #ifndef IMAGE_BASE
 302 #define IMAGE_BASE 0
 303 #endif
 304
 305
 306 static bfd_vma
 307 pe_value(bfd_link_pe_info_dval *ptr, bfd_vma def)
 308 {
 309   if (ptr && ptr->defined)
 310     return ptr->value;
 311   return def;
 312 }
 313
 314
 315 #include "coffswap.h"
 316 \f
 317 /* void warning(); */
 318
 319 /*
 320  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 321  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 322  * NOTE: If you add to/change this routine, you should mirror the changes
 323  *      in styp_to_sec_flags().
 324  */
 325 static long
 326 sec_to_styp_flags (sec_name, sec_flags)
 327      CONST char *sec_name;
 328      flagword sec_flags;
 329 {
 330   long styp_flags = 0;
 331
 332   if (!strcmp (sec_name, _TEXT))
 333     {
 334       styp_flags = STYP_TEXT;
 335     }
 336   else if (!strcmp (sec_name, _DATA))
 337     {
 338       styp_flags = STYP_DATA;
 339 #ifdef TWO_DATA_SECS
 340     }
 341   else if (!strcmp (sec_name, ".data2"))
 342     {
 343       styp_flags = STYP_DATA;
 344 #endif /* TWO_DATA_SECS */
 345     }
 346   else if (!strcmp (sec_name, _BSS))
 347     {
 348       styp_flags = STYP_BSS;
 349 #ifdef _COMMENT
 350     }
 351   else if (!strcmp (sec_name, _COMMENT))
 352     {
 353       styp_flags = STYP_INFO;
 354 #endif /* _COMMENT */
 355 #ifdef _LIB
 356     }
 357   else if (!strcmp (sec_name, _LIB))
 358     {
 359       styp_flags = STYP_LIB;
 360 #endif /* _LIB */
 361 #ifdef _LIT
 362     }
 363   else if (!strcmp (sec_name, _LIT))
 364     {
 365       styp_flags = STYP_LIT;
 366 #endif /* _LIT */
 367     }
 368   else if (!strcmp (sec_name, ".debug"))
 369     {
 370 #ifdef STYP_DEBUG
 371       styp_flags = STYP_DEBUG;
 372 #else
 373       styp_flags = STYP_INFO;
 374 #endif
 375     }
 376   else if (!strncmp (sec_name, ".stab", 5))
 377     {
 378       styp_flags = STYP_INFO;
 379     }
 380   /* Try and figure out what it should be */
 381   else if (sec_flags & SEC_CODE)
 382     {
 383       styp_flags = STYP_TEXT;
 384     }
 385   else if (sec_flags & SEC_DATA)
 386     {
 387       styp_flags = STYP_DATA;
 388     }
 389   else if (sec_flags & SEC_READONLY)
 390     {
 391 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 392       styp_flags = STYP_LIT;
 393 #else
 394       styp_flags = STYP_TEXT;
 395 #endif /* STYP_LIT */
 396     }
 397   else if (sec_flags & SEC_LOAD)
 398     {
 399       styp_flags = STYP_TEXT;
 400     }
 401   else if (sec_flags & SEC_ALLOC)
 402     {
 403       styp_flags = STYP_BSS;
 404     }
 405
 406 #ifdef STYP_NOLOAD
 407   if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
 408     styp_flags |= STYP_NOLOAD;
 409 #endif
 410
 411   return (styp_flags);
 412 }
 413 /*
 414  * Return a word with SEC_* flags set to represent the incoming
 415  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 416  * function is sec_to_styp_flags().
 417  * NOTE: If you add to/change this routine, you should mirror the changes
 418  *      in sec_to_styp_flags().
 419  */
 420 static flagword
 421 styp_to_sec_flags (abfd, hdr, name)
 422      bfd *abfd;
 423      PTR hdr;
 424      const char *name;
 425 {
 426   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 427   long styp_flags = internal_s->s_flags;
 428   flagword sec_flags = 0;
 429
 430 #ifdef STYP_NOLOAD
 431   if (styp_flags & STYP_NOLOAD)
 432     {
 433       sec_flags |= SEC_NEVER_LOAD;
 434     }
 435 #endif /* STYP_NOLOAD */
 436
 437   /* For 386 COFF, at least, an unloadable text or data section is
 438      actually a shared library section.  */
 439   if (styp_flags & STYP_TEXT)
 440     {
 441       if (sec_flags & SEC_NEVER_LOAD)
 442         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 443       else
 444         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 445     }
 446   else if (styp_flags & STYP_DATA)
 447     {
 448       if (sec_flags & SEC_NEVER_LOAD)
 449         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 450       else
 451         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 452     }
 453   else if (styp_flags & STYP_BSS)
 454     {
 455 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 456       if (sec_flags & SEC_NEVER_LOAD)
 457         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 458       else
 459 #endif
 460         sec_flags |= SEC_ALLOC;
 461     }
 462   else if (styp_flags & STYP_INFO)
 463     {
 464       /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
 465          defined.  coff_compute_section_file_positions uses
 466          COFF_PAGE_SIZE to ensure that the low order bits of the
 467          section VMA and the file offset match.  If we don't know
 468          COFF_PAGE_SIZE, we can't ensure the correct correspondence,
 469          and demand page loading of the file will fail.  */
 470 #ifdef COFF_PAGE_SIZE
 471       sec_flags |= SEC_DEBUGGING;
 472 #endif
 473     }
 474   else if (strcmp (name, _TEXT) == 0)
 475     {
 476       if (sec_flags & SEC_NEVER_LOAD)
 477         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 478       else
 479         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 480     }
 481   else if (strcmp (name, _DATA) == 0
 482 #ifdef TWO_DATA_SECS
 483            || strcmp (name, ".data2") == 0
 484 #endif
 485            )
 486     {
 487       if (sec_flags & SEC_NEVER_LOAD)
 488         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 489       else
 490         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 491     }
 492   else if (strcmp (name, _BSS) == 0)
 493     {
 494 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 495       if (sec_flags & SEC_NEVER_LOAD)
 496         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 497       else
 498 #endif
 499         sec_flags |= SEC_ALLOC;
 500     }
 501   else if (strcmp (name, ".debug") == 0
 502 #ifdef _COMMENT
 503            || strcmp (name, _COMMENT) == 0
 504 #endif
 505            || strncmp (name, ".stab", 5) == 0)
 506     {
 507 #ifdef COFF_PAGE_SIZE
 508       sec_flags |= SEC_DEBUGGING;
 509 #endif
 510     }
 511 #ifdef _LIB
 512   else if (strcmp (name, _LIB) == 0)
 513     ;
 514 #endif
 515 #ifdef _LIT
 516   else if (strcmp (name, _LIT) == 0)
 517     {
 518       sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
 519     }
 520 #endif
 521   else
 522     {
 523       sec_flags |= SEC_ALLOC | SEC_LOAD;
 524     }
 525
 526 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 527   if ((styp_flags & STYP_LIT) == STYP_LIT)
 528     {
 529       sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 530     }
 531 #endif /* STYP_LIT */
 532 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 533   if (styp_flags & STYP_OTHER_LOAD)
 534     {
 535       sec_flags = (SEC_LOAD | SEC_ALLOC);
 536     }
 537 #endif /* STYP_SDATA */
 538
 539   return (sec_flags);
 540 }
 541
 542 #define get_index(symbol)       ((symbol)->udata.i)
 543
 544 /*
 545 INTERNAL_DEFINITION
 546         bfd_coff_backend_data
 547
 548 CODE_FRAGMENT
 549
 550 Special entry points for gdb to swap in coff symbol table parts:
 551 .typedef struct
 552 .{
 553 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 554 .       bfd            *abfd,
 555 .       PTR             ext,
 556 .       int             type,
 557 .       int             class,
 558 .       int             indaux,
 559 .       int             numaux,
 560 .       PTR             in));
 561 .
 562 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 563 .       bfd            *abfd ,
 564 .       PTR             ext,
 565 .       PTR             in));
 566 .
 567 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 568 .       bfd            *abfd,
 569 .       PTR            ext,
 570 .       PTR             in));
 571 .
 572
 573 Special entry points for gas to swap out coff parts:
 574
 575 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 576 .       bfd     *abfd,
 577 .       PTR     in,
 578 .       int     type,
 579 .       int     class,
 580 .       int     indaux,
 581 .       int     numaux,
 582 .       PTR     ext));
 583 .
 584 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 585 .      bfd      *abfd,
 586 .      PTR      in,
 587 .      PTR      ext));
 588 .
 589 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 590 .       bfd     *abfd,
 591 .       PTR     in,
 592 .       PTR     ext));
 593 .
 594 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 595 .       bfd     *abfd,
 596 .       PTR     src,
 597 .       PTR     dst));
 598 .
 599 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 600 .       bfd     *abfd,
 601 .       PTR     in,
 602 .       PTR     out));
 603 .
 604 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 605 .       bfd     *abfd,
 606 .       PTR     in,
 607 .       PTR     out));
 608 .
 609 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 610 .       bfd     *abfd,
 611 .       PTR     in,
 612 .       PTR     out));
 613 .
 614
 615 Special entry points for generic COFF routines to call target
 616 dependent COFF routines:
 617
 618 . unsigned int _bfd_filhsz;
 619 . unsigned int _bfd_aoutsz;
 620 . unsigned int _bfd_scnhsz;
 621 . unsigned int _bfd_symesz;
 622 . unsigned int _bfd_auxesz;
 623 . unsigned int _bfd_relsz;
 624 . unsigned int _bfd_linesz;
 625 . boolean _bfd_coff_long_filenames;
 626 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 627 .       bfd     *abfd,
 628 .       PTR     ext,
 629 .       PTR     in));
 630 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 631 .       bfd     *abfd,
 632 .       PTR     ext,
 633 .       PTR     in));
 634 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 635 .       bfd     *abfd,
 636 .       PTR     ext,
 637 .       PTR     in));
 638 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
 639 .       bfd     *abfd,
 640 .       PTR     ext,
 641 .       PTR     in));
 642 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 643 .       bfd     *abfd,
 644 .       PTR     internal_filehdr));
 645 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 646 .       bfd     *abfd,
 647 .       PTR     internal_filehdr));
 648 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 649 .       bfd     *abfd,
 650 .       PTR     internal_filehdr,
 651 .       PTR     internal_aouthdr));
 652 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 653 .       bfd     *abfd,
 654 .       PTR     internal_scnhdr,
 655 .       const char *name));
 656 . asection *(*_bfd_make_section_hook) PARAMS ((
 657 .       bfd     *abfd,
 658 .       char    *name));
 659 . void (*_bfd_set_alignment_hook) PARAMS ((
 660 .       bfd     *abfd,
 661 .       asection *sec,
 662 .       PTR     internal_scnhdr));
 663 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 664 .       bfd     *abfd));
 665 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 666 .       bfd     *abfd,
 667 .       struct internal_syment *sym));
 668 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 669 .       bfd     *abfd,
 670 .       struct bfd_link_info *link_info,
 671 .       struct bfd_link_order *link_order,
 672 .       arelent *reloc,
 673 .       bfd_byte *data,
 674 .       unsigned int *src_ptr,
 675 .       unsigned int *dst_ptr));
 676 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
 677 .       bfd *abfd,
 678 .       asection *input_section,
 679 .       arelent *r,
 680 .       unsigned int shrink,
 681 .       struct bfd_link_info *link_info));
 682 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
 683 .       bfd *abfd,
 684 .       struct internal_syment *));
 685 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
 686 .       bfd *abfd));
 687 . boolean (*_bfd_coff_relocate_section) PARAMS ((
 688 .       bfd *output_bfd,
 689 .       struct bfd_link_info *info,
 690 .       bfd *input_bfd,
 691 .       asection *input_section,
 692 .       bfd_byte *contents,
 693 .       struct internal_reloc *relocs,
 694 .       struct internal_syment *syms,
 695 .       asection **sections));
 696 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
 697 .       bfd *abfd,
 698 .       asection *sec,
 699 .       struct internal_reloc *rel,
 700 .       struct coff_link_hash_entry *h,
 701 .       struct internal_syment *sym,
 702 .       bfd_vma *addendp));
 703 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
 704 .       bfd *obfd,
 705 .       struct bfd_link_info *info,
 706 .       bfd *ibfd,
 707 .       asection *sec,
 708 .       struct internal_reloc *reloc,
 709 .       boolean *adjustedp));
 710 .
 711 .} bfd_coff_backend_data;
 712 .
 713 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 714 .
 715 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
 716 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
 717 .
 718 .#define bfd_coff_swap_sym_in(a,e,i) \
 719 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 720 .
 721 .#define bfd_coff_swap_lineno_in(a,e,i) \
 722 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 723 .
 724 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 725 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 726 .
 727 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 728 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 729 .
 730 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
 731 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
 732 .
 733 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 734 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 735 .
 736 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 737 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 738 .
 739 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 740 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 741 .
 742 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 743 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 744 .
 745 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 746 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 747 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 748 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 749 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 750 .#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
 751 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 752 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 753 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 754 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 755 .
 756 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 757 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 758 .
 759 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 760 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 761 .
 762 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
 763 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
 764 .
 765 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 766 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 767 .
 768 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 769 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 770 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
 771 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
 772 .
 773 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
 774 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
 775 .
 776 .#define bfd_coff_make_section_hook(abfd, name)\
 777 .        ((coff_backend_info (abfd)->_bfd_make_section_hook) (abfd, name))
 778 .
 779 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 780 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 781 .
 782 .#define bfd_coff_slurp_symbol_table(abfd)\
 783 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 784 .
 785 .#define bfd_coff_symname_in_debug(abfd, sym)\
 786 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 787 .
 788 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
 789 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 790 .         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
 791 .
 792 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
 793 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 794 .         (abfd, section, reloc, shrink, link_info))
 795 .
 796 .#define bfd_coff_sym_is_global(abfd, sym)\
 797 .        ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
 798 .         (abfd, sym))
 799 .
 800 .#define bfd_coff_compute_section_file_positions(abfd)\
 801 .        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
 802 .         (abfd))
 803 .
 804 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
 805 .        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
 806 .         (obfd, info, ibfd, o, con, rel, isyms, secs))
 807 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
 808 .        ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
 809 .         (abfd, sec, rel, h, sym, addendp))
 810 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
 811 .        ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
 812 .         (obfd, info, ibfd, sec, rel, adjustedp))
 813 .
 814 */
 815
 816 /* See whether the magic number matches.  */
 817
 818 static boolean
 819 coff_bad_format_hook (abfd, filehdr)
 820      bfd * abfd;
 821      PTR filehdr;
 822 {
 823   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 824
 825   if (BADMAG (*internal_f))
 826     return false;
 827
 828   /* if the optional header is NULL or not the correct size then
 829      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
 830      and Intel 960 readwrite headers (I960WRMAGIC) is that the
 831      optional header is of a different size.
 832
 833      But the mips keeps extra stuff in it's opthdr, so dont check
 834      when doing that
 835      */
 836
 837 #if defined(M88) || defined(I960)
 838   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
 839     return false;
 840 #endif
 841
 842   return true;
 843 }
 844
 845 static asection *
 846 coff_make_section_hook (abfd, name)
 847      bfd * abfd;
 848      char *name;
 849 {
 850 #ifdef TWO_DATA_SECS
 851   /* FIXME: This predates the call to bfd_make_section_anyway
 852      in make_a_section_from_file, and can probably go away.  */
 853   /* On SCO a file created by the Microsoft assembler can have two
 854      .data sections.  We use .data2 for the second one.  */
 855   if (strcmp (name, _DATA) == 0)
 856     return bfd_make_section (abfd, ".data2");
 857 #endif
 858   return (asection *) NULL;
 859 }
 860
 861 /*
 862    initialize a section structure with information peculiar to this
 863    particular implementation of coff
 864 */
 865
 866 static boolean
 867 coff_new_section_hook (abfd, section)
 868      bfd * abfd;
 869      asection * section;
 870 {
 871   section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
 872
 873   /* Allocate aux records for section symbols, to store size and
 874      related info.
 875
 876      @@ Shouldn't use constant multiplier here!  */
 877   coffsymbol (section->symbol)->native =
 878     (combined_entry_type *) bfd_zalloc (abfd,
 879                                         sizeof (combined_entry_type) * 10);
 880
 881   /* The .stab section must be aligned to 2**2 at most, because
 882      otherwise there may be gaps in the section which gdb will not
 883      know how to interpret.  Examining the section name is a hack, but
 884      that is also how gdb locates the section.  We also align the
 885      .stabstr section this way for backward compatibility, although I
 886      believe it would work anyhow.  */
 887   if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2
 888       && (strncmp (section->name, ".stab", 5) == 0))
 889     section->alignment_power = 2;
 890
 891   return true;
 892 }
 893
 894 #ifdef I960
 895
 896 /* Set the alignment of a BFD section.  */
 897
 898 static void
 899 coff_set_alignment_hook (abfd, section, scnhdr)
 900      bfd * abfd;
 901      asection * section;
 902      PTR scnhdr;
 903 {
 904   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 905   unsigned int i;
 906
 907   for (i = 0; i < 32; i++)
 908     if ((1 << i) >= hdr->s_align)
 909       break;
 910   section->alignment_power = i;
 911 }
 912
 913 #else /* ! I960 */
 914
 915 #define coff_set_alignment_hook \
 916   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
 917
 918 #endif /* ! I960 */
 919
 920 static boolean
 921 coff_mkobject (abfd)
 922      bfd * abfd;
 923 {
 924   coff_data_type *coff;
 925
 926   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
 927   if (abfd->tdata.coff_obj_data == 0)
 928     {
 929       bfd_set_error (bfd_error_no_memory);
 930       return false;
 931     }
 932   coff = coff_data (abfd);
 933   coff->symbols = (coff_symbol_type *) NULL;
 934   coff->conversion_table = (unsigned int *) NULL;
 935   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 936   coff->relocbase = 0;
 937 /*  make_abs_section(abfd);*/
 938
 939 #ifdef COFF_WITH_PE
 940   obj_pe (abfd) = 1;
 941 #endif
 942   return true;
 943 }
 944
 945 /* Create the COFF backend specific information.  */
 946
 947 static PTR
 948 coff_mkobject_hook (abfd, filehdr, aouthdr)
 949      bfd * abfd;
 950      PTR filehdr;
 951      PTR aouthdr;
 952 {
 953   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 954   coff_data_type *coff;
 955
 956   if (coff_mkobject (abfd) == false)
 957     return NULL;
 958
 959   coff = coff_data (abfd);
 960
 961   coff->sym_filepos = internal_f->f_symptr;
 962
 963   /* These members communicate important constants about the symbol
 964      table to GDB's symbol-reading code.  These `constants'
 965      unfortunately vary among coff implementations...  */
 966   coff->local_n_btmask = N_BTMASK;
 967   coff->local_n_btshft = N_BTSHFT;
 968   coff->local_n_tmask = N_TMASK;
 969   coff->local_n_tshift = N_TSHIFT;
 970   coff->local_symesz = SYMESZ;
 971   coff->local_auxesz = AUXESZ;
 972   coff->local_linesz = LINESZ;
 973
 974   obj_raw_syment_count (abfd) =
 975     obj_conv_table_size (abfd) =
 976       internal_f->f_nsyms;
 977
 978   return (PTR) coff;
 979 }
 980
 981 /* Determine the machine architecture and type.  FIXME: This is target
 982    dependent because the magic numbers are defined in the target
 983    dependent header files.  But there is no particular need for this.
 984    If the magic numbers were moved to a separate file, this function
 985    would be target independent and would also be much more successful
 986    at linking together COFF files for different architectures.  */
 987
 988 static boolean
 989 coff_set_arch_mach_hook (abfd, filehdr)
 990      bfd *abfd;
 991      PTR filehdr;
 992 {
 993   long machine;
 994   enum bfd_architecture arch;
 995   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 996
 997   machine = 0;
 998   switch (internal_f->f_magic)
 999     {
1000 #ifdef I386MAGIC
1001     case I386MAGIC:
1002     case I386PTXMAGIC:
1003     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1004     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1005       arch = bfd_arch_i386;
1006       machine = 0;
1007       break;
1008 #endif
1009 #ifdef A29K_MAGIC_BIG
1010     case A29K_MAGIC_BIG:
1011     case A29K_MAGIC_LITTLE:
1012       arch = bfd_arch_a29k;
1013       machine = 0;
1014       break;
1015 #endif
1016 #ifdef ARMMAGIC
1017     case ARMMAGIC:
1018       arch = bfd_arch_arm;
1019       machine =0;
1020       break;
1021 #endif
1022 #ifdef MC68MAGIC
1023     case MC68MAGIC:
1024     case M68MAGIC:
1025 #ifdef MC68KBCSMAGIC
1026     case MC68KBCSMAGIC:
1027 #endif
1028 #ifdef APOLLOM68KMAGIC
1029     case APOLLOM68KMAGIC:
1030 #endif
1031 #ifdef LYNXCOFFMAGIC
1032     case LYNXCOFFMAGIC:
1033 #endif
1034       arch = bfd_arch_m68k;
1035       machine = 68020;
1036       break;
1037 #endif
1038 #ifdef MC88MAGIC
1039     case MC88MAGIC:
1040     case MC88DMAGIC:
1041     case MC88OMAGIC:
1042       arch = bfd_arch_m88k;
1043       machine = 88100;
1044       break;
1045 #endif
1046 #ifdef Z8KMAGIC
1047     case Z8KMAGIC:
1048       arch = bfd_arch_z8k;
1049       switch (internal_f->f_flags & F_MACHMASK)
1050         {
1051         case F_Z8001:
1052           machine = bfd_mach_z8001;
1053           break;
1054         case F_Z8002:
1055           machine = bfd_mach_z8002;
1056           break;
1057         default:
1058           return false;
1059         }
1060       break;
1061 #endif
1062 #ifdef I960
1063 #ifdef I960ROMAGIC
1064     case I960ROMAGIC:
1065     case I960RWMAGIC:
1066       arch = bfd_arch_i960;
1067       switch (F_I960TYPE & internal_f->f_flags)
1068         {
1069         default:
1070         case F_I960CORE:
1071           machine = bfd_mach_i960_core;
1072           break;
1073         case F_I960KB:
1074           machine = bfd_mach_i960_kb_sb;
1075           break;
1076         case F_I960MC:
1077           machine = bfd_mach_i960_mc;
1078           break;
1079         case F_I960XA:
1080           machine = bfd_mach_i960_xa;
1081           break;
1082         case F_I960CA:
1083           machine = bfd_mach_i960_ca;
1084           break;
1085         case F_I960KA:
1086           machine = bfd_mach_i960_ka_sa;
1087           break;
1088           /* start-sanitize-i960xl */
1089         case F_I960XL:
1090           machine = bfd_mach_i960_xl;
1091           break;
1092           /* end-sanitize-i960xl */
1093         }
1094       break;
1095 #endif
1096 #endif
1097
1098 #ifdef U802ROMAGIC
1099     case U802ROMAGIC:
1100     case U802WRMAGIC:
1101     case U802TOCMAGIC:
1102       arch = bfd_arch_rs6000;
1103       machine = 6000;
1104       break;
1105 #endif
1106
1107 #ifdef WE32KMAGIC
1108     case WE32KMAGIC:
1109       arch = bfd_arch_we32k;
1110       machine = 0;
1111       break;
1112 #endif
1113
1114 #ifdef H8300MAGIC
1115     case H8300MAGIC:
1116       arch = bfd_arch_h8300;
1117       machine = bfd_mach_h8300;
1118       /* !! FIXME this probably isn't the right place for this */
1119       abfd->flags |= BFD_IS_RELAXABLE;
1120       break;
1121 #endif
1122
1123 #ifdef H8300HMAGIC
1124     case H8300HMAGIC:
1125       arch = bfd_arch_h8300;
1126       machine = bfd_mach_h8300h;
1127       /* !! FIXME this probably isn't the right place for this */
1128       abfd->flags |= BFD_IS_RELAXABLE;
1129       break;
1130 #endif
1131
1132 #ifdef SH_ARCH_MAGIC_BIG
1133     case SH_ARCH_MAGIC_BIG:
1134     case SH_ARCH_MAGIC_LITTLE:
1135       arch = bfd_arch_sh;
1136       machine = 0;
1137       break;
1138 #endif
1139
1140 #ifdef H8500MAGIC
1141     case H8500MAGIC:
1142       arch = bfd_arch_h8500;
1143       machine = 0;
1144       break;
1145 #endif
1146
1147 #ifdef SPARCMAGIC
1148     case SPARCMAGIC:
1149 #ifdef LYNXCOFFMAGIC
1150     case LYNXCOFFMAGIC:
1151 #endif
1152       arch = bfd_arch_sparc;
1153       machine = 0;
1154       break;
1155 #endif
1156
1157     default:                    /* Unreadable input file type */
1158       arch = bfd_arch_obscure;
1159       break;
1160     }
1161
1162   bfd_default_set_arch_mach (abfd, arch, machine);
1163   return true;
1164 }
1165
1166 #ifdef SYMNAME_IN_DEBUG
1167
1168 static boolean
1169 symname_in_debug_hook (abfd, sym)
1170      bfd * abfd;
1171      struct internal_syment *sym;
1172 {
1173   return SYMNAME_IN_DEBUG (sym) ? true : false;
1174 }
1175
1176 #else
1177
1178 #define symname_in_debug_hook \
1179   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1180
1181 #endif
1182
1183 /*
1184 SUBSUBSECTION
1185         Writing relocations
1186
1187         To write relocations, the back end steps though the
1188         canonical relocation table and create an
1189         @code{internal_reloc}. The symbol index to use is removed from
1190         the @code{offset} field in the symbol table supplied.  The
1191         address comes directly from the sum of the section base
1192         address and the relocation offset; the type is dug directly
1193         from the howto field.  Then the @code{internal_reloc} is
1194         swapped into the shape of an @code{external_reloc} and written
1195         out to disk.
1196
1197 */
1198
1199 static boolean
1200 coff_write_relocs (abfd, first_undef)
1201      bfd * abfd;
1202      int first_undef;
1203 {
1204   asection *s;
1205   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1206     {
1207       unsigned int i;
1208       struct external_reloc dst;
1209
1210       arelent **p = s->orelocation;
1211       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1212         return false;
1213       for (i = 0; i < s->reloc_count; i++)
1214         {
1215           struct internal_reloc n;
1216           arelent *q = p[i];
1217           memset ((PTR) & n, 0, sizeof (n));
1218
1219           /* Now we've renumbered the symbols we know where the
1220              undefined symbols live in the table.  Check the reloc
1221              entries for symbols who's output bfd isn't the right one.
1222              This is because the symbol was undefined (which means
1223              that all the pointers are never made to point to the same
1224              place). This is a bad thing,'cause the symbols attached
1225              to the output bfd are indexed, so that the relocation
1226              entries know which symbol index they point to.  So we
1227              have to look up the output symbol here. */
1228
1229           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1230             {
1231               int i;
1232               const char *sname = q->sym_ptr_ptr[0]->name;
1233               asymbol **outsyms = abfd->outsymbols;
1234               for (i = first_undef; outsyms[i]; i++)
1235                 {
1236                   const char *intable = outsyms[i]->name;
1237                   if (strcmp (intable, sname) == 0) {
1238                     /* got a hit, so repoint the reloc */
1239                     q->sym_ptr_ptr = outsyms + i;
1240                     break;
1241                   }
1242                 }
1243             }
1244
1245           n.r_vaddr = q->address + s->vma;
1246
1247 #ifdef R_IHCONST
1248           /* The 29k const/consth reloc pair is a real kludge.  The consth
1249              part doesn't have a symbol; it has an offset.  So rebuilt
1250              that here.  */
1251           if (q->howto->type == R_IHCONST)
1252             n.r_symndx = q->addend;
1253           else
1254 #endif
1255             if (q->sym_ptr_ptr)
1256               {
1257                 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1258                   /* This is a relocation relative to the absolute symbol.  */
1259                   n.r_symndx = -1;
1260                 else
1261                   {
1262                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1263                     /* Take notice if the symbol reloc points to a symbol
1264                        we don't have in our symbol table.  What should we
1265                        do for this??  */
1266                     if (n.r_symndx > obj_conv_table_size (abfd))
1267                       abort ();
1268                   }
1269               }
1270
1271 #ifdef SWAP_OUT_RELOC_OFFSET
1272           n.r_offset = q->addend;
1273 #endif
1274
1275 #ifdef SELECT_RELOC
1276           /* Work out reloc type from what is required */
1277           SELECT_RELOC (n, q->howto);
1278 #else
1279           n.r_type = q->howto->type;
1280 #endif
1281           coff_swap_reloc_out (abfd, &n, &dst);
1282           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1283             return false;
1284         }
1285     }
1286
1287   return true;
1288 }
1289
1290 /* Set flags and magic number of a coff file from architecture and machine
1291    type.  Result is true if we can represent the arch&type, false if not.  */
1292
1293 static boolean
1294 coff_set_flags (abfd, magicp, flagsp)
1295      bfd * abfd;
1296      unsigned *magicp;
1297      unsigned short *flagsp;
1298 {
1299   switch (bfd_get_arch (abfd))
1300     {
1301 #ifdef Z8KMAGIC
1302     case bfd_arch_z8k:
1303       *magicp = Z8KMAGIC;
1304       switch (bfd_get_mach (abfd))
1305         {
1306         case bfd_mach_z8001:
1307           *flagsp = F_Z8001;
1308           break;
1309         case bfd_mach_z8002:
1310           *flagsp = F_Z8002;
1311           break;
1312         default:
1313           return false;
1314         }
1315       return true;
1316 #endif
1317 #ifdef I960ROMAGIC
1318
1319     case bfd_arch_i960:
1320
1321       {
1322         unsigned flags;
1323         *magicp = I960ROMAGIC;
1324         /*
1325           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1326           I960RWMAGIC);   FIXME???
1327           */
1328         switch (bfd_get_mach (abfd))
1329           {
1330           case bfd_mach_i960_core:
1331             flags = F_I960CORE;
1332             break;
1333           case bfd_mach_i960_kb_sb:
1334             flags = F_I960KB;
1335             break;
1336           case bfd_mach_i960_mc:
1337             flags = F_I960MC;
1338             break;
1339           case bfd_mach_i960_xa:
1340             flags = F_I960XA;
1341             break;
1342           case bfd_mach_i960_ca:
1343             flags = F_I960CA;
1344             break;
1345           case bfd_mach_i960_ka_sa:
1346             flags = F_I960KA;
1347             break;
1348             /* start-sanitize-i960xl */
1349           case bfd_mach_i960_xl:
1350             flags = F_I960XL;
1351             break;
1352             /* end-sanitize-i960xl */
1353           default:
1354             return false;
1355           }
1356         *flagsp = flags;
1357         return true;
1358       }
1359       break;
1360 #endif
1361 #ifdef ARMMAGIC
1362     case bfd_arch_arm:
1363       *magicp = ARMMAGIC;
1364       return true;
1365 #endif
1366 #ifdef I386MAGIC
1367     case bfd_arch_i386:
1368       *magicp = I386MAGIC;
1369 #ifdef LYNXOS
1370       /* Just overwrite the usual value if we're doing Lynx. */
1371       *magicp = LYNXCOFFMAGIC;
1372 #endif
1373       return true;
1374       break;
1375 #endif
1376 #ifdef MC68MAGIC
1377     case bfd_arch_m68k:
1378 #ifdef APOLLOM68KMAGIC
1379       *magicp = APOLLO_COFF_VERSION_NUMBER;
1380 #else
1381       *magicp = MC68MAGIC;
1382 #endif
1383 #ifdef LYNXOS
1384       /* Just overwrite the usual value if we're doing Lynx. */
1385       *magicp = LYNXCOFFMAGIC;
1386 #endif
1387       return true;
1388       break;
1389 #endif
1390
1391 #ifdef MC88MAGIC
1392     case bfd_arch_m88k:
1393       *magicp = MC88OMAGIC;
1394       return true;
1395       break;
1396 #endif
1397 #ifdef H8300MAGIC
1398     case bfd_arch_h8300:
1399       switch (bfd_get_mach (abfd))
1400         {
1401         case bfd_mach_h8300:
1402           *magicp = H8300MAGIC;
1403           return true;
1404         case bfd_mach_h8300h:
1405           *magicp = H8300HMAGIC;
1406           return true;
1407         }
1408       break;
1409 #endif
1410
1411 #ifdef SH_ARCH_MAGIC_BIG
1412     case bfd_arch_sh:
1413       if (abfd->xvec->byteorder_big_p)
1414         *magicp = SH_ARCH_MAGIC_BIG;
1415       else
1416         *magicp = SH_ARCH_MAGIC_LITTLE;
1417       return true;
1418       break;
1419 #endif
1420
1421 #ifdef SPARCMAGIC
1422     case bfd_arch_sparc:
1423       *magicp = SPARCMAGIC;
1424 #ifdef LYNXOS
1425       /* Just overwrite the usual value if we're doing Lynx. */
1426       *magicp = LYNXCOFFMAGIC;
1427 #endif
1428       return true;
1429       break;
1430 #endif
1431
1432 #ifdef H8500MAGIC
1433     case bfd_arch_h8500:
1434       *magicp = H8500MAGIC;
1435       return true;
1436       break;
1437 #endif
1438 #ifdef A29K_MAGIC_BIG
1439     case bfd_arch_a29k:
1440       if (abfd->xvec->byteorder_big_p)
1441         *magicp = A29K_MAGIC_BIG;
1442       else
1443         *magicp = A29K_MAGIC_LITTLE;
1444       return true;
1445       break;
1446 #endif
1447
1448 #ifdef WE32KMAGIC
1449     case bfd_arch_we32k:
1450       *magicp = WE32KMAGIC;
1451       return true;
1452       break;
1453 #endif
1454
1455 #ifdef U802TOCMAGIC
1456     case bfd_arch_rs6000:
1457     case bfd_arch_powerpc:
1458       *magicp = U802TOCMAGIC;
1459       return true;
1460       break;
1461 #endif
1462
1463     default:                    /* Unknown architecture */
1464       /* return false;  -- fall through to "return false" below, to avoid
1465        "statement never reached" errors on the one below. */
1466       break;
1467     }
1468
1469   return false;
1470 }
1471
1472
1473 static boolean
1474 coff_set_arch_mach (abfd, arch, machine)
1475      bfd * abfd;
1476      enum bfd_architecture arch;
1477      unsigned long machine;
1478 {
1479   unsigned dummy1;
1480   unsigned short dummy2;
1481
1482   if (! bfd_default_set_arch_mach (abfd, arch, machine))
1483     return false;
1484
1485   if (arch != bfd_arch_unknown &&
1486       coff_set_flags (abfd, &dummy1, &dummy2) != true)
1487     return false;               /* We can't represent this type */
1488
1489   return true;                  /* We're easy ... */
1490 }
1491
1492
1493 /* Calculate the file position for each section. */
1494
1495 static void
1496 coff_compute_section_file_positions (abfd)
1497      bfd * abfd;
1498 {
1499   asection *current;
1500   asection *previous = (asection *) NULL;
1501   file_ptr sofar = FILHSZ;
1502 #ifndef I960
1503   file_ptr old_sofar;
1504 #endif
1505   unsigned int count;
1506
1507   if (bfd_get_start_address (abfd))
1508     {
1509       /*  A start address may have been added to the original file. In this
1510         case it will need an optional header to record it.  */
1511       abfd->flags |= EXEC_P;
1512     }
1513
1514   if (abfd->flags & EXEC_P)
1515     sofar += AOUTSZ;
1516
1517   sofar += abfd->section_count * SCNHSZ;
1518   for (current = abfd->sections, count = 1;
1519        current != (asection *) NULL;
1520        current = current->next, ++count)
1521     {
1522       current->target_index = count;
1523
1524       /* Only deal with sections which have contents */
1525       if (!(current->flags & SEC_HAS_CONTENTS))
1526         continue;
1527
1528 #ifdef COFF_WITH_PE
1529       /* Do not include the .junk section.  This is where we collect section
1530          data which we don't need.  This is mainly the MS .debug$ data which
1531          stores codeview debug data. */
1532       if (strcmp (current->name, ".junk") == 0)
1533         {
1534          continue;
1535         }
1536 #endif
1537
1538       /* Align the sections in the file to the same boundary on
1539          which they are aligned in virtual memory.  I960 doesn't
1540          do this (FIXME) so we can stay in sync with Intel.  960
1541          doesn't yet page from files... */
1542 #ifndef I960
1543       {
1544         /* make sure this section is aligned on the right boundary - by
1545          padding the previous section up if necessary */
1546
1547         old_sofar = sofar;
1548         sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1549         if (previous != (asection *) NULL)
1550           {
1551             previous->_raw_size += sofar - old_sofar;
1552           }
1553       }
1554
1555 #endif
1556
1557 #ifdef COFF_PAGE_SIZE
1558       /* In demand paged files the low order bits of the file offset
1559          must match the low order bits of the virtual address.  */
1560       if ((abfd->flags & D_PAGED) != 0
1561           && (current->flags & SEC_ALLOC) != 0)
1562         sofar += (current->vma - sofar) % COFF_PAGE_SIZE;
1563 #endif
1564
1565       current->filepos = sofar;
1566
1567       sofar += current->_raw_size;
1568 #ifndef I960
1569       /* make sure that this section is of the right size too */
1570       old_sofar = sofar;
1571       sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1572       current->_raw_size += sofar - old_sofar;
1573 #endif
1574
1575 #ifdef _LIB
1576       /* Force .lib sections to start at zero.  The vma is then
1577          incremented in coff_set_section_contents.  This is right for
1578          SVR3.2.  */
1579       if (strcmp (current->name, _LIB) == 0)
1580         bfd_set_section_vma (abfd, current, 0);
1581 #endif
1582
1583       previous = current;
1584     }
1585 #ifdef COFF_WITH_PE
1586   /* Normally, the starting location for the symbol table will be at the end
1587      of the last section.  However, when dealing with NT, the last section
1588      must be as long as its size rounded up to the next page (0x1000). */
1589   sofar = ((sofar + NT_FILE_ALIGNMENT - 1) /
1590                            NT_FILE_ALIGNMENT) * NT_FILE_ALIGNMENT;
1591 #endif
1592
1593   obj_relocbase (abfd) = sofar;
1594   abfd->output_has_begun = true;
1595
1596 }
1597
1598 #ifndef RS6000COFF_C
1599
1600 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1601 /* @@ Should we only be adding missing symbols, or overriding the aux
1602    values for existing section symbols?  */
1603 static boolean
1604 coff_add_missing_symbols (abfd)
1605      bfd *abfd;
1606 {
1607   unsigned int nsyms = bfd_get_symcount (abfd);
1608   asymbol **sympp = abfd->outsymbols;
1609   asymbol **sympp2;
1610   unsigned int i;
1611   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1612
1613   for (i = 0; i < nsyms; i++)
1614     {
1615       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1616       CONST char *name;
1617       if (csym)
1618         {
1619           /* only do this if there is a coff representation of the input
1620            symbol */
1621           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1622             {
1623               need_file = 0;
1624               continue;
1625             }
1626           name = csym->symbol.name;
1627           if (!name)
1628             continue;
1629           if (!strcmp (name, _TEXT))
1630             need_text = 0;
1631 #ifdef APOLLO_M68
1632           else if (!strcmp (name, ".wtext"))
1633             need_text = 0;
1634 #endif
1635           else if (!strcmp (name, _DATA))
1636             need_data = 0;
1637           else if (!strcmp (name, _BSS))
1638             need_bss = 0;
1639         }
1640     }
1641   /* Now i == bfd_get_symcount (abfd).  */
1642   /* @@ For now, don't deal with .file symbol.  */
1643   need_file = 0;
1644
1645   if (!need_text && !need_data && !need_bss && !need_file)
1646     return true;
1647   nsyms += need_text + need_data + need_bss + need_file;
1648   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1649   if (!sympp2)
1650     {
1651       bfd_set_error (bfd_error_no_memory);
1652       return false;
1653     }
1654   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1655   if (need_file)
1656     {
1657       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1658       abort ();
1659     }
1660   if (need_text)
1661     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1662   if (need_data)
1663     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1664   if (need_bss)
1665     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1666   BFD_ASSERT (i == nsyms);
1667   bfd_set_symtab (abfd, sympp2, nsyms);
1668   return true;
1669 }
1670
1671 #endif /* ! defined (RS6000COFF_C) */
1672
1673 #ifdef COFF_WITH_PE
1674 static void add_data_entry (abfd, aout, idx, name, base)
1675      bfd *abfd;
1676      struct internal_aouthdr *aout;
1677      int idx;
1678      char *name;
1679      bfd_vma base;
1680 {
1681   asection *sec = bfd_get_section_by_name (abfd, name);
1682
1683   /* add import directory information if it exists */
1684   if (sec != NULL)
1685     {
1686       aout->pe->DataDirectory[idx].VirtualAddress = sec->lma - base;
1687       aout->pe->DataDirectory[idx].Size = sec->_raw_size;
1688     }
1689 }
1690
1691
1692 static void
1693 fill_pe_header_info (abfd, internal_f, internal_a, end_of_image)
1694      bfd *abfd;
1695      struct internal_filehdr *internal_f;
1696      struct internal_aouthdr *internal_a;
1697      bfd_vma end_of_image;
1698 {
1699   /* assign other filehdr fields for DOS header and NT signature */
1700
1701   bfd_link_pe_info *pe_info = coff_data (abfd)->link_info->pe_info;
1702
1703   internal_f->f_timdat = time (0);
1704
1705   if (pe_value  (&pe_info->dll, 0))
1706     internal_f->f_flags |=  F_DLL ;
1707
1708
1709   if (bfd_get_section_by_name (abfd, ".reloc"))
1710     internal_f->f_flags &= ~F_RELFLG;
1711
1712
1713   memset (internal_f->pe, 0, sizeof (struct internal_extra_pe_filehdr));
1714   memset (internal_a->pe, 0, sizeof (struct internal_extra_pe_aouthdr));
1715
1716
1717   internal_a->pe->ImageBase =  pe_value (&pe_info->image_base, IMAGE_BASE);
1718
1719   if (internal_a->tsize)
1720     internal_a->text_start -= internal_a->pe->ImageBase;
1721   if (internal_a->dsize)
1722     internal_a->data_start -= internal_a->pe->ImageBase;
1723   if (internal_a->entry)
1724     internal_a->entry -= internal_a->pe->ImageBase;
1725
1726
1727   internal_f->pe->e_magic    = DOSMAGIC;
1728   internal_f->pe->e_cblp     = 0x90;
1729   internal_f->pe->e_cp       = 0x3;
1730   internal_f->pe->e_crlc     = 0x0;
1731   internal_f->pe->e_cparhdr  = 0x4;
1732   internal_f->pe->e_minalloc = 0x0;
1733   internal_f->pe->e_maxalloc = 0xffff;
1734   internal_f->pe->e_ss       = 0x0;
1735   internal_f->pe->e_sp       = 0xb8;
1736   internal_f->pe->e_csum     = 0x0;
1737   internal_f->pe->e_ip       = 0x0;
1738   internal_f->pe->e_cs       = 0x0;
1739   internal_f->pe->e_lfarlc   = 0x40;
1740   internal_f->pe->e_ovno     = 0x0;
1741   {
1742     int idx;
1743     for (idx=0; idx < 4; idx++)
1744       internal_f->pe->e_res[idx] = 0x0;
1745   }
1746   internal_f->pe->e_oemid   = 0x0;
1747   internal_f->pe->e_oeminfo = 0x0;
1748   {
1749     int idx;
1750     for (idx=0; idx < 10; idx++)
1751       internal_f->pe->e_res2[idx] = 0x0;
1752   }
1753   internal_f->pe->e_lfanew = 0x80;
1754
1755   /* this next collection of data are mostly just characters.  It appears
1756      to be constant within the headers put on NT exes */
1757   internal_f->pe->dos_message[0]  = 0x0eba1f0e;
1758   internal_f->pe->dos_message[1]  = 0xcd09b400;
1759   internal_f->pe->dos_message[2]  = 0x4c01b821;
1760   internal_f->pe->dos_message[3]  = 0x685421cd;
1761   internal_f->pe->dos_message[4]  = 0x70207369;
1762   internal_f->pe->dos_message[5]  = 0x72676f72;
1763   internal_f->pe->dos_message[6]  = 0x63206d61;
1764   internal_f->pe->dos_message[7]  = 0x6f6e6e61;
1765   internal_f->pe->dos_message[8]  = 0x65622074;
1766   internal_f->pe->dos_message[9]  = 0x6e757220;
1767   internal_f->pe->dos_message[10] = 0x206e6920;
1768   internal_f->pe->dos_message[11] = 0x20534f44;
1769   internal_f->pe->dos_message[12] = 0x65646f6d;
1770   internal_f->pe->dos_message[13] = 0x0a0d0d2e;
1771   internal_f->pe->dos_message[14] = 0x24;
1772   internal_f->pe->dos_message[15] = 0x0;
1773   internal_f->pe->nt_signature = NT_SIGNATURE;
1774
1775
1776   /* write all of the other optional header data */
1777
1778
1779
1780   internal_a->pe->SectionAlignment = pe_value (&pe_info->section_alignment,
1781                                                NT_SECTION_ALIGNMENT);
1782
1783   internal_a->pe->FileAlignment = pe_value (&pe_info->file_alignment,
1784                                             NT_FILE_ALIGNMENT);
1785
1786   internal_a->pe->MajorOperatingSystemVersion =
1787     pe_value (&pe_info->major_os_version, 1);
1788
1789   internal_a->pe->MinorOperatingSystemVersion =
1790     pe_value (&pe_info->minor_os_version, 0);
1791
1792   internal_a->pe->MajorImageVersion =
1793     pe_value (&pe_info->major_image_version, 1);
1794
1795   internal_a->pe->MinorImageVersion =
1796     pe_value (&pe_info->minor_image_version, 0);
1797
1798
1799   internal_a->pe->MajorSubsystemVersion =
1800     pe_value (&pe_info->major_subsystem_version, 3);
1801
1802
1803   internal_a->pe->MinorSubsystemVersion =
1804     pe_value (&pe_info->minor_subsystem_version, 10);
1805
1806
1807
1808   internal_a->pe->Subsystem =
1809     pe_value (&pe_info->subsystem, BFD_PE_CONSOLE);
1810
1811
1812
1813
1814   /* Virtual start address, take virtual start address of last section,
1815      add its physical size and round up the next page (NT_SECTION_ALIGNMENT).
1816      An assumption has been made that the sections stored in the abfd
1817      structure are in order and that I have successfully saved the last
1818      section's address and size. */
1819
1820   internal_a->pe->SizeOfImage =
1821     (end_of_image - internal_a->pe->ImageBase
1822      + internal_a->pe->SectionAlignment - 1)
1823       & ~ (internal_a->pe->SectionAlignment-1);
1824
1825   /* Start of .text section will do here since it is the first section after
1826      the headers.  Note that NT_IMAGE_BASE has already been removed above */
1827   internal_a->pe->SizeOfHeaders = internal_a->text_start;
1828   internal_a->pe->CheckSum = 0;
1829   internal_a->pe->DllCharacteristics = 0;
1830
1831   internal_a->pe->SizeOfStackReserve = pe_value (&pe_info->stack_reserve,
1832                                                  NT_DEF_RESERVE);
1833   internal_a->pe->SizeOfStackCommit = pe_value (&pe_info->stack_commit,
1834                                                 NT_DEF_COMMIT);
1835
1836   internal_a->pe->SizeOfHeapReserve = pe_value (&pe_info->heap_reserve,
1837                                                 NT_DEF_RESERVE);
1838   internal_a->pe->SizeOfHeapCommit = pe_value (&pe_info->heap_commit,
1839                                                NT_DEF_COMMIT);
1840
1841   internal_a->pe->LoaderFlags = 0;
1842   internal_a->pe->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES; /* 0x10 */
1843
1844   /* first null out all data directory entries .. */
1845   memset (internal_a->pe->DataDirectory, sizeof (internal_a->pe->DataDirectory), 0);
1846
1847   add_data_entry (abfd, internal_a, 0, ".edata", internal_a->pe->ImageBase);
1848   add_data_entry (abfd, internal_a, 1, ".idata", internal_a->pe->ImageBase);
1849   add_data_entry (abfd, internal_a, 2, ".rsrc" ,internal_a->pe->ImageBase);
1850   add_data_entry (abfd, internal_a, 5, ".reloc", internal_a->pe->ImageBase);
1851
1852
1853
1854 }
1855 #endif
1856
1857 /* SUPPRESS 558 */
1858 /* SUPPRESS 529 */
1859 static boolean
1860 coff_write_object_contents (abfd)
1861      bfd * abfd;
1862 {
1863   asection *current;
1864   boolean hasrelocs = false;
1865   boolean haslinno = false;
1866   file_ptr reloc_base;
1867   file_ptr lineno_base;
1868   file_ptr sym_base;
1869   unsigned long reloc_size = 0;
1870   unsigned long lnno_size = 0;
1871   asection *text_sec = NULL;
1872   asection *data_sec = NULL;
1873   asection *bss_sec = NULL;
1874   bfd_vma end_of_image = 0;
1875
1876   struct internal_filehdr internal_f;
1877   struct internal_aouthdr internal_a;
1878
1879 #ifdef COFF_IMAGE_WITH_PE
1880   struct internal_extra_pe_aouthdr extra_a;
1881   struct internal_extra_pe_filehdr extra_f;
1882   bfd_link_pe_info defs;
1883   struct bfd_link_info dummy_info;
1884   struct bfd_link_info *info ;
1885   struct bfd_link_pe_info *pe_info;
1886
1887   if (coff_data (abfd)->link_info)
1888       info =coff_data (abfd)->link_info;
1889   else
1890     {
1891       coff_data (abfd)->link_info = info = &dummy_info;
1892       info->pe_info = 0;
1893     }
1894   pe_info = info->pe_info;
1895
1896   if (!pe_info)
1897     {
1898       /* Just use sensible defaults */
1899       memset (&defs, 0, sizeof (defs));
1900       coff_data (abfd)->link_info->pe_info = &defs;
1901     }
1902 #endif
1903
1904   bfd_set_error (bfd_error_system_call);
1905
1906   if (abfd->output_has_begun == false)
1907     coff_compute_section_file_positions (abfd);
1908
1909   reloc_base = obj_relocbase (abfd);
1910
1911   /* Make a pass through the symbol table to count line number entries and
1912      put them into the correct asections */
1913
1914   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
1915
1916   /* Work out the size of the reloc and linno areas */
1917
1918   for (current = abfd->sections; current != NULL; current =
1919        current->next)
1920     reloc_size += current->reloc_count * RELSZ;
1921
1922   lineno_base = reloc_base + reloc_size;
1923   sym_base = lineno_base + lnno_size;
1924
1925   /* Indicate in each section->line_filepos its actual file address */
1926   for (current = abfd->sections; current != NULL; current =
1927        current->next)
1928     {
1929       if (current->lineno_count)
1930         {
1931           current->line_filepos = lineno_base;
1932           current->moving_line_filepos = lineno_base;
1933           lineno_base += current->lineno_count * LINESZ;
1934         }
1935       else
1936         {
1937           current->line_filepos = 0;
1938         }
1939       if (current->reloc_count)
1940         {
1941           current->rel_filepos = reloc_base;
1942           reloc_base += current->reloc_count * RELSZ;
1943         }
1944       else
1945         {
1946           current->rel_filepos = 0;
1947         }
1948     }
1949
1950   /* Write section headers to the file.  */
1951   internal_f.f_nscns = 0;
1952
1953 #if 0
1954   if (bfd_seek (abfd,
1955                 (file_ptr) ((abfd->flags & EXEC_P) ?
1956                             (EXTRA_NT_HDRSZ + FILHSZ + AOUTSZ) :
1957                             (EXTRA_NT_HDRSZ + FILHSZ)),
1958                 SEEK_SET)
1959       != 0)
1960 #else
1961     if (bfd_seek (abfd,
1962                   (file_ptr) ((abfd->flags & EXEC_P) ?
1963                               (FILHSZ + AOUTSZ) : FILHSZ),
1964                   SEEK_SET)
1965         != 0)
1966 #endif
1967       return false;
1968
1969   {
1970     for (current = abfd->sections;
1971          current != NULL;
1972          current = current->next)
1973       {
1974         struct internal_scnhdr section;
1975
1976 #ifdef COFF_WITH_PE
1977         /* Do not include the .junk section.  This is where we collect section
1978            data which we don't need.  This is mainly the MS .debug$ data which
1979            stores codeview debug data. */
1980         if (strcmp (current->name, ".junk") == 0)
1981           {
1982             continue;
1983           }
1984 #endif
1985         internal_f.f_nscns++;
1986         strncpy (&(section.s_name[0]), current->name, 8);
1987 #ifdef _LIB
1988         /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
1989            Ian Taylor <ian@cygnus.com>.  */
1990         if (strcmp (current->name, _LIB) == 0)
1991           section.s_vaddr = 0;
1992         else
1993 #endif
1994           section.s_vaddr = current->lma;
1995         section.s_paddr = current->lma;
1996         section.s_size = current->_raw_size;
1997
1998         /* Remember the address of the end of the last section */
1999
2000         if (current->lma + current->_raw_size > end_of_image)
2001           end_of_image = current->lma + current->_raw_size ;
2002
2003         /*
2004            If this section has no size or is unloadable then the scnptr
2005            will be 0 too
2006            */
2007         if (current->_raw_size == 0 ||
2008             (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2009           {
2010             section.s_scnptr = 0;
2011           }
2012         else
2013           {
2014             section.s_scnptr = current->filepos;
2015           }
2016         section.s_relptr = current->rel_filepos;
2017         section.s_lnnoptr = current->line_filepos;
2018         section.s_nreloc = current->reloc_count;
2019         section.s_nlnno = current->lineno_count;
2020         if (current->reloc_count != 0)
2021           hasrelocs = true;
2022         if (current->lineno_count != 0)
2023           haslinno = true;
2024
2025         section.s_flags = sec_to_styp_flags (current->name, current->flags);
2026
2027         if (!strcmp (current->name, _TEXT))
2028           {
2029             text_sec = current;
2030           }
2031         else if (!strcmp (current->name, _DATA))
2032           {
2033             data_sec = current;
2034 #ifdef TWO_DATA_SECS
2035           }
2036         else if (!strcmp (current->name, ".data2"))
2037           {
2038             data_sec = current;
2039 #endif /* TWO_DATA_SECS */
2040           }
2041         else if (!strcmp (current->name, _BSS))
2042           {
2043             bss_sec = current;
2044           }
2045
2046 #ifdef I960
2047         section.s_align = (current->alignment_power
2048                            ? 1 << current->alignment_power
2049                            : 0);
2050
2051 #endif
2052         {
2053           SCNHDR buff;
2054
2055 #ifdef WINDOWS_NT
2056           /* suppress output of the sections if they are null.  ld includes
2057              the bss and data sections even if there is no size assigned
2058              to them.  NT loader doesn't like it if these section headers are
2059              included if the sections themselves are not needed */
2060           if (section.s_size == 0)
2061             internal_f.f_nscns--;
2062           else
2063             {
2064               coff_swap_scnhdr_out (abfd, &section, &buff);
2065               if (bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2066                 return false;
2067             }
2068 #else
2069           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2070               || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2071             return false;
2072 #endif
2073
2074         }
2075       }
2076   }
2077
2078
2079   /* OK, now set up the filehdr... */
2080
2081   /* Don't include the internal abs section in the section count */
2082
2083   /*
2084      We will NOT put a fucking timestamp in the header here. Every time you
2085      put it back, I will come in and take it out again.  I'm sorry.  This
2086      field does not belong here.  We fill it with a 0 so it compares the
2087      same but is not a reasonable time. -- gnu@cygnus.com
2088      */
2089
2090   internal_f.f_flags = 0;
2091
2092   if (abfd->flags & EXEC_P)
2093     internal_f.f_opthdr = AOUTSZ;
2094   else
2095     internal_f.f_opthdr = 0;
2096
2097   if (!hasrelocs)
2098     internal_f.f_flags |= F_RELFLG;
2099   if (!haslinno)
2100     internal_f.f_flags |= F_LNNO;
2101   if (abfd->flags & EXEC_P)
2102     internal_f.f_flags |= F_EXEC;
2103
2104   if (!abfd->xvec->byteorder_big_p)
2105     internal_f.f_flags |= F_AR32WR;
2106   else
2107     internal_f.f_flags |= F_AR32W;
2108
2109   /*
2110      FIXME, should do something about the other byte orders and
2111      architectures.
2112      */
2113
2114   memset (&internal_a, 0, sizeof internal_a);
2115
2116   /* Set up architecture-dependent stuff */
2117
2118   {
2119     unsigned int magic = 0;
2120     unsigned short flags = 0;
2121     coff_set_flags (abfd, &magic, &flags);
2122     internal_f.f_magic = magic;
2123     internal_f.f_flags |= flags;
2124     /* ...and the "opt"hdr... */
2125
2126 #ifdef A29K
2127 #ifdef ULTRA3                   /* NYU's machine */
2128     /* FIXME: This is a bogus check.  I really want to see if there
2129      * is a .shbss or a .shdata section, if so then set the magic
2130      * number to indicate a shared data executable.
2131      */
2132     if (internal_f.f_nscns >= 7)
2133       internal_a.magic = SHMAGIC; /* Shared magic */
2134     else
2135 #endif /* ULTRA3 */
2136       internal_a.magic = NMAGIC; /* Assume separate i/d */
2137 #define __A_MAGIC_SET__
2138 #endif /* A29K */
2139 #ifdef I960
2140     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
2141 #define __A_MAGIC_SET__
2142 #endif /* I960 */
2143 #if M88
2144 #define __A_MAGIC_SET__
2145     internal_a.magic = PAGEMAGICBCS;
2146 #endif /* M88 */
2147
2148 #if APOLLO_M68
2149 #define __A_MAGIC_SET__
2150     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
2151 #endif
2152
2153 #if defined(M68) || defined(WE32K) || defined(M68K)
2154 #define __A_MAGIC_SET__
2155 #if defined(LYNXOS)
2156     internal_a.magic = LYNXCOFFMAGIC;
2157 #endif /* LYNXOS */
2158 #endif /* M68 || WE32K || M68K */
2159
2160 #if defined(ARM)
2161 #define __A_MAGIC_SET__
2162     internal_a.magic = ZMAGIC;
2163 #endif
2164 #if defined(I386)
2165 #define __A_MAGIC_SET__
2166 #if defined(LYNXOS)
2167     internal_a.magic = LYNXCOFFMAGIC;
2168 #else  /* LYNXOS */
2169     internal_a.magic = ZMAGIC;
2170 #endif /* LYNXOS */
2171 #endif /* I386 */
2172
2173 #if defined(SPARC)
2174 #define __A_MAGIC_SET__
2175 #if defined(LYNXOS)
2176     internal_a.magic = LYNXCOFFMAGIC;
2177 #endif /* LYNXOS */
2178 #endif /* SPARC */
2179
2180 #if RS6000COFF_C
2181 #define __A_MAGIC_SET__
2182     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
2183     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
2184     RS6K_AOUTHDR_OMAGIC;
2185 #endif
2186
2187 #ifndef __A_MAGIC_SET__
2188 #include "Your aouthdr magic number is not being set!"
2189 #else
2190 #undef __A_MAGIC_SET__
2191 #endif
2192   }
2193   /* Now should write relocs, strings, syms */
2194   obj_sym_filepos (abfd) = sym_base;
2195
2196   if (bfd_get_symcount (abfd) != 0)
2197     {
2198       int firstundef;
2199 #ifndef RS6000COFF_C
2200       if (!coff_add_missing_symbols (abfd))
2201         return false;
2202 #endif
2203       if (!coff_renumber_symbols (abfd, &firstundef))
2204         return false;
2205       coff_mangle_symbols (abfd);
2206       if (! coff_write_symbols (abfd))
2207         return false;
2208       if (! coff_write_linenumbers (abfd))
2209         return false;
2210       if (! coff_write_relocs (abfd, firstundef))
2211         return false;
2212     }
2213
2214   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2215      backend linker, and obj_raw_syment_count is not valid until after
2216      coff_write_symbols is called.  */
2217   if (obj_raw_syment_count (abfd) != 0)
2218     internal_f.f_symptr = sym_base;
2219   else
2220     {
2221       internal_f.f_symptr = 0;
2222       internal_f.f_flags |= F_LSYMS;
2223     }
2224
2225   if (text_sec)
2226     {
2227       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
2228       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
2229     }
2230   if (data_sec)
2231     {
2232       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
2233       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
2234     }
2235   if (bss_sec)
2236     {
2237       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
2238     }
2239
2240   internal_a.entry = bfd_get_start_address (abfd);
2241   internal_f.f_nsyms = obj_raw_syment_count (abfd);
2242
2243
2244
2245 #ifdef COFF_IMAGE_WITH_PE
2246
2247   internal_f.pe = & extra_f;
2248   internal_a.pe = & extra_a;
2249
2250   fill_pe_header_info (abfd, &internal_f, &internal_a, end_of_image);
2251 #endif
2252
2253   /* now write them */
2254   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2255     return false;
2256   {
2257     FILHDR buff;
2258     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
2259     if (bfd_write ((PTR) & buff, 1, FILHSZ, abfd) != FILHSZ)
2260       return false;
2261   }
2262   if (abfd->flags & EXEC_P)
2263     {
2264       AOUTHDR buff;
2265       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
2266       if (bfd_write ((PTR) & buff, 1, AOUTSZ, abfd) != AOUTSZ)
2267         return false;
2268     }
2269
2270   return true;
2271 }
2272
2273 static boolean
2274 coff_set_section_contents (abfd, section, location, offset, count)
2275      bfd * abfd;
2276      sec_ptr section;
2277      PTR location;
2278      file_ptr offset;
2279      bfd_size_type count;
2280 {
2281   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
2282     coff_compute_section_file_positions (abfd);
2283
2284 #ifdef _LIB
2285   /* If this is a .lib section, bump the vma address so that it
2286        winds up being the number of .lib sections output.  This is
2287        right for SVR3.2.  Shared libraries should probably get more
2288        generic support.  Ian Taylor <ian@cygnus.com>.  */
2289   if (strcmp (section->name, _LIB) == 0)
2290     ++section->lma;
2291 #endif
2292
2293   /* Don't write out bss sections - one way to do this is to
2294        see if the filepos has not been set. */
2295   if (section->filepos == 0)
2296     return true;
2297
2298   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
2299     return false;
2300
2301   if (count != 0)
2302     {
2303       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
2304     }
2305   return true;
2306 }
2307 #if 0
2308 static boolean
2309 coff_close_and_cleanup (abfd)
2310      bfd *abfd;
2311 {
2312   if (!bfd_read_p (abfd))
2313     switch (abfd->format)
2314       {
2315       case bfd_archive:
2316         if (!_bfd_write_archive_contents (abfd))
2317           return false;
2318         break;
2319       case bfd_object:
2320         if (!coff_write_object_contents (abfd))
2321           return false;
2322         break;
2323       default:
2324         bfd_set_error (bfd_error_invalid_operation);
2325         return false;
2326       }
2327
2328   /* We depend on bfd_close to free all the memory on the obstack.  */
2329   /* FIXME if bfd_release is not using obstacks! */
2330   return true;
2331 }
2332
2333 #endif
2334
2335 static PTR
2336 buy_and_read (abfd, where, seek_direction, size)
2337      bfd *abfd;
2338      file_ptr where;
2339      int seek_direction;
2340      size_t size;
2341 {
2342   PTR area = (PTR) bfd_alloc (abfd, size);
2343   if (!area)
2344     {
2345       bfd_set_error (bfd_error_no_memory);
2346       return (NULL);
2347     }
2348   if (bfd_seek (abfd, where, seek_direction) != 0
2349       || bfd_read (area, 1, size, abfd) != size)
2350     return (NULL);
2351   return (area);
2352 }                               /* buy_and_read() */
2353
2354 /*
2355 SUBSUBSECTION
2356         Reading linenumbers
2357
2358         Creating the linenumber table is done by reading in the entire
2359         coff linenumber table, and creating another table for internal use.
2360
2361         A coff linenumber table is structured so that each function
2362         is marked as having a line number of 0. Each line within the
2363         function is an offset from the first line in the function. The
2364         base of the line number information for the table is stored in
2365         the symbol associated with the function.
2366
2367         The information is copied from the external to the internal
2368         table, and each symbol which marks a function is marked by
2369         pointing its...
2370
2371         How does this work ?
2372
2373 */
2374
2375 static boolean
2376 coff_slurp_line_table (abfd, asect)
2377      bfd *abfd;
2378      asection *asect;
2379 {
2380   LINENO *native_lineno;
2381   alent *lineno_cache;
2382
2383   BFD_ASSERT (asect->lineno == (alent *) NULL);
2384
2385   native_lineno = (LINENO *) buy_and_read (abfd,
2386                                            asect->line_filepos,
2387                                            SEEK_SET,
2388                                            (size_t) (LINESZ *
2389                                                      asect->lineno_count));
2390   lineno_cache =
2391     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
2392   if (lineno_cache == NULL)
2393     {
2394       bfd_set_error (bfd_error_no_memory);
2395       return false;
2396     }
2397   else
2398     {
2399       unsigned int counter = 0;
2400       alent *cache_ptr = lineno_cache;
2401       LINENO *src = native_lineno;
2402
2403       while (counter < asect->lineno_count)
2404         {
2405           struct internal_lineno dst;
2406           coff_swap_lineno_in (abfd, src, &dst);
2407           cache_ptr->line_number = dst.l_lnno;
2408
2409           if (cache_ptr->line_number == 0)
2410             {
2411               coff_symbol_type *sym =
2412               (coff_symbol_type *) (dst.l_addr.l_symndx
2413                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
2414               cache_ptr->u.sym = (asymbol *) sym;
2415               sym->lineno = cache_ptr;
2416             }
2417           else
2418             {
2419               cache_ptr->u.offset = dst.l_addr.l_paddr
2420                 - bfd_section_vma (abfd, asect);
2421             }                   /* If no linenumber expect a symbol index */
2422
2423           cache_ptr++;
2424           src++;
2425           counter++;
2426         }
2427       cache_ptr->line_number = 0;
2428
2429     }
2430   asect->lineno = lineno_cache;
2431   /* FIXME, free native_lineno here, or use alloca or something. */
2432   return true;
2433 }
2434
2435 static boolean
2436 coff_slurp_symbol_table (abfd)
2437      bfd * abfd;
2438 {
2439   combined_entry_type *native_symbols;
2440   coff_symbol_type *cached_area;
2441   unsigned int *table_ptr;
2442
2443   unsigned int number_of_symbols = 0;
2444
2445   if (obj_symbols (abfd))
2446     return true;
2447
2448   /* Read in the symbol table */
2449   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
2450     {
2451       return (false);
2452     }                           /* on error */
2453
2454   /* Allocate enough room for all the symbols in cached form */
2455   cached_area = ((coff_symbol_type *)
2456                  bfd_alloc (abfd,
2457                             (obj_raw_syment_count (abfd)
2458                              * sizeof (coff_symbol_type))));
2459
2460   if (cached_area == NULL)
2461     {
2462       bfd_set_error (bfd_error_no_memory);
2463       return false;
2464     }                           /* on error */
2465   table_ptr = ((unsigned int *)
2466                bfd_alloc (abfd,
2467                           (obj_raw_syment_count (abfd)
2468                            * sizeof (unsigned int))));
2469
2470   if (table_ptr == NULL)
2471     {
2472       bfd_set_error (bfd_error_no_memory);
2473       return false;
2474     }
2475   else
2476     {
2477       coff_symbol_type *dst = cached_area;
2478       unsigned int last_native_index = obj_raw_syment_count (abfd);
2479       unsigned int this_index = 0;
2480       while (this_index < last_native_index)
2481         {
2482           combined_entry_type *src = native_symbols + this_index;
2483           table_ptr[this_index] = number_of_symbols;
2484           dst->symbol.the_bfd = abfd;
2485
2486           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
2487           /* We use the native name field to point to the cached field.  */
2488           src->u.syment._n._n_n._n_zeroes = (long) dst;
2489           dst->symbol.section = coff_section_from_bfd_index (abfd,
2490                                                      src->u.syment.n_scnum);
2491           dst->symbol.flags = 0;
2492           dst->done_lineno = false;
2493
2494           switch (src->u.syment.n_sclass)
2495             {
2496 #ifdef I960
2497             case C_LEAFEXT:
2498 #if 0
2499               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2500               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2501               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2502 #endif
2503               /* Fall through to next case */
2504
2505 #endif
2506
2507             case C_EXT:
2508 #ifdef RS6000COFF_C
2509             case C_HIDEXT:
2510 #endif
2511 #ifdef COFF_WITH_PE
2512             /* PE uses storage class 0x68 to denote a section symbol */
2513             case C_SECTION:
2514 #endif
2515               if ((src->u.syment.n_scnum) == 0)
2516                 {
2517                   if ((src->u.syment.n_value) == 0)
2518                     {
2519                       dst->symbol.section = bfd_und_section_ptr;
2520                       dst->symbol.value = 0;
2521                     }
2522                   else
2523                     {
2524                       dst->symbol.section = bfd_com_section_ptr;
2525                       dst->symbol.value = (src->u.syment.n_value);
2526                     }
2527                 }
2528               else
2529                 {
2530                   /*
2531             Base the value as an index from the base of the
2532             section
2533             */
2534
2535                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2536                   dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2537
2538                   if (ISFCN ((src->u.syment.n_type)))
2539                     {
2540                       /*
2541               A function ext does not go at the end of a file
2542               */
2543                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2544                     }
2545                 }
2546
2547 #ifdef RS6000COFF_C
2548               /* If this symbol has a csect aux of type LD, the scnlen field
2549            is actually the index of the containing csect symbol.  We
2550            need to pointerize it.  */
2551               if (src->u.syment.n_numaux > 0)
2552                 {
2553                   combined_entry_type *aux;
2554
2555                   aux = src + src->u.syment.n_numaux - 1;
2556                   if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2557                     {
2558                       aux->u.auxent.x_csect.x_scnlen.p =
2559                         native_symbols + aux->u.auxent.x_csect.x_scnlen.l;
2560                       aux->fix_scnlen = 1;
2561                     }
2562                 }
2563 #endif
2564
2565               break;
2566
2567             case C_STAT:        /* static                        */
2568 #ifdef I960
2569             case C_LEAFSTAT:    /* static leaf procedure        */
2570 #endif
2571             case C_LABEL:       /* label                         */
2572               if (src->u.syment.n_scnum == -2)
2573                 dst->symbol.flags = BSF_DEBUGGING;
2574               else
2575                 dst->symbol.flags = BSF_LOCAL;
2576               /*
2577           Base the value as an index from the base of the section, if
2578           there is one
2579           */
2580               if (dst->symbol.section)
2581                 dst->symbol.value = (src->u.syment.n_value) -
2582                   dst->symbol.section->vma;
2583               else
2584                 dst->symbol.value = (src->u.syment.n_value);
2585               break;
2586
2587             case C_MOS: /* member of structure   */
2588             case C_EOS: /* end of structure              */
2589 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
2590 #ifdef C_GLBLREG
2591             case C_GLBLREG:     /* A29k-specific storage class */
2592 #endif
2593 #endif
2594             case C_REGPARM:     /* register parameter            */
2595             case C_REG: /* register variable             */
2596 #ifdef C_AUTOARG
2597             case C_AUTOARG:     /* 960-specific storage class */
2598 #endif
2599             case C_TPDEF:       /* type definition               */
2600             case C_ARG:
2601             case C_AUTO:        /* automatic variable */
2602             case C_FIELD:       /* bit field */
2603             case C_ENTAG:       /* enumeration tag               */
2604             case C_MOE: /* member of enumeration         */
2605             case C_MOU: /* member of union               */
2606             case C_UNTAG:       /* union tag                     */
2607               dst->symbol.flags = BSF_DEBUGGING;
2608               dst->symbol.value = (src->u.syment.n_value);
2609               break;
2610
2611             case C_FILE:        /* file name                     */
2612             case C_STRTAG:      /* structure tag                 */
2613 #ifdef RS6000COFF_C
2614             case C_BINCL:       /* beginning of include file     */
2615             case C_EINCL:       /* ending of include file        */
2616             case C_GSYM:
2617             case C_LSYM:
2618             case C_PSYM:
2619             case C_RSYM:
2620             case C_RPSYM:
2621             case C_STSYM:
2622             case C_DECL:
2623             case C_ENTRY:
2624             case C_FUN:
2625             case C_ESTAT:
2626 #endif
2627               dst->symbol.flags = BSF_DEBUGGING;
2628               dst->symbol.value = (src->u.syment.n_value);
2629               break;
2630
2631 #ifdef RS6000COFF_C
2632             case C_BSTAT:
2633               dst->symbol.flags = BSF_DEBUGGING;
2634               dst->symbol.value = src->u.syment.n_value;
2635
2636               /* The value is actually a symbol index.  Save a pointer to
2637            the symbol instead of the index.  FIXME: This should use a
2638            union.  */
2639               src->u.syment.n_value =
2640                 (long) (native_symbols + src->u.syment.n_value);
2641               src->fix_value = 1;
2642               break;
2643 #endif
2644
2645             case C_BLOCK:       /* ".bb" or ".eb"                */
2646             case C_FCN: /* ".bf" or ".ef"                */
2647             case C_EFCN:        /* physical end of function      */
2648               dst->symbol.flags = BSF_LOCAL;
2649               /*
2650           Base the value as an index from the base of the section
2651           */
2652               dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
2653               break;
2654
2655             case C_NULL:
2656             case C_EXTDEF:      /* external definition           */
2657             case C_ULABEL:      /* undefined label               */
2658             case C_USTATIC:     /* undefined static              */
2659 #ifndef COFF_WITH_PE
2660             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
2661                class to represent a section symbol */
2662             case C_LINE:        /* line # reformatted as symbol table entry */
2663 #endif
2664             case C_ALIAS:       /* duplicate tag                 */
2665             case C_HIDDEN:      /* ext symbol in dmert public lib */
2666             default:
2667
2668               fprintf (stderr, "Unrecognized storage class %d (assuming debugging)\n  for %s symbol `%s'\n",
2669                        src->u.syment.n_sclass, dst->symbol.section->name,
2670                        dst->symbol.name);
2671 /*      abort();*/
2672               dst->symbol.flags = BSF_DEBUGGING;
2673               dst->symbol.value = (src->u.syment.n_value);
2674               break;
2675             }
2676
2677 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
2678
2679           dst->native = src;
2680
2681           dst->symbol.udata.i = 0;
2682           dst->lineno = (alent *) NULL;
2683           this_index += (src->u.syment.n_numaux) + 1;
2684           dst++;
2685           number_of_symbols++;
2686         }                       /* walk the native symtab */
2687     }                           /* bfdize the native symtab */
2688
2689   obj_symbols (abfd) = cached_area;
2690   obj_raw_syments (abfd) = native_symbols;
2691
2692   bfd_get_symcount (abfd) = number_of_symbols;
2693   obj_convert (abfd) = table_ptr;
2694   /* Slurp the line tables for each section too */
2695   {
2696     asection *p;
2697     p = abfd->sections;
2698     while (p)
2699       {
2700         coff_slurp_line_table (abfd, p);
2701         p = p->next;
2702       }
2703   }
2704   return true;
2705 }                               /* coff_slurp_symbol_table() */
2706
2707 /* Check whether a symbol is globally visible.  This is used by the
2708    COFF backend linker code in cofflink.c, since a couple of targets
2709    have globally visible symbols which are not class C_EXT.  This
2710    function need not handle the case of n_class == C_EXT.  */
2711
2712 #undef OTHER_GLOBAL_CLASS
2713
2714 #ifdef I960
2715 #define OTHER_GLOBAL_CLASS C_LEAFEXT
2716 #endif
2717
2718 #ifdef RS6000COFF_C
2719 #define OTHER_GLOBAL_CLASS C_HIDEXT
2720 #endif
2721
2722 #ifdef COFF_WITH_PE
2723 #define OTHER_GLOBAL_CLASS C_SECTION
2724 #endif
2725
2726 #ifdef OTHER_GLOBAL_CLASS
2727
2728 static boolean
2729 coff_sym_is_global (abfd, syment)
2730      bfd *abfd;
2731      struct internal_syment *syment;
2732 {
2733   if (syment->n_sclass == OTHER_GLOBAL_CLASS)
2734     return true;
2735   return false;
2736 }
2737
2738 #undef OTHER_GLOBAL_CLASS
2739
2740 #else /* ! defined (OTHER_GLOBAL_CLASS) */
2741
2742 /* sym_is_global should not be defined if it has nothing to do.  */
2743
2744 #define coff_sym_is_global 0
2745
2746 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
2747
2748 /*
2749 SUBSUBSECTION
2750         Reading relocations
2751
2752         Coff relocations are easily transformed into the internal BFD form
2753         (@code{arelent}).
2754
2755         Reading a coff relocation table is done in the following stages:
2756
2757         o Read the entire coff relocation table into memory.
2758
2759         o Process each relocation in turn; first swap it from the
2760         external to the internal form.
2761
2762         o Turn the symbol referenced in the relocation's symbol index
2763         into a pointer into the canonical symbol table.
2764         This table is the same as the one returned by a call to
2765         @code{bfd_canonicalize_symtab}. The back end will call that
2766         routine and save the result if a canonicalization hasn't been done.
2767
2768         o The reloc index is turned into a pointer to a howto
2769         structure, in a back end specific way. For instance, the 386
2770         and 960 use the @code{r_type} to directly produce an index
2771         into a howto table vector; the 88k subtracts a number from the
2772         @code{r_type} field and creates an addend field.
2773
2774
2775 */
2776
2777 #ifndef CALC_ADDEND
2778 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
2779   {                                                             \
2780     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
2781     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
2782       coffsym = (obj_symbols (abfd)                             \
2783                  + (cache_ptr->sym_ptr_ptr - symbols));         \
2784     else if (ptr)                                               \
2785       coffsym = coff_symbol_from (abfd, ptr);                   \
2786     if (coffsym != (coff_symbol_type *) NULL                    \
2787         && coffsym->native->u.syment.n_scnum == 0)              \
2788       cache_ptr->addend = 0;                                    \
2789     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
2790              && ptr->section != (asection *) NULL)              \
2791       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
2792     else                                                        \
2793       cache_ptr->addend = 0;                                    \
2794   }
2795 #endif
2796
2797 static boolean
2798 coff_slurp_reloc_table (abfd, asect, symbols)
2799      bfd * abfd;
2800      sec_ptr asect;
2801      asymbol ** symbols;
2802 {
2803   RELOC *native_relocs;
2804   arelent *reloc_cache;
2805   arelent *cache_ptr;
2806
2807   unsigned int idx;
2808
2809   if (asect->relocation)
2810     return true;
2811   if (asect->reloc_count == 0)
2812     return true;
2813   if (asect->flags & SEC_CONSTRUCTOR)
2814     return true;
2815   if (!coff_slurp_symbol_table (abfd))
2816     return false;
2817   native_relocs =
2818     (RELOC *) buy_and_read (abfd,
2819                             asect->rel_filepos,
2820                             SEEK_SET,
2821                             (size_t) (RELSZ *
2822                                       asect->reloc_count));
2823   reloc_cache = (arelent *)
2824     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2825
2826   if (reloc_cache == NULL)
2827     {
2828       bfd_set_error (bfd_error_no_memory);
2829       return false;
2830     }
2831
2832
2833   for (idx = 0; idx < asect->reloc_count; idx++)
2834     {
2835 #ifdef RELOC_PROCESSING
2836       struct internal_reloc dst;
2837       struct external_reloc *src;
2838
2839       cache_ptr = reloc_cache + idx;
2840       src = native_relocs + idx;
2841       coff_swap_reloc_in (abfd, src, &dst);
2842
2843       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2844 #else
2845       struct internal_reloc dst;
2846       asymbol *ptr;
2847       struct external_reloc *src;
2848
2849       cache_ptr = reloc_cache + idx;
2850       src = native_relocs + idx;
2851
2852       coff_swap_reloc_in (abfd, src, &dst);
2853
2854
2855       cache_ptr->address = dst.r_vaddr;
2856
2857       if (dst.r_symndx != -1)
2858         {
2859           /* @@ Should never be greater than count of symbols!  */
2860           if (dst.r_symndx >= obj_conv_table_size (abfd))
2861             abort ();
2862           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
2863           ptr = *(cache_ptr->sym_ptr_ptr);
2864         }
2865       else
2866         {
2867           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2868           ptr = 0;
2869         }
2870
2871       /* The symbols definitions that we have read in have been
2872          relocated as if their sections started at 0. But the offsets
2873          refering to the symbols in the raw data have not been
2874          modified, so we have to have a negative addend to compensate.
2875
2876          Note that symbols which used to be common must be left alone */
2877
2878       /* Calculate any reloc addend by looking at the symbol */
2879       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
2880
2881       cache_ptr->address -= asect->vma;
2882 /* !!     cache_ptr->section = (asection *) NULL;*/
2883
2884       /* Fill in the cache_ptr->howto field from dst.r_type */
2885       RTYPE2HOWTO (cache_ptr, &dst);
2886 #endif
2887
2888     }
2889
2890   asect->relocation = reloc_cache;
2891   return true;
2892 }
2893
2894 #ifndef coff_rtype_to_howto
2895 #ifdef RTYPE2HOWTO
2896
2897 /* Get the howto structure for a reloc.  This is only used if the file
2898    including this one defines coff_relocate_section to be
2899    _bfd_coff_generic_relocate_section, so it is OK if it does not
2900    always work.  It is the responsibility of the including file to
2901    make sure it is reasonable if it is needed.  */
2902
2903 static reloc_howto_type *coff_rtype_to_howto
2904   PARAMS ((bfd *, asection *, struct internal_reloc *,
2905            struct coff_link_hash_entry *, struct internal_syment *,
2906            bfd_vma *));
2907
2908 /*ARGSUSED*/
2909 static reloc_howto_type *
2910 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
2911      bfd *abfd;
2912      asection *sec;
2913      struct internal_reloc *rel;
2914      struct coff_link_hash_entry *h;
2915      struct internal_syment *sym;
2916      bfd_vma *addendp;
2917 {
2918   arelent genrel;
2919
2920   RTYPE2HOWTO (&genrel, rel);
2921   return genrel.howto;
2922 }
2923
2924 #else /* ! defined (RTYPE2HOWTO) */
2925
2926 #define coff_rtype_to_howto NULL
2927
2928 #endif /* ! defined (RTYPE2HOWTO) */
2929 #endif /* ! defined (coff_rtype_to_howto) */
2930
2931 /* This is stupid.  This function should be a boolean predicate.  */
2932 static long
2933 coff_canonicalize_reloc (abfd, section, relptr, symbols)
2934      bfd * abfd;
2935      sec_ptr section;
2936      arelent ** relptr;
2937      asymbol ** symbols;
2938 {
2939   arelent *tblptr = section->relocation;
2940   unsigned int count = 0;
2941
2942
2943   if (section->flags & SEC_CONSTRUCTOR)
2944     {
2945       /* this section has relocs made up by us, they are not in the
2946        file, so take them out of their chain and place them into
2947        the data area provided */
2948       arelent_chain *chain = section->constructor_chain;
2949       for (count = 0; count < section->reloc_count; count++)
2950         {
2951           *relptr++ = &chain->relent;
2952           chain = chain->next;
2953         }
2954
2955     }
2956   else
2957     {
2958       if (! coff_slurp_reloc_table (abfd, section, symbols))
2959         return -1;
2960
2961       tblptr = section->relocation;
2962
2963       for (; count++ < section->reloc_count;)
2964         *relptr++ = tblptr++;
2965
2966
2967     }
2968   *relptr = 0;
2969   return section->reloc_count;
2970 }
2971
2972 #ifdef GNU960
2973 file_ptr
2974 coff_sym_filepos (abfd)
2975      bfd *abfd;
2976 {
2977   return obj_sym_filepos (abfd);
2978 }
2979 #endif
2980
2981 #ifndef coff_reloc16_estimate
2982 #define coff_reloc16_estimate dummy_reloc16_estimate
2983
2984 static int
2985 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
2986      bfd *abfd;
2987      asection *input_section;
2988      arelent *reloc;
2989      unsigned int shrink;
2990      struct bfd_link_info *link_info;
2991 {
2992   abort ();
2993 }
2994
2995 #endif
2996
2997 #ifndef coff_reloc16_extra_cases
2998 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
2999 /* This works even if abort is not declared in any header file.  */
3000 static void
3001 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
3002                            dst_ptr)
3003      bfd *abfd;
3004      struct bfd_link_info *link_info;
3005      struct bfd_link_order *link_order;
3006      arelent *reloc;
3007      bfd_byte *data;
3008      unsigned int *src_ptr;
3009      unsigned int *dst_ptr;
3010 {
3011   fprintf (stderr, "%s\n", reloc->howto->name);
3012   abort ();
3013 }
3014 #endif
3015
3016 /* If coff_relocate_section is defined, we can use the optimized COFF
3017    backend linker.  Otherwise we must continue to use the old linker.  */
3018 #ifdef coff_relocate_section
3019 #ifndef coff_bfd_link_hash_table_create
3020 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
3021 #endif
3022 #ifndef coff_bfd_link_add_symbols
3023 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
3024 #endif
3025 #ifndef coff_bfd_final_link
3026 #define coff_bfd_final_link _bfd_coff_final_link
3027 #endif
3028 #else /* ! defined (coff_relocate_section) */
3029 #define coff_relocate_section NULL
3030 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3031 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
3032 #define coff_bfd_final_link _bfd_generic_final_link
3033 #endif /* ! defined (coff_relocate_section) */
3034 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
3035
3036 #ifndef coff_adjust_symndx
3037 #define coff_adjust_symndx NULL
3038 #endif
3039
3040 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
3041 {
3042   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
3043   coff_swap_aux_out, coff_swap_sym_out,
3044   coff_swap_lineno_out, coff_swap_reloc_out,
3045   coff_swap_filehdr_out, coff_swap_aouthdr_out,
3046   coff_swap_scnhdr_out,
3047   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
3048 #ifdef COFF_LONG_FILENAMES
3049   true,
3050 #else
3051   false,
3052 #endif
3053   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
3054   coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
3055   coff_mkobject_hook, styp_to_sec_flags, coff_make_section_hook,
3056   coff_set_alignment_hook, coff_slurp_symbol_table, symname_in_debug_hook,
3057   coff_reloc16_extra_cases, coff_reloc16_estimate,
3058   coff_sym_is_global, coff_compute_section_file_positions,
3059   coff_relocate_section, coff_rtype_to_howto, coff_adjust_symndx
3060 };
3061
3062 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
3063 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3064 #define coff_get_section_contents _bfd_generic_get_section_contents
3065
3066 #define coff_bfd_copy_private_symbol_data \
3067   _bfd_generic_bfd_copy_private_symbol_data
3068 #define coff_bfd_copy_private_section_data \
3069   _bfd_generic_bfd_copy_private_section_data
3070 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
3071 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3072 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3073
3074 #ifndef coff_bfd_is_local_label
3075 #define coff_bfd_is_local_label bfd_generic_is_local_label
3076 #endif
3077 #ifndef coff_read_minisymbols
3078 #define coff_read_minisymbols _bfd_generic_read_minisymbols
3079 #endif
3080 #ifndef coff_minisymbol_to_symbol
3081 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3082 #endif
3083
3084 /* The reloc lookup routine must be supplied by each individual COFF
3085    backend.  */
3086 #ifndef coff_bfd_reloc_type_lookup
3087 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3088 #endif
3089
3090 #ifndef coff_bfd_get_relocated_section_contents
3091 #define coff_bfd_get_relocated_section_contents \
3092   bfd_generic_get_relocated_section_contents
3093 #endif
3094 #ifndef coff_bfd_relax_section
3095 #define coff_bfd_relax_section bfd_generic_relax_section
3096 #endif