Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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