?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update my e-mail address.
[binutils-gdb.git] / bfd / elf32-pru.c
blob71a0829d2008a97a80048ba4d265ab28e821c395
1 /* 32-bit ELF support for TI PRU.
2 Copyright (C) 2014-2017 Free Software Foundation, Inc.
3 Contributed by Dimitar Dimitrov <dimitar@dinux.eu>
4 Based on elf32-nios2.c
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 /* This file handles TI PRU ELF targets. */
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "libbfd.h"
28 #include "bfdlink.h"
29 #include "genlink.h"
30 #include "elf-bfd.h"
31 #include "elf/pru.h"
32 #include "opcode/pru.h"
33
34 #define SWAP_VALS(A,B) \
35 do { \
36 (A) ^= (B); \
37 (B) ^= (A); \
38 (A) ^= (B); \
39 } while (0)
40
41 /* Enable debugging printout at stdout with this variable. */
42 static bfd_boolean debug_relax = FALSE;
43
44 /* Forward declarations. */
45 static bfd_reloc_status_type pru_elf32_pmem_relocate
46 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
47 static bfd_reloc_status_type pru_elf32_s10_pcrel_relocate
48 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49 static bfd_reloc_status_type pru_elf32_u8_pcrel_relocate
50 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
51 static bfd_reloc_status_type pru_elf32_ldi32_relocate
52 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 static bfd_reloc_status_type bfd_elf_pru_diff_relocate
54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
55
56 /* Target vector. */
57 extern const bfd_target pru_elf32_vec;
58
59 /* The relocation table used for SHT_REL sections. */
60 static reloc_howto_type elf_pru_howto_table_rel[] = {
61 /* No relocation. */
62 HOWTO (R_PRU_NONE, /* type */
63 0, /* rightshift */
64 0, /* size (0 = byte, 1 = short, 2 = long) */
65 3, /* bitsize */
66 FALSE, /* pc_relative */
67 0, /* bitpos */
68 complain_overflow_dont,/* complain_on_overflow */
69 bfd_elf_generic_reloc, /* special_function */
70 "R_PRU_NONE", /* name */
71 FALSE, /* partial_inplace */
72 0, /* src_mask */
73 0, /* dst_mask */
74 FALSE), /* pcrel_offset */
75
76 HOWTO (R_PRU_16_PMEM,
77 2,
78 1, /* short */
79 32,
80 FALSE,
81 0,
82 complain_overflow_dont,
83 bfd_elf_generic_reloc,
84 "R_PRU_16_PMEM",
85 FALSE,
86 0, /* src_mask */
87 0xffff,
88 FALSE),
89
90 HOWTO (R_PRU_U16_PMEMIMM,
91 2,
92 2,
93 32,
94 FALSE,
95 8,
96 complain_overflow_unsigned,
97 pru_elf32_pmem_relocate,
98 "R_PRU_U16_PMEMIMM",
99 FALSE,
100 0, /* src_mask */
101 0x00ffff00,
102 FALSE),
103
104 HOWTO (R_PRU_BFD_RELOC_16,
105 0,
106 1, /* short */
107 16,
108 FALSE,
109 0,
110 complain_overflow_bitfield,
111 bfd_elf_generic_reloc,
112 "R_PRU_BFD_RELOC16",
113 FALSE,
114 0, /* src_mask */
115 0x0000ffff,
116 FALSE),
117
118 /* 16-bit unsigned immediate relocation. */
119 HOWTO (R_PRU_U16, /* type */
120 0, /* rightshift */
121 2, /* size (0 = byte, 1 = short, 2 = long) */
122 16, /* bitsize */
123 FALSE, /* pc_relative */
124 8, /* bitpos */
125 complain_overflow_unsigned, /* complain on overflow */
126 bfd_elf_generic_reloc, /* special function */
127 "R_PRU_U16", /* name */
128 FALSE, /* partial_inplace */
129 0, /* src_mask */
130 0x00ffff00, /* dest_mask */
131 FALSE), /* pcrel_offset */
132
133 HOWTO (R_PRU_32_PMEM,
134 2,
135 2, /* long */
136 32,
137 FALSE,
138 0,
139 complain_overflow_dont,
140 pru_elf32_pmem_relocate,
141 "R_PRU_32_PMEM",
142 FALSE,
143 0, /* src_mask */
144 0xffffffff,
145 FALSE),
146
147 HOWTO (R_PRU_BFD_RELOC_32,
148 0,
149 2, /* long */
150 32,
151 FALSE,
152 0,
153 complain_overflow_dont,
154 bfd_elf_generic_reloc,
155 "R_PRU_BFD_RELOC32",
156 FALSE,
157 0, /* src_mask */
158 0xffffffff,
159 FALSE),
160
161 HOWTO (R_PRU_S10_PCREL,
162 2,
163 2,
164 10,
165 TRUE,
166 0,
167 complain_overflow_bitfield,
168 pru_elf32_s10_pcrel_relocate,
169 "R_PRU_S10_PCREL",
170 FALSE,
171 0, /* src_mask */
172 0x060000ff,
173 TRUE),
174
175 HOWTO (R_PRU_U8_PCREL,
176 2,
177 2,
178 8,
179 TRUE,
180 0,
181 complain_overflow_unsigned,
182 pru_elf32_u8_pcrel_relocate,
183 "R_PRU_U8_PCREL",
184 FALSE,
185 0, /* src_mask */
186 0x000000ff,
187 TRUE),
188
189 HOWTO (R_PRU_LDI32,
190 0, /* rightshift */
191 4, /* size (4 = 8bytes) */
192 32, /* bitsize */
193 FALSE, /* pc_relative */
194 0, /* bitpos */
195 complain_overflow_unsigned, /* complain on overflow */
196 pru_elf32_ldi32_relocate, /* special function */
197 "R_PRU_LDI32", /* name */
198 FALSE, /* partial_inplace */
199 0, /* src_mask */
200 0xffffffff, /* dest_mask */
201 FALSE), /* pcrel_offset */
202
203 /* GNU-specific relocations. */
204 HOWTO (R_PRU_GNU_BFD_RELOC_8,
205 0,
206 0, /* byte */
207 8,
208 FALSE,
209 0,
210 complain_overflow_bitfield,
211 bfd_elf_generic_reloc,
212 "R_PRU_BFD_RELOC8",
213 FALSE,
214 0, /* src_mask */
215 0x000000ff,
216 FALSE),
217
218 HOWTO (R_PRU_GNU_DIFF8, /* type */
219 0, /* rightshift */
220 0, /* size (0 = byte, 1 = short, 2 = long) */
221 8, /* bitsize */
222 FALSE, /* pc_relative */
223 0, /* bitpos */
224 complain_overflow_bitfield, /* complain_on_overflow */
225 bfd_elf_pru_diff_relocate, /* special_function */
226 "R_PRU_DIFF8", /* name */
227 FALSE, /* partial_inplace */
228 0, /* src_mask */
229 0xff, /* dst_mask */
230 FALSE), /* pcrel_offset */
231
232 HOWTO (R_PRU_GNU_DIFF16, /* type */
233 0, /* rightshift */
234 1, /* size (0 = byte, 1 = short, 2 = long) */
235 16, /* bitsize */
236 FALSE, /* pc_relative */
237 0, /* bitpos */
238 complain_overflow_bitfield, /* complain_on_overflow */
239 bfd_elf_pru_diff_relocate,/* special_function */
240 "R_PRU_DIFF16", /* name */
241 FALSE, /* partial_inplace */
242 0, /* src_mask */
243 0xffff, /* dst_mask */
244 FALSE), /* pcrel_offset */
245
246 HOWTO (R_PRU_GNU_DIFF32, /* type */
247 0, /* rightshift */
248 2, /* size (0 = byte, 1 = short, 2 = long) */
249 32, /* bitsize */
250 FALSE, /* pc_relative */
251 0, /* bitpos */
252 complain_overflow_bitfield, /* complain_on_overflow */
253 bfd_elf_pru_diff_relocate,/* special_function */
254 "R_PRU_DIFF32", /* name */
255 FALSE, /* partial_inplace */
256 0, /* src_mask */
257 0xffffffff, /* dst_mask */
258 FALSE), /* pcrel_offset */
259
260 HOWTO (R_PRU_GNU_DIFF16_PMEM, /* type */
261 0, /* rightshift */
262 1, /* size (0 = byte, 1 = short, 2 = long) */
263 16, /* bitsize */
264 FALSE, /* pc_relative */
265 0, /* bitpos */
266 complain_overflow_bitfield, /* complain_on_overflow */
267 bfd_elf_pru_diff_relocate,/* special_function */
268 "R_PRU_DIFF16_PMEM", /* name */
269 FALSE, /* partial_inplace */
270 0, /* src_mask */
271 0xffff, /* dst_mask */
272 FALSE), /* pcrel_offset */
273
274 HOWTO (R_PRU_GNU_DIFF32_PMEM, /* type */
275 0, /* rightshift */
276 2, /* size (0 = byte, 1 = short, 2 = long) */
277 32, /* bitsize */
278 FALSE, /* pc_relative */
279 0, /* bitpos */
280 complain_overflow_bitfield, /* complain_on_overflow */
281 bfd_elf_pru_diff_relocate,/* special_function */
282 "R_PRU_DIFF32_PMEM", /* name */
283 FALSE, /* partial_inplace */
284 0, /* src_mask */
285 0xffffffff, /* dst_mask */
286 FALSE), /* pcrel_offset */
287
288 /* Add other relocations here. */
289 };
290
291 static unsigned char elf_code_to_howto_index[R_PRU_ILLEGAL + 1];
292
293 /* Return the howto for relocation RTYPE. */
294 static reloc_howto_type *
295 lookup_howto (unsigned int rtype)
296 {
297 static int initialized = 0;
298 int i;
299 int howto_tbl_size = (int) (sizeof (elf_pru_howto_table_rel)
300 / sizeof (elf_pru_howto_table_rel[0]));
301
302 if (!initialized)
303 {
304 initialized = 1;
305 memset (elf_code_to_howto_index, 0xff,
306 sizeof (elf_code_to_howto_index));
307 for (i = 0; i < howto_tbl_size; i++)
308 elf_code_to_howto_index[elf_pru_howto_table_rel[i].type] = i;
309 }
310
311 BFD_ASSERT (rtype <= R_PRU_ILLEGAL);
312 i = elf_code_to_howto_index[rtype];
313 if (i >= howto_tbl_size)
314 return 0;
315 return elf_pru_howto_table_rel + i;
316 }
317
318 /* Map for converting BFD reloc types to PRU reloc types. */
319 struct elf_reloc_map
320 {
321 bfd_reloc_code_real_type bfd_val;
322 enum elf_pru_reloc_type elf_val;
323 };
324
325 static const struct elf_reloc_map pru_reloc_map[] = {
326 {BFD_RELOC_NONE, R_PRU_NONE},
327 {BFD_RELOC_PRU_16_PMEM, R_PRU_16_PMEM},
328 {BFD_RELOC_PRU_U16_PMEMIMM, R_PRU_U16_PMEMIMM},
329 {BFD_RELOC_16, R_PRU_BFD_RELOC_16},
330 {BFD_RELOC_PRU_U16, R_PRU_U16},
331 {BFD_RELOC_PRU_32_PMEM, R_PRU_32_PMEM},
332 {BFD_RELOC_32, R_PRU_BFD_RELOC_32},
333 {BFD_RELOC_PRU_S10_PCREL, R_PRU_S10_PCREL},
334 {BFD_RELOC_PRU_U8_PCREL, R_PRU_U8_PCREL},
335 {BFD_RELOC_PRU_LDI32, R_PRU_LDI32},
336
337 {BFD_RELOC_8, R_PRU_GNU_BFD_RELOC_8},
338 {BFD_RELOC_PRU_GNU_DIFF8, R_PRU_GNU_DIFF8},
339 {BFD_RELOC_PRU_GNU_DIFF16, R_PRU_GNU_DIFF16},
340 {BFD_RELOC_PRU_GNU_DIFF32, R_PRU_GNU_DIFF32},
341 {BFD_RELOC_PRU_GNU_DIFF16_PMEM, R_PRU_GNU_DIFF16_PMEM},
342 {BFD_RELOC_PRU_GNU_DIFF32_PMEM, R_PRU_GNU_DIFF32_PMEM},
343 };
344
345
346 /* Assorted hash table functions. */
347
348 /* Create an entry in a PRU ELF linker hash table. */
349 static struct bfd_hash_entry *
350 link_hash_newfunc (struct bfd_hash_entry *entry,
351 struct bfd_hash_table *table, const char *string)
352 {
353 /* Allocate the structure if it has not already been allocated by a
354 subclass. */
355 if (entry == NULL)
356 {
357 entry = bfd_hash_allocate (table,
358 sizeof (struct elf_link_hash_entry));
359 if (entry == NULL)
360 return entry;
361 }
362
363 /* Call the allocation method of the superclass. */
364 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
365
366 return entry;
367 }
368
369 /* Implement bfd_elf32_bfd_reloc_type_lookup:
370 Given a BFD reloc type, return a howto structure. */
371 static reloc_howto_type *
372 pru_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
373 bfd_reloc_code_real_type code)
374 {
375 int i;
376 for (i = 0;
377 i < (int) (sizeof (pru_reloc_map) / sizeof (struct elf_reloc_map));
378 ++i)
379 if (pru_reloc_map[i].bfd_val == code)
380 return lookup_howto ((unsigned int) pru_reloc_map[i].elf_val);
381 return NULL;
382 }
383
384 /* Implement bfd_elf32_bfd_reloc_name_lookup:
385 Given a reloc name, return a howto structure. */
386 static reloc_howto_type *
387 pru_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
388 const char *r_name)
389 {
390 unsigned int i;
391 for (i = 0;
392 i < (sizeof (elf_pru_howto_table_rel)
393 / sizeof (elf_pru_howto_table_rel[0]));
394 i++)
395 if (elf_pru_howto_table_rel[i].name
396 && strcasecmp (elf_pru_howto_table_rel[i].name, r_name) == 0)
397 return &elf_pru_howto_table_rel[i];
398
399 return NULL;
400 }
401
402 /* Implement elf_info_to_howto:
403 Given a ELF32 relocation, fill in a arelent structure. */
404 static void
405 pru_elf32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
406 Elf_Internal_Rela *dst)
407 {
408 unsigned int r_type;
409
410 r_type = ELF32_R_TYPE (dst->r_info);
411 BFD_ASSERT (r_type < R_PRU_ILLEGAL);
412 cache_ptr->howto = lookup_howto (r_type);
413 }
414
415 /* Do the relocations that require special handling. */
416 /* Produce a word address for program memory. Linker scripts will put .text
417 at a high offset in order to differentiate it from .data. So here we also
418 mask the high bits of PMEM address.
419
420 But why 1MB when internal Program Memory much smaller? We want to catch
421 unintended overflows.
422
423 Why not use (1<<31) as an offset and a mask? Sitara DDRAM usually resides
424 there, and users might want to put some shared carveout memory region in
425 their linker scripts. So 0x80000000 might be a valid .data address.
426
427 Note that we still keep and pass down the original howto. This way we
428 can reuse this function for several different relocations. */
429 static bfd_reloc_status_type
430 pru_elf32_do_pmem_relocate (bfd *abfd, reloc_howto_type *howto,
431 asection *input_section,
432 bfd_byte *data, bfd_vma offset,
433 bfd_vma symbol_value, bfd_vma addend)
434 {
435 symbol_value = symbol_value + addend;
436 addend = 0;
437 symbol_value &= 0x3fffff;
438 return _bfd_final_link_relocate (howto, abfd, input_section,
439 data, offset, symbol_value, addend);
440 }
441
442 /* Direct copy of _bfd_final_link_relocate, but with special
443 "fill-in". This copy-paste mumbo jumbo is only needed because BFD
444 cannot deal correctly with non-contiguous bit fields. */
445 static bfd_reloc_status_type
446 pru_elf32_do_s10_pcrel_relocate (bfd *input_bfd, reloc_howto_type *howto,
447 asection *input_section,
448 bfd_byte *contents, bfd_vma address,
449 bfd_vma relocation, bfd_vma addend)
450 {
451 bfd_byte *location;
452 bfd_vma x = 0;
453 bfd_vma qboff;
454 bfd_reloc_status_type flag = bfd_reloc_ok;
455
456 /* Sanity check the address. */
457 if (address > bfd_get_section_limit (input_bfd, input_section))
458 return bfd_reloc_outofrange;
459
460 BFD_ASSERT (howto->pc_relative);
461 BFD_ASSERT (howto->pcrel_offset);
462
463 relocation = relocation + addend - (input_section->output_section->vma
464 + input_section->output_offset) - address;
465
466 location = contents + address;
467
468 /* Get the value we are going to relocate. */
469 BFD_ASSERT (bfd_get_reloc_size (howto) == 4);
470 x = bfd_get_32 (input_bfd, location);
471
472 qboff = GET_BROFF_SIGNED (x) << howto->rightshift;
473 relocation += qboff;
474
475 BFD_ASSERT (howto->complain_on_overflow == complain_overflow_bitfield);
476
477 if (relocation > 2047 && relocation < (bfd_vma)-2048l)
478 flag = bfd_reloc_overflow;
479
480 /* Check that target address is word-aligned. */
481 if (relocation & ((1 << howto->rightshift) - 1))
482 flag = bfd_reloc_outofrange;
483
484 relocation >>= (bfd_vma) howto->rightshift;
485
486 /* Fill-in the RELOCATION to the right bits of X. */
487 SET_BROFF_URAW (x, relocation);
488
489 bfd_put_32 (input_bfd, x, location);
490
491 return flag;
492 }
493
494 static bfd_reloc_status_type
495 pru_elf32_do_u8_pcrel_relocate (bfd *abfd, reloc_howto_type *howto,
496 asection *input_section,
497 bfd_byte *data, bfd_vma offset,
498 bfd_vma symbol_value, bfd_vma addend)
499 {
500 bfd_vma relocation;
501
502 BFD_ASSERT (howto->pc_relative);
503 BFD_ASSERT (howto->pcrel_offset);
504
505 relocation = symbol_value + addend - (input_section->output_section->vma
506 + input_section->output_offset) - offset;
507 relocation >>= howto->rightshift;
508
509 /* 0 and 1 are invalid target labels for LOOP. We cannot
510 encode this info in HOWTO, so catch such cases here. */
511 if (relocation < 2)
512 return bfd_reloc_outofrange;
513
514 return _bfd_final_link_relocate (howto, abfd, input_section,
515 data, offset, symbol_value, addend);
516 }
517
518 /* Idea and code taken from elf32-d30v. */
519 static bfd_reloc_status_type
520 pru_elf32_do_ldi32_relocate (bfd *abfd, reloc_howto_type *howto,
521 asection *input_section,
522 bfd_byte *data, bfd_vma offset,
523 bfd_vma symbol_value, bfd_vma addend)
524 {
525 bfd_signed_vma relocation;
526 bfd_size_type octets = offset * bfd_octets_per_byte (abfd);
527 bfd_byte *location;
528 unsigned long in1, in2, num;
529
530 /* A hacked-up version of _bfd_final_link_relocate() follows. */
531
532 /* Sanity check the address. */
533 if (octets + bfd_get_reloc_size (howto)
534 > bfd_get_section_limit_octets (abfd, input_section))
535 return bfd_reloc_outofrange;
536
537 /* This function assumes that we are dealing with a basic relocation
538 against a symbol. We want to compute the value of the symbol to
539 relocate to. This is just VALUE, the value of the symbol, plus
540 ADDEND, any addend associated with the reloc. */
541 relocation = symbol_value + addend;
542
543 BFD_ASSERT (!howto->pc_relative);
544
545 /* A hacked-up version of _bfd_relocate_contents() follows. */
546 location = data + offset * bfd_octets_per_byte (abfd);
547
548 BFD_ASSERT (!howto->pc_relative);
549
550 in1 = bfd_get_32 (abfd, location);
551 in2 = bfd_get_32 (abfd, location + 4);
552
553 /* Extract the addend - should be zero per my understanding. */
554 num = GET_INSN_FIELD (IMM16, in1) | (GET_INSN_FIELD (IMM16, in2) << 16);
555 BFD_ASSERT (!num);
556
557 relocation += num;
558
559 SET_INSN_FIELD (IMM16, in1, relocation & 0xffff);
560 SET_INSN_FIELD (IMM16, in2, relocation >> 16);
561
562 bfd_put_32 (abfd, in1, location);
563 bfd_put_32 (abfd, in2, location + 4);
564
565 return bfd_reloc_ok;
566 }
567
568 /* HOWTO handlers for relocations that require special handling. */
569
570 static bfd_reloc_status_type
571 pru_elf32_pmem_relocate (bfd *abfd, arelent *reloc_entry,
572 asymbol *symbol, void *data,
573 asection *input_section, bfd *output_bfd,
574 char **error_message)
575 {
576 /* If this is a relocatable link (output_bfd test tells us), just
577 call the generic function. Any adjustment will be done at final
578 link time. */
579 if (output_bfd != NULL)
580 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
581 input_section, output_bfd, error_message);
582
583 return pru_elf32_do_pmem_relocate (abfd, reloc_entry->howto,
584 input_section,
585 data, reloc_entry->address,
586 (symbol->value
587 + symbol->section->output_section->vma
588 + symbol->section->output_offset),
589 reloc_entry->addend);
590 }
591
592 static bfd_reloc_status_type
593 pru_elf32_s10_pcrel_relocate (bfd *abfd, arelent *reloc_entry,
594 asymbol *symbol, void *data,
595 asection *input_section, bfd *output_bfd,
596 char **error_message)
597 {
598 /* If this is a relocatable link (output_bfd test tells us), just
599 call the generic function. Any adjustment will be done at final
600 link time. */
601 if (output_bfd != NULL)
602 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
603 input_section, output_bfd, error_message);
604
605 return pru_elf32_do_s10_pcrel_relocate (abfd, reloc_entry->howto,
606 input_section, data,
607 reloc_entry->address,
608 (symbol->value
609 + symbol->section->output_section->vma
610 + symbol->section->output_offset),
611 reloc_entry->addend);
612 }
613
614 static bfd_reloc_status_type
615 pru_elf32_u8_pcrel_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
616 void *data, asection *input_section,
617 bfd *output_bfd,
618 char **error_message)
619 {
620 /* If this is a relocatable link (output_bfd test tells us), just
621 call the generic function. Any adjustment will be done at final
622 link time. */
623 if (output_bfd != NULL)
624 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
625 input_section, output_bfd, error_message);
626
627 return pru_elf32_do_u8_pcrel_relocate (abfd, reloc_entry->howto,
628 input_section,
629 data, reloc_entry->address,
630 (symbol->value
631 + symbol->section->output_section->vma
632 + symbol->section->output_offset),
633 reloc_entry->addend);
634 }
635
636 static bfd_reloc_status_type
637 pru_elf32_ldi32_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
638 void *data, asection *input_section,
639 bfd *output_bfd,
640 char **error_message)
641 {
642 /* If this is a relocatable link (output_bfd test tells us), just
643 call the generic function. Any adjustment will be done at final
644 link time. */
645 if (output_bfd != NULL)
646 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
647 input_section, output_bfd, error_message);
648
649 return pru_elf32_do_ldi32_relocate (abfd, reloc_entry->howto,
650 input_section,
651 data, reloc_entry->address,
652 (symbol->value
653 + symbol->section->output_section->vma
654 + symbol->section->output_offset),
655 reloc_entry->addend);
656 }
657
658
659 /* Implement elf_backend_relocate_section. */
660 static bfd_boolean
661 pru_elf32_relocate_section (bfd *output_bfd,
662 struct bfd_link_info *info,
663 bfd *input_bfd,
664 asection *input_section,
665 bfd_byte *contents,
666 Elf_Internal_Rela *relocs,
667 Elf_Internal_Sym *local_syms,
668 asection **local_sections)
669 {
670 Elf_Internal_Shdr *symtab_hdr;
671 struct elf_link_hash_entry **sym_hashes;
672 Elf_Internal_Rela *rel;
673 Elf_Internal_Rela *relend;
674
675 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
676 sym_hashes = elf_sym_hashes (input_bfd);
677 relend = relocs + input_section->reloc_count;
678
679 for (rel = relocs; rel < relend; rel++)
680 {
681 reloc_howto_type *howto;
682 unsigned long r_symndx;
683 Elf_Internal_Sym *sym;
684 asection *sec;
685 struct elf_link_hash_entry *h;
686 bfd_vma relocation;
687 bfd_reloc_status_type r = bfd_reloc_ok;
688 const char *name = NULL;
689 const char* msg = (const char*) NULL;
690 bfd_boolean unresolved_reloc;
691
692 r_symndx = ELF32_R_SYM (rel->r_info);
693
694 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info));
695 h = NULL;
696 sym = NULL;
697 sec = NULL;
698
699 if (r_symndx < symtab_hdr->sh_info)
700 {
701 sym = local_syms + r_symndx;
702 sec = local_sections[r_symndx];
703 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
704 }
705 else
706 {
707 bfd_boolean warned, ignored;
708
709 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
710 r_symndx, symtab_hdr, sym_hashes,
711 h, sec, relocation,
712 unresolved_reloc, warned, ignored);
713 }
714
715 if (sec && discarded_section (sec))
716 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
717 rel, 1, relend, howto, 0, contents);
718
719 /* Nothing more to do unless this is a final link. */
720 if (bfd_link_relocatable (info))
721 continue;
722
723 if (howto)
724 {
725 switch (howto->type)
726 {
727 case R_PRU_NONE:
728 /* We don't need to find a value for this symbol. It's just a
729 marker. */
730 r = bfd_reloc_ok;
731 break;
732
733 case R_PRU_U16_PMEMIMM:
734 case R_PRU_32_PMEM:
735 case R_PRU_16_PMEM:
736 r = pru_elf32_do_pmem_relocate (input_bfd, howto,
737 input_section,
738 contents, rel->r_offset,
739 relocation, rel->r_addend);
740 break;
741 case R_PRU_S10_PCREL:
742 r = pru_elf32_do_s10_pcrel_relocate (input_bfd, howto,
743 input_section,
744 contents,
745 rel->r_offset,
746 relocation,
747 rel->r_addend);
748 break;
749 case R_PRU_U8_PCREL:
750 r = pru_elf32_do_u8_pcrel_relocate (input_bfd, howto,
751 input_section,
752 contents,
753 rel->r_offset,
754 relocation,
755 rel->r_addend);
756 break;
757 case R_PRU_LDI32:
758 r = pru_elf32_do_ldi32_relocate (input_bfd, howto,
759 input_section,
760 contents,
761 rel->r_offset,
762 relocation,
763 rel->r_addend);
764 break;
765 case R_PRU_GNU_DIFF8:
766 case R_PRU_GNU_DIFF16:
767 case R_PRU_GNU_DIFF32:
768 case R_PRU_GNU_DIFF16_PMEM:
769 case R_PRU_GNU_DIFF32_PMEM:
770 /* Nothing to do here, as contents already contain the
771 diff value. */
772 r = bfd_reloc_ok;
773 break;
774
775 default:
776 r = _bfd_final_link_relocate (howto, input_bfd,
777 input_section, contents,
778 rel->r_offset, relocation,
779 rel->r_addend);
780 break;
781 }
782 }
783 else
784 r = bfd_reloc_notsupported;
785
786 if (r != bfd_reloc_ok)
787 {
788 if (h != NULL)
789 name = h->root.root.string;
790 else
791 {
792 name = bfd_elf_string_from_elf_section (input_bfd,
793 symtab_hdr->sh_link,
794 sym->st_name);
795 if (name == NULL || *name == '\0')
796 name = bfd_section_name (input_bfd, sec);
797 }
798
799 switch (r)
800 {
801 case bfd_reloc_overflow:
802 (*info->callbacks->reloc_overflow) (info, NULL, name,
803 howto->name, (bfd_vma) 0,
804 input_bfd, input_section,
805 rel->r_offset);
806 break;
807
808 case bfd_reloc_undefined:
809 (*info->callbacks->undefined_symbol) (info, name, input_bfd,
810 input_section,
811 rel->r_offset, TRUE);
812 break;
813
814 case bfd_reloc_outofrange:
815 if (msg == NULL)
816 msg = _("relocation out of range");
817 break;
818
819 case bfd_reloc_notsupported:
820 if (msg == NULL)
821 msg = _("unsupported relocation");
822 break;
823
824 case bfd_reloc_dangerous:
825 if (msg == NULL)
826 msg = _("dangerous relocation");
827 break;
828
829 default:
830 if (msg == NULL)
831 msg = _("unknown error");
832 break;
833 }
834
835 if (msg)
836 {
837 (*info->callbacks->warning) (info, msg, name, input_bfd,
838 input_section, rel->r_offset);
839 return FALSE;
840 }
841 }
842 }
843 return TRUE;
844 }
845
846 \f
847 /* Perform a diff relocation. Nothing to do, as the difference value is
848 already written into the section's contents. */
849
850 static bfd_reloc_status_type
851 bfd_elf_pru_diff_relocate (bfd *abfd ATTRIBUTE_UNUSED,
852 arelent *reloc_entry ATTRIBUTE_UNUSED,
853 asymbol *symbol ATTRIBUTE_UNUSED,
854 void *data ATTRIBUTE_UNUSED,
855 asection *input_section ATTRIBUTE_UNUSED,
856 bfd *output_bfd ATTRIBUTE_UNUSED,
857 char **error_message ATTRIBUTE_UNUSED)
858 {
859 return bfd_reloc_ok;
860 }
861
862
863 /* Returns whether the relocation type passed is a diff reloc. */
864
865 static bfd_boolean
866 elf32_pru_is_diff_reloc (Elf_Internal_Rela *irel)
867 {
868 return (ELF32_R_TYPE (irel->r_info) == R_PRU_GNU_DIFF8
869 || ELF32_R_TYPE (irel->r_info) == R_PRU_GNU_DIFF16
870 || ELF32_R_TYPE (irel->r_info) == R_PRU_GNU_DIFF32
871 || ELF32_R_TYPE (irel->r_info) == R_PRU_GNU_DIFF16_PMEM
872 || ELF32_R_TYPE (irel->r_info) == R_PRU_GNU_DIFF32_PMEM);
873 }
874
875 /* Reduce the diff value written in the section by count if the shrinked
876 insn address happens to fall between the two symbols for which this
877 diff reloc was emitted. */
878
879 static void
880 elf32_pru_adjust_diff_reloc_value (bfd *abfd,
881 struct bfd_section *isec,
882 Elf_Internal_Rela *irel,
883 bfd_vma symval,
884 bfd_vma shrinked_insn_address,
885 int count)
886 {
887 unsigned char *reloc_contents = NULL;
888 unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents;
889 if (isec_contents == NULL)
890 {
891 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents))
892 return;
893
894 elf_section_data (isec)->this_hdr.contents = isec_contents;
895 }
896
897 reloc_contents = isec_contents + irel->r_offset;
898
899 /* Read value written in object file. */
900 bfd_signed_vma x = 0;
901 switch (ELF32_R_TYPE (irel->r_info))
902 {
903 case R_PRU_GNU_DIFF8:
904 {
905 x = bfd_get_signed_8 (abfd, reloc_contents);
906 break;
907 }
908 case R_PRU_GNU_DIFF16:
909 {
910 x = bfd_get_signed_16 (abfd, reloc_contents);
911 break;
912 }
913 case R_PRU_GNU_DIFF32:
914 {
915 x = bfd_get_signed_32 (abfd, reloc_contents);
916 break;
917 }
918 case R_PRU_GNU_DIFF16_PMEM:
919 {
920 x = bfd_get_signed_16 (abfd, reloc_contents) * 4;
921 break;
922 }
923 case R_PRU_GNU_DIFF32_PMEM:
924 {
925 x = bfd_get_signed_32 (abfd, reloc_contents) * 4;
926 break;
927 }
928 default:
929 {
930 BFD_FAIL ();
931 }
932 }
933
934 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
935 into the object file at the reloc offset. sym2's logical value is
936 symval (<start_of_section>) + reloc addend. Compute the start and end
937 addresses and check if the shrinked insn falls between sym1 and sym2. */
938
939 bfd_vma end_address = symval + irel->r_addend;
940 bfd_vma start_address = end_address - x;
941
942 /* Shrink the absolute DIFF value (get the to labels "closer"
943 together), because we have removed data between labels. */
944 if (x < 0)
945 {
946 x += count;
947 /* In case the signed x is negative, restore order. */
948 SWAP_VALS (end_address, start_address);
949 }
950 else
951 {
952 x -= count;
953 }
954
955 /* Reduce the diff value by count bytes and write it back into section
956 contents. */
957
958 if (shrinked_insn_address >= start_address
959 && shrinked_insn_address <= end_address)
960 {
961 switch (ELF32_R_TYPE (irel->r_info))
962 {
963 case R_PRU_GNU_DIFF8:
964 {
965 bfd_put_signed_8 (abfd, x & 0xFF, reloc_contents);
966 break;
967 }
968 case R_PRU_GNU_DIFF16:
969 {
970 bfd_put_signed_16 (abfd, x & 0xFFFF, reloc_contents);
971 break;
972 }
973 case R_PRU_GNU_DIFF32:
974 {
975 bfd_put_signed_32 (abfd, x & 0xFFFFFFFF, reloc_contents);
976 break;
977 }
978 case R_PRU_GNU_DIFF16_PMEM:
979 {
980 bfd_put_signed_16 (abfd, (x / 4) & 0xFFFF, reloc_contents);
981 break;
982 }
983 case R_PRU_GNU_DIFF32_PMEM:
984 {
985 bfd_put_signed_32 (abfd, (x / 4) & 0xFFFFFFFF, reloc_contents);
986 break;
987 }
988 default:
989 {
990 BFD_FAIL ();
991 }
992 }
993
994 }
995 }
996
997 /* Delete some bytes from a section while changing the size of an instruction.
998 The parameter "addr" denotes the section-relative offset pointing just
999 behind the shrinked instruction. "addr+count" point at the first
1000 byte just behind the original unshrinked instruction.
1001
1002 Idea copied from the AVR port. */
1003
1004 static bfd_boolean
1005 pru_elf_relax_delete_bytes (bfd *abfd,
1006 asection *sec,
1007 bfd_vma addr,
1008 int count)
1009 {
1010 Elf_Internal_Shdr *symtab_hdr;
1011 unsigned int sec_shndx;
1012 bfd_byte *contents;
1013 Elf_Internal_Rela *irel, *irelend;
1014 Elf_Internal_Sym *isym;
1015 Elf_Internal_Sym *isymbuf = NULL;
1016 bfd_vma toaddr;
1017 struct elf_link_hash_entry **sym_hashes;
1018 struct elf_link_hash_entry **end_hashes;
1019 unsigned int symcount;
1020
1021 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1022 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1023 contents = elf_section_data (sec)->this_hdr.contents;
1024
1025 toaddr = sec->size;
1026
1027 irel = elf_section_data (sec)->relocs;
1028 irelend = irel + sec->reloc_count;
1029
1030 /* Actually delete the bytes. */
1031 if (toaddr - addr - count > 0)
1032 memmove (contents + addr, contents + addr + count,
1033 (size_t) (toaddr - addr - count));
1034 sec->size -= count;
1035
1036 /* Adjust all the reloc addresses. */
1037 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1038 {
1039 bfd_vma old_reloc_address;
1040
1041 old_reloc_address = (sec->output_section->vma
1042 + sec->output_offset + irel->r_offset);
1043
1044 /* Get the new reloc address. */
1045 if ((irel->r_offset > addr
1046 && irel->r_offset < toaddr))
1047 {
1048 if (debug_relax)
1049 printf ("Relocation at address 0x%x needs to be moved.\n"
1050 "Old section offset: 0x%x, New section offset: 0x%x \n",
1051 (unsigned int) old_reloc_address,
1052 (unsigned int) irel->r_offset,
1053 (unsigned int) ((irel->r_offset) - count));
1054
1055 irel->r_offset -= count;
1056 }
1057
1058 }
1059
1060 /* The reloc's own addresses are now ok. However, we need to readjust
1061 the reloc's addend, i.e. the reloc's value if two conditions are met:
1062 1.) the reloc is relative to a symbol in this section that
1063 is located in front of the shrinked instruction
1064 2.) symbol plus addend end up behind the shrinked instruction.
1065
1066 The most common case where this happens are relocs relative to
1067 the section-start symbol.
1068
1069 This step needs to be done for all of the sections of the bfd. */
1070
1071 {
1072 struct bfd_section *isec;
1073
1074 for (isec = abfd->sections; isec; isec = isec->next)
1075 {
1076 bfd_vma symval;
1077 bfd_vma shrinked_insn_address;
1078
1079 if (isec->reloc_count == 0)
1080 continue;
1081
1082 shrinked_insn_address = (sec->output_section->vma
1083 + sec->output_offset + addr - count);
1084
1085 irel = elf_section_data (isec)->relocs;
1086 /* PR 12161: Read in the relocs for this section if necessary. */
1087 if (irel == NULL)
1088 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
1089
1090 for (irelend = irel + isec->reloc_count;
1091 irel < irelend;
1092 irel++)
1093 {
1094 /* Read this BFD's local symbols if we haven't done
1095 so already. */
1096 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1097 {
1098 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1099 if (isymbuf == NULL)
1100 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1101 symtab_hdr->sh_info, 0,
1102 NULL, NULL, NULL);
1103 if (isymbuf == NULL)
1104 return FALSE;
1105 }
1106
1107 /* Get the value of the symbol referred to by the reloc. */
1108 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1109 {
1110 /* A local symbol. */
1111 asection *sym_sec;
1112
1113 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1114 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1115 symval = isym->st_value;
1116 /* If the reloc is absolute, it will not have
1117 a symbol or section associated with it. */
1118 if (sym_sec == sec)
1119 {
1120 symval += sym_sec->output_section->vma
1121 + sym_sec->output_offset;
1122
1123 if (debug_relax)
1124 printf ("Checking if the relocation's "
1125 "addend needs corrections.\n"
1126 "Address of anchor symbol: 0x%x \n"
1127 "Address of relocation target: 0x%x \n"
1128 "Address of relaxed insn: 0x%x \n",
1129 (unsigned int) symval,
1130 (unsigned int) (symval + irel->r_addend),
1131 (unsigned int) shrinked_insn_address);
1132
1133 /* Shrink the special DIFF relocations. */
1134 if (elf32_pru_is_diff_reloc (irel))
1135 {
1136 elf32_pru_adjust_diff_reloc_value (abfd, isec, irel,
1137 symval,
1138 shrinked_insn_address,
1139 count);
1140 }
1141
1142 /* Fix the addend, if it is affected. */
1143 if (symval <= shrinked_insn_address
1144 && (symval + irel->r_addend) > shrinked_insn_address)
1145 {
1146
1147 irel->r_addend -= count;
1148
1149 if (debug_relax)
1150 printf ("Relocation's addend needed to be fixed \n");
1151 }
1152 }
1153 /* else...Reference symbol is absolute.
1154 No adjustment needed. */
1155 }
1156 /* else...Reference symbol is extern. No need for adjusting
1157 the addend. */
1158 }
1159 }
1160 }
1161
1162 /* Adjust the local symbols defined in this section. */
1163 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1164 /* Fix PR 9841, there may be no local symbols. */
1165 if (isym != NULL)
1166 {
1167 Elf_Internal_Sym *isymend;
1168
1169 isymend = isym + symtab_hdr->sh_info;
1170 for (; isym < isymend; isym++)
1171 {
1172 if (isym->st_shndx == sec_shndx)
1173 {
1174 if (isym->st_value > addr
1175 && isym->st_value <= toaddr)
1176 isym->st_value -= count;
1177
1178 if (isym->st_value <= addr
1179 && isym->st_value + isym->st_size > addr)
1180 {
1181 /* If this assert fires then we have a symbol that ends
1182 part way through an instruction. Does that make
1183 sense? */
1184 BFD_ASSERT (isym->st_value + isym->st_size >= addr + count);
1185 isym->st_size -= count;
1186 }
1187 }
1188 }
1189 }
1190
1191 /* Now adjust the global symbols defined in this section. */
1192 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1193 - symtab_hdr->sh_info);
1194 sym_hashes = elf_sym_hashes (abfd);
1195 end_hashes = sym_hashes + symcount;
1196 for (; sym_hashes < end_hashes; sym_hashes++)
1197 {
1198 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1199 if ((sym_hash->root.type == bfd_link_hash_defined
1200 || sym_hash->root.type == bfd_link_hash_defweak)
1201 && sym_hash->root.u.def.section == sec)
1202 {
1203 if (sym_hash->root.u.def.value > addr
1204 && sym_hash->root.u.def.value <= toaddr)
1205 sym_hash->root.u.def.value -= count;
1206
1207 if (sym_hash->root.u.def.value <= addr
1208 && (sym_hash->root.u.def.value + sym_hash->size > addr))
1209 {
1210 /* If this assert fires then we have a symbol that ends
1211 part way through an instruction. Does that make
1212 sense? */
1213 BFD_ASSERT (sym_hash->root.u.def.value + sym_hash->size
1214 >= addr + count);
1215 sym_hash->size -= count;
1216 }
1217 }
1218 }
1219
1220 return TRUE;
1221 }
1222
1223 static bfd_boolean
1224 pru_elf32_relax_section (bfd * abfd, asection * sec,
1225 struct bfd_link_info * link_info,
1226 bfd_boolean * again)
1227 {
1228 Elf_Internal_Shdr * symtab_hdr;
1229 Elf_Internal_Rela * internal_relocs;
1230 Elf_Internal_Rela * irel;
1231 Elf_Internal_Rela * irelend;
1232 bfd_byte * contents = NULL;
1233 Elf_Internal_Sym * isymbuf = NULL;
1234
1235 /* Assume nothing changes. */
1236 *again = FALSE;
1237
1238 /* We don't have to do anything for a relocatable link, if
1239 this section does not have relocs, or if this is not a
1240 code section. */
1241 if (bfd_link_relocatable (link_info)
1242 || (sec->flags & SEC_RELOC) == 0
1243 || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
1244 return TRUE;
1245
1246 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1247
1248 /* Get a copy of the native relocations. */
1249 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
1250 link_info->keep_memory);
1251 if (internal_relocs == NULL)
1252 goto error_return;
1253
1254 /* Walk through them looking for relaxing opportunities. */
1255 irelend = internal_relocs + sec->reloc_count;
1256
1257 for (irel = internal_relocs; irel < irelend; irel++)
1258 {
1259 bfd_vma symval;
1260
1261 /* Get the section contents if we haven't done so already. */
1262 if (contents == NULL)
1263 {
1264 /* Get cached copy if it exists. */
1265 if (elf_section_data (sec)->this_hdr.contents != NULL)
1266 contents = elf_section_data (sec)->this_hdr.contents;
1267 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1268 goto error_return;
1269 }
1270
1271 /* Read this BFD's local symbols if we haven't done so already. */
1272 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1273 {
1274 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1275 if (isymbuf == NULL)
1276 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1277 symtab_hdr->sh_info, 0,
1278 NULL, NULL, NULL);
1279 if (isymbuf == NULL)
1280 goto error_return;
1281 }
1282
1283 /* Get the value of the symbol referred to by the reloc. */
1284 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1285 {
1286 /* A local symbol. */
1287 Elf_Internal_Sym *isym;
1288 asection *sym_sec;
1289
1290 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1291 if (isym->st_shndx == SHN_UNDEF)
1292 sym_sec = bfd_und_section_ptr;
1293 else if (isym->st_shndx == SHN_ABS)
1294 sym_sec = bfd_abs_section_ptr;
1295 else if (isym->st_shndx == SHN_COMMON)
1296 sym_sec = bfd_com_section_ptr;
1297 else
1298 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1299 symval = (isym->st_value
1300 + sym_sec->output_section->vma + sym_sec->output_offset);
1301 }
1302 else
1303 {
1304 unsigned long indx;
1305 struct elf_link_hash_entry *h;
1306
1307 /* An external symbol. */
1308 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1309 h = elf_sym_hashes (abfd)[indx];
1310 BFD_ASSERT (h != NULL);
1311
1312 if (h->root.type != bfd_link_hash_defined
1313 && h->root.type != bfd_link_hash_defweak)
1314 /* This appears to be a reference to an undefined
1315 symbol. Just ignore it--it will be caught by the
1316 regular reloc processing. */
1317 continue;
1318
1319 symval = (h->root.u.def.value
1320 + h->root.u.def.section->output_section->vma
1321 + h->root.u.def.section->output_offset);
1322 }
1323
1324 /* For simplicity of coding, we are going to modify the section
1325 contents, the section relocs, and the BFD symbol table. We
1326 must tell the rest of the code not to free up this
1327 information. It would be possible to instead create a table
1328 of changes which have to be made, as is done in coff-mips.c;
1329 that would be more work, but would require less memory when
1330 the linker is run. */
1331
1332 /* Check if we can remove an LDI instruction from the LDI32
1333 pseudo instruction if the upper 16 operand bits are zero. */
1334 if (ELF32_R_TYPE (irel->r_info) == (int) R_PRU_LDI32)
1335 {
1336 bfd_vma value = symval + irel->r_addend;
1337
1338 if (debug_relax)
1339 printf ("R_PRU_LDI32 with value=0x%lx\n", (long) value);
1340
1341 if ((long) value >> 16 == 0)
1342 {
1343 /* Note that we've changed the relocs, section contents. */
1344 elf_section_data (sec)->relocs = internal_relocs;
1345 elf_section_data (sec)->this_hdr.contents = contents;
1346 symtab_hdr->contents = (unsigned char *) isymbuf;
1347
1348 /* Delete bytes. */
1349 if (!pru_elf_relax_delete_bytes (abfd, sec, irel->r_offset + 4, 4))
1350 goto error_return;
1351
1352 /* We're done with deletion of the second instruction.
1353 Set a regular LDI relocation for the first instruction
1354 we left to load the 16-bit value into the 32-bit
1355 register. */
1356 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1357 R_PRU_U16);
1358
1359 /* That will change things, so, we should relax again.
1360 Note that this is not required, and it may be slow. */
1361 *again = TRUE;
1362 }
1363 }
1364 }
1365
1366 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1367 {
1368 if (!link_info->keep_memory)
1369 free (isymbuf);
1370 else
1371 {
1372 /* Cache the symbols for elf_link_input_bfd. */
1373 symtab_hdr->contents = (unsigned char *) isymbuf;
1374 }
1375 }
1376
1377 if (contents != NULL
1378 && elf_section_data (sec)->this_hdr.contents != contents)
1379 {
1380 if (!link_info->keep_memory)
1381 free (contents);
1382 else
1383 {
1384 /* Cache the section contents for elf_link_input_bfd. */
1385 elf_section_data (sec)->this_hdr.contents = contents;
1386 }
1387 }
1388
1389 if (internal_relocs != NULL
1390 && elf_section_data (sec)->relocs != internal_relocs)
1391 free (internal_relocs);
1392
1393 return TRUE;
1394
1395 error_return:
1396 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1397 free (isymbuf);
1398 if (contents != NULL
1399 && elf_section_data (sec)->this_hdr.contents != contents)
1400 free (contents);
1401 if (internal_relocs != NULL
1402 && elf_section_data (sec)->relocs != internal_relocs)
1403 free (internal_relocs);
1404
1405 return FALSE;
1406 }
1407
1408 /* Free the derived linker hash table. */
1409 static void
1410 pru_elf32_link_hash_table_free (bfd *obfd)
1411 {
1412 _bfd_elf_link_hash_table_free (obfd);
1413 }
1414
1415 /* Implement bfd_elf32_bfd_link_hash_table_create. */
1416 static struct bfd_link_hash_table *
1417 pru_elf32_link_hash_table_create (bfd *abfd)
1418 {
1419 struct elf_link_hash_table *ret;
1420 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1421
1422 ret = bfd_zmalloc (amt);
1423 if (ret == NULL)
1424 return NULL;
1425
1426 if (!_bfd_elf_link_hash_table_init (ret, abfd,
1427 link_hash_newfunc,
1428 sizeof (struct
1429 elf_link_hash_entry),
1430 PRU_ELF_DATA))
1431 {
1432 free (ret);
1433 return NULL;
1434 }
1435
1436 ret->root.hash_table_free = pru_elf32_link_hash_table_free;
1437
1438 return &ret->root;
1439 }
1440
1441 #define ELF_ARCH bfd_arch_pru
1442 #define ELF_TARGET_ID PRU_ELF_DATA
1443 #define ELF_MACHINE_CODE EM_TI_PRU
1444
1445 #define ELF_MAXPAGESIZE 1
1446
1447 #define bfd_elf32_bfd_link_hash_table_create \
1448 pru_elf32_link_hash_table_create
1449
1450 /* Relocation table lookup macros. */
1451
1452 #define bfd_elf32_bfd_reloc_type_lookup pru_elf32_bfd_reloc_type_lookup
1453 #define bfd_elf32_bfd_reloc_name_lookup pru_elf32_bfd_reloc_name_lookup
1454
1455 /* elf_info_to_howto (using RELA relocations). */
1456
1457 #define elf_info_to_howto pru_elf32_info_to_howto
1458
1459 /* elf backend functions. */
1460
1461 #define elf_backend_rela_normal 1
1462
1463 #define elf_backend_relocate_section pru_elf32_relocate_section
1464 #define bfd_elf32_bfd_relax_section pru_elf32_relax_section
1465
1466 #define TARGET_LITTLE_SYM pru_elf32_vec
1467 #define TARGET_LITTLE_NAME "elf32-pru"
1468
1469 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.