bfd/coffcode.h

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