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