| /* Support for the generic parts of most COFF variants, for BFD. |
| Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, |
| 2000, 2001 |
| Free Software Foundation, Inc. |
| Written by Cygnus Support. |
| |
| This file is part of BFD, the Binary File Descriptor library. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
| |
| /* |
| Most of this hacked by Steve Chamberlain, |
| sac@cygnus.com |
| */ |
| /* |
| |
| SECTION |
| coff backends |
| |
| BFD supports a number of different flavours of coff format. |
| The major differences between formats are the sizes and |
| alignments of fields in structures on disk, and the occasional |
| extra field. |
| |
| Coff in all its varieties is implemented with a few common |
| files and a number of implementation specific files. For |
| example, The 88k bcs coff format is implemented in the file |
| @file{coff-m88k.c}. This file @code{#include}s |
| @file{coff/m88k.h} which defines the external structure of the |
| coff format for the 88k, and @file{coff/internal.h} which |
| defines the internal structure. @file{coff-m88k.c} also |
| defines the relocations used by the 88k format |
| @xref{Relocations}. |
| |
| The Intel i960 processor version of coff is implemented in |
| @file{coff-i960.c}. This file has the same structure as |
| @file{coff-m88k.c}, except that it includes @file{coff/i960.h} |
| rather than @file{coff-m88k.h}. |
| |
| SUBSECTION |
| Porting to a new version of coff |
| |
| The recommended method is to select from the existing |
| implementations the version of coff which is most like the one |
| you want to use. For example, we'll say that i386 coff is |
| the one you select, and that your coff flavour is called foo. |
| Copy @file{i386coff.c} to @file{foocoff.c}, copy |
| @file{../include/coff/i386.h} to @file{../include/coff/foo.h}, |
| and add the lines to @file{targets.c} and @file{Makefile.in} |
| so that your new back end is used. Alter the shapes of the |
| structures in @file{../include/coff/foo.h} so that they match |
| what you need. You will probably also have to add |
| @code{#ifdef}s to the code in @file{coff/internal.h} and |
| @file{coffcode.h} if your version of coff is too wild. |
| |
| You can verify that your new BFD backend works quite simply by |
| building @file{objdump} from the @file{binutils} directory, |
| and making sure that its version of what's going on and your |
| host system's idea (assuming it has the pretty standard coff |
| dump utility, usually called @code{att-dump} or just |
| @code{dump}) are the same. Then clean up your code, and send |
| what you've done to Cygnus. Then your stuff will be in the |
| next release, and you won't have to keep integrating it. |
| |
| SUBSECTION |
| How the coff backend works |
| |
| SUBSUBSECTION |
| File layout |
| |
| The Coff backend is split into generic routines that are |
| applicable to any Coff target and routines that are specific |
| to a particular target. The target-specific routines are |
| further split into ones which are basically the same for all |
| Coff targets except that they use the external symbol format |
| or use different values for certain constants. |
| |
| The generic routines are in @file{coffgen.c}. These routines |
| work for any Coff target. They use some hooks into the target |
| specific code; the hooks are in a @code{bfd_coff_backend_data} |
| structure, one of which exists for each target. |
| |
| The essentially similar target-specific routines are in |
| @file{coffcode.h}. This header file includes executable C code. |
| The various Coff targets first include the appropriate Coff |
| header file, make any special defines that are needed, and |
| then include @file{coffcode.h}. |
| |
| Some of the Coff targets then also have additional routines in |
| the target source file itself. |
| |
| For example, @file{coff-i960.c} includes |
| @file{coff/internal.h} and @file{coff/i960.h}. It then |
| defines a few constants, such as @code{I960}, and includes |
| @file{coffcode.h}. Since the i960 has complex relocation |
| types, @file{coff-i960.c} also includes some code to |
| manipulate the i960 relocs. This code is not in |
| @file{coffcode.h} because it would not be used by any other |
| target. |
| |
| SUBSUBSECTION |
| Bit twiddling |
| |
| Each flavour of coff supported in BFD has its own header file |
| describing the external layout of the structures. There is also |
| an internal description of the coff layout, in |
| @file{coff/internal.h}. A major function of the |
| coff backend is swapping the bytes and twiddling the bits to |
| translate the external form of the structures into the normal |
| internal form. This is all performed in the |
| @code{bfd_swap}_@i{thing}_@i{direction} routines. Some |
| elements are different sizes between different versions of |
| coff; it is the duty of the coff version specific include file |
| to override the definitions of various packing routines in |
| @file{coffcode.h}. E.g., the size of line number entry in coff is |
| sometimes 16 bits, and sometimes 32 bits. @code{#define}ing |
| @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the |
| correct one. No doubt, some day someone will find a version of |
| coff which has a varying field size not catered to at the |
| moment. To port BFD, that person will have to add more @code{#defines}. |
| Three of the bit twiddling routines are exported to |
| @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in} |
| and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol |
| table on its own, but uses BFD to fix things up. More of the |
| bit twiddlers are exported for @code{gas}; |
| @code{coff_swap_aux_out}, @code{coff_swap_sym_out}, |
| @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out}, |
| @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out}, |
| @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track |
| of all the symbol table and reloc drudgery itself, thereby |
| saving the internal BFD overhead, but uses BFD to swap things |
| on the way out, making cross ports much safer. Doing so also |
| allows BFD (and thus the linker) to use the same header files |
| as @code{gas}, which makes one avenue to disaster disappear. |
| |
| SUBSUBSECTION |
| Symbol reading |
| |
| The simple canonical form for symbols used by BFD is not rich |
| enough to keep all the information available in a coff symbol |
| table. The back end gets around this problem by keeping the original |
| symbol table around, "behind the scenes". |
| |
| When a symbol table is requested (through a call to |
| @code{bfd_canonicalize_symtab}), a request gets through to |
| @code{coff_get_normalized_symtab}. This reads the symbol table from |
| the coff file and swaps all the structures inside into the |
| internal form. It also fixes up all the pointers in the table |
| (represented in the file by offsets from the first symbol in |
| the table) into physical pointers to elements in the new |
| internal table. This involves some work since the meanings of |
| fields change depending upon context: a field that is a |
| pointer to another structure in the symbol table at one moment |
| may be the size in bytes of a structure at the next. Another |
| pass is made over the table. All symbols which mark file names |
| (<<C_FILE>> symbols) are modified so that the internal |
| string points to the value in the auxent (the real filename) |
| rather than the normal text associated with the symbol |
| (@code{".file"}). |
| |
| At this time the symbol names are moved around. Coff stores |
| all symbols less than nine characters long physically |
| within the symbol table; longer strings are kept at the end of |
| the file in the string table. This pass moves all strings |
| into memory and replaces them with pointers to the strings. |
| |
| The symbol table is massaged once again, this time to create |
| the canonical table used by the BFD application. Each symbol |
| is inspected in turn, and a decision made (using the |
| @code{sclass} field) about the various flags to set in the |
| @code{asymbol}. @xref{Symbols}. The generated canonical table |
| shares strings with the hidden internal symbol table. |
| |
| Any linenumbers are read from the coff file too, and attached |
| to the symbols which own the functions the linenumbers belong to. |
| |
| SUBSUBSECTION |
| Symbol writing |
| |
| Writing a symbol to a coff file which didn't come from a coff |
| file will lose any debugging information. The @code{asymbol} |
| structure remembers the BFD from which the symbol was taken, and on |
| output the back end makes sure that the same destination target as |
| source target is present. |
| |
| When the symbols have come from a coff file then all the |
| debugging information is preserved. |
| |
| Symbol tables are provided for writing to the back end in a |
| vector of pointers to pointers. This allows applications like |
| the linker to accumulate and output large symbol tables |
| without having to do too much byte copying. |
| |
| This function runs through the provided symbol table and |
| patches each symbol marked as a file place holder |
| (@code{C_FILE}) to point to the next file place holder in the |
| list. It also marks each @code{offset} field in the list with |
| the offset from the first symbol of the current symbol. |
| |
| Another function of this procedure is to turn the canonical |
| value form of BFD into the form used by coff. Internally, BFD |
| expects symbol values to be offsets from a section base; so a |
| symbol physically at 0x120, but in a section starting at |
| 0x100, would have the value 0x20. Coff expects symbols to |
| contain their final value, so symbols have their values |
| changed at this point to reflect their sum with their owning |
| section. This transformation uses the |
| <<output_section>> field of the @code{asymbol}'s |
| @code{asection} @xref{Sections}. |
| |
| o <<coff_mangle_symbols>> |
| |
| This routine runs though the provided symbol table and uses |
| the offsets generated by the previous pass and the pointers |
| generated when the symbol table was read in to create the |
| structured hierachy required by coff. It changes each pointer |
| to a symbol into the index into the symbol table of the asymbol. |
| |
| o <<coff_write_symbols>> |
| |
| This routine runs through the symbol table and patches up the |
| symbols from their internal form into the coff way, calls the |
| bit twiddlers, and writes out the table to the file. |
| |
| */ |
| |
| /* |
| INTERNAL_DEFINITION |
| coff_symbol_type |
| |
| DESCRIPTION |
| The hidden information for an <<asymbol>> is described in a |
| <<combined_entry_type>>: |
| |
| CODE_FRAGMENT |
| . |
| .typedef struct coff_ptr_struct |
| .{ |
| . |
| . {* Remembers the offset from the first symbol in the file for |
| . this symbol. Generated by coff_renumber_symbols. *} |
| .unsigned int offset; |
| . |
| . {* Should the value of this symbol be renumbered. Used for |
| . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *} |
| .unsigned int fix_value : 1; |
| . |
| . {* Should the tag field of this symbol be renumbered. |
| . Created by coff_pointerize_aux. *} |
| .unsigned int fix_tag : 1; |
| . |
| . {* Should the endidx field of this symbol be renumbered. |
| . Created by coff_pointerize_aux. *} |
| .unsigned int fix_end : 1; |
| . |
| . {* Should the x_csect.x_scnlen field be renumbered. |
| . Created by coff_pointerize_aux. *} |
| .unsigned int fix_scnlen : 1; |
| . |
| . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the |
| . index into the line number entries. Set by |
| . coff_slurp_symbol_table. *} |
| .unsigned int fix_line : 1; |
| . |
| . {* The container for the symbol structure as read and translated |
| . from the file. *} |
| . |
| .union { |
| . union internal_auxent auxent; |
| . struct internal_syment syment; |
| . } u; |
| .} combined_entry_type; |
| . |
| . |
| .{* Each canonical asymbol really looks like this: *} |
| . |
| .typedef struct coff_symbol_struct |
| .{ |
| . {* The actual symbol which the rest of BFD works with *} |
| .asymbol symbol; |
| . |
| . {* A pointer to the hidden information for this symbol *} |
| .combined_entry_type *native; |
| . |
| . {* A pointer to the linenumber information for this symbol *} |
| .struct lineno_cache_entry *lineno; |
| . |
| . {* Have the line numbers been relocated yet ? *} |
| .boolean done_lineno; |
| .} coff_symbol_type; |
| |
| */ |
| |
| #ifdef COFF_WITH_PE |
| #include "peicode.h" |
| #else |
| #include "coffswap.h" |
| #endif |
| |
| #define STRING_SIZE_SIZE (4) |
| |
| static long sec_to_styp_flags PARAMS ((const char *, flagword)); |
| static flagword styp_to_sec_flags |
| PARAMS ((bfd *, PTR, const char *, asection *)); |
| static boolean coff_bad_format_hook PARAMS ((bfd *, PTR)); |
| static void coff_set_custom_section_alignment |
| PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *, |
| const unsigned int)); |
| static boolean coff_new_section_hook PARAMS ((bfd *, asection *)); |
| static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR)); |
| static boolean coff_write_relocs PARAMS ((bfd *, int)); |
| static boolean coff_set_flags |
| PARAMS ((bfd *, unsigned int *, unsigned short *)); |
| static boolean coff_set_arch_mach |
| PARAMS ((bfd *, enum bfd_architecture, unsigned long)); |
| static boolean coff_compute_section_file_positions PARAMS ((bfd *)); |
| static boolean coff_write_object_contents PARAMS ((bfd *)); |
| static boolean coff_set_section_contents |
| PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type)); |
| static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t)); |
| static boolean coff_slurp_line_table PARAMS ((bfd *, asection *)); |
| static boolean coff_slurp_symbol_table PARAMS ((bfd *)); |
| static enum coff_symbol_classification coff_classify_symbol |
| PARAMS ((bfd *, struct internal_syment *)); |
| static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **)); |
| static long coff_canonicalize_reloc |
| PARAMS ((bfd *, asection *, arelent **, asymbol **)); |
| #ifndef coff_mkobject_hook |
| static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR)); |
| #endif |
| #ifdef COFF_WITH_PE |
| static flagword handle_COMDAT PARAMS ((bfd *, flagword, PTR, const char *, asection *)); |
| #endif |
| |
| /* void warning(); */ |
| |
| /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent |
| the incoming SEC_* flags. The inverse of this function is |
| styp_to_sec_flags(). NOTE: If you add to/change this routine, you |
| should probably mirror the changes in styp_to_sec_flags(). */ |
| |
| #ifndef COFF_WITH_PE |
| |
| /* Macros for setting debugging flags. */ |
| #ifdef STYP_DEBUG |
| #define STYP_XCOFF_DEBUG STYP_DEBUG |
| #else |
| #define STYP_XCOFF_DEBUG STYP_INFO |
| #endif |
| |
| #ifdef COFF_ALIGN_IN_S_FLAGS |
| #define STYP_DEBUG_INFO STYP_DSECT |
| #else |
| #define STYP_DEBUG_INFO STYP_INFO |
| #endif |
| |
| static long |
| sec_to_styp_flags (sec_name, sec_flags) |
| CONST char *sec_name; |
| flagword sec_flags; |
| { |
| long styp_flags = 0; |
| |
| if (!strcmp (sec_name, _TEXT)) |
| { |
| styp_flags = STYP_TEXT; |
| } |
| else if (!strcmp (sec_name, _DATA)) |
| { |
| styp_flags = STYP_DATA; |
| } |
| else if (!strcmp (sec_name, _BSS)) |
| { |
| styp_flags = STYP_BSS; |
| #ifdef _COMMENT |
| } |
| else if (!strcmp (sec_name, _COMMENT)) |
| { |
| styp_flags = STYP_INFO; |
| #endif /* _COMMENT */ |
| #ifdef _LIB |
| } |
| else if (!strcmp (sec_name, _LIB)) |
| { |
| styp_flags = STYP_LIB; |
| #endif /* _LIB */ |
| #ifdef _LIT |
| } |
| else if (!strcmp (sec_name, _LIT)) |
| { |
| styp_flags = STYP_LIT; |
| #endif /* _LIT */ |
| } |
| else if (!strncmp (sec_name, ".debug", 6)) |
| { |
| /* Handle the XCOFF debug section and DWARF2 debug sections. */ |
| if (!sec_name[6]) |
| styp_flags = STYP_XCOFF_DEBUG; |
| else |
| styp_flags = STYP_DEBUG_INFO; |
| } |
| else if (!strncmp (sec_name, ".stab", 5)) |
| { |
| styp_flags = STYP_DEBUG_INFO; |
| } |
| #ifdef COFF_LONG_SECTION_NAMES |
| else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17)) |
| { |
| styp_flags = STYP_DEBUG_INFO; |
| } |
| #endif |
| #ifdef RS6000COFF_C |
| else if (!strcmp (sec_name, _PAD)) |
| { |
| styp_flags = STYP_PAD; |
| } |
| else if (!strcmp (sec_name, _LOADER)) |
| { |
| styp_flags = STYP_LOADER; |
| } |
| #endif |
| /* Try and figure out what it should be */ |
| else if (sec_flags & SEC_CODE) |
| { |
| styp_flags = STYP_TEXT; |
| } |
| else if (sec_flags & SEC_DATA) |
| { |
| styp_flags = STYP_DATA; |
| } |
| else if (sec_flags & SEC_READONLY) |
| { |
| #ifdef STYP_LIT /* 29k readonly text/data section */ |
| styp_flags = STYP_LIT; |
| #else |
| styp_flags = STYP_TEXT; |
| #endif /* STYP_LIT */ |
| } |
| else if (sec_flags & SEC_LOAD) |
| { |
| styp_flags = STYP_TEXT; |
| } |
| else if (sec_flags & SEC_ALLOC) |
| { |
| styp_flags = STYP_BSS; |
| } |
| |
| #ifdef STYP_CLINK |
| if (sec_flags & SEC_CLINK) |
| styp_flags |= STYP_CLINK; |
| #endif |
| |
| #ifdef STYP_BLOCK |
| if (sec_flags & SEC_BLOCK) |
| styp_flags |= STYP_BLOCK; |
| #endif |
| |
| #ifdef STYP_NOLOAD |
| if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0) |
| styp_flags |= STYP_NOLOAD; |
| #endif |
| |
| return styp_flags; |
| } |
| |
| #else /* COFF_WITH_PE */ |
| |
| /* The PE version; see above for the general comments. The non-PE |
| case seems to be more guessing, and breaks PE format; specifically, |
| .rdata is readonly, but it sure ain't text. Really, all this |
| should be set up properly in gas (or whatever assembler is in use), |
| and honor whatever objcopy/strip, etc. sent us as input. */ |
| |
| static long |
| sec_to_styp_flags (sec_name, sec_flags) |
| const char *sec_name ATTRIBUTE_UNUSED; |
| flagword sec_flags; |
| { |
| long styp_flags = 0; |
| |
| /* caution: there are at least three groups of symbols that have |
| very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*. |
| SEC_* are the BFD internal flags, used for generic BFD |
| information. STYP_* are the COFF section flags which appear in |
| COFF files. IMAGE_SCN_* are the PE section flags which appear in |
| PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap, |
| but there are more IMAGE_SCN_* flags. */ |
| |
| /* skip LOAD */ |
| /* READONLY later */ |
| /* skip RELOC */ |
| if ((sec_flags & SEC_CODE) != 0) |
| styp_flags |= IMAGE_SCN_CNT_CODE; |
| if ((sec_flags & SEC_DATA) != 0) |
| styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA; |
| if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0) |
| styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */ |
| /* skip ROM */ |
| /* skip CONSTRUCTOR */ |
| /* skip CONTENTS */ |
| #ifdef STYP_NOLOAD |
| if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0) |
| styp_flags |= STYP_NOLOAD; |
| #endif |
| if ((sec_flags & SEC_IS_COMMON) != 0) |
| styp_flags |= IMAGE_SCN_LNK_COMDAT; |
| if ((sec_flags & SEC_DEBUGGING) != 0) |
| styp_flags |= IMAGE_SCN_MEM_DISCARDABLE; |
| if ((sec_flags & SEC_EXCLUDE) != 0) |
| styp_flags |= IMAGE_SCN_LNK_REMOVE; |
| if ((sec_flags & SEC_NEVER_LOAD) != 0) |
| styp_flags |= IMAGE_SCN_LNK_REMOVE; |
| /* skip IN_MEMORY */ |
| /* skip SORT */ |
| if (sec_flags & SEC_LINK_ONCE) |
| styp_flags |= IMAGE_SCN_LNK_COMDAT; |
| /* skip LINK_DUPLICATES */ |
| /* skip LINKER_CREATED */ |
| |
| /* For now, the read/write bits are mapped onto SEC_READONLY, even |
| though the semantics don't quite match. The bits from the input |
| are retained in pei_section_data(abfd, section)->pe_flags */ |
| |
| styp_flags |= IMAGE_SCN_MEM_READ; /* always readable. */ |
| if ((sec_flags & SEC_READONLY) == 0) |
| styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write */ |
| if (sec_flags & SEC_CODE) |
| styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE */ |
| if (sec_flags & SEC_SHARED) |
| styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful */ |
| |
| return styp_flags; |
| } |
| |
| #endif /* COFF_WITH_PE */ |
| |
| /* Return a word with SEC_* flags set to represent the incoming STYP_* |
| flags (from scnhdr.s_flags). The inverse of this function is |
| sec_to_styp_flags(). NOTE: If you add to/change this routine, you |
| should probably mirror the changes in sec_to_styp_flags(). */ |
| |
| #ifndef COFF_WITH_PE |
| |
| static flagword |
| styp_to_sec_flags (abfd, hdr, name, section) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| PTR hdr; |
| const char *name; |
| asection *section ATTRIBUTE_UNUSED; |
| { |
| struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; |
| long styp_flags = internal_s->s_flags; |
| flagword sec_flags = 0; |
| |
| #ifdef STYP_BLOCK |
| if (styp_flags & STYP_BLOCK) |
| sec_flags |= SEC_BLOCK; |
| #endif |
| |
| #ifdef STYP_CLINK |
| if (styp_flags & STYP_CLINK) |
| sec_flags |= SEC_CLINK; |
| #endif |
| |
| #ifdef STYP_NOLOAD |
| if (styp_flags & STYP_NOLOAD) |
| { |
| sec_flags |= SEC_NEVER_LOAD; |
| } |
| #endif /* STYP_NOLOAD */ |
| |
| /* For 386 COFF, at least, an unloadable text or data section is |
| actually a shared library section. */ |
| if (styp_flags & STYP_TEXT) |
| { |
| if (sec_flags & SEC_NEVER_LOAD) |
| sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; |
| else |
| sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; |
| } |
| else if (styp_flags & STYP_DATA) |
| { |
| if (sec_flags & SEC_NEVER_LOAD) |
| sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; |
| else |
| sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; |
| } |
| else if (styp_flags & STYP_BSS) |
| { |
| #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY |
| if (sec_flags & SEC_NEVER_LOAD) |
| sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; |
| else |
| #endif |
| sec_flags |= SEC_ALLOC; |
| } |
| else if (styp_flags & STYP_INFO) |
| { |
| /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is |
| defined. coff_compute_section_file_positions uses |
| COFF_PAGE_SIZE to ensure that the low order bits of the |
| section VMA and the file offset match. If we don't know |
| COFF_PAGE_SIZE, we can't ensure the correct correspondence, |
| and demand page loading of the file will fail. */ |
| #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS) |
| sec_flags |= SEC_DEBUGGING; |
| #endif |
| } |
| else if (styp_flags & STYP_PAD) |
| { |
| sec_flags = 0; |
| } |
| else if (strcmp (name, _TEXT) == 0) |
| { |
| if (sec_flags & SEC_NEVER_LOAD) |
| sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; |
| else |
| sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; |
| } |
| else if (strcmp (name, _DATA) == 0) |
| { |
| if (sec_flags & SEC_NEVER_LOAD) |
| sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; |
| else |
| sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; |
| } |
| else if (strcmp (name, _BSS) == 0) |
| { |
| #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY |
| if (sec_flags & SEC_NEVER_LOAD) |
| sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; |
| else |
| #endif |
| sec_flags |= SEC_ALLOC; |
| } |
| else if (strncmp (name, ".debug", 6) == 0 |
| #ifdef _COMMENT |
| || strcmp (name, _COMMENT) == 0 |
| #endif |
| #ifdef COFF_LONG_SECTION_NAMES |
| || strncmp (name, ".gnu.linkonce.wi.", 17) == 0 |
| #endif |
| || strncmp (name, ".stab", 5) == 0) |
| { |
| #ifdef COFF_PAGE_SIZE |
| sec_flags |= SEC_DEBUGGING; |
| #endif |
| } |
| #ifdef _LIB |
| else if (strcmp (name, _LIB) == 0) |
| ; |
| #endif |
| #ifdef _LIT |
| else if (strcmp (name, _LIT) == 0) |
| { |
| sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY; |
| } |
| #endif |
| else |
| { |
| sec_flags |= SEC_ALLOC | SEC_LOAD; |
| } |
| |
| #ifdef STYP_LIT /* A29k readonly text/data section type */ |
| if ((styp_flags & STYP_LIT) == STYP_LIT) |
| { |
| sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY); |
| } |
| #endif /* STYP_LIT */ |
| #ifdef STYP_OTHER_LOAD /* Other loaded sections */ |
| if (styp_flags & STYP_OTHER_LOAD) |
| { |
| sec_flags = (SEC_LOAD | SEC_ALLOC); |
| } |
| #endif /* STYP_SDATA */ |
| |
| #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE) |
| /* As a GNU extension, if the name begins with .gnu.linkonce, we |
| only link a single copy of the section. This is used to support |
| g++. g++ will emit each template expansion in its own section. |
| The symbols will be defined as weak, so that multiple definitions |
| are permitted. The GNU linker extension is to actually discard |
| all but one of the sections. */ |
| if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0) |
| sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; |
| #endif |
| |
| return sec_flags; |
| } |
| |
| #else /* COFF_WITH_PE */ |
| |
| static flagword |
| handle_COMDAT (abfd, sec_flags, hdr, name, section) |
| bfd * abfd; |
| flagword sec_flags; |
| PTR hdr; |
| const char *name; |
| asection *section; |
| { |
| struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; |
| bfd_byte *esymstart, *esym, *esymend; |
| int seen_state = 0; |
| char *target_name = NULL; |
| |
| sec_flags |= SEC_LINK_ONCE; |
| |
| /* Unfortunately, the PE format stores essential information in |
| the symbol table, of all places. We need to extract that |
| information now, so that objdump and the linker will know how |
| to handle the section without worrying about the symbols. We |
| can't call slurp_symtab, because the linker doesn't want the |
| swapped symbols. */ |
| |
| /* COMDAT sections are special. The first symbol is the section |
| symbol, which tells what kind of COMDAT section it is. The |
| second symbol is the "comdat symbol" - the one with the |
| unique name. GNU uses the section symbol for the unique |
| name; MS uses ".text" for every comdat section. Sigh. - DJ */ |
| |
| /* This is not mirrored in sec_to_styp_flags(), but there |
| doesn't seem to be a need to, either, and it would at best be |
| rather messy. */ |
| |
| if (! _bfd_coff_get_external_symbols (abfd)) |
| return sec_flags; |
| |
| esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd); |
| esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd); |
| |
| while (esym < esymend) |
| { |
| struct internal_syment isym; |
| char buf[SYMNMLEN + 1]; |
| const char *symname; |
| |
| bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym); |
| |
| if (sizeof (internal_s->s_name) > SYMNMLEN) |
| { |
| /* This case implies that the matching |
| symbol name will be in the string table. */ |
| abort (); |
| } |
| |
| if (isym.n_scnum == section->target_index) |
| { |
| /* According to the MSVC documentation, the first |
| TWO entries with the section # are both of |
| interest to us. The first one is the "section |
| symbol" (section name). The second is the comdat |
| symbol name. Here, we've found the first |
| qualifying entry; we distinguish it from the |
| second with a state flag. |
| |
| In the case of gas-generated (at least until that |
| is fixed) .o files, it isn't necessarily the |
| second one. It may be some other later symbol. |
| |
| Since gas also doesn't follow MS conventions and |
| emits the section similar to .text$<name>, where |
| <something> is the name we're looking for, we |
| distinguish the two as follows: |
| |
| If the section name is simply a section name (no |
| $) we presume it's MS-generated, and look at |
| precisely the second symbol for the comdat name. |
| If the section name has a $, we assume it's |
| gas-generated, and look for <something> (whatever |
| follows the $) as the comdat symbol. */ |
| |
| /* All 3 branches use this */ |
| symname = _bfd_coff_internal_syment_name (abfd, &isym, buf); |
| |
| if (symname == NULL) |
| abort (); |
| |
| switch (seen_state) |
| { |
| case 0: |
| { |
| /* The first time we've seen the symbol. */ |
| union internal_auxent aux; |
| |
| seen_state = 1; |
| |
| /* If it isn't the stuff we're expecting, die; |
| The MS documentation is vague, but it |
| appears that the second entry serves BOTH |
| as the comdat symbol and the defining |
| symbol record (either C_STAT or C_EXT, |
| possibly with an aux entry with debug |
| information if it's a function.) It |
| appears the only way to find the second one |
| is to count. (On Intel, they appear to be |
| adjacent, but on Alpha, they have been |
| found separated.) |
| |
| Here, we think we've found the first one, |
| but there's some checking we can do to be |
| sure. */ |
| |
| if (! (isym.n_sclass == C_STAT |
| && isym.n_type == T_NULL |
| && isym.n_value == 0)) |
| abort (); |
| |
| /* FIXME LATER: MSVC generates section names |
| like .text for comdats. Gas generates |
| names like .text$foo__Fv (in the case of a |
| function). See comment above for more. */ |
| |
| if (strcmp (name, symname) != 0) |
| abort (); |
| |
| /* This is the section symbol. */ |
| bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)), |
| isym.n_type, isym.n_sclass, |
| 0, isym.n_numaux, (PTR) &aux); |
| |
| target_name = strchr (name, '$'); |
| if (target_name != NULL) |
| { |
| /* Gas mode. */ |
| seen_state = 2; |
| /* Skip the `$'. */ |
| target_name += 1; |
| } |
| |
| /* FIXME: Microsoft uses NODUPLICATES and |
| ASSOCIATIVE, but gnu uses ANY and |
| SAME_SIZE. Unfortunately, gnu doesn't do |
| the comdat symbols right. So, until we can |
| fix it to do the right thing, we are |
| temporarily disabling comdats for the MS |
| types (they're used in DLLs and C++, but we |
| don't support *their* C++ libraries anyway |
| - DJ. */ |
| |
| /* Cygwin does not follow the MS style, and |
| uses ANY and SAME_SIZE where NODUPLICATES |
| and ASSOCIATIVE should be used. For |
| Interix, we just do the right thing up |
| front. */ |
| |
| switch (aux.x_scn.x_comdat) |
| { |
| case IMAGE_COMDAT_SELECT_NODUPLICATES: |
| #ifdef STRICT_PE_FORMAT |
| sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY; |
| #else |
| sec_flags &= ~SEC_LINK_ONCE; |
| #endif |
| break; |
| |
| case IMAGE_COMDAT_SELECT_ANY: |
| sec_flags |= SEC_LINK_DUPLICATES_DISCARD; |
| break; |
| |
| case IMAGE_COMDAT_SELECT_SAME_SIZE: |
| sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE; |
| break; |
| |
| case IMAGE_COMDAT_SELECT_EXACT_MATCH: |
| /* Not yet fully implemented ??? */ |
| sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS; |
| break; |
| |
| /* debug$S gets this case; other |
| implications ??? */ |
| |
| /* There may be no symbol... we'll search |
| the whole table... Is this the right |
| place to play this game? Or should we do |
| it when reading it in. */ |
| case IMAGE_COMDAT_SELECT_ASSOCIATIVE: |
| #ifdef STRICT_PE_FORMAT |
| /* FIXME: This is not currently implemented. */ |
| sec_flags |= SEC_LINK_DUPLICATES_DISCARD; |
| #else |
| sec_flags &= ~SEC_LINK_ONCE; |
| #endif |
| break; |
| |
| default: /* 0 means "no symbol" */ |
| /* debug$F gets this case; other |
| implications ??? */ |
| sec_flags |= SEC_LINK_DUPLICATES_DISCARD; |
| break; |
| } |
| } |
| break; |
| |
| case 2: |
| /* Gas mode: the first matching on partial name. */ |
| |
| #ifndef TARGET_UNDERSCORE |
| #define TARGET_UNDERSCORE 0 |
| #endif |
| /* Is this the name we're looking for? */ |
| if (strcmp (target_name, |
| symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0) |
| { |
| /* Not the name we're looking for */ |
| esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd); |
| continue; |
| } |
| /* Fall through. */ |
| case 1: |
| /* MSVC mode: the lexically second symbol (or |
| drop through from the above). */ |
| { |
| char *newname; |
| |
| /* This must the the second symbol with the |
| section #. It is the actual symbol name. |
| Intel puts the two adjacent, but Alpha (at |
| least) spreads them out. */ |
| |
| section->comdat = |
| bfd_alloc (abfd, sizeof (struct bfd_comdat_info)); |
| if (section->comdat == NULL) |
| abort (); |
| |
| section->comdat->symbol = |
| (esym - esymstart) / bfd_coff_symesz (abfd); |
| |
| newname = bfd_alloc (abfd, strlen (symname) + 1); |
| if (newname == NULL) |
| abort (); |
| |
| strcpy (newname, symname); |
| section->comdat->name = newname; |
| } |
| |
| goto breakloop; |
| } |
| } |
| |
| esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd); |
| } |
| |
| breakloop: |
| return sec_flags; |
| } |
| |
| |
| /* The PE version; see above for the general comments. |
| |
| Since to set the SEC_LINK_ONCE and associated flags, we have to |
| look at the symbol table anyway, we return the symbol table index |
| of the symbol being used as the COMDAT symbol. This is admittedly |
| ugly, but there's really nowhere else that we have access to the |
| required information. FIXME: Is the COMDAT symbol index used for |
| any purpose other than objdump? */ |
| |
| static flagword |
| styp_to_sec_flags (abfd, hdr, name, section) |
| bfd *abfd; |
| PTR hdr; |
| const char *name; |
| asection *section; |
| { |
| struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; |
| long styp_flags = internal_s->s_flags; |
| flagword sec_flags; |
| |
| /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */ |
| sec_flags = SEC_READONLY; |
| |
| /* Process each flag bit in styp_flags in turn. */ |
| while (styp_flags) |
| { |
| long flag = styp_flags & - styp_flags; |
| char * unhandled = NULL; |
| |
| styp_flags &= ~ flag; |
| |
| /* We infer from the distinct read/write/execute bits the settings |
| of some of the bfd flags; the actual values, should we need them, |
| are also in pei_section_data (abfd, section)->pe_flags. */ |
| |
| switch (flag) |
| { |
| case STYP_DSECT: |
| unhandled = "STYP_DSECT"; |
| break; |
| case STYP_GROUP: |
| unhandled = "STYP_GROUP"; |
| break; |
| case STYP_COPY: |
| unhandled = "STYP_COPY"; |
| break; |
| case STYP_OVER: |
| unhandled = "STYP_OVER"; |
| break; |
| #ifdef SEC_NEVER_LOAD |
| case STYP_NOLOAD: |
| sec_flags |= SEC_NEVER_LOAD; |
| break; |
| #endif |
| case IMAGE_SCN_MEM_READ: |
| /* Ignored, assume it always to be true. */ |
| break; |
| case IMAGE_SCN_TYPE_NO_PAD: |
| /* Skip. */ |
| break; |
| case IMAGE_SCN_LNK_OTHER: |
| unhandled = "IMAGE_SCN_LNK_OTHER"; |
| break; |
| case IMAGE_SCN_MEM_NOT_CACHED: |
| unhandled = "IMAGE_SCN_MEM_NOT_CACHED"; |
| break; |
| case IMAGE_SCN_MEM_NOT_PAGED: |
| unhandled = "IMAGE_SCN_MEM_NOT_PAGED"; |
| break; |
| case IMAGE_SCN_MEM_EXECUTE: |
| sec_flags |= SEC_CODE; |
| break; |
| case IMAGE_SCN_MEM_WRITE: |
| sec_flags &= ~ SEC_READONLY; |
| break; |
| case IMAGE_SCN_MEM_DISCARDABLE: |
| sec_flags |= SEC_DEBUGGING; |
| break; |
| case IMAGE_SCN_MEM_SHARED: |
| sec_flags |= SEC_SHARED; |
| break; |
| case IMAGE_SCN_LNK_REMOVE: |
| sec_flags |= SEC_EXCLUDE; |
| break; |
| case IMAGE_SCN_CNT_CODE: |
| sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD; |
| break; |
| case IMAGE_SCN_CNT_INITIALIZED_DATA: |
| sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD; |
| break; |
| case IMAGE_SCN_CNT_UNINITIALIZED_DATA: |
| sec_flags |= SEC_ALLOC; |
| break; |
| case IMAGE_SCN_LNK_INFO: |
| /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is |
| defined. coff_compute_section_file_positions uses |
| COFF_PAGE_SIZE to ensure that the low order bits of the |
| section VMA and the file offset match. If we don't know |
| COFF_PAGE_SIZE, we can't ensure the correct correspondence, |
| and demand page loading of the file will fail. */ |
| #ifdef COFF_PAGE_SIZE |
| sec_flags |= SEC_DEBUGGING; |
| #endif |
| break; |
| case IMAGE_SCN_LNK_COMDAT: |
| /* COMDAT gets very special treatment. */ |
| sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section); |
| break; |
| default: |
| /* Silently ignore for now. */ |
| break; |
| } |
| |
| /* If the section flag was not handled, report it here. This will allow |
| users of the BFD library to report a problem but continue executing. |
| Tools which need to be aware of these problems (such as the linker) |
| can override the default bfd_error_handler to intercept these reports. */ |
| if (unhandled != NULL) |
| (*_bfd_error_handler) |
| (_("%s (%s): Section flag %s (0x%x) ignored"), |
| bfd_get_filename (abfd), name, unhandled, flag); |
| } |
| |
| #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE) |
| /* As a GNU extension, if the name begins with .gnu.linkonce, we |
| only link a single copy of the section. This is used to support |
| g++. g++ will emit each template expansion in its own section. |
| The symbols will be defined as weak, so that multiple definitions |
| are permitted. The GNU linker extension is to actually discard |
| all but one of the sections. */ |
| if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0) |
| sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; |
| #endif |
| |
| return sec_flags; |
| } |
| |
| #endif /* COFF_WITH_PE */ |
| |
| #define get_index(symbol) ((symbol)->udata.i) |
| |
| /* |
| INTERNAL_DEFINITION |
| bfd_coff_backend_data |
| |
| CODE_FRAGMENT |
| |
| .{* COFF symbol classifications. *} |
| . |
| .enum coff_symbol_classification |
| .{ |
| . {* Global symbol. *} |
| . COFF_SYMBOL_GLOBAL, |
| . {* Common symbol. *} |
| . COFF_SYMBOL_COMMON, |
| . {* Undefined symbol. *} |
| . COFF_SYMBOL_UNDEFINED, |
| . {* Local symbol. *} |
| . COFF_SYMBOL_LOCAL, |
| . {* PE section symbol. *} |
| . COFF_SYMBOL_PE_SECTION |
| .}; |
| . |
| Special entry points for gdb to swap in coff symbol table parts: |
| .typedef struct |
| .{ |
| . void (*_bfd_coff_swap_aux_in) PARAMS (( |
| . bfd *abfd, |
| . PTR ext, |
| . int type, |
| . int class, |
| . int indaux, |
| . int numaux, |
| . PTR in)); |
| . |
| . void (*_bfd_coff_swap_sym_in) PARAMS (( |
| . bfd *abfd , |
| . PTR ext, |
| . PTR in)); |
| . |
| . void (*_bfd_coff_swap_lineno_in) PARAMS (( |
| . bfd *abfd, |
| . PTR ext, |
| . PTR in)); |
| . |
| |
| Special entry points for gas to swap out coff parts: |
| |
| . unsigned int (*_bfd_coff_swap_aux_out) PARAMS (( |
| . bfd *abfd, |
| . PTR in, |
| . int type, |
| . int class, |
| . int indaux, |
| . int numaux, |
| . PTR ext)); |
| . |
| . unsigned int (*_bfd_coff_swap_sym_out) PARAMS (( |
| . bfd *abfd, |
| . PTR in, |
| . PTR ext)); |
| . |
| . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS (( |
| . bfd *abfd, |
| . PTR in, |
| . PTR ext)); |
| . |
| . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS (( |
| . bfd *abfd, |
| . PTR src, |
| . PTR dst)); |
| . |
| . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS (( |
| . bfd *abfd, |
| . PTR in, |
| . PTR out)); |
| . |
| . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS (( |
| . bfd *abfd, |
| . PTR in, |
| . PTR out)); |
| . |
| . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS (( |
| . bfd *abfd, |
| . PTR in, |
| . PTR out)); |
| . |
| |
| Special entry points for generic COFF routines to call target |
| dependent COFF routines: |
| |
| . unsigned int _bfd_filhsz; |
| . unsigned int _bfd_aoutsz; |
| . unsigned int _bfd_scnhsz; |
| . unsigned int _bfd_symesz; |
| . unsigned int _bfd_auxesz; |
| . unsigned int _bfd_relsz; |
| . unsigned int _bfd_linesz; |
| . unsigned int _bfd_filnmlen; |
| . boolean _bfd_coff_long_filenames; |
| . boolean _bfd_coff_long_section_names; |
| . unsigned int _bfd_coff_default_section_alignment_power; |
| . boolean _bfd_coff_force_symnames_in_strings; |
| . unsigned int _bfd_coff_debug_string_prefix_length; |
| . void (*_bfd_coff_swap_filehdr_in) PARAMS (( |
| . bfd *abfd, |
| . PTR ext, |
| . PTR in)); |
| . void (*_bfd_coff_swap_aouthdr_in) PARAMS (( |
| . bfd *abfd, |
| . PTR ext, |
| . PTR in)); |
| . void (*_bfd_coff_swap_scnhdr_in) PARAMS (( |
| . bfd *abfd, |
| . PTR ext, |
| . PTR in)); |
| . void (*_bfd_coff_swap_reloc_in) PARAMS (( |
| . bfd *abfd, |
| . PTR ext, |
| . PTR in)); |
| . boolean (*_bfd_coff_bad_format_hook) PARAMS (( |
| . bfd *abfd, |
| . PTR internal_filehdr)); |
| . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS (( |
| . bfd *abfd, |
| . PTR internal_filehdr)); |
| . PTR (*_bfd_coff_mkobject_hook) PARAMS (( |
| . bfd *abfd, |
| . PTR internal_filehdr, |
| . PTR internal_aouthdr)); |
| . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS (( |
| . bfd *abfd, |
| . PTR internal_scnhdr, |
| . const char *name, |
| . asection *section)); |
| . void (*_bfd_set_alignment_hook) PARAMS (( |
| . bfd *abfd, |
| . asection *sec, |
| . PTR internal_scnhdr)); |
| . boolean (*_bfd_coff_slurp_symbol_table) PARAMS (( |
| . bfd *abfd)); |
| . boolean (*_bfd_coff_symname_in_debug) PARAMS (( |
| . bfd *abfd, |
| . struct internal_syment *sym)); |
| . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS (( |
| . bfd *abfd, |
| . combined_entry_type *table_base, |
| . combined_entry_type *symbol, |
| . unsigned int indaux, |
| . combined_entry_type *aux)); |
| . boolean (*_bfd_coff_print_aux) PARAMS (( |
| . bfd *abfd, |
| . FILE *file, |
| . combined_entry_type *table_base, |
| . combined_entry_type *symbol, |
| . combined_entry_type *aux, |
| . unsigned int indaux)); |
| . void (*_bfd_coff_reloc16_extra_cases) PARAMS (( |
| . bfd *abfd, |
| . struct bfd_link_info *link_info, |
| . struct bfd_link_order *link_order, |
| . arelent *reloc, |
| . bfd_byte *data, |
| . unsigned int *src_ptr, |
| . unsigned int *dst_ptr)); |
| . int (*_bfd_coff_reloc16_estimate) PARAMS (( |
| . bfd *abfd, |
| . asection *input_section, |
| . arelent *r, |
| . unsigned int shrink, |
| . struct bfd_link_info *link_info)); |
| . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS (( |
| . bfd *abfd, |
| . struct internal_syment *)); |
| . boolean (*_bfd_coff_compute_section_file_positions) PARAMS (( |
| . bfd *abfd)); |
| . boolean (*_bfd_coff_start_final_link) PARAMS (( |
| . bfd *output_bfd, |
| . struct bfd_link_info *info)); |
| . boolean (*_bfd_coff_relocate_section) PARAMS (( |
| . bfd *output_bfd, |
| . struct bfd_link_info *info, |
| . bfd *input_bfd, |
| . asection *input_section, |
| . bfd_byte *contents, |
| . struct internal_reloc *relocs, |
| . struct internal_syment *syms, |
| . asection **sections)); |
| . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS (( |
| . bfd *abfd, |
| . asection *sec, |
| . struct internal_reloc *rel, |
| . struct coff_link_hash_entry *h, |
| . struct internal_syment *sym, |
| . bfd_vma *addendp)); |
| . boolean (*_bfd_coff_adjust_symndx) PARAMS (( |
| . bfd *obfd, |
| . struct bfd_link_info *info, |
| . bfd *ibfd, |
| . asection *sec, |
| . struct internal_reloc *reloc, |
| . boolean *adjustedp)); |
| . boolean (*_bfd_coff_link_add_one_symbol) PARAMS (( |
| . struct bfd_link_info *info, |
| . bfd *abfd, |
| . const char *name, |
| . flagword flags, |
| . asection *section, |
| . bfd_vma value, |
| . const char *string, |
| . boolean copy, |
| . boolean collect, |
| . struct bfd_link_hash_entry **hashp)); |
| . |
| . boolean (*_bfd_coff_link_output_has_begun) PARAMS (( |
| . bfd * abfd, |
| . struct coff_final_link_info * pfinfo)); |
| . boolean (*_bfd_coff_final_link_postscript) PARAMS (( |
| . bfd * abfd, |
| . struct coff_final_link_info * pfinfo)); |
| . |
| .} bfd_coff_backend_data; |
| . |
| .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) |
| . |
| .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ |
| . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) |
| . |
| .#define bfd_coff_swap_sym_in(a,e,i) \ |
| . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) |
| . |
| .#define bfd_coff_swap_lineno_in(a,e,i) \ |
| . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) |
| . |
| .#define bfd_coff_swap_reloc_out(abfd, i, o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_lineno_out(abfd, i, o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ |
| . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) |
| . |
| .#define bfd_coff_swap_sym_out(abfd, i,o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_filehdr_out(abfd, i,o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) |
| . |
| .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) |
| .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) |
| .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) |
| .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) |
| .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) |
| .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) |
| .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) |
| .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) |
| .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames) |
| .#define bfd_coff_long_section_names(abfd) \ |
| . (coff_backend_info (abfd)->_bfd_coff_long_section_names) |
| .#define bfd_coff_default_section_alignment_power(abfd) \ |
| . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) |
| .#define bfd_coff_swap_filehdr_in(abfd, i,o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) |
| . |
| .#define bfd_coff_swap_reloc_in(abfd, i, o) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) |
| . |
| .#define bfd_coff_bad_format_hook(abfd, filehdr) \ |
| . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) |
| . |
| .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) |
| .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr)) |
| . |
| .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\ |
| . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ |
| . (abfd, scnhdr, name, section)) |
| . |
| .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ |
| . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) |
| . |
| .#define bfd_coff_slurp_symbol_table(abfd)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) |
| . |
| .#define bfd_coff_symname_in_debug(abfd, sym)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) |
| . |
| .#define bfd_coff_force_symnames_in_strings(abfd)\ |
| . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings) |
| . |
| .#define bfd_coff_debug_string_prefix_length(abfd)\ |
| . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length) |
| . |
| .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ |
| . (abfd, file, base, symbol, aux, indaux)) |
| . |
| .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ |
| . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) |
| . |
| .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ |
| . (abfd, section, reloc, shrink, link_info)) |
| . |
| .#define bfd_coff_classify_symbol(abfd, sym)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ |
| . (abfd, sym)) |
| . |
| .#define bfd_coff_compute_section_file_positions(abfd)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ |
| . (abfd)) |
| . |
| .#define bfd_coff_start_final_link(obfd, info)\ |
| . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ |
| . (obfd, info)) |
| .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ |
| . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ |
| . (obfd, info, ibfd, o, con, rel, isyms, secs)) |
| .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ |
| . (abfd, sec, rel, h, sym, addendp)) |
| .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ |
| . (obfd, info, ibfd, sec, rel, adjustedp)) |
| .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\ |
| . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ |
| . (info, abfd, name, flags, section, value, string, cp, coll, hashp)) |
| . |
| .#define bfd_coff_link_output_has_begun(a,p) \ |
| . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p)) |
| .#define bfd_coff_final_link_postscript(a,p) \ |
| . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p)) |
| . |
| */ |
| |
| /* See whether the magic number matches. */ |
| |
| static boolean |
| coff_bad_format_hook (abfd, filehdr) |
| bfd * abfd ATTRIBUTE_UNUSED; |
| PTR filehdr; |
| { |
| struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; |
| |
| if (BADMAG (*internal_f)) |
| return false; |
| |
| /* if the optional header is NULL or not the correct size then |
| quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) |
| and Intel 960 readwrite headers (I960WRMAGIC) is that the |
| optional header is of a different size. |
| |
| But the mips keeps extra stuff in it's opthdr, so dont check |
| when doing that |
| */ |
| |
| #if defined(M88) || defined(I960) |
| if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr) |
| return false; |
| #endif |
| |
| return true; |
| } |
| |
| /* Check whether this section uses an alignment other than the |
| default. */ |
| |
| static void |
| coff_set_custom_section_alignment (abfd, section, alignment_table, table_size) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| asection *section; |
| const struct coff_section_alignment_entry *alignment_table; |
| const unsigned int table_size; |
| { |
| const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER; |
| unsigned int i; |
| |
| for (i = 0; i < table_size; ++i) |
| { |
| const char *secname = bfd_get_section_name (abfd, section); |
| if (alignment_table[i].comparison_length == (unsigned int) -1 |
| ? strcmp (alignment_table[i].name, secname) == 0 |
| : strncmp (alignment_table[i].name, secname, |
| alignment_table[i].comparison_length) == 0) |
| break; |
| } |
| if (i >= table_size) |
| return; |
| |
| if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY |
| && default_alignment < alignment_table[i].default_alignment_min) |
| return; |
| |
| if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY |
| && default_alignment > alignment_table[i].default_alignment_max) |
| return; |
| |
| section->alignment_power = alignment_table[i].alignment_power; |
| } |
| |
| /* Custom section alignment records. */ |
| |
| static const struct coff_section_alignment_entry |
| coff_section_alignment_table[] = |
| { |
| #ifdef COFF_SECTION_ALIGNMENT_ENTRIES |
| COFF_SECTION_ALIGNMENT_ENTRIES, |
| #endif |
| /* There must not be any gaps between .stabstr sections. */ |
| { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"), |
| 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, |
| /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */ |
| { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"), |
| 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, |
| /* Similarly for the .ctors and .dtors sections. */ |
| { COFF_SECTION_NAME_EXACT_MATCH (".ctors"), |
| 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, |
| { COFF_SECTION_NAME_EXACT_MATCH (".dtors"), |
| 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 } |
| }; |
| |
| static const unsigned int coff_section_alignment_table_size = |
| sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0]; |
| |
| /* Initialize a section structure with information peculiar to this |
| particular implementation of COFF. */ |
| |
| static boolean |
| coff_new_section_hook (abfd, section) |
| bfd * abfd; |
| asection * section; |
| { |
| combined_entry_type *native; |
| |
| section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER; |
| |
| #ifdef RS6000COFF_C |
| if (xcoff_data (abfd)->text_align_power != 0 |
| && strcmp (bfd_get_section_name (abfd, section), ".text") == 0) |
| section->alignment_power = xcoff_data (abfd)->text_align_power; |
| if (xcoff_data (abfd)->data_align_power != 0 |
| && strcmp (bfd_get_section_name (abfd, section), ".data") == 0) |
| section->alignment_power = xcoff_data (abfd)->data_align_power; |
| #endif |
| |
| /* Allocate aux records for section symbols, to store size and |
| related info. |
| |
| @@ The 10 is a guess at a plausible maximum number of aux entries |
| (but shouldn't be a constant). */ |
| native = ((combined_entry_type *) |
| bfd_zalloc (abfd, sizeof (combined_entry_type) * 10)); |
| if (native == NULL) |
| return false; |
| |
| /* We don't need to set up n_name, n_value, or n_scnum in the native |
| symbol information, since they'll be overriden by the BFD symbol |
| anyhow. However, we do need to set the type and storage class, |
| in case this symbol winds up getting written out. The value 0 |
| for n_numaux is already correct. */ |
| |
| native->u.syment.n_type = T_NULL; |
| native->u.syment.n_sclass = C_STAT; |
| |
| coffsymbol (section->symbol)->native = native; |
| |
| coff_set_custom_section_alignment (abfd, section, |
| coff_section_alignment_table, |
| coff_section_alignment_table_size); |
| |
| return true; |
| } |
| |
| #ifdef COFF_ALIGN_IN_SECTION_HEADER |
| |
| /* Set the alignment of a BFD section. */ |
| |
| static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR)); |
| |
| static void |
| coff_set_alignment_hook (abfd, section, scnhdr) |
| bfd * abfd ATTRIBUTE_UNUSED; |
| asection * section; |
| PTR scnhdr; |
| { |
| struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; |
| unsigned int i; |
| |
| #ifdef I960 |
| /* Extract ALIGN from 2**ALIGN stored in section header */ |
| for (i = 0; i < 32; i++) |
| if ((1 << i) >= hdr->s_align) |
| break; |
| #endif |
| #ifdef TIC80COFF |
| /* TI tools puts the alignment power in bits 8-11 */ |
| i = (hdr->s_flags >> 8) & 0xF ; |
| #endif |
| #ifdef COFF_DECODE_ALIGNMENT |
| i = COFF_DECODE_ALIGNMENT(hdr->s_flags); |
| #endif |
| section->alignment_power = i; |
| |
| #ifdef coff_set_section_load_page |
| coff_set_section_load_page (section, hdr->s_page); |
| #endif |
| } |
| |
| #else /* ! COFF_ALIGN_IN_SECTION_HEADER */ |
| #ifdef COFF_WITH_PE |
| |
| /* a couple of macros to help setting the alignment power field */ |
| #define ALIGN_SET(field,x,y) \ |
| if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\ |
| {\ |
| section->alignment_power = y;\ |
| } |
| |
| #define ELIFALIGN_SET(field,x,y) \ |
| else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \ |
| {\ |
| section->alignment_power = y;\ |
| } |
| |
| static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR)); |
| |
| static void |
| coff_set_alignment_hook (abfd, section, scnhdr) |
| bfd * abfd ATTRIBUTE_UNUSED; |
| asection * section; |
| PTR scnhdr; |
| { |
| struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; |
| |
| ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6) |
| ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5) |
| ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4) |
| ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3) |
| ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2) |
| ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1) |
| ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0) |
| |
| /* In a PE image file, the s_paddr field holds the virtual size of a |
| section, while the s_size field holds the raw size. We also keep |
| the original section flag value, since not every bit can be |
| mapped onto a generic BFD section bit. */ |
| if (coff_section_data (abfd, section) == NULL) |
| { |
| section->used_by_bfd = |
| (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)); |
| if (section->used_by_bfd == NULL) |
| { |
| /* FIXME: Return error. */ |
| abort (); |
| } |
| } |
| if (pei_section_data (abfd, section) == NULL) |
| { |
| coff_section_data (abfd, section)->tdata = |
| (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata)); |
| if (coff_section_data (abfd, section)->tdata == NULL) |
| { |
| /* FIXME: Return error. */ |
| abort (); |
| } |
| } |
| pei_section_data (abfd, section)->virt_size = hdr->s_paddr; |
| pei_section_data (abfd, section)->pe_flags = hdr->s_flags; |
| |
| section->lma = hdr->s_vaddr; |
| |
| /* check for extended relocs */ |
| if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL) |
| { |
| struct external_reloc dst; |
| struct internal_reloc n; |
| int oldpos = bfd_tell (abfd); |
| bfd_seek (abfd, hdr->s_relptr, 0); |
| if (bfd_read ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd) |
| != bfd_coff_relsz (abfd)) |
| return; |
| |
| coff_swap_reloc_in (abfd, &dst, &n); |
| bfd_seek (abfd, oldpos, 0); |
| section->reloc_count = |
| hdr->s_nreloc = n.r_vaddr; |
| } |
| } |
| #undef ALIGN_SET |
| #undef ELIFALIGN_SET |
| |
| #else /* ! COFF_WITH_PE */ |
| #ifdef RS6000COFF_C |
| |
| /* We grossly abuse this function to handle XCOFF overflow headers. |
| When we see one, we correct the reloc and line number counts in the |
| real header, and remove the section we just created. */ |
| |
| static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR)); |
| |
| static void |
| coff_set_alignment_hook (abfd, section, scnhdr) |
| bfd *abfd; |
| asection *section; |
| PTR scnhdr; |
| { |
| struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; |
| asection *real_sec; |
| asection **ps; |
| |
| if ((hdr->s_flags & STYP_OVRFLO) == 0) |
| return; |
| |
| real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc); |
| if (real_sec == NULL) |
| return; |
| |
| real_sec->reloc_count = hdr->s_paddr; |
| real_sec->lineno_count = hdr->s_vaddr; |
| |
| for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next) |
| { |
| if (*ps == section) |
| { |
| *ps = (*ps)->next; |
| --abfd->section_count; |
| break; |
| } |
| } |
| } |
| |
| #else /* ! RS6000COFF_C */ |
| |
| #define coff_set_alignment_hook \ |
| ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void) |
| |
| #endif /* ! RS6000COFF_C */ |
| #endif /* ! COFF_WITH_PE */ |
| #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */ |
| |
| #ifndef coff_mkobject |
| |
| static boolean coff_mkobject PARAMS ((bfd *)); |
| |
| static boolean |
| coff_mkobject (abfd) |
| bfd * abfd; |
| { |
| coff_data_type *coff; |
| |
| abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type)); |
| if (abfd->tdata.coff_obj_data == 0) |
| return false; |
| coff = coff_data (abfd); |
| coff->symbols = (coff_symbol_type *) NULL; |
| coff->conversion_table = (unsigned int *) NULL; |
| coff->raw_syments = (struct coff_ptr_struct *) NULL; |
| coff->relocbase = 0; |
| coff->local_toc_sym_map = 0; |
| |
| /* make_abs_section(abfd);*/ |
| |
| return true; |
| } |
| #endif |
| |
| /* Create the COFF backend specific information. */ |
| #ifndef coff_mkobject_hook |
| static PTR |
| coff_mkobject_hook (abfd, filehdr, aouthdr) |
| bfd * abfd; |
| PTR filehdr; |
| PTR aouthdr ATTRIBUTE_UNUSED; |
| { |
| struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; |
| coff_data_type *coff; |
| |
| if (coff_mkobject (abfd) == false) |
| return NULL; |
| |
| coff = coff_data (abfd); |
| |
| coff->sym_filepos = internal_f->f_symptr; |
| |
| /* These members communicate important constants about the symbol |
| table to GDB's symbol-reading code. These `constants' |
| unfortunately vary among coff implementations... */ |
| coff->local_n_btmask = N_BTMASK; |
| coff->local_n_btshft = N_BTSHFT; |
| coff->local_n_tmask = N_TMASK; |
| coff->local_n_tshift = N_TSHIFT; |
| coff->local_symesz = bfd_coff_symesz (abfd); |
| coff->local_auxesz = bfd_coff_auxesz (abfd); |
| coff->local_linesz = bfd_coff_linesz (abfd); |
| |
| coff->timestamp = internal_f->f_timdat; |
| |
| obj_raw_syment_count (abfd) = |
| obj_conv_table_size (abfd) = |
| internal_f->f_nsyms; |
| |
| #ifdef RS6000COFF_C |
| if ((internal_f->f_flags & F_SHROBJ) != 0) |
| abfd->flags |= DYNAMIC; |
| if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd)) |
| { |
| struct internal_aouthdr *internal_a = |
| (struct internal_aouthdr *) aouthdr; |
| struct xcoff_tdata *xcoff; |
| |
| xcoff = xcoff_data (abfd); |
| # ifdef U803XTOCMAGIC |
| xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC; |
| # else |
| xcoff->xcoff64 = 0; |
| # endif |
| xcoff->full_aouthdr = true; |
| xcoff->toc = internal_a->o_toc; |
| xcoff->sntoc = internal_a->o_sntoc; |
| xcoff->snentry = internal_a->o_snentry; |
| xcoff->text_align_power = internal_a->o_algntext; |
| xcoff->data_align_power = internal_a->o_algndata; |
| xcoff->modtype = internal_a->o_modtype; |
| xcoff->cputype = internal_a->o_cputype; |
| xcoff->maxdata = internal_a->o_maxdata; |
| xcoff->maxstack = internal_a->o_maxstack; |
| } |
| #endif |
| |
| #ifdef ARM |
| /* Set the flags field from the COFF header read in */ |
| if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) |
| coff->flags = 0; |
| #endif |
| |
| #ifdef COFF_WITH_PE |
| /* FIXME: I'm not sure this is ever executed, since peicode.h |
| defines coff_mkobject_hook. */ |
| if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) |
| abfd->flags |= HAS_DEBUG; |
| #endif |
| |
| return (PTR) coff; |
| } |
| #endif |
| |
| /* Determine the machine architecture and type. FIXME: This is target |
| dependent because the magic numbers are defined in the target |
| dependent header files. But there is no particular need for this. |
| If the magic numbers were moved to a separate file, this function |
| would be target independent and would also be much more successful |
| at linking together COFF files for different architectures. */ |
| |
| static boolean |
| coff_set_arch_mach_hook (abfd, filehdr) |
| bfd *abfd; |
| PTR filehdr; |
| { |
| long machine; |
| enum bfd_architecture arch; |
| struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; |
| |
| machine = 0; |
| switch (internal_f->f_magic) |
| { |
| #ifdef PPCMAGIC |
| case PPCMAGIC: |
| arch = bfd_arch_powerpc; |
| machine = 0; /* what does this mean? (krk) */ |
| break; |
| #endif |
| #ifdef I386MAGIC |
| case I386MAGIC: |
| case I386PTXMAGIC: |
| case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */ |
| case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */ |
| arch = bfd_arch_i386; |
| machine = 0; |
| break; |
| #endif |
| #ifdef IA64MAGIC |
| case IA64MAGIC: |
| arch = bfd_arch_ia64; |
| machine = 0; |
| break; |
| #endif |
| #ifdef A29K_MAGIC_BIG |
| case A29K_MAGIC_BIG: |
| case A29K_MAGIC_LITTLE: |
| arch = bfd_arch_a29k; |
| machine = 0; |
| break; |
| #endif |
| #ifdef ARMMAGIC |
| case ARMMAGIC: |
| case ARMPEMAGIC: |
| case THUMBPEMAGIC: |
| arch = bfd_arch_arm; |
| switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK) |
| { |
| case F_ARM_2: machine = bfd_mach_arm_2; break; |
| case F_ARM_2a: machine = bfd_mach_arm_2a; break; |
| case F_ARM_3: machine = bfd_mach_arm_3; break; |
| default: |
| case F_ARM_3M: machine = bfd_mach_arm_3M; break; |
| case F_ARM_4: machine = bfd_mach_arm_4; break; |
| case F_ARM_4T: machine = bfd_mach_arm_4T; break; |
| case F_ARM_5: machine = bfd_mach_arm_5; break; |
| } |
| break; |
| #endif |
| #ifdef MC68MAGIC |
| case MC68MAGIC: |
| case M68MAGIC: |
| #ifdef MC68KBCSMAGIC |
| case MC68KBCSMAGIC: |
| #endif |
| #ifdef APOLLOM68KMAGIC |
| case APOLLOM68KMAGIC: |
| #endif |
| #ifdef LYNXCOFFMAGIC |
| case LYNXCOFFMAGIC: |
| #endif |
| arch = bfd_arch_m68k; |
| machine = bfd_mach_m68020; |
| break; |
| #endif |
| #ifdef MC88MAGIC |
| case MC88MAGIC: |
| case MC88DMAGIC: |
| case MC88OMAGIC: |
| arch = bfd_arch_m88k; |
| machine = 88100; |
| break; |
| #endif |
| #ifdef Z8KMAGIC |
| case Z8KMAGIC: |
| arch = bfd_arch_z8k; |
| switch (internal_f->f_flags & F_MACHMASK) |
| { |
| case F_Z8001: |
| machine = bfd_mach_z8001; |
| break; |
| case F_Z8002: |
| machine = bfd_mach_z8002; |
| break; |
| default: |
| return false; |
| } |
| break; |
| #endif |
| #ifdef I860 |
| case I860MAGIC: |
| arch = bfd_arch_i860; |
| break; |
| #endif |
| #ifdef I960 |
| #ifdef I960ROMAGIC |
| case I960ROMAGIC: |
| case I960RWMAGIC: |
| arch = bfd_arch_i960; |
| switch (F_I960TYPE & internal_f->f_flags) |
| { |
| default: |
| case F_I960CORE: |
| machine = bfd_mach_i960_core; |
| break; |
| case F_I960KB: |
| machine = bfd_mach_i960_kb_sb; |
| break; |
| case F_I960MC: |
| machine = bfd_mach_i960_mc; |
| break; |
| case F_I960XA: |
| machine = bfd_mach_i960_xa; |
| break; |
| case F_I960CA: |
| machine = bfd_mach_i960_ca; |
| break; |
| case F_I960KA: |
| machine = bfd_mach_i960_ka_sa; |
| break; |
| case F_I960JX: |
| machine = bfd_mach_i960_jx; |
| break; |
| case F_I960HX: |
| machine = bfd_mach_i960_hx; |
| break; |
| } |
| break; |
| #endif |
| #endif |
| |
| #ifdef RS6000COFF_C |
| #ifdef XCOFF64 |
| case U803XTOCMAGIC: |
| #else |
| case U802ROMAGIC: |
| case U802WRMAGIC: |
| case U802TOCMAGIC: |
| #endif |
| { |
| int cputype; |
| |
| if (xcoff_data (abfd)->cputype != -1) |
| cputype = xcoff_data (abfd)->cputype & 0xff; |
| else |
| { |
| /* We did not get a value from the a.out header. If the |
| file has not been stripped, we may be able to get the |
| architecture information from the first symbol, if it |
| is a .file symbol. */ |
| if (obj_raw_syment_count (abfd) == 0) |
| cputype = 0; |
| else |
| { |
| bfd_byte *buf; |
| struct internal_syment sym; |
| |
| buf = (bfd_byte *) bfd_malloc (bfd_coff_symesz (abfd)); |
| if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 |
| || (bfd_read (buf, 1, bfd_coff_symesz (abfd), abfd) |
| != bfd_coff_symesz (abfd))) |
| { |
| free (buf); |
| return false; |
| } |
| bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym); |
| if (sym.n_sclass == C_FILE) |
| cputype = sym.n_type & 0xff; |
| else |
| cputype = 0; |
| free (buf); |
| } |
| } |
| |
| /* FIXME: We don't handle all cases here. */ |
| switch (cputype) |
| { |
| default: |
| case 0: |
| #ifdef POWERMAC |
| /* PowerPC Macs use the same magic numbers as RS/6000 |
| (because that's how they were bootstrapped originally), |
| but they are always PowerPC architecture. */ |
| arch = bfd_arch_powerpc; |
| machine = bfd_mach_ppc; |
| #else |
| #ifdef XCOFF64 |
| arch = bfd_arch_powerpc; |
| machine = bfd_mach_ppc_620; |
| #else |
| arch = bfd_arch_rs6000; |
| machine = bfd_mach_rs6k; |
| #endif |
| #endif /* POWERMAC */ |
| break; |
| |
| case 1: |
| arch = bfd_arch_powerpc; |
| machine = bfd_mach_ppc_601; |
| break; |
| case 2: /* 64 bit PowerPC */ |
| arch = bfd_arch_powerpc; |
| machine = bfd_mach_ppc_620; |
| break; |
| case 3: |
| arch = bfd_arch_powerpc; |
| machine = bfd_mach_ppc; |
| break; |
| case 4: |
| arch = bfd_arch_rs6000; |
| machine = bfd_mach_rs6k; |
| break; |
| } |
| } |
| break; |
| #endif |
| |
| #ifdef WE32KMAGIC |
| case WE32KMAGIC: |
| arch = bfd_arch_we32k; |
| machine = 0; |
| break; |
| #endif |
| |
| #ifdef H8300MAGIC |
| case H8300MAGIC: |
| arch = bfd_arch_h8300; |
| machine = bfd_mach_h8300; |
| /* !! FIXME this probably isn't the right place for this */ |
| abfd->flags |= BFD_IS_RELAXABLE; |
| break; |
| #endif |
| |
| #ifdef H8300HMAGIC |
| case H8300HMAGIC: |
| arch = bfd_arch_h8300; |
| machine = bfd_mach_h8300h; |
| /* !! FIXME this probably isn't the right place for this */ |
| abfd->flags |= BFD_IS_RELAXABLE; |
| break; |
| #endif |
| |
| #ifdef H8300SMAGIC |
| case H8300SMAGIC: |
| arch = bfd_arch_h8300; |
| machine = bfd_mach_h8300s; |
| /* !! FIXME this probably isn't the right place for this */ |
| abfd->flags |= BFD_IS_RELAXABLE; |
| break; |
| #endif |
| |
| #ifdef SH_ARCH_MAGIC_BIG |
| case SH_ARCH_MAGIC_BIG: |
| case SH_ARCH_MAGIC_LITTLE: |
| #ifdef COFF_WITH_PE |
| case SH_ARCH_MAGIC_WINCE: |
| #endif |
| arch = bfd_arch_sh; |
| machine = 0; |
| break; |
| #endif |
| |
| #ifdef MIPS_ARCH_MAGIC_WINCE |
| case MIPS_ARCH_MAGIC_WINCE: |
| arch = bfd_arch_mips; |
| machine = 0; |
| break; |
| #endif |
| |
| #ifdef H8500MAGIC |
| case H8500MAGIC: |
| arch = bfd_arch_h8500; |
| machine = 0; |
| break; |
| #endif |
| |
| #ifdef SPARCMAGIC |
| case SPARCMAGIC: |
| #ifdef LYNXCOFFMAGIC |
| case LYNXCOFFMAGIC: |
| #endif |
| arch = bfd_arch_sparc; |
| machine = 0; |
| break; |
| #endif |
| |
| #ifdef TIC30MAGIC |
| case TIC30MAGIC: |
| arch = bfd_arch_tic30; |
| break; |
| #endif |
| |
| #ifdef TICOFF0MAGIC |
| #ifdef TICOFF_TARGET_ARCH |
| /* this TI COFF section should be used by all new TI COFF v0 targets */ |
| case TICOFF0MAGIC: |
| arch = TICOFF_TARGET_ARCH; |
| break; |
| #endif |
| #endif |
| |
| #ifdef TICOFF1MAGIC |
| /* this TI COFF section should be used by all new TI COFF v1/2 targets */ |
| /* TI COFF1 and COFF2 use the target_id field to specify which arch */ |
| case TICOFF1MAGIC: |
| case TICOFF2MAGIC: |
| switch (internal_f->f_target_id) |
| { |
| #ifdef TI_TARGET_ID |
| case TI_TARGET_ID: |
| arch = TICOFF_TARGET_ARCH; |
| break; |
| #endif |
| default: |
| arch = bfd_arch_obscure; |
| (*_bfd_error_handler) |
| (_("Unrecognized TI COFF target id '0x%x'"), |
| internal_f->f_target_id); |
| break; |
| } |
| break; |
| #endif |
| |
| #ifdef TIC80_ARCH_MAGIC |
| case TIC80_ARCH_MAGIC: |
| arch = bfd_arch_tic80; |
| break; |
| #endif |
| |
| #ifdef MCOREMAGIC |
| case MCOREMAGIC: |
| arch = bfd_arch_mcore; |
| break; |
| #endif |
| default: /* Unreadable input file type */ |
| arch = bfd_arch_obscure; |
| break; |
| } |
| |
| bfd_default_set_arch_mach (abfd, arch, machine); |
| return true; |
| } |
| |
| #ifdef SYMNAME_IN_DEBUG |
| |
| static boolean symname_in_debug_hook |
| PARAMS ((bfd *, struct internal_syment *)); |
| |
| static boolean |
| symname_in_debug_hook (abfd, sym) |
| bfd * abfd ATTRIBUTE_UNUSED; |
| struct internal_syment *sym; |
| { |
| return SYMNAME_IN_DEBUG (sym) ? true : false; |
| } |
| |
| #else |
| |
| #define symname_in_debug_hook \ |
| (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false |
| |
| #endif |
| |
| #ifdef RS6000COFF_C |
| |
| #ifdef XCOFF64 |
| #define FORCE_SYMNAMES_IN_STRINGS |
| #endif |
| |
| /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */ |
| |
| static boolean coff_pointerize_aux_hook |
| PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, |
| unsigned int, combined_entry_type *)); |
| |
| /*ARGSUSED*/ |
| static boolean |
| coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| combined_entry_type *table_base; |
| combined_entry_type *symbol; |
| unsigned int indaux; |
| combined_entry_type *aux; |
| { |
| int class = symbol->u.syment.n_sclass; |
| |
| if ((class == C_EXT || class == C_HIDEXT) |
| && indaux + 1 == symbol->u.syment.n_numaux) |
| { |
| if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD) |
| { |
| aux->u.auxent.x_csect.x_scnlen.p = |
| table_base + aux->u.auxent.x_csect.x_scnlen.l; |
| aux->fix_scnlen = 1; |
| } |
| |
| /* Return true to indicate that the caller should not do any |
| further work on this auxent. */ |
| return true; |
| } |
| |
| /* Return false to indicate that this auxent should be handled by |
| the caller. */ |
| return false; |
| } |
| |
| #else |
| #ifdef I960 |
| |
| /* We don't want to pointerize bal entries. */ |
| |
| static boolean coff_pointerize_aux_hook |
| PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, |
| unsigned int, combined_entry_type *)); |
| |
| /*ARGSUSED*/ |
| static boolean |
| coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| combined_entry_type *table_base ATTRIBUTE_UNUSED; |
| combined_entry_type *symbol; |
| unsigned int indaux; |
| combined_entry_type *aux ATTRIBUTE_UNUSED; |
| { |
| /* Return true if we don't want to pointerize this aux entry, which |
| is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */ |
| return (indaux == 1 |
| && (symbol->u.syment.n_sclass == C_LEAFPROC |
| || symbol->u.syment.n_sclass == C_LEAFSTAT |
| || symbol->u.syment.n_sclass == C_LEAFEXT)); |
| } |
| |
| #else /* ! I960 */ |
| |
| #define coff_pointerize_aux_hook 0 |
| |
| #endif /* ! I960 */ |
| #endif /* ! RS6000COFF_C */ |
| |
| /* Print an aux entry. This returns true if it has printed it. */ |
| |
| static boolean coff_print_aux |
| PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *, |
| combined_entry_type *, unsigned int)); |
| |
| static boolean |
| coff_print_aux (abfd, file, table_base, symbol, aux, indaux) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| FILE *file ATTRIBUTE_UNUSED; |
| combined_entry_type *table_base ATTRIBUTE_UNUSED; |
| combined_entry_type *symbol ATTRIBUTE_UNUSED; |
| combined_entry_type *aux ATTRIBUTE_UNUSED; |
| unsigned int indaux ATTRIBUTE_UNUSED; |
| { |
| #ifdef RS6000COFF_C |
| if ((symbol->u.syment.n_sclass == C_EXT |
| || symbol->u.syment.n_sclass == C_HIDEXT) |
| && indaux + 1 == symbol->u.syment.n_numaux) |
| { |
| /* This is a csect entry. */ |
| fprintf (file, "AUX "); |
| if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD) |
| { |
| BFD_ASSERT (! aux->fix_scnlen); |
| fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l); |
| } |
| else |
| { |
| fprintf (file, "indx "); |
| if (! aux->fix_scnlen) |
| fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l); |
| else |
| fprintf (file, "%4ld", |
| (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base)); |
| } |
| fprintf (file, |
| " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u", |
| aux->u.auxent.x_csect.x_parmhash, |
| (unsigned int) aux->u.auxent.x_csect.x_snhash, |
| SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp), |
| SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp), |
| (unsigned int) aux->u.auxent.x_csect.x_smclas, |
| aux->u.auxent.x_csect.x_stab, |
| (unsigned int) aux->u.auxent.x_csect.x_snstab); |
| return true; |
| } |
| #endif |
| |
| /* Return false to indicate that no special action was taken. */ |
| return false; |
| } |
| |
| /* |
| SUBSUBSECTION |
| Writing relocations |
| |
| To write relocations, the back end steps though the |
| canonical relocation table and create an |
| @code{internal_reloc}. The symbol index to use is removed from |
| the @code{offset} field in the symbol table supplied. The |
| address comes directly from the sum of the section base |
| address and the relocation offset; the type is dug directly |
| from the howto field. Then the @code{internal_reloc} is |
| swapped into the shape of an @code{external_reloc} and written |
| out to disk. |
| |
| */ |
| |
| #ifdef TARG_AUX |
| |
| static int compare_arelent_ptr PARAMS ((const PTR, const PTR)); |
| |
| /* AUX's ld wants relocations to be sorted */ |
| static int |
| compare_arelent_ptr (x, y) |
| const PTR x; |
| const PTR y; |
| { |
| const arelent **a = (const arelent **) x; |
| const arelent **b = (const arelent **) y; |
| bfd_size_type aadr = (*a)->address; |
| bfd_size_type badr = (*b)->address; |
| |
| return (aadr < badr ? -1 : badr < aadr ? 1 : 0); |
| } |
| |
| #endif /* TARG_AUX */ |
| |
| static boolean |
| coff_write_relocs (abfd, first_undef) |
| bfd * abfd; |
| int first_undef; |
| { |
| asection *s; |
| |
| for (s = abfd->sections; s != (asection *) NULL; s = s->next) |
| { |
| unsigned int i; |
| struct external_reloc dst; |
| arelent **p; |
| |
| #ifndef TARG_AUX |
| p = s->orelocation; |
| #else |
| /* sort relocations before we write them out */ |
| p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *)); |
| if (p == NULL && s->reloc_count > 0) |
| return false; |
| memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *)); |
| qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr); |
| #endif |
| |
| if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0) |
| return false; |
| |
| #ifdef COFF_WITH_PE |
| if (s->reloc_count > 0xffff) |
| { |
| /* encode real count here as first reloc */ |
| struct internal_reloc n; |
| memset ((PTR) & n, 0, sizeof (n)); |
| /* add one to count *this* reloc (grr) */ |
| n.r_vaddr = s->reloc_count + 1; |
| coff_swap_reloc_out (abfd, &n, &dst); |
| if (bfd_write ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd) |
| != bfd_coff_relsz (abfd)) |
| return false; |
| } |
| #endif |
| |
| for (i = 0; i < s->reloc_count; i++) |
| { |
| struct internal_reloc n; |
| arelent *q = p[i]; |
| memset ((PTR) & n, 0, sizeof (n)); |
| |
| /* Now we've renumbered the symbols we know where the |
| undefined symbols live in the table. Check the reloc |
| entries for symbols who's output bfd isn't the right one. |
| This is because the symbol was undefined (which means |
| that all the pointers are never made to point to the same |
| place). This is a bad thing,'cause the symbols attached |
| to the output bfd are indexed, so that the relocation |
| entries know which symbol index they point to. So we |
| have to look up the output symbol here. */ |
| |
| if (q->sym_ptr_ptr[0]->the_bfd != abfd) |
| { |
| int i; |
| const char *sname = q->sym_ptr_ptr[0]->name; |
| asymbol **outsyms = abfd->outsymbols; |
| for (i = first_undef; outsyms[i]; i++) |
| { |
| const char *intable = outsyms[i]->name; |
| if (strcmp (intable, sname) == 0) { |
| /* got a hit, so repoint the reloc */ |
| q->sym_ptr_ptr = outsyms + i; |
| break; |
| } |
| } |
| } |
| |
| n.r_vaddr = q->address + s->vma; |
| |
| #ifdef R_IHCONST |
| /* The 29k const/consth reloc pair is a real kludge. The consth |
| part doesn't have a symbol; it has an offset. So rebuilt |
| that here. */ |
| if (q->howto->type == R_IHCONST) |
| n.r_symndx = q->addend; |
| else |
| #endif |
| if (q->sym_ptr_ptr) |
| { |
| #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P |
| if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s)) |
| #else |
| if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr) |
| #endif |
| /* This is a relocation relative to the absolute symbol. */ |
| n.r_symndx = -1; |
| else |
| { |
| n.r_symndx = get_index ((*(q->sym_ptr_ptr))); |
| /* Take notice if the symbol reloc points to a symbol |
| we don't have in our symbol table. What should we |
| do for this?? */ |
| if (n.r_symndx > obj_conv_table_size (abfd)) |
| abort (); |
| } |
| } |
| |
| #ifdef SWAP_OUT_RELOC_OFFSET |
| n.r_offset = q->addend; |
| #endif |
| |
| #ifdef SELECT_RELOC |
| /* Work out reloc type from what is required */ |
| SELECT_RELOC (n, q->howto); |
| #else |
| n.r_type = q->howto->type; |
| #endif |
| coff_swap_reloc_out (abfd, &n, &dst); |
| if (bfd_write ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd) |
| != bfd_coff_relsz (abfd)) |
| return false; |
| } |
| |
| #ifdef TARG_AUX |
| if (p != NULL) |
| free (p); |
| #endif |
| } |
| |
| return true; |
| } |
| |
| /* Set flags and magic number of a coff file from architecture and machine |
| type. Result is true if we can represent the arch&type, false if not. */ |
| |
| static boolean |
| coff_set_flags (abfd, magicp, flagsp) |
| bfd * abfd; |
| unsigned int *magicp ATTRIBUTE_UNUSED; |
| unsigned short *flagsp ATTRIBUTE_UNUSED; |
| { |
| switch (bfd_get_arch (abfd)) |
| { |
| #ifdef Z8KMAGIC |
| case bfd_arch_z8k: |
| *magicp = Z8KMAGIC; |
| switch (bfd_get_mach (abfd)) |
| { |
| case bfd_mach_z8001: |
| *flagsp = F_Z8001; |
| break; |
| case bfd_mach_z8002: |
| *flagsp = F_Z8002; |
| break; |
| default: |
| return false; |
| } |
| return true; |
| #endif |
| #ifdef I960ROMAGIC |
| |
| case bfd_arch_i960: |
| |
| { |
| unsigned flags; |
| *magicp = I960ROMAGIC; |
| /* |
| ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC : |
| I960RWMAGIC); FIXME??? |
| */ |
| switch (bfd_get_mach (abfd)) |
| { |
| case bfd_mach_i960_core: |
| flags = F_I960CORE; |
| break; |
| case bfd_mach_i960_kb_sb: |
| flags = F_I960KB; |
| break; |
| case bfd_mach_i960_mc: |
| flags = F_I960MC; |
| break; |
| case bfd_mach_i960_xa: |
| flags = F_I960XA; |
| break; |
| case bfd_mach_i960_ca: |
| flags = F_I960CA; |
| break; |
| case bfd_mach_i960_ka_sa: |
| flags = F_I960KA; |
| break; |
| case bfd_mach_i960_jx: |
| flags = F_I960JX; |
| break; |
| case bfd_mach_i960_hx: |
| flags = F_I960HX; |
| break; |
| default: |
| return false; |
| } |
| *flagsp = flags; |
| return true; |
| } |
| break; |
| #endif |
| |
| #ifdef TIC30MAGIC |
| case bfd_arch_tic30: |
| *magicp = TIC30MAGIC; |
| return true; |
| #endif |
| |
| #ifdef TICOFF_DEFAULT_MAGIC |
| case TICOFF_TARGET_ARCH: |
| /* if there's no indication of which version we want, use the default */ |
| if (!abfd->xvec ) |
| *magicp = TICOFF_DEFAULT_MAGIC; |
| else |
| { |
| /* we may want to output in a different COFF version */ |
| switch (abfd->xvec->name[4]) |
| { |
| case '0': |
| *magicp = TICOFF0MAGIC; |
| break; |
| case '1': |
| *magicp = TICOFF1MAGIC; |
| break; |
| case '2': |
| *magicp = TICOFF2MAGIC; |
| break; |
| default: |
| return false; |
| } |
| } |
| return true; |
| #endif |
| |
| #ifdef TIC80_ARCH_MAGIC |
| case bfd_arch_tic80: |
| *magicp = TIC80_ARCH_MAGIC; |
| return true; |
| #endif |
| #ifdef ARMMAGIC |
| case bfd_arch_arm: |
| #ifdef ARM_WINCE |
| * magicp = ARMPEMAGIC; |
| #else |
| * magicp = ARMMAGIC; |
| #endif |
| * flagsp = 0; |
| if (APCS_SET (abfd)) |
| { |
| if (APCS_26_FLAG (abfd)) |
| * flagsp |= F_APCS26; |
| |
| if (APCS_FLOAT_FLAG (abfd)) |
| * flagsp |= F_APCS_FLOAT; |
| |
| if (PIC_FLAG (abfd)) |
| * flagsp |= F_PIC; |
| } |
| if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd)) |
| * flagsp |= F_INTERWORK; |
| switch (bfd_get_mach (abfd)) |
| { |
| case bfd_mach_arm_2: * flagsp |= F_ARM_2; break; |
| case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break; |
| case bfd_mach_arm_3: * flagsp |= F_ARM_3; break; |
| case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break; |
| case bfd_mach_arm_4: * flagsp |= F_ARM_4; break; |
| case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break; |
| case bfd_mach_arm_5: * flagsp |= F_ARM_5; break; |
| /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. */ |
| case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; |
| case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break; |
| case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break; |
| } |
| return true; |
| #endif |
| #ifdef PPCMAGIC |
| case bfd_arch_powerpc: |
| *magicp = PPCMAGIC; |
| return true; |
| break; |
| #endif |
| #ifdef I386MAGIC |
| case bfd_arch_i386: |
| *magicp = I386MAGIC; |
| #ifdef LYNXOS |
| /* Just overwrite the usual value if we're doing Lynx. */ |
| *magicp = LYNXCOFFMAGIC; |
| #endif |
| return true; |
| break; |
| #endif |
| #ifdef I860MAGIC |
| case bfd_arch_i860: |
| *magicp = I860MAGIC; |
| return true; |
| break; |
| #endif |
| #ifdef IA64MAGIC |
| case bfd_arch_ia64: |
| *magicp = IA64MAGIC; |
| return true; |
| break; |
| #endif |
| #ifdef MC68MAGIC |
| case bfd_arch_m68k: |
| #ifdef APOLLOM68KMAGIC |
| *magicp = APOLLO_COFF_VERSION_NUMBER; |
| #else |
| /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */ |
| #ifdef NAMES_HAVE_UNDERSCORE |
| *magicp = MC68KBCSMAGIC; |
| #else |
| *magicp = MC68MAGIC; |
| #endif |
| #endif |
| #ifdef LYNXOS |
| /* Just overwrite the usual value if we're doing Lynx. */ |
| *magicp = LYNXCOFFMAGIC; |
| #endif |
| return true; |
| break; |
| #endif |
| |
| #ifdef MC88MAGIC |
| case bfd_arch_m88k: |
| *magicp = MC88OMAGIC; |
| return true; |
| break; |
| #endif |
| #ifdef H8300MAGIC |
| case bfd_arch_h8300: |
| switch (bfd_get_mach (abfd)) |
| { |
| case bfd_mach_h8300: |
| *magicp = H8300MAGIC; |
| return true; |
| case bfd_mach_h8300h: |
| *magicp = H8300HMAGIC; |
| return true; |
| case bfd_mach_h8300s: |
| *magicp = H8300SMAGIC; |
| return true; |
| } |
| break; |
| #endif |
| |
| #ifdef SH_ARCH_MAGIC_BIG |
| case bfd_arch_sh: |
| #ifdef COFF_IMAGE_WITH_PE |
| *magicp = SH_ARCH_MAGIC_WINCE; |
| #else |
| if (bfd_big_endian (abfd)) |
| *magicp = SH_ARCH_MAGIC_BIG; |
| else |
| *magicp = SH_ARCH_MAGIC_LITTLE; |
| #endif |
| return true; |
| break; |
| #endif |
| |
| #ifdef MIPS_ARCH_MAGIC_WINCE |
| case bfd_arch_mips: |
| *magicp = MIPS_ARCH_MAGIC_WINCE; |
| return true; |
| break; |
| #endif |
| |
| #ifdef SPARCMAGIC |
| case bfd_arch_sparc: |
| *magicp = SPARCMAGIC; |
| #ifdef LYNXOS |
| /* Just overwrite the usual value if we're doing Lynx. */ |
| *magicp = LYNXCOFFMAGIC; |
| #endif |
| return true; |
| break; |
| #endif |
| |
| #ifdef H8500MAGIC |
| case bfd_arch_h8500: |
| *magicp = H8500MAGIC; |
| return true; |
| break; |
| #endif |
| #ifdef A29K_MAGIC_BIG |
| case bfd_arch_a29k: |
| if (bfd_big_endian (abfd)) |
| *magicp = A29K_MAGIC_BIG; |
| else |
| *magicp = A29K_MAGIC_LITTLE; |
| return true; |
| break; |
| #endif |
| |
| #ifdef WE32KMAGIC |
| case bfd_arch_we32k: |
| *magicp = WE32KMAGIC; |
| return true; |
| break; |
| #endif |
| |
| #ifdef RS6000COFF_C |
| case bfd_arch_rs6000: |
| #ifndef PPCMAGIC |
| case bfd_arch_powerpc: |
| #endif |
| #ifdef XCOFF64 |
| if (bfd_get_mach (abfd) == bfd_mach_ppc_620 |
| && !strncmp (abfd->xvec->name,"aix", 3)) |
| *magicp = U803XTOCMAGIC; |
| else |
| #else |
| *magicp = U802TOCMAGIC; |
| #endif |
| return true; |
| break; |
| #endif |
| |
| #ifdef MCOREMAGIC |
| case bfd_arch_mcore: |
| * magicp = MCOREMAGIC; |
| return true; |
| #endif |
| |
| #ifdef W65MAGIC |
| case bfd_arch_w65: |
| *magicp = W65MAGIC; |
| return true; |
| #endif |
| |
| default: /* Unknown architecture. */ |
| /* Fall through to "return false" below, to avoid |
| "statement never reached" errors on the one below. */ |
| break; |
| } |
| |
| return false; |
| } |
| |
| static boolean |
| coff_set_arch_mach (abfd, arch, machine) |
| bfd * abfd; |
| enum bfd_architecture arch; |
| unsigned long machine; |
| { |
| unsigned dummy1; |
| unsigned short dummy2; |
| |
| if (! bfd_default_set_arch_mach (abfd, arch, machine)) |
| return false; |
| |
| if (arch != bfd_arch_unknown && |
| coff_set_flags (abfd, &dummy1, &dummy2) != true) |
| return false; /* We can't represent this type */ |
| |
| return true; /* We're easy ... */ |
| } |
| |
| #ifdef COFF_IMAGE_WITH_PE |
| |
| /* This is used to sort sections by VMA, as required by PE image |
| files. */ |
| |
| static int sort_by_secaddr PARAMS ((const PTR, const PTR)); |
| |
| static int |
| sort_by_secaddr (arg1, arg2) |
| const PTR arg1; |
| const PTR arg2; |
| { |
| const asection *a = *(const asection **) arg1; |
| const asection *b = *(const asection **) arg2; |
| |
| if (a->vma < b->vma) |
| return -1; |
| else if (a->vma > b->vma) |
| return 1; |
| else |
| return 0; |
| } |
| |
| #endif /* COFF_IMAGE_WITH_PE */ |
| |
| /* Calculate the file position for each section. */ |
| |
| #ifndef I960 |
| #define ALIGN_SECTIONS_IN_FILE |
| #endif |
| #if defined(TIC80COFF) || defined(TICOFF) |
| #undef ALIGN_SECTIONS_IN_FILE |
| #endif |
| |
| static boolean |
| coff_compute_section_file_positions (abfd) |
| bfd * abfd; |
| { |
| asection *current; |
| asection *previous = (asection *) NULL; |
| file_ptr sofar = bfd_coff_filhsz (abfd); |
| boolean align_adjust; |
| #ifdef ALIGN_SECTIONS_IN_FILE |
| file_ptr old_sofar; |
| #endif |
| |
| #ifdef RS6000COFF_C |
| /* On XCOFF, if we have symbols, set up the .debug section. */ |
| if (bfd_get_symcount (abfd) > 0) |
| { |
| bfd_size_type sz; |
| bfd_size_type i, symcount; |
| asymbol **symp; |
| |
| sz = 0; |
| symcount = bfd_get_symcount (abfd); |
| for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++) |
| { |
| coff_symbol_type *cf; |
| |
| cf = coff_symbol_from (abfd, *symp); |
| if (cf != NULL |
| && cf->native != NULL |
| && SYMNAME_IN_DEBUG (&cf->native->u.syment)) |
| { |
| size_t len; |
| |
| len = strlen (bfd_asymbol_name (*symp)); |
| if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd)) |
| sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd); |
| } |
| } |
| if (sz > 0) |
| { |
| asection *dsec; |
| |
| dsec = bfd_make_section_old_way (abfd, ".debug"); |
| if (dsec == NULL) |
| abort (); |
| dsec->_raw_size = sz; |
| dsec->flags |= SEC_HAS_CONTENTS; |
| } |
| } |
| #endif |
| |
| #ifdef COFF_IMAGE_WITH_PE |
| int page_size; |
| if (coff_data (abfd)->link_info) |
| { |
| page_size = pe_data (abfd)->pe_opthdr.FileAlignment; |
| } |
| else |
| page_size = PE_DEF_FILE_ALIGNMENT; |
| #else |
| #ifdef COFF_PAGE_SIZE |
| int page_size = COFF_PAGE_SIZE; |
| #endif |
| #endif |
| |
| if (bfd_get_start_address (abfd)) |
| { |
| /* A start address may have been added to the original file. In this |
| case it will need an optional header to record it. */ |
| abfd->flags |= EXEC_P; |
| } |
| |
| if (abfd->flags & EXEC_P) |
| sofar += bfd_coff_aoutsz (abfd); |
| #ifdef RS6000COFF_C |
| else if (xcoff_data (abfd)->full_aouthdr) |
| sofar += bfd_coff_aoutsz (abfd); |
| else |
| sofar += SMALL_AOUTSZ; |
| #endif |
| |
| sofar += abfd->section_count * bfd_coff_scnhsz (abfd); |
| |
| #ifdef RS6000COFF_C |
| /* XCOFF handles overflows in the reloc and line number count fields |
| by allocating a new section header to hold the correct counts. */ |
| for (current = abfd->sections; current != NULL; current = current->next) |
| if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) |
| sofar += bfd_coff_scnhsz (abfd); |
| #endif |
| |
| #ifdef COFF_IMAGE_WITH_PE |
| { |
| /* PE requires the sections to be in memory order when listed in |
| the section headers. It also does not like empty loadable |
| sections. The sections apparently do not have to be in the |
| right order in the image file itself, but we do need to get the |
| target_index values right. */ |
| |
| int count; |
| asection **section_list; |
| int i; |
| int target_index; |
| |
| count = 0; |
| for (current = abfd->sections; current != NULL; current = current->next) |
| ++count; |
| |
| /* We allocate an extra cell to simplify the final loop. */ |
| section_list = bfd_malloc (sizeof (struct asection *) * (count + 1)); |
| if (section_list == NULL) |
| return false; |
| |
| i = 0; |
| for (current = abfd->sections; current != NULL; current = current->next) |
| { |
| section_list[i] = current; |
| ++i; |
| } |
| section_list[i] = NULL; |
| |
| qsort (section_list, count, sizeof (asection *), sort_by_secaddr); |
| |
| /* Rethread the linked list into sorted order; at the same time, |
| assign target_index values. */ |
| target_index = 1; |
| abfd->sections = section_list[0]; |
| for (i = 0; i < count; i++) |
| { |
| current = section_list[i]; |
| current->next = section_list[i + 1]; |
| |
| /* Later, if the section has zero size, we'll be throwing it |
| away, so we don't want to number it now. Note that having |
| a zero size and having real contents are different |
| concepts: .bss has no contents, but (usually) non-zero |
| size. */ |
| if (current->_raw_size == 0) |
| { |
| /* Discard. However, it still might have (valid) symbols |
| in it, so arbitrarily set it to section 1 (indexing is |
| 1-based here; usually .text). __end__ and other |
| contents of .endsection really have this happen. |
| FIXME: This seems somewhat dubious. */ |
| current->target_index = 1; |
| } |
| else |
| current->target_index = target_index++; |
| } |
| |
| free (section_list); |
| } |
| #else /* ! COFF_IMAGE_WITH_PE */ |
| { |
| /* Set the target_index field. */ |
| int target_index; |
| |
| target_index = 1; |
| for (current = abfd->sections; current != NULL; current = current->next) |
| current->target_index = target_index++; |
| } |
| #endif /* ! COFF_IMAGE_WITH_PE */ |
| |
| align_adjust = false; |
| for (current = abfd->sections; |
| current != (asection *) NULL; |
| current = current->next) |
| { |
| #ifdef COFF_IMAGE_WITH_PE |
| /* With PE we have to pad each section to be a multiple of its |
| page size too, and remember both sizes. */ |
| if (coff_section_data (abfd, current) == NULL) |
| { |
| current->used_by_bfd = |
| (PTR) bfd_zalloc (abfd, sizeof (struct |