]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-or1k.c
projects / thirdparty / binutils-gdb.git / blob
? search:


451253d0e7ebb1e1526ac8911832d3e0be7a75ea
[thirdparty/binutils-gdb.git] / bfd / elf32-or1k.c
1 /* Or1k-specific support for 32-bit ELF.
2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3 Contributed for OR32 by Johan Rydberg, jrydberg@opencores.org
4
5 PIC parts added by Stefan Kristiansson, stefan.kristiansson@saunalahti.fi,
6 largely based on elf32-m32r.c and elf32-microblaze.c.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, see <http://www.gnu.org/licenses/>. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/or1k.h"
28 #include "libiberty.h"
29
30 #define N_ONES(X) (((bfd_vma)2 << (X)) - 1)
31
32 #define PLT_ENTRY_SIZE 20
33
34 #define PLT0_ENTRY_WORD0 0x19800000 /* l.movhi r12, 0 <- hi(.got+4) */
35 #define PLT0_ENTRY_WORD1 0xa98c0000 /* l.ori r12, r12, 0 <- lo(.got+4) */
36 #define PLT0_ENTRY_WORD2 0x85ec0004 /* l.lwz r15, 4(r12) <- *(.got+8)*/
37 #define PLT0_ENTRY_WORD3 0x44007800 /* l.jr r15 */
38 #define PLT0_ENTRY_WORD4 0x858c0000 /* l.lwz r12, 0(r12) */
39
40 #define PLT0_PIC_ENTRY_WORD0 0x85900004 /* l.lwz r12, 4(r16) */
41 #define PLT0_PIC_ENTRY_WORD1 0x85f00008 /* l.lwz r15, 8(r16) */
42 #define PLT0_PIC_ENTRY_WORD2 0x44007800 /* l.jr r15 */
43 #define PLT0_PIC_ENTRY_WORD3 0x15000000 /* l.nop */
44 #define PLT0_PIC_ENTRY_WORD4 0x15000000 /* l.nop */
45
46 #define PLT_ENTRY_WORD0 0x19800000 /* l.movhi r12, 0 <- hi(got idx addr) */
47 #define PLT_ENTRY_WORD1 0xa98c0000 /* l.ori r12, r12, 0 <- lo(got idx addr) */
48 #define PLT_ENTRY_WORD2 0x858c0000 /* l.lwz r12, 0(r12) */
49 #define PLT_ENTRY_WORD3 0x44006000 /* l.jr r12 */
50 #define PLT_ENTRY_WORD4 0xa9600000 /* l.ori r11, r0, 0 <- reloc offset */
51
52 #define PLT_PIC_ENTRY_WORD0 0x85900000 /* l.lwz r12, 0(r16) <- index in got */
53 #define PLT_PIC_ENTRY_WORD1 0xa9600000 /* l.ori r11, r0, 0 <- reloc offset */
54 #define PLT_PIC_ENTRY_WORD2 0x44006000 /* l.jr r12 */
55 #define PLT_PIC_ENTRY_WORD3 0x15000000 /* l.nop */
56 #define PLT_PIC_ENTRY_WORD4 0x15000000 /* l.nop */
57
58 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
59
60 static reloc_howto_type or1k_elf_howto_table[] =
61 {
62 /* This reloc does nothing. */
63 HOWTO (R_OR1K_NONE, /* type */
64 0, /* rightshift */
65 3, /* size (0 = byte, 1 = short, 2 = long) */
66 0, /* bitsize */
67 FALSE, /* pc_relative */
68 0, /* bitpos */
69 complain_overflow_dont, /* complain_on_overflow */
70 bfd_elf_generic_reloc, /* special_function */
71 "R_OR1K_NONE", /* name */
72 FALSE, /* partial_inplace */
73 0, /* src_mask */
74 0, /* dst_mask */
75 FALSE), /* pcrel_offset */
76
77 HOWTO (R_OR1K_32,
78 0, /* rightshift */
79 2, /* size (0 = byte, 1 = short, 2 = long) */
80 32, /* bitsize */
81 FALSE, /* pc_relative */
82 0, /* bitpos */
83 complain_overflow_unsigned, /* complain_on_overflow */
84 bfd_elf_generic_reloc, /* special_function */
85 "R_OR1K_32", /* name */
86 FALSE, /* partial_inplace */
87 0, /* src_mask */
88 0xffffffff, /* dst_mask */
89 FALSE), /* pcrel_offset */
90
91 HOWTO (R_OR1K_16,
92 0, /* rightshift */
93 1, /* size (0 = byte, 1 = short, 2 = long) */
94 16, /* bitsize */
95 FALSE, /* pc_relative */
96 0, /* bitpos */
97 complain_overflow_unsigned, /* complain_on_overflow */
98 bfd_elf_generic_reloc, /* special_function */
99 "R_OR1K_16", /* name */
100 FALSE, /* partial_inplace */
101 0, /* src_mask */
102 0xffff, /* dst_mask */
103 FALSE), /* pcrel_offset */
104
105 HOWTO (R_OR1K_8,
106 0, /* rightshift */
107 0, /* size (0 = byte, 1 = short, 2 = long) */
108 8, /* bitsize */
109 FALSE, /* pc_relative */
110 0, /* bitpos */
111 complain_overflow_unsigned, /* complain_on_overflow */
112 bfd_elf_generic_reloc, /* special_function */
113 "R_OR1K_8", /* name */
114 FALSE, /* partial_inplace */
115 0, /* src_mask */
116 0xff, /* dst_mask */
117 FALSE), /* pcrel_offset */
118
119 HOWTO (R_OR1K_LO_16_IN_INSN, /* type */
120 0, /* rightshift */
121 2, /* size (0 = byte, 1 = short, 2 = long) */
122 16, /* bitsize */
123 FALSE, /* pc_relative */
124 0, /* bitpos */
125 complain_overflow_dont, /* complain_on_overflow */
126 bfd_elf_generic_reloc, /* special_function */
127 "R_OR1K_LO_16_IN_INSN", /* name */
128 FALSE, /* partial_inplace */
129 0, /* src_mask */
130 0x0000ffff, /* dst_mask */
131 FALSE), /* pcrel_offset */
132
133 HOWTO (R_OR1K_HI_16_IN_INSN, /* type */
134 16, /* rightshift */
135 2, /* size (0 = byte, 1 = short, 2 = long) */
136 16, /* bitsize */
137 FALSE, /* pc_relative */
138 0, /* bitpos */
139 complain_overflow_dont, /* complain_on_overflow */
140 bfd_elf_generic_reloc, /* special_function */
141 "R_OR1K_HI_16_IN_INSN", /* name */
142 FALSE, /* partial_inplace */
143 0, /* src_mask */
144 0x0000ffff, /* dst_mask */
145 FALSE), /* pcrel_offset */
146
147 /* A PC relative 26 bit relocation, right shifted by 2. */
148 HOWTO (R_OR1K_INSN_REL_26, /* type */
149 2, /* rightshift */
150 2, /* size (0 = byte, 1 = short, 2 = long) */
151 26, /* bitsize */
152 TRUE, /* pc_relative */
153 0, /* bitpos */
154 complain_overflow_signed, /* complain_on_overflow */
155 bfd_elf_generic_reloc, /* special_function */
156 "R_OR1K_INSN_REL_26", /* name */
157 FALSE, /* partial_inplace */
158 0, /* src_mask */
159 0x03ffffff, /* dst_mask */
160 TRUE), /* pcrel_offset */
161
162 /* GNU extension to record C++ vtable hierarchy. */
163 HOWTO (R_OR1K_GNU_VTINHERIT, /* type */
164 0, /* rightshift */
165 2, /* size (0 = byte, 1 = short, 2 = long) */
166 0, /* bitsize */
167 FALSE, /* pc_relative */
168 0, /* bitpos */
169 complain_overflow_dont, /* complain_on_overflow */
170 NULL, /* special_function */
171 "R_OR1K_GNU_VTINHERIT", /* name */
172 FALSE, /* partial_inplace */
173 0, /* src_mask */
174 0, /* dst_mask */
175 FALSE), /* pcrel_offset */
176
177 /* GNU extension to record C++ vtable member usage. */
178 HOWTO (R_OR1K_GNU_VTENTRY, /* type */
179 0, /* rightshift */
180 2, /* size (0 = byte, 1 = short, 2 = long) */
181 0, /* bitsize */
182 FALSE, /* pc_relative */
183 0, /* bitpos */
184 complain_overflow_dont, /* complain_on_overflow */
185 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
186 "R_OR1K_GNU_VTENTRY", /* name */
187 FALSE, /* partial_inplace */
188 0, /* src_mask */
189 0, /* dst_mask */
190 FALSE), /* pcrel_offset */
191
192 HOWTO (R_OR1K_32_PCREL,
193 0, /* rightshift */
194 2, /* size (0 = byte, 1 = short, 2 = long) */
195 32, /* bitsize */
196 TRUE, /* pc_relative */
197 0, /* bitpos */
198 complain_overflow_signed, /* complain_on_overflow */
199 bfd_elf_generic_reloc, /* special_function */
200 "R_OR1K_32_PCREL", /* name */
201 FALSE, /* partial_inplace */
202 0, /* src_mask */
203 0xffffffff, /* dst_mask */
204 TRUE), /* pcrel_offset */
205
206 HOWTO (R_OR1K_16_PCREL,
207 0, /* rightshift */
208 1, /* size (0 = byte, 1 = short, 2 = long) */
209 16, /* bitsize */
210 TRUE, /* pc_relative */
211 0, /* bitpos */
212 complain_overflow_signed, /* complain_on_overflow */
213 bfd_elf_generic_reloc, /* special_function */
214 "R_OR1K_16_PCREL", /* name */
215 FALSE, /* partial_inplace */
216 0, /* src_mask */
217 0xffff, /* dst_mask */
218 TRUE), /* pcrel_offset */
219
220 HOWTO (R_OR1K_8_PCREL,
221 0, /* rightshift */
222 0, /* size (0 = byte, 1 = short, 2 = long) */
223 8, /* bitsize */
224 TRUE, /* pc_relative */
225 0, /* bitpos */
226 complain_overflow_signed, /* complain_on_overflow */
227 bfd_elf_generic_reloc, /* special_function */
228 "R_OR1K_8_PCREL", /* name */
229 FALSE, /* partial_inplace */
230 0, /* src_mask */
231 0xff, /* dst_mask */
232 TRUE), /* pcrel_offset */
233
234 HOWTO (R_OR1K_GOTPC_HI16, /* Type. */
235 16, /* Rightshift. */
236 2, /* Size (0 = byte, 1 = short, 2 = long). */
237 16, /* Bitsize. */
238 TRUE, /* PC_relative. */
239 0, /* Bitpos. */
240 complain_overflow_dont, /* Complain on overflow. */
241 bfd_elf_generic_reloc, /* Special Function. */
242 "R_OR1K_GOTPC_HI16", /* Name. */
243 FALSE, /* Partial Inplace. */
244 0, /* Source Mask. */
245 0xffff, /* Dest Mask. */
246 TRUE), /* PC relative offset? */
247
248 HOWTO (R_OR1K_GOTPC_LO16, /* Type. */
249 0, /* Rightshift. */
250 2, /* Size (0 = byte, 1 = short, 2 = long). */
251 16, /* Bitsize. */
252 TRUE, /* PC_relative. */
253 0, /* Bitpos. */
254 complain_overflow_dont, /* Complain on overflow. */
255 bfd_elf_generic_reloc, /* Special Function. */
256 "R_OR1K_GOTPC_LO16", /* Name. */
257 FALSE, /* Partial Inplace. */
258 0, /* Source Mask. */
259 0xffff, /* Dest Mask. */
260 TRUE), /* PC relative offset? */
261
262 HOWTO (R_OR1K_GOT16, /* type */
263 0, /* rightshift */
264 2, /* size (0 = byte, 1 = short, 2 = long) */
265 16, /* bitsize */
266 FALSE, /* pc_relative */
267 0, /* bitpos */
268 complain_overflow_signed, /* complain_on_overflow */
269 bfd_elf_generic_reloc, /* special_function */
270 "R_OR1K_GOT16", /* name */
271 FALSE, /* partial_inplace */
272 0, /* src_mask */
273 0xffff, /* dst_mask */
274 FALSE), /* pcrel_offset */
275
276 /* A 26 bit PLT relocation. Shifted by 2. */
277 HOWTO (R_OR1K_PLT26, /* Type. */
278 2, /* Rightshift. */
279 2, /* Size (0 = byte, 1 = short, 2 = long). */
280 26, /* Bitsize. */
281 TRUE, /* PC_relative. */
282 0, /* Bitpos. */
283 complain_overflow_signed, /* Complain on overflow. */
284 bfd_elf_generic_reloc,/* Special Function. */
285 "R_OR1K_PLT26", /* Name. */
286 FALSE, /* Partial Inplace. */
287 0, /* Source Mask. */
288 0x03ffffff, /* Dest Mask. */
289 TRUE), /* PC relative offset? */
290
291 HOWTO (R_OR1K_GOTOFF_HI16, /* type */
292 16, /* rightshift */
293 2, /* size (0 = byte, 1 = short, 2 = long) */
294 16, /* bitsize */
295 FALSE, /* pc_relative */
296 0, /* bitpos */
297 complain_overflow_dont, /* complain_on_overflow */
298 bfd_elf_generic_reloc, /* special_function */
299 "R_OR1K_GOTOFF_HI16", /* name */
300 FALSE, /* partial_inplace */
301 0x0, /* src_mask */
302 0xffff, /* dst_mask */
303 FALSE), /* pcrel_offset */
304
305 HOWTO (R_OR1K_GOTOFF_LO16, /* type */
306 0, /* rightshift */
307 2, /* size (0 = byte, 1 = short, 2 = long) */
308 16, /* bitsize */
309 FALSE, /* pc_relative */
310 0, /* bitpos */
311 complain_overflow_dont, /* complain_on_overflow */
312 bfd_elf_generic_reloc, /* special_function */
313 "R_OR1K_GOTOFF_LO16", /* name */
314 FALSE, /* partial_inplace */
315 0x0, /* src_mask */
316 0xffff, /* dst_mask */
317 FALSE), /* pcrel_offset */
318
319 HOWTO (R_OR1K_COPY, /* type */
320 0, /* rightshift */
321 2, /* size (0 = byte, 1 = short, 2 = long) */
322 32, /* bitsize */
323 FALSE, /* pc_relative */
324 0, /* bitpos */
325 complain_overflow_bitfield, /* complain_on_overflow */
326 bfd_elf_generic_reloc, /* special_function */
327 "R_OR1K_COPY", /* name */
328 FALSE, /* partial_inplace */
329 0xffffffff, /* src_mask */
330 0xffffffff, /* dst_mask */
331 FALSE), /* pcrel_offset */
332
333 HOWTO (R_OR1K_GLOB_DAT, /* type */
334 0, /* rightshift */
335 2, /* size (0 = byte, 1 = short, 2 = long) */
336 32, /* bitsize */
337 FALSE, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_bitfield, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_OR1K_GLOB_DAT", /* name */
342 FALSE, /* partial_inplace */
343 0xffffffff, /* src_mask */
344 0xffffffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
346
347 HOWTO (R_OR1K_JMP_SLOT, /* type */
348 0, /* rightshift */
349 2, /* size (0 = byte, 1 = short, 2 = long) */
350 32, /* bitsize */
351 FALSE, /* pc_relative */
352 0, /* bitpos */
353 complain_overflow_bitfield, /* complain_on_overflow */
354 bfd_elf_generic_reloc, /* special_function */
355 "R_OR1K_JMP_SLOT", /* name */
356 FALSE, /* partial_inplace */
357 0xffffffff, /* src_mask */
358 0xffffffff, /* dst_mask */
359 FALSE), /* pcrel_offset */
360
361 HOWTO (R_OR1K_RELATIVE, /* type */
362 0, /* rightshift */
363 2, /* size (0 = byte, 1 = short, 2 = long) */
364 32, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_bitfield, /* complain_on_overflow */
368 bfd_elf_generic_reloc, /* special_function */
369 "R_OR1K_RELATIVE", /* name */
370 FALSE, /* partial_inplace */
371 0xffffffff, /* src_mask */
372 0xffffffff, /* dst_mask */
373 FALSE), /* pcrel_offset */
374
375 HOWTO (R_OR1K_TLS_GD_HI16, /* type */
376 16, /* rightshift */
377 2, /* size (0 = byte, 1 = short, 2 = long) */
378 16, /* bitsize */
379 FALSE, /* pc_relative */
380 0, /* bitpos */
381 complain_overflow_dont, /* complain_on_overflow */
382 bfd_elf_generic_reloc, /* special_function */
383 "R_OR1K_TLS_GD_HI16", /* name */
384 FALSE, /* partial_inplace */
385 0x0, /* src_mask */
386 0xffff, /* dst_mask */
387 FALSE), /* pcrel_offset */
388
389 HOWTO (R_OR1K_TLS_GD_LO16, /* type */
390 0, /* rightshift */
391 2, /* size (0 = byte, 1 = short, 2 = long) */
392 16, /* bitsize */
393 FALSE, /* pc_relative */
394 0, /* bitpos */
395 complain_overflow_dont, /* complain_on_overflow */
396 bfd_elf_generic_reloc, /* special_function */
397 "R_OR1K_TLS_GD_LO16", /* name */
398 FALSE, /* partial_inplace */
399 0x0, /* src_mask */
400 0xffff, /* dst_mask */
401 FALSE), /* pcrel_offset */
402
403 HOWTO (R_OR1K_TLS_LDM_HI16, /* type */
404 16, /* rightshift */
405 2, /* size (0 = byte, 1 = short, 2 = long) */
406 16, /* bitsize */
407 FALSE, /* pc_relative */
408 0, /* bitpos */
409 complain_overflow_dont, /* complain_on_overflow */
410 bfd_elf_generic_reloc, /* special_function */
411 "R_OR1K_TLS_LDM_HI16", /* name */
412 FALSE, /* partial_inplace */
413 0x0, /* src_mask */
414 0xffff, /* dst_mask */
415 FALSE), /* pcrel_offset */
416
417 HOWTO (R_OR1K_TLS_LDM_LO16, /* type */
418 0, /* rightshift */
419 2, /* size (0 = byte, 1 = short, 2 = long) */
420 16, /* bitsize */
421 FALSE, /* pc_relative */
422 0, /* bitpos */
423 complain_overflow_dont, /* complain_on_overflow */
424 bfd_elf_generic_reloc, /* special_function */
425 "R_OR1K_TLS_LDM_LO16", /* name */
426 FALSE, /* partial_inplace */
427 0x0, /* src_mask */
428 0xffff, /* dst_mask */
429 FALSE), /* pcrel_offset */
430
431 HOWTO (R_OR1K_TLS_LDO_HI16, /* type */
432 16, /* rightshift */
433 2, /* size (0 = byte, 1 = short, 2 = long) */
434 16, /* bitsize */
435 FALSE, /* pc_relative */
436 0, /* bitpos */
437 complain_overflow_dont, /* complain_on_overflow */
438 bfd_elf_generic_reloc, /* special_function */
439 "R_OR1K_TLS_LDO_HI16", /* name */
440 FALSE, /* partial_inplace */
441 0x0, /* src_mask */
442 0xffff, /* dst_mask */
443 FALSE), /* pcrel_offset */
444
445 HOWTO (R_OR1K_TLS_LDO_LO16, /* type */
446 0, /* rightshift */
447 2, /* size (0 = byte, 1 = short, 2 = long) */
448 16, /* bitsize */
449 FALSE, /* pc_relative */
450 0, /* bitpos */
451 complain_overflow_dont, /* complain_on_overflow */
452 bfd_elf_generic_reloc, /* special_function */
453 "R_OR1K_TLS_LDO_LO16", /* name */
454 FALSE, /* partial_inplace */
455 0x0, /* src_mask */
456 0xffff, /* dst_mask */
457 FALSE), /* pcrel_offset */
458
459 HOWTO (R_OR1K_TLS_IE_HI16, /* type */
460 16, /* rightshift */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
462 16, /* bitsize */
463 FALSE, /* pc_relative */
464 0, /* bitpos */
465 complain_overflow_dont, /* complain_on_overflow */
466 bfd_elf_generic_reloc, /* special_function */
467 "R_OR1K_TLS_IE_HI16", /* name */
468 FALSE, /* partial_inplace */
469 0x0, /* src_mask */
470 0xffff, /* dst_mask */
471 FALSE), /* pcrel_offset */
472
473 HOWTO (R_OR1K_TLS_IE_LO16, /* type */
474 0, /* rightshift */
475 2, /* size (0 = byte, 1 = short, 2 = long) */
476 16, /* bitsize */
477 FALSE, /* pc_relative */
478 0, /* bitpos */
479 complain_overflow_dont, /* complain_on_overflow */
480 bfd_elf_generic_reloc, /* special_function */
481 "R_OR1K_TLS_IE_LO16", /* name */
482 FALSE, /* partial_inplace */
483 0x0, /* src_mask */
484 0xffff, /* dst_mask */
485 FALSE), /* pcrel_offset */
486
487 HOWTO (R_OR1K_TLS_LE_HI16, /* type */
488 16, /* rightshift */
489 2, /* size (0 = byte, 1 = short, 2 = long) */
490 16, /* bitsize */
491 FALSE, /* pc_relative */
492 0, /* bitpos */
493 complain_overflow_dont, /* complain_on_overflow */
494 bfd_elf_generic_reloc, /* special_function */
495 "R_OR1K_TLS_LE_HI16", /* name */
496 FALSE, /* partial_inplace */
497 0x0, /* src_mask */
498 0xffff, /* dst_mask */
499 FALSE), /* pcrel_offset */
500
501 HOWTO (R_OR1K_TLS_LE_LO16, /* type */
502 0, /* rightshift */
503 2, /* size (0 = byte, 1 = short, 2 = long) */
504 16, /* bitsize */
505 FALSE, /* pc_relative */
506 0, /* bitpos */
507 complain_overflow_dont, /* complain_on_overflow */
508 bfd_elf_generic_reloc, /* special_function */
509 "R_OR1K_TLS_LE_LO16", /* name */
510 FALSE, /* partial_inplace */
511 0x0, /* src_mask */
512 0xffff, /* dst_mask */
513 FALSE), /* pcrel_offset */
514
515 HOWTO (R_OR1K_TLS_TPOFF, /* type */
516 0, /* rightshift */
517 2, /* size (0 = byte, 1 = short, 2 = long) */
518 32, /* bitsize */
519 FALSE, /* pc_relative */
520 0, /* bitpos */
521 complain_overflow_bitfield, /* complain_on_overflow */
522 bfd_elf_generic_reloc, /* special_function */
523 "R_OR1K_TLS_TPOFF", /* name */
524 FALSE, /* partial_inplace */
525 0xffffffff, /* src_mask */
526 0xffffffff, /* dst_mask */
527 FALSE), /* pcrel_offset */
528
529 HOWTO (R_OR1K_TLS_DTPOFF, /* type */
530 0, /* rightshift */
531 2, /* size (0 = byte, 1 = short, 2 = long) */
532 32, /* bitsize */
533 FALSE, /* pc_relative */
534 0, /* bitpos */
535 complain_overflow_bitfield, /* complain_on_overflow */
536 bfd_elf_generic_reloc, /* special_function */
537 "R_OR1K_TLS_DTPOFF", /* name */
538 FALSE, /* partial_inplace */
539 0xffffffff, /* src_mask */
540 0xffffffff, /* dst_mask */
541 FALSE), /* pcrel_offset */
542
543 HOWTO (R_OR1K_TLS_DTPMOD, /* type */
544 0, /* rightshift */
545 2, /* size (0 = byte, 1 = short, 2 = long) */
546 32, /* bitsize */
547 FALSE, /* pc_relative */
548 0, /* bitpos */
549 complain_overflow_bitfield, /* complain_on_overflow */
550 bfd_elf_generic_reloc, /* special_function */
551 "R_OR1K_TLS_DTPMOD", /* name */
552 FALSE, /* partial_inplace */
553 0xffffffff, /* src_mask */
554 0xffffffff, /* dst_mask */
555 FALSE), /* pcrel_offset */
556
557 HOWTO (R_OR1K_AHI16, /* type */
558 16, /* rightshift */
559 2, /* size (0 = byte, 1 = short, 2 = long) */
560 16, /* bitsize */
561 FALSE, /* pc_relative */
562 0, /* bitpos */
563 complain_overflow_dont, /* complain_on_overflow */
564 bfd_elf_generic_reloc, /* special_function */
565 "R_OR1K_AHI16", /* name */
566 FALSE, /* partial_inplace */
567 0x0, /* src_mask */
568 0xffff, /* dst_mask */
569 FALSE), /* pcrel_offset */
570
571 HOWTO (R_OR1K_GOTOFF_AHI16, /* type */
572 16, /* rightshift */
573 2, /* size (0 = byte, 1 = short, 2 = long) */
574 16, /* bitsize */
575 FALSE, /* pc_relative */
576 0, /* bitpos */
577 complain_overflow_dont, /* complain_on_overflow */
578 bfd_elf_generic_reloc, /* special_function */
579 "R_OR1K_GOTOFF_AHI16", /* name */
580 FALSE, /* partial_inplace */
581 0x0, /* src_mask */
582 0xffff, /* dst_mask */
583 FALSE), /* pcrel_offset */
584
585 HOWTO (R_OR1K_TLS_IE_AHI16, /* type */
586 16, /* rightshift */
587 2, /* size (0 = byte, 1 = short, 2 = long) */
588 16, /* bitsize */
589 FALSE, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_dont, /* complain_on_overflow */
592 bfd_elf_generic_reloc, /* special_function */
593 "R_OR1K_TLS_IE_AHI16", /* name */
594 FALSE, /* partial_inplace */
595 0x0, /* src_mask */
596 0xffff, /* dst_mask */
597 FALSE), /* pcrel_offset */
598
599 HOWTO (R_OR1K_TLS_LE_AHI16, /* type */
600 16, /* rightshift */
601 2, /* size (0 = byte, 1 = short, 2 = long) */
602 16, /* bitsize */
603 FALSE, /* pc_relative */
604 0, /* bitpos */
605 complain_overflow_dont, /* complain_on_overflow */
606 bfd_elf_generic_reloc, /* special_function */
607 "R_OR1K_TLS_LE_AHI16", /* name */
608 FALSE, /* partial_inplace */
609 0x0, /* src_mask */
610 0xffff, /* dst_mask */
611 FALSE), /* pcrel_offset */
612
613 HOWTO (R_OR1K_SLO16, /* type */
614 0, /* rightshift */
615 2, /* size (0 = byte, 1 = short, 2 = long) */
616 16, /* bitsize */
617 FALSE, /* pc_relative */
618 0, /* bitpos */
619 complain_overflow_dont, /* complain_on_overflow */
620 bfd_elf_generic_reloc, /* special_function */
621 "R_OR1K_SLO16", /* name */
622 FALSE, /* partial_inplace */
623 0x0, /* src_mask */
624 0xffff, /* dst_mask */
625 FALSE), /* pcrel_offset */
626
627 HOWTO (R_OR1K_GOTOFF_SLO16, /* type */
628 0, /* rightshift */
629 2, /* size (0 = byte, 1 = short, 2 = long) */
630 16, /* bitsize */
631 FALSE, /* pc_relative */
632 0, /* bitpos */
633 complain_overflow_dont, /* complain_on_overflow */
634 bfd_elf_generic_reloc, /* special_function */
635 "R_OR1K_GOTOFF_SLO16", /* name */
636 FALSE, /* partial_inplace */
637 0x0, /* src_mask */
638 0xffff, /* dst_mask */
639 FALSE), /* pcrel_offset */
640
641 HOWTO (R_OR1K_TLS_LE_SLO16, /* type */
642 0, /* rightshift */
643 2, /* size (0 = byte, 1 = short, 2 = long) */
644 16, /* bitsize */
645 FALSE, /* pc_relative */
646 0, /* bitpos */
647 complain_overflow_dont, /* complain_on_overflow */
648 bfd_elf_generic_reloc, /* special_function */
649 "R_OR1K_TLS_LE_SLO16", /* name */
650 FALSE, /* partial_inplace */
651 0x0, /* src_mask */
652 0xffff, /* dst_mask */
653 FALSE), /* pcrel_offset */
654 };
655
656 /* Map BFD reloc types to Or1k ELF reloc types. */
657
658 struct or1k_reloc_map
659 {
660 bfd_reloc_code_real_type bfd_reloc_val;
661 unsigned int or1k_reloc_val;
662 };
663
664 static const struct or1k_reloc_map or1k_reloc_map[] =
665 {
666 { BFD_RELOC_NONE, R_OR1K_NONE },
667 { BFD_RELOC_32, R_OR1K_32 },
668 { BFD_RELOC_16, R_OR1K_16 },
669 { BFD_RELOC_8, R_OR1K_8 },
670 { BFD_RELOC_LO16, R_OR1K_LO_16_IN_INSN },
671 { BFD_RELOC_HI16, R_OR1K_HI_16_IN_INSN },
672 { BFD_RELOC_HI16_S, R_OR1K_AHI16 },
673 { BFD_RELOC_OR1K_REL_26, R_OR1K_INSN_REL_26 },
674 { BFD_RELOC_VTABLE_ENTRY, R_OR1K_GNU_VTENTRY },
675 { BFD_RELOC_VTABLE_INHERIT, R_OR1K_GNU_VTINHERIT },
676 { BFD_RELOC_32_PCREL, R_OR1K_32_PCREL },
677 { BFD_RELOC_16_PCREL, R_OR1K_16_PCREL },
678 { BFD_RELOC_8_PCREL, R_OR1K_8_PCREL },
679 { BFD_RELOC_LO16_GOTOFF, R_OR1K_GOTOFF_LO16 },
680 { BFD_RELOC_HI16_GOTOFF, R_OR1K_GOTOFF_HI16 },
681 { BFD_RELOC_HI16_S_GOTOFF, R_OR1K_GOTOFF_AHI16 },
682 { BFD_RELOC_OR1K_GOTPC_HI16, R_OR1K_GOTPC_HI16 },
683 { BFD_RELOC_OR1K_GOTPC_LO16, R_OR1K_GOTPC_LO16 },
684 { BFD_RELOC_OR1K_GOT16, R_OR1K_GOT16 },
685 { BFD_RELOC_OR1K_PLT26, R_OR1K_PLT26 },
686 { BFD_RELOC_OR1K_GLOB_DAT, R_OR1K_GLOB_DAT },
687 { BFD_RELOC_OR1K_COPY, R_OR1K_COPY },
688 { BFD_RELOC_OR1K_JMP_SLOT, R_OR1K_JMP_SLOT },
689 { BFD_RELOC_OR1K_RELATIVE, R_OR1K_RELATIVE },
690 { BFD_RELOC_OR1K_TLS_GD_HI16, R_OR1K_TLS_GD_HI16 },
691 { BFD_RELOC_OR1K_TLS_GD_LO16, R_OR1K_TLS_GD_LO16 },
692 { BFD_RELOC_OR1K_TLS_LDM_HI16, R_OR1K_TLS_LDM_HI16 },
693 { BFD_RELOC_OR1K_TLS_LDM_LO16, R_OR1K_TLS_LDM_LO16 },
694 { BFD_RELOC_OR1K_TLS_LDO_HI16, R_OR1K_TLS_LDO_HI16 },
695 { BFD_RELOC_OR1K_TLS_LDO_LO16, R_OR1K_TLS_LDO_LO16 },
696 { BFD_RELOC_OR1K_TLS_IE_HI16, R_OR1K_TLS_IE_HI16 },
697 { BFD_RELOC_OR1K_TLS_IE_LO16, R_OR1K_TLS_IE_LO16 },
698 { BFD_RELOC_OR1K_TLS_IE_AHI16, R_OR1K_TLS_IE_AHI16 },
699 { BFD_RELOC_OR1K_TLS_LE_HI16, R_OR1K_TLS_LE_HI16 },
700 { BFD_RELOC_OR1K_TLS_LE_LO16, R_OR1K_TLS_LE_LO16 },
701 { BFD_RELOC_OR1K_TLS_LE_AHI16, R_OR1K_TLS_LE_AHI16 },
702 { BFD_RELOC_OR1K_SLO16, R_OR1K_SLO16 },
703 { BFD_RELOC_OR1K_GOTOFF_SLO16, R_OR1K_GOTOFF_SLO16 },
704 { BFD_RELOC_OR1K_TLS_LE_SLO16, R_OR1K_TLS_LE_SLO16 },
705 };
706
707 #define TLS_UNKNOWN 0
708 #define TLS_NONE 1
709 #define TLS_GD 2
710 #define TLS_LD 3
711 #define TLS_IE 4
712 #define TLS_LE 5
713
714 /* ELF linker hash entry. */
715 struct elf_or1k_link_hash_entry
716 {
717 struct elf_link_hash_entry root;
718
719 /* Track dynamic relocs copied for this symbol. */
720 struct elf_dyn_relocs *dyn_relocs;
721
722 /* Track type of TLS access. */
723 unsigned char tls_type;
724 };
725
726 /* ELF object data. */
727 struct elf_or1k_obj_tdata
728 {
729 struct elf_obj_tdata root;
730
731 /* tls_type for each local got entry. */
732 unsigned char *local_tls_type;
733 };
734
735 #define elf_or1k_tdata(abfd) \
736 ((struct elf_or1k_obj_tdata *) (abfd)->tdata.any)
737
738 #define elf_or1k_local_tls_type(abfd) \
739 (elf_or1k_tdata (abfd)->local_tls_type)
740
741 /* ELF linker hash table. */
742 struct elf_or1k_link_hash_table
743 {
744 struct elf_link_hash_table root;
745
746 /* Small local sym to section mapping cache. */
747 struct sym_cache sym_sec;
748 };
749
750 /* Get the ELF linker hash table from a link_info structure. */
751 #define or1k_elf_hash_table(p) \
752 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
753 == OR1K_ELF_DATA ? ((struct elf_or1k_link_hash_table *) ((p)->hash)) : NULL)
754
755 static bfd_boolean
756 elf_or1k_mkobject (bfd *abfd)
757 {
758 return bfd_elf_allocate_object (abfd, sizeof (struct elf_or1k_obj_tdata),
759 OR1K_ELF_DATA);
760 }
761
762 /* Create an entry in an or1k ELF linker hash table. */
763
764 static struct bfd_hash_entry *
765 or1k_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
766 struct bfd_hash_table *table,
767 const char *string)
768 {
769 struct elf_or1k_link_hash_entry *ret =
770 (struct elf_or1k_link_hash_entry *) entry;
771
772 /* Allocate the structure if it has not already been allocated by a
773 subclass. */
774 if (ret == NULL)
775 ret = bfd_hash_allocate (table,
776 sizeof (struct elf_or1k_link_hash_entry));
777 if (ret == NULL)
778 return NULL;
779
780 /* Call the allocation method of the superclass. */
781 ret = ((struct elf_or1k_link_hash_entry *)
782 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
783 table, string));
784 if (ret != NULL)
785 {
786 struct elf_or1k_link_hash_entry *eh;
787
788 eh = (struct elf_or1k_link_hash_entry *) ret;
789 eh->dyn_relocs = NULL;
790 eh->tls_type = TLS_UNKNOWN;
791 }
792
793 return (struct bfd_hash_entry *) ret;
794 }
795
796 /* Create an or1k ELF linker hash table. */
797
798 static struct bfd_link_hash_table *
799 or1k_elf_link_hash_table_create (bfd *abfd)
800 {
801 struct elf_or1k_link_hash_table *ret;
802 bfd_size_type amt = sizeof (struct elf_or1k_link_hash_table);
803
804 ret = bfd_zmalloc (amt);
805 if (ret == NULL)
806 return NULL;
807
808 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
809 or1k_elf_link_hash_newfunc,
810 sizeof (struct elf_or1k_link_hash_entry),
811 OR1K_ELF_DATA))
812 {
813 free (ret);
814 return NULL;
815 }
816
817 return &ret->root.root;
818 }
819
820 static reloc_howto_type *
821 or1k_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
822 bfd_reloc_code_real_type bcode)
823 {
824 unsigned int i;
825
826 for (i = 0; i < ARRAY_SIZE (or1k_reloc_map); i++)
827 if (or1k_reloc_map[i].bfd_reloc_val == bcode)
828 {
829 unsigned int ocode = or1k_reloc_map[i].or1k_reloc_val;
830 if (ocode < (unsigned int) R_OR1K_max)
831 return &or1k_elf_howto_table[ocode];
832 else
833 break;
834 }
835
836 return NULL;
837 }
838
839 static reloc_howto_type *
840 or1k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
841 const char *r_name)
842 {
843 unsigned int i;
844
845 for (i = 0; i < R_OR1K_max; i++)
846 if (or1k_elf_howto_table[i].name != NULL
847 && strcasecmp (or1k_elf_howto_table[i].name, r_name) == 0)
848 return &or1k_elf_howto_table[i];
849
850 return NULL;
851 }
852
853 /* Set the howto pointer for an Or1k ELF reloc. */
854
855 static bfd_boolean
856 or1k_info_to_howto_rela (bfd * abfd,
857 arelent * cache_ptr,
858 Elf_Internal_Rela * dst)
859 {
860 unsigned int r_type;
861
862 r_type = ELF32_R_TYPE (dst->r_info);
863 if (r_type >= (unsigned int) R_OR1K_max)
864 {
865 /* xgettext:c-format */
866 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
867 abfd, r_type);
868 bfd_set_error (bfd_error_bad_value);
869 return FALSE;
870 }
871 cache_ptr->howto = & or1k_elf_howto_table[r_type];
872 return TRUE;
873 }
874
875
876 /* Return the relocation value for @tpoff relocations.. */
877 static bfd_vma
878 tpoff (struct bfd_link_info *info, bfd_vma address)
879 {
880 /* If tls_sec is NULL, we should have signalled an error already. */
881 if (elf_hash_table (info)->tls_sec == NULL)
882 return 0;
883
884 /* The thread pointer on or1k stores the address after the TCB where
885 the data is, just compute the difference. No need to compensate
886 for the size of TCB. */
887 return (address - elf_hash_table (info)->tls_sec->vma);
888 }
889
890 /* Like _bfd_final_link_relocate, but handles non-contiguous fields. */
891
892 static bfd_reloc_status_type
893 or1k_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
894 asection *input_section, bfd_byte *contents,
895 bfd_vma offset, bfd_vma value)
896 {
897 bfd_reloc_status_type status = bfd_reloc_ok;
898 int size = bfd_get_reloc_size (howto);
899 bfd_vma x;
900
901 /* Sanity check the address. */
902 if (offset + size > bfd_get_section_limit_octets (input_bfd, input_section))
903 return bfd_reloc_outofrange;
904
905 if (howto->pc_relative)
906 {
907 value -= (input_section->output_section->vma
908 + input_section->output_offset);
909 if (howto->pcrel_offset)
910 value -= offset;
911 }
912
913 switch (howto->type)
914 {
915 case R_OR1K_AHI16:
916 case R_OR1K_GOTOFF_AHI16:
917 case R_OR1K_TLS_IE_AHI16:
918 case R_OR1K_TLS_LE_AHI16:
919 /* Adjust the operand to match with a signed LO16. */
920 value += 0x8000;
921 break;
922
923 case R_OR1K_INSN_REL_26:
924 /* Diagnose mis-aligned branch targets. */
925 if (value & 3)
926 status = bfd_reloc_dangerous;
927 break;
928 }
929
930 status = bfd_check_overflow (howto->complain_on_overflow,
931 howto->bitsize,
932 howto->rightshift,
933 bfd_arch_bits_per_address (input_bfd),
934 value);
935 value >>= howto->rightshift;
936
937 /* If we're overwriting the entire destination,
938 then no need to read the current contents. */
939 if (size == 0 || howto->dst_mask == N_ONES (size))
940 x = 0;
941 else
942 {
943 BFD_ASSERT (size == 4);
944 x = bfd_get_32 (input_bfd, contents + offset);
945 }
946
947 switch (howto->type)
948 {
949 case R_OR1K_SLO16:
950 case R_OR1K_GOTOFF_SLO16:
951 case R_OR1K_TLS_LE_SLO16:
952 /* The split imm16 field used for stores. */
953 x = (x & ~0x3e007ff) | ((value & 0xf800) << 10) | (value & 0x7ff);
954 break;
955
956 default:
957 {
958 bfd_vma fieldmask = howto->dst_mask;
959 value <<= howto->bitpos;
960 x = (x & ~fieldmask) | (value & fieldmask);
961 }
962 break;
963 }
964
965 /* Put the relocated value back in the object file. */
966 switch (size)
967 {
968 case 0:
969 break;
970 case 1:
971 bfd_put_8 (input_bfd, x, contents + offset);
972 break;
973 case 2:
974 bfd_put_16 (input_bfd, x, contents + offset);
975 break;
976 case 4:
977 bfd_put_32 (input_bfd, x, contents + offset);
978 break;
979 #ifdef BFD64
980 case 8:
981 bfd_put_64 (input_bfd, x, contents + offset);
982 break;
983 #endif
984 default:
985 _bfd_error_handler
986 (_("%pB: Cannot handle relocation value size of %d"),
987 input_bfd, size);
988 abort ();
989 }
990 return status;
991 }
992
993 /* Relocate an Or1k ELF section.
994
995 The RELOCATE_SECTION function is called by the new ELF backend linker
996 to handle the relocations for a section.
997
998 The relocs are always passed as Rela structures; if the section
999 actually uses Rel structures, the r_addend field will always be
1000 zero.
1001
1002 This function is responsible for adjusting the section contents as
1003 necessary, and (if using Rela relocs and generating a relocatable
1004 output file) adjusting the reloc addend as necessary.
1005
1006 This function does not have to worry about setting the reloc
1007 address or the reloc symbol index.
1008
1009 LOCAL_SYMS is a pointer to the swapped in local symbols.
1010
1011 LOCAL_SECTIONS is an array giving the section in the input file
1012 corresponding to the st_shndx field of each local symbol.
1013
1014 The global hash table entry for the global symbols can be found
1015 via elf_sym_hashes (input_bfd).
1016
1017 When generating relocatable output, this function must handle
1018 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1019 going to be the section symbol corresponding to the output
1020 section, which means that the addend must be adjusted
1021 accordingly. */
1022
1023 static bfd_boolean
1024 or1k_elf_relocate_section (bfd *output_bfd,
1025 struct bfd_link_info *info,
1026 bfd *input_bfd,
1027 asection *input_section,
1028 bfd_byte *contents,
1029 Elf_Internal_Rela *relocs,
1030 Elf_Internal_Sym *local_syms,
1031 asection **local_sections)
1032 {
1033 Elf_Internal_Shdr *symtab_hdr;
1034 struct elf_link_hash_entry **sym_hashes;
1035 Elf_Internal_Rela *rel;
1036 Elf_Internal_Rela *relend;
1037 struct elf_or1k_link_hash_table *htab = or1k_elf_hash_table (info);
1038 bfd *dynobj;
1039 asection *sreloc;
1040 bfd_vma *local_got_offsets;
1041 asection *sgot, *splt;
1042 bfd_vma plt_base, got_base;
1043 bfd_boolean ret_val = TRUE;
1044
1045 if (htab == NULL)
1046 return FALSE;
1047
1048 dynobj = htab->root.dynobj;
1049 local_got_offsets = elf_local_got_offsets (input_bfd);
1050
1051 sreloc = elf_section_data (input_section)->sreloc;
1052
1053 splt = htab->root.splt;
1054 plt_base = 0;
1055 if (splt != NULL)
1056 plt_base = splt->output_section->vma + splt->output_offset;
1057
1058 sgot = htab->root.sgot;
1059 got_base = 0;
1060 if (sgot != NULL)
1061 got_base = sgot->output_section->vma + sgot->output_offset;
1062
1063 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1064 sym_hashes = elf_sym_hashes (input_bfd);
1065 relend = relocs + input_section->reloc_count;
1066
1067 for (rel = relocs; rel < relend; rel++)
1068 {
1069 reloc_howto_type *howto;
1070 unsigned long r_symndx;
1071 Elf_Internal_Sym *sym;
1072 asection *sec;
1073 struct elf_link_hash_entry *h;
1074 bfd_vma relocation;
1075 bfd_reloc_status_type r;
1076 const char *name = NULL;
1077 int r_type;
1078
1079 r_type = ELF32_R_TYPE (rel->r_info);
1080 r_symndx = ELF32_R_SYM (rel->r_info);
1081
1082 if (r_type == R_OR1K_GNU_VTINHERIT
1083 || r_type == R_OR1K_GNU_VTENTRY)
1084 continue;
1085
1086 if (r_type < 0 || r_type >= (int) R_OR1K_max)
1087 {
1088 _bfd_error_handler
1089 (_("%pB: unknown relocation type %d"),
1090 input_bfd, (int) r_type);
1091 bfd_set_error (bfd_error_bad_value);
1092 ret_val = FALSE;
1093 continue;
1094 }
1095
1096 howto = or1k_elf_howto_table + ELF32_R_TYPE (rel->r_info);
1097 h = NULL;
1098 sym = NULL;
1099 sec = NULL;
1100
1101 if (r_symndx < symtab_hdr->sh_info)
1102 {
1103 sym = local_syms + r_symndx;
1104 sec = local_sections[r_symndx];
1105 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1106
1107 name = bfd_elf_string_from_elf_section
1108 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1109 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1110 }
1111 else
1112 {
1113 bfd_boolean unresolved_reloc, warned, ignored;
1114
1115 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1116 r_symndx, symtab_hdr, sym_hashes,
1117 h, sec, relocation,
1118 unresolved_reloc, warned, ignored);
1119 name = h->root.root.string;
1120 }
1121
1122 if (sec != NULL && discarded_section (sec))
1123 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1124 rel, 1, relend, howto, 0, contents);
1125
1126 if (bfd_link_relocatable (info))
1127 continue;
1128
1129 switch (howto->type)
1130 {
1131 case R_OR1K_PLT26:
1132 /* If the call is not local, redirect the branch to the PLT.
1133 Otherwise do nothing to send the branch to the symbol direct. */
1134 if (!SYMBOL_CALLS_LOCAL (info, h))
1135 {
1136 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
1137 relocation = plt_base + h->plt.offset;
1138 }
1139
1140 /* Addend should be zero. */
1141 if (rel->r_addend != 0)
1142 {
1143 _bfd_error_handler
1144 (_("%pB: addend should be zero for plt relocations"),
1145 input_bfd);
1146 bfd_set_error (bfd_error_bad_value);
1147 ret_val = FALSE;
1148 }
1149 break;
1150
1151 case R_OR1K_GOT16:
1152 /* Relocation is to the entry for this symbol in the global
1153 offset table. */
1154 BFD_ASSERT (sgot != NULL);
1155 if (h != NULL)
1156 {
1157 bfd_boolean dyn;
1158 bfd_vma off;
1159
1160 off = h->got.offset;
1161 BFD_ASSERT (off != (bfd_vma) -1);
1162
1163 dyn = htab->root.dynamic_sections_created;
1164 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1165 bfd_link_pic (info),
1166 h)
1167 || (bfd_link_pic (info)
1168 && SYMBOL_REFERENCES_LOCAL (info, h)))
1169 {
1170 /* This is actually a static link, or it is a
1171 -Bsymbolic link and the symbol is defined
1172 locally, or the symbol was forced to be local
1173 because of a version file. We must initialize
1174 this entry in the global offset table. Since the
1175 offset must always be a multiple of 4, we use the
1176 least significant bit to record whether we have
1177 initialized it already.
1178
1179 When doing a dynamic link, we create a .rela.got
1180 relocation entry to initialize the value. This
1181 is done in the finish_dynamic_symbol routine. */
1182 if ((off & 1) != 0)
1183 off &= ~1;
1184 else
1185 {
1186 /* Write entry in GOT. */
1187 bfd_put_32 (output_bfd, relocation,
1188 sgot->contents + off);
1189 /* Mark GOT entry as having been written. */
1190 h->got.offset |= 1;
1191 }
1192 }
1193
1194 relocation = sgot->output_offset + off;
1195 }
1196 else
1197 {
1198 bfd_vma off;
1199 bfd_byte *loc;
1200
1201 BFD_ASSERT (local_got_offsets != NULL
1202 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1203
1204 /* Get offset into GOT table. */
1205 off = local_got_offsets[r_symndx];
1206
1207 /* The offset must always be a multiple of 4. We use
1208 the least significant bit to record whether we have
1209 already processed this entry. */
1210 if ((off & 1) != 0)
1211 off &= ~1;
1212 else
1213 {
1214 /* Write entry in GOT. */
1215 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1216 if (bfd_link_pic (info))
1217 {
1218 asection *srelgot;
1219 Elf_Internal_Rela outrel;
1220
1221 /* We need to generate a R_OR1K_RELATIVE reloc
1222 for the dynamic linker. */
1223 srelgot = htab->root.srelgot;
1224 BFD_ASSERT (srelgot != NULL);
1225
1226 outrel.r_offset = got_base + off;
1227 outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
1228 outrel.r_addend = relocation;
1229 loc = srelgot->contents;
1230 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1231 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1232 ++srelgot->reloc_count;
1233 }
1234
1235 local_got_offsets[r_symndx] |= 1;
1236 }
1237 relocation = sgot->output_offset + off;
1238 }
1239
1240 /* Addend should be zero. */
1241 if (rel->r_addend != 0)
1242 {
1243 _bfd_error_handler
1244 (_("%pB: addend should be zero for got relocations"),
1245 input_bfd);
1246 bfd_set_error (bfd_error_bad_value);
1247 ret_val = FALSE;
1248 }
1249 break;
1250
1251 case R_OR1K_GOTOFF_LO16:
1252 case R_OR1K_GOTOFF_HI16:
1253 case R_OR1K_GOTOFF_AHI16:
1254 case R_OR1K_GOTOFF_SLO16:
1255 /* Relocation is offset from GOT. */
1256 BFD_ASSERT (sgot != NULL);
1257 if (!SYMBOL_REFERENCES_LOCAL (info, h))
1258 {
1259 _bfd_error_handler
1260 (_("%pB: gotoff relocation against dynamic symbol %s"),
1261 input_bfd, h->root.root.string);
1262 ret_val = FALSE;
1263 bfd_set_error (bfd_error_bad_value);
1264 }
1265 relocation -= got_base;
1266 break;
1267
1268 case R_OR1K_INSN_REL_26:
1269 /* For a non-shared link, these will reference either the plt
1270 or a .dynbss copy of the symbol. */
1271 if (bfd_link_pic (info) && !SYMBOL_REFERENCES_LOCAL (info, h))
1272 {
1273 _bfd_error_handler
1274 (_("%pB: pc-relative relocation against dynamic symbol %s"),
1275 input_bfd, name);
1276 ret_val = FALSE;
1277 bfd_set_error (bfd_error_bad_value);
1278 }
1279 break;
1280
1281 case R_OR1K_HI_16_IN_INSN:
1282 case R_OR1K_LO_16_IN_INSN:
1283 case R_OR1K_AHI16:
1284 case R_OR1K_SLO16:
1285 if (bfd_link_pic (info))
1286 {
1287 _bfd_error_handler
1288 (_("%pB: non-pic relocation against symbol %s"),
1289 input_bfd, name);
1290 ret_val = FALSE;
1291 bfd_set_error (bfd_error_bad_value);
1292 }
1293 break;
1294
1295 case R_OR1K_32:
1296 /* R_OR1K_16? */
1297 {
1298 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
1299 from removed linkonce sections, or sections discarded by
1300 a linker script. */
1301 if (r_symndx == STN_UNDEF
1302 || (input_section->flags & SEC_ALLOC) == 0)
1303 break;
1304
1305 /* Emit a direct relocation if the symbol is dynamic,
1306 or a RELATIVE reloc for shared objects. We can omit
1307 RELATIVE relocs to local undefweak symbols. */
1308 if (bfd_link_pic (info)
1309 ? (h == NULL
1310 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1311 || h->root.type != bfd_link_hash_undefweak)
1312 : (h != NULL
1313 && h->dynindx != -1
1314 && !h->non_got_ref
1315 && ((h->def_dynamic && !h->def_regular)
1316 || h->root.type == bfd_link_hash_undefweak
1317 || h->root.type == bfd_link_hash_undefined)))
1318 {
1319 Elf_Internal_Rela outrel;
1320 bfd_byte *loc;
1321 bfd_boolean skip;
1322
1323 /* When generating a shared object, these relocations
1324 are copied into the output file to be resolved at run
1325 time. */
1326
1327 BFD_ASSERT (sreloc != NULL);
1328
1329 skip = FALSE;
1330
1331 outrel.r_offset =
1332 _bfd_elf_section_offset (output_bfd, info, input_section,
1333 rel->r_offset);
1334 if (outrel.r_offset == (bfd_vma) -1)
1335 skip = TRUE;
1336 else if (outrel.r_offset == (bfd_vma) -2)
1337 skip = TRUE;
1338 outrel.r_offset += (input_section->output_section->vma
1339 + input_section->output_offset);
1340
1341 if (skip)
1342 memset (&outrel, 0, sizeof outrel);
1343 else if (SYMBOL_REFERENCES_LOCAL (info, h))
1344 {
1345 outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
1346 outrel.r_addend = relocation + rel->r_addend;
1347 }
1348 else
1349 {
1350 BFD_ASSERT (h->dynindx != -1);
1351 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1352 outrel.r_addend = rel->r_addend;
1353 }
1354
1355 loc = sreloc->contents;
1356 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1357 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1358 break;
1359 }
1360 break;
1361 }
1362
1363 case R_OR1K_TLS_LDM_HI16:
1364 case R_OR1K_TLS_LDM_LO16:
1365 case R_OR1K_TLS_LDO_HI16:
1366 case R_OR1K_TLS_LDO_LO16:
1367 /* TODO: implement support for local dynamic. */
1368 BFD_FAIL ();
1369 _bfd_error_handler
1370 (_("%pB: support for local dynamic not implemented"),
1371 input_bfd);
1372 bfd_set_error (bfd_error_bad_value);
1373 return FALSE;
1374
1375 case R_OR1K_TLS_GD_HI16:
1376 case R_OR1K_TLS_GD_LO16:
1377 case R_OR1K_TLS_IE_HI16:
1378 case R_OR1K_TLS_IE_LO16:
1379 case R_OR1K_TLS_IE_AHI16:
1380 {
1381 bfd_vma gotoff;
1382 Elf_Internal_Rela rela;
1383 bfd_byte *loc;
1384 int dynamic;
1385
1386 sreloc = bfd_get_section_by_name (dynobj, ".rela.got");
1387
1388 /* Mark as TLS related GOT entry by setting
1389 bit 2 as well as bit 1. */
1390 if (h != NULL)
1391 {
1392 gotoff = h->got.offset;
1393 h->got.offset |= 3;
1394 }
1395 else
1396 {
1397 gotoff = local_got_offsets[r_symndx];
1398 local_got_offsets[r_symndx] |= 3;
1399 }
1400
1401 /* Only process the relocation once. */
1402 if (gotoff & 1)
1403 {
1404 relocation = sgot->output_offset + (gotoff & ~3);
1405 break;
1406 }
1407
1408 BFD_ASSERT (elf_hash_table (info)->hgot == NULL
1409 || elf_hash_table (info)->hgot->root.u.def.value == 0);
1410
1411 /* Dynamic entries will require relocations. if we do not need
1412 them we will just use the default R_OR1K_NONE and
1413 not set anything. */
1414 dynamic = bfd_link_pic (info)
1415 || (sec && (sec->flags & SEC_ALLOC) != 0
1416 && h != NULL
1417 && (h->root.type == bfd_link_hash_defweak || !h->def_regular));
1418
1419 /* Shared GD. */
1420 if (dynamic && (howto->type == R_OR1K_TLS_GD_HI16
1421 || howto->type == R_OR1K_TLS_GD_LO16))
1422 {
1423 int i;
1424
1425 /* Add DTPMOD and DTPOFF GOT and rela entries. */
1426 for (i = 0; i < 2; ++i)
1427 {
1428 rela.r_offset = got_base + gotoff + i*4;
1429 if (h != NULL && h->dynindx != -1)
1430 {
1431 rela.r_info = ELF32_R_INFO (h->dynindx,
1432 (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF));
1433 rela.r_addend = 0;
1434 }
1435 else
1436 {
1437 rela.r_info = ELF32_R_INFO (0,
1438 (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF));
1439 rela.r_addend = tpoff (info, relocation);
1440 }
1441
1442 loc = sreloc->contents;
1443 loc += sreloc->reloc_count++ *
1444 sizeof (Elf32_External_Rela);
1445
1446 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1447 bfd_put_32 (output_bfd, 0, sgot->contents + gotoff + i*4);
1448 }
1449 }
1450 /* Static GD. */
1451 else if (howto->type == R_OR1K_TLS_GD_HI16
1452 || howto->type == R_OR1K_TLS_GD_LO16)
1453 {
1454 bfd_put_32 (output_bfd, 1, sgot->contents + gotoff);
1455 bfd_put_32 (output_bfd, tpoff (info, relocation),
1456 sgot->contents + gotoff + 4);
1457 }
1458 /* Shared IE. */
1459 else if (dynamic)
1460 {
1461 /* Add TPOFF GOT and rela entries. */
1462 rela.r_offset = got_base + gotoff;
1463 if (h != NULL && h->dynindx != -1)
1464 {
1465 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_TLS_TPOFF);
1466 rela.r_addend = 0;
1467 }
1468 else
1469 {
1470 rela.r_info = ELF32_R_INFO (0, R_OR1K_TLS_TPOFF);
1471 rela.r_addend = tpoff (info, relocation);
1472 }
1473
1474 loc = sreloc->contents;
1475 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1476
1477 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1478 bfd_put_32 (output_bfd, 0, sgot->contents + gotoff);
1479 }
1480 /* Static IE. */
1481 else
1482 {
1483 bfd_put_32 (output_bfd, tpoff (info, relocation),
1484 sgot->contents + gotoff);
1485 }
1486 relocation = sgot->output_offset + gotoff;
1487 break;
1488 }
1489
1490 case R_OR1K_TLS_LE_HI16:
1491 case R_OR1K_TLS_LE_LO16:
1492 case R_OR1K_TLS_LE_AHI16:
1493 case R_OR1K_TLS_LE_SLO16:
1494 /* Relocation is offset from TP. */
1495 relocation = tpoff (info, relocation);
1496 break;
1497
1498 case R_OR1K_TLS_DTPMOD:
1499 case R_OR1K_TLS_DTPOFF:
1500 case R_OR1K_TLS_TPOFF:
1501 /* These are resolved dynamically on load and shouldn't
1502 be used as linker input. */
1503 BFD_FAIL ();
1504 _bfd_error_handler
1505 (_("%pB: will not resolve runtime TLS relocation"),
1506 input_bfd);
1507 bfd_set_error (bfd_error_bad_value);
1508 return FALSE;
1509
1510 default:
1511 break;
1512 }
1513
1514 r = or1k_final_link_relocate (howto, input_bfd, input_section, contents,
1515 rel->r_offset, relocation + rel->r_addend);
1516
1517 if (r != bfd_reloc_ok)
1518 {
1519 const char *msg = NULL;
1520
1521 switch (r)
1522 {
1523 case bfd_reloc_overflow:
1524 (*info->callbacks->reloc_overflow)
1525 (info, (h ? &h->root : NULL), name, howto->name,
1526 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1527 break;
1528
1529 case bfd_reloc_undefined:
1530 (*info->callbacks->undefined_symbol)
1531 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1532 break;
1533
1534 case bfd_reloc_outofrange:
1535 msg = _("internal error: out of range error");
1536 break;
1537
1538 case bfd_reloc_notsupported:
1539 msg = _("internal error: unsupported relocation error");
1540 break;
1541
1542 case bfd_reloc_dangerous:
1543 msg = _("internal error: dangerous relocation");
1544 break;
1545
1546 default:
1547 msg = _("internal error: unknown error");
1548 break;
1549 }
1550
1551 if (msg)
1552 (*info->callbacks->warning) (info, msg, name, input_bfd,
1553 input_section, rel->r_offset);
1554 }
1555 }
1556
1557 return ret_val;
1558 }
1559
1560 /* Return the section that should be marked against GC for a given
1561 relocation. */
1562
1563 static asection *
1564 or1k_elf_gc_mark_hook (asection *sec,
1565 struct bfd_link_info *info,
1566 Elf_Internal_Rela *rel,
1567 struct elf_link_hash_entry *h,
1568 Elf_Internal_Sym *sym)
1569 {
1570 if (h != NULL)
1571 switch (ELF32_R_TYPE (rel->r_info))
1572 {
1573 case R_OR1K_GNU_VTINHERIT:
1574 case R_OR1K_GNU_VTENTRY:
1575 return NULL;
1576 }
1577
1578 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1579 }
1580
1581 /* Look through the relocs for a section during the first phase. */
1582
1583 static bfd_boolean
1584 or1k_elf_check_relocs (bfd *abfd,
1585 struct bfd_link_info *info,
1586 asection *sec,
1587 const Elf_Internal_Rela *relocs)
1588 {
1589 Elf_Internal_Shdr *symtab_hdr;
1590 struct elf_link_hash_entry **sym_hashes;
1591 const Elf_Internal_Rela *rel;
1592
1593 const Elf_Internal_Rela *rel_end;
1594 struct elf_or1k_link_hash_table *htab;
1595 bfd *dynobj;
1596 asection *sreloc = NULL;
1597
1598 if (bfd_link_relocatable (info))
1599 return TRUE;
1600
1601 /* Don't do anything special with non-loaded, non-alloced sections.
1602 In particular, any relocs in such sections should not affect GOT
1603 and PLT reference counting (ie. we don't allow them to create GOT
1604 or PLT entries), there's no possibility or desire to optimize TLS
1605 relocs, and there's not much point in propagating relocs to shared
1606 libs that the dynamic linker won't relocate. */
1607 if ((sec->flags & SEC_ALLOC) == 0)
1608 return TRUE;
1609
1610 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1611 sym_hashes = elf_sym_hashes (abfd);
1612
1613 htab = or1k_elf_hash_table (info);
1614 if (htab == NULL)
1615 return FALSE;
1616
1617 dynobj = htab->root.dynobj;
1618
1619 rel_end = relocs + sec->reloc_count;
1620 for (rel = relocs; rel < rel_end; rel++)
1621 {
1622 struct elf_link_hash_entry *h;
1623 unsigned long r_symndx;
1624 unsigned char tls_type;
1625 int r_type;
1626
1627 r_symndx = ELF32_R_SYM (rel->r_info);
1628 if (r_symndx < symtab_hdr->sh_info)
1629 h = NULL;
1630 else
1631 {
1632 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1633 while (h->root.type == bfd_link_hash_indirect
1634 || h->root.type == bfd_link_hash_warning)
1635 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1636 }
1637
1638 r_type = ELF32_R_TYPE (rel->r_info);
1639 switch (r_type)
1640 {
1641 case R_OR1K_TLS_GD_HI16:
1642 case R_OR1K_TLS_GD_LO16:
1643 tls_type = TLS_GD;
1644 break;
1645 case R_OR1K_TLS_LDM_HI16:
1646 case R_OR1K_TLS_LDM_LO16:
1647 case R_OR1K_TLS_LDO_HI16:
1648 case R_OR1K_TLS_LDO_LO16:
1649 tls_type = TLS_LD;
1650 break;
1651 case R_OR1K_TLS_IE_HI16:
1652 case R_OR1K_TLS_IE_LO16:
1653 case R_OR1K_TLS_IE_AHI16:
1654 tls_type = TLS_IE;
1655 break;
1656 case R_OR1K_TLS_LE_HI16:
1657 case R_OR1K_TLS_LE_LO16:
1658 case R_OR1K_TLS_LE_AHI16:
1659 case R_OR1K_TLS_LE_SLO16:
1660 tls_type = TLS_LE;
1661 break;
1662 default:
1663 tls_type = TLS_NONE;
1664 }
1665
1666 /* Record TLS type. */
1667 if (h != NULL)
1668 ((struct elf_or1k_link_hash_entry *) h)->tls_type = tls_type;
1669 else
1670 {
1671 unsigned char *local_tls_type;
1672
1673 /* This is a TLS type record for a local symbol. */
1674 local_tls_type = (unsigned char *) elf_or1k_local_tls_type (abfd);
1675 if (local_tls_type == NULL)
1676 {
1677 bfd_size_type size;
1678
1679 size = symtab_hdr->sh_info;
1680 local_tls_type = bfd_zalloc (abfd, size);
1681 if (local_tls_type == NULL)
1682 return FALSE;
1683 elf_or1k_local_tls_type (abfd) = local_tls_type;
1684 }
1685 local_tls_type[r_symndx] = tls_type;
1686 }
1687
1688 switch (r_type)
1689 {
1690 /* This relocation describes the C++ object vtable hierarchy.
1691 Reconstruct it for later use during GC. */
1692 case R_OR1K_GNU_VTINHERIT:
1693 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1694 return FALSE;
1695 break;
1696
1697 /* This relocation describes which C++ vtable entries are actually
1698 used. Record for later use during GC. */
1699 case R_OR1K_GNU_VTENTRY:
1700 BFD_ASSERT (h != NULL);
1701 if (h != NULL
1702 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1703 return FALSE;
1704 break;
1705
1706 /* This relocation requires .plt entry. */
1707 case R_OR1K_PLT26:
1708 if (h != NULL)
1709 {
1710 h->needs_plt = 1;
1711 h->plt.refcount += 1;
1712 }
1713 break;
1714
1715 case R_OR1K_GOT16:
1716 case R_OR1K_TLS_GD_HI16:
1717 case R_OR1K_TLS_GD_LO16:
1718 case R_OR1K_TLS_IE_HI16:
1719 case R_OR1K_TLS_IE_LO16:
1720 case R_OR1K_TLS_IE_AHI16:
1721 if (h != NULL)
1722 h->got.refcount += 1;
1723 else
1724 {
1725 bfd_signed_vma *local_got_refcounts;
1726
1727 /* This is a global offset table entry for a local symbol. */
1728 local_got_refcounts = elf_local_got_refcounts (abfd);
1729 if (local_got_refcounts == NULL)
1730 {
1731 bfd_size_type size;
1732
1733 size = symtab_hdr->sh_info;
1734 size *= sizeof (bfd_signed_vma);
1735 local_got_refcounts = bfd_zalloc (abfd, size);
1736 if (local_got_refcounts == NULL)
1737 return FALSE;
1738 elf_local_got_refcounts (abfd) = local_got_refcounts;
1739 }
1740 local_got_refcounts[r_symndx] += 1;
1741 }
1742 /* FALLTHRU */
1743
1744 case R_OR1K_GOTOFF_HI16:
1745 case R_OR1K_GOTOFF_LO16:
1746 case R_OR1K_GOTOFF_AHI16:
1747 case R_OR1K_GOTOFF_SLO16:
1748 if (htab->root.sgot == NULL)
1749 {
1750 if (dynobj == NULL)
1751 htab->root.dynobj = dynobj = abfd;
1752 if (!_bfd_elf_create_got_section (dynobj, info))
1753 return FALSE;
1754 }
1755 break;
1756
1757 case R_OR1K_INSN_REL_26:
1758 case R_OR1K_HI_16_IN_INSN:
1759 case R_OR1K_LO_16_IN_INSN:
1760 case R_OR1K_AHI16:
1761 case R_OR1K_SLO16:
1762 case R_OR1K_32:
1763 {
1764 if (h != NULL && !bfd_link_pic (info))
1765 {
1766 /* We may need a copy reloc. */
1767 h->non_got_ref = 1;
1768
1769 /* We may also need a .plt entry. */
1770 h->plt.refcount += 1;
1771 if (r_type != R_OR1K_INSN_REL_26)
1772 h->pointer_equality_needed = 1;
1773 }
1774
1775 /* If we are creating a shared library, and this is a reloc
1776 against a global symbol, or a non PC relative reloc
1777 against a local symbol, then we need to copy the reloc
1778 into the shared library. However, if we are linking with
1779 -Bsymbolic, we do not need to copy a reloc against a
1780 global symbol which is defined in an object we are
1781 including in the link (i.e., DEF_REGULAR is set). At
1782 this point we have not seen all the input files, so it is
1783 possible that DEF_REGULAR is not set now but will be set
1784 later (it is never cleared). In case of a weak definition,
1785 DEF_REGULAR may be cleared later by a strong definition in
1786 a shared library. We account for that possibility below by
1787 storing information in the relocs_copied field of the hash
1788 table entry. A similar situation occurs when creating
1789 shared libraries and symbol visibility changes render the
1790 symbol local.
1791
1792 If on the other hand, we are creating an executable, we
1793 may need to keep relocations for symbols satisfied by a
1794 dynamic library if we manage to avoid copy relocs for the
1795 symbol. */
1796
1797 if ((bfd_link_pic (info)
1798 && (sec->flags & SEC_ALLOC) != 0
1799 && (r_type != R_OR1K_INSN_REL_26
1800 || (h != NULL
1801 && (!SYMBOLIC_BIND (info, h)
1802 || h->root.type == bfd_link_hash_defweak
1803 || !h->def_regular))))
1804 || (!bfd_link_pic (info)
1805 && (sec->flags & SEC_ALLOC) != 0
1806 && h != NULL
1807 && (h->root.type == bfd_link_hash_defweak
1808 || !h->def_regular)))
1809 {
1810 struct elf_dyn_relocs *p;
1811 struct elf_dyn_relocs **head;
1812
1813 /* When creating a shared object, we must copy these
1814 relocs into the output file. We create a reloc
1815 section in dynobj and make room for the reloc. */
1816 if (sreloc == NULL)
1817 {
1818 const char *name;
1819 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1820 unsigned int shnam = _bfd_elf_single_rel_hdr (sec)->sh_name;
1821
1822 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1823 if (name == NULL)
1824 return FALSE;
1825
1826 if (strncmp (name, ".rela", 5) != 0
1827 || strcmp (bfd_get_section_name (abfd, sec),
1828 name + 5) != 0)
1829 {
1830 _bfd_error_handler
1831 /* xgettext:c-format */
1832 (_("%pB: bad relocation section name `%s\'"),
1833 abfd, name);
1834 }
1835
1836 if (htab->root.dynobj == NULL)
1837 htab->root.dynobj = abfd;
1838 dynobj = htab->root.dynobj;
1839
1840 sreloc = bfd_get_section_by_name (dynobj, name);
1841 if (sreloc == NULL)
1842 {
1843 sreloc = _bfd_elf_make_dynamic_reloc_section
1844 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
1845
1846 if (sreloc == NULL)
1847 return FALSE;
1848 }
1849 elf_section_data (sec)->sreloc = sreloc;
1850 }
1851
1852 /* If this is a global symbol, we count the number of
1853 relocations we need for this symbol. */
1854 if (h != NULL)
1855 head = &((struct elf_or1k_link_hash_entry *) h)->dyn_relocs;
1856 else
1857 {
1858 /* Track dynamic relocs needed for local syms too.
1859 We really need local syms available to do this
1860 easily. Oh well. */
1861
1862 asection *s;
1863 Elf_Internal_Sym *isym;
1864 void *vpp;
1865
1866 isym = bfd_sym_from_r_symndx (&htab->sym_sec,
1867 abfd, r_symndx);
1868 if (isym == NULL)
1869 return FALSE;
1870
1871 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1872 if (s == NULL)
1873 return FALSE;
1874
1875 vpp = &elf_section_data (s)->local_dynrel;
1876 head = (struct elf_dyn_relocs **) vpp;
1877 }
1878
1879 p = *head;
1880 if (p == NULL || p->sec != sec)
1881 {
1882 bfd_size_type amt = sizeof *p;
1883 p = ((struct elf_dyn_relocs *)
1884 bfd_alloc (htab->root.dynobj, amt));
1885 if (p == NULL)
1886 return FALSE;
1887 p->next = *head;
1888 *head = p;
1889 p->sec = sec;
1890 p->count = 0;
1891 p->pc_count = 0;
1892 }
1893
1894 p->count += 1;
1895 if (r_type == R_OR1K_INSN_REL_26)
1896 p->pc_count += 1;
1897 }
1898 }
1899 break;
1900 }
1901 }
1902
1903 return TRUE;
1904 }
1905
1906 /* Finish up the dynamic sections. */
1907
1908 static bfd_boolean
1909 or1k_elf_finish_dynamic_sections (bfd *output_bfd,
1910 struct bfd_link_info *info)
1911 {
1912 bfd *dynobj;
1913 asection *sdyn, *sgot;
1914 struct elf_or1k_link_hash_table *htab;
1915
1916 htab = or1k_elf_hash_table (info);
1917 if (htab == NULL)
1918 return FALSE;
1919
1920 dynobj = htab->root.dynobj;
1921
1922 sgot = htab->root.sgotplt;
1923 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1924
1925 if (htab->root.dynamic_sections_created)
1926 {
1927 asection *splt;
1928 Elf32_External_Dyn *dyncon, *dynconend;
1929
1930 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1931
1932 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1933 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1934
1935 for (; dyncon < dynconend; dyncon++)
1936 {
1937 Elf_Internal_Dyn dyn;
1938 asection *s;
1939
1940 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1941
1942 switch (dyn.d_tag)
1943 {
1944 default:
1945 continue;
1946
1947 case DT_PLTGOT:
1948 s = htab->root.sgotplt;
1949 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1950 break;
1951
1952 case DT_JMPREL:
1953 s = htab->root.srelplt;
1954 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1955 break;
1956
1957 case DT_PLTRELSZ:
1958 s = htab->root.srelplt;
1959 dyn.d_un.d_val = s->size;
1960 break;
1961 }
1962 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1963 }
1964
1965
1966 /* Fill in the first entry in the procedure linkage table. */
1967 splt = htab->root.splt;
1968 if (splt && splt->size > 0)
1969 {
1970 if (bfd_link_pic (info))
1971 {
1972 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0,
1973 splt->contents);
1974 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1,
1975 splt->contents + 4);
1976 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2,
1977 splt->contents + 8);
1978 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3,
1979 splt->contents + 12);
1980 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4,
1981 splt->contents + 16);
1982 }
1983 else
1984 {
1985 unsigned long addr;
1986 /* addr = .got + 4 */
1987 addr = sgot->output_section->vma + sgot->output_offset + 4;
1988 bfd_put_32 (output_bfd,
1989 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1990 splt->contents);
1991 bfd_put_32 (output_bfd,
1992 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1993 splt->contents + 4);
1994 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1995 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1996 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1997 }
1998
1999 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
2000 }
2001 }
2002
2003 /* Set the first entry in the global offset table to the address of
2004 the dynamic section. */
2005 if (sgot && sgot->size > 0)
2006 {
2007 if (sdyn == NULL)
2008 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2009 else
2010 bfd_put_32 (output_bfd,
2011 sdyn->output_section->vma + sdyn->output_offset,
2012 sgot->contents);
2013 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2014 }
2015
2016 if (htab->root.sgot && htab->root.sgot->size > 0)
2017 elf_section_data (htab->root.sgot->output_section)->this_hdr.sh_entsize = 4;
2018
2019 return TRUE;
2020 }
2021
2022 /* Finish up dynamic symbol handling. We set the contents of various
2023 dynamic sections here. */
2024
2025 static bfd_boolean
2026 or1k_elf_finish_dynamic_symbol (bfd *output_bfd,
2027 struct bfd_link_info *info,
2028 struct elf_link_hash_entry *h,
2029 Elf_Internal_Sym *sym)
2030 {
2031 struct elf_or1k_link_hash_table *htab;
2032 bfd_byte *loc;
2033
2034 htab = or1k_elf_hash_table (info);
2035 if (htab == NULL)
2036 return FALSE;
2037
2038 if (h->plt.offset != (bfd_vma) -1)
2039 {
2040 asection *splt;
2041 asection *sgot;
2042 asection *srela;
2043
2044 bfd_vma plt_index;
2045 bfd_vma got_offset;
2046 bfd_vma got_addr;
2047 Elf_Internal_Rela rela;
2048
2049 /* This symbol has an entry in the procedure linkage table. Set
2050 it up. */
2051 BFD_ASSERT (h->dynindx != -1);
2052
2053 splt = htab->root.splt;
2054 sgot = htab->root.sgotplt;
2055 srela = htab->root.srelplt;
2056 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
2057
2058 /* Get the index in the procedure linkage table which
2059 corresponds to this symbol. This is the index of this symbol
2060 in all the symbols for which we are making plt entries. The
2061 first entry in the procedure linkage table is reserved. */
2062 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2063
2064 /* Get the offset into the .got table of the entry that
2065 corresponds to this function. Each .got entry is 4 bytes.
2066 The first three are reserved. */
2067 got_offset = (plt_index + 3) * 4;
2068 got_addr = got_offset;
2069
2070 /* Fill in the entry in the procedure linkage table. */
2071 if (! bfd_link_pic (info))
2072 {
2073 got_addr += htab->root.sgotplt->output_section->vma
2074 + htab->root.sgotplt->output_offset;
2075 bfd_put_32 (output_bfd, PLT_ENTRY_WORD0 | ((got_addr >> 16) & 0xffff),
2076 splt->contents + h->plt.offset);
2077 bfd_put_32 (output_bfd, PLT_ENTRY_WORD1 | (got_addr & 0xffff),
2078 splt->contents + h->plt.offset + 4);
2079 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
2080 splt->contents + h->plt.offset + 8);
2081 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
2082 splt->contents + h->plt.offset + 12);
2083 bfd_put_32 (output_bfd, PLT_ENTRY_WORD4
2084 | plt_index * sizeof (Elf32_External_Rela),
2085 splt->contents + h->plt.offset + 16);
2086 }
2087 else
2088 {
2089 bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD0 | (got_addr & 0xffff),
2090 splt->contents + h->plt.offset);
2091 bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD1
2092 | plt_index * sizeof (Elf32_External_Rela),
2093 splt->contents + h->plt.offset + 4);
2094 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD2,
2095 splt->contents + h->plt.offset + 8);
2096 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD3,
2097 splt->contents + h->plt.offset + 12);
2098 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD4,
2099 splt->contents + h->plt.offset + 16);
2100 }
2101
2102 /* Fill in the entry in the global offset table. */
2103 bfd_put_32 (output_bfd,
2104 (splt->output_section->vma
2105 + splt->output_offset), /* Same offset. */
2106 sgot->contents + got_offset);
2107
2108 /* Fill in the entry in the .rela.plt section. */
2109 rela.r_offset = (sgot->output_section->vma
2110 + sgot->output_offset
2111 + got_offset);
2112 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_JMP_SLOT);
2113 rela.r_addend = 0;
2114 loc = srela->contents;
2115 loc += plt_index * sizeof (Elf32_External_Rela);
2116 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2117
2118 if (!h->def_regular)
2119 {
2120 /* Mark the symbol as undefined, rather than as defined in
2121 the .plt section. Leave the value alone. */
2122 sym->st_shndx = SHN_UNDEF;
2123 }
2124
2125 }
2126
2127 if (h->got.offset != (bfd_vma) -1
2128 && (h->got.offset & 2) == 0) /* Homemade TLS check. */
2129 {
2130 asection *sgot;
2131 asection *srela;
2132 Elf_Internal_Rela rela;
2133
2134 /* This symbol has an entry in the global offset table. Set it
2135 up. */
2136 sgot = htab->root.sgot;
2137 srela = htab->root.srelgot;
2138 BFD_ASSERT (sgot != NULL && srela != NULL);
2139
2140 rela.r_offset = (sgot->output_section->vma
2141 + sgot->output_offset
2142 + (h->got.offset &~ 1));
2143
2144 /* If this is a -Bsymbolic link, and the symbol is defined
2145 locally, we just want to emit a RELATIVE reloc. Likewise if
2146 the symbol was forced to be local because of a version file.
2147 The entry in the global offset table will already have been
2148 initialized in the relocate_section function. */
2149 if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
2150 {
2151 rela.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
2152 rela.r_addend = (h->root.u.def.value
2153 + h->root.u.def.section->output_section->vma
2154 + h->root.u.def.section->output_offset);
2155 }
2156 else
2157 {
2158 BFD_ASSERT ((h->got.offset & 1) == 0);
2159 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2160 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_GLOB_DAT);
2161 rela.r_addend = 0;
2162 }
2163
2164 loc = srela->contents;
2165 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
2166 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2167 ++srela->reloc_count;
2168 }
2169
2170 if (h->needs_copy)
2171 {
2172 asection *s;
2173 Elf_Internal_Rela rela;
2174
2175 /* This symbols needs a copy reloc. Set it up. */
2176 BFD_ASSERT (h->dynindx != -1
2177 && (h->root.type == bfd_link_hash_defined
2178 || h->root.type == bfd_link_hash_defweak));
2179
2180 rela.r_offset = (h->root.u.def.value
2181 + h->root.u.def.section->output_section->vma
2182 + h->root.u.def.section->output_offset);
2183 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_COPY);
2184 rela.r_addend = 0;
2185 if (h->root.u.def.section == htab->root.sdynrelro)
2186 s = htab->root.sreldynrelro;
2187 else
2188 s = htab->root.srelbss;
2189 loc = s->contents + s->reloc_count * sizeof (Elf32_External_Rela);
2190 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2191 ++s->reloc_count;
2192 }
2193
2194 /* Mark some specially defined symbols as absolute. */
2195 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2196 || h == htab->root.hgot)
2197 sym->st_shndx = SHN_ABS;
2198
2199 return TRUE;
2200 }
2201
2202 static enum elf_reloc_type_class
2203 or1k_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2204 const asection *rel_sec ATTRIBUTE_UNUSED,
2205 const Elf_Internal_Rela *rela)
2206 {
2207 switch ((int) ELF32_R_TYPE (rela->r_info))
2208 {
2209 case R_OR1K_RELATIVE: return reloc_class_relative;
2210 case R_OR1K_JMP_SLOT: return reloc_class_plt;
2211 case R_OR1K_COPY: return reloc_class_copy;
2212 default: return reloc_class_normal;
2213 }
2214 }
2215
2216 /* Find dynamic relocs for H that apply to read-only sections. */
2217
2218 static asection *
2219 readonly_dynrelocs (struct elf_link_hash_entry *h)
2220 {
2221 struct elf_dyn_relocs *p;
2222 struct elf_or1k_link_hash_entry *eh = (struct elf_or1k_link_hash_entry *) h;
2223
2224 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2225 {
2226 asection *s = p->sec->output_section;
2227
2228 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2229 return p->sec;
2230 }
2231 return NULL;
2232 }
2233
2234 /* Adjust a symbol defined by a dynamic object and referenced by a
2235 regular object. The current definition is in some section of the
2236 dynamic object, but we're not including those sections. We have to
2237 change the definition to something the rest of the link can
2238 understand. */
2239
2240 static bfd_boolean
2241 or1k_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2242 struct elf_link_hash_entry *h)
2243 {
2244 struct elf_or1k_link_hash_table *htab;
2245 bfd *dynobj;
2246 asection *s, *srel;
2247
2248 dynobj = elf_hash_table (info)->dynobj;
2249
2250 /* Make sure we know what is going on here. */
2251 BFD_ASSERT (dynobj != NULL
2252 && (h->needs_plt
2253 || h->is_weakalias
2254 || (h->def_dynamic
2255 && h->ref_regular
2256 && !h->def_regular)));
2257
2258 /* If this is a function, put it in the procedure linkage table. We
2259 will fill in the contents of the procedure linkage table later,
2260 when we know the address of the .got section. */
2261 if (h->type == STT_FUNC
2262 || h->needs_plt)
2263 {
2264 if (! bfd_link_pic (info)
2265 && !h->def_dynamic
2266 && !h->ref_dynamic
2267 && h->root.type != bfd_link_hash_undefweak
2268 && h->root.type != bfd_link_hash_undefined)
2269 {
2270 /* This case can occur if we saw a PLT reloc in an input
2271 file, but the symbol was never referred to by a dynamic
2272 object. In such a case, we don't actually need to build
2273 a procedure linkage table, and we can just do a PCREL
2274 reloc instead. */
2275 h->plt.offset = (bfd_vma) -1;
2276 h->needs_plt = 0;
2277 }
2278
2279 return TRUE;
2280 }
2281 else
2282 h->plt.offset = (bfd_vma) -1;
2283
2284 /* If this is a weak symbol, and there is a real definition, the
2285 processor independent code will have arranged for us to see the
2286 real definition first, and we can just use the same value. */
2287 if (h->is_weakalias)
2288 {
2289 struct elf_link_hash_entry *def = weakdef (h);
2290 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2291 h->root.u.def.section = def->root.u.def.section;
2292 h->root.u.def.value = def->root.u.def.value;
2293 return TRUE;
2294 }
2295
2296 /* This is a reference to a symbol defined by a dynamic object which
2297 is not a function. */
2298
2299 /* If we are creating a shared library, we must presume that the
2300 only references to the symbol are via the global offset table.
2301 For such cases we need not do anything here; the relocations will
2302 be handled correctly by relocate_section. */
2303 if (bfd_link_pic (info))
2304 return TRUE;
2305
2306 /* If there are no references to this symbol that do not use the
2307 GOT, we don't need to generate a copy reloc. */
2308 if (!h->non_got_ref)
2309 return TRUE;
2310
2311 /* If -z nocopyreloc was given, we won't generate them either. */
2312 if (info->nocopyreloc)
2313 {
2314 h->non_got_ref = 0;
2315 return TRUE;
2316 }
2317
2318 /* If we don't find any dynamic relocs in read-only sections, then
2319 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2320 if (!readonly_dynrelocs (h))
2321 {
2322 h->non_got_ref = 0;
2323 return TRUE;
2324 }
2325
2326 /* We must allocate the symbol in our .dynbss section, which will
2327 become part of the .bss section of the executable. There will be
2328 an entry for this symbol in the .dynsym section. The dynamic
2329 object will contain position independent code, so all references
2330 from the dynamic object to this symbol will go through the global
2331 offset table. The dynamic linker will use the .dynsym entry to
2332 determine the address it must put in the global offset table, so
2333 both the dynamic object and the regular object will refer to the
2334 same memory location for the variable. */
2335
2336 htab = or1k_elf_hash_table (info);
2337 if (htab == NULL)
2338 return FALSE;
2339
2340 /* We must generate a R_OR1K_COPY reloc to tell the dynamic linker
2341 to copy the initial value out of the dynamic object and into the
2342 runtime process image. We need to remember the offset into the
2343 .rela.bss section we are going to use. */
2344 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2345 {
2346 s = htab->root.sdynrelro;
2347 srel = htab->root.sreldynrelro;
2348 }
2349 else
2350 {
2351 s = htab->root.sdynbss;
2352 srel = htab->root.srelbss;
2353 }
2354 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2355 {
2356 srel->size += sizeof (Elf32_External_Rela);
2357 h->needs_copy = 1;
2358 }
2359
2360 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2361 }
2362
2363 /* Allocate space in .plt, .got and associated reloc sections for
2364 dynamic relocs. */
2365
2366 static bfd_boolean
2367 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2368 {
2369 struct bfd_link_info *info;
2370 struct elf_or1k_link_hash_table *htab;
2371 struct elf_or1k_link_hash_entry *eh;
2372 struct elf_dyn_relocs *p;
2373
2374 if (h->root.type == bfd_link_hash_indirect)
2375 return TRUE;
2376
2377 info = (struct bfd_link_info *) inf;
2378 htab = or1k_elf_hash_table (info);
2379 if (htab == NULL)
2380 return FALSE;
2381
2382 eh = (struct elf_or1k_link_hash_entry *) h;
2383
2384 if (htab->root.dynamic_sections_created
2385 && h->plt.refcount > 0)
2386 {
2387 /* Make sure this symbol is output as a dynamic symbol.
2388 Undefined weak syms won't yet be marked as dynamic. */
2389 if (h->dynindx == -1
2390 && !h->forced_local)
2391 {
2392 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2393 return FALSE;
2394 }
2395
2396 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
2397 {
2398 asection *s = htab->root.splt;
2399
2400 /* If this is the first .plt entry, make room for the special
2401 first entry. */
2402 if (s->size == 0)
2403 s->size = PLT_ENTRY_SIZE;
2404
2405 h->plt.offset = s->size;
2406
2407 /* If this symbol is not defined in a regular file, and we are
2408 not generating a shared library, then set the symbol to this
2409 location in the .plt. This is required to make function
2410 pointers compare as equal between the normal executable and
2411 the shared library. */
2412 if (! bfd_link_pic (info)
2413 && !h->def_regular)
2414 {
2415 h->root.u.def.section = s;
2416 h->root.u.def.value = h->plt.offset;
2417 }
2418
2419 /* Make room for this entry. */
2420 s->size += PLT_ENTRY_SIZE;
2421
2422 /* We also need to make an entry in the .got.plt section, which
2423 will be placed in the .got section by the linker script. */
2424 htab->root.sgotplt->size += 4;
2425
2426 /* We also need to make an entry in the .rel.plt section. */
2427 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
2428 }
2429 else
2430 {
2431 h->plt.offset = (bfd_vma) -1;
2432 h->needs_plt = 0;
2433 }
2434 }
2435 else
2436 {
2437 h->plt.offset = (bfd_vma) -1;
2438 h->needs_plt = 0;
2439 }
2440
2441 if (h->got.refcount > 0)
2442 {
2443 asection *s;
2444 bfd_boolean dyn;
2445 unsigned char tls_type;
2446
2447 /* Make sure this symbol is output as a dynamic symbol.
2448 Undefined weak syms won't yet be marked as dynamic. */
2449 if (h->dynindx == -1
2450 && !h->forced_local)
2451 {
2452 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2453 return FALSE;
2454 }
2455
2456 s = htab->root.sgot;
2457
2458 h->got.offset = s->size;
2459
2460 tls_type = ((struct elf_or1k_link_hash_entry *) h)->tls_type;
2461
2462 /* TLS GD requires two GOT and two relocs. */
2463 if (tls_type == TLS_GD)
2464 s->size += 8;
2465 else
2466 s->size += 4;
2467 dyn = htab->root.dynamic_sections_created;
2468 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
2469 {
2470 if (tls_type == TLS_GD)
2471 htab->root.srelgot->size += 2 * sizeof (Elf32_External_Rela);
2472 else
2473 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
2474 }
2475 }
2476 else
2477 h->got.offset = (bfd_vma) -1;
2478
2479 if (eh->dyn_relocs == NULL)
2480 return TRUE;
2481
2482 /* In the shared -Bsymbolic case, discard space allocated for
2483 dynamic pc-relative relocs against symbols which turn out to be
2484 defined in regular objects. For the normal shared case, discard
2485 space for pc-relative relocs that have become local due to symbol
2486 visibility changes. */
2487
2488 if (bfd_link_pic (info))
2489 {
2490 if (SYMBOL_CALLS_LOCAL (info, h))
2491 {
2492 struct elf_dyn_relocs **pp;
2493
2494 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2495 {
2496 p->count -= p->pc_count;
2497 p->pc_count = 0;
2498 if (p->count == 0)
2499 *pp = p->next;
2500 else
2501 pp = &p->next;
2502 }
2503 }
2504
2505 /* Also discard relocs on undefined weak syms with non-default
2506 visibility. */
2507 if (eh->dyn_relocs != NULL
2508 && h->root.type == bfd_link_hash_undefweak)
2509 {
2510 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2511 eh->dyn_relocs = NULL;
2512
2513 /* Make sure undefined weak symbols are output as a dynamic
2514 symbol in PIEs. */
2515 else if (h->dynindx == -1
2516 && !h->forced_local)
2517 {
2518 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2519 return FALSE;
2520 }
2521 }
2522 }
2523 else
2524 {
2525 /* For the non-shared case, discard space for relocs against
2526 symbols which turn out to need copy relocs or are not
2527 dynamic. */
2528
2529 if (!h->non_got_ref
2530 && ((h->def_dynamic
2531 && !h->def_regular)
2532 || (htab->root.dynamic_sections_created
2533 && (h->root.type == bfd_link_hash_undefweak
2534 || h->root.type == bfd_link_hash_undefined))))
2535 {
2536 /* Make sure this symbol is output as a dynamic symbol.
2537 Undefined weak syms won't yet be marked as dynamic. */
2538 if (h->dynindx == -1
2539 && !h->forced_local)
2540 {
2541 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2542 return FALSE;
2543 }
2544
2545 /* If that succeeded, we know we'll be keeping all the
2546 relocs. */
2547 if (h->dynindx != -1)
2548 goto keep;
2549 }
2550
2551 eh->dyn_relocs = NULL;
2552
2553 keep: ;
2554 }
2555
2556 /* Finally, allocate space. */
2557 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2558 {
2559 asection *sreloc = elf_section_data (p->sec)->sreloc;
2560 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2561 }
2562
2563 return TRUE;
2564 }
2565
2566 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2567 read-only sections. */
2568
2569 static bfd_boolean
2570 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
2571 {
2572 asection *sec;
2573
2574 if (h->root.type == bfd_link_hash_indirect)
2575 return TRUE;
2576
2577 sec = readonly_dynrelocs (h);
2578 if (sec != NULL)
2579 {
2580 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
2581
2582 info->flags |= DF_TEXTREL;
2583 info->callbacks->minfo
2584 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2585 sec->owner, h->root.root.string, sec);
2586
2587 /* Not an error, just cut short the traversal. */
2588 return FALSE;
2589 }
2590 return TRUE;
2591 }
2592
2593 /* Set the sizes of the dynamic sections. */
2594
2595 static bfd_boolean
2596 or1k_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2597 struct bfd_link_info *info)
2598 {
2599 struct elf_or1k_link_hash_table *htab;
2600 bfd *dynobj;
2601 asection *s;
2602 bfd_boolean relocs;
2603 bfd *ibfd;
2604
2605 htab = or1k_elf_hash_table (info);
2606 if (htab == NULL)
2607 return FALSE;
2608
2609 dynobj = htab->root.dynobj;
2610 BFD_ASSERT (dynobj != NULL);
2611
2612 if (htab->root.dynamic_sections_created)
2613 {
2614 /* Set the contents of the .interp section to the interpreter. */
2615 if (bfd_link_executable (info) && !info->nointerp)
2616 {
2617 s = bfd_get_section_by_name (dynobj, ".interp");
2618 BFD_ASSERT (s != NULL);
2619 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2620 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2621 }
2622 }
2623
2624 /* Set up .got offsets for local syms, and space for local dynamic
2625 relocs. */
2626 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2627 {
2628 bfd_signed_vma *local_got;
2629 bfd_signed_vma *end_local_got;
2630 bfd_size_type locsymcount;
2631 Elf_Internal_Shdr *symtab_hdr;
2632 unsigned char *local_tls_type;
2633 asection *srel;
2634
2635 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2636 continue;
2637
2638 for (s = ibfd->sections; s != NULL; s = s->next)
2639 {
2640 struct elf_dyn_relocs *p;
2641
2642 for (p = ((struct elf_dyn_relocs *)
2643 elf_section_data (s)->local_dynrel);
2644 p != NULL;
2645 p = p->next)
2646 {
2647 if (! bfd_is_abs_section (p->sec)
2648 && bfd_is_abs_section (p->sec->output_section))
2649 {
2650 /* Input section has been discarded, either because
2651 it is a copy of a linkonce section or due to
2652 linker script /DISCARD/, so we'll be discarding
2653 the relocs too. */
2654 }
2655 else if (p->count != 0)
2656 {
2657 srel = elf_section_data (p->sec)->sreloc;
2658 srel->size += p->count * sizeof (Elf32_External_Rela);
2659 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2660 info->flags |= DF_TEXTREL;
2661 }
2662 }
2663 }
2664
2665 local_got = elf_local_got_refcounts (ibfd);
2666 if (!local_got)
2667 continue;
2668
2669 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2670 locsymcount = symtab_hdr->sh_info;
2671 end_local_got = local_got + locsymcount;
2672 s = htab->root.sgot;
2673 srel = htab->root.srelgot;
2674 local_tls_type = (unsigned char *) elf_or1k_local_tls_type (ibfd);
2675 for (; local_got < end_local_got; ++local_got)
2676 {
2677 if (*local_got > 0)
2678 {
2679 *local_got = s->size;
2680
2681 /* TLS GD requires two GOT and two relocs. */
2682 if (local_tls_type != NULL && *local_tls_type == TLS_GD)
2683 s->size += 8;
2684 else
2685 s->size += 4;
2686 if (bfd_link_pic (info))
2687 {
2688 if (local_tls_type != NULL && *local_tls_type == TLS_GD)
2689 srel->size += 2 * sizeof (Elf32_External_Rela);
2690 else
2691 srel->size += sizeof (Elf32_External_Rela);
2692 }
2693 }
2694 else
2695
2696 *local_got = (bfd_vma) -1;
2697
2698 if (local_tls_type)
2699 ++local_tls_type;
2700 }
2701 }
2702
2703 /* Allocate global sym .plt and .got entries, and space for global
2704 sym dynamic relocs. */
2705 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2706
2707 /* We now have determined the sizes of the various dynamic sections.
2708 Allocate memory for them. */
2709 relocs = FALSE;
2710 for (s = dynobj->sections; s != NULL; s = s->next)
2711 {
2712 if ((s->flags & SEC_LINKER_CREATED) == 0)
2713 continue;
2714
2715 if (s == htab->root.splt
2716 || s == htab->root.sgot
2717 || s == htab->root.sgotplt
2718 || s == htab->root.sdynbss
2719 || s == htab->root.sdynrelro)
2720 {
2721 /* Strip this section if we don't need it; see the
2722 comment below. */
2723 }
2724 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2725 {
2726 if (s->size != 0 && s != htab->root.srelplt)
2727 relocs = TRUE;
2728
2729 /* We use the reloc_count field as a counter if we need
2730 to copy relocs into the output file. */
2731 s->reloc_count = 0;
2732 }
2733 else
2734 /* It's not one of our sections, so don't allocate space. */
2735 continue;
2736
2737 if (s->size == 0)
2738 {
2739 /* If we don't need this section, strip it from the
2740 output file. This is mostly to handle .rela.bss and
2741 .rela.plt. We must create both sections in
2742 create_dynamic_sections, because they must be created
2743 before the linker maps input sections to output
2744 sections. The linker does that before
2745 adjust_dynamic_symbol is called, and it is that
2746 function which decides whether anything needs to go
2747 into these sections. */
2748 s->flags |= SEC_EXCLUDE;
2749 continue;
2750 }
2751
2752 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2753 continue;
2754
2755 /* Allocate memory for the section contents. We use bfd_zalloc
2756 here in case unused entries are not reclaimed before the
2757 section's contents are written out. This should not happen,
2758 but this way if it does, we get a R_OR1K_NONE reloc instead
2759 of garbage. */
2760 s->contents = bfd_zalloc (dynobj, s->size);
2761
2762 if (s->contents == NULL)
2763 return FALSE;
2764 }
2765
2766 if (htab->root.dynamic_sections_created)
2767 {
2768 /* Add some entries to the .dynamic section. We fill in the
2769 values later, in or1k_elf_finish_dynamic_sections, but we
2770 must add the entries now so that we get the correct size for
2771 the .dynamic section. The DT_DEBUG entry is filled in by the
2772 dynamic linker and used by the debugger. */
2773 #define add_dynamic_entry(TAG, VAL) \
2774 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2775
2776 if (bfd_link_executable (info))
2777 {
2778 if (! add_dynamic_entry (DT_DEBUG, 0))
2779 return FALSE;
2780 }
2781
2782 if (htab->root.splt->size != 0)
2783 {
2784 if (! add_dynamic_entry (DT_PLTGOT, 0)
2785 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2786 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2787 || ! add_dynamic_entry (DT_JMPREL, 0))
2788 return FALSE;
2789 }
2790
2791 if (relocs)
2792 {
2793 if (! add_dynamic_entry (DT_RELA, 0)
2794 || ! add_dynamic_entry (DT_RELASZ, 0)
2795 || ! add_dynamic_entry (DT_RELAENT,
2796 sizeof (Elf32_External_Rela)))
2797 return FALSE;
2798
2799 /* If any dynamic relocs apply to a read-only section,
2800 then we need a DT_TEXTREL entry. */
2801 if ((info->flags & DF_TEXTREL) == 0)
2802 elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2803
2804 if ((info->flags & DF_TEXTREL) != 0)
2805 {
2806 if (! add_dynamic_entry (DT_TEXTREL, 0))
2807 return FALSE;
2808 }
2809 }
2810 }
2811
2812 #undef add_dynamic_entry
2813 return TRUE;
2814 }
2815
2816 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2817
2818 static void
2819 or1k_elf_copy_indirect_symbol (struct bfd_link_info *info,
2820 struct elf_link_hash_entry *dir,
2821 struct elf_link_hash_entry *ind)
2822 {
2823 struct elf_or1k_link_hash_entry * edir;
2824 struct elf_or1k_link_hash_entry * eind;
2825
2826 edir = (struct elf_or1k_link_hash_entry *) dir;
2827 eind = (struct elf_or1k_link_hash_entry *) ind;
2828
2829 if (eind->dyn_relocs != NULL)
2830 {
2831 if (edir->dyn_relocs != NULL)
2832 {
2833 struct elf_dyn_relocs **pp;
2834 struct elf_dyn_relocs *p;
2835
2836 /* Add reloc counts against the indirect sym to the direct sym
2837 list. Merge any entries against the same section. */
2838 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2839 {
2840 struct elf_dyn_relocs *q;
2841
2842 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2843 if (q->sec == p->sec)
2844 {
2845 q->pc_count += p->pc_count;
2846 q->count += p->count;
2847 *pp = p->next;
2848 break;
2849 }
2850 if (q == NULL)
2851 pp = &p->next;
2852 }
2853 *pp = edir->dyn_relocs;
2854 }
2855
2856 edir->dyn_relocs = eind->dyn_relocs;
2857 eind->dyn_relocs = NULL;
2858 }
2859
2860 if (ind->root.type == bfd_link_hash_indirect)
2861 {
2862 if (dir->got.refcount <= 0)
2863 {
2864 edir->tls_type = eind->tls_type;
2865 eind->tls_type = TLS_UNKNOWN;
2866 }
2867 }
2868
2869 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2870 }
2871
2872 /* Set the right machine number. */
2873
2874 static bfd_boolean
2875 or1k_elf_object_p (bfd *abfd)
2876 {
2877 unsigned long mach = bfd_mach_or1k;
2878
2879 if (elf_elfheader (abfd)->e_flags & EF_OR1K_NODELAY)
2880 mach = bfd_mach_or1knd;
2881
2882 return bfd_default_set_arch_mach (abfd, bfd_arch_or1k, mach);
2883 }
2884
2885 /* Store the machine number in the flags field. */
2886
2887 static void
2888 or1k_elf_final_write_processing (bfd *abfd,
2889 bfd_boolean linker ATTRIBUTE_UNUSED)
2890 {
2891 switch (bfd_get_mach (abfd))
2892 {
2893 default:
2894 case bfd_mach_or1k:
2895 break;
2896 case bfd_mach_or1knd:
2897 elf_elfheader (abfd)->e_flags |= EF_OR1K_NODELAY;
2898 break;
2899 }
2900 }
2901
2902 static bfd_boolean
2903 or1k_elf_set_private_flags (bfd *abfd, flagword flags)
2904 {
2905 BFD_ASSERT (!elf_flags_init (abfd)
2906 || elf_elfheader (abfd)->e_flags == flags);
2907
2908 elf_elfheader (abfd)->e_flags = flags;
2909 elf_flags_init (abfd) = TRUE;
2910 return TRUE;
2911 }
2912
2913 /* Make sure all input files are consistent with respect to
2914 EF_OR1K_NODELAY flag setting. */
2915
2916 static bfd_boolean
2917 elf32_or1k_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2918 {
2919 bfd *obfd = info->output_bfd;
2920 flagword out_flags;
2921 flagword in_flags;
2922
2923 in_flags = elf_elfheader (ibfd)->e_flags;
2924 out_flags = elf_elfheader (obfd)->e_flags;
2925
2926 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2927 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2928 return TRUE;
2929
2930 if (!elf_flags_init (obfd))
2931 {
2932 elf_flags_init (obfd) = TRUE;
2933 elf_elfheader (obfd)->e_flags = in_flags;
2934
2935 return TRUE;
2936 }
2937
2938 if (in_flags == out_flags)
2939 return TRUE;
2940
2941 if ((in_flags & EF_OR1K_NODELAY) != (out_flags & EF_OR1K_NODELAY))
2942 {
2943 _bfd_error_handler
2944 (_("%pB: %s flag mismatch with previous modules"),
2945 ibfd, "EF_OR1K_NODELAY");
2946
2947 bfd_set_error (bfd_error_bad_value);
2948 return FALSE;
2949 }
2950
2951 return TRUE;
2952
2953 }
2954
2955 #define ELF_ARCH bfd_arch_or1k
2956 #define ELF_MACHINE_CODE EM_OR1K
2957 #define ELF_TARGET_ID OR1K_ELF_DATA
2958 #define ELF_MAXPAGESIZE 0x2000
2959
2960 #define TARGET_BIG_SYM or1k_elf32_vec
2961 #define TARGET_BIG_NAME "elf32-or1k"
2962
2963 #define elf_info_to_howto_rel NULL
2964 #define elf_info_to_howto or1k_info_to_howto_rela
2965 #define elf_backend_relocate_section or1k_elf_relocate_section
2966 #define elf_backend_gc_mark_hook or1k_elf_gc_mark_hook
2967 #define elf_backend_check_relocs or1k_elf_check_relocs
2968 #define elf_backend_reloc_type_class or1k_elf_reloc_type_class
2969 #define elf_backend_can_gc_sections 1
2970 #define elf_backend_rela_normal 1
2971
2972 #define bfd_elf32_mkobject elf_or1k_mkobject
2973
2974 #define bfd_elf32_bfd_merge_private_bfd_data elf32_or1k_merge_private_bfd_data
2975 #define bfd_elf32_bfd_set_private_flags or1k_elf_set_private_flags
2976 #define bfd_elf32_bfd_reloc_type_lookup or1k_reloc_type_lookup
2977 #define bfd_elf32_bfd_reloc_name_lookup or1k_reloc_name_lookup
2978
2979 #define elf_backend_object_p or1k_elf_object_p
2980 #define elf_backend_final_write_processing or1k_elf_final_write_processing
2981 #define elf_backend_can_refcount 1
2982
2983 #define elf_backend_plt_readonly 1
2984 #define elf_backend_want_got_plt 1
2985 #define elf_backend_want_plt_sym 0
2986 #define elf_backend_got_header_size 12
2987 #define elf_backend_dtrel_excludes_plt 1
2988 #define elf_backend_want_dynrelro 1
2989
2990 #define bfd_elf32_bfd_link_hash_table_create or1k_elf_link_hash_table_create
2991 #define elf_backend_copy_indirect_symbol or1k_elf_copy_indirect_symbol
2992 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2993 #define elf_backend_finish_dynamic_sections or1k_elf_finish_dynamic_sections
2994 #define elf_backend_size_dynamic_sections or1k_elf_size_dynamic_sections
2995 #define elf_backend_adjust_dynamic_symbol or1k_elf_adjust_dynamic_symbol
2996 #define elf_backend_finish_dynamic_symbol or1k_elf_finish_dynamic_symbol
2997
2998 #include "elf32-target.h"
A mirror of the official binutils-gdb repository