OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [bfd/] [coffcode.h] - Blame information for rev 1778

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Support for the generic parts of most COFF variants, for BFD.
2
   Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3
   Free Software Foundation, Inc.
4
   Written by Cygnus Support.
5
 
6
This file is part of BFD, the Binary File Descriptor library.
7
 
8
This program is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 2 of the License, or
11
(at your option) any later version.
12
 
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
GNU General Public License for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with this program; if not, write to the Free Software
20
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
 
22
/*
23
Most of this hacked by  Steve Chamberlain,
24
                        sac@cygnus.com
25
*/
26
/*
27
 
28
SECTION
29
        coff backends
30
 
31
        BFD supports a number of different flavours of coff format.
32
        The major differences between formats are the sizes and
33
        alignments of fields in structures on disk, and the occasional
34
        extra field.
35
 
36
        Coff in all its varieties is implemented with a few common
37
        files and a number of implementation specific files. For
38
        example, The 88k bcs coff format is implemented in the file
39
        @file{coff-m88k.c}. This file @code{#include}s
40
        @file{coff/m88k.h} which defines the external structure of the
41
        coff format for the 88k, and @file{coff/internal.h} which
42
        defines the internal structure. @file{coff-m88k.c} also
43
        defines the relocations used by the 88k format
44
        @xref{Relocations}.
45
 
46
        The Intel i960 processor version of coff is implemented in
47
        @file{coff-i960.c}. This file has the same structure as
48
        @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
49
        rather than @file{coff-m88k.h}.
50
 
51
SUBSECTION
52
        Porting to a new version of coff
53
 
54
        The recommended method is to select from the existing
55
        implementations the version of coff which is most like the one
56
        you want to use.  For example, we'll say that i386 coff is
57
        the one you select, and that your coff flavour is called foo.
58
        Copy @file{i386coff.c} to @file{foocoff.c}, copy
59
        @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
60
        and add the lines to @file{targets.c} and @file{Makefile.in}
61
        so that your new back end is used. Alter the shapes of the
62
        structures in @file{../include/coff/foo.h} so that they match
63
        what you need. You will probably also have to add
64
        @code{#ifdef}s to the code in @file{coff/internal.h} and
65
        @file{coffcode.h} if your version of coff is too wild.
66
 
67
        You can verify that your new BFD backend works quite simply by
68
        building @file{objdump} from the @file{binutils} directory,
69
        and making sure that its version of what's going on and your
70
        host system's idea (assuming it has the pretty standard coff
71
        dump utility, usually called @code{att-dump} or just
72
        @code{dump}) are the same.  Then clean up your code, and send
73
        what you've done to Cygnus. Then your stuff will be in the
74
        next release, and you won't have to keep integrating it.
75
 
76
SUBSECTION
77
        How the coff backend works
78
 
79
SUBSUBSECTION
80
        File layout
81
 
82
        The Coff backend is split into generic routines that are
83
        applicable to any Coff target and routines that are specific
84
        to a particular target.  The target-specific routines are
85
        further split into ones which are basically the same for all
86
        Coff targets except that they use the external symbol format
87
        or use different values for certain constants.
88
 
89
        The generic routines are in @file{coffgen.c}.  These routines
90
        work for any Coff target.  They use some hooks into the target
91
        specific code; the hooks are in a @code{bfd_coff_backend_data}
92
        structure, one of which exists for each target.
93
 
94
        The essentially similar target-specific routines are in
95
        @file{coffcode.h}.  This header file includes executable C code.
96
        The various Coff targets first include the appropriate Coff
97
        header file, make any special defines that are needed, and
98
        then include @file{coffcode.h}.
99
 
100
        Some of the Coff targets then also have additional routines in
101
        the target source file itself.
102
 
103
        For example, @file{coff-i960.c} includes
104
        @file{coff/internal.h} and @file{coff/i960.h}.  It then
105
        defines a few constants, such as @code{I960}, and includes
106
        @file{coffcode.h}.  Since the i960 has complex relocation
107
        types, @file{coff-i960.c} also includes some code to
108
        manipulate the i960 relocs.  This code is not in
109
        @file{coffcode.h} because it would not be used by any other
110
        target.
111
 
112
SUBSUBSECTION
113
        Bit twiddling
114
 
115
        Each flavour of coff supported in BFD has its own header file
116
        describing the external layout of the structures. There is also
117
        an internal description of the coff layout, in
118
        @file{coff/internal.h}. A major function of the
119
        coff backend is swapping the bytes and twiddling the bits to
120
        translate the external form of the structures into the normal
121
        internal form. This is all performed in the
122
        @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
123
        elements are different sizes between different versions of
124
        coff; it is the duty of the coff version specific include file
125
        to override the definitions of various packing routines in
126
        @file{coffcode.h}. E.g., the size of line number entry in coff is
127
        sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
128
        @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
129
        correct one. No doubt, some day someone will find a version of
130
        coff which has a varying field size not catered to at the
131
        moment. To port BFD, that person will have to add more @code{#defines}.
132
        Three of the bit twiddling routines are exported to
133
        @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
134
        and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
135
        table on its own, but uses BFD to fix things up.  More of the
136
        bit twiddlers are exported for @code{gas};
137
        @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
138
        @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
139
        @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
140
        @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
141
        of all the symbol table and reloc drudgery itself, thereby
142
        saving the internal BFD overhead, but uses BFD to swap things
143
        on the way out, making cross ports much safer.  Doing so also
144
        allows BFD (and thus the linker) to use the same header files
145
        as @code{gas}, which makes one avenue to disaster disappear.
146
 
147
SUBSUBSECTION
148
        Symbol reading
149
 
150
        The simple canonical form for symbols used by BFD is not rich
151
        enough to keep all the information available in a coff symbol
152
        table. The back end gets around this problem by keeping the original
153
        symbol table around, "behind the scenes".
154
 
155
        When a symbol table is requested (through a call to
156
        @code{bfd_canonicalize_symtab}), a request gets through to
157
        @code{coff_get_normalized_symtab}. This reads the symbol table from
158
        the coff file and swaps all the structures inside into the
159
        internal form. It also fixes up all the pointers in the table
160
        (represented in the file by offsets from the first symbol in
161
        the table) into physical pointers to elements in the new
162
        internal table. This involves some work since the meanings of
163
        fields change depending upon context: a field that is a
164
        pointer to another structure in the symbol table at one moment
165
        may be the size in bytes of a structure at the next.  Another
166
        pass is made over the table. All symbols which mark file names
167
        (<<C_FILE>> symbols) are modified so that the internal
168
        string points to the value in the auxent (the real filename)
169
        rather than the normal text associated with the symbol
170
        (@code{".file"}).
171
 
172
        At this time the symbol names are moved around. Coff stores
173
        all symbols less than nine characters long physically
174
        within the symbol table; longer strings are kept at the end of
175
        the file in the string  table. This pass moves all strings
176
        into memory and replaces them with pointers to the strings.
177
 
178
 
179
        The symbol table is massaged once again, this time to create
180
        the canonical table used by the BFD application. Each symbol
181
        is inspected in turn, and a decision made (using the
182
        @code{sclass} field) about the various flags to set in the
183
        @code{asymbol}.  @xref{Symbols}. The generated canonical table
184
        shares strings with the hidden internal symbol table.
185
 
186
        Any linenumbers are read from the coff file too, and attached
187
        to the symbols which own the functions the linenumbers belong to.
188
 
189
SUBSUBSECTION
190
        Symbol writing
191
 
192
        Writing a symbol to a coff file which didn't come from a coff
193
        file will lose any debugging information. The @code{asymbol}
194
        structure remembers the BFD from which the symbol was taken, and on
195
        output the back end makes sure that the same destination target as
196
        source target is present.
197
 
198
        When the symbols have come from a coff file then all the
199
        debugging information is preserved.
200
 
201
        Symbol tables are provided for writing to the back end in a
202
        vector of pointers to pointers. This allows applications like
203
        the linker to accumulate and output large symbol tables
204
        without having to do too much byte copying.
205
 
206
        This function runs through the provided symbol table and
207
        patches each symbol marked as a file place holder
208
        (@code{C_FILE}) to point to the next file place holder in the
209
        list. It also marks each @code{offset} field in the list with
210
        the offset from the first symbol of the current symbol.
211
 
212
        Another function of this procedure is to turn the canonical
213
        value form of BFD into the form used by coff. Internally, BFD
214
        expects symbol values to be offsets from a section base; so a
215
        symbol physically at 0x120, but in a section starting at
216
        0x100, would have the value 0x20. Coff expects symbols to
217
        contain their final value, so symbols have their values
218
        changed at this point to reflect their sum with their owning
219
        section.  This transformation uses the
220
        <<output_section>> field of the @code{asymbol}'s
221
        @code{asection} @xref{Sections}.
222
 
223
        o <<coff_mangle_symbols>>
224
 
225
        This routine runs though the provided symbol table and uses
226
        the offsets generated by the previous pass and the pointers
227
        generated when the symbol table was read in to create the
228
        structured hierachy required by coff. It changes each pointer
229
        to a symbol into the index into the symbol table of the asymbol.
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 table 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
        <<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 value of this symbol be renumbered.  Used for
257
.          XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
258
.unsigned int fix_value : 1;
259
.
260
.       {* Should the tag field of this symbol be renumbered.
261
.          Created by coff_pointerize_aux. *}
262
.unsigned int fix_tag : 1;
263
.
264
.       {* Should the endidx field of this symbol be renumbered.
265
.          Created by coff_pointerize_aux. *}
266
.unsigned int fix_end : 1;
267
.
268
.       {* Should the x_csect.x_scnlen field be renumbered.
269
.          Created by coff_pointerize_aux. *}
270
.unsigned int fix_scnlen : 1;
271
.
272
.       {* Fix up an XCOFF C_BINCL/C_EINCL symbol.  The value is the
273
.          index into the line number entries.  Set by
274
.          coff_slurp_symbol_table.  *}
275
.unsigned int fix_line : 1;
276
.
277
.       {* The container for the symbol structure as read and translated
278
.           from the file. *}
279
.
280
.union {
281
.   union internal_auxent auxent;
282
.   struct internal_syment syment;
283
. } u;
284
.} combined_entry_type;
285
.
286
.
287
.{* Each canonical asymbol really looks like this: *}
288
.
289
.typedef struct coff_symbol_struct
290
.{
291
.   {* The actual symbol which the rest of BFD works with *}
292
.asymbol symbol;
293
.
294
.   {* A pointer to the hidden information for this symbol *}
295
.combined_entry_type *native;
296
.
297
.   {* A pointer to the linenumber information for this symbol *}
298
.struct lineno_cache_entry *lineno;
299
.
300
.   {* Have the line numbers been relocated yet ? *}
301
.boolean done_lineno;
302
.} coff_symbol_type;
303
 
304
 
305
*/
306
 
307
#ifdef COFF_WITH_PE
308
#include "peicode.h"
309
#else
310
#include "coffswap.h"
311
#endif
312
 
313
#define STRING_SIZE_SIZE (4)
314
 
315
static long sec_to_styp_flags PARAMS ((const char *, flagword));
316
static flagword styp_to_sec_flags
317
  PARAMS ((bfd *, PTR, const char *, asection *));
318
static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
319
static void coff_set_custom_section_alignment
320
  PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
321
           const unsigned int));
322
static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
323
static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
324
static boolean coff_write_relocs PARAMS ((bfd *, int));
325
static boolean coff_set_flags
326
  PARAMS ((bfd *, unsigned int *, unsigned short *));
327
static boolean coff_set_arch_mach
328
  PARAMS ((bfd *, enum bfd_architecture, unsigned long));
329
static boolean coff_compute_section_file_positions PARAMS ((bfd *));
330
static boolean coff_write_object_contents PARAMS ((bfd *));
331
static boolean coff_set_section_contents
332
  PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
333
static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t));
334
static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
335
static boolean coff_slurp_symbol_table PARAMS ((bfd *));
336
static enum coff_symbol_classification coff_classify_symbol
337
  PARAMS ((bfd *, struct internal_syment *));
338
static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
339
static long coff_canonicalize_reloc
340
  PARAMS ((bfd *, asection *, arelent **, asymbol **));
341
#ifndef coff_mkobject_hook
342
static PTR coff_mkobject_hook PARAMS ((bfd *, PTR,  PTR));
343
#endif
344
 
345
/* void warning(); */
346
 
347
/* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
348
   the incoming SEC_* flags.  The inverse of this function is
349
   styp_to_sec_flags().  NOTE: If you add to/change this routine, you
350
   should probably mirror the changes in styp_to_sec_flags().  */
351
 
352
#ifndef COFF_WITH_PE
353
 
354
static long
355
sec_to_styp_flags (sec_name, sec_flags)
356
     CONST char *sec_name;
357
     flagword sec_flags;
358
{
359
  long styp_flags = 0;
360
 
361
  if (!strcmp (sec_name, _TEXT))
362
    {
363
      styp_flags = STYP_TEXT;
364
    }
365
  else if (!strcmp (sec_name, _DATA))
366
    {
367
      styp_flags = STYP_DATA;
368
    }
369
  else if (!strcmp (sec_name, _BSS))
370
    {
371
      styp_flags = STYP_BSS;
372
#ifdef _COMMENT
373
    }
374
  else if (!strcmp (sec_name, _COMMENT))
375
    {
376
      styp_flags = STYP_INFO;
377
#endif /* _COMMENT */
378
#ifdef _LIB
379
    }
380
  else if (!strcmp (sec_name, _LIB))
381
    {
382
      styp_flags = STYP_LIB;
383
#endif /* _LIB */
384
#ifdef _LIT
385
    }
386
  else if (!strcmp (sec_name, _LIT))
387
    {
388
      styp_flags = STYP_LIT;
389
#endif /* _LIT */
390
    }
391
  else if (!strcmp (sec_name, ".debug"))
392
    {
393
#ifdef STYP_DEBUG
394
      styp_flags = STYP_DEBUG;
395
#else
396
      styp_flags = STYP_INFO;
397
#endif
398
    }
399
  else if (!strncmp (sec_name, ".stab", 5))
400
    {
401
#ifdef COFF_ALIGN_IN_S_FLAGS
402
      styp_flags = STYP_DSECT;
403
#else
404
      styp_flags = STYP_INFO;
405
#endif
406
    }
407
#ifdef RS6000COFF_C
408
  else if (!strcmp (sec_name, _PAD))
409
    {
410
      styp_flags = STYP_PAD;
411
    }
412
  else if (!strcmp (sec_name, _LOADER))
413
    {
414
      styp_flags = STYP_LOADER;
415
    }
416
#endif
417
  /* Try and figure out what it should be */
418
  else if (sec_flags & SEC_CODE)
419
    {
420
      styp_flags = STYP_TEXT;
421
    }
422
  else if (sec_flags & SEC_DATA)
423
    {
424
      styp_flags = STYP_DATA;
425
    }
426
  else if (sec_flags & SEC_READONLY)
427
    {
428
#ifdef STYP_LIT                 /* 29k readonly text/data section */
429
      styp_flags = STYP_LIT;
430
#else
431
      styp_flags = STYP_TEXT;
432
#endif /* STYP_LIT */
433
    }
434
  else if (sec_flags & SEC_LOAD)
435
    {
436
      styp_flags = STYP_TEXT;
437
    }
438
  else if (sec_flags & SEC_ALLOC)
439
    {
440
      styp_flags = STYP_BSS;
441
    }
442
 
443
#ifdef STYP_CLINK
444
  if (sec_flags & SEC_CLINK)
445
    styp_flags |= STYP_CLINK;
446
#endif
447
 
448
#ifdef STYP_BLOCK
449
  if (sec_flags & SEC_BLOCK)
450
    styp_flags |= STYP_BLOCK;
451
#endif
452
 
453
#ifdef STYP_NOLOAD
454
  if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
455
    styp_flags |= STYP_NOLOAD;
456
#endif
457
 
458
  return styp_flags;
459
}
460
 
461
#else /* COFF_WITH_PE */
462
 
463
/* The PE version; see above for the general comments.  The non-PE
464
   case seems to be more guessing, and breaks PE format; specifically,
465
   .rdata is readonly, but it sure ain't text.  Really, all this
466
   should be set up properly in gas (or whatever assembler is in use),
467
   and honor whatever objcopy/strip, etc. sent us as input.  */
468
 
469
static long
470
sec_to_styp_flags (sec_name, sec_flags)
471
     const char *sec_name ATTRIBUTE_UNUSED;
472
     flagword sec_flags;
473
{
474
  long styp_flags = 0;
475
 
476
  /* caution: there are at least three groups of symbols that have
477
     very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
478
     SEC_* are the BFD internal flags, used for generic BFD
479
     information.  STYP_* are the COFF section flags which appear in
480
     COFF files.  IMAGE_SCN_* are the PE section flags which appear in
481
     PE files.  The STYP_* flags and the IMAGE_SCN_* flags overlap,
482
     but there are more IMAGE_SCN_* flags.  */
483
 
484
  /* skip LOAD */
485
  /* READONLY later */
486
  /* skip RELOC */
487
  if ((sec_flags & SEC_CODE) != 0)
488
    styp_flags |= IMAGE_SCN_CNT_CODE;
489
  if ((sec_flags & SEC_DATA) != 0)
490
    styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
491
  if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
492
    styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA;  /* ==STYP_BSS */
493
  /* skip ROM */
494
  /* skip CONSTRUCTOR */
495
  /* skip CONTENTS */
496
#ifdef STYP_NOLOAD
497
  if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
498
    styp_flags |= STYP_NOLOAD;
499
#endif
500
  if ((sec_flags & SEC_IS_COMMON) != 0)
501
    styp_flags |= IMAGE_SCN_LNK_COMDAT;
502
  if ((sec_flags & SEC_DEBUGGING) != 0)
503
    styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
504
  if ((sec_flags & SEC_EXCLUDE) != 0)
505
    styp_flags |= IMAGE_SCN_LNK_REMOVE;
506
  if ((sec_flags & SEC_NEVER_LOAD) != 0)
507
    styp_flags |= IMAGE_SCN_LNK_REMOVE;
508
  /* skip IN_MEMORY */
509
  /* skip SORT */
510
  if (sec_flags & SEC_LINK_ONCE)
511
    styp_flags |= IMAGE_SCN_LNK_COMDAT;
512
  /* skip LINK_DUPLICATES */
513
  /* skip LINKER_CREATED */
514
 
515
  /* For now, the read/write bits are mapped onto SEC_READONLY, even
516
     though the semantics don't quite match.  The bits from the input
517
     are retained in pei_section_data(abfd, section)->pe_flags */
518
 
519
  styp_flags |= IMAGE_SCN_MEM_READ;       /* always readable. */
520
  if ((sec_flags & SEC_READONLY) == 0)
521
    styp_flags |= IMAGE_SCN_MEM_WRITE;    /* Invert READONLY for write */
522
  if (sec_flags & SEC_CODE)
523
    styp_flags |= IMAGE_SCN_MEM_EXECUTE;  /* CODE->EXECUTE */
524
  if (sec_flags & SEC_SHARED)
525
    styp_flags |= IMAGE_SCN_MEM_SHARED;   /* Shared remains meaningful */
526
 
527
  return styp_flags;
528
}
529
 
530
#endif /* COFF_WITH_PE */
531
 
532
/* Return a word with SEC_* flags set to represent the incoming STYP_*
533
   flags (from scnhdr.s_flags).  The inverse of this function is
534
   sec_to_styp_flags().  NOTE: If you add to/change this routine, you
535
   should probably mirror the changes in sec_to_styp_flags().  */
536
 
537
#ifndef COFF_WITH_PE
538
 
539
static flagword
540
styp_to_sec_flags (abfd, hdr, name, section)
541
     bfd *abfd ATTRIBUTE_UNUSED;
542
     PTR hdr;
543
     const char *name;
544
     asection *section ATTRIBUTE_UNUSED;
545
{
546
  struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
547
  long styp_flags = internal_s->s_flags;
548
  flagword sec_flags = 0;
549
 
550
#ifdef STYP_BLOCK
551
  if (styp_flags & STYP_BLOCK)
552
      sec_flags |= SEC_BLOCK;
553
#endif  
554
 
555
#ifdef STYP_CLINK
556
  if (styp_flags & STYP_CLINK)
557
      sec_flags |= SEC_CLINK;
558
#endif  
559
 
560
#ifdef STYP_NOLOAD
561
  if (styp_flags & STYP_NOLOAD)
562
    {
563
      sec_flags |= SEC_NEVER_LOAD;
564
    }
565
#endif /* STYP_NOLOAD */
566
 
567
  /* For 386 COFF, at least, an unloadable text or data section is
568
     actually a shared library section.  */
569
  if (styp_flags & STYP_TEXT)
570
    {
571
      if (sec_flags & SEC_NEVER_LOAD)
572
        sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
573
      else
574
        sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
575
    }
576
  else if (styp_flags & STYP_DATA)
577
    {
578
      if (sec_flags & SEC_NEVER_LOAD)
579
        sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
580
      else
581
        sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
582
    }
583
  else if (styp_flags & STYP_BSS)
584
    {
585
#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
586
      if (sec_flags & SEC_NEVER_LOAD)
587
        sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
588
      else
589
#endif
590
        sec_flags |= SEC_ALLOC;
591
    }
592
  else if (styp_flags & STYP_INFO)
593
    {
594
      /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
595
         defined.  coff_compute_section_file_positions uses
596
         COFF_PAGE_SIZE to ensure that the low order bits of the
597
         section VMA and the file offset match.  If we don't know
598
         COFF_PAGE_SIZE, we can't ensure the correct correspondence,
599
         and demand page loading of the file will fail.  */
600
#if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
601
      sec_flags |= SEC_DEBUGGING;
602
#endif
603
    }
604
  else if (styp_flags & STYP_PAD)
605
    {
606
      sec_flags = 0;
607
    }
608
  else if (strcmp (name, _TEXT) == 0)
609
    {
610
      if (sec_flags & SEC_NEVER_LOAD)
611
        sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
612
      else
613
        sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
614
    }
615
  else if (strcmp (name, _DATA) == 0)
616
    {
617
      if (sec_flags & SEC_NEVER_LOAD)
618
        sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
619
      else
620
        sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
621
    }
622
  else if (strcmp (name, _BSS) == 0)
623
    {
624
#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
625
      if (sec_flags & SEC_NEVER_LOAD)
626
        sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
627
      else
628
#endif
629
        sec_flags |= SEC_ALLOC;
630
    }
631
  else if (strcmp (name, ".debug") == 0
632
#ifdef _COMMENT
633
           || strcmp (name, _COMMENT) == 0
634
#endif
635
           || strncmp (name, ".stab", 5) == 0)
636
    {
637
#ifdef COFF_PAGE_SIZE
638
      sec_flags |= SEC_DEBUGGING;
639
#endif
640
    }
641
#ifdef _LIB
642
  else if (strcmp (name, _LIB) == 0)
643
    ;
644
#endif
645
#ifdef _LIT
646
  else if (strcmp (name, _LIT) == 0)
647
    {
648
      sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
649
    }
650
#endif
651
  else
652
    {
653
      sec_flags |= SEC_ALLOC | SEC_LOAD;
654
    }
655
 
656
#ifdef STYP_LIT                 /* A29k readonly text/data section type */
657
  if ((styp_flags & STYP_LIT) == STYP_LIT)
658
    {
659
      sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
660
    }
661
#endif /* STYP_LIT */
662
#ifdef STYP_OTHER_LOAD          /* Other loaded sections */
663
  if (styp_flags & STYP_OTHER_LOAD)
664
    {
665
      sec_flags = (SEC_LOAD | SEC_ALLOC);
666
    }
667
#endif /* STYP_SDATA */
668
 
669
#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
670
  /* As a GNU extension, if the name begins with .gnu.linkonce, we
671
     only link a single copy of the section.  This is used to support
672
     g++.  g++ will emit each template expansion in its own section.
673
     The symbols will be defined as weak, so that multiple definitions
674
     are permitted.  The GNU linker extension is to actually discard
675
     all but one of the sections.  */
676
  if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
677
    sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
678
#endif
679
 
680
  return sec_flags;
681
}
682
 
