Subversion Repositories Kolibri OS

Rev

Rev 5197 | Blame | Compare with Previous | Last modification | View Log | RSS feed

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