?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
arm: PR gas/25472 Enable DSP instructions with +mve
[binutils-gdb.git] / bfd / elf32-microblaze.c
blob7b839f8c9a0c6fa4f95937ca8539ad4d2fbf0917
1 /* Xilinx MicroBlaze-specific support for 32-bit ELF
2
3 Copyright (C) 2009-2020 Free Software Foundation, Inc.
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
19 Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22
23 int dbg = 0;
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "elf-bfd.h"
30 #include "elf/microblaze.h"
31 #include <assert.h>
32
33 #define USE_RELA /* Only USE_REL is actually significant, but this is
34 here are a reminder... */
35 #define INST_WORD_SIZE 4
36
37 static int ro_small_data_pointer = 0;
38 static int rw_small_data_pointer = 0;
39
40 static reloc_howto_type * microblaze_elf_howto_table [(int) R_MICROBLAZE_max];
41
42 static reloc_howto_type microblaze_elf_howto_raw[] =
43 {
44 /* This reloc does nothing. */
45 HOWTO (R_MICROBLAZE_NONE, /* Type. */
46 0, /* Rightshift. */
47 3, /* Size (0 = byte, 1 = short, 2 = long). */
48 0, /* Bitsize. */
49 FALSE, /* PC_relative. */
50 0, /* Bitpos. */
51 complain_overflow_dont, /* Complain on overflow. */
52 NULL, /* Special Function. */
53 "R_MICROBLAZE_NONE", /* Name. */
54 FALSE, /* Partial Inplace. */
55 0, /* Source Mask. */
56 0, /* Dest Mask. */
57 FALSE), /* PC relative offset? */
58
59 /* A standard 32 bit relocation. */
60 HOWTO (R_MICROBLAZE_32, /* Type. */
61 0, /* Rightshift. */
62 2, /* Size (0 = byte, 1 = short, 2 = long). */
63 32, /* Bitsize. */
64 FALSE, /* PC_relative. */
65 0, /* Bitpos. */
66 complain_overflow_bitfield, /* Complain on overflow. */
67 bfd_elf_generic_reloc,/* Special Function. */
68 "R_MICROBLAZE_32", /* Name. */
69 FALSE, /* Partial Inplace. */
70 0, /* Source Mask. */
71 0xffffffff, /* Dest Mask. */
72 FALSE), /* PC relative offset? */
73
74 /* A standard PCREL 32 bit relocation. */
75 HOWTO (R_MICROBLAZE_32_PCREL,/* Type. */
76 0, /* Rightshift. */
77 2, /* Size (0 = byte, 1 = short, 2 = long). */
78 32, /* Bitsize. */
79 TRUE, /* PC_relative. */
80 0, /* Bitpos. */
81 complain_overflow_bitfield, /* Complain on overflow. */
82 bfd_elf_generic_reloc,/* Special Function. */
83 "R_MICROBLAZE_32_PCREL", /* Name. */
84 TRUE, /* Partial Inplace. */
85 0, /* Source Mask. */
86 0xffffffff, /* Dest Mask. */
87 TRUE), /* PC relative offset? */
88
89 /* A 64 bit PCREL relocation. Table-entry not really used. */
90 HOWTO (R_MICROBLAZE_64_PCREL,/* Type. */
91 0, /* Rightshift. */
92 2, /* Size (0 = byte, 1 = short, 2 = long). */
93 16, /* Bitsize. */
94 TRUE, /* PC_relative. */
95 0, /* Bitpos. */
96 complain_overflow_dont, /* Complain on overflow. */
97 bfd_elf_generic_reloc,/* Special Function. */
98 "R_MICROBLAZE_64_PCREL", /* Name. */
99 FALSE, /* Partial Inplace. */
100 0, /* Source Mask. */
101 0x0000ffff, /* Dest Mask. */
102 TRUE), /* PC relative offset? */
103
104 /* The low half of a PCREL 32 bit relocation. */
105 HOWTO (R_MICROBLAZE_32_PCREL_LO, /* Type. */
106 0, /* Rightshift. */
107 2, /* Size (0 = byte, 1 = short, 2 = long). */
108 16, /* Bitsize. */
109 TRUE, /* PC_relative. */
110 0, /* Bitpos. */
111 complain_overflow_signed, /* Complain on overflow. */
112 bfd_elf_generic_reloc, /* Special Function. */
113 "R_MICROBLAZE_32_PCREL_LO", /* Name. */
114 FALSE, /* Partial Inplace. */
115 0, /* Source Mask. */
116 0x0000ffff, /* Dest Mask. */
117 TRUE), /* PC relative offset? */
118
119 /* A 64 bit relocation. Table entry not really used. */
120 HOWTO (R_MICROBLAZE_64, /* Type. */
121 0, /* Rightshift. */
122 2, /* Size (0 = byte, 1 = short, 2 = long). */
123 16, /* Bitsize. */
124 FALSE, /* PC_relative. */
125 0, /* Bitpos. */
126 complain_overflow_dont, /* Complain on overflow. */
127 bfd_elf_generic_reloc,/* Special Function. */
128 "R_MICROBLAZE_64", /* Name. */
129 FALSE, /* Partial Inplace. */
130 0, /* Source Mask. */
131 0x0000ffff, /* Dest Mask. */
132 FALSE), /* PC relative offset? */
133
134 /* The low half of a 32 bit relocation. */
135 HOWTO (R_MICROBLAZE_32_LO, /* Type. */
136 0, /* Rightshift. */
137 2, /* Size (0 = byte, 1 = short, 2 = long). */
138 16, /* Bitsize. */
139 FALSE, /* PC_relative. */
140 0, /* Bitpos. */
141 complain_overflow_signed, /* Complain on overflow. */
142 bfd_elf_generic_reloc,/* Special Function. */
143 "R_MICROBLAZE_32_LO", /* Name. */
144 FALSE, /* Partial Inplace. */
145 0, /* Source Mask. */
146 0x0000ffff, /* Dest Mask. */
147 FALSE), /* PC relative offset? */
148
149 /* Read-only small data section relocation. */
150 HOWTO (R_MICROBLAZE_SRO32, /* Type. */
151 0, /* Rightshift. */
152 2, /* Size (0 = byte, 1 = short, 2 = long). */
153 16, /* Bitsize. */
154 FALSE, /* PC_relative. */
155 0, /* Bitpos. */
156 complain_overflow_bitfield, /* Complain on overflow. */
157 bfd_elf_generic_reloc,/* Special Function. */
158 "R_MICROBLAZE_SRO32", /* Name. */
159 FALSE, /* Partial Inplace. */
160 0, /* Source Mask. */
161 0x0000ffff, /* Dest Mask. */
162 FALSE), /* PC relative offset? */
163
164 /* Read-write small data area relocation. */
165 HOWTO (R_MICROBLAZE_SRW32, /* Type. */
166 0, /* Rightshift. */
167 2, /* Size (0 = byte, 1 = short, 2 = long). */
168 16, /* Bitsize. */
169 FALSE, /* PC_relative. */
170 0, /* Bitpos. */
171 complain_overflow_bitfield, /* Complain on overflow. */
172 bfd_elf_generic_reloc,/* Special Function. */
173 "R_MICROBLAZE_SRW32", /* Name. */
174 FALSE, /* Partial Inplace. */
175 0, /* Source Mask. */
176 0x0000ffff, /* Dest Mask. */
177 FALSE), /* PC relative offset? */
178
179 /* This reloc does nothing. Used for relaxation. */
180 HOWTO (R_MICROBLAZE_64_NONE, /* Type. */
181 0, /* Rightshift. */
182 3, /* Size (0 = byte, 1 = short, 2 = long). */
183 0, /* Bitsize. */
184 TRUE, /* PC_relative. */
185 0, /* Bitpos. */
186 complain_overflow_dont, /* Complain on overflow. */
187 NULL, /* Special Function. */
188 "R_MICROBLAZE_64_NONE",/* Name. */
189 FALSE, /* Partial Inplace. */
190 0, /* Source Mask. */
191 0, /* Dest Mask. */
192 FALSE), /* PC relative offset? */
193
194 /* Symbol Op Symbol relocation. */
195 HOWTO (R_MICROBLAZE_32_SYM_OP_SYM, /* Type. */
196 0, /* Rightshift. */
197 2, /* Size (0 = byte, 1 = short, 2 = long). */
198 32, /* Bitsize. */
199 FALSE, /* PC_relative. */
200 0, /* Bitpos. */
201 complain_overflow_bitfield, /* Complain on overflow. */
202 bfd_elf_generic_reloc,/* Special Function. */
203 "R_MICROBLAZE_32_SYM_OP_SYM", /* Name. */
204 FALSE, /* Partial Inplace. */
205 0, /* Source Mask. */
206 0xffffffff, /* Dest Mask. */
207 FALSE), /* PC relative offset? */
208
209 /* GNU extension to record C++ vtable hierarchy. */
210 HOWTO (R_MICROBLAZE_GNU_VTINHERIT, /* Type. */
211 0, /* Rightshift. */
212 2, /* Size (0 = byte, 1 = short, 2 = long). */
213 0, /* Bitsize. */
214 FALSE, /* PC_relative. */
215 0, /* Bitpos. */
216 complain_overflow_dont,/* Complain on overflow. */
217 NULL, /* Special Function. */
218 "R_MICROBLAZE_GNU_VTINHERIT", /* Name. */
219 FALSE, /* Partial Inplace. */
220 0, /* Source Mask. */
221 0, /* Dest Mask. */
222 FALSE), /* PC relative offset? */
223
224 /* GNU extension to record C++ vtable member usage. */
225 HOWTO (R_MICROBLAZE_GNU_VTENTRY, /* Type. */
226 0, /* Rightshift. */
227 2, /* Size (0 = byte, 1 = short, 2 = long). */
228 0, /* Bitsize. */
229 FALSE, /* PC_relative. */
230 0, /* Bitpos. */
231 complain_overflow_dont,/* Complain on overflow. */
232 _bfd_elf_rel_vtable_reloc_fn, /* Special Function. */
233 "R_MICROBLAZE_GNU_VTENTRY", /* Name. */
234 FALSE, /* Partial Inplace. */
235 0, /* Source Mask. */
236 0, /* Dest Mask. */
237 FALSE), /* PC relative offset? */
238
239 /* A 64 bit GOTPC relocation. Table-entry not really used. */
240 HOWTO (R_MICROBLAZE_GOTPC_64, /* Type. */
241 0, /* Rightshift. */
242 2, /* Size (0 = byte, 1 = short, 2 = long). */
243 16, /* Bitsize. */
244 TRUE, /* PC_relative. */
245 0, /* Bitpos. */
246 complain_overflow_dont, /* Complain on overflow. */
247 bfd_elf_generic_reloc, /* Special Function. */
248 "R_MICROBLAZE_GOTPC_64", /* Name. */
249 FALSE, /* Partial Inplace. */
250 0, /* Source Mask. */
251 0x0000ffff, /* Dest Mask. */
252 TRUE), /* PC relative offset? */
253
254 /* A 64 bit TEXTPCREL relocation. Table-entry not really used. */
255 HOWTO (R_MICROBLAZE_TEXTPCREL_64, /* Type. */
256 0, /* Rightshift. */
257 2, /* Size (0 = byte, 1 = short, 2 = long). */
258 16, /* Bitsize. */
259 TRUE, /* PC_relative. */
260 0, /* Bitpos. */
261 complain_overflow_dont, /* Complain on overflow. */
262 bfd_elf_generic_reloc, /* Special Function. */
263 "R_MICROBLAZE_TEXTPCREL_64", /* Name. */
264 FALSE, /* Partial Inplace. */
265 0, /* Source Mask. */
266 0x0000ffff, /* Dest Mask. */
267 TRUE), /* PC relative offset? */
268
269 /* A 64 bit GOT relocation. Table-entry not really used. */
270 HOWTO (R_MICROBLAZE_GOT_64, /* Type. */
271 0, /* Rightshift. */
272 2, /* Size (0 = byte, 1 = short, 2 = long). */
273 16, /* Bitsize. */
274 FALSE, /* PC_relative. */
275 0, /* Bitpos. */
276 complain_overflow_dont, /* Complain on overflow. */
277 bfd_elf_generic_reloc,/* Special Function. */
278 "R_MICROBLAZE_GOT_64",/* Name. */
279 FALSE, /* Partial Inplace. */
280 0, /* Source Mask. */
281 0x0000ffff, /* Dest Mask. */
282 FALSE), /* PC relative offset? */
283
284 /* A 64 bit TEXTREL relocation. Table-entry not really used. */
285 HOWTO (R_MICROBLAZE_TEXTREL_64, /* Type. */
286 0, /* Rightshift. */
287 2, /* Size (0 = byte, 1 = short, 2 = long). */
288 16, /* Bitsize. */
289 FALSE, /* PC_relative. */
290 0, /* Bitpos. */
291 complain_overflow_dont, /* Complain on overflow. */
292 bfd_elf_generic_reloc,/* Special Function. */
293 "R_MICROBLAZE_TEXTREL_64",/* Name. */
294 FALSE, /* Partial Inplace. */
295 0, /* Source Mask. */
296 0x0000ffff, /* Dest Mask. */
297 FALSE), /* PC relative offset? */
298
299 /* A 64 bit PLT relocation. Table-entry not really used. */
300 HOWTO (R_MICROBLAZE_PLT_64, /* Type. */
301 0, /* Rightshift. */
302 2, /* Size (0 = byte, 1 = short, 2 = long). */
303 16, /* Bitsize. */
304 TRUE, /* PC_relative. */
305 0, /* Bitpos. */
306 complain_overflow_dont, /* Complain on overflow. */
307 bfd_elf_generic_reloc,/* Special Function. */
308 "R_MICROBLAZE_PLT_64",/* Name. */
309 FALSE, /* Partial Inplace. */
310 0, /* Source Mask. */
311 0x0000ffff, /* Dest Mask. */
312 TRUE), /* PC relative offset? */
313
314 /* Table-entry not really used. */
315 HOWTO (R_MICROBLAZE_REL, /* Type. */
316 0, /* Rightshift. */
317 2, /* Size (0 = byte, 1 = short, 2 = long). */
318 16, /* Bitsize. */
319 TRUE, /* PC_relative. */
320 0, /* Bitpos. */
321 complain_overflow_dont, /* Complain on overflow. */
322 bfd_elf_generic_reloc,/* Special Function. */
323 "R_MICROBLAZE_REL", /* Name. */
324 FALSE, /* Partial Inplace. */
325 0, /* Source Mask. */
326 0x0000ffff, /* Dest Mask. */
327 TRUE), /* PC relative offset? */
328
329 /* Table-entry not really used. */
330 HOWTO (R_MICROBLAZE_JUMP_SLOT,/* Type. */
331 0, /* Rightshift. */
332 2, /* Size (0 = byte, 1 = short, 2 = long). */
333 16, /* Bitsize. */
334 TRUE, /* PC_relative. */
335 0, /* Bitpos. */
336 complain_overflow_dont, /* Complain on overflow. */
337 bfd_elf_generic_reloc,/* Special Function. */
338 "R_MICROBLAZE_JUMP_SLOT", /* Name. */
339 FALSE, /* Partial Inplace. */
340 0, /* Source Mask. */
341 0x0000ffff, /* Dest Mask. */
342 TRUE), /* PC relative offset? */
343
344 /* Table-entry not really used. */
345 HOWTO (R_MICROBLAZE_GLOB_DAT,/* Type. */
346 0, /* Rightshift. */
347 2, /* Size (0 = byte, 1 = short, 2 = long). */
348 16, /* Bitsize. */
349 TRUE, /* PC_relative. */
350 0, /* Bitpos. */
351 complain_overflow_dont, /* Complain on overflow. */
352 bfd_elf_generic_reloc,/* Special Function. */
353 "R_MICROBLAZE_GLOB_DAT", /* Name. */
354 FALSE, /* Partial Inplace. */
355 0, /* Source Mask. */
356 0x0000ffff, /* Dest Mask. */
357 TRUE), /* PC relative offset? */
358
359 /* A 64 bit GOT relative relocation. Table-entry not really used. */
360 HOWTO (R_MICROBLAZE_GOTOFF_64, /* Type. */
361 0, /* Rightshift. */
362 2, /* Size (0 = byte, 1 = short, 2 = long). */
363 16, /* Bitsize. */
364 FALSE, /* PC_relative. */
365 0, /* Bitpos. */
366 complain_overflow_dont, /* Complain on overflow. */
367 bfd_elf_generic_reloc,/* Special Function. */
368 "R_MICROBLAZE_GOTOFF_64", /* Name. */
369 FALSE, /* Partial Inplace. */
370 0, /* Source Mask. */
371 0x0000ffff, /* Dest Mask. */
372 FALSE), /* PC relative offset? */
373
374 /* A 32 bit GOT relative relocation. Table-entry not really used. */
375 HOWTO (R_MICROBLAZE_GOTOFF_32, /* Type. */
376 0, /* 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_MICROBLAZE_GOTOFF_32", /* Name. */
384 FALSE, /* Partial Inplace. */
385 0, /* Source Mask. */
386 0x0000ffff, /* Dest Mask. */
387 FALSE), /* PC relative offset? */
388
389 /* COPY relocation. Table-entry not really used. */
390 HOWTO (R_MICROBLAZE_COPY, /* Type. */
391 0, /* Rightshift. */
392 2, /* Size (0 = byte, 1 = short, 2 = long). */
393 16, /* Bitsize. */
394 FALSE, /* PC_relative. */
395 0, /* Bitpos. */
396 complain_overflow_dont, /* Complain on overflow. */
397 bfd_elf_generic_reloc,/* Special Function. */
398 "R_MICROBLAZE_COPY", /* Name. */
399 FALSE, /* Partial Inplace. */
400 0, /* Source Mask. */
401 0x0000ffff, /* Dest Mask. */
402 FALSE), /* PC relative offset? */
403
404 /* Marker relocs for TLS. */
405 HOWTO (R_MICROBLAZE_TLS,
406 0, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 32, /* bitsize */
409 FALSE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_dont, /* complain_on_overflow */
412 bfd_elf_generic_reloc, /* special_function */
413 "R_MICROBLAZE_TLS", /* name */
414 FALSE, /* partial_inplace */
415 0, /* src_mask */
416 0x0000ffff, /* dst_mask */
417 FALSE), /* pcrel_offset */
418
419 HOWTO (R_MICROBLAZE_TLSGD,
420 0, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 32, /* bitsize */
423 FALSE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_dont, /* complain_on_overflow */
426 bfd_elf_generic_reloc, /* special_function */
427 "R_MICROBLAZE_TLSGD", /* name */
428 FALSE, /* partial_inplace */
429 0, /* src_mask */
430 0x0000ffff, /* dst_mask */
431 FALSE), /* pcrel_offset */
432
433 HOWTO (R_MICROBLAZE_TLSLD,
434 0, /* rightshift */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
436 32, /* bitsize */
437 FALSE, /* pc_relative */
438 0, /* bitpos */
439 complain_overflow_dont, /* complain_on_overflow */
440 bfd_elf_generic_reloc, /* special_function */
441 "R_MICROBLAZE_TLSLD", /* name */
442 FALSE, /* partial_inplace */
443 0, /* src_mask */
444 0x0000ffff, /* dst_mask */
445 FALSE), /* pcrel_offset */
446
447 /* Computes the load module index of the load module that contains the
448 definition of its TLS sym. */
449 HOWTO (R_MICROBLAZE_TLSDTPMOD32,
450 0, /* rightshift */
451 2, /* size (0 = byte, 1 = short, 2 = long) */
452 32, /* bitsize */
453 FALSE, /* pc_relative */
454 0, /* bitpos */
455 complain_overflow_dont, /* complain_on_overflow */
456 bfd_elf_generic_reloc, /* special_function */
457 "R_MICROBLAZE_TLSDTPMOD32", /* name */
458 FALSE, /* partial_inplace */
459 0, /* src_mask */
460 0x0000ffff, /* dst_mask */
461 FALSE), /* pcrel_offset */
462
463 /* Computes a dtv-relative displacement, the difference between the value
464 of sym+add and the base address of the thread-local storage block that
465 contains the definition of sym, minus 0x8000. Used for initializing GOT */
466 HOWTO (R_MICROBLAZE_TLSDTPREL32,
467 0, /* rightshift */
468 2, /* size (0 = byte, 1 = short, 2 = long) */
469 32, /* bitsize */
470 FALSE, /* pc_relative */
471 0, /* bitpos */
472 complain_overflow_dont, /* complain_on_overflow */
473 bfd_elf_generic_reloc, /* special_function */
474 "R_MICROBLAZE_TLSDTPREL32", /* name */
475 FALSE, /* partial_inplace */
476 0, /* src_mask */
477 0x0000ffff, /* dst_mask */
478 FALSE), /* pcrel_offset */
479
480 /* Computes a dtv-relative displacement, the difference between the value
481 of sym+add and the base address of the thread-local storage block that
482 contains the definition of sym, minus 0x8000. */
483 HOWTO (R_MICROBLAZE_TLSDTPREL64,
484 0, /* rightshift */
485 2, /* size (0 = byte, 1 = short, 2 = long) */
486 32, /* bitsize */
487 FALSE, /* pc_relative */
488 0, /* bitpos */
489 complain_overflow_dont, /* complain_on_overflow */
490 bfd_elf_generic_reloc, /* special_function */
491 "R_MICROBLAZE_TLSDTPREL64", /* name */
492 FALSE, /* partial_inplace */
493 0, /* src_mask */
494 0x0000ffff, /* dst_mask */
495 FALSE), /* pcrel_offset */
496
497 /* Computes a tp-relative displacement, the difference between the value of
498 sym+add and the value of the thread pointer (r13). */
499 HOWTO (R_MICROBLAZE_TLSGOTTPREL32,
500 0, /* rightshift */
501 2, /* size (0 = byte, 1 = short, 2 = long) */
502 32, /* bitsize */
503 FALSE, /* pc_relative */
504 0, /* bitpos */
505 complain_overflow_dont, /* complain_on_overflow */
506 bfd_elf_generic_reloc, /* special_function */
507 "R_MICROBLAZE_TLSGOTTPREL32", /* name */
508 FALSE, /* partial_inplace */
509 0, /* src_mask */
510 0x0000ffff, /* dst_mask */
511 FALSE), /* pcrel_offset */
512
513 /* Computes a tp-relative displacement, the difference between the value of
514 sym+add and the value of the thread pointer (r13). */
515 HOWTO (R_MICROBLAZE_TLSTPREL32,
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_dont, /* complain_on_overflow */
522 bfd_elf_generic_reloc, /* special_function */
523 "R_MICROBLAZE_TLSTPREL32", /* name */
524 FALSE, /* partial_inplace */
525 0, /* src_mask */
526 0x0000ffff, /* dst_mask */
527 FALSE), /* pcrel_offset */
528
529 };
530
531 #ifndef NUM_ELEM
532 #define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])
533 #endif
534 \f
535 /* Initialize the microblaze_elf_howto_table, so that linear accesses can be done. */
536
537 static void
538 microblaze_elf_howto_init (void)
539 {
540 unsigned int i;
541
542 for (i = NUM_ELEM (microblaze_elf_howto_raw); i--;)
543 {
544 unsigned int type;
545
546 type = microblaze_elf_howto_raw[i].type;
547
548 BFD_ASSERT (type < NUM_ELEM (microblaze_elf_howto_table));
549
550 microblaze_elf_howto_table [type] = & microblaze_elf_howto_raw [i];
551 }
552 }
553 \f
554 static reloc_howto_type *
555 microblaze_elf_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
556 bfd_reloc_code_real_type code)
557 {
558 enum elf_microblaze_reloc_type microblaze_reloc = R_MICROBLAZE_NONE;
559
560 switch (code)
561 {
562 case BFD_RELOC_NONE:
563 microblaze_reloc = R_MICROBLAZE_NONE;
564 break;
565 case BFD_RELOC_MICROBLAZE_64_NONE:
566 microblaze_reloc = R_MICROBLAZE_64_NONE;
567 break;
568 case BFD_RELOC_32:
569 microblaze_reloc = R_MICROBLAZE_32;
570 break;
571 /* RVA is treated the same as 32 */
572 case BFD_RELOC_RVA:
573 microblaze_reloc = R_MICROBLAZE_32;
574 break;
575 case BFD_RELOC_32_PCREL:
576 microblaze_reloc = R_MICROBLAZE_32_PCREL;
577 break;
578 case BFD_RELOC_64_PCREL:
579 microblaze_reloc = R_MICROBLAZE_64_PCREL;
580 break;
581 case BFD_RELOC_MICROBLAZE_32_LO_PCREL:
582 microblaze_reloc = R_MICROBLAZE_32_PCREL_LO;
583 break;
584 case BFD_RELOC_64:
585 microblaze_reloc = R_MICROBLAZE_64;
586 break;
587 case BFD_RELOC_MICROBLAZE_32_LO:
588 microblaze_reloc = R_MICROBLAZE_32_LO;
589 break;
590 case BFD_RELOC_MICROBLAZE_32_ROSDA:
591 microblaze_reloc = R_MICROBLAZE_SRO32;
592 break;
593 case BFD_RELOC_MICROBLAZE_32_RWSDA:
594 microblaze_reloc = R_MICROBLAZE_SRW32;
595 break;
596 case BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM:
597 microblaze_reloc = R_MICROBLAZE_32_SYM_OP_SYM;
598 break;
599 case BFD_RELOC_VTABLE_INHERIT:
600 microblaze_reloc = R_MICROBLAZE_GNU_VTINHERIT;
601 break;
602 case BFD_RELOC_VTABLE_ENTRY:
603 microblaze_reloc = R_MICROBLAZE_GNU_VTENTRY;
604 break;
605 case BFD_RELOC_MICROBLAZE_64_GOTPC:
606 microblaze_reloc = R_MICROBLAZE_GOTPC_64;
607 break;
608 case BFD_RELOC_MICROBLAZE_64_GOT:
609 microblaze_reloc = R_MICROBLAZE_GOT_64;
610 break;
611 case BFD_RELOC_MICROBLAZE_64_TEXTPCREL:
612 microblaze_reloc = R_MICROBLAZE_TEXTPCREL_64;
613 break;
614 case BFD_RELOC_MICROBLAZE_64_TEXTREL:
615 microblaze_reloc = R_MICROBLAZE_TEXTREL_64;
616 break;
617 case BFD_RELOC_MICROBLAZE_64_PLT:
618 microblaze_reloc = R_MICROBLAZE_PLT_64;
619 break;
620 case BFD_RELOC_MICROBLAZE_64_GOTOFF:
621 microblaze_reloc = R_MICROBLAZE_GOTOFF_64;
622 break;
623 case BFD_RELOC_MICROBLAZE_32_GOTOFF:
624 microblaze_reloc = R_MICROBLAZE_GOTOFF_32;
625 break;
626 case BFD_RELOC_MICROBLAZE_64_TLSGD:
627 microblaze_reloc = R_MICROBLAZE_TLSGD;
628 break;
629 case BFD_RELOC_MICROBLAZE_64_TLSLD:
630 microblaze_reloc = R_MICROBLAZE_TLSLD;
631 break;
632 case BFD_RELOC_MICROBLAZE_32_TLSDTPREL:
633 microblaze_reloc = R_MICROBLAZE_TLSDTPREL32;
634 break;
635 case BFD_RELOC_MICROBLAZE_64_TLSDTPREL:
636 microblaze_reloc = R_MICROBLAZE_TLSDTPREL64;
637 break;
638 case BFD_RELOC_MICROBLAZE_32_TLSDTPMOD:
639 microblaze_reloc = R_MICROBLAZE_TLSDTPMOD32;
640 break;
641 case BFD_RELOC_MICROBLAZE_64_TLSGOTTPREL:
642 microblaze_reloc = R_MICROBLAZE_TLSGOTTPREL32;
643 break;
644 case BFD_RELOC_MICROBLAZE_64_TLSTPREL:
645 microblaze_reloc = R_MICROBLAZE_TLSTPREL32;
646 break;
647 case BFD_RELOC_MICROBLAZE_COPY:
648 microblaze_reloc = R_MICROBLAZE_COPY;
649 break;
650 default:
651 return (reloc_howto_type *) NULL;
652 }
653
654 if (!microblaze_elf_howto_table [R_MICROBLAZE_32])
655 /* Initialize howto table if needed. */
656 microblaze_elf_howto_init ();
657
658 return microblaze_elf_howto_table [(int) microblaze_reloc];
659 };
660
661 static reloc_howto_type *
662 microblaze_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
663 const char *r_name)
664 {
665 unsigned int i;
666
667 for (i = 0; i < NUM_ELEM (microblaze_elf_howto_raw); i++)
668 if (microblaze_elf_howto_raw[i].name != NULL
669 && strcasecmp (microblaze_elf_howto_raw[i].name, r_name) == 0)
670 return &microblaze_elf_howto_raw[i];
671
672 return NULL;
673 }
674
675 /* Set the howto pointer for a RCE ELF reloc. */
676
677 static bfd_boolean
678 microblaze_elf_info_to_howto (bfd * abfd,
679 arelent * cache_ptr,
680 Elf_Internal_Rela * dst)
681 {
682 unsigned int r_type;
683
684 if (!microblaze_elf_howto_table [R_MICROBLAZE_32])
685 /* Initialize howto table if needed. */
686 microblaze_elf_howto_init ();
687
688 r_type = ELF32_R_TYPE (dst->r_info);
689 if (r_type >= R_MICROBLAZE_max)
690 {
691 /* xgettext:c-format */
692 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
693 abfd, r_type);
694 bfd_set_error (bfd_error_bad_value);
695 return FALSE;
696 }
697
698 cache_ptr->howto = microblaze_elf_howto_table [r_type];
699 return TRUE;
700 }
701
702 /* Microblaze ELF local labels start with 'L.' or '$L', not '.L'. */
703
704 static bfd_boolean
705 microblaze_elf_is_local_label_name (bfd *abfd, const char *name)
706 {
707 if (name[0] == 'L' && name[1] == '.')
708 return TRUE;
709
710 if (name[0] == '$' && name[1] == 'L')
711 return TRUE;
712
713 /* With gcc, the labels go back to starting with '.', so we accept
714 the generic ELF local label syntax as well. */
715 return _bfd_elf_is_local_label_name (abfd, name);
716 }
717
718 /* ELF linker hash entry. */
719
720 struct elf32_mb_link_hash_entry
721 {
722 struct elf_link_hash_entry elf;
723
724 /* Track dynamic relocs copied for this symbol. */
725 struct elf_dyn_relocs *dyn_relocs;
726
727 /* TLS Reference Types for the symbol; Updated by check_relocs */
728 #define TLS_GD 1 /* GD reloc. */
729 #define TLS_LD 2 /* LD reloc. */
730 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
731 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
732 #define TLS_TLS 16 /* Any TLS reloc. */
733 unsigned char tls_mask;
734
735 };
736
737 #define IS_TLS_GD(x) (x == (TLS_TLS | TLS_GD))
738 #define IS_TLS_LD(x) (x == (TLS_TLS | TLS_LD))
739 #define IS_TLS_DTPREL(x) (x == (TLS_TLS | TLS_DTPREL))
740 #define IS_TLS_NONE(x) (x == 0)
741
742 #define elf32_mb_hash_entry(ent) ((struct elf32_mb_link_hash_entry *)(ent))
743
744 /* ELF linker hash table. */
745
746 struct elf32_mb_link_hash_table
747 {
748 struct elf_link_hash_table elf;
749
750 /* Small local sym to section mapping cache. */
751 struct sym_cache sym_sec;
752
753 /* TLS Local Dynamic GOT Entry */
754 union {
755 bfd_signed_vma refcount;
756 bfd_vma offset;
757 } tlsld_got;
758 };
759
760 /* Nonzero if this section has TLS related relocations. */
761 #define has_tls_reloc sec_flg0
762
763 /* Get the ELF linker hash table from a link_info structure. */
764
765 #define elf32_mb_hash_table(p) \
766 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
767 == MICROBLAZE_ELF_DATA ? ((struct elf32_mb_link_hash_table *) ((p)->hash)) : NULL)
768
769 /* Create an entry in a microblaze ELF linker hash table. */
770
771 static struct bfd_hash_entry *
772 link_hash_newfunc (struct bfd_hash_entry *entry,
773 struct bfd_hash_table *table,
774 const char *string)
775 {
776 /* Allocate the structure if it has not already been allocated by a
777 subclass. */
778 if (entry == NULL)
779 {
780 entry = bfd_hash_allocate (table,
781 sizeof (struct elf32_mb_link_hash_entry));
782 if (entry == NULL)
783 return entry;
784 }
785
786 /* Call the allocation method of the superclass. */
787 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
788 if (entry != NULL)
789 {
790 struct elf32_mb_link_hash_entry *eh;
791
792 eh = (struct elf32_mb_link_hash_entry *) entry;
793 eh->dyn_relocs = NULL;
794 eh->tls_mask = 0;
795 }
796
797 return entry;
798 }
799
800 /* Create a mb ELF linker hash table. */
801
802 static struct bfd_link_hash_table *
803 microblaze_elf_link_hash_table_create (bfd *abfd)
804 {
805 struct elf32_mb_link_hash_table *ret;
806 bfd_size_type amt = sizeof (struct elf32_mb_link_hash_table);
807
808 ret = (struct elf32_mb_link_hash_table *) bfd_zmalloc (amt);
809 if (ret == NULL)
810 return NULL;
811
812 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
813 sizeof (struct elf32_mb_link_hash_entry),
814 MICROBLAZE_ELF_DATA))
815 {
816 free (ret);
817 return NULL;
818 }
819
820 return &ret->elf.root;
821 }
822 \f
823 /* Set the values of the small data pointers. */
824
825 static void
826 microblaze_elf_final_sdp (struct bfd_link_info *info)
827 {
828 struct bfd_link_hash_entry *h;
829
830 h = bfd_link_hash_lookup (info->hash, RO_SDA_ANCHOR_NAME, FALSE, FALSE, TRUE);
831 if (h != (struct bfd_link_hash_entry *) NULL
832 && h->type == bfd_link_hash_defined)
833 ro_small_data_pointer = (h->u.def.value
834 + h->u.def.section->output_section->vma
835 + h->u.def.section->output_offset);
836
837 h = bfd_link_hash_lookup (info->hash, RW_SDA_ANCHOR_NAME, FALSE, FALSE, TRUE);
838 if (h != (struct bfd_link_hash_entry *) NULL
839 && h->type == bfd_link_hash_defined)
840 rw_small_data_pointer = (h->u.def.value
841 + h->u.def.section->output_section->vma
842 + h->u.def.section->output_offset);
843 }
844
845 static bfd_vma
846 dtprel_base (struct bfd_link_info *info)
847 {
848 /* If tls_sec is NULL, we should have signalled an error already. */
849 if (elf_hash_table (info)->tls_sec == NULL)
850 return 0;
851 return elf_hash_table (info)->tls_sec->vma;
852 }
853
854 /* The size of the thread control block. */
855 #define TCB_SIZE 8
856
857 /* Output a simple dynamic relocation into SRELOC. */
858
859 static void
860 microblaze_elf_output_dynamic_relocation (bfd *output_bfd,
861 asection *sreloc,
862 unsigned long reloc_index,
863 unsigned long indx,
864 int r_type,
865 bfd_vma offset,
866 bfd_vma addend)
867 {
868
869 Elf_Internal_Rela rel;
870
871 rel.r_info = ELF32_R_INFO (indx, r_type);
872 rel.r_offset = offset;
873 rel.r_addend = addend;
874
875 bfd_elf32_swap_reloca_out (output_bfd, &rel,
876 (sreloc->contents + reloc_index * sizeof (Elf32_External_Rela)));
877 }
878
879 /* This code is taken from elf32-m32r.c
880 There is some attempt to make this function usable for many architectures,
881 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
882 if only to serve as a learning tool.
883
884 The RELOCATE_SECTION function is called by the new ELF backend linker
885 to handle the relocations for a section.
886
887 The relocs are always passed as Rela structures; if the section
888 actually uses Rel structures, the r_addend field will always be
889 zero.
890
891 This function is responsible for adjust the section contents as
892 necessary, and (if using Rela relocs and generating a
893 relocatable output file) adjusting the reloc addend as
894 necessary.
895
896 This function does not have to worry about setting the reloc
897 address or the reloc symbol index.
898
899 LOCAL_SYMS is a pointer to the swapped in local symbols.
900
901 LOCAL_SECTIONS is an array giving the section in the input file
902 corresponding to the st_shndx field of each local symbol.
903
904 The global hash table entry for the global symbols can be found
905 via elf_sym_hashes (input_bfd).
906
907 When generating relocatable output, this function must handle
908 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
909 going to be the section symbol corresponding to the output
910 section, which means that the addend must be adjusted
911 accordingly. */
912
913 static bfd_boolean
914 microblaze_elf_relocate_section (bfd *output_bfd,
915 struct bfd_link_info *info,
916 bfd *input_bfd,
917 asection *input_section,
918 bfd_byte *contents,
919 Elf_Internal_Rela *relocs,
920 Elf_Internal_Sym *local_syms,
921 asection **local_sections)
922 {
923 struct elf32_mb_link_hash_table *htab;
924 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
925 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
926 Elf_Internal_Rela *rel, *relend;
927 int endian = (bfd_little_endian (output_bfd)) ? 0 : 2;
928 /* Assume success. */
929 bfd_boolean ret = TRUE;
930 asection *sreloc;
931 bfd_vma *local_got_offsets;
932 unsigned int tls_type;
933
934 if (!microblaze_elf_howto_table[R_MICROBLAZE_max-1])
935 microblaze_elf_howto_init ();
936
937 htab = elf32_mb_hash_table (info);
938 if (htab == NULL)
939 return FALSE;
940
941 local_got_offsets = elf_local_got_offsets (input_bfd);
942
943 sreloc = elf_section_data (input_section)->sreloc;
944
945 rel = relocs;
946 relend = relocs + input_section->reloc_count;
947 for (; rel < relend; rel++)
948 {
949 int r_type;
950 reloc_howto_type *howto;
951 unsigned long r_symndx;
952 bfd_vma addend = rel->r_addend;
953 bfd_vma offset = rel->r_offset;
954 struct elf_link_hash_entry *h;
955 Elf_Internal_Sym *sym;
956 asection *sec;
957 const char *sym_name;
958 bfd_reloc_status_type r = bfd_reloc_ok;
959 const char *errmsg = NULL;
960 bfd_boolean unresolved_reloc = FALSE;
961
962 h = NULL;
963 r_type = ELF32_R_TYPE (rel->r_info);
964 tls_type = 0;
965
966 if (r_type < 0 || r_type >= (int) R_MICROBLAZE_max)
967 {
968 /* xgettext:c-format */
969 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
970 input_bfd, (int) r_type);
971 bfd_set_error (bfd_error_bad_value);
972 ret = FALSE;
973 continue;
974 }
975
976 howto = microblaze_elf_howto_table[r_type];
977 r_symndx = ELF32_R_SYM (rel->r_info);
978
979 if (bfd_link_relocatable (info))
980 {
981 /* This is a relocatable link. We don't have to change
982 anything, unless the reloc is against a section symbol,
983 in which case we have to adjust according to where the
984 section symbol winds up in the output section. */
985 sec = NULL;
986 if (r_symndx >= symtab_hdr->sh_info)
987 /* External symbol. */
988 continue;
989
990 /* Local symbol. */
991 sym = local_syms + r_symndx;
992 sym_name = "<local symbol>";
993 /* STT_SECTION: symbol is associated with a section. */
994 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
995 /* Symbol isn't associated with a section. Nothing to do. */
996 continue;
997
998 sec = local_sections[r_symndx];
999 addend += sec->output_offset + sym->st_value;
1000 #ifndef USE_REL
1001 /* This can't be done for USE_REL because it doesn't mean anything
1002 and elf_link_input_bfd asserts this stays zero. */
1003 /* rel->r_addend = addend; */
1004 #endif
1005
1006 #ifndef USE_REL
1007 /* Addends are stored with relocs. We're done. */
1008 continue;
1009 #else /* USE_REL */
1010 /* If partial_inplace, we need to store any additional addend
1011 back in the section. */
1012 if (!howto->partial_inplace)
1013 continue;
1014 /* ??? Here is a nice place to call a special_function like handler. */
1015 r = _bfd_relocate_contents (howto, input_bfd, addend,
1016 contents + offset);
1017 #endif /* USE_REL */
1018 }
1019 else
1020 {
1021 bfd_vma relocation;
1022 bfd_boolean resolved_to_zero;
1023
1024 /* This is a final link. */
1025 sym = NULL;
1026 sec = NULL;
1027 unresolved_reloc = FALSE;
1028
1029 if (r_symndx < symtab_hdr->sh_info)
1030 {
1031 /* Local symbol. */
1032 sym = local_syms + r_symndx;
1033 sec = local_sections[r_symndx];
1034 if (sec == 0)
1035 continue;
1036 sym_name = "<local symbol>";
1037 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1038 /* r_addend may have changed if the reference section was
1039 a merge section. */
1040 addend = rel->r_addend;
1041 }
1042 else
1043 {
1044 /* External symbol. */
1045 bfd_boolean warned ATTRIBUTE_UNUSED;
1046 bfd_boolean ignored ATTRIBUTE_UNUSED;
1047
1048 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1049 r_symndx, symtab_hdr, sym_hashes,
1050 h, sec, relocation,
1051 unresolved_reloc, warned, ignored);
1052 sym_name = h->root.root.string;
1053 }
1054
1055 /* Sanity check the address. */
1056 if (offset > bfd_get_section_limit (input_bfd, input_section))
1057 {
1058 r = bfd_reloc_outofrange;
1059 goto check_reloc;
1060 }
1061
1062 resolved_to_zero = (h != NULL
1063 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
1064
1065 switch ((int) r_type)
1066 {
1067 case (int) R_MICROBLAZE_SRO32 :
1068 {
1069 const char *name;
1070
1071 /* Only relocate if the symbol is defined. */
1072 if (sec)
1073 {
1074 name = bfd_section_name (sec);
1075
1076 if (strcmp (name, ".sdata2") == 0
1077 || strcmp (name, ".sbss2") == 0)
1078 {
1079 if (ro_small_data_pointer == 0)
1080 microblaze_elf_final_sdp (info);
1081 if (ro_small_data_pointer == 0)
1082 {
1083 ret = FALSE;
1084 r = bfd_reloc_undefined;
1085 goto check_reloc;
1086 }
1087
1088 /* At this point `relocation' contains the object's
1089 address. */
1090 relocation -= ro_small_data_pointer;
1091 /* Now it contains the offset from _SDA2_BASE_. */
1092 r = _bfd_final_link_relocate (howto, input_bfd,
1093 input_section,
1094 contents, offset,
1095 relocation, addend);
1096 }
1097 else
1098 {
1099 _bfd_error_handler
1100 /* xgettext:c-format */
1101 (_("%pB: the target (%s) of an %s relocation"
1102 " is in the wrong section (%pA)"),
1103 input_bfd,
1104 sym_name,
1105 microblaze_elf_howto_table[(int) r_type]->name,
1106 sec);
1107 /*bfd_set_error (bfd_error_bad_value); ??? why? */
1108 ret = FALSE;
1109 continue;
1110 }
1111 }
1112 }
1113 break;
1114
1115 case (int) R_MICROBLAZE_SRW32 :
1116 {
1117 const char *name;
1118
1119 /* Only relocate if the symbol is defined. */
1120 if (sec)
1121 {
1122 name = bfd_section_name (sec);
1123
1124 if (strcmp (name, ".sdata") == 0
1125 || strcmp (name, ".sbss") == 0)
1126 {
1127 if (rw_small_data_pointer == 0)
1128 microblaze_elf_final_sdp (info);
1129 if (rw_small_data_pointer == 0)
1130 {
1131 ret = FALSE;
1132 r = bfd_reloc_undefined;
1133 goto check_reloc;
1134 }
1135
1136 /* At this point `relocation' contains the object's
1137 address. */
1138 relocation -= rw_small_data_pointer;
1139 /* Now it contains the offset from _SDA_BASE_. */
1140 r = _bfd_final_link_relocate (howto, input_bfd,
1141 input_section,
1142 contents, offset,
1143 relocation, addend);
1144 }
1145 else
1146 {
1147 _bfd_error_handler
1148 /* xgettext:c-format */
1149 (_("%pB: the target (%s) of an %s relocation"
1150 " is in the wrong section (%pA)"),
1151 input_bfd,
1152 sym_name,
1153 microblaze_elf_howto_table[(int) r_type]->name,
1154 sec);
1155 /*bfd_set_error (bfd_error_bad_value); ??? why? */
1156 ret = FALSE;
1157 continue;
1158 }
1159 }
1160 }
1161 break;
1162
1163 case (int) R_MICROBLAZE_32_SYM_OP_SYM:
1164 break; /* Do nothing. */
1165
1166 case (int) R_MICROBLAZE_GOTPC_64:
1167 relocation = (htab->elf.sgotplt->output_section->vma
1168 + htab->elf.sgotplt->output_offset);
1169 relocation -= (input_section->output_section->vma
1170 + input_section->output_offset
1171 + offset + INST_WORD_SIZE);
1172 relocation += addend;
1173 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1174 contents + offset + endian);
1175 bfd_put_16 (input_bfd, relocation & 0xffff,
1176 contents + offset + endian + INST_WORD_SIZE);
1177 break;
1178
1179 case (int) R_MICROBLAZE_TEXTPCREL_64:
1180 relocation = input_section->output_section->vma;
1181 relocation -= (input_section->output_section->vma
1182 + input_section->output_offset
1183 + offset + INST_WORD_SIZE);
1184 relocation += addend;
1185 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1186 contents + offset + endian);
1187 bfd_put_16 (input_bfd, relocation & 0xffff,
1188 contents + offset + endian + INST_WORD_SIZE);
1189 break;
1190
1191 case (int) R_MICROBLAZE_PLT_64:
1192 {
1193 bfd_vma immediate;
1194 if (htab->elf.splt != NULL && h != NULL
1195 && h->plt.offset != (bfd_vma) -1)
1196 {
1197 relocation = (htab->elf.splt->output_section->vma
1198 + htab->elf.splt->output_offset
1199 + h->plt.offset);
1200 unresolved_reloc = FALSE;
1201 immediate = relocation - (input_section->output_section->vma
1202 + input_section->output_offset
1203 + offset + INST_WORD_SIZE);
1204 bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
1205 contents + offset + endian);
1206 bfd_put_16 (input_bfd, immediate & 0xffff,
1207 contents + offset + endian + INST_WORD_SIZE);
1208 }
1209 else
1210 {
1211 relocation -= (input_section->output_section->vma
1212 + input_section->output_offset
1213 + offset + INST_WORD_SIZE);
1214 immediate = relocation;
1215 bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
1216 contents + offset + endian);
1217 bfd_put_16 (input_bfd, immediate & 0xffff,
1218 contents + offset + endian + INST_WORD_SIZE);
1219 }
1220 break;
1221 }
1222
1223 case (int) R_MICROBLAZE_TLSGD:
1224 tls_type = (TLS_TLS | TLS_GD);
1225 goto dogot;
1226 case (int) R_MICROBLAZE_TLSLD:
1227 tls_type = (TLS_TLS | TLS_LD);
1228 /* Fall through. */
1229 dogot:
1230 case (int) R_MICROBLAZE_GOT_64:
1231 {
1232 bfd_vma *offp;
1233 bfd_vma off, off2;
1234 unsigned long indx;
1235 bfd_vma static_value;
1236
1237 bfd_boolean need_relocs = FALSE;
1238 if (htab->elf.sgot == NULL)
1239 abort ();
1240
1241 indx = 0;
1242 offp = NULL;
1243
1244 /* 1. Identify GOT Offset;
1245 2. Compute Static Values
1246 3. Process Module Id, Process Offset
1247 4. Fixup Relocation with GOT offset value. */
1248
1249 /* 1. Determine GOT Offset to use : TLS_LD, global, local */
1250 if (IS_TLS_LD (tls_type))
1251 offp = &htab->tlsld_got.offset;
1252 else if (h != NULL)
1253 {
1254 if (htab->elf.sgotplt != NULL
1255 && h->got.offset != (bfd_vma) -1)
1256 offp = &h->got.offset;
1257 else
1258 abort ();
1259 }
1260 else
1261 {
1262 if (local_got_offsets == NULL)
1263 abort ();
1264 offp = &local_got_offsets[r_symndx];
1265 }
1266
1267 if (!offp)
1268 abort ();
1269
1270 off = (*offp) & ~1;
1271 off2 = off;
1272
1273 if (IS_TLS_LD(tls_type) || IS_TLS_GD(tls_type))
1274 off2 = off + 4;
1275
1276 /* Symbol index to use for relocs */
1277 if (h != NULL)
1278 {
1279 bfd_boolean dyn =
1280 elf_hash_table (info)->dynamic_sections_created;
1281
1282 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1283 bfd_link_pic (info),
1284 h)
1285 && (!bfd_link_pic (info)
1286 || !SYMBOL_REFERENCES_LOCAL (info, h)))
1287 indx = h->dynindx;
1288 }
1289
1290 /* Need to generate relocs ? */
1291 if ((bfd_link_pic (info) || indx != 0)
1292 && (h == NULL
1293 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1294 && !resolved_to_zero)
1295 || h->root.type != bfd_link_hash_undefweak))
1296 need_relocs = TRUE;
1297
1298 /* 2. Compute/Emit Static value of r-expression */
1299 static_value = relocation + addend;
1300
1301 /* 3. Process module-id and offset */
1302 if (! ((*offp) & 1) )
1303 {
1304 bfd_vma got_offset;
1305
1306 got_offset = (htab->elf.sgot->output_section->vma
1307 + htab->elf.sgot->output_offset
1308 + off);
1309
1310 /* Process module-id */
1311 if (IS_TLS_LD(tls_type))
1312 {
1313 if (! bfd_link_pic (info))
1314 bfd_put_32 (output_bfd, 1,
1315 htab->elf.sgot->contents + off);
1316 else
1317 microblaze_elf_output_dynamic_relocation
1318 (output_bfd,
1319 htab->elf.srelgot,
1320 htab->elf.srelgot->reloc_count++,
1321 /* symindex= */ 0, R_MICROBLAZE_TLSDTPMOD32,
1322 got_offset, 0);
1323 }
1324 else if (IS_TLS_GD(tls_type))
1325 {
1326 if (! need_relocs)
1327 bfd_put_32 (output_bfd, 1,
1328 htab->elf.sgot->contents + off);
1329 else
1330 microblaze_elf_output_dynamic_relocation
1331 (output_bfd,
1332 htab->elf.srelgot,
1333 htab->elf.srelgot->reloc_count++,
1334 /* symindex= */ indx, R_MICROBLAZE_TLSDTPMOD32,
1335 got_offset, indx ? 0 : static_value);
1336 }
1337
1338 /* Process Offset */
1339 if (htab->elf.srelgot == NULL)
1340 abort ();
1341
1342 got_offset = (htab->elf.sgot->output_section->vma
1343 + htab->elf.sgot->output_offset
1344 + off2);
1345 if (IS_TLS_LD(tls_type))
1346 {
1347 /* For LD, offset should be 0 */
1348 *offp |= 1;
1349 bfd_put_32 (output_bfd, 0,
1350 htab->elf.sgot->contents + off2);
1351 }
1352 else if (IS_TLS_GD(tls_type))
1353 {
1354 *offp |= 1;
1355 static_value -= dtprel_base(info);
1356 if (need_relocs)
1357 microblaze_elf_output_dynamic_relocation
1358 (output_bfd,
1359 htab->elf.srelgot,
1360 htab->elf.srelgot->reloc_count++,
1361 /* symindex= */ indx, R_MICROBLAZE_TLSDTPREL32,
1362 got_offset, indx ? 0 : static_value);
1363 else
1364 bfd_put_32 (output_bfd, static_value,
1365 htab->elf.sgot->contents + off2);
1366 }
1367 else
1368 {
1369 bfd_put_32 (output_bfd, static_value,
1370 htab->elf.sgot->contents + off2);
1371
1372 /* Relocs for dyn symbols generated by
1373 finish_dynamic_symbols */
1374 if (bfd_link_pic (info) && h == NULL)
1375 {
1376 *offp |= 1;
1377 microblaze_elf_output_dynamic_relocation
1378 (output_bfd,
1379 htab->elf.srelgot,
1380 htab->elf.srelgot->reloc_count++,
1381 /* symindex= */ indx, R_MICROBLAZE_REL,
1382 got_offset, static_value);
1383 }
1384 }
1385 }
1386
1387 /* 4. Fixup Relocation with GOT offset value
1388 Compute relative address of GOT entry for applying
1389 the current relocation */
1390 relocation = htab->elf.sgot->output_section->vma
1391 + htab->elf.sgot->output_offset
1392 + off
1393 - htab->elf.sgotplt->output_section->vma
1394 - htab->elf.sgotplt->output_offset;
1395
1396 /* Apply Current Relocation */
1397 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1398 contents + offset + endian);
1399 bfd_put_16 (input_bfd, relocation & 0xffff,
1400 contents + offset + endian + INST_WORD_SIZE);
1401
1402 unresolved_reloc = FALSE;
1403 break;
1404 }
1405
1406 case (int) R_MICROBLAZE_GOTOFF_64:
1407 {
1408 bfd_vma immediate;
1409 unsigned short lo, high;
1410 relocation += addend;
1411 relocation -= (htab->elf.sgotplt->output_section->vma
1412 + htab->elf.sgotplt->output_offset);
1413 /* Write this value into correct location. */
1414 immediate = relocation;
1415 lo = immediate & 0x0000ffff;
1416 high = (immediate >> 16) & 0x0000ffff;
1417 bfd_put_16 (input_bfd, high, contents + offset + endian);
1418 bfd_put_16 (input_bfd, lo,
1419 contents + offset + INST_WORD_SIZE + endian);
1420 break;
1421 }
1422
1423 case (int) R_MICROBLAZE_GOTOFF_32:
1424 {
1425 relocation += addend;
1426 relocation -= (htab->elf.sgotplt->output_section->vma
1427 + htab->elf.sgotplt->output_offset);
1428 /* Write this value into correct location. */
1429 bfd_put_32 (input_bfd, relocation, contents + offset);
1430 break;
1431 }
1432
1433 case (int) R_MICROBLAZE_TLSDTPREL64:
1434 relocation += addend;
1435 relocation -= dtprel_base(info);
1436 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1437 contents + offset + 2);
1438 bfd_put_16 (input_bfd, relocation & 0xffff,
1439 contents + offset + 2 + INST_WORD_SIZE);
1440 break;
1441 case (int) R_MICROBLAZE_TEXTREL_64:
1442 case (int) R_MICROBLAZE_TEXTREL_32_LO:
1443 case (int) R_MICROBLAZE_64_PCREL :
1444 case (int) R_MICROBLAZE_64:
1445 case (int) R_MICROBLAZE_32:
1446 {
1447 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
1448 from removed linkonce sections, or sections discarded by
1449 a linker script. */
1450 if (r_symndx == STN_UNDEF || (input_section->flags & SEC_ALLOC) == 0)
1451 {
1452 relocation += addend;
1453 if (r_type == R_MICROBLAZE_32)
1454 bfd_put_32 (input_bfd, relocation, contents + offset);
1455 else
1456 {
1457 if (r_type == R_MICROBLAZE_64_PCREL)
1458 relocation -= (input_section->output_section->vma
1459 + input_section->output_offset
1460 + offset + INST_WORD_SIZE);
1461 else if (r_type == R_MICROBLAZE_TEXTREL_64
1462 || r_type == R_MICROBLAZE_TEXTREL_32_LO)
1463 relocation -= input_section->output_section->vma;
1464
1465 if (r_type == R_MICROBLAZE_TEXTREL_32_LO)
1466 bfd_put_16 (input_bfd, relocation & 0xffff,
1467 contents + offset + endian);
1468
1469 else
1470 {
1471 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1472 contents + offset + endian);
1473 bfd_put_16 (input_bfd, relocation & 0xffff,
1474 contents + offset + endian + INST_WORD_SIZE);
1475 }
1476 }
1477 break;
1478 }
1479
1480 if ((bfd_link_pic (info)
1481 && (h == NULL
1482 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1483 && !resolved_to_zero)
1484 || h->root.type != bfd_link_hash_undefweak)
1485 && (!howto->pc_relative
1486 || (h != NULL
1487 && h->dynindx != -1
1488 && (!info->symbolic
1489 || !h->def_regular))))
1490 || (!bfd_link_pic (info)
1491 && h != NULL
1492 && h->dynindx != -1
1493 && !h->non_got_ref
1494 && ((h->def_dynamic
1495 && !h->def_regular)
1496 || h->root.type == bfd_link_hash_undefweak
1497 || h->root.type == bfd_link_hash_undefined)))
1498 {
1499 Elf_Internal_Rela outrel;
1500 bfd_byte *loc;
1501 bfd_boolean skip;
1502
1503 /* When generating a shared object, these relocations
1504 are copied into the output file to be resolved at run
1505 time. */
1506
1507 BFD_ASSERT (sreloc != NULL);
1508
1509 skip = FALSE;
1510
1511 outrel.r_offset =
1512 _bfd_elf_section_offset (output_bfd, info, input_section,
1513 rel->r_offset);
1514 if (outrel.r_offset == (bfd_vma) -1)
1515 skip = TRUE;
1516 else if (outrel.r_offset == (bfd_vma) -2)
1517 skip = TRUE;
1518 outrel.r_offset += (input_section->output_section->vma
1519 + input_section->output_offset);
1520
1521 if (skip)
1522 memset (&outrel, 0, sizeof outrel);
1523 /* h->dynindx may be -1 if the symbol was marked to
1524 become local. */
1525 else if (h != NULL
1526 && ((! info->symbolic && h->dynindx != -1)
1527 || !h->def_regular))
1528 {
1529 BFD_ASSERT (h->dynindx != -1);
1530 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1531 outrel.r_addend = addend;
1532 }
1533 else
1534 {
1535 if (r_type == R_MICROBLAZE_32)
1536 {
1537 outrel.r_info = ELF32_R_INFO (0, R_MICROBLAZE_REL);
1538 outrel.r_addend = relocation + addend;
1539 }
1540 else
1541 {
1542 BFD_FAIL ();
1543 _bfd_error_handler
1544 (_("%pB: probably compiled without -fPIC?"),
1545 input_bfd);
1546 bfd_set_error (bfd_error_bad_value);
1547 return FALSE;
1548 }
1549 }
1550
1551 loc = sreloc->contents;
1552 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1553 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1554 break;
1555 }
1556 else
1557 {
1558 relocation += addend;
1559 if (r_type == R_MICROBLAZE_32)
1560 bfd_put_32 (input_bfd, relocation, contents + offset);
1561 else
1562 {
1563 if (r_type == R_MICROBLAZE_64_PCREL)
1564 relocation -= (input_section->output_section->vma
1565 + input_section->output_offset
1566 + offset + INST_WORD_SIZE);
1567 else if (r_type == R_MICROBLAZE_TEXTREL_64
1568 || r_type == R_MICROBLAZE_TEXTREL_32_LO)
1569 relocation -= input_section->output_section->vma;
1570
1571 if (r_type == R_MICROBLAZE_TEXTREL_32_LO)
1572 {
1573 bfd_put_16 (input_bfd, relocation & 0xffff,
1574 contents + offset + endian);
1575 }
1576 else
1577 {
1578 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1579 contents + offset + endian);
1580 bfd_put_16 (input_bfd, relocation & 0xffff,
1581 contents + offset + endian
1582 + INST_WORD_SIZE);
1583 }
1584 }
1585 break;
1586 }
1587 }
1588
1589 default :
1590 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1591 contents, offset,
1592 relocation, addend);
1593 break;
1594 }
1595 }
1596
1597 check_reloc:
1598
1599 if (r != bfd_reloc_ok)
1600 {
1601 /* FIXME: This should be generic enough to go in a utility. */
1602 const char *name;
1603
1604 if (h != NULL)
1605 name = h->root.root.string;
1606 else
1607 {
1608 name = (bfd_elf_string_from_elf_section
1609 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1610 if (name == NULL || *name == '\0')
1611 name = bfd_section_name (sec);
1612 }
1613
1614 if (errmsg != NULL)
1615 goto common_error;
1616
1617 switch (r)
1618 {
1619 case bfd_reloc_overflow:
1620 (*info->callbacks->reloc_overflow)
1621 (info, (h ? &h->root : NULL), name, howto->name,
1622 (bfd_vma) 0, input_bfd, input_section, offset);
1623 break;
1624
1625 case bfd_reloc_undefined:
1626 (*info->callbacks->undefined_symbol)
1627 (info, name, input_bfd, input_section, offset, TRUE);
1628 break;
1629
1630 case bfd_reloc_outofrange:
1631 errmsg = _("internal error: out of range error");
1632 goto common_error;
1633
1634 case bfd_reloc_notsupported:
1635 errmsg = _("internal error: unsupported relocation error");
1636 goto common_error;
1637
1638 case bfd_reloc_dangerous:
1639 errmsg = _("internal error: dangerous error");
1640 goto common_error;
1641
1642 default:
1643 errmsg = _("internal error: unknown error");
1644 /* Fall through. */
1645 common_error:
1646 (*info->callbacks->warning) (info, errmsg, name, input_bfd,
1647 input_section, offset);
1648 break;
1649 }
1650 }
1651 }
1652
1653 return ret;
1654 }
1655 \f
1656 /* Calculate fixup value for reference. */
1657
1658 static int
1659 calc_fixup (bfd_vma start, bfd_vma size, asection *sec)
1660 {
1661 bfd_vma end = start + size;
1662 int i, fixup = 0;
1663
1664 if (sec == NULL || sec->relax == NULL)
1665 return 0;
1666
1667 /* Look for addr in relax table, total fixup value. */
1668 for (i = 0; i < sec->relax_count; i++)
1669 {
1670 if (end <= sec->relax[i].addr)
1671 break;
1672 if ((end != start) && (start > sec->relax[i].addr))
1673 continue;
1674 fixup += sec->relax[i].size;
1675 }
1676 return fixup;
1677 }
1678
1679 /* Read-modify-write into the bfd, an immediate value into appropriate fields of
1680 a 32-bit instruction. */
1681 static void
1682 microblaze_bfd_write_imm_value_32 (bfd *abfd, bfd_byte *bfd_addr, bfd_vma val)
1683 {
1684 unsigned long instr = bfd_get_32 (abfd, bfd_addr);
1685 instr &= ~0x0000ffff;
1686 instr |= (val & 0x0000ffff);
1687 bfd_put_32 (abfd, instr, bfd_addr);
1688 }
1689
1690 /* Read-modify-write into the bfd, an immediate value into appropriate fields of
1691 two consecutive 32-bit instructions. */
1692 static void
1693 microblaze_bfd_write_imm_value_64 (bfd *abfd, bfd_byte *bfd_addr, bfd_vma val)
1694 {
1695 unsigned long instr_hi;
1696 unsigned long instr_lo;
1697
1698 instr_hi = bfd_get_32 (abfd, bfd_addr);
1699 instr_hi &= ~0x0000ffff;
1700 instr_hi |= ((val >> 16) & 0x0000ffff);
1701 bfd_put_32 (abfd, instr_hi, bfd_addr);
1702
1703 instr_lo = bfd_get_32 (abfd, bfd_addr + INST_WORD_SIZE);
1704 instr_lo &= ~0x0000ffff;
1705 instr_lo |= (val & 0x0000ffff);
1706 bfd_put_32 (abfd, instr_lo, bfd_addr + INST_WORD_SIZE);
1707 }
1708
1709 static bfd_boolean
1710 microblaze_elf_relax_section (bfd *abfd,
1711 asection *sec,
1712 struct bfd_link_info *link_info,
1713 bfd_boolean *again)
1714 {
1715 Elf_Internal_Shdr *symtab_hdr;
1716 Elf_Internal_Rela *internal_relocs;
1717 Elf_Internal_Rela *free_relocs = NULL;
1718 Elf_Internal_Rela *irel, *irelend;
1719 bfd_byte *contents = NULL;
1720 bfd_byte *free_contents = NULL;
1721 int rel_count;
1722 unsigned int shndx;
1723 int i, sym_index;
1724 asection *o;
1725 struct elf_link_hash_entry *sym_hash;
1726 Elf_Internal_Sym *isymbuf, *isymend;
1727 Elf_Internal_Sym *isym;
1728 int symcount;
1729 int offset;
1730 bfd_vma src, dest;
1731
1732 /* We only do this once per section. We may be able to delete some code
1733 by running multiple passes, but it is not worth it. */
1734 *again = FALSE;
1735
1736 /* Only do this for a text section. */
1737 if (bfd_link_relocatable (link_info)
1738 || (sec->flags & SEC_RELOC) == 0
1739 || (sec->reloc_count == 0)
1740 || (sec->flags & SEC_CODE) == 0)
1741 return TRUE;
1742
1743 BFD_ASSERT ((sec->size > 0) || (sec->rawsize > 0));
1744
1745 /* If this is the first time we have been called for this section,
1746 initialize the cooked size. */
1747 if (sec->size == 0)
1748 sec->size = sec->rawsize;
1749
1750 /* Get symbols for this section. */
1751 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1752 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1753 symcount = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
1754 if (isymbuf == NULL)
1755 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, symcount,
1756 0, NULL, NULL, NULL);
1757 BFD_ASSERT (isymbuf != NULL);
1758
1759 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
1760 if (internal_relocs == NULL)
1761 goto error_return;
1762 if (! link_info->keep_memory)
1763 free_relocs = internal_relocs;
1764
1765 sec->relax = (struct relax_table *) bfd_malloc ((sec->reloc_count + 1)
1766 * sizeof (struct relax_table));
1767 if (sec->relax == NULL)
1768 goto error_return;
1769 sec->relax_count = 0;
1770
1771 irelend = internal_relocs + sec->reloc_count;
1772 rel_count = 0;
1773 for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1774 {
1775 bfd_vma symval;
1776 if ((ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64_PCREL)
1777 && (ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64)
1778 && (ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_TEXTREL_64))
1779 continue; /* Can't delete this reloc. */
1780
1781 /* Get the section contents. */
1782 if (contents == NULL)
1783 {
1784 if (elf_section_data (sec)->this_hdr.contents != NULL)
1785 contents = elf_section_data (sec)->this_hdr.contents;
1786 else
1787 {
1788 contents = (bfd_byte *) bfd_malloc (sec->size);
1789 if (contents == NULL)
1790 goto error_return;
1791 free_contents = contents;
1792
1793 if (!bfd_get_section_contents (abfd, sec, contents,
1794 (file_ptr) 0, sec->size))
1795 goto error_return;
1796 elf_section_data (sec)->this_hdr.contents = contents;
1797 }
1798 }
1799
1800 /* Get the value of the symbol referred to by the reloc. */
1801 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1802 {
1803 /* A local symbol. */
1804 asection *sym_sec;
1805
1806 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1807 if (isym->st_shndx == SHN_UNDEF)
1808 sym_sec = bfd_und_section_ptr;
1809 else if (isym->st_shndx == SHN_ABS)
1810 sym_sec = bfd_abs_section_ptr;
1811 else if (isym->st_shndx == SHN_COMMON)
1812 sym_sec = bfd_com_section_ptr;
1813 else
1814 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1815
1816 symval = _bfd_elf_rela_local_sym (abfd, isym, &sym_sec, irel);
1817 }
1818 else
1819 {
1820 unsigned long indx;
1821 struct elf_link_hash_entry *h;
1822
1823 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1824 h = elf_sym_hashes (abfd)[indx];
1825 BFD_ASSERT (h != NULL);
1826
1827 if (h->root.type != bfd_link_hash_defined
1828 && h->root.type != bfd_link_hash_defweak)
1829 /* This appears to be a reference to an undefined
1830 symbol. Just ignore it--it will be caught by the
1831 regular reloc processing. */
1832 continue;
1833
1834 symval = (h->root.u.def.value
1835 + h->root.u.def.section->output_section->vma
1836 + h->root.u.def.section->output_offset);
1837 }
1838
1839 /* If this is a PC-relative reloc, subtract the instr offset from
1840 the symbol value. */
1841 if (ELF32_R_TYPE (irel->r_info) == (int) R_MICROBLAZE_64_PCREL)
1842 {
1843 symval = symval + irel->r_addend
1844 - (irel->r_offset
1845 + sec->output_section->vma
1846 + sec->output_offset);
1847 }
1848 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MICROBLAZE_TEXTREL_64)
1849 {
1850 symval = symval + irel->r_addend - (sec->output_section->vma);
1851 }
1852 else
1853 symval += irel->r_addend;
1854
1855 if ((symval & 0xffff8000) == 0
1856 || (symval & 0xffff8000) == 0xffff8000)
1857 {
1858 /* We can delete this instruction. */
1859 sec->relax[sec->relax_count].addr = irel->r_offset;
1860 sec->relax[sec->relax_count].size = INST_WORD_SIZE;
1861 sec->relax_count++;
1862
1863 /* Rewrite relocation type. */
1864 switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1865 {
1866 case R_MICROBLAZE_64_PCREL:
1867 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1868 (int) R_MICROBLAZE_32_PCREL_LO);
1869 break;
1870 case R_MICROBLAZE_64:
1871 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1872 (int) R_MICROBLAZE_32_LO);
1873 break;
1874 case R_MICROBLAZE_TEXTREL_64:
1875 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1876 (int) R_MICROBLAZE_TEXTREL_32_LO);
1877 break;
1878 default:
1879 /* Cannot happen. */
1880 BFD_ASSERT (FALSE);
1881 }
1882 }
1883 } /* Loop through all relocations. */
1884
1885 /* Loop through the relocs again, and see if anything needs to change. */
1886 if (sec->relax_count > 0)
1887 {
1888 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1889 rel_count = 0;
1890 sec->relax[sec->relax_count].addr = sec->size;
1891
1892 for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1893 {
1894 bfd_vma nraddr;
1895
1896 /* Get the new reloc address. */
1897 nraddr = irel->r_offset - calc_fixup (irel->r_offset, 0, sec);
1898 switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1899 {
1900 default:
1901 break;
1902 case R_MICROBLAZE_64_PCREL:
1903 break;
1904 case R_MICROBLAZE_TEXTREL_64:
1905 case R_MICROBLAZE_TEXTREL_32_LO:
1906 case R_MICROBLAZE_64:
1907 case R_MICROBLAZE_32_LO:
1908 /* If this reloc is against a symbol defined in this
1909 section, we must check the addend to see it will put the value in
1910 range to be adjusted, and hence must be changed. */
1911 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1912 {
1913 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1914 /* Only handle relocs against .text. */
1915 if (isym->st_shndx == shndx
1916 && ELF32_ST_TYPE (isym->st_info) == STT_SECTION)
1917 irel->r_addend -= calc_fixup (irel->r_addend, 0, sec);
1918 }
1919 break;
1920 case R_MICROBLAZE_NONE:
1921 {
1922 /* This was a PC-relative instruction that was
1923 completely resolved. */
1924 int sfix, efix;
1925 bfd_vma target_address;
1926 target_address = irel->r_addend + irel->r_offset;
1927 sfix = calc_fixup (irel->r_offset, 0, sec);
1928 efix = calc_fixup (target_address, 0, sec);
1929 irel->r_addend -= (efix - sfix);
1930 /* Should use HOWTO. */
1931 microblaze_bfd_write_imm_value_32 (abfd, contents + irel->r_offset,
1932 irel->r_addend);
1933 }
1934 break;
1935 case R_MICROBLAZE_64_NONE:
1936 {
1937 /* This was a PC-relative 64-bit instruction that was
1938 completely resolved. */
1939 int sfix, efix;
1940 bfd_vma target_address;
1941 target_address = irel->r_addend + irel->r_offset + INST_WORD_SIZE;
1942 sfix = calc_fixup (irel->r_offset + INST_WORD_SIZE, 0, sec);
1943 efix = calc_fixup (target_address, 0, sec);
1944 irel->r_addend -= (efix - sfix);
1945 microblaze_bfd_write_imm_value_32 (abfd, contents + irel->r_offset
1946 + INST_WORD_SIZE, irel->r_addend);
1947 }
1948 break;
1949 }
1950 irel->r_offset = nraddr;
1951 } /* Change all relocs in this section. */
1952
1953 /* Look through all other sections. */
1954 for (o = abfd->sections; o != NULL; o = o->next)
1955 {
1956 Elf_Internal_Rela *irelocs;
1957 Elf_Internal_Rela *irelscan, *irelscanend;
1958 bfd_byte *ocontents;
1959
1960 if (o == sec
1961 || (o->flags & SEC_RELOC) == 0
1962 || o->reloc_count == 0)
1963 continue;
1964
1965 /* We always cache the relocs. Perhaps, if info->keep_memory is
1966 FALSE, we should free them, if we are permitted to. */
1967
1968 irelocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, TRUE);
1969 if (irelocs == NULL)
1970 goto error_return;
1971
1972 ocontents = NULL;
1973 irelscanend = irelocs + o->reloc_count;
1974 for (irelscan = irelocs; irelscan < irelscanend; irelscan++)
1975 {
1976 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32)
1977 {
1978 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1979
1980 /* Look at the reloc only if the value has been resolved. */
1981 if (isym->st_shndx == shndx
1982 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1983 {
1984 if (ocontents == NULL)
1985 {
1986 if (elf_section_data (o)->this_hdr.contents != NULL)
1987 ocontents = elf_section_data (o)->this_hdr.contents;
1988 else
1989 {
1990 /* We always cache the section contents.
1991 Perhaps, if info->keep_memory is FALSE, we
1992 should free them, if we are permitted to. */
1993 if (o->rawsize == 0)
1994 o->rawsize = o->size;
1995 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1996 if (ocontents == NULL)
1997 goto error_return;
1998 if (!bfd_get_section_contents (abfd, o, ocontents,
1999 (file_ptr) 0,
2000 o->rawsize))
2001 goto error_return;
2002 elf_section_data (o)->this_hdr.contents = ocontents;
2003 }
2004
2005 }
2006 irelscan->r_addend -= calc_fixup (irelscan->r_addend, 0, sec);
2007 }
2008 else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_SYM_OP_SYM)
2009 {
2010 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2011
2012 /* Look at the reloc only if the value has been resolved. */
2013 if (ocontents == NULL)
2014 {
2015 if (elf_section_data (o)->this_hdr.contents != NULL)
2016 ocontents = elf_section_data (o)->this_hdr.contents;
2017 else
2018 {
2019 /* We always cache the section contents.
2020 Perhaps, if info->keep_memory is FALSE, we
2021 should free them, if we are permitted to. */
2022
2023 if (o->rawsize == 0)
2024 o->rawsize = o->size;
2025 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2026 if (ocontents == NULL)
2027 goto error_return;
2028 if (!bfd_get_section_contents (abfd, o, ocontents,
2029 (file_ptr) 0,
2030 o->rawsize))
2031 goto error_return;
2032 elf_section_data (o)->this_hdr.contents = ocontents;
2033 }
2034 }
2035 irelscan->r_addend -= calc_fixup (irel->r_addend
2036 + isym->st_value,
2037 0,
2038 sec);
2039 }
2040 }
2041 else if ((ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_PCREL_LO)
2042 || (ELF32_R_TYPE (irelscan->r_info)
2043 == (int) R_MICROBLAZE_32_LO)
2044 || (ELF32_R_TYPE (irelscan->r_info)
2045 == (int) R_MICROBLAZE_TEXTREL_32_LO))
2046 {
2047 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2048
2049 /* Look at the reloc only if the value has been resolved. */
2050 if (isym->st_shndx == shndx
2051 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
2052 {
2053 bfd_vma immediate;
2054 bfd_vma target_address;
2055
2056 if (ocontents == NULL)
2057 {
2058 if (elf_section_data (o)->this_hdr.contents != NULL)
2059 ocontents = elf_section_data (o)->this_hdr.contents;
2060 else
2061 {
2062 /* We always cache the section contents.
2063 Perhaps, if info->keep_memory is FALSE, we
2064 should free them, if we are permitted to. */
2065 if (o->rawsize == 0)
2066 o->rawsize = o->size;
2067 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2068 if (ocontents == NULL)
2069 goto error_return;
2070 if (!bfd_get_section_contents (abfd, o, ocontents,
2071 (file_ptr) 0,
2072 o->rawsize))
2073 goto error_return;
2074 elf_section_data (o)->this_hdr.contents = ocontents;
2075 }
2076 }
2077
2078 unsigned long instr = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
2079 immediate = instr & 0x0000ffff;
2080 target_address = immediate;
2081 offset = calc_fixup (target_address, 0, sec);
2082 immediate -= offset;
2083 irelscan->r_addend -= offset;
2084 microblaze_bfd_write_imm_value_32 (abfd, ocontents + irelscan->r_offset,
2085 irelscan->r_addend);
2086 }
2087 }
2088
2089 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64
2090 || (ELF32_R_TYPE (irelscan->r_info)
2091 == (int) R_MICROBLAZE_TEXTREL_64))
2092 {
2093 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2094
2095 /* Look at the reloc only if the value has been resolved. */
2096 if (isym->st_shndx == shndx
2097 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
2098 {
2099 bfd_vma immediate;
2100
2101 if (ocontents == NULL)
2102 {
2103 if (elf_section_data (o)->this_hdr.contents != NULL)
2104 ocontents = elf_section_data (o)->this_hdr.contents;
2105 else
2106 {
2107 /* We always cache the section contents.
2108 Perhaps, if info->keep_memory is FALSE, we
2109 should free them, if we are permitted to. */
2110
2111 if (o->rawsize == 0)
2112 o->rawsize = o->size;
2113 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2114 if (ocontents == NULL)
2115 goto error_return;
2116 if (!bfd_get_section_contents (abfd, o, ocontents,
2117 (file_ptr) 0,
2118 o->rawsize))
2119 goto error_return;
2120 elf_section_data (o)->this_hdr.contents = ocontents;
2121 }
2122 }
2123 unsigned long instr_hi = bfd_get_32 (abfd, ocontents
2124 + irelscan->r_offset);
2125 unsigned long instr_lo = bfd_get_32 (abfd, ocontents
2126 + irelscan->r_offset
2127 + INST_WORD_SIZE);
2128 immediate = (instr_hi & 0x0000ffff) << 16;
2129 immediate |= (instr_lo & 0x0000ffff);
2130 offset = calc_fixup (irelscan->r_addend, 0, sec);
2131 immediate -= offset;
2132 irelscan->r_addend -= offset;
2133 }
2134 }
2135 else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64_PCREL)
2136 {
2137 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2138
2139 /* Look at the reloc only if the value has been resolved. */
2140 if (isym->st_shndx == shndx
2141 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
2142 {
2143 bfd_vma immediate;
2144 bfd_vma target_address;
2145
2146 if (ocontents == NULL)
2147 {
2148 if (elf_section_data (o)->this_hdr.contents != NULL)
2149 ocontents = elf_section_data (o)->this_hdr.contents;
2150 else
2151 {
2152 /* We always cache the section contents.
2153 Perhaps, if info->keep_memory is FALSE, we
2154 should free them, if we are permitted to. */
2155 if (o->rawsize == 0)
2156 o->rawsize = o->size;
2157 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2158 if (ocontents == NULL)
2159 goto error_return;
2160 if (!bfd_get_section_contents (abfd, o, ocontents,
2161 (file_ptr) 0,
2162 o->rawsize))
2163 goto error_return;
2164 elf_section_data (o)->this_hdr.contents = ocontents;
2165 }
2166 }
2167 unsigned long instr_hi = bfd_get_32 (abfd, ocontents
2168 + irelscan->r_offset);
2169 unsigned long instr_lo = bfd_get_32 (abfd, ocontents
2170 + irelscan->r_offset
2171 + INST_WORD_SIZE);
2172 immediate = (instr_hi & 0x0000ffff) << 16;
2173 immediate |= (instr_lo & 0x0000ffff);
2174 target_address = immediate;
2175 offset = calc_fixup (target_address, 0, sec);
2176 immediate -= offset;
2177 irelscan->r_addend -= offset;
2178 microblaze_bfd_write_imm_value_64 (abfd, ocontents
2179 + irelscan->r_offset, immediate);
2180 }
2181 }
2182 }
2183 }
2184
2185 /* Adjust the local symbols defined in this section. */
2186 isymend = isymbuf + symtab_hdr->sh_info;
2187 for (isym = isymbuf; isym < isymend; isym++)
2188 {
2189 if (isym->st_shndx == shndx)
2190 {
2191 isym->st_value -= calc_fixup (isym->st_value, 0, sec);
2192 if (isym->st_size)
2193 isym->st_size -= calc_fixup (isym->st_value, isym->st_size, sec);
2194 }
2195 }
2196
2197 /* Now adjust the global symbols defined in this section. */
2198 isym = isymbuf + symtab_hdr->sh_info;
2199 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)) - symtab_hdr->sh_info;
2200 for (sym_index = 0; sym_index < symcount; sym_index++)
2201 {
2202 sym_hash = elf_sym_hashes (abfd)[sym_index];
2203 if ((sym_hash->root.type == bfd_link_hash_defined
2204 || sym_hash->root.type == bfd_link_hash_defweak)
2205 && sym_hash->root.u.def.section == sec)
2206 {
2207 sym_hash->root.u.def.value -= calc_fixup (sym_hash->root.u.def.value,
2208 0, sec);
2209 if (sym_hash->size)
2210 sym_hash->size -= calc_fixup (sym_hash->root.u.def.value,
2211 sym_hash->size, sec);
2212 }
2213 }
2214
2215 /* Physically move the code and change the cooked size. */
2216 dest = sec->relax[0].addr;
2217 for (i = 0; i < sec->relax_count; i++)
2218 {
2219 int len;
2220 src = sec->relax[i].addr + sec->relax[i].size;
2221 len = sec->relax[i+1].addr - sec->relax[i].addr - sec->relax[i].size;
2222
2223 memmove (contents + dest, contents + src, len);
2224 sec->size -= sec->relax[i].size;
2225 dest += len;
2226 }
2227
2228 elf_section_data (sec)->relocs = internal_relocs;
2229 free_relocs = NULL;
2230
2231 elf_section_data (sec)->this_hdr.contents = contents;
2232 free_contents = NULL;
2233
2234 symtab_hdr->contents = (bfd_byte *) isymbuf;
2235 }
2236
2237 if (free_relocs != NULL)
2238 {
2239 free (free_relocs);
2240 free_relocs = NULL;
2241 }
2242
2243 if (free_contents != NULL)
2244 {
2245 if (!link_info->keep_memory)
2246 free (free_contents);
2247 else
2248 /* Cache the section contents for elf_link_input_bfd. */
2249 elf_section_data (sec)->this_hdr.contents = contents;
2250 free_contents = NULL;
2251 }
2252
2253 if (sec->relax_count == 0)
2254 {
2255 *again = FALSE;
2256 free (sec->relax);
2257 sec->relax = NULL;
2258 }
2259 else
2260 *again = TRUE;
2261 return TRUE;
2262
2263 error_return:
2264 if (free_relocs != NULL)
2265 free (free_relocs);
2266 if (free_contents != NULL)
2267 free (free_contents);
2268 if (sec->relax != NULL)
2269 {
2270 free (sec->relax);
2271 sec->relax = NULL;
2272 sec->relax_count = 0;
2273 }
2274 return FALSE;
2275 }
2276
2277 /* Return the section that should be marked against GC for a given
2278 relocation. */
2279
2280 static asection *
2281 microblaze_elf_gc_mark_hook (asection *sec,
2282 struct bfd_link_info * info,
2283 Elf_Internal_Rela * rel,
2284 struct elf_link_hash_entry * h,
2285 Elf_Internal_Sym * sym)
2286 {
2287 if (h != NULL)
2288 switch (ELF32_R_TYPE (rel->r_info))
2289 {
2290 case R_MICROBLAZE_GNU_VTINHERIT:
2291 case R_MICROBLAZE_GNU_VTENTRY:
2292 return NULL;
2293 }
2294
2295 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2296 }
2297
2298 /* PIC support. */
2299
2300 #define PLT_ENTRY_SIZE 16
2301
2302 #define PLT_ENTRY_WORD_0 0xb0000000 /* "imm 0". */
2303 #define PLT_ENTRY_WORD_1 0xe9940000 /* "lwi r12,r20,0" - relocated to lwi r12,r20,func@GOT. */
2304 #define PLT_ENTRY_WORD_1_NOPIC 0xe9800000 /* "lwi r12,r0,0" - non-PIC object. */
2305 #define PLT_ENTRY_WORD_2 0x98186000 /* "brad r12". */
2306 #define PLT_ENTRY_WORD_3 0x80000000 /* "nop". */
2307
2308 static bfd_boolean
2309 update_local_sym_info (bfd *abfd,
2310 Elf_Internal_Shdr *symtab_hdr,
2311 unsigned long r_symndx,
2312 unsigned int tls_type)
2313 {
2314 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
2315 unsigned char *local_got_tls_masks;
2316
2317 if (local_got_refcounts == NULL)
2318 {
2319 bfd_size_type size = symtab_hdr->sh_info;
2320
2321 size *= (sizeof (*local_got_refcounts) + sizeof (*local_got_tls_masks));
2322 local_got_refcounts = bfd_zalloc (abfd, size);
2323 if (local_got_refcounts == NULL)
2324 return FALSE;
2325 elf_local_got_refcounts (abfd) = local_got_refcounts;
2326 }
2327
2328 local_got_tls_masks =
2329 (unsigned char *) (local_got_refcounts + symtab_hdr->sh_info);
2330 local_got_tls_masks[r_symndx] |= tls_type;
2331 local_got_refcounts[r_symndx] += 1;
2332
2333 return TRUE;
2334 }
2335 /* Look through the relocs for a section during the first phase. */
2336
2337 static bfd_boolean
2338 microblaze_elf_check_relocs (bfd * abfd,
2339 struct bfd_link_info * info,
2340 asection * sec,
2341 const Elf_Internal_Rela * relocs)
2342 {
2343 Elf_Internal_Shdr * symtab_hdr;
2344 struct elf_link_hash_entry ** sym_hashes;
2345 struct elf_link_hash_entry ** sym_hashes_end;
2346 const Elf_Internal_Rela * rel;
2347 const Elf_Internal_Rela * rel_end;
2348 struct elf32_mb_link_hash_table *htab;
2349 asection *sreloc = NULL;
2350
2351 if (bfd_link_relocatable (info))
2352 return TRUE;
2353
2354 htab = elf32_mb_hash_table (info);
2355 if (htab == NULL)
2356 return FALSE;
2357
2358 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2359 sym_hashes = elf_sym_hashes (abfd);
2360 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2361 if (!elf_bad_symtab (abfd))
2362 sym_hashes_end -= symtab_hdr->sh_info;
2363
2364 rel_end = relocs + sec->reloc_count;
2365
2366 for (rel = relocs; rel < rel_end; rel++)
2367 {
2368 unsigned int r_type;
2369 struct elf_link_hash_entry * h;
2370 unsigned long r_symndx;
2371 unsigned char tls_type = 0;
2372
2373 r_symndx = ELF32_R_SYM (rel->r_info);
2374 r_type = ELF32_R_TYPE (rel->r_info);
2375
2376 if (r_symndx < symtab_hdr->sh_info)
2377 h = NULL;
2378 else
2379 {
2380 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
2381 while (h->root.type == bfd_link_hash_indirect
2382 || h->root.type == bfd_link_hash_warning)
2383 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2384 }
2385
2386 switch (r_type)
2387 {
2388 /* This relocation describes the C++ object vtable hierarchy.
2389 Reconstruct it for later use during GC. */
2390 case R_MICROBLAZE_GNU_VTINHERIT:
2391 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2392 return FALSE;
2393 break;
2394
2395 /* This relocation describes which C++ vtable entries are actually
2396 used. Record for later use during GC. */
2397 case R_MICROBLAZE_GNU_VTENTRY:
2398 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2399 return FALSE;
2400 break;
2401
2402 /* This relocation requires .plt entry. */
2403 case R_MICROBLAZE_PLT_64:
2404 if (h != NULL)
2405 {
2406 h->needs_plt = 1;
2407 h->plt.refcount += 1;
2408 }
2409 break;
2410
2411 /* This relocation requires .got entry. */
2412 case R_MICROBLAZE_TLSGD:
2413 tls_type |= (TLS_TLS | TLS_GD);
2414 goto dogottls;
2415 case R_MICROBLAZE_TLSLD:
2416 tls_type |= (TLS_TLS | TLS_LD);
2417 /* Fall through. */
2418 dogottls:
2419 sec->has_tls_reloc = 1;
2420 /* Fall through. */
2421 case R_MICROBLAZE_GOT_64:
2422 if (htab->elf.sgot == NULL)
2423 {
2424 if (htab->elf.dynobj == NULL)
2425 htab->elf.dynobj = abfd;
2426 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2427 return FALSE;
2428 }
2429 if (h != NULL)
2430 {
2431 h->got.refcount += 1;
2432 elf32_mb_hash_entry (h)->tls_mask |= tls_type;
2433 }
2434 else
2435 {
2436 if (! update_local_sym_info(abfd, symtab_hdr, r_symndx, tls_type) )
2437 return FALSE;
2438 }
2439 break;
2440
2441 case R_MICROBLAZE_GOTOFF_64:
2442 case R_MICROBLAZE_GOTOFF_32:
2443 if (htab->elf.sgot == NULL)
2444 {
2445 if (htab->elf.dynobj == NULL)
2446 htab->elf.dynobj = abfd;
2447 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2448 return FALSE;
2449 }
2450 break;
2451
2452 case R_MICROBLAZE_64:
2453 case R_MICROBLAZE_64_PCREL:
2454 case R_MICROBLAZE_32:
2455 {
2456 if (h != NULL && !bfd_link_pic (info))
2457 {
2458 /* we may need a copy reloc. */
2459 h->non_got_ref = 1;
2460
2461 /* we may also need a .plt entry. */
2462 h->plt.refcount += 1;
2463 if (ELF32_R_TYPE (rel->r_info) != R_MICROBLAZE_64_PCREL)
2464 h->pointer_equality_needed = 1;
2465 }
2466
2467
2468 /* If we are creating a shared library, and this is a reloc
2469 against a global symbol, or a non PC relative reloc
2470 against a local symbol, then we need to copy the reloc
2471 into the shared library. However, if we are linking with
2472 -Bsymbolic, we do not need to copy a reloc against a
2473 global symbol which is defined in an object we are
2474 including in the link (i.e., DEF_REGULAR is set). At
2475 this point we have not seen all the input files, so it is
2476 possible that DEF_REGULAR is not set now but will be set
2477 later (it is never cleared). In case of a weak definition,
2478 DEF_REGULAR may be cleared later by a strong definition in
2479 a shared library. We account for that possibility below by
2480 storing information in the relocs_copied field of the hash
2481 table entry. A similar situation occurs when creating
2482 shared libraries and symbol visibility changes render the
2483 symbol local.
2484
2485 If on the other hand, we are creating an executable, we
2486 may need to keep relocations for symbols satisfied by a
2487 dynamic library if we manage to avoid copy relocs for the
2488 symbol. */
2489
2490 if ((bfd_link_pic (info)
2491 && (sec->flags & SEC_ALLOC) != 0
2492 && (r_type != R_MICROBLAZE_64_PCREL
2493 || (h != NULL
2494 && (! info->symbolic
2495 || h->root.type == bfd_link_hash_defweak
2496 || !h->def_regular))))
2497 || (!bfd_link_pic (info)
2498 && (sec->flags & SEC_ALLOC) != 0
2499 && h != NULL
2500 && (h->root.type == bfd_link_hash_defweak
2501 || !h->def_regular)))
2502 {
2503 struct elf_dyn_relocs *p;
2504 struct elf_dyn_relocs **head;
2505
2506 /* When creating a shared object, we must copy these
2507 relocs into the output file. We create a reloc
2508 section in dynobj and make room for the reloc. */
2509
2510 if (sreloc == NULL)
2511 {
2512 bfd *dynobj;
2513
2514 if (htab->elf.dynobj == NULL)
2515 htab->elf.dynobj = abfd;
2516 dynobj = htab->elf.dynobj;
2517
2518 sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj,
2519 2, abfd, 1);
2520 if (sreloc == NULL)
2521 return FALSE;
2522 }
2523
2524 /* If this is a global symbol, we count the number of
2525 relocations we need for this symbol. */
2526 if (h != NULL)
2527 head = &((struct elf32_mb_link_hash_entry *) h)->dyn_relocs;
2528 else
2529 {
2530 /* Track dynamic relocs needed for local syms too.
2531 We really need local syms available to do this
2532 easily. Oh well. */
2533
2534 asection *s;
2535 Elf_Internal_Sym *isym;
2536 void *vpp;
2537
2538 isym = bfd_sym_from_r_symndx (&htab->sym_sec,
2539 abfd, r_symndx);
2540 if (isym == NULL)
2541 return FALSE;
2542
2543 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2544 if (s == NULL)
2545 return FALSE;
2546
2547 vpp = &elf_section_data (s)->local_dynrel;
2548 head = (struct elf_dyn_relocs **) vpp;
2549 }
2550
2551 p = *head;
2552 if (p == NULL || p->sec != sec)
2553 {
2554 bfd_size_type amt = sizeof *p;
2555 p = ((struct elf_dyn_relocs *)
2556 bfd_alloc (htab->elf.dynobj, amt));
2557 if (p == NULL)
2558 return FALSE;
2559 p->next = *head;
2560 *head = p;
2561 p->sec = sec;
2562 p->count = 0;
2563 p->pc_count = 0;
2564 }
2565
2566 p->count += 1;
2567 if (r_type == R_MICROBLAZE_64_PCREL)
2568 p->pc_count += 1;
2569 }
2570 }
2571 break;
2572 }
2573 }
2574
2575 return TRUE;
2576 }
2577
2578 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2579
2580 static void
2581 microblaze_elf_copy_indirect_symbol (struct bfd_link_info *info,
2582 struct elf_link_hash_entry *dir,
2583 struct elf_link_hash_entry *ind)
2584 {
2585 struct elf32_mb_link_hash_entry *edir, *eind;
2586
2587 edir = (struct elf32_mb_link_hash_entry *) dir;
2588 eind = (struct elf32_mb_link_hash_entry *) ind;
2589
2590 if (eind->dyn_relocs != NULL)
2591 {
2592 if (edir->dyn_relocs != NULL)
2593 {
2594 struct elf_dyn_relocs **pp;
2595 struct elf_dyn_relocs *p;
2596
2597 if (ind->root.type == bfd_link_hash_indirect)
2598 abort ();
2599
2600 /* Add reloc counts against the weak sym to the strong sym
2601 list. Merge any entries against the same section. */
2602 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2603 {
2604 struct elf_dyn_relocs *q;
2605
2606 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2607 if (q->sec == p->sec)
2608 {
2609 q->pc_count += p->pc_count;
2610 q->count += p->count;
2611 *pp = p->next;
2612 break;
2613 }
2614 if (q == NULL)
2615 pp = &p->next;
2616 }
2617 *pp = edir->dyn_relocs;
2618 }
2619
2620 edir->dyn_relocs = eind->dyn_relocs;
2621 eind->dyn_relocs = NULL;
2622 }
2623
2624 edir->tls_mask |= eind->tls_mask;
2625
2626 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2627 }
2628
2629 /* Find dynamic relocs for H that apply to read-only sections. */
2630
2631 static asection *
2632 readonly_dynrelocs (struct elf_link_hash_entry *h)
2633 {
2634 struct elf_dyn_relocs *p;
2635
2636 for (p = elf32_mb_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
2637 {
2638 asection *s = p->sec->output_section;
2639
2640 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2641 return p->sec;
2642 }
2643 return NULL;
2644 }
2645
2646 static bfd_boolean
2647 microblaze_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2648 struct elf_link_hash_entry *h)
2649 {
2650 struct elf32_mb_link_hash_table *htab;
2651 asection *s, *srel;
2652 unsigned int power_of_two;
2653
2654 htab = elf32_mb_hash_table (info);
2655 if (htab == NULL)
2656 return FALSE;
2657
2658 /* If this is a function, put it in the procedure linkage table. We
2659 will fill in the contents of the procedure linkage table later,
2660 when we know the address of the .got section. */
2661 if (h->type == STT_FUNC
2662 || h->needs_plt)
2663 {
2664 if (h->plt.refcount <= 0
2665 || SYMBOL_CALLS_LOCAL (info, h)
2666 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2667 && h->root.type == bfd_link_hash_undefweak))
2668 {
2669 /* This case can occur if we saw a PLT reloc in an input
2670 file, but the symbol was never referred to by a dynamic
2671 object, or if all references were garbage collected. In
2672 such a case, we don't actually need to build a procedure
2673 linkage table, and we can just do a PC32 reloc instead. */
2674 h->plt.offset = (bfd_vma) -1;
2675 h->needs_plt = 0;
2676 }
2677
2678 return TRUE;
2679 }
2680 else
2681 /* It's possible that we incorrectly decided a .plt reloc was
2682 needed for an R_MICROBLAZE_64_PCREL reloc to a non-function sym in
2683 check_relocs. We can't decide accurately between function and
2684 non-function syms in check-relocs; Objects loaded later in
2685 the link may change h->type. So fix it now. */
2686 h->plt.offset = (bfd_vma) -1;
2687
2688 /* If this is a weak symbol, and there is a real definition, the
2689 processor independent code will have arranged for us to see the
2690 real definition first, and we can just use the same value. */
2691 if (h->is_weakalias)
2692 {
2693 struct elf_link_hash_entry *def = weakdef (h);
2694 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2695 h->root.u.def.section = def->root.u.def.section;
2696 h->root.u.def.value = def->root.u.def.value;
2697 return TRUE;
2698 }
2699
2700 /* This is a reference to a symbol defined by a dynamic object which
2701 is not a function. */
2702
2703 /* If we are creating a shared library, we must presume that the
2704 only references to the symbol are via the global offset table.
2705 For such cases we need not do anything here; the relocations will
2706 be handled correctly by relocate_section. */
2707 if (bfd_link_pic (info))
2708 return TRUE;
2709
2710 /* If there are no references to this symbol that do not use the
2711 GOT, we don't need to generate a copy reloc. */
2712 if (!h->non_got_ref)
2713 return TRUE;
2714
2715 /* If -z nocopyreloc was given, we won't generate them either. */
2716 if (info->nocopyreloc)
2717 {
2718 h->non_got_ref = 0;
2719 return TRUE;
2720 }
2721
2722 /* If we don't find any dynamic relocs in read-only sections, then
2723 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2724 if (!readonly_dynrelocs (h))
2725 {
2726 h->non_got_ref = 0;
2727 return TRUE;
2728 }
2729
2730 /* We must allocate the symbol in our .dynbss section, which will
2731 become part of the .bss section of the executable. There will be
2732 an entry for this symbol in the .dynsym section. The dynamic
2733 object will contain position independent code, so all references
2734 from the dynamic object to this symbol will go through the global
2735 offset table. The dynamic linker will use the .dynsym entry to
2736 determine the address it must put in the global offset table, so
2737 both the dynamic object and the regular object will refer to the
2738 same memory location for the variable. */
2739
2740 /* We must generate a R_MICROBLAZE_COPY reloc to tell the dynamic linker
2741 to copy the initial value out of the dynamic object and into the
2742 runtime process image. */
2743 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2744 {
2745 s = htab->elf.sdynrelro;
2746 srel = htab->elf.sreldynrelro;
2747 }
2748 else
2749 {
2750 s = htab->elf.sdynbss;
2751 srel = htab->elf.srelbss;
2752 }
2753 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2754 {
2755 srel->size += sizeof (Elf32_External_Rela);
2756 h->needs_copy = 1;
2757 }
2758
2759 /* We need to figure out the alignment required for this symbol. I
2760 have no idea how ELF linkers handle this. */
2761 power_of_two = bfd_log2 (h->size);
2762 if (power_of_two > 3)
2763 power_of_two = 3;
2764
2765 /* Apply the required alignment. */
2766 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
2767 if (power_of_two > s->alignment_power)
2768 {
2769 if (!bfd_set_section_alignment (s, power_of_two))
2770 return FALSE;
2771 }
2772
2773 /* Define the symbol as being at this point in the section. */
2774 h->root.u.def.section = s;
2775 h->root.u.def.value = s->size;
2776
2777 /* Increment the section size to make room for the symbol. */
2778 s->size += h->size;
2779 return TRUE;
2780 }
2781
2782 /* Allocate space in .plt, .got and associated reloc sections for
2783 dynamic relocs. */
2784
2785 static bfd_boolean
2786 allocate_dynrelocs (struct elf_link_hash_entry *h, void * dat)
2787 {
2788 struct bfd_link_info *info;
2789 struct elf32_mb_link_hash_table *htab;
2790 struct elf32_mb_link_hash_entry *eh;
2791 struct elf_dyn_relocs *p;
2792
2793 if (h->root.type == bfd_link_hash_indirect)
2794 return TRUE;
2795
2796 info = (struct bfd_link_info *) dat;
2797 htab = elf32_mb_hash_table (info);
2798 if (htab == NULL)
2799 return FALSE;
2800
2801 if (htab->elf.dynamic_sections_created
2802 && h->plt.refcount > 0)
2803 {
2804 /* Make sure this symbol is output as a dynamic symbol.
2805 Undefined weak syms won't yet be marked as dynamic. */
2806 if (h->dynindx == -1
2807 && !h->forced_local)
2808 {
2809 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2810 return FALSE;
2811 }
2812
2813 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
2814 {
2815 asection *s = htab->elf.splt;
2816
2817 /* The first entry in .plt is reserved. */
2818 if (s->size == 0)
2819 s->size = PLT_ENTRY_SIZE;
2820
2821 h->plt.offset = s->size;
2822
2823 /* If this symbol is not defined in a regular file, and we are
2824 not generating a shared library, then set the symbol to this
2825 location in the .plt. This is required to make function
2826 pointers compare as equal between the normal executable and
2827 the shared library. */
2828 if (! bfd_link_pic (info)
2829 && !h->def_regular)
2830 {
2831 h->root.u.def.section = s;
2832 h->root.u.def.value = h->plt.offset;
2833 }
2834
2835 /* Make room for this entry. */
2836 s->size += PLT_ENTRY_SIZE;
2837
2838 /* We also need to make an entry in the .got.plt section, which
2839 will be placed in the .got section by the linker script. */
2840 htab->elf.sgotplt->size += 4;
2841
2842 /* We also need to make an entry in the .rel.plt section. */
2843 htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
2844 }
2845 else
2846 {
2847 h->plt.offset = (bfd_vma) -1;
2848 h->needs_plt = 0;
2849 }
2850 }
2851 else
2852 {
2853 h->plt.offset = (bfd_vma) -1;
2854 h->needs_plt = 0;
2855 }
2856
2857 eh = (struct elf32_mb_link_hash_entry *) h;
2858 if (h->got.refcount > 0)
2859 {
2860 unsigned int need;
2861 asection *s;
2862
2863 /* Make sure this symbol is output as a dynamic symbol.
2864 Undefined weak syms won't yet be marked as dynamic. */
2865 if (h->dynindx == -1
2866 && !h->forced_local)
2867 {
2868 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2869 return FALSE;
2870 }
2871
2872 need = 0;
2873 if ((eh->tls_mask & TLS_TLS) != 0)
2874 {
2875 /* Handle TLS Symbol */
2876 if ((eh->tls_mask & TLS_LD) != 0)
2877 {
2878 if (!eh->elf.def_dynamic)
2879 /* We'll just use htab->tlsld_got.offset. This should
2880 always be the case. It's a little odd if we have
2881 a local dynamic reloc against a non-local symbol. */
2882 htab->tlsld_got.refcount += 1;
2883 else
2884 need += 8;
2885 }
2886 if ((eh->tls_mask & TLS_GD) != 0)
2887 need += 8;
2888 }
2889 else
2890 {
2891 /* Regular (non-TLS) symbol */
2892 need += 4;
2893 }
2894 if (need == 0)
2895 {
2896 h->got.offset = (bfd_vma) -1;
2897 }
2898 else
2899 {
2900 s = htab->elf.sgot;
2901 h->got.offset = s->size;
2902 s->size += need;
2903 htab->elf.srelgot->size += need * (sizeof (Elf32_External_Rela) / 4);
2904 }
2905 }
2906 else
2907 h->got.offset = (bfd_vma) -1;
2908
2909 if (eh->dyn_relocs == NULL)
2910 return TRUE;
2911
2912 /* In the shared -Bsymbolic case, discard space allocated for
2913 dynamic pc-relative relocs against symbols which turn out to be
2914 defined in regular objects. For the normal shared case, discard
2915 space for pc-relative relocs that have become local due to symbol
2916 visibility changes. */
2917
2918 if (bfd_link_pic (info))
2919 {
2920 if (h->def_regular
2921 && (h->forced_local
2922 || info->symbolic))
2923 {
2924 struct elf_dyn_relocs **pp;
2925
2926 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2927 {
2928 p->count -= p->pc_count;
2929 p->pc_count = 0;
2930 if (p->count == 0)
2931 *pp = p->next;
2932 else
2933 pp = &p->next;
2934 }
2935 }
2936 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2937 eh->dyn_relocs = NULL;
2938 }
2939 else
2940 {
2941 /* For the non-shared case, discard space for relocs against
2942 symbols which turn out to need copy relocs or are not
2943 dynamic. */
2944
2945 if (!h->non_got_ref
2946 && ((h->def_dynamic
2947 && !h->def_regular)
2948 || (htab->elf.dynamic_sections_created
2949 && (h->root.type == bfd_link_hash_undefweak
2950 || h->root.type == bfd_link_hash_undefined))))
2951 {
2952 /* Make sure this symbol is output as a dynamic symbol.
2953 Undefined weak syms won't yet be marked as dynamic. */
2954 if (h->dynindx == -1
2955 && !h->forced_local)
2956 {
2957 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2958 return FALSE;
2959 }
2960
2961 /* If that succeeded, we know we'll be keeping all the
2962 relocs. */
2963 if (h->dynindx != -1)
2964 goto keep;
2965 }
2966
2967 eh->dyn_relocs = NULL;
2968
2969 keep: ;
2970 }
2971
2972 /* Finally, allocate space. */
2973 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2974 {
2975 asection *sreloc = elf_section_data (p->sec)->sreloc;
2976 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2977 }
2978
2979 return TRUE;
2980 }
2981
2982 /* Set the sizes of the dynamic sections. */
2983
2984 static bfd_boolean
2985 microblaze_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2986 struct bfd_link_info *info)
2987 {
2988 struct elf32_mb_link_hash_table *htab;
2989 bfd *dynobj;
2990 asection *s;
2991 bfd *ibfd;
2992
2993 htab = elf32_mb_hash_table (info);
2994 if (htab == NULL)
2995 return FALSE;
2996
2997 dynobj = htab->elf.dynobj;
2998 BFD_ASSERT (dynobj != NULL);
2999
3000 /* Set up .got offsets for local syms, and space for local dynamic
3001 relocs. */
3002 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3003 {
3004 bfd_signed_vma *local_got;
3005 bfd_signed_vma *end_local_got;
3006 bfd_size_type locsymcount;
3007 Elf_Internal_Shdr *symtab_hdr;
3008 unsigned char *lgot_masks;
3009 asection *srel;
3010
3011 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3012 continue;
3013
3014 for (s = ibfd->sections; s != NULL; s = s->next)
3015 {
3016 struct elf_dyn_relocs *p;
3017
3018 for (p = ((struct elf_dyn_relocs *)
3019 elf_section_data (s)->local_dynrel);
3020 p != NULL;
3021 p = p->next)
3022 {
3023 if (!bfd_is_abs_section (p->sec)
3024 && bfd_is_abs_section (p->sec->output_section))
3025 {
3026 /* Input section has been discarded, either because
3027 it is a copy of a linkonce section or due to
3028 linker script /DISCARD/, so we'll be discarding
3029 the relocs too. */
3030 }
3031 else if (p->count != 0)
3032 {
3033 srel = elf_section_data (p->sec)->sreloc;
3034 srel->size += p->count * sizeof (Elf32_External_Rela);
3035 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3036 info->flags |= DF_TEXTREL;
3037 }
3038 }
3039 }
3040
3041 local_got = elf_local_got_refcounts (ibfd);
3042 if (!local_got)
3043 continue;
3044
3045 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3046 locsymcount = symtab_hdr->sh_info;
3047 end_local_got = local_got + locsymcount;
3048 lgot_masks = (unsigned char *) end_local_got;
3049 s = htab->elf.sgot;
3050 srel = htab->elf.srelgot;
3051
3052 for (; local_got < end_local_got; ++local_got, ++lgot_masks)
3053 {
3054 if (*local_got > 0)
3055 {
3056 unsigned int need = 0;
3057 if ((*lgot_masks & TLS_TLS) != 0)
3058 {
3059 if ((*lgot_masks & TLS_GD) != 0)
3060 need += 8;
3061 if ((*lgot_masks & TLS_LD) != 0)
3062 htab->tlsld_got.refcount += 1;
3063 }
3064 else
3065 need += 4;
3066
3067 if (need == 0)
3068 {
3069 *local_got = (bfd_vma) -1;
3070 }
3071 else
3072 {
3073 *local_got = s->size;
3074 s->size += need;
3075 if (bfd_link_pic (info))
3076 srel->size += need * (sizeof (Elf32_External_Rela) / 4);
3077 }
3078 }
3079 else
3080 *local_got = (bfd_vma) -1;
3081 }
3082 }
3083
3084 /* Allocate global sym .plt and .got entries, and space for global
3085 sym dynamic relocs. */
3086 elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
3087
3088 if (htab->tlsld_got.refcount > 0)
3089 {
3090 htab->tlsld_got.offset = htab->elf.sgot->size;
3091 htab->elf.sgot->size += 8;
3092 if (bfd_link_pic (info))
3093 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
3094 }
3095 else
3096 htab->tlsld_got.offset = (bfd_vma) -1;
3097
3098 if (elf_hash_table (info)->dynamic_sections_created)
3099 {
3100 /* Make space for the trailing nop in .plt. */
3101 if (htab->elf.splt->size > 0)
3102 htab->elf.splt->size += 4;
3103 }
3104
3105 /* The check_relocs and adjust_dynamic_symbol entry points have
3106 determined the sizes of the various dynamic sections. Allocate
3107 memory for them. */
3108 for (s = dynobj->sections; s != NULL; s = s->next)
3109 {
3110 const char *name;
3111 bfd_boolean strip = FALSE;
3112
3113 if ((s->flags & SEC_LINKER_CREATED) == 0)
3114 continue;
3115
3116 /* It's OK to base decisions on the section name, because none
3117 of the dynobj section names depend upon the input files. */
3118 name = bfd_section_name (s);
3119
3120 if (strncmp (name, ".rela", 5) == 0)
3121 {
3122 if (s->size == 0)
3123 {
3124 /* If we don't need this section, strip it from the
3125 output file. This is to handle .rela.bss and
3126 .rela.plt. We must create it in
3127 create_dynamic_sections, because it must be created
3128 before the linker maps input sections to output
3129 sections. The linker does that before
3130 adjust_dynamic_symbol is called, and it is that
3131 function which decides whether anything needs to go
3132 into these sections. */
3133 strip = TRUE;
3134 }
3135 else
3136 {
3137 /* We use the reloc_count field as a counter if we need
3138 to copy relocs into the output file. */
3139 s->reloc_count = 0;
3140 }
3141 }
3142 else if (s != htab->elf.splt
3143 && s != htab->elf.sgot
3144 && s != htab->elf.sgotplt
3145 && s != htab->elf.sdynbss
3146 && s != htab->elf.sdynrelro)
3147 {
3148 /* It's not one of our sections, so don't allocate space. */
3149 continue;
3150 }
3151
3152 if (strip)
3153 {
3154 s->flags |= SEC_EXCLUDE;
3155 continue;
3156 }
3157
3158 /* Allocate memory for the section contents. */
3159 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3160 Unused entries should be reclaimed before the section's contents
3161 are written out, but at the moment this does not happen. Thus in
3162 order to prevent writing out garbage, we initialise the section's
3163 contents to zero. */
3164 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3165 if (s->contents == NULL && s->size != 0)
3166 return FALSE;
3167 }
3168
3169 if (elf_hash_table (info)->dynamic_sections_created)
3170 {
3171 /* Add some entries to the .dynamic section. We fill in the
3172 values later, in microblaze_elf_finish_dynamic_sections, but we
3173 must add the entries now so that we get the correct size for
3174 the .dynamic section. The DT_DEBUG entry is filled in by the
3175 dynamic linker and used by the debugger. */
3176 #define add_dynamic_entry(TAG, VAL) \
3177 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3178
3179 if (bfd_link_executable (info))
3180 {
3181 if (!add_dynamic_entry (DT_DEBUG, 0))
3182 return FALSE;
3183 }
3184
3185 if (!add_dynamic_entry (DT_RELA, 0)
3186 || !add_dynamic_entry (DT_RELASZ, 0)
3187 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3188 return FALSE;
3189
3190 if (htab->elf.splt->size != 0)
3191 {
3192 if (!add_dynamic_entry (DT_PLTGOT, 0)
3193 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3194 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3195 || !add_dynamic_entry (DT_JMPREL, 0)
3196 || !add_dynamic_entry (DT_BIND_NOW, 1))
3197 return FALSE;
3198 }
3199
3200 if (info->flags & DF_TEXTREL)
3201 {
3202 if (!add_dynamic_entry (DT_TEXTREL, 0))
3203 return FALSE;
3204 }
3205 }
3206 #undef add_dynamic_entry
3207 return TRUE;
3208 }
3209
3210 /* Finish up dynamic symbol handling. We set the contents of various
3211 dynamic sections here. */
3212
3213 static bfd_boolean
3214 microblaze_elf_finish_dynamic_symbol (bfd *output_bfd,
3215 struct bfd_link_info *info,
3216 struct elf_link_hash_entry *h,
3217 Elf_Internal_Sym *sym)
3218 {
3219 struct elf32_mb_link_hash_table *htab;
3220 struct elf32_mb_link_hash_entry *eh = elf32_mb_hash_entry(h);
3221
3222 htab = elf32_mb_hash_table (info);
3223 if (htab == NULL)
3224 return FALSE;
3225
3226 if (h->plt.offset != (bfd_vma) -1)
3227 {
3228 asection *splt;
3229 asection *srela;
3230 asection *sgotplt;
3231 Elf_Internal_Rela rela;
3232 bfd_byte *loc;
3233 bfd_vma plt_index;
3234 bfd_vma got_offset;
3235 bfd_vma got_addr;
3236
3237 /* This symbol has an entry in the procedure linkage table. Set
3238 it up. */
3239 BFD_ASSERT (h->dynindx != -1);
3240
3241 splt = htab->elf.splt;
3242 srela = htab->elf.srelplt;
3243 sgotplt = htab->elf.sgotplt;
3244 BFD_ASSERT (splt != NULL && srela != NULL && sgotplt != NULL);
3245
3246 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; /* first entry reserved. */
3247 got_offset = (plt_index + 3) * 4; /* 3 reserved ??? */
3248 got_addr = got_offset;
3249
3250 /* For non-PIC objects we need absolute address of the GOT entry. */
3251 if (!bfd_link_pic (info))
3252 got_addr += sgotplt->output_section->vma + sgotplt->output_offset;
3253
3254 /* Fill in the entry in the procedure linkage table. */
3255 bfd_put_32 (output_bfd, PLT_ENTRY_WORD_0 + ((got_addr >> 16) & 0xffff),
3256 splt->contents + h->plt.offset);
3257 if (bfd_link_pic (info))
3258 bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1 + (got_addr & 0xffff),
3259 splt->contents + h->plt.offset + 4);
3260 else
3261 bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1_NOPIC + (got_addr & 0xffff),
3262 splt->contents + h->plt.offset + 4);
3263 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_2,
3264 splt->contents + h->plt.offset + 8);
3265 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_3,
3266 splt->contents + h->plt.offset + 12);
3267
3268 /* Any additions to the .got section??? */
3269 /* bfd_put_32 (output_bfd,
3270 splt->output_section->vma + splt->output_offset + h->plt.offset + 4,
3271 sgotplt->contents + got_offset); */
3272
3273 /* Fill in the entry in the .rela.plt section. */
3274 rela.r_offset = (sgotplt->output_section->vma
3275 + sgotplt->output_offset
3276 + got_offset);
3277 rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_JUMP_SLOT);
3278 rela.r_addend = 0;
3279 loc = srela->contents;
3280 loc += plt_index * sizeof (Elf32_External_Rela);
3281 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3282
3283 if (!h->def_regular)
3284 {
3285 /* Mark the symbol as undefined, rather than as defined in
3286 the .plt section. Zero the value. */
3287 sym->st_shndx = SHN_UNDEF;
3288 sym->st_value = 0;
3289 }
3290 }
3291
3292 /* h->got.refcount to be checked ? */
3293 if (h->got.offset != (bfd_vma) -1 &&
3294 ! ((h->got.offset & 1) ||
3295 IS_TLS_LD(eh->tls_mask) || IS_TLS_GD(eh->tls_mask)))
3296 {
3297 asection *sgot;
3298 asection *srela;
3299 bfd_vma offset;
3300
3301 /* This symbol has an entry in the global offset table. Set it
3302 up. */
3303
3304 sgot = htab->elf.sgot;
3305 srela = htab->elf.srelgot;
3306 BFD_ASSERT (sgot != NULL && srela != NULL);
3307
3308 offset = (sgot->output_section->vma + sgot->output_offset
3309 + (h->got.offset &~ (bfd_vma) 1));
3310
3311 /* If this is a -Bsymbolic link, and the symbol is defined
3312 locally, we just want to emit a RELATIVE reloc. Likewise if
3313 the symbol was forced to be local because of a version file.
3314 The entry in the global offset table will already have been
3315 initialized in the relocate_section function. */
3316 if (bfd_link_pic (info)
3317 && ((info->symbolic && h->def_regular)
3318 || h->dynindx == -1))
3319 {
3320 asection *sec = h->root.u.def.section;
3321 bfd_vma value;
3322
3323 value = h->root.u.def.value;
3324 if (sec->output_section != NULL)
3325 /* PR 21180: If the output section is NULL, then the symbol is no
3326 longer needed, and in theory the GOT entry is redundant. But
3327 it is too late to change our minds now... */
3328 value += sec->output_section->vma + sec->output_offset;
3329
3330 microblaze_elf_output_dynamic_relocation (output_bfd,
3331 srela, srela->reloc_count++,
3332 /* symindex= */ 0,
3333 R_MICROBLAZE_REL, offset,
3334 value);
3335 }
3336 else
3337 {
3338 microblaze_elf_output_dynamic_relocation (output_bfd,
3339 srela, srela->reloc_count++,
3340 h->dynindx,
3341 R_MICROBLAZE_GLOB_DAT,
3342 offset, 0);
3343 }
3344
3345 bfd_put_32 (output_bfd, (bfd_vma) 0,
3346 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3347 }
3348
3349 if (h->needs_copy)
3350 {
3351 asection *s;
3352 Elf_Internal_Rela rela;
3353 bfd_byte *loc;
3354
3355 /* This symbols needs a copy reloc. Set it up. */
3356
3357 BFD_ASSERT (h->dynindx != -1);
3358
3359 rela.r_offset = (h->root.u.def.value
3360 + h->root.u.def.section->output_section->vma
3361 + h->root.u.def.section->output_offset);
3362 rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_COPY);
3363 rela.r_addend = 0;
3364 if (h->root.u.def.section == htab->elf.sdynrelro)
3365 s = htab->elf.sreldynrelro;
3366 else
3367 s = htab->elf.srelbss;
3368 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3369 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3370 }
3371
3372 /* Mark some specially defined symbols as absolute. */
3373 if (h == htab->elf.hdynamic
3374 || h == htab->elf.hgot
3375 || h == htab->elf.hplt)
3376 sym->st_shndx = SHN_ABS;
3377
3378 return TRUE;
3379 }
3380
3381
3382 /* Finish up the dynamic sections. */
3383
3384 static bfd_boolean
3385 microblaze_elf_finish_dynamic_sections (bfd *output_bfd,
3386 struct bfd_link_info *info)
3387 {
3388 bfd *dynobj;
3389 asection *sdyn, *sgot;
3390 struct elf32_mb_link_hash_table *htab;
3391
3392 htab = elf32_mb_hash_table (info);
3393 if (htab == NULL)
3394 return FALSE;
3395
3396 dynobj = htab->elf.dynobj;
3397
3398 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3399
3400 if (htab->elf.dynamic_sections_created)
3401 {
3402 asection *splt;
3403 Elf32_External_Dyn *dyncon, *dynconend;
3404
3405 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3406 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3407 for (; dyncon < dynconend; dyncon++)
3408 {
3409 Elf_Internal_Dyn dyn;
3410 asection *s;
3411 bfd_boolean size;
3412
3413 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3414
3415 switch (dyn.d_tag)
3416 {
3417 case DT_PLTGOT:
3418 s = htab->elf.sgotplt;
3419 size = FALSE;
3420 break;
3421
3422 case DT_PLTRELSZ:
3423 s = htab->elf.srelplt;
3424 size = TRUE;
3425 break;
3426
3427 case DT_JMPREL:
3428 s = htab->elf.srelplt;
3429 size = FALSE;
3430 break;
3431
3432 default:
3433 continue;
3434 }
3435
3436 if (s == NULL)
3437 dyn.d_un.d_val = 0;
3438 else
3439 {
3440 if (!size)
3441 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3442 else
3443 dyn.d_un.d_val = s->size;
3444 }
3445 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3446 }
3447
3448 splt = htab->elf.splt;
3449 BFD_ASSERT (splt != NULL && sdyn != NULL);
3450
3451 /* Clear the first entry in the procedure linkage table,
3452 and put a nop in the last four bytes. */
3453 if (splt->size > 0)
3454 {
3455 memset (splt->contents, 0, PLT_ENTRY_SIZE);
3456 bfd_put_32 (output_bfd, (bfd_vma) 0x80000000 /* nop. */,
3457 splt->contents + splt->size - 4);
3458
3459 if (splt->output_section != bfd_abs_section_ptr)
3460 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3461 }
3462 }
3463
3464 /* Set the first entry in the global offset table to the address of
3465 the dynamic section. */
3466 sgot = htab->elf.sgotplt;
3467 if (sgot && sgot->size > 0)
3468 {
3469 if (sdyn == NULL)
3470 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3471 else
3472 bfd_put_32 (output_bfd,
3473 sdyn->output_section->vma + sdyn->output_offset,
3474 sgot->contents);
3475 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3476 }
3477
3478 if (htab->elf.sgot && htab->elf.sgot->size > 0)
3479 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
3480
3481 return TRUE;
3482 }
3483
3484 /* Hook called by the linker routine which adds symbols from an object
3485 file. We use it to put .comm items in .sbss, and not .bss. */
3486
3487 static bfd_boolean
3488 microblaze_elf_add_symbol_hook (bfd *abfd,
3489 struct bfd_link_info *info,
3490 Elf_Internal_Sym *sym,
3491 const char **namep ATTRIBUTE_UNUSED,
3492 flagword *flagsp ATTRIBUTE_UNUSED,
3493 asection **secp,
3494 bfd_vma *valp)
3495 {
3496 if (sym->st_shndx == SHN_COMMON
3497 && !bfd_link_relocatable (info)
3498 && sym->st_size <= elf_gp_size (abfd))
3499 {
3500 /* Common symbols less than or equal to -G nn bytes are automatically
3501 put into .sbss. */
3502 *secp = bfd_make_section_old_way (abfd, ".sbss");
3503 if (*secp == NULL
3504 || !bfd_set_section_flags (*secp, SEC_IS_COMMON))
3505 return FALSE;
3506
3507 *valp = sym->st_size;
3508 }
3509
3510 return TRUE;
3511 }
3512
3513 #define TARGET_LITTLE_SYM microblaze_elf32_le_vec
3514 #define TARGET_LITTLE_NAME "elf32-microblazeel"
3515
3516 #define TARGET_BIG_SYM microblaze_elf32_vec
3517 #define TARGET_BIG_NAME "elf32-microblaze"
3518
3519 #define ELF_ARCH bfd_arch_microblaze
3520 #define ELF_TARGET_ID MICROBLAZE_ELF_DATA
3521 #define ELF_MACHINE_CODE EM_MICROBLAZE
3522 #define ELF_MACHINE_ALT1 EM_MICROBLAZE_OLD
3523 #define ELF_MAXPAGESIZE 0x1000
3524 #define elf_info_to_howto microblaze_elf_info_to_howto
3525 #define elf_info_to_howto_rel NULL
3526
3527 #define bfd_elf32_bfd_reloc_type_lookup microblaze_elf_reloc_type_lookup
3528 #define bfd_elf32_bfd_is_local_label_name microblaze_elf_is_local_label_name
3529 #define elf_backend_relocate_section microblaze_elf_relocate_section
3530 #define bfd_elf32_bfd_relax_section microblaze_elf_relax_section
3531 #define bfd_elf32_bfd_merge_private_bfd_data _bfd_generic_verify_endian_match
3532 #define bfd_elf32_bfd_reloc_name_lookup microblaze_elf_reloc_name_lookup
3533
3534 #define elf_backend_gc_mark_hook microblaze_elf_gc_mark_hook
3535 #define elf_backend_check_relocs microblaze_elf_check_relocs
3536 #define elf_backend_copy_indirect_symbol microblaze_elf_copy_indirect_symbol
3537 #define bfd_elf32_bfd_link_hash_table_create microblaze_elf_link_hash_table_create
3538 #define elf_backend_can_gc_sections 1
3539 #define elf_backend_can_refcount 1
3540 #define elf_backend_want_got_plt 1
3541 #define elf_backend_plt_readonly 1
3542 #define elf_backend_got_header_size 12
3543 #define elf_backend_want_dynrelro 1
3544 #define elf_backend_rela_normal 1
3545 #define elf_backend_dtrel_excludes_plt 1
3546
3547 #define elf_backend_adjust_dynamic_symbol microblaze_elf_adjust_dynamic_symbol
3548 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3549 #define elf_backend_finish_dynamic_sections microblaze_elf_finish_dynamic_sections
3550 #define elf_backend_finish_dynamic_symbol microblaze_elf_finish_dynamic_symbol
3551 #define elf_backend_size_dynamic_sections microblaze_elf_size_dynamic_sections
3552 #define elf_backend_add_symbol_hook microblaze_elf_add_symbol_hook
3553
3554 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.