683
#else /* COFF_WITH_PE */
684
 
685
/* The PE version; see above for the general comments.
686
 
687
   Since to set the SEC_LINK_ONCE and associated flags, we have to
688
   look at the symbol table anyway, we return the symbol table index
689
   of the symbol being used as the COMDAT symbol.  This is admittedly
690
   ugly, but there's really nowhere else that we have access to the
691
   required information.  FIXME: Is the COMDAT symbol index used for
692
   any purpose other than objdump?  */
693
 
694
static flagword
695
styp_to_sec_flags (abfd, hdr, name, section)
696
     bfd *abfd ATTRIBUTE_UNUSED;
697
     PTR hdr;
698
     const char *name;
699
     asection *section;
700
{
701
  struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
702
  long styp_flags = internal_s->s_flags;
703
  flagword sec_flags = 0;
704
 
705
  if (styp_flags & STYP_DSECT)
706
    abort ();  /* Don't know what to do */
707
#ifdef SEC_NEVER_LOAD
708
  if (styp_flags & STYP_NOLOAD)
709
    sec_flags |= SEC_NEVER_LOAD;
710
#endif
711
  if (styp_flags & STYP_GROUP)
712
    abort ();  /* Don't know what to do */
713
  /* skip IMAGE_SCN_TYPE_NO_PAD */
714
  if (styp_flags & STYP_COPY)
715
    abort ();  /* Don't know what to do */
716
  if (styp_flags & IMAGE_SCN_CNT_CODE)
717
    sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
718
  if (styp_flags & IMAGE_SCN_CNT_INITIALIZED_DATA)
719
    sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
720
  if (styp_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
721
    sec_flags |= SEC_ALLOC;
722
  if (styp_flags & IMAGE_SCN_LNK_OTHER)
723
    abort ();  /* Don't know what to do */
724
  if (styp_flags & IMAGE_SCN_LNK_INFO)
725
    {
726
      /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
727
         defined.  coff_compute_section_file_positions uses
728
         COFF_PAGE_SIZE to ensure that the low order bits of the
729
         section VMA and the file offset match.  If we don't know
730
         COFF_PAGE_SIZE, we can't ensure the correct correspondence,
731
         and demand page loading of the file will fail.  */
732
#ifdef COFF_PAGE_SIZE
733
      sec_flags |= SEC_DEBUGGING;
734
#endif
735
    }
736
  if (styp_flags & STYP_OVER)
737
    abort ();  /* Don't know what to do */
738
  if (styp_flags & IMAGE_SCN_LNK_REMOVE)
739
    sec_flags |= SEC_EXCLUDE;
740
 
741
  if (styp_flags & IMAGE_SCN_MEM_SHARED)
742
    sec_flags |= SEC_SHARED;
743
  /* COMDAT: see below */
744
  if (styp_flags & IMAGE_SCN_MEM_DISCARDABLE)
745
    sec_flags |= SEC_DEBUGGING;
746
  if (styp_flags & IMAGE_SCN_MEM_NOT_CACHED)
747
    abort ();/* Don't know what to do */
748
  if (styp_flags & IMAGE_SCN_MEM_NOT_PAGED)
749
    abort (); /* Don't know what to do */
750
 
751
  /* We infer from the distinct read/write/execute bits the settings
752
     of some of the bfd flags; the actual values, should we need them,
753
     are also in pei_section_data (abfd, section)->pe_flags.  */
754
 
755
  if (styp_flags & IMAGE_SCN_MEM_EXECUTE)
756
    sec_flags |= SEC_CODE;   /* Probably redundant */
757
  /* IMAGE_SCN_MEM_READ is simply ignored, assuming it always to be true. */
758
  if ((styp_flags & IMAGE_SCN_MEM_WRITE) == 0)
759
    sec_flags |= SEC_READONLY;
760
 
761
  /* COMDAT gets very special treatment.  */
762
  if (styp_flags & IMAGE_SCN_LNK_COMDAT)
763
    {
764
      sec_flags |= SEC_LINK_ONCE;
765
 
766
      /* Unfortunately, the PE format stores essential information in
767
         the symbol table, of all places.  We need to extract that
768
         information now, so that objdump and the linker will know how
769
         to handle the section without worrying about the symbols.  We
770
         can't call slurp_symtab, because the linker doesn't want the
771
         swapped symbols.  */
772
 
773
      /* COMDAT sections are special.  The first symbol is the section
774
         symbol, which tells what kind of COMDAT section it is.  The
775
         second symbol is the "comdat symbol" - the one with the
776
         unique name.  GNU uses the section symbol for the unique
777
         name; MS uses ".text" for every comdat section.  Sigh.  - DJ */
778
 
779
      /* This is not mirrored in sec_to_styp_flags(), but there
780
         doesn't seem to be a need to, either, and it would at best be
781
         rather messy.  */
782
 
783
      if (_bfd_coff_get_external_symbols (abfd))
784
        {
785
          bfd_byte *esymstart, *esym, *esymend;
786
          int seen_state = 0;
787
          char *target_name = NULL;
788
 
789
          esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
790
          esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
791
 
792
          while (esym < esymend)
793
            {
794
              struct internal_syment isym;
795
              char buf[SYMNMLEN + 1];
796
              const char *symname;
797
 
798
              bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
799
 
800
              if (sizeof (internal_s->s_name) > SYMNMLEN)
801
                {
802
                  /* This case implies that the matching symbol name
803
                     will be in the string table.  */
804
                  abort ();
805
                }
806
 
807
              if (isym.n_scnum == section->target_index)
808
                {
809
                  /* According to the MSVC documentation, the first
810
                     TWO entries with the section # are both of
811
                     interest to us.  The first one is the "section
812
                     symbol" (section name).  The second is the comdat
813
                     symbol name.  Here, we've found the first
814
                     qualifying entry; we distinguish it from the
815
                     second with a state flag.
816
 
817
                     In the case of gas-generated (at least until that
818
                     is fixed) .o files, it isn't necessarily the
819
                     second one.  It may be some other later symbol.
820
 
821
                     Since gas also doesn't follow MS conventions and
822
                     emits the section similar to .text$<name>, where
823
                     <something> is the name we're looking for, we
824
                     distinguish the two as follows:
825
 
826
                     If the section name is simply a section name (no
827
                     $) we presume it's MS-generated, and look at
828
                     precisely the second symbol for the comdat name.
829
                     If the section name has a $, we assume it's
830
                     gas-generated, and look for <something> (whatever
831
                     follows the $) as the comdat symbol.  */
832
 
833
                  /* All 3 branches use this */
834
                  symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
835
 
836
                  if (symname == NULL)
837
                    abort ();
838
 
839
                  switch (seen_state)
840
                    {
841
                    case 0:
842
                      {
843
                        /* The first time we've seen the symbol.  */
844
                        union internal_auxent aux;
845
 
846
                        seen_state = 1;
847
 
848
                        /* If it isn't the stuff we're expecting, die;
849
                           The MS documentation is vague, but it
850
                           appears that the second entry serves BOTH
851
                           as the comdat symbol and the defining
852
                           symbol record (either C_STAT or C_EXT,
853
                           possibly with an aux entry with debug
854
                           information if it's a function.)  It
855
                           appears the only way to find the second one
856
                           is to count.  (On Intel, they appear to be
857
                           adjacent, but on Alpha, they have been
858
                           found separated.)
859
 
860
                           Here, we think we've found the first one,
861
                           but there's some checking we can do to be
862
                           sure.  */
863
 
864
                        if (! (isym.n_sclass == C_STAT
865
                               && isym.n_type == T_NULL
866
                               && isym.n_value == 0))
867
                          abort ();
868
 
869
                        /* FIXME LATER: MSVC generates section names
870
                           like .text for comdats.  Gas generates
871
                           names like .text$foo__Fv (in the case of a
872
                           function).  See comment above for more.  */
873
 
874
                        if (strcmp (name, symname) != 0)
875
                          abort ();
876
 
877
                        /* This is the section symbol.  */
878
 
879
                        bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
880
                                              isym.n_type, isym.n_sclass,
881
                                              0, isym.n_numaux, (PTR) &aux);
882
 
883
                        target_name = strchr (name, '$');
884
                        if (target_name != NULL)
885
                          {
886
                            /* Gas mode.  */
887
                            seen_state = 2;
888
                            /* Skip the `$'.  */
889
                            target_name += 1;
890
                          }
891
 
892
                        /* FIXME: Microsoft uses NODUPLICATES and
893
                           ASSOCIATIVE, but gnu uses ANY and
894
                           SAME_SIZE.  Unfortunately, gnu doesn't do
895
                           the comdat symbols right.  So, until we can
896
                           fix it to do the right thing, we are
897
                           temporarily disabling comdats for the MS
898
                           types (they're used in DLLs and C++, but we
899
                           don't support *their* C++ libraries anyway
900
                           - DJ.  */
901
 
902
                        /* Cygwin does not follow the MS style, and
903
                           uses ANY and SAME_SIZE where NODUPLICATES
904
                           and ASSOCIATIVE should be used.  For
905
                           Interix, we just do the right thing up
906
                           front.  */
907
 
908
                        switch (aux.x_scn.x_comdat)
909
                          {
910
                          case IMAGE_COMDAT_SELECT_NODUPLICATES:
911
#ifdef STRICT_PE_FORMAT 
912
                            sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
913
#else
914
                            sec_flags &= ~SEC_LINK_ONCE;
915
#endif
916
                            break;
917
 
918
                          case IMAGE_COMDAT_SELECT_ANY:
919
                            sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
920
                            break;
921
 
922
                          case IMAGE_COMDAT_SELECT_SAME_SIZE:
923
                            sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
924
                            break;
925
 
926
                          case IMAGE_COMDAT_SELECT_EXACT_MATCH:
927
                            /* Not yet fully implemented ??? */
928
                            sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
929
                            break;
930
 
931
                          /* debug$S gets this case; other
932
                             implications ??? */
933
 
934
                          /* There may be no symbol... we'll search
935
                             the whole table... Is this the right
936
                             place to play this game? Or should we do
937
                             it when reading it in.  */
938
                          case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
939
#ifdef STRICT_PE_FORMAT
940
                            /* FIXME: This is not currently implemented.  */
941
                            sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
942
#else
943
                            sec_flags &= ~SEC_LINK_ONCE;
944
#endif
945
                            break;
946
 
947
                          default:  /* 0 means "no symbol" */
948
                            /* debug$F gets this case; other
949
                               implications ??? */
950
                            sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
951
                            break;
952
                          }
953
                      }
954
                      break;
955
 
956
                    case 2:
957
                      /* Gas mode: the first matching on partial name.  */
958
 
959
#ifndef TARGET_UNDERSCORE
960
#define TARGET_UNDERSCORE 0
961
#endif
962
                      /* Is this the name we're looking for? */
963
                      if (strcmp (target_name,
964
                                  symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
965
                        {
966
                            /* Not the name we're looking for */
967
                            esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
968
                            continue;
969
                        }
970
                      /* Fall through.  */
971
                    case 1:
972
                      /* MSVC mode: the lexically second symbol (or
973
                         drop through from the above).  */
974
                      {
975
                        char *newname;
976
 
977
                        /* This must the the second symbol with the
978
                           section #.  It is the actual symbol name.
979
                           Intel puts the two adjacent, but Alpha (at
980
                           least) spreads them out.  */
981
 
982
                        section->comdat =
983
                          bfd_alloc (abfd, sizeof (struct bfd_comdat_info));
984
                        if (section->comdat == NULL)
985
                          abort ();
986
                        section->comdat->symbol =
987
                          (esym - esymstart) / bfd_coff_symesz (abfd);
988
 
989
                        newname = bfd_alloc (abfd, strlen (symname) + 1);
990
                        if (newname == NULL)
991
                          abort ();
992
 
993
                        strcpy (newname, symname);
994
                        section->comdat->name = newname;
995
 
996
                      }
997
 
998
                      goto breakloop;
999
                    }
1000
                }
1001
 
1002
              esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
1003
            }
1004
          breakloop:
1005
        }
1006
    }
1007
 
1008
#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1009
  /* As a GNU extension, if the name begins with .gnu.linkonce, we
1010
     only link a single copy of the section.  This is used to support
1011
     g++.  g++ will emit each template expansion in its own section.
1012
     The symbols will be defined as weak, so that multiple definitions
1013
     are permitted.  The GNU linker extension is to actually discard
1014
     all but one of the sections.  */
1015
  if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1016
    sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1017
#endif
1018
 
1019
  return sec_flags;
1020
}
1021
 
1022
#endif /* COFF_WITH_PE */
1023
 
1024
#define get_index(symbol)       ((symbol)->udata.i)
1025
 
1026
/*
1027
INTERNAL_DEFINITION
1028
        bfd_coff_backend_data
1029
 
1030
CODE_FRAGMENT
1031
 
1032
.{* COFF symbol classifications.  *}
1033
.
1034
.enum coff_symbol_classification
1035
.{
1036
.  {* Global symbol.  *}
1037
.  COFF_SYMBOL_GLOBAL,
1038
.  {* Common symbol.  *}
1039
.  COFF_SYMBOL_COMMON,
1040
.  {* Undefined symbol.  *}
1041
.  COFF_SYMBOL_UNDEFINED,
1042
.  {* Local symbol.  *}
1043
.  COFF_SYMBOL_LOCAL,
1044
.  {* PE section symbol.  *}
1045
.  COFF_SYMBOL_PE_SECTION
1046
.};
1047
.
1048
Special entry points for gdb to swap in coff symbol table parts:
1049
.typedef struct
1050
.{
1051
.  void (*_bfd_coff_swap_aux_in) PARAMS ((
1052
.       bfd            *abfd,
1053
.       PTR             ext,
1054
.       int             type,
1055
.       int             class,
1056
.       int             indaux,
1057
.       int             numaux,
1058
.       PTR             in));
1059
.
1060
.  void (*_bfd_coff_swap_sym_in) PARAMS ((
1061
.       bfd            *abfd ,
1062
.       PTR             ext,
1063
.       PTR             in));
1064
.
1065
.  void (*_bfd_coff_swap_lineno_in) PARAMS ((
1066
.       bfd            *abfd,
1067
.       PTR            ext,
1068
.       PTR             in));
1069
.
1070
 
1071
Special entry points for gas to swap out coff parts:
1072
 
1073
. unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
1074
.       bfd     *abfd,
1075
.       PTR     in,
1076
.       int     type,
1077
.       int     class,
1078
.       int     indaux,
1079
.       int     numaux,
1080
.       PTR     ext));
1081
.
1082
. unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
1083
.      bfd      *abfd,
1084
.      PTR      in,
1085
.      PTR      ext));
1086
.
1087
. unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
1088
.       bfd     *abfd,
1089
.       PTR     in,
1090
.       PTR     ext));
1091
.
1092
. unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
1093
.       bfd     *abfd,
1094
.       PTR     src,
1095
.       PTR     dst));
1096
.
1097
. unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
1098
.       bfd     *abfd,
1099
.       PTR     in,
1100
.       PTR     out));
1101
.
1102
. unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1103
.       bfd     *abfd,
1104
.       PTR     in,
1105
.       PTR     out));
1106
.
1107
. unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1108
.       bfd     *abfd,
1109
.       PTR     in,
1110
.       PTR     out));
1111
.
1112
 
1113
Special entry points for generic COFF routines to call target
1114
dependent COFF routines:
1115
 
1116
. unsigned int _bfd_filhsz;
1117
. unsigned int _bfd_aoutsz;
1118
. unsigned int _bfd_scnhsz;
1119
. unsigned int _bfd_symesz;
1120
. unsigned int _bfd_auxesz;
1121
. unsigned int _bfd_relsz;
1122
. unsigned int _bfd_linesz;
1123
. unsigned int _bfd_filnmlen;
1124
. boolean _bfd_coff_long_filenames;
1125
. boolean _bfd_coff_long_section_names;
1126
. unsigned int _bfd_coff_default_section_alignment_power;
1127
. void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1128
.       bfd     *abfd,
1129
.       PTR     ext,
1130
.       PTR     in));
1131
. void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1132
.       bfd     *abfd,
1133
.       PTR     ext,
1134
.       PTR     in));
1135
. void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1136
.       bfd     *abfd,
1137
.       PTR     ext,
1138
.       PTR     in));
1139
. void (*_bfd_coff_swap_reloc_in) PARAMS ((
1140
.       bfd     *abfd,
1141
.       PTR     ext,
1142
.       PTR     in));
1143
. boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1144
.       bfd     *abfd,
1145
.       PTR     internal_filehdr));
1146
. boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1147
.       bfd     *abfd,
1148
.       PTR     internal_filehdr));
1149
. PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1150
.       bfd     *abfd,
1151
.       PTR     internal_filehdr,
1152
.       PTR     internal_aouthdr));
1153
. flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1154
.       bfd     *abfd,
1155
.       PTR     internal_scnhdr,
1156
.       const char *name,
1157
.       asection *section));
1158
. void (*_bfd_set_alignment_hook) PARAMS ((
1159
.       bfd     *abfd,
1160
.       asection *sec,
1161
.       PTR     internal_scnhdr));
1162
. boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1163
.       bfd     *abfd));
1164
. boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1165
.       bfd     *abfd,
1166
.       struct internal_syment *sym));
1167
. boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1168
.       bfd *abfd,
1169
.       combined_entry_type *table_base,
1170
.       combined_entry_type *symbol,
1171
.       unsigned int indaux,
1172
.       combined_entry_type *aux));
1173
. boolean (*_bfd_coff_print_aux) PARAMS ((
1174
.       bfd *abfd,
1175
.       FILE *file,
1176
.       combined_entry_type *table_base,
1177
.       combined_entry_type *symbol,
1178
.       combined_entry_type *aux,
1179
.       unsigned int indaux));
1180
. void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1181
.       bfd     *abfd,
1182
.       struct bfd_link_info *link_info,
1183
.       struct bfd_link_order *link_order,
1184
.       arelent *reloc,
1185
.       bfd_byte *data,
1186
.       unsigned int *src_ptr,
1187
.       unsigned int *dst_ptr));
1188
. int (*_bfd_coff_reloc16_estimate) PARAMS ((
1189
.       bfd *abfd,
1190
.       asection *input_section,
1191
.       arelent *r,
1192
.       unsigned int shrink,
1193
.       struct bfd_link_info *link_info));
1194
. enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1195
.       bfd *abfd,
1196
.       struct internal_syment *));
1197
. boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1198
.       bfd *abfd));
1199
. boolean (*_bfd_coff_start_final_link) PARAMS ((
1200
.       bfd *output_bfd,
1201
.       struct bfd_link_info *info));
1202
. boolean (*_bfd_coff_relocate_section) PARAMS ((
1203
.       bfd *output_bfd,
1204
.       struct bfd_link_info *info,
1205
.       bfd *input_bfd,
1206
.       asection *input_section,
1207
.       bfd_byte *contents,
1208
.       struct internal_reloc *relocs,
1209
.       struct internal_syment *syms,
1210
.       asection **sections));
1211
. reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1212
.       bfd *abfd,
1213
.       asection *sec,
1214
.       struct internal_reloc *rel,
1215
.       struct coff_link_hash_entry *h,
1216
.       struct internal_syment *sym,
1217
.       bfd_vma *addendp));
1218
. boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1219
.       bfd *obfd,
1220
.       struct bfd_link_info *info,
1221
.       bfd *ibfd,
1222
.       asection *sec,
1223
.       struct internal_reloc *reloc,
1224
.       boolean *adjustedp));
1225
. boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1226
.       struct bfd_link_info *info,
1227
.       bfd *abfd,
1228
.       const char *name,
1229
.       flagword flags,
1230
.       asection *section,
1231
.       bfd_vma value,
1232
.       const char *string,
1233
.       boolean copy,
1234
.       boolean collect,
1235
.       struct bfd_link_hash_entry **hashp));
1236
.
1237
. boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1238
.       bfd * abfd,
1239
.       struct coff_final_link_info * pfinfo));
1240
. boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1241
.       bfd * abfd,
1242
.       struct coff_final_link_info * pfinfo));
1243
.
1244
.} bfd_coff_backend_data;
1245
.
1246
.#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1247
.
1248
.#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1249
.        ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1250
.
1251
.#define bfd_coff_swap_sym_in(a,e,i) \
1252
.        ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1253
.
1254
.#define bfd_coff_swap_lineno_in(a,e,i) \
1255
.        ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1256
.
1257
.#define bfd_coff_swap_reloc_out(abfd, i, o) \
1258
.        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1259
.
1260
.#define bfd_coff_swap_lineno_out(abfd, i, o) \
1261
.        ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1262
.
1263
.#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1264
.        ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1265
.
1266
.#define bfd_coff_swap_sym_out(abfd, i,o) \
1267
.        ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1268
.
1269
.#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1270
.        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1271
.
1272
.#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1273
.        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1274
.
1275
.#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1276
.        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1277
.
1278
.#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1279
.#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1280
.#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1281
.#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1282
.#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1283
.#define bfd_coff_relsz(abfd)  (coff_backend_info (abfd)->_bfd_relsz)
1284
.#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1285
.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1286
.#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1287
.#define bfd_coff_long_section_names(abfd) \
1288
.        (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1289
.#define bfd_coff_default_section_alignment_power(abfd) \
1290
.        (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1291
.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1292
.        ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1293
.
1294
.#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1295
.        ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1296
.
1297
.#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1298
.        ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1299
.
1300
.#define bfd_coff_swap_reloc_in(abfd, i, o) \
1301
.        ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1302
.
1303
.#define bfd_coff_bad_format_hook(abfd, filehdr) \
1304
.        ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1305
.
1306
.#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1307
.        ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1308
.#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1309
.        ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1310
.
1311
.#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1312
.        ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1313
.         (abfd, scnhdr, name, section))
1314
.
1315
.#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1316
.        ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1317
.
1318
.#define bfd_coff_slurp_symbol_table(abfd)\
1319
.        ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1320
.
1321
.#define bfd_coff_symname_in_debug(abfd, sym)\
1322
.        ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1323
.
1324
.#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1325
.        ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1326
.         (abfd, file, base, symbol, aux, indaux))
1327
.
1328
.#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1329
.        ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1330
.         (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1331
.
1332
.#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1333
.        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1334
.         (abfd, section, reloc, shrink, link_info))
1335
.
1336
.#define bfd_coff_classify_symbol(abfd, sym)\
1337
.        ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1338
.         (abfd, sym))
1339
.
1340
.#define bfd_coff_compute_section_file_positions(abfd)\
1341
.        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1342
.         (abfd))
1343
.
1344
.#define bfd_coff_start_final_link(obfd, info)\
1345
.        ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1346
.         (obfd, info))
1347
.#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1348
.        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1349
.         (obfd, info, ibfd, o, con, rel, isyms, secs))
1350
.#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1351
.        ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1352
.         (abfd, sec, rel, h, sym, addendp))
1353
.#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1354
.        ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1355
.         (obfd, info, ibfd, sec, rel, adjustedp))
1356
.#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1357
.        ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1358
.         (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1359
.
1360
.#define bfd_coff_link_output_has_begun(a,p) \
1361
.        ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1362
.#define bfd_coff_final_link_postscript(a,p) \
1363
.        ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1364
.
1365
*/
1366
 
1367
/* See whether the magic number matches.  */
1368
 
1369
static boolean
1370
coff_bad_format_hook (abfd, filehdr)
1371
     bfd * abfd ATTRIBUTE_UNUSED;
1372
     PTR filehdr;
1373
{
1374
  struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1375
 
1376
  if (BADMAG (*internal_f))
1377
    return false;
1378
 
1379
  /* if the optional header is NULL or not the correct size then
1380
     quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1381
     and Intel 960 readwrite headers (I960WRMAGIC) is that the
1382
     optional header is of a different size.
1383
 
1384
     But the mips keeps extra stuff in it's opthdr, so dont check
1385
     when doing that
1386
     */
1387
 
1388
#if defined(M88) || defined(I960)
1389
  if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1390
    return false;
1391
#endif
1392
 
1393
  return true;
1394
}
1395
 
1396
/* Check whether this section uses an alignment other than the
1397
   default.  */
1398
 
1399
static void
1400
coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1401
     bfd *abfd ATTRIBUTE_UNUSED;
1402
     asection *section;
1403
     const struct coff_section_alignment_entry *alignment_table;
1404
     const unsigned int table_size;
1405
{
1406
  const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1407
  unsigned int i;
1408
 
1409
  for (i = 0; i < table_size; ++i)
1410
    {
1411
      const char *secname = bfd_get_section_name (abfd, section);
1412
      if (alignment_table[i].comparison_length == (unsigned int) -1
1413
          ? strcmp (alignment_table[i].name, secname) == 0
1414
          : strncmp (alignment_table[i].name, secname,
1415
                     alignment_table[i].comparison_length) == 0)
1416
        break;
1417
    }
1418
  if (i >= table_size)
1419
    return;
1420
 
1421
  if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1422
      && default_alignment < alignment_table[i].default_alignment_min)
1423
    return;
1424
 
1425
  if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1426
      && default_alignment > alignment_table[i].default_alignment_max)
1427
    return;
1428
 
1429
  section->alignment_power = alignment_table[i].alignment_power;
1430
}
1431
 
