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