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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [coffcode.h] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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