1432
/* Custom section alignment records.  */
1433
 
1434
static const struct coff_section_alignment_entry
1435
coff_section_alignment_table[] =
1436
{
1437
#ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1438
  COFF_SECTION_ALIGNMENT_ENTRIES,
1439
#endif
1440
  /* There must not be any gaps between .stabstr sections.  */
1441
  { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1442
    1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1443
  /* The .stab section must be aligned to 2**2 at most, to avoid gaps.  */
1444
  { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1445
    3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1446
  /* Similarly for the .ctors and .dtors sections.  */
1447
  { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1448
    3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1449
  { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1450
    3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1451
};
1452
 
1453
static const unsigned int coff_section_alignment_table_size =
1454
  sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1455
 
1456
/* Initialize a section structure with information peculiar to this
1457
   particular implementation of COFF.  */
1458
 
1459
static boolean
1460
coff_new_section_hook (abfd, section)
1461
     bfd *abfd;
1462
     asection *section;
1463
{
1464
  combined_entry_type *native;
1465
 
1466
  section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1467
 
1468
#ifdef RS6000COFF_C
1469
  if (xcoff_data (abfd)->text_align_power != 0
1470
      && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1471
    section->alignment_power = xcoff_data (abfd)->text_align_power;
1472
  if (xcoff_data (abfd)->data_align_power != 0
1473
      && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1474
    section->alignment_power = xcoff_data (abfd)->data_align_power;
1475
#endif
1476
 
1477
  /* Allocate aux records for section symbols, to store size and
1478
     related info.
1479
 
1480
     @@ The 10 is a guess at a plausible maximum number of aux entries
1481
     (but shouldn't be a constant).  */
1482
  native = ((combined_entry_type *)
1483
            bfd_zalloc (abfd, sizeof (combined_entry_type) * 10));
1484
  if (native == NULL)
1485
    return false;
1486
 
1487
  /* We don't need to set up n_name, n_value, or n_scnum in the native
1488
     symbol information, since they'll be overriden by the BFD symbol
1489
     anyhow.  However, we do need to set the type and storage class,
1490
     in case this symbol winds up getting written out.  The value 0
1491
     for n_numaux is already correct.  */
1492
 
1493
  native->u.syment.n_type = T_NULL;
1494
  native->u.syment.n_sclass = C_STAT;
1495
 
1496
  coffsymbol (section->symbol)->native = native;
1497
 
1498
  coff_set_custom_section_alignment (abfd, section,
1499
                                     coff_section_alignment_table,
1500
                                     coff_section_alignment_table_size);
1501
 
1502
  return true;
1503
}
1504
 
1505
#ifdef COFF_ALIGN_IN_SECTION_HEADER
1506
 
1507
/* Set the alignment of a BFD section.  */
1508
 
1509
static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1510
 
1511
static void
1512
coff_set_alignment_hook (abfd, section, scnhdr)
1513
     bfd * abfd ATTRIBUTE_UNUSED;
1514
     asection * section;
1515
     PTR scnhdr;
1516
{
1517
  struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1518
  unsigned int i;
1519
 
1520
#ifdef I960
1521
  /* Extract ALIGN from 2**ALIGN stored in section header */
1522
  for (i = 0; i < 32; i++)
1523
    if ((1 << i) >= hdr->s_align)
1524
      break;
1525
#endif
1526
#ifdef TIC80COFF
1527
  /* TI tools puts the alignment power in bits 8-11 */
1528
  i = (hdr->s_flags >> 8) & 0xF ;
1529
#endif
1530
#ifdef COFF_DECODE_ALIGNMENT
1531
  i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1532
#endif
1533
  section->alignment_power = i;
1534
}
1535
 
1536
#else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1537
#ifdef COFF_WITH_PE
1538
 
1539
/* a couple of macros to help setting the alignment power field */
1540
#define ALIGN_SET(field,x,y) \
1541
  if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1542
  {\
1543
     section->alignment_power = y;\
1544
  }
1545
 
1546
#define ELIFALIGN_SET(field,x,y) \
1547
  else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1548
  {\
1549
     section->alignment_power = y;\
1550
  }
1551
 
1552
static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1553
 
1554
static void
1555
coff_set_alignment_hook (abfd, section, scnhdr)
1556
     bfd * abfd ATTRIBUTE_UNUSED;
1557
     asection * section;
1558
     PTR scnhdr;
1559
{
1560
  struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1561
 
1562
  ALIGN_SET     (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1563
  ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1564
  ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1565
  ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES,  3)
1566
  ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES,  2)
1567
  ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES,  1)
1568
  ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES,  0)
1569
 
1570
  /* In a PE image file, the s_paddr field holds the virtual size of a
1571
     section, while the s_size field holds the raw size.  We also keep
1572
     the original section flag value, since not every bit can be
1573
     mapped onto a generic BFD section bit.  */
1574
  if (coff_section_data (abfd, section) == NULL)
1575
    {
1576
      section->used_by_bfd =
1577
        (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
1578
      if (section->used_by_bfd == NULL)
1579
        {
1580
          /* FIXME: Return error.  */
1581
          abort ();
1582
        }
1583
    }
1584
  if (pei_section_data (abfd, section) == NULL)
1585
    {
1586
      coff_section_data (abfd, section)->tdata =
1587
        (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
1588
      if (coff_section_data (abfd, section)->tdata == NULL)
1589
        {
1590
          /* FIXME: Return error.  */
1591
          abort ();
1592
        }
1593
    }
1594
  pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1595
  pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1596
 
1597
  section->lma = hdr->s_vaddr;
1598
}
1599
#undef ALIGN_SET
1600
#undef ELIFALIGN_SET
1601
 
1602
#else /* ! COFF_WITH_PE */
1603
#ifdef RS6000COFF_C
1604
 
1605
/* We grossly abuse this function to handle XCOFF overflow headers.
1606
   When we see one, we correct the reloc and line number counts in the
1607
   real header, and remove the section we just created.  */
1608
 
1609
static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1610
 
1611
static void
1612
coff_set_alignment_hook (abfd, section, scnhdr)
1613
     bfd *abfd;
1614
     asection *section;
1615
     PTR scnhdr;
1616
{
1617
  struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1618
  asection *real_sec;
1619
  asection **ps;
1620
 
1621
  if ((hdr->s_flags & STYP_OVRFLO) == 0)
1622
    return;
1623
 
1624
  real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1625
  if (real_sec == NULL)
1626
    return;
1627
 
1628
  real_sec->reloc_count = hdr->s_paddr;
1629
  real_sec->lineno_count = hdr->s_vaddr;
1630
 
1631
  for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1632
    {
1633
      if (*ps == section)
1634
        {
1635
          *ps = (*ps)->next;
1636
          --abfd->section_count;
1637
          break;
1638
        }
1639
    }
1640
}
1641
 
1642
#else /* ! RS6000COFF_C */
1643
 
1644
#define coff_set_alignment_hook \
1645
  ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1646
 
1647
#endif /* ! RS6000COFF_C */
1648
#endif /* ! COFF_WITH_PE */
1649
#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1650
 
1651
#ifndef coff_mkobject
1652
 
1653
static boolean coff_mkobject PARAMS ((bfd *));
1654
 
1655
static boolean
1656
coff_mkobject (abfd)
1657
     bfd * abfd;
1658
{
1659
  coff_data_type *coff;
1660
 
1661
  abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1662
  if (abfd->tdata.coff_obj_data == 0)
1663
    return false;
1664
  coff = coff_data (abfd);
1665
  coff->symbols = (coff_symbol_type *) NULL;
1666
  coff->conversion_table = (unsigned int *) NULL;
1667
  coff->raw_syments = (struct coff_ptr_struct *) NULL;
1668
  coff->relocbase = 0;
1669
  coff->local_toc_sym_map = 0;
1670
 
1671
/*  make_abs_section(abfd);*/
1672
 
1673
  return true;
1674
}
1675
#endif
1676
 
1677
/* Create the COFF backend specific information.  */
1678
#ifndef coff_mkobject_hook
1679
static PTR
1680
coff_mkobject_hook (abfd, filehdr, aouthdr)
1681
     bfd * abfd;
1682
     PTR filehdr;
1683
     PTR aouthdr ATTRIBUTE_UNUSED;
1684
{
1685
  struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1686
  coff_data_type *coff;
1687
 
1688
  if (coff_mkobject (abfd) == false)
1689
    return NULL;
1690
 
1691
  coff = coff_data (abfd);
1692
 
1693
  coff->sym_filepos = internal_f->f_symptr;
1694
 
1695
  /* These members communicate important constants about the symbol
1696
     table to GDB's symbol-reading code.  These `constants'
1697
     unfortunately vary among coff implementations...  */
1698
  coff->local_n_btmask = N_BTMASK;
1699
  coff->local_n_btshft = N_BTSHFT;
1700
  coff->local_n_tmask = N_TMASK;
1701
  coff->local_n_tshift = N_TSHIFT;
1702
  coff->local_symesz = bfd_coff_symesz (abfd);
1703
  coff->local_auxesz = bfd_coff_auxesz (abfd);
1704
  coff->local_linesz = bfd_coff_linesz (abfd);
1705
 
1706
  coff->timestamp = internal_f->f_timdat;
1707
 
1708
  obj_raw_syment_count (abfd) =
1709
    obj_conv_table_size (abfd) =
1710
      internal_f->f_nsyms;
1711
 
1712
#ifdef RS6000COFF_C
1713
  if ((internal_f->f_flags & F_SHROBJ) != 0)
1714
    abfd->flags |= DYNAMIC;
1715
  if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1716
    {
1717
      struct internal_aouthdr *internal_a =
1718
        (struct internal_aouthdr *) aouthdr;
1719
      struct xcoff_tdata *xcoff;
1720
 
1721
      xcoff = xcoff_data (abfd);
1722
      xcoff->full_aouthdr = true;
1723
      xcoff->toc = internal_a->o_toc;
1724
      xcoff->sntoc = internal_a->o_sntoc;
1725
      xcoff->snentry = internal_a->o_snentry;
1726
      xcoff->text_align_power = internal_a->o_algntext;
1727
      xcoff->data_align_power = internal_a->o_algndata;
1728
      xcoff->modtype = internal_a->o_modtype;
1729
      xcoff->cputype = internal_a->o_cputype;
1730
      xcoff->maxdata = internal_a->o_maxdata;
1731
      xcoff->maxstack = internal_a->o_maxstack;
1732
    }
1733
#endif
1734
 
1735
#ifdef ARM 
1736
  /* Set the flags field from the COFF header read in */
1737
  if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1738
    coff->flags = 0;
1739
#endif
1740
 
1741
#ifdef COFF_WITH_PE
1742
  /* FIXME: I'm not sure this is ever executed, since peicode.h
1743
     defines coff_mkobject_hook.  */
1744
  if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1745
    abfd->flags |= HAS_DEBUG;
1746
#endif
1747
 
1748
  return (PTR) coff;
1749
}
1750
#endif
1751
 
1752
/* Determine the machine architecture and type.  FIXME: This is target
1753
   dependent because the magic numbers are defined in the target
1754
   dependent header files.  But there is no particular need for this.
1755
   If the magic numbers were moved to a separate file, this function
1756
   would be target independent and would also be much more successful
1757
   at linking together COFF files for different architectures.  */
1758
 
1759
static boolean
1760
coff_set_arch_mach_hook (abfd, filehdr)
1761
     bfd *abfd;
1762
     PTR filehdr;
1763
{
1764
  long machine;
1765
  enum bfd_architecture arch;
1766
  struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1767
 
1768
  machine = 0;
1769
  switch (internal_f->f_magic)
1770
    {
1771
#ifdef OR32_MAGIC_BIG
1772
    case OR32_MAGIC_BIG:
1773
    case OR32_MAGIC_LITTLE:
1774
      arch = bfd_arch_or32;
1775
      machine = 0;
1776
      break;
1777
#endif
1778
#ifdef OR16_MAGIC_BIG
1779
    case OR16_MAGIC_BIG:
1780
    case OR16_MAGIC_LITTLE:
1781
      arch = bfd_arch_or16;
1782
      machine = 0;
1783
      break;
1784
#endif
1785
#ifdef PPCMAGIC
1786
    case PPCMAGIC:
1787
      arch = bfd_arch_powerpc;
1788
      machine = 0; /* what does this mean? (krk) */
1789
      break;
1790
#endif
1791
#ifdef I386MAGIC
1792
    case I386MAGIC:
1793
    case I386PTXMAGIC:
1794
    case I386AIXMAGIC:          /* Danbury PS/2 AIX C Compiler */
1795
    case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1796
      arch = bfd_arch_i386;
1797
      machine = 0;
1798
      break;
1799
#endif
1800
#ifdef A29K_MAGIC_BIG
1801
    case A29K_MAGIC_BIG:
1802
    case A29K_MAGIC_LITTLE:
1803
      arch = bfd_arch_a29k;
1804
      machine = 0;
1805
      break;
1806
#endif
1807
#ifdef ARMMAGIC
1808
    case ARMMAGIC:
1809
    case ARMPEMAGIC:
1810
    case THUMBPEMAGIC:
1811
      arch = bfd_arch_arm;
1812
      switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1813
        {
1814
        case F_ARM_2:  machine = bfd_mach_arm_2;  break;
1815
        case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1816
        case F_ARM_3:  machine = bfd_mach_arm_3;  break;
1817
        default:
1818
        case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1819
        case F_ARM_4:  machine = bfd_mach_arm_4;  break;
1820
        case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1821
        case F_ARM_5:  machine = bfd_mach_arm_5;  break;
1822
        }
1823
      break;
1824
#endif
1825
#ifdef MC68MAGIC
1826
    case MC68MAGIC:
1827
    case M68MAGIC:
1828
#ifdef MC68KBCSMAGIC
1829
    case MC68KBCSMAGIC:
1830
#endif
1831
#ifdef APOLLOM68KMAGIC
1832
    case APOLLOM68KMAGIC:
1833
#endif
1834
#ifdef LYNXCOFFMAGIC
1835
    case LYNXCOFFMAGIC:
1836
#endif
1837
      arch = bfd_arch_m68k;
1838
      machine = bfd_mach_m68020;
1839
      break;
1840
#endif
1841
#ifdef MC88MAGIC
1842
    case MC88MAGIC:
1843
    case MC88DMAGIC:
1844
    case MC88OMAGIC:
1845
      arch = bfd_arch_m88k;
1846
      machine = 88100;
1847
      break;
1848
#endif
1849
#ifdef Z8KMAGIC
1850
    case Z8KMAGIC:
1851
      arch = bfd_arch_z8k;
1852
      switch (internal_f->f_flags & F_MACHMASK)
1853
        {
1854
        case F_Z8001:
1855
          machine = bfd_mach_z8001;
1856
          break;
1857
        case F_Z8002:
1858
          machine = bfd_mach_z8002;
1859
          break;
1860
        default:
1861
          return false;
1862
        }
1863
      break;
1864
#endif
1865
#ifdef I860
1866
    case I860MAGIC:
1867
      arch = bfd_arch_i860;
1868
      break;
1869
#endif
1870
#ifdef I960
1871
#ifdef I960ROMAGIC
1872
    case I960ROMAGIC:
1873
    case I960RWMAGIC:
1874
      arch = bfd_arch_i960;
1875
      switch (F_I960TYPE & internal_f->f_flags)
1876
        {
1877
        default:
1878
        case F_I960CORE:
1879
          machine = bfd_mach_i960_core;
1880
          break;
1881
        case F_I960KB:
1882
          machine = bfd_mach_i960_kb_sb;
1883
          break;
1884
        case F_I960MC:
1885
          machine = bfd_mach_i960_mc;
1886
          break;
1887
        case F_I960XA:
1888
          machine = bfd_mach_i960_xa;
1889
          break;
1890
        case F_I960CA:
1891
          machine = bfd_mach_i960_ca;
1892
          break;
1893
        case F_I960KA:
1894
          machine = bfd_mach_i960_ka_sa;
1895
          break;
1896
        case F_I960JX:
1897
          machine = bfd_mach_i960_jx;
1898
          break;
1899
        case F_I960HX:
1900
          machine = bfd_mach_i960_hx;
1901
          break;
1902
        }
1903
      break;
1904
#endif
1905
#endif
1906
 
1907
#ifdef RS6000COFF_C
1908
    case U802ROMAGIC:
1909
    case U802WRMAGIC:
1910
    case U802TOCMAGIC:
1911
      {
1912
        int cputype;
1913
 
1914
        if (xcoff_data (abfd)->cputype != -1)
1915
          cputype = xcoff_data (abfd)->cputype & 0xff;
1916
        else
1917
          {
1918
            /* We did not get a value from the a.out header.  If the
1919
               file has not been stripped, we may be able to get the
1920
               architecture information from the first symbol, if it
1921
               is a .file symbol.  */
1922
            if (obj_raw_syment_count (abfd) == 0)
1923
              cputype = 0;
1924
            else
1925
              {
1926
                bfd_byte *buf;
1927
                struct internal_syment sym;
1928
 
1929
                buf = (bfd_byte *) bfd_malloc (bfd_coff_symesz (abfd));
1930
                if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1931
                    || (bfd_read (buf, 1, bfd_coff_symesz (abfd), abfd)
1932
                        != bfd_coff_symesz (abfd)))
1933
                  {
1934
                    free (buf);
1935
                    return false;
1936
                  }
1937
                coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1938
                if (sym.n_sclass == C_FILE)
1939
                  cputype = sym.n_type & 0xff;
1940
                else
1941
                  cputype = 0;
1942
                free (buf);
1943
              }
1944
          }
1945
 
1946
        /* FIXME: We don't handle all cases here.  */
1947
        switch (cputype)
1948
          {
1949
          default:
1950
          case 0:
1951
#ifdef POWERMAC
1952
            /* PowerPC Macs use the same magic numbers as RS/6000
1953
               (because that's how they were bootstrapped originally),
1954
               but they are always PowerPC architecture.  */
1955
            arch = bfd_arch_powerpc;
1956
            machine = 0;
1957
#else
1958
            arch = bfd_arch_rs6000;
1959
            machine = 6000;
1960
#endif /* POWERMAC */
1961
            break;
1962
 
1963
          case 1:
1964
            arch = bfd_arch_powerpc;
1965
            machine = 601;
1966
            break;
1967
          case 2: /* 64 bit PowerPC */
1968
            arch = bfd_arch_powerpc;
1969
            machine = 620;
1970
            break;
1971
          case 3:
1972
            arch = bfd_arch_powerpc;
1973
            machine = 0;
1974
            break;
1975
          case 4:
1976
            arch = bfd_arch_rs6000;
1977
            machine = 6000;
1978
            break;
1979
          }
1980
      }
1981
      break;
1982
#endif
1983
 
1984
#ifdef WE32KMAGIC
1985
    case WE32KMAGIC:
1986
      arch = bfd_arch_we32k;
1987
      machine = 0;
1988
      break;
1989
#endif
1990
 
1991
#ifdef H8300MAGIC
1992
    case H8300MAGIC:
1993
      arch = bfd_arch_h8300;
1994
      machine = bfd_mach_h8300;
1995
      /* !! FIXME this probably isn't the right place for this */
1996
      abfd->flags |= BFD_IS_RELAXABLE;
1997
      break;
1998
#endif
1999
 
2000
#ifdef H8300HMAGIC
2001
    case H8300HMAGIC:
2002
      arch = bfd_arch_h8300;
2003
      machine = bfd_mach_h8300h;
2004
      /* !! FIXME this probably isn't the right place for this */
2005
      abfd->flags |= BFD_IS_RELAXABLE;
2006
      break;
2007
#endif
2008
 
2009
#ifdef H8300SMAGIC
2010
    case H8300SMAGIC:
2011
      arch = bfd_arch_h8300;
2012
      machine = bfd_mach_h8300s;
2013
      /* !! FIXME this probably isn't the right place for this */
2014
      abfd->flags |= BFD_IS_RELAXABLE;
2015
      break;
2016
#endif
2017
 
2018
#ifdef SH_ARCH_MAGIC_BIG
2019
    case SH_ARCH_MAGIC_BIG:
2020
    case SH_ARCH_MAGIC_LITTLE:
2021
#ifdef COFF_WITH_PE
2022
    case SH_ARCH_MAGIC_WINCE:
2023
#endif
2024
      arch = bfd_arch_sh;
2025
      machine = 0;
2026
      break;
2027
#endif
2028
 
2029
#ifdef MIPS_ARCH_MAGIC_WINCE
2030
    case MIPS_ARCH_MAGIC_WINCE:
2031
      arch = bfd_arch_mips;
2032
      machine = 0;
2033
      break;
2034
#endif
2035
 
2036
#ifdef H8500MAGIC
2037
    case H8500MAGIC:
2038
      arch = bfd_arch_h8500;
2039
      machine = 0;
2040
      break;
2041
#endif
2042
 
2043
#ifdef SPARCMAGIC
2044
    case SPARCMAGIC:
2045
#ifdef LYNXCOFFMAGIC
2046
    case LYNXCOFFMAGIC:
2047
#endif
2048
      arch = bfd_arch_sparc;
2049
      machine = 0;
2050
      break;
2051
#endif
2052
 
2053
#ifdef TIC30MAGIC
2054
    case TIC30MAGIC:
2055
      arch = bfd_arch_tic30;
2056
      break;
2057
#endif
2058
 
2059
#ifdef TICOFF0MAGIC
2060
#ifdef TICOFF_TARGET_ARCH
2061
      /* this TI COFF section should be used by all new TI COFF v0 targets */
2062
    case TICOFF0MAGIC:
2063
      arch = TICOFF_TARGET_ARCH;
2064
      break;
2065
#endif
2066
#endif
2067
 
2068
#ifdef TICOFF1MAGIC
2069
      /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2070
      /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2071
    case TICOFF1MAGIC:
2072
    case TICOFF2MAGIC:
2073
      switch (internal_f->f_target_id)
2074
        {
2075
#ifdef TI_TARGET_ID
2076
        case TI_TARGET_ID:
2077
          arch = TICOFF_TARGET_ARCH;
2078
          break;
2079
#endif
2080
        default:
2081
          (*_bfd_error_handler)
2082
            (_("Unrecognized TI COFF target id '0x%x'"),
2083
             internal_f->f_target_id);
2084
          break;
2085
        }
2086
      break;
2087
#endif
2088
 
2089
#ifdef TIC80_ARCH_MAGIC
2090
    case TIC80_ARCH_MAGIC:
2091
      arch = bfd_arch_tic80;
2092
      break;
2093
#endif
2094
 
2095
#ifdef MCOREMAGIC
2096
    case MCOREMAGIC:
2097
      arch = bfd_arch_mcore;
2098
      break;
2099
#endif
2100
    default:                    /* Unreadable input file type */
2101
      arch = bfd_arch_obscure;
2102
      break;
2103
    }
2104
 
2105
  bfd_default_set_arch_mach (abfd, arch, machine);
2106
  return true;
2107
}
2108
 
2109
#ifdef SYMNAME_IN_DEBUG
2110
 
2111
static boolean symname_in_debug_hook
2112
  PARAMS ((bfd *, struct internal_syment *));
2113
 
2114
static boolean
2115
symname_in_debug_hook (abfd, sym)
2116
     bfd * abfd ATTRIBUTE_UNUSED;
2117
     struct internal_syment *sym;
2118
{
2119
  return SYMNAME_IN_DEBUG (sym) ? true : false;
2120
}
2121
 
2122
#else
2123
 
2124
#define symname_in_debug_hook \
2125
  (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2126
 
2127
#endif
2128
 
2129
#ifdef RS6000COFF_C
2130
 
2131
/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
2132
 
2133
static boolean coff_pointerize_aux_hook
2134
  PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2135
           unsigned int, combined_entry_type *));
2136
 
2137
/*ARGSUSED*/
2138
static boolean
2139
coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2140
     bfd *abfd ATTRIBUTE_UNUSED;
2141
     combined_entry_type *table_base;
2142
     combined_entry_type *symbol;
2143
     unsigned int indaux;
2144
     combined_entry_type *aux;
2145
{
2146
  int class = symbol->u.syment.n_sclass;
2147
 
2148
  if ((class == C_EXT || class == C_HIDEXT)
2149
      && indaux + 1 == symbol->u.syment.n_numaux)
2150
    {
2151
      if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2152
        {
2153
          aux->u.auxent.x_csect.x_scnlen.p =
2154
            table_base + aux->u.auxent.x_csect.x_scnlen.l;
2155
          aux->fix_scnlen = 1;
2156
        }
2157
 
2158
      /* Return true to indicate that the caller should not do any
2159
         further work on this auxent.  */
2160
      return true;
2161
    }
2162
 
2163
  /* Return false to indicate that this auxent should be handled by
2164
     the caller.  */
2165
  return false;
2166
}
2167
 
2168
#else
2169
#ifdef I960
2170
 
2171
/* We don't want to pointerize bal entries.  */
2172
 
2173
static boolean coff_pointerize_aux_hook
2174
  PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2175
           unsigned int, combined_entry_type *));
2176
 
2177
/*ARGSUSED*/
2178
static boolean
2179
coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2180
     bfd *abfd ATTRIBUTE_UNUSED;
2181
     combined_entry_type *table_base ATTRIBUTE_UNUSED;
2182
     combined_entry_type *symbol;
2183
     unsigned int indaux;
2184
     combined_entry_type *aux ATTRIBUTE_UNUSED;
2185
{
2186
  /* Return true if we don't want to pointerize this aux entry, which
2187
     is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
2188
  return (indaux == 1
2189
          && (symbol->u.syment.n_sclass == C_LEAFPROC
2190
              || symbol->u.syment.n_sclass == C_LEAFSTAT
2191
              || symbol->u.syment.n_sclass == C_LEAFEXT));
2192
}
2193
 
2194
#else /* ! I960 */
2195
 
2196
#define coff_pointerize_aux_hook 0
2197
 
2198
#endif /* ! I960 */
2199
#endif /* ! RS6000COFF_C */
2200
 
2201
/* Print an aux entry.  This returns true if it has printed it.  */
2202
 
2203
static boolean coff_print_aux
2204
  PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2205
           combined_entry_type *, unsigned int));
