?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge from gcc
[binutils.git] / bfd / elf32-microblaze.c
blobc975e76800f8a2c5505291c7800a0b3a89d228fb
1 /* Xilinx MicroBlaze-specific support for 32-bit ELF
2
3 Copyright 2009 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 "bfd.h"
26 #include "sysdep.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 2, /* Size (0 = byte, 1 = short, 2 = long). */
48 32, /* Bitsize. */
49 FALSE, /* PC_relative. */
50 0, /* Bitpos. */
51 complain_overflow_bitfield, /* 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 2, /* Size (0 = byte, 1 = short, 2 = long). */
183 32, /* Bitsize. */
184 TRUE, /* PC_relative. */
185 0, /* Bitpos. */
186 complain_overflow_bitfield, /* 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 GOT relocation. Table-entry not really used. */
255 HOWTO (R_MICROBLAZE_GOT_64, /* Type. */
256 0, /* Rightshift. */
257 2, /* Size (0 = byte, 1 = short, 2 = long). */
258 16, /* Bitsize. */
259 FALSE, /* PC_relative. */
260 0, /* Bitpos. */
261 complain_overflow_dont, /* Complain on overflow. */
262 bfd_elf_generic_reloc,/* Special Function. */
263 "R_MICROBLAZE_GOT_64",/* Name. */
264 FALSE, /* Partial Inplace. */
265 0, /* Source Mask. */
266 0x0000ffff, /* Dest Mask. */
267 FALSE), /* PC relative offset? */
268
269 /* A 64 bit PLT relocation. Table-entry not really used. */
270 HOWTO (R_MICROBLAZE_PLT_64, /* Type. */
271 0, /* Rightshift. */
272 2, /* Size (0 = byte, 1 = short, 2 = long). */
273 16, /* Bitsize. */
274 TRUE, /* PC_relative. */
275 0, /* Bitpos. */
276 complain_overflow_dont, /* Complain on overflow. */
277 bfd_elf_generic_reloc,/* Special Function. */
278 "R_MICROBLAZE_PLT_64",/* Name. */
279 FALSE, /* Partial Inplace. */
280 0, /* Source Mask. */
281 0x0000ffff, /* Dest Mask. */
282 TRUE), /* PC relative offset? */
283
284 /* Table-entry not really used. */
285 HOWTO (R_MICROBLAZE_REL, /* Type. */
286 0, /* Rightshift. */
287 2, /* Size (0 = byte, 1 = short, 2 = long). */
288 16, /* Bitsize. */
289 TRUE, /* PC_relative. */
290 0, /* Bitpos. */
291 complain_overflow_dont, /* Complain on overflow. */
292 bfd_elf_generic_reloc,/* Special Function. */
293 "R_MICROBLAZE_REL", /* Name. */
294 FALSE, /* Partial Inplace. */
295 0, /* Source Mask. */
296 0x0000ffff, /* Dest Mask. */
297 TRUE), /* PC relative offset? */
298
299 /* Table-entry not really used. */
300 HOWTO (R_MICROBLAZE_JUMP_SLOT,/* 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_JUMP_SLOT", /* 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_GLOB_DAT,/* 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_GLOB_DAT", /* Name. */
324 FALSE, /* Partial Inplace. */
325 0, /* Source Mask. */
326 0x0000ffff, /* Dest Mask. */
327 TRUE), /* PC relative offset? */
328
329 /* A 64 bit GOT relative relocation. Table-entry not really used. */
330 HOWTO (R_MICROBLAZE_GOTOFF_64, /* Type. */
331 0, /* Rightshift. */
332 2, /* Size (0 = byte, 1 = short, 2 = long). */
333 16, /* Bitsize. */
334 FALSE, /* PC_relative. */
335 0, /* Bitpos. */
336 complain_overflow_dont, /* Complain on overflow. */
337 bfd_elf_generic_reloc,/* Special Function. */
338 "R_MICROBLAZE_GOTOFF_64", /* Name. */
339 FALSE, /* Partial Inplace. */
340 0, /* Source Mask. */
341 0x0000ffff, /* Dest Mask. */
342 FALSE), /* PC relative offset? */
343
344 /* A 32 bit GOT relative relocation. Table-entry not really used. */
345 HOWTO (R_MICROBLAZE_GOTOFF_32, /* Type. */
346 0, /* Rightshift. */
347 2, /* Size (0 = byte, 1 = short, 2 = long). */
348 16, /* Bitsize. */
349 FALSE, /* PC_relative. */
350 0, /* Bitpos. */
351 complain_overflow_dont, /* Complain on overflow. */
352 bfd_elf_generic_reloc, /* Special Function. */
353 "R_MICROBLAZE_GOTOFF_32", /* Name. */
354 FALSE, /* Partial Inplace. */
355 0, /* Source Mask. */
356 0x0000ffff, /* Dest Mask. */
357 FALSE), /* PC relative offset? */
358
359 /* COPY relocation. Table-entry not really used. */
360 HOWTO (R_MICROBLAZE_COPY, /* 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_COPY", /* Name. */
369 FALSE, /* Partial Inplace. */
370 0, /* Source Mask. */
371 0x0000ffff, /* Dest Mask. */
372 FALSE), /* PC relative offset? */
373 };
374
375 #ifndef NUM_ELEM
376 #define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])
377 #endif
378 \f
379 /* Initialize the microblaze_elf_howto_table, so that linear accesses can be done. */
380
381 static void
382 microblaze_elf_howto_init (void)
383 {
384 unsigned int i;
385
386 for (i = NUM_ELEM (microblaze_elf_howto_raw); i--;)
387 {
388 unsigned int type;
389
390 type = microblaze_elf_howto_raw[i].type;
391
392 BFD_ASSERT (type < NUM_ELEM (microblaze_elf_howto_table));
393
394 microblaze_elf_howto_table [type] = & microblaze_elf_howto_raw [i];
395 }
396 }
397 \f
398 static reloc_howto_type *
399 microblaze_elf_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
400 bfd_reloc_code_real_type code)
401 {
402 enum elf_microblaze_reloc_type microblaze_reloc = R_MICROBLAZE_NONE;
403
404 switch (code)
405 {
406 case BFD_RELOC_NONE:
407 microblaze_reloc = R_MICROBLAZE_NONE;
408 break;
409 case BFD_RELOC_MICROBLAZE_64_NONE:
410 microblaze_reloc = R_MICROBLAZE_64_NONE;
411 break;
412 case BFD_RELOC_32:
413 microblaze_reloc = R_MICROBLAZE_32;
414 break;
415 /* RVA is treated the same as 32 */
416 case BFD_RELOC_RVA:
417 microblaze_reloc = R_MICROBLAZE_32;
418 break;
419 case BFD_RELOC_32_PCREL:
420 microblaze_reloc = R_MICROBLAZE_32_PCREL;
421 break;
422 case BFD_RELOC_64_PCREL:
423 microblaze_reloc = R_MICROBLAZE_64_PCREL;
424 break;
425 case BFD_RELOC_MICROBLAZE_32_LO_PCREL:
426 microblaze_reloc = R_MICROBLAZE_32_PCREL_LO;
427 break;
428 case BFD_RELOC_64:
429 microblaze_reloc = R_MICROBLAZE_64;
430 break;
431 case BFD_RELOC_MICROBLAZE_32_LO:
432 microblaze_reloc = R_MICROBLAZE_32_LO;
433 break;
434 case BFD_RELOC_MICROBLAZE_32_ROSDA:
435 microblaze_reloc = R_MICROBLAZE_SRO32;
436 break;
437 case BFD_RELOC_MICROBLAZE_32_RWSDA:
438 microblaze_reloc = R_MICROBLAZE_SRW32;
439 break;
440 case BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM:
441 microblaze_reloc = R_MICROBLAZE_32_SYM_OP_SYM;
442 break;
443 case BFD_RELOC_VTABLE_INHERIT:
444 microblaze_reloc = R_MICROBLAZE_GNU_VTINHERIT;
445 break;
446 case BFD_RELOC_VTABLE_ENTRY:
447 microblaze_reloc = R_MICROBLAZE_GNU_VTENTRY;
448 break;
449 case BFD_RELOC_MICROBLAZE_64_GOTPC:
450 microblaze_reloc = R_MICROBLAZE_GOTPC_64;
451 break;
452 case BFD_RELOC_MICROBLAZE_64_GOT:
453 microblaze_reloc = R_MICROBLAZE_GOT_64;
454 break;
455 case BFD_RELOC_MICROBLAZE_64_PLT:
456 microblaze_reloc = R_MICROBLAZE_PLT_64;
457 break;
458 case BFD_RELOC_MICROBLAZE_64_GOTOFF:
459 microblaze_reloc = R_MICROBLAZE_GOTOFF_64;
460 break;
461 case BFD_RELOC_MICROBLAZE_32_GOTOFF:
462 microblaze_reloc = R_MICROBLAZE_GOTOFF_32;
463 break;
464 case BFD_RELOC_MICROBLAZE_COPY:
465 microblaze_reloc = R_MICROBLAZE_COPY;
466 break;
467 default:
468 return (reloc_howto_type *) NULL;
469 }
470
471 if (!microblaze_elf_howto_table [R_MICROBLAZE_32])
472 /* Initialize howto table if needed. */
473 microblaze_elf_howto_init ();
474
475 return microblaze_elf_howto_table [(int) microblaze_reloc];
476 };
477
478 static reloc_howto_type *
479 microblaze_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
480 const char *r_name)
481 {
482 unsigned int i;
483
484 for (i = 0; i < NUM_ELEM (microblaze_elf_howto_raw); i++)
485 if (microblaze_elf_howto_raw[i].name != NULL
486 && strcasecmp (microblaze_elf_howto_raw[i].name, r_name) == 0)
487 return &microblaze_elf_howto_raw[i];
488
489 return NULL;
490 }
491
492 /* Set the howto pointer for a RCE ELF reloc. */
493
494 static void
495 microblaze_elf_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED,
496 arelent * cache_ptr,
497 Elf_Internal_Rela * dst)
498 {
499 if (!microblaze_elf_howto_table [R_MICROBLAZE_32])
500 /* Initialize howto table if needed. */
501 microblaze_elf_howto_init ();
502
503 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_MICROBLAZE_max);
504
505 cache_ptr->howto = microblaze_elf_howto_table [ELF32_R_TYPE (dst->r_info)];
506 }
507
508 /* Microblaze ELF local labels start with 'L.' or '$L', not '.L'. */
509
510 static bfd_boolean
511 microblaze_elf_is_local_label_name (bfd *abfd, const char *name)
512 {
513 if (name[0] == 'L' && name[1] == '.')
514 return TRUE;
515
516 if (name[0] == '$' && name[1] == 'L')
517 return TRUE;
518
519 /* With gcc, the labels go back to starting with '.', so we accept
520 the generic ELF local label syntax as well. */
521 return _bfd_elf_is_local_label_name (abfd, name);
522 }
523
524 /* The microblaze linker (like many others) needs to keep track of
525 the number of relocs that it decides to copy as dynamic relocs in
526 check_relocs for each symbol. This is so that it can later discard
527 them if they are found to be unnecessary. We store the information
528 in a field extending the regular ELF linker hash table. */
529
530 struct elf32_mb_dyn_relocs
531 {
532 struct elf32_mb_dyn_relocs *next;
533
534 /* The input section of the reloc. */
535 asection *sec;
536
537 /* Total number of relocs copied for the input section. */
538 bfd_size_type count;
539
540 /* Number of pc-relative relocs copied for the input section. */
541 bfd_size_type pc_count;
542 };
543
544 /* ELF linker hash entry. */
545
546 struct elf32_mb_link_hash_entry
547 {
548 struct elf_link_hash_entry elf;
549
550 /* Track dynamic relocs copied for this symbol. */
551 struct elf32_mb_dyn_relocs *dyn_relocs;
552
553 };
554
555 #define elf32_mb_hash_entry(ent) ((struct elf32_mb_link_hash_entry *)(ent))
556
557 /* ELF linker hash table. */
558
559 struct elf32_mb_link_hash_table
560 {
561 struct elf_link_hash_table elf;
562
563 /* Short-cuts to get to dynamic linker sections. */
564 asection *sgot;
565 asection *sgotplt;
566 asection *srelgot;
567 asection *splt;
568 asection *srelplt;
569 asection *sdynbss;
570 asection *srelbss;
571
572 /* Small local sym to section mapping cache. */
573 struct sym_cache sym_sec;
574 };
575
576 /* Get the ELF linker hash table from a link_info structure. */
577
578 #define elf32_mb_hash_table(p) \
579 ((struct elf32_mb_link_hash_table *) ((p)->hash))
580
581 /* Create an entry in a microblaze ELF linker hash table. */
582
583 static struct bfd_hash_entry *
584 link_hash_newfunc (struct bfd_hash_entry *entry,
585 struct bfd_hash_table *table,
586 const char *string)
587 {
588 /* Allocate the structure if it has not already been allocated by a
589 subclass. */
590 if (entry == NULL)
591 {
592 entry = bfd_hash_allocate (table,
593 sizeof (struct elf32_mb_link_hash_entry));
594 if (entry == NULL)
595 return entry;
596 }
597
598 /* Call the allocation method of the superclass. */
599 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
600 if (entry != NULL)
601 {
602 struct elf32_mb_link_hash_entry *eh;
603
604 eh = (struct elf32_mb_link_hash_entry *) entry;
605 eh->dyn_relocs = NULL;
606 }
607
608 return entry;
609 }
610
611 /* Create a mb ELF linker hash table. */
612
613 static struct bfd_link_hash_table *
614 microblaze_elf_link_hash_table_create (bfd *abfd)
615 {
616 struct elf32_mb_link_hash_table *ret;
617 bfd_size_type amt = sizeof (struct elf32_mb_link_hash_table);
618
619 ret = (struct elf32_mb_link_hash_table *) bfd_zmalloc (amt);
620 if (ret == NULL)
621 return NULL;
622
623 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
624 sizeof (struct elf32_mb_link_hash_entry)))
625 {
626 free (ret);
627 return NULL;
628 }
629
630 return &ret->elf.root;
631 }
632 \f
633 /* Set the values of the small data pointers. */
634
635 static void
636 microblaze_elf_final_sdp (struct bfd_link_info *info)
637 {
638 struct bfd_link_hash_entry *h;
639
640 h = bfd_link_hash_lookup (info->hash, RO_SDA_ANCHOR_NAME, FALSE, FALSE, TRUE);
641 if (h != (struct bfd_link_hash_entry *) NULL
642 && h->type == bfd_link_hash_defined)
643 ro_small_data_pointer = (h->u.def.value
644 + h->u.def.section->output_section->vma
645 + h->u.def.section->output_offset);
646
647 h = bfd_link_hash_lookup (info->hash, RW_SDA_ANCHOR_NAME, FALSE, FALSE, TRUE);
648 if (h != (struct bfd_link_hash_entry *) NULL
649 && h->type == bfd_link_hash_defined)
650 rw_small_data_pointer = (h->u.def.value
651 + h->u.def.section->output_section->vma
652 + h->u.def.section->output_offset);
653 }
654
655 /* This code is taken from elf32-m32r.c
656 There is some attempt to make this function usable for many architectures,
657 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
658 if only to serve as a learning tool.
659
660 The RELOCATE_SECTION function is called by the new ELF backend linker
661 to handle the relocations for a section.
662
663 The relocs are always passed as Rela structures; if the section
664 actually uses Rel structures, the r_addend field will always be
665 zero.
666
667 This function is responsible for adjust the section contents as
668 necessary, and (if using Rela relocs and generating a
669 relocatable output file) adjusting the reloc addend as
670 necessary.
671
672 This function does not have to worry about setting the reloc
673 address or the reloc symbol index.
674
675 LOCAL_SYMS is a pointer to the swapped in local symbols.
676
677 LOCAL_SECTIONS is an array giving the section in the input file
678 corresponding to the st_shndx field of each local symbol.
679
680 The global hash table entry for the global symbols can be found
681 via elf_sym_hashes (input_bfd).
682
683 When generating relocatable output, this function must handle
684 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
685 going to be the section symbol corresponding to the output
686 section, which means that the addend must be adjusted
687 accordingly. */
688
689 static bfd_boolean
690 microblaze_elf_relocate_section (bfd *output_bfd,
691 struct bfd_link_info *info,
692 bfd *input_bfd,
693 asection *input_section,
694 bfd_byte *contents,
695 Elf_Internal_Rela *relocs,
696 Elf_Internal_Sym *local_syms,
697 asection **local_sections)
698 {
699 struct elf32_mb_link_hash_table *htab;
700 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
701 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
702 Elf_Internal_Rela *rel, *relend;
703 /* Assume success. */
704 bfd_boolean ret = TRUE;
705 asection *sreloc;
706 bfd_vma *local_got_offsets;
707
708 if (!microblaze_elf_howto_table[R_MICROBLAZE_max-1])
709 microblaze_elf_howto_init ();
710
711 htab = elf32_mb_hash_table (info);
712 local_got_offsets = elf_local_got_offsets (input_bfd);
713
714 sreloc = elf_section_data (input_section)->sreloc;
715
716 rel = relocs;
717 relend = relocs + input_section->reloc_count;
718 for (; rel < relend; rel++)
719 {
720 int r_type;
721 reloc_howto_type *howto;
722 unsigned long r_symndx;
723 bfd_vma addend = rel->r_addend;
724 bfd_vma offset = rel->r_offset;
725 struct elf_link_hash_entry *h;
726 Elf_Internal_Sym *sym;
727 asection *sec;
728 const char *sym_name;
729 bfd_reloc_status_type r = bfd_reloc_ok;
730 const char *errmsg = NULL;
731 bfd_boolean unresolved_reloc = FALSE;
732
733 h = NULL;
734 r_type = ELF32_R_TYPE (rel->r_info);
735 if (r_type < 0 || r_type >= (int) R_MICROBLAZE_max)
736 {
737 (*_bfd_error_handler) (_("%s: unknown relocation type %d"),
738 bfd_get_filename (input_bfd), (int) r_type);
739 bfd_set_error (bfd_error_bad_value);
740 ret = FALSE;
741 continue;
742 }
743
744 howto = microblaze_elf_howto_table[r_type];
745 r_symndx = ELF32_R_SYM (rel->r_info);
746
747 if (info->relocatable)
748 {
749 /* This is a relocatable link. We don't have to change
750 anything, unless the reloc is against a section symbol,
751 in which case we have to adjust according to where the
752 section symbol winds up in the output section. */
753 sec = NULL;
754 if (r_symndx >= symtab_hdr->sh_info)
755 /* External symbol. */
756 continue;
757
758 /* Local symbol. */
759 sym = local_syms + r_symndx;
760 sym_name = "<local symbol>";
761 /* STT_SECTION: symbol is associated with a section. */
762 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
763 /* Symbol isn't associated with a section. Nothing to do. */
764 continue;
765
766 sec = local_sections[r_symndx];
767 addend += sec->output_offset + sym->st_value;
768 #ifndef USE_REL
769 /* This can't be done for USE_REL because it doesn't mean anything
770 and elf_link_input_bfd asserts this stays zero. */
771 /* rel->r_addend = addend; */
772 #endif
773
774 #ifndef USE_REL
775 /* Addends are stored with relocs. We're done. */
776 continue;
777 #else /* USE_REL */
778 /* If partial_inplace, we need to store any additional addend
779 back in the section. */
780 if (!howto->partial_inplace)
781 continue;
782 /* ??? Here is a nice place to call a special_function like handler. */
783 r = _bfd_relocate_contents (howto, input_bfd, addend,
784 contents + offset);
785 #endif /* USE_REL */
786 }
787 else
788 {
789 bfd_vma relocation;
790
791 /* This is a final link. */
792 sym = NULL;
793 sec = NULL;
794 unresolved_reloc = FALSE;
795
796 if (r_symndx < symtab_hdr->sh_info)
797 {
798 /* Local symbol. */
799 sym = local_syms + r_symndx;
800 sec = local_sections[r_symndx];
801 if (sec == 0)
802 continue;
803 sym_name = "<local symbol>";
804 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
805 /* r_addend may have changed if the reference section was
806 a merge section. */
807 addend = rel->r_addend;
808 }
809 else
810 {
811 /* External symbol. */
812 bfd_boolean warned ATTRIBUTE_UNUSED;
813
814 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
815 r_symndx, symtab_hdr, sym_hashes,
816 h, sec, relocation,
817 unresolved_reloc, warned);
818 sym_name = h->root.root.string;
819 }
820
821 /* Sanity check the address. */
822 if (offset > bfd_get_section_limit (output_bfd, input_section))
823 {
824 r = bfd_reloc_outofrange;
825 goto check_reloc;
826 }
827
828 switch ((int) r_type)
829 {
830 case (int) R_MICROBLAZE_SRO32 :
831 {
832 const char *name;
833
834 /* Only relocate if the symbol is defined. */
835 if (sec)
836 {
837 name = bfd_get_section_name (abfd, sec);
838
839 if (strcmp (name, ".sdata2") == 0
840 || strcmp (name, ".sbss2") == 0)
841 {
842 if (ro_small_data_pointer == 0)
843 microblaze_elf_final_sdp (info);
844 if (ro_small_data_pointer == 0)
845 {
846 ret = FALSE;
847 r = bfd_reloc_undefined;
848 goto check_reloc;
849 }
850
851 /* At this point `relocation' contains the object's
852 address. */
853 relocation -= ro_small_data_pointer;
854 /* Now it contains the offset from _SDA2_BASE_. */
855 r = _bfd_final_link_relocate (howto, input_bfd,
856 input_section,
857 contents, offset,
858 relocation, addend);
859 }
860 else
861 {
862 (*_bfd_error_handler) (_("%s: The target (%s) of an %s relocation is in the wrong section (%s)"),
863 bfd_get_filename (input_bfd),
864 sym_name,
865 microblaze_elf_howto_table[(int) r_type]->name,
866 bfd_get_section_name (abfd, sec));
867 /*bfd_set_error (bfd_error_bad_value); ??? why? */
868 ret = FALSE;
869 continue;
870 }
871 }
872 }
873 break;
874
875 case (int) R_MICROBLAZE_SRW32 :
876 {
877 const char *name;
878
879 /* Only relocate if the symbol is defined. */
880 if (sec)
881 {
882 name = bfd_get_section_name (abfd, sec);
883
884 if (strcmp (name, ".sdata") == 0
885 || strcmp (name, ".sbss") == 0)
886 {
887 if (rw_small_data_pointer == 0)
888 microblaze_elf_final_sdp (info);
889 if (rw_small_data_pointer == 0)
890 {
891 ret = FALSE;
892 r = bfd_reloc_undefined;
893 goto check_reloc;
894 }
895
896 /* At this point `relocation' contains the object's
897 address. */
898 relocation -= rw_small_data_pointer;
899 /* Now it contains the offset from _SDA_BASE_. */
900 r = _bfd_final_link_relocate (howto, input_bfd,
901 input_section,
902 contents, offset,
903 relocation, addend);
904 }
905 else
906 {
907 (*_bfd_error_handler) (_("%s: The target (%s) of an %s relocation is in the wrong section (%s)"),
908 bfd_get_filename (input_bfd),
909 sym_name,
910 microblaze_elf_howto_table[(int) r_type]->name,
911 bfd_get_section_name (abfd, sec));
912 /*bfd_set_error (bfd_error_bad_value); ??? why? */
913 ret = FALSE;
914 continue;
915 }
916 }
917 }
918 break;
919
920 case (int) R_MICROBLAZE_32_SYM_OP_SYM:
921 break; /* Do nothing. */
922
923 case (int) R_MICROBLAZE_GOTPC_64:
924 relocation = htab->sgotplt->output_section->vma
925 + htab->sgotplt->output_offset;
926 relocation -= (input_section->output_section->vma
927 + input_section->output_offset
928 + offset + INST_WORD_SIZE);
929 relocation += addend;
930 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
931 contents + offset + 2);
932 bfd_put_16 (input_bfd, relocation & 0xffff,
933 contents + offset + 2 + INST_WORD_SIZE);
934 break;
935
936 case (int) R_MICROBLAZE_PLT_64:
937 {
938 bfd_vma immediate;
939 if (htab->splt != NULL && h != NULL
940 && h->plt.offset != (bfd_vma) -1)
941 {
942 relocation = (htab->splt->output_section->vma
943 + htab->splt->output_offset
944 + h->plt.offset);
945 unresolved_reloc = FALSE;
946 immediate = relocation - (input_section->output_section->vma
947 + input_section->output_offset
948 + offset + INST_WORD_SIZE);
949 bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
950 contents + offset + 2);
951 bfd_put_16 (input_bfd, immediate & 0xffff,
952 contents + offset + 2 + INST_WORD_SIZE);
953 }
954 else
955 {
956 relocation -= (input_section->output_section->vma
957 + input_section->output_offset
958 + offset + INST_WORD_SIZE);
959 immediate = relocation;
960 bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
961 contents + offset + 2);
962 bfd_put_16 (input_bfd, immediate & 0xffff,
963 contents + offset + 2 + INST_WORD_SIZE);
964 }
965 break;
966 }
967
968 case (int) R_MICROBLAZE_GOT_64:
969 {
970 if (htab->sgot == NULL)
971 abort ();
972 if (h == NULL)
973 {
974 bfd_vma off;
975 if (local_got_offsets == NULL)
976 abort ();
977 off = local_got_offsets[r_symndx];
978 /* The LSB indicates whether we've already
979 created relocation. */
980 if (off & 1)
981 off &= ~1;
982 else
983 {
984 bfd_put_32 (output_bfd, relocation + addend,
985 htab->sgot->contents + off);
986
987 if (info->shared)
988 {
989 Elf_Internal_Rela outrel;
990 bfd_byte *loc;
991 if (htab->srelgot == NULL)
992 abort ();
993 outrel.r_offset = (htab->sgot->output_section->vma
994 + htab->sgot->output_offset
995 + off);
996 outrel.r_info = ELF32_R_INFO (0, R_MICROBLAZE_REL);
997 outrel.r_addend = relocation + addend;
998 loc = htab->srelgot->contents;
999 loc += htab->srelgot->reloc_count++
1000 * sizeof (Elf32_External_Rela);
1001 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1002 }
1003 local_got_offsets[r_symndx] |= 1;
1004 }
1005 relocation = htab->sgot->output_section->vma
1006 + htab->sgot->output_offset + off
1007 - htab->sgotplt->output_section->vma
1008 - htab->sgotplt->output_offset;
1009 unresolved_reloc = FALSE;
1010 }
1011 else
1012 {
1013 if (htab->sgotplt != NULL && h != NULL
1014 && h->got.offset != (bfd_vma) -1)
1015 {
1016 bfd_put_32 (output_bfd, relocation + addend,
1017 htab->sgot->contents + h->got.offset);
1018 relocation = htab->sgot->output_section->vma
1019 + htab->sgot->output_offset
1020 + h->got.offset
1021 - htab->sgotplt->output_section->vma
1022 - htab->sgotplt->output_offset;
1023 unresolved_reloc = FALSE;
1024 }
1025 else
1026 abort (); /* ??? */
1027 }
1028 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1029 contents + offset + 2);
1030 bfd_put_16 (input_bfd, relocation & 0xffff,
1031 contents + offset + 2 + INST_WORD_SIZE);
1032 break;
1033 }
1034
1035 case (int) R_MICROBLAZE_GOTOFF_64:
1036 {
1037 bfd_vma immediate;
1038 unsigned short lo, high;
1039 relocation += addend;
1040 relocation -= htab->sgotplt->output_section->vma
1041 + htab->sgotplt->output_offset;
1042 /* Write this value into correct location. */
1043 immediate = relocation;
1044 lo = immediate & 0x0000ffff;
1045 high = (immediate >> 16) & 0x0000ffff;
1046 bfd_put_16 (input_bfd, high, contents + offset + 2);
1047 bfd_put_16 (input_bfd, lo, contents + offset + INST_WORD_SIZE + 2);
1048 break;
1049 }
1050
1051 case (int) R_MICROBLAZE_GOTOFF_32:
1052 {
1053 relocation += addend;
1054 relocation -= htab->sgotplt->output_section->vma
1055 + htab->sgotplt->output_offset;
1056 /* Write this value into correct location. */
1057 bfd_put_32 (input_bfd, relocation, contents + offset);
1058 break;
1059 }
1060
1061 case (int) R_MICROBLAZE_64_PCREL :
1062 case (int) R_MICROBLAZE_64:
1063 case (int) R_MICROBLAZE_32:
1064 {
1065 /* r_symndx will be zero only for relocs against symbols
1066 from removed linkonce sections, or sections discarded by
1067 a linker script. */
1068 if (r_symndx == 0 || (input_section->flags & SEC_ALLOC) == 0)
1069 {
1070 relocation += addend;
1071 if (r_type == R_MICROBLAZE_32)
1072 bfd_put_32 (input_bfd, relocation, contents + offset);
1073 else
1074 {
1075 if (r_type == R_MICROBLAZE_64_PCREL)
1076 relocation -= (input_section->output_section->vma
1077 + input_section->output_offset
1078 + offset + INST_WORD_SIZE);
1079 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1080 contents + offset + 2);
1081 bfd_put_16 (input_bfd, relocation & 0xffff,
1082 contents + offset + 2 + INST_WORD_SIZE);
1083 }
1084 break;
1085 }
1086
1087 if ((info->shared
1088 && (h == NULL
1089 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1090 || h->root.type != bfd_link_hash_undefweak)
1091 && (!howto->pc_relative
1092 || (h != NULL
1093 && h->dynindx != -1
1094 && (!info->symbolic
1095 || !h->def_regular))))
1096 || (!info->shared
1097 && h != NULL
1098 && h->dynindx != -1
1099 && !h->non_got_ref
1100 && ((h->def_dynamic
1101 && !h->def_regular)
1102 || h->root.type == bfd_link_hash_undefweak
1103 || h->root.type == bfd_link_hash_undefined)))
1104 {
1105 Elf_Internal_Rela outrel;
1106 bfd_byte *loc;
1107 bfd_boolean skip, relocate = FALSE;
1108
1109 /* When generating a shared object, these relocations
1110 are copied into the output file to be resolved at run
1111 time. */
1112
1113 BFD_ASSERT (sreloc != NULL);
1114
1115 skip = FALSE;
1116
1117 outrel.r_offset =
1118 _bfd_elf_section_offset (output_bfd, info, input_section,
1119 rel->r_offset);
1120 if (outrel.r_offset == (bfd_vma) -1)
1121 skip = TRUE;
1122 else if (outrel.r_offset == (bfd_vma) -2)
1123 skip = TRUE, relocate = TRUE;
1124 outrel.r_offset += (input_section->output_section->vma
1125 + input_section->output_offset);
1126
1127 if (skip)
1128 memset (&outrel, 0, sizeof outrel);
1129 /* h->dynindx may be -1 if the symbol was marked to
1130 become local. */
1131 else if (h != NULL
1132 && ((! info->symbolic && h->dynindx != -1)
1133 || !h->def_regular))
1134 {
1135 BFD_ASSERT (h->dynindx != -1);
1136 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1137 outrel.r_addend = addend;
1138 }
1139 else
1140 {
1141 if (r_type == R_MICROBLAZE_32)
1142 {
1143 outrel.r_info = ELF32_R_INFO (0, R_MICROBLAZE_REL);
1144 outrel.r_addend = relocation + addend;
1145 }
1146 else
1147 {
1148 BFD_FAIL ();
1149 (*_bfd_error_handler)
1150 (_("%B: probably compiled without -fPIC?"),
1151 input_bfd);
1152 bfd_set_error (bfd_error_bad_value);
1153 return FALSE;
1154 }
1155 }
1156
1157 loc = sreloc->contents;
1158 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1159 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1160 break;
1161 }
1162 else
1163 {
1164 relocation += addend;
1165 if (r_type == R_MICROBLAZE_32)
1166 bfd_put_32 (input_bfd, relocation, contents + offset);
1167 else
1168 {
1169 if (r_type == R_MICROBLAZE_64_PCREL)
1170 relocation -= (input_section->output_section->vma
1171 + input_section->output_offset
1172 + offset + INST_WORD_SIZE);
1173 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1174 contents + offset + 2);
1175 bfd_put_16 (input_bfd, relocation & 0xffff,
1176 contents + offset + 2 + INST_WORD_SIZE);
1177 }
1178 break;
1179 }
1180 }
1181
1182 default :
1183 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1184 contents, offset,
1185 relocation, addend);
1186 break;
1187 }
1188 }
1189
1190 check_reloc:
1191
1192 if (r != bfd_reloc_ok)
1193 {
1194 /* FIXME: This should be generic enough to go in a utility. */
1195 const char *name;
1196
1197 if (h != NULL)
1198 name = h->root.root.string;
1199 else
1200 {
1201 name = (bfd_elf_string_from_elf_section
1202 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1203 if (name == NULL || *name == '\0')
1204 name = bfd_section_name (input_bfd, sec);
1205 }
1206
1207 if (errmsg != NULL)
1208 goto common_error;
1209
1210 switch (r)
1211 {
1212 case bfd_reloc_overflow:
1213 if (!((*info->callbacks->reloc_overflow)
1214 (info, (h ? &h->root : NULL), name, howto->name,
1215 (bfd_vma) 0, input_bfd, input_section, offset)))
1216 return FALSE;
1217 break;
1218
1219 case bfd_reloc_undefined:
1220 if (!((*info->callbacks->undefined_symbol)
1221 (info, name, input_bfd, input_section, offset, TRUE)))
1222 return FALSE;
1223 break;
1224
1225 case bfd_reloc_outofrange:
1226 errmsg = _("internal error: out of range error");
1227 goto common_error;
1228
1229 case bfd_reloc_notsupported:
1230 errmsg = _("internal error: unsupported relocation error");
1231 goto common_error;
1232
1233 case bfd_reloc_dangerous:
1234 errmsg = _("internal error: dangerous error");
1235 goto common_error;
1236
1237 default:
1238 errmsg = _("internal error: unknown error");
1239 /* Fall through. */
1240 common_error:
1241 if (!((*info->callbacks->warning)
1242 (info, errmsg, name, input_bfd, input_section, offset)))
1243 return FALSE;
1244 break;
1245 }
1246 }
1247 }
1248
1249 return ret;
1250 }
1251 \f
1252 /* Calculate fixup value for reference. */
1253
1254 static int
1255 calc_fixup (bfd_vma addr, asection *sec)
1256 {
1257 int i, fixup = 0;
1258
1259 if (sec == NULL || sec->relax == NULL)
1260 return 0;
1261
1262 /* Look for addr in relax table, total fixup value. */
1263 for (i = 0; i < sec->relax_count; i++)
1264 {
1265 if (addr <= sec->relax[i].addr)
1266 break;
1267 fixup += sec->relax[i].size;
1268 }
1269
1270 return fixup;
1271 }
1272
1273 static bfd_boolean
1274 microblaze_elf_relax_section (bfd *abfd,
1275 asection *sec,
1276 struct bfd_link_info *link_info,
1277 bfd_boolean *again)
1278 {
1279 Elf_Internal_Shdr *symtab_hdr;
1280 Elf_Internal_Rela *internal_relocs;
1281 Elf_Internal_Rela *free_relocs = NULL;
1282 Elf_Internal_Rela *irel, *irelend;
1283 bfd_byte *contents = NULL;
1284 bfd_byte *free_contents = NULL;
1285 int rel_count;
1286 unsigned int shndx;
1287 int i, index;
1288 asection *o;
1289 struct elf_link_hash_entry *sym_hash;
1290 Elf_Internal_Sym *isymbuf, *isymend;
1291 Elf_Internal_Sym *isym;
1292 int symcount;
1293 int offset;
1294 bfd_vma src, dest;
1295
1296 /* We only do this once per section. We may be able to delete some code
1297 by running multiple passes, but it is not worth it. */
1298 *again = FALSE;
1299
1300 /* Only do this for a text section. */
1301 if (link_info->relocatable
1302 || (sec->flags & SEC_RELOC) == 0
1303 || (sec->reloc_count == 0))
1304 return TRUE;
1305
1306 BFD_ASSERT ((sec->size > 0) || (sec->rawsize > 0));
1307
1308 /* If this is the first time we have been called for this section,
1309 initialize the cooked size. */
1310 if (sec->size == 0)
1311 sec->size = sec->rawsize;
1312
1313 /* Get symbols for this section. */
1314 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1315 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1316 symcount = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
1317 if (isymbuf == NULL)
1318 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, symcount,
1319 0, NULL, NULL, NULL);
1320 BFD_ASSERT (isymbuf != NULL);
1321
1322 internal_relocs = _bfd_elf_link_read_relocs
1323 (abfd, sec, NULL, NULL, link_info->keep_memory);
1324 if (internal_relocs == NULL)
1325 goto error_return;
1326 if (! link_info->keep_memory)
1327 free_relocs = internal_relocs;
1328
1329 sec->relax = (struct relax_table *) bfd_malloc ((sec->reloc_count + 1)
1330 * sizeof (struct relax_table));
1331 if (sec->relax == NULL)
1332 goto error_return;
1333 sec->relax_count = 0;
1334
1335 irelend = internal_relocs + sec->reloc_count;
1336 rel_count = 0;
1337 for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1338 {
1339 bfd_vma symval;
1340 if ((ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64_PCREL)
1341 && (ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64 ))
1342 continue; /* Can't delete this reloc. */
1343
1344 /* Get the section contents. */
1345 if (contents == NULL)
1346 {
1347 if (elf_section_data (sec)->this_hdr.contents != NULL)
1348 contents = elf_section_data (sec)->this_hdr.contents;
1349 else
1350 {
1351 contents = (bfd_byte *) bfd_malloc (sec->size);
1352 if (contents == NULL)
1353 goto error_return;
1354 free_contents = contents;
1355
1356 if (!bfd_get_section_contents (abfd, sec, contents,
1357 (file_ptr) 0, sec->size))
1358 goto error_return;
1359 elf_section_data (sec)->this_hdr.contents = contents;
1360 }
1361 }
1362
1363 /* Get the value of the symbol referred to by the reloc. */
1364 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1365 {
1366 /* A local symbol. */
1367 Elf_Internal_Sym *isym;
1368 asection *sym_sec;
1369
1370 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1371 if (isym->st_shndx == SHN_UNDEF)
1372 sym_sec = bfd_und_section_ptr;
1373 else if (isym->st_shndx == SHN_ABS)
1374 sym_sec = bfd_abs_section_ptr;
1375 else if (isym->st_shndx == SHN_COMMON)
1376 sym_sec = bfd_com_section_ptr;
1377 else
1378 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1379
1380 symval = _bfd_elf_rela_local_sym (abfd, isym, &sym_sec, irel);
1381 }
1382 else
1383 {
1384 unsigned long indx;
1385 struct elf_link_hash_entry *h;
1386
1387 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1388 h = elf_sym_hashes (abfd)[indx];
1389 BFD_ASSERT (h != NULL);
1390
1391 if (h->root.type != bfd_link_hash_defined
1392 && h->root.type != bfd_link_hash_defweak)
1393 /* This appears to be a reference to an undefined
1394 symbol. Just ignore it--it will be caught by the
1395 regular reloc processing. */
1396 continue;
1397
1398 symval = (h->root.u.def.value
1399 + h->root.u.def.section->output_section->vma
1400 + h->root.u.def.section->output_offset);
1401 }
1402
1403 /* If this is a PC-relative reloc, subtract the instr offset from
1404 the symbol value. */
1405 if (ELF32_R_TYPE (irel->r_info) == (int) R_MICROBLAZE_64_PCREL)
1406 {
1407 symval = symval + irel->r_addend
1408 - (irel->r_offset
1409 + sec->output_section->vma
1410 + sec->output_offset);
1411 }
1412 else
1413 symval += irel->r_addend;
1414
1415 if ((symval & 0xffff8000) == 0
1416 || (symval & 0xffff8000) == 0xffff8000)
1417 {
1418 /* We can delete this instruction. */
1419 sec->relax[sec->relax_count].addr = irel->r_offset;
1420 sec->relax[sec->relax_count].size = INST_WORD_SIZE;
1421 sec->relax_count++;
1422
1423 /* Rewrite relocation type. */
1424 switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1425 {
1426 case R_MICROBLAZE_64_PCREL:
1427 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1428 (int) R_MICROBLAZE_32_PCREL_LO);
1429 break;
1430 case R_MICROBLAZE_64:
1431 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1432 (int) R_MICROBLAZE_32_LO);
1433 break;
1434 default:
1435 /* Cannot happen. */
1436 BFD_ASSERT (FALSE);
1437 }
1438 }
1439 } /* Loop through all relocations. */
1440
1441 /* Loop through the relocs again, and see if anything needs to change. */
1442 if (sec->relax_count > 0)
1443 {
1444 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1445 rel_count = 0;
1446 sec->relax[sec->relax_count].addr = sec->size;
1447
1448 for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1449 {
1450 bfd_vma nraddr;
1451
1452 /* Get the new reloc address. */
1453 nraddr = irel->r_offset - calc_fixup (irel->r_offset, sec);
1454 switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1455 {
1456 default:
1457 break;
1458 case R_MICROBLAZE_64_PCREL:
1459 break;
1460 case R_MICROBLAZE_64:
1461 case R_MICROBLAZE_32_LO:
1462 /* If this reloc is against a symbol defined in this
1463 section, we must check the addend to see it will put the value in
1464 range to be adjusted, and hence must be changed. */
1465 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1466 {
1467 Elf_Internal_Sym *isym;
1468 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1469 /* Only handle relocs against .text. */
1470 if (isym->st_shndx == shndx
1471 && ELF32_ST_TYPE (isym->st_info) == STT_SECTION)
1472 irel->r_addend -= calc_fixup (irel->r_addend, sec);
1473 }
1474 break;
1475 case R_MICROBLAZE_NONE:
1476 {
1477 /* This was a PC-relative instruction that was
1478 completely resolved. */
1479 int sfix, efix;
1480 bfd_vma target_address;
1481 target_address = irel->r_addend + irel->r_offset;
1482 sfix = calc_fixup (irel->r_offset, sec);
1483 efix = calc_fixup (target_address, sec);
1484 irel->r_addend -= (efix - sfix);
1485 /* Should use HOWTO. */
1486 bfd_put_16 (abfd, irel->r_addend, contents + irel->r_offset + 2);
1487 }
1488 break;
1489 case R_MICROBLAZE_64_NONE:
1490 {
1491 /* This was a PC-relative 64-bit instruction that was
1492 completely resolved. */
1493 int sfix, efix;
1494 bfd_vma target_address;
1495 target_address = irel->r_addend + irel->r_offset + INST_WORD_SIZE;
1496 sfix = calc_fixup (irel->r_offset + INST_WORD_SIZE, sec);
1497 efix = calc_fixup (target_address, sec);
1498 irel->r_addend -= (efix - sfix);
1499 bfd_put_16 (abfd, irel->r_addend, contents + irel->r_offset
1500 + INST_WORD_SIZE + 2);
1501 }
1502 break;
1503 }
1504 irel->r_offset = nraddr;
1505 } /* Change all relocs in this section. */
1506
1507 /* Look through all other sections. */
1508 for (o = abfd->sections; o != NULL; o = o->next)
1509 {
1510 Elf_Internal_Rela *internal_relocs;
1511 Elf_Internal_Rela *irelscan, *irelscanend;
1512 bfd_byte *ocontents;
1513
1514 if (o == sec
1515 || (o->flags & SEC_RELOC) == 0
1516 || o->reloc_count == 0)
1517 continue;
1518
1519 /* We always cache the relocs. Perhaps, if info->keep_memory is
1520 FALSE, we should free them, if we are permitted to. */
1521
1522 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, TRUE);
1523 if (internal_relocs == NULL)
1524 goto error_return;
1525
1526 ocontents = NULL;
1527 irelscanend = internal_relocs + o->reloc_count;
1528 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1529 {
1530 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32)
1531 {
1532 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1533
1534 /* Look at the reloc only if the value has been resolved. */
1535 if (isym->st_shndx == shndx
1536 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1537 {
1538 if (ocontents == NULL)
1539 {
1540 if (elf_section_data (o)->this_hdr.contents != NULL)
1541 ocontents = elf_section_data (o)->this_hdr.contents;
1542 else
1543 {
1544 /* We always cache the section contents.
1545 Perhaps, if info->keep_memory is FALSE, we
1546 should free them, if we are permitted to. */
1547 if (o->rawsize == 0)
1548 o->rawsize = o->size;
1549 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1550 if (ocontents == NULL)
1551 goto error_return;
1552 if (!bfd_get_section_contents (abfd, o, ocontents,
1553 (file_ptr) 0,
1554 o->rawsize))
1555 goto error_return;
1556 elf_section_data (o)->this_hdr.contents = ocontents;
1557 }
1558
1559 }
1560 irelscan->r_addend -= calc_fixup (irelscan->r_addend, sec);
1561 }
1562 else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_SYM_OP_SYM)
1563 {
1564 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1565
1566 /* Look at the reloc only if the value has been resolved. */
1567 if (ocontents == NULL)
1568 {
1569 if (elf_section_data (o)->this_hdr.contents != NULL)
1570 ocontents = elf_section_data (o)->this_hdr.contents;
1571 else
1572 {
1573 /* We always cache the section contents.
1574 Perhaps, if info->keep_memory is FALSE, we
1575 should free them, if we are permitted to. */
1576
1577 if (o->rawsize == 0)
1578 o->rawsize = o->size;
1579 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1580 if (ocontents == NULL)
1581 goto error_return;
1582 if (!bfd_get_section_contents (abfd, o, ocontents,
1583 (file_ptr) 0,
1584 o->rawsize))
1585 goto error_return;
1586 elf_section_data (o)->this_hdr.contents = ocontents;
1587 }
1588 }
1589 irelscan->r_addend -= calc_fixup (irel->r_addend
1590 + isym->st_value,
1591 sec);
1592 }
1593 }
1594 else if ((ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_PCREL_LO)
1595 || (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_LO))
1596 {
1597 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1598
1599 /* Look at the reloc only if the value has been resolved. */
1600 if (isym->st_shndx == shndx
1601 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1602 {
1603 bfd_vma immediate;
1604 bfd_vma target_address;
1605
1606 if (ocontents == NULL)
1607 {
1608 if (elf_section_data (o)->this_hdr.contents != NULL)
1609 ocontents = elf_section_data (o)->this_hdr.contents;
1610 else
1611 {
1612 /* We always cache the section contents.
1613 Perhaps, if info->keep_memory is FALSE, we
1614 should free them, if we are permitted to. */
1615 if (o->rawsize == 0)
1616 o->rawsize = o->size;
1617 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1618 if (ocontents == NULL)
1619 goto error_return;
1620 if (!bfd_get_section_contents (abfd, o, ocontents,
1621 (file_ptr) 0,
1622 o->rawsize))
1623 goto error_return;
1624 elf_section_data (o)->this_hdr.contents = ocontents;
1625 }
1626 }
1627
1628 immediate = (unsigned short) bfd_get_16 (abfd, ocontents +
1629 irelscan->r_offset + 2);
1630 target_address = immediate;
1631 offset = calc_fixup (target_address, sec);
1632 immediate -= offset;
1633 irelscan->r_addend -= offset;
1634 bfd_put_16 (abfd, immediate, ocontents + irelscan->r_offset + 2);
1635 }
1636 }
1637
1638 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64)
1639 {
1640 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1641
1642 /* Look at the reloc only if the value has been resolved. */
1643 if (isym->st_shndx == shndx
1644 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1645 {
1646 bfd_vma immediate;
1647
1648 if (ocontents == NULL)
1649 {
1650 if (elf_section_data (o)->this_hdr.contents != NULL)
1651 ocontents = elf_section_data (o)->this_hdr.contents;
1652 else
1653 {
1654 /* We always cache the section contents.
1655 Perhaps, if info->keep_memory is FALSE, we
1656 should free them, if we are permitted to. */
1657
1658 if (o->rawsize == 0)
1659 o->rawsize = o->size;
1660 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1661 if (ocontents == NULL)
1662 goto error_return;
1663 if (!bfd_get_section_contents (abfd, o, ocontents,
1664 (file_ptr) 0,
1665 o->rawsize))
1666 goto error_return;
1667 elf_section_data (o)->this_hdr.contents = ocontents;
1668 }
1669 }
1670 immediate = (unsigned short) (bfd_get_16 (abfd, ocontents
1671 + irelscan->r_offset
1672 + 2) << 16)
1673 & 0xffff0000;
1674 immediate += (unsigned short) (bfd_get_16 (abfd, ocontents
1675 + irelscan->r_offset
1676 + INST_WORD_SIZE + 2))
1677 & 0x0000ffff;
1678
1679 offset = calc_fixup (irelscan->r_addend, sec);
1680 immediate -= offset;
1681 irelscan->r_addend -= offset;
1682 }
1683 }
1684 else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64_PCREL)
1685 {
1686 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1687
1688 /* Look at the reloc only if the value has been resolved. */
1689 if (isym->st_shndx == shndx
1690 && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1691 {
1692 bfd_vma immediate;
1693 bfd_vma target_address;
1694
1695 if (ocontents == NULL)
1696 {
1697 if (elf_section_data (o)->this_hdr.contents != NULL)
1698 ocontents = elf_section_data (o)->this_hdr.contents;
1699 else
1700 {
1701 /* We always cache the section contents.
1702 Perhaps, if info->keep_memory is FALSE, we
1703 should free them, if we are permitted to. */
1704 if (o->rawsize == 0)
1705 o->rawsize = o->size;
1706 ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1707 if (ocontents == NULL)
1708 goto error_return;
1709 if (!bfd_get_section_contents (abfd, o, ocontents,
1710 (file_ptr) 0,
1711 o->rawsize))
1712 goto error_return;
1713 elf_section_data (o)->this_hdr.contents = ocontents;
1714 }
1715 }
1716
1717 immediate = (unsigned short)
1718 (bfd_get_16 (abfd, ocontents + irelscan->r_offset + 2) << 16)
1719 & 0xffff0000;
1720 immediate += (unsigned short)
1721 (bfd_get_16 (abfd, ocontents + irelscan->r_offset
1722 + INST_WORD_SIZE + 2))
1723 & 0x0000ffff;
1724 target_address = immediate;
1725 offset = calc_fixup (target_address, sec);
1726 immediate -= offset;
1727 irelscan->r_addend -= offset;
1728 bfd_put_16 (abfd, ((immediate >> 16) & 0x0000ffff),
1729 ocontents + irelscan->r_offset + 2);
1730 bfd_put_16 (abfd, (immediate & 0x0000ffff),
1731 ocontents + irelscan->r_offset + INST_WORD_SIZE + 2);
1732 }
1733 }
1734 }
1735 }
1736
1737 /* Adjust the local symbols defined in this section. */
1738 isymend = isymbuf + symtab_hdr->sh_info;
1739 for (isym = isymbuf; isym < isymend; isym++)
1740 {
1741 if (isym->st_shndx == shndx)
1742 isym->st_value =- calc_fixup (isym->st_value, sec);
1743 }
1744
1745 /* Now adjust the global symbols defined in this section. */
1746 isym = isymbuf + symtab_hdr->sh_info;
1747 isymend = isymbuf + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1748 for (index = 0; isym < isymend; isym++, index++)
1749 {
1750 sym_hash = elf_sym_hashes (abfd)[index];
1751 if (isym->st_shndx == shndx
1752 && (sym_hash->root.type == bfd_link_hash_defined
1753 || sym_hash->root.type == bfd_link_hash_defweak)
1754 && sym_hash->root.u.def.section == sec)
1755 {
1756 sym_hash->root.u.def.value -= calc_fixup (sym_hash->root.u.def.value,
1757 sec);
1758 }
1759 }
1760
1761 /* Physically move the code and change the cooked size. */
1762 dest = sec->relax[0].addr;
1763 for (i = 0; i < sec->relax_count; i++)
1764 {
1765 int len;
1766 src = sec->relax[i].addr + sec->relax[i].size;
1767 len = sec->relax[i+1].addr - sec->relax[i].addr - sec->relax[i].size;
1768
1769 memmove (contents + dest, contents + src, len);
1770 sec->size -= sec->relax[i].size;
1771 dest += len;
1772 }
1773
1774 elf_section_data (sec)->relocs = internal_relocs;
1775 free_relocs = NULL;
1776
1777 elf_section_data (sec)->this_hdr.contents = contents;
1778 free_contents = NULL;
1779
1780 symtab_hdr->contents = (bfd_byte *) isymbuf;
1781 }
1782
1783 if (free_relocs != NULL)
1784 {
1785 free (free_relocs);
1786 free_relocs = NULL;
1787 }
1788
1789 if (free_contents != NULL)
1790 {
1791 if (!link_info->keep_memory)
1792 free (free_contents);
1793 else
1794 /* Cache the section contents for elf_link_input_bfd. */
1795 elf_section_data (sec)->this_hdr.contents = contents;
1796 free_contents = NULL;
1797 }
1798
1799 if (sec->relax_count == 0)
1800 {
1801 free (sec->relax);
1802 sec->relax = NULL;
1803 }
1804 return TRUE;
1805
1806 error_return:
1807 if (free_relocs != NULL)
1808 free (free_relocs);
1809 if (free_contents != NULL)
1810 free (free_contents);
1811 if (sec->relax != NULL)
1812 {
1813 free (sec->relax);
1814 sec->relax = NULL;
1815 sec->relax_count = 0;
1816 }
1817 return FALSE;
1818 }
1819
1820 /* Return the section that should be marked against GC for a given
1821 relocation. */
1822
1823 static asection *
1824 microblaze_elf_gc_mark_hook (asection *sec,
1825 struct bfd_link_info * info ATTRIBUTE_UNUSED,
1826 Elf_Internal_Rela * rel,
1827 struct elf_link_hash_entry * h,
1828 Elf_Internal_Sym * sym)
1829 {
1830 if (h != NULL)
1831 {
1832 switch (ELF32_R_TYPE (rel->r_info))
1833 {
1834 case R_MICROBLAZE_GNU_VTINHERIT:
1835 case R_MICROBLAZE_GNU_VTENTRY:
1836 break;
1837
1838 default:
1839 switch (h->root.type)
1840 {
1841 case bfd_link_hash_defined:
1842 case bfd_link_hash_defweak:
1843 return h->root.u.def.section;
1844
1845 case bfd_link_hash_common:
1846 return h->root.u.c.p->section;
1847
1848 default:
1849 break;
1850 }
1851 }
1852 }
1853 else
1854 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1855
1856 return NULL;
1857 }
1858
1859 /* Update the got entry reference counts for the section being removed. */
1860
1861 static bfd_boolean
1862 microblaze_elf_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
1863 struct bfd_link_info * info ATTRIBUTE_UNUSED,
1864 asection * sec ATTRIBUTE_UNUSED,
1865 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
1866 {
1867 return TRUE;
1868 }
1869
1870 /* PIC support. */
1871
1872 #define PLT_ENTRY_SIZE 16
1873
1874 #define PLT_ENTRY_WORD_0 0xb0000000 /* "imm 0". */
1875 #define PLT_ENTRY_WORD_1 0xe9940000 /* "lwi r12,r20,0" - relocated to lwi r12,r20,func@GOT. */
1876 #define PLT_ENTRY_WORD_1_NOPIC 0xe9800000 /* "lwi r12,r0,0" - non-PIC object. */
1877 #define PLT_ENTRY_WORD_2 0x98186000 /* "brad r12". */
1878 #define PLT_ENTRY_WORD_3 0x80000000 /* "nop". */
1879
1880 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1881 shortcuts to them in our hash table. */
1882
1883 static bfd_boolean
1884 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1885 {
1886 struct elf32_mb_link_hash_table *htab;
1887
1888 if (! _bfd_elf_create_got_section (dynobj, info))
1889 return FALSE;
1890 htab = elf32_mb_hash_table (info);
1891 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1892 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1893 if (!htab->sgot || !htab->sgotplt)
1894 return FALSE;
1895
1896 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
1897 if (htab->srelgot == NULL
1898 || ! bfd_set_section_flags (dynobj, htab->srelgot, SEC_ALLOC
1899 | SEC_LOAD
1900 | SEC_HAS_CONTENTS
1901 | SEC_IN_MEMORY
1902 | SEC_LINKER_CREATED
1903 | SEC_READONLY)
1904 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1905 return FALSE;
1906 return TRUE;
1907 }
1908
1909 /* Look through the relocs for a section during the first phase. */
1910
1911 static bfd_boolean
1912 microblaze_elf_check_relocs (bfd * abfd,
1913 struct bfd_link_info * info,
1914 asection * sec,
1915 const Elf_Internal_Rela * relocs)
1916 {
1917 Elf_Internal_Shdr * symtab_hdr;
1918 struct elf_link_hash_entry ** sym_hashes;
1919 struct elf_link_hash_entry ** sym_hashes_end;
1920 const Elf_Internal_Rela * rel;
1921 const Elf_Internal_Rela * rel_end;
1922 struct elf32_mb_link_hash_table *htab;
1923 bfd_vma *local_got_offsets;
1924 asection *sreloc = NULL;
1925
1926 if (info->relocatable)
1927 return TRUE;
1928
1929 htab = elf32_mb_hash_table (info);
1930 local_got_offsets = elf_local_got_offsets (abfd);
1931 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1932 sym_hashes = elf_sym_hashes (abfd);
1933 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
1934 if (!elf_bad_symtab (abfd))
1935 sym_hashes_end -= symtab_hdr->sh_info;
1936
1937 rel_end = relocs + sec->reloc_count;
1938
1939 for (rel = relocs; rel < rel_end; rel++)
1940 {
1941 unsigned int r_type;
1942 struct elf_link_hash_entry * h;
1943 unsigned long r_symndx;
1944
1945 r_symndx = ELF32_R_SYM (rel->r_info);
1946 r_type = ELF32_R_TYPE (rel->r_info);
1947
1948 if (r_symndx < symtab_hdr->sh_info)
1949 h = NULL;
1950 else
1951 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
1952
1953 switch (r_type)
1954 {
1955 /* This relocation describes the C++ object vtable hierarchy.
1956 Reconstruct it for later use during GC. */
1957 case R_MICROBLAZE_GNU_VTINHERIT:
1958 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1959 return FALSE;
1960 break;
1961
1962 /* This relocation describes which C++ vtable entries are actually
1963 used. Record for later use during GC. */
1964 case R_MICROBLAZE_GNU_VTENTRY:
1965 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1966 return FALSE;
1967 break;
1968
1969 /* This relocation requires .plt entry. */
1970 case R_MICROBLAZE_PLT_64:
1971 if (h != NULL)
1972 {
1973 h->needs_plt = 1;
1974 h->plt.refcount += 1;
1975 }
1976 break;
1977
1978 /* This relocation requires .got entry. */
1979 case R_MICROBLAZE_GOT_64:
1980 if (htab->sgot == NULL)
1981 {
1982 if (htab->elf.dynobj == NULL)
1983 htab->elf.dynobj = abfd;
1984 if (!create_got_section (htab->elf.dynobj, info))
1985 return FALSE;
1986 }
1987 if (h != NULL)
1988 {
1989 h->got.refcount += 1;
1990 }
1991 else
1992 {
1993 bfd_signed_vma *local_got_refcounts;
1994
1995 /* This is a global offset table entry for a local symbol. */
1996 local_got_refcounts = elf_local_got_refcounts (abfd);
1997 if (local_got_refcounts == NULL)
1998 {
1999 bfd_size_type size;
2000
2001 size = symtab_hdr->sh_info;
2002 size *= sizeof (bfd_signed_vma);
2003 local_got_refcounts = bfd_zalloc (abfd, size);
2004 if (local_got_refcounts == NULL)
2005 return FALSE;
2006 elf_local_got_refcounts (abfd) = local_got_refcounts;
2007 }
2008 local_got_refcounts[r_symndx] += 1;
2009 }
2010 break;
2011
2012 case R_MICROBLAZE_64:
2013 case R_MICROBLAZE_64_PCREL:
2014 case R_MICROBLAZE_32:
2015 {
2016 if (h != NULL && !info->shared)
2017 {
2018 /* we may need a copy reloc. */
2019 h->non_got_ref = 1;
2020
2021 /* we may also need a .plt entry. */
2022 h->plt.refcount += 1;
2023 if (ELF32_R_TYPE (rel->r_info) != R_MICROBLAZE_64_PCREL)
2024 h->pointer_equality_needed = 1;
2025 }
2026
2027
2028 /* If we are creating a shared library, and this is a reloc
2029 against a global symbol, or a non PC relative reloc
2030 against a local symbol, then we need to copy the reloc
2031 into the shared library. However, if we are linking with
2032 -Bsymbolic, we do not need to copy a reloc against a
2033 global symbol which is defined in an object we are
2034 including in the link (i.e., DEF_REGULAR is set). At
2035 this point we have not seen all the input files, so it is
2036 possible that DEF_REGULAR is not set now but will be set
2037 later (it is never cleared). In case of a weak definition,
2038 DEF_REGULAR may be cleared later by a strong definition in
2039 a shared library. We account for that possibility below by
2040 storing information in the relocs_copied field of the hash
2041 table entry. A similar situation occurs when creating
2042 shared libraries and symbol visibility changes render the
2043 symbol local.
2044
2045 If on the other hand, we are creating an executable, we
2046 may need to keep relocations for symbols satisfied by a
2047 dynamic library if we manage to avoid copy relocs for the
2048 symbol. */
2049
2050 if ((info->shared
2051 && (sec->flags & SEC_ALLOC) != 0
2052 && (r_type != R_MICROBLAZE_64_PCREL
2053 || (h != NULL
2054 && (! info->symbolic
2055 || h->root.type == bfd_link_hash_defweak
2056 || !h->def_regular))))
2057 || (!info->shared
2058 && (sec->flags & SEC_ALLOC) != 0
2059 && h != NULL
2060 && (h->root.type == bfd_link_hash_defweak
2061 || !h->def_regular)))
2062 {
2063 struct elf32_mb_dyn_relocs *p;
2064 struct elf32_mb_dyn_relocs **head;
2065
2066 /* When creating a shared object, we must copy these
2067 relocs into the output file. We create a reloc
2068 section in dynobj and make room for the reloc. */
2069
2070 if (sreloc == NULL)
2071 {
2072 const char *name;
2073 bfd *dynobj;
2074 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
2075 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
2076
2077 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
2078 if (name == NULL)
2079 return FALSE;
2080
2081 if (strncmp (name, ".rela", 5) != 0
2082 || strcmp (bfd_get_section_name (abfd, sec),
2083 name + 5) != 0)
2084 {
2085 (*_bfd_error_handler)
2086 (_("%B: bad relocation section name `%s\'"),
2087 abfd, name);
2088 }
2089
2090 if (htab->elf.dynobj == NULL)
2091 htab->elf.dynobj = abfd;
2092 dynobj = htab->elf.dynobj;
2093
2094 sreloc = bfd_get_section_by_name (dynobj, name);
2095 if (sreloc == NULL)
2096 {
2097 flagword flags;
2098
2099 sreloc = bfd_make_section (dynobj, name);
2100 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2101 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2102 if ((sec->flags & SEC_ALLOC) != 0)
2103 flags |= SEC_ALLOC | SEC_LOAD;
2104 if (sreloc == NULL
2105 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2106 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2107 return FALSE;
2108 }
2109 elf_section_data (sec)->sreloc = sreloc;
2110 }
2111
2112 /* If this is a global symbol, we count the number of
2113 relocations we need for this symbol. */
2114 if (h != NULL)
2115 head = &((struct elf32_mb_link_hash_entry *) h)->dyn_relocs;
2116 else
2117 {
2118 /* Track dynamic relocs needed for local syms too.
2119 We really need local syms available to do this
2120 easily. Oh well. */
2121
2122 asection *s;
2123 Elf_Internal_Sym *isym;
2124 void *vpp;
2125
2126 isym = bfd_sym_from_r_symndx (&htab->sym_sec,
2127 abfd, r_symndx);
2128 if (isym == NULL)
2129 return FALSE;
2130
2131 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2132 if (s == NULL)
2133 return FALSE;
2134
2135 vpp = &elf_section_data (s)->local_dynrel;
2136 head = (struct elf32_mb_dyn_relocs **) vpp;
2137 }
2138
2139 p = *head;
2140 if (p == NULL || p->sec != sec)
2141 {
2142 bfd_size_type amt = sizeof *p;
2143 p = ((struct elf32_mb_dyn_relocs *)
2144 bfd_alloc (htab->elf.dynobj, amt));
2145 if (p == NULL)
2146 return FALSE;
2147 p->next = *head;
2148 *head = p;
2149 p->sec = sec;
2150 p->count = 0;
2151 p->pc_count = 0;
2152 }
2153
2154 p->count += 1;
2155 if (r_type == R_MICROBLAZE_64_PCREL)
2156 p->pc_count += 1;
2157 }
2158 }
2159 break;
2160 }
2161 }
2162
2163 return TRUE;
2164 }
2165
2166 static bfd_boolean
2167 microblaze_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2168 {
2169 struct elf32_mb_link_hash_table *htab;
2170
2171 htab = elf32_mb_hash_table (info);
2172 if (!htab->sgot && !create_got_section (dynobj, info))
2173 return FALSE;
2174
2175 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2176 return FALSE;
2177
2178 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2179 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2180 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2181 if (!info->shared)
2182 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
2183
2184 if (!htab->splt || !htab->srelplt || !htab->sdynbss
2185 || (!info->shared && !htab->srelbss))
2186 abort ();
2187
2188 return TRUE;
2189 }
2190
2191 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2192
2193 static void
2194 microblaze_elf_copy_indirect_symbol (struct bfd_link_info *info,
2195 struct elf_link_hash_entry *dir,
2196 struct elf_link_hash_entry *ind)
2197 {
2198 struct elf32_mb_link_hash_entry *edir, *eind;
2199
2200 edir = (struct elf32_mb_link_hash_entry *) dir;
2201 eind = (struct elf32_mb_link_hash_entry *) ind;
2202
2203 if (eind->dyn_relocs != NULL)
2204 {
2205 if (edir->dyn_relocs != NULL)
2206 {
2207 struct elf32_mb_dyn_relocs **pp;
2208 struct elf32_mb_dyn_relocs *p;
2209
2210 if (ind->root.type == bfd_link_hash_indirect)
2211 abort ();
2212
2213 /* Add reloc counts against the weak sym to the strong sym
2214 list. Merge any entries against the same section. */
2215 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2216 {
2217 struct elf32_mb_dyn_relocs *q;
2218
2219 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2220 if (q->sec == p->sec)
2221 {
2222 q->pc_count += p->pc_count;
2223 q->count += p->count;
2224 *pp = p->next;
2225 break;
2226 }
2227 if (q == NULL)
2228 pp = &p->next;
2229 }
2230 *pp = edir->dyn_relocs;
2231 }
2232
2233 edir->dyn_relocs = eind->dyn_relocs;
2234 eind->dyn_relocs = NULL;
2235 }
2236
2237 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2238 }
2239
2240 static bfd_boolean
2241 microblaze_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2242 struct elf_link_hash_entry *h)
2243 {
2244 struct elf32_mb_link_hash_table *htab;
2245 struct elf32_mb_link_hash_entry * eh;
2246 struct elf32_mb_dyn_relocs *p;
2247 asection *sdynbss, *s;
2248 unsigned int power_of_two;
2249 bfd *dynobj;
2250
2251 htab = elf32_mb_hash_table (info);
2252
2253 /* If this is a function, put it in the procedure linkage table. We
2254 will fill in the contents of the procedure linkage table later,
2255 when we know the address of the .got section. */
2256 if (h->type == STT_FUNC
2257 || h->needs_plt)
2258 {
2259 if (h->plt.refcount <= 0
2260 || SYMBOL_CALLS_LOCAL (info, h)
2261 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2262 && h->root.type == bfd_link_hash_undefweak))
2263 {
2264 /* This case can occur if we saw a PLT reloc in an input
2265 file, but the symbol was never referred to by a dynamic
2266 object, or if all references were garbage collected. In
2267 such a case, we don't actually need to build a procedure
2268 linkage table, and we can just do a PC32 reloc instead. */
2269 h->plt.offset = (bfd_vma) -1;
2270 h->needs_plt = 0;
2271 }
2272
2273 return TRUE;
2274 }
2275 else
2276 /* It's possible that we incorrectly decided a .plt reloc was
2277 needed for an R_MICROBLAZE_64_PCREL reloc to a non-function sym in
2278 check_relocs. We can't decide accurately between function and
2279 non-function syms in check-relocs; Objects loaded later in
2280 the link may change h->type. So fix it now. */
2281 h->plt.offset = (bfd_vma) -1;
2282
2283 /* If this is a weak symbol, and there is a real definition, the
2284 processor independent code will have arranged for us to see the
2285 real definition first, and we can just use the same value. */
2286 if (h->u.weakdef != NULL)
2287 {
2288 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2289 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2290 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2291 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2292 return TRUE;
2293 }
2294
2295 /* This is a reference to a symbol defined by a dynamic object which
2296 is not a function. */
2297
2298 /* If we are creating a shared library, we must presume that the
2299 only references to the symbol are via the global offset table.
2300 For such cases we need not do anything here; the relocations will
2301 be handled correctly by relocate_section. */
2302 if (info->shared)
2303 return TRUE;
2304
2305 /* If there are no references to this symbol that do not use the
2306 GOT, we don't need to generate a copy reloc. */
2307 if (!h->non_got_ref)
2308 return TRUE;
2309
2310 /* If -z nocopyreloc was given, we won't generate them either. */
2311 if (info->nocopyreloc)
2312 {
2313 h->non_got_ref = 0;
2314 return TRUE;
2315 }
2316
2317 eh = (struct elf32_mb_link_hash_entry *) h;
2318 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2319 {
2320 s = p->sec->output_section;
2321 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2322 break;
2323 }
2324
2325 /* If we didn't find any dynamic relocs in read-only sections, then
2326 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2327 if (p == NULL)
2328 {
2329 h->non_got_ref = 0;
2330 return TRUE;
2331 }
2332
2333 /* We must allocate the symbol in our .dynbss section, which will
2334 become part of the .bss section of the executable. There will be
2335 an entry for this symbol in the .dynsym section. The dynamic
2336 object will contain position independent code, so all references
2337 from the dynamic object to this symbol will go through the global
2338 offset table. The dynamic linker will use the .dynsym entry to
2339 determine the address it must put in the global offset table, so
2340 both the dynamic object and the regular object will refer to the
2341 same memory location for the variable. */
2342
2343 /* We must generate a R_MICROBLAZE_COPY reloc to tell the dynamic linker
2344 to copy the initial value out of the dynamic object and into the
2345 runtime process image. */
2346 dynobj = elf_hash_table (info)->dynobj;
2347 BFD_ASSERT (dynobj != NULL);
2348 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2349 {
2350 htab->srelbss->size += sizeof (Elf32_External_Rela);
2351 h->needs_copy = 1;
2352 }
2353
2354 /* We need to figure out the alignment required for this symbol. I
2355 have no idea how ELF linkers handle this. */
2356 power_of_two = bfd_log2 (h->size);
2357 if (power_of_two > 3)
2358 power_of_two = 3;
2359
2360 sdynbss = htab->sdynbss;
2361 /* Apply the required alignment. */
2362 sdynbss->size = BFD_ALIGN (sdynbss->size, (bfd_size_type) (1 << power_of_two));
2363 if (power_of_two > bfd_get_section_alignment (dynobj, sdynbss))
2364 {
2365 if (! bfd_set_section_alignment (dynobj, sdynbss, power_of_two))
2366 return FALSE;
2367 }
2368
2369 /* Define the symbol as being at this point in the section. */
2370 h->root.u.def.section = sdynbss;
2371 h->root.u.def.value = sdynbss->size;
2372
2373 /* Increment the section size to make room for the symbol. */
2374 sdynbss->size += h->size;
2375 return TRUE;
2376 }
2377
2378 /* Allocate space in .plt, .got and associated reloc sections for
2379 dynamic relocs. */
2380
2381 static bfd_boolean
2382 allocate_dynrelocs (struct elf_link_hash_entry *h, void * dat)
2383 {
2384 struct bfd_link_info *info;
2385 struct elf32_mb_link_hash_table *htab;
2386 struct elf32_mb_link_hash_entry *eh;
2387 struct elf32_mb_dyn_relocs *p;
2388
2389 if (h->root.type == bfd_link_hash_indirect)
2390 return TRUE;
2391
2392 if (h->root.type == bfd_link_hash_warning)
2393 /* When warning symbols are created, they **replace** the "real"
2394 entry in the hash table, thus we never get to see the real
2395 symbol in a hash traversal. So look at it now. */
2396 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2397
2398 info = (struct bfd_link_info *) dat;
2399 htab = elf32_mb_hash_table (info);
2400
2401 if (htab->elf.dynamic_sections_created
2402 && h->plt.refcount > 0)
2403 {
2404 /* Make sure this symbol is output as a dynamic symbol.
2405 Undefined weak syms won't yet be marked as dynamic. */
2406 if (h->dynindx == -1
2407 && !h->forced_local)
2408 {
2409 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2410 return FALSE;
2411 }
2412
2413 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2414 {
2415 asection *s = htab->splt;
2416
2417 /* The first entry in .plt is reserved. */
2418 if (s->size == 0)
2419 s->size = PLT_ENTRY_SIZE;
2420
2421 h->plt.offset = s->size;
2422
2423 /* If this symbol is not defined in a regular file, and we are
2424 not generating a shared library, then set the symbol to this
2425 location in the .plt. This is required to make function
2426 pointers compare as equal between the normal executable and
2427 the shared library. */
2428 if (! info->shared
2429 && !h->def_regular)
2430 {
2431 h->root.u.def.section = s;
2432 h->root.u.def.value = h->plt.offset;
2433 }
2434
2435 /* Make room for this entry. */
2436 s->size += PLT_ENTRY_SIZE;
2437
2438 /* We also need to make an entry in the .got.plt section, which
2439 will be placed in the .got section by the linker script. */
2440 htab->sgotplt->size += 4;
2441
2442 /* We also need to make an entry in the .rel.plt section. */
2443 htab->srelplt->size += sizeof (Elf32_External_Rela);
2444 }
2445 else
2446 {
2447 h->plt.offset = (bfd_vma) -1;
2448 h->needs_plt = 0;
2449 }
2450 }
2451 else
2452 {
2453 h->plt.offset = (bfd_vma) -1;
2454 h->needs_plt = 0;
2455 }
2456
2457 if (h->got.refcount > 0)
2458 {
2459 asection *s;
2460
2461 /* Make sure this symbol is output as a dynamic symbol.
2462 Undefined weak syms won't yet be marked as dynamic. */
2463 if (h->dynindx == -1
2464 && !h->forced_local)
2465 {
2466 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2467 return FALSE;
2468 }
2469
2470 s = htab->sgot;
2471 h->got.offset = s->size;
2472 s->size += 4;
2473 htab->srelgot->size += sizeof (Elf32_External_Rela);
2474 }
2475 else
2476 h->got.offset = (bfd_vma) -1;
2477
2478 eh = (struct elf32_mb_link_hash_entry *) h;
2479 if (eh->dyn_relocs == NULL)
2480 return TRUE;
2481
2482 /* In the shared -Bsymbolic case, discard space allocated for
2483 dynamic pc-relative relocs against symbols which turn out to be
2484 defined in regular objects. For the normal shared case, discard
2485 space for pc-relative relocs that have become local due to symbol
2486 visibility changes. */
2487
2488 if (info->shared)
2489 {
2490 if (h->def_regular
2491 && (h->forced_local
2492 || info->symbolic))
2493 {
2494 struct elf32_mb_dyn_relocs **pp;
2495
2496 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2497 {
2498 p->count -= p->pc_count;
2499 p->pc_count = 0;
2500 if (p->count == 0)
2501 *pp = p->next;
2502 else
2503 pp = &p->next;
2504 }
2505 }
2506 }
2507 else
2508 {
2509 /* For the non-shared case, discard space for relocs against
2510 symbols which turn out to need copy relocs or are not
2511 dynamic. */
2512
2513 if (!h->non_got_ref
2514 && ((h->def_dynamic
2515 && !h->def_regular)
2516 || (htab->elf.dynamic_sections_created
2517 && (h->root.type == bfd_link_hash_undefweak
2518 || h->root.type == bfd_link_hash_undefined))))
2519 {
2520 /* Make sure this symbol is output as a dynamic symbol.
2521 Undefined weak syms won't yet be marked as dynamic. */
2522 if (h->dynindx == -1
2523 && !h->forced_local)
2524 {
2525 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2526 return FALSE;
2527 }
2528
2529 /* If that succeeded, we know we'll be keeping all the
2530 relocs. */
2531 if (h->dynindx != -1)
2532 goto keep;
2533 }
2534
2535 eh->dyn_relocs = NULL;
2536
2537 keep: ;
2538 }
2539
2540 /* Finally, allocate space. */
2541 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2542 {
2543 asection *sreloc = elf_section_data (p->sec)->sreloc;
2544 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2545 }
2546
2547 return TRUE;
2548 }
2549
2550 /* Set the sizes of the dynamic sections. */
2551
2552 static bfd_boolean
2553 microblaze_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2554 struct bfd_link_info *info)
2555 {
2556 struct elf32_mb_link_hash_table *htab;
2557 bfd *dynobj;
2558 asection *s;
2559 bfd *ibfd;
2560
2561 htab = elf32_mb_hash_table (info);
2562 dynobj = htab->elf.dynobj;
2563 BFD_ASSERT (dynobj != NULL);
2564
2565 /* Set up .got offsets for local syms, and space for local dynamic
2566 relocs. */
2567 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2568 {
2569 bfd_signed_vma *local_got;
2570 bfd_signed_vma *end_local_got;
2571 bfd_size_type locsymcount;
2572 Elf_Internal_Shdr *symtab_hdr;
2573 asection *srel;
2574
2575 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2576 continue;
2577
2578 for (s = ibfd->sections; s != NULL; s = s->next)
2579 {
2580 struct elf32_mb_dyn_relocs *p;
2581
2582 for (p = ((struct elf32_mb_dyn_relocs *)
2583 elf_section_data (s)->local_dynrel);
2584 p != NULL;
2585 p = p->next)
2586 {
2587 if (!bfd_is_abs_section (p->sec)
2588 && bfd_is_abs_section (p->sec->output_section))
2589 {
2590 /* Input section has been discarded, either because
2591 it is a copy of a linkonce section or due to
2592 linker script /DISCARD/, so we'll be discarding
2593 the relocs too. */
2594 }
2595 else if (p->count != 0)
2596 {
2597 srel = elf_section_data (p->sec)->sreloc;
2598 srel->size += p->count * sizeof (Elf32_External_Rela);
2599 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2600 info->flags |= DF_TEXTREL;
2601 }
2602 }
2603 }
2604
2605 local_got = elf_local_got_refcounts (ibfd);
2606 if (!local_got)
2607 continue;
2608
2609 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2610 locsymcount = symtab_hdr->sh_info;
2611 end_local_got = local_got + locsymcount;
2612 s = htab->sgot;
2613 srel = htab->srelgot;
2614
2615 for (; local_got < end_local_got; ++local_got)
2616 {
2617 if (*local_got > 0)
2618 {
2619 *local_got = s->size;
2620 s->size += 4;
2621 if (info->shared)
2622 srel->size += sizeof (Elf32_External_Rela);
2623 }
2624 else
2625 *local_got = (bfd_vma) -1;
2626 }
2627 }
2628
2629 /* Allocate global sym .plt and .got entries, and space for global
2630 sym dynamic relocs. */
2631 elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
2632
2633 if (elf_hash_table (info)->dynamic_sections_created)
2634 {
2635 /* Make space for the trailing nop in .plt. */
2636 if (htab->splt->size > 0)
2637 htab->splt->size += 4;
2638 }
2639
2640 /* The check_relocs and adjust_dynamic_symbol entry points have
2641 determined the sizes of the various dynamic sections. Allocate
2642 memory for them. */
2643 for (s = dynobj->sections; s != NULL; s = s->next)
2644 {
2645 const char *name;
2646 bfd_boolean strip = FALSE;
2647
2648 if ((s->flags & SEC_LINKER_CREATED) == 0)
2649 continue;
2650
2651 /* It's OK to base decisions on the section name, because none
2652 of the dynobj section names depend upon the input files. */
2653 name = bfd_get_section_name (dynobj, s);
2654
2655 if (strncmp (name, ".rela", 5) == 0)
2656 {
2657 if (s->size == 0)
2658 {
2659 /* If we don't need this section, strip it from the
2660 output file. This is to handle .rela.bss and
2661 .rela.plt. We must create it in
2662 create_dynamic_sections, because it must be created
2663 before the linker maps input sections to output
2664 sections. The linker does that before
2665 adjust_dynamic_symbol is called, and it is that
2666 function which decides whether anything needs to go
2667 into these sections. */
2668 strip = TRUE;
2669 }
2670 else
2671 {
2672 /* We use the reloc_count field as a counter if we need
2673 to copy relocs into the output file. */
2674 s->reloc_count = 0;
2675 }
2676 }
2677 else if (s != htab->splt && s != htab->sgot && s != htab->sgotplt)
2678 {
2679 /* It's not one of our sections, so don't allocate space. */
2680 continue;
2681 }
2682
2683 if (strip)
2684 {
2685 s->flags |= SEC_EXCLUDE;
2686 continue;
2687 }
2688
2689 /* Allocate memory for the section contents. */
2690 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
2691 Unused entries should be reclaimed before the section's contents
2692 are written out, but at the moment this does not happen. Thus in
2693 order to prevent writing out garbage, we initialise the section's
2694 contents to zero. */
2695 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2696 if (s->contents == NULL && s->size != 0)
2697 return FALSE;
2698 }
2699
2700 if (elf_hash_table (info)->dynamic_sections_created)
2701 {
2702 /* Add some entries to the .dynamic section. We fill in the
2703 values later, in microblaze_elf_finish_dynamic_sections, but we
2704 must add the entries now so that we get the correct size for
2705 the .dynamic section. The DT_DEBUG entry is filled in by the
2706 dynamic linker and used by the debugger. */
2707 #define add_dynamic_entry(TAG, VAL) \
2708 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2709
2710 if (info->executable)
2711 {
2712 if (!add_dynamic_entry (DT_DEBUG, 0))
2713 return FALSE;
2714 }
2715
2716 if (!add_dynamic_entry (DT_RELA, 0)
2717 || !add_dynamic_entry (DT_RELASZ, 0)
2718 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2719 return FALSE;
2720
2721 if (htab->splt->size != 0)
2722 {
2723 if (!add_dynamic_entry (DT_PLTGOT, 0)
2724 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2725 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2726 || !add_dynamic_entry (DT_JMPREL, 0)
2727 || !add_dynamic_entry (DT_BIND_NOW, 1))
2728 return FALSE;
2729 }
2730
2731 if (info->flags & DF_TEXTREL)
2732 {
2733 if (!add_dynamic_entry (DT_TEXTREL, 0))
2734 return FALSE;
2735 }
2736 }
2737 #undef add_dynamic_entry
2738 return TRUE;
2739 }
2740
2741 /* Finish up dynamic symbol handling. We set the contents of various
2742 dynamic sections here. */
2743
2744 static bfd_boolean
2745 microblaze_elf_finish_dynamic_symbol (bfd *output_bfd,
2746 struct bfd_link_info *info,
2747 struct elf_link_hash_entry *h,
2748 Elf_Internal_Sym *sym)
2749 {
2750 bfd *dynobj;
2751 struct elf32_mb_link_hash_table *htab;
2752
2753 htab = elf32_mb_hash_table (info);
2754 dynobj = htab->elf.dynobj;
2755
2756 if (h->plt.offset != (bfd_vma) -1)
2757 {
2758 asection *splt;
2759 asection *srela;
2760 asection *sgotplt;
2761 Elf_Internal_Rela rela;
2762 bfd_byte *loc;
2763 bfd_vma plt_index;
2764 bfd_vma got_offset;
2765 bfd_vma got_addr;
2766
2767 /* This symbol has an entry in the procedure linkage table. Set
2768 it up. */
2769 BFD_ASSERT (h->dynindx != -1);
2770
2771 splt = htab->splt;
2772 srela = htab->srelplt;
2773 sgotplt = htab->sgotplt;
2774 BFD_ASSERT (splt != NULL && srela != NULL && sgotplt != NULL);
2775
2776 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; /* first entry reserved. */
2777 got_offset = (plt_index + 3) * 4; /* 3 reserved ??? */
2778 got_addr = got_offset;
2779
2780 /* For non-PIC objects we need absolute address of the GOT entry. */
2781 if (!info->shared)
2782 got_addr += htab->sgotplt->output_section->vma + sgotplt->output_offset;
2783
2784 /* Fill in the entry in the procedure linkage table. */
2785 bfd_put_32 (output_bfd, PLT_ENTRY_WORD_0 + ((got_addr >> 16) & 0xffff),
2786 splt->contents + h->plt.offset);
2787 if (info->shared)
2788 bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1 + (got_addr & 0xffff),
2789 splt->contents + h->plt.offset + 4);
2790 else
2791 bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1_NOPIC + (got_addr & 0xffff),
2792 splt->contents + h->plt.offset + 4);
2793 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_2,
2794 splt->contents + h->plt.offset + 8);
2795 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_3,
2796 splt->contents + h->plt.offset + 12);
2797
2798 /* Any additions to the .got section??? */
2799 /* bfd_put_32 (output_bfd,
2800 splt->output_section->vma + splt->output_offset + h->plt.offset + 4,
2801 sgotplt->contents + got_offset); */
2802
2803 /* Fill in the entry in the .rela.plt section. */
2804 rela.r_offset = (sgotplt->output_section->vma
2805 + sgotplt->output_offset
2806 + got_offset);
2807 rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_JUMP_SLOT);
2808 rela.r_addend = 0;
2809 loc = srela->contents;
2810 loc += plt_index * sizeof (Elf32_External_Rela);
2811 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2812
2813 if (!h->def_regular)
2814 {
2815 /* Mark the symbol as undefined, rather than as defined in
2816 the .plt section. Zero the value. */
2817 sym->st_shndx = SHN_UNDEF;
2818 sym->st_value = 0;
2819 }
2820 }
2821
2822 if (h->got.offset != (bfd_vma) -1)
2823 {
2824 asection *sgot;
2825 asection *srela;
2826 Elf_Internal_Rela rela;
2827 bfd_byte *loc;
2828
2829 /* This symbol has an entry in the global offset table. Set it
2830 up. */
2831
2832 sgot = htab->sgot;
2833 srela = htab->srelgot;
2834 BFD_ASSERT (sgot != NULL && srela != NULL);
2835
2836 rela.r_offset = (sgot->output_section->vma
2837 + sgot->output_offset
2838 + (h->got.offset &~ (bfd_vma) 1));
2839
2840 /* If this is a -Bsymbolic link, and the symbol is defined
2841 locally, we just want to emit a RELATIVE reloc. Likewise if
2842 the symbol was forced to be local because of a version file.
2843 The entry in the global offset table will already have been
2844 initialized in the relocate_section function. */
2845 if (info->shared
2846 && (info->symbolic || h->dynindx == -1)
2847 && h->def_regular)
2848 {
2849 asection *sec = h->root.u.def.section;
2850 rela.r_info = ELF32_R_INFO (0, R_MICROBLAZE_REL);
2851 rela.r_addend = (h->root.u.def.value
2852 + sec->output_section->vma
2853 + sec->output_offset);
2854 }
2855 else
2856 {
2857 rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_GLOB_DAT);
2858 rela.r_addend = 0;
2859 }
2860
2861 bfd_put_32 (output_bfd, (bfd_vma) 0,
2862 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2863 loc = srela->contents;
2864 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2865 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2866 }
2867
2868 if (h->needs_copy)
2869 {
2870 asection *s;
2871 Elf_Internal_Rela rela;
2872 bfd_byte *loc;
2873
2874 /* This symbols needs a copy reloc. Set it up. */
2875
2876 BFD_ASSERT (h->dynindx != -1);
2877
2878 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2879 ".rela.bss");
2880 BFD_ASSERT (s != NULL);
2881
2882 rela.r_offset = (h->root.u.def.value
2883 + h->root.u.def.section->output_section->vma
2884 + h->root.u.def.section->output_offset);
2885 rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_COPY);
2886 rela.r_addend = 0;
2887 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2888 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2889 }
2890
2891 /* Mark some specially defined symbols as absolute. */
2892 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2893 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2894 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2895 sym->st_shndx = SHN_ABS;
2896
2897 return TRUE;
2898 }
2899
2900
2901 /* Finish up the dynamic sections. */
2902
2903 static bfd_boolean
2904 microblaze_elf_finish_dynamic_sections (bfd *output_bfd,
2905 struct bfd_link_info *info)
2906 {
2907 bfd *dynobj;
2908 asection *sdyn, *sgot;
2909 struct elf32_mb_link_hash_table *htab;
2910
2911 htab = elf32_mb_hash_table (info);
2912 dynobj = htab->elf.dynobj;
2913
2914 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2915
2916 if (htab->elf.dynamic_sections_created)
2917 {
2918 asection *splt;
2919 Elf32_External_Dyn *dyncon, *dynconend;
2920
2921 splt = bfd_get_section_by_name (dynobj, ".plt");
2922 BFD_ASSERT (splt != NULL && sdyn != NULL);
2923
2924 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2925 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2926 for (; dyncon < dynconend; dyncon++)
2927 {
2928 Elf_Internal_Dyn dyn;
2929 const char *name;
2930 bfd_boolean size;
2931
2932 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2933
2934 switch (dyn.d_tag)
2935 {
2936 case DT_PLTGOT: name = ".got.plt"; size = FALSE; break;
2937 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
2938 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
2939 case DT_RELA: name = ".rela.dyn"; size = FALSE; break;
2940 case DT_RELASZ: name = ".rela.dyn"; size = TRUE; break;
2941 default: name = NULL; size = FALSE; break;
2942 }
2943
2944 if (name != NULL)
2945 {
2946 asection *s;
2947
2948 s = bfd_get_section_by_name (output_bfd, name);
2949 if (s == NULL)
2950 dyn.d_un.d_val = 0;
2951 else
2952 {
2953 if (! size)
2954 dyn.d_un.d_ptr = s->vma;
2955 else
2956 dyn.d_un.d_val = s->size;
2957 }
2958 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2959 }
2960 }
2961
2962 /* Clear the first entry in the procedure linkage table,
2963 and put a nop in the last four bytes. */
2964 if (splt->size > 0)
2965 {
2966 memset (splt->contents, 0, PLT_ENTRY_SIZE);
2967 bfd_put_32 (output_bfd, (bfd_vma) 0x80000000 /* nop. */,
2968 splt->contents + splt->size - 4);
2969 }
2970
2971 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
2972 }
2973
2974 /* Set the first entry in the global offset table to the address of
2975 the dynamic section. */
2976 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2977 if (sgot && sgot->size > 0)
2978 {
2979 if (sdyn == NULL)
2980 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2981 else
2982 bfd_put_32 (output_bfd,
2983 sdyn->output_section->vma + sdyn->output_offset,
2984 sgot->contents);
2985 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2986 }
2987
2988 if (htab->sgot && htab->sgot->size > 0)
2989 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
2990
2991 return TRUE;
2992 }
2993
2994 /* Hook called by the linker routine which adds symbols from an object
2995 file. We use it to put .comm items in .sbss, and not .bss. */
2996
2997 static bfd_boolean
2998 microblaze_elf_add_symbol_hook (bfd *abfd,
2999 struct bfd_link_info *info,
3000 Elf_Internal_Sym *sym,
3001 const char **namep ATTRIBUTE_UNUSED,
3002 flagword *flagsp ATTRIBUTE_UNUSED,
3003 asection **secp,
3004 bfd_vma *valp)
3005 {
3006 if (sym->st_shndx == SHN_COMMON
3007 && !info->relocatable
3008 && sym->st_size <= elf_gp_size (abfd))
3009 {
3010 /* Common symbols less than or equal to -G nn bytes are automatically
3011 put into .sbss. */
3012 *secp = bfd_make_section_anyway (abfd, ".sbss");
3013 if (*secp == NULL
3014 || ! bfd_set_section_flags (abfd, *secp, SEC_IS_COMMON))
3015 return FALSE;
3016
3017 *valp = sym->st_size;
3018 }
3019
3020 return TRUE;
3021 }
3022
3023
3024 #define TARGET_BIG_SYM bfd_elf32_microblaze_vec
3025 #define TARGET_BIG_NAME "elf32-microblaze"
3026
3027 #define ELF_ARCH bfd_arch_microblaze
3028 #define ELF_MACHINE_CODE EM_MICROBLAZE
3029 #define ELF_MACHINE_ALT1 EM_MICROBLAZE_OLD
3030 #define ELF_MAXPAGESIZE 0x4 /* 4k, if we ever have 'em. */
3031 #define elf_info_to_howto microblaze_elf_info_to_howto
3032 #define elf_info_to_howto_rel NULL
3033
3034 #define bfd_elf32_bfd_reloc_type_lookup microblaze_elf_reloc_type_lookup
3035 #define bfd_elf32_bfd_is_local_label_name microblaze_elf_is_local_label_name
3036 #define elf_backend_relocate_section microblaze_elf_relocate_section
3037 #define bfd_elf32_bfd_relax_section microblaze_elf_relax_section
3038 #define bfd_elf32_bfd_reloc_name_lookup microblaze_elf_reloc_name_lookup
3039
3040 #define elf_backend_gc_mark_hook microblaze_elf_gc_mark_hook
3041 #define elf_backend_gc_sweep_hook microblaze_elf_gc_sweep_hook
3042 #define elf_backend_check_relocs microblaze_elf_check_relocs
3043 #define elf_backend_copy_indirect_symbol microblaze_elf_copy_indirect_symbol
3044 #define bfd_elf32_bfd_link_hash_table_create microblaze_elf_link_hash_table_create
3045 #define elf_backend_can_gc_sections 1
3046 #define elf_backend_can_refcount 1
3047 #define elf_backend_want_got_plt 1
3048 #define elf_backend_plt_readonly 1
3049 #define elf_backend_got_header_size 12
3050 #define elf_backend_rela_normal 1
3051
3052 #define elf_backend_adjust_dynamic_symbol microblaze_elf_adjust_dynamic_symbol
3053 #define elf_backend_create_dynamic_sections microblaze_elf_create_dynamic_sections
3054 #define elf_backend_finish_dynamic_sections microblaze_elf_finish_dynamic_sections
3055 #define elf_backend_finish_dynamic_symbol microblaze_elf_finish_dynamic_symbol
3056 #define elf_backend_size_dynamic_sections microblaze_elf_size_dynamic_sections
3057 #define elf_backend_add_symbol_hook microblaze_elf_add_symbol_hook
3058
3059 #include "elf32-target.h"
git-cvsimport of binutils cvsroot