bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 value of this symbol be renumbered.  Used for
 256 .          XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
 257 .unsigned int fix_value : 1;
 258 .
 259 .       {* Should the tag field of this symbol be renumbered.
 260 .          Created by coff_pointerize_aux. *}
 261 .unsigned int fix_tag : 1;
 262 .
 263 .       {* Should the endidx field of this symbol be renumbered.
 264 .          Created by coff_pointerize_aux. *}
 265 .unsigned int fix_end : 1;
 266 .
 267 .       {* Should the x_csect.x_scnlen field be renumbered.
 268 .          Created by coff_slurp_symbol_table. *}
 269 .unsigned int fix_scnlen : 1;
 270 .
 271 .       {* The container for the symbol structure as read and translated
 272 .           from the file. *}
 273 .
 274 .union {
 275 .   union internal_auxent auxent;
 276 .   struct internal_syment syment;
 277 . } u;
 278 .} combined_entry_type;
 279 .
 280 .
 281 .{* Each canonical asymbol really looks like this: *}
 282 .
 283 .typedef struct coff_symbol_struct
 284 .{
 285 .   {* The actual symbol which the rest of BFD works with *}
 286 .asymbol symbol;
 287 .
 288 .   {* A pointer to the hidden information for this symbol *}
 289 .combined_entry_type *native;
 290 .
 291 .   {* A pointer to the linenumber information for this symbol *}
 292 .struct lineno_cache_entry *lineno;
 293 .
 294 .   {* Have the line numbers been relocated yet ? *}
 295 .boolean done_lineno;
 296 .} coff_symbol_type;
 297
 298
 299 */
 300
 301 #ifdef COFF_IMAGE_WITH_PE
 302 #include "peicode.h"
 303 #else
 304 #include "coffswap.h"
 305 #endif
 306
 307 \f
 308 /* void warning(); */
 309
 310 /*
 311  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 312  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 313  * NOTE: If you add to/change this routine, you should mirror the changes
 314  *      in styp_to_sec_flags().
 315  */
 316 static long
 317 sec_to_styp_flags (sec_name, sec_flags)
 318      CONST char *sec_name;
 319      flagword sec_flags;
 320 {
 321   long styp_flags = 0;
 322
 323   if (!strcmp (sec_name, _TEXT))
 324     {
 325       styp_flags = STYP_TEXT;
 326     }
 327   else if (!strcmp (sec_name, _DATA))
 328     {
 329       styp_flags = STYP_DATA;
 330 #ifdef TWO_DATA_SECS
 331     }
 332   else if (!strcmp (sec_name, ".data2"))
 333     {
 334       styp_flags = STYP_DATA;
 335 #endif /* TWO_DATA_SECS */
 336     }
 337   else if (!strcmp (sec_name, _BSS))
 338     {
 339       styp_flags = STYP_BSS;
 340 #ifdef _COMMENT
 341     }
 342   else if (!strcmp (sec_name, _COMMENT))
 343     {
 344       styp_flags = STYP_INFO;
 345 #endif /* _COMMENT */
 346 #ifdef _LIB
 347     }
 348   else if (!strcmp (sec_name, _LIB))
 349     {
 350       styp_flags = STYP_LIB;
 351 #endif /* _LIB */
 352 #ifdef _LIT
 353     }
 354   else if (!strcmp (sec_name, _LIT))
 355     {
 356       styp_flags = STYP_LIT;
 357 #endif /* _LIT */
 358     }
 359   else if (!strcmp (sec_name, ".debug"))
 360     {
 361 #ifdef STYP_DEBUG
 362       styp_flags = STYP_DEBUG;
 363 #else
 364       styp_flags = STYP_INFO;
 365 #endif
 366     }
 367   else if (!strncmp (sec_name, ".stab", 5))
 368     {
 369       styp_flags = STYP_INFO;
 370     }
 371 #ifdef COFF_WITH_PE
 372   else if (!strcmp (sec_name, ".edata"))
 373     {
 374       styp_flags = STYP_DATA;
 375     }
 376 #endif
 377   /* Try and figure out what it should be */
 378   else if (sec_flags & SEC_CODE)
 379     {
 380       styp_flags = STYP_TEXT;
 381     }
 382   else if (sec_flags & SEC_DATA)
 383     {
 384       styp_flags = STYP_DATA;
 385     }
 386   else if (sec_flags & SEC_READONLY)
 387     {
 388 #ifdef STYP_LIT                 /* 29k readonly text/data section */
 389       styp_flags = STYP_LIT;
 390 #else
 391       styp_flags = STYP_TEXT;
 392 #endif /* STYP_LIT */
 393     }
 394   else if (sec_flags & SEC_LOAD)
 395     {
 396       styp_flags = STYP_TEXT;
 397     }
 398   else if (sec_flags & SEC_ALLOC)
 399     {
 400       styp_flags = STYP_BSS;
 401     }
 402
 403 #ifdef STYP_NOLOAD
 404   if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
 405     styp_flags |= STYP_NOLOAD;
 406 #endif
 407
 408   return (styp_flags);
 409 }
 410 /*
 411  * Return a word with SEC_* flags set to represent the incoming
 412  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 413  * function is sec_to_styp_flags().
 414  * NOTE: If you add to/change this routine, you should mirror the changes
 415  *      in sec_to_styp_flags().
 416  */
 417 static flagword
 418 styp_to_sec_flags (abfd, hdr, name)
 419      bfd *abfd;
 420      PTR hdr;
 421      const char *name;
 422 {
 423   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 424   long styp_flags = internal_s->s_flags;
 425   flagword sec_flags = 0;
 426
 427 #ifdef STYP_NOLOAD
 428   if (styp_flags & STYP_NOLOAD)
 429     {
 430       sec_flags |= SEC_NEVER_LOAD;
 431     }
 432 #endif /* STYP_NOLOAD */
 433
 434   /* For 386 COFF, at least, an unloadable text or data section is
 435      actually a shared library section.  */
 436   if (styp_flags & STYP_TEXT)
 437     {
 438       if (sec_flags & SEC_NEVER_LOAD)
 439         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 440       else
 441         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 442     }
 443   else if (styp_flags & STYP_DATA)
 444     {
 445       if (sec_flags & SEC_NEVER_LOAD)
 446         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 447       else
 448         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 449     }
 450   else if (styp_flags & STYP_BSS)
 451     {
 452 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 453       if (sec_flags & SEC_NEVER_LOAD)
 454         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 455       else
 456 #endif
 457         sec_flags |= SEC_ALLOC;
 458     }
 459   else if (styp_flags & STYP_INFO)
 460     {
 461       /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
 462          defined.  coff_compute_section_file_positions uses
 463          COFF_PAGE_SIZE to ensure that the low order bits of the
 464          section VMA and the file offset match.  If we don't know
 465          COFF_PAGE_SIZE, we can't ensure the correct correspondence,
 466          and demand page loading of the file will fail.  */
 467 #ifdef COFF_PAGE_SIZE
 468       sec_flags |= SEC_DEBUGGING;
 469 #endif
 470     }
 471   else if (strcmp (name, _TEXT) == 0)
 472     {
 473       if (sec_flags & SEC_NEVER_LOAD)
 474         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
 475       else
 476         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 477     }
 478   else if (strcmp (name, _DATA) == 0
 479 #ifdef TWO_DATA_SECS
 480            || strcmp (name, ".data2") == 0
 481 #endif
 482            )
 483     {
 484       if (sec_flags & SEC_NEVER_LOAD)
 485         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
 486       else
 487         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 488     }
 489   else if (strcmp (name, _BSS) == 0)
 490     {
 491 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
 492       if (sec_flags & SEC_NEVER_LOAD)
 493         sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
 494       else
 495 #endif
 496         sec_flags |= SEC_ALLOC;
 497     }
 498   else if (strcmp (name, ".debug") == 0
 499 #ifdef _COMMENT
 500            || strcmp (name, _COMMENT) == 0
 501 #endif
 502            || strncmp (name, ".stab", 5) == 0)
 503     {
 504 #ifdef COFF_PAGE_SIZE
 505       sec_flags |= SEC_DEBUGGING;
 506 #endif
 507     }
 508 #ifdef _LIB
 509   else if (strcmp (name, _LIB) == 0)
 510     ;
 511 #endif
 512 #ifdef _LIT
 513   else if (strcmp (name, _LIT) == 0)
 514     {
 515       sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
 516     }
 517 #endif
 518   else
 519     {
 520       sec_flags |= SEC_ALLOC | SEC_LOAD;
 521     }
 522
 523 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 524   if ((styp_flags & STYP_LIT) == STYP_LIT)
 525     {
 526       sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 527     }
 528 #endif /* STYP_LIT */
 529 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 530   if (styp_flags & STYP_OTHER_LOAD)
 531     {
 532       sec_flags = (SEC_LOAD | SEC_ALLOC);
 533     }
 534 #endif /* STYP_SDATA */
 535
 536   return (sec_flags);
 537 }
 538
 539 #define get_index(symbol)       ((symbol)->udata.i)
 540
 541 /*
 542 INTERNAL_DEFINITION
 543         bfd_coff_backend_data
 544
 545 CODE_FRAGMENT
 546
 547 Special entry points for gdb to swap in coff symbol table parts:
 548 .typedef struct
 549 .{
 550 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 551 .       bfd            *abfd,
 552 .       PTR             ext,
 553 .       int             type,
 554 .       int             class,
 555 .       int             indaux,
 556 .       int             numaux,
 557 .       PTR             in));
 558 .
 559 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 560 .       bfd            *abfd ,
 561 .       PTR             ext,
 562 .       PTR             in));
 563 .
 564 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 565 .       bfd            *abfd,
 566 .       PTR            ext,
 567 .       PTR             in));
 568 .
 569
 570 Special entry points for gas to swap out coff parts:
 571
 572 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 573 .       bfd     *abfd,
 574 .       PTR     in,
 575 .       int     type,
 576 .       int     class,
 577 .       int     indaux,
 578 .       int     numaux,
 579 .       PTR     ext));
 580 .
 581 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 582 .      bfd      *abfd,
 583 .      PTR      in,
 584 .      PTR      ext));
 585 .
 586 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 587 .       bfd     *abfd,
 588 .       PTR     in,
 589 .       PTR     ext));
 590 .
 591 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 592 .       bfd     *abfd,
 593 .       PTR     src,
 594 .       PTR     dst));
 595 .
 596 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 597 .       bfd     *abfd,
 598 .       PTR     in,
 599 .       PTR     out));
 600 .
 601 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 602 .       bfd     *abfd,
 603 .       PTR     in,
 604 .       PTR     out));
 605 .
 606 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 607 .       bfd     *abfd,
 608 .       PTR     in,
 609 .       PTR     out));
 610 .
 611
 612 Special entry points for generic COFF routines to call target
 613 dependent COFF routines:
 614
 615 . unsigned int _bfd_filhsz;
 616 . unsigned int _bfd_aoutsz;
 617 . unsigned int _bfd_scnhsz;
 618 . unsigned int _bfd_symesz;
 619 . unsigned int _bfd_auxesz;
 620 . unsigned int _bfd_relsz;
 621 . unsigned int _bfd_linesz;
 622 . boolean _bfd_coff_long_filenames;
 623 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 624 .       bfd     *abfd,
 625 .       PTR     ext,
 626 .       PTR     in));
 627 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 628 .       bfd     *abfd,
 629 .       PTR     ext,
 630 .       PTR     in));
 631 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 632 .       bfd     *abfd,
 633 .       PTR     ext,
 634 .       PTR     in));
 635 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
 636 .       bfd     *abfd,
 637 .       PTR     ext,
 638 .       PTR     in));
 639 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 640 .       bfd     *abfd,
 641 .       PTR     internal_filehdr));
 642 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 643 .       bfd     *abfd,
 644 .       PTR     internal_filehdr));
 645 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 646 .       bfd     *abfd,
 647 .       PTR     internal_filehdr,
 648 .       PTR     internal_aouthdr));
 649 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 650 .       bfd     *abfd,
 651 .       PTR     internal_scnhdr,
 652 .       const char *name));
 653 . asection *(*_bfd_make_section_hook) PARAMS ((
 654 .       bfd     *abfd,
 655 .       char    *name));
 656 . void (*_bfd_set_alignment_hook) PARAMS ((
 657 .       bfd     *abfd,
 658 .       asection *sec,
 659 .       PTR     internal_scnhdr));
 660 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 661 .       bfd     *abfd));
 662 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 663 .       bfd     *abfd,
 664 .       struct internal_syment *sym));
 665 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 666 .       bfd     *abfd,
 667 .       struct bfd_link_info *link_info,
 668 .       struct bfd_link_order *link_order,
 669 .       arelent *reloc,
 670 .       bfd_byte *data,
 671 .       unsigned int *src_ptr,
 672 .       unsigned int *dst_ptr));
 673 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
 674 .       bfd *abfd,
 675 .       asection *input_section,
 676 .       arelent *r,
 677 .       unsigned int shrink,
 678 .       struct bfd_link_info *link_info));
 679 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
 680 .       bfd *abfd,
 681 .       struct internal_syment *));
 682 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
 683 .       bfd *abfd));
 684 . boolean (*_bfd_coff_start_final_link) PARAMS ((
 685 .       bfd *output_bfd,
 686 .       struct bfd_link_info *info));
 687 . boolean (*_bfd_coff_relocate_section) PARAMS ((
 688 .       bfd *output_bfd,
 689 .       struct bfd_link_info *info,
 690 .       bfd *input_bfd,
 691 .       asection *input_section,
 692 .       bfd_byte *contents,
 693 .       struct internal_reloc *relocs,
 694 .       struct internal_syment *syms,
 695 .       asection **sections));
 696 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
 697 .       bfd *abfd,
 698 .       asection *sec,
 699 .       struct internal_reloc *rel,
 700 .       struct coff_link_hash_entry *h,
 701 .       struct internal_syment *sym,
 702 .       bfd_vma *addendp));
 703 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
 704 .       bfd *obfd,
 705 .       struct bfd_link_info *info,
 706 .       bfd *ibfd,
 707 .       asection *sec,
 708 .       struct internal_reloc *reloc,
 709 .       boolean *adjustedp));
 710 .
 711 .} bfd_coff_backend_data;
 712 .
 713 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 714 .
 715 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
 716 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
 717 .
 718 .#define bfd_coff_swap_sym_in(a,e,i) \
 719 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 720 .
 721 .#define bfd_coff_swap_lineno_in(a,e,i) \
 722 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 723 .
 724 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 725 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 726 .
 727 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 728 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 729 .
 730 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
 731 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
 732 .
 733 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 734 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 735 .
 736 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 737 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 738 .
 739 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 740 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 741 .
 742 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 743 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 744 .
 745 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 746 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 747 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 748 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 749 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 750 .#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
 751 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 752 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 753 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 754 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 755 .
 756 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 757 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 758 .
 759 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 760 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 761 .
 762 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
 763 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
 764 .
 765 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 766 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 767 .
 768 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 769 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 770 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
 771 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
 772 .
 773 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
 774 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
 775 .
 776 .#define bfd_coff_make_section_hook(abfd, name)\
 777 .        ((coff_backend_info (abfd)->_bfd_make_section_hook) (abfd, name))
 778 .
 779 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 780 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 781 .
 782 .#define bfd_coff_slurp_symbol_table(abfd)\
 783 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 784 .
 785 .#define bfd_coff_symname_in_debug(abfd, sym)\
 786 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 787 .
 788 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
 789 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 790 .         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
 791 .
 792 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
 793 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 794 .         (abfd, section, reloc, shrink, link_info))
 795 .
 796 .#define bfd_coff_sym_is_global(abfd, sym)\
 797 .        ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
 798 .         (abfd, sym))
 799 .
 800 .#define bfd_coff_compute_section_file_positions(abfd)\
 801 .        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
 802 .         (abfd))
 803 .
 804 .#define bfd_coff_start_final_link(obfd, info)\
 805 .        ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
 806 .         (obfd, info))
 807 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
 808 .        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
 809 .         (obfd, info, ibfd, o, con, rel, isyms, secs))
 810 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
 811 .        ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
 812 .         (abfd, sec, rel, h, sym, addendp))
 813 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
 814 .        ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
 815 .         (obfd, info, ibfd, sec, rel, adjustedp))
 816 .
 817 */
 818
 819 /* See whether the magic number matches.  */
 820
 821 static boolean
 822 coff_bad_format_hook (abfd, filehdr)
 823      bfd * abfd;
 824      PTR filehdr;
 825 {
 826   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 827
 828   if (BADMAG (*internal_f))
 829     return false;
 830
 831   /* if the optional header is NULL or not the correct size then
 832      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
 833      and Intel 960 readwrite headers (I960WRMAGIC) is that the
 834      optional header is of a different size.
 835
 836      But the mips keeps extra stuff in it's opthdr, so dont check
 837      when doing that
 838      */
 839
 840 #if defined(M88) || defined(I960)
 841   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
 842     return false;
 843 #endif
 844
 845   return true;
 846 }
 847
 848 static asection *
 849 coff_make_section_hook (abfd, name)
 850      bfd * abfd;
 851      char *name;
 852 {
 853 #ifdef TWO_DATA_SECS
 854   /* FIXME: This predates the call to bfd_make_section_anyway
 855      in make_a_section_from_file, and can probably go away.  */
 856   /* On SCO a file created by the Microsoft assembler can have two
 857      .data sections.  We use .data2 for the second one.  */
 858   if (strcmp (name, _DATA) == 0)
 859     return bfd_make_section (abfd, ".data2");
 860 #endif
 861   return (asection *) NULL;
 862 }
 863
 864 /*
 865    initialize a section structure with information peculiar to this
 866    particular implementation of coff
 867 */
 868
 869 static boolean
 870 coff_new_section_hook (abfd, section)
 871      bfd * abfd;
 872      asection * section;
 873 {
 874   section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
 875
 876   /* Allocate aux records for section symbols, to store size and
 877      related info.
 878
 879      @@ Shouldn't use constant multiplier here!  */
 880   coffsymbol (section->symbol)->native =
 881     (combined_entry_type *) bfd_zalloc (abfd,
 882                                         sizeof (combined_entry_type) * 10);
 883
 884   /* The .stab section must be aligned to 2**2 at most, because
 885      otherwise there may be gaps in the section which gdb will not
 886      know how to interpret.  Examining the section name is a hack, but
 887      that is also how gdb locates the section.  We also align the
 888      .stabstr section this way for backward compatibility, although I
 889      believe it would work anyhow.  */
 890   if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2
 891       && (strncmp (section->name, ".stab", 5) == 0))
 892     section->alignment_power = 2;
 893
 894   return true;
 895 }
 896
 897 #ifdef I960
 898
 899 /* Set the alignment of a BFD section.  */
 900
 901 static void
 902 coff_set_alignment_hook (abfd, section, scnhdr)
 903      bfd * abfd;
 904      asection * section;
 905      PTR scnhdr;
 906 {
 907   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 908   unsigned int i;
 909
 910   for (i = 0; i < 32; i++)
 911     if ((1 << i) >= hdr->s_align)
 912       break;
 913   section->alignment_power = i;
 914 }
 915
 916 #else /* ! I960 */
 917
 918 #define coff_set_alignment_hook \
 919   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
 920
 921 #endif /* ! I960 */
 922
 923 #ifndef coff_mkobject
 924 static boolean
 925 coff_mkobject (abfd)
 926      bfd * abfd;
 927 {
 928   coff_data_type *coff;
 929
 930   abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
 931   if (abfd->tdata.coff_obj_data == 0)
 932     {
 933       bfd_set_error (bfd_error_no_memory);
 934       return false;
 935     }
 936   coff = coff_data (abfd);
 937   coff->symbols = (coff_symbol_type *) NULL;
 938   coff->conversion_table = (unsigned int *) NULL;
 939   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 940   coff->relocbase = 0;
 941 /*  make_abs_section(abfd);*/
 942
 943   return true;
 944 }
 945 #endif
 946
 947 /* Create the COFF backend specific information.  */
 948 #ifndef coff_mkobject_hook
 949 static PTR
 950 coff_mkobject_hook (abfd, filehdr, aouthdr)
 951      bfd * abfd;
 952      PTR filehdr;
 953      PTR aouthdr;
 954 {
 955   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 956   coff_data_type *coff;
 957
 958   if (coff_mkobject (abfd) == false)
 959     return NULL;
 960
 961   coff = coff_data (abfd);
 962
 963   coff->sym_filepos = internal_f->f_symptr;
 964
 965   /* These members communicate important constants about the symbol
 966      table to GDB's symbol-reading code.  These `constants'
 967      unfortunately vary among coff implementations...  */
 968   coff->local_n_btmask = N_BTMASK;
 969   coff->local_n_btshft = N_BTSHFT;
 970   coff->local_n_tmask = N_TMASK;
 971   coff->local_n_tshift = N_TSHIFT;
 972   coff->local_symesz = SYMESZ;
 973   coff->local_auxesz = AUXESZ;
 974   coff->local_linesz = LINESZ;
 975
 976   obj_raw_syment_count (abfd) =
 977     obj_conv_table_size (abfd) =
 978       internal_f->f_nsyms;
 979
 980   return (PTR) coff;
 981 }
 982 #endif
 983
 984 /* Determine the machine architecture and type.  FIXME: This is target
 985    dependent because the magic numbers are defined in the target
 986    dependent header files.  But there is no particular need for this.
 987    If the magic numbers were moved to a separate file, this function
 988    would be target independent and would also be much more successful
 989    at linking together COFF files for different architectures.  */
 990
 991 static boolean
 992 coff_set_arch_mach_hook (abfd, filehdr)
 993      bfd *abfd;
 994      PTR filehdr;
 995 {
 996   long machine;
 997   enum bfd_architecture arch;
 998   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 999
1000   machine = 0;
1001   switch (internal_f->f_magic)
1002     {
1003 #ifdef I386MAGIC
1004     case I386MAGIC:
1005     case I386PTXMAGIC:
1006     case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1007     case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1008       arch = bfd_arch_i386;
1009       machine = 0;
1010       break;
1011 #endif
1012 #ifdef A29K_MAGIC_BIG
1013     case A29K_MAGIC_BIG:
1014     case A29K_MAGIC_LITTLE:
1015       arch = bfd_arch_a29k;
1016       machine = 0;
1017       break;
1018 #endif
1019 #ifdef ARMMAGIC
1020     case ARMMAGIC:
1021       arch = bfd_arch_arm;
1022       machine =0;
1023       break;
1024 #endif
1025 #ifdef MC68MAGIC
1026     case MC68MAGIC:
1027     case M68MAGIC:
1028 #ifdef MC68KBCSMAGIC
1029     case MC68KBCSMAGIC:
1030 #endif
1031 #ifdef APOLLOM68KMAGIC
1032     case APOLLOM68KMAGIC:
1033 #endif
1034 #ifdef LYNXCOFFMAGIC
1035     case LYNXCOFFMAGIC:
1036 #endif
1037       arch = bfd_arch_m68k;
1038       machine = 68020;
1039       break;
1040 #endif
1041 #ifdef MC88MAGIC
1042     case MC88MAGIC:
1043     case MC88DMAGIC:
1044     case MC88OMAGIC:
1045       arch = bfd_arch_m88k;
1046       machine = 88100;
1047       break;
1048 #endif
1049 #ifdef Z8KMAGIC
1050     case Z8KMAGIC:
1051       arch = bfd_arch_z8k;
1052       switch (internal_f->f_flags & F_MACHMASK)
1053         {
1054         case F_Z8001:
1055           machine = bfd_mach_z8001;
1056           break;
1057         case F_Z8002:
1058           machine = bfd_mach_z8002;
1059           break;
1060         default:
1061           return false;
1062         }
1063       break;
1064 #endif
1065 #ifdef I960
1066 #ifdef I960ROMAGIC
1067     case I960ROMAGIC:
1068     case I960RWMAGIC:
1069       arch = bfd_arch_i960;
1070       switch (F_I960TYPE & internal_f->f_flags)
1071         {
1072         default:
1073         case F_I960CORE:
1074           machine = bfd_mach_i960_core;
1075           break;
1076         case F_I960KB:
1077           machine = bfd_mach_i960_kb_sb;
1078           break;
1079         case F_I960MC:
1080           machine = bfd_mach_i960_mc;
1081           break;
1082         case F_I960XA:
1083           machine = bfd_mach_i960_xa;
1084           break;
1085         case F_I960CA:
1086           machine = bfd_mach_i960_ca;
1087           break;
1088         case F_I960KA:
1089           machine = bfd_mach_i960_ka_sa;
1090           break;
1091           /* start-sanitize-i960xl */
1092         case F_I960XL:
1093           machine = bfd_mach_i960_xl;
1094           break;
1095           /* end-sanitize-i960xl */
1096         }
1097       break;
1098 #endif
1099 #endif
1100
1101 #ifdef U802ROMAGIC
1102     case U802ROMAGIC:
1103     case U802WRMAGIC:
1104     case U802TOCMAGIC:
1105       arch = bfd_arch_rs6000;
1106       machine = 6000;
1107       break;
1108 #endif
1109
1110 #ifdef WE32KMAGIC
1111     case WE32KMAGIC:
1112       arch = bfd_arch_we32k;
1113       machine = 0;
1114       break;
1115 #endif
1116
1117 #ifdef H8300MAGIC
1118     case H8300MAGIC:
1119       arch = bfd_arch_h8300;
1120       machine = bfd_mach_h8300;
1121       /* !! FIXME this probably isn't the right place for this */
1122       abfd->flags |= BFD_IS_RELAXABLE;
1123       break;
1124 #endif
1125
1126 #ifdef H8300HMAGIC
1127     case H8300HMAGIC:
1128       arch = bfd_arch_h8300;
1129       machine = bfd_mach_h8300h;
1130       /* !! FIXME this probably isn't the right place for this */
1131       abfd->flags |= BFD_IS_RELAXABLE;
1132       break;
1133 #endif
1134
1135 #ifdef SH_ARCH_MAGIC_BIG
1136     case SH_ARCH_MAGIC_BIG:
1137     case SH_ARCH_MAGIC_LITTLE:
1138       arch = bfd_arch_sh;
1139       machine = 0;
1140       break;
1141 #endif
1142
1143 #ifdef H8500MAGIC
1144     case H8500MAGIC:
1145       arch = bfd_arch_h8500;
1146       machine = 0;
1147       break;
1148 #endif
1149
1150 #ifdef SPARCMAGIC
1151     case SPARCMAGIC:
1152 #ifdef LYNXCOFFMAGIC
1153     case LYNXCOFFMAGIC:
1154 #endif
1155       arch = bfd_arch_sparc;
1156       machine = 0;
1157       break;
1158 #endif
1159
1160     default:                    /* Unreadable input file type */
1161       arch = bfd_arch_obscure;
1162       break;
1163     }
1164
1165   bfd_default_set_arch_mach (abfd, arch, machine);
1166   return true;
1167 }
1168
1169 #ifdef SYMNAME_IN_DEBUG
1170
1171 static boolean
1172 symname_in_debug_hook (abfd, sym)
1173      bfd * abfd;
1174      struct internal_syment *sym;
1175 {
1176   return SYMNAME_IN_DEBUG (sym) ? true : false;
1177 }
1178
1179 #else
1180
1181 #define symname_in_debug_hook \
1182   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1183
1184 #endif
1185
1186 /*
1187 SUBSUBSECTION
1188         Writing relocations
1189
1190         To write relocations, the back end steps though the
1191         canonical relocation table and create an
1192         @code{internal_reloc}. The symbol index to use is removed from
1193         the @code{offset} field in the symbol table supplied.  The
1194         address comes directly from the sum of the section base
1195         address and the relocation offset; the type is dug directly
1196         from the howto field.  Then the @code{internal_reloc} is
1197         swapped into the shape of an @code{external_reloc} and written
1198         out to disk.
1199
1200 */
1201
1202 static boolean
1203 coff_write_relocs (abfd, first_undef)
1204      bfd * abfd;
1205      int first_undef;
1206 {
1207   asection *s;
1208   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1209     {
1210       unsigned int i;
1211       struct external_reloc dst;
1212
1213       arelent **p = s->orelocation;
1214       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1215         return false;
1216       for (i = 0; i < s->reloc_count; i++)
1217         {
1218           struct internal_reloc n;
1219           arelent *q = p[i];
1220           memset ((PTR) & n, 0, sizeof (n));
1221
1222           /* Now we've renumbered the symbols we know where the
1223              undefined symbols live in the table.  Check the reloc
1224              entries for symbols who's output bfd isn't the right one.
1225              This is because the symbol was undefined (which means
1226              that all the pointers are never made to point to the same
1227              place). This is a bad thing,'cause the symbols attached
1228              to the output bfd are indexed, so that the relocation
1229              entries know which symbol index they point to.  So we
1230              have to look up the output symbol here. */
1231
1232           if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1233             {
1234               int i;
1235               const char *sname = q->sym_ptr_ptr[0]->name;
1236               asymbol **outsyms = abfd->outsymbols;
1237               for (i = first_undef; outsyms[i]; i++)
1238                 {
1239                   const char *intable = outsyms[i]->name;
1240                   if (strcmp (intable, sname) == 0) {
1241                     /* got a hit, so repoint the reloc */
1242                     q->sym_ptr_ptr = outsyms + i;
1243                     break;
1244                   }
1245                 }
1246             }
1247
1248           n.r_vaddr = q->address + s->vma;
1249
1250 #ifdef R_IHCONST
1251           /* The 29k const/consth reloc pair is a real kludge.  The consth
1252              part doesn't have a symbol; it has an offset.  So rebuilt
1253              that here.  */
1254           if (q->howto->type == R_IHCONST)
1255             n.r_symndx = q->addend;
1256           else
1257 #endif
1258             if (q->sym_ptr_ptr)
1259               {
1260                 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1261                   /* This is a relocation relative to the absolute symbol.  */
1262                   n.r_symndx = -1;
1263                 else
1264                   {
1265                     n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1266                     /* Take notice if the symbol reloc points to a symbol
1267                        we don't have in our symbol table.  What should we
1268                        do for this??  */
1269                     if (n.r_symndx > obj_conv_table_size (abfd))
1270                       abort ();
1271                   }
1272               }
1273
1274 #ifdef SWAP_OUT_RELOC_OFFSET
1275           n.r_offset = q->addend;
1276 #endif
1277
1278 #ifdef SELECT_RELOC
1279           /* Work out reloc type from what is required */
1280           SELECT_RELOC (n, q->howto);
1281 #else
1282           n.r_type = q->howto->type;
1283 #endif
1284           coff_swap_reloc_out (abfd, &n, &dst);
1285           if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1286             return false;
1287         }
1288     }
1289
1290   return true;
1291 }
1292
1293 /* Set flags and magic number of a coff file from architecture and machine
1294    type.  Result is true if we can represent the arch&type, false if not.  */
1295
1296 static boolean
1297 coff_set_flags (abfd, magicp, flagsp)
1298      bfd * abfd;
1299      unsigned *magicp;
1300      unsigned short *flagsp;
1301 {
1302   switch (bfd_get_arch (abfd))
1303     {
1304 #ifdef Z8KMAGIC
1305     case bfd_arch_z8k:
1306       *magicp = Z8KMAGIC;
1307       switch (bfd_get_mach (abfd))
1308         {
1309         case bfd_mach_z8001:
1310           *flagsp = F_Z8001;
1311           break;
1312         case bfd_mach_z8002:
1313           *flagsp = F_Z8002;
1314           break;
1315         default:
1316           return false;
1317         }
1318       return true;
1319 #endif
1320 #ifdef I960ROMAGIC
1321
1322     case bfd_arch_i960:
1323
1324       {
1325         unsigned flags;
1326         *magicp = I960ROMAGIC;
1327         /*
1328           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1329           I960RWMAGIC);   FIXME???
1330           */
1331         switch (bfd_get_mach (abfd))
1332           {
1333           case bfd_mach_i960_core:
1334             flags = F_I960CORE;
1335             break;
1336           case bfd_mach_i960_kb_sb:
1337             flags = F_I960KB;
1338             break;
1339           case bfd_mach_i960_mc:
1340             flags = F_I960MC;
1341             break;
1342           case bfd_mach_i960_xa:
1343             flags = F_I960XA;
1344             break;
1345           case bfd_mach_i960_ca:
1346             flags = F_I960CA;
1347             break;
1348           case bfd_mach_i960_ka_sa:
1349             flags = F_I960KA;
1350             break;
1351             /* start-sanitize-i960xl */
1352           case bfd_mach_i960_xl:
1353             flags = F_I960XL;
1354             break;
1355             /* end-sanitize-i960xl */
1356           default:
1357             return false;
1358           }
1359         *flagsp = flags;
1360         return true;
1361       }
1362       break;
1363 #endif
1364 #ifdef ARMMAGIC
1365     case bfd_arch_arm:
1366       *magicp = ARMMAGIC;
1367       return true;
1368 #endif
1369 #ifdef I386MAGIC
1370     case bfd_arch_i386:
1371       *magicp = I386MAGIC;
1372 #ifdef LYNXOS
1373       /* Just overwrite the usual value if we're doing Lynx. */
1374       *magicp = LYNXCOFFMAGIC;
1375 #endif
1376       return true;
1377       break;
1378 #endif
1379 #ifdef MC68MAGIC
1380     case bfd_arch_m68k:
1381 #ifdef APOLLOM68KMAGIC
1382       *magicp = APOLLO_COFF_VERSION_NUMBER;
1383 #else
1384       *magicp = MC68MAGIC;
1385 #endif
1386 #ifdef LYNXOS
1387       /* Just overwrite the usual value if we're doing Lynx. */
1388       *magicp = LYNXCOFFMAGIC;
1389 #endif
1390       return true;
1391       break;
1392 #endif
1393
1394 #ifdef MC88MAGIC
1395     case bfd_arch_m88k:
1396       *magicp = MC88OMAGIC;
1397       return true;
1398       break;
1399 #endif
1400 #ifdef H8300MAGIC
1401     case bfd_arch_h8300:
1402       switch (bfd_get_mach (abfd))
1403         {
1404         case bfd_mach_h8300:
1405           *magicp = H8300MAGIC;
1406           return true;
1407         case bfd_mach_h8300h:
1408           *magicp = H8300HMAGIC;
1409           return true;
1410         }
1411       break;
1412 #endif
1413
1414 #ifdef SH_ARCH_MAGIC_BIG
1415     case bfd_arch_sh:
1416       if (abfd->xvec->byteorder_big_p)
1417         *magicp = SH_ARCH_MAGIC_BIG;
1418       else
1419         *magicp = SH_ARCH_MAGIC_LITTLE;
1420       return true;
1421       break;
1422 #endif
1423
1424 #ifdef SPARCMAGIC
1425     case bfd_arch_sparc:
1426       *magicp = SPARCMAGIC;
1427 #ifdef LYNXOS
1428       /* Just overwrite the usual value if we're doing Lynx. */
1429       *magicp = LYNXCOFFMAGIC;
1430 #endif
1431       return true;
1432       break;
1433 #endif
1434
1435 #ifdef H8500MAGIC
1436     case bfd_arch_h8500:
1437       *magicp = H8500MAGIC;
1438       return true;
1439       break;
1440 #endif
1441 #ifdef A29K_MAGIC_BIG
1442     case bfd_arch_a29k:
1443       if (abfd->xvec->byteorder_big_p)
1444         *magicp = A29K_MAGIC_BIG;
1445       else
1446         *magicp = A29K_MAGIC_LITTLE;
1447       return true;
1448       break;
1449 #endif
1450
1451 #ifdef WE32KMAGIC
1452     case bfd_arch_we32k:
1453       *magicp = WE32KMAGIC;
1454       return true;
1455       break;
1456 #endif
1457
1458 #ifdef U802TOCMAGIC
1459     case bfd_arch_rs6000:
1460     case bfd_arch_powerpc:
1461       *magicp = U802TOCMAGIC;
1462       return true;
1463       break;
1464 #endif
1465
1466     default:                    /* Unknown architecture */
1467       /* return false;  -- fall through to "return false" below, to avoid
1468        "statement never reached" errors on the one below. */
1469       break;
1470     }
1471
1472   return false;
1473 }
1474
1475
1476 static boolean
1477 coff_set_arch_mach (abfd, arch, machine)
1478      bfd * abfd;
1479      enum bfd_architecture arch;
1480      unsigned long machine;
1481 {
1482   unsigned dummy1;
1483   unsigned short dummy2;
1484
1485   if (! bfd_default_set_arch_mach (abfd, arch, machine))
1486     return false;
1487
1488   if (arch != bfd_arch_unknown &&
1489       coff_set_flags (abfd, &dummy1, &dummy2) != true)
1490     return false;               /* We can't represent this type */
1491
1492   return true;                  /* We're easy ... */
1493 }
1494
1495
1496 /* Calculate the file position for each section. */
1497
1498 static void
1499 coff_compute_section_file_positions (abfd)
1500      bfd * abfd;
1501 {
1502   asection *current;
1503   asection *previous = (asection *) NULL;
1504   file_ptr sofar = FILHSZ;
1505
1506 #ifndef I960
1507   file_ptr old_sofar;
1508 #endif
1509   unsigned int count;
1510
1511
1512 #ifdef COFF_IMAGE_WITH_PE
1513   int page_size;
1514   if (coff_data (abfd)->link_info)
1515     {
1516       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
1517     }
1518   else
1519     page_size = PE_DEF_FILE_ALIGNMENT;
1520 #elif defined (COFF_PAGE_SIZE)
1521   int page_size = COFF_PAGE_SIZE;
1522 #endif
1523
1524   if (bfd_get_start_address (abfd))
1525     {
1526       /*  A start address may have been added to the original file. In this
1527           case it will need an optional header to record it.  */
1528       abfd->flags |= EXEC_P;
1529     }
1530
1531   if (abfd->flags & EXEC_P)
1532     sofar += AOUTSZ;
1533
1534   sofar += abfd->section_count * SCNHSZ;
1535   for (current = abfd->sections, count = 1;
1536        current != (asection *) NULL;
1537        current = current->next, ++count)
1538     {
1539       current->target_index = count;
1540
1541       /* Only deal with sections which have contents */
1542       if (!(current->flags & SEC_HAS_CONTENTS))
1543         continue;
1544
1545 #ifdef COFF_WITH_PE
1546       /* Do not include the .junk section.  This is where we collect section
1547          data which we don't need.  This is mainly the MS .debug$ data which
1548          stores codeview debug data. */
1549       if (strcmp (current->name, ".junk") == 0)
1550         {
1551           continue;
1552         }
1553 #endif
1554
1555       /* Align the sections in the file to the same boundary on
1556          which they are aligned in virtual memory.  I960 doesn't
1557          do this (FIXME) so we can stay in sync with Intel.  960
1558          doesn't yet page from files... */
1559 #ifndef I960
1560       {
1561         /* make sure this section is aligned on the right boundary - by
1562            padding the previous section up if necessary */
1563
1564         old_sofar = sofar;
1565         sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1566         if (previous != (asection *) NULL)
1567           {
1568             previous->_raw_size += sofar - old_sofar;
1569           }
1570       }
1571
1572 #endif
1573
1574       /* In demand paged files the low order bits of the file offset
1575          must match the low order bits of the virtual address.  */
1576 #ifdef COFF_PAGE_SIZE
1577       if ((abfd->flags & D_PAGED) != 0
1578           && (current->flags & SEC_ALLOC) != 0)
1579         sofar += (current->vma - sofar) % page_size;
1580 #endif
1581       current->filepos = sofar;
1582
1583 #ifdef COFF_IMAGE_WITH_PE
1584       /* With PE we have to pad each section to be a multiple of its page size
1585          too, and remember both sizes. Cooked_size becomes very useful. */
1586       current->_cooked_size = current->_raw_size;
1587       current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
1588 #endif
1589
1590       sofar += current->_raw_size;
1591
1592 #ifndef I960
1593       /* make sure that this section is of the right size too */
1594       old_sofar = sofar;
1595       sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
1596       current->_raw_size += sofar - old_sofar;
1597 #endif
1598
1599 #ifdef _LIB
1600       /* Force .lib sections to start at zero.  The vma is then
1601          incremented in coff_set_section_contents.  This is right for
1602          SVR3.2.  */
1603       if (strcmp (current->name, _LIB) == 0)
1604         bfd_set_section_vma (abfd, current, 0);
1605 #endif
1606
1607       previous = current;
1608     }
1609
1610   obj_relocbase (abfd) = sofar;
1611   abfd->output_has_begun = true;
1612
1613 }
1614
1615 #ifndef RS6000COFF_C
1616
1617 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1618 /* @@ Should we only be adding missing symbols, or overriding the aux
1619    values for existing section symbols?  */
1620 static boolean
1621 coff_add_missing_symbols (abfd)
1622      bfd *abfd;
1623 {
1624   unsigned int nsyms = bfd_get_symcount (abfd);
1625   asymbol **sympp = abfd->outsymbols;
1626   asymbol **sympp2;
1627   unsigned int i;
1628   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1629
1630   for (i = 0; i < nsyms; i++)
1631     {
1632       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1633       CONST char *name;
1634       if (csym)
1635         {
1636           /* only do this if there is a coff representation of the input
1637            symbol */
1638           if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1639             {
1640               need_file = 0;
1641               continue;
1642             }
1643           name = csym->symbol.name;
1644           if (!name)
1645             continue;
1646           if (!strcmp (name, _TEXT))
1647             need_text = 0;
1648 #ifdef APOLLO_M68
1649           else if (!strcmp (name, ".wtext"))
1650             need_text = 0;
1651 #endif
1652           else if (!strcmp (name, _DATA))
1653             need_data = 0;
1654           else if (!strcmp (name, _BSS))
1655             need_bss = 0;
1656         }
1657     }
1658   /* Now i == bfd_get_symcount (abfd).  */
1659   /* @@ For now, don't deal with .file symbol.  */
1660   need_file = 0;
1661
1662   if (!need_text && !need_data && !need_bss && !need_file)
1663     return true;
1664   nsyms += need_text + need_data + need_bss + need_file;
1665   sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1666   if (!sympp2)
1667     {
1668       bfd_set_error (bfd_error_no_memory);
1669       return false;
1670     }
1671   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1672   if (need_file)
1673     {
1674       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1675       abort ();
1676     }
1677   if (need_text)
1678     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1679   if (need_data)
1680     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1681   if (need_bss)
1682     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1683   BFD_ASSERT (i == nsyms);
1684   bfd_set_symtab (abfd, sympp2, nsyms);
1685   return true;
1686 }
1687
1688 #endif /* ! defined (RS6000COFF_C) */
1689
1690
1691
1692 /* SUPPRESS 558 */
1693 /* SUPPRESS 529 */
1694 static boolean
1695 coff_write_object_contents (abfd)
1696      bfd * abfd;
1697 {
1698   asection *current;
1699   boolean hasrelocs = false;
1700   boolean haslinno = false;
1701   file_ptr reloc_base;
1702   file_ptr lineno_base;
1703   file_ptr sym_base;
1704   unsigned long reloc_size = 0;
1705   unsigned long lnno_size = 0;
1706   asection *text_sec = NULL;
1707   asection *data_sec = NULL;
1708   asection *bss_sec = NULL;
1709
1710   struct internal_filehdr internal_f;
1711   struct internal_aouthdr internal_a;
1712
1713   bfd_set_error (bfd_error_system_call);
1714
1715   if (abfd->output_has_begun == false)
1716     coff_compute_section_file_positions (abfd);
1717
1718   reloc_base = obj_relocbase (abfd);
1719
1720   /* Make a pass through the symbol table to count line number entries and
1721      put them into the correct asections */
1722
1723   lnno_size = coff_count_linenumbers (abfd) * LINESZ;
1724
1725   /* Work out the size of the reloc and linno areas */
1726
1727   for (current = abfd->sections; current != NULL; current =
1728        current->next)
1729     reloc_size += current->reloc_count * RELSZ;
1730
1731   lineno_base = reloc_base + reloc_size;
1732   sym_base = lineno_base + lnno_size;
1733
1734   /* Indicate in each section->line_filepos its actual file address */
1735   for (current = abfd->sections; current != NULL; current =
1736        current->next)
1737     {
1738       if (current->lineno_count)
1739         {
1740           current->line_filepos = lineno_base;
1741           current->moving_line_filepos = lineno_base;
1742           lineno_base += current->lineno_count * LINESZ;
1743         }
1744       else
1745         {
1746           current->line_filepos = 0;
1747         }
1748       if (current->reloc_count)
1749         {
1750           current->rel_filepos = reloc_base;
1751           reloc_base += current->reloc_count * RELSZ;
1752         }
1753       else
1754         {
1755           current->rel_filepos = 0;
1756         }
1757     }
1758
1759   /* Write section headers to the file.  */
1760   internal_f.f_nscns = 0;
1761
1762   if (bfd_seek (abfd,
1763                 (file_ptr) ((abfd->flags & EXEC_P) ?
1764                             (FILHSZ + AOUTSZ) : FILHSZ),
1765                 SEEK_SET) != 0)
1766     return false;
1767
1768   for (current = abfd->sections;
1769        current != NULL;
1770        current = current->next)
1771     {
1772       struct internal_scnhdr section;
1773
1774 #ifdef COFF_WITH_PE
1775       /* Do not include the .junk section.  This is where we collect section
1776          data which we don't need.  This is mainly the MS .debug$ data which
1777          stores codeview debug data. */
1778       if (strcmp (current->name, ".junk") == 0)
1779         {
1780           continue;
1781         }
1782
1783       /* If we've got a .reloc section, remember. */
1784
1785       if (strcmp (current->name, ".reloc") == 0)
1786         {
1787           pe_data (abfd)->has_reloc_section = 1;
1788         }
1789 #endif
1790       internal_f.f_nscns++;
1791       strncpy (&(section.s_name[0]), current->name, 8);
1792 #ifdef _LIB
1793       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
1794          Ian Taylor <ian@cygnus.com>.  */
1795       if (strcmp (current->name, _LIB) == 0)
1796         section.s_vaddr = 0;
1797       else
1798 #endif
1799       section.s_vaddr = current->lma;
1800       section.s_paddr = current->lma;
1801       section.s_size =  current->_raw_size;
1802
1803 #ifdef COFF_WITH_PE
1804       section.s_paddr = current->_cooked_size;
1805 #endif
1806
1807       /*
1808          If this section has no size or is unloadable then the scnptr
1809          will be 0 too
1810          */
1811       if (current->_raw_size == 0 ||
1812           (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1813         {
1814           section.s_scnptr = 0;
1815         }
1816       else
1817         {
1818           section.s_scnptr = current->filepos;
1819         }
1820       section.s_relptr = current->rel_filepos;
1821       section.s_lnnoptr = current->line_filepos;
1822       section.s_nreloc = current->reloc_count;
1823       section.s_nlnno = current->lineno_count;
1824       if (current->reloc_count != 0)
1825         hasrelocs = true;
1826       if (current->lineno_count != 0)
1827         haslinno = true;
1828
1829       section.s_flags = sec_to_styp_flags (current->name, current->flags);
1830
1831       if (!strcmp (current->name, _TEXT))
1832         {
1833           text_sec = current;
1834         }
1835       else if (!strcmp (current->name, _DATA))
1836         {
1837           data_sec = current;
1838 #ifdef TWO_DATA_SECS
1839         }
1840       else if (!strcmp (current->name, ".data2"))
1841         {
1842           data_sec = current;
1843 #endif /* TWO_DATA_SECS */
1844         }
1845       else if (!strcmp (current->name, _BSS))
1846         {
1847           bss_sec = current;
1848         }
1849
1850 #ifdef I960
1851       section.s_align = (current->alignment_power
1852                          ? 1 << current->alignment_power
1853                          : 0);
1854
1855 #endif
1856
1857 #ifdef COFF_IMAGE_WITH_PE
1858       /* suppress output of the sections if they are null.  ld includes
1859          the bss and data sections even if there is no size assigned
1860          to them.  NT loader doesn't like it if these section headers are
1861          included if the sections themselves are not needed */
1862       if (section.s_size == 0)
1863         internal_f.f_nscns--;
1864       else
1865 #endif
1866         {
1867           SCNHDR buff;
1868           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
1869               || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
1870             return false;
1871         }
1872     }
1873
1874
1875
1876   /* OK, now set up the filehdr... */
1877
1878   /* Don't include the internal abs section in the section count */
1879
1880   /*
1881      We will NOT put a fucking timestamp in the header here. Every time you
1882      put it back, I will come in and take it out again.  I'm sorry.  This
1883      field does not belong here.  We fill it with a 0 so it compares the
1884      same but is not a reasonable time. -- gnu@cygnus.com
1885      */
1886
1887   internal_f.f_flags = 0;
1888
1889   if (abfd->flags & EXEC_P)
1890     internal_f.f_opthdr = AOUTSZ;
1891   else
1892     internal_f.f_opthdr = 0;
1893
1894   if (!hasrelocs)
1895     internal_f.f_flags |= F_RELFLG;
1896   if (!haslinno)
1897     internal_f.f_flags |= F_LNNO;
1898   if (abfd->flags & EXEC_P)
1899     internal_f.f_flags |= F_EXEC;
1900
1901   if (!abfd->xvec->byteorder_big_p)
1902     internal_f.f_flags |= F_AR32WR;
1903   else
1904     internal_f.f_flags |= F_AR32W;
1905
1906   /*
1907      FIXME, should do something about the other byte orders and
1908      architectures.
1909      */
1910
1911   memset (&internal_a, 0, sizeof internal_a);
1912
1913   /* Set up architecture-dependent stuff */
1914
1915   {
1916     unsigned int magic = 0;
1917     unsigned short flags = 0;
1918     coff_set_flags (abfd, &magic, &flags);
1919     internal_f.f_magic = magic;
1920     internal_f.f_flags |= flags;
1921     /* ...and the "opt"hdr... */
1922
1923 #ifdef A29K
1924 #ifdef ULTRA3                   /* NYU's machine */
1925     /* FIXME: This is a bogus check.  I really want to see if there
1926      * is a .shbss or a .shdata section, if so then set the magic
1927      * number to indicate a shared data executable.
1928      */
1929     if (internal_f.f_nscns >= 7)
1930       internal_a.magic = SHMAGIC; /* Shared magic */
1931     else
1932 #endif /* ULTRA3 */
1933       internal_a.magic = NMAGIC; /* Assume separate i/d */
1934 #define __A_MAGIC_SET__
1935 #endif /* A29K */
1936 #ifdef I960
1937     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
1938 #define __A_MAGIC_SET__
1939 #endif /* I960 */
1940 #if M88
1941 #define __A_MAGIC_SET__
1942     internal_a.magic = PAGEMAGICBCS;
1943 #endif /* M88 */
1944
1945 #if APOLLO_M68
1946 #define __A_MAGIC_SET__
1947     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
1948 #endif
1949
1950 #if defined(M68) || defined(WE32K) || defined(M68K)
1951 #define __A_MAGIC_SET__
1952 #if defined(LYNXOS)
1953     internal_a.magic = LYNXCOFFMAGIC;
1954 #endif /* LYNXOS */
1955 #endif /* M68 || WE32K || M68K */
1956
1957 #if defined(ARM)
1958 #define __A_MAGIC_SET__
1959     internal_a.magic = ZMAGIC;
1960 #endif
1961 #if defined(I386)
1962 #define __A_MAGIC_SET__
1963 #if defined(LYNXOS)
1964     internal_a.magic = LYNXCOFFMAGIC;
1965 #else  /* LYNXOS */
1966     internal_a.magic = ZMAGIC;
1967 #endif /* LYNXOS */
1968 #endif /* I386 */
1969
1970 #if defined(SPARC)
1971 #define __A_MAGIC_SET__
1972 #if defined(LYNXOS)
1973     internal_a.magic = LYNXCOFFMAGIC;
1974 #endif /* LYNXOS */
1975 #endif /* SPARC */
1976
1977 #if RS6000COFF_C
1978 #define __A_MAGIC_SET__
1979     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
1980     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
1981     RS6K_AOUTHDR_OMAGIC;
1982 #endif
1983
1984 #ifndef __A_MAGIC_SET__
1985 #include "Your aouthdr magic number is not being set!"
1986 #else
1987 #undef __A_MAGIC_SET__
1988 #endif
1989   }
1990   /* Now should write relocs, strings, syms */
1991   obj_sym_filepos (abfd) = sym_base;
1992
1993   if (bfd_get_symcount (abfd) != 0)
1994     {
1995       int firstundef;
1996 #ifndef RS6000COFF_C
1997       if (!coff_add_missing_symbols (abfd))
1998         return false;
1999 #endif
2000       if (!coff_renumber_symbols (abfd, &firstundef))
2001         return false;
2002       coff_mangle_symbols (abfd);
2003       if (! coff_write_symbols (abfd))
2004         return false;
2005       if (! coff_write_linenumbers (abfd))
2006         return false;
2007       if (! coff_write_relocs (abfd, firstundef))
2008         return false;
2009     }
2010
2011   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2012      backend linker, and obj_raw_syment_count is not valid until after
2013      coff_write_symbols is called.  */
2014   if (obj_raw_syment_count (abfd) != 0)
2015     internal_f.f_symptr = sym_base;
2016   else
2017     {
2018       internal_f.f_symptr = 0;
2019       internal_f.f_flags |= F_LSYMS;
2020     }
2021
2022   if (text_sec)
2023     {
2024       internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
2025       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
2026     }
2027   if (data_sec)
2028     {
2029       internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
2030       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
2031     }
2032   if (bss_sec)
2033     {
2034       internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
2035     }
2036
2037   internal_a.entry = bfd_get_start_address (abfd);
2038   internal_f.f_nsyms = obj_raw_syment_count (abfd);
2039
2040   /* now write them */
2041   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2042     return false;
2043   {
2044     FILHDR buff;
2045     coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
2046     if (bfd_write ((PTR) & buff, 1, FILHSZ, abfd) != FILHSZ)
2047       return false;
2048   }
2049   if (abfd->flags & EXEC_P)
2050     {
2051       AOUTHDR buff;
2052       coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
2053       if (bfd_write ((PTR) & buff, 1, AOUTSZ, abfd) != AOUTSZ)
2054         return false;
2055     }
2056
2057   return true;
2058 }
2059
2060 static boolean
2061 coff_set_section_contents (abfd, section, location, offset, count)
2062      bfd * abfd;
2063      sec_ptr section;
2064      PTR location;
2065      file_ptr offset;
2066      bfd_size_type count;
2067 {
2068   if (abfd->output_has_begun == false)  /* set by bfd.c handler */
2069     coff_compute_section_file_positions (abfd);
2070
2071 #ifdef _LIB
2072   /* If this is a .lib section, bump the vma address so that it
2073        winds up being the number of .lib sections output.  This is
2074        right for SVR3.2.  Shared libraries should probably get more
2075        generic support.  Ian Taylor <ian@cygnus.com>.  */
2076   if (strcmp (section->name, _LIB) == 0)
2077     ++section->lma;
2078 #endif
2079
2080   /* Don't write out bss sections - one way to do this is to
2081        see if the filepos has not been set. */
2082   if (section->filepos == 0)
2083     return true;
2084
2085   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
2086     return false;
2087
2088   if (count != 0)
2089     {
2090       return (bfd_write (location, 1, count, abfd) == count) ? true : false;
2091     }
2092   return true;
2093 }
2094 #if 0
2095 static boolean
2096 coff_close_and_cleanup (abfd)
2097      bfd *abfd;
2098 {
2099   if (!bfd_read_p (abfd))
2100     switch (abfd->format)
2101       {
2102       case bfd_archive:
2103         if (!_bfd_write_archive_contents (abfd))
2104           return false;
2105         break;
2106       case bfd_object:
2107         if (!coff_write_object_contents (abfd))
2108           return false;
2109         break;
2110       default:
2111         bfd_set_error (bfd_error_invalid_operation);
2112         return false;
2113       }
2114
2115   /* We depend on bfd_close to free all the memory on the obstack.  */
2116   /* FIXME if bfd_release is not using obstacks! */
2117   return true;
2118 }
2119
2120 #endif
2121
2122 static PTR
2123 buy_and_read (abfd, where, seek_direction, size)
2124      bfd *abfd;
2125      file_ptr where;
2126      int seek_direction;
2127      size_t size;
2128 {
2129   PTR area = (PTR) bfd_alloc (abfd, size);
2130   if (!area)
2131     {
2132       bfd_set_error (bfd_error_no_memory);
2133       return (NULL);
2134     }
2135   if (bfd_seek (abfd, where, seek_direction) != 0
2136       || bfd_read (area, 1, size, abfd) != size)
2137     return (NULL);
2138   return (area);
2139 }                               /* buy_and_read() */
2140
2141 /*
2142 SUBSUBSECTION
2143         Reading linenumbers
2144
2145         Creating the linenumber table is done by reading in the entire
2146         coff linenumber table, and creating another table for internal use.
2147
2148         A coff linenumber table is structured so that each function
2149         is marked as having a line number of 0. Each line within the
2150         function is an offset from the first line in the function. The
2151         base of the line number information for the table is stored in
2152         the symbol associated with the function.
2153
2154         The information is copied from the external to the internal
2155         table, and each symbol which marks a function is marked by
2156         pointing its...
2157
2158         How does this work ?
2159
2160 */
2161
2162 static boolean
2163 coff_slurp_line_table (abfd, asect)
2164      bfd *abfd;
2165      asection *asect;
2166 {
2167   LINENO *native_lineno;
2168   alent *lineno_cache;
2169
2170   BFD_ASSERT (asect->lineno == (alent *) NULL);
2171
2172   native_lineno = (LINENO *) buy_and_read (abfd,
2173                                            asect->line_filepos,
2174                                            SEEK_SET,
2175                                            (size_t) (LINESZ *
2176                                                      asect->lineno_count));
2177   lineno_cache =
2178     (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
2179   if (lineno_cache == NULL)
2180     {
2181       bfd_set_error (bfd_error_no_memory);
2182       return false;
2183     }
2184   else
2185     {
2186       unsigned int counter = 0;
2187       alent *cache_ptr = lineno_cache;
2188       LINENO *src = native_lineno;
2189
2190       while (counter < asect->lineno_count)
2191         {
2192           struct internal_lineno dst;
2193           coff_swap_lineno_in (abfd, src, &dst);
2194           cache_ptr->line_number = dst.l_lnno;
2195
2196           if (cache_ptr->line_number == 0)
2197             {
2198               coff_symbol_type *sym =
2199               (coff_symbol_type *) (dst.l_addr.l_symndx
2200                       + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
2201               cache_ptr->u.sym = (asymbol *) sym;
2202               sym->lineno = cache_ptr;
2203             }
2204           else
2205             {
2206               cache_ptr->u.offset = dst.l_addr.l_paddr
2207                 - bfd_section_vma (abfd, asect);
2208             }                   /* If no linenumber expect a symbol index */
2209
2210           cache_ptr++;
2211           src++;
2212           counter++;
2213         }
2214       cache_ptr->line_number = 0;
2215
2216     }
2217   asect->lineno = lineno_cache;
2218   /* FIXME, free native_lineno here, or use alloca or something. */
2219   return true;
2220 }
2221
2222 static boolean
2223 coff_slurp_symbol_table (abfd)
2224      bfd * abfd;
2225 {
2226   combined_entry_type *native_symbols;
2227   coff_symbol_type *cached_area;
2228   unsigned int *table_ptr;
2229
2230   unsigned int number_of_symbols = 0;
2231
2232   if (obj_symbols (abfd))
2233     return true;
2234
2235   /* Read in the symbol table */
2236   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
2237     {
2238       return (false);
2239     }                           /* on error */
2240
2241   /* Allocate enough room for all the symbols in cached form */
2242   cached_area = ((coff_symbol_type *)
2243                  bfd_alloc (abfd,
2244                             (obj_raw_syment_count (abfd)
2245                              * sizeof (coff_symbol_type))));
2246
2247   if (cached_area == NULL)
2248     {
2249       bfd_set_error (bfd_error_no_memory);
2250       return false;
2251     }                           /* on error */
2252   table_ptr = ((unsigned int *)
2253                bfd_alloc (abfd,
2254                           (obj_raw_syment_count (abfd)
2255                            * sizeof (unsigned int))));
2256
2257   if (table_ptr == NULL)
2258     {
2259       bfd_set_error (bfd_error_no_memory);
2260       return false;
2261     }
2262   else
2263     {
2264       coff_symbol_type *dst = cached_area;
2265       unsigned int last_native_index = obj_raw_syment_count (abfd);
2266       unsigned int this_index = 0;
2267       while (this_index < last_native_index)
2268         {
2269           combined_entry_type *src = native_symbols + this_index;
2270           table_ptr[this_index] = number_of_symbols;
2271           dst->symbol.the_bfd = abfd;
2272
2273           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
2274           /* We use the native name field to point to the cached field.  */
2275           src->u.syment._n._n_n._n_zeroes = (long) dst;
2276           dst->symbol.section = coff_section_from_bfd_index (abfd,
2277                                                      src->u.syment.n_scnum);
2278           dst->symbol.flags = 0;
2279           dst->done_lineno = false;
2280
2281           switch (src->u.syment.n_sclass)
2282             {
2283 #ifdef I960
2284             case C_LEAFEXT:
2285 #if 0
2286               dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2287               dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2288               dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2289 #endif
2290               /* Fall through to next case */
2291
2292 #endif
2293
2294             case C_EXT:
2295 #ifdef RS6000COFF_C
2296             case C_HIDEXT:
2297 #endif
2298 #ifdef COFF_WITH_PE
2299             /* PE uses storage class 0x68 to denote a section symbol */
2300             case C_SECTION:
2301 #endif
2302               if ((src->u.syment.n_scnum) == 0)
2303                 {
2304                   if ((src->u.syment.n_value) == 0)
2305                     {
2306                       dst->symbol.section = bfd_und_section_ptr;
2307                       dst->symbol.value = 0;
2308                     }
2309                   else
2310                     {
2311                       dst->symbol.section = bfd_com_section_ptr;
2312                       dst->symbol.value = (src->u.syment.n_value);
2313                     }
2314                 }
2315               else
2316                 {
2317                   /*
2318             Base the value as an index from the base of the
2319             section
2320             */
2321
2322                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2323                   dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2324
2325                   if (ISFCN ((src->u.syment.n_type)))
2326                     {
2327                       /*
2328               A function ext does not go at the end of a file
2329               */
2330                       dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
2331                     }
2332                 }
2333
2334 #ifdef RS6000COFF_C
2335               /* If this symbol has a csect aux of type LD, the scnlen field
2336            is actually the index of the containing csect symbol.  We
2337            need to pointerize it.  */
2338               if (src->u.syment.n_numaux > 0)
2339                 {
2340                   combined_entry_type *aux;
2341
2342                   aux = src + src->u.syment.n_numaux - 1;
2343                   if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2344                     {
2345                       aux->u.auxent.x_csect.x_scnlen.p =
2346                         native_symbols + aux->u.auxent.x_csect.x_scnlen.l;
2347                       aux->fix_scnlen = 1;
2348                     }
2349                 }
2350 #endif
2351
2352               break;
2353
2354             case C_STAT:        /* static                        */
2355 #ifdef I960
2356             case C_LEAFSTAT:    /* static leaf procedure        */
2357 #endif
2358             case C_LABEL:       /* label                         */
2359               if (src->u.syment.n_scnum == -2)
2360                 dst->symbol.flags = BSF_DEBUGGING;
2361               else
2362                 dst->symbol.flags = BSF_LOCAL;
2363               /*
2364           Base the value as an index from the base of the section, if
2365           there is one
2366           */
2367               if (dst->symbol.section)
2368                 dst->symbol.value = (src->u.syment.n_value) -
2369                   dst->symbol.section->vma;
2370               else
2371                 dst->symbol.value = (src->u.syment.n_value);
2372               break;
2373
2374             case C_MOS: /* member of structure   */
2375             case C_EOS: /* end of structure              */
2376 #ifdef NOTDEF                   /* C_AUTOARG has the same value */
2377 #ifdef C_GLBLREG
2378             case C_GLBLREG:     /* A29k-specific storage class */
2379 #endif
2380 #endif
2381             case C_REGPARM:     /* register parameter            */
2382             case C_REG: /* register variable             */
2383 #ifdef C_AUTOARG
2384             case C_AUTOARG:     /* 960-specific storage class */
2385 #endif
2386             case C_TPDEF:       /* type definition               */
2387             case C_ARG:
2388             case C_AUTO:        /* automatic variable */
2389             case C_FIELD:       /* bit field */
2390             case C_ENTAG:       /* enumeration tag               */
2391             case C_MOE: /* member of enumeration         */
2392             case C_MOU: /* member of union               */
2393             case C_UNTAG:       /* union tag                     */
2394               dst->symbol.flags = BSF_DEBUGGING;
2395               dst->symbol.value = (src->u.syment.n_value);
2396               break;
2397
2398             case C_FILE:        /* file name                     */
2399             case C_STRTAG:      /* structure tag                 */
2400 #ifdef RS6000COFF_C
2401             case C_BINCL:       /* beginning of include file     */
2402             case C_EINCL:       /* ending of include file        */
2403             case C_GSYM:
2404             case C_LSYM:
2405             case C_PSYM:
2406             case C_RSYM:
2407             case C_RPSYM:
2408             case C_STSYM:
2409             case C_DECL:
2410             case C_ENTRY:
2411             case C_FUN:
2412             case C_ESTAT:
2413 #endif
2414               dst->symbol.flags = BSF_DEBUGGING;
2415               dst->symbol.value = (src->u.syment.n_value);
2416               break;
2417
2418 #ifdef RS6000COFF_C
2419             case C_BSTAT:
2420               dst->symbol.flags = BSF_DEBUGGING;
2421               dst->symbol.value = src->u.syment.n_value;
2422
2423               /* The value is actually a symbol index.  Save a pointer to
2424            the symbol instead of the index.  FIXME: This should use a
2425            union.  */
2426               src->u.syment.n_value =
2427                 (long) (native_symbols + src->u.syment.n_value);
2428               src->fix_value = 1;
2429               break;
2430 #endif
2431
2432             case C_BLOCK:       /* ".bb" or ".eb"                */
2433             case C_FCN: /* ".bf" or ".ef"                */
2434             case C_EFCN:        /* physical end of function      */
2435               dst->symbol.flags = BSF_LOCAL;
2436               /*
2437           Base the value as an index from the base of the section
2438           */
2439               dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
2440               break;
2441
2442             case C_NULL:
2443             case C_EXTDEF:      /* external definition           */
2444             case C_ULABEL:      /* undefined label               */
2445             case C_USTATIC:     /* undefined static              */
2446 #ifndef COFF_WITH_PE
2447             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
2448                class to represent a section symbol */
2449             case C_LINE:        /* line # reformatted as symbol table entry */
2450 #endif
2451             case C_ALIAS:       /* duplicate tag                 */
2452             case C_HIDDEN:      /* ext symbol in dmert public lib */
2453             default:
2454
2455               fprintf (stderr, "Unrecognized storage class %d (assuming debugging)\n  for %s symbol `%s'\n",
2456                        src->u.syment.n_sclass, dst->symbol.section->name,
2457                        dst->symbol.name);
2458 /*      abort();*/
2459               dst->symbol.flags = BSF_DEBUGGING;
2460               dst->symbol.value = (src->u.syment.n_value);
2461               break;
2462             }
2463
2464 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
2465
2466           dst->native = src;
2467
2468           dst->symbol.udata.i = 0;
2469           dst->lineno = (alent *) NULL;
2470           this_index += (src->u.syment.n_numaux) + 1;
2471           dst++;
2472           number_of_symbols++;
2473         }                       /* walk the native symtab */
2474     }                           /* bfdize the native symtab */
2475
2476   obj_symbols (abfd) = cached_area;
2477   obj_raw_syments (abfd) = native_symbols;
2478
2479   bfd_get_symcount (abfd) = number_of_symbols;
2480   obj_convert (abfd) = table_ptr;
2481   /* Slurp the line tables for each section too */
2482   {
2483     asection *p;
2484     p = abfd->sections;
2485     while (p)
2486       {
2487         coff_slurp_line_table (abfd, p);
2488         p = p->next;
2489       }
2490   }
2491   return true;
2492 }                               /* coff_slurp_symbol_table() */
2493
2494 /* Check whether a symbol is globally visible.  This is used by the
2495    COFF backend linker code in cofflink.c, since a couple of targets
2496    have globally visible symbols which are not class C_EXT.  This
2497    function need not handle the case of n_class == C_EXT.  */
2498
2499 #undef OTHER_GLOBAL_CLASS
2500
2501 #ifdef I960
2502 #define OTHER_GLOBAL_CLASS C_LEAFEXT
2503 #endif
2504
2505 #ifdef RS6000COFF_C
2506 #define OTHER_GLOBAL_CLASS C_HIDEXT
2507 #endif
2508
2509 #ifdef COFF_WITH_PE
2510 #define OTHER_GLOBAL_CLASS C_SECTION
2511 #endif
2512
2513 #ifdef OTHER_GLOBAL_CLASS
2514
2515 static boolean
2516 coff_sym_is_global (abfd, syment)
2517      bfd *abfd;
2518      struct internal_syment *syment;
2519 {
2520   if (syment->n_sclass == OTHER_GLOBAL_CLASS)
2521     return true;
2522   return false;
2523 }
2524
2525 #undef OTHER_GLOBAL_CLASS
2526
2527 #else /* ! defined (OTHER_GLOBAL_CLASS) */
2528
2529 /* sym_is_global should not be defined if it has nothing to do.  */
2530
2531 #define coff_sym_is_global 0
2532
2533 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
2534
2535 /*
2536 SUBSUBSECTION
2537         Reading relocations
2538
2539         Coff relocations are easily transformed into the internal BFD form
2540         (@code{arelent}).
2541
2542         Reading a coff relocation table is done in the following stages:
2543
2544         o Read the entire coff relocation table into memory.
2545
2546         o Process each relocation in turn; first swap it from the
2547         external to the internal form.
2548
2549         o Turn the symbol referenced in the relocation's symbol index
2550         into a pointer into the canonical symbol table.
2551         This table is the same as the one returned by a call to
2552         @code{bfd_canonicalize_symtab}. The back end will call that
2553         routine and save the result if a canonicalization hasn't been done.
2554
2555         o The reloc index is turned into a pointer to a howto
2556         structure, in a back end specific way. For instance, the 386
2557         and 960 use the @code{r_type} to directly produce an index
2558         into a howto table vector; the 88k subtracts a number from the
2559         @code{r_type} field and creates an addend field.
2560
2561
2562 */
2563
2564 #ifndef CALC_ADDEND
2565 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
2566   {                                                             \
2567     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
2568     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
2569       coffsym = (obj_symbols (abfd)                             \
2570                  + (cache_ptr->sym_ptr_ptr - symbols));         \
2571     else if (ptr)                                               \
2572       coffsym = coff_symbol_from (abfd, ptr);                   \
2573     if (coffsym != (coff_symbol_type *) NULL                    \
2574         && coffsym->native->u.syment.n_scnum == 0)              \
2575       cache_ptr->addend = 0;                                    \
2576     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
2577              && ptr->section != (asection *) NULL)              \
2578       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
2579     else                                                        \
2580       cache_ptr->addend = 0;                                    \
2581   }
2582 #endif
2583
2584 static boolean
2585 coff_slurp_reloc_table (abfd, asect, symbols)
2586      bfd * abfd;
2587      sec_ptr asect;
2588      asymbol ** symbols;
2589 {
2590   RELOC *native_relocs;
2591   arelent *reloc_cache;
2592   arelent *cache_ptr;
2593
2594   unsigned int idx;
2595
2596   if (asect->relocation)
2597     return true;
2598   if (asect->reloc_count == 0)
2599     return true;
2600   if (asect->flags & SEC_CONSTRUCTOR)
2601     return true;
2602   if (!coff_slurp_symbol_table (abfd))
2603     return false;
2604   native_relocs =
2605     (RELOC *) buy_and_read (abfd,
2606                             asect->rel_filepos,
2607                             SEEK_SET,
2608                             (size_t) (RELSZ *
2609                                       asect->reloc_count));
2610   reloc_cache = (arelent *)
2611     bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
2612
2613   if (reloc_cache == NULL)
2614     {
2615       bfd_set_error (bfd_error_no_memory);
2616       return false;
2617     }
2618
2619
2620   for (idx = 0; idx < asect->reloc_count; idx++)
2621     {
2622 #ifdef RELOC_PROCESSING
2623       struct internal_reloc dst;
2624       struct external_reloc *src;
2625
2626       cache_ptr = reloc_cache + idx;
2627       src = native_relocs + idx;
2628       coff_swap_reloc_in (abfd, src, &dst);
2629
2630       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
2631 #else
2632       struct internal_reloc dst;
2633       asymbol *ptr;
2634       struct external_reloc *src;
2635
2636       cache_ptr = reloc_cache + idx;
2637       src = native_relocs + idx;
2638
2639       coff_swap_reloc_in (abfd, src, &dst);
2640
2641
2642       cache_ptr->address = dst.r_vaddr;
2643
2644       if (dst.r_symndx != -1)
2645         {
2646           /* @@ Should never be greater than count of symbols!  */
2647           if (dst.r_symndx >= obj_conv_table_size (abfd))
2648             abort ();
2649           cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
2650           ptr = *(cache_ptr->sym_ptr_ptr);
2651         }
2652       else
2653         {
2654           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2655           ptr = 0;
2656         }
2657
2658       /* The symbols definitions that we have read in have been
2659          relocated as if their sections started at 0. But the offsets
2660          refering to the symbols in the raw data have not been
2661          modified, so we have to have a negative addend to compensate.
2662
2663          Note that symbols which used to be common must be left alone */
2664
2665       /* Calculate any reloc addend by looking at the symbol */
2666       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
2667
2668       cache_ptr->address -= asect->vma;
2669 /* !!     cache_ptr->section = (asection *) NULL;*/
2670
2671       /* Fill in the cache_ptr->howto field from dst.r_type */
2672       RTYPE2HOWTO (cache_ptr, &dst);
2673 #endif
2674
2675     }
2676
2677   asect->relocation = reloc_cache;
2678   return true;
2679 }
2680
2681 #ifndef coff_rtype_to_howto
2682 #ifdef RTYPE2HOWTO
2683
2684 /* Get the howto structure for a reloc.  This is only used if the file
2685    including this one defines coff_relocate_section to be
2686    _bfd_coff_generic_relocate_section, so it is OK if it does not
2687    always work.  It is the responsibility of the including file to
2688    make sure it is reasonable if it is needed.  */
2689
2690 static reloc_howto_type *coff_rtype_to_howto
2691   PARAMS ((bfd *, asection *, struct internal_reloc *,
2692            struct coff_link_hash_entry *, struct internal_syment *,
2693            bfd_vma *));
2694
2695 /*ARGSUSED*/
2696 static reloc_howto_type *
2697 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
2698      bfd *abfd;
2699      asection *sec;
2700      struct internal_reloc *rel;
2701      struct coff_link_hash_entry *h;
2702      struct internal_syment *sym;
2703      bfd_vma *addendp;
2704 {
2705   arelent genrel;
2706
2707   RTYPE2HOWTO (&genrel, rel);
2708   return genrel.howto;
2709 }
2710
2711 #else /* ! defined (RTYPE2HOWTO) */
2712
2713 #define coff_rtype_to_howto NULL
2714
2715 #endif /* ! defined (RTYPE2HOWTO) */
2716 #endif /* ! defined (coff_rtype_to_howto) */
2717
2718 /* This is stupid.  This function should be a boolean predicate.  */
2719 static long
2720 coff_canonicalize_reloc (abfd, section, relptr, symbols)
2721      bfd * abfd;
2722      sec_ptr section;
2723      arelent ** relptr;
2724      asymbol ** symbols;
2725 {
2726   arelent *tblptr = section->relocation;
2727   unsigned int count = 0;
2728
2729
2730   if (section->flags & SEC_CONSTRUCTOR)
2731     {
2732       /* this section has relocs made up by us, they are not in the
2733        file, so take them out of their chain and place them into
2734        the data area provided */
2735       arelent_chain *chain = section->constructor_chain;
2736       for (count = 0; count < section->reloc_count; count++)
2737         {
2738           *relptr++ = &chain->relent;
2739           chain = chain->next;
2740         }
2741
2742     }
2743   else
2744     {
2745       if (! coff_slurp_reloc_table (abfd, section, symbols))
2746         return -1;
2747
2748       tblptr = section->relocation;
2749
2750       for (; count++ < section->reloc_count;)
2751         *relptr++ = tblptr++;
2752
2753
2754     }
2755   *relptr = 0;
2756   return section->reloc_count;
2757 }
2758
2759 #ifdef GNU960
2760 file_ptr
2761 coff_sym_filepos (abfd)
2762      bfd *abfd;
2763 {
2764   return obj_sym_filepos (abfd);
2765 }
2766 #endif
2767
2768 #ifndef coff_reloc16_estimate
2769 #define coff_reloc16_estimate dummy_reloc16_estimate
2770
2771 static int
2772 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
2773      bfd *abfd;
2774      asection *input_section;
2775      arelent *reloc;
2776      unsigned int shrink;
2777      struct bfd_link_info *link_info;
2778 {
2779   abort ();
2780 }
2781
2782 #endif
2783
2784 #ifndef coff_reloc16_extra_cases
2785 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
2786 /* This works even if abort is not declared in any header file.  */
2787 static void
2788 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
2789                            dst_ptr)
2790      bfd *abfd;
2791      struct bfd_link_info *link_info;
2792      struct bfd_link_order *link_order;
2793      arelent *reloc;
2794      bfd_byte *data;
2795      unsigned int *src_ptr;
2796      unsigned int *dst_ptr;
2797 {
2798   fprintf (stderr, "%s\n", reloc->howto->name);
2799   abort ();
2800 }
2801 #endif
2802
2803 /* If coff_relocate_section is defined, we can use the optimized COFF
2804    backend linker.  Otherwise we must continue to use the old linker.  */
2805 #ifdef coff_relocate_section
2806 #ifndef coff_bfd_link_hash_table_create
2807 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
2808 #endif
2809 #ifndef coff_bfd_link_add_symbols
2810 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
2811 #endif
2812 #ifndef coff_bfd_final_link
2813 #define coff_bfd_final_link _bfd_coff_final_link
2814 #endif
2815 #else /* ! defined (coff_relocate_section) */
2816 #define coff_relocate_section NULL
2817 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
2818 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
2819 #define coff_bfd_final_link _bfd_generic_final_link
2820 #endif /* ! defined (coff_relocate_section) */
2821 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
2822
2823 #ifndef coff_start_final_link
2824 #define coff_start_final_link NULL
2825 #endif
2826
2827 #ifndef coff_adjust_symndx
2828 #define coff_adjust_symndx NULL
2829 #endif
2830
2831 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
2832 {
2833   coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
2834   coff_swap_aux_out, coff_swap_sym_out,
2835   coff_swap_lineno_out, coff_swap_reloc_out,
2836   coff_swap_filehdr_out, coff_swap_aouthdr_out,
2837   coff_swap_scnhdr_out,
2838   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
2839 #ifdef COFF_LONG_FILENAMES
2840   true,
2841 #else
2842   false,
2843 #endif
2844   coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
2845   coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
2846   coff_mkobject_hook, styp_to_sec_flags, coff_make_section_hook,
2847   coff_set_alignment_hook, coff_slurp_symbol_table, symname_in_debug_hook,
2848   coff_reloc16_extra_cases, coff_reloc16_estimate,
2849   coff_sym_is_global, coff_compute_section_file_positions,
2850   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
2851   coff_adjust_symndx
2852 };
2853
2854 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
2855 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
2856 #define coff_get_section_contents _bfd_generic_get_section_contents
2857
2858 #define coff_bfd_copy_private_symbol_data \
2859   _bfd_generic_bfd_copy_private_symbol_data
2860 #define coff_bfd_copy_private_section_data \
2861   _bfd_generic_bfd_copy_private_section_data
2862 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
2863 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
2864 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
2865
2866 #ifndef coff_bfd_print_private_bfd_data
2867 #define coff_bfd_print_private_bfd_data \
2868    _bfd_generic_bfd_print_private_bfd_data
2869 #endif
2870
2871 #ifndef coff_bfd_is_local_label
2872 #define coff_bfd_is_local_label bfd_generic_is_local_label
2873 #endif
2874 #ifndef coff_read_minisymbols
2875 #define coff_read_minisymbols _bfd_generic_read_minisymbols
2876 #endif
2877 #ifndef coff_minisymbol_to_symbol
2878 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
2879 #endif
2880
2881 /* The reloc lookup routine must be supplied by each individual COFF
2882    backend.  */
2883 #ifndef coff_bfd_reloc_type_lookup
2884 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
2885 #endif
2886
2887 #ifndef coff_bfd_get_relocated_section_contents
2888 #define coff_bfd_get_relocated_section_contents \
2889   bfd_generic_get_relocated_section_contents
2890 #endif
2891 #ifndef coff_bfd_relax_section
2892 #define coff_bfd_relax_section bfd_generic_relax_section
2893 #endif