bfd/coffcode.h

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