bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /*
  22 Most of this hacked by  Steve Chamberlain,
  23                         [email protected]
  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 #include "coffswap.h"
 302 \f
 303 /* void warning(); */
 304
 305 /*
 306  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 307  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 308  * NOTE: If you add to/change this routine, you should mirror the changes
 309  *      in styp_to_sec_flags().
 310  */
 311 static long
 312 sec_to_styp_flags (sec_name, sec_flags)
 313      CONST char *sec_name;
 314      flagword sec_flags;
 315 {
 316   long styp_flags = 0;
 317
 318   if (!strcmp (sec_name, _TEXT))
 319     {
 320       styp_flags = STYP_TEXT;
 321     }
 322   else if (!strcmp (sec_name, _DATA))
 323     {
 324       styp_flags = STYP_DATA;
 325 #ifdef TWO_DATA_SECS
 326     }
 327   else if (!strcmp (sec_name, ".data2"))
 328     {
 329       styp_flags = STYP_DATA;
 330 #endif /* TWO_DATA_SECS */
 331     }
 332   else if (!strcmp (sec_name, _BSS))
 333     {
 334       styp_flags = STYP_BSS;
 335 #ifdef _COMMENT
 336     }
 337   else if (!strcmp (sec_name, _COMMENT))
 338     {
 339       styp_flags = STYP_INFO;
 340 #endif /* _COMMENT */
 341 #ifdef _LIB
 342     }
 343   else if (!strcmp (sec_name, _LIB))
 344     {
 345       styp_flags = STYP_LIB;
 346 #endif /* _LIB */
 347 #ifdef _LIT
 348     }
 349   else if (!strcmp (sec_name, _LIT))
 350     {
 351       styp_flags = STYP_LIT;
 352 #endif /* _LIT */
 353     }
 354   else if (!strcmp (sec_name, ".debug"))
 355     {
 356 #ifdef STYP_DEBUG
 357       styp_flags = STYP_DEBUG;
 358 #else
 359       styp_flags = STYP_INFO;
 360 #endif
 361     }
 362   else if (!strcmp (sec_name, ".stab")
 363            || !strncmp (sec_name, ".stabstr", 8))
 364     {
 365       styp_flags = STYP_INFO;
 366     }
 367   /* Try and figure out what it should be */
 368   else if (sec_flags & SEC_CODE)
 369     {
 370       styp_flags = STYP_TEXT;
 371     }
 372   else if (sec_flags & SEC_DATA)
 373     {
 374       styp_flags = STYP_DATA;
 375     }
 376   else if (sec_flags & SEC_READONLY)
 377     {
 378 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 379       styp_flags = STYP_LIT;
 380 #else
 381       styp_flags = STYP_TEXT;
 382 #endif /* STYP_LIT */
 383     }
 384   else if (sec_flags & SEC_LOAD)
 385     {
 386       styp_flags = STYP_TEXT;
 387     }
 388   else if (sec_flags & SEC_ALLOC)
 389     {
 390       styp_flags = STYP_BSS;
 391     }
 392
 393 #ifdef STYP_NOLOAD
 394   if (sec_flags & SEC_NEVER_LOAD)
 395     styp_flags |= STYP_NOLOAD;
 396 #endif
 397
 398   return (styp_flags);
 399 }
 400 /*
 401  * Return a word with SEC_* flags set to represent the incoming
 402  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 403  * function is sec_to_styp_flags().
 404  * NOTE: If you add to/change this routine, you should mirror the changes
 405  *      in sec_to_styp_flags().
 406  */
 407 static flagword
 408 DEFUN (styp_to_sec_flags, (abfd, hdr),
 409        bfd * abfd AND
 410        PTR hdr)
 411 {
 412   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 413   long styp_flags = internal_s->s_flags;
 414   flagword sec_flags = 0;
 415
 416 #ifdef STYP_NOLOAD
 417   if (styp_flags & STYP_NOLOAD)
 418     {
 419       sec_flags |= SEC_NEVER_LOAD;
 420     }
 421 #endif /* STYP_NOLOAD */
 422
 423   /* For 386 COFF, at least, an unloadable text or data section is
 424      actually a shared library section.  */
 425   if (styp_flags & STYP_TEXT)
 426     {
 427       if (sec_flags & SEC_NEVER_LOAD)
 428         sec_flags |= SEC_CODE | SEC_SHARED_LIBRARY;
 429       else
 430         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 431     }
 432   else if (styp_flags & STYP_DATA)
 433     {
 434       if (sec_flags & SEC_NEVER_LOAD)
 435         sec_flags |= SEC_DATA | SEC_SHARED_LIBRARY;
 436       else
 437         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 438     }
 439   else if (styp_flags & STYP_BSS)
 440     {
 441 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 442       if (sec_flags & SEC_NEVER_LOAD)
 443         sec_flags |= SEC_ALLOC | SEC_SHARED_LIBRARY;
 444       else
 445 #endif
 446         sec_flags |= SEC_ALLOC;
 447     }
 448   else if (styp_flags & STYP_INFO)
 449     {
 450       /* This should be marked as SEC_DEBUGGING, but that can't be
 451          done until we make sure that strip can still work.  strip
 452          will probably have to preserve the same number of sections to
 453          ensure that the section vma matches the section file
 454          position.  */
 455     }
 456   else
 457     {
 458       sec_flags |= SEC_ALLOC | SEC_LOAD;
 459     }
 460
 461 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 462   if ((styp_flags & STYP_LIT) == STYP_LIT)
 463     {
 464       sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 465     }
 466 #endif /* STYP_LIT */
 467 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 468   if (styp_flags & STYP_OTHER_LOAD)
 469     {
 470       sec_flags = (SEC_LOAD | SEC_ALLOC);
 471     }
 472 #endif /* STYP_SDATA */
 473
 474   return (sec_flags);
 475 }
 476
 477 #define get_index(symbol)       ((long) (symbol)->udata)
 478
 479 /*
 480 INTERNAL_DEFINITION
 481         bfd_coff_backend_data
 482
 483 CODE_FRAGMENT
 484
 485 Special entry points for gdb to swap in coff symbol table parts:
 486 .typedef struct
 487 .{
 488 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 489 .       bfd            *abfd,
 490 .       PTR             ext,
 491 .       int             type,
 492 .       int             class,
 493 .       int             indaux,
 494 .       int             numaux,
 495 .       PTR             in));
 496 .
 497 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 498 .       bfd            *abfd ,
 499 .       PTR             ext,
 500 .       PTR             in));
 501 .
 502 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 503 .       bfd            *abfd,
 504 .       PTR            ext,
 505 .       PTR             in));
 506 .
 507
 508 Special entry points for gas to swap out coff parts:
 509
 510 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 511 .       bfd     *abfd,
 512 .       PTR     in,
 513 .       int     type,
 514 .       int     class,
 515 .       int     indaux,
 516 .       int     numaux,
 517 .       PTR     ext));
 518 .
 519 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 520 .      bfd      *abfd,
 521 .      PTR      in,
 522 .      PTR      ext));
 523 .
 524 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 525 .       bfd     *abfd,
 526 .       PTR     in,
 527 .       PTR     ext));
 528 .
 529 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 530 .       bfd     *abfd,
 531 .       PTR     src,
 532 .       PTR     dst));
 533 .
 534 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 535 .       bfd     *abfd,
 536 .       PTR     in,
 537 .       PTR     out));
 538 .
 539 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 540 .       bfd     *abfd,
 541 .       PTR     in,
 542 .       PTR     out));
 543 .
 544 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 545 .       bfd     *abfd,
 546 .       PTR     in,
 547 .       PTR     out));
 548 .
 549
 550 Special entry points for generic COFF routines to call target
 551 dependent COFF routines:
 552
 553 . unsigned int _bfd_filhsz;
 554 . unsigned int _bfd_aoutsz;
 555 . unsigned int _bfd_scnhsz;
 556 . unsigned int _bfd_symesz;
 557 . unsigned int _bfd_auxesz;
 558 . unsigned int _bfd_linesz;
 559 . boolean _bfd_coff_long_filenames;
 560 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 561 .       bfd     *abfd,
 562 .       PTR     ext,
 563 .       PTR     in));
 564 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 565 .       bfd     *abfd,
 566 .       PTR     ext,
 567 .       PTR     in));
 568 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 569 .       bfd     *abfd,
 570 .       PTR     ext,
 571 .       PTR     in));
 572 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 573 .       bfd     *abfd,
 574 .       PTR     internal_filehdr));
 575 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 576 .       bfd     *abfd,
 577 .       PTR     internal_filehdr));
 578 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 579 .       bfd     *abfd,
 580 .       PTR     internal_filehdr,
 581 .       PTR     internal_aouthdr));
 582 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 583 .       bfd     *abfd,
 584 .       PTR     internal_scnhdr));
 585 . asection *(*_bfd_make_section_hook) PARAMS ((
 586 .       bfd     *abfd,
 587 .       char    *name));
 588 . void (*_bfd_set_alignment_hook) PARAMS ((
 589 .       bfd     *abfd,
 590 .       asection *sec,
 591 .       PTR     internal_scnhdr));
 592 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 593 .       bfd     *abfd));
 594 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 595 .       bfd     *abfd,
 596 .       struct internal_syment *sym));
 597 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 598 .       bfd     *abfd,
 599 .       struct bfd_link_info *link_info,
 600 .       struct bfd_link_order *link_order,
 601 .       arelent *reloc,
 602 .       bfd_byte *data,
 603 .       unsigned int *src_ptr,
 604 .       unsigned int *dst_ptr));
 605 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
 606 .       asection *input_section,
 607 .       asymbol **symbols,
 608 .       arelent *r,
 609 .       unsigned int shrink,
 610 .       struct bfd_link_info *link_info));
 611 .
 612 .} bfd_coff_backend_data;
 613 .
 614 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 615 .
 616 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
 617 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
 618 .
 619 .#define bfd_coff_swap_sym_in(a,e,i) \
 620 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 621 .
 622 .#define bfd_coff_swap_lineno_in(a,e,i) \
 623 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 624 .
 625 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 626 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 627 .
 628 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 629 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 630 .
 631 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
 632 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
 633 .
 634 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 635 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 636 .
 637 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 638 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 639 .
 640 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 641 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 642 .
 643 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 644 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 645 .
 646 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 647 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 648 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 649 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 650 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 651 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 652 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 653 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 654 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 655 .
 656 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 657 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 658 .
 659 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 660 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 661 .
 662 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 663 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 664 .
 665 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 666 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 667 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
 668 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
 669 .
 670 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr)\
 671 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr))
 672 .
 673 .#define bfd_coff_make_section_hook(abfd, name)\
 674 .        ((coff_backend_info (abfd)->_bfd_make_section_hook) (abfd, name))
 675 .
 676 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 677 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 678 .
 679 .#define bfd_coff_slurp_symbol_table(abfd)\
 680 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 681 .
 682 .#define bfd_coff_symname_in_debug(abfd, sym)\
 683 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 684 .
 685 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
 686 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 687 .         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
 688 .
 689 .#define bfd_coff_reloc16_estimate(abfd, section, symbols, reloc, shrink, link_info)\
 690 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 691 .         (section, symbols, reloc, shrink, link_info))
 692 .
 693 */
 694
 695 /* See whether the magic number matches.  */
 696
 697 static boolean
 698 DEFUN (coff_bad_format_hook, (abfd, filehdr),
 699        bfd * abfd AND
 700        PTR filehdr)
 701 {
 702   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 703
 704   if (BADMAG (*internal_f))
 705     return false;
 706
 707   /* if the optional header is NULL or not the correct size then
 708      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
 709      and Intel 960 readwrite headers (I960WRMAGIC) is that the
 710      optional header is of a different size.
 711
 712      But the mips keeps extra stuff in it's opthdr, so dont check
 713      when doing that
 714      */
 715
 716 #if defined(M88) || defined(I960)
 717   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
 718     return false;
 719 #endif
 720
 721   return true;
 722 }
 723
 724 static asection *
 725 DEFUN (coff_make_section_hook, (abfd, name),
 726        bfd * abfd AND
 727        char *name)
 728 {
 729 #ifdef TWO_DATA_SECS
 730   /* FIXME: This predates the call to bfd_make_section_anyway
 731      in make_a_section_from_file, and can probably go away.  */
 732   /* On SCO a file created by the Microsoft assembler can have two
 733      .data sections.  We use .data2 for the second one.  */
 734   if (strcmp (name, _DATA) == 0)
 735     return bfd_make_section (abfd, ".data2");
 736 #endif
 737   return (asection *) NULL;
 738 }
 739
 740 /*
 741    initialize a section structure with information peculiar to this
 742    particular implementation of coff
 743 */
 744
 745 static boolean
 746 DEFUN (coff_new_section_hook, (abfd, section),
 747        bfd * abfd AND
 748        asection * section)
 749 {
 750   section->alignment_power = abfd->xvec->align_power_min;
 751   /* Allocate aux records for section symbols, to store size and
 752      related info.
 753
 754      @@ Shouldn't use constant multiplier here!  */
 755   coffsymbol (section->symbol)->native =
 756     (combined_entry_type *) bfd_zalloc (abfd,
 757                                         sizeof (combined_entry_type) * 10);
 758   return true;
 759 }
 760
 761
 762 #ifdef I960
 763
 764 /* Set the alignment of a BFD section.  */
 765
 766 static void
 767 DEFUN (coff_set_alignment_hook, (abfd, section, scnhdr),
 768        bfd * abfd AND
 769        asection * section AND
 770        PTR scnhdr)
 771 {
 772   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 773   unsigned int i;
 774
 775   for (i = 0; i < 32; i++)
 776     if ((1 << i) >= hdr->s_align)
 777       break;
 778   section->alignment_power = i;
 779 }
 780
 781 #else /* ! I960 */
 782
 783 #define coff_set_alignment_hook \
 784   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
 785
 786 #endif /* ! I960 */
 787
 788 static boolean
 789 DEFUN (coff_mkobject, (abfd),
 790        bfd * abfd)
 791 {
 792   coff_data_type *coff;
 793
 794   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
 795   if (abfd->tdata.coff_obj_data == 0)
 796     {
 797       bfd_error = no_memory;
 798       return false;
 799     }
 800   coff = coff_data (abfd);
 801   coff->symbols = (coff_symbol_type *) NULL;
 802   coff->conversion_table = (unsigned int *) NULL;
 803   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 804   coff->raw_linenos = (struct lineno *) NULL;
 805   coff->relocbase = 0;
 806 /*  make_abs_section(abfd);*/
 807   return true;
 808 }
 809
 810 /* Create the COFF backend specific information.  */
 811
 812 static PTR
 813 DEFUN (coff_mkobject_hook, (abfd, filehdr, aouthdr),
 814        bfd * abfd AND
 815        PTR filehdr AND
 816        PTR aouthdr)
 817 {
 818   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 819   coff_data_type *coff;
 820
 821   if (coff_mkobject (abfd) == false)
 822     return NULL;
 823
 824   coff = coff_data (abfd);
 825
 826   coff->sym_filepos = internal_f->f_symptr;
 827   coff->flags = internal_f->f_flags;
 828
 829   /* These members communicate important constants about the symbol
 830      table to GDB's symbol-reading code.  These `constants'
 831      unfortunately vary among coff implementations...  */
 832   coff->local_n_btmask = N_BTMASK;
 833   coff->local_n_btshft = N_BTSHFT;
 834   coff->local_n_tmask = N_TMASK;
 835   coff->local_n_tshift = N_TSHIFT;
 836   coff->local_symesz = SYMESZ;
 837   coff->local_auxesz = AUXESZ;
 838   coff->local_linesz = LINESZ;
 839
 840   return (PTR) coff;
 841 }
 842
 843 /* Determine the machine architecture and type.  FIXME: This is target
 844    dependent because the magic numbers are defined in the target
 845    dependent header files.  But there is no particular need for this.
 846    If the magic numbers were moved to a separate file, this function
 847    would be target independent and would also be much more successful
 848    at linking together COFF files for different architectures.  */
 849
 850 static boolean
 851 coff_set_arch_mach_hook (abfd, filehdr)
 852      bfd *abfd;
 853      PTR filehdr;
 854 {
 855   long machine;
 856   enum bfd_architecture arch;
 857   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 858
 859   machine = 0;
 860   switch (internal_f->f_magic)
 861     {
 862 #ifdef I386MAGIC
 863     case I386MAGIC:
 864     case I386PTXMAGIC:
 865     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
 866     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
 867       arch = bfd_arch_i386;
 868       machine = 0;
 869       break;
 870 #endif
 871
 872 #ifdef A29K_MAGIC_BIG
 873     case A29K_MAGIC_BIG:
 874     case A29K_MAGIC_LITTLE:
 875       arch = bfd_arch_a29k;
 876       machine = 0;
 877       break;
 878 #endif
 879
 880 #ifdef MC68MAGIC
 881     case MC68MAGIC:
 882     case M68MAGIC:
 883 #ifdef MC68KBCSMAGIC
 884     case MC68KBCSMAGIC:
 885 #endif
 886 #ifdef APOLLOM68KMAGIC
 887     case APOLLOM68KMAGIC:
 888 #endif
 889 #ifdef LYNXCOFFMAGIC
 890     case LYNXCOFFMAGIC:
 891 #endif
 892       arch = bfd_arch_m68k;
 893       machine = 68020;
 894       break;
 895 #endif
 896 #ifdef MC88MAGIC
 897     case MC88MAGIC:
 898     case MC88DMAGIC:
 899     case MC88OMAGIC:
 900       arch = bfd_arch_m88k;
 901       machine = 88100;
 902       break;
 903 #endif
 904 #ifdef Z8KMAGIC
 905     case Z8KMAGIC:
 906       arch = bfd_arch_z8k;
 907       switch (internal_f->f_flags & F_MACHMASK)
 908         {
 909         case F_Z8001:
 910           machine = bfd_mach_z8001;
 911           break;
 912         case F_Z8002:
 913           machine = bfd_mach_z8002;
 914           break;
 915         default:
 916           return false;
 917         }
 918       break;
 919 #endif
 920 #ifdef I960
 921 #ifdef I960ROMAGIC
 922     case I960ROMAGIC:
 923     case I960RWMAGIC:
 924       arch = bfd_arch_i960;
 925       switch (F_I960TYPE & internal_f->f_flags)
 926         {
 927         default:
 928         case F_I960CORE:
 929           machine = bfd_mach_i960_core;
 930           break;
 931         case F_I960KB:
 932           machine = bfd_mach_i960_kb_sb;
 933           break;
 934         case F_I960MC:
 935           machine = bfd_mach_i960_mc;
 936           break;
 937         case F_I960XA:
 938           machine = bfd_mach_i960_xa;
 939           break;
 940         case F_I960CA:
 941           machine = bfd_mach_i960_ca;
 942           break;
 943         case F_I960KA:
 944           machine = bfd_mach_i960_ka_sa;
 945           break;
 946         }
 947       break;
 948 #endif
 949 #endif
 950
 951 #ifdef U802ROMAGIC
 952     case U802ROMAGIC:
 953     case U802WRMAGIC:
 954     case U802TOCMAGIC:
 955       arch = bfd_arch_rs6000;
 956       machine = 6000;
 957       break;
 958 #endif
 959
 960 #ifdef WE32KMAGIC
 961     case WE32KMAGIC:
 962       arch = bfd_arch_we32k;
 963       machine = 0;
 964       break;
 965 #endif
 966
 967 #ifdef H8300MAGIC
 968     case H8300MAGIC:
 969       arch = bfd_arch_h8300;
 970       machine = bfd_mach_h8300;
 971       /* !! FIXME this probably isn't the right place for this */
 972       abfd->flags |= BFD_IS_RELAXABLE;
 973       break;
 974 #endif
 975
 976 #ifdef H8300HMAGIC
 977     case H8300HMAGIC:
 978       arch = bfd_arch_h8300;
 979       machine = bfd_mach_h8300h;
 980       /* !! FIXME this probably isn't the right place for this */
 981       abfd->flags |= BFD_IS_RELAXABLE;
 982       break;
 983 #endif
 984
 985 #ifdef SHMAGIC
 986     case SHMAGIC:
 987       arch = bfd_arch_sh;
 988       machine = 0;
 989       break;
 990 #endif
 991
 992 #ifdef H8500MAGIC
 993     case H8500MAGIC:
 994       arch = bfd_arch_h8500;
 995       machine = 0;
 996       break;
 997 #endif
 998
 999 #ifdef SPARCMAGIC
1000     case SPARCMAGIC:
1001       arch = bfd_arch_sparc;
1002       machine = 0;
1003       break;
1004 #endif
1005
1006     default:                    /* Unreadable input file type */
1007       arch = bfd_arch_obscure;
1008       break;
1009     }
1010
1011   bfd_default_set_arch_mach (abfd, arch, machine);
1012   return true;
1013 }
1014
1015 #ifdef SYMNAME_IN_DEBUG
1016
1017 static boolean
1018 DEFUN (symname_in_debug_hook, (abfd, sym),
1019        bfd * abfd AND
1020        struct internal_syment *sym)
1021 {
1022   return SYMNAME_IN_DEBUG (sym) ? true : false;
1023 }
1024
1025 #else
1026
1027 #define symname_in_debug_hook \
1028   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1029
1030 #endif
1031
1032 /*
1033 SUBSUBSECTION
1034         Writing relocations
1035
1036         To write relocations, the back end steps though the
1037         canonical relocation table and create an
1038         @code{internal_reloc}. The symbol index to use is removed from
1039         the @code{offset} field in the symbol table supplied.  The
1040         address comes directly from the sum of the section base
1041         address and the relocation offset; the type is dug directly
1042         from the howto field.  Then the @code{internal_reloc} is
1043         swapped into the shape of an @code{external_reloc} and written
1044         out to disk.
1045
1046 */
1047
1048 static void
1049 DEFUN (coff_write_relocs, (abfd),
1050        bfd * abfd)
1051 {
1052   asection *s;
1053   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1054     {
1055       unsigned int i;
1056       struct external_reloc dst;
1057
1058       arelent **p = s->orelocation;
1059       bfd_seek (abfd, s->rel_filepos, SEEK_SET);
1060       for (i = 0; i < s->reloc_count; i++)
1061         {
1062           struct internal_reloc n;
1063           arelent *q = p[i];
1064           memset ((PTR) & n, 0, sizeof (n));
1065
1066           n.r_vaddr = q->address + s->vma;
1067
1068 #ifdef R_IHCONST
1069           /* The 29k const/consth reloc pair is a real kludge.  The consth
1070          part doesn't have a symbol; it has an offset.  So rebuilt
1071          that here.  */
1072           if (q->howto->type == R_IHCONST)
1073             n.r_symndx = q->addend;
1074           else
1075 #endif
1076           if (q->sym_ptr_ptr)
1077             {
1078               if (q->sym_ptr_ptr == bfd_abs_section.symbol_ptr_ptr)
1079                 /* This is a relocation relative to the absolute symbol.  */
1080                 n.r_symndx = -1;
1081               else
1082                 {
1083                   n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1084                   /* Take notice if the symbol reloc points to a symbol
1085                    we don't have in our symbol table.  What should we
1086                    do for this??  */
1087                   if (n.r_symndx > obj_conv_table_size (abfd))
1088                     abort ();
1089                 }
1090             }
1091
1092 #ifdef SWAP_OUT_RELOC_OFFSET
1093           n.r_offset = q->addend;
1094 #endif
1095
1096 #ifdef SELECT_RELOC
1097           /* Work out reloc type from what is required */
1098           SELECT_RELOC (n, q->howto);
1099 #else
1100           n.r_type = q->howto->type;
1101 #endif
1102           coff_swap_reloc_out (abfd, &n, &dst);
1103           bfd_write ((PTR) & dst, 1, RELSZ, abfd);
1104         }
1105     }
1106 }
1107
1108 /* Set flags and magic number of a coff file from architecture and machine
1109    type.  Result is true if we can represent the arch&type, false if not.  */
1110
1111 static boolean
1112 DEFUN (coff_set_flags, (abfd, magicp, flagsp),
1113        bfd * abfd AND
1114        unsigned *magicp AND
1115        unsigned short *flagsp)
1116 {
1117   switch (bfd_get_arch (abfd))
1118     {
1119 #ifdef Z8KMAGIC
1120     case bfd_arch_z8k:
1121       *magicp = Z8KMAGIC;
1122       switch (bfd_get_mach (abfd))
1123         {
1124         case bfd_mach_z8001:
1125           *flagsp = F_Z8001;
1126           break;
1127         case bfd_mach_z8002:
1128           *flagsp = F_Z8002;
1129           break;
1130         default:
1131           return false;
1132         }
1133       return true;
1134 #endif
1135 #ifdef I960ROMAGIC
1136
1137     case bfd_arch_i960:
1138
1139       {
1140         unsigned flags;
1141         *magicp = I960ROMAGIC;
1142         /*
1143           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1144           I960RWMAGIC);   FIXME???
1145           */
1146         switch (bfd_get_mach (abfd))
1147           {
1148           case bfd_mach_i960_core:
1149             flags = F_I960CORE;
1150             break;
1151           case bfd_mach_i960_kb_sb:
1152             flags = F_I960KB;
1153             break;
1154           case bfd_mach_i960_mc:
1155             flags = F_I960MC;
1156             break;
1157           case bfd_mach_i960_xa:
1158             flags = F_I960XA;
1159             break;
1160           case bfd_mach_i960_ca:
1161             flags = F_I960CA;
1162             break;
1163           case bfd_mach_i960_ka_sa:
1164             flags = F_I960KA;
1165             break;
1166           default:
1167             return false;
1168           }
1169         *flagsp = flags;
1170         return true;
1171       }
1172       break;
1173 #endif
1174 #ifdef I386MAGIC
1175     case bfd_arch_i386:
1176       *magicp = I386MAGIC;
1177 #ifdef LYNXOS
1178       /* Just overwrite the usual value if we're doing Lynx. */
1179       *magicp = LYNXCOFFMAGIC;
1180 #endif
1181       return true;
1182       break;
1183 #endif
1184 #ifdef MC68MAGIC
1185     case bfd_arch_m68k:
1186 #ifdef APOLLOM68KMAGIC
1187       *magicp = APOLLO_COFF_VERSION_NUMBER;
1188 #else
1189       *magicp = MC68MAGIC;
1190 #endif
1191 #ifdef LYNXOS
1192       /* Just overwrite the usual value if we're doing Lynx. */
1193       *magicp = LYNXCOFFMAGIC;
1194 #endif
1195       return true;
1196       break;
1197 #endif
1198
1199 #ifdef MC88MAGIC
1200     case bfd_arch_m88k:
1201       *magicp = MC88OMAGIC;
1202       return true;
1203       break;
1204 #endif
1205 #ifdef H8300MAGIC
1206     case bfd_arch_h8300:
1207       switch (bfd_get_mach (abfd))
1208         {
1209         case bfd_mach_h8300:
1210           *magicp = H8300MAGIC;
1211           return true;
1212         case bfd_mach_h8300h:
1213           *magicp = H8300HMAGIC;
1214           return true;
1215         }
1216       break;
1217 #endif
1218
1219 #ifdef SHMAGIC
1220     case bfd_arch_sh:
1221       *magicp = SHMAGIC;
1222       return true;
1223       break;
1224 #endif
1225
1226 #ifdef SPARCMAGIC
1227     case bfd_arch_sparc:
1228       *magicp = SPARCMAGIC;
1229 #ifdef LYNXOS
1230       /* Just overwrite the usual value if we're doing Lynx. */
1231       *magicp = LYNXCOFFMAGIC;
1232 #endif
1233       return true;
1234       break;
1235 #endif
1236
1237 #ifdef H8500MAGIC
1238     case bfd_arch_h8500:
1239       *magicp = H8500MAGIC;
1240       return true;
1241       break;
1242 #endif
1243 #ifdef A29K_MAGIC_BIG
1244     case bfd_arch_a29k:
1245       if (abfd->xvec->byteorder_big_p)
1246         *magicp = A29K_MAGIC_BIG;
1247       else
1248         *magicp = A29K_MAGIC_LITTLE;
1249       return true;
1250       break;
1251 #endif
1252
1253 #ifdef WE32KMAGIC
1254     case bfd_arch_we32k:
1255       *magicp = WE32KMAGIC;
1256       return true;
1257       break;
1258 #endif
1259
1260 #ifdef U802TOCMAGIC
1261     case bfd_arch_rs6000:
1262       *magicp = U802TOCMAGIC;
1263       return true;
1264       break;
1265 #endif
1266
1267     default:                    /* Unknown architecture */
1268       /* return false;  -- fall through to "return false" below, to avoid
1269        "statement never reached" errors on the one below. */
1270       break;
1271     }
1272
1273   return false;
1274 }
1275
1276
1277 static boolean
1278 DEFUN (coff_set_arch_mach, (abfd, arch, machine),
1279        bfd * abfd AND
1280        enum bfd_architecture arch AND
1281        unsigned long machine)
1282 {
1283   unsigned dummy1;
1284   unsigned short dummy2;
1285   bfd_default_set_arch_mach (abfd, arch, machine);
1286
1287   if (arch != bfd_arch_unknown &&
1288       coff_set_flags (abfd, &dummy1, &dummy2) != true)
1289     return false;               /* We can't represent this type */
1290   return true;                  /* We're easy ... */
1291 }
1292
1293
1294 /* Calculate the file position for each section. */
1295
1296 static void
1297 DEFUN (coff_compute_section_file_positions, (abfd),
1298        bfd * abfd)
1299 {
1300   asection *current;
1301   asection *previous = (asection *) NULL;
1302   file_ptr sofar = FILHSZ;
1303 #ifndef I960
1304   file_ptr old_sofar;
1305 #endif
1306   if (bfd_get_start_address (abfd))
1307     {
1308       /*  A start address may have been added to the original file. In this
1309         case it will need an optional header to record it.  */
1310       abfd->flags |= EXEC_P;
1311     }
1312
1313   if (abfd->flags & EXEC_P)
1314     sofar += AOUTSZ;
1315
1316   sofar += abfd->section_count * SCNHSZ;
1317   for (current = abfd->sections;
1318        current != (asection *) NULL;
1319        current = current->next)
1320     {
1321
1322       /* Only deal with sections which have contents */
1323       if (!(current->flags & SEC_HAS_CONTENTS))
1324         continue;
1325
1326       /* Align the sections in the file to the same boundary on
1327          which they are aligned in virtual memory.  I960 doesn't
1328          do this (FIXME) so we can stay in sync with Intel.  960
1329          doesn't yet page from files... */
1330 #ifndef I960
1331       {
1332         /* make sure this section is aligned on the right boundary - by
1333          padding the previous section up if necessary */
1334
1335         old_sofar = sofar;
1336         sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1337         if (previous != (asection *) NULL)
1338           {
1339             previous->_raw_size += sofar - old_sofar;
1340           }
1341       }
1342
1343 #endif
1344       /* FIXME, in demand paged files, the low order bits of the file
1345          offset must match the low order bits of the virtual address.
1346          "Low order" is apparently implementation defined.  Add code
1347          here to round sofar up to match the virtual address.  */
1348
1349       current->filepos = sofar;
1350
1351       sofar += current->_raw_size;
1352 #ifndef I960
1353       /* make sure that this section is of the right size too */
1354       old_sofar = sofar;
1355       sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1356       current->_raw_size += sofar - old_sofar;
1357 #endif
1358
1359 #ifdef _LIB
1360       /* Force .lib sections to start at zero.  The vma is then
1361          incremented in coff_set_section_contents.  This is right for
1362          SVR3.2.  */
1363       if (strcmp (current->name, _LIB) == 0)
1364         bfd_set_section_vma (abfd, current, 0);
1365 #endif
1366
1367       previous = current;
1368     }
1369   obj_relocbase (abfd) = sofar;
1370 }
1371
1372 #ifndef RS6000COFF_C
1373
1374 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1375 /* @@ Should we only be adding missing symbols, or overriding the aux
1376    values for existing section symbols?  */
1377 static boolean
1378 coff_add_missing_symbols (abfd)
1379      bfd *abfd;
1380 {
1381   unsigned int nsyms = bfd_get_symcount (abfd);
1382   asymbol **sympp = abfd->outsymbols;
1383   asymbol **sympp2;
1384   unsigned int i;
1385   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1386
1387   for (i = 0; i < nsyms; i++)
1388     {
1389       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1390       CONST char *name;
1391       if (csym)
1392         {
1393           /* only do this if there is a coff representation of the input
1394            symbol */
1395           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1396             {
1397               need_file = 0;
1398               continue;
1399             }
1400           name = csym->symbol.name;
1401           if (!name)
1402             continue;
1403           if (!strcmp (name, _TEXT))
1404             need_text = 0;
1405 #ifdef APOLLO_M68
1406           else if (!strcmp (name, ".wtext"))
1407             need_text = 0;
1408 #endif
1409           else if (!strcmp (name, _DATA))
1410             need_data = 0;
1411           else if (!strcmp (name, _BSS))
1412             need_bss = 0;
1413         }
1414     }
1415   /* Now i == bfd_get_symcount (abfd).  */
1416   /* @@ For now, don't deal with .file symbol.  */
1417   need_file = 0;
1418
1419   if (!need_text && !need_data && !need_bss && !need_file)
1420     return true;
1421   nsyms += need_text + need_data + need_bss + need_file;
1422   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1423   if (!sympp2)
1424     {
1425       bfd_error = no_memory;
1426       return false;
1427     }
1428   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1429   if (need_file)
1430     {
1431       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1432       abort ();
1433     }
1434   if (need_text)
1435     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1436   if (need_data)
1437     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1438   if (need_bss)
1439     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1440   BFD_ASSERT (i == nsyms);
1441   bfd_set_symtab (abfd, sympp2, nsyms);
1442   return true;
1443 }
1444
1445 #endif /* ! defined (RS6000COFF_C) */
1446
1447 /* SUPPRESS 558 */
1448 /* SUPPRESS 529 */
1449 static boolean
1450 DEFUN (coff_write_object_contents, (abfd),
1451        bfd * abfd)
1452 {
1453   asection *current;
1454   unsigned int count;
1455
1456   boolean hasrelocs = false;
1457   boolean haslinno = false;
1458   file_ptr reloc_base;
1459   file_ptr lineno_base;
1460   file_ptr sym_base;
1461   file_ptr scn_base;
1462   file_ptr data_base;
1463   unsigned long reloc_size = 0;
1464   unsigned long lnno_size = 0;
1465   asection *text_sec = NULL;
1466   asection *data_sec = NULL;
1467   asection *bss_sec = NULL;
1468
1469   struct internal_filehdr internal_f;
1470   struct internal_aouthdr internal_a;
1471
1472
1473   bfd_error = system_call_error;
1474   /* Number the output sections, starting from one on the first section
1475      with a name which doesn't start with a *.
1476      @@ The code doesn't make this check.  Is it supposed to be done,
1477      or isn't it??  */
1478   count = 1;
1479   for (current = abfd->sections; current != (asection *) NULL;
1480        current = current->next)
1481     {
1482       current->target_index = count;
1483       count++;
1484     }
1485
1486   if (abfd->output_has_begun == false)
1487     {
1488       coff_compute_section_file_positions (abfd);
1489     }
1490
1491   if (abfd->sections != (asection *) NULL)
1492     {
1493       scn_base = abfd->sections->filepos;
1494     }
1495   else
1496     {
1497       scn_base = 0;
1498     }
1499   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
1500     return false;
1501   reloc_base = obj_relocbase (abfd);
1502
1503   /* Make a pass through the symbol table to count line number entries and
1504      put them into the correct asections */
1505
1506   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
1507   data_base = scn_base;
1508
1509   /* Work out the size of the reloc and linno areas */
1510
1511   for (current = abfd->sections; current != NULL; current =
1512        current->next)
1513     {
1514       /* We give section headers to +ve indexes */
1515       if (current->target_index > 0)
1516         {
1517
1518           reloc_size += current->reloc_count * RELSZ;
1519           data_base += SCNHSZ;
1520         }
1521
1522     }
1523
1524   lineno_base = reloc_base + reloc_size;
1525   sym_base = lineno_base + lnno_size;
1526
1527   /* Indicate in each section->line_filepos its actual file address */
1528   for (current = abfd->sections; current != NULL; current =
1529        current->next)
1530     {
1531       if (current->target_index > 0)
1532         {
1533
1534           if (current->lineno_count)
1535             {
1536               current->line_filepos = lineno_base;
1537               current->moving_line_filepos = lineno_base;
1538               lineno_base += current->lineno_count * LINESZ;
1539             }
1540           else
1541             {
1542               current->line_filepos = 0;
1543             }
1544           if (current->reloc_count)
1545             {
1546               current->rel_filepos = reloc_base;
1547               reloc_base += current->reloc_count * RELSZ;
1548             }
1549           else
1550             {
1551               current->rel_filepos = 0;
1552             }
1553         }
1554     }
1555
1556
1557
1558   /* Write section headers to the file.  */
1559   internal_f.f_nscns = 0;
1560   bfd_seek (abfd,
1561             (file_ptr) ((abfd->flags & EXEC_P) ?
1562                         (FILHSZ + AOUTSZ) : FILHSZ),
1563             SEEK_SET);
1564
1565   {
1566 #if 0
1567     unsigned int pad = abfd->flags & D_PAGED ? data_base : 0;
1568 #endif
1569     unsigned int pad = 0;
1570
1571     for (current = abfd->sections;
1572          current != NULL;
1573          current = current->next)
1574       {
1575         struct internal_scnhdr section;
1576         if (current->target_index > 0)
1577           {
1578             internal_f.f_nscns++;
1579             strncpy (&(section.s_name[0]), current->name, 8);
1580 #ifdef _LIB
1581             /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
1582            Ian Taylor <[email protected]>.  */
1583             if (strcmp (current->name, _LIB) == 0)
1584               section.s_vaddr = 0;
1585             else
1586 #endif
1587               section.s_vaddr = current->lma + pad;
1588             section.s_paddr = current->lma + pad;
1589             section.s_size = current->_raw_size - pad;
1590             /*
1591           If this section has no size or is unloadable then the scnptr
1592           will be 0 too
1593           */
1594             if (current->_raw_size - pad == 0 ||
1595                 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1596               {
1597                 section.s_scnptr = 0;
1598               }
1599             else
1600               {
1601                 section.s_scnptr = current->filepos;
1602               }
1603             section.s_relptr = current->rel_filepos;
1604             section.s_lnnoptr = current->line_filepos;
1605             section.s_nreloc = current->reloc_count;
1606             section.s_nlnno = current->lineno_count;
1607             if (current->reloc_count != 0)
1608               hasrelocs = true;
1609             if (current->lineno_count != 0)
1610               haslinno = true;
1611
1612             section.s_flags = sec_to_styp_flags (current->name, current->flags);
1613
1614             if (!strcmp (current->name, _TEXT))
1615               {
1616                 text_sec = current;
1617               }
1618             else if (!strcmp (current->name, _DATA))
1619               {
1620                 data_sec = current;
1621 #ifdef TWO_DATA_SECS
1622               }
1623             else if (!strcmp (current->name, ".data2"))
1624               {
1625                 data_sec = current;
1626 #endif /* TWO_DATA_SECS */
1627               }
1628             else if (!strcmp (current->name, _BSS))
1629               {
1630                 bss_sec = current;
1631               }
1632
1633 #ifdef I960
1634             section.s_align = (current->alignment_power
1635                                ? 1 << current->alignment_power
1636                                : 0);
1637
1638 #endif
1639             {
1640               SCNHDR buff;
1641
1642               coff_swap_scnhdr_out (abfd, &section, &buff);
1643               bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd);
1644
1645             }
1646
1647             pad = 0;
1648           }
1649       }
1650   }
1651
1652
1653   /* OK, now set up the filehdr... */
1654
1655   /* Don't include the internal abs section in the section count */
1656
1657   /*
1658     We will NOT put a fucking timestamp in the header here. Every time you
1659     put it back, I will come in and take it out again.  I'm sorry.  This
1660     field does not belong here.  We fill it with a 0 so it compares the
1661     same but is not a reasonable time. -- [email protected]
1662     */
1663   internal_f.f_timdat = 0;
1664
1665   if (bfd_get_symcount (abfd) != 0)
1666     internal_f.f_symptr = sym_base;
1667   else
1668     internal_f.f_symptr = 0;
1669
1670   internal_f.f_flags = 0;
1671
1672   if (abfd->flags & EXEC_P)
1673     internal_f.f_opthdr = AOUTSZ;
1674   else
1675     internal_f.f_opthdr = 0;
1676
1677   if (!hasrelocs)
1678     internal_f.f_flags |= F_RELFLG;
1679   if (!haslinno)
1680     internal_f.f_flags |= F_LNNO;
1681   if (0 == bfd_get_symcount (abfd))
1682     internal_f.f_flags |= F_LSYMS;
1683   if (abfd->flags & EXEC_P)
1684     internal_f.f_flags |= F_EXEC;
1685
1686   if (!abfd->xvec->byteorder_big_p)
1687     internal_f.f_flags |= F_AR32WR;
1688   else
1689     internal_f.f_flags |= F_AR32W;
1690
1691   /*
1692     FIXME, should do something about the other byte orders and
1693     architectures.
1694     */
1695
1696   memset (&internal_a, 0, sizeof internal_a);
1697
1698   /* Set up architecture-dependent stuff */
1699
1700   {
1701     unsigned int magic = 0;
1702     unsigned short flags = 0;
1703     coff_set_flags (abfd, &magic, &flags);
1704     internal_f.f_magic = magic;
1705     internal_f.f_flags |= flags;
1706     /* ...and the "opt"hdr... */
1707
1708 #ifdef A29K
1709 #ifdef ULTRA3                   /* NYU's machine */
1710     /* FIXME: This is a bogus check.  I really want to see if there
1711    * is a .shbss or a .shdata section, if so then set the magic
1712    * number to indicate a shared data executable.
1713    */
1714     if (internal_f.f_nscns >= 7)
1715       internal_a.magic = SHMAGIC;       /* Shared magic */
1716     else
1717 #endif /* ULTRA3 */
1718       internal_a.magic = NMAGIC;/* Assume separate i/d */
1719 #define __A_MAGIC_SET__
1720 #endif /* A29K */
1721 #ifdef I960
1722     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
1723 #define __A_MAGIC_SET__
1724 #endif /* I960 */
1725 #if M88
1726 #define __A_MAGIC_SET__
1727     internal_a.magic = PAGEMAGICBCS;
1728 #endif /* M88 */
1729
1730 #if APOLLO_M68
1731 #define __A_MAGIC_SET__
1732     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
1733 #endif
1734
1735 #if M68 || WE32K
1736 #define __A_MAGIC_SET__
1737     /* Never was anything here for the 68k */
1738 #endif /* M68 || WE32K */
1739
1740 #if I386
1741 #define __A_MAGIC_SET__
1742     internal_a.magic = ZMAGIC;
1743 #endif /* I386 */
1744
1745 #if RS6000COFF_C
1746 #define __A_MAGIC_SET__
1747     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
1748       (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
1749       RS6K_AOUTHDR_OMAGIC;
1750 #endif
1751
1752 #ifndef __A_MAGIC_SET__
1753 #include "Your aouthdr magic number is not being set!"
1754 #else
1755 #undef __A_MAGIC_SET__
1756 #endif
1757   }
1758   /* Now should write relocs, strings, syms */
1759   obj_sym_filepos (abfd) = sym_base;
1760
1761   if (bfd_get_symcount (abfd) != 0)
1762     {
1763 #ifndef RS6000COFF_C
1764       if (!coff_add_missing_symbols (abfd))
1765         return false;
1766 #endif
1767       if (!coff_renumber_symbols (abfd))
1768         return false;
1769       coff_mangle_symbols (abfd);
1770       coff_write_symbols (abfd);
1771       if (!coff_write_linenumbers (abfd))
1772         return false;
1773       coff_write_relocs (abfd);
1774     }
1775   if (text_sec)
1776     {
1777       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
1778       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
1779     }
1780   if (data_sec)
1781     {
1782       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
1783       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
1784     }
1785   if (bss_sec)
1786     {
1787       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
1788     }
1789
1790   internal_a.entry = bfd_get_start_address (abfd);
1791   internal_f.f_nsyms = bfd_get_symcount (abfd);
1792
1793   /* now write them */
1794   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1795     return false;
1796   {
1797     FILHDR buff;
1798     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
1799     bfd_write ((PTR) & buff, 1, FILHSZ, abfd);
1800   }
1801   if (abfd->flags & EXEC_P)
1802     {
1803       AOUTHDR buff;
1804       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
1805       bfd_write ((PTR) & buff, 1, AOUTSZ, abfd);
1806     }
1807   return true;
1808 }
1809
1810 static boolean
1811 DEFUN (coff_set_section_contents, (abfd, section, location, offset, count),
1812        bfd * abfd AND
1813        sec_ptr section AND
1814        PTR location AND
1815        file_ptr offset AND
1816        bfd_size_type count)
1817 {
1818   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
1819     coff_compute_section_file_positions (abfd);
1820
1821 #ifdef _LIB
1822   /* If this is a .lib section, bump the vma address so that it
1823        winds up being the number of .lib sections output.  This is
1824        right for SVR3.2.  Shared libraries should probably get more
1825        generic support.  Ian Taylor <[email protected]>.  */
1826   if (strcmp (section->name, _LIB) == 0)
1827     ++section->lma;
1828 #endif
1829
1830   /* Don't write out bss sections - one way to do this is to
1831        see if the filepos has not been set. */
1832   if (section->filepos == 0)
1833     return true;
1834
1835   bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
1836
1837   if (count != 0)
1838     {
1839       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
1840     }
1841   return true;
1842 }
1843 #if 0
1844 static boolean
1845 coff_close_and_cleanup (abfd)
1846      bfd *abfd;
1847 {
1848   if (!bfd_read_p (abfd))
1849     switch (abfd->format)
1850       {
1851       case bfd_archive:
1852         if (!_bfd_write_archive_contents (abfd))
1853           return false;
1854         break;
1855       case bfd_object:
1856         if (!coff_write_object_contents (abfd))
1857           return false;
1858         break;
1859       default:
1860         bfd_error = invalid_operation;
1861         return false;
1862       }
1863
1864   /* We depend on bfd_close to free all the memory on the obstack.  */
1865   /* FIXME if bfd_release is not using obstacks! */
1866   return true;
1867 }
1868
1869 #endif
1870
1871 static PTR
1872 buy_and_read (abfd, where, seek_direction, size)
1873      bfd *abfd;
1874      file_ptr where;
1875      int seek_direction;
1876      size_t size;
1877 {
1878   PTR area = (PTR) bfd_alloc (abfd, size);
1879   if (!area)
1880     {
1881       bfd_error = no_memory;
1882       return (NULL);
1883     }
1884   bfd_seek (abfd, where, seek_direction);
1885   if (bfd_read (area, 1, size, abfd) != size)
1886     {
1887       bfd_error = system_call_error;
1888       return (NULL);
1889     }                           /* on error */
1890   return (area);
1891 }                               /* buy_and_read() */
1892
1893 /*
1894 SUBSUBSECTION
1895         Reading linenumbers
1896
1897         Creating the linenumber table is done by reading in the entire
1898         coff linenumber table, and creating another table for internal use.
1899
1900         A coff linenumber table is structured so that each function
1901         is marked as having a line number of 0. Each line within the
1902         function is an offset from the first line in the function. The
1903         base of the line number information for the table is stored in
1904         the symbol associated with the function.
1905
1906         The information is copied from the external to the internal
1907         table, and each symbol which marks a function is marked by
1908         pointing its...
1909
1910         How does this work ?
1911
1912 */
1913
1914 static boolean
1915 coff_slurp_line_table (abfd, asect)
1916      bfd *abfd;
1917      asection *asect;
1918 {
1919   LINENO *native_lineno;
1920   alent *lineno_cache;
1921
1922   BFD_ASSERT (asect->lineno == (alent *) NULL);
1923
1924   native_lineno = (LINENO *) buy_and_read (abfd,
1925                                            asect->line_filepos,
1926                                            SEEK_SET,
1927                                            (size_t) (LINESZ *
1928                                                      asect->lineno_count));
1929   lineno_cache =
1930     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
1931   if (lineno_cache == NULL)
1932     {
1933       bfd_error = no_memory;
1934       return false;
1935     }
1936   else
1937     {
1938       unsigned int counter = 0;
1939       alent *cache_ptr = lineno_cache;
1940       LINENO *src = native_lineno;
1941
1942       while (counter < asect->lineno_count)
1943         {
1944           struct internal_lineno dst;
1945           coff_swap_lineno_in (abfd, src, &dst);
1946           cache_ptr->line_number = dst.l_lnno;
1947
1948           if (cache_ptr->line_number == 0)
1949             {
1950               coff_symbol_type *sym =
1951               (coff_symbol_type *) (dst.l_addr.l_symndx
1952                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
1953               cache_ptr->u.sym = (asymbol *) sym;
1954               sym->lineno = cache_ptr;
1955             }
1956           else
1957             {
1958               cache_ptr->u.offset = dst.l_addr.l_paddr
1959                 - bfd_section_vma (abfd, asect);
1960             }                   /* If no linenumber expect a symbol index */
1961
1962           cache_ptr++;
1963           src++;
1964           counter++;
1965         }
1966       cache_ptr->line_number = 0;
1967
1968     }
1969   asect->lineno = lineno_cache;
1970   /* FIXME, free native_lineno here, or use alloca or something. */
1971   return true;
1972 }
1973
1974 static boolean
1975 DEFUN (coff_slurp_symbol_table, (abfd),
1976        bfd * abfd)
1977 {
1978   combined_entry_type *native_symbols;
1979   coff_symbol_type *cached_area;
1980   unsigned int *table_ptr;
1981
1982   unsigned int number_of_symbols = 0;
1983   if (obj_symbols (abfd))
1984     return true;
1985   bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET);
1986
1987   /* Read in the symbol table */
1988   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
1989     {
1990       return (false);
1991     }                           /* on error */
1992
1993   /* Allocate enough room for all the symbols in cached form */
1994   cached_area =
1995     (coff_symbol_type *)
1996     bfd_alloc (abfd, (size_t) (bfd_get_symcount (abfd) * sizeof (coff_symbol_type)));
1997
1998   if (cached_area == NULL)
1999     {
2000       bfd_error = no_memory;
2001       return false;
2002     }                           /* on error */
2003   table_ptr =
2004     (unsigned int *)
2005     bfd_alloc (abfd, (size_t) (bfd_get_symcount (abfd) * sizeof (unsigned int)));
2006
2007   if (table_ptr == NULL)
2008     {
2009       bfd_error = no_memory;
2010       return false;
2011     }
2012   else
2013     {
2014       coff_symbol_type *dst = cached_area;
2015       unsigned int last_native_index = bfd_get_symcount (abfd);
2016       unsigned int this_index = 0;
2017       while (this_index < last_native_index)
2018         {
2019           combined_entry_type *src = native_symbols + this_index;
2020           table_ptr[this_index] = number_of_symbols;
2021           dst->symbol.the_bfd = abfd;
2022
2023           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
2024           /* We use the native name field to point to the cached field.  */
2025           src->u.syment._n._n_n._n_zeroes = (long) dst;
2026           dst->symbol.section = coff_section_from_bfd_index (abfd,
2027                                                      src->u.syment.n_scnum);
2028           dst->symbol.flags = 0;
2029           dst->done_lineno = false;
2030
2031           switch (src->u.syment.n_sclass)
2032             {
2033 #ifdef I960
2034             case C_LEAFEXT:
2035 #if 0
2036               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2037               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2038               dst->symbol.flags |= BSF_NOT_AT_END;
2039 #endif
2040               /* Fall through to next case */
2041
2042 #endif
2043
2044             case C_EXT:
2045 #ifdef RS6000COFF_C
2046             case C_HIDEXT:
2047 #endif
2048               if ((src->u.syment.n_scnum) == 0)
2049                 {
2050                   if ((src->u.syment.n_value) == 0)
2051                     {
2052                       dst->symbol.section = &bfd_und_section;
2053                       dst->symbol.value = 0;
2054                     }
2055                   else
2056                     {
2057                       dst->symbol.section = &bfd_com_section;
2058                       dst->symbol.value = (src->u.syment.n_value);
2059                     }
2060                 }
2061               else
2062                 {
2063                   /*
2064             Base the value as an index from the base of the
2065             section
2066             */
2067
2068                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2069                   dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2070
2071                   if (ISFCN ((src->u.syment.n_type)))
2072                     {
2073                       /*
2074               A function ext does not go at the end of a file
2075               */
2076                       dst->symbol.flags |= BSF_NOT_AT_END;
2077                     }
2078                 }
2079
2080 #ifdef RS6000COFF_C
2081               /* If this symbol has a csect aux of type LD, the scnlen field
2082            is actually the index of the containing csect symbol.  We
2083            need to pointerize it.  */
2084               if (src->u.syment.n_numaux > 0)
2085                 {
2086                   combined_entry_type *aux;
2087
2088                   aux = src + src->u.syment.n_numaux - 1;
2089                   if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2090                     {
2091                       aux->u.auxent.x_csect.x_scnlen.p =
2092                         native_symbols + aux->u.auxent.x_csect.x_scnlen.l;
2093                       aux->fix_scnlen = 1;
2094                     }
2095                 }
2096 #endif
2097
2098               break;
2099
2100             case C_STAT:        /* static                        */
2101 #ifdef I960
2102             case C_LEAFSTAT:    /* static leaf procedure        */
2103 #endif
2104             case C_LABEL:       /* label                         */
2105               if (src->u.syment.n_scnum == -2)
2106                 dst->symbol.flags = BSF_DEBUGGING;
2107               else
2108                 dst->symbol.flags = BSF_LOCAL;
2109               /*
2110           Base the value as an index from the base of the section, if
2111           there is one
2112           */
2113               if (dst->symbol.section)
2114                 dst->symbol.value = (src->u.syment.n_value) -
2115                   dst->symbol.section->vma;
2116               else
2117                 dst->symbol.value = (src->u.syment.n_value);
2118               break;
2119
2120             case C_MOS: /* member of structure   */
2121             case C_EOS: /* end of structure              */
2122 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
2123 #ifdef C_GLBLREG
2124             case C_GLBLREG:     /* A29k-specific storage class */
2125 #endif
2126 #endif
2127             case C_REGPARM:     /* register parameter            */
2128             case C_REG: /* register variable             */
2129 #ifdef C_AUTOARG
2130             case C_AUTOARG:     /* 960-specific storage class */
2131 #endif
2132             case C_TPDEF:       /* type definition               */
2133             case C_ARG:
2134             case C_AUTO:        /* automatic variable */
2135             case C_FIELD:       /* bit field */
2136             case C_ENTAG:       /* enumeration tag               */
2137             case C_MOE: /* member of enumeration         */
2138             case C_MOU: /* member of union               */
2139             case C_UNTAG:       /* union tag                     */
2140               dst->symbol.flags = BSF_DEBUGGING;
2141               dst->symbol.value = (src->u.syment.n_value);
2142               break;
2143
2144             case C_FILE:        /* file name                     */
2145             case C_STRTAG:      /* structure tag                 */
2146 #ifdef RS6000COFF_C
2147             case C_BINCL:       /* beginning of include file     */
2148             case C_EINCL:       /* ending of include file        */
2149             case C_GSYM:
2150             case C_LSYM:
2151             case C_PSYM:
2152             case C_RSYM:
2153             case C_RPSYM:
2154             case C_STSYM:
2155             case C_DECL:
2156             case C_ENTRY:
2157             case C_FUN:
2158             case C_ESTAT:
2159 #endif
2160               dst->symbol.flags = BSF_DEBUGGING;
2161               dst->symbol.value = (src->u.syment.n_value);
2162               break;
2163
2164 #ifdef RS6000COFF_C
2165             case C_BSTAT:
2166               dst->symbol.flags = BSF_DEBUGGING;
2167               dst->symbol.value = src->u.syment.n_value;
2168
2169               /* The value is actually a symbol index.  Save a pointer to
2170            the symbol instead of the index.  FIXME: This should use a
2171            union.  */
2172               src->u.syment.n_value =
2173                 (long) (native_symbols + src->u.syment.n_value);
2174               src->fix_value = 1;
2175               break;
2176 #endif
2177
2178             case C_BLOCK:       /* ".bb" or ".eb"                */
2179             case C_FCN: /* ".bf" or ".ef"                */
2180             case C_EFCN:        /* physical end of function      */
2181               dst->symbol.flags = BSF_LOCAL;
2182               /*
2183           Base the value as an index from the base of the section
2184           */
2185               dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
2186               break;
2187
2188             case C_NULL:
2189             case C_EXTDEF:      /* external definition           */
2190             case C_ULABEL:      /* undefined label               */
2191             case C_USTATIC:     /* undefined static              */
2192             case C_LINE:        /* line # reformatted as symbol table entry */
2193             case C_ALIAS:       /* duplicate tag                 */
2194             case C_HIDDEN:      /* ext symbol in dmert public lib */
2195             default:
2196
2197               fprintf (stderr, "Unrecognized storage class %d (assuming debugging)\n  for %s symbol `%s'\n",
2198                        src->u.syment.n_sclass, dst->symbol.section->name,
2199                        dst->symbol.name);
2200 /*      abort();*/
2201               dst->symbol.flags = BSF_DEBUGGING;
2202               dst->symbol.value = (src->u.syment.n_value);
2203               break;
2204             }
2205
2206 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
2207
2208           dst->native = src;
2209
2210           dst->symbol.udata = 0;
2211           dst->lineno = (alent *) NULL;
2212           this_index += (src->u.syment.n_numaux) + 1;
2213           dst++;
2214           number_of_symbols++;
2215         }                       /* walk the native symtab */
2216     }                           /* bfdize the native symtab */
2217
2218   obj_symbols (abfd) = cached_area;
2219   obj_raw_syments (abfd) = native_symbols;
2220
2221   obj_conv_table_size (abfd) = bfd_get_symcount (abfd);
2222   bfd_get_symcount (abfd) = number_of_symbols;
2223   obj_convert (abfd) = table_ptr;
2224   /* Slurp the line tables for each section too */
2225   {
2226     asection *p;
2227     p = abfd->sections;
2228     while (p)
2229       {
2230         coff_slurp_line_table (abfd, p);
2231         p = p->next;
2232       }
2233   }
2234   return true;
2235 }                               /* coff_slurp_symbol_table() */
2236
2237 /*
2238 SUBSUBSECTION
2239         Reading relocations
2240
2241         Coff relocations are easily transformed into the internal BFD form
2242         (@code{arelent}).
2243
2244         Reading a coff relocation table is done in the following stages:
2245
2246         o Read the entire coff relocation table into memory.
2247
2248         o Process each relocation in turn; first swap it from the
2249         external to the internal form.
2250
2251         o Turn the symbol referenced in the relocation's symbol index
2252         into a pointer into the canonical symbol table.
2253         This table is the same as the one returned by a call to
2254         @code{bfd_canonicalize_symtab}. The back end will call that
2255         routine and save the result if a canonicalization hasn't been done.
2256
2257         o The reloc index is turned into a pointer to a howto
2258         structure, in a back end specific way. For instance, the 386
2259         and 960 use the @code{r_type} to directly produce an index
2260         into a howto table vector; the 88k subtracts a number from the
2261         @code{r_type} field and creates an addend field.
2262
2263
2264 */
2265
2266 #ifndef CALC_ADDEND
2267 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)        \
2268             if (ptr && bfd_asymbol_bfd(ptr) == abfd     \
2269                 && !bfd_is_com_section(ptr->section)    \
2270                 && !(ptr->flags & BSF_OLD_COMMON))      \
2271             {                                           \
2272                 cache_ptr->addend = -(ptr->section->vma + ptr->value);  \
2273             }                                           \
2274             else {                                      \
2275                 cache_ptr->addend = 0;                  \
2276             }
2277 #endif
2278
2279 static boolean
2280 DEFUN (coff_slurp_reloc_table, (abfd, asect, symbols),
2281        bfd * abfd AND
2282        sec_ptr asect AND
2283        asymbol ** symbols)
2284 {
2285   RELOC *native_relocs;
2286   arelent *reloc_cache;
2287   arelent *cache_ptr;
2288
2289   unsigned int idx;
2290
2291   if (asect->relocation)
2292     return true;
2293   if (asect->reloc_count == 0)
2294     return true;
2295   if (asect->flags & SEC_CONSTRUCTOR)
2296     return true;
2297   if (!coff_slurp_symbol_table (abfd))
2298     return false;
2299   native_relocs =
2300     (RELOC *) buy_and_read (abfd,
2301                             asect->rel_filepos,
2302                             SEEK_SET,
2303                             (size_t) (RELSZ *
2304                                       asect->reloc_count));
2305   reloc_cache = (arelent *)
2306     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2307
2308   if (reloc_cache == NULL)
2309     {
2310       bfd_error = no_memory;
2311       return false;
2312     }
2313
2314
2315   for (idx = 0; idx < asect->reloc_count; idx++)
2316     {
2317 #ifdef RELOC_PROCESSING
2318       struct internal_reloc dst;
2319       struct external_reloc *src;
2320
2321       cache_ptr = reloc_cache + idx;
2322       src = native_relocs + idx;
2323       bfd_swap_reloc_in (abfd, src, &dst);
2324
2325       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2326 #else
2327       struct internal_reloc dst;
2328       asymbol *ptr;
2329       struct external_reloc *src;
2330
2331       cache_ptr = reloc_cache + idx;
2332       src = native_relocs + idx;
2333
2334       bfd_swap_reloc_in (abfd, src, &dst);
2335
2336
2337       cache_ptr->address = dst.r_vaddr;
2338
2339       if (dst.r_symndx != -1)
2340         {
2341           /* @@ Should never be greater than count of symbols!  */
2342           if (dst.r_symndx >= obj_conv_table_size (abfd))
2343             abort ();
2344           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
2345           ptr = *(cache_ptr->sym_ptr_ptr);
2346         }
2347       else
2348         {
2349           cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
2350           ptr = 0;
2351         }
2352
2353       /* The symbols definitions that we have read in have been
2354          relocated as if their sections started at 0. But the offsets
2355          refering to the symbols in the raw data have not been
2356          modified, so we have to have a negative addend to compensate.
2357
2358          Note that symbols which used to be common must be left alone */
2359
2360       /* Calculate any reloc addend by looking at the symbol */
2361       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
2362
2363       cache_ptr->address -= asect->vma;
2364 /* !!     cache_ptr->section = (asection *) NULL;*/
2365
2366       /* Fill in the cache_ptr->howto field from dst.r_type */
2367       RTYPE2HOWTO (cache_ptr, &dst);
2368 #endif
2369
2370     }
2371
2372   asect->relocation = reloc_cache;
2373   return true;
2374 }
2375
2376
2377 /* This is stupid.  This function should be a boolean predicate.  */
2378 static unsigned int
2379 DEFUN (coff_canonicalize_reloc, (abfd, section, relptr, symbols),
2380        bfd * abfd AND
2381        sec_ptr section AND
2382        arelent ** relptr AND
2383        asymbol ** symbols)
2384 {
2385   arelent *tblptr = section->relocation;
2386   unsigned int count = 0;
2387
2388
2389   if (section->flags & SEC_CONSTRUCTOR)
2390     {
2391       /* this section has relocs made up by us, they are not in the
2392        file, so take them out of their chain and place them into
2393        the data area provided */
2394       arelent_chain *chain = section->constructor_chain;
2395       for (count = 0; count < section->reloc_count; count++)
2396         {
2397           *relptr++ = &chain->relent;
2398           chain = chain->next;
2399         }
2400
2401     }
2402   else
2403     {
2404       coff_slurp_reloc_table (abfd, section, symbols);
2405
2406
2407       tblptr = section->relocation;
2408       if (!tblptr)
2409         return 0;
2410
2411       for (; count++ < section->reloc_count;)
2412         *relptr++ = tblptr++;
2413
2414
2415     }
2416   *relptr = 0;
2417   return section->reloc_count;
2418 }
2419
2420 #ifdef GNU960
2421 file_ptr
2422 coff_sym_filepos (abfd)
2423      bfd *abfd;
2424 {
2425   return obj_sym_filepos (abfd);
2426 }
2427 #endif
2428
2429 #ifndef coff_reloc16_estimate
2430 #define coff_reloc16_estimate dummy_reloc16_estimate
2431
2432 static int
2433 dummy_reloc16_estimate (input_section, symbols, reloc, shrink, link_info)
2434      asection *input_section;
2435      asymbol **symbols;
2436      arelent *reloc;
2437      unsigned int shrink;
2438      struct bfd_link_info *link_info;
2439 {
2440   abort ();
2441 }
2442
2443 #endif
2444
2445 #ifndef coff_reloc16_extra_cases
2446 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
2447 /* This works even if abort is not declared in any header file.  */
2448 static void
2449 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
2450                            dst_ptr)
2451      bfd *abfd;
2452      struct bfd_link_info *link_info;
2453      struct bfd_link_order *link_order;
2454      arelent *reloc;
2455      bfd_byte *data;
2456      unsigned int *src_ptr;
2457      unsigned int *dst_ptr;
2458 {
2459   fprintf (stderr, "%s\n", reloc->howto->name);
2460   abort ();
2461 }
2462 #endif
2463
2464 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
2465 {
2466   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
2467   coff_swap_aux_out, coff_swap_sym_out,
2468   coff_swap_lineno_out, coff_swap_reloc_out,
2469   coff_swap_filehdr_out, coff_swap_aouthdr_out,
2470   coff_swap_scnhdr_out,
2471   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, LINESZ,
2472 #ifdef COFF_LONG_FILENAMES
2473   true,
2474 #else
2475   false,
2476 #endif
2477   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
2478   coff_bad_format_hook, coff_set_arch_mach_hook, coff_mkobject_hook,
2479   styp_to_sec_flags, coff_make_section_hook, coff_set_alignment_hook,
2480   coff_slurp_symbol_table, symname_in_debug_hook,
2481   coff_reloc16_extra_cases, coff_reloc16_estimate
2482 };
2483
2484 #define coff_core_file_failing_command  _bfd_dummy_core_file_failing_command
2485 #define coff_core_file_failing_signal   _bfd_dummy_core_file_failing_signal
2486 #define coff_core_file_matches_executable_p     _bfd_dummy_core_file_matches_executable_p
2487 #define coff_slurp_armap                bfd_slurp_coff_armap
2488 #define coff_slurp_extended_name_table  _bfd_slurp_extended_name_table
2489 #define coff_truncate_arname            bfd_dont_truncate_arname
2490 #define coff_openr_next_archived_file   bfd_generic_openr_next_archived_file
2491 #define coff_generic_stat_arch_elt      bfd_generic_stat_arch_elt
2492 #define coff_get_section_contents       bfd_generic_get_section_contents
2493 #define coff_close_and_cleanup          bfd_generic_close_and_cleanup
2494
2495 #define coff_bfd_debug_info_start       bfd_void
2496 #define coff_bfd_debug_info_end         bfd_void
2497 #define coff_bfd_debug_info_accumulate  \
2498                         (void (*) PARAMS ((bfd *, struct sec *))) bfd_void
2499 #define coff_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
2500 #define coff_bfd_relax_section          bfd_generic_relax_section
2501 #ifndef coff_bfd_reloc_type_lookup
2502 #define coff_bfd_reloc_type_lookup \
2503   ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
2504 #endif
2505 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
2506 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
2507 #define coff_bfd_final_link _bfd_generic_final_link