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