2206
 
2207
static boolean
2208
coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2209
     bfd *abfd ATTRIBUTE_UNUSED;
2210
     FILE *file ATTRIBUTE_UNUSED;
2211
     combined_entry_type *table_base ATTRIBUTE_UNUSED;
2212
     combined_entry_type *symbol ATTRIBUTE_UNUSED;
2213
     combined_entry_type *aux ATTRIBUTE_UNUSED;
2214
     unsigned int indaux ATTRIBUTE_UNUSED;
2215
{
2216
#ifdef RS6000COFF_C
2217
  if ((symbol->u.syment.n_sclass == C_EXT
2218
       || symbol->u.syment.n_sclass == C_HIDEXT)
2219
      && indaux + 1 == symbol->u.syment.n_numaux)
2220
    {
2221
      /* This is a csect entry.  */
2222
      fprintf (file, "AUX ");
2223
      if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2224
        {
2225
          BFD_ASSERT (! aux->fix_scnlen);
2226
          fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
2227
        }
2228
      else
2229
        {
2230
          fprintf (file, "indx ");
2231
          if (! aux->fix_scnlen)
2232
            fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
2233
          else
2234
            fprintf (file, "%4ld",
2235
                     (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2236
        }
2237
      fprintf (file,
2238
               " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2239
               aux->u.auxent.x_csect.x_parmhash,
2240
               (unsigned int) aux->u.auxent.x_csect.x_snhash,
2241
               SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2242
               SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2243
               (unsigned int) aux->u.auxent.x_csect.x_smclas,
2244
               aux->u.auxent.x_csect.x_stab,
2245
               (unsigned int) aux->u.auxent.x_csect.x_snstab);
2246
      return true;
2247
    }
2248
#endif
2249
 
2250
  /* Return false to indicate that no special action was taken.  */
2251
  return false;
2252
}
2253
 
2254
/*
2255
SUBSUBSECTION
2256
        Writing relocations
2257
 
2258
        To write relocations, the back end steps though the
2259
        canonical relocation table and create an
2260
        @code{internal_reloc}. The symbol index to use is removed from
2261
        the @code{offset} field in the symbol table supplied.  The
2262
        address comes directly from the sum of the section base
2263
        address and the relocation offset; the type is dug directly
2264
        from the howto field.  Then the @code{internal_reloc} is
2265
        swapped into the shape of an @code{external_reloc} and written
2266
        out to disk.
2267
 
2268
*/
2269
 
2270
#ifdef TARG_AUX
2271
 
2272
static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2273
 
2274
/* AUX's ld wants relocations to be sorted */
2275
static int
2276
compare_arelent_ptr (x, y)
2277
     const PTR x;
2278
     const PTR y;
2279
{
2280
  const arelent **a = (const arelent **) x;
2281
  const arelent **b = (const arelent **) y;
2282
  bfd_size_type aadr = (*a)->address;
2283
  bfd_size_type badr = (*b)->address;
2284
 
2285
  return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2286
}
2287
 
2288
#endif /* TARG_AUX */
2289
 
2290
static boolean
2291
coff_write_relocs (abfd, first_undef)
2292
     bfd * abfd;
2293
     int first_undef;
2294
{
2295
  asection *s;
2296
 
2297
  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2298
    {
2299
      unsigned int i;
2300
      struct external_reloc dst;
2301
      arelent **p;
2302
 
2303
#ifndef TARG_AUX
2304
      p = s->orelocation;
2305
#else
2306
      /* sort relocations before we write them out */
2307
      p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
2308
      if (p == NULL && s->reloc_count > 0)
2309
        return false;
2310
      memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
2311
      qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2312
#endif
2313
 
2314
      if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2315
        return false;
2316
      for (i = 0; i < s->reloc_count; i++)
2317
        {
2318
          struct internal_reloc n;
2319
          arelent *q = p[i];
2320
          memset ((PTR) & n, 0, sizeof (n));
2321
 
2322
          /* Now we've renumbered the symbols we know where the
2323
             undefined symbols live in the table.  Check the reloc
2324
             entries for symbols who's output bfd isn't the right one.
2325
             This is because the symbol was undefined (which means
2326
             that all the pointers are never made to point to the same
2327
             place). This is a bad thing,'cause the symbols attached
2328
             to the output bfd are indexed, so that the relocation
2329
             entries know which symbol index they point to.  So we
2330
             have to look up the output symbol here. */
2331
 
2332
          if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2333
            {
2334
              int i;
2335
              const char *sname = q->sym_ptr_ptr[0]->name;
2336
              asymbol **outsyms = abfd->outsymbols;
2337
              for (i = first_undef; outsyms[i]; i++)
2338
                {
2339
                  const char *intable = outsyms[i]->name;
2340
                  if (strcmp (intable, sname) == 0) {
2341
                    /* got a hit, so repoint the reloc */
2342
                    q->sym_ptr_ptr = outsyms + i;
2343
                    break;
2344
                  }
2345
                }
2346
            }
2347
 
2348
          n.r_vaddr = q->address + s->vma;
2349
 
2350
#ifdef R_IHCONST
2351
          /* The 29k const/consth reloc pair is a real kludge.  The consth
2352
             part doesn't have a symbol; it has an offset.  So rebuilt
2353
             that here.  */
2354
          if (q->howto->type == R_IHCONST)
2355
            n.r_symndx = q->addend;
2356
          else
2357
#endif
2358
            if (q->sym_ptr_ptr)
2359
              {
2360
#ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2361
                if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2362
#else
2363
                if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
2364
#endif
2365
                  /* This is a relocation relative to the absolute symbol.  */
2366
                  n.r_symndx = -1;
2367
                else
2368
                  {
2369
                    n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2370
                    /* Take notice if the symbol reloc points to a symbol
2371
                       we don't have in our symbol table.  What should we
2372
                       do for this??  */
2373
                    if (n.r_symndx > obj_conv_table_size (abfd))
2374
                      abort ();
2375
                  }
2376
              }
2377
 
2378
#ifdef SWAP_OUT_RELOC_OFFSET
2379
          n.r_offset = q->addend;
2380
#endif
2381
 
2382
#ifdef SELECT_RELOC
2383
          /* Work out reloc type from what is required */
2384
          SELECT_RELOC (n, q->howto);
2385
#else
2386
          n.r_type = q->howto->type;
2387
#endif
2388
          coff_swap_reloc_out (abfd, &n, &dst);
2389
          if (bfd_write ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd)
2390
              != bfd_coff_relsz (abfd))
2391
            return false;
2392
        }
2393
 
2394
#ifdef TARG_AUX
2395
      if (p != NULL)
2396
        free (p);
2397
#endif
2398
    }
2399
 
2400
  return true;
2401
}
2402
 
2403
/* Set flags and magic number of a coff file from architecture and machine
2404
   type.  Result is true if we can represent the arch&type, false if not.  */
2405
 
2406
static boolean
2407
coff_set_flags (abfd, magicp, flagsp)
2408
     bfd * abfd;
2409
     unsigned int *magicp ATTRIBUTE_UNUSED;
2410
     unsigned short *flagsp ATTRIBUTE_UNUSED;
2411
{
2412
  switch (bfd_get_arch (abfd))
2413
    {
2414
#ifdef Z8KMAGIC
2415
    case bfd_arch_z8k:
2416
      *magicp = Z8KMAGIC;
2417
      switch (bfd_get_mach (abfd))
2418
        {
2419
        case bfd_mach_z8001:
2420
          *flagsp = F_Z8001;
2421
          break;
2422
        case bfd_mach_z8002:
2423
          *flagsp = F_Z8002;
2424
          break;
2425
        default:
2426
          return false;
2427
        }
2428
      return true;
2429
#endif
2430
#ifdef I960ROMAGIC
2431
 
2432
    case bfd_arch_i960:
2433
 
2434
      {
2435
        unsigned flags;
2436
        *magicp = I960ROMAGIC;
2437
        /*
2438
          ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2439
          I960RWMAGIC);   FIXME???
2440
          */
2441
        switch (bfd_get_mach (abfd))
2442
          {
2443
          case bfd_mach_i960_core:
2444
            flags = F_I960CORE;
2445
            break;
2446
          case bfd_mach_i960_kb_sb:
2447
            flags = F_I960KB;
2448
            break;
2449
          case bfd_mach_i960_mc:
2450
            flags = F_I960MC;
2451
            break;
2452
          case bfd_mach_i960_xa:
2453
            flags = F_I960XA;
2454
            break;
2455
          case bfd_mach_i960_ca:
2456
            flags = F_I960CA;
2457
            break;
2458
          case bfd_mach_i960_ka_sa:
2459
            flags = F_I960KA;
2460
            break;
2461
          case bfd_mach_i960_jx:
2462
            flags = F_I960JX;
2463
            break;
2464
          case bfd_mach_i960_hx:
2465
            flags = F_I960HX;
2466
            break;
2467
          default:
2468
            return false;
2469
          }
2470
        *flagsp = flags;
2471
        return true;
2472
      }
2473
      break;
2474
#endif
2475
 
2476
#ifdef TIC30MAGIC
2477
    case bfd_arch_tic30:
2478
      *magicp = TIC30MAGIC;
2479
      return true;
2480
#endif
2481
 
2482
#ifdef TICOFF_DEFAULT_MAGIC
2483
    case TICOFF_TARGET_ARCH:
2484
      /* if there's no indication of which version we want, use the default */
2485
      if (!abfd->xvec )
2486
        *magicp = TICOFF_DEFAULT_MAGIC;
2487
      else
2488
        {
2489
          /* we may want to output in a different COFF version */
2490
          switch (abfd->xvec->name[4])
2491
            {
2492
            case '0':
2493
              *magicp = TICOFF0MAGIC;
2494
              break;
2495
            case '1':
2496
              *magicp = TICOFF1MAGIC;
2497
              break;
2498
            case '2':
2499
              *magicp = TICOFF2MAGIC;
2500
              break;
2501
            default:
2502
              return false;
2503
            }
2504
        }
2505
      return true;
2506
#endif
2507
 
2508
#ifdef TIC80_ARCH_MAGIC
2509
    case bfd_arch_tic80:
2510
      *magicp = TIC80_ARCH_MAGIC;
2511
      return true;
2512
#endif
2513
#ifdef ARMMAGIC
2514
    case bfd_arch_arm:
2515
#ifdef ARM_WINCE
2516
      * magicp = ARMPEMAGIC;
2517
#else
2518
      * magicp = ARMMAGIC;
2519
#endif
2520
      * flagsp = 0;
2521
      if (APCS_SET (abfd))
2522
        {
2523
          if (APCS_26_FLAG (abfd))
2524
            * flagsp |= F_APCS26;
2525
 
2526
          if (APCS_FLOAT_FLAG (abfd))
2527
            * flagsp |= F_APCS_FLOAT;
2528
 
2529
          if (PIC_FLAG (abfd))
2530
            * flagsp |= F_PIC;
2531
        }
2532
      if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2533
        * flagsp |= F_INTERWORK;
2534
      switch (bfd_get_mach (abfd))
2535
        {
2536
        case bfd_mach_arm_2:  * flagsp |= F_ARM_2;  break;
2537
        case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2538
        case bfd_mach_arm_3:  * flagsp |= F_ARM_3;  break;
2539
        case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2540
        case bfd_mach_arm_4:  * flagsp |= F_ARM_4;  break;
2541
        case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2542
        case bfd_mach_arm_5:  * flagsp |= F_ARM_5;  break;
2543
        case bfd_mach_arm_5T: * flagsp |= F_ARM_5;  break; /* XXX - we do not have an F_ARM_5T */
2544
        }
2545
      return true;
2546
#endif
2547
#ifdef PPCMAGIC
2548
    case bfd_arch_powerpc:
2549
      *magicp = PPCMAGIC;
2550
      return true;
2551
      break;
2552
#endif
2553
#ifdef I386MAGIC
2554
    case bfd_arch_i386:
2555
      *magicp = I386MAGIC;
2556
#ifdef LYNXOS
2557
      /* Just overwrite the usual value if we're doing Lynx. */
2558
      *magicp = LYNXCOFFMAGIC;
2559
#endif
2560
      return true;
2561
      break;
2562
#endif
2563
#ifdef I860MAGIC
2564
    case bfd_arch_i860:
2565
      *magicp = I860MAGIC;
2566
      return true;
2567
      break;
2568
#endif
2569
#ifdef MC68MAGIC
2570
    case bfd_arch_m68k:
2571
#ifdef APOLLOM68KMAGIC
2572
      *magicp = APOLLO_COFF_VERSION_NUMBER;
2573
#else
2574
      /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c.  */
2575
#ifdef NAMES_HAVE_UNDERSCORE
2576
      *magicp = MC68KBCSMAGIC;
2577
#else
2578
      *magicp = MC68MAGIC;
2579
#endif
2580
#endif
2581
#ifdef LYNXOS
2582
      /* Just overwrite the usual value if we're doing Lynx. */
2583
      *magicp = LYNXCOFFMAGIC;
2584
#endif
2585
      return true;
2586
      break;
2587
#endif
2588
 
2589
#ifdef MC88MAGIC
2590
    case bfd_arch_m88k:
2591
      *magicp = MC88OMAGIC;
2592
      return true;
2593
      break;
2594
#endif
2595
#ifdef H8300MAGIC
2596
    case bfd_arch_h8300:
2597
      switch (bfd_get_mach (abfd))
2598
        {
2599
        case bfd_mach_h8300:
2600
          *magicp = H8300MAGIC;
2601
          return true;
2602
        case bfd_mach_h8300h:
2603
          *magicp = H8300HMAGIC;
2604
          return true;
2605
        case bfd_mach_h8300s:
2606
          *magicp = H8300SMAGIC;
2607
          return true;
2608
        }
2609
      break;
2610
#endif
2611
 
2612
#ifdef SH_ARCH_MAGIC_BIG
2613
    case bfd_arch_sh:
2614
#ifdef COFF_IMAGE_WITH_PE
2615
      *magicp = SH_ARCH_MAGIC_WINCE;
2616
#else
2617
      if (bfd_big_endian (abfd))
2618
        *magicp = SH_ARCH_MAGIC_BIG;
2619
      else
2620
        *magicp = SH_ARCH_MAGIC_LITTLE;
2621
#endif
2622
      return true;
2623
      break;
2624
#endif
2625
 
2626
#ifdef MIPS_ARCH_MAGIC_WINCE
2627
    case bfd_arch_mips:
2628
      *magicp = MIPS_ARCH_MAGIC_WINCE;
2629
      return true;
2630
      break;
2631
#endif
2632
 
2633
#ifdef SPARCMAGIC
2634
    case bfd_arch_sparc:
2635
      *magicp = SPARCMAGIC;
2636
#ifdef LYNXOS
2637
      /* Just overwrite the usual value if we're doing Lynx. */
2638
      *magicp = LYNXCOFFMAGIC;
2639
#endif
2640
      return true;
2641
      break;
2642
#endif
2643
 
2644
#ifdef H8500MAGIC
2645
    case bfd_arch_h8500:
2646
      *magicp = H8500MAGIC;
2647
      return true;
2648
      break;
2649
#endif
2650
#ifdef A29K_MAGIC_BIG
2651
    case bfd_arch_a29k:
2652
      if (bfd_big_endian (abfd))
2653
        *magicp = A29K_MAGIC_BIG;
2654
      else
2655
        *magicp = A29K_MAGIC_LITTLE;
2656
      return true;
2657
      break;
2658
#endif
2659
 
2660
#ifdef WE32KMAGIC
2661
    case bfd_arch_we32k:
2662
      *magicp = WE32KMAGIC;
2663
      return true;
2664
      break;
2665
#endif
2666
 
2667
#ifdef U802TOCMAGIC
2668
    case bfd_arch_rs6000:
2669
#ifndef PPCMAGIC
2670
    case bfd_arch_powerpc:
2671
#endif
2672
      *magicp = U802TOCMAGIC;
2673
      return true;
2674
      break;
2675
#endif
2676
#ifdef OR32_MAGIC_BIG
2677
    case bfd_arch_or32:
2678
      if (bfd_big_endian (abfd))
2679
        *magicp = OR32_MAGIC_BIG;
2680
      else
2681
        *magicp = OR32_MAGIC_LITTLE;
2682
      return true;
2683
      break;
2684
#endif
2685
 
2686
#ifdef OR16_MAGIC_BIG
2687
    case bfd_arch_or16:
2688
      if (bfd_big_endian (abfd))
2689
        *magicp = OR16_MAGIC_BIG;
2690
      else
2691
        *magicp = OR16_MAGIC_LITTLE;
2692
      return true;
2693
      break;
2694
#endif
2695
 
2696
#ifdef MCOREMAGIC
2697
    case bfd_arch_mcore:
2698
      * magicp = MCOREMAGIC;
2699
      return true;
2700
#endif
2701
 
2702
    default:                    /* Unknown architecture */
2703
      /* return false;  -- fall through to "return false" below, to avoid
2704
       "statement never reached" errors on the one below. */
2705
      break;
2706
    }
2707
 
2708
  return false;
2709
}
2710
 
2711
 
2712
static boolean
2713
coff_set_arch_mach (abfd, arch, machine)
2714
     bfd * abfd;
2715
     enum bfd_architecture arch;
2716
     unsigned long machine;
2717
{
2718
  unsigned dummy1;
2719
  unsigned short dummy2;
2720
 
2721
  if (! bfd_default_set_arch_mach (abfd, arch, machine))
2722
    return false;
2723
 
2724
  if (arch != bfd_arch_unknown &&
2725
      coff_set_flags (abfd, &dummy1, &dummy2) != true)
2726
    return false;               /* We can't represent this type */
2727
 
2728
  return true;                  /* We're easy ... */
2729
}
2730
 
2731
#ifdef COFF_IMAGE_WITH_PE
2732
 
2733
/* This is used to sort sections by VMA, as required by PE image
2734
   files.  */
2735
 
2736
static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2737
 
2738
static int
2739
sort_by_secaddr (arg1, arg2)
2740
     const PTR arg1;
2741
     const PTR arg2;
2742
{
2743
  const asection *a = *(const asection **) arg1;
2744
  const asection *b = *(const asection **) arg2;
2745
 
2746
  if (a->vma < b->vma)
2747
    return -1;
2748
  else if (a->vma > b->vma)
2749
    return 1;
2750
  else
2751
    return 0;
2752
}
2753
 
2754
#endif /* COFF_IMAGE_WITH_PE */
2755
 
2756
/* Calculate the file position for each section. */
2757
 
2758
#ifndef I960
2759
#define ALIGN_SECTIONS_IN_FILE
2760
#endif
2761
#if defined(TIC80COFF) || defined(TICOFF)
2762
#undef ALIGN_SECTIONS_IN_FILE
2763
#endif
2764
 
2765
static boolean
2766
coff_compute_section_file_positions (abfd)
2767
     bfd * abfd;
2768
{
2769
  asection *current;
2770
  asection *previous = (asection *) NULL;
2771
  file_ptr sofar = bfd_coff_filhsz (abfd);
2772
  boolean align_adjust;
2773
#ifdef ALIGN_SECTIONS_IN_FILE
2774
  file_ptr old_sofar;
2775
#endif
2776
 
2777
#ifdef RS6000COFF_C
2778
  /* On XCOFF, if we have symbols, set up the .debug section.  */
2779
  if (bfd_get_symcount (abfd) > 0)
2780
    {
2781
      bfd_size_type sz;
2782
      bfd_size_type i, symcount;
2783
      asymbol **symp;
2784
 
2785
      sz = 0;
2786
      symcount = bfd_get_symcount (abfd);
2787
      for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2788
        {
2789
          coff_symbol_type *cf;
2790
 
2791
          cf = coff_symbol_from (abfd, *symp);
2792
          if (cf != NULL
2793
              && cf->native != NULL
2794
              && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2795
            {
2796
              size_t len;
2797
 
2798
              len = strlen (bfd_asymbol_name (*symp));
2799
              if (len > SYMNMLEN)
2800
                sz += len + 3;
2801
            }
2802
        }
2803
      if (sz > 0)
2804
        {
2805
          asection *dsec;
2806
 
2807
          dsec = bfd_make_section_old_way (abfd, ".debug");
2808
          if (dsec == NULL)
2809
            abort ();
2810
          dsec->_raw_size = sz;
2811
          dsec->flags |= SEC_HAS_CONTENTS;
2812
        }
2813
    }
2814
#endif
2815
 
2816
#ifdef COFF_IMAGE_WITH_PE
2817
  int page_size;
2818
  if (coff_data (abfd)->link_info)
2819
    {
2820
      page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2821
    }
2822
  else
2823
    page_size = PE_DEF_FILE_ALIGNMENT;
2824
#else
2825
#ifdef COFF_PAGE_SIZE
2826
  int page_size = COFF_PAGE_SIZE;
2827
#endif
2828
#endif
2829
 
2830
  if (bfd_get_start_address (abfd))
2831
    {
2832
      /*  A start address may have been added to the original file. In this
2833
          case it will need an optional header to record it.  */
2834
      abfd->flags |= EXEC_P;
2835
    }
2836
 
2837
  if (abfd->flags & EXEC_P)
2838
    sofar += bfd_coff_aoutsz (abfd);
2839
#ifdef RS6000COFF_C
2840
  else if (xcoff_data (abfd)->full_aouthdr)
2841
    sofar += bfd_coff_aoutsz (abfd);
2842
  else
2843
    sofar += SMALL_AOUTSZ;
2844
#endif
2845
 
2846
  sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2847
 
2848
#ifdef RS6000COFF_C
2849
  /* XCOFF handles overflows in the reloc and line number count fields
2850
     by allocating a new section header to hold the correct counts.  */
2851
  for (current = abfd->sections; current != NULL; current = current->next)
2852
    if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2853
      sofar += bfd_coff_scnhsz (abfd);
2854
#endif
2855
 
2856
#ifdef COFF_IMAGE_WITH_PE
2857
  {
2858
    /* PE requires the sections to be in memory order when listed in
2859
       the section headers.  It also does not like empty loadable
2860
       sections.  The sections apparently do not have to be in the
2861
       right order in the image file itself, but we do need to get the
2862
       target_index values right.  */
2863
 
2864
    int count;
2865
    asection **section_list;
2866
    int i;
2867
    int target_index;
2868
 
2869
    count = 0;
2870
    for (current = abfd->sections; current != NULL; current = current->next)
2871
      ++count;
2872
 
2873
    /* We allocate an extra cell to simplify the final loop.  */
2874
    section_list = bfd_malloc (sizeof (struct asection *) * (count + 1));
2875
    if (section_list == NULL)
2876
      return false;
2877
 
2878
    i = 0;
2879
    for (current = abfd->sections; current != NULL; current = current->next)
2880
      {
2881
        section_list[i] = current;
2882
        ++i;
2883
      }
2884
    section_list[i] = NULL;
2885
 
2886
    qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
2887
 
2888
    /* Rethread the linked list into sorted order; at the same time,
2889
       assign target_index values.  */
2890
    target_index = 1;
2891
    abfd->sections = section_list[0];
2892
    for (i = 0; i < count; i++)
2893
      {
2894
        current = section_list[i];
2895
        current->next = section_list[i + 1];
2896
 
2897
        /* Later, if the section has zero size, we'll be throwing it
2898
           away, so we don't want to number it now.  Note that having
2899
           a zero size and having real contents are different
2900
           concepts: .bss has no contents, but (usually) non-zero
2901
           size.  */
2902
        if (current->_raw_size == 0)
2903
          {
2904
            /* Discard.  However, it still might have (valid) symbols
2905
               in it, so arbitrarily set it to section 1 (indexing is
2906
               1-based here; usually .text).  __end__ and other
2907
               contents of .endsection really have this happen.
2908
               FIXME: This seems somewhat dubious.  */
2909
            current->target_index = 1;
2910
          }
2911
        else
2912
          current->target_index = target_index++;
2913
      }
2914
 
2915
    free (section_list);
2916
  }
2917
#else /* ! COFF_IMAGE_WITH_PE */
2918
  {
2919
    /* Set the target_index field.  */
2920
    int target_index;
2921
 
2922
    target_index = 1;
2923
    for (current = abfd->sections; current != NULL; current = current->next)
2924
      current->target_index = target_index++;
2925
  }
2926
#endif /* ! COFF_IMAGE_WITH_PE */
2927
 
2928
  align_adjust = false;
2929
  for (current = abfd->sections;
2930
       current != (asection *) NULL;
2931
       current = current->next)
2932
    {
2933
#ifdef COFF_IMAGE_WITH_PE
2934
      /* With PE we have to pad each section to be a multiple of its
2935
         page size too, and remember both sizes.  */
2936
      if (coff_section_data (abfd, current) == NULL)
2937
        {
2938
          current->used_by_bfd =
2939
            (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
2940
          if (current->used_by_bfd == NULL)
2941
            return false;
2942
        }
2943
      if (pei_section_data (abfd, current) == NULL)
2944
        {
2945
          coff_section_data (abfd, current)->tdata =
2946
            (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
2947
          if (coff_section_data (abfd, current)->tdata == NULL)
2948
            return false;
2949
        }
2950
      if (pei_section_data (abfd, current)->virt_size == 0)
2951
        pei_section_data (abfd, current)->virt_size = current->_raw_size;
2952
#endif
2953
 
2954
      /* Only deal with sections which have contents.  */
2955
      if (!(current->flags & SEC_HAS_CONTENTS))
2956
        continue;
2957
 
2958
#ifdef COFF_IMAGE_WITH_PE
2959
      /* Make sure we skip empty sections in a PE image.  */
2960
      if (current->_raw_size == 0)
2961
        continue;
2962
#endif
2963
 
2964
      /* Align the sections in the file to the same boundary on
2965
         which they are aligned in virtual memory.  I960 doesn't
2966
         do this (FIXME) so we can stay in sync with Intel.  960
2967
         doesn't yet page from files... */
2968
#ifdef ALIGN_SECTIONS_IN_FILE
2969
      if ((abfd->flags & EXEC_P) != 0)
2970
        {
2971
          /* make sure this section is aligned on the right boundary - by
2972
             padding the previous section up if necessary */
2973
 
2974
          old_sofar = sofar;
2975
          sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2976
          if (previous != (asection *) NULL)
2977
            {
2978
              previous->_raw_size += sofar - old_sofar;
2979
            }
2980
        }
2981
 
2982
#endif
2983
 
2984
      /* In demand paged files the low order bits of the file offset
2985
         must match the low order bits of the virtual address.  */
2986
#ifdef COFF_PAGE_SIZE
2987
      if ((abfd->flags & D_PAGED) != 0
2988
          && (current->flags & SEC_ALLOC) != 0)
2989
        sofar += (current->vma - sofar) % page_size;
2990
#endif
2991
      current->filepos = sofar;
2992
 
2993
#ifdef COFF_IMAGE_WITH_PE
2994
      /* Set the padded size.  */
2995
      current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2996
#endif
2997
 
2998
      sofar += current->_raw_size;
2999
 
3000
#ifdef ALIGN_SECTIONS_IN_FILE
3001
      /* make sure that this section is of the right size too */
3002
      if ((abfd->flags & EXEC_P) == 0)
3003
        {
3004
          bfd_size_type old_size;
3005
 
3006
          old_size = current->_raw_size;
3007
          current->_raw_size = BFD_ALIGN (current->_raw_size,
3008
                                          1 << current->alignment_power);
3009
          align_adjust = current->_raw_size != old_size;
3010
          sofar += current->_raw_size - old_size;
3011
        }
3012
      else
3013
        {
3014
          old_sofar = sofar;
3015
          sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3016
          align_adjust = sofar != old_sofar;
3017
          current->_raw_size += sofar - old_sofar;
3018
        }
3019
#endif
3020
 
3021
#ifdef COFF_IMAGE_WITH_PE
3022
      /* For PE we need to make sure we pad out to the aligned
3023
         _raw_size, in case the caller only writes out data to the
3024
         unaligned _raw_size.  */
3025
      if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3026
        align_adjust = true;
3027
#endif
3028
 
3029
#ifdef _LIB
3030
      /* Force .lib sections to start at zero.  The vma is then
3031
         incremented in coff_set_section_contents.  This is right for
3032
         SVR3.2.  */
3033
      if (strcmp (current->name, _LIB) == 0)
3034
        bfd_set_section_vma (abfd, current, 0);
3035
#endif
3036
 
3037
      previous = current;
3038
    }
3039
 
3040
  /* It is now safe to write to the output file.  If we needed an
3041
     alignment adjustment for the last section, then make sure that
3042
     there is a byte at offset sofar.  If there are no symbols and no
3043
     relocs, then nothing follows the last section.  If we don't force
3044
     the last byte out, then the file may appear to be truncated.  */
3045
  if (align_adjust)
3046
    {
3047
      bfd_byte b;
3048
 
3049
      b = 0;
3050
      if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3051
          || bfd_write (&b, 1, 1, abfd) != 1)
3052
        return false;
3053
    }
3054
 
3055
  /* Make sure the relocations are aligned.  We don't need to make
3056
     sure that this byte exists, because it will only matter if there
3057
     really are relocs.  */
3058
  sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3059
 
3060
  obj_relocbase (abfd) = sofar;
3061
  abfd->output_has_begun = true;
3062
 
3063
  return true;
3064
}
3065
 
3066
#if 0
3067
 
3068
/* This can never work, because it is called too late--after the
3069
   section positions have been set.  I can't figure out what it is
3070
   for, so I am going to disable it--Ian Taylor 20 March 1996.  */
3071
 
3072
/* If .file, .text, .data, .bss symbols are missing, add them.  */
3073
/* @@ Should we only be adding missing symbols, or overriding the aux
3074
   values for existing section symbols?  */
3075
static boolean
3076
coff_add_missing_symbols (abfd)
3077
     bfd *abfd;
3078
{
3079
  unsigned int nsyms = bfd_get_symcount (abfd);
3080
  asymbol **sympp = abfd->outsymbols;
3081
  asymbol **sympp2;
3082
  unsigned int i;
3083
  int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3084
 
3085
  for (i = 0; i < nsyms; i++)
3086
    {
3087
      coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3088
      CONST char *name;
3089
      if (csym)
3090
        {
3091
          /* only do this if there is a coff representation of the input
3092
           symbol */
3093
          if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3094
            {
3095
              need_file = 0;
3096
              continue;
3097
            }
3098
          name = csym->symbol.name;
3099
          if (!name)
3100
            continue;
3101
          if (!strcmp (name, _TEXT))
3102
            need_text = 0;
3103
#ifdef APOLLO_M68
3104
          else if (!strcmp (name, ".wtext"))
3105
            need_text = 0;
3106
#endif
3107
          else if (!strcmp (name, _DATA))
3108
            need_data = 0;
3109
          else if (!strcmp (name, _BSS))
3110
            need_bss = 0;
3111
        }
3112
    }
3113
  /* Now i == bfd_get_symcount (abfd).  */
3114
  /* @@ For now, don't deal with .file symbol.  */
3115
  need_file = 0;
3116
 
3117
  if (!need_text && !need_data && !need_bss && !need_file)
3118
    return true;
3119
  nsyms += need_text + need_data + need_bss + need_file;
3120
  sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
3121
  if (!sympp2)
3122
    return false;
3123
  memcpy (sympp2, sympp, i * sizeof (asymbol *));
3124
  if (need_file)
3125
    {
3126
      /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
3127
      abort ();
3128
    }
3129
  if (need_text)
3130
    sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3131
  if (need_data)
3132
    sympp2[i++] = coff_section_symbol (abfd, _DATA);
3133
  if (need_bss)
3134
    sympp2[i++] = coff_section_symbol (abfd, _BSS);
3135
  BFD_ASSERT (i == nsyms);
3136
  bfd_set_symtab (abfd, sympp2, nsyms);
3137
  return true;
3138
}
3139
 
3140
#endif /* 0 */
3141
 
3142
/* SUPPRESS 558 */
3143
/* SUPPRESS 529 */
3144
static boolean
3145
coff_write_object_contents (abfd)
3146
     bfd * abfd;
3147
{
3148
  asection *current;
3149
  boolean hasrelocs = false;
3150
  boolean haslinno = false;
3151
  boolean hasdebug = false;
3152
  file_ptr scn_base;
3153
  file_ptr reloc_base;
3154
  file_ptr lineno_base;
3155
  file_ptr sym_base;
3156
  unsigned long reloc_size = 0;
3157
  unsigned long lnno_size = 0;
3158
  boolean long_section_names;
3159
  asection *text_sec = NULL;
3160
  asection *data_sec = NULL;
3161
  asection *bss_sec = NULL;
3162
  struct internal_filehdr internal_f;
3163
  struct internal_aouthdr internal_a;
3164
#ifdef COFF_LONG_SECTION_NAMES
3165
  size_t string_size = STRING_SIZE_SIZE;
3166
#endif
3167
 
3168
  bfd_set_error (bfd_error_system_call);
3169
 
3170
  /* Make a pass through the symbol table to count line number entries and
3171
     put them into the correct asections */
3172
 
3173
  lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3174
 
3175
  if (abfd->output_has_begun == false)
3176
    {
3177
      if (! coff_compute_section_file_positions (abfd))
3178
        return false;
3179
    }
3180
 
3181
  reloc_base = obj_relocbase (abfd);
3182
 
3183
  /* Work out the size of the reloc and linno areas */
3184
 
3185
  for (current = abfd->sections; current != NULL; current =
3186
       current->next)
3187
    reloc_size += current->reloc_count * bfd_coff_relsz (abfd);
3188
 
3189
  lineno_base = reloc_base + reloc_size;
3190
  sym_base = lineno_base + lnno_size;
3191
 
3192
  /* Indicate in each section->line_filepos its actual file address */
3193
  for (current = abfd->sections; current != NULL; current =
3194
       current->next)
3195
    {
3196
      if (current->lineno_count)
3197
        {
3198
          current->line_filepos = lineno_base;
3199
          current->moving_line_filepos = lineno_base;
3200
          lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3201
        }
3202
      else
3203
        {
3204
          current->line_filepos = 0;
3205
        }
3206
      if (current->reloc_count)
3207
        {
3208
          current->rel_filepos = reloc_base;
3209
          reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3210
        }
3211
      else
3212
        {
3213
          current->rel_filepos = 0;
3214
        }
3215
    }
3216
 
3217
  /* Write section headers to the file.  */
3218
  internal_f.f_nscns = 0;
3219
 
3220
  if ((abfd->flags & EXEC_P) != 0)
3221
    scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3222
  else
3223
    {
3224
      scn_base = bfd_coff_filhsz (abfd);
3225
#ifdef RS6000COFF_C
3226
      if (xcoff_data (abfd)->full_aouthdr)
3227
        scn_base += bfd_coff_aoutsz (abfd);
3228
      else
3229
        scn_base += SMALL_AOUTSZ;
3230
#endif
3231
    }
3232
 
3233
  if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3234
    return false;
3235
 
3236
  long_section_names = false;
3237
  for (current = abfd->sections;
3238
       current != NULL;
3239
       current = current->next)
3240
    {
3241
      struct internal_scnhdr section;
3242
      boolean is_reloc_section = false;
3243
 
3244
#ifdef COFF_IMAGE_WITH_PE
3245
      if (strcmp (current->name, ".reloc") == 0)
3246
        {
3247
          is_reloc_section = true;
3248
          hasrelocs = true;
3249
          pe_data (abfd)->has_reloc_section = 1;
3250
        }
3251
#endif
3252
 
3253
      internal_f.f_nscns++;
3254
 
3255
      strncpy (section.s_name, current->name, SCNNMLEN);
3256
 
3257
#ifdef COFF_LONG_SECTION_NAMES
3258
      /* Handle long section names as in PE.  This must be compatible
3259
         with the code in coff_write_symbols and _bfd_coff_final_link.  */
3260
      {
3261
        size_t len;
3262
 
3263
        len = strlen (current->name);
3264
        if (len > SCNNMLEN)
3265
          {
3266
            memset (section.s_name, 0, SCNNMLEN);
3267
            sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3268
            string_size += len + 1;
3269
            long_section_names = true;
3270
          }
3271
      }
3272
#endif
3273
 
3274
#ifdef _LIB
3275
      /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
3276
         Ian Taylor <ian@cygnus.com>.  */
3277
      if (strcmp (current->name, _LIB) == 0)
3278
        section.s_vaddr = 0;
3279
      else
3280
#endif
3281
      section.s_vaddr = current->vma;
3282
      section.s_paddr = current->lma;
3283
      section.s_size =  current->_raw_size;
3284
 
3285
#ifdef COFF_WITH_PE
3286
      section.s_paddr = 0;
3287
#endif
3288
#ifdef COFF_IMAGE_WITH_PE
3289
      /* Reminder: s_paddr holds the virtual size of the section.  */
3290
      if (coff_section_data (abfd, current) != NULL
3291
          && pei_section_data (abfd, current) != NULL)
3292
        section.s_paddr = pei_section_data (abfd, current)->virt_size;
3293
      else
3294
        section.s_paddr = 0;
3295
#endif
3296
 
3297
      /*
3298
         If this section has no size or is unloadable then the scnptr
3299
         will be 0 too
3300
         */
3301
      if (current->_raw_size == 0 ||
3302
          (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3303
        {
3304
          section.s_scnptr = 0;
3305
        }
3306
      else
3307
        {
3308
          section.s_scnptr = current->filepos;
3309
        }
3310
      section.s_relptr = current->rel_filepos;
3311
      section.s_lnnoptr = current->line_filepos;
3312
      section.s_nreloc = current->reloc_count;
3313
      section.s_nlnno = current->lineno_count;
3314
#ifndef COFF_IMAGE_WITH_PE
3315
      /* In PEI, relocs come in the .reloc section.  */
3316
      if (current->reloc_count != 0)
3317
        hasrelocs = true;
3318
#endif
3319
      if (current->lineno_count != 0)
3320
        haslinno = true;
3321
      if ((current->flags & SEC_DEBUGGING) != 0
3322
          && ! is_reloc_section)
3323
        hasdebug = true;
3324
 
3325
#ifdef RS6000COFF_C
3326
      /* Indicate the use of an XCOFF overflow section header.  */
3327
      if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3328
        {
3329
          section.s_nreloc = 0xffff;
3330
          section.s_nlnno = 0xffff;
3331
        }
3332
#endif
3333
 
3334
      section.s_flags = sec_to_styp_flags (current->name, current->flags);
3335
 
3336
      if (!strcmp (current->name, _TEXT))
3337
        {
3338
          text_sec = current;
3339
        }
3340
      else if (!strcmp (current->name, _DATA))
3341
        {
3342
          data_sec = current;
3343
        }
3344
      else if (!strcmp (current->name, _BSS))
3345
        {
3346
          bss_sec = current;
3347
        }
3348
 
3349
#ifdef I960
3350
      section.s_align = (current->alignment_power
3351
                         ? 1 << current->alignment_power
3352
                         : 0);
3353
#endif
3354
#ifdef TIC80COFF 
3355
      /* TI COFF puts the alignment power in bits 8-11 of the flags */
3356
      section.s_flags |= (current->alignment_power & 0xF) << 8;
3357
#endif
3358
#ifdef COFF_ENCODE_ALIGNMENT
3359
      COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3360
#endif
3361
 
3362
#ifdef COFF_IMAGE_WITH_PE
3363
      /* Suppress output of the sections if they are null.  ld
3364
         includes the bss and data sections even if there is no size
3365
         assigned to them.  NT loader doesn't like it if these section
3366
         headers are included if the sections themselves are not
3367
         needed.  See also coff_compute_section_file_positions.  */
3368
      if (section.s_size == 0)
3369
        internal_f.f_nscns--;
3370
      else
3371
#endif
3372
        {
3373
          SCNHDR buff;
3374
          if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3375
              || bfd_write ((PTR) (&buff), 1, bfd_coff_scnhsz (abfd), abfd)
3376
                   != bfd_coff_scnhsz (abfd))
3377
            return false;
3378
        }
3379
 
3380
#ifdef COFF_WITH_PE
3381
      /* PE stores COMDAT section information in the symbol table.  If
3382
         this section is supposed to have some COMDAT info, track down
3383
         the symbol in the symbol table and modify it.  */
3384
      if ((current->flags & SEC_LINK_ONCE) != 0)
3385
        {
3386
          unsigned int i, count;
3387
          asymbol **psym;
3388
          coff_symbol_type *csym = NULL;
3389
          asymbol **psymsec;
3390
 
3391
          psymsec = NULL;
3392
          count = bfd_get_symcount (abfd);
3393
          for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3394
            {
3395
              if ((*psym)->section != current)
3396
                continue;
3397
 
3398
              /* Remember the location of the first symbol in this
3399
                 section.  */
3400
              if (psymsec == NULL)
3401
                psymsec = psym;
3402
 
3403
              /* See if this is the section symbol.  */
3404
              if (strcmp ((*psym)->name, current->name) == 0)
3405
                {
3406
                  csym = coff_symbol_from (abfd, *psym);
3407
                  if (csym == NULL
3408
                      || csym->native == NULL
3409
                      || csym->native->u.syment.n_numaux < 1
3410
                      || csym->native->u.syment.n_sclass != C_STAT
3411
                      || csym->native->u.syment.n_type != T_NULL)
3412
                    continue;
3413
 
3414
                  /* Here *PSYM is the section symbol for CURRENT.  */
3415
 
3416
                  break;
3417
                }
3418
            }
3419
 
3420
          /* Did we find it?
3421
             Note that we might not if we're converting the file from
3422
             some other object file format.  */
3423
          if (i < count)
3424
            {
3425
              combined_entry_type *aux;
3426
 
3427
              /* We don't touch the x_checksum field.  The
3428
                 x_associated field is not currently supported.  */
3429
 
3430
              aux = csym->native + 1;
3431
              switch (current->flags & SEC_LINK_DUPLICATES)
3432
                {
3433
                case SEC_LINK_DUPLICATES_DISCARD:
3434
                  aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3435
                  break;
3436
 
3437
                case SEC_LINK_DUPLICATES_ONE_ONLY:
3438
                  aux->u.auxent.x_scn.x_comdat =
3439
                    IMAGE_COMDAT_SELECT_NODUPLICATES;
3440
                  break;
3441
 
3442
                case SEC_LINK_DUPLICATES_SAME_SIZE:
3443
                  aux->u.auxent.x_scn.x_comdat =
3444
                    IMAGE_COMDAT_SELECT_SAME_SIZE;
3445
                  break;
3446
 
3447
                case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3448
                  aux->u.auxent.x_scn.x_comdat =
3449
                    IMAGE_COMDAT_SELECT_EXACT_MATCH;
3450
                  break;
3451
                }
3452
 
3453
              /* The COMDAT symbol must be the first symbol from this
3454
                 section in the symbol table.  In order to make this
3455
                 work, we move the COMDAT symbol before the first
3456
                 symbol we found in the search above.  It's OK to
3457
                 rearrange the symbol table at this point, because
3458
                 coff_renumber_symbols is going to rearrange it
3459
                 further and fix up all the aux entries.  */
3460
              if (psym != psymsec)
3461
                {
3462
                  asymbol *hold;
3463
                  asymbol **pcopy;
3464
 
3465
                  hold = *psym;
3466
                  for (pcopy = psym; pcopy > psymsec; pcopy--)
3467
                    pcopy[0] = pcopy[-1];
3468
                  *psymsec = hold;
3469
                }
3470
            }
3471
        }
3472
#endif /* COFF_WITH_PE */
3473
    }
3474
 
3475
#ifdef RS6000COFF_C
3476
  /* XCOFF handles overflows in the reloc and line number count fields
3477
     by creating a new section header to hold the correct values.  */
3478
  for (current = abfd->sections; current != NULL; current = current->next)
3479
    {
3480
      if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3481
        {
3482
          struct internal_scnhdr scnhdr;
3483
          SCNHDR buff;
3484
 
3485
          internal_f.f_nscns++;
3486
          strncpy (&(scnhdr.s_name[0]), current->name, 8);
3487
          scnhdr.s_paddr = current->reloc_count;
3488
          scnhdr.s_vaddr = current->lineno_count;
3489
          scnhdr.s_size = 0;
3490
          scnhdr.s_scnptr = 0;
3491
          scnhdr.s_relptr = current->rel_filepos;
3492
          scnhdr.s_lnnoptr = current->line_filepos;
3493
          scnhdr.s_nreloc = current->target_index;
3494
          scnhdr.s_nlnno = current->target_index;
3495
          scnhdr.s_flags = STYP_OVRFLO;
3496
          if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3497
              || bfd_write ((PTR) &buff, 1, bfd_coff_scnhsz (abfd), abfd)
3498
                   != bfd_coff_scnhsz (abfd))
3499
            return false;
3500
        }
3501
    }
3502
#endif
3503
 
3504
  /* OK, now set up the filehdr... */
3505
 
3506
  /* Don't include the internal abs section in the section count */
3507
 
3508
  /*
3509
     We will NOT put a fucking timestamp in the header here. Every time you
3510
     put it back, I will come in and take it out again.  I'm sorry.  This
3511
     field does not belong here.  We fill it with a 0 so it compares the
3512
     same but is not a reasonable time. -- gnu@cygnus.com
3513
     */
3514
  internal_f.f_timdat = 0;
3515
 
3516
  internal_f.f_flags = 0;
3517
 
3518
  if (abfd->flags & EXEC_P)
3519
    internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3520
  else
3521
    {
3522
      internal_f.f_opthdr = 0;
3523
#ifdef RS6000COFF_C
3524
      if (xcoff_data (abfd)->full_aouthdr)
3525
        internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3526
      else
3527
        internal_f.f_opthdr = SMALL_AOUTSZ;
3528
#endif
3529
    }
3530
 
3531
  if (!hasrelocs)
3532
    internal_f.f_flags |= F_RELFLG;
3533
  if (!haslinno)
3534
    internal_f.f_flags |= F_LNNO;
3535
  if (abfd->flags & EXEC_P)
3536
    internal_f.f_flags |= F_EXEC;
3537
#ifdef COFF_IMAGE_WITH_PE
3538
  if (! hasdebug)
3539
    internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3540
#endif
3541
 
3542
#ifndef COFF_WITH_PE
3543
  if (bfd_little_endian (abfd))
3544
    internal_f.f_flags |= F_AR32WR;
3545
  else
3546
    internal_f.f_flags |= F_AR32W;
3547
#endif
3548
 
3549
#ifdef TI_TARGET_ID
3550
  /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3551
     but it doesn't hurt to set it internally */
3552
  internal_f.f_target_id = TI_TARGET_ID;
3553
#endif
3554
#ifdef TIC80_TARGET_ID
3555
  internal_f.f_target_id = TIC80_TARGET_ID;
3556
#endif
3557
 
3558
  /*
3559
     FIXME, should do something about the other byte orders and
3560
     architectures.
3561
     */
3562
 
3563
#ifdef RS6000COFF_C
3564
  if ((abfd->flags & DYNAMIC) != 0)
3565
    internal_f.f_flags |= F_SHROBJ;
3566
  if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3567
    internal_f.f_flags |= F_DYNLOAD;
3568
#endif
3569
 
3570
  memset (&internal_a, 0, sizeof internal_a);
3571
 
3572
  /* Set up architecture-dependent stuff */
3573
 
3574
  {
3575
    unsigned int magic = 0;
3576
    unsigned short flags = 0;
3577
    coff_set_flags (abfd, &magic, &flags);
3578
    internal_f.f_magic = magic;
3579
    internal_f.f_flags |= flags;
3580
    /* ...and the "opt"hdr... */
3581
 
3582
#ifdef A29K
3583
#ifdef ULTRA3                   /* NYU's machine */
3584
    /* FIXME: This is a bogus check.  I really want to see if there
3585
     * is a .shbss or a .shdata section, if so then set the magic
3586
     * number to indicate a shared data executable.
3587
     */
3588
    if (internal_f.f_nscns >= 7)
3589
      internal_a.magic = SHMAGIC; /* Shared magic */
3590
    else
3591
#endif /* ULTRA3 */
3592
      internal_a.magic = NMAGIC; /* Assume separate i/d */
3593
#define __A_MAGIC_SET__
3594
#endif /* A29K */
3595
#ifdef TICOFF_AOUT_MAGIC
3596
    internal_a.magic = TICOFF_AOUT_MAGIC;
3597
#define __A_MAGIC_SET__
3598
#endif
3599
#ifdef TIC80COFF
3600
    internal_a.magic = TIC80_ARCH_MAGIC;
3601
#define __A_MAGIC_SET__
3602
#endif /* TIC80 */
3603
#ifdef I860
3604
    /* FIXME: What are the a.out magic numbers for the i860?  */
3605
    internal_a.magic = 0;
3606
#define __A_MAGIC_SET__
3607
#endif /* I860 */
3608
#ifdef I960
3609
    internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3610
#define __A_MAGIC_SET__
3611
#endif /* I960 */
3612
#if M88
3613
#define __A_MAGIC_SET__
3614
    internal_a.magic = PAGEMAGICBCS;
3615
#endif /* M88 */
3616
 
3617
#if APOLLO_M68
3618
#define __A_MAGIC_SET__
3619
    internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3620
#endif
3621
 
3622
#if defined(M68) || defined(WE32K) || defined(M68K)
3623
#define __A_MAGIC_SET__
3624
#if defined(LYNXOS)
3625
    internal_a.magic = LYNXCOFFMAGIC;
3626
#else
3627
#if defined(TARG_AUX)
3628
    internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3629
                        abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3630
                        PAGEMAGICEXECSWAPPED);
3631
#else
3632
#if defined (PAGEMAGICPEXECPAGED)
3633
    internal_a.magic = PAGEMAGICPEXECPAGED;
3634
#endif
3635
#endif /* TARG_AUX */
3636
#endif /* LYNXOS */
3637
#endif /* M68 || WE32K || M68K */
3638
 
3639
#if defined(ARM)
3640
#define __A_MAGIC_SET__
3641
    internal_a.magic = ZMAGIC;
3642
#endif 
3643
 
3644
#if defined(PPC_PE)
3645
#define __A_MAGIC_SET__
3646
    internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3647
#endif
3648
 
3649
#if defined MCORE_PE
3650
#define __A_MAGIC_SET__
3651
    internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3652
#endif 
3653
 
3654
#if defined(I386)
3655
#define __A_MAGIC_SET__
3656
#if defined(LYNXOS)
3657
    internal_a.magic = LYNXCOFFMAGIC;
3658
#else  /* LYNXOS */
3659
    internal_a.magic = ZMAGIC;
3660
#endif /* LYNXOS */
3661
#endif /* I386 */
3662
 
3663
#if defined(SPARC)
3664
#define __A_MAGIC_SET__
3665
#if defined(LYNXOS)
3666
    internal_a.magic = LYNXCOFFMAGIC;
3667
#endif /* LYNXOS */
3668
#endif /* SPARC */
3669
 
3670
#ifdef RS6000COFF_C
3671
#define __A_MAGIC_SET__
3672
    internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3673
    (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3674
    RS6K_AOUTHDR_OMAGIC;
3675
#endif
3676
 
3677
#if defined(SH) && defined(COFF_WITH_PE)
3678
#define __A_MAGIC_SET__
3679
    internal_a.magic = SH_PE_MAGIC;
3680
#endif
3681
 
3682
#ifdef OR32
3683
#define __A_MAGIC_SET__
3684
      internal_a.magic = NMAGIC; /* Assume separate i/d */
3685
#endif
3686
#ifdef OR16
3687
#define __A_MAGIC_SET__
3688
      internal_a.magic = NMAGIC; /* Assume separate i/d */
3689
#endif
3690
 
3691
#if defined(MIPS) && defined(COFF_WITH_PE)
3692
#define __A_MAGIC_SET__
3693
    internal_a.magic = MIPS_PE_MAGIC;
3694
#endif
3695
 
3696
#ifndef __A_MAGIC_SET__
3697
#include "Your aouthdr magic number is not being set!"
3698
#else
3699
#undef __A_MAGIC_SET__
3700
#endif
3701
  }
3702
 
3703
  /* FIXME: Does anybody ever set this to another value?  */
3704
  internal_a.vstamp = 0;
3705
 
3706
  /* Now should write relocs, strings, syms */
3707
  obj_sym_filepos (abfd) = sym_base;
3708
 
3709
  if (bfd_get_symcount (abfd) != 0)
3710
    {
3711
      int firstundef;
3712
#if 0
3713
      if (!coff_add_missing_symbols (abfd))
3714
        return false;
3715
#endif
3716
      if (!coff_renumber_symbols (abfd, &firstundef))
3717
        return false;
3718
      coff_mangle_symbols (abfd);
3719
      if (! coff_write_symbols (abfd))
3720
        return false;
3721
      if (! coff_write_linenumbers (abfd))
3722
        return false;
3723
      if (! coff_write_relocs (abfd, firstundef))
3724
        return false;
3725
    }
3726
#ifdef COFF_LONG_SECTION_NAMES
3727
  else if (long_section_names)
3728
    {
3729
      /* If we have long section names we have to write out the string
3730
         table even if there are no symbols.  */
3731
      if (! coff_write_symbols (abfd))
3732
        return false;
3733
    }
3734
#endif
3735
#ifdef COFF_IMAGE_WITH_PE
3736
#ifdef PPC_PE
3737
  else if ((abfd->flags & EXEC_P) != 0)
3738
    {
3739
      bfd_byte b;
3740
 
3741
      /* PowerPC PE appears to require that all executable files be
3742
         rounded up to the page size.  */
3743
      b = 0;
3744
      if (bfd_seek (abfd,
3745
                    BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3746
                    SEEK_SET) != 0
3747
          || bfd_write (&b, 1, 1, abfd) != 1)
3748
        return false;
3749
    }
3750
#endif
3751
#endif
3752
 
3753
  /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3754
     backend linker, and obj_raw_syment_count is not valid until after
3755
     coff_write_symbols is called.  */
3756
  if (obj_raw_syment_count (abfd) != 0)
3757
    {
3758
      internal_f.f_symptr = sym_base;
3759
#ifdef RS6000COFF_C
3760
      /* AIX appears to require that F_RELFLG not be set if there are
3761
         local symbols but no relocations.  */
3762
      internal_f.f_flags &=~ F_RELFLG;
3763
#endif
3764
    }
3765
  else
3766
    {
3767
      if (long_section_names)
3768
        internal_f.f_symptr = sym_base;
3769
      else
3770
        internal_f.f_symptr = 0;
3771
      internal_f.f_flags |= F_LSYMS;
3772
    }
3773
 
3774
  if (text_sec)
3775
    {
3776
      internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3777
      internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3778
    }
3779
  if (data_sec)
3780
    {
3781
      internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3782
      internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3783
    }
3784
  if (bss_sec)
3785
    {
3786
      internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3787
      if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3788
        internal_a.data_start = bss_sec->vma;
3789
    }
3790
 
3791
  internal_a.entry = bfd_get_start_address (abfd);
3792
  internal_f.f_nsyms = obj_raw_syment_count (abfd);
3793
 
3794
#ifdef RS6000COFF_C
3795
  if (xcoff_data (abfd)->full_aouthdr)
3796
    {
3797
      bfd_vma toc;
3798
      asection *loader_sec;
3799
 
3800
      internal_a.vstamp = 1;
3801
 
3802
      internal_a.o_snentry = xcoff_data (abfd)->snentry;
3803
      if (internal_a.o_snentry == 0)
3804
        internal_a.entry = (bfd_vma) -1;
3805
 
3806
      if (text_sec != NULL)
3807
        {
3808
          internal_a.o_sntext = text_sec->target_index;
3809
          internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3810
        }
3811
      else
3812
        {
3813
          internal_a.o_sntext = 0;
3814
          internal_a.o_algntext = 0;
3815
        }
3816
      if (data_sec != NULL)
3817
        {
3818
          internal_a.o_sndata = data_sec->target_index;
3819
          internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3820
        }
3821
      else
3822
        {
3823
          internal_a.o_sndata = 0;
3824
          internal_a.o_algndata = 0;
3825
        }
3826
      loader_sec = bfd_get_section_by_name (abfd, ".loader");
3827
      if (loader_sec != NULL)
3828
        internal_a.o_snloader = loader_sec->target_index;
3829
      else
3830
        internal_a.o_snloader = 0;
3831
      if (bss_sec != NULL)
3832
        internal_a.o_snbss = bss_sec->target_index;
3833
      else
3834
        internal_a.o_snbss = 0;
3835
 
3836
      toc = xcoff_data (abfd)->toc;
3837
      internal_a.o_toc = toc;
3838
      internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3839
 
3840
      internal_a.o_modtype = xcoff_data (abfd)->modtype;
3841
      if (xcoff_data (abfd)->cputype != -1)
3842
        internal_a.o_cputype = xcoff_data (abfd)->cputype;
3843
      else
3844
        {
3845
          switch (bfd_get_arch (abfd))
3846
            {
3847
            case bfd_arch_rs6000:
3848
              internal_a.o_cputype = 4;
3849
              break;
3850
            case bfd_arch_powerpc:
3851
              if (bfd_get_mach (abfd) == 0)
3852
                internal_a.o_cputype = 3;
3853
              else
3854
                internal_a.o_cputype = 1;
3855
              break;
3856
            default:
3857
              abort ();
3858
            }
3859
        }
3860
      internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3861
      internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3862
    }
3863
#endif
3864
 
3865
  /* now write them */
3866
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3867
    return false;
3868
 
3869
  {
3870
    char * buff;
3871
    bfd_size_type amount;
3872
 
3873
    buff = bfd_malloc (bfd_coff_filhsz (abfd));
3874
    if (buff == NULL)
3875
      return false;
3876
 
3877
    coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
3878
    amount = bfd_write ((PTR) buff, 1, bfd_coff_filhsz (abfd), abfd);
3879
 
3880
    free (buff);
3881
 
3882
    if (amount != bfd_coff_filhsz (abfd))
3883
      return false;
3884
  }
3885
 
3886
  if (abfd->flags & EXEC_P)
3887
    {
3888
      /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3889
         include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3890
      char * buff;
3891
      bfd_size_type amount;
3892
 
3893
      buff = bfd_malloc (bfd_coff_aoutsz (abfd));
3894
      if (buff == NULL)
3895
        return false;
3896
 
3897
      coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
3898
      amount = bfd_write ((PTR) buff, 1, bfd_coff_aoutsz (abfd), abfd);
3899
 
3900
      free (buff);
3901
 
3902
      if (amount != bfd_coff_aoutsz (abfd))
3903
        return false;
3904
    }
3905
#ifdef RS6000COFF_C
3906
  else
3907
    {
3908
      AOUTHDR buff;
3909
      size_t size;
3910
 
3911
      /* XCOFF seems to always write at least a small a.out header.  */
3912
      coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
3913
      if (xcoff_data (abfd)->full_aouthdr)
3914
        size = bfd_coff_aoutsz (abfd);
3915
      else
3916
        size = SMALL_AOUTSZ;
3917
      if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
3918
        return false;
3919
    }
3920
#endif
3921
 
3922
  return true;
3923
}
3924
 
3925
static boolean
3926
coff_set_section_contents (abfd, section, location, offset, count)
3927
     bfd * abfd;
3928
     sec_ptr section;
3929
     PTR location;
3930
     file_ptr offset;
3931
     bfd_size_type count;
3932
{
3933
  if (abfd->output_has_begun == false)  /* set by bfd.c handler */
3934
    {
3935
      if (! coff_compute_section_file_positions (abfd))
3936
        return false;
3937
    }
3938
 
3939
#if defined(_LIB) && !defined(TARG_AUX)
3940
 
3941
   /* The physical address field of a .lib section is used to hold the
3942
      number of shared libraries in the section.  This code counts the
3943
      number of sections being written, and increments the lma field
3944
      with the number.
3945
 
3946
      I have found no documentation on the contents of this section.
3947
      Experimentation indicates that the section contains zero or more
3948
      records, each of which has the following structure:
3949
 
3950
      - a (four byte) word holding the length of this record, in words,
3951
      - a word that always seems to be set to "2",
3952
      - the path to a shared library, null-terminated and then padded
3953
        to a whole word boundary.
3954
 
3955
      bfd_assert calls have been added to alert if an attempt is made
3956
      to write a section which doesn't follow these assumptions.  The
3957
      code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3958
      <robertl@arnet.com> (Thanks!).
3959
 
3960
      Gvran Uddeborg <gvran@uddeborg.pp.se> */
3961
 
3962
    if (strcmp (section->name, _LIB) == 0)
3963
      {
3964
        bfd_byte *rec, *recend;
3965
 
3966
        rec = (bfd_byte *) location;
3967
        recend = rec + count;
3968
        while (rec < recend)
3969
          {
3970
            ++section->lma;
3971
            rec += bfd_get_32 (abfd, rec) * 4;
3972
          }
3973
 
3974
        BFD_ASSERT (rec == recend);
3975
      }
3976
 
3977
#endif
3978
 
3979
  /* Don't write out bss sections - one way to do this is to
3980
       see if the filepos has not been set. */
3981
  if (section->filepos == 0)
3982
    return true;
3983
 
3984
  if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
3985
    return false;
3986
 
3987
  if (count != 0)
3988
    {
3989
      return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3990
    }
3991
  return true;
3992
}
3993
#if 0
3994
static boolean
3995
coff_close_and_cleanup (abfd)
3996
     bfd *abfd;
3997
{
3998
  if (!bfd_read_p (abfd))
3999
    switch (abfd->format)
4000
      {
4001
      case bfd_archive:
4002
        if (!_bfd_write_archive_contents (abfd))
4003
          return false;
4004
        break;
4005
      case bfd_object:
4006
        if (!coff_write_object_contents (abfd))
4007
          return false;
4008
        break;
4009
      default:
4010
        bfd_set_error (bfd_error_invalid_operation);
4011
        return false;
4012
      }
4013
 
4014
  /* We depend on bfd_close to free all the memory on the objalloc.  */
4015
  return true;
4016
}
4017
 
4018
#endif
4019
 
4020
static PTR
4021
buy_and_read (abfd, where, seek_direction, size)
4022
     bfd *abfd;
4023
     file_ptr where;
4024
     int seek_direction;
4025
     size_t size;
4026
{
4027
  PTR area = (PTR) bfd_alloc (abfd, size);
4028
  if (!area)
4029
    return (NULL);
4030
  if (bfd_seek (abfd, where, seek_direction) != 0
4031
      || bfd_read (area, 1, size, abfd) != size)
4032
    return (NULL);
4033
  return (area);
4034
}                               /* buy_and_read() */
4035
 
4036
/*
4037
SUBSUBSECTION
4038
        Reading linenumbers
4039
 
4040
        Creating the linenumber table is done by reading in the entire
4041
        coff linenumber table, and creating another table for internal use.
4042
 
4043
        A coff linenumber table is structured so that each function
4044
        is marked as having a line number of 0. Each line within the
4045
        function is an offset from the first line in the function. The
4046
        base of the line number information for the table is stored in
4047
        the symbol associated with the function.
4048
 
4049
        Note: The PE format uses line number 0 for a flag indicating a
4050
        new source file.
4051
 
4052
        The information is copied from the external to the internal
4053
        table, and each symbol which marks a function is marked by
4054
        pointing its...
4055
 
4056
        How does this work ?
4057
 
4058
*/
4059
 
4060
static boolean
4061
coff_slurp_line_table (abfd, asect)
4062
     bfd *abfd;
4063
     asection *asect;
4064
{
4065
  LINENO *native_lineno;
4066
  alent *lineno_cache;
4067
 
4068
  BFD_ASSERT (asect->lineno == (alent *) NULL);
4069
 
4070
  native_lineno = (LINENO *) buy_and_read (abfd,
4071
                                           asect->line_filepos,
4072
                                           SEEK_SET,
4073
                                           (size_t) (bfd_coff_linesz (abfd) *
4074
                                                     asect->lineno_count));
4075
  lineno_cache =
4076
    (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
4077
  if (lineno_cache == NULL)
4078
    return false;
4079
  else
4080
    {
4081
      unsigned int counter = 0;
4082
      alent *cache_ptr = lineno_cache;
4083
      LINENO *src = native_lineno;
4084
 
4085
      while (counter < asect->lineno_count)
4086
        {
4087
          struct internal_lineno dst;
4088
          coff_swap_lineno_in (abfd, src, &dst);
4089
          cache_ptr->line_number = dst.l_lnno;
4090
 
4091
          if (cache_ptr->line_number == 0)
4092
            {
4093
              boolean warned;
4094
              long symndx;
4095
              coff_symbol_type *sym;
4096
 
4097
              warned = false;
4098
              symndx = dst.l_addr.l_symndx;
4099
              if (symndx < 0
4100
                  || (unsigned long) symndx >= obj_raw_syment_count (abfd))
4101
                {
4102
                  (*_bfd_error_handler)
4103
                    (_("%s: warning: illegal symbol index %ld in line numbers"),
4104
                     bfd_get_filename (abfd), dst.l_addr.l_symndx);
4105
                  symndx = 0;
4106
                  warned = true;
4107
                }
4108
              /* FIXME: We should not be casting between ints and
4109
                 pointers like this.  */
4110
              sym = ((coff_symbol_type *)
4111
                     ((symndx + obj_raw_syments (abfd))
4112
                      ->u.syment._n._n_n._n_zeroes));
4113
              cache_ptr->u.sym = (asymbol *) sym;
4114
              if (sym->lineno != NULL && ! warned)
4115
                {
4116
                  (*_bfd_error_handler)
4117
                    (_("%s: warning: duplicate line number information for `%s'"),
4118
                     bfd_get_filename (abfd),
4119
                     bfd_asymbol_name (&sym->symbol));
4120
                }
4121
              sym->lineno = cache_ptr;
4122
            }
4123
          else
4124
            {
4125
              cache_ptr->u.offset = dst.l_addr.l_paddr
4126
                - bfd_section_vma (abfd, asect);
4127
            }                   /* If no linenumber expect a symbol index */
4128
 
4129
          cache_ptr++;
4130
          src++;
4131
          counter++;
4132
        }
4133
      cache_ptr->line_number = 0;
4134
 
4135
    }
4136
  asect->lineno = lineno_cache;
4137
  /* FIXME, free native_lineno here, or use alloca or something. */
4138
  return true;
4139
}
4140
 
4141
/* Slurp in the symbol table, converting it to generic form.  Note
4142
   that if coff_relocate_section is defined, the linker will read
4143
   symbols via coff_link_add_symbols, rather than via this routine.  */
4144
 
4145
static boolean
4146
coff_slurp_symbol_table (abfd)
4147
     bfd * abfd;
4148
{
4149
  combined_entry_type *native_symbols;
4150
  coff_symbol_type *cached_area;
4151
  unsigned int *table_ptr;
4152
 
4153
  unsigned int number_of_symbols = 0;
4154
 
4155
  if (obj_symbols (abfd))
4156
    return true;
4157
 
4158
  /* Read in the symbol table */
4159
  if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4160
    {
4161
      return (false);
4162
    }                           /* on error */
4163
 
4164
  /* Allocate enough room for all the symbols in cached form */
4165
  cached_area = ((coff_symbol_type *)
4166
                 bfd_alloc (abfd,
4167
                            (obj_raw_syment_count (abfd)
4168
                             * sizeof (coff_symbol_type))));
4169
 
4170
  if (cached_area == NULL)
4171
    return false;
4172
  table_ptr = ((unsigned int *)
4173
               bfd_alloc (abfd,
4174
                          (obj_raw_syment_count (abfd)
4175
                           * sizeof (unsigned int))));
4176
 
4177
  if (table_ptr == NULL)
4178
    return false;
4179
  else
4180
    {
4181
      coff_symbol_type *dst = cached_area;
4182
      unsigned int last_native_index = obj_raw_syment_count (abfd);
4183
      unsigned int this_index = 0;
4184
      while (this_index < last_native_index)
4185
        {
4186
          combined_entry_type *src = native_symbols + this_index;
4187
          table_ptr[this_index] = number_of_symbols;
4188
          dst->symbol.the_bfd = abfd;
4189
 
4190
          dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4191
          /* We use the native name field to point to the cached field.  */
4192
          src->u.syment._n._n_n._n_zeroes = (long) dst;
4193
          dst->symbol.section = coff_section_from_bfd_index (abfd,
4194
                                                     src->u.syment.n_scnum);
4195
          dst->symbol.flags = 0;
4196
          dst->done_lineno = false;
4197
 
4198
          switch (src->u.syment.n_sclass)
4199
            {
4200
#ifdef I960
4201
            case C_LEAFEXT:
4202
#if 0
4203
              dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4204
              dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4205
              dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4206
#endif
4207
              /* Fall through to next case */
4208
 
4209
#endif
4210
 
4211
            case C_EXT:
4212
            case C_WEAKEXT:
4213
#if defined ARM
4214
            case C_THUMBEXT:
4215
            case C_THUMBEXTFUNC:
4216
#endif
4217
#ifdef RS6000COFF_C
4218
            case C_HIDEXT:
4219
#endif
4220
#ifdef C_SYSTEM
4221
            case C_SYSTEM:      /* System Wide variable */
4222
#endif
4223
#ifdef COFF_WITH_PE
4224
            /* In PE, 0x68 (104) denotes a section symbol */
4225
            case C_SECTION:
4226
            /* In PE, 0x69 (105) denotes a weak external symbol.  */
4227
            case C_NT_WEAK:
4228
#endif
4229
              switch (coff_classify_symbol (abfd, &src->u.syment))
4230
                {
4231
                case COFF_SYMBOL_GLOBAL:
4232
                  dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4233
#if defined COFF_WITH_PE
4234
                  /* PE sets the symbol to a value relative to the
4235
                     start of the section.  */
4236
                  dst->symbol.value = src->u.syment.n_value;
4237
#else
4238
                  dst->symbol.value = (src->u.syment.n_value
4239
                                       - dst->symbol.section->vma);
4240
#endif
4241
                  if (ISFCN ((src->u.syment.n_type)))
4242
                    {
4243
                      /* A function ext does not go at the end of a
4244
                         file.  */
4245
                      dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4246
                    }
4247
                  break;
4248
 
4249
                case COFF_SYMBOL_COMMON:
4250
                  dst->symbol.section = bfd_com_section_ptr;
4251
                  dst->symbol.value = src->u.syment.n_value;
4252
                  break;
4253
 
4254
                case COFF_SYMBOL_UNDEFINED:
4255
                  dst->symbol.section = bfd_und_section_ptr;
4256
                  dst->symbol.value = 0;
4257
                  break;
4258
 
4259
                case COFF_SYMBOL_PE_SECTION:
4260
                  dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4261
                  dst->symbol.value = 0;
4262
                  break;
4263
 
4264
                case COFF_SYMBOL_LOCAL:
4265
                  dst->symbol.flags = BSF_LOCAL;
4266
#if defined COFF_WITH_PE
4267
                  /* PE sets the symbol to a value relative to the
4268
                     start of the section.  */
4269
                  dst->symbol.value = src->u.syment.n_value;
4270
#else
4271
                  dst->symbol.value = (src->u.syment.n_value
4272
                                       - dst->symbol.section->vma);
4273
#endif
4274
                  if (ISFCN ((src->u.syment.n_type)))
4275
                    dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4276
                  break;
4277
                }
4278
 
4279
#ifdef RS6000COFF_C
4280
              /* A symbol with a csect entry should not go at the end.  */
4281
              if (src->u.syment.n_numaux > 0)
4282
                dst->symbol.flags |= BSF_NOT_AT_END;
4283
#endif
4284
 
4285
#ifdef COFF_WITH_PE
4286
              if (src->u.syment.n_sclass == C_NT_WEAK)
4287
                dst->symbol.flags = BSF_WEAK;
4288
              if (src->u.syment.n_sclass == C_SECTION
4289
                  && src->u.syment.n_scnum > 0)
4290
                {
4291
                  dst->symbol.flags = BSF_LOCAL;
4292
                }
4293
#endif
4294
 
4295
              if (src->u.syment.n_sclass == C_WEAKEXT)
4296
                dst->symbol.flags = BSF_WEAK;
4297
 
4298
              break;
4299
 
4300
            case C_STAT:        /* static                        */
4301
#ifdef I960
4302
            case C_LEAFSTAT:    /* static leaf procedure        */
4303
#endif
4304
#if defined ARM 
4305
            case C_THUMBSTAT:   /* Thumb static                  */
4306
            case C_THUMBLABEL:  /* Thumb label                   */
4307
            case C_THUMBSTATFUNC:/* Thumb static function        */
4308
#endif
4309
            case C_LABEL:       /* label                         */
4310
              if (src->u.syment.n_scnum == N_DEBUG)
4311
                dst->symbol.flags = BSF_DEBUGGING;
4312
              else
4313
                dst->symbol.flags = BSF_LOCAL;
4314
 
4315
              /* Base the value as an index from the base of the
4316
                 section, if there is one.  */
4317
              if (dst->symbol.section)
4318
                {
4319
#if defined COFF_WITH_PE
4320
                  /* PE sets the symbol to a value relative to the
4321
                     start of the section.  */
4322
                  dst->symbol.value = src->u.syment.n_value;
4323
#else
4324
                  dst->symbol.value = (src->u.syment.n_value
4325
                                       - dst->symbol.section->vma);
4326
#endif
4327
                }
4328
              else
4329
                dst->symbol.value = src->u.syment.n_value;
4330
              break;
4331
 
4332
            case C_MOS: /* member of structure   */
4333
            case C_EOS: /* end of structure              */
4334
#ifdef NOTDEF                   /* C_AUTOARG has the same value */
4335
#ifdef C_GLBLREG
4336
            case C_GLBLREG:     /* A29k-specific storage class */
4337
#endif
4338
#endif
4339
            case C_REGPARM:     /* register parameter            */
4340
            case C_REG: /* register variable             */
4341
              /* C_AUTOARG conflictes with TI COFF C_UEXT */
4342
#if !defined (TIC80COFF) && !defined (TICOFF)
4343
#ifdef C_AUTOARG
4344
            case C_AUTOARG:     /* 960-specific storage class */
4345
#endif
4346
#endif
4347
            case C_TPDEF:       /* type definition               */
4348
            case C_ARG:
4349
            case C_AUTO:        /* automatic variable */
4350
            case C_FIELD:       /* bit field */
4351
            case C_ENTAG:       /* enumeration tag               */
4352
            case C_MOE: /* member of enumeration         */
4353
            case C_MOU: /* member of union               */
4354
            case C_UNTAG:       /* union tag                     */
4355
              dst->symbol.flags = BSF_DEBUGGING;
4356
              dst->symbol.value = (src->u.syment.n_value);
4357
              break;
4358
 
4359
            case C_FILE:        /* file name                     */
4360
            case C_STRTAG:      /* structure tag                 */
4361
#ifdef RS6000COFF_C
4362
            case C_GSYM:
4363
            case C_LSYM:
4364
            case C_PSYM:
4365
            case C_RSYM:
4366
            case C_RPSYM:
4367
            case C_STSYM:
4368
            case C_BCOMM:
4369
            case C_ECOMM:
4370
            case C_DECL:
4371
            case C_ENTRY:
4372
            case C_FUN:
4373
            case C_ESTAT:
4374
#endif
4375
              dst->symbol.flags = BSF_DEBUGGING;
4376
              dst->symbol.value = (src->u.syment.n_value);
4377
              break;
4378
 
4379
#ifdef RS6000COFF_C
4380
            case C_BINCL:       /* beginning of include file     */
4381
            case C_EINCL:       /* ending of include file        */
4382
              /* The value is actually a pointer into the line numbers
4383
                 of the file.  We locate the line number entry, and
4384
                 set the section to the section which contains it, and
4385
                 the value to the index in that section.  */
4386
              {
4387
                asection *sec;
4388
 
4389
                dst->symbol.flags = BSF_DEBUGGING;
4390
                for (sec = abfd->sections; sec != NULL; sec = sec->next)
4391
                  if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4392
                      && ((file_ptr) (sec->line_filepos
4393
                                      + sec->lineno_count * bfd_coff_linesz (abfd))
4394
                          > (file_ptr) src->u.syment.n_value))
4395
                    break;
4396
                if (sec == NULL)
4397
                  dst->symbol.value = 0;
4398
                else
4399
                  {
4400
                    dst->symbol.section = sec;
4401
                    dst->symbol.value = ((src->u.syment.n_value
4402
                                          - sec->line_filepos)
4403
                                         / bfd_coff_linesz (abfd));
4404
                    src->fix_line = 1;
4405
                  }
4406
              }
4407
              break;
4408
 
4409
            case C_BSTAT:
4410
              dst->symbol.flags = BSF_DEBUGGING;
4411
 
4412
              /* The value is actually a symbol index.  Save a pointer
4413
                 to the symbol instead of the index.  FIXME: This
4414
                 should use a union.  */
4415
              src->u.syment.n_value =
4416
                (long) (native_symbols + src->u.syment.n_value);
4417
              dst->symbol.value = src->u.syment.n_value;
4418
              src->fix_value = 1;
4419
              break;
4420
#endif
4421
 
4422
            case C_BLOCK:       /* ".bb" or ".eb"                */
4423
            case C_FCN:         /* ".bf" or ".ef" (or PE ".lf")  */
4424
            case C_EFCN:        /* physical end of function      */
4425
#if defined COFF_WITH_PE
4426
              /* PE sets the symbol to a value relative to the start
4427
                 of the section.  */
4428
              dst->symbol.value = src->u.syment.n_value;
4429
              if (strcmp (dst->symbol.name, ".bf") != 0)
4430
                {
4431
                  /* PE uses funny values for .ef and .lf; don't
4432
                     relocate them.  */
4433
                  dst->symbol.flags = BSF_DEBUGGING;
4434
                }
4435
              else
4436
                dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4437
#else
4438
              /* Base the value as an index from the base of the
4439
                 section.  */
4440
              dst->symbol.flags = BSF_LOCAL;
4441
              dst->symbol.value = (src->u.syment.n_value
4442
                                   - dst->symbol.section->vma);
4443
#endif
4444
              break;
4445
 
4446
            case C_STATLAB:     /* Static load time label */
4447
              dst->symbol.value = src->u.syment.n_value;
4448
              dst->symbol.flags = BSF_GLOBAL;
4449
              break;
4450
 
4451
            case C_NULL:
4452
              /* PE DLLs sometimes have zeroed out symbols for some
4453
                 reason.  Just ignore them without a warning.  */
4454
              if (src->u.syment.n_type == 0
4455
                  && src->u.syment.n_value == 0
4456
                  && src->u.syment.n_scnum == 0)
4457
                break;
4458
              /* Fall through.  */
4459
            case C_EXTDEF:      /* external definition           */
4460
            case C_ULABEL:      /* undefined label               */
4461
            case C_USTATIC:     /* undefined static              */
4462
#ifndef COFF_WITH_PE
4463
            /* C_LINE in regular coff is 0x68.  NT has taken over this storage
4464
               class to represent a section symbol */
4465
            case C_LINE:        /* line # reformatted as symbol table entry */
4466
              /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
4467
            case C_ALIAS:       /* duplicate tag                 */
4468
#endif
4469
              /* New storage classes for TI COFF */
4470
#if defined(TIC80COFF) || defined(TICOFF)
4471
            case C_UEXT:        /* Tentative external definition */
4472
#endif
4473
            case C_EXTLAB:      /* External load time label */
4474
            case C_HIDDEN:      /* ext symbol in dmert public lib */
4475
            default:
4476
              (*_bfd_error_handler)
4477
                (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4478
                 bfd_get_filename (abfd), src->u.syment.n_sclass,
4479
                 dst->symbol.section->name, dst->symbol.name);
4480
              dst->symbol.flags = BSF_DEBUGGING;
4481
              dst->symbol.value = (src->u.syment.n_value);
4482
              break;
4483
            }
4484
 
4485
/*      BFD_ASSERT(dst->symbol.flags != 0);*/
4486
 
4487
          dst->native = src;
4488
 
4489
          dst->symbol.udata.i = 0;
4490
          dst->lineno = (alent *) NULL;
4491
          this_index += (src->u.syment.n_numaux) + 1;
4492
          dst++;
4493
          number_of_symbols++;
4494
        }                       /* walk the native symtab */
4495
    }                           /* bfdize the native symtab */
4496
 
4497
  obj_symbols (abfd) = cached_area;
4498
  obj_raw_syments (abfd) = native_symbols;
4499
 
4500
  bfd_get_symcount (abfd) = number_of_symbols;
4501
  obj_convert (abfd) = table_ptr;
4502
  /* Slurp the line tables for each section too */
4503
  {
4504
    asection *p;
4505
    p = abfd->sections;
4506
    while (p)
4507
      {
4508
        coff_slurp_line_table (abfd, p);
4509
        p = p->next;
4510
      }
4511
  }
4512
  return true;
4513
}                               /* coff_slurp_symbol_table() */
4514
 
4515
/* Classify a COFF symbol.  A couple of targets have globally visible
4516
   symbols which are not class C_EXT, and this handles those.  It also
4517
   recognizes some special PE cases.  */
4518
 
4519
static enum coff_symbol_classification
4520
coff_classify_symbol (abfd, syment)
4521
     bfd *abfd;
4522
     struct internal_syment *syment;
4523
{
4524
  /* FIXME: This partially duplicates the switch in
4525
     coff_slurp_symbol_table.  */
4526
  switch (syment->n_sclass)
4527
    {
4528
    case C_EXT:
4529
    case C_WEAKEXT:
4530
#ifdef I960
4531
    case C_LEAFEXT:
4532
#endif
4533
#ifdef ARM
4534
    case C_THUMBEXT:
4535
    case C_THUMBEXTFUNC:
4536
#endif
4537
#ifdef C_SYSTEM
4538
    case C_SYSTEM:
4539
#endif
4540
#ifdef COFF_WITH_PE
4541
    case C_NT_WEAK:
4542
#endif
4543
      if (syment->n_scnum == 0)
4544
        {
4545
          if (syment->n_value == 0)
4546
            return COFF_SYMBOL_UNDEFINED;
4547
          else
4548
            return COFF_SYMBOL_COMMON;
4549
        }
4550
      return COFF_SYMBOL_GLOBAL;
4551
 
4552
    default:
4553
      break;
4554
    }
4555
 
4556
#ifdef COFF_WITH_PE
4557
  if (syment->n_sclass == C_STAT)
4558
    {
4559
      if (syment->n_scnum == 0)
4560
        {
4561
          /* The Microsoft compiler sometimes generates these if a
4562
             small static function is inlined every time it is used.
4563
             The function is discarded, but the symbol table entry
4564
             remains.  */
4565
          return COFF_SYMBOL_LOCAL;
4566
        }
4567
 
4568
#ifdef STRICT_PE_FORMAT
4569
      /* This is correct for Microsoft generated objects, but it
4570
         breaks gas generated objects.  */
4571
 
4572
      if (syment->n_value == 0)
4573
        {
4574
          asection *sec;
4575
          char buf[SYMNMLEN + 1];
4576
 
4577
          sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4578
          if (sec != NULL
4579
              && (strcmp (bfd_get_section_name (abfd, sec),
4580
                          _bfd_coff_internal_syment_name (abfd, syment, buf))
4581
                  == 0))
4582
            return COFF_SYMBOL_PE_SECTION;
4583
        }
4584
#endif
4585
 
4586
      return COFF_SYMBOL_LOCAL;
4587
    }
4588
 
4589
  if (syment->n_sclass == C_SECTION)
4590
    {
4591
      /* In some cases in a DLL generated by the Microsoft linker, the
4592
         n_value field will contain garbage.  FIXME: This should
4593
         probably be handled by the swapping function instead.  */
4594
      syment->n_value = 0;
4595
      if (syment->n_scnum == 0)
4596
        return COFF_SYMBOL_UNDEFINED;
4597
      return COFF_SYMBOL_PE_SECTION;
4598
    }
4599
#endif /* COFF_WITH_PE */
4600
 
4601
  /* If it is not a global symbol, we presume it is a local symbol.  */
4602
 
4603
  if (syment->n_scnum == 0)
4604
    {
4605
      char buf[SYMNMLEN + 1];
4606
 
4607
      (*_bfd_error_handler)
4608
        (_("warning: %s: local symbol `%s' has no section"),
4609
         bfd_get_filename (abfd),
4610
         _bfd_coff_internal_syment_name (abfd, syment, buf));
4611
    }
4612
 
4613
  return COFF_SYMBOL_LOCAL;
4614
}
4615
 
4616
/*
4617
SUBSUBSECTION
4618
        Reading relocations
4619
 
4620
        Coff relocations are easily transformed into the internal BFD form
4621
        (@code{arelent}).
4622
 
4623
        Reading a coff relocation table is done in the following stages:
4624
 
4625
        o Read the entire coff relocation table into memory.
4626
 
4627
        o Process each relocation in turn; first swap it from the
4628
        external to the internal form.
4629
 
4630
        o Turn the symbol referenced in the relocation's symbol index
4631
        into a pointer into the canonical symbol table.
4632
        This table is the same as the one returned by a call to
4633
        @code{bfd_canonicalize_symtab}. The back end will call that
4634
        routine and save the result if a canonicalization hasn't been done.
4635
 
4636
        o The reloc index is turned into a pointer to a howto
4637
        structure, in a back end specific way. For instance, the 386
4638
        and 960 use the @code{r_type} to directly produce an index
4639
        into a howto table vector; the 88k subtracts a number from the
4640
        @code{r_type} field and creates an addend field.
4641
 
4642
 
4643
*/
4644
 
4645
#ifndef CALC_ADDEND
4646
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
4647
  {                                                             \
4648
    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
4649
    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
4650
      coffsym = (obj_symbols (abfd)                             \
4651
                 + (cache_ptr->sym_ptr_ptr - symbols));         \
4652
    else if (ptr)                                               \
4653
      coffsym = coff_symbol_from (abfd, ptr);                   \
4654
    if (coffsym != (coff_symbol_type *) NULL                    \
4655
        && coffsym->native->u.syment.n_scnum == 0)              \
4656
      cache_ptr->addend = 0;                                    \
4657
    else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
4658
             && ptr->section != (asection *) NULL)              \
4659
      cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
4660
    else                                                        \
4661
      cache_ptr->addend = 0;                                    \
4662
  }
4663
#endif
4664
 
4665
static boolean
4666
coff_slurp_reloc_table (abfd, asect, symbols)
4667
     bfd * abfd;
4668
     sec_ptr asect;
4669
     asymbol ** symbols;
4670
{
4671
  RELOC *native_relocs;
4672
  arelent *reloc_cache;
4673
  arelent *cache_ptr;
4674
 
4675
  unsigned int idx;
4676
 
4677
  if (asect->relocation)
4678
    return true;
4679
  if (asect->reloc_count == 0)
4680
    return true;
4681
  if (asect->flags & SEC_CONSTRUCTOR)
4682
    return true;
4683
  if (!coff_slurp_symbol_table (abfd))
4684
    return false;
4685
  native_relocs =
4686
    (RELOC *) buy_and_read (abfd,
4687
                            asect->rel_filepos,
4688
                            SEEK_SET,
4689
                            (size_t) (bfd_coff_relsz (abfd) *
4690
                                      asect->reloc_count));
4691
  reloc_cache = (arelent *)
4692
    bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
4693
 
4694
  if (reloc_cache == NULL)
4695
    return false;
4696
 
4697
 
4698
  for (idx = 0; idx < asect->reloc_count; idx++)
4699
    {
4700
      struct internal_reloc dst;
4701
      struct external_reloc *src;
4702
#ifndef RELOC_PROCESSING
4703
      asymbol *ptr;
4704
#endif
4705
 
4706
      cache_ptr = reloc_cache + idx;
4707
      src = native_relocs + idx;
4708
 
4709
      coff_swap_reloc_in (abfd, src, &dst);
4710
 
4711
#ifdef RELOC_PROCESSING
4712
      RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4713
#else
4714
      cache_ptr->address = dst.r_vaddr;
4715
 
4716
      if (dst.r_symndx != -1)
4717
        {
4718
          if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4719
            {
4720
              (*_bfd_error_handler)
4721
                (_("%s: warning: illegal symbol index %ld in relocs"),
4722
                 bfd_get_filename (abfd), dst.r_symndx);
4723
              cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4724
              ptr = NULL;
4725
            }
4726
          else
4727
            {
4728
              cache_ptr->sym_ptr_ptr = (symbols
4729
                                        + obj_convert (abfd)[dst.r_symndx]);
4730
              ptr = *(cache_ptr->sym_ptr_ptr);
4731
            }
4732
        }
4733
      else
4734
        {
4735
          cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4736
          ptr = NULL;
4737
        }
4738
 
4739
      /* The symbols definitions that we have read in have been
4740
         relocated as if their sections started at 0. But the offsets
4741
         refering to the symbols in the raw data have not been
4742
         modified, so we have to have a negative addend to compensate.
4743
 
4744
         Note that symbols which used to be common must be left alone */
4745
 
4746
      /* Calculate any reloc addend by looking at the symbol */
4747
      CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4748
 
4749
      cache_ptr->address -= asect->vma;
4750
/* !!     cache_ptr->section = (asection *) NULL;*/
4751
 
4752
      /* Fill in the cache_ptr->howto field from dst.r_type */
4753
      RTYPE2HOWTO (cache_ptr, &dst);
4754
#endif  /* RELOC_PROCESSING */
4755
 
4756
      if (cache_ptr->howto == NULL)
4757
        {
4758
          (*_bfd_error_handler)
4759
            (_("%s: illegal relocation type %d at address 0x%lx"),
4760
             bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4761
          bfd_set_error (bfd_error_bad_value);
4762
          return false;
4763
        }
4764
    }
4765
 
4766
  asect->relocation = reloc_cache;
4767
  return true;
4768
}
4769
 
4770
#ifndef coff_rtype_to_howto
4771
#ifdef RTYPE2HOWTO
4772
 
4773
/* Get the howto structure for a reloc.  This is only used if the file
4774
   including this one defines coff_relocate_section to be
4775
   _bfd_coff_generic_relocate_section, so it is OK if it does not
4776
   always work.  It is the responsibility of the including file to
4777
   make sure it is reasonable if it is needed.  */
4778
 
4779
static reloc_howto_type *coff_rtype_to_howto
4780
  PARAMS ((bfd *, asection *, struct internal_reloc *,
4781
           struct coff_link_hash_entry *, struct internal_syment *,
4782
           bfd_vma *));
4783
 
4784
/*ARGSUSED*/
4785
static reloc_howto_type *
4786
coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
4787
     bfd *abfd ATTRIBUTE_UNUSED;
4788
     asection *sec ATTRIBUTE_UNUSED;
4789
     struct internal_reloc *rel;
4790
     struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4791
     struct internal_syment *sym ATTRIBUTE_UNUSED;
4792
     bfd_vma *addendp ATTRIBUTE_UNUSED;
4793
{
4794
  arelent genrel;
4795
 
4796
  RTYPE2HOWTO (&genrel, rel);
4797
  return genrel.howto;
4798
}
4799
 
4800
#else /* ! defined (RTYPE2HOWTO) */
4801
 
4802
#define coff_rtype_to_howto NULL
4803
 
4804
#endif /* ! defined (RTYPE2HOWTO) */
4805
#endif /* ! defined (coff_rtype_to_howto) */
4806
 
4807
/* This is stupid.  This function should be a boolean predicate.  */
4808
static long
4809
coff_canonicalize_reloc (abfd, section, relptr, symbols)
4810
     bfd * abfd;
4811
     sec_ptr section;
4812
     arelent ** relptr;
4813
     asymbol ** symbols;
4814
{
4815
  arelent *tblptr = section->relocation;
4816
  unsigned int count = 0;
4817
 
4818
 
4819
  if (section->flags & SEC_CONSTRUCTOR)
4820
    {
4821
      /* this section has relocs made up by us, they are not in the
4822
       file, so take them out of their chain and place them into
4823
       the data area provided */
4824
      arelent_chain *chain = section->constructor_chain;
4825
      for (count = 0; count < section->reloc_count; count++)
4826
        {
4827
          *relptr++ = &chain->relent;
4828
          chain = chain->next;
4829
        }
4830
 
4831
    }
4832
  else
4833
    {
4834
      if (! coff_slurp_reloc_table (abfd, section, symbols))
4835
        return -1;
4836
 
4837
      tblptr = section->relocation;
4838
 
4839
      for (; count++ < section->reloc_count;)
4840
        *relptr++ = tblptr++;
4841
 
4842
 
4843
    }
4844
  *relptr = 0;
4845
  return section->reloc_count;
4846
}
4847
 
4848
#ifdef GNU960
4849
file_ptr
4850
coff_sym_filepos (abfd)
4851
     bfd *abfd;
4852
{
4853
  return obj_sym_filepos (abfd);
4854
}
4855
#endif
4856
 
4857
#ifndef coff_reloc16_estimate
4858
#define coff_reloc16_estimate dummy_reloc16_estimate
4859
 
4860
static int dummy_reloc16_estimate
4861
  PARAMS ((bfd *, asection *, arelent *, unsigned int,
4862
           struct bfd_link_info *));
4863
 
4864
static int
4865
dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
4866
     bfd *abfd ATTRIBUTE_UNUSED;
4867
     asection *input_section ATTRIBUTE_UNUSED;
4868
     arelent *reloc ATTRIBUTE_UNUSED;
4869
     unsigned int shrink ATTRIBUTE_UNUSED;
4870
     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4871
{
4872
  abort ();
4873
  return 0;
4874
}
4875
 
4876
#endif
4877
 
4878
#ifndef coff_reloc16_extra_cases
4879
 
4880
#define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4881
 
4882
/* This works even if abort is not declared in any header file.  */
4883
 
4884
static void dummy_reloc16_extra_cases
4885
  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
4886
           bfd_byte *, unsigned int *, unsigned int *));
4887
 
4888
static void
4889
dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4890
                           dst_ptr)
