bfd/coffcode.h

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