bfd/coffcode.h

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