4891
     bfd *abfd ATTRIBUTE_UNUSED;
4892
     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4893
     struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
4894
     arelent *reloc ATTRIBUTE_UNUSED;
4895
     bfd_byte *data ATTRIBUTE_UNUSED;
4896
     unsigned int *src_ptr ATTRIBUTE_UNUSED;
4897
     unsigned int *dst_ptr ATTRIBUTE_UNUSED;
4898
{
4899
  abort ();
4900
}
4901
#endif
4902
 
4903
/* If coff_relocate_section is defined, we can use the optimized COFF
4904
   backend linker.  Otherwise we must continue to use the old linker.  */
4905
#ifdef coff_relocate_section
4906
#ifndef coff_bfd_link_hash_table_create
4907
#define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4908
#endif
4909
#ifndef coff_bfd_link_add_symbols
4910
#define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4911
#endif
4912
#ifndef coff_bfd_final_link
4913
#define coff_bfd_final_link _bfd_coff_final_link
4914
#endif
4915
#else /* ! defined (coff_relocate_section) */
4916
#define coff_relocate_section NULL
4917
#ifndef coff_bfd_link_hash_table_create
4918
#define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4919
#endif
4920
#ifndef coff_bfd_link_add_symbols
4921
#define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4922
#endif
4923
#define coff_bfd_final_link _bfd_generic_final_link
4924
#endif /* ! defined (coff_relocate_section) */
4925
 
