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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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