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