4926
#define coff_bfd_link_split_section  _bfd_generic_link_split_section
4927
 
4928
#ifndef coff_start_final_link
4929
#define coff_start_final_link NULL
4930
#endif
4931
 
4932
#ifndef coff_adjust_symndx
4933
#define coff_adjust_symndx NULL
4934
#endif
4935
 
4936
#ifndef coff_link_add_one_symbol
4937
#define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4938
#endif
4939
 
4940
#ifndef coff_link_output_has_begun
4941
 
4942
static boolean coff_link_output_has_begun
4943
  PARAMS ((bfd *, struct coff_final_link_info *));
4944
 
4945
static boolean
4946
coff_link_output_has_begun (abfd, info)
4947
     bfd * abfd;
4948
     struct coff_final_link_info * info ATTRIBUTE_UNUSED;
4949
{
4950
  return abfd->output_has_begun;
4951
}
4952
#endif
4953
 
4954
#ifndef coff_final_link_postscript
4955
 
4956
static boolean coff_final_link_postscript
4957
  PARAMS ((bfd *, struct coff_final_link_info *));
4958
 
4959
static boolean
4960
coff_final_link_postscript (abfd, pfinfo)
4961
     bfd * abfd ATTRIBUTE_UNUSED;
4962
     struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
4963
{
4964
  return true;
4965
}
4966
#endif
4967
 
