| /* bfd back-end for HP PA-RISC SOM objects. |
| Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, |
| 2000, 2001 |
| Free Software Foundation, Inc. |
| |
| Contributed by the Center for Software Science at the |
| University of Utah. |
| |
| 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. */ |
| |
| #include "alloca-conf.h" |
| #include "bfd.h" |
| #include "sysdep.h" |
| |
| #if defined (HOST_HPPAHPUX) || defined (HOST_HPPABSD) || defined (HOST_HPPAOSF) || defined(HOST_HPPAMPEIX) |
| |
| #include "libbfd.h" |
| #include "som.h" |
| |
| #include <sys/param.h> |
| #include <signal.h> |
| #include <machine/reg.h> |
| #include <sys/file.h> |
| #include <ctype.h> |
| |
| /* Magic not defined in standard HP-UX header files until 8.0 */ |
| |
| #ifndef CPU_PA_RISC1_0 |
| #define CPU_PA_RISC1_0 0x20B |
| #endif /* CPU_PA_RISC1_0 */ |
| |
| #ifndef CPU_PA_RISC1_1 |
| #define CPU_PA_RISC1_1 0x210 |
| #endif /* CPU_PA_RISC1_1 */ |
| |
| #ifndef CPU_PA_RISC2_0 |
| #define CPU_PA_RISC2_0 0x214 |
| #endif /* CPU_PA_RISC2_0 */ |
| |
| #ifndef _PA_RISC1_0_ID |
| #define _PA_RISC1_0_ID CPU_PA_RISC1_0 |
| #endif /* _PA_RISC1_0_ID */ |
| |
| #ifndef _PA_RISC1_1_ID |
| #define _PA_RISC1_1_ID CPU_PA_RISC1_1 |
| #endif /* _PA_RISC1_1_ID */ |
| |
| #ifndef _PA_RISC2_0_ID |
| #define _PA_RISC2_0_ID CPU_PA_RISC2_0 |
| #endif /* _PA_RISC2_0_ID */ |
| |
| #ifndef _PA_RISC_MAXID |
| #define _PA_RISC_MAXID 0x2FF |
| #endif /* _PA_RISC_MAXID */ |
| |
| #ifndef _PA_RISC_ID |
| #define _PA_RISC_ID(__m_num) \ |
| (((__m_num) == _PA_RISC1_0_ID) || \ |
| ((__m_num) >= _PA_RISC1_1_ID && (__m_num) <= _PA_RISC_MAXID)) |
| #endif /* _PA_RISC_ID */ |
| |
| /* HIUX in it's infinite stupidity changed the names for several "well |
| known" constants. Work around such braindamage. Try the HPUX version |
| first, then the HIUX version, and finally provide a default. */ |
| #ifdef HPUX_AUX_ID |
| #define EXEC_AUX_ID HPUX_AUX_ID |
| #endif |
| |
| #if !defined (EXEC_AUX_ID) && defined (HIUX_AUX_ID) |
| #define EXEC_AUX_ID HIUX_AUX_ID |
| #endif |
| |
| #ifndef EXEC_AUX_ID |
| #define EXEC_AUX_ID 0 |
| #endif |
| |
| /* Size (in chars) of the temporary buffers used during fixup and string |
| table writes. */ |
| |
| #define SOM_TMP_BUFSIZE 8192 |
| |
| /* Size of the hash table in archives. */ |
| #define SOM_LST_HASH_SIZE 31 |
| |
| /* Max number of SOMs to be found in an archive. */ |
| #define SOM_LST_MODULE_LIMIT 1024 |
| |
| /* Generic alignment macro. */ |
| #define SOM_ALIGN(val, alignment) \ |
| (((val) + (alignment) - 1) & ~((alignment) - 1)) |
| |
| /* SOM allows any one of the four previous relocations to be reused |
| with a "R_PREV_FIXUP" relocation entry. Since R_PREV_FIXUP |
| relocations are always a single byte, using a R_PREV_FIXUP instead |
| of some multi-byte relocation makes object files smaller. |
| |
| Note one side effect of using a R_PREV_FIXUP is the relocation that |
| is being repeated moves to the front of the queue. */ |
| struct reloc_queue { |
| unsigned char *reloc; |
| unsigned int size; |
| } reloc_queue[4]; |
| |
| /* This fully describes the symbol types which may be attached to |
| an EXPORT or IMPORT directive. Only SOM uses this formation |
| (ELF has no need for it). */ |
| typedef enum { |
| SYMBOL_TYPE_UNKNOWN, |
| SYMBOL_TYPE_ABSOLUTE, |
| SYMBOL_TYPE_CODE, |
| SYMBOL_TYPE_DATA, |
| SYMBOL_TYPE_ENTRY, |
| SYMBOL_TYPE_MILLICODE, |
| SYMBOL_TYPE_PLABEL, |
| SYMBOL_TYPE_PRI_PROG, |
| SYMBOL_TYPE_SEC_PROG, |
| } pa_symbol_type; |
| |
| struct section_to_type { |
| char *section; |
| char type; |
| }; |
| |
| /* Assorted symbol information that needs to be derived from the BFD symbol |
| and/or the BFD backend private symbol data. */ |
| struct som_misc_symbol_info { |
| unsigned int symbol_type; |
| unsigned int symbol_scope; |
| unsigned int arg_reloc; |
| unsigned int symbol_info; |
| unsigned int symbol_value; |
| unsigned int priv_level; |
| unsigned int secondary_def; |
| }; |
| |
| /* Forward declarations */ |
| |
| static boolean som_mkobject PARAMS ((bfd *)); |
| static const bfd_target * som_object_setup PARAMS ((bfd *, |
| struct header *, |
| struct som_exec_auxhdr *, |
| unsigned long)); |
| static boolean setup_sections PARAMS ((bfd *, struct header *, unsigned long)); |
| static const bfd_target * som_object_p PARAMS ((bfd *)); |
| static boolean som_write_object_contents PARAMS ((bfd *)); |
| static boolean som_slurp_string_table PARAMS ((bfd *)); |
| static unsigned int som_slurp_symbol_table PARAMS ((bfd *)); |
| static long som_get_symtab_upper_bound PARAMS ((bfd *)); |
| static long som_canonicalize_reloc PARAMS ((bfd *, sec_ptr, |
| arelent **, asymbol **)); |
| static long som_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr)); |
| static unsigned int som_set_reloc_info PARAMS ((unsigned char *, unsigned int, |
| arelent *, asection *, |
| asymbol **, boolean)); |
| static boolean som_slurp_reloc_table PARAMS ((bfd *, asection *, |
| asymbol **, boolean)); |
| static long som_get_symtab PARAMS ((bfd *, asymbol **)); |
| static asymbol * som_make_empty_symbol PARAMS ((bfd *)); |
| static void som_print_symbol PARAMS ((bfd *, PTR, |
| asymbol *, bfd_print_symbol_type)); |
| static boolean som_new_section_hook PARAMS ((bfd *, asection *)); |
| static boolean som_bfd_copy_private_symbol_data PARAMS ((bfd *, asymbol *, |
| bfd *, asymbol *)); |
| static boolean som_bfd_copy_private_section_data PARAMS ((bfd *, asection *, |
| bfd *, asection *)); |
| static boolean som_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *)); |
| #define som_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data |
| #define som_bfd_set_private_flags _bfd_generic_bfd_set_private_flags |
| static boolean som_bfd_is_local_label_name PARAMS ((bfd *, const char *)); |
| static boolean som_set_section_contents PARAMS ((bfd *, sec_ptr, PTR, |
| file_ptr, bfd_size_type)); |
| static boolean som_get_section_contents PARAMS ((bfd *, sec_ptr, PTR, |
| file_ptr, bfd_size_type)); |
| static boolean som_set_arch_mach PARAMS ((bfd *, enum bfd_architecture, |
| unsigned long)); |
| static boolean som_find_nearest_line PARAMS ((bfd *, asection *, |
| asymbol **, bfd_vma, |
| CONST char **, |
| CONST char **, |
| unsigned int *)); |
| static void som_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *)); |
| static asection * bfd_section_from_som_symbol PARAMS ((bfd *, |
| struct symbol_dictionary_record *)); |
| static int log2 PARAMS ((unsigned int)); |
| static bfd_reloc_status_type hppa_som_reloc PARAMS ((bfd *, arelent *, |
| asymbol *, PTR, |
| asection *, bfd *, |
| char **)); |
| static void som_initialize_reloc_queue PARAMS ((struct reloc_queue *)); |
| static void som_reloc_queue_insert PARAMS ((unsigned char *, unsigned int, |
| struct reloc_queue *)); |
| static void som_reloc_queue_fix PARAMS ((struct reloc_queue *, unsigned int)); |
| static int som_reloc_queue_find PARAMS ((unsigned char *, unsigned int, |
| struct reloc_queue *)); |
| static unsigned char * try_prev_fixup PARAMS ((bfd *, int *, unsigned char *, |
| unsigned int, |
| struct reloc_queue *)); |
| |
| static unsigned char * som_reloc_skip PARAMS ((bfd *, unsigned int, |
| unsigned char *, unsigned int *, |
| struct reloc_queue *)); |
| static unsigned char * som_reloc_addend PARAMS ((bfd *, int, unsigned char *, |
| unsigned int *, |
| struct reloc_queue *)); |
| static unsigned char * som_reloc_call PARAMS ((bfd *, unsigned char *, |
| unsigned int *, |
| arelent *, int, |
| struct reloc_queue *)); |
| static unsigned long som_count_spaces PARAMS ((bfd *)); |
| static unsigned long som_count_subspaces PARAMS ((bfd *)); |
| static int compare_syms PARAMS ((const void *, const void *)); |
| static int compare_subspaces PARAMS ((const void *, const void *)); |
| static unsigned long som_compute_checksum PARAMS ((bfd *)); |
| static boolean som_prep_headers PARAMS ((bfd *)); |
| static int som_sizeof_headers PARAMS ((bfd *, boolean)); |
| static boolean som_finish_writing PARAMS ((bfd *)); |
| static boolean som_build_and_write_symbol_table PARAMS ((bfd *)); |
| static void som_prep_for_fixups PARAMS ((bfd *, asymbol **, unsigned long)); |
| static boolean som_write_fixups PARAMS ((bfd *, unsigned long, unsigned int *)); |
| static boolean som_write_space_strings PARAMS ((bfd *, unsigned long, |
| unsigned int *)); |
| static boolean som_write_symbol_strings PARAMS ((bfd *, unsigned long, |
| asymbol **, unsigned int, |
| unsigned *, |
| COMPUNIT *)); |
| static boolean som_begin_writing PARAMS ((bfd *)); |
| static reloc_howto_type * som_bfd_reloc_type_lookup |
| PARAMS ((bfd *, bfd_reloc_code_real_type)); |
| static char som_section_type PARAMS ((const char *)); |
| static int som_decode_symclass PARAMS ((asymbol *)); |
| static boolean som_bfd_count_ar_symbols PARAMS ((bfd *, struct lst_header *, |
| symindex *)); |
| |
| static boolean som_bfd_fill_in_ar_symbols PARAMS ((bfd *, struct lst_header *, |
| carsym **syms)); |
| static boolean som_slurp_armap PARAMS ((bfd *)); |
| static boolean som_write_armap PARAMS ((bfd *, unsigned int, struct orl *, |
| unsigned int, int)); |
| static void som_bfd_derive_misc_symbol_info PARAMS ((bfd *, asymbol *, |
| struct som_misc_symbol_info *)); |
| static boolean som_bfd_prep_for_ar_write PARAMS ((bfd *, unsigned int *, |
| unsigned int *)); |
| static unsigned int som_bfd_ar_symbol_hash PARAMS ((asymbol *)); |
| static boolean som_bfd_ar_write_symbol_stuff PARAMS ((bfd *, unsigned int, |
| unsigned int, |
| struct lst_header, |
| unsigned int)); |
| static boolean som_is_space PARAMS ((asection *)); |
| static boolean som_is_subspace PARAMS ((asection *)); |
| static boolean som_is_container PARAMS ((asection *, asection *)); |
| static boolean som_bfd_free_cached_info PARAMS ((bfd *)); |
| static boolean som_bfd_link_split_section PARAMS ((bfd *, asection *)); |
| |
| /* Map SOM section names to POSIX/BSD single-character symbol types. |
| |
| This table includes all the standard subspaces as defined in the |
| current "PRO ABI for PA-RISC Systems", $UNWIND$ which for |
| some reason was left out, and sections specific to embedded stabs. */ |
| |
| static const struct section_to_type stt[] = { |
| {"$TEXT$", 't'}, |
| {"$SHLIB_INFO$", 't'}, |
| {"$MILLICODE$", 't'}, |
| {"$LIT$", 't'}, |
| {"$CODE$", 't'}, |
| {"$UNWIND_START$", 't'}, |
| {"$UNWIND$", 't'}, |
| {"$PRIVATE$", 'd'}, |
| {"$PLT$", 'd'}, |
| {"$SHLIB_DATA$", 'd'}, |
| {"$DATA$", 'd'}, |
| {"$SHORTDATA$", 'g'}, |
| {"$DLT$", 'd'}, |
| {"$GLOBAL$", 'g'}, |
| {"$SHORTBSS$", 's'}, |
| {"$BSS$", 'b'}, |
| {"$GDB_STRINGS$", 'N'}, |
| {"$GDB_SYMBOLS$", 'N'}, |
| {0, 0} |
| }; |
| |
| /* About the relocation formatting table... |
| |
| There are 256 entries in the table, one for each possible |
| relocation opcode available in SOM. We index the table by |
| the relocation opcode. The names and operations are those |
| defined by a.out_800 (4). |
| |
| Right now this table is only used to count and perform minimal |
| processing on relocation streams so that they can be internalized |
| into BFD and symbolically printed by utilities. To make actual use |
| of them would be much more difficult, BFD's concept of relocations |
| is far too simple to handle SOM relocations. The basic assumption |
| that a relocation can be completely processed independent of other |
| relocations before an object file is written is invalid for SOM. |
| |
| The SOM relocations are meant to be processed as a stream, they |
| specify copying of data from the input section to the output section |
| while possibly modifying the data in some manner. They also can |
| specify that a variable number of zeros or uninitialized data be |
| inserted on in the output segment at the current offset. Some |
| relocations specify that some previous relocation be re-applied at |
| the current location in the input/output sections. And finally a number |
| of relocations have effects on other sections (R_ENTRY, R_EXIT, |
| R_UNWIND_AUX and a variety of others). There isn't even enough room |
| in the BFD relocation data structure to store enough information to |
| perform all the relocations. |
| |
| Each entry in the table has three fields. |
| |
| The first entry is an index into this "class" of relocations. This |
| index can then be used as a variable within the relocation itself. |
| |
| The second field is a format string which actually controls processing |
| of the relocation. It uses a simple postfix machine to do calculations |
| based on variables/constants found in the string and the relocation |
| stream. |
| |
| The third field specifys whether or not this relocation may use |
| a constant (V) from the previous R_DATA_OVERRIDE rather than a constant |
| stored in the instruction. |
| |
| Variables: |
| |
| L = input space byte count |
| D = index into class of relocations |
| M = output space byte count |
| N = statement number (unused?) |
| O = stack operation |
| R = parameter relocation bits |
| S = symbol index |
| T = first 32 bits of stack unwind information |
| U = second 32 bits of stack unwind information |
| V = a literal constant (usually used in the next relocation) |
| P = a previous relocation |
| |
| Lower case letters (starting with 'b') refer to following |
| bytes in the relocation stream. 'b' is the next 1 byte, |
| c is the next 2 bytes, d is the next 3 bytes, etc... |
| This is the variable part of the relocation entries that |
| makes our life a living hell. |
| |
| numerical constants are also used in the format string. Note |
| the constants are represented in decimal. |
| |
| '+', "*" and "=" represents the obvious postfix operators. |
| '<' represents a left shift. |
| |
| Stack Operations: |
| |
| Parameter Relocation Bits: |
| |
| Unwind Entries: |
| |
| Previous Relocations: The index field represents which in the queue |
| of 4 previous fixups should be re-applied. |
| |
| Literal Constants: These are generally used to represent addend |
| parts of relocations when these constants are not stored in the |
| fields of the instructions themselves. For example the instruction |
| addil foo-$global$-0x1234 would use an override for "0x1234" rather |
| than storing it into the addil itself. */ |
| |
| struct fixup_format { |
| int D; |
| const char *format; |
| }; |
| |
| static const struct fixup_format som_fixup_formats[256] = { |
| /* R_NO_RELOCATION */ |
| 0, "LD1+4*=", /* 0x00 */ |
| 1, "LD1+4*=", /* 0x01 */ |
| 2, "LD1+4*=", /* 0x02 */ |
| 3, "LD1+4*=", /* 0x03 */ |
| 4, "LD1+4*=", /* 0x04 */ |
| 5, "LD1+4*=", /* 0x05 */ |
| 6, "LD1+4*=", /* 0x06 */ |
| 7, "LD1+4*=", /* 0x07 */ |
| 8, "LD1+4*=", /* 0x08 */ |
| 9, "LD1+4*=", /* 0x09 */ |
| 10, "LD1+4*=", /* 0x0a */ |
| 11, "LD1+4*=", /* 0x0b */ |
| 12, "LD1+4*=", /* 0x0c */ |
| 13, "LD1+4*=", /* 0x0d */ |
| 14, "LD1+4*=", /* 0x0e */ |
| 15, "LD1+4*=", /* 0x0f */ |
| 16, "LD1+4*=", /* 0x10 */ |
| 17, "LD1+4*=", /* 0x11 */ |
| 18, "LD1+4*=", /* 0x12 */ |
| 19, "LD1+4*=", /* 0x13 */ |
| 20, "LD1+4*=", /* 0x14 */ |
| 21, "LD1+4*=", /* 0x15 */ |
| 22, "LD1+4*=", /* 0x16 */ |
| 23, "LD1+4*=", /* 0x17 */ |
| 0, "LD8<b+1+4*=", /* 0x18 */ |
| 1, "LD8<b+1+4*=", /* 0x19 */ |
| 2, "LD8<b+1+4*=", /* 0x1a */ |
| 3, "LD8<b+1+4*=", /* 0x1b */ |
| 0, "LD16<c+1+4*=", /* 0x1c */ |
| 1, "LD16<c+1+4*=", /* 0x1d */ |
| 2, "LD16<c+1+4*=", /* 0x1e */ |
| 0, "Ld1+=", /* 0x1f */ |
| /* R_ZEROES */ |
| 0, "Lb1+4*=", /* 0x20 */ |
| 1, "Ld1+=", /* 0x21 */ |
| /* R_UNINIT */ |
| 0, "Lb1+4*=", /* 0x22 */ |
| 1, "Ld1+=", /* 0x23 */ |
| /* R_RELOCATION */ |
| 0, "L4=", /* 0x24 */ |
| /* R_DATA_ONE_SYMBOL */ |
| 0, "L4=Sb=", /* 0x25 */ |
| 1, "L4=Sd=", /* 0x26 */ |
| /* R_DATA_PLEBEL */ |
| 0, "L4=Sb=", /* 0x27 */ |
| 1, "L4=Sd=", /* 0x28 */ |
| /* R_SPACE_REF */ |
| 0, "L4=", /* 0x29 */ |
| /* R_REPEATED_INIT */ |
| 0, "L4=Mb1+4*=", /* 0x2a */ |
| 1, "Lb4*=Mb1+L*=", /* 0x2b */ |
| 2, "Lb4*=Md1+4*=", /* 0x2c */ |
| 3, "Ld1+=Me1+=", /* 0x2d */ |
| 0, "", /* 0x2e */ |
| 0, "", /* 0x2f */ |
| /* R_PCREL_CALL */ |
| 0, "L4=RD=Sb=", /* 0x30 */ |
| 1, "L4=RD=Sb=", /* 0x31 */ |
| 2, "L4=RD=Sb=", /* 0x32 */ |
| 3, "L4=RD=Sb=", /* 0x33 */ |
| 4, "L4=RD=Sb=", /* 0x34 */ |
| 5, "L4=RD=Sb=", /* 0x35 */ |
| 6, "L4=RD=Sb=", /* 0x36 */ |
| 7, "L4=RD=Sb=", /* 0x37 */ |
| 8, "L4=RD=Sb=", /* 0x38 */ |
| 9, "L4=RD=Sb=", /* 0x39 */ |
| 0, "L4=RD8<b+=Sb=",/* 0x3a */ |
| 1, "L4=RD8<b+=Sb=",/* 0x3b */ |
| 0, "L4=RD8<b+=Sd=",/* 0x3c */ |
| 1, "L4=RD8<b+=Sd=",/* 0x3d */ |
| /* R_SHORT_PCREL_MODE */ |
| 0, "", /* 0x3e */ |
| /* R_LONG_PCREL_MODE */ |
| 0, "", /* 0x3f */ |
| /* R_ABS_CALL */ |
| 0, "L4=RD=Sb=", /* 0x40 */ |
| 1, "L4=RD=Sb=", /* 0x41 */ |
| 2, "L4=RD=Sb=", /* 0x42 */ |
| 3, "L4=RD=Sb=", /* 0x43 */ |
| 4, "L4=RD=Sb=", /* 0x44 */ |
| 5, "L4=RD=Sb=", /* 0x45 */ |
| 6, "L4=RD=Sb=", /* 0x46 */ |
| 7, "L4=RD=Sb=", /* 0x47 */ |
| 8, "L4=RD=Sb=", /* 0x48 */ |
| 9, "L4=RD=Sb=", /* 0x49 */ |
| 0, "L4=RD8<b+=Sb=",/* 0x4a */ |
| 1, "L4=RD8<b+=Sb=",/* 0x4b */ |
| 0, "L4=RD8<b+=Sd=",/* 0x4c */ |
| 1, "L4=RD8<b+=Sd=",/* 0x4d */ |
| /* R_RESERVED */ |
| 0, "", /* 0x4e */ |
| 0, "", /* 0x4f */ |
| /* R_DP_RELATIVE */ |
| 0, "L4=SD=", /* 0x50 */ |
| 1, "L4=SD=", /* 0x51 */ |
| 2, "L4=SD=", /* 0x52 */ |
| 3, "L4=SD=", /* 0x53 */ |
| 4, "L4=SD=", /* 0x54 */ |
| 5, "L4=SD=", /* 0x55 */ |
| 6, "L4=SD=", /* 0x56 */ |
| 7, "L4=SD=", /* 0x57 */ |
| 8, "L4=SD=", /* 0x58 */ |
| 9, "L4=SD=", /* 0x59 */ |
| 10, "L4=SD=", /* 0x5a */ |
| 11, "L4=SD=", /* 0x5b */ |
| 12, "L4=SD=", /* 0x5c */ |
| 13, "L4=SD=", /* 0x5d */ |
| 14, "L4=SD=", /* 0x5e */ |
| 15, "L4=SD=", /* 0x5f */ |
| 16, "L4=SD=", /* 0x60 */ |
| 17, "L4=SD=", /* 0x61 */ |
| 18, "L4=SD=", /* 0x62 */ |
| 19, "L4=SD=", /* 0x63 */ |
| 20, "L4=SD=", /* 0x64 */ |
| 21, "L4=SD=", /* 0x65 */ |
| 22, "L4=SD=", /* 0x66 */ |
| 23, "L4=SD=", /* 0x67 */ |
| 24, "L4=SD=", /* 0x68 */ |
| 25, "L4=SD=", /* 0x69 */ |
| 26, "L4=SD=", /* 0x6a */ |
| 27, "L4=SD=", /* 0x6b */ |
| 28, "L4=SD=", /* 0x6c */ |
| 29, "L4=SD=", /* 0x6d */ |
| 30, "L4=SD=", /* 0x6e */ |
| 31, "L4=SD=", /* 0x6f */ |
| 32, "L4=Sb=", /* 0x70 */ |
| 33, "L4=Sd=", /* 0x71 */ |
| /* R_RESERVED */ |
| 0, "", /* 0x72 */ |
| 0, "", /* 0x73 */ |
| 0, "", /* 0x74 */ |
| 0, "", /* 0x75 */ |
| 0, "", /* 0x76 */ |
| 0, "", /* 0x77 */ |
| /* R_DLT_REL */ |
| 0, "L4=Sb=", /* 0x78 */ |
| 1, "L4=Sd=", /* 0x79 */ |
| /* R_RESERVED */ |
| 0, "", /* 0x7a */ |
| 0, "", /* 0x7b */ |
| 0, "", /* 0x7c */ |
| 0, "", /* 0x7d */ |
| 0, "", /* 0x7e */ |
| 0, "", /* 0x7f */ |
| /* R_CODE_ONE_SYMBOL */ |
| 0, "L4=SD=", /* 0x80 */ |
| 1, "L4=SD=", /* 0x81 */ |
| 2, "L4=SD=", /* 0x82 */ |
| 3, "L4=SD=", /* 0x83 */ |
| 4, "L4=SD=", /* 0x84 */ |
| 5, "L4=SD=", /* 0x85 */ |
| 6, "L4=SD=", /* 0x86 */ |
| 7, "L4=SD=", /* 0x87 */ |
| 8, "L4=SD=", /* 0x88 */ |
| 9, "L4=SD=", /* 0x89 */ |
| 10, "L4=SD=", /* 0x8q */ |
| 11, "L4=SD=", /* 0x8b */ |
| 12, "L4=SD=", /* 0x8c */ |
| 13, "L4=SD=", /* 0x8d */ |
| 14, "L4=SD=", /* 0x8e */ |
| 15, "L4=SD=", /* 0x8f */ |
| 16, "L4=SD=", /* 0x90 */ |
| 17, "L4=SD=", /* 0x91 */ |
| 18, "L4=SD=", /* 0x92 */ |
| 19, "L4=SD=", /* 0x93 */ |
| 20, "L4=SD=", /* 0x94 */ |
| 21, "L4=SD=", /* 0x95 */ |
| 22, "L4=SD=", /* 0x96 */ |
| 23, "L4=SD=", /* 0x97 */ |
| 24, "L4=SD=", /* 0x98 */ |
| 25, "L4=SD=", /* 0x99 */ |
| 26, "L4=SD=", /* 0x9a */ |
| 27, "L4=SD=", /* 0x9b */ |
| 28, "L4=SD=", /* 0x9c */ |
| 29, "L4=SD=", /* 0x9d */ |
| 30, "L4=SD=", /* 0x9e */ |
| 31, "L4=SD=", /* 0x9f */ |
| 32, "L4=Sb=", /* 0xa0 */ |
| 33, "L4=Sd=", /* 0xa1 */ |
| /* R_RESERVED */ |
| 0, "", /* 0xa2 */ |
| 0, "", /* 0xa3 */ |
| 0, "", /* 0xa4 */ |
| 0, "", /* 0xa5 */ |
| 0, "", /* 0xa6 */ |
| 0, "", /* 0xa7 */ |
| 0, "", /* 0xa8 */ |
| 0, "", /* 0xa9 */ |
| 0, "", /* 0xaa */ |
| 0, "", /* 0xab */ |
| 0, "", /* 0xac */ |
| 0, "", /* 0xad */ |
| /* R_MILLI_REL */ |
| 0, "L4=Sb=", /* 0xae */ |
| 1, "L4=Sd=", /* 0xaf */ |
| /* R_CODE_PLABEL */ |
| 0, "L4=Sb=", /* 0xb0 */ |
| 1, "L4=Sd=", /* 0xb1 */ |
| /* R_BREAKPOINT */ |
| 0, "L4=", /* 0xb2 */ |
| /* R_ENTRY */ |
| 0, "Te=Ue=", /* 0xb3 */ |
| 1, "Uf=", /* 0xb4 */ |
| /* R_ALT_ENTRY */ |
| 0, "", /* 0xb5 */ |
| /* R_EXIT */ |
| 0, "", /* 0xb6 */ |
| /* R_BEGIN_TRY */ |
| 0, "", /* 0xb7 */ |
| /* R_END_TRY */ |
| 0, "R0=", /* 0xb8 */ |
| 1, "Rb4*=", /* 0xb9 */ |
| 2, "Rd4*=", /* 0xba */ |
| /* R_BEGIN_BRTAB */ |
| 0, "", /* 0xbb */ |
| /* R_END_BRTAB */ |
| 0, "", /* 0xbc */ |
| /* R_STATEMENT */ |
| 0, "Nb=", /* 0xbd */ |
| 1, "Nc=", /* 0xbe */ |
| 2, "Nd=", /* 0xbf */ |
| /* R_DATA_EXPR */ |
| 0, "L4=", /* 0xc0 */ |
| /* R_CODE_EXPR */ |
| 0, "L4=", /* 0xc1 */ |
| /* R_FSEL */ |
| 0, "", /* 0xc2 */ |
| /* R_LSEL */ |
| 0, "", /* 0xc3 */ |
| /* R_RSEL */ |
| 0, "", /* 0xc4 */ |
| /* R_N_MODE */ |
| 0, "", /* 0xc5 */ |
| /* R_S_MODE */ |
| 0, "", /* 0xc6 */ |
| /* R_D_MODE */ |
| 0, "", /* 0xc7 */ |
| /* R_R_MODE */ |
| 0, "", /* 0xc8 */ |
| /* R_DATA_OVERRIDE */ |
| 0, "V0=", /* 0xc9 */ |
| 1, "Vb=", /* 0xca */ |
| 2, "Vc=", /* 0xcb */ |
| 3, "Vd=", /* 0xcc */ |
| 4, "Ve=", /* 0xcd */ |
| /* R_TRANSLATED */ |
| 0, "", /* 0xce */ |
| /* R_AUX_UNWIND */ |
| 0, "Sd=Vf=Ef=", /* 0xcf */ |
| /* R_COMP1 */ |
| 0, "Ob=", /* 0xd0 */ |
| /* R_COMP2 */ |
| 0, "Ob=Sd=", /* 0xd1 */ |
| /* R_COMP3 */ |
| 0, "Ob=Ve=", /* 0xd2 */ |
| /* R_PREV_FIXUP */ |
| 0, "P", /* 0xd3 */ |
| 1, "P", /* 0xd4 */ |
| 2, "P", /* 0xd5 */ |
| 3, "P", /* 0xd6 */ |
| /* R_SEC_STMT */ |
| 0, "", /* 0xd7 */ |
| /* R_N0SEL */ |
| 0, "", /* 0xd8 */ |
| /* R_N1SEL */ |
| 0, "", /* 0xd9 */ |
| /* R_LINETAB */ |
| 0, "Eb=Sd=Ve=", /* 0xda */ |
| /* R_LINETAB_ESC */ |
| 0, "Eb=Mb=", /* 0xdb */ |
| /* R_LTP_OVERRIDE */ |
| 0, "", /* 0xdc */ |
| /* R_COMMENT */ |
| 0, "Ob=Ve=", /* 0xdd */ |
| /* R_RESERVED */ |
| 0, "", /* 0xde */ |
| 0, "", /* 0xdf */ |
| 0, "", /* 0xe0 */ |
| 0, "", /* 0xe1 */ |
| 0, "", /* 0xe2 */ |
| 0, "", /* 0xe3 */ |
| 0, "", /* 0xe4 */ |
| 0, "", /* 0xe5 */ |
| 0, "", /* 0xe6 */ |
| 0, "", /* 0xe7 */ |
| 0, "", /* 0xe8 */ |
| 0, "", /* 0xe9 */ |
| 0, "", /* 0xea */ |
| 0, "", /* 0xeb */ |
| 0, "", /* 0xec */ |
| 0, "", /* 0xed */ |
| 0, "", /* 0xee */ |
| 0, "", /* 0xef */ |
| 0, "", /* 0xf0 */ |
| 0, "", /* 0xf1 */ |
| 0, "", /* 0xf2 */ |
| 0, "", /* 0xf3 */ |
| 0, "", /* 0xf4 */ |
| 0, "", /* 0xf5 */ |
| 0, "", /* 0xf6 */ |
| 0, "", /* 0xf7 */ |
| 0, "", /* 0xf8 */ |
| 0, "", /* 0xf9 */ |
| 0, "", /* 0xfa */ |
| 0, "", /* 0xfb */ |
| 0, "", /* 0xfc */ |
| 0, "", /* 0xfd */ |
| 0, "", /* 0xfe */ |
| 0, "", /* 0xff */ |
| }; |
| |
| static const int comp1_opcodes[] = { |
| 0x00, |
| 0x40, |
| 0x41, |
| 0x42, |
| 0x43, |
| 0x44, |
| 0x45, |
| 0x46, |
| 0x47, |
| 0x48, |
| 0x49, |
| 0x4a, |
| 0x4b, |
| 0x60, |
| 0x80, |
| 0xa0, |
| 0xc0, |
| -1 |
| }; |
| |
| static const int comp2_opcodes[] = { |
| 0x00, |
| 0x80, |
| 0x82, |
| 0xc0, |
| -1 |
| }; |
| |
| static const int comp3_opcodes[] = { |
| 0x00, |
| 0x02, |
| -1 |
| }; |
| |
| /* These apparently are not in older versions of hpux reloc.h (hpux7). */ |
| #ifndef R_DLT_REL |
| #define R_DLT_REL 0x78 |
| #endif |
| |
| #ifndef R_AUX_UNWIND |
| #define R_AUX_UNWIND 0xcf |
| #endif |
| |
| #ifndef R_SEC_STMT |
| #define R_SEC_STMT 0xd7 |
| #endif |
| |
| /* And these first appeared in hpux10. */ |
| #ifndef R_SHORT_PCREL_MODE |
| #define NO_PCREL_MODES |
| #define R_SHORT_PCREL_MODE 0x3e |
| #endif |
| |
| #ifndef R_LONG_PCREL_MODE |
| #define R_LONG_PCREL_MODE 0x3f |
| #endif |
| |
| #ifndef R_N0SEL |
| #define R_N0SEL 0xd8 |
| #endif |
| |
| #ifndef R_N1SEL |
| #define R_N1SEL 0xd9 |
| #endif |
| |
| #ifndef R_LINETAB |
| #define R_LINETAB 0xda |
| #endif |
| |
| #ifndef R_LINETAB_ESC |
| #define R_LINETAB_ESC 0xdb |
| #endif |
| |
| #ifndef R_LTP_OVERRIDE |
| #define R_LTP_OVERRIDE 0xdc |
| #endif |
| |
| #ifndef R_COMMENT |
| #define R_COMMENT 0xdd |
| #endif |
| |
| #define SOM_HOWTO(TYPE, NAME) \ |
| HOWTO(TYPE, 0, 0, 32, false, 0, 0, hppa_som_reloc, NAME, false, 0, 0, false) |
| |
| static reloc_howto_type som_hppa_howto_table[] = { |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_NO_RELOCATION, "R_NO_RELOCATION"), |
| SOM_HOWTO (R_ZEROES, "R_ZEROES"), |
| SOM_HOWTO (R_ZEROES, "R_ZEROES"), |
| SOM_HOWTO (R_UNINIT, "R_UNINIT"), |
| SOM_HOWTO (R_UNINIT, "R_UNINIT"), |
| SOM_HOWTO (R_RELOCATION, "R_RELOCATION"), |
| SOM_HOWTO (R_DATA_ONE_SYMBOL, "R_DATA_ONE_SYMBOL"), |
| SOM_HOWTO (R_DATA_ONE_SYMBOL, "R_DATA_ONE_SYMBOL"), |
| SOM_HOWTO (R_DATA_PLABEL, "R_DATA_PLABEL"), |
| SOM_HOWTO (R_DATA_PLABEL, "R_DATA_PLABEL"), |
| SOM_HOWTO (R_SPACE_REF, "R_SPACE_REF"), |
| SOM_HOWTO (R_REPEATED_INIT, "REPEATED_INIT"), |
| SOM_HOWTO (R_REPEATED_INIT, "REPEATED_INIT"), |
| SOM_HOWTO (R_REPEATED_INIT, "REPEATED_INIT"), |
| SOM_HOWTO (R_REPEATED_INIT, "REPEATED_INIT"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_PCREL_CALL, "R_PCREL_CALL"), |
| SOM_HOWTO (R_SHORT_PCREL_MODE, "R_SHORT_PCREL_MODE"), |
| SOM_HOWTO (R_LONG_PCREL_MODE, "R_LONG_PCREL_MODE"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_ABS_CALL, "R_ABS_CALL"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_DP_RELATIVE, "R_DP_RELATIVE"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_DLT_REL, "R_DLT_REL"), |
| SOM_HOWTO (R_DLT_REL, "R_DLT_REL"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_CODE_ONE_SYMBOL, "R_CODE_ONE_SYMBOL"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_MILLI_REL, "R_MILLI_REL"), |
| SOM_HOWTO (R_MILLI_REL, "R_MILLI_REL"), |
| SOM_HOWTO (R_CODE_PLABEL, "R_CODE_PLABEL"), |
| SOM_HOWTO (R_CODE_PLABEL, "R_CODE_PLABEL"), |
| SOM_HOWTO (R_BREAKPOINT, "R_BREAKPOINT"), |
| SOM_HOWTO (R_ENTRY, "R_ENTRY"), |
| SOM_HOWTO (R_ENTRY, "R_ENTRY"), |
| SOM_HOWTO (R_ALT_ENTRY, "R_ALT_ENTRY"), |
| SOM_HOWTO (R_EXIT, "R_EXIT"), |
| SOM_HOWTO (R_BEGIN_TRY, "R_BEGIN_TRY"), |
| SOM_HOWTO (R_END_TRY, "R_END_TRY"), |
| SOM_HOWTO (R_END_TRY, "R_END_TRY"), |
| SOM_HOWTO (R_END_TRY, "R_END_TRY"), |
| SOM_HOWTO (R_BEGIN_BRTAB, "R_BEGIN_BRTAB"), |
| SOM_HOWTO (R_END_BRTAB, "R_END_BRTAB"), |
| SOM_HOWTO (R_STATEMENT, "R_STATEMENT"), |
| SOM_HOWTO (R_STATEMENT, "R_STATEMENT"), |
| SOM_HOWTO (R_STATEMENT, "R_STATEMENT"), |
| SOM_HOWTO (R_DATA_EXPR, "R_DATA_EXPR"), |
| SOM_HOWTO (R_CODE_EXPR, "R_CODE_EXPR"), |
| SOM_HOWTO (R_FSEL, "R_FSEL"), |
| SOM_HOWTO (R_LSEL, "R_LSEL"), |
| SOM_HOWTO (R_RSEL, "R_RSEL"), |
| SOM_HOWTO (R_N_MODE, "R_N_MODE"), |
| SOM_HOWTO (R_S_MODE, "R_S_MODE"), |
| SOM_HOWTO (R_D_MODE, "R_D_MODE"), |
| SOM_HOWTO (R_R_MODE, "R_R_MODE"), |
| SOM_HOWTO (R_DATA_OVERRIDE, "R_DATA_OVERRIDE"), |
| SOM_HOWTO (R_DATA_OVERRIDE, "R_DATA_OVERRIDE"), |
| SOM_HOWTO (R_DATA_OVERRIDE, "R_DATA_OVERRIDE"), |
| SOM_HOWTO (R_DATA_OVERRIDE, "R_DATA_OVERRIDE"), |
| SOM_HOWTO (R_DATA_OVERRIDE, "R_DATA_OVERRIDE"), |
| SOM_HOWTO (R_TRANSLATED, "R_TRANSLATED"), |
| SOM_HOWTO (R_AUX_UNWIND, "R_AUX_UNWIND"), |
| SOM_HOWTO (R_COMP1, "R_COMP1"), |
| SOM_HOWTO (R_COMP2, "R_COMP2"), |
| SOM_HOWTO (R_COMP3, "R_COMP3"), |
| SOM_HOWTO (R_PREV_FIXUP, "R_PREV_FIXUP"), |
| SOM_HOWTO (R_PREV_FIXUP, "R_PREV_FIXUP"), |
| SOM_HOWTO (R_PREV_FIXUP, "R_PREV_FIXUP"), |
| SOM_HOWTO (R_PREV_FIXUP, "R_PREV_FIXUP"), |
| SOM_HOWTO (R_SEC_STMT, "R_SEC_STMT"), |
| SOM_HOWTO (R_N0SEL, "R_N0SEL"), |
| SOM_HOWTO (R_N1SEL, "R_N1SEL"), |
| SOM_HOWTO (R_LINETAB, "R_LINETAB"), |
| SOM_HOWTO (R_LINETAB_ESC, "R_LINETAB_ESC"), |
| SOM_HOWTO (R_LTP_OVERRIDE, "R_LTP_OVERRIDE"), |
| SOM_HOWTO (R_COMMENT, "R_COMMENT"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED"), |
| SOM_HOWTO (R_RESERVED, "R_RESERVED") |
| }; |
| |
| /* Initialize the SOM relocation queue. By definition the queue holds |
| the last four multibyte fixups. */ |
| |
| static void |
| som_initialize_reloc_queue (queue) |
| struct reloc_queue *queue; |
| { |
| queue[0].reloc = NULL; |
| queue[0].size = 0; |
| queue[1].reloc = NULL; |
| queue[1].size = 0; |
| queue[2].reloc = NULL; |
| queue[2].size = 0; |
| queue[3].reloc = NULL; |
| queue[3].size = 0; |
| } |
| |
| /* Insert a new relocation into the relocation queue. */ |
| |
| static void |
| som_reloc_queue_insert (p, size, queue) |
| unsigned char *p; |
| unsigned int size; |
| struct reloc_queue *queue; |
| { |
| queue[3].reloc = queue[2].reloc; |
| queue[3].size = queue[2].size; |
| queue[2].reloc = queue[1].reloc; |
| queue[2].size = queue[1].size; |
| queue[1].reloc = queue[0].reloc; |
| queue[1].size = queue[0].size; |
| queue[0].reloc = p; |
| queue[0].size = size; |
| } |
| |
| /* When an entry in the relocation queue is reused, the entry moves |
| to the front of the queue. */ |
| |
| static void |
| som_reloc_queue_fix (queue, index) |
| struct reloc_queue *queue; |
| unsigned int index; |
| { |
| if (index == 0) |
| return; |
| |
| if (index == 1) |
| { |
| unsigned char *tmp1 = queue[0].reloc; |
| unsigned int tmp2 = queue[0].size; |
| queue[0].reloc = queue[1].reloc; |
| queue[0].size = queue[1].size; |
| queue[1].reloc = tmp1; |
| queue[1].size = tmp2; |
| return; |
| } |
| |
| if (index == 2) |
| { |
| unsigned char *tmp1 = queue[0].reloc; |
| unsigned int tmp2 = queue[0].size; |
| queue[0].reloc = queue[2].reloc; |
| queue[0].size = queue[2].size; |
| queue[2].reloc = queue[1].reloc; |
| queue[2].size = queue[1].size; |
| queue[1].reloc = tmp1; |
| queue[1].size = tmp2; |
| return; |
| } |
| |
| if (index == 3) |
| { |
| unsigned char *tmp1 = queue[0].reloc; |
| unsigned int tmp2 = queue[0].size; |
| queue[0].reloc = queue[3].reloc; |
| queue[0].size = queue[3].size; |
| queue[3].reloc = queue[2].reloc; |
| queue[3].size = queue[2].size; |
| queue[2].reloc = queue[1].reloc; |
| queue[2].size = queue[1].size; |
| queue[1].reloc = tmp1; |
| queue[1].size = tmp2; |
| return; |
| } |
| abort (); |
| } |
| |
| /* Search for a particular relocation in the relocation queue. */ |
| |
| static int |
| som_reloc_queue_find (p, size, queue) |
| unsigned char *p; |
| unsigned int size; |
| struct reloc_queue *queue; |
| { |
| if (queue[0].reloc && !memcmp (p, queue[0].reloc, size) |
| && size == queue[0].size) |
| return 0; |
| if (queue[1].reloc && !memcmp (p, queue[1].reloc, size) |
| && size == queue[1].size) |
| return 1; |
| if (queue[2].reloc && !memcmp (p, queue[2].reloc, size) |
| && size == queue[2].size) |
| return 2; |
| if (queue[3].reloc && !memcmp (p, queue[3].reloc, size) |
| && size == queue[3].size) |
| return 3; |
| return -1; |
| } |
| |
| static unsigned char * |
| try_prev_fixup (abfd, subspace_reloc_sizep, p, size, queue) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| int *subspace_reloc_sizep; |
| unsigned char *p; |
| unsigned int size; |
| struct reloc_queue *queue; |
| { |
| int queue_index = som_reloc_queue_find (p, size, queue); |
| |
| if (queue_index != -1) |
| { |
| /* Found this in a previous fixup. Undo the fixup we |
| just built and use R_PREV_FIXUP instead. We saved |
| a total of size - 1 bytes in the fixup stream. */ |
| bfd_put_8 (abfd, R_PREV_FIXUP + queue_index, p); |
| p += 1; |
| *subspace_reloc_sizep += 1; |
| som_reloc_queue_fix (queue, queue_index); |
| } |
| else |
| { |
| som_reloc_queue_insert (p, size, queue); |
| *subspace_reloc_sizep += size; |
| p += size; |
| } |
| return p; |
| } |
| |
| /* Emit the proper R_NO_RELOCATION fixups to map the next SKIP |
| bytes without any relocation. Update the size of the subspace |
| relocation stream via SUBSPACE_RELOC_SIZE_P; also return the |
| current pointer into the relocation stream. */ |
| |
| static unsigned char * |
| som_reloc_skip (abfd, skip, p, subspace_reloc_sizep, queue) |
| bfd *abfd; |
| unsigned int skip; |
| unsigned char *p; |
| unsigned int *subspace_reloc_sizep; |
| struct reloc_queue *queue; |
| { |
| /* Use a 4 byte R_NO_RELOCATION entry with a maximal value |
| then R_PREV_FIXUPs to get the difference down to a |
| reasonable size. */ |
| if (skip >= 0x1000000) |
| { |
| skip -= 0x1000000; |
| bfd_put_8 (abfd, R_NO_RELOCATION + 31, p); |
| bfd_put_8 (abfd, 0xff, p + 1); |
| bfd_put_16 (abfd, 0xffff, p + 2); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue); |
| while (skip >= 0x1000000) |
| { |
| skip -= 0x1000000; |
| bfd_put_8 (abfd, R_PREV_FIXUP, p); |
| p++; |
| *subspace_reloc_sizep += 1; |
| /* No need to adjust queue here since we are repeating the |
| most recent fixup. */ |
| } |
| } |
| |
| /* The difference must be less than 0x1000000. Use one |
| more R_NO_RELOCATION entry to get to the right difference. */ |
| if ((skip & 3) == 0 && skip <= 0xc0000 && skip > 0) |
| { |
| /* Difference can be handled in a simple single-byte |
| R_NO_RELOCATION entry. */ |
| if (skip <= 0x60) |
| { |
| bfd_put_8 (abfd, R_NO_RELOCATION + (skip >> 2) - 1, p); |
| *subspace_reloc_sizep += 1; |
| p++; |
| } |
| /* Handle it with a two byte R_NO_RELOCATION entry. */ |
| else if (skip <= 0x1000) |
| { |
| bfd_put_8 (abfd, R_NO_RELOCATION + 24 + (((skip >> 2) - 1) >> 8), p); |
| bfd_put_8 (abfd, (skip >> 2) - 1, p + 1); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue); |
| } |
| /* Handle it with a three byte R_NO_RELOCATION entry. */ |
| else |
| { |
| bfd_put_8 (abfd, R_NO_RELOCATION + 28 + (((skip >> 2) - 1) >> 16), p); |
| bfd_put_16 (abfd, (skip >> 2) - 1, p + 1); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue); |
| } |
| } |
| /* Ugh. Punt and use a 4 byte entry. */ |
| else if (skip > 0) |
| { |
| bfd_put_8 (abfd, R_NO_RELOCATION + 31, p); |
| bfd_put_8 (abfd, (skip - 1) >> 16, p + 1); |
| bfd_put_16 (abfd, skip - 1, p + 2); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue); |
| } |
| return p; |
| } |
| |
| /* Emit the proper R_DATA_OVERRIDE fixups to handle a nonzero addend |
| from a BFD relocation. Update the size of the subspace relocation |
| stream via SUBSPACE_RELOC_SIZE_P; also return the current pointer |
| into the relocation stream. */ |
| |
| static unsigned char * |
| som_reloc_addend (abfd, addend, p, subspace_reloc_sizep, queue) |
| bfd *abfd; |
| int addend; |
| unsigned char *p; |
| unsigned int *subspace_reloc_sizep; |
| struct reloc_queue *queue; |
| { |
| if ((unsigned) (addend) + 0x80 < 0x100) |
| { |
| bfd_put_8 (abfd, R_DATA_OVERRIDE + 1, p); |
| bfd_put_8 (abfd, addend, p + 1); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue); |
| } |
| else if ((unsigned) (addend) + 0x8000 < 0x10000) |
| { |
| bfd_put_8 (abfd, R_DATA_OVERRIDE + 2, p); |
| bfd_put_16 (abfd, addend, p + 1); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue); |
| } |
| else if ((unsigned) (addend) + 0x800000 < 0x1000000) |
| { |
| bfd_put_8 (abfd, R_DATA_OVERRIDE + 3, p); |
| bfd_put_8 (abfd, addend >> 16, p + 1); |
| bfd_put_16 (abfd, addend, p + 2); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue); |
| } |
| else |
| { |
| bfd_put_8 (abfd, R_DATA_OVERRIDE + 4, p); |
| bfd_put_32 (abfd, addend, p + 1); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue); |
| } |
| return p; |
| } |
| |
| /* Handle a single function call relocation. */ |
| |
| static unsigned char * |
| som_reloc_call (abfd, p, subspace_reloc_sizep, bfd_reloc, sym_num, queue) |
| bfd *abfd; |
| unsigned char *p; |
| unsigned int *subspace_reloc_sizep; |
| arelent *bfd_reloc; |
| int sym_num; |
| struct reloc_queue *queue; |
| { |
| int arg_bits = HPPA_R_ARG_RELOC (bfd_reloc->addend); |
| int rtn_bits = arg_bits & 0x3; |
| int type, done = 0; |
| |
| /* You'll never believe all this is necessary to handle relocations |
| for function calls. Having to compute and pack the argument |
| relocation bits is the real nightmare. |
| |
| If you're interested in how this works, just forget it. You really |
| do not want to know about this braindamage. */ |
| |
| /* First see if this can be done with a "simple" relocation. Simple |
| relocations have a symbol number < 0x100 and have simple encodings |
| of argument relocations. */ |
| |
| if (sym_num < 0x100) |
| { |
| switch (arg_bits) |
| { |
| case 0: |
| case 1: |
| type = 0; |
| break; |
| case 1 << 8: |
| case 1 << 8 | 1: |
| type = 1; |
| break; |
| case 1 << 8 | 1 << 6: |
| case 1 << 8 | 1 << 6 | 1: |
| type = 2; |
| break; |
| case 1 << 8 | 1 << 6 | 1 << 4: |
| case 1 << 8 | 1 << 6 | 1 << 4 | 1: |
| type = 3; |
| break; |
| case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2: |
| case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2 | 1: |
| type = 4; |
| break; |
| default: |
| /* Not one of the easy encodings. This will have to be |
| handled by the more complex code below. */ |
| type = -1; |
| break; |
| } |
| if (type != -1) |
| { |
| /* Account for the return value too. */ |
| if (rtn_bits) |
| type += 5; |
| |
| /* Emit a 2 byte relocation. Then see if it can be handled |
| with a relocation which is already in the relocation queue. */ |
| bfd_put_8 (abfd, bfd_reloc->howto->type + type, p); |
| bfd_put_8 (abfd, sym_num, p + 1); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue); |
| done = 1; |
| } |
| } |
| |
| /* If this could not be handled with a simple relocation, then do a hard |
| one. Hard relocations occur if the symbol number was too high or if |
| the encoding of argument relocation bits is too complex. */ |
| if (! done) |
| { |
| /* Don't ask about these magic sequences. I took them straight |
| from gas-1.36 which took them from the a.out man page. */ |
| type = rtn_bits; |
| if ((arg_bits >> 6 & 0xf) == 0xe) |
| type += 9 * 40; |
| else |
| type += (3 * (arg_bits >> 8 & 3) + (arg_bits >> 6 & 3)) * 40; |
| if ((arg_bits >> 2 & 0xf) == 0xe) |
| type += 9 * 4; |
| else |
| type += (3 * (arg_bits >> 4 & 3) + (arg_bits >> 2 & 3)) * 4; |
| |
| /* Output the first two bytes of the relocation. These describe |
| the length of the relocation and encoding style. */ |
| bfd_put_8 (abfd, bfd_reloc->howto->type + 10 |
| + 2 * (sym_num >= 0x100) + (type >= 0x100), |
| p); |
| bfd_put_8 (abfd, type, p + 1); |
| |
| /* Now output the symbol index and see if this bizarre relocation |
| just happened to be in the relocation queue. */ |
| if (sym_num < 0x100) |
| { |
| bfd_put_8 (abfd, sym_num, p + 2); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue); |
| } |
| else |
| { |
| bfd_put_8 (abfd, sym_num >> 16, p + 2); |
| bfd_put_16 (abfd, sym_num, p + 3); |
| p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue); |
| } |
| } |
| return p; |
| } |
| |
| /* Return the logarithm of X, base 2, considering X unsigned. |
| Abort -1 if X is not a power or two or is zero. */ |
| |
| static int |
| log2 (x) |
| unsigned int x; |
| { |
| int log = 0; |
| |
| /* Test for 0 or a power of 2. */ |
| if (x == 0 || x != (x & -x)) |
| return -1; |
| |
| while ((x >>= 1) != 0) |
| log++; |
| return log; |
| } |
| |
| static bfd_reloc_status_type |
| hppa_som_reloc (abfd, reloc_entry, symbol_in, data, |
| input_section, output_bfd, error_message) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| arelent *reloc_entry; |
| asymbol *symbol_in ATTRIBUTE_UNUSED; |
| PTR data ATTRIBUTE_UNUSED; |
| asection *input_section; |
| bfd *output_bfd; |
| char **error_message ATTRIBUTE_UNUSED; |
| { |
| if (output_bfd) |
| { |
| reloc_entry->address += input_section->output_offset; |
| return bfd_reloc_ok; |
| } |
| return bfd_reloc_ok; |
| } |
| |
| /* Given a generic HPPA relocation type, the instruction format, |
| and a field selector, return one or more appropriate SOM relocations. */ |
| |
| int ** |
| hppa_som_gen_reloc_type (abfd, base_type, format, field, sym_diff, sym) |
| bfd *abfd; |
| int base_type; |
| int format; |
| enum hppa_reloc_field_selector_type_alt field; |
| int sym_diff; |
| asymbol *sym; |
| { |
| int *final_type, **final_types; |
| |
| final_types = (int **) bfd_alloc (abfd, sizeof (int *) * 6); |
| final_type = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types || !final_type) |
| return NULL; |
| |
| /* The field selector may require additional relocations to be |
| generated. It's impossible to know at this moment if additional |
| relocations will be needed, so we make them. The code to actually |
| write the relocation/fixup stream is responsible for removing |
| any redundant relocations. */ |
| switch (field) |
| { |
| case e_fsel: |
| case e_psel: |
| case e_lpsel: |
| case e_rpsel: |
| final_types[0] = final_type; |
| final_types[1] = NULL; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| break; |
| |
| case e_tsel: |
| case e_ltsel: |
| case e_rtsel: |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| if (field == e_tsel) |
| *final_types[0] = R_FSEL; |
| else if (field == e_ltsel) |
| *final_types[0] = R_LSEL; |
| else |
| *final_types[0] = R_RSEL; |
| final_types[1] = final_type; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| break; |
| |
| case e_lssel: |
| case e_rssel: |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| *final_types[0] = R_S_MODE; |
| final_types[1] = final_type; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| break; |
| |
| case e_lsel: |
| case e_rsel: |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| *final_types[0] = R_N_MODE; |
| final_types[1] = final_type; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| break; |
| |
| case e_ldsel: |
| case e_rdsel: |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| *final_types[0] = R_D_MODE; |
| final_types[1] = final_type; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| break; |
| |
| case e_lrsel: |
| case e_rrsel: |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| *final_types[0] = R_R_MODE; |
| final_types[1] = final_type; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| break; |
| |
| case e_nsel: |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| *final_types[0] = R_N1SEL; |
| final_types[1] = final_type; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| break; |
| |
| case e_nlsel: |
| case e_nlrsel: |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| *final_types[0] = R_N0SEL; |
| final_types[1] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[1]) |
| return NULL; |
| if (field == e_nlsel) |
| *final_types[1] = R_N_MODE; |
| else |
| *final_types[1] = R_R_MODE; |
| final_types[2] = final_type; |
| final_types[3] = NULL; |
| *final_type = base_type; |
| break; |
| } |
| |
| switch (base_type) |
| { |
| case R_HPPA: |
| /* The difference of two symbols needs *very* special handling. */ |
| if (sym_diff) |
| { |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| final_types[1] = (int *) bfd_alloc (abfd, sizeof (int)); |
| final_types[2] = (int *) bfd_alloc (abfd, sizeof (int)); |
| final_types[3] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0] || !final_types[1] || !final_types[2]) |
| return NULL; |
| if (field == e_fsel) |
| *final_types[0] = R_FSEL; |
| else if (field == e_rsel) |
| *final_types[0] = R_RSEL; |
| else if (field == e_lsel) |
| *final_types[0] = R_LSEL; |
| *final_types[1] = R_COMP2; |
| *final_types[2] = R_COMP2; |
| *final_types[3] = R_COMP1; |
| final_types[4] = final_type; |
| if (format == 32) |
| *final_types[4] = R_DATA_EXPR; |
| else |
| *final_types[4] = R_CODE_EXPR; |
| final_types[5] = NULL; |
| break; |
| } |
| /* PLABELs get their own relocation type. */ |
| else if (field == e_psel |
| || field == e_lpsel |
| || field == e_rpsel) |
| { |
| /* A PLABEL relocation that has a size of 32 bits must |
| be a R_DATA_PLABEL. All others are R_CODE_PLABELs. */ |
| if (format == 32) |
| *final_type = R_DATA_PLABEL; |
| else |
| *final_type = R_CODE_PLABEL; |
| } |
| /* PIC stuff. */ |
| else if (field == e_tsel |
| || field == e_ltsel |
| || field == e_rtsel) |
| *final_type = R_DLT_REL; |
| /* A relocation in the data space is always a full 32bits. */ |
| else if (format == 32) |
| { |
| *final_type = R_DATA_ONE_SYMBOL; |
| |
| /* If there's no SOM symbol type associated with this BFD |
| symbol, then set the symbol type to ST_DATA. |
| |
| Only do this if the type is going to default later when |
| we write the object file. |
| |
| This is done so that the linker never encounters an |
| R_DATA_ONE_SYMBOL reloc involving an ST_CODE symbol. |
| |
| This allows the compiler to generate exception handling |
| tables. |
| |
| Note that one day we may need to also emit BEGIN_BRTAB and |
| END_BRTAB to prevent the linker from optimizing away insns |
| in exception handling regions. */ |
| if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN |
| && (sym->flags & BSF_SECTION_SYM) == 0 |
| && (sym->flags & BSF_FUNCTION) == 0 |
| && ! bfd_is_com_section (sym->section)) |
| som_symbol_data (sym)->som_type = SYMBOL_TYPE_DATA; |
| } |
| break; |
| |
| case R_HPPA_GOTOFF: |
| /* More PLABEL special cases. */ |
| if (field == e_psel |
| || field == e_lpsel |
| || field == e_rpsel) |
| *final_type = R_DATA_PLABEL; |
| break; |
| |
| case R_HPPA_COMPLEX: |
| /* The difference of two symbols needs *very* special handling. */ |
| if (sym_diff) |
| { |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| final_types[1] = (int *) bfd_alloc (abfd, sizeof (int)); |
| final_types[2] = (int *) bfd_alloc (abfd, sizeof (int)); |
| final_types[3] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0] || !final_types[1] || !final_types[2]) |
| return NULL; |
| if (field == e_fsel) |
| *final_types[0] = R_FSEL; |
| else if (field == e_rsel) |
| *final_types[0] = R_RSEL; |
| else if (field == e_lsel) |
| *final_types[0] = R_LSEL; |
| *final_types[1] = R_COMP2; |
| *final_types[2] = R_COMP2; |
| *final_types[3] = R_COMP1; |
| final_types[4] = final_type; |
| if (format == 32) |
| *final_types[4] = R_DATA_EXPR; |
| else |
| *final_types[4] = R_CODE_EXPR; |
| final_types[5] = NULL; |
| break; |
| } |
| else |
| break; |
| |
| case R_HPPA_NONE: |
| case R_HPPA_ABS_CALL: |
| /* Right now we can default all these. */ |
| break; |
| |
| case R_HPPA_PCREL_CALL: |
| { |
| #ifndef NO_PCREL_MODES |
| /* If we have short and long pcrel modes, then generate the proper |
| mode selector, then the pcrel relocation. Redundant selectors |
| will be eliminted as the relocs are sized and emitted. */ |
| final_types[0] = (int *) bfd_alloc (abfd, sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| if (format == 17) |
| *final_types[0] = R_SHORT_PCREL_MODE; |
| else |
| *final_types[0] = R_LONG_PCREL_MODE; |
| final_types[1] = final_type; |
| final_types[2] = NULL; |
| *final_type = base_type; |
| #endif |
| break; |
| } |
| } |
| return final_types; |
| } |
| |
| /* Return the address of the correct entry in the PA SOM relocation |
| howto table. */ |
| |
| static reloc_howto_type * |
| som_bfd_reloc_type_lookup (abfd, code) |
| bfd *abfd ATTRIBUTE_UNUSED; |
| bfd_reloc_code_real_type code; |
| { |
| if ((int) code < (int) R_NO_RELOCATION + 255) |
| { |
| BFD_ASSERT ((int) som_hppa_howto_table[(int) code].type == (int) code); |
| return &som_hppa_howto_table[(int) code]; |
| } |
| |
| return (reloc_howto_type *) 0; |
| } |
| |
| /* Perform some initialization for an object. Save results of this |
| initialization in the BFD. */ |
| |
| static const bfd_target * |
| som_object_setup (abfd, file_hdrp, aux_hdrp, current_offset) |
| bfd *abfd; |
| struct header *file_hdrp; |
| struct som_exec_auxhdr *aux_hdrp; |
| unsigned long current_offset; |
| { |
| asection *section; |
| int found; |
| |
| /* som_mkobject will set bfd_error if som_mkobject fails. */ |
| if (som_mkobject (abfd) != true) |
| return 0; |
| |
| /* Set BFD flags based on what information is available in the SOM. */ |
| abfd->flags = BFD_NO_FLAGS; |
| if (file_hdrp->symbol_total) |
| abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS; |
| |
| switch (file_hdrp->a_magic) |
| { |
| case DEMAND_MAGIC: |
| abfd->flags |= (D_PAGED | WP_TEXT | EXEC_P); |
| break; |
| case SHARE_MAGIC: |
| abfd->flags |= (WP_TEXT | EXEC_P); |
| break; |
| case EXEC_MAGIC: |
| abfd->flags |= (EXEC_P); |
| break; |
| case RELOC_MAGIC: |
| abfd->flags |= HAS_RELOC; |
| break; |
| #ifdef SHL_MAGIC |
| case SHL_MAGIC: |
| #endif |
| #ifdef DL_MAGIC |
| case DL_MAGIC: |
| #endif |
| abfd->flags |= DYNAMIC; |
| break; |
| |
| default: |
| break; |
| } |
| |
| /* Allocate space to hold the saved exec header information. */ |
| obj_som_exec_data (abfd) = (struct som_exec_data *) |
| bfd_zalloc (abfd, sizeof (struct som_exec_data)); |
| if (obj_som_exec_data (abfd) == NULL) |
| return NULL; |
| |
| /* The braindamaged OSF1 linker switched exec_flags and exec_entry! |
| |
| We used to identify OSF1 binaries based on NEW_VERSION_ID, but |
| apparently the latest HPUX linker is using NEW_VERSION_ID now. |
| |
| It's about time, OSF has used the new id since at least 1992; |
| HPUX didn't start till nearly 1995!. |
| |
| The new approach examines the entry field. If it's zero or not 4 |
| byte aligned then it's not a proper code address and we guess it's |
| really the executable flags. */ |
| found = 0; |
| for (section = abfd->sections; section; section = section->next) |
| { |
| if ((section->flags & SEC_CODE) == 0) |
| continue; |
| if (aux_hdrp->exec_entry >= section->vma |
| && aux_hdrp->exec_entry < section->vma + section->_cooked_size) |
| found = 1; |
| } |
| if (aux_hdrp->exec_entry == 0 |
| || (aux_hdrp->exec_entry & 0x3) != 0 |
| || ! found) |
| { |
| bfd_get_start_address (abfd) = aux_hdrp->exec_flags; |
| obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_entry; |
| } |
| else |
| { |
| bfd_get_start_address (abfd) = aux_hdrp->exec_entry + current_offset; |
| obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_flags; |
| } |
| |
| bfd_default_set_arch_mach (abfd, bfd_arch_hppa, pa10); |
| bfd_get_symcount (abfd) = file_hdrp->symbol_total; |
| |
| /* Initialize the saved symbol table and string table to NULL. |
| Save important offsets and sizes from the SOM header into |
| the BFD. */ |
| obj_som_stringtab (abfd) = (char *) NULL; |
| obj_som_symtab (abfd) = (som_symbol_type *) NULL; |
| obj_som_sorted_syms (abfd) = NULL; |
| obj_som_stringtab_size (abfd) = file_hdrp->symbol_strings_size; |
| obj_som_sym_filepos (abfd) = file_hdrp->symbol_location + current_offset; |
| obj_som_str_filepos (abfd) = (file_hdrp->symbol_strings_location |
| + current_offset); |
| obj_som_reloc_filepos (abfd) = (file_hdrp->fixup_request_location |
| + current_offset); |
| obj_som_exec_data (abfd)->system_id = file_hdrp->system_id; |
| |
| return abfd->xvec; |
| } |
| |
| /* Convert all of the space and subspace info into BFD sections. Each space |
| contains a number of subspaces, which in turn describe the mapping between |
| regions of the exec file, and the address space that the program runs in. |
| BFD sections which correspond to spaces will overlap the sections for the |
| associated subspaces. */ |
| |
| static boolean |
| setup_sections (abfd, file_hdr, current_offset) |
| bfd *abfd; |
| struct header *file_hdr; |
| unsigned long current_offset; |
| { |
| char *space_strings; |
| unsigned int space_index, i; |
| unsigned int total_subspaces = 0; |
| asection **subspace_sections, *section; |
| |
| /* First, read in space names. */ |
| |
| space_strings = bfd_malloc (file_hdr->space_strings_size); |
| if (!space_strings && file_hdr->space_strings_size != 0) |
| goto error_return; |
| |
| if (bfd_seek (abfd, current_offset + file_hdr->space_strings_location, |
| SEEK_SET) < 0) |
| goto error_return; |
| if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd) |
| != file_hdr->space_strings_size) |
| goto error_return; |
| |
| /* Loop over all of the space dictionaries, building up sections. */ |
| for (space_index = 0; space_index < file_hdr->space_total; space_index++) |
| { |
| struct space_dictionary_record space; |
| struct subspace_dictionary_record subspace, save_subspace; |
| int subspace_index; |
| asection *space_asect; |
| char *newname; |
| |
| /* Read the space dictionary element. */ |
| if (bfd_seek (abfd, |
| (current_offset + file_hdr->space_location |
| + space_index * sizeof space), |
| SEEK_SET) < 0) |
| goto error_return; |
| if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space) |
| goto error_return; |
| |
| /* Setup the space name string. */ |
| space.name.n_name = space.name.n_strx + space_strings; |
| |
| /* Make a section out of it. */ |
| newname = bfd_alloc (abfd, strlen (space.name.n_name) + 1); |
| if (!newname) |
| goto error_return; |
| strcpy (newname, space.name.n_name); |
| |
| space_asect = bfd_make_section_anyway (abfd, newname); |
| if (!space_asect) |
| goto error_return; |
| |
| if (space.is_loadable == 0) |
| space_asect->flags |= SEC_DEBUGGING; |
| |
| /* Set up all the attributes for the space. */ |
| if (bfd_som_set_section_attributes (space_asect, space.is_defined, |
| space.is_private, space.sort_key, |
| space.space_number) == false) |
| goto error_return; |
| |
| /* If the space has no subspaces, then we're done. */ |
| if (space.subspace_quantity == 0) |
| continue; |
| |
| /* Now, read in the first subspace for this space. */ |
| if (bfd_seek (abfd, |
| (current_offset + file_hdr->subspace_location |
| + space.subspace_index * sizeof subspace), |
| SEEK_SET) < 0) |
| goto error_return; |
| if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace) |
| goto error_return; |
| /* Seek back to the start of the subspaces for loop below. */ |
| if (bfd_seek (abfd, |
| (current_offset + file_hdr->subspace_location |
| + space.subspace_index * sizeof subspace), |
| SEEK_SET) < 0) |
| goto error_return; |
| |
| /* Setup the start address and file loc from the first subspace |
| record. */ |
| space_asect->vma = subspace.subspace_start; |
| space_asect->filepos = subspace.file_loc_init_value + current_offset; |
| space_asect->alignment_power = log2 (subspace.alignment); |
| if (space_asect->alignment_power == -1) |
| goto error_return; |
| |
| /* Initialize save_subspace so we can reliably determine if this |
| loop placed any useful values into it. */ |
| memset (&save_subspace, 0, sizeof (struct subspace_dictionary_record)); |
| |
| /* Loop over the rest of the subspaces, building up more sections. */ |
| for (subspace_index = 0; subspace_index < space.subspace_quantity; |
| subspace_index++) |
| { |
| asection *subspace_asect; |
| |
| /* Read in the next subspace. */ |
| if (bfd_read (&subspace, 1, sizeof subspace, abfd) |
| != sizeof subspace) |
| goto error_return; |
| |
| /* Setup the subspace name string. */ |
| subspace.name.n_name = subspace.name.n_strx + space_strings; |
| |
| newname = bfd_alloc (abfd, strlen (subspace.name.n_name) + 1); |
| if (!newname) |
| goto error_return; |
| strcpy (newname, subspace.name.n_name); |
| |
| /* Make a section out of this subspace. */ |
| subspace_asect = bfd_make_section_anyway (abfd, newname); |
| if (!subspace_asect) |
| goto error_return; |
| |
| /* Store private information about the section. */ |
| if (bfd_som_set_subsection_attributes (subspace_asect, space_asect, |
| subspace.access_control_bits, |
| subspace.sort_key, |
| subspace.quadrant) == false) |
| goto error_return; |
| |
| /* Keep an easy mapping between subspaces and sections. |
| Note we do not necessarily read the subspaces in the |
| same order in which they appear in the object file. |
| |
| So to make the target index come out correctly, we |
| store the location of the subspace header in target |
| index, then sort using the location of the subspace |
| header as the key. Then we can assign correct |
| subspace indices. */ |
| total_subspaces++; |
| subspace_asect->target_index = bfd_tell (abfd) - sizeof (subspace); |
| |
| /* Set SEC_READONLY and SEC_CODE/SEC_DATA as specified |
| by the access_control_bits in the subspace header. */ |
| switch (subspace.access_control_bits >> 4) |
| { |
| /* Readonly data. */ |
| case 0x0: |
| subspace_asect->flags |= SEC_DATA | SEC_READONLY; |
| break; |
| |
| /* Normal data. */ |
| case 0x1: |
| subspace_asect->flags |= SEC_DATA; |
| break; |
| |
| /* Readonly code and the gateways. |
| Gateways have other attributes which do not map |
| into anything BFD knows about. */ |
| case 0x2: |
| case 0x4: |
| case 0x5: |
| case 0x6: |
| case 0x7: |
| subspace_asect->flags |= SEC_CODE | SEC_READONLY; |
| break; |
| |
| /* dynamic (writable) code. */ |
| case 0x3: |
| subspace_asect->flags |= SEC_CODE; |
| break; |
| } |
| |
| if (subspace.dup_common || subspace.is_common) |
| subspace_asect->flags |= SEC_IS_COMMON; |
| else if (subspace.subspace_length > 0) |
| subspace_asect->flags |= SEC_HAS_CONTENTS; |
| |
| if (subspace.is_loadable) |
| subspace_asect->flags |= SEC_ALLOC | SEC_LOAD; |
| else |
| subspace_asect->flags |= SEC_DEBUGGING; |
| |
| if (subspace.code_only) |
| subspace_asect->flags |= SEC_CODE; |
| |
| /* Both file_loc_init_value and initialization_length will |
| be zero for a BSS like subspace. */ |
| if (subspace.file_loc_init_value == 0 |
| && subspace.initialization_length == 0) |
| subspace_asect->flags &= ~(SEC_DATA | SEC_LOAD | SEC_HAS_CONTENTS); |
| |
| /* This subspace has relocations. |
| The fixup_request_quantity is a byte count for the number of |
| entries in the relocation stream; it is not the actual number |
| of relocations in the subspace. */ |
| if (subspace.fixup_request_quantity != 0) |
| { |
| subspace_asect->flags |= SEC_RELOC; |
| subspace_asect->rel_filepos = subspace.fixup_request_index; |
| som_section_data (subspace_asect)->reloc_size |
| = subspace.fixup_request_quantity; |
| /* We can not determine this yet. When we read in the |
| relocation table the correct value will be filled in. */ |
| subspace_asect->reloc_count = -1; |
| } |
| |
| /* Update save_subspace if appropriate. */ |
| if (subspace.file_loc_init_value > save_subspace.file_loc_init_value) |
| save_subspace = subspace; |
| |
| subspace_asect->vma = subspace.subspace_start; |
| subspace_asect->_cooked_size = subspace.subspace_length; |
| subspace_asect->_raw_size = subspace.subspace_length; |
| subspace_asect->filepos = (subspace.file_loc_init_value |
| + current_offset); |
| subspace_asect->alignment_power = log2 (subspace.alignment); |
| if (subspace_asect->alignment_power == -1) |
| goto error_return; |
| } |
| |
| /* This can happen for a .o which defines symbols in otherwise |
| empty subspaces. */ |
| if (!save_subspace.file_loc_init_value) |
| { |
| space_asect->_cooked_size = 0; |
| space_asect->_raw_size = 0; |
| } |
| else |
| { |
| /* Setup the sizes for the space section based upon the info in the |
| last subspace of the space. */ |
| space_asect->_cooked_size = (save_subspace.subspace_start |
| - space_asect->vma |
| + save_subspace.subspace_length); |
| space_asect->_raw_size = (save_subspace.file_loc_init_value |
| - space_asect->filepos |
| + save_subspace.initialization_length); |
| } |
| } |
| /* Now that we've read in all the subspace records, we need to assign |
| a target index to each subspace. */ |
| subspace_sections = (asection **) bfd_malloc (total_subspaces |
| * sizeof (asection *)); |
| if (subspace_sections == NULL) |
| goto error_return; |
| |
| for (i = 0, section = abfd->sections; section; section = section->next) |
| { |
| if (!som_is_subspace (section)) |
| continue; |
| |
| subspace_sections[i] = section; |
| i++; |
| } |
| qsort (subspace_sections, total_subspaces, |
| sizeof (asection *), compare_subspaces); |
| |
| /* subspace_sections is now sorted in the order in which the subspaces |
| appear in the object file. Assign an index to each one now. */ |
| for (i = 0; i < total_subspaces; i++) |
| subspace_sections[i]->target_index = i; |
| |
| if (space_strings != NULL) |
| free (space_strings); |
| |
| if (subspace_sections != NULL) |
| free (subspace_sections); |
| |
| return true; |
| |
| error_return: |
| if (space_strings != NULL) |
| free (space_strings); |
| |
| if (subspace_sections != NULL) |
| free (subspace_sections); |
| return false; |
| } |
| |
| /* Read in a SOM object and make it into a BFD. */ |
| |
| static const bfd_target * |
| som_object_p (abfd) |
| bfd *abfd; |
| { |
| struct header file_hdr; |
| struct som_exec_auxhdr aux_hdr; |
| unsigned long current_offset = 0; |
| struct lst_header lst_header; |
| struct som_entry som_entry; |
| #define ENTRY_SIZE sizeof (struct som_entry) |
| |
| if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| if (!_PA_RISC_ID (file_hdr.system_id)) |
| { |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| switch (file_hdr.a_magic) |
| { |
| case RELOC_MAGIC: |
| case EXEC_MAGIC: |
| case SHARE_MAGIC: |
| case DEMAND_MAGIC: |
| #ifdef DL_MAGIC |
| case DL_MAGIC: |
| #endif |
| #ifdef SHL_MAGIC |
| case SHL_MAGIC: |
| #endif |
| #ifdef SHARED_MAGIC_CNX |
| case SHARED_MAGIC_CNX: |
| #endif |
| break; |
| |
| #ifdef EXECLIBMAGIC |
| case EXECLIBMAGIC: |
| /* Read the lst header and determine where the SOM directory begins. */ |
| |
| if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) < 0) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| if (bfd_read ((PTR) & lst_header, 1, SLSTHDR, abfd) != SLSTHDR) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| /* Position to and read the first directory entry. */ |
| |
| if (bfd_seek (abfd, lst_header.dir_loc, SEEK_SET) < 0) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| if (bfd_read ((PTR) & som_entry, 1, ENTRY_SIZE, abfd) != ENTRY_SIZE) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| /* Now position to the first SOM. */ |
| |
| if (bfd_seek (abfd, som_entry.location, SEEK_SET) < 0) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| current_offset = som_entry.location; |
| |
| /* And finally, re-read the som header. */ |
| |
| if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| break; |
| #endif |
| |
| default: |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| if (file_hdr.version_id != VERSION_ID |
| && file_hdr.version_id != NEW_VERSION_ID) |
| { |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| |
| /* If the aux_header_size field in the file header is zero, then this |
| object is an incomplete executable (a .o file). Do not try to read |
| a non-existant auxiliary header. */ |
| memset (&aux_hdr, 0, sizeof (struct som_exec_auxhdr)); |
| if (file_hdr.aux_header_size != 0) |
| { |
| if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return 0; |
| } |
| } |
| |
| if (!setup_sections (abfd, &file_hdr, current_offset)) |
| { |
| /* setup_sections does not bubble up a bfd error code. */ |
| bfd_set_error (bfd_error_bad_value); |
| return 0; |
| } |
| |
| /* This appears to be a valid SOM object. Do some initialization. */ |
| return som_object_setup (abfd, &file_hdr, &aux_hdr, current_offset); |
| } |
| |
| /* Create a SOM object. */ |
| |
| static boolean |
| som_mkobject (abfd) |
| bfd *abfd; |
| { |
| /* Allocate memory to hold backend information. */ |
| abfd->tdata.som_data = (struct som_data_struct *) |
| bfd_zalloc (abfd, sizeof (struct som_data_struct)); |
| if (abfd->tdata.som_data == NULL) |
| return false; |
| return true; |
| } |
| |
| /* Initialize some information in the file header. This routine makes |
| not attempt at doing the right thing for a full executable; it |
| is only meant to handle relocatable objects. */ |
| |
| static boolean |
| som_prep_headers (abfd) |
| bfd *abfd; |
| { |
| struct header *file_hdr; |
| asection *section; |
| |
| /* Make and attach a file header to the BFD. */ |
| file_hdr = (struct header *) bfd_zalloc (abfd, sizeof (struct header)); |
| if (file_hdr == NULL) |
| return false; |
| obj_som_file_hdr (abfd) = file_hdr; |
| |
| if (abfd->flags & (EXEC_P | DYNAMIC)) |
| { |
| |
| /* Make and attach an exec header to the BFD. */ |
| obj_som_exec_hdr (abfd) = (struct som_exec_auxhdr *) |
| bfd_zalloc (abfd, sizeof (struct som_exec_auxhdr)); |
| if (obj_som_exec_hdr (abfd) == NULL) |
| return false; |
| |
| if (abfd->flags & D_PAGED) |
| file_hdr->a_magic = DEMAND_MAGIC; |
| else if (abfd->flags & WP_TEXT) |
| file_hdr->a_magic = SHARE_MAGIC; |
| #ifdef SHL_MAGIC |
| else if (abfd->flags & DYNAMIC) |
| file_hdr->a_magic = SHL_MAGIC; |
| #endif |
| else |
| file_hdr->a_magic = EXEC_MAGIC; |
| } |
| else |
| file_hdr->a_magic = RELOC_MAGIC; |
| |
| /* Only new format SOM is supported. */ |
| file_hdr->version_id = NEW_VERSION_ID; |
| |
| /* These fields are optional, and embedding timestamps is not always |
| a wise thing to do, it makes comparing objects during a multi-stage |
| bootstrap difficult. */ |
| file_hdr->file_time.secs = 0; |
| file_hdr->file_time.nanosecs = 0; |
| |
| file_hdr->entry_space = 0; |
| file_hdr->entry_subspace = 0; |
| file_hdr->entry_offset = 0; |
| file_hdr->presumed_dp = 0; |
| |
| /* Now iterate over the sections translating information from |
| BFD sections to SOM spaces/subspaces. */ |
| |
| for (section = abfd->sections; section != NULL; section = section->next) |
| { |
| /* Ignore anything which has not been marked as a space or |
| subspace. */ |
| if (!som_is_space (section) && !som_is_subspace (section)) |
| continue; |
| |
| if (som_is_space (section)) |
| { |
| /* Allocate space for the space dictionary. */ |
| som_section_data (section)->space_dict = |
| (struct space_dictionary_record *) |
| bfd_zalloc (abfd, sizeof (struct space_dictionary_record)); |
| if (som_section_data (section)->space_dict == NULL) |
| return false; |
| /* Set space attributes. Note most attributes of SOM spaces |
| are set based on the subspaces it contains. */ |
| som_section_data (section)->space_dict->loader_fix_index = -1; |
| som_section_data (section)->space_dict->init_pointer_index = -1; |
| |
| /* Set more attributes that were stuffed away in private data. */ |
| som_section_data (section)->space_dict->sort_key = |
| som_section_data (section)->copy_data->sort_key; |
| som_section_data (section)->space_dict->is_defined = |
| som_section_data (section)->copy_data->is_defined; |
| som_section_data (section)->space_dict->is_private = |
| som_section_data (section)->copy_data->is_private; |
| som_section_data (section)->space_dict->space_number = |
| som_section_data (section)->copy_data->space_number; |
| } |
| else |
| { |
| /* Allocate space for the subspace dictionary. */ |
| som_section_data (section)->subspace_dict |
| = (struct subspace_dictionary_record *) |
| bfd_zalloc (abfd, sizeof (struct subspace_dictionary_record)); |
| if (som_section_data (section)->subspace_dict == NULL) |
| return false; |
| |
| /* Set subspace attributes. Basic stuff is done here, additional |
| attributes are filled in later as more information becomes |
| available. */ |
| if (section->flags & SEC_IS_COMMON) |
| { |
| som_section_data (section)->subspace_dict->dup_common = 1; |
| som_section_data (section)->subspace_dict->is_common = 1; |
| } |
| |
| if (section->flags & SEC_ALLOC) |
| som_section_data (section)->subspace_dict->is_loadable = 1; |
| |
| if (section->flags & SEC_CODE) |
| som_section_data (section)->subspace_dict->code_only = 1; |
| |
| som_section_data (section)->subspace_dict->subspace_start = |
| section->vma; |
| som_section_data (section)->subspace_dict->subspace_length = |
| bfd_section_size (abfd, section); |
| som_section_data (section)->subspace_dict->initialization_length = |
| bfd_section_size (abfd, section); |
| som_section_data (section)->subspace_dict->alignment = |
| 1 << section->alignment_power; |
| |
| /* Set more attributes that were stuffed away in private data. */ |
| som_section_data (section)->subspace_dict->sort_key = |
| som_section_data (section)->copy_data->sort_key; |
| som_section_data (section)->subspace_dict->access_control_bits = |
| som_section_data (section)->copy_data->access_control_bits; |
| som_section_data (section)->subspace_dict->quadrant = |
| som_section_data (section)->copy_data->quadrant; |
| } |
| } |
| return true; |
| } |
| |
| /* Return true if the given section is a SOM space, false otherwise. */ |
| |
| static boolean |
| som_is_space (section) |
| asection *section; |
| { |
| /* If no copy data is available, then it's neither a space nor a |
| subspace. */ |
| if (som_section_data (section)->copy_data == NULL) |
| return false; |
| |
| /* If the containing space isn't the same as the given section, |
| then this isn't a space. */ |
| if (som_section_data (section)->copy_data->container != section |
| && (som_section_data (section)->copy_data->container->output_section |
| != section)) |
| return false; |
| |
| /* OK. Must be a space. */ |
| return true; |
| } |
| |
| /* Return true if the given section is a SOM subspace, false otherwise. */ |
| |
| static boolean |
| som_is_subspace (section) |
| asection *section; |
| { |
| /* If no copy data is available, then it's neither a space nor a |
| subspace. */ |
| if (som_section_data (section)->copy_data == NULL) |
| return false; |
| |
| /* If the containing space is the same as the given section, |
| then this isn't a subspace. */ |
| if (som_section_data (section)->copy_data->container == section |
| || (som_section_data (section)->copy_data->container->output_section |
| == section)) |
| return false; |
| |
| /* OK. Must be a subspace. */ |
| return true; |
| } |
| |
| /* Return true if the given space containins the given subspace. It |
| is safe to assume space really is a space, and subspace really |
| is a subspace. */ |
| |
| static boolean |
| som_is_container (space, subspace) |
| asection *space, *subspace; |
| { |
| return (som_section_data (subspace)->copy_data->container == space |
| || (som_section_data (subspace)->copy_data->container->output_section |
| == space)); |
| } |
| |
| /* Count and return the number of spaces attached to the given BFD. */ |
| |
| static unsigned long |
| som_count_spaces (abfd) |
| bfd *abfd; |
| { |
| int count = 0; |
| asection *section; |
| |
| for (section = abfd->sections; section != NULL; section = section->next) |
| count += som_is_space (section); |
| |
| return count; |
| } |
| |
| /* Count the number of subspaces attached to the given BFD. */ |
| |
| static unsigned long |
| som_count_subspaces (abfd) |
| bfd *abfd; |
| { |
| int count = 0; |
| asection *section; |
| |
| for (section = abfd->sections; section != NULL; section = section->next) |
| count += som_is_subspace (section); |
| |
| return count; |
| } |
| |
| /* Return -1, 0, 1 indicating the relative ordering of sym1 and sym2. |
| |
| We desire symbols to be ordered starting with the symbol with the |
| highest relocation count down to the symbol with the lowest relocation |
| count. Doing so compacts the relocation stream. */ |
| |
| static int |
| compare_syms (arg1, arg2) |
| const PTR arg1; |
| const PTR arg2; |
| |
| { |
| asymbol **sym1 = (asymbol **) arg1; |
| asymbol **sym2 = (asymbol **) arg2; |
| unsigned int count1, count2; |
| |
| /* Get relocation count for each symbol. Note that the count |
| is stored in the udata pointer for section symbols! */ |
| if ((*sym1)->flags & BSF_SECTION_SYM) |
| count1 = (*sym1)->udata.i; |
| else |
| count1 = som_symbol_data (*sym1)->reloc_count; |
| |
| if ((*sym2)->flags & BSF_SECTION_SYM) |
| count2 = (*sym2)->udata.i; |
| else |
| count2 = som_symbol_data (*sym2)->reloc_count; |
| |
| /* Return the appropriate value. */ |
| if (count1 < count2) |
| return 1; |
| else if (count1 > count2) |
| return -1; |
| return 0; |
| } |
| |
| /* Return -1, 0, 1 indicating the relative ordering of subspace1 |
| and subspace. */ |
| |
| static int |
| compare_subspaces (arg1, arg2) |
| const PTR arg1; |
| const PTR arg2; |
| |
| { |
| asection **subspace1 = (asection **) arg1; |
| asection **subspace2 = (asection **) arg2; |
| |
| if ((*subspace1)->target_index < (*subspace2)->target_index) |
| return -1; |
| else if ((*subspace2)->target_index < (*subspace1)->target_index) |
| return 1; |
| else |
| return 0; |
| } |
| |
| /* Perform various work in preparation for emitting the fixup stream. */ |
| |
| static void |
| som_prep_for_fixups (abfd, syms, num_syms) |
| bfd *abfd; |
| asymbol **syms; |
| unsigned long num_syms; |
| { |
| int i; |
| asection *section; |
| asymbol **sorted_syms; |
| |
| /* Most SOM relocations involving a symbol have a length which is |
| dependent on the index of the symbol. So symbols which are |
| used often in relocations should have a small index. */ |
| |
| /* First initialize the counters for each symbol. */ |
| for (i = 0; i < num_syms; i++) |
| { |
| /* Handle a section symbol; these have no pointers back to the |
| SOM symbol info. So we just use the udata field to hold the |
| relocation count. */ |
| if (som_symbol_data (syms[i]) == NULL |
| || syms[i]->flags & BSF_SECTION_SYM) |
| { |
| syms[i]->flags |= BSF_SECTION_SYM; |
| syms[i]->udata.i = 0; |
| } |
| else |
| som_symbol_data (syms[i])->reloc_count = 0; |
| } |
| |
| /* Now that the counters are initialized, make a weighted count |
| of how often a given symbol is used in a relocation. */ |
| for (section = abfd->sections; section != NULL; section = section->next) |
| { |
| int i; |
| |
| /* Does this section have any relocations? */ |
| if (section->reloc_count <= 0) |
| continue; |
| |
| /* Walk through each relocation for this section. */ |
| for (i = 1; i < section->reloc_count; i++) |
| { |
| arelent *reloc = section->orelocation[i]; |
| int scale; |
| |
| /* A relocation against a symbol in the *ABS* section really |
| does not have a symbol. Likewise if the symbol isn't associated |
| with any section. */ |
| if (reloc->sym_ptr_ptr == NULL |
| || bfd_is_abs_section ((*reloc->sym_ptr_ptr)->section)) |
| continue; |
| |
| /* Scaling to encourage symbols involved in R_DP_RELATIVE |
| and R_CODE_ONE_SYMBOL relocations to come first. These |
| two relocations have single byte versions if the symbol |
| index is very small. */ |
| if (reloc->howto->type == R_DP_RELATIVE |
| || reloc->howto->type == R_CODE_ONE_SYMBOL) |
| scale = 2; |
| else |
| scale = 1; |
| |
| /* Handle section symbols by storing the count in the udata |
| field. It will not be used and the count is very important |
| for these symbols. */ |
| if ((*reloc->sym_ptr_ptr)->flags & BSF_SECTION_SYM) |
| { |
| (*reloc->sym_ptr_ptr)->udata.i = |
| (*reloc->sym_ptr_ptr)->udata.i + scale; |
| continue; |
| } |
| |
| /* A normal symbol. Increment the count. */ |
| som_symbol_data (*reloc->sym_ptr_ptr)->reloc_count += scale; |
| } |
| } |
| |
| /* Sort a copy of the symbol table, rather than the canonical |
| output symbol table. */ |
| sorted_syms = (asymbol **) bfd_zalloc (abfd, num_syms * sizeof (asymbol *)); |
| memcpy (sorted_syms, syms, num_syms * sizeof (asymbol *)); |
| qsort (sorted_syms, num_syms, sizeof (asymbol *), compare_syms); |
| obj_som_sorted_syms (abfd) = sorted_syms; |
| |
| /* Compute the symbol indexes, they will be needed by the relocation |
| code. */ |
| for (i = 0; i < num_syms; i++) |
| { |
| /* A section symbol. Again, there is no pointer to backend symbol |
| information, so we reuse the udata field again. */ |
| if (sorted_syms[i]->flags & BSF_SECTION_SYM) |
| sorted_syms[i]->udata.i = i; |
| else |
| som_symbol_data (sorted_syms[i])->index = i; |
| } |
| } |
| |
| static boolean |
| som_write_fixups (abfd, current_offset, total_reloc_sizep) |
| bfd *abfd; |
| unsigned long current_offset; |
| unsigned int *total_reloc_sizep; |
| { |
| unsigned int i, j; |
| /* Chunk of memory that we can use as buffer space, then throw |
| away. */ |
| |