1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2023 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
30 enum 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
39 enum 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
47 struct got_entry
48 {
49 struct got_entry *next;
50 enum tls_type_e type;
51 bfd_vma offset;
52 bool processed;
53 bool 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
59 static struct got_entry **
60 arc_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
79 static struct got_entry *
80 got_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
94 static void
95 new_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
129 static enum tls_type_e
130 tls_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
156 static struct got_entry **
157 get_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
174 static enum tls_type_e
175 arc_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
217 static bool
218 arc_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 struct arc_static_sym_data {
266 bfd_vma sym_value;
267 const char *symbol_name;
268 };
269
270 static struct arc_static_sym_data
271 get_static_sym_data (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 static const char local_name[] = "(local)";
278 struct arc_static_sym_data ret = { 0, NULL };
279
280 if (h != NULL)
281 {
282 BFD_ASSERT (h->root.type != bfd_link_hash_undefweak
283 && h->root.type != bfd_link_hash_undefined);
284 /* TODO: This should not be here. */
285 reloc_data->sym_value = h->root.u.def.value;
286 reloc_data->sym_section = h->root.u.def.section;
287
288 ret.sym_value = h->root.u.def.value
289 + h->root.u.def.section->output_section->vma
290 + h->root.u.def.section->output_offset;
291
292 ret.symbol_name = h->root.root.string;
293 }
294 else
295 {
296 Elf_Internal_Sym *sym = local_syms + r_symndx;
297 asection *sec = local_sections[r_symndx];
298
299 ret.sym_value = sym->st_value
300 + sec->output_section->vma
301 + sec->output_offset;
302
303 ret.symbol_name = local_name;
304 }
305 return ret;
306 }
307
308 static bfd_vma
309 relocate_fix_got_relocs_for_got_info (struct got_entry ** list_p,
310 enum tls_type_e type,
311 struct bfd_link_info * info,
312 bfd * output_bfd,
313 unsigned long r_symndx,
314 Elf_Internal_Sym * local_syms,
315 asection ** local_sections,
316 struct elf_link_hash_entry * h,
317 struct arc_relocation_data * reloc_data)
318 {
319 struct elf_link_hash_table *htab = elf_hash_table (info);
320 struct got_entry *entry = NULL;
321
322 if (list_p == NULL || type == GOT_UNKNOWN || type == GOT_TLS_LE)
323 return 0;
324
325 entry = got_entry_for_type (list_p, type);
326 BFD_ASSERT (entry);
327
328 if (h == NULL
329 || h->forced_local == true
330 || (! elf_hash_table (info)->dynamic_sections_created
331 || (bfd_link_pic (info)
332 && SYMBOL_REFERENCES_LOCAL (info, h))))
333 {
334 const char ATTRIBUTE_UNUSED *symbol_name;
335 asection *tls_sec = elf_hash_table (info)->tls_sec;
336
337 if (entry && !entry->processed)
338 {
339 switch (entry->type)
340 {
341 case GOT_TLS_GD:
342 {
343 BFD_ASSERT (tls_sec && tls_sec->output_section);
344 bfd_vma sec_vma = tls_sec->output_section->vma;
345
346 if (h == NULL || h->forced_local
347 || !elf_hash_table (info)->dynamic_sections_created)
348 {
349 struct arc_static_sym_data tmp =
350 get_static_sym_data (r_symndx, local_syms, local_sections,
351 h, reloc_data);
352
353 bfd_put_32 (output_bfd,
354 tmp.sym_value - sec_vma
355 + (elf_hash_table (info)->dynamic_sections_created
356 ? 0
357 : (align_power (0,
358 tls_sec->alignment_power))),
359 htab->sgot->contents + entry->offset
360 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
361 ? 4 : 0));
362
363 ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
364 "@ %lx, for symbol %s\n",
365 (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
366 "GOT_TLS_IE"),
367 (long) (sym_value - sec_vma),
368 (long) (htab->sgot->output_section->vma
369 + htab->sgot->output_offset
370 + entry->offset
371 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
372 ? 4 : 0)),
373 tmp.symbol_name);
374 }
375 }
376 break;
377
378 case GOT_TLS_IE:
379 {
380 BFD_ASSERT (tls_sec && tls_sec->output_section);
381 bfd_vma ATTRIBUTE_UNUSED sec_vma
382 = tls_sec->output_section->vma;
383
384 struct arc_static_sym_data tmp =
385 get_static_sym_data (r_symndx, local_syms, local_sections,
386 h, reloc_data);
387
388 bfd_put_32 (output_bfd,
389 tmp.sym_value - sec_vma
390 + (elf_hash_table (info)->dynamic_sections_created
391 ? 0
392 : (align_power (TCB_SIZE,
393 tls_sec->alignment_power))),
394 htab->sgot->contents + entry->offset
395 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
396 ? 4 : 0));
397
398 ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
399 "@ %p, for symbol %s\n",
400 (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
401 "GOT_TLS_IE"),
402 (long) (sym_value - sec_vma),
403 (long) (htab->sgot->output_section->vma
404 + htab->sgot->output_offset
405 + entry->offset
406 + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
407 ? 4 : 0)),
408 tmp.symbol_name);
409 }
410 break;
411
412 case GOT_NORMAL:
413 {
414 bfd_vma sec_vma
415 = reloc_data->sym_section->output_section->vma
416 + reloc_data->sym_section->output_offset;
417
418 if (h != NULL
419 && h->root.type == bfd_link_hash_undefweak)
420 ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
421 "@ %#08lx for sym %s in got offset %#lx "
422 "(is undefweak)\n",
423 (long) (htab->sgot->output_section->vma
424 + htab->sgot->output_offset
425 + entry->offset),
426 symbol_name,
427 (long) entry->offset);
428 else
429 {
430 bfd_put_32 (output_bfd,
431 reloc_data->sym_value + sec_vma,
432 htab->sgot->contents + entry->offset);
433 ARC_DEBUG ("arc_info: PATCHED: %#08lx "
434 "@ %#08lx for sym %s in got offset %#lx\n",
435 (long) (reloc_data->sym_value + sec_vma),
436 (long) (htab->sgot->output_section->vma
437 + htab->sgot->output_offset
438 + entry->offset),
439 symbol_name,
440 (long) entry->offset);
441 }
442 }
443 break;
444 default:
445 BFD_ASSERT (0);
446 break;
447 }
448 entry->processed = true;
449 }
450 }
451
452 return entry->offset;
453 }
454
455 static void
456 create_got_dynrelocs_for_single_entry (struct got_entry *list,
457 bfd *output_bfd,
458 struct bfd_link_info * info,
459 struct elf_link_hash_entry *h)
460 {
461 if (list == NULL)
462 return;
463
464 bfd_vma got_offset = list->offset;
465
466 if (list->type == GOT_NORMAL
467 && !list->created_dyn_relocation)
468 {
469 if (bfd_link_pic (info)
470 && h != NULL
471 && (info->symbolic || h->dynindx == -1)
472 && h->def_regular)
473 {
474 ADD_RELA (output_bfd, got, got_offset, 0, R_ARC_RELATIVE, 0);
475 }
476 /* Do not fully understand the side effects of this condition.
477 The relocation space might still being reserved. Perhaps
478 I should clear its value. */
479 else if (h != NULL && h->dynindx != -1)
480 {
481 ADD_RELA (output_bfd, got, got_offset, h->dynindx, R_ARC_GLOB_DAT, 0);
482 }
483 list->created_dyn_relocation = true;
484 }
485 else if (list->existing_entries != TLS_GOT_NONE
486 && !list->created_dyn_relocation)
487 {
488 /* TODO TLS: This is not called for local symbols.
489 In order to correctly implement TLS, this should also
490 be called for all local symbols with tls got entries.
491 Should be moved to relocate_section in order to make it
492 work for local symbols. */
493 struct elf_link_hash_table *htab = elf_hash_table (info);
494 enum tls_got_entries e = list->existing_entries;
495
496 BFD_ASSERT (list->type != GOT_TLS_GD
497 || list->existing_entries == TLS_GOT_MOD_AND_OFF);
498
499 bfd_vma dynindx = (h == NULL || h->dynindx == -1) ? 0 : h->dynindx;
500
501 if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_MOD)
502 {
503 ADD_RELA (output_bfd, got, got_offset, dynindx,
504 R_ARC_TLS_DTPMOD, 0);
505 ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
506 GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = 0x0\n",
507 list->type,
508 (long) got_offset,
509 (long) (htab->sgot->output_section->vma
510 + htab->sgot->output_offset + got_offset),
511 (long) dynindx);
512 }
513
514 if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_OFF)
515 {
516 bfd_vma addend = 0;
517 if (list->type == GOT_TLS_IE)
518 {
519 addend = bfd_get_32 (output_bfd,
520 htab->sgot->contents + got_offset);
521 }
522
523 ADD_RELA (output_bfd, got,
524 got_offset + (e == TLS_GOT_MOD_AND_OFF ? 4 : 0),
525 dynindx,
526 (list->type == GOT_TLS_IE ? R_ARC_TLS_TPOFF
527 : R_ARC_TLS_DTPOFF),
528 addend);
529
530 ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
531 GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = %#lx\n",
532 list->type,
533 (long) got_offset,
534 (long) (htab->sgot->output_section->vma
535 + htab->sgot->output_offset + got_offset),
536 (long) dynindx, (long) addend);
537 }
538 list->created_dyn_relocation = true;
539 }
540 }
541
542 static void
543 create_got_dynrelocs_for_got_info (struct got_entry **list_p,
544 bfd *output_bfd,
545 struct bfd_link_info * info,
546 struct elf_link_hash_entry *h)
547 {
548 if (list_p == NULL)
549 return;
550
551 struct got_entry *list = *list_p;
552 /* Traverse the list of got entries for this symbol. */
553 while (list)
554 {
555 create_got_dynrelocs_for_single_entry (list, output_bfd, info, h);
556 list = list->next;
557 }
558 }
559
560 #undef ADD_SYMBOL_REF_SEC_AND_RELOC
561
562 #endif /* ARC_GOT_H */