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