contrib/gdb/bfd/coffcode.h

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