bfd/coffcode.h

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