4968
#ifndef coff_SWAP_aux_in
4969
#define coff_SWAP_aux_in coff_swap_aux_in
4970
#endif
4971
#ifndef coff_SWAP_sym_in
4972
#define coff_SWAP_sym_in coff_swap_sym_in
4973
#endif
4974
#ifndef coff_SWAP_lineno_in
4975
#define coff_SWAP_lineno_in coff_swap_lineno_in
4976
#endif
4977
#ifndef coff_SWAP_aux_out
4978
#define coff_SWAP_aux_out coff_swap_aux_out
4979
#endif
4980
#ifndef coff_SWAP_sym_out
4981
#define coff_SWAP_sym_out coff_swap_sym_out
4982
#endif
4983
#ifndef coff_SWAP_lineno_out
4984
#define coff_SWAP_lineno_out coff_swap_lineno_out
4985
#endif
4986
#ifndef coff_SWAP_reloc_out
4987
#define coff_SWAP_reloc_out coff_swap_reloc_out
4988
#endif
4989
#ifndef coff_SWAP_filehdr_out
4990
#define coff_SWAP_filehdr_out coff_swap_filehdr_out
4991
#endif
4992
#ifndef coff_SWAP_aouthdr_out
4993
#define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4994
#endif
4995
#ifndef coff_SWAP_scnhdr_out
4996
#define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4997
#endif
4998
#ifndef coff_SWAP_reloc_in
4999
#define coff_SWAP_reloc_in coff_swap_reloc_in
5000
#endif
5001
#ifndef coff_SWAP_filehdr_in
5002
#define coff_SWAP_filehdr_in coff_swap_filehdr_in
5003
#endif
5004
#ifndef coff_SWAP_aouthdr_in
5005
#define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5006
#endif
5007
#ifndef coff_SWAP_scnhdr_in
5008
#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5009
#endif
5010
 
