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                         [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 #ifdef _LIT
 342   }
 343   else if (!strcmp (sec_name, _LIT))
 344   {
 345     stype_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 H8500MAGIC
 925   case H8500MAGIC:
 926     arch = bfd_arch_h8500;
 927     machine = 0;
 928     break;
 929 #endif
 930
 931   default:                      /* Unreadable input file type */
 932     arch = bfd_arch_obscure;
 933 break;
 934   }
 935
 936   bfd_default_set_arch_mach(abfd, arch, machine);
 937   return true;
 938 }
 939
 940 #ifdef SYMNAME_IN_DEBUG
 941
 942 static boolean
 943 DEFUN (symname_in_debug_hook, (abfd, sym),
 944        bfd *abfd AND
 945        struct internal_syment *sym)
 946 {
 947   return SYMNAME_IN_DEBUG (sym) ? true : false;
 948 }
 949
 950 #else
 951
 952 #define symname_in_debug_hook \
 953   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
 954
 955 #endif
 956
 957 /*
 958 SUBSUBSECTION
 959         Writing Relocations
 960
 961         To write relocations, all the back end does is step though the
 962         canonical relocation table, and create an
 963         @code{internal_reloc}. The symbol index to use is removed from
 964         the @code{offset} field in the symbol table supplied, the
 965         address comes directly from the sum of the section base
 966         address and the relocation offset and the type is dug directly
 967         from the howto field.  Then the @code{internal_reloc} is
 968         swapped into the shape of an @code{external_reloc} and written
 969         out to disk.
 970
 971 */
 972
 973 static void
 974 DEFUN(coff_write_relocs,(abfd),
 975       bfd            *abfd)
 976 {
 977   asection       *s;
 978   for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
 979     unsigned int    i;
 980     struct external_reloc dst;
 981
 982     arelent       **p = s->orelocation;
 983     bfd_seek(abfd, s->rel_filepos, SEEK_SET);
 984     for (i = 0; i < s->reloc_count; i++) {
 985       struct internal_reloc    n;
 986       arelent        *q = p[i];
 987       memset((PTR)&n, 0, sizeof(n));
 988
 989       n.r_vaddr = q->address + s->vma;
 990       /* The 29k const/consth reloc pair is a real kludge - the consth
 991          part doesn't have a symbol - it has an offset. So rebuilt
 992          that here */
 993 #ifdef R_IHCONST
 994       if (q->howto->type == R_IHCONST)
 995         n.r_symndx = q->addend;
 996       else
 997 #endif
 998
 999
1000       if (q->sym_ptr_ptr)
1001       {
1002         if (q->sym_ptr_ptr == bfd_abs_section.symbol_ptr_ptr)
1003         {
1004           /* This is a relocation relative to the absolute symbol */
1005           n.r_symndx = -1;
1006         }
1007         else
1008         {
1009           n.r_symndx = get_index((*(q->sym_ptr_ptr)));
1010           /* Take notice if the symbol reloc points to a symbol we don't have
1011              in our symbol table.  What should we do for this??  */
1012           if (n.r_symndx > obj_conv_table_size (abfd))
1013            abort ();
1014         }
1015
1016
1017       }
1018
1019 #ifdef SELECT_RELOC
1020       /* Work out reloc type from what is required */
1021       SELECT_RELOC(n.r_type, q->howto);
1022 #else
1023       n.r_type = q->howto->type;
1024 #endif
1025       coff_swap_reloc_out(abfd, &n, &dst);
1026       bfd_write((PTR) &dst, 1, RELSZ, abfd);
1027     }
1028   }
1029 }
1030
1031 /* Set flags and magic number of a coff file from architecture and machine
1032    type.  Result is true if we can represent the arch&type, false if not.  */
1033
1034 static          boolean
1035 DEFUN(coff_set_flags,(abfd, magicp, flagsp),
1036       bfd            *abfd AND
1037       unsigned       *magicp AND
1038       unsigned short *flagsp)
1039 {
1040   switch (bfd_get_arch(abfd)) {
1041 #ifdef Z8KMAGIC
1042    case bfd_arch_z8k:
1043     *magicp = Z8KMAGIC;
1044     switch (bfd_get_mach(abfd))
1045     {
1046      case bfd_mach_z8001:
1047       *flagsp = F_Z8001;
1048       break;
1049      case bfd_mach_z8002:
1050       *flagsp = F_Z8002;
1051       break;
1052      default:
1053       return false;
1054     }
1055     return true;
1056 #endif
1057 #ifdef I960ROMAGIC
1058
1059     case bfd_arch_i960:
1060
1061       {
1062         unsigned        flags;
1063         *magicp = I960ROMAGIC;
1064         /*
1065           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1066           I960RWMAGIC);   FIXME???
1067           */
1068         switch (bfd_get_mach(abfd)) {
1069         case bfd_mach_i960_core:
1070           flags = F_I960CORE;
1071           break;
1072         case bfd_mach_i960_kb_sb:
1073           flags = F_I960KB;
1074           break;
1075         case bfd_mach_i960_mc:
1076           flags = F_I960MC;
1077           break;
1078         case bfd_mach_i960_xa:
1079           flags = F_I960XA;
1080           break;
1081         case bfd_mach_i960_ca:
1082           flags = F_I960CA;
1083           break;
1084         case bfd_mach_i960_ka_sa:
1085           flags = F_I960KA;
1086           break;
1087         default:
1088           return false;
1089         }
1090         *flagsp = flags;
1091         return true;
1092       }
1093     break;
1094 #endif
1095 #ifdef I386MAGIC
1096   case bfd_arch_i386:
1097     *magicp = I386MAGIC;
1098     return true;
1099     break;
1100 #endif
1101 #ifdef MC68MAGIC
1102   case bfd_arch_m68k:
1103     *magicp = MC68MAGIC;
1104     return true;
1105     break;
1106 #endif
1107
1108 #ifdef MC88MAGIC
1109     case bfd_arch_m88k:
1110       *magicp = MC88OMAGIC;
1111       return true;
1112       break;
1113 #endif
1114 #ifdef H8300MAGIC
1115     case bfd_arch_h8300:
1116       *magicp = H8300MAGIC;
1117       return true;
1118       break;
1119 #endif
1120 #ifdef H8500MAGIC
1121     case bfd_arch_h8500:
1122       *magicp = H8500MAGIC;
1123       return true;
1124       break;
1125 #endif
1126 #ifdef A29K_MAGIC_BIG
1127     case bfd_arch_a29k:
1128       if (abfd->xvec->byteorder_big_p)
1129        *magicp = A29K_MAGIC_BIG;
1130       else
1131        *magicp = A29K_MAGIC_LITTLE;
1132       return true;
1133       break;
1134 #endif
1135
1136 #ifdef WE32KMAGIC
1137   case bfd_arch_we32k:
1138     *magicp = WE32KMAGIC;
1139     return true;
1140     break;
1141 #endif
1142
1143 #ifdef U802TOCMAGIC
1144   case bfd_arch_rs6000:
1145     *magicp = U802TOCMAGIC;
1146     return true;
1147     break;
1148 #endif
1149
1150   default:                      /* Unknown architecture */
1151     /* return false;  -- fall through to "return false" below, to avoid
1152        "statement never reached" errors on the one below. */
1153     break;
1154   }
1155
1156   return false;
1157 }
1158
1159
1160 static          boolean
1161 DEFUN(coff_set_arch_mach,(abfd, arch, machine),
1162       bfd            *abfd AND
1163       enum bfd_architecture arch AND
1164       unsigned long   machine)
1165 {
1166   unsigned        dummy1;
1167   unsigned     short dummy2;
1168   bfd_default_set_arch_mach(abfd, arch, machine);
1169
1170   if (arch != bfd_arch_unknown &&
1171       coff_set_flags(abfd, &dummy1, &dummy2) != true)
1172     return false;               /* We can't represent this type */
1173   return true;                  /* We're easy ... */
1174 }
1175
1176
1177 /* Calculate the file position for each section. */
1178
1179 static void
1180 DEFUN(coff_compute_section_file_positions,(abfd),
1181       bfd            *abfd)
1182 {
1183   asection       *current;
1184   asection      *previous = (asection *)NULL;
1185   file_ptr        sofar = FILHSZ;
1186 #ifndef I960
1187   file_ptr      old_sofar;
1188 #endif
1189   if (bfd_get_start_address(abfd))
1190   {
1191     /*  A start address may have been added to the original file. In this
1192         case it will need an optional header to record it.  */
1193     abfd->flags |= EXEC_P;
1194   }
1195
1196   if (abfd->flags & EXEC_P)
1197    sofar += AOUTSZ;
1198
1199   sofar += abfd->section_count * SCNHSZ;
1200   for (current = abfd->sections;
1201        current != (asection *)NULL;
1202        current = current->next) {
1203
1204       /* Only deal with sections which have contents */
1205       if (!(current->flags & SEC_HAS_CONTENTS))
1206        continue;
1207
1208       /* Align the sections in the file to the same boundary on
1209          which they are aligned in virtual memory.  I960 doesn't
1210          do this (FIXME) so we can stay in sync with Intel.  960
1211          doesn't yet page from files... */
1212 #ifndef I960
1213     {
1214       /* make sure this section is aligned on the right boundary - by
1215          padding the previous section up if necessary */
1216
1217       old_sofar= sofar;
1218       sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
1219       if (previous != (asection *)NULL) {
1220           previous->_raw_size += sofar - old_sofar;
1221         }
1222     }
1223
1224 #endif
1225       /* FIXME, in demand paged files, the low order bits of the file
1226          offset must match the low order bits of the virtual address.
1227          "Low order" is apparently implementation defined.  Add code
1228          here to round sofar up to match the virtual address.  */
1229
1230       current->filepos = sofar;
1231
1232       sofar += current->_raw_size;
1233 #ifndef I960
1234       /* make sure that this section is of the right size too */
1235       old_sofar =  sofar;
1236       sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
1237       current->_raw_size += sofar - old_sofar ;
1238 #endif
1239
1240 #ifdef _LIB
1241       /* Force .lib sections to start at zero.  The vma is then
1242          incremented in coff_set_section_contents.  This is right for
1243          SVR3.2.  */
1244       if (strcmp (current->name, _LIB) == 0)
1245         bfd_set_section_vma (abfd, current, 0);
1246 #endif
1247
1248       previous = current;
1249     }
1250   obj_relocbase(abfd) = sofar;
1251 }
1252
1253 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1254 /* @@ Should we only be adding missing symbols, or overriding the aux
1255    values for existing section symbols?  */
1256 static void
1257 coff_add_missing_symbols (abfd)
1258      bfd *abfd;
1259 {
1260   unsigned int nsyms = bfd_get_symcount (abfd);
1261   asymbol **sympp = abfd->outsymbols;
1262   asymbol **sympp2;
1263   unsigned int i;
1264   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1265
1266   for (i = 0; i < nsyms; i++)
1267     {
1268       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1269       CONST char *name;
1270       if (csym)
1271       {
1272         /* only do this if there is a coff representation of the input
1273            symbol */
1274         if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1275         {
1276           need_file = 0;
1277           continue;
1278         }
1279         name = csym->symbol.name;
1280         if (!name)
1281          continue;
1282         if (!strcmp (name, _TEXT))
1283          need_text = 0;
1284         else if (!strcmp (name, _DATA))
1285          need_data = 0;
1286         else if (!strcmp (name, _BSS))
1287          need_bss = 0;
1288       }
1289     }
1290   /* Now i == bfd_get_symcount (abfd).  */
1291   /* @@ For now, don't deal with .file symbol.  */
1292   need_file = 0;
1293
1294   if (!need_text && !need_data && !need_bss && !need_file)
1295     return;
1296   nsyms += need_text + need_data + need_bss + need_file;
1297   sympp2 = (asymbol**) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1298   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1299   if (need_file)
1300     {
1301       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1302       abort ();
1303     }
1304   if (need_text)
1305     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1306   if (need_data)
1307     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1308   if (need_bss)
1309     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1310   BFD_ASSERT (i == nsyms);
1311   bfd_set_symtab (abfd, sympp2, nsyms);
1312 }
1313
1314 /* SUPPRESS 558 */
1315 /* SUPPRESS 529 */
1316 static          boolean
1317 DEFUN(coff_write_object_contents,(abfd),
1318       bfd            *abfd)
1319 {
1320   asection       *current;
1321   unsigned int count;
1322
1323   boolean         hasrelocs = false;
1324   boolean         haslinno = false;
1325   file_ptr        reloc_base;
1326   file_ptr        lineno_base;
1327   file_ptr        sym_base;
1328   file_ptr        scn_base;
1329   file_ptr        data_base;
1330   unsigned long   reloc_size = 0;
1331   unsigned long   lnno_size = 0;
1332   asection       *text_sec = NULL;
1333   asection       *data_sec = NULL;
1334   asection       *bss_sec = NULL;
1335
1336   struct internal_filehdr internal_f;
1337   struct internal_aouthdr internal_a;
1338
1339
1340   bfd_error = system_call_error;
1341   /* Number the output sections, starting from one on the first section
1342      with a name which doesn't start with a *.
1343      @@ The code doesn't make this check.  Is it supposed to be done,
1344      or isn't it??  */
1345   count = 1;
1346   for (current = abfd->sections; current != (asection *)NULL;
1347        current = current->next)
1348   {
1349       current->target_index = count;
1350       count++;
1351   }
1352
1353   if(abfd->output_has_begun == false) {
1354       coff_compute_section_file_positions(abfd);
1355     }
1356
1357   if (abfd->sections != (asection *)NULL) {
1358       scn_base = abfd->sections->filepos;
1359     }
1360   else {
1361       scn_base = 0;
1362     }
1363   if (bfd_seek(abfd, scn_base, SEEK_SET) != 0)
1364    return false;
1365   reloc_base = obj_relocbase(abfd);
1366
1367   /* Make a pass through the symbol table to count line number entries and
1368      put them into the correct asections */
1369
1370   lnno_size =  coff_count_linenumbers(abfd) * LINESZ;
1371   data_base = scn_base;
1372
1373   /* Work out the size of the reloc and linno areas */
1374
1375   for (current = abfd->sections; current != NULL; current =
1376        current->next)
1377   {
1378     /* We give section headers to +ve indexes */
1379     if (current->target_index > 0)
1380     {
1381
1382       reloc_size += current->reloc_count * RELSZ;
1383       data_base += SCNHSZ;
1384     }
1385
1386   }
1387
1388   lineno_base = reloc_base + reloc_size;
1389   sym_base = lineno_base + lnno_size;
1390
1391   /* Indicate in each section->line_filepos its actual file address */
1392   for (current = abfd->sections; current != NULL; current =
1393        current->next)
1394   {
1395     if (current->target_index > 0)
1396     {
1397
1398       if (current->lineno_count) {
1399           current->line_filepos = lineno_base;
1400           current->moving_line_filepos = lineno_base;
1401           lineno_base += current->lineno_count * LINESZ;
1402         }
1403       else {
1404           current->line_filepos = 0;
1405         }
1406       if (current->reloc_count) {
1407           current->rel_filepos = reloc_base;
1408           reloc_base += current->reloc_count * RELSZ;
1409         }
1410       else {
1411           current->rel_filepos = 0;
1412         }
1413     }
1414   }
1415
1416
1417
1418   /* Write section headers to the file.  */
1419   internal_f.f_nscns = 0;
1420   bfd_seek(abfd,
1421            (file_ptr) ((abfd->flags & EXEC_P) ?
1422                        (FILHSZ + AOUTSZ) : FILHSZ),
1423            SEEK_SET);
1424
1425 {
1426 #if 0
1427   unsigned int    pad = abfd->flags & D_PAGED ? data_base : 0;
1428 #endif
1429   unsigned int    pad = 0;
1430
1431   for (current = abfd->sections;
1432        current != NULL;
1433        current = current->next) {
1434       struct internal_scnhdr section;
1435       if (current->target_index > 0)
1436       {
1437         internal_f.f_nscns ++;
1438         strncpy(&(section.s_name[0]), current->name, 8);
1439 #ifdef _LIB
1440         /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
1441            Ian Taylor <[email protected]>.  */
1442         if (strcmp (current->name, _LIB) == 0)
1443           section.s_vaddr = 0;
1444         else
1445 #endif
1446         section.s_vaddr = current->lma + pad;
1447         section.s_paddr = current->lma + pad;
1448         section.s_size = current->_raw_size - pad;
1449         /*
1450           If this section has no size or is unloadable then the scnptr
1451           will be 0 too
1452           */
1453         if (current->_raw_size - pad == 0 ||
1454             (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) {
1455             section.s_scnptr = 0;
1456           }
1457         else {
1458             section.s_scnptr = current->filepos;
1459           }
1460         section.s_relptr = current->rel_filepos;
1461         section.s_lnnoptr = current->line_filepos;
1462         section.s_nreloc = current->reloc_count;
1463         section.s_nlnno = current->lineno_count;
1464         if (current->reloc_count != 0)
1465          hasrelocs = true;
1466         if (current->lineno_count != 0)
1467          haslinno = true;
1468
1469         section.s_flags = sec_to_styp_flags(current->name,current->flags);
1470
1471         if (!strcmp(current->name, _TEXT)) {
1472             text_sec = current;
1473           } else if (!strcmp(current->name, _DATA)) {
1474               data_sec = current;
1475 #ifdef TWO_DATA_SECS
1476             } else if (!strcmp(current->name, ".data2")) {
1477               data_sec = current;
1478 #endif /* TWO_DATA_SECS */
1479             } else if (!strcmp(current->name, _BSS)) {
1480                 bss_sec = current;
1481               }
1482
1483 #ifdef I960
1484         section.s_align = (current->alignment_power
1485                            ? 1 << current->alignment_power
1486                            : 0);
1487
1488 #endif
1489       {
1490         SCNHDR          buff;
1491
1492         coff_swap_scnhdr_out(abfd, &section, &buff);
1493         bfd_write((PTR) (&buff), 1, SCNHSZ, abfd);
1494
1495       }
1496
1497         pad = 0;
1498       }
1499     }
1500 }
1501
1502
1503   /* OK, now set up the filehdr... */
1504
1505   /* Don't include the internal abs section in the section count */
1506
1507   /*
1508     We will NOT put a fucking timestamp in the header here. Every time you
1509     put it back, I will come in and take it out again.  I'm sorry.  This
1510     field does not belong here.  We fill it with a 0 so it compares the
1511     same but is not a reasonable time. -- [email protected]
1512     */
1513   internal_f.f_timdat = 0;
1514
1515   if (bfd_get_symcount(abfd) != 0)
1516    internal_f.f_symptr = sym_base;
1517   else
1518    internal_f.f_symptr = 0;
1519
1520   internal_f.f_flags = 0;
1521
1522   if (abfd->flags & EXEC_P)
1523    internal_f.f_opthdr = AOUTSZ;
1524   else
1525    internal_f.f_opthdr = 0;
1526
1527   if (!hasrelocs)
1528    internal_f.f_flags |= F_RELFLG;
1529   if (!haslinno)
1530    internal_f.f_flags |= F_LNNO;
1531   if (0 == bfd_get_symcount(abfd))
1532    internal_f.f_flags |= F_LSYMS;
1533   if (abfd->flags & EXEC_P)
1534    internal_f.f_flags |= F_EXEC;
1535
1536   if (!abfd->xvec->byteorder_big_p)
1537    internal_f.f_flags |= F_AR32WR;
1538   else
1539   internal_f.f_flags |= F_AR32W;
1540
1541   /*
1542     FIXME, should do something about the other byte orders and
1543     architectures.
1544     */
1545
1546   /* Set up architecture-dependent stuff */
1547
1548 { unsigned int   magic = 0;
1549   unsigned short    flags = 0;
1550   coff_set_flags(abfd, &magic, &flags);
1551   internal_f.f_magic = magic;
1552   internal_f.f_flags |= flags;
1553   /* ...and the "opt"hdr... */
1554
1555 #ifdef A29K
1556 # ifdef ULTRA3                  /* NYU's machine */
1557   /* FIXME: This is a bogus check.  I really want to see if there
1558    * is a .shbss or a .shdata section, if so then set the magic
1559    * number to indicate a shared data executable.
1560    */
1561   if (internal_f.f_nscns >= 7)
1562    internal_a.magic = SHMAGIC;  /* Shared magic */
1563   else
1564 # endif                         /* ULTRA3 */
1565    internal_a.magic = NMAGIC;   /* Assume separate i/d */
1566 #define __A_MAGIC_SET__
1567 #endif                          /* A29K */
1568 #ifdef I960
1569   internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
1570 #define __A_MAGIC_SET__
1571 #endif                          /* I960 */
1572 #if M88
1573 #define __A_MAGIC_SET__
1574   internal_a.magic = PAGEMAGICBCS;
1575 #endif                          /* M88 */
1576
1577 #if M68 || WE32K
1578 #define __A_MAGIC_SET__
1579   /* Never was anything here for the 68k */
1580 #endif                          /* M68 || WE32K */
1581
1582 #if I386
1583 # define __A_MAGIC_SET__
1584   internal_a.magic = ZMAGIC;
1585 #endif /* I386 */
1586
1587 #if RS6000COFF_C
1588 #define __A_MAGIC_SET__
1589   internal_a.magic = (abfd->flags & D_PAGED)? RS6K_AOUTHDR_ZMAGIC:
1590   (abfd->flags & WP_TEXT)? RS6K_AOUTHDR_NMAGIC:
1591   RS6K_AOUTHDR_OMAGIC;
1592 #endif
1593
1594 #ifndef __A_MAGIC_SET__
1595 # include "Your aouthdr magic number is not being set!"
1596 #else
1597 # undef __A_MAGIC_SET__
1598 #endif
1599 }
1600   /* Now should write relocs, strings, syms */
1601   obj_sym_filepos(abfd) = sym_base;
1602
1603   if (bfd_get_symcount(abfd) != 0) {
1604       coff_add_missing_symbols (abfd);
1605       coff_renumber_symbols(abfd);
1606       coff_mangle_symbols(abfd);
1607       coff_write_symbols(abfd);
1608       coff_write_linenumbers(abfd);
1609       coff_write_relocs(abfd);
1610     }
1611   if (text_sec) {
1612       internal_a.tsize = bfd_get_section_size_before_reloc(text_sec);
1613       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
1614     }
1615   if (data_sec) {
1616       internal_a.dsize = bfd_get_section_size_before_reloc(data_sec);
1617       internal_a.data_start = internal_a.dsize ? data_sec->vma      : 0;
1618     }
1619   if (bss_sec) {
1620       internal_a.bsize = bfd_get_section_size_before_reloc(bss_sec);
1621     }
1622
1623   internal_a.entry = bfd_get_start_address(abfd);
1624   internal_f.f_nsyms =  bfd_get_symcount(abfd);
1625
1626   /* now write them */
1627   if (bfd_seek(abfd, (file_ptr) 0, SEEK_SET) != 0)
1628    return false;
1629 {
1630   FILHDR buff;
1631   coff_swap_filehdr_out(abfd, (PTR)&internal_f, (PTR)&buff);
1632   bfd_write((PTR) &buff, 1, FILHSZ, abfd);
1633 }
1634   if (abfd->flags & EXEC_P) {
1635       AOUTHDR buff;
1636       coff_swap_aouthdr_out(abfd, (PTR)&internal_a, (PTR)&buff);
1637       bfd_write((PTR) &buff, 1, AOUTSZ, abfd);
1638     }
1639   return true;
1640 }
1641
1642 static          boolean
1643 DEFUN(coff_set_section_contents,(abfd, section, location, offset, count),
1644       bfd            *abfd AND
1645       sec_ptr         section AND
1646       PTR             location AND
1647       file_ptr        offset AND
1648       bfd_size_type   count)
1649 {
1650     if (abfd->output_has_begun == false)        /* set by bfd.c handler */
1651         coff_compute_section_file_positions(abfd);
1652
1653 #ifdef _LIB
1654     /* If this is a .lib section, bump the vma address so that it
1655        winds up being the number of .lib sections output.  This is
1656        right for SVR3.2.  Shared libraries should probably get more
1657        generic support.  Ian Taylor <[email protected]>.  */
1658     if (strcmp (section->name, _LIB) == 0)
1659       ++section->lma;
1660 #endif
1661
1662     /* Don't write out bss sections - one way to do this is to
1663        see if the filepos has not been set. */
1664     if (section->filepos == 0)
1665       return true;
1666
1667     bfd_seek(abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
1668
1669     if (count != 0) {
1670         return (bfd_write(location, 1, count, abfd) == count) ? true : false;
1671     }
1672     return true;
1673 }
1674 #if 0
1675 static          boolean
1676 coff_close_and_cleanup(abfd)
1677     bfd            *abfd;
1678 {
1679   if (!bfd_read_p(abfd))
1680     switch (abfd->format) {
1681     case bfd_archive:
1682       if (!_bfd_write_archive_contents(abfd))
1683         return false;
1684       break;
1685     case bfd_object:
1686       if (!coff_write_object_contents(abfd))
1687         return false;
1688       break;
1689     default:
1690       bfd_error = invalid_operation;
1691       return false;
1692     }
1693
1694   /* We depend on bfd_close to free all the memory on the obstack.  */
1695   /* FIXME if bfd_release is not using obstacks! */
1696   return true;
1697 }
1698
1699 #endif
1700
1701 static PTR
1702 buy_and_read(abfd, where, seek_direction, size)
1703     bfd            *abfd;
1704     file_ptr        where;
1705     int             seek_direction;
1706     size_t          size;
1707 {
1708     PTR             area = (PTR) bfd_alloc(abfd, size);
1709     if (!area) {
1710         bfd_error = no_memory;
1711         return (NULL);
1712     }
1713     bfd_seek(abfd, where, seek_direction);
1714     if (bfd_read(area, 1, size, abfd) != size) {
1715         bfd_error = system_call_error;
1716         return (NULL);
1717     }                           /* on error */
1718     return (area);
1719 }                               /* buy_and_read() */
1720
1721 /*
1722 SUBSUBSECTION
1723         Reading Linenumbers
1724
1725         Creating the linenumber table is done by reading in the entire
1726         coff linenumber table, and creating another table for internal use.
1727
1728         A coff line number table is structured so that each function
1729         is marked as having a line number of 0. Each line within the
1730         function is an offset from the first line in the function. The
1731         base of the line number information for the table is stored in
1732         the symbol associated with the function.
1733
1734         The information is copied from the external to the internal
1735         table, and each symbol which marks a function is marked by
1736         pointing its...
1737
1738         How does this work ?
1739
1740 */
1741
1742 static boolean
1743 coff_slurp_line_table(abfd, asect)
1744 bfd            *abfd;
1745 asection       *asect;
1746   {
1747     LINENO  *native_lineno;
1748     alent          *lineno_cache;
1749
1750     BFD_ASSERT(asect->lineno == (alent *) NULL);
1751
1752     native_lineno = (LINENO *) buy_and_read(abfd,
1753                                             asect->line_filepos,
1754                                             SEEK_SET,
1755                                             (size_t) (LINESZ *
1756                                                       asect->lineno_count));
1757     lineno_cache =
1758       (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent)));
1759     if (lineno_cache == NULL) {
1760       bfd_error = no_memory;
1761       return false;
1762     } else {
1763       unsigned int    counter = 0;
1764       alent          *cache_ptr = lineno_cache;
1765       LINENO  *src = native_lineno;
1766
1767       while (counter < asect->lineno_count) {
1768         struct internal_lineno dst;
1769         coff_swap_lineno_in(abfd, src, &dst);
1770         cache_ptr->line_number = dst.l_lnno;
1771
1772         if (cache_ptr->line_number == 0) {
1773           coff_symbol_type *sym =
1774             (coff_symbol_type *) (dst.l_addr.l_symndx
1775                                   + obj_raw_syments(abfd))->u.syment._n._n_n._n_zeroes;
1776           cache_ptr->u.sym = (asymbol *) sym;
1777           sym->lineno = cache_ptr;
1778         }
1779         else {
1780           cache_ptr->u.offset = dst.l_addr.l_paddr
1781             - bfd_section_vma(abfd, asect);
1782         }                               /* If no linenumber expect a symbol index */
1783
1784         cache_ptr++;
1785         src++;
1786         counter++;
1787       }
1788       cache_ptr->line_number = 0;
1789
1790     }
1791     asect->lineno = lineno_cache;
1792     /* FIXME, free native_lineno here, or use alloca or something. */
1793     return true;
1794   }                             /* coff_slurp_line_table() */
1795
1796 static          boolean
1797 DEFUN(coff_slurp_symbol_table,(abfd),
1798       bfd            *abfd)
1799 {
1800   combined_entry_type         *native_symbols;
1801   coff_symbol_type *cached_area;
1802   unsigned int   *table_ptr;
1803
1804   unsigned int    number_of_symbols = 0;
1805   if (obj_symbols(abfd))
1806     return true;
1807   bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
1808
1809   /* Read in the symbol table */
1810   if ((native_symbols = coff_get_normalized_symtab(abfd)) == NULL) {
1811     return (false);
1812   }                             /* on error */
1813
1814   /* Allocate enough room for all the symbols in cached form */
1815   cached_area =
1816     (coff_symbol_type *)
1817       bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type)));
1818
1819   if (cached_area == NULL) {
1820     bfd_error = no_memory;
1821     return false;
1822   }                             /* on error */
1823   table_ptr =
1824     (unsigned int *)
1825       bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int)));
1826
1827   if (table_ptr == NULL) {
1828     bfd_error = no_memory;
1829     return false;
1830   }
1831   else
1832   {
1833     coff_symbol_type *dst = cached_area;
1834     unsigned int    last_native_index = bfd_get_symcount(abfd);
1835     unsigned int    this_index = 0;
1836     while (this_index < last_native_index) {
1837       combined_entry_type         *src = native_symbols + this_index;
1838       table_ptr[this_index] = number_of_symbols;
1839       dst->symbol.the_bfd = abfd;
1840
1841       dst->symbol.name = (char *)(src->u.syment._n._n_n._n_offset);
1842       /*
1843         We use the native name field to point to the cached field
1844         */
1845       src->u.syment._n._n_n._n_zeroes = (int) dst;
1846       dst->symbol.section = coff_section_from_bfd_index(abfd,
1847                                                         src->u.syment.n_scnum);
1848       dst->symbol.flags = 0;
1849       dst->done_lineno = false;
1850
1851       switch (src->u.syment.n_sclass) {
1852 #ifdef I960
1853       case C_LEAFEXT:
1854 #if 0
1855         dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
1856         dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
1857         dst->symbol.flags |= BSF_NOT_AT_END;
1858 #endif
1859         /* Fall through to next case */
1860
1861 #endif
1862
1863       case C_EXT:
1864 #ifdef RS6000COFF_C
1865       case C_HIDEXT:
1866 #endif
1867         if ((src->u.syment.n_scnum) == 0) {
1868           if ((src->u.syment.n_value) == 0) {
1869             dst->symbol.section = &bfd_und_section;
1870             dst->symbol.value= 0;
1871           }
1872           else {
1873             dst->symbol.section = &bfd_com_section;
1874             dst->symbol.value = (src->u.syment.n_value);
1875           }
1876         }
1877         else {
1878           /*
1879             Base the value as an index from the base of the
1880             section
1881             */
1882
1883             dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
1884             dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
1885
1886           if (ISFCN((src->u.syment.n_type))) {
1887             /*
1888               A function ext does not go at the end of a file
1889               */
1890             dst->symbol.flags |= BSF_NOT_AT_END;
1891           }
1892         }
1893
1894
1895         break;
1896
1897       case C_STAT:              /* static                        */
1898 #ifdef I960
1899       case C_LEAFSTAT:          /* static leaf procedure        */
1900 #endif
1901       case C_LABEL:             /* label                         */
1902         if (src->u.syment.n_scnum == -2)
1903           dst->symbol.flags = BSF_DEBUGGING;
1904         else
1905           dst->symbol.flags = BSF_LOCAL;
1906         /*
1907           Base the value as an index from the base of the section, if
1908           there is one
1909           */
1910         if (dst->symbol.section)
1911           dst->symbol.value = (src->u.syment.n_value) -
1912             dst->symbol.section->vma;
1913         else
1914           dst->symbol.value = (src->u.syment.n_value) ;
1915         break;
1916
1917       case C_MOS:               /* member of structure   */
1918       case C_EOS:               /* end of structure              */
1919 #ifdef NOTDEF   /* C_AUTOARG has the same value */
1920 #ifdef C_GLBLREG
1921       case C_GLBLREG:           /* A29k-specific storage class */
1922 #endif
1923 #endif
1924       case C_REGPARM:           /* register parameter            */
1925       case C_REG:               /* register variable             */
1926 #ifdef C_AUTOARG
1927       case C_AUTOARG:           /* 960-specific storage class */
1928 #endif
1929       case C_TPDEF:             /* type definition               */
1930       case C_ARG:
1931       case C_AUTO:              /* automatic variable */
1932       case C_FIELD:             /* bit field */
1933       case C_ENTAG:             /* enumeration tag               */
1934       case C_MOE:               /* member of enumeration         */
1935       case C_MOU:               /* member of union               */
1936       case C_UNTAG:             /* union tag                     */
1937         dst->symbol.flags = BSF_DEBUGGING;
1938         dst->symbol.value = (src->u.syment.n_value);
1939         break;
1940
1941       case C_FILE:              /* file name                     */
1942       case C_STRTAG:            /* structure tag                 */
1943 #ifdef RS6000COFF_C
1944       case C_BINCL:             /* beginning of include file     */
1945       case C_EINCL:             /* ending of include file        */
1946       case C_GSYM:
1947       case C_LSYM:
1948       case C_PSYM:
1949       case C_RSYM:
1950       case C_RPSYM:
1951       case C_STSYM:
1952       case C_DECL:
1953       case C_ENTRY:
1954       case C_FUN:
1955       case C_BSTAT:
1956       case C_ESTAT:
1957 #endif
1958         dst->symbol.flags = BSF_DEBUGGING;
1959         dst->symbol.value = (src->u.syment.n_value);
1960         break;
1961
1962       case C_BLOCK:             /* ".bb" or ".eb"                */
1963       case C_FCN:               /* ".bf" or ".ef"                */
1964       case C_EFCN:              /* physical end of function      */
1965         dst->symbol.flags = BSF_LOCAL;
1966         /*
1967           Base the value as an index from the base of the section
1968           */
1969         dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
1970         break;
1971
1972       case C_NULL:
1973       case C_EXTDEF:            /* external definition           */
1974       case C_ULABEL:            /* undefined label               */
1975       case C_USTATIC:           /* undefined static              */
1976       case C_LINE:              /* line # reformatted as symbol table entry */
1977       case C_ALIAS:             /* duplicate tag                 */
1978       case C_HIDDEN:            /* ext symbol in dmert public lib */
1979       default:
1980
1981         fprintf(stderr,"Unrecognized storage class %d\n",
1982                                 src->u.syment.n_sclass);
1983 /*      abort();*/
1984         dst->symbol.flags = BSF_DEBUGGING;
1985         dst->symbol.value = (src->u.syment.n_value);
1986         break;
1987       }
1988
1989 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
1990
1991       dst->native = src;
1992
1993       dst->symbol.udata = 0;
1994       dst->lineno = (alent *) NULL;
1995       this_index += (src->u.syment.n_numaux) + 1;
1996       dst++;
1997       number_of_symbols++;
1998     }                           /* walk the native symtab */
1999   }                             /* bfdize the native symtab */
2000
2001   obj_symbols(abfd) = cached_area;
2002   obj_raw_syments(abfd) = native_symbols;
2003
2004   obj_conv_table_size (abfd) = bfd_get_symcount (abfd);
2005   bfd_get_symcount(abfd) = number_of_symbols;
2006   obj_convert(abfd) = table_ptr;
2007   /* Slurp the line tables for each section too */
2008     {
2009       asection       *p;
2010       p = abfd->sections;
2011       while (p) {
2012         coff_slurp_line_table(abfd, p);
2013         p = p->next;
2014       }
2015     }
2016   return true;
2017 }                               /* coff_slurp_symbol_table() */
2018
2019 /*
2020 SUBSUBSECTION
2021         Reading Relocations
2022
2023         Coff relocations are easily transformed into the internal BFD form
2024         (@code{arelent}).
2025
2026         Reading a coff relocation table is done in the following stages:
2027
2028         o The entire coff relocation table is read into memory.
2029
2030         o Each relocation is processed in turn, first it is swapped from the
2031         external to the internal form.
2032
2033         o The symbol referenced in the relocation's symbol index is
2034         turned intoa pointer into the canonical symbol table. Note
2035         that this table is the same as the one returned by a call to
2036         @code{bfd_canonicalize_symtab}. The back end will call the
2037         routine and save the result if a canonicalization hasn't been done.
2038
2039         o The reloc index is turned into a pointer to a howto
2040         structure, in a back end specific way. For instance, the 386
2041         and 960 use the @code{r_type} to directly produce an index
2042         into a howto table vector; the 88k subtracts a number from the
2043         @code{r_type} field and creates an addend field.
2044
2045
2046 */
2047
2048 #ifndef CALC_ADDEND
2049 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)        \
2050             if (ptr && bfd_asymbol_bfd(ptr) == abfd             \
2051                 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
2052             {                                           \
2053                 cache_ptr->addend = -(ptr->section->vma + ptr->value);  \
2054             }                                           \
2055             else {                                      \
2056                 cache_ptr->addend = 0;                  \
2057             }
2058 #endif
2059
2060 static          boolean
2061 DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
2062       bfd            *abfd AND
2063       sec_ptr         asect AND
2064       asymbol       **symbols)
2065 {
2066   RELOC   *native_relocs;
2067   arelent        *reloc_cache;
2068   arelent        *cache_ptr;
2069
2070   unsigned int idx;
2071
2072   if (asect->relocation)
2073    return true;
2074   if (asect->reloc_count == 0)
2075    return true;
2076   if (asect->flags & SEC_CONSTRUCTOR)
2077    return true;
2078   if (!coff_slurp_symbol_table(abfd))
2079    return false;
2080   native_relocs =
2081    (RELOC *) buy_and_read(abfd,
2082                           asect->rel_filepos,
2083                           SEEK_SET,
2084                           (size_t) (RELSZ *
2085                                     asect->reloc_count));
2086   reloc_cache = (arelent *)
2087    bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
2088
2089   if (reloc_cache == NULL) {
2090       bfd_error = no_memory;
2091       return false;
2092     }
2093
2094
2095   for (idx = 0; idx < asect->reloc_count; idx ++)
2096   {
2097 #ifdef RELOC_PROCESSING
2098       struct internal_reloc dst;
2099       struct external_reloc  *src;
2100
2101       cache_ptr = reloc_cache + idx;
2102       src = native_relocs + idx;
2103       bfd_swap_reloc_in(abfd, src, &dst);
2104
2105       RELOC_PROCESSING(cache_ptr, &dst, symbols, abfd, asect);
2106 #else
2107       struct internal_reloc dst;
2108       asymbol        *ptr;
2109       struct external_reloc  *src;
2110
2111       cache_ptr = reloc_cache + idx;
2112       src = native_relocs + idx;
2113
2114       bfd_swap_reloc_in(abfd, src, &dst);
2115
2116
2117       cache_ptr->address = dst.r_vaddr;
2118
2119       if (dst.r_symndx != -1)
2120         {
2121           /* @@ Should never be greater than count of symbols!  */
2122           if (dst.r_symndx >= obj_conv_table_size (abfd))
2123             abort ();
2124           cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
2125           ptr = *(cache_ptr->sym_ptr_ptr);
2126         }
2127       else
2128         {
2129           cache_ptr->sym_ptr_ptr= bfd_abs_section.symbol_ptr_ptr;
2130           ptr = 0;
2131         }
2132
2133       /*
2134         The symbols definitions that we have read in have been
2135         relocated as if their sections started at 0. But the offsets
2136         refering to the symbols in the raw data have not been
2137         modified, so we have to have a negative addend to compensate.
2138
2139         Note that symbols which used to be common must be left alone */
2140
2141       /* Calculate any reloc addend by looking at the symbol */
2142       CALC_ADDEND(abfd, ptr, dst, cache_ptr);
2143
2144       cache_ptr->address -= asect->vma;
2145 /* !!     cache_ptr->section = (asection *) NULL;*/
2146
2147       /* Fill in the cache_ptr->howto field from dst.r_type */
2148       RTYPE2HOWTO(cache_ptr, &dst);
2149 #endif
2150
2151   }
2152
2153   asect->relocation = reloc_cache;
2154   return true;
2155 }
2156
2157
2158 /* This is stupid.  This function should be a boolean predicate */
2159 static unsigned int
2160 DEFUN(coff_canonicalize_reloc, (abfd, section, relptr, symbols),
2161 bfd            *abfd AND
2162 sec_ptr         section AND
2163 arelent       **relptr AND
2164 asymbol       **symbols)
2165 {
2166   arelent        *tblptr = section->relocation;
2167   unsigned int    count = 0;
2168
2169
2170   if (section->flags & SEC_CONSTRUCTOR)
2171   {
2172     /* this section has relocs made up by us, they are not in the
2173        file, so take them out of their chain and place them into
2174        the data area provided */
2175     arelent_chain *chain = section->constructor_chain;
2176     for (count = 0; count < section->reloc_count; count ++)
2177     {
2178       *relptr ++ = &chain->relent;
2179       chain = chain->next;
2180     }
2181
2182   }
2183   else
2184   {
2185     coff_slurp_reloc_table(abfd, section, symbols);
2186
2187
2188     tblptr = section->relocation;
2189     if (!tblptr)
2190      return 0;
2191
2192     for (; count++ < section->reloc_count;)
2193      *relptr++ = tblptr++;
2194
2195
2196   }
2197   *relptr = 0;
2198   return section->reloc_count;
2199 }
2200
2201 #ifdef GNU960
2202 file_ptr
2203 coff_sym_filepos(abfd)
2204 bfd *abfd;
2205   {
2206     return obj_sym_filepos(abfd);
2207   }
2208 #endif
2209
2210 #ifndef coff_reloc16_extra_cases
2211 #define coff_reloc16_extra_cases \
2212   (void (*) PARAMS ((bfd *, bfd_seclet_type *, arelent *, bfd_byte *,\
2213                      unsigned int *, unsigned int *))) abort
2214 #endif
2215
2216 static CONST bfd_coff_backend_data bfd_coff_std_swap_table = {
2217  coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
2218  coff_swap_aux_out, coff_swap_sym_out,
2219  coff_swap_lineno_out, coff_swap_reloc_out,
2220  coff_swap_filehdr_out, coff_swap_aouthdr_out,
2221  coff_swap_scnhdr_out,
2222  FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, LINESZ,
2223 #ifdef COFF_LONG_FILENAMES
2224  true,
2225 #else
2226  false,
2227 #endif
2228  coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
2229  coff_bad_format_hook, coff_set_arch_mach_hook, coff_mkobject_hook,
2230  styp_to_sec_flags, coff_make_section_hook, coff_set_alignment_hook,
2231  coff_slurp_symbol_table, symname_in_debug_hook, coff_reloc16_extra_cases
2232 };
2233
2234 #define coff_core_file_failing_command  _bfd_dummy_core_file_failing_command
2235 #define coff_core_file_failing_signal   _bfd_dummy_core_file_failing_signal
2236 #define coff_core_file_matches_executable_p     _bfd_dummy_core_file_matches_executable_p
2237 #define coff_slurp_armap                bfd_slurp_coff_armap
2238 #define coff_slurp_extended_name_table  _bfd_slurp_extended_name_table
2239 #define coff_truncate_arname            bfd_dont_truncate_arname
2240 #define coff_openr_next_archived_file   bfd_generic_openr_next_archived_file
2241 #define coff_generic_stat_arch_elt      bfd_generic_stat_arch_elt
2242 #define coff_get_section_contents       bfd_generic_get_section_contents
2243 #define coff_close_and_cleanup          bfd_generic_close_and_cleanup
2244
2245 #define coff_bfd_debug_info_start       bfd_void
2246 #define coff_bfd_debug_info_end         bfd_void
2247 #define coff_bfd_debug_info_accumulate  \
2248                         (void (*) PARAMS ((bfd *, struct sec *))) bfd_void
2249 #define coff_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
2250 #define coff_bfd_relax_section          bfd_generic_relax_section
2251 #define coff_bfd_seclet_link            bfd_generic_seclet_link
2252 #define coff_bfd_reloc_type_lookup \
2253   ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)