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