5011
static const bfd_coff_backend_data bfd_coff_std_swap_table =
5012
{
5013
  coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5014
  coff_SWAP_aux_out, coff_SWAP_sym_out,
5015
  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5016
  coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5017
  coff_SWAP_scnhdr_out,
5018
  FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5019
#ifdef COFF_LONG_FILENAMES
5020
  true,
5021
#else
5022
  false,
5023
#endif
5024
#ifdef COFF_LONG_SECTION_NAMES
5025
  true,
5026
#else
5027
  false,
5028
#endif
5029
  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5030
  coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5031
  coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5032
  coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5033
  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5034
  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5035
  coff_classify_symbol, coff_compute_section_file_positions,
5036
  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5037
  coff_adjust_symndx, coff_link_add_one_symbol,
5038
  coff_link_output_has_begun, coff_final_link_postscript
5039
};
5040
 
5041
#ifndef coff_close_and_cleanup
5042
#define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
5043
#endif
5044
 
5045
#ifndef coff_bfd_free_cached_info
5046
#define coff_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
5047
#endif
5048
 
5049
#ifndef coff_get_section_contents
5050
#define coff_get_section_contents           _bfd_generic_get_section_contents
5051
#endif
5052
 
5053
#ifndef coff_bfd_copy_private_symbol_data
5054
#define coff_bfd_copy_private_symbol_data   _bfd_generic_bfd_copy_private_symbol_data
5055
#endif
5056
 
5057
#ifndef coff_bfd_copy_private_section_data
5058
#define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
5059
#endif
5060
 
5061
#ifndef coff_bfd_copy_private_bfd_data 
5062
#define coff_bfd_copy_private_bfd_data      _bfd_generic_bfd_copy_private_bfd_data
5063
#endif
5064
 
5065
#ifndef coff_bfd_merge_private_bfd_data
5066
#define coff_bfd_merge_private_bfd_data     _bfd_generic_bfd_merge_private_bfd_data
5067
#endif
5068
 
5069
#ifndef coff_bfd_set_private_flags
5070
#define coff_bfd_set_private_flags          _bfd_generic_bfd_set_private_flags
5071
#endif
5072
 
5073
#ifndef coff_bfd_print_private_bfd_data 
5074
#define coff_bfd_print_private_bfd_data     _bfd_generic_bfd_print_private_bfd_data
5075
#endif
5076
 
5077
#ifndef coff_bfd_is_local_label_name
5078
#define coff_bfd_is_local_label_name        _bfd_coff_is_local_label_name
5079
#endif
5080
 
5081
#ifndef coff_read_minisymbols
5082
#define coff_read_minisymbols               _bfd_generic_read_minisymbols
5083
#endif
5084
 
5085
#ifndef coff_minisymbol_to_symbol
5086
#define coff_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
5087
#endif
5088
 
5089
/* The reloc lookup routine must be supplied by each individual COFF
5090
   backend.  */
5091
#ifndef coff_bfd_reloc_type_lookup
5092
#define coff_bfd_reloc_type_lookup          _bfd_norelocs_bfd_reloc_type_lookup
5093
#endif
5094
 
5095
#ifndef coff_bfd_get_relocated_section_contents
5096
#define coff_bfd_get_relocated_section_contents \
5097
  bfd_generic_get_relocated_section_contents
5098
#endif
5099
 
5100
#ifndef coff_bfd_relax_section
5101
#define coff_bfd_relax_section              bfd_generic_relax_section
5102
#endif
5103
 
5104
#ifndef coff_bfd_gc_sections
5105
#define coff_bfd_gc_sections                bfd_generic_gc_sections
5106
#endif
5107
 
5108
#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5109
const bfd_target VAR =                                                  \
5110
{                                                                       \
5111
  NAME ,                                                                \
5112
  bfd_target_coff_flavour,                                              \
5113
  BFD_ENDIAN_BIG,               /* data byte order is big */            \
5114
  BFD_ENDIAN_BIG,               /* header byte order is big */          \
5115
  /* object flags */                                                    \
5116
  (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5117
   HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5118
  /* section flags */                                                   \
5119
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5120
  UNDER,                        /* leading symbol underscore */         \
5121
  '/',                          /* ar_pad_char */                       \
5122
  15,                           /* ar_max_namelen */                    \
5123
                                                                        \
5124
  /* Data conversion functions.  */                                     \
5125
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5126
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5127
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5128
                                                                        \
5129
  /* Header conversion functions.  */                                   \
5130
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5131
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5132
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5133
                                                                        \
5134
        /* bfd_check_format */                                          \
5135
  { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5136
    _bfd_dummy_target },                                                \
5137
        /* bfd_set_format */                                            \
5138
  { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5139
        /* bfd_write_contents */                                        \
5140
  { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5141
    bfd_false },                                                        \
5142
                                                                        \
5143
  BFD_JUMP_TABLE_GENERIC (coff),                                        \
5144
  BFD_JUMP_TABLE_COPY (coff),                                           \
5145
  BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5146
  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5147
  BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5148
  BFD_JUMP_TABLE_RELOCS (coff),                                         \
5149
  BFD_JUMP_TABLE_WRITE (coff),                                          \
5150
  BFD_JUMP_TABLE_LINK (coff),                                           \
5151
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5152
                                                                        \
5153
  ALTERNATIVE,                                                          \
5154
                                                                        \
5155
  COFF_SWAP_TABLE                                                       \
5156
};
5157
 
5158
#define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE)      \
5159
const bfd_target VAR =                                                  \
5160
{                                                                       \
5161
  NAME ,                                                                \
5162
  bfd_target_coff_flavour,                                              \
5163
  BFD_ENDIAN_LITTLE,            /* data byte order is little */         \
5164
  BFD_ENDIAN_LITTLE,            /* header byte order is little */       \
5165
        /* object flags */                                              \
5166
  (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5167
   HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5168
        /* section flags */                                             \
5169
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5170
  UNDER,                        /* leading symbol underscore */         \
5171
  '/',                          /* ar_pad_char */                       \
5172
  15,                           /* ar_max_namelen */                    \
5173
                                                                        \
5174
  /* Data conversion functions.  */                                     \
5175
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5176
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5177
  bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5178
  /* Header conversion functions.  */                                   \
5179
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
5180
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
5181
  bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
5182
        /* bfd_check_format */                                          \
5183
  { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5184
    _bfd_dummy_target },                                                \
5185
       /* bfd_set_format */                                             \
5186
  { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5187
        /* bfd_write_contents */                                        \
5188
  { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5189
    bfd_false },                                                        \
5190
                                                                        \
5191
  BFD_JUMP_TABLE_GENERIC (coff),                                        \
5192
  BFD_JUMP_TABLE_COPY (coff),                                           \
5193
  BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5194
  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5195
  BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5196
  BFD_JUMP_TABLE_RELOCS (coff),                                         \
5197
  BFD_JUMP_TABLE_WRITE (coff),                                          \
5198
  BFD_JUMP_TABLE_LINK (coff),                                           \
5199
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5200
                                                                        \
5201
  ALTERNATIVE,                                                          \
5202
                                                                        \
5203
  COFF_SWAP_TABLE                                                       \
5204
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.