| /* bfd back-end for HP PA-RISC SOM objects. |
| Copyright (C) 1990-2021 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA |
| 02110-1301, USA. */ |
| |
| #include "sysdep.h" |
| #include "bfd.h" |
| #include "libiberty.h" |
| #include "libbfd.h" |
| #include "som.h" |
| #include "safe-ctype.h" |
| #include "som/reloc.h" |
| #include "aout/ar.h" |
| |
| static bfd_reloc_status_type hppa_som_reloc |
| (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); |
| static bool som_mkobject (bfd *); |
| static bool som_is_space (asection *); |
| static bool som_is_subspace (asection *); |
| static int compare_subspaces (const void *, const void *); |
| static uint32_t som_compute_checksum (struct som_external_header *); |
| static bool som_build_and_write_symbol_table (bfd *); |
| static unsigned int som_slurp_symbol_table (bfd *); |
| |
| /* 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) &~ ((unsigned long) (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. */ |
| static 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 |
| { |
| const 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; |
| unsigned int is_comdat; |
| unsigned int is_common; |
| unsigned int dup_common; |
| }; |
| |
| /* 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_PLABEL. */ |
| { 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_DATA_GPREL. */ |
| { 0, "L4=Sd=" }, /* 0x72 */ |
| /* R_RESERVED. */ |
| { 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=Ve=Ee=" }, /* 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=Vf=" }, /* 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). */ |
| |
| /* And these first appeared in hpux10. */ |
| #ifndef R_SHORT_PCREL_MODE |
| #define NO_PCREL_MODES |
| #define R_SHORT_PCREL_MODE 0x3e |
| #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_DATA_GPREL, "R_DATA_GPREL"), |
| 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 (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 (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 (struct reloc_queue *queue, unsigned int idx) |
| { |
| if (idx == 0) |
| return; |
| |
| if (idx == 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 (idx == 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 (idx == 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 (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 (bfd *abfd ATTRIBUTE_UNUSED, |
| unsigned 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 (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, (bfd_vma) 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, (bfd_vma) (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, (bfd_vma) 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 (bfd *abfd, |
| bfd_vma addend, |
| unsigned char *p, |
| unsigned int *subspace_reloc_sizep, |
| struct reloc_queue *queue) |
| { |
| if (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 (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 (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 (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, (bfd_vma) 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, |
| if X is a power of 2. Otherwise, returns -1. */ |
| |
| static int |
| exact_log2 (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 (bfd *abfd ATTRIBUTE_UNUSED, |
| arelent *reloc_entry, |
| asymbol *symbol_in ATTRIBUTE_UNUSED, |
| void *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; |
| } |
| |
| /* 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 (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 = bfd_alloc (abfd, (bfd_size_type) sizeof (int *) * 6); |
| final_type = bfd_alloc (abfd, (bfd_size_type) 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] = bfd_alloc (abfd, (bfd_size_type) 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] = bfd_alloc (abfd, (bfd_size_type) 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] = bfd_alloc (abfd, (bfd_size_type) 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] = bfd_alloc (abfd, (bfd_size_type) 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] = bfd_alloc (abfd, (bfd_size_type) 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] = bfd_alloc (abfd, (bfd_size_type) 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] = bfd_alloc (abfd, (bfd_size_type) sizeof (int)); |
| if (!final_types[0]) |
| return NULL; |
| *final_types[0] = R_N0SEL; |
| final_types[1] = bfd_alloc (abfd, (bfd_size_type) 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; |
| |
| /* FIXME: These two field selectors are not currently supported. */ |
| case e_ltpsel: |
| case e_rtpsel: |
| abort (); |
| } |
| |
| switch (base_type) |
| { |
| case R_HPPA: |
| /* The difference of two symbols needs *very* special handling. */ |
| if (sym_diff) |
| { |
| size_t amt = sizeof (int); |
| |
| final_types[0] = bfd_alloc (abfd, amt); |
| final_types[1] = bfd_alloc (abfd, amt); |
| final_types[2] = bfd_alloc (abfd, amt); |
| final_types[3] = bfd_alloc (abfd, amt); |
| 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; |
| else if (field == e_fsel && format == 32) |
| *final_type = R_DATA_GPREL; |
| break; |
| |
| case R_HPPA_COMPLEX: |
| /* The difference of two symbols needs *very* special handling. */ |
| if (sym_diff) |
| { |
| size_t amt = sizeof (int); |
| |
| final_types[0] = bfd_alloc (abfd, amt); |
| final_types[1] = bfd_alloc (abfd, amt); |
| final_types[2] = bfd_alloc (abfd, amt); |
| final_types[3] = bfd_alloc (abfd, amt); |
| 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 eliminated as the relocs are sized and emitted. */ |
| size_t amt = sizeof (int); |
| |
| final_types[0] = bfd_alloc (abfd, amt); |
| 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 (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 NULL; |
| } |
| |
| static reloc_howto_type * |
| som_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, |
| const char *r_name) |
| { |
| unsigned int i; |
| |
| for (i = 0; |
| i < sizeof (som_hppa_howto_table) / sizeof (som_hppa_howto_table[0]); |
| i++) |
| if (som_hppa_howto_table[i].name != NULL |
| && strcasecmp (som_hppa_howto_table[i].name, r_name) == 0) |
| return &som_hppa_howto_table[i]; |
| |
| return NULL; |
| } |
| |
| static void |
| som_swap_clock_in (struct som_external_clock *src, |
| struct som_clock *dst) |
| { |
| dst->secs = bfd_getb32 (src->secs); |
| dst->nanosecs = bfd_getb32 (src->nanosecs); |
| } |
| |
| static void |
| som_swap_clock_out (struct som_clock *src, |
| struct som_external_clock *dst) |
| { |
| bfd_putb32 (src->secs, dst->secs); |
| bfd_putb32 (src->nanosecs, dst->nanosecs); |
| } |
| |
| static void |
| som_swap_header_in (struct som_external_header *src, |
| struct som_header *dst) |
| { |
| dst->system_id = bfd_getb16 (src->system_id); |
| dst->a_magic = bfd_getb16 (src->a_magic); |
| dst->version_id = bfd_getb32 (src->version_id); |
| som_swap_clock_in (&src->file_time, &dst->file_time); |
| dst->entry_space = bfd_getb32 (src->entry_space); |
| dst->entry_subspace = bfd_getb32 (src->entry_subspace); |
| dst->entry_offset = bfd_getb32 (src->entry_offset); |
| dst->aux_header_location = bfd_getb32 (src->aux_header_location); |
| dst->aux_header_size = bfd_getb32 (src->aux_header_size); |
| dst->som_length = bfd_getb32 (src->som_length); |
| dst->presumed_dp = bfd_getb32 (src->presumed_dp); |
| dst->space_location = bfd_getb32 (src->space_location); |
| dst->space_total = bfd_getb32 (src->space_total); |
| dst->subspace_location = bfd_getb32 (src->subspace_location); |
| dst->subspace_total = bfd_getb32 (src->subspace_total); |
| dst->loader_fixup_location = bfd_getb32 (src->loader_fixup_location); |
| dst->loader_fixup_total = bfd_getb32 (src->loader_fixup_total); |
| dst->space_strings_location = bfd_getb32 (src->space_strings_location); |
| dst->space_strings_size = bfd_getb32 (src->space_strings_size); |
| dst->init_array_location = bfd_getb32 (src->init_array_location); |
| dst->init_array_total = bfd_getb32 (src->init_array_total); |
| dst->compiler_location = bfd_getb32 (src->compiler_location); |
| dst->compiler_total = bfd_getb32 (src->compiler_total); |
| dst->symbol_location = bfd_getb32 (src->symbol_location); |
| dst->symbol_total = bfd_getb32 (src->symbol_total); |
| dst->fixup_request_location = bfd_getb32 (src->fixup_request_location); |
| dst->fixup_request_total = bfd_getb32 (src->fixup_request_total); |
| dst->symbol_strings_location = bfd_getb32 (src->symbol_strings_location); |
| dst->symbol_strings_size = bfd_getb32 (src->symbol_strings_size); |
| dst->unloadable_sp_location = bfd_getb32 (src->unloadable_sp_location); |
| dst->unloadable_sp_size = bfd_getb32 (src->unloadable_sp_size); |
| dst->checksum = bfd_getb32 (src->checksum); |
| } |
| |
| static void |
| som_swap_header_out (struct som_header *src, |
| struct som_external_header *dst) |
| { |
| bfd_putb16 (src->system_id, dst->system_id); |
| bfd_putb16 (src->a_magic, dst->a_magic); |
| bfd_putb32 (src->version_id, dst->version_id); |
| som_swap_clock_out (&src->file_time, &dst->file_time); |
| bfd_putb32 (src->entry_space, dst->entry_space); |
| bfd_putb32 (src->entry_subspace, dst->entry_subspace); |
| bfd_putb32 (src->entry_offset, dst->entry_offset); |
| bfd_putb32 (src->aux_header_location, dst->aux_header_location); |
| bfd_putb32 (src->aux_header_size, dst->aux_header_size); |
| bfd_putb32 (src->som_length, dst->som_length); |
| bfd_putb32 (src->presumed_dp, dst->presumed_dp); |
| bfd_putb32 (src->space_location, dst->space_location); |
| bfd_putb32 (src->space_total, dst->space_total); |
| bfd_putb32 (src->subspace_location, dst->subspace_location); |
| bfd_putb32 (src->subspace_total, dst->subspace_total); |
| bfd_putb32 (src->loader_fixup_location, dst->loader_fixup_location); |
| bfd_putb32 (src->loader_fixup_total, dst->loader_fixup_total); |
| bfd_putb32 (src->space_strings_location, dst->space_strings_location); |
| bfd_putb32 (src->space_strings_size, dst->space_strings_size); |
| bfd_putb32 (src->init_array_location, dst->init_array_location); |
| bfd_putb32 (src->init_array_total, dst->init_array_total); |
| bfd_putb32 (src->compiler_location, dst->compiler_location); |
| bfd_putb32 (src->compiler_total, dst->compiler_total); |
| bfd_putb32 (src->symbol_location, dst->symbol_location); |
| bfd_putb32 (src->symbol_total, dst->symbol_total); |
| bfd_putb32 (src->fixup_request_location, dst->fixup_request_location); |
| bfd_putb32 (src->fixup_request_total, dst->fixup_request_total); |
| bfd_putb32 (src->symbol_strings_location, dst->symbol_strings_location); |
| bfd_putb32 (src->symbol_strings_size, dst->symbol_strings_size); |
| bfd_putb32 (src->unloadable_sp_location, dst->unloadable_sp_location); |
| bfd_putb32 (src->unloadable_sp_size, dst->unloadable_sp_size); |
| bfd_putb32 (src->checksum, dst->checksum); |
| } |
| |
| static void |
| som_swap_space_dictionary_in (struct som_external_space_dictionary_record *src, |
| struct som_space_dictionary_record *dst) |
| { |
| unsigned int flags; |
| |
| dst->name = bfd_getb32 (src->name); |
| flags = bfd_getb32 (src->flags); |
| dst->is_loadable = (flags & SOM_SPACE_IS_LOADABLE) != 0; |
| dst->is_defined = (flags & SOM_SPACE_IS_DEFINED) != 0; |
| dst->is_private = (flags & SOM_SPACE_IS_PRIVATE) != 0; |
| dst->has_intermediate_code = (flags & SOM_SPACE_HAS_INTERMEDIATE_CODE) != 0; |
| dst->is_tspecific = (flags & SOM_SPACE_IS_TSPECIFIC) != 0; |
| dst->reserved = 0; |
| dst->sort_key = (flags >> SOM_SPACE_SORT_KEY_SH) & SOM_SPACE_SORT_KEY_MASK; |
| dst->reserved2 = 0; |
| dst->space_number = bfd_getb32 (src->space_number); |
| dst->subspace_index = bfd_getb32 (src->subspace_index); |
| dst->subspace_quantity = bfd_getb32 (src->subspace_quantity); |
| dst->loader_fix_index = bfd_getb32 (src->loader_fix_index); |
| dst->loader_fix_quantity = bfd_getb32 (src->loader_fix_quantity); |
| dst->init_pointer_index = bfd_getb32 (src->init_pointer_index); |
| dst->init_pointer_quantity = bfd_getb32 (src->init_pointer_quantity); |
| } |
| |
| static void |
| som_swap_space_dictionary_out (struct som_space_dictionary_record *src, |
| struct som_external_space_dictionary_record *dst) |
| { |
| unsigned int flags; |
| |
| bfd_putb32 (src->name, dst->name); |
| |
| flags = 0; |
| if (src->is_loadable) |
| flags |= SOM_SPACE_IS_LOADABLE; |
| if (src->is_defined) |
| flags |= SOM_SPACE_IS_DEFINED; |
| if (src->is_private) |
| flags |= SOM_SPACE_IS_PRIVATE; |
| if (src->has_intermediate_code) |
| flags |= SOM_SPACE_HAS_INTERMEDIATE_CODE; |
| if (src->is_tspecific) |
| flags |= SOM_SPACE_IS_TSPECIFIC; |
| flags |= (src->sort_key & SOM_SPACE_SORT_KEY_MASK) << SOM_SPACE_SORT_KEY_SH; |
| bfd_putb32 (flags, dst->flags); |
| bfd_putb32 (src->space_number, dst->space_number); |
| bfd_putb32 (src->subspace_index, dst->subspace_index); |
| bfd_putb32 (src->subspace_quantity, dst->subspace_quantity); |
| bfd_putb32 (src->loader_fix_index, dst->loader_fix_index); |
| bfd_putb32 (src->loader_fix_quantity, dst->loader_fix_quantity); |
| bfd_putb32 (src->init_pointer_index, dst->init_pointer_index); |
| bfd_putb32 (src->init_pointer_quantity, dst->init_pointer_quantity); |
| } |
| |
| static void |
| som_swap_subspace_dictionary_in |
| (struct som_external_subspace_dictionary_record *src, |
| struct som_subspace_dictionary_record *dst) |
| { |
| unsigned int flags; |
| dst->space_index = bfd_getb32 (src->space_index); |
| flags = bfd_getb32 (src->flags); |
| dst->access_control_bits = (flags >> SOM_SUBSPACE_ACCESS_CONTROL_BITS_SH) |
| & SOM_SUBSPACE_ACCESS_CONTROL_BITS_MASK; |
| dst->memory_resident = (flags & SOM_SUBSPACE_MEMORY_RESIDENT) != 0; |
| dst->dup_common = (flags & SOM_SUBSPACE_DUP_COMMON) != 0; |
| dst->is_common = (flags & SOM_SUBSPACE_IS_COMMON) != 0; |
| dst->is_loadable = (flags & SOM_SUBSPACE_IS_LOADABLE) != 0; |
| dst->quadrant = (flags >> SOM_SUBSPACE_QUADRANT_SH) |
| & SOM_SUBSPACE_QUADRANT_MASK; |
| dst->initially_frozen = (flags & SOM_SUBSPACE_INITIALLY_FROZEN) != 0; |
| dst->is_first = (flags & SOM_SUBSPACE_IS_FIRST) != 0; |
| dst->code_only = (flags & SOM_SUBSPACE_CODE_ONLY) != 0; |
| dst->sort_key = (flags >> SOM_SUBSPACE_SORT_KEY_SH) |
| & SOM_SUBSPACE_SORT_KEY_MASK; |
| dst->replicate_init = (flags & SOM_SUBSPACE_REPLICATE_INIT) != 0; |
| dst->continuation = (flags & SOM_SUBSPACE_CONTINUATION) != 0; |
| dst->is_tspecific = (flags & SOM_SUBSPACE_IS_TSPECIFIC) != 0; |
| dst->is_comdat = (flags & SOM_SUBSPACE_IS_COMDAT) != 0; |
| dst->reserved = 0; |
| dst->file_loc_init_value = bfd_getb32 (src->file_loc_init_value); |
| dst->initialization_length = bfd_getb32 (src->initialization_length); |
| dst->subspace_start = bfd_getb32 (src->subspace_start); |
| dst->subspace_length = bfd_getb32 (src->subspace_length); |
| dst->alignment = bfd_getb32 (src->alignment); |
| dst->name = bfd_getb32 (src->name); |
| dst->fixup_request_index = bfd_getb32 (src->fixup_request_index); |
| dst->fixup_request_quantity = bfd_getb32 (src->fixup_request_quantity); |
| } |
| |
| static void |
| som_swap_subspace_dictionary_record_out |
| (struct som_subspace_dictionary_record *src, |
| struct som_external_subspace_dictionary_record *dst) |
| { |
| unsigned int flags; |
| |
| bfd_putb32 (src->space_index, dst->space_index); |
| flags = (src->access_control_bits & SOM_SUBSPACE_ACCESS_CONTROL_BITS_MASK) |
| << SOM_SUBSPACE_ACCESS_CONTROL_BITS_SH; |
| if (src->memory_resident) |
| flags |= SOM_SUBSPACE_MEMORY_RESIDENT; |
| if (src->dup_common) |
| flags |= SOM_SUBSPACE_DUP_COMMON; |
| if (src->is_common) |
| flags |= SOM_SUBSPACE_IS_COMMON; |
| if (src->is_loadable) |
| flags |= SOM_SUBSPACE_IS_LOADABLE; |
| flags |= (src->quadrant & SOM_SUBSPACE_QUADRANT_MASK) |
| << SOM_SUBSPACE_QUADRANT_SH; |
| if (src->initially_frozen) |
| flags |= SOM_SUBSPACE_INITIALLY_FROZEN; |
| if (src->is_first) |
| flags |= SOM_SUBSPACE_IS_FIRST; |
| if (src->code_only) |
| flags |= SOM_SUBSPACE_CODE_ONLY; |
| flags |= (src->sort_key & SOM_SUBSPACE_SORT_KEY_MASK) |
| << SOM_SUBSPACE_SORT_KEY_SH; |
| if (src->replicate_init) |
| flags |= SOM_SUBSPACE_REPLICATE_INIT; |
| if (src->continuation) |
| flags |= SOM_SUBSPACE_CONTINUATION; |
| if (src->is_tspecific) |
| flags |= SOM_SUBSPACE_IS_TSPECIFIC; |
| if (src->is_comdat) |
| flags |= SOM_SUBSPACE_IS_COMDAT; |
| bfd_putb32 (flags, dst->flags); |
| bfd_putb32 (src->file_loc_init_value, dst->file_loc_init_value); |
| bfd_putb32 (src->initialization_length, dst->initialization_length); |
| bfd_putb32 (src->subspace_start, dst->subspace_start); |
| bfd_putb32 (src->subspace_length, dst->subspace_length); |
| bfd_putb32 (src->alignment, dst->alignment); |
| bfd_putb32 (src->name, dst->name); |
| bfd_putb32 (src->fixup_request_index, dst->fixup_request_index); |
| bfd_putb32 (src->fixup_request_quantity, dst->fixup_request_quantity); |
| } |
| |
| static void |
| som_swap_aux_id_in (struct som_external_aux_id *src, |
| struct som_aux_id *dst) |
| { |
| unsigned int flags = bfd_getb32 (src->flags); |
| |
| dst->mandatory = (flags & SOM_AUX_ID_MANDATORY) != 0; |
| dst->copy = (flags & SOM_AUX_ID_COPY) != 0; |
| dst->append = (flags & SOM_AUX_ID_APPEND) != 0; |
| dst->ignore = (flags & SOM_AUX_ID_IGNORE) != 0; |
| dst->type = (flags >> SOM_AUX_ID_TYPE_SH) & SOM_AUX_ID_TYPE_MASK; |
| dst->length = bfd_getb32 (src->length); |
| } |
| |
| static void |
| som_swap_aux_id_out (struct som_aux_id *src, |
| struct som_external_aux_id *dst) |
| { |
| unsigned int flags = 0; |
| |
| if (src->mandatory) |
| flags |= SOM_AUX_ID_MANDATORY; |
| if (src->copy) |
| flags |= SOM_AUX_ID_COPY; |
| if (src->append) |
| flags |= SOM_AUX_ID_APPEND; |
| if (src->ignore) |
| flags |= SOM_AUX_ID_IGNORE; |
| flags |= (src->type & SOM_AUX_ID_TYPE_MASK) << SOM_AUX_ID_TYPE_SH; |
| bfd_putb32 (flags, dst->flags); |
| bfd_putb32 (src->length, dst->length); |
| } |
| |
| static void |
| som_swap_string_auxhdr_out (struct som_string_auxhdr *src, |
| struct som_external_string_auxhdr *dst) |
| { |
| som_swap_aux_id_out (&src->header_id, &dst->header_id); |
| bfd_putb32 (src->string_length, dst->string_length); |
| } |
| |
| static void |
| som_swap_compilation_unit_out (struct som_compilation_unit *src, |
| struct som_external_compilation_unit *dst) |
| { |
| bfd_putb32 (src->name.strx, dst->name); |
| bfd_putb32 (src->language_name.strx, dst->language_name); |
| bfd_putb32 (src->product_id.strx, dst->product_id); |
| bfd_putb32 (src->version_id.strx, dst->version_id); |
| bfd_putb32 (src->flags, dst->flags); |
| som_swap_clock_out (&src->compile_time, &dst->compile_time); |
| som_swap_clock_out (&src->source_time, &dst->source_time); |
| } |
| |
| static void |
| som_swap_exec_auxhdr_in (struct som_external_exec_auxhdr *src, |
| struct som_exec_auxhdr *dst) |
| { |
| som_swap_aux_id_in (&src->som_auxhdr, &dst->som_auxhdr); |
| dst->exec_tsize = bfd_getb32 (src->exec_tsize); |
| dst->exec_tmem = bfd_getb32 (src->exec_tmem); |
| dst->exec_tfile = bfd_getb32 (src->exec_tfile); |
| dst->exec_dsize = bfd_getb32 (src->exec_dsize); |
| dst->exec_dmem = bfd_getb32 (src->exec_dmem); |
| dst->exec_dfile = bfd_getb32 (src->exec_dfile); |
| dst->exec_bsize = bfd_getb32 (src->exec_bsize); |
| dst->exec_entry = bfd_getb32 (src->exec_entry); |
| dst->exec_flags = bfd_getb32 (src->exec_flags); |
| dst->exec_bfill = bfd_getb32 (src->exec_bfill); |
| } |
| |
| static void |
| som_swap_exec_auxhdr_out (struct som_exec_auxhdr *src, |
| struct som_external_exec_auxhdr *dst) |
| { |
| som_swap_aux_id_out (&src->som_auxhdr, &dst->som_auxhdr); |
| bfd_putb32 (src->exec_tsize, dst->exec_tsize); |
| bfd_putb32 (src->exec_tmem, dst->exec_tmem); |
| bfd_putb32 (src->exec_tfile, dst->exec_tfile); |
| bfd_putb32 (src->exec_dsize, dst->exec_dsize); |
| bfd_putb32 (src->exec_dmem, dst->exec_dmem); |
| bfd_putb32 (src->exec_dfile, dst->exec_dfile); |
| bfd_putb32 (src->exec_bsize, dst->exec_bsize); |
| bfd_putb32 (src->exec_entry, dst->exec_entry); |
| bfd_putb32 (src->exec_flags, dst->exec_flags); |
| bfd_putb32 (src->exec_bfill, dst->exec_bfill); |
| } |
| |
| static void |
| som_swap_lst_header_in (struct som_external_lst_header *src, |
| struct som_lst_header *dst) |
| { |
| dst->system_id = bfd_getb16 (src->system_id); |
| dst->a_magic = bfd_getb16 (src->a_magic); |
| dst->version_id = bfd_getb32 (src->version_id); |
| som_swap_clock_in (&src->file_time, &dst->file_time); |
| dst->hash_loc = bfd_getb32 (src->hash_loc); |
| dst->hash_size = bfd_getb32 (src->hash_size); |
| dst->module_count = bfd_getb32 (src->module_count); |
| dst->module_limit = bfd_getb32 (src->module_limit); |
| dst->dir_loc = bfd_getb32 (src->dir_loc); |
| dst->export_loc = bfd_getb32 (src->export_loc); |
| dst->export_count = bfd_getb32 (src->export_count); |
| dst->import_loc = bfd_getb32 (src->import_loc); |
| dst->aux_loc = bfd_getb32 (src->aux_loc); |
| dst->aux_size = bfd_getb32 (src->aux_size); |
| dst->string_loc = bfd_getb32 (src->string_loc); |
| dst->string_size = bfd_getb32 (src->string_size); |
| dst->free_list = bfd_getb32 (src->free_list); |
| dst->file_end = bfd_getb32 (src->file_end); |
| dst->checksum = bfd_getb32 (src->checksum); |
| } |
| |
| /* Perform some initialization for an object. Save results of this |
| initialization in the BFD. */ |
| |
| static bfd_cleanup |
| som_object_setup (bfd *abfd, |
| struct som_header *file_hdrp, |
| struct som_exec_auxhdr *aux_hdrp, |
| unsigned long current_offset) |
| { |
| asection *section; |
| |
| /* som_mkobject will set bfd_error if som_mkobject fails. */ |
| if (! som_mkobject (abfd)) |
| return NULL; |
| |
| /* 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; |
| } |
| |
| /* Save the auxiliary header. */ |
| obj_som_exec_hdr (abfd) = aux_hdrp; |
| |
| /* Allocate space to hold the saved exec header information. */ |
| obj_som_exec_data (abfd) = bfd_zalloc (abfd, (bfd_size_type) 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 for an executable. If |
| it is not 4-byte aligned then it's not a proper code address and |
| we guess it's really the executable flags. For a main program, |
| we also consider zero to be indicative of a buggy linker, since |
| that is not a valid entry point. The entry point for a shared |
| library, however, can be zero so we do not consider that to be |
| indicative of a buggy linker. */ |
| if (aux_hdrp) |
| { |
| int found = 0; |
| |
| for (section = abfd->sections; section; section = section->next) |
| { |
| bfd_vma entry; |
| |
| if ((section->flags & SEC_CODE) == 0) |
| continue; |
| entry = aux_hdrp->exec_entry + aux_hdrp->exec_tmem; |
| if (entry >= section->vma |
| && entry < section->vma + section->size) |
| found = 1; |
| } |
| if ((aux_hdrp->exec_entry == 0 && !(abfd->flags & DYNAMIC)) |
| || (aux_hdrp->exec_entry & 0x3) != 0 |
| || ! found) |
| { |
| abfd->start_address = aux_hdrp->exec_flags; |
| obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_entry; |
| } |
| else |
| { |
| abfd->start_address = aux_hdrp->exec_entry + current_offset; |
| obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_flags; |
| } |
| } |
| |
| obj_som_exec_data (abfd)->version_id = file_hdrp->version_id; |
| |
| bfd_default_set_arch_mach (abfd, bfd_arch_hppa, pa10); |
| abfd->symcount = 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) = NULL; |
| obj_som_symtab (abfd) = 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 _bfd_no_cleanup; |
| } |
| |
| /* 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 bool |
| setup_sections (bfd *abfd, |
| struct som_header *file_hdr, |
| unsigned long current_offset) |
| { |
| char *space_strings = NULL; |
| unsigned int space_index, i; |
| unsigned int total_subspaces = 0; |
| asection **subspace_sections = NULL; |
| asection *section; |
| size_t amt; |
| |
| /* First, read in space names. */ |
| amt = file_hdr->space_strings_size; |
| if (amt == (size_t) -1) |
| { |
| bfd_set_error (bfd_error_no_memory); |
| goto error_return; |
| } |
| if (bfd_seek (abfd, current_offset + file_hdr->space_strings_location, |
| SEEK_SET) != 0) |
| goto error_return; |
| space_strings = (char *) _bfd_malloc_and_read (abfd, amt + 1, amt); |
| if (space_strings == NULL) |
| goto error_return; |
| /* Make sure that the string table is NUL terminated. */ |
| space_strings[amt] = 0; |
| |
| /* Loop over all of the space dictionaries, building up sections. */ |
| for (space_index = 0; space_index < file_hdr->space_total; space_index++) |
| { |
| struct som_space_dictionary_record space; |
| struct som_external_space_dictionary_record ext_space; |
| char *space_name; |
| struct som_external_subspace_dictionary_record ext_subspace; |
| struct som_subspace_dictionary_record subspace, save_subspace; |
| unsigned int subspace_index; |
| asection *space_asect; |
| bfd_size_type space_size = 0; |
| char *newname; |
| |
| /* Read the space dictionary element. */ |
| if (bfd_seek (abfd, |
| (current_offset + file_hdr->space_location |
| + space_index * sizeof (ext_space)), |
| SEEK_SET) != 0) |
| goto error_return; |
| amt = sizeof ext_space; |
| if (bfd_bread (&ext_space, amt, abfd) != amt) |
| goto error_return; |
| |
| som_swap_space_dictionary_in (&ext_space, &space); |
| |
| /* Setup the space name string. */ |
| if (space.name >= file_hdr->space_strings_size) |
| goto error_return; |
| |
| space_name = space.name + space_strings; |
| |
| /* Make a section out of it. */ |
| amt = strlen (space_name) + 1; |
| newname = bfd_alloc (abfd, amt); |
| if (!newname) |
| goto error_return; |
| strcpy (newname, space_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)) |
| 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 ext_subspace), |
| SEEK_SET) != 0) |
| goto error_return; |
| amt = sizeof ext_subspace; |
| if (bfd_bread (&ext_subspace, amt, abfd) != amt) |
| 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 ext_subspace), |
| SEEK_SET) != 0) |
| goto error_return; |
| |
| som_swap_subspace_dictionary_in (&ext_subspace, &subspace); |
| |
| /* 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 = exact_log2 (subspace.alignment); |
| if (space_asect->alignment_power == (unsigned) -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 (save_subspace)); |
| |
| /* 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; |
| char *subspace_name; |
| |
| /* Read in the next subspace. */ |
| amt = sizeof ext_subspace; |
| if (bfd_bread (&ext_subspace, amt, abfd) != amt) |
| goto error_return; |
| |
| som_swap_subspace_dictionary_in (&ext_subspace, &subspace); |
| |
| /* Setup the subspace name string. */ |
| if (subspace.name >= file_hdr->space_strings_size) |
| goto error_return; |
| |
| subspace_name = subspace.name + space_strings; |
| |
| amt = strlen (subspace_name) + 1; |
| newname = bfd_alloc (abfd, amt); |
| if (!newname) |
| goto error_return; |
| strcpy (newname, subspace_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, |
| subspace.is_comdat, |
| subspace.is_common, |
| subspace.dup_common)) |
| 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.is_comdat || subspace.is_common || subspace.dup_common) |
| subspace_asect->flags |= SEC_LINK_ONCE; |
| |
| 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 = (unsigned) -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->size = subspace.subspace_length; |
| subspace_asect->filepos = (subspace.file_loc_init_value |
| + current_offset); |
| subspace_asect->alignment_power = exact_log2 (subspace.alignment); |
| if (subspace_asect->alignment_power == (unsigned) -1) |
| goto error_return; |
| |
| /* Keep track of the accumulated sizes of the sections. */ |
| space_size += subspace.subspace_length; |
| } |
| |
| /* This can happen for a .o which defines symbols in otherwise |
| empty subspaces. */ |
| if (!save_subspace.file_loc_init_value) |
| space_asect->size = 0; |
| else |
| { |
| if (file_hdr->a_magic != RELOC_MAGIC) |
| { |
| /* Setup the size for the space section based upon the info |
| in the last subspace of the space. */ |
| space_asect->size = (save_subspace.subspace_start |
| - space_asect->vma |
| + save_subspace.subspace_length); |
| } |
| else |
| { |
| /* The subspace_start field is not initialised in relocatable |
| only objects, so it cannot be used for length calculations. |
| Instead we use the space_size value which we have been |
| accumulating. This isn't an accurate estimate since it |
| ignores alignment and ordering issues. */ |
| space_asect->size = space_size; |
| } |
| } |
| } |
| /* Now that we've read in all the subspace records, we need to assign |
| a target index to each subspace. */ |
| if (_bfd_mul_overflow (total_subspaces, sizeof (asection *), &amt)) |
| { |
| bfd_set_error (bfd_error_file_too_big); |
| goto error_return; |
| } |
| subspace_sections = bfd_malloc (amt); |
| 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; |
| |
| free (space_strings); |
| free (subspace_sections); |
| return true; |
| |
| error_return: |
| free (space_strings); |
| free (subspace_sections); |
| return false; |
| } |
| |
| |
| /* Read in a SOM object and make it into a BFD. */ |
| |
| static bfd_cleanup |
| som_object_p (bfd *abfd) |
| { |
| struct som_external_header ext_file_hdr; |
| struct som_header file_hdr; |
| struct som_exec_auxhdr *aux_hdr_ptr = NULL; |
| unsigned long current_offset = 0; |
| struct som_external_lst_header ext_lst_header; |
| struct som_external_som_entry ext_som_entry; |
| size_t amt; |
| unsigned int loc; |
| #define ENTRY_SIZE sizeof (struct som_external_som_entry) |
| |
| amt = sizeof (struct som_external_header); |
| if (bfd_bread (&ext_file_hdr, amt, abfd) != amt) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| som_swap_header_in (&ext_file_hdr, &file_hdr); |
| |
| if (!_PA_RISC_ID (file_hdr.system_id)) |
| { |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| switch (file_hdr.a_magic) |
| { |
| case RELOC_MAGIC: |
| case EXEC_MAGIC: |
| case SHARE_MAGIC: |
| case DEMAND_MAGIC: |
| case DL_MAGIC: |
| case SHL_MAGIC: |
| #ifdef SHARED_MAGIC_CNX |
| case SHARED_MAGIC_CNX: |
| #endif |
| break; |
| |
| 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 NULL; |
| } |
| |
| amt = sizeof (struct som_external_lst_header); |
| if (bfd_bread (&ext_lst_header, amt, abfd) != amt) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| /* Position to and read the first directory entry. */ |
| loc = bfd_getb32 (ext_lst_header.dir_loc); |
| if (bfd_seek (abfd, loc, SEEK_SET) != 0) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| amt = ENTRY_SIZE; |
| if (bfd_bread (&ext_som_entry, amt, abfd) != amt) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| /* Now position to the first SOM. */ |
| current_offset = bfd_getb32 (ext_som_entry.location); |
| if (bfd_seek (abfd, current_offset, SEEK_SET) != 0) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| /* And finally, re-read the som header. */ |
| amt = sizeof (struct som_external_header); |
| if (bfd_bread (&ext_file_hdr, amt, abfd) != amt) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| som_swap_header_in (&ext_file_hdr, &file_hdr); |
| |
| break; |
| |
| default: |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| if (file_hdr.version_id != OLD_VERSION_ID |
| && file_hdr.version_id != NEW_VERSION_ID) |
| { |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| |
| /* 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. */ |
| if (file_hdr.aux_header_size != 0) |
| { |
| struct som_external_exec_auxhdr ext_exec_auxhdr; |
| |
| aux_hdr_ptr = bfd_zalloc (abfd, |
| (bfd_size_type) sizeof (*aux_hdr_ptr)); |
| if (aux_hdr_ptr == NULL) |
| return NULL; |
| amt = sizeof (struct som_external_exec_auxhdr); |
| if (bfd_bread (&ext_exec_auxhdr, amt, abfd) != amt) |
| { |
| if (bfd_get_error () != bfd_error_system_call) |
| bfd_set_error (bfd_error_wrong_format); |
| return NULL; |
| } |
| som_swap_exec_auxhdr_in (&ext_exec_auxhdr, aux_hdr_ptr); |
| } |
| |
| 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 NULL; |
| } |
| |
| /* This appears to be a valid SOM object. Do some initialization. */ |
| return som_object_setup (abfd, &file_hdr, aux_hdr_ptr, current_offset); |
| } |
| |
| /* Create a SOM object. */ |
| |
| static bool |
| som_mkobject (bfd *abfd) |
| { |
| /* Allocate memory to hold backend information. */ |
| abfd->tdata.som_data = bfd_zalloc (abfd, (bfd_size_type) 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 bool |
| som_prep_headers (bfd *abfd) |
| { |
| struct som_header *file_hdr; |
| asection *section; |
| size_t amt = sizeof (struct som_header); |
| |
| /* Make and attach a file header to the BFD. */ |
| file_hdr = bfd_zalloc (abfd, amt); |
| 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. */ |
| amt = sizeof (struct som_exec_auxhdr); |
| obj_som_exec_hdr (abfd) = bfd_zalloc (abfd, amt); |
| 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; |
| |
| /* 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. */ |
| amt = sizeof (struct som_space_dictionary_record); |
| som_section_data (section)->space_dict = bfd_zalloc (abfd, amt); |
| 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. */ |
| amt = sizeof (struct som_subspace_dictionary_record); |
| som_section_data (section)->subspace_dict = bfd_zalloc (abfd, amt); |
| 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_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 = |
| section->size; |
| som_section_data (section)->subspace_dict->initialization_length = |
| section->size; |
| 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; |
| som_section_data (section)->subspace_dict->is_comdat = |
| som_section_data (section)->copy_data->is_comdat; |
| som_section_data (section)->subspace_dict->is_common = |
| som_section_data (section)->copy_data->is_common; |
| som_section_data (section)->subspace_dict->dup_common = |
| som_section_data (section)->copy_data->dup_common; |
| } |
| } |
| return true; |
| } |
| |
| /* Return TRUE if the given section is a SOM space, FALSE otherwise. */ |
| |
| static bool |
| som_is_space (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 bool |
| som_is_subspace (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 contains the given subspace. It |
| is safe to assume space really is a space, and subspace really |
| is a subspace. */ |
| |
| static bool |
| som_is_container (asection *space, asection *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 (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 (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 (const void *arg1, const void *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 (const void *arg1, const void *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 bool |
| som_prep_for_fixups (bfd *abfd, asymbol **syms, unsigned long num_syms) |
| { |
| unsigned long i; |
| asection *section; |
| asymbol **sorted_syms; |
| size_t amt; |
| |
| if (num_syms == 0) |
| return true; |
| |
| /* 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 =
|