arc-got.h revision 1.1.1.3
1/* ARC-specific support for 32-bit ELF 2 Copyright (C) 1994-2019 Free Software Foundation, Inc. 3 Contributed by Cupertino Miranda (cmiranda@synopsys.com). 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22#ifndef ARC_GOT_H 23#define ARC_GOT_H 24 25#define TCB_SIZE (8) 26 27#define align_power(addr, align) \ 28 (((addr) + ((bfd_vma) 1 << (align)) - 1) & (-((bfd_vma) 1 << (align)))) 29 30enum tls_type_e 31{ 32 GOT_UNKNOWN = 0, 33 GOT_NORMAL, 34 GOT_TLS_GD, 35 GOT_TLS_IE, 36 GOT_TLS_LE 37}; 38 39enum tls_got_entries 40{ 41 TLS_GOT_NONE = 0, 42 TLS_GOT_MOD, 43 TLS_GOT_OFF, 44 TLS_GOT_MOD_AND_OFF 45}; 46 47struct got_entry 48{ 49 struct got_entry *next; 50 enum tls_type_e type; 51 bfd_vma offset; 52 bfd_boolean processed; 53 bfd_boolean created_dyn_relocation; 54 enum tls_got_entries existing_entries; 55}; 56 57/* Return the local got list, if not defined, create an empty one. */ 58 59static struct got_entry ** 60arc_get_local_got_ents (bfd * abfd) 61{ 62 if (elf_local_got_ents (abfd) == NULL) 63 { 64 bfd_size_type amt = (elf_tdata (abfd)->symtab_hdr.sh_info 65 * sizeof (*elf_local_got_ents (abfd))); 66 elf_local_got_ents (abfd) = bfd_zmalloc (amt); 67 if (elf_local_got_ents (abfd) == NULL) 68 { 69 _bfd_error_handler (_("%pB: cannot allocate memory for local " 70 "GOT entries"), abfd); 71 bfd_set_error (bfd_error_bad_value); 72 return NULL; 73 } 74 } 75 76 return elf_local_got_ents (abfd); 77} 78 79static struct got_entry * 80got_entry_for_type (struct got_entry **list, 81 enum tls_type_e type) 82{ 83 struct got_entry **p = list; 84 85 while (*p != NULL) 86 { 87 if ((*p)->type == type) 88 return *p; 89 p = &((*p)->next); 90 } 91 return NULL; 92} 93 94static void 95new_got_entry_to_list (struct got_entry **list, 96 enum tls_type_e type, 97 bfd_vma offset, 98 enum tls_got_entries existing_entries) 99{ 100 /* Find list end. Avoid having multiple entries of the same 101 type. */ 102 struct got_entry **p = list; 103 struct got_entry *entry; 104 105 while (*p != NULL) 106 { 107 if ((*p)->type == type) 108 return; 109 p = &((*p)->next); 110 } 111 112 entry = (struct got_entry *) xmalloc (sizeof (struct got_entry)); 113 114 entry->type = type; 115 entry->offset = offset; 116 entry->next = NULL; 117 entry->processed = FALSE; 118 entry->created_dyn_relocation = FALSE; 119 entry->existing_entries = existing_entries; 120 121 ARC_DEBUG ("New GOT got entry added to list: " 122 "type: %d, offset: %ld, existing_entries: %d\n", 123 type, (long) offset, existing_entries); 124 125 /* Add the entry to the end of the list. */ 126 *p = entry; 127} 128 129static enum tls_type_e 130tls_type_for_reloc (reloc_howto_type *howto) 131{ 132 enum tls_type_e ret = GOT_UNKNOWN; 133 134 if (is_reloc_for_GOT (howto)) 135 return GOT_NORMAL; 136 137 switch (howto->type) 138 { 139 case R_ARC_TLS_GD_GOT: 140 ret = GOT_TLS_GD; 141 break; 142 case R_ARC_TLS_IE_GOT: 143 ret = GOT_TLS_IE; 144 break; 145 case R_ARC_TLS_LE_32: 146 ret = GOT_TLS_LE; 147 break; 148 default: 149 ret = GOT_UNKNOWN; 150 break; 151 } 152 153 return ret; 154}; 155 156static struct got_entry ** 157get_got_entry_list_for_symbol (bfd *abfd, 158 unsigned long r_symndx, 159 struct elf_link_hash_entry *h) 160{ 161 struct elf_arc_link_hash_entry *h1 = 162 ((struct elf_arc_link_hash_entry *) h); 163 if (h1 != NULL) 164 { 165 return &h1->got_ents; 166 } 167 else 168 { 169 return arc_get_local_got_ents (abfd) + r_symndx; 170 } 171} 172 173 174static enum tls_type_e 175arc_got_entry_type_for_reloc (reloc_howto_type *howto) 176{ 177 enum tls_type_e type = GOT_UNKNOWN; 178 179 if (is_reloc_for_GOT (howto)) 180 return GOT_NORMAL; 181 182 if (is_reloc_for_TLS (howto)) 183 { 184 switch (howto->type) 185 { 186 case R_ARC_TLS_GD_GOT: 187 type = GOT_TLS_GD; 188 break; 189 case R_ARC_TLS_IE_GOT: 190 type = GOT_TLS_IE; 191 break; 192 default: 193 break; 194 } 195 } 196 return type; 197} 198 199#define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H) \ 200 htab->s##SECNAME->size; \ 201 { \ 202 if (COND_FOR_RELOC) \ 203 { \ 204 htab->srel##SECNAME->size += sizeof (Elf32_External_Rela); \ 205 ARC_DEBUG ("arc_info: Added reloc space in " \ 206 #SECNAME " section at " __FILE__ \ 207 ":%d for symbol %s\n", \ 208 __LINE__, name_for_global_symbol (H)); \ 209 } \ 210 if (H) \ 211 if (H->dynindx == -1 && !H->forced_local) \ 212 if (! bfd_elf_link_record_dynamic_symbol (info, H)) \ 213 return FALSE; \ 214 htab->s##SECNAME->size += 4; \ 215 } \ 216 217static bfd_boolean 218arc_fill_got_info_for_reloc (enum tls_type_e type, 219 struct got_entry **list, 220 struct bfd_link_info * info, 221 struct elf_link_hash_entry *h) 222{ 223 struct elf_link_hash_table *htab = elf_hash_table (info); 224 225 if (got_entry_for_type (list, type) != NULL) 226 return TRUE; 227 228 switch (type) 229 { 230 case GOT_NORMAL: 231 { 232 bfd_vma offset 233 = ADD_SYMBOL_REF_SEC_AND_RELOC (got, bfd_link_pic (info) 234 || h != NULL, h); 235 new_got_entry_to_list (list, type, offset, TLS_GOT_NONE); 236 } 237 break; 238 239 240 case GOT_TLS_GD: 241 { 242 bfd_vma offset 243 = ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h); 244 bfd_vma ATTRIBUTE_UNUSED notneeded 245 = ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h); 246 new_got_entry_to_list (list, type, offset, TLS_GOT_MOD_AND_OFF); 247 } 248 break; 249 case GOT_TLS_IE: 250 case GOT_TLS_LE: 251 { 252 bfd_vma offset 253 = ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h); 254 new_got_entry_to_list (list, type, offset, TLS_GOT_OFF); 255 } 256 break; 257 258 default: 259 return FALSE; 260 break; 261 } 262 return TRUE; 263} 264 265 266static bfd_vma 267relocate_fix_got_relocs_for_got_info (struct got_entry ** list_p, 268 enum tls_type_e type, 269 struct bfd_link_info * info, 270 bfd * output_bfd, 271 unsigned long r_symndx, 272 Elf_Internal_Sym * local_syms, 273 asection ** local_sections, 274 struct elf_link_hash_entry * h, 275 struct arc_relocation_data * reloc_data) 276{ 277 struct elf_link_hash_table *htab = elf_hash_table (info); 278 struct got_entry *entry = NULL; 279 280 if (list_p == NULL || type == GOT_UNKNOWN || type == GOT_TLS_LE) 281 return 0; 282 283 entry = got_entry_for_type (list_p, type); 284 BFD_ASSERT (entry); 285 286 if (h == NULL 287 || h->forced_local == TRUE 288 || (! elf_hash_table (info)->dynamic_sections_created 289 || (bfd_link_pic (info) 290 && SYMBOL_REFERENCES_LOCAL (info, h)))) 291 { 292 const char ATTRIBUTE_UNUSED *symbol_name; 293 static const char local_name[] = "(local)"; 294 asection *tls_sec = NULL; 295 bfd_vma sym_value = 0; 296 297 if (h != NULL) 298 { 299 // TODO: This should not be here. 300 reloc_data->sym_value = h->root.u.def.value; 301 reloc_data->sym_section = h->root.u.def.section; 302 303 sym_value = h->root.u.def.value 304 + h->root.u.def.section->output_section->vma 305 + h->root.u.def.section->output_offset; 306 307 tls_sec = elf_hash_table (info)->tls_sec; 308 309 symbol_name = h->root.root.string; 310 } 311 else 312 { 313 Elf_Internal_Sym *sym = local_syms + r_symndx; 314 asection *sec = local_sections[r_symndx]; 315 316 sym_value = sym->st_value 317 + sec->output_section->vma 318 + sec->output_offset; 319 320 tls_sec = elf_hash_table (info)->tls_sec; 321 322 symbol_name = local_name; 323 } 324 325 326 if (entry && !entry->processed) 327 { 328 switch (entry->type) 329 { 330 case GOT_TLS_GD: 331 { 332 BFD_ASSERT (tls_sec && tls_sec->output_section); 333 bfd_vma sec_vma = tls_sec->output_section->vma; 334 335 if (h == NULL || h->forced_local 336 || !elf_hash_table (info)->dynamic_sections_created) 337 { 338 bfd_put_32 (output_bfd, 339 sym_value - sec_vma 340 + (elf_hash_table (info)->dynamic_sections_created 341 ? 0 342 : (align_power (0, 343 tls_sec->alignment_power))), 344 htab->sgot->contents + entry->offset 345 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF 346 ? 4 : 0)); 347 348 ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx " 349 "@ %lx, for symbol %s\n", 350 (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" : 351 "GOT_TLS_IE"), 352 (long) (sym_value - sec_vma), 353 (long) (htab->sgot->output_section->vma 354 + htab->sgot->output_offset 355 + entry->offset 356 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF 357 ? 4 : 0)), 358 symbol_name); 359 } 360 } 361 break; 362 363 case GOT_TLS_IE: 364 { 365 BFD_ASSERT (tls_sec && tls_sec->output_section); 366 bfd_vma ATTRIBUTE_UNUSED sec_vma 367 = tls_sec->output_section->vma; 368 369 bfd_put_32 (output_bfd, 370 sym_value - sec_vma 371 + (elf_hash_table (info)->dynamic_sections_created 372 ? 0 373 : (align_power (TCB_SIZE, 374 tls_sec->alignment_power))), 375 htab->sgot->contents + entry->offset 376 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF 377 ? 4 : 0)); 378 379 ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx " 380 "@ %p, for symbol %s\n", 381 (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" : 382 "GOT_TLS_IE"), 383 (long) (sym_value - sec_vma), 384 (long) (htab->sgot->output_section->vma 385 + htab->sgot->output_offset 386 + entry->offset 387 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF 388 ? 4 : 0)), 389 symbol_name); 390 } 391 break; 392 393 case GOT_NORMAL: 394 { 395 bfd_vma sec_vma 396 = reloc_data->sym_section->output_section->vma 397 + reloc_data->sym_section->output_offset; 398 399 if (h != NULL 400 && h->root.type == bfd_link_hash_undefweak) 401 ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED " 402 "@ %#08lx for sym %s in got offset %#lx " 403 "(is undefweak)\n", 404 (long) (htab->sgot->output_section->vma 405 + htab->sgot->output_offset 406 + entry->offset), 407 symbol_name, 408 (long) entry->offset); 409 else 410 { 411 bfd_put_32 (output_bfd, 412 reloc_data->sym_value + sec_vma, 413 htab->sgot->contents + entry->offset); 414 ARC_DEBUG ("arc_info: PATCHED: %#08lx " 415 "@ %#08lx for sym %s in got offset %#lx\n", 416 (long) (reloc_data->sym_value + sec_vma), 417 (long) (htab->sgot->output_section->vma 418 + htab->sgot->output_offset + entry->offset), 419 symbol_name, 420 (long) entry->offset); 421 } 422 } 423 break; 424 default: 425 BFD_ASSERT (0); 426 break; 427 } 428 entry->processed = TRUE; 429 } 430 } 431 432 return entry->offset; 433} 434 435static void 436create_got_dynrelocs_for_single_entry (struct got_entry *list, 437 bfd *output_bfd, 438 struct bfd_link_info * info, 439 struct elf_link_hash_entry *h) 440{ 441 if (list == NULL) 442 return; 443 444 bfd_vma got_offset = list->offset; 445 446 if (list->type == GOT_NORMAL 447 && !list->created_dyn_relocation) 448 { 449 if (bfd_link_pic (info) 450 && h != NULL 451 && (info->symbolic || h->dynindx == -1) 452 && h->def_regular) 453 { 454 ADD_RELA (output_bfd, got, got_offset, 0, R_ARC_RELATIVE, 0); 455 } 456 /* Do not fully understand the side effects of this condition. 457 The relocation space might still being reserved. Perhaps 458 I should clear its value. */ 459 else if (h != NULL && h->dynindx != -1) 460 { 461 ADD_RELA (output_bfd, got, got_offset, h->dynindx, R_ARC_GLOB_DAT, 0); 462 } 463 list->created_dyn_relocation = TRUE; 464 } 465 else if (list->existing_entries != TLS_GOT_NONE 466 && !list->created_dyn_relocation) 467 { 468 /* TODO TLS: This is not called for local symbols. 469 In order to correctly implement TLS, this should also 470 be called for all local symbols with tls got entries. 471 Should be moved to relocate_section in order to make it 472 work for local symbols. */ 473 struct elf_link_hash_table *htab = elf_hash_table (info); 474 enum tls_got_entries e = list->existing_entries; 475 476 BFD_ASSERT (list->type != GOT_TLS_GD 477 || list->existing_entries == TLS_GOT_MOD_AND_OFF); 478 479 bfd_vma dynindx = (h == NULL || h->dynindx == -1) ? 0 : h->dynindx; 480 481 if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_MOD) 482 { 483 ADD_RELA (output_bfd, got, got_offset, dynindx, 484 R_ARC_TLS_DTPMOD, 0); 485 ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \ 486GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = 0x0\n", 487 list->type, 488 (long) got_offset, 489 (long) (htab->sgot->output_section->vma 490 + htab->sgot->output_offset + got_offset), 491 (long) dynindx); 492 } 493 494 if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_OFF) 495 { 496 bfd_vma addend = 0; 497 if (list->type == GOT_TLS_IE) 498 { 499 addend = bfd_get_32 (output_bfd, 500 htab->sgot->contents + got_offset); 501 } 502 503 ADD_RELA (output_bfd, got, 504 got_offset + (e == TLS_GOT_MOD_AND_OFF ? 4 : 0), 505 dynindx, 506 (list->type == GOT_TLS_IE ? R_ARC_TLS_TPOFF 507 : R_ARC_TLS_DTPOFF), 508 addend); 509 510 ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \ 511GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = %#lx\n", 512 list->type, 513 (long) got_offset, 514 (long) (htab->sgot->output_section->vma 515 + htab->sgot->output_offset + got_offset), 516 (long) dynindx, (long) addend); 517 } 518 list->created_dyn_relocation = TRUE; 519 } 520} 521 522static void 523create_got_dynrelocs_for_got_info (struct got_entry **list_p, 524 bfd *output_bfd, 525 struct bfd_link_info * info, 526 struct elf_link_hash_entry *h) 527{ 528 if (list_p == NULL) 529 return; 530 531 struct got_entry *list = *list_p; 532 /* Traverse the list of got entries for this symbol. */ 533 while (list) 534 { 535 create_got_dynrelocs_for_single_entry (list, output_bfd, info, h); 536 list = list->next; 537 } 538} 539 540#undef ADD_SYMBOL_REF_SEC_AND_RELOC 541 542#endif /* ARC_GOT_H */ 543