1 /* BFD back-end for HP PA-RISC ELF files. 2 Copyright (C) 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc. 3 4 Written by 5 6 Center for Software Science 7 Department of Computer Science 8 University of Utah 9 10 This file is part of BFD, the Binary File Descriptor library. 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 2 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 25 26 #include "bfd.h" 27 #include "sysdep.h" 28 #include "bfdlink.h" 29 #include "libbfd.h" 30 #include "obstack.h" 31 #include "elf-bfd.h" 32 33 /* The internal type of a symbol table extension entry. */ 34 typedef unsigned long symext_entryS; 35 36 /* The external type of a symbol table extension entry. */ 37 #define ELF32_PARISC_SX_SIZE (4) 38 #define ELF32_PARISC_SX_GET(bfd, addr) bfd_h_get_32 ((bfd), (addr)) 39 #define ELF32_PARISC_SX_PUT(bfd, val, addr) \ 40 bfd_h_put_32 ((bfd), (val), (addr)) 41 42 /* HPPA symbol table extension entry types */ 43 enum elf32_hppa_symextn_types 44 { 45 PARISC_SXT_NULL, 46 PARISC_SXT_SYMNDX, 47 PARISC_SXT_ARG_RELOC, 48 }; 49 50 /* These macros compose and decompose the value of a symextn entry: 51 52 entry_type = ELF32_PARISC_SX_TYPE(word); 53 entry_value = ELF32_PARISC_SX_VAL(word); 54 word = ELF32_PARISC_SX_WORD(type,val); */ 55 56 #define ELF32_PARISC_SX_TYPE(p) ((p) >> 24) 57 #define ELF32_PARISC_SX_VAL(p) ((p) & 0xFFFFFF) 58 #define ELF32_PARISC_SX_WORD(type,val) (((type) << 24) + (val & 0xFFFFFF)) 59 60 /* The following was added facilitate implementation of the .hppa_symextn 61 section. This section is built after the symbol table is built in the 62 elf_write_object_contents routine (called from bfd_close). It is built 63 so late because it requires information that is not known until 64 the symbol and string table sections have been allocated, and 65 the symbol table has been built. */ 66 67 #define SYMEXTN_SECTION_NAME ".PARISC.symext" 68 69 struct symext_chain 70 { 71 symext_entryS entry; 72 struct symext_chain *next; 73 }; 74 75 typedef struct symext_chain symext_chainS; 76 77 /* We use three different hash tables to hold information for 78 linking PA ELF objects. 79 80 The first is the elf32_hppa_link_hash_table which is derived 81 from the standard ELF linker hash table. We use this as a place to 82 attach other hash tables and static information. 83 84 The second is the stub hash table which is derived from the 85 base BFD hash table. The stub hash table holds the information 86 necessary to build the linker stubs during a link. 87 88 The last hash table keeps track of argument location information needed 89 to build hash tables. Each function with nonzero argument location 90 bits will have an entry in this table. */ 91 92 /* Hash table for linker stubs. */ 93 94 struct elf32_hppa_stub_hash_entry 95 { 96 /* Base hash table entry structure, we can get the name of the stub 97 (and thus know exactly what actions it performs) from the base 98 hash table entry. */ 99 struct bfd_hash_entry root; 100 101 /* Offset of the beginning of this stub. */ 102 bfd_vma offset; 103 104 /* Given the symbol's value and its section we can determine its final 105 value when building the stubs (so the stub knows where to jump. */ 106 symvalue target_value; 107 asection *target_section; 108 }; 109 110 struct elf32_hppa_stub_hash_table 111 { 112 /* The hash table itself. */ 113 struct bfd_hash_table root; 114 115 /* The stub BFD. */ 116 bfd *stub_bfd; 117 118 /* Where to place the next stub. */ 119 bfd_byte *location; 120 121 /* Current offset in the stub section. */ 122 unsigned int offset; 123 124 }; 125 126 /* Hash table for argument location information. */ 127 128 struct elf32_hppa_args_hash_entry 129 { 130 /* Base hash table entry structure. */ 131 struct bfd_hash_entry root; 132 133 /* The argument location bits for this entry. */ 134 int arg_bits; 135 }; 136 137 struct elf32_hppa_args_hash_table 138 { 139 /* The hash table itself. */ 140 struct bfd_hash_table root; 141 }; 142 143 struct elf32_hppa_link_hash_entry 144 { 145 struct elf_link_hash_entry root; 146 }; 147 148 struct elf32_hppa_link_hash_table 149 { 150 /* The main hash table. */ 151 struct elf_link_hash_table root; 152 153 /* The stub hash table. */ 154 struct elf32_hppa_stub_hash_table *stub_hash_table; 155 156 /* The argument relocation bits hash table. */ 157 struct elf32_hppa_args_hash_table *args_hash_table; 158 159 /* A count of the number of output symbols. */ 160 unsigned int output_symbol_count; 161 162 /* Stuff so we can handle DP relative relocations. */ 163 long global_value; 164 int global_sym_defined; 165 }; 166 167 /* FIXME. */ 168 #define ARGUMENTS 0 169 #define RETURN_VALUE 1 170 171 /* The various argument relocations that may be performed. */ 172 typedef enum 173 { 174 /* No relocation. */ 175 NO, 176 /* Relocate 32 bits from GR to FP register. */ 177 GF, 178 /* Relocate 64 bits from a GR pair to FP pair. */ 179 GD, 180 /* Relocate 32 bits from FP to GR. */ 181 FG, 182 /* Relocate 64 bits from FP pair to GR pair. */ 183 DG, 184 } arg_reloc_type; 185 186 /* What is being relocated (eg which argument or the return value). */ 187 typedef enum 188 { 189 ARG0, ARG1, ARG2, ARG3, RET, 190 } arg_reloc_location; 191 192 193 /* ELF32/HPPA relocation support 194 195 This file contains ELF32/HPPA relocation support as specified 196 in the Stratus FTX/Golf Object File Format (SED-1762) dated 197 February 1994. */ 198 199 #include "elf32-hppa.h" 200 #include "hppa_stubs.h" 201 202 static bfd_reloc_status_type hppa_elf_reloc 203 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 204 205 static unsigned long hppa_elf_relocate_insn 206 PARAMS ((bfd *, asection *, unsigned long, unsigned long, long, 207 long, unsigned long, unsigned long, unsigned long)); 208 209 static bfd_reloc_status_type hppa_elf_reloc 210 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd*, char **)); 211 212 static reloc_howto_type * elf_hppa_reloc_type_lookup 213 PARAMS ((bfd *, bfd_reloc_code_real_type)); 214 215 static boolean elf32_hppa_set_section_contents 216 PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); 217 218 static void elf32_hppa_info_to_howto 219 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *)); 220 221 static boolean elf32_hppa_backend_symbol_table_processing 222 PARAMS ((bfd *, elf_symbol_type *, unsigned int)); 223 224 static void elf32_hppa_backend_begin_write_processing 225 PARAMS ((bfd *, struct bfd_link_info *)); 226 227 static void elf32_hppa_backend_final_write_processing 228 PARAMS ((bfd *, boolean)); 229 230 static void add_entry_to_symext_chain 231 PARAMS ((bfd *, unsigned int, unsigned int, symext_chainS **, 232 symext_chainS **)); 233 234 static void 235 elf_hppa_tc_make_sections PARAMS ((bfd *, symext_chainS *)); 236 237 static boolean hppa_elf_is_local_label PARAMS ((bfd *, asymbol *)); 238 239 static boolean elf32_hppa_add_symbol_hook 240 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *, 241 const char **, flagword *, asection **, bfd_vma *)); 242 243 static bfd_reloc_status_type elf32_hppa_bfd_final_link_relocate 244 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, 245 bfd_byte *, bfd_vma, bfd_vma, bfd_vma, struct bfd_link_info *, 246 asection *, const char *, int)); 247 248 static struct bfd_link_hash_table *elf32_hppa_link_hash_table_create 249 PARAMS ((bfd *)); 250 251 static struct bfd_hash_entry * 252 elf32_hppa_stub_hash_newfunc 253 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 254 255 static struct bfd_hash_entry * 256 elf32_hppa_args_hash_newfunc 257 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 258 259 static boolean 260 elf32_hppa_relocate_section 261 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, 262 bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 263 264 static boolean 265 elf32_hppa_stub_hash_table_init 266 PARAMS ((struct elf32_hppa_stub_hash_table *, bfd *, 267 struct bfd_hash_entry *(*) PARAMS ((struct bfd_hash_entry *, 268 struct bfd_hash_table *, 269 const char *)))); 270 271 static boolean 272 elf32_hppa_build_one_stub PARAMS ((struct bfd_hash_entry *, PTR)); 273 274 static boolean 275 elf32_hppa_read_symext_info 276 PARAMS ((bfd *, Elf_Internal_Shdr *, struct elf32_hppa_args_hash_table *, 277 Elf_Internal_Sym *)); 278 279 static unsigned int elf32_hppa_size_of_stub 280 PARAMS ((unsigned int, unsigned int, bfd_vma, bfd_vma, const char *)); 281 282 static boolean elf32_hppa_arg_reloc_needed 283 PARAMS ((unsigned int, unsigned int, arg_reloc_type [])); 284 285 static void elf32_hppa_name_of_stub 286 PARAMS ((unsigned int, unsigned int, bfd_vma, bfd_vma, char *)); 287 288 static boolean elf32_hppa_size_symext PARAMS ((struct bfd_hash_entry *, PTR)); 289 290 static boolean elf32_hppa_link_output_symbol_hook 291 PARAMS ((bfd *, struct bfd_link_info *, const char *, 292 Elf_Internal_Sym *, asection *)); 293 294 /* ELF/PA relocation howto entries. */ 295 296 static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] = 297 { 298 {R_PARISC_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_NONE"}, 299 /* The values in DIR32 are to placate the check in 300 _bfd_stab_section_find_nearest_line. */ 301 {R_PARISC_DIR32, 0, 2, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR32", false, 0, 0xffffffff, false}, 302 {R_PARISC_DIR21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR21L"}, 303 {R_PARISC_DIR17R, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR17R"}, 304 {R_PARISC_DIR17F, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR17F"}, 305 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 306 {R_PARISC_DIR14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR14R"}, 307 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 308 309 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 310 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 311 {R_PARISC_PCREL21L, 0, 0, 21, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL21L"}, 312 {R_PARISC_PCREL17R, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17R"}, 313 {R_PARISC_PCREL17F, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17F"}, 314 {R_PARISC_PCREL17C, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17C"}, 315 {R_PARISC_PCREL14R, 0, 0, 14, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL14R"}, 316 {R_PARISC_PCREL14F, 0, 0, 14, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL14F"}, 317 318 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 319 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 320 {R_PARISC_DPREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL21L"}, 321 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 322 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 323 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 324 {R_PARISC_DPREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL14R"}, 325 {R_PARISC_DPREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL14F"}, 326 327 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 328 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 329 {R_PARISC_DLTREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL21L"}, 330 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 331 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 332 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 333 {R_PARISC_DLTREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL14R"}, 334 {R_PARISC_DLTREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL14F"}, 335 336 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 337 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 338 {R_PARISC_DLTIND21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND21L"}, 339 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 340 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 341 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 342 {R_PARISC_DLTIND14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND14R"}, 343 {R_PARISC_DLTIND14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND14F"}, 344 345 {R_PARISC_SETBASE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_SETBASE"}, 346 {R_PARISC_BASEREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL32"}, 347 {R_PARISC_BASEREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL21L"}, 348 {R_PARISC_BASEREL17R, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL17R"}, 349 {R_PARISC_BASEREL17F, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL17F"}, 350 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 351 {R_PARISC_BASEREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL14R"}, 352 {R_PARISC_BASEREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL14F"}, 353 354 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 355 {R_PARISC_TEXTREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_TEXTREL32"}, 356 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 357 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 358 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 359 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 360 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 361 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 362 363 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 364 {R_PARISC_DATAREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 365 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 366 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 367 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 368 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 369 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 370 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 371 372 373 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 374 {R_PARISC_PLABEL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL32"}, 375 {R_PARISC_PLABEL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL21L"}, 376 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 377 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 378 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 379 {R_PARISC_PLABEL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL14R"}, 380 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 381 382 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 383 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 384 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 385 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 386 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 387 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 388 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 389 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 390 391 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 392 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 393 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 394 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 395 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 396 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 397 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 398 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 399 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 400 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 401 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 402 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 403 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 404 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 405 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 406 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 407 408 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 409 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 410 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 411 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 412 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 413 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 414 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 415 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 416 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 417 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 418 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 419 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 420 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 421 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 422 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 423 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 424 425 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 426 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 427 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 428 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 429 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 430 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 431 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 432 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 433 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 434 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 435 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 436 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 437 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 438 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 439 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 440 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 441 442 443 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 444 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 445 {R_PARISC_PLTIND21L, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND21L"}, 446 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 447 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 448 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"}, 449 {R_PARISC_PLTIND14R, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND14R"}, 450 {R_PARISC_PLTIND14F, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND14F"}, 451 452 453 {R_PARISC_COPY, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_COPY"}, 454 {R_PARISC_GLOB_DAT, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_GLOB_DAT"}, 455 {R_PARISC_JMP_SLOT, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_JMP_SLOT"}, 456 {R_PARISC_RELATIVE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_RELATIVE"}, 457 458 {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont, NULL, "R_PARISC_UNIMPLEMENTED"}, 459 }; 460 461 /* Where (what register type) is an argument comming from? */ 462 typedef enum 463 { 464 AR_NO, 465 AR_GR, 466 AR_FR, 467 AR_FU, 468 AR_FPDBL1, 469 AR_FPDBL2, 470 } arg_location; 471 472 /* Horizontal represents the callee's argument location information, 473 vertical represents caller's argument location information. Value at a 474 particular X,Y location represents what (if any) argument relocation 475 needs to be performed to make caller and callee agree. */ 476 477 static CONST arg_reloc_type arg_mismatches[6][6] = 478 { 479 {NO, NO, NO, NO, NO, NO}, 480 {NO, NO, GF, NO, GD, NO}, 481 {NO, FG, NO, NO, NO, NO}, 482 {NO, NO, NO, NO, NO, NO}, 483 {NO, DG, NO, NO, NO, NO}, 484 {NO, DG, NO, NO, NO, NO}, 485 }; 486 487 /* Likewise, but reversed for the return value. */ 488 static CONST arg_reloc_type ret_mismatches[6][6] = 489 { 490 {NO, NO, NO, NO, NO, NO}, 491 {NO, NO, FG, NO, DG, NO}, 492 {NO, GF, NO, NO, NO, NO}, 493 {NO, NO, NO, NO, NO, NO}, 494 {NO, GD, NO, NO, NO, NO}, 495 {NO, GD, NO, NO, NO, NO}, 496 }; 497 498 /* Misc static crud for symbol extension records. */ 499 static symext_chainS *symext_rootP; 500 static symext_chainS *symext_lastP; 501 static bfd_size_type symext_chain_size; 502 503 /* FIXME: We should be able to try this static variable! */ 504 static bfd_byte *symextn_contents; 505 506 507 /* For linker stub hash tables. */ 508 #define elf32_hppa_stub_hash_lookup(table, string, create, copy) \ 509 ((struct elf32_hppa_stub_hash_entry *) \ 510 bfd_hash_lookup (&(table)->root, (string), (create), (copy))) 511 512 #define elf32_hppa_stub_hash_traverse(table, func, info) \ 513 (bfd_hash_traverse \ 514 (&(table)->root, \ 515 (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \ 516 (info))) 517 518 /* For linker args hash tables. */ 519 #define elf32_hppa_args_hash_lookup(table, string, create, copy) \ 520 ((struct elf32_hppa_args_hash_entry *) \ 521 bfd_hash_lookup (&(table)->root, (string), (create), (copy))) 522 523 #define elf32_hppa_args_hash_traverse(table, func, info) \ 524 (bfd_hash_traverse \ 525 (&(table)->root, \ 526 (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \ 527 (info))) 528 529 #define elf32_hppa_args_hash_table_init(table, newfunc) \ 530 (bfd_hash_table_init \ 531 (&(table)->root, \ 532 (struct bfd_hash_entry *(*) PARAMS ((struct bfd_hash_entry *, \ 533 struct bfd_hash_table *, \ 534 const char *))) (newfunc))) 535 536 /* For HPPA linker hash table. */ 537 538 #define elf32_hppa_link_hash_lookup(table, string, create, copy, follow)\ 539 ((struct elf32_hppa_link_hash_entry *) \ 540 elf_link_hash_lookup (&(table)->root, (string), (create), \ 541 (copy), (follow))) 542 543 #define elf32_hppa_link_hash_traverse(table, func, info) \ 544 (elf_link_hash_traverse \ 545 (&(table)->root, \ 546 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \ 547 (info))) 548 549 /* Get the PA ELF linker hash table from a link_info structure. */ 550 551 #define elf32_hppa_hash_table(p) \ 552 ((struct elf32_hppa_link_hash_table *) ((p)->hash)) 553 554 555 /* Extract specific argument location bits for WHICH from 556 the full argument location in AR. */ 557 #define EXTRACT_ARBITS(ar, which) ((ar) >> (8 - ((which) * 2))) & 3 558 559 /* Assorted hash table functions. */ 560 561 /* Initialize an entry in the stub hash table. */ 562 563 static struct bfd_hash_entry * 564 elf32_hppa_stub_hash_newfunc (entry, table, string) 565 struct bfd_hash_entry *entry; 566 struct bfd_hash_table *table; 567 const char *string; 568 { 569 struct elf32_hppa_stub_hash_entry *ret; 570 571 ret = (struct elf32_hppa_stub_hash_entry *) entry; 572 573 /* Allocate the structure if it has not already been allocated by a 574 subclass. */ 575 if (ret == NULL) 576 ret = ((struct elf32_hppa_stub_hash_entry *) 577 bfd_hash_allocate (table, 578 sizeof (struct elf32_hppa_stub_hash_entry))); 579 if (ret == NULL) 580 return NULL; 581 582 /* Call the allocation method of the superclass. */ 583 ret = ((struct elf32_hppa_stub_hash_entry *) 584 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 585 586 if (ret) 587 { 588 /* Initialize the local fields. */ 589 ret->offset = 0; 590 ret->target_value = 0; 591 ret->target_section = NULL; 592 } 593 594 return (struct bfd_hash_entry *) ret; 595 } 596 597 /* Initialize a stub hash table. */ 598 599 static boolean 600 elf32_hppa_stub_hash_table_init (table, stub_bfd, newfunc) 601 struct elf32_hppa_stub_hash_table *table; 602 bfd *stub_bfd; 603 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, 604 struct bfd_hash_table *, 605 const char *)); 606 { 607 table->offset = 0; 608 table->location = 0; 609 table->stub_bfd = stub_bfd; 610 return (bfd_hash_table_init (&table->root, newfunc)); 611 } 612 613 /* Initialize an entry in the argument location hash table. */ 614 615 static struct bfd_hash_entry * 616 elf32_hppa_args_hash_newfunc (entry, table, string) 617 struct bfd_hash_entry *entry; 618 struct bfd_hash_table *table; 619 const char *string; 620 { 621 struct elf32_hppa_args_hash_entry *ret; 622 623 ret = (struct elf32_hppa_args_hash_entry *) entry; 624 625 /* Allocate the structure if it has not already been allocated by a 626 subclass. */ 627 if (ret == NULL) 628 ret = ((struct elf32_hppa_args_hash_entry *) 629 bfd_hash_allocate (table, 630 sizeof (struct elf32_hppa_args_hash_entry))); 631 if (ret == NULL) 632 return NULL; 633 634 /* Call the allocation method of the superclass. */ 635 ret = ((struct elf32_hppa_args_hash_entry *) 636 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 637 638 /* Initialize the local fields. */ 639 if (ret) 640 ret->arg_bits = 0; 641 642 return (struct bfd_hash_entry *) ret; 643 } 644 645 /* Create the derived linker hash table. The PA ELF port uses the derived 646 hash table to keep information specific to the PA ELF linker (without 647 using static variables). */ 648 649 static struct bfd_link_hash_table * 650 elf32_hppa_link_hash_table_create (abfd) 651 bfd *abfd; 652 { 653 struct elf32_hppa_link_hash_table *ret; 654 655 ret = ((struct elf32_hppa_link_hash_table *) 656 bfd_alloc (abfd, sizeof (struct elf32_hppa_link_hash_table))); 657 if (ret == NULL) 658 return NULL; 659 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 660 _bfd_elf_link_hash_newfunc)) 661 { 662 bfd_release (abfd, ret); 663 return NULL; 664 } 665 ret->stub_hash_table = NULL; 666 ret->args_hash_table = NULL; 667 ret->output_symbol_count = 0; 668 ret->global_value = 0; 669 ret->global_sym_defined = 0; 670 671 return &ret->root.root; 672 } 673 674 /* Relocate the given INSN given the various input parameters. 675 676 FIXME: endianness and sizeof (long) issues abound here. */ 677 678 static unsigned long 679 hppa_elf_relocate_insn (abfd, input_sect, insn, address, sym_value, 680 r_addend, r_format, r_field, pcrel) 681 bfd *abfd; 682 asection *input_sect; 683 unsigned long insn; 684 unsigned long address; 685 long sym_value; 686 long r_addend; 687 unsigned long r_format; 688 unsigned long r_field; 689 unsigned long pcrel; 690 { 691 unsigned char opcode = get_opcode (insn); 692 long constant_value; 693 694 switch (opcode) 695 { 696 case LDO: 697 case LDB: 698 case LDH: 699 case LDW: 700 case LDWM: 701 case STB: 702 case STH: 703 case STW: 704 case STWM: 705 case COMICLR: 706 case SUBI: 707 case ADDIT: 708 case ADDI: 709 case LDIL: 710 case ADDIL: 711 constant_value = HPPA_R_CONSTANT (r_addend); 712 713 if (pcrel) 714 sym_value -= address; 715 716 sym_value = hppa_field_adjust (sym_value, constant_value, r_field); 717 return hppa_rebuild_insn (abfd, insn, sym_value, r_format); 718 719 case BL: 720 case BE: 721 case BLE: 722 /* XXX computing constant_value is not needed??? */ 723 constant_value = assemble_17 ((insn & 0x001f0000) >> 16, 724 (insn & 0x00001ffc) >> 2, 725 insn & 1); 726 727 constant_value = (constant_value << 15) >> 15; 728 if (pcrel) 729 { 730 sym_value -= 731 address + input_sect->output_offset 732 + input_sect->output_section->vma; 733 sym_value = hppa_field_adjust (sym_value, -8, r_field); 734 } 735 else 736 sym_value = hppa_field_adjust (sym_value, constant_value, r_field); 737 738 return hppa_rebuild_insn (abfd, insn, sym_value >> 2, r_format); 739 740 default: 741 if (opcode == 0) 742 { 743 constant_value = HPPA_R_CONSTANT (r_addend); 744 745 if (pcrel) 746 sym_value -= address; 747 748 return hppa_field_adjust (sym_value, constant_value, r_field); 749 } 750 else 751 abort (); 752 } 753 } 754 755 /* Relocate an HPPA ELF section. */ 756 757 static boolean 758 elf32_hppa_relocate_section (output_bfd, info, input_bfd, input_section, 759 contents, relocs, local_syms, local_sections) 760 bfd *output_bfd; 761 struct bfd_link_info *info; 762 bfd *input_bfd; 763 asection *input_section; 764 bfd_byte *contents; 765 Elf_Internal_Rela *relocs; 766 Elf_Internal_Sym *local_syms; 767 asection **local_sections; 768 { 769 Elf_Internal_Shdr *symtab_hdr; 770 Elf_Internal_Rela *rel; 771 Elf_Internal_Rela *relend; 772 773 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 774 775 rel = relocs; 776 relend = relocs + input_section->reloc_count; 777 for (; rel < relend; rel++) 778 { 779 int r_type; 780 reloc_howto_type *howto; 781 unsigned long r_symndx; 782 struct elf_link_hash_entry *h; 783 Elf_Internal_Sym *sym; 784 asection *sym_sec; 785 bfd_vma relocation; 786 bfd_reloc_status_type r; 787 const char *sym_name; 788 789 r_type = ELF32_R_TYPE (rel->r_info); 790 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED) 791 { 792 bfd_set_error (bfd_error_bad_value); 793 return false; 794 } 795 howto = elf_hppa_howto_table + r_type; 796 797 r_symndx = ELF32_R_SYM (rel->r_info); 798 799 if (info->relocateable) 800 { 801 /* This is a relocateable link. We don't have to change 802 anything, unless the reloc is against a section symbol, 803 in which case we have to adjust according to where the 804 section symbol winds up in the output section. */ 805 if (r_symndx < symtab_hdr->sh_info) 806 { 807 sym = local_syms + r_symndx; 808 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 809 { 810 sym_sec = local_sections[r_symndx]; 811 rel->r_addend += sym_sec->output_offset; 812 } 813 } 814 815 continue; 816 } 817 818 /* This is a final link. */ 819 h = NULL; 820 sym = NULL; 821 sym_sec = NULL; 822 if (r_symndx < symtab_hdr->sh_info) 823 { 824 sym = local_syms + r_symndx; 825 sym_sec = local_sections[r_symndx]; 826 relocation = ((ELF_ST_TYPE (sym->st_info) == STT_SECTION 827 ? 0 : sym->st_value) 828 + sym_sec->output_offset 829 + sym_sec->output_section->vma); 830 } 831 else 832 { 833 long indx; 834 835 indx = r_symndx - symtab_hdr->sh_info; 836 h = elf_sym_hashes (input_bfd)[indx]; 837 while (h->root.type == bfd_link_hash_indirect 838 || h->root.type == bfd_link_hash_warning) 839 h = (struct elf_link_hash_entry *) h->root.u.i.link; 840 if (h->root.type == bfd_link_hash_defined 841 || h->root.type == bfd_link_hash_defweak) 842 { 843 sym_sec = h->root.u.def.section; 844 relocation = (h->root.u.def.value 845 + sym_sec->output_offset 846 + sym_sec->output_section->vma); 847 } 848 else if (h->root.type == bfd_link_hash_undefweak) 849 relocation = 0; 850 else 851 { 852 if (!((*info->callbacks->undefined_symbol) 853 (info, h->root.root.string, input_bfd, 854 input_section, rel->r_offset))) 855 return false; 856 break; 857 } 858 } 859 860 if (h != NULL) 861 sym_name = h->root.root.string; 862 else 863 { 864 sym_name = bfd_elf_string_from_elf_section (input_bfd, 865 symtab_hdr->sh_link, 866 sym->st_name); 867 if (sym_name == NULL) 868 return false; 869 if (*sym_name == '\0') 870 sym_name = bfd_section_name (input_bfd, sym_sec); 871 } 872 873 /* If args_hash_table is NULL, then we have encountered some 874 kind of link error (ex. undefined symbols). Do not try to 875 apply any relocations, continue the loop so we can notify 876 the user of several errors in a single attempted link. */ 877 if (elf32_hppa_hash_table (info)->args_hash_table == NULL) 878 continue; 879 880 r = elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd, 881 input_section, contents, 882 rel->r_offset, relocation, 883 rel->r_addend, info, sym_sec, 884 sym_name, h == NULL); 885 886 if (r != bfd_reloc_ok) 887 { 888 switch (r) 889 { 890 /* This can happen for DP relative relocs if $global$ is 891 undefined. This is a panic situation so we don't try 892 to continue. */ 893 case bfd_reloc_undefined: 894 case bfd_reloc_notsupported: 895 if (!((*info->callbacks->undefined_symbol) 896 (info, "$global$", input_bfd, 897 input_section, rel->r_offset))) 898 return false; 899 return false; 900 case bfd_reloc_dangerous: 901 { 902 /* We use this return value to indicate that we performed 903 a "dangerous" relocation. This doesn't mean we did 904 the wrong thing, it just means there may be some cleanup 905 that needs to be done here. 906 907 In particular we had to swap the last call insn and its 908 delay slot. If the delay slot insn needed a relocation, 909 then we'll need to adjust the next relocation entry's 910 offset to account for the fact that the insn moved. 911 912 This hair wouldn't be necessary if we inserted stubs 913 between procedures and used a "bl" to get to the stub. */ 914 if (rel != relend) 915 { 916 Elf_Internal_Rela *next_rel = rel + 1; 917 918 if (rel->r_offset + 4 == next_rel->r_offset) 919 next_rel->r_offset -= 4; 920 } 921 break; 922 } 923 default: 924 case bfd_reloc_outofrange: 925 case bfd_reloc_overflow: 926 { 927 if (!((*info->callbacks->reloc_overflow) 928 (info, sym_name, howto->name, (bfd_vma) 0, 929 input_bfd, input_section, rel->r_offset))) 930 return false; 931 } 932 break; 933 } 934 } 935 } 936 937 return true; 938 } 939 940 /* Return one (or more) BFD relocations which implement the base 941 relocation with modifications based on format and field. */ 942 943 elf32_hppa_reloc_type ** 944 hppa_elf_gen_reloc_type (abfd, base_type, format, field, ignore, sym) 945 bfd *abfd; 946 elf32_hppa_reloc_type base_type; 947 int format; 948 int field; 949 int ignore; 950 asymbol *sym; 951 { 952 elf32_hppa_reloc_type *finaltype; 953 elf32_hppa_reloc_type **final_types; 954 955 /* Allocate slots for the BFD relocation. */ 956 final_types = (elf32_hppa_reloc_type **) 957 bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 2); 958 if (final_types == NULL) 959 return NULL; 960 961 /* Allocate space for the relocation itself. */ 962 finaltype = (elf32_hppa_reloc_type *) 963 bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type)); 964 if (finaltype == NULL) 965 return NULL; 966 967 /* Some reasonable defaults. */ 968 final_types[0] = finaltype; 969 final_types[1] = NULL; 970 971 #define final_type finaltype[0] 972 973 final_type = base_type; 974 975 /* Just a tangle of nested switch statements to deal with the braindamage 976 that a different field selector means a completely different relocation 977 for PA ELF. */ 978 switch (base_type) 979 { 980 case R_HPPA: 981 case R_HPPA_ABS_CALL: 982 switch (format) 983 { 984 case 14: 985 switch (field) 986 { 987 case e_rsel: 988 case e_rrsel: 989 final_type = R_PARISC_DIR14R; 990 break; 991 case e_rtsel: 992 final_type = R_PARISC_DLTREL14R; 993 break; 994 case e_tsel: 995 final_type = R_PARISC_DLTREL14F; 996 break; 997 case e_rpsel: 998 final_type = R_PARISC_PLABEL14R; 999 break; 1000 default: 1001 return NULL; 1002 } 1003 break; 1004 1005 case 17: 1006 switch (field) 1007 { 1008 case e_fsel: 1009 final_type = R_PARISC_DIR17F; 1010 break; 1011 case e_rsel: 1012 case e_rrsel: 1013 final_type = R_PARISC_DIR17R; 1014 break; 1015 default: 1016 return NULL; 1017 } 1018 break; 1019 1020 case 21: 1021 switch (field) 1022 { 1023 case e_lsel: 1024 case e_lrsel: 1025 final_type = R_PARISC_DIR21L; 1026 break; 1027 case e_ltsel: 1028 final_type = R_PARISC_DLTREL21L; 1029 break; 1030 case e_lpsel: 1031 final_type = R_PARISC_PLABEL21L; 1032 break; 1033 default: 1034 return NULL; 1035 } 1036 break; 1037 1038 case 32: 1039 switch (field) 1040 { 1041 case e_fsel: 1042 final_type = R_PARISC_DIR32; 1043 break; 1044 case e_psel: 1045 final_type = R_PARISC_PLABEL32; 1046 break; 1047 default: 1048 return NULL; 1049 } 1050 break; 1051 1052 default: 1053 return NULL; 1054 } 1055 break; 1056 1057 1058 case R_HPPA_GOTOFF: 1059 switch (format) 1060 { 1061 case 14: 1062 switch (field) 1063 { 1064 case e_rsel: 1065 case e_rrsel: 1066 final_type = R_PARISC_DPREL14R; 1067 break; 1068 case e_fsel: 1069 final_type = R_PARISC_DPREL14F; 1070 break; 1071 default: 1072 return NULL; 1073 } 1074 break; 1075 1076 case 21: 1077 switch (field) 1078 { 1079 case e_lrsel: 1080 case e_lsel: 1081 final_type = R_PARISC_DPREL21L; 1082 break; 1083 default: 1084 return NULL; 1085 } 1086 break; 1087 1088 default: 1089 return NULL; 1090 } 1091 break; 1092 1093 1094 case R_HPPA_PCREL_CALL: 1095 switch (format) 1096 { 1097 case 14: 1098 switch (field) 1099 { 1100 case e_rsel: 1101 case e_rrsel: 1102 final_type = R_PARISC_PCREL14R; 1103 break; 1104 case e_fsel: 1105 final_type = R_PARISC_PCREL14F; 1106 break; 1107 default: 1108 return NULL; 1109 } 1110 break; 1111 1112 case 17: 1113 switch (field) 1114 { 1115 case e_rsel: 1116 case e_rrsel: 1117 final_type = R_PARISC_PCREL17R; 1118 break; 1119 case e_fsel: 1120 final_type = R_PARISC_PCREL17F; 1121 break; 1122 default: 1123 return NULL; 1124 } 1125 break; 1126 1127 case 21: 1128 switch (field) 1129 { 1130 case e_lsel: 1131 case e_lrsel: 1132 final_type = R_PARISC_PCREL21L; 1133 break; 1134 default: 1135 return NULL; 1136 } 1137 break; 1138 1139 default: 1140 return NULL; 1141 } 1142 break; 1143 1144 default: 1145 return NULL; 1146 } 1147 1148 return final_types; 1149 } 1150 1151 #undef final_type 1152 1153 /* Set the contents of a particular section at a particular location. */ 1154 1155 static boolean 1156 elf32_hppa_set_section_contents (abfd, section, location, offset, count) 1157 bfd *abfd; 1158 sec_ptr section; 1159 PTR location; 1160 file_ptr offset; 1161 bfd_size_type count; 1162 { 1163 /* Ignore write requests for the symbol extension section until we've 1164 had the chance to rebuild it ourselves. */ 1165 if (!strcmp (section->name, ".PARISC.symextn") && !symext_chain_size) 1166 return true; 1167 else 1168 return _bfd_elf_set_section_contents (abfd, section, location, 1169 offset, count); 1170 } 1171 1172 /* Translate from an elf into field into a howto relocation pointer. */ 1173 1174 static void 1175 elf32_hppa_info_to_howto (abfd, cache_ptr, dst) 1176 bfd *abfd; 1177 arelent *cache_ptr; 1178 Elf32_Internal_Rela *dst; 1179 { 1180 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_PARISC_UNIMPLEMENTED); 1181 cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE (dst->r_info)]; 1182 } 1183 1184 1185 /* Actually perform a relocation. NOTE this is (mostly) superceeded 1186 by elf32_hppa_bfd_final_link_relocate which is called by the new 1187 fast linker. */ 1188 1189 static bfd_reloc_status_type 1190 hppa_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, 1191 error_message) 1192 bfd *abfd; 1193 arelent *reloc_entry; 1194 asymbol *symbol_in; 1195 PTR data; 1196 asection *input_section; 1197 bfd *output_bfd; 1198 char **error_message; 1199 { 1200 /* It is no longer valid to call hppa_elf_reloc when creating 1201 a final executable. */ 1202 if (output_bfd) 1203 { 1204 reloc_entry->address += input_section->output_offset; 1205 1206 /* Work around lossage in generic elf code to write relocations. 1207 (maps different section symbols into the same symbol index). */ 1208 if ((symbol_in->flags & BSF_SECTION_SYM) 1209 && symbol_in->section) 1210 reloc_entry->addend += symbol_in->section->output_offset; 1211 return bfd_reloc_ok; 1212 } 1213 else 1214 { 1215 *error_message = (char *) "Unsupported call to hppa_elf_reloc"; 1216 return bfd_reloc_notsupported; 1217 } 1218 } 1219 1220 /* Actually perform a relocation as part of a final link. This can get 1221 rather hairy when linker stubs are needed. */ 1222 1223 static bfd_reloc_status_type 1224 elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd, 1225 input_section, contents, offset, value, 1226 addend, info, sym_sec, sym_name, is_local) 1227 reloc_howto_type *howto; 1228 bfd *input_bfd; 1229 bfd *output_bfd; 1230 asection *input_section; 1231 bfd_byte *contents; 1232 bfd_vma offset; 1233 bfd_vma value; 1234 bfd_vma addend; 1235 struct bfd_link_info *info; 1236 asection *sym_sec; 1237 const char *sym_name; 1238 int is_local; 1239 { 1240 unsigned long insn; 1241 unsigned long r_type = howto->type; 1242 unsigned long r_format = howto->bitsize; 1243 unsigned long r_field = e_fsel; 1244 bfd_byte *hit_data = contents + offset; 1245 boolean r_pcrel = howto->pc_relative; 1246 1247 insn = bfd_get_32 (input_bfd, hit_data); 1248 1249 /* Make sure we have a value for $global$. FIXME isn't this effectively 1250 just like the gp pointer on MIPS? Can we use those routines for this 1251 purpose? */ 1252 if (!elf32_hppa_hash_table (info)->global_sym_defined) 1253 { 1254 struct elf_link_hash_entry *h; 1255 asection *sec; 1256 1257 h = elf_link_hash_lookup (elf_hash_table (info), "$global$", false, 1258 false, false); 1259 1260 /* If there isn't a $global$, then we're in deep trouble. */ 1261 if (h == NULL) 1262 return bfd_reloc_notsupported; 1263 1264 /* If $global$ isn't a defined symbol, then we're still in deep 1265 trouble. */ 1266 if (h->root.type != bfd_link_hash_defined) 1267 return bfd_reloc_undefined; 1268 1269 sec = h->root.u.def.section; 1270 elf32_hppa_hash_table (info)->global_value = (h->root.u.def.value 1271 + sec->output_section->vma 1272 + sec->output_offset); 1273 elf32_hppa_hash_table (info)->global_sym_defined = 1; 1274 } 1275 1276 switch (r_type) 1277 { 1278 case R_PARISC_NONE: 1279 break; 1280 1281 case R_PARISC_DIR32: 1282 case R_PARISC_DIR17F: 1283 case R_PARISC_PCREL17C: 1284 r_field = e_fsel; 1285 goto do_basic_type_1; 1286 case R_PARISC_DIR21L: 1287 case R_PARISC_PCREL21L: 1288 r_field = e_lrsel; 1289 goto do_basic_type_1; 1290 case R_PARISC_DIR17R: 1291 case R_PARISC_PCREL17R: 1292 case R_PARISC_DIR14R: 1293 case R_PARISC_PCREL14R: 1294 r_field = e_rrsel; 1295 goto do_basic_type_1; 1296 1297 /* For all the DP relative relocations, we need to examine the symbol's 1298 section. If it's a code section, then "data pointer relative" makes 1299 no sense. In that case we don't adjust the "value", and for 21 bit 1300 addil instructions, we change the source addend register from %dp to 1301 %r0. */ 1302 case R_PARISC_DPREL21L: 1303 r_field = e_lrsel; 1304 if (sym_sec->flags & SEC_CODE) 1305 { 1306 if ((insn & 0xfc000000) >> 26 == 0xa 1307 && (insn & 0x03e00000) >> 21 == 0x1b) 1308 insn &= ~0x03e00000; 1309 } 1310 else 1311 value -= elf32_hppa_hash_table (info)->global_value; 1312 goto do_basic_type_1; 1313 case R_PARISC_DPREL14R: 1314 r_field = e_rrsel; 1315 if ((sym_sec->flags & SEC_CODE) == 0) 1316 value -= elf32_hppa_hash_table (info)->global_value; 1317 goto do_basic_type_1; 1318 case R_PARISC_DPREL14F: 1319 r_field = e_fsel; 1320 if ((sym_sec->flags & SEC_CODE) == 0) 1321 value -= elf32_hppa_hash_table (info)->global_value; 1322 goto do_basic_type_1; 1323 1324 /* These cases are separate as they may involve a lot more work 1325 to deal with linker stubs. */ 1326 case R_PARISC_PLABEL32: 1327 case R_PARISC_PLABEL21L: 1328 case R_PARISC_PLABEL14R: 1329 case R_PARISC_PCREL17F: 1330 { 1331 bfd_vma location; 1332 unsigned int len, caller_args, callee_args; 1333 arg_reloc_type arg_reloc_types[5]; 1334 struct elf32_hppa_args_hash_table *args_hash_table; 1335 struct elf32_hppa_args_hash_entry *args_hash; 1336 char *new_name, *stub_name; 1337 1338 /* Get the field selector right. We'll need it in a minute. */ 1339 if (r_type == R_PARISC_PCREL17F 1340 || r_type == R_PARISC_PLABEL32) 1341 r_field = e_fsel; 1342 else if (r_type == R_PARISC_PLABEL21L) 1343 r_field = e_lrsel; 1344 else if (r_type == R_PARISC_PLABEL14R) 1345 r_field = e_rrsel; 1346 1347 /* Find out where we are and where we're going. */ 1348 location = (offset + 1349 input_section->output_offset + 1350 input_section->output_section->vma); 1351 1352 /* Now look for the argument relocation bits associated with the 1353 target. */ 1354 len = strlen (sym_name) + 1; 1355 if (is_local) 1356 len += 9; 1357 new_name = bfd_malloc (len); 1358 if (!new_name) 1359 return bfd_reloc_notsupported; 1360 strcpy (new_name, sym_name); 1361 1362 /* Local symbols have unique IDs. */ 1363 if (is_local) 1364 sprintf (new_name + len - 10, "_%08x", (int)sym_sec); 1365 1366 args_hash_table = elf32_hppa_hash_table (info)->args_hash_table; 1367 1368 args_hash = elf32_hppa_args_hash_lookup (args_hash_table, 1369 new_name, false, false); 1370 if (args_hash == NULL) 1371 callee_args = 0; 1372 else 1373 callee_args = args_hash->arg_bits; 1374 1375 /* If this is a CALL relocation, then get the caller's bits 1376 from the addend. Else use the magic 0x155 value for PLABELS. 1377 1378 Also we don't care about the destination (value) for PLABELS. */ 1379 if (r_type == R_PARISC_PCREL17F) 1380 caller_args = HPPA_R_ARG_RELOC (addend); 1381 else 1382 { 1383 caller_args = 0x155; 1384 location = value; 1385 } 1386 1387 /* Any kind of linker stub needed? */ 1388 if (((int)(value - location) > 0x3ffff) 1389 || ((int)(value - location) < (int)0xfffc0000) 1390 || elf32_hppa_arg_reloc_needed (caller_args, callee_args, 1391 arg_reloc_types)) 1392 { 1393 struct elf32_hppa_stub_hash_table *stub_hash_table; 1394 struct elf32_hppa_stub_hash_entry *stub_hash; 1395 asection *stub_section; 1396 1397 /* Build a name for the stub. */ 1398 1399 len = strlen (new_name); 1400 len += 23; 1401 stub_name = bfd_malloc (len); 1402 if (!stub_name) 1403 return bfd_reloc_notsupported; 1404 elf32_hppa_name_of_stub (caller_args, callee_args, 1405 location, value, stub_name); 1406 strcat (stub_name, new_name); 1407 free (new_name); 1408 1409 stub_hash_table = elf32_hppa_hash_table (info)->stub_hash_table; 1410 1411 stub_hash 1412 = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name, 1413 false, false); 1414 1415 /* We're done with that name. */ 1416 free (stub_name); 1417 1418 /* The stub BFD only has one section. */ 1419 stub_section = stub_hash_table->stub_bfd->sections; 1420 1421 if (stub_hash != NULL) 1422 { 1423 1424 if (r_type == R_PARISC_PCREL17F) 1425 { 1426 unsigned long delay_insn; 1427 unsigned int opcode, rtn_reg, ldo_target_reg, ldo_src_reg; 1428 1429 /* We'll need to peek at the next insn. */ 1430 delay_insn = bfd_get_32 (input_bfd, hit_data + 4); 1431 opcode = get_opcode (delay_insn); 1432 1433 /* We also need to know the return register for this 1434 call. */ 1435 rtn_reg = (insn & 0x03e00000) >> 21; 1436 1437 ldo_src_reg = (delay_insn & 0x03e00000) >> 21; 1438 ldo_target_reg = (delay_insn & 0x001f0000) >> 16; 1439 1440 /* Munge up the value and other parameters for 1441 hppa_elf_relocate_insn. */ 1442 1443 value = (stub_hash->offset 1444 + stub_section->output_offset 1445 + stub_section->output_section->vma); 1446 1447 r_format = 17; 1448 r_field = e_fsel; 1449 r_pcrel = 0; 1450 addend = 0; 1451 1452 /* We need to peek at the delay insn and determine if 1453 we'll need to swap the branch and its delay insn. */ 1454 if ((insn & 2) 1455 || (opcode == LDO 1456 && ldo_target_reg == rtn_reg) 1457 || (delay_insn == 0x08000240)) 1458 { 1459 /* No need to swap the branch and its delay slot, but 1460 we do need to make sure to jump past the return 1461 pointer update in the stub. */ 1462 value += 4; 1463 1464 /* If the delay insn does a return pointer adjustment, 1465 then we have to make sure it stays valid. */ 1466 if (opcode == LDO 1467 && ldo_target_reg == rtn_reg) 1468 { 1469 delay_insn &= 0xfc00ffff; 1470 delay_insn |= ((31 << 21) | (31 << 16)); 1471 bfd_put_32 (input_bfd, delay_insn, hit_data + 4); 1472 } 1473 /* Use a BLE to reach the stub. */ 1474 insn = BLE_SR4_R0; 1475 } 1476 else 1477 { 1478 /* Wonderful, we have to swap the call insn and its 1479 delay slot. */ 1480 bfd_put_32 (input_bfd, delay_insn, hit_data); 1481 /* Use a BLE,n to reach the stub. */ 1482 insn = (BLE_SR4_R0 | 0x2); 1483 bfd_put_32 (input_bfd, insn, hit_data + 4); 1484 insn = hppa_elf_relocate_insn (input_bfd, 1485 input_section, 1486 insn, offset + 4, 1487 value, addend, 1488 r_format, r_field, 1489 r_pcrel); 1490 /* Update the instruction word. */ 1491 bfd_put_32 (input_bfd, insn, hit_data + 4); 1492 return bfd_reloc_dangerous; 1493 } 1494 } 1495 else 1496 { 1497 /* PLABEL stuff is easy. */ 1498 1499 value = (stub_hash->offset 1500 + stub_section->output_offset 1501 + stub_section->output_section->vma); 1502 /* We don't need the RP adjustment for PLABELs. */ 1503 value += 4; 1504 if (r_type == R_PARISC_PLABEL32) 1505 r_format = 32; 1506 else if (r_type == R_PARISC_PLABEL21L) 1507 r_format = 21; 1508 else if (r_type == R_PARISC_PLABEL14R) 1509 r_format = 14; 1510 1511 r_pcrel = 0; 1512 addend = 0; 1513 } 1514 } 1515 else 1516 return bfd_reloc_notsupported; 1517 } 1518 goto do_basic_type_1; 1519 } 1520 1521 do_basic_type_1: 1522 insn = hppa_elf_relocate_insn (input_bfd, input_section, insn, 1523 offset, value, addend, r_format, 1524 r_field, r_pcrel); 1525 break; 1526 1527 /* Something we don't know how to handle. */ 1528 default: 1529 return bfd_reloc_notsupported; 1530 } 1531 1532 /* Update the instruction word. */ 1533 bfd_put_32 (input_bfd, insn, hit_data); 1534 return (bfd_reloc_ok); 1535 } 1536 1537 /* Return the address of the howto table entry to perform the CODE 1538 relocation for an ARCH machine. */ 1539 1540 static reloc_howto_type * 1541 elf_hppa_reloc_type_lookup (abfd, code) 1542 bfd *abfd; 1543 bfd_reloc_code_real_type code; 1544 { 1545 if ((int) code < (int) R_PARISC_UNIMPLEMENTED) 1546 { 1547 BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code); 1548 return &elf_hppa_howto_table[(int) code]; 1549 } 1550 return NULL; 1551 } 1552 1553 /* Return true if SYM represents a local label symbol. */ 1554 1555 static boolean 1556 hppa_elf_is_local_label (abfd, sym) 1557 bfd *abfd; 1558 asymbol *sym; 1559 { 1560 return (sym->name[0] == 'L' && sym->name[1] == '$'); 1561 } 1562 1563 /* Do any backend specific processing when beginning to write an object 1564 file. For PA ELF we need to determine the size of the symbol extension 1565 section *before* any other output processing happens. */ 1566 1567 static void 1568 elf32_hppa_backend_begin_write_processing (abfd, info) 1569 bfd *abfd; 1570 struct bfd_link_info *info; 1571 { 1572 unsigned int i; 1573 asection *symextn_sec; 1574 1575 /* Size up the symbol extension section. */ 1576 if ((abfd->outsymbols == NULL 1577 && info == NULL) 1578 || symext_chain_size != 0) 1579 return; 1580 1581 if (info == NULL) 1582 { 1583 /* We were not called from the BFD ELF linker code, so we need 1584 to examine the output BFD's outsymbols. 1585 1586 Note we can not build the symbol extensions now as the symbol 1587 map hasn't been set up. */ 1588 for (i = 0; i < abfd->symcount; i++) 1589 { 1590 elf_symbol_type *symbol = (elf_symbol_type *)abfd->outsymbols[i]; 1591 1592 /* Only functions ever need an entry in the symbol extension 1593 section. */ 1594 if (!(symbol->symbol.flags & BSF_FUNCTION)) 1595 continue; 1596 1597 /* And only if they specify the locations of their arguments. */ 1598 if (symbol->tc_data.hppa_arg_reloc == 0) 1599 continue; 1600 1601 /* Yup. This function symbol needs an entry. */ 1602 symext_chain_size += 2 * ELF32_PARISC_SX_SIZE; 1603 } 1604 } 1605 else if (info->relocateable == true) 1606 { 1607 struct elf32_hppa_args_hash_table *table; 1608 table = elf32_hppa_hash_table (info)->args_hash_table; 1609 1610 /* Determine the size of the symbol extension section. */ 1611 elf32_hppa_args_hash_traverse (table, 1612 elf32_hppa_size_symext, 1613 &symext_chain_size); 1614 } 1615 1616 /* Now create the section and set its size. We'll fill in the 1617 contents later. */ 1618 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME); 1619 if (symextn_sec == NULL) 1620 symextn_sec = bfd_make_section (abfd, SYMEXTN_SECTION_NAME); 1621 1622 bfd_set_section_flags (abfd, symextn_sec, 1623 SEC_LOAD | SEC_HAS_CONTENTS | SEC_DATA); 1624 symextn_sec->output_section = symextn_sec; 1625 symextn_sec->output_offset = 0; 1626 bfd_set_section_alignment (abfd, symextn_sec, 2); 1627 bfd_set_section_size (abfd, symextn_sec, symext_chain_size); 1628 } 1629 1630 /* Called for each entry in the args location hash table. For each 1631 entry we bump the size pointer by 2 records (16 bytes). */ 1632 1633 static boolean 1634 elf32_hppa_size_symext (gen_entry, in_args) 1635 struct bfd_hash_entry *gen_entry; 1636 PTR in_args; 1637 { 1638 bfd_size_type *sizep = (bfd_size_type *)in_args; 1639 1640 *sizep += 2 * ELF32_PARISC_SX_SIZE; 1641 return true; 1642 } 1643 1644 /* Backend routine called by the linker for each output symbol. 1645 1646 For PA ELF we use this opportunity to add an appropriate entry 1647 to the symbol extension chain for function symbols. */ 1648 1649 static boolean 1650 elf32_hppa_link_output_symbol_hook (abfd, info, name, sym, section) 1651 bfd *abfd; 1652 struct bfd_link_info *info; 1653 const char *name; 1654 Elf_Internal_Sym *sym; 1655 asection *section; 1656 { 1657 char *new_name; 1658 unsigned int len, index; 1659 struct elf32_hppa_args_hash_table *args_hash_table; 1660 struct elf32_hppa_args_hash_entry *args_hash; 1661 1662 /* If the args hash table is NULL, then we've encountered an error 1663 of some sorts (for example, an undefined symbol). In that case 1664 we've got nothing else to do. 1665 1666 NOTE: elf_link_output_symbol will abort if we return false here! */ 1667 if (elf32_hppa_hash_table (info)->args_hash_table == NULL) 1668 return true; 1669 1670 index = elf32_hppa_hash_table (info)->output_symbol_count++; 1671 1672 /* We need to look up this symbol in the args hash table to see if 1673 it has argument relocation bits. */ 1674 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC) 1675 return true; 1676 1677 /* We know it's a function symbol of some kind. */ 1678 len = strlen (name) + 1; 1679 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL) 1680 len += 9; 1681 1682 new_name = bfd_malloc (len); 1683 if (new_name == NULL) 1684 return false; 1685 1686 strcpy (new_name, name); 1687 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL) 1688 sprintf (new_name + len - 10, "_%08x", (int)section); 1689 1690 /* Now that we have the unique name, we can look it up in the 1691 args hash table. */ 1692 args_hash_table = elf32_hppa_hash_table (info)->args_hash_table; 1693 args_hash = elf32_hppa_args_hash_lookup (args_hash_table, new_name, 1694 false, false); 1695 free (new_name); 1696 if (args_hash == NULL) 1697 return true; 1698 1699 /* We know this symbol has arg reloc bits. */ 1700 add_entry_to_symext_chain (abfd, args_hash->arg_bits, 1701 index, &symext_rootP, &symext_lastP); 1702 return true; 1703 } 1704 1705 /* Perform any processing needed late in the object file writing process. 1706 For PA ELF we build and set the contents of the symbol extension 1707 section. */ 1708 1709 static void 1710 elf32_hppa_backend_final_write_processing (abfd, linker) 1711 bfd *abfd; 1712 boolean linker; 1713 { 1714 asection *symextn_sec; 1715 unsigned int i; 1716 1717 /* Now build the symbol extension section. */ 1718 if (symext_chain_size == 0) 1719 return; 1720 1721 if (! linker) 1722 { 1723 /* We were not called from the backend linker, so we still need 1724 to build the symbol extension chain. 1725 1726 Look at each symbol, adding the appropriate information to the 1727 symbol extension section list as necessary. */ 1728 for (i = 0; i < abfd->symcount; i++) 1729 { 1730 elf_symbol_type *symbol = (elf_symbol_type *) abfd->outsymbols[i]; 1731 1732 /* Only functions ever need an entry in the symbol extension 1733 section. */ 1734 if (!(symbol->symbol.flags & BSF_FUNCTION)) 1735 continue; 1736 1737 /* And only if they specify the locations of their arguments. */ 1738 if (symbol->tc_data.hppa_arg_reloc == 0) 1739 continue; 1740 1741 /* Add this symbol's information to the chain. */ 1742 add_entry_to_symext_chain (abfd, symbol->tc_data.hppa_arg_reloc, 1743 symbol->symbol.udata.i, &symext_rootP, 1744 &symext_lastP); 1745 } 1746 } 1747 1748 /* Now fill in the contents of the symbol extension section. */ 1749 elf_hppa_tc_make_sections (abfd, symext_rootP); 1750 1751 /* And attach that as the section's contents. */ 1752 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME); 1753 if (symextn_sec == (asection *) 0) 1754 abort(); 1755 1756 symextn_sec->contents = (void *)symextn_contents; 1757 1758 bfd_set_section_contents (abfd, symextn_sec, symextn_sec->contents, 1759 symextn_sec->output_offset, symextn_sec->_raw_size); 1760 } 1761 1762 /* Update the symbol extention chain to include the symbol pointed to 1763 by SYMBOLP if SYMBOLP is a function symbol. Used internally and by GAS. */ 1764 1765 static void 1766 add_entry_to_symext_chain (abfd, arg_reloc, sym_idx, symext_root, symext_last) 1767 bfd *abfd; 1768 unsigned int arg_reloc; 1769 unsigned int sym_idx; 1770 symext_chainS **symext_root; 1771 symext_chainS **symext_last; 1772 { 1773 symext_chainS *symextP; 1774 1775 /* Allocate memory and initialize this entry. */ 1776 symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2); 1777 if (!symextP) 1778 abort(); /* FIXME */ 1779 1780 symextP[0].entry = ELF32_PARISC_SX_WORD (PARISC_SXT_SYMNDX, sym_idx); 1781 symextP[0].next = &symextP[1]; 1782 1783 symextP[1].entry = ELF32_PARISC_SX_WORD (PARISC_SXT_ARG_RELOC, arg_reloc); 1784 symextP[1].next = NULL; 1785 1786 /* Now update the chain itself so it can be walked later to build 1787 the symbol extension section. */ 1788 if (*symext_root == NULL) 1789 { 1790 *symext_root = &symextP[0]; 1791 *symext_last = &symextP[1]; 1792 } 1793 else 1794 { 1795 (*symext_last)->next = &symextP[0]; 1796 *symext_last = &symextP[1]; 1797 } 1798 } 1799 1800 /* Build the symbol extension section. */ 1801 1802 static void 1803 elf_hppa_tc_make_sections (abfd, symext_root) 1804 bfd *abfd; 1805 symext_chainS *symext_root; 1806 { 1807 symext_chainS *symextP; 1808 unsigned int i; 1809 asection *symextn_sec; 1810 1811 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME); 1812 1813 /* Grab some memory for the contents of the symbol extension section 1814 itself. */ 1815 symextn_contents = (bfd_byte *) bfd_zalloc (abfd, 1816 symextn_sec->_raw_size); 1817 if (!symextn_contents) 1818 abort(); /* FIXME */ 1819 1820 /* Fill in the contents of the symbol extension chain. */ 1821 for (i = 0, symextP = symext_root; symextP; symextP = symextP->next, ++i) 1822 ELF32_PARISC_SX_PUT (abfd, (bfd_vma) symextP->entry, 1823 symextn_contents + i * ELF32_PARISC_SX_SIZE); 1824 1825 return; 1826 } 1827 1828 /* Do some PA ELF specific work after reading in the symbol table. 1829 In particular attach the argument relocation from the 1830 symbol extension section to the appropriate symbols. */ 1831 1832 static boolean 1833 elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt) 1834 bfd *abfd; 1835 elf_symbol_type *esyms; 1836 unsigned int symcnt; 1837 { 1838 Elf32_Internal_Shdr *symextn_hdr = 1839 bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME); 1840 unsigned int i, current_sym_idx = 0; 1841 1842 /* If no symbol extension existed, then all symbol extension information 1843 is assumed to be zero. */ 1844 if (symextn_hdr == NULL) 1845 { 1846 for (i = 0; i < symcnt; i++) 1847 esyms[i].tc_data.hppa_arg_reloc = 0; 1848 return (true); 1849 } 1850 1851 /* FIXME: Why not use bfd_get_section_contents here? Also should give 1852 memory back when we're done. */ 1853 /* Allocate a buffer of the appropriate size for the symextn section. */ 1854 symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size); 1855 if (!symextn_hdr->contents) 1856 return false; 1857 1858 /* Read in the symextn section. */ 1859 if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1) 1860 return false; 1861 if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->sh_size, abfd) 1862 != symextn_hdr->sh_size) 1863 return false; 1864 1865 /* Parse entries in the symbol extension section, updating the symtab 1866 entries as we go */ 1867 for (i = 0; i < symextn_hdr->sh_size / ELF32_PARISC_SX_SIZE; i++) 1868 { 1869 symext_entryS se = 1870 ELF32_PARISC_SX_GET (abfd, 1871 ((unsigned char *)symextn_hdr->contents 1872 + i * ELF32_PARISC_SX_SIZE)); 1873 unsigned int se_value = ELF32_PARISC_SX_VAL (se); 1874 unsigned int se_type = ELF32_PARISC_SX_TYPE (se); 1875 1876 switch (se_type) 1877 { 1878 case PARISC_SXT_NULL: 1879 break; 1880 1881 case PARISC_SXT_SYMNDX: 1882 if (se_value >= symcnt) 1883 { 1884 bfd_set_error (bfd_error_bad_value); 1885 return (false); 1886 } 1887 current_sym_idx = se_value - 1; 1888 break; 1889 1890 case PARISC_SXT_ARG_RELOC: 1891 esyms[current_sym_idx].tc_data.hppa_arg_reloc = se_value; 1892 break; 1893 1894 default: 1895 bfd_set_error (bfd_error_bad_value); 1896 return (false); 1897 } 1898 } 1899 return (true); 1900 } 1901 1902 /* Read and attach the symbol extension information for the symbols 1903 in INPUT_BFD to the argument location hash table. Handle locals 1904 if DO_LOCALS is true; likewise for globals when DO_GLOBALS is true. */ 1905 1906 static boolean 1907 elf32_hppa_read_symext_info (input_bfd, symtab_hdr, args_hash_table, local_syms) 1908 bfd *input_bfd; 1909 Elf_Internal_Shdr *symtab_hdr; 1910 struct elf32_hppa_args_hash_table *args_hash_table; 1911 Elf_Internal_Sym *local_syms; 1912 { 1913 asection *symextn_sec; 1914 bfd_byte *contents; 1915 unsigned int i, n_entries, current_index = 0; 1916 1917 /* Get the symbol extension section for this BFD. If no section exists 1918 then there's nothing to do. Likewise if the section exists, but 1919 has no contents. */ 1920 symextn_sec = bfd_get_section_by_name (input_bfd, SYMEXTN_SECTION_NAME); 1921 if (symextn_sec == NULL) 1922 return true; 1923 1924 /* Done separately so we can turn off SEC_HAS_CONTENTS (see below). */ 1925 if (symextn_sec->_raw_size == 0) 1926 { 1927 symextn_sec->flags &= ~SEC_HAS_CONTENTS; 1928 return true; 1929 } 1930 1931 contents = (bfd_byte *) bfd_malloc ((size_t) symextn_sec->_raw_size); 1932 if (contents == NULL) 1933 return false; 1934 1935 /* How gross. We turn off SEC_HAS_CONTENTS for the input symbol extension 1936 sections to keep the generic ELF/BFD code from trying to do anything 1937 with them. We have to undo that hack temporarily so that we can read 1938 in the contents with the generic code. */ 1939 symextn_sec->flags |= SEC_HAS_CONTENTS; 1940 if (bfd_get_section_contents (input_bfd, symextn_sec, contents, 1941 0, symextn_sec->_raw_size) == false) 1942 { 1943 symextn_sec->flags &= ~SEC_HAS_CONTENTS; 1944 free (contents); 1945 return false; 1946 } 1947 1948 /* Gross. Turn off SEC_HAS_CONTENTS for the input symbol extension 1949 sections (see above). */ 1950 symextn_sec->flags &= ~SEC_HAS_CONTENTS; 1951 1952 n_entries = symextn_sec->_raw_size / ELF32_PARISC_SX_SIZE; 1953 for (i = 0; i < n_entries; i++) 1954 { 1955 symext_entryS entry = 1956 ELF32_PARISC_SX_GET (input_bfd, contents + i * ELF32_PARISC_SX_SIZE); 1957 unsigned int value = ELF32_PARISC_SX_VAL (entry); 1958 unsigned int type = ELF32_PARISC_SX_TYPE (entry); 1959 struct elf32_hppa_args_hash_entry *args_hash; 1960 1961 switch (type) 1962 { 1963 case PARISC_SXT_NULL: 1964 break; 1965 1966 case PARISC_SXT_SYMNDX: 1967 if (value >= symtab_hdr->sh_size / sizeof (Elf32_External_Sym)) 1968 { 1969 bfd_set_error (bfd_error_bad_value); 1970 free (contents); 1971 return false; 1972 } 1973 current_index = value; 1974 break; 1975 1976 case PARISC_SXT_ARG_RELOC: 1977 if (current_index < symtab_hdr->sh_info) 1978 { 1979 Elf_Internal_Shdr *hdr; 1980 char *new_name; 1981 const char *sym_name; 1982 asection *sym_sec; 1983 unsigned int len; 1984 1985 hdr = elf_elfsections (input_bfd)[local_syms[current_index].st_shndx]; 1986 sym_sec = hdr->bfd_section; 1987 sym_name = bfd_elf_string_from_elf_section (input_bfd, 1988 symtab_hdr->sh_link, 1989 local_syms[current_index].st_name); 1990 len = strlen (sym_name) + 10; 1991 new_name = bfd_malloc (len); 1992 if (new_name == NULL) 1993 { 1994 free (contents); 1995 return false; 1996 } 1997 strcpy (new_name, sym_name); 1998 sprintf (new_name + len - 10, "_%08x", (int)sym_sec); 1999 2000 /* This is a global symbol with argument location info. 2001 We need to enter it into the hash table. */ 2002 args_hash = elf32_hppa_args_hash_lookup (args_hash_table, 2003 new_name, true, 2004 true); 2005 free (new_name); 2006 if (args_hash == NULL) 2007 { 2008 free (contents); 2009 return false; 2010 } 2011 args_hash->arg_bits = value; 2012 break; 2013 } 2014 else if (current_index >= symtab_hdr->sh_info) 2015 { 2016 struct elf_link_hash_entry *h; 2017 2018 current_index -= symtab_hdr->sh_info; 2019 h = elf_sym_hashes(input_bfd)[current_index]; 2020 /* This is a global symbol with argument location 2021 information. We need to enter it into the hash table. */ 2022 args_hash = elf32_hppa_args_hash_lookup (args_hash_table, 2023 h->root.root.string, 2024 true, true); 2025 if (args_hash == NULL) 2026 { 2027 bfd_set_error (bfd_error_bad_value); 2028 free (contents); 2029 return false; 2030 } 2031 args_hash->arg_bits = value; 2032 break; 2033 } 2034 else 2035 break; 2036 2037 default: 2038 bfd_set_error (bfd_error_bad_value); 2039 free (contents); 2040 return false; 2041 } 2042 } 2043 free (contents); 2044 return true; 2045 } 2046 2047 /* Undo the generic ELF code's subtraction of section->vma from the 2048 value of each external symbol. */ 2049 2050 static boolean 2051 elf32_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp) 2052 bfd *abfd; 2053 struct bfd_link_info *info; 2054 const Elf_Internal_Sym *sym; 2055 const char **namep; 2056 flagword *flagsp; 2057 asection **secp; 2058 bfd_vma *valp; 2059 { 2060 *valp += (*secp)->vma; 2061 return true; 2062 } 2063 2064 /* Determine the name of the stub needed to perform a call assuming the 2065 argument relocation bits for caller and callee are in CALLER and CALLEE 2066 for a call from LOCATION to DESTINATION. Copy the name into STUB_NAME. */ 2067 2068 static void 2069 elf32_hppa_name_of_stub (caller, callee, location, destination, stub_name) 2070 unsigned int caller, callee; 2071 bfd_vma location, destination; 2072 char *stub_name; 2073 { 2074 arg_reloc_type arg_reloc_types[5]; 2075 2076 if (elf32_hppa_arg_reloc_needed (caller, callee, arg_reloc_types)) 2077 { 2078 arg_reloc_location i; 2079 /* Fill in the basic template. */ 2080 strcpy (stub_name, "__XX_XX_XX_XX_XX_stub_"); 2081 2082 /* Now fix the specifics. */ 2083 for (i = ARG0; i <= RET; i++) 2084 switch (arg_reloc_types[i]) 2085 { 2086 case NO: 2087 stub_name[3 * i + 2] = 'N'; 2088 stub_name[3 * i + 3] = 'O'; 2089 break; 2090 case GF: 2091 stub_name[3 * i + 2] = 'G'; 2092 stub_name[3 * i + 3] = 'F'; 2093 break; 2094 case FG: 2095 stub_name[3 * i + 2] = 'F'; 2096 stub_name[3 * i + 3] = 'G'; 2097 break; 2098 case GD: 2099 stub_name[3 * i + 2] = 'G'; 2100 stub_name[3 * i + 3] = 'D'; 2101 break; 2102 case DG: 2103 stub_name[3 * i + 2] = 'D'; 2104 stub_name[3 * i + 3] = 'G'; 2105 break; 2106 } 2107 } 2108 else 2109 strcpy (stub_name, "_____long_branch_stub_"); 2110 } 2111 2112 /* Determine if an argument relocation stub is needed to perform a 2113 call assuming the argument relocation bits for caller and callee 2114 are in CALLER and CALLEE. Place the type of relocations (if any) 2115 into stub_types_p. */ 2116 2117 static boolean 2118 elf32_hppa_arg_reloc_needed (caller, callee, stub_types) 2119 unsigned int caller, callee; 2120 arg_reloc_type stub_types[5]; 2121 { 2122 /* Special case for no relocations. */ 2123 if (caller == 0 || callee == 0) 2124 return 0; 2125 else 2126 { 2127 arg_location caller_loc[5]; 2128 arg_location callee_loc[5]; 2129 2130 /* Extract the location information for the argument and return 2131 value on both the caller and callee sides. */ 2132 caller_loc[ARG0] = EXTRACT_ARBITS (caller, ARG0); 2133 callee_loc[ARG0] = EXTRACT_ARBITS (callee, ARG0); 2134 caller_loc[ARG1] = EXTRACT_ARBITS (caller, ARG1); 2135 callee_loc[ARG1] = EXTRACT_ARBITS (callee, ARG1); 2136 caller_loc[ARG2] = EXTRACT_ARBITS (caller, ARG2); 2137 callee_loc[ARG2] = EXTRACT_ARBITS (callee, ARG2); 2138 caller_loc[ARG3] = EXTRACT_ARBITS (caller, ARG3); 2139 callee_loc[ARG3] = EXTRACT_ARBITS (callee, ARG3); 2140 caller_loc[RET] = EXTRACT_ARBITS (caller, RET); 2141 callee_loc[RET] = EXTRACT_ARBITS (callee, RET); 2142 2143 /* Check some special combinations. This is necessary to 2144 deal with double precision FP arguments. */ 2145 if (caller_loc[ARG0] == AR_FU || caller_loc[ARG1] == AR_FU) 2146 { 2147 caller_loc[ARG0] = AR_FPDBL1; 2148 caller_loc[ARG1] = AR_NO; 2149 } 2150 if (caller_loc[ARG2] == AR_FU || caller_loc[ARG3] == AR_FU) 2151 { 2152 caller_loc[ARG2] = AR_FPDBL2; 2153 caller_loc[ARG3] = AR_NO; 2154 } 2155 if (callee_loc[ARG0] == AR_FU || callee_loc[ARG1] == AR_FU) 2156 { 2157 callee_loc[ARG0] = AR_FPDBL1; 2158 callee_loc[ARG1] = AR_NO; 2159 } 2160 if (callee_loc[ARG2] == AR_FU || callee_loc[ARG3] == AR_FU) 2161 { 2162 callee_loc[ARG2] = AR_FPDBL2; 2163 callee_loc[ARG3] = AR_NO; 2164 } 2165 2166 /* Now look up any relocation needed for each argument and the 2167 return value. */ 2168 stub_types[ARG0] = arg_mismatches[caller_loc[ARG0]][callee_loc[ARG0]]; 2169 stub_types[ARG1] = arg_mismatches[caller_loc[ARG1]][callee_loc[ARG1]]; 2170 stub_types[ARG2] = arg_mismatches[caller_loc[ARG2]][callee_loc[ARG2]]; 2171 stub_types[ARG3] = arg_mismatches[caller_loc[ARG3]][callee_loc[ARG3]]; 2172 stub_types[RET] = ret_mismatches[caller_loc[RET]][callee_loc[RET]]; 2173 2174 return (stub_types[ARG0] != NO 2175 || stub_types[ARG1] != NO 2176 || stub_types[ARG2] != NO 2177 || stub_types[ARG3] != NO 2178 || stub_types[RET] != NO); 2179 } 2180 } 2181 2182 /* Compute the size of the stub needed to call from LOCATION to DESTINATION 2183 (a function named SYM_NAME), with argument relocation bits CALLER and 2184 CALLEE. Return zero if no stub is needed to perform such a call. */ 2185 2186 static unsigned int 2187 elf32_hppa_size_of_stub (callee, caller, location, destination, sym_name) 2188 unsigned int callee, caller; 2189 bfd_vma location, destination; 2190 const char *sym_name; 2191 { 2192 arg_reloc_type arg_reloc_types[5]; 2193 2194 /* Determine if a long branch or argument relocation stub is needed. 2195 If an argument relocation stub is needed, the relocation will be 2196 stored into arg_reloc_types. */ 2197 if (!(((int)(location - destination) > 0x3ffff) 2198 || ((int)(location - destination) < (int)0xfffc0000) 2199 || elf32_hppa_arg_reloc_needed (caller, callee, arg_reloc_types))) 2200 return 0; 2201 2202 /* Some kind of stub is needed. Determine how big it needs to be. 2203 First check for argument relocation stubs as they also handle 2204 long calls. Then check for long calls to millicode and finally 2205 the normal long calls. */ 2206 if (arg_reloc_types[ARG0] != NO 2207 || arg_reloc_types[ARG1] != NO 2208 || arg_reloc_types[ARG2] != NO 2209 || arg_reloc_types[ARG3] != NO 2210 || arg_reloc_types[RET] != NO) 2211 { 2212 /* Some kind of argument relocation stub is needed. */ 2213 unsigned int len = 16; 2214 arg_reloc_location i; 2215 2216 /* Each GR or FG relocation takes 2 insns, each GD or DG 2217 relocation takes 3 insns. Plus 4 more insns for the 2218 RP adjustment, ldil & (be | ble) and copy. */ 2219 for (i = ARG0; i <= RET; i++) 2220 switch (arg_reloc_types[i]) 2221 { 2222 case GF: 2223 case FG: 2224 len += 8; 2225 break; 2226 2227 case GD: 2228 case DG: 2229 len += 12; 2230 break; 2231 2232 default: 2233 break; 2234 } 2235 2236 /* Extra instructions are needed if we're relocating a return value. */ 2237 if (arg_reloc_types[RET] != NO) 2238 len += 12; 2239 2240 return len; 2241 } 2242 else if (!strncmp ("$$", sym_name, 2) 2243 && strcmp ("$$dyncall", sym_name)) 2244 return 12; 2245 else 2246 return 16; 2247 } 2248 2249 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY. 2250 IN_ARGS contains the stub BFD and link info pointers. */ 2251 2252 static boolean 2253 elf32_hppa_build_one_stub (gen_entry, in_args) 2254 struct bfd_hash_entry *gen_entry; 2255 PTR in_args; 2256 { 2257 void **args = (void **)in_args; 2258 bfd *stub_bfd = (bfd *)args[0]; 2259 struct bfd_link_info *info = (struct bfd_link_info *)args[1]; 2260 struct elf32_hppa_stub_hash_entry *entry; 2261 struct elf32_hppa_stub_hash_table *stub_hash_table; 2262 bfd_byte *loc; 2263 symvalue sym_value; 2264 const char *sym_name; 2265 2266 /* Initialize pointers to the stub hash table, the particular entry we 2267 are building a stub for, and where (in memory) we should place the stub 2268 instructions. */ 2269 entry = (struct elf32_hppa_stub_hash_entry *)gen_entry; 2270 stub_hash_table = elf32_hppa_hash_table(info)->stub_hash_table; 2271 loc = stub_hash_table->location; 2272 2273 /* Make a note of the offset within the stubs for this entry. */ 2274 entry->offset = stub_hash_table->offset; 2275 2276 /* The symbol's name starts at offset 22. */ 2277 sym_name = entry->root.string + 22; 2278 2279 sym_value = (entry->target_value 2280 + entry->target_section->output_offset 2281 + entry->target_section->output_section->vma); 2282 2283 if (strncmp ("_____long_branch_stub_", entry->root.string, 22)) 2284 { 2285 /* This must be an argument or return value relocation stub. */ 2286 unsigned long insn; 2287 arg_reloc_location i; 2288 bfd_byte *begin_loc = loc; 2289 2290 /* First the return pointer adjustment. Depending on exact calling 2291 sequence this instruction may be skipped. */ 2292 bfd_put_32 (stub_bfd, LDO_M4_R31_R31, loc); 2293 loc += 4; 2294 2295 /* If we are relocating a return value, then we're going to have 2296 to return into the stub. So we have to save off the user's 2297 return pointer into the stack at RP'. */ 2298 if (strncmp (entry->root.string + 14, "NO", 2)) 2299 { 2300 bfd_put_32 (stub_bfd, STW_R31_M8R30, loc); 2301 loc += 4; 2302 } 2303 2304 /* Iterate over the argument relocations, emitting instructions 2305 to move them around as necessary. */ 2306 for (i = ARG0; i <= ARG3; i++) 2307 { 2308 if (!strncmp (entry->root.string + 3 * i + 2, "GF", 2)) 2309 { 2310 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | ((26 - i) << 16), loc); 2311 bfd_put_32 (stub_bfd, FLDW_M16R30_FARG | (4 + i), loc + 4); 2312 loc += 8; 2313 } 2314 else if (!strncmp (entry->root.string + 3 * i + 2, "FG", 2)) 2315 { 2316 bfd_put_32 (stub_bfd, FSTW_FARG_M16R30 | (4 + i), loc); 2317 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | ((26 - i) << 16), loc + 4); 2318 loc += 8; 2319 } 2320 else if (!strncmp (entry->root.string + 3 * i + 2, "GD", 2)) 2321 { 2322 bfd_put_32 (stub_bfd, STW_ARG_M12R30 | ((26 - i) << 16), loc); 2323 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | ((25 - i) << 16), loc + 4); 2324 bfd_put_32 (stub_bfd, FLDD_M16R30_FARG | (5 + i), loc + 8); 2325 loc += 12; 2326 } 2327 else if (!strncmp (entry->root.string + 3 * i + 2, "DG", 2)) 2328 { 2329 bfd_put_32 (stub_bfd, FSTD_FARG_M16R30 | (5 + i), loc); 2330 bfd_put_32 (stub_bfd, LDW_M12R30_ARG | ((26 - i) << 16), loc + 4); 2331 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | ((25 - i) << 16), loc + 8); 2332 loc += 12; 2333 } 2334 } 2335 2336 /* Load the high bits of the target address into %r1. */ 2337 insn = hppa_rebuild_insn (stub_bfd, LDIL_R1, 2338 hppa_field_adjust (sym_value, 0, e_lrsel), 21); 2339 bfd_put_32 (stub_bfd, insn, loc); 2340 loc += 4; 2341 2342 /* If we are relocating a return value, then we're going to have 2343 to return into the stub, then perform the return value relocation. */ 2344 if (strncmp (entry->root.string + 14, "NO", 2)) 2345 { 2346 /* To return to the stub we "ble" to the target and copy the return 2347 pointer from %r31 into %r2. */ 2348 insn = hppa_rebuild_insn (stub_bfd, 2349 BLE_SR4_R1, 2350 hppa_field_adjust (sym_value, 0, 2351 e_rrsel) >> 2, 2352 17); 2353 bfd_put_32 (stub_bfd, insn, loc); 2354 bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 4); 2355 2356 /* Reload the return pointer for our caller from the stack. */ 2357 bfd_put_32 (stub_bfd, LDW_M8R30_R31, loc + 8); 2358 loc += 12; 2359 2360 /* Perform the return value relocation. */ 2361 if (!strncmp (entry->root.string + 14, "GF", 2)) 2362 { 2363 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | (28 << 16), loc); 2364 bfd_put_32 (stub_bfd, FLDW_M16R30_FARG | 4, loc + 4); 2365 loc += 8; 2366 } 2367 else if (!strncmp (entry->root.string + 14, "FG", 2)) 2368 { 2369 bfd_put_32 (stub_bfd, FSTW_FARG_M16R30 | 4, loc); 2370 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | (28 << 16), loc + 4); 2371 loc += 8; 2372 } 2373 else if (!strncmp (entry->root.string + 2, "GD", 2)) 2374 { 2375 bfd_put_32 (stub_bfd, STW_ARG_M12R30 | (28 << 16), loc); 2376 bfd_put_32 (stub_bfd, STW_ARG_M16R30 | (29 << 16), loc + 4); 2377 bfd_put_32 (stub_bfd, FLDD_M16R30_FARG | 4, loc + 8); 2378 loc += 12; 2379 } 2380 else if (!strncmp (entry->root.string + 2, "DG", 2)) 2381 { 2382 bfd_put_32 (stub_bfd, FSTD_FARG_M16R30 | 4, loc); 2383 bfd_put_32 (stub_bfd, LDW_M12R30_ARG | (28 << 16), loc + 4); 2384 bfd_put_32 (stub_bfd, LDW_M16R30_ARG | (29 << 16), loc + 8); 2385 loc += 12; 2386 } 2387 /* Branch back to the user's code now. */ 2388 bfd_put_32 (stub_bfd, BV_N_0_R31, loc); 2389 loc += 4; 2390 } 2391 else 2392 { 2393 /* No return value relocation, so we can simply "be" to the 2394 target and copy out return pointer into %r2. */ 2395 insn = hppa_rebuild_insn (stub_bfd, BE_SR4_R1, 2396 hppa_field_adjust (sym_value, 0, 2397 e_rrsel) >> 2, 17); 2398 bfd_put_32 (stub_bfd, insn, loc); 2399 bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 4); 2400 loc += 8; 2401 } 2402 2403 /* Update the location and offsets. */ 2404 stub_hash_table->location += (loc - begin_loc); 2405 stub_hash_table->offset += (loc - begin_loc); 2406 } 2407 else 2408 { 2409 /* Create one of two variant long branch stubs. One for $$dyncall and 2410 normal calls, the other for calls to millicode. */ 2411 unsigned long insn; 2412 int millicode_call = 0; 2413 2414 if (!strncmp ("$$", sym_name, 2) && strcmp ("$$dyncall", sym_name)) 2415 millicode_call = 1; 2416 2417 /* First the return pointer adjustment. Depending on exact calling 2418 sequence this instruction may be skipped. */ 2419 bfd_put_32 (stub_bfd, LDO_M4_R31_R31, loc); 2420 2421 /* The next two instructions are the long branch itself. A long branch 2422 is formed with "ldil" loading the upper bits of the target address 2423 into a register, then branching with "be" which adds in the lower bits. 2424 Long branches to millicode nullify the delay slot of the "be". */ 2425 insn = hppa_rebuild_insn (stub_bfd, LDIL_R1, 2426 hppa_field_adjust (sym_value, 0, e_lrsel), 21); 2427 bfd_put_32 (stub_bfd, insn, loc + 4); 2428 insn = hppa_rebuild_insn (stub_bfd, BE_SR4_R1 | (millicode_call ? 2 : 0), 2429 hppa_field_adjust (sym_value, 0, e_rrsel) >> 2, 2430 17); 2431 bfd_put_32 (stub_bfd, insn, loc + 8); 2432 2433 if (!millicode_call) 2434 { 2435 /* The sequence to call this stub places the return pointer into %r31, 2436 the final target expects the return pointer in %r2, so copy the 2437 return pointer into the proper register. */ 2438 bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 12); 2439 2440 /* Update the location and offsets. */ 2441 stub_hash_table->location += 16; 2442 stub_hash_table->offset += 16; 2443 } 2444 else 2445 { 2446 /* Update the location and offsets. */ 2447 stub_hash_table->location += 12; 2448 stub_hash_table->offset += 12; 2449 } 2450 2451 } 2452 return true; 2453 } 2454 2455 /* External entry points for sizing and building linker stubs. */ 2456 2457 /* Build all the stubs associated with the current output file. The 2458 stubs are kept in a hash table attached to the main linker hash 2459 table. This is called via hppaelf_finish in the linker. */ 2460 2461 boolean 2462 elf32_hppa_build_stubs (stub_bfd, info) 2463 bfd *stub_bfd; 2464 struct bfd_link_info *info; 2465 { 2466 /* The stub BFD only has one section. */ 2467 asection *stub_sec = stub_bfd->sections; 2468 struct elf32_hppa_stub_hash_table *table; 2469 unsigned int size; 2470 void *args[2]; 2471 2472 /* So we can pass both the BFD for the stubs and the link info 2473 structure to the routine which actually builds stubs. */ 2474 args[0] = stub_bfd; 2475 args[1] = info; 2476 2477 /* Allocate memory to hold the linker stubs. */ 2478 size = bfd_section_size (stub_bfd, stub_sec); 2479 stub_sec->contents = (unsigned char *) bfd_zalloc (stub_bfd, size); 2480 if (stub_sec->contents == NULL) 2481 return false; 2482 table = elf32_hppa_hash_table(info)->stub_hash_table; 2483 table->location = stub_sec->contents; 2484 2485 /* Build the stubs as directed by the stub hash table. */ 2486 elf32_hppa_stub_hash_traverse (table, elf32_hppa_build_one_stub, args); 2487 2488 return true; 2489 } 2490 2491 /* Determine and set the size of the stub section for a final link. 2492 2493 The basic idea here is to examine all the relocations looking for 2494 PC-relative calls to a target that is unreachable with a "bl" 2495 instruction or calls where the caller and callee disagree on the 2496 location of their arguments or return value. */ 2497 2498 boolean 2499 elf32_hppa_size_stubs (stub_bfd, output_bfd, link_info) 2500 bfd *stub_bfd; 2501 bfd *output_bfd; 2502 struct bfd_link_info *link_info; 2503 { 2504 bfd *input_bfd; 2505 asection *section, *stub_sec = 0; 2506 Elf_Internal_Shdr *symtab_hdr; 2507 Elf_Internal_Sym *local_syms, *isym, **all_local_syms; 2508 Elf32_External_Sym *ext_syms, *esym; 2509 unsigned int i, index, bfd_count = 0; 2510 struct elf32_hppa_stub_hash_table *stub_hash_table = 0; 2511 struct elf32_hppa_args_hash_table *args_hash_table = 0; 2512 2513 /* Create and initialize the stub hash table. */ 2514 stub_hash_table = ((struct elf32_hppa_stub_hash_table *) 2515 bfd_malloc (sizeof (struct elf32_hppa_stub_hash_table))); 2516 if (!stub_hash_table) 2517 goto error_return; 2518 2519 if (!elf32_hppa_stub_hash_table_init (stub_hash_table, stub_bfd, 2520 elf32_hppa_stub_hash_newfunc)) 2521 goto error_return; 2522 2523 /* Likewise for the argument location hash table. */ 2524 args_hash_table = ((struct elf32_hppa_args_hash_table *) 2525 bfd_malloc (sizeof (struct elf32_hppa_args_hash_table))); 2526 if (!args_hash_table) 2527 goto error_return; 2528 2529 if (!elf32_hppa_args_hash_table_init (args_hash_table, 2530 elf32_hppa_args_hash_newfunc)) 2531 goto error_return; 2532 2533 /* Attach the hash tables to the main hash table. */ 2534 elf32_hppa_hash_table(link_info)->stub_hash_table = stub_hash_table; 2535 elf32_hppa_hash_table(link_info)->args_hash_table = args_hash_table; 2536 2537 /* Count the number of input BFDs. */ 2538 for (input_bfd = link_info->input_bfds; 2539 input_bfd != NULL; 2540 input_bfd = input_bfd->link_next) 2541 bfd_count++; 2542 2543 /* We want to read in symbol extension records only once. To do this 2544 we need to read in the local symbols in parallel and save them for 2545 later use; so hold pointers to the local symbols in an array. */ 2546 all_local_syms 2547 = (Elf_Internal_Sym **) bfd_malloc (sizeof (Elf_Internal_Sym *) 2548 * bfd_count); 2549 if (all_local_syms == NULL) 2550 goto error_return; 2551 memset (all_local_syms, 0, sizeof (Elf_Internal_Sym *) * bfd_count); 2552 2553 /* Walk over all the input BFDs adding entries to the args hash table 2554 for all the external functions. */ 2555 for (input_bfd = link_info->input_bfds, index = 0; 2556 input_bfd != NULL; 2557 input_bfd = input_bfd->link_next, index++) 2558 { 2559 /* We'll need the symbol table in a second. */ 2560 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2561 if (symtab_hdr->sh_info == 0) 2562 continue; 2563 2564 /* We need an array of the local symbols attached to the input bfd. 2565 Unfortunately, we're going to have to read & swap them in. */ 2566 local_syms 2567 = (Elf_Internal_Sym *) bfd_malloc (symtab_hdr->sh_info 2568 * sizeof (Elf_Internal_Sym)); 2569 if (local_syms == NULL) 2570 { 2571 for (i = 0; i < bfd_count; i++) 2572 if (all_local_syms[i]) 2573 free (all_local_syms[i]); 2574 free (all_local_syms); 2575 goto error_return; 2576 } 2577 all_local_syms[index] = local_syms; 2578 2579 ext_syms 2580 = (Elf32_External_Sym *) bfd_malloc (symtab_hdr->sh_info 2581 * sizeof (Elf32_External_Sym)); 2582 if (ext_syms == NULL) 2583 { 2584 for (i = 0; i < bfd_count; i++) 2585 if (all_local_syms[i]) 2586 free (all_local_syms[i]); 2587 free (all_local_syms); 2588 goto error_return; 2589 } 2590 2591 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0 2592 || bfd_read (ext_syms, 1, 2593 (symtab_hdr->sh_info 2594 * sizeof (Elf32_External_Sym)), input_bfd) 2595 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))) 2596 { 2597 for (i = 0; i < bfd_count; i++) 2598 if (all_local_syms[i]) 2599 free (all_local_syms[i]); 2600 free (all_local_syms); 2601 free (ext_syms); 2602 goto error_return; 2603 } 2604 2605 /* Swap the local symbols in. */ 2606 isym = local_syms; 2607 esym = ext_syms; 2608 for (i = 0; i < symtab_hdr->sh_info; i++, esym++, isym++) 2609 bfd_elf32_swap_symbol_in (input_bfd, esym, isym); 2610 2611 /* Now we can free the external symbols. */ 2612 free (ext_syms); 2613 2614 if (elf32_hppa_read_symext_info (input_bfd, symtab_hdr, args_hash_table, 2615 local_syms) == false) 2616 { 2617 for (i = 0; i < bfd_count; i++) 2618 if (all_local_syms[i]) 2619 free (all_local_syms[i]); 2620 free (all_local_syms); 2621 goto error_return; 2622 } 2623 } 2624 2625 /* Magic as we know the stub bfd only has one section. */ 2626 stub_sec = stub_bfd->sections; 2627 2628 /* If generating a relocateable output file, then we don't 2629 have to examine the relocs. */ 2630 if (link_info->relocateable) 2631 { 2632 for (i = 0; i < bfd_count; i++) 2633 if (all_local_syms[i]) 2634 free (all_local_syms[i]); 2635 free (all_local_syms); 2636 return true; 2637 } 2638 2639 /* Now that we have argument location information for all the global 2640 functions we can start looking for stubs. */ 2641 for (input_bfd = link_info->input_bfds, index = 0; 2642 input_bfd != NULL; 2643 input_bfd = input_bfd->link_next, index++) 2644 { 2645 /* We'll need the symbol table in a second. */ 2646 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2647 if (symtab_hdr->sh_info == 0) 2648 continue; 2649 2650 local_syms = all_local_syms[index]; 2651 2652 /* Walk over each section attached to the input bfd. */ 2653 for (section = input_bfd->sections; 2654 section != NULL; 2655 section = section->next) 2656 { 2657 Elf_Internal_Shdr *input_rel_hdr; 2658 Elf32_External_Rela *external_relocs, *erelaend, *erela; 2659 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 2660 2661 /* If there aren't any relocs, then there's nothing to do. */ 2662 if ((section->flags & SEC_RELOC) == 0 2663 || section->reloc_count == 0) 2664 continue; 2665 2666 /* Allocate space for the external relocations. */ 2667 external_relocs 2668 = ((Elf32_External_Rela *) 2669 bfd_malloc (section->reloc_count 2670 * sizeof (Elf32_External_Rela))); 2671 if (external_relocs == NULL) 2672 { 2673 for (i = 0; i < bfd_count; i++) 2674 if (all_local_syms[i]) 2675 free (all_local_syms[i]); 2676 free (all_local_syms); 2677 goto error_return; 2678 } 2679 2680 /* Likewise for the internal relocations. */ 2681 internal_relocs 2682 = ((Elf_Internal_Rela *) 2683 bfd_malloc (section->reloc_count * sizeof (Elf_Internal_Rela))); 2684 if (internal_relocs == NULL) 2685 { 2686 free (external_relocs); 2687 for (i = 0; i < bfd_count; i++) 2688 if (all_local_syms[i]) 2689 free (all_local_syms[i]); 2690 free (all_local_syms); 2691 goto error_return; 2692 } 2693 2694 /* Read in the external relocs. */ 2695 input_rel_hdr = &elf_section_data (section)->rel_hdr; 2696 if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0 2697 || bfd_read (external_relocs, 1, input_rel_hdr->sh_size, 2698 input_bfd) != input_rel_hdr->sh_size) 2699 { 2700 free (external_relocs); 2701 free (internal_relocs); 2702 for (i = 0; i < bfd_count; i++) 2703 if (all_local_syms[i]) 2704 free (all_local_syms[i]); 2705 free (all_local_syms); 2706 goto error_return; 2707 } 2708 2709 /* Swap in the relocs. */ 2710 erela = external_relocs; 2711 erelaend = erela + section->reloc_count; 2712 irela = internal_relocs; 2713 for (; erela < erelaend; erela++, irela++) 2714 bfd_elf32_swap_reloca_in (input_bfd, erela, irela); 2715 2716 /* We're done with the external relocs, free them. */ 2717 free (external_relocs); 2718 2719 /* Now examine each relocation. */ 2720 irela = internal_relocs; 2721 irelaend = irela + section->reloc_count; 2722 for (; irela < irelaend; irela++) 2723 { 2724 long r_type, callee_args, caller_args, size_of_stub; 2725 unsigned long r_index; 2726 struct elf_link_hash_entry *hash; 2727 struct elf32_hppa_stub_hash_entry *stub_hash; 2728 struct elf32_hppa_args_hash_entry *args_hash; 2729 Elf_Internal_Sym *sym; 2730 asection *sym_sec; 2731 const char *sym_name; 2732 symvalue sym_value; 2733 bfd_vma location, destination; 2734 char *new_name = NULL; 2735 2736 r_type = ELF32_R_TYPE (irela->r_info); 2737 r_index = ELF32_R_SYM (irela->r_info); 2738 2739 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED) 2740 { 2741 bfd_set_error (bfd_error_bad_value); 2742 free (internal_relocs); 2743 for (i = 0; i < bfd_count; i++) 2744 if (all_local_syms[i]) 2745 free (all_local_syms[i]); 2746 free (all_local_syms); 2747 goto error_return; 2748 } 2749 2750 /* Only look for stubs on call instructions or plabel 2751 references. */ 2752 if (r_type != R_PARISC_PCREL17F 2753 && r_type != R_PARISC_PLABEL32 2754 && r_type != R_PARISC_PLABEL21L 2755 && r_type != R_PARISC_PLABEL14R) 2756 continue; 2757 2758 /* Now determine the call target, its name, value, section 2759 and argument relocation bits. */ 2760 hash = NULL; 2761 sym = NULL; 2762 sym_sec = NULL; 2763 if (r_index < symtab_hdr->sh_info) 2764 { 2765 /* It's a local symbol. */ 2766 Elf_Internal_Shdr *hdr; 2767 2768 sym = local_syms + r_index; 2769 hdr = elf_elfsections (input_bfd)[sym->st_shndx]; 2770 sym_sec = hdr->bfd_section; 2771 sym_name = bfd_elf_string_from_elf_section (input_bfd, 2772 symtab_hdr->sh_link, 2773 sym->st_name); 2774 sym_value = (ELF_ST_TYPE (sym->st_info) == STT_SECTION 2775 ? 0 : sym->st_value); 2776 destination = (sym_value 2777 + sym_sec->output_offset 2778 + sym_sec->output_section->vma); 2779 2780 /* Tack on an ID so we can uniquely identify this local 2781 symbol in the stub or arg info hash tables. */ 2782 new_name = bfd_malloc (strlen (sym_name) + 10); 2783 if (new_name == 0) 2784 { 2785 free (internal_relocs); 2786 for (i = 0; i < bfd_count; i++) 2787 if (all_local_syms[i]) 2788 free (all_local_syms[i]); 2789 free (all_local_syms); 2790 goto error_return; 2791 } 2792 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec); 2793 sym_name = new_name; 2794 } 2795 else 2796 { 2797 /* It's an external symbol. */ 2798 long index; 2799 2800 index = r_index - symtab_hdr->sh_info; 2801 hash = elf_sym_hashes (input_bfd)[index]; 2802 if (hash->root.type == bfd_link_hash_defined 2803 || hash->root.type == bfd_link_hash_defweak) 2804 { 2805 sym_sec = hash->root.u.def.section; 2806 sym_name = hash->root.root.string; 2807 sym_value = hash->root.u.def.value; 2808 destination = (sym_value 2809 + sym_sec->output_offset 2810 + sym_sec->output_section->vma); 2811 } 2812 else 2813 { 2814 bfd_set_error (bfd_error_bad_value); 2815 free (internal_relocs); 2816 for (i = 0; i < bfd_count; i++) 2817 if (all_local_syms[i]) 2818 free (all_local_syms[i]); 2819 free (all_local_syms); 2820 goto error_return; 2821 } 2822 } 2823 2824 args_hash = elf32_hppa_args_hash_lookup (args_hash_table, 2825 sym_name, false, false); 2826 2827 /* Get both caller and callee argument information. */ 2828 if (args_hash == NULL) 2829 callee_args = 0; 2830 else 2831 callee_args = args_hash->arg_bits; 2832 2833 /* For calls get the caller's bits from the addend of 2834 the call relocation. For PLABELS the caller's bits 2835 are assumed to have all args & return values in general 2836 registers (0x155). */ 2837 if (r_type == R_PARISC_PCREL17F) 2838 caller_args = HPPA_R_ARG_RELOC (irela->r_addend); 2839 else 2840 caller_args = 0x155; 2841 2842 /* Now determine where the call point is. */ 2843 location = (section->output_offset 2844 + section->output_section->vma 2845 + irela->r_offset); 2846 2847 /* We only care about the destination for PCREL function 2848 calls (eg. we don't care for PLABELS). */ 2849 if (r_type != R_PARISC_PCREL17F) 2850 location = destination; 2851 2852 /* Determine what (if any) linker stub is needed and its 2853 size (in bytes). */ 2854 size_of_stub = elf32_hppa_size_of_stub (callee_args, 2855 caller_args, 2856 location, 2857 destination, 2858 sym_name); 2859 if (size_of_stub != 0) 2860 { 2861 char *stub_name; 2862 unsigned int len; 2863 2864 /* Get the name of this stub. */ 2865 len = strlen (sym_name); 2866 len += 23; 2867 2868 stub_name = bfd_malloc (len); 2869 if (!stub_name) 2870 { 2871 /* Because sym_name was mallocd above for local 2872 symbols. */ 2873 if (r_index < symtab_hdr->sh_info) 2874 free (new_name); 2875 2876 free (internal_relocs); 2877 for (i = 0; i < bfd_count; i++) 2878 if (all_local_syms[i]) 2879 free (all_local_syms[i]); 2880 free (all_local_syms); 2881 goto error_return; 2882 } 2883 elf32_hppa_name_of_stub (caller_args, callee_args, 2884 location, destination, stub_name); 2885 strcat (stub_name + 22, sym_name); 2886 2887 /* Because sym_name was malloced above for local symbols. */ 2888 if (r_index < symtab_hdr->sh_info) 2889 free (new_name); 2890 2891 stub_hash 2892 = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name, 2893 false, false); 2894 if (stub_hash != NULL) 2895 { 2896 /* The proper stub has already been created, nothing 2897 else to do. */ 2898 free (stub_name); 2899 } 2900 else 2901 { 2902 bfd_set_section_size (stub_bfd, stub_sec, 2903 (bfd_section_size (stub_bfd, 2904 stub_sec) 2905 + size_of_stub)); 2906 2907 /* Enter this entry into the linker stub hash table. */ 2908 stub_hash 2909 = elf32_hppa_stub_hash_lookup (stub_hash_table, 2910 stub_name, true, true); 2911 if (stub_hash == NULL) 2912 { 2913 free (stub_name); 2914 free (internal_relocs); 2915 for (i = 0; i < bfd_count; i++) 2916 if (all_local_syms[i]) 2917 free (all_local_syms[i]); 2918 free (all_local_syms); 2919 goto error_return; 2920 } 2921 2922 /* We'll need these to determine the address that the 2923 stub will branch to. */ 2924 stub_hash->target_value = sym_value; 2925 stub_hash->target_section = sym_sec; 2926 } 2927 free (stub_name); 2928 } 2929 } 2930 /* We're done with the internal relocs, free them. */ 2931 free (internal_relocs); 2932 } 2933 } 2934 /* We're done with the local symbols, free them. */ 2935 for (i = 0; i < bfd_count; i++) 2936 if (all_local_syms[i]) 2937 free (all_local_syms[i]); 2938 free (all_local_syms); 2939 return true; 2940 2941 error_return: 2942 /* Return gracefully, avoiding dangling references to the hash tables. */ 2943 if (stub_hash_table) 2944 { 2945 elf32_hppa_hash_table(link_info)->stub_hash_table = NULL; 2946 free (stub_hash_table); 2947 } 2948 if (args_hash_table) 2949 { 2950 elf32_hppa_hash_table(link_info)->args_hash_table = NULL; 2951 free (args_hash_table); 2952 } 2953 /* Set the size of the stub section to zero since we're never going 2954 to create them. Avoids losing when we try to get its contents 2955 too. */ 2956 bfd_set_section_size (stub_bfd, stub_sec, 0); 2957 return false; 2958 } 2959 2960 /* Misc BFD support code. */ 2961 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup 2962 #define bfd_elf32_bfd_is_local_label hppa_elf_is_local_label 2963 2964 /* Symbol extension stuff. */ 2965 #define bfd_elf32_set_section_contents elf32_hppa_set_section_contents 2966 #define elf_info_to_howto elf32_hppa_info_to_howto 2967 #define elf_backend_symbol_table_processing \ 2968 elf32_hppa_backend_symbol_table_processing 2969 #define elf_backend_begin_write_processing \ 2970 elf32_hppa_backend_begin_write_processing 2971 #define elf_backend_final_write_processing \ 2972 elf32_hppa_backend_final_write_processing 2973 2974 /* Stuff for the BFD linker. */ 2975 #define elf_backend_relocate_section elf32_hppa_relocate_section 2976 #define elf_backend_add_symbol_hook elf32_hppa_add_symbol_hook 2977 #define elf_backend_link_output_symbol_hook \ 2978 elf32_hppa_link_output_symbol_hook 2979 #define bfd_elf32_bfd_link_hash_table_create \ 2980 elf32_hppa_link_hash_table_create 2981 2982 #define TARGET_BIG_SYM bfd_elf32_hppa_vec 2983 #define TARGET_BIG_NAME "elf32-hppa" 2984 #define ELF_ARCH bfd_arch_hppa 2985 #define ELF_MACHINE_CODE EM_PARISC 2986 #define ELF_MAXPAGESIZE 0x1000 2987 2988 #include "elf32-target.h" 2989