?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* po/sr.po: New Serbian translation.
[binutils.git] / bfd / elf32-m32r.c
blob37d995d14c362308fa3c95ad5433d530c1da2067
1 /* M32R-specific support for 32-bit ELF.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010, 2011 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 Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/m32r.h"
27
28 #define NOP_INSN 0x7000
29 #define MAKE_PARALLEL(insn) ((insn) | 0x8000)
30
31 /* Use REL instead of RELA to save space.
32 This only saves space in libraries and object files, but perhaps
33 relocs will be put in ROM? All in all though, REL relocs are a pain
34 to work with. */
35 /* #define USE_REL 1
36
37 #ifndef USE_REL
38 #define USE_REL 0
39 #endif */
40 /* Use RELA. But use REL to link old objects for backwords compatibility. */
41
42 /* Functions for the M32R ELF linker. */
43
44 /* The name of the dynamic interpreter. This is put in the .interp
45 section. */
46
47 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
48
49 /* The nop opcode we use. */
50
51 #define M32R_NOP 0x7000f000
52
53 #define PLT_EMPTY 0x10101010 /* RIE -> RIE */
54
55 /* The size in bytes of an entry in the procedure linkage table. */
56
57 #define PLT_ENTRY_SIZE 20
58 #define PLT_HEADER_SIZE 20
59
60 /* The first one entries in a procedure linkage table are reserved,
61 and the initial contents are unimportant (we zero them out).
62 Subsequent entries look like this. */
63
64 #define PLT0_ENTRY_WORD0 0xd6c00000 /* seth r6, #high(.got+4) */
65 #define PLT0_ENTRY_WORD1 0x86e60000 /* or3 r6, r6, #low(.got)+4) */
66 #define PLT0_ENTRY_WORD2 0x24e626c6 /* ld r4, @r6+ -> ld r6, @r6 */
67 #define PLT0_ENTRY_WORD3 0x1fc6f000 /* jmp r6 || pnop */
68 #define PLT0_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
69
70 #define PLT0_PIC_ENTRY_WORD0 0xa4cc0004 /* ld r4, @(4,r12) */
71 #define PLT0_PIC_ENTRY_WORD1 0xa6cc0008 /* ld r6, @(8,r12) */
72 #define PLT0_PIC_ENTRY_WORD2 0x1fc6f000 /* jmp r6 || nop */
73 #define PLT0_PIC_ENTRY_WORD3 PLT_EMPTY /* RIE -> RIE */
74 #define PLT0_PIC_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
75
76 #define PLT_ENTRY_WORD0 0xe6000000 /* ld24 r6, .name_in_GOT */
77 #define PLT_ENTRY_WORD1 0x06acf000 /* add r6, r12 || nop */
78 #define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT) */
79 #define PLT_ENTRY_WORD1b 0x86e60000 /* or3 r6, r6, #low(.name_in_GOT) */
80 #define PLT_ENTRY_WORD2 0x26c61fc6 /* ld r6, @r6 -> jmp r6 */
81 #define PLT_ENTRY_WORD3 0xe5000000 /* ld24 r5, $offset */
82 #define PLT_ENTRY_WORD4 0xff000000 /* bra .plt0. */
83
84
85 /* Utility to actually perform an R_M32R_10_PCREL reloc. */
86
87 static bfd_reloc_status_type
88 m32r_elf_do_10_pcrel_reloc (bfd *abfd,
89 reloc_howto_type *howto,
90 asection *input_section,
91 bfd_byte *data,
92 bfd_vma offset,
93 asection *symbol_section ATTRIBUTE_UNUSED,
94 bfd_vma symbol_value,
95 bfd_vma addend)
96 {
97 bfd_signed_vma relocation;
98 unsigned long x;
99 bfd_reloc_status_type status;
100
101 /* Sanity check the address (offset in section). */
102 if (offset > bfd_get_section_limit (abfd, input_section))
103 return bfd_reloc_outofrange;
104
105 relocation = symbol_value + addend;
106 /* Make it pc relative. */
107 relocation -= (input_section->output_section->vma
108 + input_section->output_offset);
109 /* These jumps mask off the lower two bits of the current address
110 before doing pcrel calculations. */
111 relocation -= (offset & -(bfd_vma) 4);
112
113 if (relocation < -0x200 || relocation > 0x1ff)
114 status = bfd_reloc_overflow;
115 else
116 status = bfd_reloc_ok;
117
118 x = bfd_get_16 (abfd, data + offset);
119 relocation >>= howto->rightshift;
120 relocation <<= howto->bitpos;
121 x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask);
122 bfd_put_16 (abfd, (bfd_vma) x, data + offset);
123
124 return status;
125 }
126
127 /* Handle the R_M32R_10_PCREL reloc. */
128
129 static bfd_reloc_status_type
130 m32r_elf_10_pcrel_reloc (bfd * abfd,
131 arelent * reloc_entry,
132 asymbol * symbol,
133 void * data,
134 asection * input_section,
135 bfd * output_bfd,
136 char ** error_message ATTRIBUTE_UNUSED)
137 {
138 /* This part is from bfd_elf_generic_reloc. */
139 if (output_bfd != NULL
140 && (symbol->flags & BSF_SECTION_SYM) == 0
141 && (! reloc_entry->howto->partial_inplace
142 || reloc_entry->addend == 0))
143 {
144 reloc_entry->address += input_section->output_offset;
145 return bfd_reloc_ok;
146 }
147
148 if (output_bfd != NULL)
149 /* FIXME: See bfd_perform_relocation. Is this right? */
150 return bfd_reloc_continue;
151
152 return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto,
153 input_section,
154 data, reloc_entry->address,
155 symbol->section,
156 (symbol->value
157 + symbol->section->output_section->vma
158 + symbol->section->output_offset),
159 reloc_entry->addend);
160 }
161
162 /* Do generic partial_inplace relocation.
163 This is a local replacement for bfd_elf_generic_reloc. */
164
165 static bfd_reloc_status_type
166 m32r_elf_generic_reloc (bfd *input_bfd,
167 arelent *reloc_entry,
168 asymbol *symbol,
169 void * data,
170 asection *input_section,
171 bfd *output_bfd,
172 char **error_message ATTRIBUTE_UNUSED)
173 {
174 bfd_reloc_status_type ret;
175 bfd_vma relocation;
176 bfd_byte *inplace_address;
177
178 /* This part is from bfd_elf_generic_reloc.
179 If we're relocating, and this an external symbol, we don't want
180 to change anything. */
181 if (output_bfd != NULL
182 && (symbol->flags & BSF_SECTION_SYM) == 0
183 && reloc_entry->addend == 0)
184 {
185 reloc_entry->address += input_section->output_offset;
186 return bfd_reloc_ok;
187 }
188
189 /* Now do the reloc in the usual way.
190 ??? It would be nice to call bfd_elf_generic_reloc here,
191 but we have partial_inplace set. bfd_elf_generic_reloc will
192 pass the handling back to bfd_install_relocation which will install
193 a section relative addend which is wrong. */
194
195 /* Sanity check the address (offset in section). */
196 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
197 return bfd_reloc_outofrange;
198
199 ret = bfd_reloc_ok;
200 if (bfd_is_und_section (symbol->section)
201 && output_bfd == NULL)
202 ret = bfd_reloc_undefined;
203
204 if (bfd_is_com_section (symbol->section)
205 || output_bfd != NULL)
206 relocation = 0;
207 else
208 relocation = symbol->value;
209
210 /* Only do this for a final link. */
211 if (output_bfd == NULL)
212 {
213 relocation += symbol->section->output_section->vma;
214 relocation += symbol->section->output_offset;
215 }
216
217 relocation += reloc_entry->addend;
218 inplace_address = (bfd_byte *) data + reloc_entry->address;
219
220 #define DOIT(x) \
221 x = ( (x & ~reloc_entry->howto->dst_mask) | \
222 (((x & reloc_entry->howto->src_mask) + relocation) & \
223 reloc_entry->howto->dst_mask))
224
225 switch (reloc_entry->howto->size)
226 {
227 case 1:
228 {
229 short x = bfd_get_16 (input_bfd, inplace_address);
230 DOIT (x);
231 bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address);
232 }
233 break;
234 case 2:
235 {
236 unsigned long x = bfd_get_32 (input_bfd, inplace_address);
237 DOIT (x);
238 bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address);
239 }
240 break;
241 default:
242 BFD_ASSERT (0);
243 }
244
245 if (output_bfd != NULL)
246 reloc_entry->address += input_section->output_offset;
247
248 return ret;
249 }
250
251 /* Handle the R_M32R_SDA16 reloc.
252 This reloc is used to compute the address of objects in the small data area
253 and to perform loads and stores from that area.
254 The lower 16 bits are sign extended and added to the register specified
255 in the instruction, which is assumed to point to _SDA_BASE_. */
256
257 static bfd_reloc_status_type
258 m32r_elf_sda16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
259 arelent *reloc_entry,
260 asymbol *symbol,
261 void * data ATTRIBUTE_UNUSED,
262 asection *input_section,
263 bfd *output_bfd,
264 char **error_message ATTRIBUTE_UNUSED)
265 {
266 /* This part is from bfd_elf_generic_reloc. */
267 if (output_bfd != NULL
268 && (symbol->flags & BSF_SECTION_SYM) == 0
269 && (! reloc_entry->howto->partial_inplace
270 || reloc_entry->addend == 0))
271 {
272 reloc_entry->address += input_section->output_offset;
273 return bfd_reloc_ok;
274 }
275
276 if (output_bfd != NULL)
277 /* FIXME: See bfd_perform_relocation. Is this right? */
278 return bfd_reloc_continue;
279
280 /* FIXME: not sure what to do here yet. But then again, the linker
281 may never call us. */
282 abort ();
283 }
284
285 \f
286 /* Handle the R_M32R_HI16_[SU]LO relocs.
287 HI16_SLO is for the add3 and load/store with displacement instructions.
288 HI16_ULO is for the or3 instruction.
289 For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to
290 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
291 we must add one to the high 16 bytes (which will get subtracted off when
292 the low 16 bits are added).
293 These relocs have to be done in combination with an R_M32R_LO16 reloc
294 because there is a carry from the LO16 to the HI16. Here we just save
295 the information we need; we do the actual relocation when we see the LO16.
296 This code is copied from the elf32-mips.c. We also support an arbitrary
297 number of HI16 relocs to be associated with a single LO16 reloc. The
298 assembler sorts the relocs to ensure each HI16 immediately precedes its
299 LO16. However if there are multiple copies, the assembler may not find
300 the real LO16 so it picks the first one it finds. */
301
302 struct m32r_hi16
303 {
304 struct m32r_hi16 *next;
305 bfd_byte *addr;
306 bfd_vma addend;
307 };
308
309 /* FIXME: This should not be a static variable. */
310
311 static struct m32r_hi16 *m32r_hi16_list;
312
313 static bfd_reloc_status_type
314 m32r_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
315 arelent *reloc_entry,
316 asymbol *symbol,
317 void * data,
318 asection *input_section,
319 bfd *output_bfd,
320 char **error_message ATTRIBUTE_UNUSED)
321 {
322 bfd_reloc_status_type ret;
323 bfd_vma relocation;
324 struct m32r_hi16 *n;
325
326 /* This part is from bfd_elf_generic_reloc.
327 If we're relocating, and this an external symbol, we don't want
328 to change anything. */
329 if (output_bfd != NULL
330 && (symbol->flags & BSF_SECTION_SYM) == 0
331 && reloc_entry->addend == 0)
332 {
333 reloc_entry->address += input_section->output_offset;
334 return bfd_reloc_ok;
335 }
336
337 /* Sanity check the address (offset in section). */
338 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
339 return bfd_reloc_outofrange;
340
341 ret = bfd_reloc_ok;
342 if (bfd_is_und_section (symbol->section)
343 && output_bfd == NULL)
344 ret = bfd_reloc_undefined;
345
346 if (bfd_is_com_section (symbol->section))
347 relocation = 0;
348 else
349 relocation = symbol->value;
350
351 relocation += symbol->section->output_section->vma;
352 relocation += symbol->section->output_offset;
353 relocation += reloc_entry->addend;
354
355 /* Save the information, and let LO16 do the actual relocation. */
356 n = bfd_malloc ((bfd_size_type) sizeof *n);
357 if (n == NULL)
358 return bfd_reloc_outofrange;
359 n->addr = (bfd_byte *) data + reloc_entry->address;
360 n->addend = relocation;
361 n->next = m32r_hi16_list;
362 m32r_hi16_list = n;
363
364 if (output_bfd != NULL)
365 reloc_entry->address += input_section->output_offset;
366
367 return ret;
368 }
369
370 /* Handle an M32R ELF HI16 reloc. */
371
372 static void
373 m32r_elf_relocate_hi16 (bfd *input_bfd,
374 int type,
375 Elf_Internal_Rela *relhi,
376 Elf_Internal_Rela *rello,
377 bfd_byte *contents,
378 bfd_vma addend)
379 {
380 unsigned long insn;
381 bfd_vma addlo;
382
383 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
384
385 addlo = bfd_get_32 (input_bfd, contents + rello->r_offset);
386 if (type == R_M32R_HI16_SLO)
387 addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000;
388 else
389 addlo &= 0xffff;
390
391 addend += ((insn & 0xffff) << 16) + addlo;
392
393 /* Reaccount for sign extension of low part. */
394 if (type == R_M32R_HI16_SLO
395 && (addend & 0x8000) != 0)
396 addend += 0x10000;
397
398 bfd_put_32 (input_bfd,
399 (insn & 0xffff0000) | ((addend >> 16) & 0xffff),
400 contents + relhi->r_offset);
401 }
402
403 /* Do an R_M32R_LO16 relocation. This is a straightforward 16 bit
404 inplace relocation; this function exists in order to do the
405 R_M32R_HI16_[SU]LO relocation described above. */
406
407 static bfd_reloc_status_type
408 m32r_elf_lo16_reloc (bfd *input_bfd,
409 arelent *reloc_entry,
410 asymbol *symbol,
411 void * data,
412 asection *input_section,
413 bfd *output_bfd,
414 char **error_message)
415 {
416 /* This part is from bfd_elf_generic_reloc.
417 If we're relocating, and this an external symbol, we don't want
418 to change anything. */
419 if (output_bfd != NULL
420 && (symbol->flags & BSF_SECTION_SYM) == 0
421 && reloc_entry->addend == 0)
422 {
423 reloc_entry->address += input_section->output_offset;
424 return bfd_reloc_ok;
425 }
426
427 if (m32r_hi16_list != NULL)
428 {
429 struct m32r_hi16 *l;
430
431 l = m32r_hi16_list;
432 while (l != NULL)
433 {
434 unsigned long insn;
435 unsigned long val;
436 unsigned long vallo;
437 struct m32r_hi16 *next;
438
439 /* Do the HI16 relocation. Note that we actually don't need
440 to know anything about the LO16 itself, except where to
441 find the low 16 bits of the addend needed by the LO16. */
442 insn = bfd_get_32 (input_bfd, l->addr);
443 vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address)
444 & 0xffff) ^ 0x8000) - 0x8000;
445 val = ((insn & 0xffff) << 16) + vallo;
446 val += l->addend;
447
448 /* Reaccount for sign extension of low part. */
449 if ((val & 0x8000) != 0)
450 val += 0x10000;
451
452 insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff);
453 bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr);
454
455 next = l->next;
456 free (l);
457 l = next;
458 }
459
460 m32r_hi16_list = NULL;
461 }
462
463 /* Now do the LO16 reloc in the usual way.
464 ??? It would be nice to call bfd_elf_generic_reloc here,
465 but we have partial_inplace set. bfd_elf_generic_reloc will
466 pass the handling back to bfd_install_relocation which will install
467 a section relative addend which is wrong. */
468 return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
469 input_section, output_bfd, error_message);
470 }
471
472 \f
473 static reloc_howto_type m32r_elf_howto_table[] =
474 {
475 /* This reloc does nothing. */
476 HOWTO (R_M32R_NONE, /* type */
477 0, /* rightshift */
478 2, /* size (0 = byte, 1 = short, 2 = long) */
479 32, /* bitsize */
480 FALSE, /* pc_relative */
481 0, /* bitpos */
482 complain_overflow_bitfield, /* complain_on_overflow */
483 bfd_elf_generic_reloc, /* special_function */
484 "R_M32R_NONE", /* name */
485 FALSE, /* partial_inplace */
486 0, /* src_mask */
487 0, /* dst_mask */
488 FALSE), /* pcrel_offset */
489
490 /* A 16 bit absolute relocation. */
491 HOWTO (R_M32R_16, /* type */
492 0, /* rightshift */
493 1, /* size (0 = byte, 1 = short, 2 = long) */
494 16, /* bitsize */
495 FALSE, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_bitfield, /* complain_on_overflow */
498 m32r_elf_generic_reloc,/* special_function */
499 "R_M32R_16", /* name */
500 TRUE, /* partial_inplace */
501 0xffff, /* src_mask */
502 0xffff, /* dst_mask */
503 FALSE), /* pcrel_offset */
504
505 /* A 32 bit absolute relocation. */
506 HOWTO (R_M32R_32, /* type */
507 0, /* rightshift */
508 2, /* size (0 = byte, 1 = short, 2 = long) */
509 32, /* bitsize */
510 FALSE, /* pc_relative */
511 0, /* bitpos */
512 complain_overflow_bitfield, /* complain_on_overflow */
513 m32r_elf_generic_reloc,/* special_function */
514 "R_M32R_32", /* name */
515 TRUE, /* partial_inplace */
516 0xffffffff, /* src_mask */
517 0xffffffff, /* dst_mask */
518 FALSE), /* pcrel_offset */
519
520 /* A 24 bit address. */
521 HOWTO (R_M32R_24, /* type */
522 0, /* rightshift */
523 2, /* size (0 = byte, 1 = short, 2 = long) */
524 24, /* bitsize */
525 FALSE, /* pc_relative */
526 0, /* bitpos */
527 complain_overflow_unsigned, /* complain_on_overflow */
528 m32r_elf_generic_reloc,/* special_function */
529 "R_M32R_24", /* name */
530 TRUE, /* partial_inplace */
531 0xffffff, /* src_mask */
532 0xffffff, /* dst_mask */
533 FALSE), /* pcrel_offset */
534
535 /* An PC Relative 10-bit relocation, shifted by 2.
536 This reloc is complicated because relocations are relative to pc & -4.
537 i.e. branches in the right insn slot use the address of the left insn
538 slot for pc. */
539 /* ??? It's not clear whether this should have partial_inplace set or not.
540 Branch relaxing in the assembler can store the addend in the insn,
541 and if bfd_install_relocation gets called the addend may get added
542 again. */
543 HOWTO (R_M32R_10_PCREL, /* type */
544 2, /* rightshift */
545 1, /* size (0 = byte, 1 = short, 2 = long) */
546 10, /* bitsize */
547 TRUE, /* pc_relative */
548 0, /* bitpos */
549 complain_overflow_signed, /* complain_on_overflow */
550 m32r_elf_10_pcrel_reloc, /* special_function */
551 "R_M32R_10_PCREL", /* name */
552 FALSE, /* partial_inplace */
553 0xff, /* src_mask */
554 0xff, /* dst_mask */
555 TRUE), /* pcrel_offset */
556
557 /* A relative 18 bit relocation, right shifted by 2. */
558 HOWTO (R_M32R_18_PCREL, /* type */
559 2, /* rightshift */
560 2, /* size (0 = byte, 1 = short, 2 = long) */
561 16, /* bitsize */
562 TRUE, /* pc_relative */
563 0, /* bitpos */
564 complain_overflow_signed, /* complain_on_overflow */
565 bfd_elf_generic_reloc, /* special_function */
566 "R_M32R_18_PCREL", /* name */
567 FALSE, /* partial_inplace */
568 0xffff, /* src_mask */
569 0xffff, /* dst_mask */
570 TRUE), /* pcrel_offset */
571
572 /* A relative 26 bit relocation, right shifted by 2. */
573 /* ??? It's not clear whether this should have partial_inplace set or not.
574 Branch relaxing in the assembler can store the addend in the insn,
575 and if bfd_install_relocation gets called the addend may get added
576 again. */
577 HOWTO (R_M32R_26_PCREL, /* type */
578 2, /* rightshift */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
580 26, /* bitsize */
581 TRUE, /* pc_relative */
582 0, /* bitpos */
583 complain_overflow_signed, /* complain_on_overflow */
584 bfd_elf_generic_reloc, /* special_function */
585 "R_M32R_26_PCREL", /* name */
586 FALSE, /* partial_inplace */
587 0xffffff, /* src_mask */
588 0xffffff, /* dst_mask */
589 TRUE), /* pcrel_offset */
590
591 /* High 16 bits of address when lower 16 is or'd in. */
592 HOWTO (R_M32R_HI16_ULO, /* type */
593 16, /* rightshift */
594 2, /* size (0 = byte, 1 = short, 2 = long) */
595 16, /* bitsize */
596 FALSE, /* pc_relative */
597 0, /* bitpos */
598 complain_overflow_dont, /* complain_on_overflow */
599 m32r_elf_hi16_reloc, /* special_function */
600 "R_M32R_HI16_ULO", /* name */
601 TRUE, /* partial_inplace */
602 0x0000ffff, /* src_mask */
603 0x0000ffff, /* dst_mask */
604 FALSE), /* pcrel_offset */
605
606 /* High 16 bits of address when lower 16 is added in. */
607 HOWTO (R_M32R_HI16_SLO, /* type */
608 16, /* rightshift */
609 2, /* size (0 = byte, 1 = short, 2 = long) */
610 16, /* bitsize */
611 FALSE, /* pc_relative */
612 0, /* bitpos */
613 complain_overflow_dont, /* complain_on_overflow */
614 m32r_elf_hi16_reloc, /* special_function */
615 "R_M32R_HI16_SLO", /* name */
616 TRUE, /* partial_inplace */
617 0x0000ffff, /* src_mask */
618 0x0000ffff, /* dst_mask */
619 FALSE), /* pcrel_offset */
620
621 /* Lower 16 bits of address. */
622 HOWTO (R_M32R_LO16, /* type */
623 0, /* rightshift */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
625 16, /* bitsize */
626 FALSE, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_dont, /* complain_on_overflow */
629 m32r_elf_lo16_reloc, /* special_function */
630 "R_M32R_LO16", /* name */
631 TRUE, /* partial_inplace */
632 0x0000ffff, /* src_mask */
633 0x0000ffff, /* dst_mask */
634 FALSE), /* pcrel_offset */
635
636 /* Small data area 16 bits offset. */
637 HOWTO (R_M32R_SDA16, /* type */
638 0, /* rightshift */
639 2, /* size (0 = byte, 1 = short, 2 = long) */
640 16, /* bitsize */
641 FALSE, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_signed, /* complain_on_overflow */
644 m32r_elf_sda16_reloc, /* special_function */
645 "R_M32R_SDA16", /* name */
646 TRUE, /* partial_inplace */ /* FIXME: correct? */
647 0x0000ffff, /* src_mask */
648 0x0000ffff, /* dst_mask */
649 FALSE), /* pcrel_offset */
650
651 /* GNU extension to record C++ vtable hierarchy. */
652 HOWTO (R_M32R_GNU_VTINHERIT, /* type */
653 0, /* rightshift */
654 2, /* size (0 = byte, 1 = short, 2 = long) */
655 0, /* bitsize */
656 FALSE, /* pc_relative */
657 0, /* bitpos */
658 complain_overflow_dont, /* complain_on_overflow */
659 NULL, /* special_function */
660 "R_M32R_GNU_VTINHERIT", /* name */
661 FALSE, /* partial_inplace */
662 0, /* src_mask */
663 0, /* dst_mask */
664 FALSE), /* pcrel_offset */
665
666 /* GNU extension to record C++ vtable member usage. */
667 HOWTO (R_M32R_GNU_VTENTRY, /* type */
668 0, /* rightshift */
669 2, /* size (0 = byte, 1 = short, 2 = long) */
670 0, /* bitsize */
671 FALSE, /* pc_relative */
672 0, /* bitpos */
673 complain_overflow_dont, /* complain_on_overflow */
674 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
675 "R_M32R_GNU_VTENTRY", /* name */
676 FALSE, /* partial_inplace */
677 0, /* src_mask */
678 0, /* dst_mask */
679 FALSE), /* pcrel_offset */
680
681 EMPTY_HOWTO (13),
682 EMPTY_HOWTO (14),
683 EMPTY_HOWTO (15),
684 EMPTY_HOWTO (16),
685 EMPTY_HOWTO (17),
686 EMPTY_HOWTO (18),
687 EMPTY_HOWTO (19),
688 EMPTY_HOWTO (20),
689 EMPTY_HOWTO (21),
690 EMPTY_HOWTO (22),
691 EMPTY_HOWTO (23),
692 EMPTY_HOWTO (24),
693 EMPTY_HOWTO (25),
694 EMPTY_HOWTO (26),
695 EMPTY_HOWTO (27),
696 EMPTY_HOWTO (28),
697 EMPTY_HOWTO (29),
698 EMPTY_HOWTO (30),
699 EMPTY_HOWTO (31),
700 EMPTY_HOWTO (32),
701
702 /* A 16 bit absolute relocation. */
703 HOWTO (R_M32R_16_RELA, /* type */
704 0, /* rightshift */
705 1, /* size (0 = byte, 1 = short, 2 = long) */
706 16, /* bitsize */
707 FALSE, /* pc_relative */
708 0, /* bitpos */
709 complain_overflow_bitfield, /* complain_on_overflow */
710 bfd_elf_generic_reloc, /* special_function */
711 "R_M32R_16_RELA", /* name */
712 FALSE, /* partial_inplace */
713 0xffff, /* src_mask */
714 0xffff, /* dst_mask */
715 FALSE), /* pcrel_offset */
716
717 /* A 32 bit absolute relocation. */
718 HOWTO (R_M32R_32_RELA, /* type */
719 0, /* rightshift */
720 2, /* size (0 = byte, 1 = short, 2 = long) */
721 32, /* bitsize */
722 FALSE, /* pc_relative */
723 0, /* bitpos */
724 complain_overflow_bitfield, /* complain_on_overflow */
725 bfd_elf_generic_reloc,/* special_function */
726 "R_M32R_32_RELA", /* name */
727 FALSE, /* partial_inplace */
728 0xffffffff, /* src_mask */
729 0xffffffff, /* dst_mask */
730 FALSE), /* pcrel_offset */
731
732 /* A 24 bit address. */
733 HOWTO (R_M32R_24_RELA, /* type */
734 0, /* rightshift */
735 2, /* size (0 = byte, 1 = short, 2 = long) */
736 24, /* bitsize */
737 FALSE, /* pc_relative */
738 0, /* bitpos */
739 complain_overflow_unsigned, /* complain_on_overflow */
740 bfd_elf_generic_reloc,/* special_function */
741 "R_M32R_24_RELA", /* name */
742 FALSE, /* partial_inplace */
743 0xffffff, /* src_mask */
744 0xffffff, /* dst_mask */
745 FALSE), /* pcrel_offset */
746
747 HOWTO (R_M32R_10_PCREL_RELA, /* type */
748 2, /* rightshift */
749 1, /* size (0 = byte, 1 = short, 2 = long) */
750 10, /* bitsize */
751 TRUE, /* pc_relative */
752 0, /* bitpos */
753 complain_overflow_signed, /* complain_on_overflow */
754 m32r_elf_10_pcrel_reloc, /* special_function */
755 "R_M32R_10_PCREL_RELA",/* name */
756 FALSE, /* partial_inplace */
757 0xff, /* src_mask */
758 0xff, /* dst_mask */
759 TRUE), /* pcrel_offset */
760
761 /* A relative 18 bit relocation, right shifted by 2. */
762 HOWTO (R_M32R_18_PCREL_RELA, /* type */
763 2, /* rightshift */
764 2, /* size (0 = byte, 1 = short, 2 = long) */
765 16, /* bitsize */
766 TRUE, /* pc_relative */
767 0, /* bitpos */
768 complain_overflow_signed, /* complain_on_overflow */
769 bfd_elf_generic_reloc, /* special_function */
770 "R_M32R_18_PCREL_RELA",/* name */
771 FALSE, /* partial_inplace */
772 0xffff, /* src_mask */
773 0xffff, /* dst_mask */
774 TRUE), /* pcrel_offset */
775
776 /* A relative 26 bit relocation, right shifted by 2. */
777 HOWTO (R_M32R_26_PCREL_RELA, /* type */
778 2, /* rightshift */
779 2, /* size (0 = byte, 1 = short, 2 = long) */
780 26, /* bitsize */
781 TRUE, /* pc_relative */
782 0, /* bitpos */
783 complain_overflow_signed, /* complain_on_overflow */
784 bfd_elf_generic_reloc, /* special_function */
785 "R_M32R_26_PCREL_RELA",/* name */
786 FALSE, /* partial_inplace */
787 0xffffff, /* src_mask */
788 0xffffff, /* dst_mask */
789 TRUE), /* pcrel_offset */
790
791 /* High 16 bits of address when lower 16 is or'd in. */
792 HOWTO (R_M32R_HI16_ULO_RELA, /* type */
793 16, /* rightshift */
794 2, /* size (0 = byte, 1 = short, 2 = long) */
795 16, /* bitsize */
796 FALSE, /* pc_relative */
797 0, /* bitpos */
798 complain_overflow_dont, /* complain_on_overflow */
799 bfd_elf_generic_reloc, /* special_function */
800 "R_M32R_HI16_ULO_RELA",/* name */
801 FALSE, /* partial_inplace */
802 0x0000ffff, /* src_mask */
803 0x0000ffff, /* dst_mask */
804 FALSE), /* pcrel_offset */
805
806 /* High 16 bits of address when lower 16 is added in. */
807 HOWTO (R_M32R_HI16_SLO_RELA, /* type */
808 16, /* rightshift */
809 2, /* size (0 = byte, 1 = short, 2 = long) */
810 16, /* bitsize */
811 FALSE, /* pc_relative */
812 0, /* bitpos */
813 complain_overflow_dont, /* complain_on_overflow */
814 bfd_elf_generic_reloc, /* special_function */
815 "R_M32R_HI16_SLO_RELA",/* name */
816 FALSE, /* partial_inplace */
817 0x0000ffff, /* src_mask */
818 0x0000ffff, /* dst_mask */
819 FALSE), /* pcrel_offset */
820
821 /* Lower 16 bits of address. */
822 HOWTO (R_M32R_LO16_RELA, /* type */
823 0, /* rightshift */
824 2, /* size (0 = byte, 1 = short, 2 = long) */
825 16, /* bitsize */
826 FALSE, /* pc_relative */
827 0, /* bitpos */
828 complain_overflow_dont, /* complain_on_overflow */
829 bfd_elf_generic_reloc, /* special_function */
830 "R_M32R_LO16_RELA", /* name */
831 FALSE, /* partial_inplace */
832 0x0000ffff, /* src_mask */
833 0x0000ffff, /* dst_mask */
834 FALSE), /* pcrel_offset */
835
836 /* Small data area 16 bits offset. */
837 HOWTO (R_M32R_SDA16_RELA, /* type */
838 0, /* rightshift */
839 2, /* size (0 = byte, 1 = short, 2 = long) */
840 16, /* bitsize */
841 FALSE, /* pc_relative */
842 0, /* bitpos */
843 complain_overflow_signed, /* complain_on_overflow */
844 bfd_elf_generic_reloc, /* special_function */
845 "R_M32R_SDA16_RELA", /* name */
846 TRUE, /* partial_inplace */ /* FIXME: correct? */
847 0x0000ffff, /* src_mask */
848 0x0000ffff, /* dst_mask */
849 FALSE), /* pcrel_offset */
850
851 /* GNU extension to record C++ vtable hierarchy. */
852 HOWTO (R_M32R_RELA_GNU_VTINHERIT, /* type */
853 0, /* rightshift */
854 2, /* size (0 = byte, 1 = short, 2 = long) */
855 0, /* bitsize */
856 FALSE, /* pc_relative */
857 0, /* bitpos */
858 complain_overflow_dont, /* complain_on_overflow */
859 NULL, /* special_function */
860 "R_M32R_RELA_GNU_VTINHERIT", /* name */
861 FALSE, /* partial_inplace */
862 0, /* src_mask */
863 0, /* dst_mask */
864 FALSE), /* pcrel_offset */
865
866 /* GNU extension to record C++ vtable member usage. */
867 HOWTO (R_M32R_RELA_GNU_VTENTRY, /* type */
868 0, /* rightshift */
869 2, /* size (0 = byte, 1 = short, 2 = long) */
870 0, /* bitsize */
871 FALSE, /* pc_relative */
872 0, /* bitpos */
873 complain_overflow_dont, /* complain_on_overflow */
874 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
875 "R_M32R_RELA_GNU_VTENTRY", /* name */
876 FALSE, /* partial_inplace */
877 0, /* src_mask */
878 0, /* dst_mask */
879 FALSE), /* pcrel_offset */
880
881 /* A 32 bit PC relative relocation. */
882 HOWTO (R_M32R_REL32, /* type */
883 0, /* rightshift */
884 2, /* size (0 = byte, 1 = short, 2 = long) */
885 32, /* bitsize */
886 TRUE, /* pc_relative */
887 0, /* bitpos */
888 complain_overflow_bitfield, /* complain_on_overflow */
889 bfd_elf_generic_reloc,/* special_function */
890 "R_M32R_REL32", /* name */
891 FALSE, /* partial_inplace */
892 0xffffffff, /* src_mask */
893 0xffffffff, /* dst_mask */
894 TRUE), /* pcrel_offset */
895
896 EMPTY_HOWTO (46),
897 EMPTY_HOWTO (47),
898
899 /* Like R_M32R_24, but referring to the GOT table entry for
900 the symbol. */
901 HOWTO (R_M32R_GOT24, /* type */
902 0, /* rightshift */
903 2, /* size (0 = byte, 1 = short, 2 = long) */
904 24, /* bitsize */
905 FALSE, /* pc_relative */
906 0, /* bitpos */
907 complain_overflow_unsigned, /* complain_on_overflow */
908 bfd_elf_generic_reloc, /* special_function */
909 "R_M32R_GOT24", /* name */
910 FALSE, /* partial_inplace */
911 0xffffff, /* src_mask */
912 0xffffff, /* dst_mask */
913 FALSE), /* pcrel_offset */
914
915 /* Like R_M32R_PCREL, but referring to the procedure linkage table
916 entry for the symbol. */
917 HOWTO (R_M32R_26_PLTREL, /* type */
918 2, /* rightshift */
919 2, /* size (0 = byte, 1 = short, 2 = long) */
920 24, /* bitsize */
921 TRUE, /* pc_relative */
922 0, /* bitpos */
923 complain_overflow_signed, /* complain_on_overflow */
924 bfd_elf_generic_reloc, /* special_function */
925 "R_M32R_26_PLTREL", /* name */
926 FALSE, /* partial_inplace */
927 0xffffff, /* src_mask */
928 0xffffff, /* dst_mask */
929 TRUE), /* pcrel_offset */
930
931 /* This is used only by the dynamic linker. The symbol should exist
932 both in the object being run and in some shared library. The
933 dynamic linker copies the data addressed by the symbol from the
934 shared library into the object, because the object being
935 run has to have the data at some particular address. */
936 HOWTO (R_M32R_COPY, /* type */
937 0, /* rightshift */
938 2, /* size (0 = byte, 1 = short, 2 = long) */
939 32, /* bitsize */
940 FALSE, /* pc_relative */
941 0, /* bitpos */
942 complain_overflow_bitfield, /* complain_on_overflow */
943 bfd_elf_generic_reloc, /* special_function */
944 "R_M32R_COPY", /* name */
945 FALSE, /* partial_inplace */
946 0xffffffff, /* src_mask */
947 0xffffffff, /* dst_mask */
948 FALSE), /* pcrel_offset */
949
950 /* Like R_M32R_24, but used when setting global offset table
951 entries. */
952 HOWTO (R_M32R_GLOB_DAT, /* type */
953 0, /* rightshift */
954 2, /* size (0 = byte, 1 = short, 2 = long) */
955 32, /* bitsize */
956 FALSE, /* pc_relative */
957 0, /* bitpos */
958 complain_overflow_bitfield, /* complain_on_overflow */
959 bfd_elf_generic_reloc, /* special_function */
960 "R_M32R_GLOB_DAT", /* name */
961 FALSE, /* partial_inplace */
962 0xffffffff, /* src_mask */
963 0xffffffff, /* dst_mask */
964 FALSE), /* pcrel_offset */
965
966 /* Marks a procedure linkage table entry for a symbol. */
967 HOWTO (R_M32R_JMP_SLOT, /* type */
968 0, /* rightshift */
969 2, /* size (0 = byte, 1 = short, 2 = long) */
970 32, /* bitsize */
971 FALSE, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_bitfield, /* complain_on_overflow */
974 bfd_elf_generic_reloc, /* special_function */
975 "R_M32R_JMP_SLOT", /* name */
976 FALSE, /* partial_inplace */
977 0xffffffff, /* src_mask */
978 0xffffffff, /* dst_mask */
979 FALSE), /* pcrel_offset */
980
981 /* Used only by the dynamic linker. When the object is run, this
982 longword is set to the load address of the object, plus the
983 addend. */
984 HOWTO (R_M32R_RELATIVE, /* type */
985 0, /* rightshift */
986 2, /* size (0 = byte, 1 = short, 2 = long) */
987 32, /* bitsize */
988 FALSE, /* pc_relative */
989 0, /* bitpos */
990 complain_overflow_bitfield, /* complain_on_overflow */
991 bfd_elf_generic_reloc, /* special_function */
992 "R_M32R_RELATIVE", /* name */
993 FALSE, /* partial_inplace */
994 0xffffffff, /* src_mask */
995 0xffffffff, /* dst_mask */
996 FALSE), /* pcrel_offset */
997
998 HOWTO (R_M32R_GOTOFF, /* type */
999 0, /* rightshift */
1000 2, /* size (0 = byte, 1 = short, 2 = long) */
1001 24, /* bitsize */
1002 FALSE, /* pc_relative */
1003 0, /* bitpos */
1004 complain_overflow_bitfield, /* complain_on_overflow */
1005 bfd_elf_generic_reloc, /* special_function */
1006 "R_M32R_GOTOFF", /* name */
1007 FALSE, /* partial_inplace */
1008 0xffffff, /* src_mask */
1009 0xffffff, /* dst_mask */
1010 FALSE), /* pcrel_offset */
1011
1012 /* An PC Relative 24-bit relocation used when setting PIC offset
1013 table register. */
1014 HOWTO (R_M32R_GOTPC24, /* type */
1015 0, /* rightshift */
1016 2, /* size (0 = byte, 1 = short, 2 = long) */
1017 24, /* bitsize */
1018 TRUE, /* pc_relative */
1019 0, /* bitpos */
1020 complain_overflow_unsigned, /* complain_on_overflow */
1021 bfd_elf_generic_reloc, /* special_function */
1022 "R_M32R_GOTPC24", /* name */
1023 FALSE, /* partial_inplace */
1024 0xffffff, /* src_mask */
1025 0xffffff, /* dst_mask */
1026 TRUE), /* pcrel_offset */
1027
1028 /* Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1029 the symbol. */
1030 HOWTO (R_M32R_GOT16_HI_ULO, /* type */
1031 16, /* rightshift */
1032 2, /* size (0 = byte, 1 = short, 2 = long) */
1033 16, /* bitsize */
1034 FALSE, /* pc_relative */
1035 0, /* bitpos */
1036 complain_overflow_dont, /* complain_on_overflow */
1037 bfd_elf_generic_reloc, /* special_function */
1038 "R_M32R_GOT16_HI_ULO", /* name */
1039 FALSE, /* partial_inplace */
1040 0x0000ffff, /* src_mask */
1041 0x0000ffff, /* dst_mask */
1042 FALSE), /* pcrel_offset */
1043
1044 /* Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1045 the symbol. */
1046 HOWTO (R_M32R_GOT16_HI_SLO, /* type */
1047 16, /* rightshift */
1048 2, /* size (0 = byte, 1 = short, 2 = long) */
1049 16, /* bitsize */
1050 FALSE, /* pc_relative */
1051 0, /* bitpos */
1052 complain_overflow_dont, /* complain_on_overflow */
1053 bfd_elf_generic_reloc, /* special_function */
1054 "R_M32R_GOT16_HI_SLO", /* name */
1055 FALSE, /* partial_inplace */
1056 0x0000ffff, /* src_mask */
1057 0x0000ffff, /* dst_mask */
1058 FALSE), /* pcrel_offset */
1059
1060 /* Like R_M32R_LO16, but referring to the GOT table entry for
1061 the symbol. */
1062 HOWTO (R_M32R_GOT16_LO, /* type */
1063 0, /* rightshift */
1064 2, /* size (0 = byte, 1 = short, 2 = long) */
1065 16, /* bitsize */
1066 FALSE, /* pc_relative */
1067 0, /* bitpos */
1068 complain_overflow_dont, /* complain_on_overflow */
1069 bfd_elf_generic_reloc, /* special_function */
1070 "R_M32R_GOT16_LO", /* name */
1071 FALSE, /* partial_inplace */
1072 0x0000ffff, /* src_mask */
1073 0x0000ffff, /* dst_mask */
1074 FALSE), /* pcrel_offset */
1075
1076 /* An PC Relative relocation used when setting PIC offset table register.
1077 Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1078 the symbol. */
1079 HOWTO (R_M32R_GOTPC_HI_ULO, /* type */
1080 16, /* rightshift */
1081 2, /* size (0 = byte, 1 = short, 2 = long) */
1082 16, /* bitsize */
1083 FALSE, /* pc_relative */
1084 0, /* bitpos */
1085 complain_overflow_dont, /* complain_on_overflow */
1086 bfd_elf_generic_reloc, /* special_function */
1087 "R_M32R_GOTPC_HI_ULO", /* name */
1088 FALSE, /* partial_inplace */
1089 0x0000ffff, /* src_mask */
1090 0x0000ffff, /* dst_mask */
1091 TRUE), /* pcrel_offset */
1092
1093 /* An PC Relative relocation used when setting PIC offset table register.
1094 Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1095 the symbol. */
1096 HOWTO (R_M32R_GOTPC_HI_SLO, /* type */
1097 16, /* rightshift */
1098 2, /* size (0 = byte, 1 = short, 2 = long) */
1099 16, /* bitsize */
1100 FALSE, /* pc_relative */
1101 0, /* bitpos */
1102 complain_overflow_dont, /* complain_on_overflow */
1103 bfd_elf_generic_reloc, /* special_function */
1104 "R_M32R_GOTPC_HI_SLO", /* name */
1105 FALSE, /* partial_inplace */
1106 0x0000ffff, /* src_mask */
1107 0x0000ffff, /* dst_mask */
1108 TRUE), /* pcrel_offset */
1109
1110 /* An PC Relative relocation used when setting PIC offset table register.
1111 Like R_M32R_LO16, but referring to the GOT table entry for
1112 the symbol. */
1113 HOWTO (R_M32R_GOTPC_LO, /* type */
1114 0, /* rightshift */
1115 2, /* size (0 = byte, 1 = short, 2 = long) */
1116 16, /* bitsize */
1117 FALSE, /* pc_relative */
1118 0, /* bitpos */
1119 complain_overflow_dont, /* complain_on_overflow */
1120 bfd_elf_generic_reloc, /* special_function */
1121 "R_M32R_GOTPC_LO", /* name */
1122 FALSE, /* partial_inplace */
1123 0x0000ffff, /* src_mask */
1124 0x0000ffff, /* dst_mask */
1125 TRUE), /* pcrel_offset */
1126
1127 HOWTO (R_M32R_GOTOFF_HI_ULO, /* type */
1128 16, /* rightshift */
1129 2, /* size (0 = byte, 1 = short, 2 = long) */
1130 16, /* bitsize */
1131 FALSE, /* pc_relative */
1132 0, /* bitpos */
1133 complain_overflow_dont, /* complain_on_overflow */
1134 bfd_elf_generic_reloc, /* special_function */
1135 "R_M32R_GOTOFF_HI_ULO",/* name */
1136 FALSE, /* partial_inplace */
1137 0x0000ffff, /* src_mask */
1138 0x0000ffff, /* dst_mask */
1139 FALSE), /* pcrel_offset */
1140
1141 HOWTO (R_M32R_GOTOFF_HI_SLO, /* type */
1142 16, /* rightshift */
1143 2, /* size (0 = byte, 1 = short, 2 = long) */
1144 16, /* bitsize */
1145 FALSE, /* pc_relative */
1146 0, /* bitpos */
1147 complain_overflow_dont, /* complain_on_overflow */
1148 bfd_elf_generic_reloc, /* special_function */
1149 "R_M32R_GOTOFF_HI_SLO",/* name */
1150 FALSE, /* partial_inplace */
1151 0x0000ffff, /* src_mask */
1152 0x0000ffff, /* dst_mask */
1153 FALSE), /* pcrel_offset */
1154
1155 HOWTO (R_M32R_GOTOFF_LO, /* type */
1156 0, /* rightshift */
1157 2, /* size (0 = byte, 1 = short, 2 = long) */
1158 16, /* bitsize */
1159 FALSE, /* pc_relative */
1160 0, /* bitpos */
1161 complain_overflow_dont, /* complain_on_overflow */
1162 bfd_elf_generic_reloc, /* special_function */
1163 "R_M32R_GOTOFF_LO", /* name */
1164 FALSE, /* partial_inplace */
1165 0x0000ffff, /* src_mask */
1166 0x0000ffff, /* dst_mask */
1167 FALSE), /* pcrel_offset */
1168 };
1169
1170 /* Map BFD reloc types to M32R ELF reloc types. */
1171
1172 struct m32r_reloc_map
1173 {
1174 bfd_reloc_code_real_type bfd_reloc_val;
1175 unsigned char elf_reloc_val;
1176 };
1177
1178 #ifdef USE_M32R_OLD_RELOC
1179 static const struct m32r_reloc_map m32r_reloc_map_old[] =
1180 {
1181 { BFD_RELOC_NONE, R_M32R_NONE },
1182 { BFD_RELOC_16, R_M32R_16 },
1183 { BFD_RELOC_32, R_M32R_32 },
1184 { BFD_RELOC_M32R_24, R_M32R_24 },
1185 { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL },
1186 { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL },
1187 { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL },
1188 { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO },
1189 { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO },
1190 { BFD_RELOC_M32R_LO16, R_M32R_LO16 },
1191 { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 },
1192 { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT },
1193 { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY },
1194 };
1195 #else
1196 static const struct m32r_reloc_map m32r_reloc_map[] =
1197 {
1198 { BFD_RELOC_NONE, R_M32R_NONE },
1199 { BFD_RELOC_16, R_M32R_16_RELA },
1200 { BFD_RELOC_32, R_M32R_32_RELA },
1201 { BFD_RELOC_M32R_24, R_M32R_24_RELA },
1202 { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL_RELA },
1203 { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL_RELA },
1204 { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL_RELA },
1205 { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO_RELA },
1206 { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO_RELA },
1207 { BFD_RELOC_M32R_LO16, R_M32R_LO16_RELA },
1208 { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
1209 { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
1210 { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
1211 { BFD_RELOC_32_PCREL, R_M32R_REL32 },
1212
1213 { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
1214 { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
1215 { BFD_RELOC_M32R_COPY, R_M32R_COPY },
1216 { BFD_RELOC_M32R_GLOB_DAT, R_M32R_GLOB_DAT },
1217 { BFD_RELOC_M32R_JMP_SLOT, R_M32R_JMP_SLOT },
1218 { BFD_RELOC_M32R_RELATIVE, R_M32R_RELATIVE },
1219 { BFD_RELOC_M32R_GOTOFF, R_M32R_GOTOFF },
1220 { BFD_RELOC_M32R_GOTPC24, R_M32R_GOTPC24 },
1221 { BFD_RELOC_M32R_GOT16_HI_ULO, R_M32R_GOT16_HI_ULO },
1222 { BFD_RELOC_M32R_GOT16_HI_SLO, R_M32R_GOT16_HI_SLO },
1223 { BFD_RELOC_M32R_GOT16_LO, R_M32R_GOT16_LO },
1224 { BFD_RELOC_M32R_GOTPC_HI_ULO, R_M32R_GOTPC_HI_ULO },
1225 { BFD_RELOC_M32R_GOTPC_HI_SLO, R_M32R_GOTPC_HI_SLO },
1226 { BFD_RELOC_M32R_GOTPC_LO, R_M32R_GOTPC_LO },
1227 { BFD_RELOC_M32R_GOTOFF_HI_ULO, R_M32R_GOTOFF_HI_ULO },
1228 { BFD_RELOC_M32R_GOTOFF_HI_SLO, R_M32R_GOTOFF_HI_SLO },
1229 { BFD_RELOC_M32R_GOTOFF_LO, R_M32R_GOTOFF_LO },
1230 };
1231 #endif
1232
1233 static reloc_howto_type *
1234 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1235 bfd_reloc_code_real_type code)
1236 {
1237 unsigned int i;
1238
1239 #ifdef USE_M32R_OLD_RELOC
1240 for (i = 0;
1241 i < sizeof (m32r_reloc_map_old) / sizeof (struct m32r_reloc_map);
1242 i++)
1243 if (m32r_reloc_map_old[i].bfd_reloc_val == code)
1244 return &m32r_elf_howto_table[m32r_reloc_map_old[i].elf_reloc_val];
1245
1246 #else /* ! USE_M32R_OLD_RELOC */
1247
1248 for (i = 0;
1249 i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map);
1250 i++)
1251 if (m32r_reloc_map[i].bfd_reloc_val == code)
1252 return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val];
1253 #endif
1254
1255 return NULL;
1256 }
1257
1258 static reloc_howto_type *
1259 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1260 const char *r_name)
1261 {
1262 unsigned int i;
1263
1264 for (i = 0;
1265 i < sizeof (m32r_elf_howto_table) / sizeof (m32r_elf_howto_table[0]);
1266 i++)
1267 if (m32r_elf_howto_table[i].name != NULL
1268 && strcasecmp (m32r_elf_howto_table[i].name, r_name) == 0)
1269 return &m32r_elf_howto_table[i];
1270
1271 return NULL;
1272 }
1273
1274 /* Set the howto pointer for an M32R ELF reloc. */
1275
1276 static void
1277 m32r_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1278 arelent *cache_ptr,
1279 Elf_Internal_Rela *dst)
1280 {
1281 unsigned int r_type;
1282
1283 r_type = ELF32_R_TYPE (dst->r_info);
1284 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) <= (unsigned int) R_M32R_GNU_VTENTRY);
1285 cache_ptr->howto = &m32r_elf_howto_table[r_type];
1286 }
1287
1288 static void
1289 m32r_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1290 arelent *cache_ptr,
1291 Elf_Internal_Rela *dst)
1292 {
1293 BFD_ASSERT ((ELF32_R_TYPE(dst->r_info) == (unsigned int) R_M32R_NONE)
1294 || ((ELF32_R_TYPE(dst->r_info) > (unsigned int) R_M32R_GNU_VTENTRY)
1295 && (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_M32R_max)));
1296 cache_ptr->howto = &m32r_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
1297 }
1298
1299 \f
1300 /* Given a BFD section, try to locate the corresponding ELF section
1301 index. */
1302
1303 static bfd_boolean
1304 _bfd_m32r_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
1305 asection *sec,
1306 int *retval)
1307 {
1308 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1309 {
1310 *retval = SHN_M32R_SCOMMON;
1311 return TRUE;
1312 }
1313 return FALSE;
1314 }
1315
1316 /* M32R ELF uses two common sections. One is the usual one, and the other
1317 is for small objects. All the small objects are kept together, and then
1318 referenced via one register, which yields faster assembler code. It is
1319 up to the compiler to emit an instruction to load the register with
1320 _SDA_BASE. This is what we use for the small common section. This
1321 approach is copied from elf32-mips.c. */
1322 static asection m32r_elf_scom_section;
1323 static asymbol m32r_elf_scom_symbol;
1324 static asymbol *m32r_elf_scom_symbol_ptr;
1325
1326 /* Handle the special M32R section numbers that a symbol may use. */
1327
1328 static void
1329 _bfd_m32r_elf_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
1330 {
1331 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
1332
1333 switch (elfsym->internal_elf_sym.st_shndx)
1334 {
1335 case SHN_M32R_SCOMMON:
1336 if (m32r_elf_scom_section.name == NULL)
1337 {
1338 /* Initialize the small common section. */
1339 m32r_elf_scom_section.name = ".scommon";
1340 m32r_elf_scom_section.flags = SEC_IS_COMMON;
1341 m32r_elf_scom_section.output_section = &m32r_elf_scom_section;
1342 m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol;
1343 m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr;
1344 m32r_elf_scom_symbol.name = ".scommon";
1345 m32r_elf_scom_symbol.flags = BSF_SECTION_SYM;
1346 m32r_elf_scom_symbol.section = &m32r_elf_scom_section;
1347 m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol;
1348 }
1349 asym->section = &m32r_elf_scom_section;
1350 asym->value = elfsym->internal_elf_sym.st_size;
1351 break;
1352 }
1353 }
1354
1355 /* Hook called by the linker routine which adds symbols from an object
1356 file. We must handle the special M32R section numbers here.
1357 We also keep watching for whether we need to create the sdata special
1358 linker sections. */
1359
1360 static bfd_boolean
1361 m32r_elf_add_symbol_hook (bfd *abfd,
1362 struct bfd_link_info *info,
1363 Elf_Internal_Sym *sym,
1364 const char **namep,
1365 flagword *flagsp ATTRIBUTE_UNUSED,
1366 asection **secp,
1367 bfd_vma *valp)
1368 {
1369 if (! info->relocatable
1370 && (*namep)[0] == '_' && (*namep)[1] == 'S'
1371 && strcmp (*namep, "_SDA_BASE_") == 0
1372 && is_elf_hash_table (info->hash))
1373 {
1374 /* This is simpler than using _bfd_elf_create_linker_section
1375 (our needs are simpler than ppc's needs). Also
1376 _bfd_elf_create_linker_section currently has a bug where if a .sdata
1377 section already exists a new one is created that follows it which
1378 screws of _SDA_BASE_ address calcs because output_offset != 0. */
1379 struct elf_link_hash_entry *h;
1380 struct bfd_link_hash_entry *bh;
1381 asection *s = bfd_get_section_by_name (abfd, ".sdata");
1382
1383 /* The following code was cobbled from elf32-ppc.c and elflink.c. */
1384 if (s == NULL)
1385 {
1386 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1387 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1388
1389 s = bfd_make_section_anyway_with_flags (abfd, ".sdata",
1390 flags);
1391 if (s == NULL)
1392 return FALSE;
1393 bfd_set_section_alignment (abfd, s, 2);
1394 }
1395
1396 bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_",
1397 FALSE, FALSE, FALSE);
1398
1399 if ((bh == NULL || bh->type == bfd_link_hash_undefined)
1400 && !(_bfd_generic_link_add_one_symbol (info,
1401 abfd,
1402 "_SDA_BASE_",
1403 BSF_GLOBAL,
1404 s,
1405 (bfd_vma) 32768,
1406 NULL,
1407 FALSE,
1408 get_elf_backend_data (abfd)->collect,
1409 &bh)))
1410 return FALSE;
1411 h = (struct elf_link_hash_entry *) bh;
1412 h->type = STT_OBJECT;
1413 }
1414
1415 switch (sym->st_shndx)
1416 {
1417 case SHN_M32R_SCOMMON:
1418 *secp = bfd_make_section_old_way (abfd, ".scommon");
1419 (*secp)->flags |= SEC_IS_COMMON;
1420 *valp = sym->st_size;
1421 break;
1422 }
1423
1424 return TRUE;
1425 }
1426
1427 /* We have to figure out the SDA_BASE value, so that we can adjust the
1428 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
1429 BFD. If we can't find it, we're stuck. We cache it in the ELF
1430 target data. We don't need to adjust the symbol value for an
1431 external symbol if we are producing relocatable output. */
1432
1433 static bfd_reloc_status_type
1434 m32r_elf_final_sda_base (bfd *output_bfd,
1435 struct bfd_link_info *info,
1436 const char **error_message,
1437 bfd_vma *psb)
1438 {
1439 if (elf_gp (output_bfd) == 0)
1440 {
1441 struct bfd_link_hash_entry *h;
1442
1443 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
1444 if (h != NULL && h->type == bfd_link_hash_defined)
1445 elf_gp (output_bfd) = (h->u.def.value
1446 + h->u.def.section->output_section->vma
1447 + h->u.def.section->output_offset);
1448 else
1449 {
1450 /* Only get the error once. */
1451 *psb = elf_gp (output_bfd) = 4;
1452 *error_message =
1453 (const char *) _("SDA relocation when _SDA_BASE_ not defined");
1454 return bfd_reloc_dangerous;
1455 }
1456 }
1457 *psb = elf_gp (output_bfd);
1458 return bfd_reloc_ok;
1459 }
1460 \f
1461 /* Return size of a PLT entry. */
1462 #define elf_m32r_sizeof_plt(info) PLT_ENTRY_SIZE
1463
1464 /* The m32r linker needs to keep track of the number of relocs that it
1465 decides to copy in check_relocs for each symbol. This is so that
1466 it can discard PC relative relocs if it doesn't need them when
1467 linking with -Bsymbolic. We store the information in a field
1468 extending the regular ELF linker hash table. */
1469
1470 /* This structure keeps track of the number of PC relative relocs we
1471 have copied for a given symbol. */
1472
1473 struct elf_m32r_pcrel_relocs_copied
1474 {
1475 /* Next section. */
1476 struct elf_m32r_pcrel_relocs_copied *next;
1477 /* A section in dynobj. */
1478 asection *section;
1479 /* Number of relocs copied in this section. */
1480 bfd_size_type count;
1481 };
1482
1483 /* The sh linker needs to keep track of the number of relocs that it
1484 decides to copy as dynamic relocs in check_relocs for each symbol.
1485 This is so that it can later discard them if they are found to be
1486 unnecessary. We store the information in a field extending the
1487 regular ELF linker hash table. */
1488
1489 struct elf_m32r_dyn_relocs
1490 {
1491 struct elf_m32r_dyn_relocs *next;
1492
1493 /* The input section of the reloc. */
1494 asection *sec;
1495
1496 /* Total number of relocs copied for the input section. */
1497 bfd_size_type count;
1498
1499 /* Number of pc-relative relocs copied for the input section. */
1500 bfd_size_type pc_count;
1501 };
1502
1503
1504 /* m32r ELF linker hash entry. */
1505
1506 struct elf_m32r_link_hash_entry
1507 {
1508 struct elf_link_hash_entry root;
1509
1510 /* Track dynamic relocs copied for this symbol. */
1511 struct elf_m32r_dyn_relocs *dyn_relocs;
1512 };
1513
1514 /* m32r ELF linker hash table. */
1515
1516 struct elf_m32r_link_hash_table
1517 {
1518 struct elf_link_hash_table root;
1519
1520 /* Short-cuts to get to dynamic linker sections. */
1521 asection *sgot;
1522 asection *sgotplt;
1523 asection *srelgot;
1524 asection *splt;
1525 asection *srelplt;
1526 asection *sdynbss;
1527 asection *srelbss;
1528
1529 /* Small local sym cache. */
1530 struct sym_cache sym_cache;
1531 };
1532
1533 /* Traverse an m32r ELF linker hash table. */
1534
1535 #define m32r_elf_link_hash_traverse(table, func, info) \
1536 (elf_link_hash_traverse \
1537 (&(table)->root, \
1538 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1539 (info)))
1540
1541 /* Get the m32r ELF linker hash table from a link_info structure. */
1542
1543 #define m32r_elf_hash_table(p) \
1544 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1545 == M32R_ELF_DATA ? ((struct elf_m32r_link_hash_table *) ((p)->hash)) : NULL)
1546
1547 /* Create an entry in an m32r ELF linker hash table. */
1548
1549 static struct bfd_hash_entry *
1550 m32r_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1551 struct bfd_hash_table *table,
1552 const char *string)
1553 {
1554 struct elf_m32r_link_hash_entry *ret =
1555 (struct elf_m32r_link_hash_entry *) entry;
1556
1557 /* Allocate the structure if it has not already been allocated by a
1558 subclass. */
1559 if (ret == NULL)
1560 ret = bfd_hash_allocate (table,
1561 sizeof (struct elf_m32r_link_hash_entry));
1562 if (ret == NULL)
1563 return NULL;
1564
1565 /* Call the allocation method of the superclass. */
1566 ret = ((struct elf_m32r_link_hash_entry *)
1567 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1568 table, string));
1569 if (ret != NULL)
1570 {
1571 struct elf_m32r_link_hash_entry *eh;
1572
1573 eh = (struct elf_m32r_link_hash_entry *) ret;
1574 eh->dyn_relocs = NULL;
1575 }
1576
1577 return (struct bfd_hash_entry *) ret;
1578 }
1579
1580 /* Create an m32r ELF linker hash table. */
1581
1582 static struct bfd_link_hash_table *
1583 m32r_elf_link_hash_table_create (bfd *abfd)
1584 {
1585 struct elf_m32r_link_hash_table *ret;
1586 bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
1587
1588 ret = bfd_malloc (amt);
1589 if (ret == NULL)
1590 return NULL;
1591
1592 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1593 m32r_elf_link_hash_newfunc,
1594 sizeof (struct elf_m32r_link_hash_entry),
1595 M32R_ELF_DATA))
1596 {
1597 free (ret);
1598 return NULL;
1599 }
1600
1601 ret->sgot = NULL;
1602 ret->sgotplt = NULL;
1603 ret->srelgot = NULL;
1604 ret->splt = NULL;
1605 ret->srelplt = NULL;
1606 ret->sdynbss = NULL;
1607 ret->srelbss = NULL;
1608 ret->sym_cache.abfd = NULL;
1609
1610 return &ret->root.root;
1611 }
1612
1613 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1614 shortcuts to them in our hash table. */
1615
1616 static bfd_boolean
1617 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1618 {
1619 struct elf_m32r_link_hash_table *htab;
1620
1621 if (! _bfd_elf_create_got_section (dynobj, info))
1622 return FALSE;
1623
1624 htab = m32r_elf_hash_table (info);
1625 if (htab == NULL)
1626 return FALSE;
1627
1628 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1629 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1630 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1631 if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
1632 abort ();
1633
1634 return TRUE;
1635 }
1636
1637 /* Create dynamic sections when linking against a dynamic object. */
1638
1639 static bfd_boolean
1640 m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1641 {
1642 struct elf_m32r_link_hash_table *htab;
1643 flagword flags, pltflags;
1644 asection *s;
1645 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1646 int ptralign = 2; /* 32bit */
1647
1648 htab = m32r_elf_hash_table (info);
1649 if (htab == NULL)
1650 return FALSE;
1651
1652 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1653 .rel[a].bss sections. */
1654 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1655 | SEC_LINKER_CREATED);
1656
1657 pltflags = flags;
1658 pltflags |= SEC_CODE;
1659 if (bed->plt_not_loaded)
1660 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1661 if (bed->plt_readonly)
1662 pltflags |= SEC_READONLY;
1663
1664 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
1665 htab->splt = s;
1666 if (s == NULL
1667 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1668 return FALSE;
1669
1670 if (bed->want_plt_sym)
1671 {
1672 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1673 .plt section. */
1674 struct bfd_link_hash_entry *bh = NULL;
1675 struct elf_link_hash_entry *h;
1676
1677 if (! (_bfd_generic_link_add_one_symbol
1678 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1679 (bfd_vma) 0, NULL, FALSE,
1680 get_elf_backend_data (abfd)->collect, &bh)))
1681 return FALSE;
1682 h = (struct elf_link_hash_entry *) bh;
1683 h->def_regular = 1;
1684 h->type = STT_OBJECT;
1685 htab->root.hplt = h;
1686
1687 if (info->shared
1688 && ! bfd_elf_link_record_dynamic_symbol (info, h))
1689 return FALSE;
1690 }
1691
1692 s = bfd_make_section_with_flags (abfd,
1693 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
1694 flags | SEC_READONLY);
1695 htab->srelplt = s;
1696 if (s == NULL
1697 || ! bfd_set_section_alignment (abfd, s, ptralign))
1698 return FALSE;
1699
1700 if (htab->sgot == NULL
1701 && ! create_got_section (abfd, info))
1702 return FALSE;
1703
1704 {
1705 const char *secname;
1706 char *relname;
1707 flagword secflags;
1708 asection *sec;
1709
1710 for (sec = abfd->sections; sec; sec = sec->next)
1711 {
1712 secflags = bfd_get_section_flags (abfd, sec);
1713 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
1714 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
1715 continue;
1716 secname = bfd_get_section_name (abfd, sec);
1717 relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
1718 strcpy (relname, ".rela");
1719 strcat (relname, secname);
1720 if (bfd_get_section_by_name (abfd, secname))
1721 continue;
1722 s = bfd_make_section_with_flags (abfd, relname,
1723 flags | SEC_READONLY);
1724 if (s == NULL
1725 || ! bfd_set_section_alignment (abfd, s, ptralign))
1726 return FALSE;
1727 }
1728 }
1729
1730 if (bed->want_dynbss)
1731 {
1732 /* The .dynbss section is a place to put symbols which are defined
1733 by dynamic objects, are referenced by regular objects, and are
1734 not functions. We must allocate space for them in the process
1735 image and use a R_*_COPY reloc to tell the dynamic linker to
1736 initialize them at run time. The linker script puts the .dynbss
1737 section into the .bss section of the final image. */
1738 s = bfd_make_section_with_flags (abfd, ".dynbss",
1739 SEC_ALLOC | SEC_LINKER_CREATED);
1740 htab->sdynbss = s;
1741 if (s == NULL)
1742 return FALSE;
1743 /* The .rel[a].bss section holds copy relocs. This section is not
1744 normally needed. We need to create it here, though, so that the
1745 linker will map it to an output section. We can't just create it
1746 only if we need it, because we will not know whether we need it
1747 until we have seen all the input files, and the first time the
1748 main linker code calls BFD after examining all the input files
1749 (size_dynamic_sections) the input sections have already been
1750 mapped to the output sections. If the section turns out not to
1751 be needed, we can discard it later. We will never need this
1752 section when generating a shared object, since they do not use
1753 copy relocs. */
1754 if (! info->shared)
1755 {
1756 s = bfd_make_section_with_flags (abfd,
1757 (bed->default_use_rela_p
1758 ? ".rela.bss" : ".rel.bss"),
1759 flags | SEC_READONLY);
1760 htab->srelbss = s;
1761 if (s == NULL
1762 || ! bfd_set_section_alignment (abfd, s, ptralign))
1763 return FALSE;
1764 }
1765 }
1766
1767 return TRUE;
1768 }
1769
1770 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1771
1772 static void
1773 m32r_elf_copy_indirect_symbol (struct bfd_link_info *info,
1774 struct elf_link_hash_entry *dir,
1775 struct elf_link_hash_entry *ind)
1776 {
1777 struct elf_m32r_link_hash_entry * edir;
1778 struct elf_m32r_link_hash_entry * eind;
1779
1780 edir = (struct elf_m32r_link_hash_entry *) dir;
1781 eind = (struct elf_m32r_link_hash_entry *) ind;
1782
1783 if (eind->dyn_relocs != NULL)
1784 {
1785 if (edir->dyn_relocs != NULL)
1786 {
1787 struct elf_m32r_dyn_relocs **pp;
1788 struct elf_m32r_dyn_relocs *p;
1789
1790 /* Add reloc counts against the indirect sym to the direct sym
1791 list. Merge any entries against the same section. */
1792 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
1793 {
1794 struct elf_m32r_dyn_relocs *q;
1795
1796 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1797 if (q->sec == p->sec)
1798 {
1799 q->pc_count += p->pc_count;
1800 q->count += p->count;
1801 *pp = p->next;
1802 break;
1803 }
1804 if (q == NULL)
1805 pp = &p->next;
1806 }
1807 *pp = edir->dyn_relocs;
1808 }
1809
1810 edir->dyn_relocs = eind->dyn_relocs;
1811 eind->dyn_relocs = NULL;
1812 }
1813
1814 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1815 }
1816
1817 \f
1818 /* Adjust a symbol defined by a dynamic object and referenced by a
1819 regular object. The current definition is in some section of the
1820 dynamic object, but we're not including those sections. We have to
1821 change the definition to something the rest of the link can
1822 understand. */
1823
1824 static bfd_boolean
1825 m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1826 struct elf_link_hash_entry *h)
1827 {
1828 struct elf_m32r_link_hash_table *htab;
1829 struct elf_m32r_link_hash_entry *eh;
1830 struct elf_m32r_dyn_relocs *p;
1831 bfd *dynobj;
1832 asection *s;
1833
1834 #ifdef DEBUG_PIC
1835 printf ("m32r_elf_adjust_dynamic_symbol()\n");
1836 #endif
1837
1838 dynobj = elf_hash_table (info)->dynobj;
1839
1840 /* Make sure we know what is going on here. */
1841 BFD_ASSERT (dynobj != NULL
1842 && (h->needs_plt
1843 || h->u.weakdef != NULL
1844 || (h->def_dynamic
1845 && h->ref_regular
1846 && !h->def_regular)));
1847
1848 /* If this is a function, put it in the procedure linkage table. We
1849 will fill in the contents of the procedure linkage table later,
1850 when we know the address of the .got section. */
1851 if (h->type == STT_FUNC
1852 || h->needs_plt)
1853 {
1854 if (! info->shared
1855 && !h->def_dynamic
1856 && !h->ref_dynamic
1857 && h->root.type != bfd_link_hash_undefweak
1858 && h->root.type != bfd_link_hash_undefined)
1859 {
1860 /* This case can occur if we saw a PLT reloc in an input
1861 file, but the symbol was never referred to by a dynamic
1862 object. In such a case, we don't actually need to build
1863 a procedure linkage table, and we can just do a PCREL
1864 reloc instead. */
1865 h->plt.offset = (bfd_vma) -1;
1866 h->needs_plt = 0;
1867 }
1868
1869 return TRUE;
1870 }
1871 else
1872 h->plt.offset = (bfd_vma) -1;
1873
1874 /* If this is a weak symbol, and there is a real definition, the
1875 processor independent code will have arranged for us to see the
1876 real definition first, and we can just use the same value. */
1877 if (h->u.weakdef != NULL)
1878 {
1879 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1880 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1881 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1882 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1883 return TRUE;
1884 }
1885
1886 /* This is a reference to a symbol defined by a dynamic object which
1887 is not a function. */
1888
1889 /* If we are creating a shared library, we must presume that the
1890 only references to the symbol are via the global offset table.
1891 For such cases we need not do anything here; the relocations will
1892 be handled correctly by relocate_section. */
1893 if (info->shared)
1894 return TRUE;
1895
1896 /* If there are no references to this symbol that do not use the
1897 GOT, we don't need to generate a copy reloc. */
1898 if (!h->non_got_ref)
1899 return TRUE;
1900
1901 /* If -z nocopyreloc was given, we won't generate them either. */
1902 if (info->nocopyreloc)
1903 {
1904 h->non_got_ref = 0;
1905 return TRUE;
1906 }
1907
1908 eh = (struct elf_m32r_link_hash_entry *) h;
1909 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1910 {
1911 s = p->sec->output_section;
1912 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1913 break;
1914 }
1915
1916 /* If we didn't find any dynamic relocs in sections which needs the
1917 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1918 the copy reloc. */
1919 if (p == NULL)
1920 {
1921 h->non_got_ref = 0;
1922 return TRUE;
1923 }
1924
1925 if (h->size == 0)
1926 {
1927 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1928 h->root.root.string);
1929 return TRUE;
1930 }
1931
1932 /* We must allocate the symbol in our .dynbss section, which will
1933 become part of the .bss section of the executable. There will be
1934 an entry for this symbol in the .dynsym section. The dynamic
1935 object will contain position independent code, so all references
1936 from the dynamic object to this symbol will go through the global
1937 offset table. The dynamic linker will use the .dynsym entry to
1938 determine the address it must put in the global offset table, so
1939 both the dynamic object and the regular object will refer to the
1940 same memory location for the variable. */
1941
1942 htab = m32r_elf_hash_table (info);
1943 if (htab == NULL)
1944 return FALSE;
1945
1946 s = htab->sdynbss;
1947 BFD_ASSERT (s != NULL);
1948
1949 /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
1950 to copy the initial value out of the dynamic object and into the
1951 runtime process image. We need to remember the offset into the
1952 .rela.bss section we are going to use. */
1953 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1954 {
1955 asection *srel;
1956
1957 srel = htab->srelbss;
1958 BFD_ASSERT (srel != NULL);
1959 srel->size += sizeof (Elf32_External_Rela);
1960 h->needs_copy = 1;
1961 }
1962
1963 return _bfd_elf_adjust_dynamic_copy (h, s);
1964 }
1965
1966 /* Allocate space in .plt, .got and associated reloc sections for
1967 dynamic relocs. */
1968
1969 static bfd_boolean
1970 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1971 {
1972 struct bfd_link_info *info;
1973 struct elf_m32r_link_hash_table *htab;
1974 struct elf_m32r_link_hash_entry *eh;
1975 struct elf_m32r_dyn_relocs *p;
1976
1977 if (h->root.type == bfd_link_hash_indirect)
1978 return TRUE;
1979
1980 info = (struct bfd_link_info *) inf;
1981 htab = m32r_elf_hash_table (info);
1982 if (htab == NULL)
1983 return FALSE;
1984
1985 eh = (struct elf_m32r_link_hash_entry *) h;
1986
1987 if (htab->root.dynamic_sections_created
1988 && h->plt.refcount > 0)
1989 {
1990 /* Make sure this symbol is output as a dynamic symbol.
1991 Undefined weak syms won't yet be marked as dynamic. */
1992 if (h->dynindx == -1
1993 && !h->forced_local)
1994 {
1995 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1996 return FALSE;
1997 }
1998
1999 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2000 {
2001 asection *s = htab->splt;
2002
2003 /* If this is the first .plt entry, make room for the special
2004 first entry. */
2005 if (s->size == 0)
2006 s->size += PLT_ENTRY_SIZE;
2007
2008 h->plt.offset = s->size;
2009
2010 /* If this symbol is not defined in a regular file, and we are
2011 not generating a shared library, then set the symbol to this
2012 location in the .plt. This is required to make function
2013 pointers compare as equal between the normal executable and
2014 the shared library. */
2015 if (! info->shared
2016 && !h->def_regular)
2017 {
2018 h->root.u.def.section = s;
2019 h->root.u.def.value = h->plt.offset;
2020 }
2021
2022 /* Make room for this entry. */
2023 s->size += PLT_ENTRY_SIZE;
2024
2025 /* We also need to make an entry in the .got.plt section, which
2026 will be placed in the .got section by the linker script. */
2027 htab->sgotplt->size += 4;
2028
2029 /* We also need to make an entry in the .rel.plt section. */
2030 htab->srelplt->size += sizeof (Elf32_External_Rela);
2031 }
2032 else
2033 {
2034 h->plt.offset = (bfd_vma) -1;
2035 h->needs_plt = 0;
2036 }
2037 }
2038 else
2039 {
2040 h->plt.offset = (bfd_vma) -1;
2041 h->needs_plt = 0;
2042 }
2043
2044 if (h->got.refcount > 0)
2045 {
2046 asection *s;
2047 bfd_boolean dyn;
2048
2049 /* Make sure this symbol is output as a dynamic symbol.
2050 Undefined weak syms won't yet be marked as dynamic. */
2051 if (h->dynindx == -1
2052 && !h->forced_local)
2053 {
2054 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2055 return FALSE;
2056 }
2057
2058 s = htab->sgot;
2059
2060 h->got.offset = s->size;
2061 s->size += 4;
2062 dyn = htab->root.dynamic_sections_created;
2063 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2064 htab->srelgot->size += sizeof (Elf32_External_Rela);
2065 }
2066 else
2067 h->got.offset = (bfd_vma) -1;
2068
2069 if (eh->dyn_relocs == NULL)
2070 return TRUE;
2071
2072 /* In the shared -Bsymbolic case, discard space allocated for
2073 dynamic pc-relative relocs against symbols which turn out to be
2074 defined in regular objects. For the normal shared case, discard
2075 space for pc-relative relocs that have become local due to symbol
2076 visibility changes. */
2077
2078 if (info->shared)
2079 {
2080 if (h->def_regular
2081 && (h->forced_local
2082 || info->symbolic))
2083 {
2084 struct elf_m32r_dyn_relocs **pp;
2085
2086 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2087 {
2088 p->count -= p->pc_count;
2089 p->pc_count = 0;
2090 if (p->count == 0)
2091 *pp = p->next;
2092 else
2093 pp = &p->next;
2094 }
2095 }
2096
2097 /* Also discard relocs on undefined weak syms with non-default
2098 visibility. */
2099 if (eh->dyn_relocs != NULL
2100 && h->root.type == bfd_link_hash_undefweak)
2101 {
2102 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2103 eh->dyn_relocs = NULL;
2104
2105 /* Make sure undefined weak symbols are output as a dynamic
2106 symbol in PIEs. */
2107 else if (h->dynindx == -1
2108 && !h->forced_local)
2109 {
2110 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2111 return FALSE;
2112 }
2113 }
2114 }
2115 else
2116 {
2117 /* For the non-shared case, discard space for relocs against
2118 symbols which turn out to need copy relocs or are not
2119 dynamic. */
2120
2121 if (!h->non_got_ref
2122 && ((h->def_dynamic
2123 && !h->def_regular)
2124 || (htab->root.dynamic_sections_created
2125 && (h->root.type == bfd_link_hash_undefweak
2126 || h->root.type == bfd_link_hash_undefined))))
2127 {
2128 /* Make sure this symbol is output as a dynamic symbol.
2129 Undefined weak syms won't yet be marked as dynamic. */
2130 if (h->dynindx == -1
2131 && !h->forced_local)
2132 {
2133 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2134 return FALSE;
2135 }
2136
2137 /* If that succeeded, we know we'll be keeping all the
2138 relocs. */
2139 if (h->dynindx != -1)
2140 goto keep;
2141 }
2142
2143 eh->dyn_relocs = NULL;
2144
2145 keep: ;
2146 }
2147
2148 /* Finally, allocate space. */
2149 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2150 {
2151 asection *sreloc = elf_section_data (p->sec)->sreloc;
2152 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2153 }
2154
2155 return TRUE;
2156 }
2157
2158 /* Find any dynamic relocs that apply to read-only sections. */
2159
2160 static bfd_boolean
2161 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2162 {
2163 struct elf_m32r_link_hash_entry *eh;
2164 struct elf_m32r_dyn_relocs *p;
2165
2166 eh = (struct elf_m32r_link_hash_entry *) h;
2167 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2168 {
2169 asection *s = p->sec->output_section;
2170
2171 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2172 {
2173 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2174
2175 info->flags |= DF_TEXTREL;
2176
2177 /* Not an error, just cut short the traversal. */
2178 return FALSE;
2179 }
2180 }
2181 return TRUE;
2182 }
2183
2184 /* Set the sizes of the dynamic sections. */
2185
2186 static bfd_boolean
2187 m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2188 struct bfd_link_info *info)
2189 {
2190 struct elf_m32r_link_hash_table *htab;
2191 bfd *dynobj;
2192 asection *s;
2193 bfd_boolean relocs;
2194 bfd *ibfd;
2195
2196 #ifdef DEBUG_PIC
2197 printf ("m32r_elf_size_dynamic_sections()\n");
2198 #endif
2199
2200 htab = m32r_elf_hash_table (info);
2201 if (htab == NULL)
2202 return FALSE;
2203
2204 dynobj = htab->root.dynobj;
2205 BFD_ASSERT (dynobj != NULL);
2206
2207 if (htab->root.dynamic_sections_created)
2208 {
2209 /* Set the contents of the .interp section to the interpreter. */
2210 if (info->executable)
2211 {
2212 s = bfd_get_section_by_name (dynobj, ".interp");
2213 BFD_ASSERT (s != NULL);
2214 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2215 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2216 }
2217 }
2218
2219 /* Set up .got offsets for local syms, and space for local dynamic
2220 relocs. */
2221 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2222 {
2223 bfd_signed_vma *local_got;
2224 bfd_signed_vma *end_local_got;
2225 bfd_size_type locsymcount;
2226 Elf_Internal_Shdr *symtab_hdr;
2227 asection *srel;
2228
2229 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2230 continue;
2231
2232 for (s = ibfd->sections; s != NULL; s = s->next)
2233 {
2234 struct elf_m32r_dyn_relocs *p;
2235
2236 for (p = ((struct elf_m32r_dyn_relocs *)
2237 elf_section_data (s)->local_dynrel);
2238 p != NULL;
2239 p = p->next)
2240 {
2241 if (! bfd_is_abs_section (p->sec)
2242 && bfd_is_abs_section (p->sec->output_section))
2243 {
2244 /* Input section has been discarded, either because
2245 it is a copy of a linkonce section or due to
2246 linker script /DISCARD/, so we'll be discarding
2247 the relocs too. */
2248 }
2249 else if (p->count != 0)
2250 {
2251 srel = elf_section_data (p->sec)->sreloc;
2252 srel->size += p->count * sizeof (Elf32_External_Rela);
2253 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2254 info->flags |= DF_TEXTREL;
2255 }
2256 }
2257 }
2258
2259 local_got = elf_local_got_refcounts (ibfd);
2260 if (!local_got)
2261 continue;
2262
2263 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2264 locsymcount = symtab_hdr->sh_info;
2265 end_local_got = local_got + locsymcount;
2266 s = htab->sgot;
2267 srel = htab->srelgot;
2268 for (; local_got < end_local_got; ++local_got)
2269 {
2270 if (*local_got > 0)
2271 {
2272 *local_got = s->size;
2273 s->size += 4;
2274 if (info->shared)
2275 srel->size += sizeof (Elf32_External_Rela);
2276 }
2277 else
2278 *local_got = (bfd_vma) -1;
2279 }
2280 }
2281
2282 /* Allocate global sym .plt and .got entries, and space for global
2283 sym dynamic relocs. */
2284 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2285
2286 /* We now have determined the sizes of the various dynamic sections.
2287 Allocate memory for them. */
2288 relocs = FALSE;
2289 for (s = dynobj->sections; s != NULL; s = s->next)
2290 {
2291 if ((s->flags & SEC_LINKER_CREATED) == 0)
2292 continue;
2293
2294 if (s == htab->splt
2295 || s == htab->sgot
2296 || s == htab->sgotplt
2297 || s == htab->sdynbss)
2298 {
2299 /* Strip this section if we don't need it; see the
2300 comment below. */
2301 }
2302 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2303 {
2304 if (s->size != 0 && s != htab->srelplt)
2305 relocs = TRUE;
2306
2307 /* We use the reloc_count field as a counter if we need
2308 to copy relocs into the output file. */
2309 s->reloc_count = 0;
2310 }
2311 else
2312 /* It's not one of our sections, so don't allocate space. */
2313 continue;
2314
2315 if (s->size == 0)
2316 {
2317 /* If we don't need this section, strip it from the
2318 output file. This is mostly to handle .rela.bss and
2319 .rela.plt. We must create both sections in
2320 create_dynamic_sections, because they must be created
2321 before the linker maps input sections to output
2322 sections. The linker does that before
2323 adjust_dynamic_symbol is called, and it is that
2324 function which decides whether anything needs to go
2325 into these sections. */
2326 s->flags |= SEC_EXCLUDE;
2327 continue;
2328 }
2329
2330 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2331 continue;
2332
2333 /* Allocate memory for the section contents. We use bfd_zalloc
2334 here in case unused entries are not reclaimed before the
2335 section's contents are written out. This should not happen,
2336 but this way if it does, we get a R_M32R_NONE reloc instead
2337 of garbage. */
2338 s->contents = bfd_zalloc (dynobj, s->size);
2339 if (s->contents == NULL)
2340 return FALSE;
2341 }
2342
2343 if (htab->root.dynamic_sections_created)
2344 {
2345 /* Add some entries to the .dynamic section. We fill in the
2346 values later, in m32r_elf_finish_dynamic_sections, but we
2347 must add the entries now so that we get the correct size for
2348 the .dynamic section. The DT_DEBUG entry is filled in by the
2349 dynamic linker and used by the debugger. */
2350 #define add_dynamic_entry(TAG, VAL) \
2351 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2352
2353 if (info->executable)
2354 {
2355 if (! add_dynamic_entry (DT_DEBUG, 0))
2356 return FALSE;
2357 }
2358
2359 if (htab->splt->size != 0)
2360 {
2361 if (! add_dynamic_entry (DT_PLTGOT, 0)
2362 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2363 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2364 || ! add_dynamic_entry (DT_JMPREL, 0))
2365 return FALSE;
2366 }
2367
2368 if (relocs)
2369 {
2370 if (! add_dynamic_entry (DT_RELA, 0)
2371 || ! add_dynamic_entry (DT_RELASZ, 0)
2372 || ! add_dynamic_entry (DT_RELAENT,
2373 sizeof (Elf32_External_Rela)))
2374 return FALSE;
2375
2376 /* If any dynamic relocs apply to a read-only section,
2377 then we need a DT_TEXTREL entry. */
2378 if ((info->flags & DF_TEXTREL) == 0)
2379 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2380 info);
2381
2382 if ((info->flags & DF_TEXTREL) != 0)
2383 {
2384 if (! add_dynamic_entry (DT_TEXTREL, 0))
2385 return FALSE;
2386 }
2387 }
2388 }
2389 #undef add_dynamic_entry
2390
2391 return TRUE;
2392 }
2393
2394 /* Relocate an M32R/D ELF section.
2395 There is some attempt to make this function usable for many architectures,
2396 both for RELA and REL type relocs, if only to serve as a learning tool.
2397
2398 The RELOCATE_SECTION function is called by the new ELF backend linker
2399 to handle the relocations for a section.
2400
2401 The relocs are always passed as Rela structures; if the section
2402 actually uses Rel structures, the r_addend field will always be
2403 zero.
2404
2405 This function is responsible for adjust the section contents as
2406 necessary, and (if using Rela relocs and generating a
2407 relocatable output file) adjusting the reloc addend as
2408 necessary.
2409
2410 This function does not have to worry about setting the reloc
2411 address or the reloc symbol index.
2412
2413 LOCAL_SYMS is a pointer to the swapped in local symbols.
2414
2415 LOCAL_SECTIONS is an array giving the section in the input file
2416 corresponding to the st_shndx field of each local symbol.
2417
2418 The global hash table entry for the global symbols can be found
2419 via elf_sym_hashes (input_bfd).
2420
2421 When generating relocatable output, this function must handle
2422 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2423 going to be the section symbol corresponding to the output
2424 section, which means that the addend must be adjusted
2425 accordingly. */
2426
2427 static bfd_boolean
2428 m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
2429 struct bfd_link_info *info,
2430 bfd *input_bfd,
2431 asection *input_section,
2432 bfd_byte *contents,
2433 Elf_Internal_Rela *relocs,
2434 Elf_Internal_Sym *local_syms,
2435 asection **local_sections)
2436 {
2437 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2438 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2439 Elf_Internal_Rela *rel, *relend;
2440 /* Assume success. */
2441 bfd_boolean ret = TRUE;
2442 struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2443 bfd *dynobj;
2444 bfd_vma *local_got_offsets;
2445 asection *sgot, *splt, *sreloc;
2446 bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2447
2448 if (htab == NULL)
2449 return FALSE;
2450
2451 dynobj = htab->root.dynobj;
2452 local_got_offsets = elf_local_got_offsets (input_bfd);
2453
2454 sgot = htab->sgot;
2455 splt = htab->splt;
2456 sreloc = NULL;
2457
2458 rel = relocs;
2459 relend = relocs + input_section->reloc_count;
2460 for (; rel < relend; rel++)
2461 {
2462 int r_type;
2463 reloc_howto_type *howto;
2464 unsigned long r_symndx;
2465 struct elf_link_hash_entry *h;
2466 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
2467 ensure it's zero (we use REL relocs, not RELA). Therefore this
2468 should be assigning zero to `addend', but for clarity we use
2469 `r_addend'. */
2470 bfd_vma addend = rel->r_addend;
2471 bfd_vma offset = rel->r_offset;
2472 bfd_vma relocation;
2473 Elf_Internal_Sym *sym;
2474 asection *sec;
2475 const char *sym_name;
2476 bfd_reloc_status_type r;
2477 const char *errmsg = NULL;
2478 bfd_boolean use_rel = FALSE;
2479
2480 h = NULL;
2481 r_type = ELF32_R_TYPE (rel->r_info);
2482 if (r_type < 0 || r_type >= (int) R_M32R_max)
2483 {
2484 (*_bfd_error_handler) (_("%B: unknown relocation type %d"),
2485 input_bfd,
2486 (int) r_type);
2487 bfd_set_error (bfd_error_bad_value);
2488 ret = FALSE;
2489 continue;
2490 }
2491
2492 if ( r_type == R_M32R_GNU_VTENTRY
2493 || r_type == R_M32R_GNU_VTINHERIT
2494 || r_type == R_M32R_NONE
2495 || r_type == R_M32R_RELA_GNU_VTENTRY
2496 || r_type == R_M32R_RELA_GNU_VTINHERIT)
2497 continue;
2498
2499 if (r_type <= R_M32R_GNU_VTENTRY)
2500 use_rel = TRUE;
2501
2502 howto = m32r_elf_howto_table + r_type;
2503 r_symndx = ELF32_R_SYM (rel->r_info);
2504
2505 sym = NULL;
2506 sec = NULL;
2507 h = NULL;
2508
2509 if (r_symndx < symtab_hdr->sh_info)
2510 {
2511 /* Local symbol. */
2512 sym = local_syms + r_symndx;
2513 sec = local_sections[r_symndx];
2514 sym_name = "<local symbol>";
2515
2516 if (!use_rel)
2517 {
2518 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2519 addend = rel->r_addend;
2520 }
2521 else
2522 {
2523 relocation = (sec->output_section->vma
2524 + sec->output_offset
2525 + sym->st_value);
2526 }
2527 }
2528 else
2529 {
2530 /* External symbol. */
2531 relocation = 0;
2532
2533 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2534 while (h->root.type == bfd_link_hash_indirect
2535 || h->root.type == bfd_link_hash_warning)
2536 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2537 sym_name = h->root.root.string;
2538
2539 if (h->root.type == bfd_link_hash_defined
2540 || h->root.type == bfd_link_hash_defweak)
2541 {
2542 bfd_boolean dyn;
2543 sec = h->root.u.def.section;
2544
2545 dyn = htab->root.dynamic_sections_created;
2546 sec = h->root.u.def.section;
2547 if (r_type == R_M32R_GOTPC24
2548 || (r_type == R_M32R_GOTPC_HI_ULO
2549 || r_type == R_M32R_GOTPC_HI_SLO
2550 || r_type == R_M32R_GOTPC_LO)
2551 || (r_type == R_M32R_26_PLTREL
2552 && h->plt.offset != (bfd_vma) -1)
2553 || ((r_type == R_M32R_GOT24
2554 || r_type == R_M32R_GOT16_HI_ULO
2555 || r_type == R_M32R_GOT16_HI_SLO
2556 || r_type == R_M32R_GOT16_LO)
2557 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2558 info->shared, h)
2559 && (! info->shared
2560 || (! info->symbolic && h->dynindx != -1)
2561 || !h->def_regular))
2562 || (info->shared
2563 && ((! info->symbolic && h->dynindx != -1)
2564 || !h->def_regular)
2565 && (((r_type == R_M32R_16_RELA
2566 || r_type == R_M32R_32_RELA
2567 || r_type == R_M32R_24_RELA
2568 || r_type == R_M32R_HI16_ULO_RELA
2569 || r_type == R_M32R_HI16_SLO_RELA
2570 || r_type == R_M32R_LO16_RELA)
2571 && !h->forced_local)
2572 || r_type == R_M32R_REL32
2573 || r_type == R_M32R_10_PCREL_RELA
2574 || r_type == R_M32R_18_PCREL_RELA
2575 || r_type == R_M32R_26_PCREL_RELA)
2576 && ((input_section->flags & SEC_ALLOC) != 0
2577 /* DWARF will emit R_M32R_16(24,32) relocations
2578 in its sections against symbols defined
2579 externally in shared libraries. We can't do
2580 anything with them here. */
2581 || ((input_section->flags & SEC_DEBUGGING) != 0
2582 && h->def_dynamic))))
2583 {
2584 /* In these cases, we don't need the relocation
2585 value. We check specially because in some
2586 obscure cases sec->output_section will be NULL. */
2587 }
2588 else if (sec->output_section != NULL)
2589 relocation = (h->root.u.def.value
2590 + sec->output_section->vma
2591 + sec->output_offset);
2592 else if (!info->relocatable
2593 && (_bfd_elf_section_offset (output_bfd, info,
2594 input_section,
2595 rel->r_offset)
2596 != (bfd_vma) -1))
2597 {
2598 (*_bfd_error_handler)
2599 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2600 input_bfd,
2601 input_section,
2602 (long) rel->r_offset,
2603 howto->name,
2604 h->root.root.string);
2605 }
2606 }
2607 else if (h->root.type == bfd_link_hash_undefweak)
2608 ;
2609 else if (info->unresolved_syms_in_objects == RM_IGNORE
2610 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2611 ;
2612 else if (!info->relocatable)
2613 {
2614 if (! ((*info->callbacks->undefined_symbol)
2615 (info, h->root.root.string, input_bfd,
2616 input_section, offset,
2617 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2618 || ELF_ST_VISIBILITY (h->other)))))
2619 return FALSE;
2620 }
2621 }
2622
2623 if (sec != NULL && elf_discarded_section (sec))
2624 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2625 rel, relend, howto, contents);
2626
2627 if (info->relocatable && !use_rel)
2628 {
2629 /* This is a relocatable link. We don't have to change
2630 anything, unless the reloc is against a section symbol,
2631 in which case we have to adjust according to where the
2632 section symbol winds up in the output section. */
2633 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2634 rel->r_addend += sec->output_offset;
2635 continue;
2636 }
2637
2638 if (info->relocatable && use_rel)
2639 {
2640 /* This is a relocatable link. We don't have to change
2641 anything, unless the reloc is against a section symbol,
2642 in which case we have to adjust according to where the
2643 section symbol winds up in the output section. */
2644 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2645 continue;
2646
2647 addend += sec->output_offset;
2648
2649 /* If partial_inplace, we need to store any additional addend
2650 back in the section. */
2651 if (! howto->partial_inplace)
2652 continue;
2653 /* ??? Here is a nice place to call a special_function
2654 like handler. */
2655 if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2656 r = _bfd_relocate_contents (howto, input_bfd,
2657 addend, contents + offset);
2658 else
2659 {
2660 Elf_Internal_Rela *lorel;
2661
2662 /* We allow an arbitrary number of HI16 relocs before the
2663 LO16 reloc. This permits gcc to emit the HI and LO relocs
2664 itself. */
2665 for (lorel = rel + 1;
2666 (lorel < relend
2667 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2668 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2669 lorel++)
2670 continue;
2671 if (lorel < relend
2672 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2673 {
2674 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2675 contents, addend);
2676 r = bfd_reloc_ok;
2677 }
2678 else
2679 r = _bfd_relocate_contents (howto, input_bfd,
2680 addend, contents + offset);
2681 }
2682 }
2683 else
2684 {
2685 /* Sanity check the address. */
2686 if (offset > high_address)
2687 {
2688 r = bfd_reloc_outofrange;
2689 goto check_reloc;
2690 }
2691
2692 switch ((int) r_type)
2693 {
2694 case R_M32R_GOTOFF:
2695 /* Relocation is relative to the start of the global offset
2696 table (for ld24 rx, #uimm24). eg access at label+addend
2697
2698 ld24 rx. #label@GOTOFF + addend
2699 sub rx, r12. */
2700
2701 BFD_ASSERT (sgot != NULL);
2702
2703 relocation = -(relocation - sgot->output_section->vma);
2704 rel->r_addend = -rel->r_addend;
2705 break;
2706
2707 case R_M32R_GOTOFF_HI_ULO:
2708 case R_M32R_GOTOFF_HI_SLO:
2709 case R_M32R_GOTOFF_LO:
2710 BFD_ASSERT (sgot != NULL);
2711
2712 relocation -= sgot->output_section->vma;
2713
2714 if ((r_type == R_M32R_GOTOFF_HI_SLO)
2715 && ((relocation + rel->r_addend) & 0x8000))
2716 rel->r_addend += 0x10000;
2717 break;
2718
2719 case R_M32R_GOTPC24:
2720 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2721 ld24 rx,#_GLOBAL_OFFSET_TABLE_
2722 */
2723 relocation = sgot->output_section->vma;
2724 break;
2725
2726 case R_M32R_GOTPC_HI_ULO:
2727 case R_M32R_GOTPC_HI_SLO:
2728 case R_M32R_GOTPC_LO:
2729 {
2730 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2731 bl .+4
2732 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2733 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2734 or
2735 bl .+4
2736 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2737 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2738 */
2739 relocation = sgot->output_section->vma;
2740 relocation -= (input_section->output_section->vma
2741 + input_section->output_offset
2742 + rel->r_offset);
2743 if ((r_type == R_M32R_GOTPC_HI_SLO)
2744 && ((relocation + rel->r_addend) & 0x8000))
2745 rel->r_addend += 0x10000;
2746
2747 break;
2748 }
2749 case R_M32R_GOT16_HI_ULO:
2750 case R_M32R_GOT16_HI_SLO:
2751 case R_M32R_GOT16_LO:
2752 /* Fall through. */
2753 case R_M32R_GOT24:
2754 /* Relocation is to the entry for this symbol in the global
2755 offset table. */
2756 BFD_ASSERT (sgot != NULL);
2757
2758 if (h != NULL)
2759 {
2760 bfd_boolean dyn;
2761 bfd_vma off;
2762
2763 off = h->got.offset;
2764 BFD_ASSERT (off != (bfd_vma) -1);
2765
2766 dyn = htab->root.dynamic_sections_created;
2767 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2768 || (info->shared
2769 && (info->symbolic
2770 || h->dynindx == -1
2771 || h->forced_local)
2772 && h->def_regular))
2773 {
2774 /* This is actually a static link, or it is a
2775 -Bsymbolic link and the symbol is defined
2776 locally, or the symbol was forced to be local
2777 because of a version file. We must initialize
2778 this entry in the global offset table. Since the
2779 offset must always be a multiple of 4, we use the
2780 least significant bit to record whether we have
2781 initialized it already.
2782
2783 When doing a dynamic link, we create a .rela.got
2784 relocation entry to initialize the value. This
2785 is done in the finish_dynamic_symbol routine. */
2786 if ((off & 1) != 0)
2787 off &= ~1;
2788 else
2789 {
2790 bfd_put_32 (output_bfd, relocation,
2791 sgot->contents + off);
2792 h->got.offset |= 1;
2793 }
2794 }
2795
2796 relocation = sgot->output_offset + off;
2797 }
2798 else
2799 {
2800 bfd_vma off;
2801 bfd_byte *loc;
2802
2803 BFD_ASSERT (local_got_offsets != NULL
2804 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2805
2806 off = local_got_offsets[r_symndx];
2807
2808 /* The offset must always be a multiple of 4. We use
2809 the least significant bit to record whether we have
2810 already processed this entry. */
2811 if ((off & 1) != 0)
2812 off &= ~1;
2813 else
2814 {
2815 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2816
2817 if (info->shared)
2818 {
2819 asection *srelgot;
2820 Elf_Internal_Rela outrel;
2821
2822 /* We need to generate a R_M32R_RELATIVE reloc
2823 for the dynamic linker. */
2824 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2825 BFD_ASSERT (srelgot != NULL);
2826
2827 outrel.r_offset = (sgot->output_section->vma
2828 + sgot->output_offset
2829 + off);
2830 outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2831 outrel.r_addend = relocation;
2832 loc = srelgot->contents;
2833 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
2834 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2835 ++srelgot->reloc_count;
2836 }
2837
2838 local_got_offsets[r_symndx] |= 1;
2839 }
2840
2841 relocation = sgot->output_offset + off;
2842 }
2843 if ((r_type == R_M32R_GOT16_HI_SLO)
2844 && ((relocation + rel->r_addend) & 0x8000))
2845 rel->r_addend += 0x10000;
2846
2847 break;
2848
2849 case R_M32R_26_PLTREL:
2850 /* Relocation is to the entry for this symbol in the
2851 procedure linkage table. */
2852
2853 /* The native assembler will generate a 26_PLTREL reloc
2854 for a local symbol if you assemble a call from one
2855 section to another when using -K pic. */
2856 if (h == NULL)
2857 break;
2858
2859 if (h->forced_local)
2860 break;
2861
2862 if (h->plt.offset == (bfd_vma) -1)
2863 /* We didn't make a PLT entry for this symbol. This
2864 happens when statically linking PIC code, or when
2865 using -Bsymbolic. */
2866 break;
2867
2868 relocation = (splt->output_section->vma
2869 + splt->output_offset
2870 + h->plt.offset);
2871 break;
2872
2873 case R_M32R_HI16_SLO_RELA:
2874 if ((relocation + rel->r_addend) & 0x8000)
2875 rel->r_addend += 0x10000;
2876 /* Fall through. */
2877
2878 case R_M32R_16_RELA:
2879 case R_M32R_24_RELA:
2880 case R_M32R_32_RELA:
2881 case R_M32R_REL32:
2882 case R_M32R_10_PCREL_RELA:
2883 case R_M32R_18_PCREL_RELA:
2884 case R_M32R_26_PCREL_RELA:
2885 case R_M32R_HI16_ULO_RELA:
2886 case R_M32R_LO16_RELA:
2887 if (info->shared
2888 && r_symndx != STN_UNDEF
2889 && (input_section->flags & SEC_ALLOC) != 0
2890 && (( r_type != R_M32R_10_PCREL_RELA
2891 && r_type != R_M32R_18_PCREL_RELA
2892 && r_type != R_M32R_26_PCREL_RELA
2893 && r_type != R_M32R_REL32)
2894 || (h != NULL
2895 && h->dynindx != -1
2896 && (! info->symbolic
2897 || !h->def_regular))))
2898 {
2899 Elf_Internal_Rela outrel;
2900 bfd_boolean skip, relocate;
2901 bfd_byte *loc;
2902
2903 /* When generating a shared object, these relocations
2904 are copied into the output file to be resolved at run
2905 time. */
2906 if (sreloc == NULL)
2907 {
2908 sreloc = _bfd_elf_get_dynamic_reloc_section
2909 (input_bfd, input_section, /*rela?*/ TRUE);
2910 if (sreloc == NULL)
2911 return FALSE;
2912 }
2913
2914 skip = FALSE;
2915 relocate = FALSE;
2916
2917 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2918 info,
2919 input_section,
2920 rel->r_offset);
2921 if (outrel.r_offset == (bfd_vma) -1)
2922 skip = TRUE;
2923 else if (outrel.r_offset == (bfd_vma) -2)
2924 skip = relocate = TRUE;
2925 outrel.r_offset += (input_section->output_section->vma
2926 + input_section->output_offset);
2927
2928 if (skip)
2929 memset (&outrel, 0, sizeof outrel);
2930 else if ( r_type == R_M32R_10_PCREL_RELA
2931 || r_type == R_M32R_18_PCREL_RELA
2932 || r_type == R_M32R_26_PCREL_RELA
2933 || r_type == R_M32R_REL32)
2934 {
2935 BFD_ASSERT (h != NULL && h->dynindx != -1);
2936 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2937 outrel.r_addend = rel->r_addend;
2938 }
2939 else
2940 {
2941 /* h->dynindx may be -1 if this symbol was marked to
2942 become local. */
2943 if (h == NULL
2944 || ((info->symbolic || h->dynindx == -1)
2945 && h->def_regular))
2946 {
2947 relocate = TRUE;
2948 outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2949 outrel.r_addend = relocation + rel->r_addend;
2950 }
2951 else
2952 {
2953 BFD_ASSERT (h->dynindx != -1);
2954 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2955 outrel.r_addend = relocation + rel->r_addend;
2956 }
2957 }
2958
2959 loc = sreloc->contents;
2960 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
2961 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2962 ++sreloc->reloc_count;
2963
2964 /* If this reloc is against an external symbol, we do
2965 not want to fiddle with the addend. Otherwise, we
2966 need to include the symbol value so that it becomes
2967 an addend for the dynamic reloc. */
2968 if (! relocate)
2969 continue;
2970 break;
2971 }
2972 else if (r_type != R_M32R_10_PCREL_RELA)
2973 break;
2974 /* Fall through. */
2975
2976 case (int) R_M32R_10_PCREL :
2977 r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
2978 contents, offset,
2979 sec, relocation, addend);
2980 goto check_reloc;
2981
2982 case (int) R_M32R_HI16_SLO :
2983 case (int) R_M32R_HI16_ULO :
2984 {
2985 Elf_Internal_Rela *lorel;
2986
2987 /* We allow an arbitrary number of HI16 relocs before the
2988 LO16 reloc. This permits gcc to emit the HI and LO relocs
2989 itself. */
2990 for (lorel = rel + 1;
2991 (lorel < relend
2992 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2993 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2994 lorel++)
2995 continue;
2996 if (lorel < relend
2997 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2998 {
2999 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
3000 contents, relocation + addend);
3001 r = bfd_reloc_ok;
3002 }
3003 else
3004 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3005 contents, offset,
3006 relocation, addend);
3007 }
3008
3009 goto check_reloc;
3010
3011 case (int) R_M32R_SDA16_RELA:
3012 case (int) R_M32R_SDA16 :
3013 {
3014 const char *name;
3015
3016 BFD_ASSERT (sec != NULL);
3017 name = bfd_get_section_name (abfd, sec);
3018
3019 if ( strcmp (name, ".sdata") == 0
3020 || strcmp (name, ".sbss") == 0
3021 || strcmp (name, ".scommon") == 0)
3022 {
3023 bfd_vma sda_base;
3024 bfd *out_bfd = sec->output_section->owner;
3025
3026 r = m32r_elf_final_sda_base (out_bfd, info,
3027 &errmsg,
3028 &sda_base);
3029 if (r != bfd_reloc_ok)
3030 {
3031 ret = FALSE;
3032 goto check_reloc;
3033 }
3034
3035 /* At this point `relocation' contains the object's
3036 address. */
3037 relocation -= sda_base;
3038 /* Now it contains the offset from _SDA_BASE_. */
3039 }
3040 else
3041 {
3042 (*_bfd_error_handler)
3043 (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3044 input_bfd,
3045 sec,
3046 sym_name,
3047 m32r_elf_howto_table[(int) r_type].name);
3048 /*bfd_set_error (bfd_error_bad_value); ??? why? */
3049 ret = FALSE;
3050 continue;
3051 }
3052 }
3053 /* Fall through. */
3054
3055 default : /* OLD_M32R_RELOC */
3056
3057 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3058 contents, offset,
3059 relocation, addend);
3060 goto check_reloc;
3061 }
3062
3063 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3064 contents, rel->r_offset,
3065 relocation, rel->r_addend);
3066
3067 }
3068
3069 check_reloc:
3070
3071 if (r != bfd_reloc_ok)
3072 {
3073 /* FIXME: This should be generic enough to go in a utility. */
3074 const char *name;
3075
3076 if (h != NULL)
3077 name = h->root.root.string;
3078 else
3079 {
3080 name = (bfd_elf_string_from_elf_section
3081 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3082 if (name == NULL || *name == '\0')
3083 name = bfd_section_name (input_bfd, sec);
3084 }
3085
3086 if (errmsg != NULL)
3087 goto common_error;
3088
3089 switch (r)
3090 {
3091 case bfd_reloc_overflow:
3092 if (! ((*info->callbacks->reloc_overflow)
3093 (info, (h ? &h->root : NULL), name, howto->name,
3094 (bfd_vma) 0, input_bfd, input_section, offset)))
3095 return FALSE;
3096 break;
3097
3098 case bfd_reloc_undefined:
3099 if (! ((*info->callbacks->undefined_symbol)
3100 (info, name, input_bfd, input_section,
3101 offset, TRUE)))
3102 return FALSE;
3103 break;
3104
3105 case bfd_reloc_outofrange:
3106 errmsg = _("internal error: out of range error");
3107 goto common_error;
3108
3109 case bfd_reloc_notsupported:
3110 errmsg = _("internal error: unsupported relocation error");
3111 goto common_error;
3112
3113 case bfd_reloc_dangerous:
3114 errmsg = _("internal error: dangerous error");
3115 goto common_error;
3116
3117 default:
3118 errmsg = _("internal error: unknown error");
3119 /* fall through */
3120
3121 common_error:
3122 if (!((*info->callbacks->warning)
3123 (info, errmsg, name, input_bfd, input_section,
3124 offset)))
3125 return FALSE;
3126 break;
3127 }
3128 }
3129 }
3130
3131 return ret;
3132 }
3133
3134 /* Finish up dynamic symbol handling. We set the contents of various
3135 dynamic sections here. */
3136
3137 static bfd_boolean
3138 m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3139 struct bfd_link_info *info,
3140 struct elf_link_hash_entry *h,
3141 Elf_Internal_Sym *sym)
3142 {
3143 struct elf_m32r_link_hash_table *htab;
3144 bfd_byte *loc;
3145
3146 #ifdef DEBUG_PIC
3147 printf ("m32r_elf_finish_dynamic_symbol()\n");
3148 #endif
3149
3150 htab = m32r_elf_hash_table (info);
3151 if (htab == NULL)
3152 return FALSE;
3153
3154 if (h->plt.offset != (bfd_vma) -1)
3155 {
3156 asection *splt;
3157 asection *sgot;
3158 asection *srela;
3159
3160 bfd_vma plt_index;
3161 bfd_vma got_offset;
3162 Elf_Internal_Rela rela;
3163
3164 /* This symbol has an entry in the procedure linkage table. Set
3165 it up. */
3166
3167 BFD_ASSERT (h->dynindx != -1);
3168
3169 splt = htab->splt;
3170 sgot = htab->sgotplt;
3171 srela = htab->srelplt;
3172 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3173
3174 /* Get the index in the procedure linkage table which
3175 corresponds to this symbol. This is the index of this symbol
3176 in all the symbols for which we are making plt entries. The
3177 first entry in the procedure linkage table is reserved. */
3178 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3179
3180 /* Get the offset into the .got table of the entry that
3181 corresponds to this function. Each .got entry is 4 bytes.
3182 The first three are reserved. */
3183 got_offset = (plt_index + 3) * 4;
3184
3185 /* Fill in the entry in the procedure linkage table. */
3186 if (! info->shared)
3187 {
3188 bfd_put_32 (output_bfd,
3189 (PLT_ENTRY_WORD0b
3190 + (((sgot->output_section->vma
3191 + sgot->output_offset
3192 + got_offset) >> 16) & 0xffff)),
3193 splt->contents + h->plt.offset);
3194 bfd_put_32 (output_bfd,
3195 (PLT_ENTRY_WORD1b
3196 + ((sgot->output_section->vma
3197 + sgot->output_offset
3198 + got_offset) & 0xffff)),
3199 splt->contents + h->plt.offset + 4);
3200 bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3201 splt->contents + h->plt.offset + 8);
3202 bfd_put_32 (output_bfd,
3203 (PLT_ENTRY_WORD3
3204 + plt_index * sizeof (Elf32_External_Rela)),
3205 splt->contents + h->plt.offset + 12);
3206 bfd_put_32 (output_bfd,
3207 (PLT_ENTRY_WORD4
3208 + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3209 splt->contents + h->plt.offset + 16);
3210 }
3211 else
3212 {
3213 bfd_put_32 (output_bfd,
3214 PLT_ENTRY_WORD0 + got_offset,
3215 splt->contents + h->plt.offset);
3216 bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3217 splt->contents + h->plt.offset + 4);
3218 bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3219 splt->contents + h->plt.offset + 8);
3220 bfd_put_32 (output_bfd,
3221 (PLT_ENTRY_WORD3
3222 + plt_index * sizeof (Elf32_External_Rela)),
3223 splt->contents + h->plt.offset + 12);
3224 bfd_put_32 (output_bfd,
3225 (PLT_ENTRY_WORD4
3226 + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3227 splt->contents + h->plt.offset + 16);
3228 }
3229
3230 /* Fill in the entry in the global offset table. */
3231 bfd_put_32 (output_bfd,
3232 (splt->output_section->vma
3233 + splt->output_offset
3234 + h->plt.offset
3235 + 12), /* same offset */
3236 sgot->contents + got_offset);
3237
3238 /* Fill in the entry in the .rela.plt section. */
3239 rela.r_offset = (sgot->output_section->vma
3240 + sgot->output_offset
3241 + got_offset);
3242 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3243 rela.r_addend = 0;
3244 loc = srela->contents;
3245 loc += plt_index * sizeof (Elf32_External_Rela);
3246 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3247
3248 if (!h->def_regular)
3249 {
3250 /* Mark the symbol as undefined, rather than as defined in
3251 the .plt section. Leave the value alone. */
3252 sym->st_shndx = SHN_UNDEF;
3253 }
3254 }
3255
3256 if (h->got.offset != (bfd_vma) -1)
3257 {
3258 asection *sgot;
3259 asection *srela;
3260 Elf_Internal_Rela rela;
3261
3262 /* This symbol has an entry in the global offset table. Set it
3263 up. */
3264
3265 sgot = htab->sgot;
3266 srela = htab->srelgot;
3267 BFD_ASSERT (sgot != NULL && srela != NULL);
3268
3269 rela.r_offset = (sgot->output_section->vma
3270 + sgot->output_offset
3271 + (h->got.offset &~ 1));
3272
3273 /* If this is a -Bsymbolic link, and the symbol is defined
3274 locally, we just want to emit a RELATIVE reloc. Likewise if
3275 the symbol was forced to be local because of a version file.
3276 The entry in the global offset table will already have been
3277 initialized in the relocate_section function. */
3278 if (info->shared
3279 && (info->symbolic
3280 || h->dynindx == -1
3281 || h->forced_local)
3282 && h->def_regular)
3283 {
3284 rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3285 rela.r_addend = (h->root.u.def.value
3286 + h->root.u.def.section->output_section->vma
3287 + h->root.u.def.section->output_offset);
3288 }
3289 else
3290 {
3291 BFD_ASSERT ((h->got.offset & 1) == 0);
3292 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3293 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3294 rela.r_addend = 0;
3295 }
3296
3297 loc = srela->contents;
3298 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3299 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3300 ++srela->reloc_count;
3301 }
3302
3303 if (h->needs_copy)
3304 {
3305 asection *s;
3306 Elf_Internal_Rela rela;
3307
3308 /* This symbols needs a copy reloc. Set it up. */
3309
3310 BFD_ASSERT (h->dynindx != -1
3311 && (h->root.type == bfd_link_hash_defined
3312 || h->root.type == bfd_link_hash_defweak));
3313
3314 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3315 ".rela.bss");
3316 BFD_ASSERT (s != NULL);
3317
3318 rela.r_offset = (h->root.u.def.value
3319 + h->root.u.def.section->output_section->vma
3320 + h->root.u.def.section->output_offset);
3321 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3322 rela.r_addend = 0;
3323 loc = s->contents;
3324 loc += s->reloc_count * sizeof (Elf32_External_Rela);
3325 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3326 ++s->reloc_count;
3327 }
3328
3329 /* Mark some specially defined symbols as absolute. */
3330 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3331 || h == htab->root.hgot)
3332 sym->st_shndx = SHN_ABS;
3333
3334 return TRUE;
3335 }
3336
3337
3338 /* Finish up the dynamic sections. */
3339
3340 static bfd_boolean
3341 m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3342 struct bfd_link_info *info)
3343 {
3344 struct elf_m32r_link_hash_table *htab;
3345 bfd *dynobj;
3346 asection *sdyn;
3347 asection *sgot;
3348
3349 #ifdef DEBUG_PIC
3350 printf ("m32r_elf_finish_dynamic_sections()\n");
3351 #endif
3352
3353 htab = m32r_elf_hash_table (info);
3354 if (htab == NULL)
3355 return FALSE;
3356
3357 dynobj = htab->root.dynobj;
3358
3359 sgot = htab->sgotplt;
3360 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3361
3362 if (htab->root.dynamic_sections_created)
3363 {
3364 asection *splt;
3365 Elf32_External_Dyn *dyncon, *dynconend;
3366
3367 BFD_ASSERT (sgot != NULL && sdyn != NULL);
3368
3369 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3370 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3371
3372 for (; dyncon < dynconend; dyncon++)
3373 {
3374 Elf_Internal_Dyn dyn;
3375 asection *s;
3376
3377 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3378
3379 switch (dyn.d_tag)
3380 {
3381 default:
3382 break;
3383
3384 case DT_PLTGOT:
3385 s = htab->sgot->output_section;
3386 goto get_vma;
3387 case DT_JMPREL:
3388 s = htab->srelplt->output_section;
3389 get_vma:
3390 BFD_ASSERT (s != NULL);
3391 dyn.d_un.d_ptr = s->vma;
3392 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3393 break;
3394
3395 case DT_PLTRELSZ:
3396 s = htab->srelplt->output_section;
3397 BFD_ASSERT (s != NULL);
3398 dyn.d_un.d_val = s->size;
3399 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3400 break;
3401
3402 case DT_RELASZ:
3403 /* My reading of the SVR4 ABI indicates that the
3404 procedure linkage table relocs (DT_JMPREL) should be
3405 included in the overall relocs (DT_RELA). This is
3406 what Solaris does. However, UnixWare can not handle
3407 that case. Therefore, we override the DT_RELASZ entry
3408 here to make it not include the JMPREL relocs. Since
3409 the linker script arranges for .rela.plt to follow all
3410 other relocation sections, we don't have to worry
3411 about changing the DT_RELA entry. */
3412 if (htab->srelplt != NULL)
3413 {
3414 s = htab->srelplt->output_section;
3415 dyn.d_un.d_val -= s->size;
3416 }
3417 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3418 break;
3419 }
3420 }
3421
3422 /* Fill in the first entry in the procedure linkage table. */
3423 splt = htab->splt;
3424 if (splt && splt->size > 0)
3425 {
3426 if (info->shared)
3427 {
3428 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3429 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3430 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3431 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3432 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3433 }
3434 else
3435 {
3436 unsigned long addr;
3437 /* addr = .got + 4 */
3438 addr = sgot->output_section->vma + sgot->output_offset + 4;
3439 bfd_put_32 (output_bfd,
3440 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3441 splt->contents);
3442 bfd_put_32 (output_bfd,
3443 PLT0_ENTRY_WORD1 | (addr & 0xffff),
3444 splt->contents + 4);
3445 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3446 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3447 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3448 }
3449
3450 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3451 PLT_ENTRY_SIZE;
3452 }
3453 }
3454
3455 /* Fill in the first three entries in the global offset table. */
3456 if (sgot && sgot->size > 0)
3457 {
3458 if (sdyn == NULL)
3459 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3460 else
3461 bfd_put_32 (output_bfd,
3462 sdyn->output_section->vma + sdyn->output_offset,
3463 sgot->contents);
3464 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3465 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3466
3467 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3468 }
3469
3470 return TRUE;
3471 }
3472
3473 \f
3474 /* Set the right machine number. */
3475
3476 static bfd_boolean
3477 m32r_elf_object_p (bfd *abfd)
3478 {
3479 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3480 {
3481 default:
3482 case E_M32R_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r); break;
3483 case E_M32RX_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3484 case E_M32R2_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3485 }
3486 return TRUE;
3487 }
3488
3489 /* Store the machine number in the flags field. */
3490
3491 static void
3492 m32r_elf_final_write_processing (bfd *abfd,
3493 bfd_boolean linker ATTRIBUTE_UNUSED)
3494 {
3495 unsigned long val;
3496
3497 switch (bfd_get_mach (abfd))
3498 {
3499 default:
3500 case bfd_mach_m32r: val = E_M32R_ARCH; break;
3501 case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3502 case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3503 }
3504
3505 elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3506 elf_elfheader (abfd)->e_flags |= val;
3507 }
3508
3509 /* Function to keep M32R specific file flags. */
3510
3511 static bfd_boolean
3512 m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3513 {
3514 BFD_ASSERT (!elf_flags_init (abfd)
3515 || elf_elfheader (abfd)->e_flags == flags);
3516
3517 elf_elfheader (abfd)->e_flags = flags;
3518 elf_flags_init (abfd) = TRUE;
3519 return TRUE;
3520 }
3521
3522 /* Merge backend specific data from an object file to the output
3523 object file when linking. */
3524
3525 static bfd_boolean
3526 m32r_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3527 {
3528 flagword out_flags;
3529 flagword in_flags;
3530
3531 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3532 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3533 return TRUE;
3534
3535 in_flags = elf_elfheader (ibfd)->e_flags;
3536 out_flags = elf_elfheader (obfd)->e_flags;
3537
3538 if (! elf_flags_init (obfd))
3539 {
3540 /* If the input is the default architecture then do not
3541 bother setting the flags for the output architecture,
3542 instead allow future merges to do this. If no future
3543 merges ever set these flags then they will retain their
3544 unitialised values, which surprise surprise, correspond
3545 to the default values. */
3546 if (bfd_get_arch_info (ibfd)->the_default)
3547 return TRUE;
3548
3549 elf_flags_init (obfd) = TRUE;
3550 elf_elfheader (obfd)->e_flags = in_flags;
3551
3552 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3553 && bfd_get_arch_info (obfd)->the_default)
3554 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3555 bfd_get_mach (ibfd));
3556
3557 return TRUE;
3558 }
3559
3560 /* Check flag compatibility. */
3561 if (in_flags == out_flags)
3562 return TRUE;
3563
3564 if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3565 {
3566 if ( ((in_flags & EF_M32R_ARCH) != E_M32R_ARCH)
3567 || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3568 || ((in_flags & EF_M32R_ARCH) == E_M32R2_ARCH))
3569 {
3570 (*_bfd_error_handler)
3571 (_("%B: Instruction set mismatch with previous modules"), ibfd);
3572
3573 bfd_set_error (bfd_error_bad_value);
3574 return FALSE;
3575 }
3576 }
3577
3578 return TRUE;
3579 }
3580
3581 /* Display the flags field. */
3582
3583 static bfd_boolean
3584 m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3585 {
3586 FILE * file = (FILE *) ptr;
3587
3588 BFD_ASSERT (abfd != NULL && ptr != NULL);
3589
3590 _bfd_elf_print_private_bfd_data (abfd, ptr);
3591
3592 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3593
3594 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3595 {
3596 default:
3597 case E_M32R_ARCH: fprintf (file, _(": m32r instructions")); break;
3598 case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3599 case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3600 }
3601
3602 fputc ('\n', file);
3603
3604 return TRUE;
3605 }
3606
3607 static asection *
3608 m32r_elf_gc_mark_hook (asection *sec,
3609 struct bfd_link_info *info,
3610 Elf_Internal_Rela *rel,
3611 struct elf_link_hash_entry *h,
3612 Elf_Internal_Sym *sym)
3613 {
3614 if (h != NULL)
3615 switch (ELF32_R_TYPE (rel->r_info))
3616 {
3617 case R_M32R_GNU_VTINHERIT:
3618 case R_M32R_GNU_VTENTRY:
3619 case R_M32R_RELA_GNU_VTINHERIT:
3620 case R_M32R_RELA_GNU_VTENTRY:
3621 return NULL;
3622 }
3623
3624 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3625 }
3626
3627 static bfd_boolean
3628 m32r_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
3629 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3630 asection *sec ATTRIBUTE_UNUSED,
3631 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3632 {
3633 /* Update the got entry reference counts for the section being removed. */
3634 Elf_Internal_Shdr *symtab_hdr;
3635 struct elf_link_hash_entry **sym_hashes;
3636 bfd_signed_vma *local_got_refcounts;
3637 const Elf_Internal_Rela *rel, *relend;
3638
3639 if (info->relocatable)
3640 return TRUE;
3641
3642 elf_section_data (sec)->local_dynrel = NULL;
3643
3644 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3645 sym_hashes = elf_sym_hashes (abfd);
3646 local_got_refcounts = elf_local_got_refcounts (abfd);
3647
3648 relend = relocs + sec->reloc_count;
3649 for (rel = relocs; rel < relend; rel++)
3650 {
3651 unsigned long r_symndx;
3652 struct elf_link_hash_entry *h = NULL;
3653
3654 r_symndx = ELF32_R_SYM (rel->r_info);
3655 if (r_symndx >= symtab_hdr->sh_info)
3656 {
3657 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3658 while (h->root.type == bfd_link_hash_indirect
3659 || h->root.type == bfd_link_hash_warning)
3660 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3661 }
3662
3663 switch (ELF32_R_TYPE (rel->r_info))
3664 {
3665 case R_M32R_GOT16_HI_ULO:
3666 case R_M32R_GOT16_HI_SLO:
3667 case R_M32R_GOT16_LO:
3668 case R_M32R_GOTOFF:
3669 case R_M32R_GOTOFF_HI_ULO:
3670 case R_M32R_GOTOFF_HI_SLO:
3671 case R_M32R_GOTOFF_LO:
3672 case R_M32R_GOT24:
3673 case R_M32R_GOTPC_HI_ULO:
3674 case R_M32R_GOTPC_HI_SLO:
3675 case R_M32R_GOTPC_LO:
3676 case R_M32R_GOTPC24:
3677 if (h != NULL)
3678 {
3679 if (h->got.refcount > 0)
3680 h->got.refcount--;
3681 }
3682 else
3683 {
3684 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
3685 local_got_refcounts[r_symndx]--;
3686 }
3687 break;
3688
3689 case R_M32R_16_RELA:
3690 case R_M32R_24_RELA:
3691 case R_M32R_32_RELA:
3692 case R_M32R_REL32:
3693 case R_M32R_HI16_ULO_RELA:
3694 case R_M32R_HI16_SLO_RELA:
3695 case R_M32R_LO16_RELA:
3696 case R_M32R_SDA16_RELA:
3697 case R_M32R_10_PCREL_RELA:
3698 case R_M32R_18_PCREL_RELA:
3699 case R_M32R_26_PCREL_RELA:
3700 if (h != NULL)
3701 {
3702 struct elf_m32r_link_hash_entry *eh;
3703 struct elf_m32r_dyn_relocs **pp;
3704 struct elf_m32r_dyn_relocs *p;
3705
3706 if (!info->shared && h->plt.refcount > 0)
3707 h->plt.refcount -= 1;
3708
3709 eh = (struct elf_m32r_link_hash_entry *) h;
3710
3711 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3712 if (p->sec == sec)
3713 {
3714 if ( ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3715 || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3716 || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3717 || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3718 p->pc_count -= 1;
3719 p->count -= 1;
3720 if (p->count == 0)
3721 *pp = p->next;
3722 break;
3723 }
3724 }
3725 break;
3726
3727 case R_M32R_26_PLTREL:
3728 if (h != NULL)
3729 {
3730 if (h->plt.refcount > 0)
3731 h->plt.refcount--;
3732 }
3733 break;
3734
3735 default:
3736 break;
3737 }
3738 }
3739
3740 return TRUE;
3741 }
3742
3743 /* Look through the relocs for a section during the first phase.
3744 Since we don't do .gots or .plts, we just need to consider the
3745 virtual table relocs for gc. */
3746
3747 static bfd_boolean
3748 m32r_elf_check_relocs (bfd *abfd,
3749 struct bfd_link_info *info,
3750 asection *sec,
3751 const Elf_Internal_Rela *relocs)
3752 {
3753 Elf_Internal_Shdr *symtab_hdr;
3754 struct elf_link_hash_entry **sym_hashes;
3755 const Elf_Internal_Rela *rel;
3756 const Elf_Internal_Rela *rel_end;
3757 struct elf_m32r_link_hash_table *htab;
3758 bfd *dynobj;
3759 asection *sreloc;
3760
3761 if (info->relocatable)
3762 return TRUE;
3763
3764 sreloc = NULL;
3765 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3766 sym_hashes = elf_sym_hashes (abfd);
3767
3768 htab = m32r_elf_hash_table (info);
3769 if (htab == NULL)
3770 return FALSE;
3771
3772 dynobj = htab->root.dynobj;
3773
3774 rel_end = relocs + sec->reloc_count;
3775 for (rel = relocs; rel < rel_end; rel++)
3776 {
3777 int r_type;
3778 struct elf_link_hash_entry *h;
3779 unsigned long r_symndx;
3780
3781 r_symndx = ELF32_R_SYM (rel->r_info);
3782 r_type = ELF32_R_TYPE (rel->r_info);
3783 if (r_symndx < symtab_hdr->sh_info)
3784 h = NULL;
3785 else
3786 {
3787 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3788 while (h->root.type == bfd_link_hash_indirect
3789 || h->root.type == bfd_link_hash_warning)
3790 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3791 }
3792
3793 /* Some relocs require a global offset table. */
3794 if (htab->sgot == NULL)
3795 {
3796 switch (r_type)
3797 {
3798 case R_M32R_GOT16_HI_ULO:
3799 case R_M32R_GOT16_HI_SLO:
3800 case R_M32R_GOTOFF:
3801 case R_M32R_GOTOFF_HI_ULO:
3802 case R_M32R_GOTOFF_HI_SLO:
3803 case R_M32R_GOTOFF_LO:
3804 case R_M32R_GOT16_LO:
3805 case R_M32R_GOTPC24:
3806 case R_M32R_GOTPC_HI_ULO:
3807 case R_M32R_GOTPC_HI_SLO:
3808 case R_M32R_GOTPC_LO:
3809 case R_M32R_GOT24:
3810 if (dynobj == NULL)
3811 htab->root.dynobj = dynobj = abfd;
3812 if (! create_got_section (dynobj, info))
3813 return FALSE;
3814 break;
3815
3816 default:
3817 break;
3818 }
3819 }
3820
3821 switch (r_type)
3822 {
3823 case R_M32R_GOT16_HI_ULO:
3824 case R_M32R_GOT16_HI_SLO:
3825 case R_M32R_GOT16_LO:
3826 case R_M32R_GOT24:
3827
3828 if (h != NULL)
3829 h->got.refcount += 1;
3830 else
3831 {
3832 bfd_signed_vma *local_got_refcounts;
3833
3834 /* This is a global offset table entry for a local
3835 symbol. */
3836 local_got_refcounts = elf_local_got_refcounts (abfd);
3837 if (local_got_refcounts == NULL)
3838 {
3839 bfd_size_type size;
3840
3841 size = symtab_hdr->sh_info;
3842 size *= sizeof (bfd_signed_vma);
3843 local_got_refcounts = bfd_zalloc (abfd, size);
3844 if (local_got_refcounts == NULL)
3845 return FALSE;
3846 elf_local_got_refcounts (abfd) = local_got_refcounts;
3847 }
3848 local_got_refcounts[r_symndx] += 1;
3849 }
3850 break;
3851
3852 case R_M32R_26_PLTREL:
3853 /* This symbol requires a procedure linkage table entry. We
3854 actually build the entry in adjust_dynamic_symbol,
3855 because this might be a case of linking PIC code without
3856 linking in any dynamic objects, in which case we don't
3857 need to generate a procedure linkage table after all. */
3858
3859 /* If this is a local symbol, we resolve it directly without
3860 creating a procedure linkage table entry. */
3861 if (h == NULL)
3862 continue;
3863
3864 if (h->forced_local)
3865 break;
3866
3867 h->needs_plt = 1;
3868 h->plt.refcount += 1;
3869 break;
3870
3871 case R_M32R_16_RELA:
3872 case R_M32R_24_RELA:
3873 case R_M32R_32_RELA:
3874 case R_M32R_REL32:
3875 case R_M32R_HI16_ULO_RELA:
3876 case R_M32R_HI16_SLO_RELA:
3877 case R_M32R_LO16_RELA:
3878 case R_M32R_SDA16_RELA:
3879 case R_M32R_10_PCREL_RELA:
3880 case R_M32R_18_PCREL_RELA:
3881 case R_M32R_26_PCREL_RELA:
3882
3883 if (h != NULL && !info->shared)
3884 {
3885 h->non_got_ref = 1;
3886 h->plt.refcount += 1;
3887 }
3888
3889 /* If we are creating a shared library, and this is a reloc
3890 against a global symbol, or a non PC relative reloc
3891 against a local symbol, then we need to copy the reloc
3892 into the shared library. However, if we are linking with
3893 -Bsymbolic, we do not need to copy a reloc against a
3894 global symbol which is defined in an object we are
3895 including in the link (i.e., DEF_REGULAR is set). At
3896 this point we have not seen all the input files, so it is
3897 possible that DEF_REGULAR is not set now but will be set
3898 later (it is never cleared). We account for that
3899 possibility below by storing information in the
3900 dyn_relocs field of the hash table entry. A similar
3901 situation occurs when creating shared libraries and symbol
3902 visibility changes render the symbol local.
3903
3904 If on the other hand, we are creating an executable, we
3905 may need to keep relocations for symbols satisfied by a
3906 dynamic library if we manage to avoid copy relocs for the
3907 symbol. */
3908 if ((info->shared
3909 && (sec->flags & SEC_ALLOC) != 0
3910 && (( r_type != R_M32R_26_PCREL_RELA
3911 && r_type != R_M32R_18_PCREL_RELA
3912 && r_type != R_M32R_10_PCREL_RELA
3913 && r_type != R_M32R_REL32)
3914 || (h != NULL
3915 && (! info->symbolic
3916 || h->root.type == bfd_link_hash_defweak
3917 || !h->def_regular))))
3918 || (!info->shared
3919 && (sec->flags & SEC_ALLOC) != 0
3920 && h != NULL
3921 && (h->root.type == bfd_link_hash_defweak
3922 || !h->def_regular)))
3923 {
3924 struct elf_m32r_dyn_relocs *p;
3925 struct elf_m32r_dyn_relocs **head;
3926
3927 if (dynobj == NULL)
3928 htab->root.dynobj = dynobj = abfd;
3929
3930 /* When creating a shared object, we must copy these
3931 relocs into the output file. We create a reloc
3932 section in dynobj and make room for the reloc. */
3933 if (sreloc == NULL)
3934 {
3935 sreloc = _bfd_elf_make_dynamic_reloc_section
3936 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3937
3938 if (sreloc == NULL)
3939 return FALSE;
3940 }
3941
3942 /* If this is a global symbol, we count the number of
3943 relocations we need for this symbol. */
3944 if (h != NULL)
3945 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3946 else
3947 {
3948 /* Track dynamic relocs needed for local syms too. */
3949 asection *s;
3950 void *vpp;
3951 Elf_Internal_Sym *isym;
3952
3953 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3954 abfd, r_symndx);
3955 if (isym == NULL)
3956 return FALSE;
3957
3958 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3959 if (s == NULL)
3960 s = sec;
3961
3962 vpp = &elf_section_data (s)->local_dynrel;
3963 head = (struct elf_m32r_dyn_relocs **) vpp;
3964 }
3965
3966 p = *head;
3967 if (p == NULL || p->sec != sec)
3968 {
3969 bfd_size_type amt = sizeof (*p);
3970
3971 p = bfd_alloc (dynobj, amt);
3972 if (p == NULL)
3973 return FALSE;
3974 p->next = *head;
3975 *head = p;
3976 p->sec = sec;
3977 p->count = 0;
3978 p->pc_count = 0;
3979 }
3980
3981 p->count += 1;
3982 if ( ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3983 || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3984 || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3985 || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3986 p->pc_count += 1;
3987 }
3988 break;
3989
3990 /* This relocation describes the C++ object vtable hierarchy.
3991 Reconstruct it for later use during GC. */
3992 case R_M32R_RELA_GNU_VTINHERIT:
3993 case R_M32R_GNU_VTINHERIT:
3994 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3995 return FALSE;
3996 break;
3997
3998 /* This relocation describes which C++ vtable entries are actually
3999 used. Record for later use during GC. */
4000 case R_M32R_GNU_VTENTRY:
4001 BFD_ASSERT (h != NULL);
4002 if (h != NULL
4003 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4004 return FALSE;
4005 break;
4006 case R_M32R_RELA_GNU_VTENTRY:
4007 BFD_ASSERT (h != NULL);
4008 if (h != NULL
4009 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4010 return FALSE;
4011 break;
4012 }
4013 }
4014
4015 return TRUE;
4016 }
4017
4018 static const struct bfd_elf_special_section m32r_elf_special_sections[] =
4019 {
4020 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
4021 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
4022 { NULL, 0, 0, 0, 0 }
4023 };
4024
4025 static enum elf_reloc_type_class
4026 m32r_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4027 {
4028 switch ((int) ELF32_R_TYPE (rela->r_info))
4029 {
4030 case R_M32R_RELATIVE: return reloc_class_relative;
4031 case R_M32R_JMP_SLOT: return reloc_class_plt;
4032 case R_M32R_COPY: return reloc_class_copy;
4033 default: return reloc_class_normal;
4034 }
4035 }
4036 \f
4037 #define ELF_ARCH bfd_arch_m32r
4038 #define ELF_TARGET_ID M32R_ELF_DATA
4039 #define ELF_MACHINE_CODE EM_M32R
4040 #define ELF_MACHINE_ALT1 EM_CYGNUS_M32R
4041 #define ELF_MAXPAGESIZE 0x1 /* Explicitly requested by Mitsubishi. */
4042
4043 #define TARGET_BIG_SYM bfd_elf32_m32r_vec
4044 #define TARGET_BIG_NAME "elf32-m32r"
4045 #define TARGET_LITTLE_SYM bfd_elf32_m32rle_vec
4046 #define TARGET_LITTLE_NAME "elf32-m32rle"
4047
4048 #define elf_info_to_howto m32r_info_to_howto
4049 #define elf_info_to_howto_rel m32r_info_to_howto_rel
4050 #define elf_backend_section_from_bfd_section _bfd_m32r_elf_section_from_bfd_section
4051 #define elf_backend_symbol_processing _bfd_m32r_elf_symbol_processing
4052 #define elf_backend_add_symbol_hook m32r_elf_add_symbol_hook
4053 #define elf_backend_relocate_section m32r_elf_relocate_section
4054 #define elf_backend_gc_mark_hook m32r_elf_gc_mark_hook
4055 #define elf_backend_gc_sweep_hook m32r_elf_gc_sweep_hook
4056 #define elf_backend_check_relocs m32r_elf_check_relocs
4057
4058 #define elf_backend_create_dynamic_sections m32r_elf_create_dynamic_sections
4059 #define bfd_elf32_bfd_link_hash_table_create m32r_elf_link_hash_table_create
4060 #define elf_backend_size_dynamic_sections m32r_elf_size_dynamic_sections
4061 #define elf_backend_omit_section_dynsym \
4062 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4063 #define elf_backend_finish_dynamic_sections m32r_elf_finish_dynamic_sections
4064 #define elf_backend_adjust_dynamic_symbol m32r_elf_adjust_dynamic_symbol
4065 #define elf_backend_finish_dynamic_symbol m32r_elf_finish_dynamic_symbol
4066 #define elf_backend_reloc_type_class m32r_elf_reloc_type_class
4067 #define elf_backend_copy_indirect_symbol m32r_elf_copy_indirect_symbol
4068
4069 #define elf_backend_can_gc_sections 1
4070 /*#if !USE_REL
4071 #define elf_backend_rela_normal 1
4072 #endif*/
4073 #define elf_backend_can_refcount 1
4074 #define elf_backend_want_got_plt 1
4075 #define elf_backend_plt_readonly 1
4076 #define elf_backend_want_plt_sym 0
4077 #define elf_backend_got_header_size 12
4078
4079 #define elf_backend_may_use_rel_p 1
4080 #ifdef USE_M32R_OLD_RELOC
4081 #define elf_backend_default_use_rela_p 0
4082 #define elf_backend_may_use_rela_p 0
4083 #else
4084 #define elf_backend_default_use_rela_p 1
4085 #define elf_backend_may_use_rela_p 1
4086 #endif
4087
4088 #define elf_backend_object_p m32r_elf_object_p
4089 #define elf_backend_final_write_processing m32r_elf_final_write_processing
4090 #define bfd_elf32_bfd_merge_private_bfd_data m32r_elf_merge_private_bfd_data
4091 #define bfd_elf32_bfd_set_private_flags m32r_elf_set_private_flags
4092 #define bfd_elf32_bfd_print_private_bfd_data m32r_elf_print_private_bfd_data
4093 #define elf_backend_special_sections m32r_elf_special_sections
4094
4095 #include "elf32-target.h"
4096
4097 #undef ELF_MAXPAGESIZE
4098 #define ELF_MAXPAGESIZE 0x1000
4099
4100 #undef TARGET_BIG_SYM
4101 #define TARGET_BIG_SYM bfd_elf32_m32rlin_vec
4102 #undef TARGET_BIG_NAME
4103 #define TARGET_BIG_NAME "elf32-m32r-linux"
4104 #undef TARGET_LITTLE_SYM
4105 #define TARGET_LITTLE_SYM bfd_elf32_m32rlelin_vec
4106 #undef TARGET_LITTLE_NAME
4107 #define TARGET_LITTLE_NAME "elf32-m32rle-linux"
4108 #undef elf32_bed
4109 #define elf32_bed elf32_m32r_lin_bed
4110
4111 #include "elf32-target.h"
4112
git-cvsimport of binutils cvsroot