bfd/coffcode.h

   1 /* Support for the generic parts of most COFF variants, for BFD.
   2    Copyright 1990, 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, 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 difference 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 implimented 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         @code{coff-m88k.c}. This file @code{#include}s
  39         @code{coff/m88k.h} which defines the external structure of the
  40         coff format for the 88k, and @code{coff/internal.h} which
  41         defines the internal structure. @code{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         @code{coff-i960.c}. This file has the same structure as
  47         @code{coff-m88k.c}, except that it includes @code{coff/i960.h}
  48         rather than @code{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         implimentations the version of coff which is most like the one
  55         you want to use, for our purposes, we'll say that i386 coff is
  56         the one you select, and that your coff flavour is called foo.
  57         Copy the @code{i386coff.c} to @code{foocoff.c}, copy
  58         @code{../include/coff/i386.h} to @code{../include/coff/foo.h}
  59         and add the lines to @code{targets.c} and @code{Makefile.in}
  60         so that your new back end is used. Alter the shapes of the
  61         structures in @code{../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 @code{coff/internal.h} and
  64         @code{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 @code{objdump} from the @code{binutils} directory,
  68         and making sure that its version of what's going on at your
  69         host systems 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 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         descibing the external layout of the structures. There is also
 116         an internal description of the coff layout (in
 117         @code{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         @code{coffcode.h}. Eg 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 for 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.  This 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 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 changes 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 in 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 was born, and on output
 194         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. Note that 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 to an index into the symbol table of the symbol
 229         being referenced.
 230
 231         o coff_write_symbols
 232
 233         This routine runs through the symbol table and patches up the
 234         symbols from their internal form into the coff way, calls the
 235         bit twiddlers and writes out the tabel to the file.
 236
 237 */
 238
 239 /*
 240 INTERNAL_DEFINITION
 241         coff_symbol_type
 242
 243 DESCRIPTION
 244         The hidden information for an asymbol is described in a
 245         coff_ptr_struct, which is typedefed to a combined_entry_type
 246
 247 CODE_FRAGMENT
 248 .
 249 .typedef struct coff_ptr_struct
 250 .{
 251 .
 252 .       {* Remembers the offset from the first symbol in the file for
 253 .          this symbol. Generated by coff_renumber_symbols. *}
 254 .unsigned int offset;
 255 .
 256 .       {* Should the tag field of this symbol be renumbered.
 257 .          Created by coff_pointerize_aux. *}
 258 .char fix_tag;
 259 .
 260 .       {* Should the endidx field of this symbol be renumbered.
 261 .          Created by coff_pointerize_aux. *}
 262 .char fix_end;
 263 .
 264 .       {* The container for the symbol structure as read and translated
 265 .           from the file. *}
 266 .
 267 .union {
 268 .   union internal_auxent auxent;
 269 .   struct internal_syment syment;
 270 . } u;
 271 .} combined_entry_type;
 272 .
 273 .
 274 .{* Each canonical asymbol really looks like this: *}
 275 .
 276 .typedef struct coff_symbol_struct
 277 .{
 278 .   {* The actual symbol which the rest of BFD works with *}
 279 .asymbol symbol;
 280 .
 281 .   {* A pointer to the hidden information for this symbol *}
 282 .combined_entry_type *native;
 283 .
 284 .   {* A pointer to the linenumber information for this symbol *}
 285 .struct lineno_cache_entry *lineno;
 286 .
 287 .   {* Have the line numbers been relocated yet ? *}
 288 .boolean done_lineno;
 289 .} coff_symbol_type;
 290
 291
 292 */
 293
 294 #include "seclet.h"
 295 #include "coffswap.h"
 296 \f
 297 /* void warning(); */
 298
 299 /*
 300  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
 301  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
 302  * NOTE: If you add to/change this routine, you should mirror the changes
 303  *      in styp_to_sec_flags().
 304  */
 305 static long
 306 DEFUN(sec_to_styp_flags, (sec_name, sec_flags),
 307         CONST char *            sec_name        AND
 308         flagword        sec_flags)
 309 {
 310     long styp_flags = 0;
 311
 312     if (!strcmp(sec_name, _TEXT)) {
 313         return((long)STYP_TEXT);
 314     } else if (!strcmp(sec_name, _DATA)) {
 315         return((long)STYP_DATA);
 316 #ifdef TWO_DATA_SECS
 317     } else if (!strcmp(sec_name, ".data2")) {
 318         return((long)STYP_DATA);
 319 #endif /* TWO_DATA_SECS */
 320     } else if (!strcmp(sec_name, _BSS)) {
 321         return((long)STYP_BSS);
 322 #ifdef _COMMENT
 323     } else if (!strcmp(sec_name, _COMMENT)) {
 324         return((long)STYP_INFO);
 325 #endif /* _COMMENT */
 326 #ifdef _LIB
 327     } else if (!strcmp(sec_name, _LIB)) {
 328         return((long)STYP_LIB);
 329 #endif /* _LIB */
 330     }
 331
 332 /* Try and figure out what it should be */
 333    if (sec_flags & SEC_CODE) styp_flags = STYP_TEXT;
 334    if (sec_flags & SEC_DATA) styp_flags = STYP_DATA;
 335    else if (sec_flags & SEC_READONLY)
 336 #ifdef STYP_LIT /* 29k readonly text/data section */
 337         styp_flags = STYP_LIT;
 338 #else
 339         styp_flags = STYP_TEXT;
 340 #endif  /* STYP_LIT */
 341    else if (sec_flags & SEC_LOAD) styp_flags = STYP_TEXT;
 342
 343    if (styp_flags == 0) styp_flags = STYP_BSS;
 344
 345 #ifdef STYP_NOLOAD
 346    if (sec_flags & SEC_NEVER_LOAD)
 347         styp_flags |= STYP_NOLOAD;
 348 #endif
 349
 350    return(styp_flags);
 351 }
 352 /*
 353  * Return a word with SEC_* flags set to represent the incoming
 354  * STYP_* flags (from scnhdr.s_flags).   The inverse of this
 355  * function is sec_to_styp_flags().
 356  * NOTE: If you add to/change this routine, you should mirror the changes
 357  *      in sec_to_styp_flags().
 358  */
 359 static flagword
 360 DEFUN(styp_to_sec_flags, (abfd, hdr),
 361       bfd *abfd AND
 362       PTR hdr)
 363 {
 364   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
 365   long styp_flags = internal_s->s_flags;
 366   flagword      sec_flags=0;
 367
 368 #ifdef STYP_NOLOAD
 369   if (styp_flags & STYP_NOLOAD)
 370   {
 371     sec_flags |= SEC_NEVER_LOAD;
 372   }
 373 #endif /* STYP_NOLOAD */
 374
 375   /* For 386 COFF, at least, an unloadable text or data section is
 376      actually a shared library section.  */
 377   if (styp_flags & STYP_TEXT)
 378   {
 379     if (sec_flags & SEC_NEVER_LOAD)
 380       sec_flags |= SEC_CODE | SEC_SHARED_LIBRARY;
 381     else
 382       sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
 383   }
 384   else if (styp_flags & STYP_DATA)
 385   {
 386     if (sec_flags & SEC_NEVER_LOAD)
 387       sec_flags |= SEC_DATA | SEC_SHARED_LIBRARY;
 388     else
 389       sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
 390   }
 391   else if (styp_flags & STYP_BSS)
 392   {
 393     sec_flags |= SEC_ALLOC;
 394   }
 395   else if (styp_flags & STYP_INFO)
 396   {
 397     sec_flags |= SEC_NEVER_LOAD;
 398   }
 399   else
 400   {
 401     sec_flags |= SEC_ALLOC | SEC_LOAD;
 402   }
 403
 404 #ifdef STYP_LIT                 /* A29k readonly text/data section type */
 405   if ((styp_flags & STYP_LIT) == STYP_LIT)
 406   {
 407     sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
 408   }
 409 #endif                          /* STYP_LIT */
 410 #ifdef STYP_OTHER_LOAD          /* Other loaded sections */
 411   if (styp_flags & STYP_OTHER_LOAD)
 412   {
 413     sec_flags = (SEC_LOAD | SEC_ALLOC);
 414   }
 415 #endif                          /* STYP_SDATA */
 416
 417   return(sec_flags);
 418 }
 419
 420 #define get_index(symbol)       ((int) (symbol)->udata)
 421
 422 /*
 423 INTERNAL_DEFINITION
 424         bfd_coff_backend_data
 425
 426 CODE_FRAGMENT
 427
 428 Special entry points for gdb to swap in coff symbol table parts
 429 .typedef struct
 430 .{
 431 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 432 .       bfd            *abfd ,
 433 .       PTR             ext,
 434 .       int             type,
 435 .       int             class ,
 436 .       PTR             in));
 437 .
 438 .  void (*_bfd_coff_swap_sym_in) PARAMS ((
 439 .       bfd            *abfd ,
 440 .       PTR             ext,
 441 .       PTR             in));
 442 .
 443 .  void (*_bfd_coff_swap_lineno_in) PARAMS ((
 444 .       bfd            *abfd,
 445 .       PTR            ext,
 446 .       PTR             in));
 447 .
 448
 449 Special entry points for gas to swap coff parts
 450
 451 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
 452 .       bfd     *abfd,
 453 .       PTR     in,
 454 .       int     type,
 455 .       int     class,
 456 .       PTR     ext));
 457 .
 458 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
 459 .      bfd      *abfd,
 460 .      PTR      in,
 461 .      PTR      ext));
 462 .
 463 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
 464 .       bfd     *abfd,
 465 .       PTR     in,
 466 .       PTR     ext));
 467 .
 468 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
 469 .       bfd     *abfd,
 470 .       PTR     src,
 471 .       PTR     dst));
 472 .
 473 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
 474 .       bfd     *abfd,
 475 .       PTR     in,
 476 .       PTR     out));
 477 .
 478 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
 479 .       bfd     *abfd,
 480 .       PTR     in,
 481 .       PTR     out));
 482 .
 483 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
 484 .       bfd     *abfd,
 485 .       PTR     in,
 486 .       PTR     out));
 487 .
 488
 489 Special entry points for generic COFF routines to call target
 490 dependent COFF routines
 491
 492 . unsigned int _bfd_filhsz;
 493 . unsigned int _bfd_aoutsz;
 494 . unsigned int _bfd_scnhsz;
 495 . unsigned int _bfd_symesz;
 496 . unsigned int _bfd_auxesz;
 497 . unsigned int _bfd_linesz;
 498 . boolean _bfd_coff_long_filenames;
 499 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
 500 .       bfd     *abfd,
 501 .       PTR     ext,
 502 .       PTR     in));
 503 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
 504 .       bfd     *abfd,
 505 .       PTR     ext,
 506 .       PTR     in));
 507 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
 508 .       bfd     *abfd,
 509 .       PTR     ext,
 510 .       PTR     in));
 511 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
 512 .       bfd     *abfd,
 513 .       PTR     internal_filehdr));
 514 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
 515 .       bfd     *abfd,
 516 .       PTR     internal_filehdr));
 517 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
 518 .       bfd     *abfd,
 519 .       PTR     internal_filehdr));
 520 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
 521 .       bfd     *abfd,
 522 .       PTR     internal_scnhdr));
 523 . asection *(*_bfd_make_section_hook) PARAMS ((
 524 .       bfd     *abfd,
 525 .       char    *name));
 526 . void (*_bfd_set_alignment_hook) PARAMS ((
 527 .       bfd     *abfd,
 528 .       asection *sec,
 529 .       PTR     internal_scnhdr));
 530 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
 531 .       bfd     *abfd));
 532 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
 533 .       bfd     *abfd,
 534 .       struct internal_syment *sym));
 535 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
 536 .       bfd     *abfd,
 537 .       bfd_seclet_type *seclet,
 538 .       arelent *reloc,
 539 .       bfd_byte *data,
 540 .       unsigned int *src_ptr,
 541 .       unsigned int *dst_ptr));
 542 .} bfd_coff_backend_data;
 543 .
 544 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
 545 .
 546 .#define bfd_coff_swap_aux_in(a,e,t,c,i) \
 547 .        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,i))
 548 .
 549 .#define bfd_coff_swap_sym_in(a,e,i) \
 550 .        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
 551 .
 552 .#define bfd_coff_swap_lineno_in(a,e,i) \
 553 .        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
 554 .
 555 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 556 .        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
 557 .
 558 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 559 .        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
 560 .
 561 .#define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
 562 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aux_out) (abfd, i,t,c, o))
 563 .
 564 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 565 .        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
 566 .
 567 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 568 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
 569 .
 570 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 571 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
 572 .
 573 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 574 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
 575 .
 576 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
 577 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
 578 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
 579 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
 580 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
 581 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
 582 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
 583 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 584 .        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
 585 .
 586 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 587 .        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
 588 .
 589 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
 590 .        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
 591 .
 592 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
 593 .        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
 594 .
 595 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
 596 .        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
 597 .#define bfd_coff_mkobject_hook(abfd, filehdr)\
 598 .        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr))
 599 .
 600 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr)\
 601 .        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr))
 602 .
 603 .#define bfd_coff_make_section_hook(abfd, name)\
 604 .        ((coff_backend_info (abfd)->_bfd_make_section_hook) (abfd, name))
 605 .
 606 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
 607 .        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
 608 .
 609 .#define bfd_coff_slurp_symbol_table(abfd)\
 610 .        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
 611 .
 612 .#define bfd_coff_symname_in_debug(abfd, sym)\
 613 .        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
 614 .
 615 .#define bfd_coff_reloc16_extra_cases(abfd, seclet, reloc, data, src_ptr, dst_ptr)\
 616 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
 617 .         (abfd, seclet, reloc, data, src_ptr, dst_ptr))
 618 .
 619 */
 620
 621 /* See whether the magic number matches.  */
 622
 623 static boolean
 624 DEFUN(coff_bad_format_hook, (abfd, filehdr),
 625       bfd *abfd AND
 626       PTR filehdr)
 627 {
 628   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 629
 630   if (BADMAG (*internal_f))
 631     return false;
 632
 633   /* if the optional header is NULL or not the correct size then
 634      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
 635      and Intel 960 readwrite headers (I960WRMAGIC) is that the
 636      optional header is of a different size.
 637
 638      But the mips keeps extra stuff in it's opthdr, so dont check
 639      when doing that
 640      */
 641
 642 #if defined(M88) || defined(I960)
 643   if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
 644     return false;
 645 #endif
 646
 647   return true;
 648 }
 649
 650 static asection *
 651 DEFUN (coff_make_section_hook, (abfd, name),
 652        bfd *abfd AND
 653        char *name)
 654 {
 655 #ifdef TWO_DATA_SECS
 656   /* On SCO a file created by the Microsoft assembler can have two
 657      .data sections.  We use .data2 for the second one.  */
 658   if (strcmp (name, _DATA) == 0)
 659     return bfd_make_section (abfd, ".data2");
 660 #endif
 661   return (asection *) NULL;
 662 }
 663
 664 /*
 665    initialize a section structure with information peculiar to this
 666    particular implementation of coff
 667 */
 668
 669 static boolean
 670 DEFUN(coff_new_section_hook,(abfd, section),
 671       bfd            *abfd AND
 672       asection       *section)
 673 {
 674   section->alignment_power = abfd->xvec->align_power_min;
 675   /* Allocate aux records for section symbols, to store size and
 676      related info.
 677
 678      @@ Shouldn't use constant multiplier here!  */
 679   coffsymbol (section->symbol)->native =
 680     (combined_entry_type *) bfd_zalloc (abfd,
 681                                         sizeof (combined_entry_type) * 10);
 682   return true;
 683 }
 684
 685
 686 #ifdef I960
 687
 688 /* Set the alignment of a BFD section.  */
 689
 690 static void
 691 DEFUN (coff_set_alignment_hook, (abfd, section, scnhdr),
 692        bfd *abfd AND
 693        asection *section AND
 694        PTR scnhdr)
 695 {
 696   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
 697   unsigned int i;
 698
 699   for (i = 0; i < 32; i++)
 700     if ((1 << i) >= hdr->s_align)
 701       break;
 702   section->alignment_power = i;
 703 }
 704
 705 #else /* ! I960 */
 706
 707 #define coff_set_alignment_hook \
 708   ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
 709
 710 #endif /* ! I960 */
 711
 712 static          boolean
 713 DEFUN(coff_mkobject,(abfd),
 714       bfd            *abfd)
 715 {
 716   coff_data_type *coff;
 717
 718   abfd->tdata.coff_obj_data = (struct coff_tdata *)bfd_zalloc (abfd,sizeof(coff_data_type));
 719   if (abfd->tdata.coff_obj_data == 0){
 720     bfd_error = no_memory;
 721     return false;
 722   }
 723   coff = coff_data (abfd);
 724   coff->symbols = (coff_symbol_type *) NULL;
 725   coff->conversion_table = (unsigned int *) NULL;
 726   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 727   coff->raw_linenos = (struct lineno *) NULL;
 728   coff->relocbase = 0;
 729 /*  make_abs_section(abfd);*/
 730   return true;
 731 }
 732
 733 /* Create the COFF backend specific information.  */
 734
 735 static          PTR
 736 DEFUN(coff_mkobject_hook,(abfd, filehdr),
 737       bfd            *abfd AND
 738       PTR            filehdr)
 739 {
 740   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 741   coff_data_type *coff;
 742
 743   if (coff_mkobject (abfd) == false)
 744     return NULL;
 745
 746   coff = coff_data (abfd);
 747
 748   coff->sym_filepos = internal_f->f_symptr;
 749   coff->flags = internal_f->f_flags;
 750
 751   /* These members communicate important constants about the symbol
 752      table to GDB's symbol-reading code.  These `constants'
 753      unfortunately vary among coff implementations...  */
 754   coff->local_n_btmask = N_BTMASK;
 755   coff->local_n_btshft = N_BTSHFT;
 756   coff->local_n_tmask  = N_TMASK;
 757   coff->local_n_tshift = N_TSHIFT;
 758   coff->local_symesz   = SYMESZ;
 759   coff->local_auxesz   = AUXESZ;
 760   coff->local_linesz   = LINESZ;
 761
 762   return (PTR) coff;
 763 }
 764
 765 /* Determine the machine architecture and type.  FIXME: This is target
 766    dependent because the magic numbers are defined in the target
 767    dependent header files.  But there is no particular need for this.
 768    If the magic numbers were moved to a separate file, this function
 769    would be target independent and would also be much more successful
 770    at linking together COFF files for different architectures.  */
 771
 772 static boolean
 773 DEFUN (coff_set_arch_mach_hook, (abfd, filehdr),
 774        bfd *abfd AND
 775        PTR filehdr)
 776 {
 777   long machine;
 778   enum bfd_architecture arch;
 779   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 780
 781   machine = 0;
 782   switch (internal_f->f_magic) {
 783 #ifdef I386MAGIC
 784   case I386MAGIC:
 785 #ifdef I386AIXMAGIC
 786   case I386AIXMAGIC:            /* Danbury PS/2 AIX C Compiler */
 787 #endif
 788     arch = bfd_arch_i386;
 789     machine = 0;
 790     break;
 791 #endif
 792
 793 #ifdef A29K_MAGIC_BIG
 794   case  A29K_MAGIC_BIG:
 795   case  A29K_MAGIC_LITTLE:
 796     arch = bfd_arch_a29k;
 797     machine = 0;
 798     break;
 799 #endif
 800
 801 #ifdef MIPS
 802   case  MIPS_MAGIC_1:
 803   case  MIPS_MAGIC_2:
 804   case  MIPS_MAGIC_3:
 805     arch = bfd_arch_mips;
 806     machine = 0;
 807     break;
 808 #endif
 809
 810 #ifdef MC68MAGIC
 811   case MC68MAGIC:
 812   case M68MAGIC:
 813     arch = bfd_arch_m68k;
 814     machine = 68020;
 815     break;
 816 #endif
 817 #ifdef MC88MAGIC
 818   case MC88MAGIC:
 819   case MC88DMAGIC:
 820   case MC88OMAGIC:
 821     arch = bfd_arch_m88k;
 822     machine = 88100;
 823     break;
 824 #endif
 825 #ifdef Z8KMAGIC
 826    case Z8KMAGIC:
 827     arch = bfd_arch_z8k;
 828     switch (internal_f->f_flags & F_MACHMASK)
 829       {
 830       case F_Z8001:
 831         machine = bfd_mach_z8001;
 832         break;
 833       case F_Z8002:
 834         machine = bfd_mach_z8002;
 835         break;
 836       default:
 837         return false;
 838       }
 839     break;
 840 #endif
 841 #ifdef I960
 842 #ifdef I960ROMAGIC
 843   case I960ROMAGIC:
 844   case I960RWMAGIC:
 845     arch = bfd_arch_i960;
 846     switch (F_I960TYPE & internal_f->f_flags)
 847         {
 848         default:
 849         case F_I960CORE:
 850           machine = bfd_mach_i960_core;
 851           break;
 852         case F_I960KB:
 853           machine = bfd_mach_i960_kb_sb;
 854           break;
 855         case  F_I960MC:
 856           machine = bfd_mach_i960_mc;
 857           break;
 858         case F_I960XA:
 859           machine = bfd_mach_i960_xa;
 860           break;
 861         case F_I960CA:
 862           machine = bfd_mach_i960_ca;
 863           break;
 864         case F_I960KA:
 865           machine = bfd_mach_i960_ka_sa;
 866           break;
 867         }
 868     break;
 869 #endif
 870 #endif
 871
 872 #ifdef U802ROMAGIC
 873   case U802ROMAGIC:
 874   case U802WRMAGIC:
 875   case U802TOCMAGIC:
 876     arch = bfd_arch_rs6000;
 877     machine = 6000;
 878     break;
 879 #endif
 880
 881 #ifdef WE32KMAGIC
 882   case WE32KMAGIC:
 883     arch = bfd_arch_we32k;
 884     machine = 0;
 885     break;
 886 #endif
 887
 888 #ifdef H8300MAGIC
 889   case H8300MAGIC:
 890     arch = bfd_arch_h8300;
 891     machine = 0;
 892     break;
 893 #endif
 894
 895   default:                      /* Unreadable input file type */
 896     arch = bfd_arch_obscure;
 897 break;
 898   }
 899
 900   bfd_default_set_arch_mach(abfd, arch, machine);
 901   return true;
 902 }
 903
 904 #ifdef SYMNAME_IN_DEBUG
 905
 906 static boolean
 907 DEFUN (symname_in_debug_hook, (abfd, sym),
 908        bfd *abfd AND
 909        struct internal_syment *sym)
 910 {
 911   return SYMNAME_IN_DEBUG (sym) ? true : false;
 912 }
 913
 914 #else
 915
 916 #define symname_in_debug_hook \
 917   (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
 918
 919 #endif
 920
 921 /*
 922 SUBSUBSECTION
 923         Writing Relocations
 924
 925         To write relocations, all the back end does is step though the
 926         canonical relocation table, and create an
 927         @code{internal_reloc}. The symbol index to use is removed from
 928         the @code{offset} field in the symbol table supplied, the
 929         address comes directly from the sum of the section base
 930         address and the relocation offset and the type is dug directly
 931         from the howto field.  Then the @code{internal_reloc} is
 932         swapped into the shape of an @code{external_reloc} and written
 933         out to disk.
 934
 935 */
 936
 937 static void
 938 DEFUN(coff_write_relocs,(abfd),
 939       bfd            *abfd)
 940 {
 941   asection       *s;
 942   for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
 943     unsigned int    i;
 944     struct external_reloc dst;
 945
 946     arelent       **p = s->orelocation;
 947     bfd_seek(abfd, s->rel_filepos, SEEK_SET);
 948     for (i = 0; i < s->reloc_count; i++) {
 949       struct internal_reloc    n;
 950       arelent        *q = p[i];
 951       memset((PTR)&n, 0, sizeof(n));
 952
 953       n.r_vaddr = q->address + s->vma;
 954       /* The 29k const/consth reloc pair is a real kludge - the consth
 955          part doesn't have a symbol - it has an offset. So rebuilt
 956          that here */
 957 #ifdef R_IHCONST
 958       if (q->howto->type == R_IHCONST)
 959         n.r_symndx = q->addend;
 960       else
 961 #endif
 962
 963
 964       if (q->sym_ptr_ptr)
 965       {
 966         if (q->sym_ptr_ptr == bfd_abs_section.symbol_ptr_ptr)
 967         {
 968           /* This is a relocation relative to the absolute symbol */
 969           n.r_symndx = -1;
 970         }
 971         else
 972         {
 973           n.r_symndx = get_index((*(q->sym_ptr_ptr)));
 974           /* Take notice if the symbol reloc points to a symbol we don't have
 975              in our symbol table.  What should we do for this??  */
 976           if (n.r_symndx > obj_conv_table_size (abfd))
 977            abort ();
 978         }
 979
 980
 981       }
 982
 983 #ifdef SELECT_RELOC
 984       /* Work out reloc type from what is required */
 985       SELECT_RELOC(n.r_type, q->howto);
 986 #else
 987       n.r_type = q->howto->type;
 988 #endif
 989       coff_swap_reloc_out(abfd, &n, &dst);
 990       bfd_write((PTR) &dst, 1, RELSZ, abfd);
 991     }
 992   }
 993 }
 994
 995 /* Set flags and magic number of a coff file from architecture and machine
 996    type.  Result is true if we can represent the arch&type, false if not.  */
 997
 998 static          boolean
 999 DEFUN(coff_set_flags,(abfd, magicp, flagsp),
1000       bfd            *abfd AND
1001       unsigned       *magicp AND
1002       unsigned short *flagsp)
1003 {
1004   switch (bfd_get_arch(abfd)) {
1005 #ifdef Z8KMAGIC
1006    case bfd_arch_z8k:
1007     *magicp = Z8KMAGIC;
1008     switch (bfd_get_mach(abfd))
1009     {
1010      case bfd_mach_z8001:
1011       *flagsp = F_Z8001;
1012       break;
1013      case bfd_mach_z8002:
1014       *flagsp = F_Z8002;
1015       break;
1016      default:
1017       return false;
1018     }
1019     return true;
1020 #endif
1021 #ifdef I960ROMAGIC
1022
1023     case bfd_arch_i960:
1024
1025       {
1026         unsigned        flags;
1027         *magicp = I960ROMAGIC;
1028         /*
1029           ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1030           I960RWMAGIC);   FIXME???
1031           */
1032         switch (bfd_get_mach(abfd)) {
1033         case bfd_mach_i960_core:
1034           flags = F_I960CORE;
1035           break;
1036         case bfd_mach_i960_kb_sb:
1037           flags = F_I960KB;
1038           break;
1039         case bfd_mach_i960_mc:
1040           flags = F_I960MC;
1041           break;
1042         case bfd_mach_i960_xa:
1043           flags = F_I960XA;
1044           break;
1045         case bfd_mach_i960_ca:
1046           flags = F_I960CA;
1047           break;
1048         case bfd_mach_i960_ka_sa:
1049           flags = F_I960KA;
1050           break;
1051         default:
1052           return false;
1053         }
1054         *flagsp = flags;
1055         return true;
1056       }
1057     break;
1058 #endif
1059 #ifdef MIPS
1060   case bfd_arch_mips:
1061     *magicp = MIPS_MAGIC_2;
1062     return true;
1063     break;
1064 #endif
1065 #ifdef I386MAGIC
1066   case bfd_arch_i386:
1067     *magicp = I386MAGIC;
1068     return true;
1069     break;
1070 #endif
1071 #ifdef MC68MAGIC
1072   case bfd_arch_m68k:
1073     *magicp = MC68MAGIC;
1074     return true;
1075     break;
1076 #endif
1077
1078 #ifdef MC88MAGIC
1079     case bfd_arch_m88k:
1080       *magicp = MC88OMAGIC;
1081       return true;
1082       break;
1083 #endif
1084 #ifdef H8300MAGIC
1085     case bfd_arch_h8300:
1086       *magicp = H8300MAGIC;
1087       return true;
1088       break;
1089 #endif
1090 #ifdef A29K_MAGIC_BIG
1091     case bfd_arch_a29k:
1092       if (abfd->xvec->byteorder_big_p)
1093        *magicp = A29K_MAGIC_BIG;
1094       else
1095        *magicp = A29K_MAGIC_LITTLE;
1096       return true;
1097       break;
1098 #endif
1099
1100 #ifdef WE32KMAGIC
1101   case bfd_arch_we32k:
1102     *magicp = WE32KMAGIC;
1103     return true;
1104     break;
1105 #endif
1106
1107 #ifdef U802TOCMAGIC
1108   case bfd_arch_rs6000:
1109     *magicp = U802TOCMAGIC;
1110     return true;
1111     break;
1112 #endif
1113
1114   default:                      /* Unknown architecture */
1115     /* return false;  -- fall through to "return false" below, to avoid
1116        "statement never reached" errors on the one below. */
1117     break;
1118   }
1119
1120   return false;
1121 }
1122
1123
1124 static          boolean
1125 DEFUN(coff_set_arch_mach,(abfd, arch, machine),
1126       bfd            *abfd AND
1127       enum bfd_architecture arch AND
1128       unsigned long   machine)
1129 {
1130   unsigned        dummy1;
1131   unsigned     short dummy2;
1132   bfd_default_set_arch_mach(abfd, arch, machine);
1133
1134   if (arch != bfd_arch_unknown &&
1135       coff_set_flags(abfd, &dummy1, &dummy2) != true)
1136     return false;               /* We can't represent this type */
1137   return true;                  /* We're easy ... */
1138 }
1139
1140
1141 /* Calculate the file position for each section. */
1142
1143 static void
1144 DEFUN(coff_compute_section_file_positions,(abfd),
1145       bfd            *abfd)
1146 {
1147   asection       *current;
1148   asection      *previous = (asection *)NULL;
1149   file_ptr        sofar = FILHSZ;
1150   file_ptr      old_sofar;
1151   if (bfd_get_start_address(abfd))
1152   {
1153     /*  A start address may have been added to the original file. In this
1154         case it will need an optional header to record it.  */
1155     abfd->flags |= EXEC_P;
1156   }
1157
1158   if (abfd->flags & EXEC_P)
1159    sofar += AOUTSZ;
1160
1161   sofar += abfd->section_count * SCNHSZ;
1162   for (current = abfd->sections;
1163        current != (asection *)NULL;
1164        current = current->next) {
1165
1166       /* Only deal with sections which have contents */
1167       if (!(current->flags & SEC_HAS_CONTENTS))
1168        continue;
1169
1170       /* Align the sections in the file to the same boundary on
1171          which they are aligned in virtual memory.  I960 doesn't
1172          do this (FIXME) so we can stay in sync with Intel.  960
1173          doesn't yet page from files... */
1174 #ifndef I960
1175     {
1176       /* make sure this section is aligned on the right boundary - by
1177          padding the previous section up if necessary */
1178
1179       old_sofar= sofar;
1180       sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
1181       if (previous != (asection *)NULL) {
1182           previous->_raw_size += sofar - old_sofar;
1183         }
1184     }
1185
1186 #endif
1187       /* FIXME, in demand paged files, the low order bits of the file
1188          offset must match the low order bits of the virtual address.
1189          "Low order" is apparently implementation defined.  Add code
1190          here to round sofar up to match the virtual address.  */
1191
1192       current->filepos = sofar;
1193
1194       sofar += current->_raw_size;
1195 #ifndef I960
1196       /* make sure that this section is of the right size too */
1197       old_sofar =  sofar;
1198       sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
1199       current->_raw_size += sofar - old_sofar ;
1200 #endif
1201
1202       previous = current;
1203     }
1204   obj_relocbase(abfd) = sofar;
1205 }
1206
1207 /* If .file, .text, .data, .bss symbols are missing, add them.  */
1208 /* @@ Should we only be adding missing symbols, or overriding the aux
1209    values for existing section symbols?  */
1210 static void
1211 coff_add_missing_symbols (abfd)
1212      bfd *abfd;
1213 {
1214   unsigned int nsyms = bfd_get_symcount (abfd);
1215   asymbol **sympp = abfd->outsymbols;
1216   asymbol **sympp2;
1217   unsigned int i;
1218   int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
1219
1220   for (i = 0; i < nsyms; i++)
1221     {
1222       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
1223       CONST char *name;
1224       if (csym)
1225       {
1226         /* only do this if there is a coff representation of the input
1227            symbol */
1228         if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
1229         {
1230           need_file = 0;
1231           continue;
1232         }
1233         name = csym->symbol.name;
1234         if (!name)
1235          continue;
1236         if (!strcmp (name, _TEXT))
1237          need_text = 0;
1238         else if (!strcmp (name, _DATA))
1239          need_data = 0;
1240         else if (!strcmp (name, _BSS))
1241          need_bss = 0;
1242       }
1243     }
1244   /* Now i == bfd_get_symcount (abfd).  */
1245   /* @@ For now, don't deal with .file symbol.  */
1246   need_file = 0;
1247
1248   if (!need_text && !need_data && !need_bss && !need_file)
1249     return;
1250   nsyms += need_text + need_data + need_bss + need_file;
1251   sympp2 = (asymbol**) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
1252   memcpy (sympp2, sympp, i * sizeof (asymbol *));
1253   if (need_file)
1254     {
1255       /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
1256       abort ();
1257     }
1258   if (need_text)
1259     sympp2[i++] = coff_section_symbol (abfd, _TEXT);
1260   if (need_data)
1261     sympp2[i++] = coff_section_symbol (abfd, _DATA);
1262   if (need_bss)
1263     sympp2[i++] = coff_section_symbol (abfd, _BSS);
1264   BFD_ASSERT (i == nsyms);
1265   bfd_set_symtab (abfd, sympp2, nsyms);
1266 }
1267
1268 /* SUPPRESS 558 */
1269 /* SUPPRESS 529 */
1270 static          boolean
1271 DEFUN(coff_write_object_contents,(abfd),
1272       bfd            *abfd)
1273 {
1274   asection       *current;
1275   unsigned int count;
1276
1277   boolean         hasrelocs = false;
1278   boolean         haslinno = false;
1279   file_ptr        reloc_base;
1280   file_ptr        lineno_base;
1281   file_ptr        sym_base;
1282   file_ptr        scn_base;
1283   file_ptr        data_base;
1284   unsigned long   reloc_size = 0;
1285   unsigned long   lnno_size = 0;
1286   asection       *text_sec = NULL;
1287   asection       *data_sec = NULL;
1288   asection       *bss_sec = NULL;
1289
1290   struct internal_filehdr internal_f;
1291   struct internal_aouthdr internal_a;
1292
1293
1294   bfd_error = system_call_error;
1295   /* Number the output sections, starting from one on the first section
1296      with a name which doesn't start with a *.
1297      @@ The code doesn't make this check.  Is it supposed to be done,
1298      or isn't it??  */
1299   count = 1;
1300   for (current = abfd->sections; current != (asection *)NULL;
1301        current = current->next)
1302   {
1303       current->target_index = count;
1304       count++;
1305   }
1306
1307   if(abfd->output_has_begun == false) {
1308       coff_compute_section_file_positions(abfd);
1309     }
1310
1311   if (abfd->sections != (asection *)NULL) {
1312       scn_base = abfd->sections->filepos;
1313     }
1314   else {
1315       scn_base = 0;
1316     }
1317   if (bfd_seek(abfd, scn_base, SEEK_SET) != 0)
1318    return false;
1319   reloc_base = obj_relocbase(abfd);
1320
1321   /* Make a pass through the symbol table to count line number entries and
1322      put them into the correct asections */
1323
1324   coff_count_linenumbers(abfd);
1325   data_base = scn_base;
1326
1327   /* Work out the size of the reloc and linno areas */
1328
1329   for (current = abfd->sections; current != NULL; current =
1330        current->next)
1331   {
1332     /* We give section headers to +ve indexes */
1333     if (current->target_index > 0)
1334     {
1335
1336       reloc_size += current->reloc_count * RELSZ;
1337       lnno_size += current->lineno_count * LINESZ;
1338       data_base += SCNHSZ;
1339     }
1340
1341   }
1342
1343   lineno_base = reloc_base + reloc_size;
1344   sym_base = lineno_base + lnno_size;
1345
1346   /* Indicate in each section->line_filepos its actual file address */
1347   for (current = abfd->sections; current != NULL; current =
1348        current->next)
1349   {
1350     if (current->target_index > 0)
1351     {
1352
1353       if (current->lineno_count) {
1354           current->line_filepos = lineno_base;
1355           current->moving_line_filepos = lineno_base;
1356           lineno_base += current->lineno_count * LINESZ;
1357         }
1358       else {
1359           current->line_filepos = 0;
1360         }
1361       if (current->reloc_count) {
1362           current->rel_filepos = reloc_base;
1363           reloc_base += current->reloc_count * RELSZ;
1364         }
1365       else {
1366           current->rel_filepos = 0;
1367         }
1368     }
1369   }
1370
1371
1372
1373   /* Write section headers to the file.  */
1374   internal_f.f_nscns = 0;
1375   bfd_seek(abfd,
1376            (file_ptr) ((abfd->flags & EXEC_P) ?
1377                        (FILHSZ + AOUTSZ) : FILHSZ),
1378            SEEK_SET);
1379
1380 {
1381 #if 0
1382   unsigned int    pad = abfd->flags & D_PAGED ? data_base : 0;
1383 #endif
1384   unsigned int    pad = 0;
1385
1386   for (current = abfd->sections;
1387        current != NULL;
1388        current = current->next) {
1389       struct internal_scnhdr section;
1390       if (current->target_index > 0)
1391       {
1392         internal_f.f_nscns ++;
1393         strncpy(&(section.s_name[0]), current->name, 8);
1394 #ifdef _LIB
1395         /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
1396            Ian Taylor <ian@cygnus.com>.  */
1397         if (strcmp (current->name, _LIB) == 0)
1398           section.s_vaddr = 0;
1399         else
1400 #endif
1401           section.s_vaddr = current->vma + pad;
1402         section.s_paddr = current->vma + pad;
1403         section.s_size = current->_raw_size - pad;
1404         /*
1405           If this section has no size or is unloadable then the scnptr
1406           will be 0 too
1407           */
1408         if (current->_raw_size - pad == 0 ||
1409             (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) {
1410             section.s_scnptr = 0;
1411           }
1412         else {
1413             section.s_scnptr = current->filepos;
1414           }
1415         section.s_relptr = current->rel_filepos;
1416         section.s_lnnoptr = current->line_filepos;
1417         section.s_nreloc = current->reloc_count;
1418         section.s_nlnno = current->lineno_count;
1419         if (current->reloc_count != 0)
1420          hasrelocs = true;
1421         if (current->lineno_count != 0)
1422          haslinno = true;
1423
1424         section.s_flags = sec_to_styp_flags(current->name,current->flags);
1425
1426         if (!strcmp(current->name, _TEXT)) {
1427             text_sec = current;
1428           } else if (!strcmp(current->name, _DATA)) {
1429               data_sec = current;
1430 #ifdef TWO_DATA_SECS
1431             } else if (!strcmp(current->name, ".data2")) {
1432               data_sec = current;
1433 #endif /* TWO_DATA_SECS */
1434             } else if (!strcmp(current->name, _BSS)) {
1435                 bss_sec = current;
1436               }
1437
1438 #ifdef I960
1439         section.s_align = (current->alignment_power
1440                            ? 1 << current->alignment_power
1441                            : 0);
1442
1443 #endif
1444       {
1445         SCNHDR          buff;
1446
1447         coff_swap_scnhdr_out(abfd, &section, &buff);
1448         bfd_write((PTR) (&buff), 1, SCNHSZ, abfd);
1449
1450       }
1451
1452         pad = 0;
1453       }
1454     }
1455 }
1456
1457
1458   /* OK, now set up the filehdr... */
1459
1460   /* Don't include the internal abs section in the section count */
1461
1462   /*
1463     We will NOT put a fucking timestamp in the header here. Every time you
1464     put it back, I will come in and take it out again.  I'm sorry.  This
1465     field does not belong here.  We fill it with a 0 so it compares the
1466     same but is not a reasonable time. -- gnu@cygnus.com
1467     */
1468   internal_f.f_timdat = 0;
1469
1470   if (bfd_get_symcount(abfd) != 0)
1471    internal_f.f_symptr = sym_base;
1472   else
1473    internal_f.f_symptr = 0;
1474
1475   internal_f.f_flags = 0;
1476
1477   if (abfd->flags & EXEC_P)
1478    internal_f.f_opthdr = AOUTSZ;
1479   else
1480    internal_f.f_opthdr = 0;
1481
1482   if (!hasrelocs)
1483    internal_f.f_flags |= F_RELFLG;
1484   if (!haslinno)
1485    internal_f.f_flags |= F_LNNO;
1486   if (0 == bfd_get_symcount(abfd))
1487    internal_f.f_flags |= F_LSYMS;
1488   if (abfd->flags & EXEC_P)
1489    internal_f.f_flags |= F_EXEC;
1490
1491   if (!abfd->xvec->byteorder_big_p)
1492    internal_f.f_flags |= F_AR32WR;
1493   else
1494   internal_f.f_flags |= F_AR32W;
1495
1496   /*
1497     FIXME, should do something about the other byte orders and
1498     architectures.
1499     */
1500
1501   /* Set up architecture-dependent stuff */
1502
1503 { unsigned int   magic = 0;
1504   unsigned short    flags = 0;
1505   coff_set_flags(abfd, &magic, &flags);
1506   internal_f.f_magic = magic;
1507   internal_f.f_flags |= flags;
1508   /* ...and the "opt"hdr... */
1509
1510 #ifdef A29K
1511 # ifdef ULTRA3                  /* NYU's machine */
1512   /* FIXME: This is a bogus check.  I really want to see if there
1513    * is a .shbss or a .shdata section, if so then set the magic
1514    * number to indicate a shared data executable.
1515    */
1516   if (internal_f.f_nscns >= 7)
1517    internal_a.magic = SHMAGIC;  /* Shared magic */
1518   else
1519 # endif                         /* ULTRA3 */
1520    internal_a.magic = NMAGIC;   /* Assume separate i/d */
1521 #define __A_MAGIC_SET__
1522 #endif                          /* A29K */
1523 #ifdef I960
1524   internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
1525 #define __A_MAGIC_SET__
1526 #endif                          /* I960 */
1527 #if M88
1528 #define __A_MAGIC_SET__
1529   internal_a.magic = PAGEMAGICBCS;
1530 #endif                          /* M88 */
1531
1532 #if M68 || MIPS || WE32K
1533 #define __A_MAGIC_SET__
1534   /* Never was anything here for the 68k */
1535 #endif                          /* M68 || MIPS || WE32K */
1536
1537 #if I386
1538 # define __A_MAGIC_SET__
1539   internal_a.magic = ZMAGIC;
1540 #endif /* I386 */
1541
1542 #if RS6000COFF_C
1543 #define __A_MAGIC_SET__
1544   internal_a.magic = (abfd->flags & D_PAGED)? RS6K_AOUTHDR_ZMAGIC:
1545   (abfd->flags & WP_TEXT)? RS6K_AOUTHDR_NMAGIC:
1546   RS6K_AOUTHDR_OMAGIC;
1547 #endif
1548
1549 #ifndef __A_MAGIC_SET__
1550 # include "Your aouthdr magic number is not being set!"
1551 #else
1552 # undef __A_MAGIC_SET__
1553 #endif
1554 }
1555   /* Now should write relocs, strings, syms */
1556   obj_sym_filepos(abfd) = sym_base;
1557
1558   if (bfd_get_symcount(abfd) != 0) {
1559       coff_add_missing_symbols (abfd);
1560       coff_renumber_symbols(abfd);
1561       coff_mangle_symbols(abfd);
1562       coff_write_symbols(abfd);
1563       coff_write_linenumbers(abfd);
1564       coff_write_relocs(abfd);
1565     }
1566   if (text_sec) {
1567       internal_a.tsize = bfd_get_section_size_before_reloc(text_sec);
1568       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
1569     }
1570   if (data_sec) {
1571       internal_a.dsize = bfd_get_section_size_before_reloc(data_sec);
1572       internal_a.data_start = internal_a.dsize ? data_sec->vma      : 0;
1573     }
1574   if (bss_sec) {
1575       internal_a.bsize = bfd_get_section_size_before_reloc(bss_sec);
1576     }
1577
1578   internal_a.entry = bfd_get_start_address(abfd);
1579   internal_f.f_nsyms =  bfd_get_symcount(abfd);
1580
1581   /* now write them */
1582   if (bfd_seek(abfd, (file_ptr) 0, SEEK_SET) != 0)
1583    return false;
1584 {
1585   FILHDR buff;
1586   coff_swap_filehdr_out(abfd, (PTR)&internal_f, (PTR)&buff);
1587   bfd_write((PTR) &buff, 1, FILHSZ, abfd);
1588 }
1589   if (abfd->flags & EXEC_P) {
1590       AOUTHDR buff;
1591       coff_swap_aouthdr_out(abfd, (PTR)&internal_a, (PTR)&buff);
1592       bfd_write((PTR) &buff, 1, AOUTSZ, abfd);
1593     }
1594   return true;
1595 }
1596
1597 static          boolean
1598 DEFUN(coff_set_section_contents,(abfd, section, location, offset, count),
1599       bfd            *abfd AND
1600       sec_ptr         section AND
1601       PTR             location AND
1602       file_ptr        offset AND
1603       bfd_size_type   count)
1604 {
1605     if (abfd->output_has_begun == false)        /* set by bfd.c handler */
1606         coff_compute_section_file_positions(abfd);
1607
1608 #ifdef _LIB
1609     /* If this is a .lib section, bump the vma address so that it
1610        winds up being the number of .lib sections output.  This is
1611        right for SVR3.2.  Shared libraries should probably get more
1612        generic support.  Ian Taylor <ian@cygnus.com>.  */
1613     if (strcmp (section->name, _LIB) == 0)
1614       ++section->vma;
1615 #endif
1616
1617     bfd_seek(abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
1618
1619     if (count != 0) {
1620         return (bfd_write(location, 1, count, abfd) == count) ? true : false;
1621     }
1622     return true;
1623 }
1624 #if 0
1625 static          boolean
1626 coff_close_and_cleanup(abfd)
1627     bfd            *abfd;
1628 {
1629   if (!bfd_read_p(abfd))
1630     switch (abfd->format) {
1631     case bfd_archive:
1632       if (!_bfd_write_archive_contents(abfd))
1633         return false;
1634       break;
1635     case bfd_object:
1636       if (!coff_write_object_contents(abfd))
1637         return false;
1638       break;
1639     default:
1640       bfd_error = invalid_operation;
1641       return false;
1642     }
1643
1644   /* We depend on bfd_close to free all the memory on the obstack.  */
1645   /* FIXME if bfd_release is not using obstacks! */
1646   return true;
1647 }
1648
1649 #endif
1650
1651 static PTR
1652 buy_and_read(abfd, where, seek_direction, size)
1653     bfd            *abfd;
1654     file_ptr        where;
1655     int             seek_direction;
1656     size_t          size;
1657 {
1658     PTR             area = (PTR) bfd_alloc(abfd, size);
1659     if (!area) {
1660         bfd_error = no_memory;
1661         return (NULL);
1662     }
1663     bfd_seek(abfd, where, seek_direction);
1664     if (bfd_read(area, 1, size, abfd) != size) {
1665         bfd_error = system_call_error;
1666         return (NULL);
1667     }                           /* on error */
1668     return (area);
1669 }                               /* buy_and_read() */
1670
1671 /*
1672 SUBSUBSECTION
1673         Reading Linenumbers
1674
1675         Creating the linenumber table is done by reading in the entire
1676         coff linenumber table, and creating another table for internal use.
1677
1678         A coff line number table is structured so that each function
1679         is marked as having a line number of 0. Each line within the
1680         function is an offset from the first line in the function. The
1681         base of the line number information for the table is stored in
1682         the symbol associated with the function.
1683
1684         The information is copied from the external to the internal
1685         table, and each symbol which marks a function is marked by
1686         pointing its...
1687
1688         How does this work ?
1689
1690 */
1691
1692 static boolean
1693 coff_slurp_line_table(abfd, asect)
1694 bfd            *abfd;
1695 asection       *asect;
1696   {
1697     LINENO  *native_lineno;
1698     alent          *lineno_cache;
1699
1700     BFD_ASSERT(asect->lineno == (alent *) NULL);
1701
1702     native_lineno = (LINENO *) buy_and_read(abfd,
1703                                             asect->line_filepos,
1704                                             SEEK_SET,
1705                                             (size_t) (LINESZ *
1706                                                       asect->lineno_count));
1707     lineno_cache =
1708       (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent)));
1709     if (lineno_cache == NULL) {
1710       bfd_error = no_memory;
1711       return false;
1712     } else {
1713       unsigned int    counter = 0;
1714       alent          *cache_ptr = lineno_cache;
1715       LINENO  *src = native_lineno;
1716
1717       while (counter < asect->lineno_count) {
1718         struct internal_lineno dst;
1719         coff_swap_lineno_in(abfd, src, &dst);
1720         cache_ptr->line_number = dst.l_lnno;
1721
1722         if (cache_ptr->line_number == 0) {
1723           coff_symbol_type *sym =
1724             (coff_symbol_type *) (dst.l_addr.l_symndx
1725                                   + obj_raw_syments(abfd))->u.syment._n._n_n._n_zeroes;
1726           cache_ptr->u.sym = (asymbol *) sym;
1727           sym->lineno = cache_ptr;
1728         }
1729         else {
1730           cache_ptr->u.offset = dst.l_addr.l_paddr
1731             - bfd_section_vma(abfd, asect);
1732         }                               /* If no linenumber expect a symbol index */
1733
1734         cache_ptr++;
1735         src++;
1736         counter++;
1737       }
1738       cache_ptr->line_number = 0;
1739
1740     }
1741     asect->lineno = lineno_cache;
1742     /* FIXME, free native_lineno here, or use alloca or something. */
1743     return true;
1744   }                             /* coff_slurp_line_table() */
1745
1746 static          boolean
1747 DEFUN(coff_slurp_symbol_table,(abfd),
1748       bfd            *abfd)
1749 {
1750   combined_entry_type         *native_symbols;
1751   coff_symbol_type *cached_area;
1752   unsigned int   *table_ptr;
1753
1754   unsigned int    number_of_symbols = 0;
1755   if (obj_symbols(abfd))
1756     return true;
1757   bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
1758
1759   /* Read in the symbol table */
1760   if ((native_symbols = coff_get_normalized_symtab(abfd)) == NULL) {
1761     return (false);
1762   }                             /* on error */
1763
1764   /* Allocate enough room for all the symbols in cached form */
1765   cached_area =
1766     (coff_symbol_type *)
1767       bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type)));
1768
1769   if (cached_area == NULL) {
1770     bfd_error = no_memory;
1771     return false;
1772   }                             /* on error */
1773   table_ptr =
1774     (unsigned int *)
1775       bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int)));
1776
1777   if (table_ptr == NULL) {
1778     bfd_error = no_memory;
1779     return false;
1780   }
1781   else
1782   {
1783     coff_symbol_type *dst = cached_area;
1784     unsigned int    last_native_index = bfd_get_symcount(abfd);
1785     unsigned int    this_index = 0;
1786     while (this_index < last_native_index) {
1787       combined_entry_type         *src = native_symbols + this_index;
1788       table_ptr[this_index] = number_of_symbols;
1789       dst->symbol.the_bfd = abfd;
1790
1791       dst->symbol.name = (char *)(src->u.syment._n._n_n._n_offset);
1792       /*
1793         We use the native name field to point to the cached field
1794         */
1795       src->u.syment._n._n_n._n_zeroes = (int) dst;
1796       dst->symbol.section = coff_section_from_bfd_index(abfd,
1797                                                         src->u.syment.n_scnum);
1798       dst->symbol.flags = 0;
1799       dst->done_lineno = false;
1800
1801       switch (src->u.syment.n_sclass) {
1802 #ifdef I960
1803       case C_LEAFEXT:
1804 #if 0
1805         dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
1806         dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
1807         dst->symbol.flags |= BSF_NOT_AT_END;
1808 #endif
1809         /* Fall through to next case */
1810
1811 #endif
1812
1813       case C_EXT:
1814 #ifdef RS6000COFF_C
1815       case C_HIDEXT:
1816 #endif
1817         if ((src->u.syment.n_scnum) == 0) {
1818           if ((src->u.syment.n_value) == 0) {
1819             dst->symbol.section = &bfd_und_section;
1820             dst->symbol.value= 0;
1821           }
1822           else {
1823             dst->symbol.section = &bfd_com_section;
1824             dst->symbol.value = (src->u.syment.n_value);
1825           }
1826         }
1827         else {
1828           /*
1829             Base the value as an index from the base of the
1830             section
1831             */
1832
1833             dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
1834             dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
1835
1836           if (ISFCN((src->u.syment.n_type))) {
1837             /*
1838               A function ext does not go at the end of a file
1839               */
1840             dst->symbol.flags |= BSF_NOT_AT_END;
1841           }
1842         }
1843
1844
1845         break;
1846
1847       case C_STAT:              /* static                        */
1848 #ifdef I960
1849       case C_LEAFSTAT:          /* static leaf procedure        */
1850 #endif
1851       case C_LABEL:             /* label                         */
1852         if (src->u.syment.n_scnum == -2)
1853           dst->symbol.flags = BSF_DEBUGGING;
1854         else
1855           dst->symbol.flags = BSF_LOCAL;
1856         /*
1857           Base the value as an index from the base of the section, if
1858           there is one
1859           */
1860         if (dst->symbol.section)
1861           dst->symbol.value = (src->u.syment.n_value) -
1862             dst->symbol.section->vma;
1863         else
1864           dst->symbol.value = (src->u.syment.n_value) ;
1865         break;
1866
1867       case C_MOS:               /* member of structure   */
1868       case C_EOS:               /* end of structure              */
1869 #ifdef NOTDEF   /* C_AUTOARG has the same value */
1870 #ifdef C_GLBLREG
1871       case C_GLBLREG:           /* A29k-specific storage class */
1872 #endif
1873 #endif
1874       case C_REGPARM:           /* register parameter            */
1875       case C_REG:               /* register variable             */
1876 #ifdef C_AUTOARG
1877       case C_AUTOARG:           /* 960-specific storage class */
1878 #endif
1879       case C_TPDEF:             /* type definition               */
1880       case C_ARG:
1881       case C_AUTO:              /* automatic variable */
1882       case C_FIELD:             /* bit field */
1883       case C_ENTAG:             /* enumeration tag               */
1884       case C_MOE:               /* member of enumeration         */
1885       case C_MOU:               /* member of union               */
1886       case C_UNTAG:             /* union tag                     */
1887         dst->symbol.flags = BSF_DEBUGGING;
1888         dst->symbol.value = (src->u.syment.n_value);
1889         break;
1890
1891       case C_FILE:              /* file name                     */
1892       case C_STRTAG:            /* structure tag                 */
1893 #ifdef RS6000COFF_C
1894       case C_BINCL:             /* beginning of include file     */
1895       case C_EINCL:             /* ending of include file        */
1896       case C_GSYM:
1897       case C_LSYM:
1898       case C_PSYM:
1899       case C_RSYM:
1900       case C_RPSYM:
1901       case C_STSYM:
1902       case C_DECL:
1903       case C_ENTRY:
1904       case C_FUN:
1905       case C_BSTAT:
1906       case C_ESTAT:
1907 #endif
1908         dst->symbol.flags = BSF_DEBUGGING;
1909         dst->symbol.value = (src->u.syment.n_value);
1910         break;
1911
1912       case C_BLOCK:             /* ".bb" or ".eb"                */
1913       case C_FCN:               /* ".bf" or ".ef"                */
1914       case C_EFCN:              /* physical end of function      */
1915         dst->symbol.flags = BSF_LOCAL;
1916         /*
1917           Base the value as an index from the base of the section
1918           */
1919         dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
1920         break;
1921
1922       case C_NULL:
1923       case C_EXTDEF:            /* external definition           */
1924       case C_ULABEL:            /* undefined label               */
1925       case C_USTATIC:           /* undefined static              */
1926       case C_LINE:              /* line # reformatted as symbol table entry */
1927       case C_ALIAS:             /* duplicate tag                 */
1928       case C_HIDDEN:            /* ext symbol in dmert public lib */
1929       default:
1930
1931         fprintf(stderr,"Unrecognized storage class %d\n",
1932                                 src->u.syment.n_sclass);
1933 /*      abort();*/
1934         dst->symbol.flags = BSF_DEBUGGING;
1935         dst->symbol.value = (src->u.syment.n_value);
1936         break;
1937       }
1938
1939 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
1940
1941       dst->native = src;
1942
1943       dst->symbol.udata = 0;
1944       dst->lineno = (alent *) NULL;
1945       this_index += (src->u.syment.n_numaux) + 1;
1946       dst++;
1947       number_of_symbols++;
1948     }                           /* walk the native symtab */
1949   }                             /* bfdize the native symtab */
1950
1951   obj_symbols(abfd) = cached_area;
1952   obj_raw_syments(abfd) = native_symbols;
1953
1954   obj_conv_table_size (abfd) = bfd_get_symcount (abfd);
1955   bfd_get_symcount(abfd) = number_of_symbols;
1956   obj_convert(abfd) = table_ptr;
1957   /* Slurp the line tables for each section too */
1958     {
1959       asection       *p;
1960       p = abfd->sections;
1961       while (p) {
1962         coff_slurp_line_table(abfd, p);
1963         p = p->next;
1964       }
1965     }
1966   return true;
1967 }                               /* coff_slurp_symbol_table() */
1968
1969 /*
1970 SUBSUBSECTION
1971         Reading Relocations
1972
1973         Coff relocations are easily transformed into the internal BFD form
1974         (@code{arelent}).
1975
1976         Reading a coff relocation table is done in the following stages:
1977
1978         o The entire coff relocation table is read into memory.
1979
1980         o Each relocation is processed in turn, first it is swapped from the
1981         external to the internal form.
1982
1983         o The symbol referenced in the relocation's symbol index is
1984         turned intoa pointer into the canonical symbol table. Note
1985         that this table is the same as the one returned by a call to
1986         @code{bfd_canonicalize_symtab}. The back end will call the
1987         routine and save the result if a canonicalization hasn't been done.
1988
1989         o The reloc index is turned into a pointer to a howto
1990         structure, in a back end specific way. For instance, the 386
1991         and 960 use the @code{r_type} to directly produce an index
1992         into a howto table vector; the 88k subtracts a number from the
1993         @code{r_type} field and creates an addend field.
1994
1995
1996 */
1997
1998 #ifndef CALC_ADDEND
1999 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)        \
2000             if (ptr && bfd_asymbol_bfd(ptr) == abfd             \
2001                 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
2002             {                                           \
2003                 cache_ptr->addend = -(ptr->section->vma + ptr->value);  \
2004             }                                           \
2005             else {                                      \
2006                 cache_ptr->addend = 0;                  \
2007             }
2008 #endif
2009
2010 static          boolean
2011 DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
2012       bfd            *abfd AND
2013       sec_ptr         asect AND
2014       asymbol       **symbols)
2015 {
2016   RELOC   *native_relocs;
2017   arelent        *reloc_cache;
2018   arelent        *cache_ptr;
2019
2020   unsigned int idx;
2021
2022   if (asect->relocation)
2023    return true;
2024   if (asect->reloc_count == 0)
2025    return true;
2026   if (asect->flags & SEC_CONSTRUCTOR)
2027    return true;
2028   if (!coff_slurp_symbol_table(abfd))
2029    return false;
2030   native_relocs =
2031    (RELOC *) buy_and_read(abfd,
2032                           asect->rel_filepos,
2033                           SEEK_SET,
2034                           (size_t) (RELSZ *
2035                                     asect->reloc_count));
2036   reloc_cache = (arelent *)
2037    bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
2038
2039   if (reloc_cache == NULL) {
2040       bfd_error = no_memory;
2041       return false;
2042     }
2043
2044
2045   for (idx = 0; idx < asect->reloc_count; idx ++)
2046   {
2047 #ifdef RELOC_PROCESSING
2048       struct internal_reloc dst;
2049       struct external_reloc  *src;
2050
2051       cache_ptr = reloc_cache + idx;
2052       src = native_relocs + idx;
2053       bfd_swap_reloc_in(abfd, src, &dst);
2054
2055       RELOC_PROCESSING(cache_ptr, &dst, symbols, abfd, asect);
2056 #else
2057       struct internal_reloc dst;
2058       asymbol        *ptr;
2059       struct external_reloc  *src;
2060
2061       cache_ptr = reloc_cache + idx;
2062       src = native_relocs + idx;
2063
2064       bfd_swap_reloc_in(abfd, src, &dst);
2065
2066
2067       cache_ptr->address = dst.r_vaddr;
2068
2069       if (dst.r_symndx != -1)
2070         {
2071           /* @@ Should never be greater than count of symbols!  */
2072           if (dst.r_symndx >= obj_conv_table_size (abfd))
2073             abort ();
2074           cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
2075           ptr = *(cache_ptr->sym_ptr_ptr);
2076         }
2077       else
2078         {
2079           cache_ptr->sym_ptr_ptr= bfd_abs_section.symbol_ptr_ptr;
2080           ptr = 0;
2081         }
2082
2083       /*
2084         The symbols definitions that we have read in have been
2085         relocated as if their sections started at 0. But the offsets
2086         refering to the symbols in the raw data have not been
2087         modified, so we have to have a negative addend to compensate.
2088
2089         Note that symbols which used to be common must be left alone */
2090
2091       /* Calculate any reloc addend by looking at the symbol */
2092       CALC_ADDEND(abfd, ptr, dst, cache_ptr);
2093
2094       cache_ptr->address -= asect->vma;
2095 /* !!     cache_ptr->section = (asection *) NULL;*/
2096
2097       /* Fill in the cache_ptr->howto field from dst.r_type */
2098       RTYPE2HOWTO(cache_ptr, &dst);
2099 #endif
2100
2101   }
2102
2103   asect->relocation = reloc_cache;
2104   return true;
2105 }
2106
2107
2108 /* This is stupid.  This function should be a boolean predicate */
2109 static unsigned int
2110 DEFUN(coff_canonicalize_reloc, (abfd, section, relptr, symbols),
2111 bfd            *abfd AND
2112 sec_ptr         section AND
2113 arelent       **relptr AND
2114 asymbol       **symbols)
2115 {
2116   arelent        *tblptr = section->relocation;
2117   unsigned int    count = 0;
2118
2119
2120   if (section->flags & SEC_CONSTRUCTOR)
2121   {
2122     /* this section has relocs made up by us, they are not in the
2123        file, so take them out of their chain and place them into
2124        the data area provided */
2125     arelent_chain *chain = section->constructor_chain;
2126     for (count = 0; count < section->reloc_count; count ++)
2127     {
2128       *relptr ++ = &chain->relent;
2129       chain = chain->next;
2130     }
2131
2132   }
2133   else
2134   {
2135     coff_slurp_reloc_table(abfd, section, symbols);
2136
2137
2138     tblptr = section->relocation;
2139     if (!tblptr)
2140      return 0;
2141
2142     for (; count++ < section->reloc_count;)
2143      *relptr++ = tblptr++;
2144
2145
2146   }
2147   *relptr = 0;
2148   return section->reloc_count;
2149 }
2150
2151 #ifdef GNU960
2152 file_ptr
2153 coff_sym_filepos(abfd)
2154 bfd *abfd;
2155   {
2156     return obj_sym_filepos(abfd);
2157   }
2158 #endif
2159
2160 #ifndef coff_reloc16_extra_cases
2161 #define coff_reloc16_extra_cases \
2162   (void (*) PARAMS ((bfd *, bfd_seclet_type *, arelent *, bfd_byte *,\
2163                      unsigned int *, unsigned int *))) abort
2164 #endif
2165
2166 static CONST bfd_coff_backend_data bfd_coff_std_swap_table = {
2167  coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
2168  coff_swap_aux_out, coff_swap_sym_out,
2169  coff_swap_lineno_out, coff_swap_reloc_out,
2170  coff_swap_filehdr_out, coff_swap_aouthdr_out,
2171  coff_swap_scnhdr_out,
2172  FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, LINESZ,
2173 #ifdef COFF_LONG_FILENAMES
2174  true,
2175 #else
2176  false,
2177 #endif
2178  coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
2179  coff_bad_format_hook, coff_set_arch_mach_hook, coff_mkobject_hook,
2180  styp_to_sec_flags, coff_make_section_hook, coff_set_alignment_hook,
2181  coff_slurp_symbol_table, symname_in_debug_hook, coff_reloc16_extra_cases
2182 };
2183
2184 #define coff_core_file_failing_command  _bfd_dummy_core_file_failing_command
2185 #define coff_core_file_failing_signal   _bfd_dummy_core_file_failing_signal
2186 #define coff_core_file_matches_executable_p     _bfd_dummy_core_file_matches_executable_p
2187 #define coff_slurp_armap                bfd_slurp_coff_armap
2188 #define coff_slurp_extended_name_table  _bfd_slurp_extended_name_table
2189 #define coff_truncate_arname            bfd_dont_truncate_arname
2190 #define coff_openr_next_archived_file   bfd_generic_openr_next_archived_file
2191 #define coff_generic_stat_arch_elt      bfd_generic_stat_arch_elt
2192 #define coff_get_section_contents       bfd_generic_get_section_contents
2193 #define coff_close_and_cleanup          bfd_generic_close_and_cleanup
2194
2195 #define coff_bfd_debug_info_start       bfd_void
2196 #define coff_bfd_debug_info_end         bfd_void
2197 #define coff_bfd_debug_info_accumulate  \
2198                         (void (*) PARAMS ((bfd *, struct sec *))) bfd_void
2199 #define coff_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
2200 #define coff_bfd_relax_section          bfd_generic_relax_section