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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [bfd/] [coffcode.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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