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 | SEC_COFF_SHARED_LIBRARY)) != 0)
 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 styp_to_sec_flags (abfd, hdr)
 409      bfd * abfd;
 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_COFF_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_COFF_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_COFF_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 .       bfd *abfd,
 607 .       asection *input_section,
 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, reloc, shrink, link_info)\
 690 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 691 .         (abfd, section, reloc, shrink, link_info))
 692 .
 693 */
 694
 695 /* See whether the magic number matches.  */
 696
 697 static boolean
 698 coff_bad_format_hook (abfd, filehdr)
 699      bfd * abfd;
 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 coff_make_section_hook (abfd, name)
 726      bfd * abfd;
 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 coff_new_section_hook (abfd, section)
 747      bfd * abfd;
 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
 759 #ifdef COFF_SPARC
 760   /* This is to allow double-word operations on addresses in data or bss. */
 761   if (strcmp (section->name, ".data") == 0
 762       || strcmp (section->name, ".bss") == 0)
 763     section->alignment_power = 3;
 764 #endif /* COFF_SPARC */
 765
 766   return true;
 767 }
 768
 769
 770 #ifdef I960
 771
 772 /* Set the alignment of a BFD section.  */
 773
 774 static void
 775 coff_set_alignment_hook (abfd, section, scnhdr)
 776      bfd * abfd;
 777      asection * section;
 778      PTR scnhdr;
 779 {
 780   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 781   unsigned int i;
 782
 783   for (i = 0; i < 32; i++)
 784     if ((1 << i) >= hdr->s_align)
 785       break;
 786   section->alignment_power = i;
 787 }
 788
 789 #else /* ! I960 */
 790
 791 #define coff_set_alignment_hook \
 792   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
 793
 794 #endif /* ! I960 */
 795
 796 static boolean
 797 coff_mkobject (abfd)
 798      bfd * abfd;
 799 {
 800   coff_data_type *coff;
 801
 802   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
 803   if (abfd->tdata.coff_obj_data == 0)
 804     {
 805       bfd_set_error (bfd_error_no_memory);
 806       return false;
 807     }
 808   coff = coff_data (abfd);
 809   coff->symbols = (coff_symbol_type *) NULL;
 810   coff->conversion_table = (unsigned int *) NULL;
 811   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 812   coff->raw_linenos = (struct lineno *) NULL;
 813   coff->relocbase = 0;
 814 /*  make_abs_section(abfd);*/
 815   return true;
 816 }
 817
 818 /* Create the COFF backend specific information.  */
 819
 820 static PTR
 821 coff_mkobject_hook (abfd, filehdr, aouthdr)
 822      bfd * abfd;
 823      PTR filehdr;
 824      PTR aouthdr;
 825 {
 826   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 827   coff_data_type *coff;
 828
 829   if (coff_mkobject (abfd) == false)
 830     return NULL;
 831
 832   coff = coff_data (abfd);
 833
 834   coff->sym_filepos = internal_f->f_symptr;
 835   coff->flags = internal_f->f_flags;
 836
 837   /* These members communicate important constants about the symbol
 838      table to GDB's symbol-reading code.  These `constants'
 839      unfortunately vary among coff implementations...  */
 840   coff->local_n_btmask = N_BTMASK;
 841   coff->local_n_btshft = N_BTSHFT;
 842   coff->local_n_tmask = N_TMASK;
 843   coff->local_n_tshift = N_TSHIFT;
 844   coff->local_symesz = SYMESZ;
 845   coff->local_auxesz = AUXESZ;
 846   coff->local_linesz = LINESZ;
 847
 848   return (PTR) coff;
 849 }
 850
 851 /* Determine the machine architecture and type.  FIXME: This is target
 852    dependent because the magic numbers are defined in the target
 853    dependent header files.  But there is no particular need for this.
 854    If the magic numbers were moved to a separate file, this function
 855    would be target independent and would also be much more successful
 856    at linking together COFF files for different architectures.  */
 857
 858 static boolean
 859 coff_set_arch_mach_hook (abfd, filehdr)
 860      bfd *abfd;
 861      PTR filehdr;
 862 {
 863   long machine;
 864   enum bfd_architecture arch;
 865   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 866
 867   machine = 0;
 868   switch (internal_f->f_magic)
 869     {
 870 #ifdef I386MAGIC
 871     case I386MAGIC:
 872     case I386PTXMAGIC:
 873     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
 874     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
 875       arch = bfd_arch_i386;
 876       machine = 0;
 877       break;
 878 #endif
 879
 880 #ifdef A29K_MAGIC_BIG
 881     case A29K_MAGIC_BIG:
 882     case A29K_MAGIC_LITTLE:
 883       arch = bfd_arch_a29k;
 884       machine = 0;
 885       break;
 886 #endif
 887
 888 #ifdef MC68MAGIC
 889     case MC68MAGIC:
 890     case M68MAGIC:
 891 #ifdef MC68KBCSMAGIC
 892     case MC68KBCSMAGIC:
 893 #endif
 894 #ifdef APOLLOM68KMAGIC
 895     case APOLLOM68KMAGIC:
 896 #endif
 897 #ifdef LYNXCOFFMAGIC
 898     case LYNXCOFFMAGIC:
 899 #endif
 900       arch = bfd_arch_m68k;
 901       machine = 68020;
 902       break;
 903 #endif
 904 #ifdef MC88MAGIC
 905     case MC88MAGIC:
 906     case MC88DMAGIC:
 907     case MC88OMAGIC:
 908       arch = bfd_arch_m88k;
 909       machine = 88100;
 910       break;
 911 #endif
 912 #ifdef Z8KMAGIC
 913     case Z8KMAGIC:
 914       arch = bfd_arch_z8k;
 915       switch (internal_f->f_flags & F_MACHMASK)
 916         {
 917         case F_Z8001:
 918           machine = bfd_mach_z8001;
 919           break;
 920         case F_Z8002:
 921           machine = bfd_mach_z8002;
 922           break;
 923         default:
 924           return false;
 925         }
 926       break;
 927 #endif
 928 #ifdef I960
 929 #ifdef I960ROMAGIC
 930     case I960ROMAGIC:
 931     case I960RWMAGIC:
 932       arch = bfd_arch_i960;
 933       switch (F_I960TYPE & internal_f->f_flags)
 934         {
 935         default:
 936         case F_I960CORE:
 937           machine = bfd_mach_i960_core;
 938           break;
 939         case F_I960KB:
 940           machine = bfd_mach_i960_kb_sb;
 941           break;
 942         case F_I960MC:
 943           machine = bfd_mach_i960_mc;
 944           break;
 945         case F_I960XA:
 946           machine = bfd_mach_i960_xa;
 947           break;
 948         case F_I960CA:
 949           machine = bfd_mach_i960_ca;
 950           break;
 951         case F_I960KA:
 952           machine = bfd_mach_i960_ka_sa;
 953           break;
 954         }
 955       break;
 956 #endif
 957 #endif
 958
 959 #ifdef U802ROMAGIC
 960     case U802ROMAGIC:
 961     case U802WRMAGIC:
 962     case U802TOCMAGIC:
 963       arch = bfd_arch_rs6000;
 964       machine = 6000;
 965       break;
 966 #endif
 967
 968 #ifdef WE32KMAGIC
 969     case WE32KMAGIC:
 970       arch = bfd_arch_we32k;
 971       machine = 0;
 972       break;
 973 #endif
 974
 975 #ifdef H8300MAGIC
 976     case H8300MAGIC:
 977       arch = bfd_arch_h8300;
 978       machine = bfd_mach_h8300;
 979       /* !! FIXME this probably isn't the right place for this */
 980       abfd->flags |= BFD_IS_RELAXABLE;
 981       break;
 982 #endif
 983
 984 #ifdef H8300HMAGIC
 985     case H8300HMAGIC:
 986       arch = bfd_arch_h8300;
 987       machine = bfd_mach_h8300h;
 988       /* !! FIXME this probably isn't the right place for this */
 989       abfd->flags |= BFD_IS_RELAXABLE;
 990       break;
 991 #endif
 992
 993 #ifdef SH_ARCH_MAGIC
 994     case SH_ARCH_MAGIC:
 995       arch = bfd_arch_sh;
 996       machine = 0;
 997       break;
 998 #endif
 999
1000 #ifdef H8500MAGIC
1001     case H8500MAGIC:
1002       arch = bfd_arch_h8500;
1003       machine = 0;
1004       break;
1005 #endif
1006
1007 #ifdef SPARCMAGIC
1008     case SPARCMAGIC:
1009 #ifdef LYNXCOFFMAGIC
1010     case LYNXCOFFMAGIC:
1011 #endif
1012       arch = bfd_arch_sparc;
1013       machine = 0;
1014       break;
1015 #endif
1016
1017     default:                    /* Unreadable input file type */
1018       arch = bfd_arch_obscure;
1019       break;
1020     }
1021
1022   bfd_default_set_arch_mach (abfd, arch, machine);
1023   return true;
1024 }
1025
1026 #ifdef SYMNAME_IN_DEBUG
1027
1028 static boolean
1029 symname_in_debug_hook (abfd, sym)
1030      bfd * abfd;
1031      struct internal_syment *sym;
1032 {
1033   return SYMNAME_IN_DEBUG (sym) ? true : false;
1034 }
1035
1036 #else
1037
1038 #define symname_in_debug_hook \
1039   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1040
1041 #endif
1042
1043 /*
1044 SUBSUBSECTION
1045         Writing relocations
1046
1047         To write relocations, the back end steps though the
1048         canonical relocation table and create an
1049         @code{internal_reloc}. The symbol index to use is removed from
1050         the @code{offset} field in the symbol table supplied.  The
1051         address comes directly from the sum of the section base
1052         address and the relocation offset; the type is dug directly
1053         from the howto field.  Then the @code{internal_reloc} is
1054         swapped into the shape of an @code{external_reloc} and written
1055         out to disk.
1056
1057 */
1058
1059 static boolean
1060 coff_write_relocs (abfd)
1061      bfd * abfd;
1062 {
1063   asection *s;
1064   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1065     {
1066       unsigned int i;
1067       struct external_reloc dst;
1068
1069       arelent **p = s->orelocation;
1070       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1071         return false;
1072       for (i = 0; i < s->reloc_count; i++)
1073         {
1074           struct internal_reloc n;
1075           arelent *q = p[i];
1076           memset ((PTR) & n, 0, sizeof (n));
1077
1078           n.r_vaddr = q->address + s->vma;
1079
1080 #ifdef R_IHCONST
1081           /* The 29k const/consth reloc pair is a real kludge.  The consth
1082          part doesn't have a symbol; it has an offset.  So rebuilt
1083          that here.  */
1084           if (q->howto->type == R_IHCONST)
1085             n.r_symndx = q->addend;
1086           else
1087 #endif
1088           if (q->sym_ptr_ptr)
1089             {
1090               if (q->sym_ptr_ptr == bfd_abs_section.symbol_ptr_ptr)
1091                 /* This is a relocation relative to the absolute symbol.  */
1092                 n.r_symndx = -1;
1093               else
1094                 {
1095                   n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1096                   /* Take notice if the symbol reloc points to a symbol
1097                    we don't have in our symbol table.  What should we
1098                    do for this??  */
1099                   if (n.r_symndx > obj_conv_table_size (abfd))
1100                     abort ();
1101                 }
1102             }
1103
1104 #ifdef SWAP_OUT_RELOC_OFFSET
1105           n.r_offset = q->addend;
1106 #endif
1107
1108 #ifdef SELECT_RELOC
1109           /* Work out reloc type from what is required */
1110           SELECT_RELOC (n, q->howto);
1111 #else
1112           n.r_type = q->howto->type;
1113 #endif
1114           coff_swap_reloc_out (abfd, &n, &dst);
1115           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1116             return false;
1117         }
1118     }
1119
1120   return true;
1121 }
1122
1123 /* Set flags and magic number of a coff file from architecture and machine
1124    type.  Result is true if we can represent the arch&type, false if not.  */
1125
1126 static boolean
1127 coff_set_flags (abfd, magicp, flagsp)
1128      bfd * abfd;
1129      unsigned *magicp;
1130      unsigned short *flagsp;
1131 {
1132   switch (bfd_get_arch (abfd))
1133     {
1134 #ifdef Z8KMAGIC
1135     case bfd_arch_z8k:
1136       *magicp = Z8KMAGIC;
1137       switch (bfd_get_mach (abfd))
1138         {
1139         case bfd_mach_z8001:
1140           *flagsp = F_Z8001;
1141           break;
1142         case bfd_mach_z8002:
1143           *flagsp = F_Z8002;
1144           break;
1145         default:
1146           return false;
1147         }
1148       return true;
1149 #endif
1150 #ifdef I960ROMAGIC
1151
1152     case bfd_arch_i960:
1153
1154       {
1155         unsigned flags;
1156         *magicp = I960ROMAGIC;
1157         /*
1158           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1159           I960RWMAGIC);   FIXME???
1160           */
1161         switch (bfd_get_mach (abfd))
1162           {
1163           case bfd_mach_i960_core:
1164             flags = F_I960CORE;
1165             break;
1166           case bfd_mach_i960_kb_sb:
1167             flags = F_I960KB;
1168             break;
1169           case bfd_mach_i960_mc:
1170             flags = F_I960MC;
1171             break;
1172           case bfd_mach_i960_xa:
1173             flags = F_I960XA;
1174             break;
1175           case bfd_mach_i960_ca:
1176             flags = F_I960CA;
1177             break;
1178           case bfd_mach_i960_ka_sa:
1179             flags = F_I960KA;
1180             break;
1181           default:
1182             return false;
1183           }
1184         *flagsp = flags;
1185         return true;
1186       }
1187       break;
1188 #endif
1189 #ifdef I386MAGIC
1190     case bfd_arch_i386:
1191       *magicp = I386MAGIC;
1192 #ifdef LYNXOS
1193       /* Just overwrite the usual value if we're doing Lynx. */
1194       *magicp = LYNXCOFFMAGIC;
1195 #endif
1196       return true;
1197       break;
1198 #endif
1199 #ifdef MC68MAGIC
1200     case bfd_arch_m68k:
1201 #ifdef APOLLOM68KMAGIC
1202       *magicp = APOLLO_COFF_VERSION_NUMBER;
1203 #else
1204       *magicp = MC68MAGIC;
1205 #endif
1206 #ifdef LYNXOS
1207       /* Just overwrite the usual value if we're doing Lynx. */
1208       *magicp = LYNXCOFFMAGIC;
1209 #endif
1210       return true;
1211       break;
1212 #endif
1213
1214 #ifdef MC88MAGIC
1215     case bfd_arch_m88k:
1216       *magicp = MC88OMAGIC;
1217       return true;
1218       break;
1219 #endif
1220 #ifdef H8300MAGIC
1221     case bfd_arch_h8300:
1222       switch (bfd_get_mach (abfd))
1223         {
1224         case bfd_mach_h8300:
1225           *magicp = H8300MAGIC;
1226           return true;
1227         case bfd_mach_h8300h:
1228           *magicp = H8300HMAGIC;
1229           return true;
1230         }
1231       break;
1232 #endif
1233
1234 #ifdef SH_ARCH_MAGIC
1235     case bfd_arch_sh:
1236       *magicp = SH_ARCH_MAGIC;
1237       return true;
1238       break;
1239 #endif
1240
1241 #ifdef SPARCMAGIC
1242     case bfd_arch_sparc:
1243       *magicp = SPARCMAGIC;
1244 #ifdef LYNXOS
1245       /* Just overwrite the usual value if we're doing Lynx. */
1246       *magicp = LYNXCOFFMAGIC;
1247 #endif
1248       return true;
1249       break;
1250 #endif
1251
1252 #ifdef H8500MAGIC
1253     case bfd_arch_h8500:
1254       *magicp = H8500MAGIC;
1255       return true;
1256       break;
1257 #endif
1258 #ifdef A29K_MAGIC_BIG
1259     case bfd_arch_a29k:
1260       if (abfd->xvec->byteorder_big_p)
1261         *magicp = A29K_MAGIC_BIG;
1262       else
1263         *magicp = A29K_MAGIC_LITTLE;
1264       return true;
1265       break;
1266 #endif
1267
1268 #ifdef WE32KMAGIC
1269     case bfd_arch_we32k:
1270       *magicp = WE32KMAGIC;
1271       return true;
1272       break;
1273 #endif
1274
1275 #ifdef U802TOCMAGIC
1276     case bfd_arch_rs6000:
1277     case bfd_arch_powerpc:
1278       *magicp = U802TOCMAGIC;
1279       return true;
1280       break;
1281 #endif
1282
1283     default:                    /* Unknown architecture */
1284       /* return false;  -- fall through to "return false" below, to avoid
1285        "statement never reached" errors on the one below. */
1286       break;
1287     }
1288
1289   return false;
1290 }
1291
1292
1293 static boolean
1294 coff_set_arch_mach (abfd, arch, machine)
1295      bfd * abfd;
1296      enum bfd_architecture arch;
1297      unsigned long machine;
1298 {
1299   unsigned dummy1;
1300   unsigned short dummy2;
1301
1302   if (! bfd_default_set_arch_mach (abfd, arch, machine))
1303     return false;
1304
1305   if (arch != bfd_arch_unknown &&
1306       coff_set_flags (abfd, &dummy1, &dummy2) != true)
1307     return false;               /* We can't represent this type */
1308
1309   return true;                  /* We're easy ... */
1310 }
1311
1312
1313 /* Calculate the file position for each section. */
1314
1315 static void
1316 coff_compute_section_file_positions (abfd)
1317      bfd * abfd;
1318 {
1319   asection *current;
1320   asection *previous = (asection *) NULL;
1321   file_ptr sofar = FILHSZ;
1322 #ifndef I960
1323   file_ptr old_sofar;
1324 #endif
1325   if (bfd_get_start_address (abfd))
1326     {
1327       /*  A start address may have been added to the original file. In this
1328         case it will need an optional header to record it.  */
1329       abfd->flags |= EXEC_P;
1330     }
1331
1332   if (abfd->flags & EXEC_P)
1333     sofar += AOUTSZ;
1334
1335   sofar += abfd->section_count * SCNHSZ;
1336   for (current = abfd->sections;
1337        current != (asection *) NULL;
1338        current = current->next)
1339     {
1340
1341       /* Only deal with sections which have contents */
1342       if (!(current->flags & SEC_HAS_CONTENTS))
1343         continue;
1344
1345       /* Align the sections in the file to the same boundary on
1346          which they are aligned in virtual memory.  I960 doesn't
1347          do this (FIXME) so we can stay in sync with Intel.  960
1348          doesn't yet page from files... */
1349 #ifndef I960
1350       {
1351         /* make sure this section is aligned on the right boundary - by
1352          padding the previous section up if necessary */
1353
1354         old_sofar = sofar;
1355         sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1356         if (previous != (asection *) NULL)
1357           {
1358             previous->_raw_size += sofar - old_sofar;
1359           }
1360       }
1361
1362 #endif
1363       /* FIXME, in demand paged files, the low order bits of the file
1364          offset must match the low order bits of the virtual address.
1365          "Low order" is apparently implementation defined.  Add code
1366          here to round sofar up to match the virtual address.  */
1367
1368       current->filepos = sofar;
1369
1370       sofar += current->_raw_size;
1371 #ifndef I960
1372       /* make sure that this section is of the right size too */
1373       old_sofar = sofar;
1374       sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1375       current->_raw_size += sofar - old_sofar;
1376 #endif
1377
1378 #ifdef _LIB
1379       /* Force .lib sections to start at zero.  The vma is then
1380          incremented in coff_set_section_contents.  This is right for
1381          SVR3.2.  */
1382       if (strcmp (current->name, _LIB) == 0)
1383         bfd_set_section_vma (abfd, current, 0);
1384 #endif
1385
1386       previous = current;
1387     }
1388   obj_relocbase (abfd) = sofar;
1389 }
1390
1391 #ifndef RS6000COFF_C
1392
1393 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1394 /* @@ Should we only be adding missing symbols, or overriding the aux
1395    values for existing section symbols?  */
1396 static boolean
1397 coff_add_missing_symbols (abfd)
1398      bfd *abfd;
1399 {
1400   unsigned int nsyms = bfd_get_symcount (abfd);
1401   asymbol **sympp = abfd->outsymbols;
1402   asymbol **sympp2;
1403   unsigned int i;
1404   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1405
1406   for (i = 0; i < nsyms; i++)
1407     {
1408       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1409       CONST char *name;
1410       if (csym)
1411         {
1412           /* only do this if there is a coff representation of the input
1413            symbol */
1414           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1415             {
1416               need_file = 0;
1417               continue;
1418             }
1419           name = csym->symbol.name;
1420           if (!name)
1421             continue;
1422           if (!strcmp (name, _TEXT))
1423             need_text = 0;
1424 #ifdef APOLLO_M68
1425           else if (!strcmp (name, ".wtext"))
1426             need_text = 0;
1427 #endif
1428           else if (!strcmp (name, _DATA))
1429             need_data = 0;
1430           else if (!strcmp (name, _BSS))
1431             need_bss = 0;
1432         }
1433     }
1434   /* Now i == bfd_get_symcount (abfd).  */
1435   /* @@ For now, don't deal with .file symbol.  */
1436   need_file = 0;
1437
1438   if (!need_text && !need_data && !need_bss && !need_file)
1439     return true;
1440   nsyms += need_text + need_data + need_bss + need_file;
1441   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1442   if (!sympp2)
1443     {
1444       bfd_set_error (bfd_error_no_memory);
1445       return false;
1446     }
1447   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1448   if (need_file)
1449     {
1450       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1451       abort ();
1452     }
1453   if (need_text)
1454     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1455   if (need_data)
1456     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1457   if (need_bss)
1458     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1459   BFD_ASSERT (i == nsyms);
1460   bfd_set_symtab (abfd, sympp2, nsyms);
1461   return true;
1462 }
1463
1464 #endif /* ! defined (RS6000COFF_C) */
1465
1466 /* SUPPRESS 558 */
1467 /* SUPPRESS 529 */
1468 static boolean
1469 coff_write_object_contents (abfd)
1470      bfd * abfd;
1471 {
1472   asection *current;
1473   unsigned int count;
1474
1475   boolean hasrelocs = false;
1476   boolean haslinno = false;
1477   file_ptr reloc_base;
1478   file_ptr lineno_base;
1479   file_ptr sym_base;
1480   file_ptr scn_base;
1481   file_ptr data_base;
1482   unsigned long reloc_size = 0;
1483   unsigned long lnno_size = 0;
1484   asection *text_sec = NULL;
1485   asection *data_sec = NULL;
1486   asection *bss_sec = NULL;
1487
1488   struct internal_filehdr internal_f;
1489   struct internal_aouthdr internal_a;
1490
1491
1492   bfd_set_error (bfd_error_system_call);
1493   /* Number the output sections, starting from one on the first section
1494      with a name which doesn't start with a *.
1495      @@ The code doesn't make this check.  Is it supposed to be done,
1496      or isn't it??  */
1497   count = 1;
1498   for (current = abfd->sections; current != (asection *) NULL;
1499        current = current->next)
1500     {
1501       current->target_index = count;
1502       count++;
1503     }
1504
1505   if (abfd->output_has_begun == false)
1506     {
1507       coff_compute_section_file_positions (abfd);
1508     }
1509
1510   if (abfd->sections != (asection *) NULL)
1511     {
1512       scn_base = abfd->sections->filepos;
1513     }
1514   else
1515     {
1516       scn_base = 0;
1517     }
1518   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
1519     return false;
1520   reloc_base = obj_relocbase (abfd);
1521
1522   /* Make a pass through the symbol table to count line number entries and
1523      put them into the correct asections */
1524
1525   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
1526   data_base = scn_base;
1527
1528   /* Work out the size of the reloc and linno areas */
1529
1530   for (current = abfd->sections; current != NULL; current =
1531        current->next)
1532     {
1533       /* We give section headers to +ve indexes */
1534       if (current->target_index > 0)
1535         {
1536
1537           reloc_size += current->reloc_count * RELSZ;
1538           data_base += SCNHSZ;
1539         }
1540
1541     }
1542
1543   lineno_base = reloc_base + reloc_size;
1544   sym_base = lineno_base + lnno_size;
1545
1546   /* Indicate in each section->line_filepos its actual file address */
1547   for (current = abfd->sections; current != NULL; current =
1548        current->next)
1549     {
1550       if (current->target_index > 0)
1551         {
1552
1553           if (current->lineno_count)
1554             {
1555               current->line_filepos = lineno_base;
1556               current->moving_line_filepos = lineno_base;
1557               lineno_base += current->lineno_count * LINESZ;
1558             }
1559           else
1560             {
1561               current->line_filepos = 0;
1562             }
1563           if (current->reloc_count)
1564             {
1565               current->rel_filepos = reloc_base;
1566               reloc_base += current->reloc_count * RELSZ;
1567             }
1568           else
1569             {
1570               current->rel_filepos = 0;
1571             }
1572         }
1573     }
1574
1575
1576
1577   /* Write section headers to the file.  */
1578   internal_f.f_nscns = 0;
1579   if (bfd_seek (abfd,
1580                 (file_ptr) ((abfd->flags & EXEC_P) ?
1581                             (FILHSZ + AOUTSZ) : FILHSZ),
1582                 SEEK_SET)
1583       != 0)
1584     return false;
1585
1586   {
1587 #if 0
1588     unsigned int pad = abfd->flags & D_PAGED ? data_base : 0;
1589 #endif
1590     unsigned int pad = 0;
1591
1592     for (current = abfd->sections;
1593          current != NULL;
1594          current = current->next)
1595       {
1596         struct internal_scnhdr section;
1597         if (current->target_index > 0)
1598           {
1599             internal_f.f_nscns++;
1600             strncpy (&(section.s_name[0]), current->name, 8);
1601 #ifdef _LIB
1602             /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
1603            Ian Taylor <[email protected]>.  */
1604             if (strcmp (current->name, _LIB) == 0)
1605               section.s_vaddr = 0;
1606             else
1607 #endif
1608               section.s_vaddr = current->lma + pad;
1609             section.s_paddr = current->lma + pad;
1610             section.s_size = current->_raw_size - pad;
1611             /*
1612           If this section has no size or is unloadable then the scnptr
1613           will be 0 too
1614           */
1615             if (current->_raw_size - pad == 0 ||
1616                 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1617               {
1618                 section.s_scnptr = 0;
1619               }
1620             else
1621               {
1622                 section.s_scnptr = current->filepos;
1623               }
1624             section.s_relptr = current->rel_filepos;
1625             section.s_lnnoptr = current->line_filepos;
1626             section.s_nreloc = current->reloc_count;
1627             section.s_nlnno = current->lineno_count;
1628             if (current->reloc_count != 0)
1629               hasrelocs = true;
1630             if (current->lineno_count != 0)
1631               haslinno = true;
1632
1633             section.s_flags = sec_to_styp_flags (current->name, current->flags);
1634
1635             if (!strcmp (current->name, _TEXT))
1636               {
1637                 text_sec = current;
1638               }
1639             else if (!strcmp (current->name, _DATA))
1640               {
1641                 data_sec = current;
1642 #ifdef TWO_DATA_SECS
1643               }
1644             else if (!strcmp (current->name, ".data2"))
1645               {
1646                 data_sec = current;
1647 #endif /* TWO_DATA_SECS */
1648               }
1649             else if (!strcmp (current->name, _BSS))
1650               {
1651                 bss_sec = current;
1652               }
1653
1654 #ifdef I960
1655             section.s_align = (current->alignment_power
1656                                ? 1 << current->alignment_power
1657                                : 0);
1658
1659 #endif
1660             {
1661               SCNHDR buff;
1662
1663               coff_swap_scnhdr_out (abfd, &section, &buff);
1664               if (bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
1665                 return false;
1666
1667             }
1668
1669             pad = 0;
1670           }
1671       }
1672   }
1673
1674
1675   /* OK, now set up the filehdr... */
1676
1677   /* Don't include the internal abs section in the section count */
1678
1679   /*
1680     We will NOT put a fucking timestamp in the header here. Every time you
1681     put it back, I will come in and take it out again.  I'm sorry.  This
1682     field does not belong here.  We fill it with a 0 so it compares the
1683     same but is not a reasonable time. -- [email protected]
1684     */
1685   internal_f.f_timdat = 0;
1686
1687   if (bfd_get_symcount (abfd) != 0)
1688     internal_f.f_symptr = sym_base;
1689   else
1690     internal_f.f_symptr = 0;
1691
1692   internal_f.f_flags = 0;
1693
1694   if (abfd->flags & EXEC_P)
1695     internal_f.f_opthdr = AOUTSZ;
1696   else
1697     internal_f.f_opthdr = 0;
1698
1699   if (!hasrelocs)
1700     internal_f.f_flags |= F_RELFLG;
1701   if (!haslinno)
1702     internal_f.f_flags |= F_LNNO;
1703   if (0 == bfd_get_symcount (abfd))
1704     internal_f.f_flags |= F_LSYMS;
1705   if (abfd->flags & EXEC_P)
1706     internal_f.f_flags |= F_EXEC;
1707
1708   if (!abfd->xvec->byteorder_big_p)
1709     internal_f.f_flags |= F_AR32WR;
1710   else
1711     internal_f.f_flags |= F_AR32W;
1712
1713   /*
1714     FIXME, should do something about the other byte orders and
1715     architectures.
1716     */
1717
1718   memset (&internal_a, 0, sizeof internal_a);
1719
1720   /* Set up architecture-dependent stuff */
1721
1722   {
1723     unsigned int magic = 0;
1724     unsigned short flags = 0;
1725     coff_set_flags (abfd, &magic, &flags);
1726     internal_f.f_magic = magic;
1727     internal_f.f_flags |= flags;
1728     /* ...and the "opt"hdr... */
1729
1730 #ifdef A29K
1731 #ifdef ULTRA3                   /* NYU's machine */
1732     /* FIXME: This is a bogus check.  I really want to see if there
1733    * is a .shbss or a .shdata section, if so then set the magic
1734    * number to indicate a shared data executable.
1735    */
1736     if (internal_f.f_nscns >= 7)
1737       internal_a.magic = SHMAGIC;       /* Shared magic */
1738     else
1739 #endif /* ULTRA3 */
1740       internal_a.magic = NMAGIC;/* Assume separate i/d */
1741 #define __A_MAGIC_SET__
1742 #endif /* A29K */
1743 #ifdef I960
1744     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
1745 #define __A_MAGIC_SET__
1746 #endif /* I960 */
1747 #if M88
1748 #define __A_MAGIC_SET__
1749     internal_a.magic = PAGEMAGICBCS;
1750 #endif /* M88 */
1751
1752 #if APOLLO_M68
1753 #define __A_MAGIC_SET__
1754     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
1755 #endif
1756
1757 #if M68 || WE32K
1758 #define __A_MAGIC_SET__
1759     /* Never was anything here for the 68k */
1760 #endif /* M68 || WE32K */
1761
1762 #if I386
1763 #define __A_MAGIC_SET__
1764     internal_a.magic = ZMAGIC;
1765 #endif /* I386 */
1766
1767 #if RS6000COFF_C
1768 #define __A_MAGIC_SET__
1769     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
1770       (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
1771       RS6K_AOUTHDR_OMAGIC;
1772 #endif
1773
1774 #ifndef __A_MAGIC_SET__
1775 #include "Your aouthdr magic number is not being set!"
1776 #else
1777 #undef __A_MAGIC_SET__
1778 #endif
1779   }
1780   /* Now should write relocs, strings, syms */
1781   obj_sym_filepos (abfd) = sym_base;
1782
1783   if (bfd_get_symcount (abfd) != 0)
1784     {
1785 #ifndef RS6000COFF_C
1786       if (!coff_add_missing_symbols (abfd))
1787         return false;
1788 #endif
1789       if (!coff_renumber_symbols (abfd))
1790         return false;
1791       coff_mangle_symbols (abfd);
1792       if (! coff_write_symbols (abfd))
1793         return false;
1794       if (! coff_write_linenumbers (abfd))
1795         return false;
1796       if (! coff_write_relocs (abfd))
1797         return false;
1798     }
1799   if (text_sec)
1800     {
1801       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
1802       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
1803     }
1804   if (data_sec)
1805     {
1806       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
1807       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
1808     }
1809   if (bss_sec)
1810     {
1811       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
1812     }
1813
1814   internal_a.entry = bfd_get_start_address (abfd);
1815   internal_f.f_nsyms = bfd_get_symcount (abfd);
1816
1817   /* now write them */
1818   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1819     return false;
1820   {
1821     FILHDR buff;
1822     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
1823     if (bfd_write ((PTR) & buff, 1, FILHSZ, abfd) != FILHSZ)
1824       return false;
1825   }
1826   if (abfd->flags & EXEC_P)
1827     {
1828       AOUTHDR buff;
1829       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
1830       if (bfd_write ((PTR) & buff, 1, AOUTSZ, abfd) != AOUTSZ)
1831         return false;
1832     }
1833   return true;
1834 }
1835
1836 static boolean
1837 coff_set_section_contents (abfd, section, location, offset, count)
1838      bfd * abfd;
1839      sec_ptr section;
1840      PTR location;
1841      file_ptr offset;
1842      bfd_size_type count;
1843 {
1844   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
1845     coff_compute_section_file_positions (abfd);
1846
1847 #ifdef _LIB
1848   /* If this is a .lib section, bump the vma address so that it
1849        winds up being the number of .lib sections output.  This is
1850        right for SVR3.2.  Shared libraries should probably get more
1851        generic support.  Ian Taylor <[email protected]>.  */
1852   if (strcmp (section->name, _LIB) == 0)
1853     ++section->lma;
1854 #endif
1855
1856   /* Don't write out bss sections - one way to do this is to
1857        see if the filepos has not been set. */
1858   if (section->filepos == 0)
1859     return true;
1860
1861   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
1862     return false;
1863
1864   if (count != 0)
1865     {
1866       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
1867     }
1868   return true;
1869 }
1870 #if 0
1871 static boolean
1872 coff_close_and_cleanup (abfd)
1873      bfd *abfd;
1874 {
1875   if (!bfd_read_p (abfd))
1876     switch (abfd->format)
1877       {
1878       case bfd_archive:
1879         if (!_bfd_write_archive_contents (abfd))
1880           return false;
1881         break;
1882       case bfd_object:
1883         if (!coff_write_object_contents (abfd))
1884           return false;
1885         break;
1886       default:
1887         bfd_set_error (bfd_error_invalid_operation);
1888         return false;
1889       }
1890
1891   /* We depend on bfd_close to free all the memory on the obstack.  */
1892   /* FIXME if bfd_release is not using obstacks! */
1893   return true;
1894 }
1895
1896 #endif
1897
1898 static PTR
1899 buy_and_read (abfd, where, seek_direction, size)
1900      bfd *abfd;
1901      file_ptr where;
1902      int seek_direction;
1903      size_t size;
1904 {
1905   PTR area = (PTR) bfd_alloc (abfd, size);
1906   if (!area)
1907     {
1908       bfd_set_error (bfd_error_no_memory);
1909       return (NULL);
1910     }
1911   if (bfd_seek (abfd, where, seek_direction) != 0
1912       || bfd_read (area, 1, size, abfd) != size)
1913     return (NULL);
1914   return (area);
1915 }                               /* buy_and_read() */
1916
1917 /*
1918 SUBSUBSECTION
1919         Reading linenumbers
1920
1921         Creating the linenumber table is done by reading in the entire
1922         coff linenumber table, and creating another table for internal use.
1923
1924         A coff linenumber table is structured so that each function
1925         is marked as having a line number of 0. Each line within the
1926         function is an offset from the first line in the function. The
1927         base of the line number information for the table is stored in
1928         the symbol associated with the function.
1929
1930         The information is copied from the external to the internal
1931         table, and each symbol which marks a function is marked by
1932         pointing its...
1933
1934         How does this work ?
1935
1936 */
1937
1938 static boolean
1939 coff_slurp_line_table (abfd, asect)
1940      bfd *abfd;
1941      asection *asect;
1942 {
1943   LINENO *native_lineno;
1944   alent *lineno_cache;
1945
1946   BFD_ASSERT (asect->lineno == (alent *) NULL);
1947
1948   native_lineno = (LINENO *) buy_and_read (abfd,
1949                                            asect->line_filepos,
1950                                            SEEK_SET,
1951                                            (size_t) (LINESZ *
1952                                                      asect->lineno_count));
1953   lineno_cache =
1954     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
1955   if (lineno_cache == NULL)
1956     {
1957       bfd_set_error (bfd_error_no_memory);
1958       return false;
1959     }
1960   else
1961     {
1962       unsigned int counter = 0;
1963       alent *cache_ptr = lineno_cache;
1964       LINENO *src = native_lineno;
1965
1966       while (counter < asect->lineno_count)
1967         {
1968           struct internal_lineno dst;
1969           coff_swap_lineno_in (abfd, src, &dst);
1970           cache_ptr->line_number = dst.l_lnno;
1971
1972           if (cache_ptr->line_number == 0)
1973             {
1974               coff_symbol_type *sym =
1975               (coff_symbol_type *) (dst.l_addr.l_symndx
1976                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
1977               cache_ptr->u.sym = (asymbol *) sym;
1978               sym->lineno = cache_ptr;
1979             }
1980           else
1981             {
1982               cache_ptr->u.offset = dst.l_addr.l_paddr
1983                 - bfd_section_vma (abfd, asect);
1984             }                   /* If no linenumber expect a symbol index */
1985
1986           cache_ptr++;
1987           src++;
1988           counter++;
1989         }
1990       cache_ptr->line_number = 0;
1991
1992     }
1993   asect->lineno = lineno_cache;
1994   /* FIXME, free native_lineno here, or use alloca or something. */
1995   return true;
1996 }
1997
1998 static boolean
1999 coff_slurp_symbol_table (abfd)
2000      bfd * abfd;
2001 {
2002   combined_entry_type *native_symbols;
2003   coff_symbol_type *cached_area;
2004   unsigned int *table_ptr;
2005
2006   unsigned int number_of_symbols = 0;
2007   if (obj_symbols (abfd))
2008     return true;
2009   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
2010     return false;
2011
2012   /* Read in the symbol table */
2013   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
2014     {
2015       return (false);
2016     }                           /* on error */
2017
2018   /* Allocate enough room for all the symbols in cached form */
2019   cached_area =
2020     (coff_symbol_type *)
2021     bfd_alloc (abfd, (size_t) (bfd_get_symcount (abfd) * sizeof (coff_symbol_type)));
2022
2023   if (cached_area == NULL)
2024     {
2025       bfd_set_error (bfd_error_no_memory);
2026       return false;
2027     }                           /* on error */
2028   table_ptr =
2029     (unsigned int *)
2030     bfd_alloc (abfd, (size_t) (bfd_get_symcount (abfd) * sizeof (unsigned int)));
2031
2032   if (table_ptr == NULL)
2033     {
2034       bfd_set_error (bfd_error_no_memory);
2035       return false;
2036     }
2037   else
2038     {
2039       coff_symbol_type *dst = cached_area;
2040       unsigned int last_native_index = bfd_get_symcount (abfd);
2041       unsigned int this_index = 0;
2042       while (this_index < last_native_index)
2043         {
2044           combined_entry_type *src = native_symbols + this_index;
2045           table_ptr[this_index] = number_of_symbols;
2046           dst->symbol.the_bfd = abfd;
2047
2048           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
2049           /* We use the native name field to point to the cached field.  */
2050           src->u.syment._n._n_n._n_zeroes = (long) dst;
2051           dst->symbol.section = coff_section_from_bfd_index (abfd,
2052                                                      src->u.syment.n_scnum);
2053           dst->symbol.flags = 0;
2054           dst->done_lineno = false;
2055
2056           switch (src->u.syment.n_sclass)
2057             {
2058 #ifdef I960
2059             case C_LEAFEXT:
2060 #if 0
2061               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2062               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2063               dst->symbol.flags |= BSF_NOT_AT_END;
2064 #endif
2065               /* Fall through to next case */
2066
2067 #endif
2068
2069             case C_EXT:
2070 #ifdef RS6000COFF_C
2071             case C_HIDEXT:
2072 #endif
2073               if ((src->u.syment.n_scnum) == 0)
2074                 {
2075                   if ((src->u.syment.n_value) == 0)
2076                     {
2077                       dst->symbol.section = &bfd_und_section;
2078                       dst->symbol.value = 0;
2079                     }
2080                   else
2081                     {
2082                       dst->symbol.section = &bfd_com_section;
2083                       dst->symbol.value = (src->u.syment.n_value);
2084                     }
2085                 }
2086               else
2087                 {
2088                   /*
2089             Base the value as an index from the base of the
2090             section
2091             */
2092
2093                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2094                   dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2095
2096                   if (ISFCN ((src->u.syment.n_type)))
2097                     {
2098                       /*
2099               A function ext does not go at the end of a file
2100               */
2101                       dst->symbol.flags |= BSF_NOT_AT_END;
2102                     }
2103                 }
2104
2105 #ifdef RS6000COFF_C
2106               /* If this symbol has a csect aux of type LD, the scnlen field
2107            is actually the index of the containing csect symbol.  We
2108            need to pointerize it.  */
2109               if (src->u.syment.n_numaux > 0)
2110                 {
2111                   combined_entry_type *aux;
2112
2113                   aux = src + src->u.syment.n_numaux - 1;
2114                   if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2115                     {
2116                       aux->u.auxent.x_csect.x_scnlen.p =
2117                         native_symbols + aux->u.auxent.x_csect.x_scnlen.l;
2118                       aux->fix_scnlen = 1;
2119                     }
2120                 }
2121 #endif
2122
2123               break;
2124
2125             case C_STAT:        /* static                        */
2126 #ifdef I960
2127             case C_LEAFSTAT:    /* static leaf procedure        */
2128 #endif
2129             case C_LABEL:       /* label                         */
2130               if (src->u.syment.n_scnum == -2)
2131                 dst->symbol.flags = BSF_DEBUGGING;
2132               else
2133                 dst->symbol.flags = BSF_LOCAL;
2134               /*
2135           Base the value as an index from the base of the section, if
2136           there is one
2137           */
2138               if (dst->symbol.section)
2139                 dst->symbol.value = (src->u.syment.n_value) -
2140                   dst->symbol.section->vma;
2141               else
2142                 dst->symbol.value = (src->u.syment.n_value);
2143               break;
2144
2145             case C_MOS: /* member of structure   */
2146             case C_EOS: /* end of structure              */
2147 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
2148 #ifdef C_GLBLREG
2149             case C_GLBLREG:     /* A29k-specific storage class */
2150 #endif
2151 #endif
2152             case C_REGPARM:     /* register parameter            */
2153             case C_REG: /* register variable             */
2154 #ifdef C_AUTOARG
2155             case C_AUTOARG:     /* 960-specific storage class */
2156 #endif
2157             case C_TPDEF:       /* type definition               */
2158             case C_ARG:
2159             case C_AUTO:        /* automatic variable */
2160             case C_FIELD:       /* bit field */
2161             case C_ENTAG:       /* enumeration tag               */
2162             case C_MOE: /* member of enumeration         */
2163             case C_MOU: /* member of union               */
2164             case C_UNTAG:       /* union tag                     */
2165               dst->symbol.flags = BSF_DEBUGGING;
2166               dst->symbol.value = (src->u.syment.n_value);
2167               break;
2168
2169             case C_FILE:        /* file name                     */
2170             case C_STRTAG:      /* structure tag                 */
2171 #ifdef RS6000COFF_C
2172             case C_BINCL:       /* beginning of include file     */
2173             case C_EINCL:       /* ending of include file        */
2174             case C_GSYM:
2175             case C_LSYM:
2176             case C_PSYM:
2177             case C_RSYM:
2178             case C_RPSYM:
2179             case C_STSYM:
2180             case C_DECL:
2181             case C_ENTRY:
2182             case C_FUN:
2183             case C_ESTAT:
2184 #endif
2185               dst->symbol.flags = BSF_DEBUGGING;
2186               dst->symbol.value = (src->u.syment.n_value);
2187               break;
2188
2189 #ifdef RS6000COFF_C
2190             case C_BSTAT:
2191               dst->symbol.flags = BSF_DEBUGGING;
2192               dst->symbol.value = src->u.syment.n_value;
2193
2194               /* The value is actually a symbol index.  Save a pointer to
2195            the symbol instead of the index.  FIXME: This should use a
2196            union.  */
2197               src->u.syment.n_value =
2198                 (long) (native_symbols + src->u.syment.n_value);
2199               src->fix_value = 1;
2200               break;
2201 #endif
2202
2203             case C_BLOCK:       /* ".bb" or ".eb"                */
2204             case C_FCN: /* ".bf" or ".ef"                */
2205             case C_EFCN:        /* physical end of function      */
2206               dst->symbol.flags = BSF_LOCAL;
2207               /*
2208           Base the value as an index from the base of the section
2209           */
2210               dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
2211               break;
2212
2213             case C_NULL:
2214             case C_EXTDEF:      /* external definition           */
2215             case C_ULABEL:      /* undefined label               */
2216             case C_USTATIC:     /* undefined static              */
2217             case C_LINE:        /* line # reformatted as symbol table entry */
2218             case C_ALIAS:       /* duplicate tag                 */
2219             case C_HIDDEN:      /* ext symbol in dmert public lib */
2220             default:
2221
2222               fprintf (stderr, "Unrecognized storage class %d (assuming debugging)\n  for %s symbol `%s'\n",
2223                        src->u.syment.n_sclass, dst->symbol.section->name,
2224                        dst->symbol.name);
2225 /*      abort();*/
2226               dst->symbol.flags = BSF_DEBUGGING;
2227               dst->symbol.value = (src->u.syment.n_value);
2228               break;
2229             }
2230
2231 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
2232
2233           dst->native = src;
2234
2235           dst->symbol.udata = 0;
2236           dst->lineno = (alent *) NULL;
2237           this_index += (src->u.syment.n_numaux) + 1;
2238           dst++;
2239           number_of_symbols++;
2240         }                       /* walk the native symtab */
2241     }                           /* bfdize the native symtab */
2242
2243   obj_symbols (abfd) = cached_area;
2244   obj_raw_syments (abfd) = native_symbols;
2245
2246   obj_conv_table_size (abfd) = bfd_get_symcount (abfd);
2247   bfd_get_symcount (abfd) = number_of_symbols;
2248   obj_convert (abfd) = table_ptr;
2249   /* Slurp the line tables for each section too */
2250   {
2251     asection *p;
2252     p = abfd->sections;
2253     while (p)
2254       {
2255         coff_slurp_line_table (abfd, p);
2256         p = p->next;
2257       }
2258   }
2259   return true;
2260 }                               /* coff_slurp_symbol_table() */
2261
2262 /*
2263 SUBSUBSECTION
2264         Reading relocations
2265
2266         Coff relocations are easily transformed into the internal BFD form
2267         (@code{arelent}).
2268
2269         Reading a coff relocation table is done in the following stages:
2270
2271         o Read the entire coff relocation table into memory.
2272
2273         o Process each relocation in turn; first swap it from the
2274         external to the internal form.
2275
2276         o Turn the symbol referenced in the relocation's symbol index
2277         into a pointer into the canonical symbol table.
2278         This table is the same as the one returned by a call to
2279         @code{bfd_canonicalize_symtab}. The back end will call that
2280         routine and save the result if a canonicalization hasn't been done.
2281
2282         o The reloc index is turned into a pointer to a howto
2283         structure, in a back end specific way. For instance, the 386
2284         and 960 use the @code{r_type} to directly produce an index
2285         into a howto table vector; the 88k subtracts a number from the
2286         @code{r_type} field and creates an addend field.
2287
2288
2289 */
2290
2291 #ifndef CALC_ADDEND
2292 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
2293   {                                                             \
2294     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
2295     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
2296       coffsym = (obj_symbols (abfd)                             \
2297                  + (cache_ptr->sym_ptr_ptr - symbols));         \
2298     else if (ptr)                                               \
2299       coffsym = coff_symbol_from (abfd, ptr);                   \
2300     if (coffsym != (coff_symbol_type *) NULL                    \
2301         && coffsym->native->u.syment.n_scnum == 0)              \
2302       cache_ptr->addend = 0;                                    \
2303     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
2304              && ptr->section != (asection *) NULL)              \
2305       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
2306     else                                                        \
2307       cache_ptr->addend = 0;                                    \
2308   }
2309 #endif
2310
2311 static boolean
2312 coff_slurp_reloc_table (abfd, asect, symbols)
2313      bfd * abfd;
2314      sec_ptr asect;
2315      asymbol ** symbols;
2316 {
2317   RELOC *native_relocs;
2318   arelent *reloc_cache;
2319   arelent *cache_ptr;
2320
2321   unsigned int idx;
2322
2323   if (asect->relocation)
2324     return true;
2325   if (asect->reloc_count == 0)
2326     return true;
2327   if (asect->flags & SEC_CONSTRUCTOR)
2328     return true;
2329   if (!coff_slurp_symbol_table (abfd))
2330     return false;
2331   native_relocs =
2332     (RELOC *) buy_and_read (abfd,
2333                             asect->rel_filepos,
2334                             SEEK_SET,
2335                             (size_t) (RELSZ *
2336                                       asect->reloc_count));
2337   reloc_cache = (arelent *)
2338     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2339
2340   if (reloc_cache == NULL)
2341     {
2342       bfd_set_error (bfd_error_no_memory);
2343       return false;
2344     }
2345
2346
2347   for (idx = 0; idx < asect->reloc_count; idx++)
2348     {
2349 #ifdef RELOC_PROCESSING
2350       struct internal_reloc dst;
2351       struct external_reloc *src;
2352
2353       cache_ptr = reloc_cache + idx;
2354       src = native_relocs + idx;
2355       bfd_swap_reloc_in (abfd, src, &dst);
2356
2357       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2358 #else
2359       struct internal_reloc dst;
2360       asymbol *ptr;
2361       struct external_reloc *src;
2362
2363       cache_ptr = reloc_cache + idx;
2364       src = native_relocs + idx;
2365
2366       bfd_swap_reloc_in (abfd, src, &dst);
2367
2368
2369       cache_ptr->address = dst.r_vaddr;
2370
2371       if (dst.r_symndx != -1)
2372         {
2373           /* @@ Should never be greater than count of symbols!  */
2374           if (dst.r_symndx >= obj_conv_table_size (abfd))
2375             abort ();
2376           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
2377           ptr = *(cache_ptr->sym_ptr_ptr);
2378         }
2379       else
2380         {
2381           cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
2382           ptr = 0;
2383         }
2384
2385       /* The symbols definitions that we have read in have been
2386          relocated as if their sections started at 0. But the offsets
2387          refering to the symbols in the raw data have not been
2388          modified, so we have to have a negative addend to compensate.
2389
2390          Note that symbols which used to be common must be left alone */
2391
2392       /* Calculate any reloc addend by looking at the symbol */
2393       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
2394
2395       cache_ptr->address -= asect->vma;
2396 /* !!     cache_ptr->section = (asection *) NULL;*/
2397
2398       /* Fill in the cache_ptr->howto field from dst.r_type */
2399       RTYPE2HOWTO (cache_ptr, &dst);
2400 #endif
2401
2402     }
2403
2404   asect->relocation = reloc_cache;
2405   return true;
2406 }
2407
2408
2409 /* This is stupid.  This function should be a boolean predicate.  */
2410 static long
2411 coff_canonicalize_reloc (abfd, section, relptr, symbols)
2412      bfd * abfd;
2413      sec_ptr section;
2414      arelent ** relptr;
2415      asymbol ** symbols;
2416 {
2417   arelent *tblptr = section->relocation;
2418   unsigned int count = 0;
2419
2420
2421   if (section->flags & SEC_CONSTRUCTOR)
2422     {
2423       /* this section has relocs made up by us, they are not in the
2424        file, so take them out of their chain and place them into
2425        the data area provided */
2426       arelent_chain *chain = section->constructor_chain;
2427       for (count = 0; count < section->reloc_count; count++)
2428         {
2429           *relptr++ = &chain->relent;
2430           chain = chain->next;
2431         }
2432
2433     }
2434   else
2435     {
2436       if (! coff_slurp_reloc_table (abfd, section, symbols))
2437         return -1;
2438
2439       tblptr = section->relocation;
2440
2441       for (; count++ < section->reloc_count;)
2442         *relptr++ = tblptr++;
2443
2444
2445     }
2446   *relptr = 0;
2447   return section->reloc_count;
2448 }
2449
2450 #ifdef GNU960
2451 file_ptr
2452 coff_sym_filepos (abfd)
2453      bfd *abfd;
2454 {
2455   return obj_sym_filepos (abfd);
2456 }
2457 #endif
2458
2459 #ifndef coff_reloc16_estimate
2460 #define coff_reloc16_estimate dummy_reloc16_estimate
2461
2462 static int
2463 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
2464      bfd *abfd;
2465      asection *input_section;
2466      arelent *reloc;
2467      unsigned int shrink;
2468      struct bfd_link_info *link_info;
2469 {
2470   abort ();
2471 }
2472
2473 #endif
2474
2475 #ifndef coff_reloc16_extra_cases
2476 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
2477 /* This works even if abort is not declared in any header file.  */
2478 static void
2479 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
2480                            dst_ptr)
2481      bfd *abfd;
2482      struct bfd_link_info *link_info;
2483      struct bfd_link_order *link_order;
2484      arelent *reloc;
2485      bfd_byte *data;
2486      unsigned int *src_ptr;
2487      unsigned int *dst_ptr;
2488 {
2489   fprintf (stderr, "%s\n", reloc->howto->name);
2490   abort ();
2491 }
2492 #endif
2493
2494 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
2495 {
2496   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
2497   coff_swap_aux_out, coff_swap_sym_out,
2498   coff_swap_lineno_out, coff_swap_reloc_out,
2499   coff_swap_filehdr_out, coff_swap_aouthdr_out,
2500   coff_swap_scnhdr_out,
2501   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, LINESZ,
2502 #ifdef COFF_LONG_FILENAMES
2503   true,
2504 #else
2505   false,
2506 #endif
2507   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
2508   coff_bad_format_hook, coff_set_arch_mach_hook, coff_mkobject_hook,
2509   styp_to_sec_flags, coff_make_section_hook, coff_set_alignment_hook,
2510   coff_slurp_symbol_table, symname_in_debug_hook,
2511   coff_reloc16_extra_cases, coff_reloc16_estimate
2512 };
2513
2514 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
2515 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
2516 #define coff_get_section_contents _bfd_generic_get_section_contents
2517
2518 #define coff_bfd_copy_private_section_data \
2519   _bfd_generic_bfd_copy_private_section_data
2520 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
2521
2522 #ifndef coff_bfd_is_local_label
2523 #define coff_bfd_is_local_label bfd_generic_is_local_label
2524 #endif
2525
2526 /* The reloc lookup routine must be supplied by each individual COFF
2527    backend.  */
2528 #ifndef coff_bfd_reloc_type_lookup
2529 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
2530 #endif
2531
2532 #define coff_bfd_get_relocated_section_contents \
2533   bfd_generic_get_relocated_section_contents
2534 #define coff_bfd_relax_section bfd_generic_relax_section
2535 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
2536 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
2537 #define coff_bfd_final_link _bfd_generic_final_link