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