* pe-dll.c (make_import_fixup_mark): Avoid type-punned pointer.
[binutils.git] / bfd / elf32-m32r.c
blob8adb1e2f61103da7854764f2a649820d7c92382c
1 /* M32R-specific support for 32-bit ELF.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
10 (at your option) any later version.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/m32r.h"
27 static bfd_reloc_status_type m32r_elf_10_pcrel_reloc
28 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
29 static bfd_reloc_status_type m32r_elf_do_10_pcrel_reloc
30 PARAMS ((bfd *, reloc_howto_type *, asection *,
31 bfd_byte *, bfd_vma, asection *, bfd_vma, bfd_vma));
32 static bfd_reloc_status_type m32r_elf_hi16_reloc
33 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
34 static void m32r_elf_relocate_hi16
35 PARAMS ((bfd *, int, Elf_Internal_Rela *, Elf_Internal_Rela *,
36 bfd_byte *, bfd_vma));
37 bfd_reloc_status_type m32r_elf_lo16_reloc
38 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
39 bfd_reloc_status_type m32r_elf_generic_reloc
40 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
41 static bfd_reloc_status_type m32r_elf_sda16_reloc
42 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
44 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
45 static void m32r_info_to_howto_rel
46 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
47 boolean _bfd_m32r_elf_section_from_bfd_section
48 PARAMS ((bfd *, asection *, int *));
49 void _bfd_m32r_elf_symbol_processing
50 PARAMS ((bfd *, asymbol *));
51 static boolean m32r_elf_add_symbol_hook
52 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
53 const char **, flagword *, asection **, bfd_vma *));
54 static boolean m32r_elf_relocate_section
55 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
56 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
57 #if 0 /* not yet */
58 static boolean m32r_elf_relax_delete_bytes
59 PARAMS ((bfd *, asection *, bfd_vma, int));
60 #endif
61 static bfd_reloc_status_type m32r_elf_final_sda_base
62 PARAMS ((bfd *, struct bfd_link_info *, const char **, bfd_vma *));
63 static boolean m32r_elf_object_p
64 PARAMS ((bfd *));
65 static void m32r_elf_final_write_processing
66 PARAMS ((bfd *, boolean));
67 static boolean m32r_elf_set_private_flags
68 PARAMS ((bfd *, flagword));
69 static boolean m32r_elf_merge_private_bfd_data
70 PARAMS ((bfd *, bfd *));
71 static boolean m32r_elf_print_private_bfd_data
72 PARAMS ((bfd *, PTR));
73 static boolean m32r_elf_gc_sweep_hook
74 PARAMS ((bfd *, struct bfd_link_info *, asection *,
75 const Elf_Internal_Rela *));
76 static boolean m32r_elf_check_relocs
77 PARAMS ((bfd *, struct bfd_link_info *, asection *,
78 const Elf_Internal_Rela *));
80 asection * m32r_elf_gc_mark_hook
81 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
82 struct elf_link_hash_entry *, Elf_Internal_Sym *));
84 #define NOP_INSN 0x7000
85 #define MAKE_PARALLEL(insn) ((insn) | 0x8000)
87 /* Use REL instead of RELA to save space.
88 This only saves space in libraries and object files, but perhaps
89 relocs will be put in ROM? All in all though, REL relocs are a pain
90 to work with. */
91 #define USE_REL
93 static reloc_howto_type m32r_elf_howto_table[] =
95 /* This reloc does nothing. */
96 HOWTO (R_M32R_NONE, /* type */
97 0, /* rightshift */
98 2, /* size (0 = byte, 1 = short, 2 = long) */
99 32, /* bitsize */
100 false, /* pc_relative */
101 0, /* bitpos */
102 complain_overflow_bitfield, /* complain_on_overflow */
103 bfd_elf_generic_reloc, /* special_function */
104 "R_M32R_NONE", /* name */
105 false, /* partial_inplace */
106 0, /* src_mask */
107 0, /* dst_mask */
108 false), /* pcrel_offset */
110 /* A 16 bit absolute relocation. */
111 HOWTO (R_M32R_16, /* type */
112 0, /* rightshift */
113 1, /* size (0 = byte, 1 = short, 2 = long) */
114 16, /* bitsize */
115 false, /* pc_relative */
116 0, /* bitpos */
117 complain_overflow_bitfield, /* complain_on_overflow */
118 m32r_elf_generic_reloc,/* special_function */
119 "R_M32R_16", /* name */
120 true, /* partial_inplace */
121 0xffff, /* src_mask */
122 0xffff, /* dst_mask */
123 false), /* pcrel_offset */
125 /* A 32 bit absolute relocation. */
126 HOWTO (R_M32R_32, /* type */
127 0, /* rightshift */
128 2, /* size (0 = byte, 1 = short, 2 = long) */
129 32, /* bitsize */
130 false, /* pc_relative */
131 0, /* bitpos */
132 complain_overflow_bitfield, /* complain_on_overflow */
133 m32r_elf_generic_reloc,/* special_function */
134 "R_M32R_32", /* name */
135 true, /* partial_inplace */
136 0xffffffff, /* src_mask */
137 0xffffffff, /* dst_mask */
138 false), /* pcrel_offset */
140 /* A 24 bit address. */
141 HOWTO (R_M32R_24, /* type */
142 0, /* rightshift */
143 2, /* size (0 = byte, 1 = short, 2 = long) */
144 24, /* bitsize */
145 false, /* pc_relative */
146 0, /* bitpos */
147 complain_overflow_unsigned, /* complain_on_overflow */
148 m32r_elf_generic_reloc,/* special_function */
149 "R_M32R_24", /* name */
150 true, /* partial_inplace */
151 0xffffff, /* src_mask */
152 0xffffff, /* dst_mask */
153 false), /* pcrel_offset */
155 /* An PC Relative 10-bit relocation, shifted by 2.
156 This reloc is complicated because relocations are relative to pc & -4.
157 i.e. branches in the right insn slot use the address of the left insn
158 slot for pc. */
159 /* ??? It's not clear whether this should have partial_inplace set or not.
160 Branch relaxing in the assembler can store the addend in the insn,
161 and if bfd_install_relocation gets called the addend may get added
162 again. */
163 HOWTO (R_M32R_10_PCREL, /* type */
164 2, /* rightshift */
165 1, /* size (0 = byte, 1 = short, 2 = long) */
166 10, /* bitsize */
167 true, /* pc_relative */
168 0, /* bitpos */
169 complain_overflow_signed, /* complain_on_overflow */
170 m32r_elf_10_pcrel_reloc, /* special_function */
171 "R_M32R_10_PCREL", /* name */
172 false, /* partial_inplace */
173 0xff, /* src_mask */
174 0xff, /* dst_mask */
175 true), /* pcrel_offset */
177 /* A relative 18 bit relocation, right shifted by 2. */
178 HOWTO (R_M32R_18_PCREL, /* type */
179 2, /* rightshift */
180 2, /* size (0 = byte, 1 = short, 2 = long) */
181 16, /* bitsize */
182 true, /* pc_relative */
183 0, /* bitpos */
184 complain_overflow_signed, /* complain_on_overflow */
185 bfd_elf_generic_reloc, /* special_function */
186 "R_M32R_18_PCREL", /* name */
187 false, /* partial_inplace */
188 0xffff, /* src_mask */
189 0xffff, /* dst_mask */
190 true), /* pcrel_offset */
192 /* A relative 26 bit relocation, right shifted by 2. */
193 /* ??? It's not clear whether this should have partial_inplace set or not.
194 Branch relaxing in the assembler can store the addend in the insn,
195 and if bfd_install_relocation gets called the addend may get added
196 again. */
197 HOWTO (R_M32R_26_PCREL, /* type */
198 2, /* rightshift */
199 2, /* size (0 = byte, 1 = short, 2 = long) */
200 26, /* bitsize */
201 true, /* pc_relative */
202 0, /* bitpos */
203 complain_overflow_signed, /* complain_on_overflow */
204 bfd_elf_generic_reloc, /* special_function */
205 "R_M32R_26_PCREL", /* name */
206 false, /* partial_inplace */
207 0xffffff, /* src_mask */
208 0xffffff, /* dst_mask */
209 true), /* pcrel_offset */
211 /* High 16 bits of address when lower 16 is or'd in. */
212 HOWTO (R_M32R_HI16_ULO, /* type */
213 16, /* rightshift */
214 2, /* size (0 = byte, 1 = short, 2 = long) */
215 16, /* bitsize */
216 false, /* pc_relative */
217 0, /* bitpos */
218 complain_overflow_dont, /* complain_on_overflow */
219 m32r_elf_hi16_reloc, /* special_function */
220 "R_M32R_HI16_ULO", /* name */
221 true, /* partial_inplace */
222 0x0000ffff, /* src_mask */
223 0x0000ffff, /* dst_mask */
224 false), /* pcrel_offset */
226 /* High 16 bits of address when lower 16 is added in. */
227 HOWTO (R_M32R_HI16_SLO, /* type */
228 16, /* rightshift */
229 2, /* size (0 = byte, 1 = short, 2 = long) */
230 16, /* bitsize */
231 false, /* pc_relative */
232 0, /* bitpos */
233 complain_overflow_dont, /* complain_on_overflow */
234 m32r_elf_hi16_reloc, /* special_function */
235 "R_M32R_HI16_SLO", /* name */
236 true, /* partial_inplace */
237 0x0000ffff, /* src_mask */
238 0x0000ffff, /* dst_mask */
239 false), /* pcrel_offset */
241 /* Lower 16 bits of address. */
242 HOWTO (R_M32R_LO16, /* type */
243 0, /* rightshift */
244 2, /* size (0 = byte, 1 = short, 2 = long) */
245 16, /* bitsize */
246 false, /* pc_relative */
247 0, /* bitpos */
248 complain_overflow_dont, /* complain_on_overflow */
249 m32r_elf_lo16_reloc, /* special_function */
250 "R_M32R_LO16", /* name */
251 true, /* partial_inplace */
252 0x0000ffff, /* src_mask */
253 0x0000ffff, /* dst_mask */
254 false), /* pcrel_offset */
256 /* Small data area 16 bits offset. */
257 HOWTO (R_M32R_SDA16, /* type */
258 0, /* rightshift */
259 2, /* size (0 = byte, 1 = short, 2 = long) */
260 16, /* bitsize */
261 false, /* pc_relative */
262 0, /* bitpos */
263 complain_overflow_signed, /* complain_on_overflow */
264 m32r_elf_sda16_reloc, /* special_function */
265 "R_M32R_SDA16", /* name */
266 true, /* partial_inplace */ /* FIXME: correct? */
267 0x0000ffff, /* src_mask */
268 0x0000ffff, /* dst_mask */
269 false), /* pcrel_offset */
271 /* GNU extension to record C++ vtable hierarchy */
272 HOWTO (R_M32R_GNU_VTINHERIT, /* type */
273 0, /* rightshift */
274 2, /* size (0 = byte, 1 = short, 2 = long) */
275 0, /* bitsize */
276 false, /* pc_relative */
277 0, /* bitpos */
278 complain_overflow_dont, /* complain_on_overflow */
279 NULL, /* special_function */
280 "R_M32R_GNU_VTINHERIT", /* name */
281 false, /* partial_inplace */
282 0, /* src_mask */
283 0, /* dst_mask */
284 false), /* pcrel_offset */
286 /* GNU extension to record C++ vtable member usage */
287 HOWTO (R_M32R_GNU_VTENTRY, /* type */
288 0, /* rightshift */
289 2, /* size (0 = byte, 1 = short, 2 = long) */
290 0, /* bitsize */
291 false, /* pc_relative */
292 0, /* bitpos */
293 complain_overflow_dont, /* complain_on_overflow */
294 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
295 "R_M32R_GNU_VTENTRY", /* name */
296 false, /* partial_inplace */
297 0, /* src_mask */
298 0, /* dst_mask */
299 false), /* pcrel_offset */
303 /* Handle the R_M32R_10_PCREL reloc. */
305 static bfd_reloc_status_type
306 m32r_elf_10_pcrel_reloc (abfd, reloc_entry, symbol, data,
307 input_section, output_bfd, error_message)
308 bfd * abfd;
309 arelent * reloc_entry;
310 asymbol * symbol;
311 PTR data;
312 asection * input_section;
313 bfd * output_bfd;
314 char ** error_message ATTRIBUTE_UNUSED;
316 /* This part is from bfd_elf_generic_reloc. */
317 if (output_bfd != (bfd *) NULL
318 && (symbol->flags & BSF_SECTION_SYM) == 0
319 && (! reloc_entry->howto->partial_inplace
320 || reloc_entry->addend == 0))
322 reloc_entry->address += input_section->output_offset;
323 return bfd_reloc_ok;
326 if (output_bfd != NULL)
328 /* FIXME: See bfd_perform_relocation. Is this right? */
329 return bfd_reloc_continue;
332 return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto,
333 input_section,
334 data, reloc_entry->address,
335 symbol->section,
336 (symbol->value
337 + symbol->section->output_section->vma
338 + symbol->section->output_offset),
339 reloc_entry->addend);
342 /* Utility to actually perform an R_M32R_10_PCREL reloc. */
344 static bfd_reloc_status_type
345 m32r_elf_do_10_pcrel_reloc (abfd, howto, input_section, data, offset,
346 symbol_section, symbol_value, addend)
347 bfd *abfd;
348 reloc_howto_type *howto;
349 asection *input_section;
350 bfd_byte *data;
351 bfd_vma offset;
352 asection *symbol_section ATTRIBUTE_UNUSED;
353 bfd_vma symbol_value;
354 bfd_vma addend;
356 bfd_signed_vma relocation;
357 unsigned long x;
358 bfd_reloc_status_type status;
360 /* Sanity check the address (offset in section). */
361 if (offset > input_section->_cooked_size)
362 return bfd_reloc_outofrange;
364 relocation = symbol_value + addend;
365 /* Make it pc relative. */
366 relocation -= (input_section->output_section->vma
367 + input_section->output_offset);
368 /* These jumps mask off the lower two bits of the current address
369 before doing pcrel calculations. */
370 relocation -= (offset & -(bfd_vma) 4);
372 if (relocation < -0x200 || relocation > 0x1ff)
373 status = bfd_reloc_overflow;
374 else
375 status = bfd_reloc_ok;
377 x = bfd_get_16 (abfd, data + offset);
378 relocation >>= howto->rightshift;
379 relocation <<= howto->bitpos;
380 x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask);
381 bfd_put_16 (abfd, (bfd_vma) x, data + offset);
383 return status;
386 /* Handle the R_M32R_HI16_[SU]LO relocs.
387 HI16_SLO is for the add3 and load/store with displacement instructions.
388 HI16_ULO is for the or3 instruction.
389 For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to
390 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
391 we must add one to the high 16 bytes (which will get subtracted off when
392 the low 16 bits are added).
393 These relocs have to be done in combination with an R_M32R_LO16 reloc
394 because there is a carry from the LO16 to the HI16. Here we just save
395 the information we need; we do the actual relocation when we see the LO16.
396 This code is copied from the elf32-mips.c. We also support an arbitrary
397 number of HI16 relocs to be associated with a single LO16 reloc. The
398 assembler sorts the relocs to ensure each HI16 immediately precedes its
399 LO16. However if there are multiple copies, the assembler may not find
400 the real LO16 so it picks the first one it finds. */
402 struct m32r_hi16
404 struct m32r_hi16 *next;
405 bfd_byte *addr;
406 bfd_vma addend;
409 /* FIXME: This should not be a static variable. */
411 static struct m32r_hi16 *m32r_hi16_list;
413 static bfd_reloc_status_type
414 m32r_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
415 input_section, output_bfd, error_message)
416 bfd *abfd ATTRIBUTE_UNUSED;
417 arelent *reloc_entry;
418 asymbol *symbol;
419 PTR data;
420 asection *input_section;
421 bfd *output_bfd;
422 char **error_message ATTRIBUTE_UNUSED;
424 bfd_reloc_status_type ret;
425 bfd_vma relocation;
426 struct m32r_hi16 *n;
428 /* This part is from bfd_elf_generic_reloc.
429 If we're relocating, and this an external symbol, we don't want
430 to change anything. */
431 if (output_bfd != (bfd *) NULL
432 && (symbol->flags & BSF_SECTION_SYM) == 0
433 && reloc_entry->addend == 0)
435 reloc_entry->address += input_section->output_offset;
436 return bfd_reloc_ok;
439 /* Sanity check the address (offset in section). */
440 if (reloc_entry->address > input_section->_cooked_size)
441 return bfd_reloc_outofrange;
443 ret = bfd_reloc_ok;
444 if (bfd_is_und_section (symbol->section)
445 && output_bfd == (bfd *) NULL)
446 ret = bfd_reloc_undefined;
448 if (bfd_is_com_section (symbol->section))
449 relocation = 0;
450 else
451 relocation = symbol->value;
453 relocation += symbol->section->output_section->vma;
454 relocation += symbol->section->output_offset;
455 relocation += reloc_entry->addend;
457 /* Save the information, and let LO16 do the actual relocation. */
458 n = (struct m32r_hi16 *) bfd_malloc ((bfd_size_type) sizeof *n);
459 if (n == NULL)
460 return bfd_reloc_outofrange;
461 n->addr = (bfd_byte *) data + reloc_entry->address;
462 n->addend = relocation;
463 n->next = m32r_hi16_list;
464 m32r_hi16_list = n;
466 if (output_bfd != (bfd *) NULL)
467 reloc_entry->address += input_section->output_offset;
469 return ret;
472 /* Handle an M32R ELF HI16 reloc. */
474 static void
475 m32r_elf_relocate_hi16 (input_bfd, type, relhi, rello, contents, addend)
476 bfd *input_bfd;
477 int type;
478 Elf_Internal_Rela *relhi;
479 Elf_Internal_Rela *rello;
480 bfd_byte *contents;
481 bfd_vma addend;
483 unsigned long insn;
484 bfd_vma addlo;
486 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
488 addlo = bfd_get_32 (input_bfd, contents + rello->r_offset);
489 if (type == R_M32R_HI16_SLO)
490 addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000;
491 else
492 addlo &= 0xffff;
494 addend += ((insn & 0xffff) << 16) + addlo;
496 /* Reaccount for sign extension of low part. */
497 if (type == R_M32R_HI16_SLO
498 && (addend & 0x8000) != 0)
499 addend += 0x10000;
501 bfd_put_32 (input_bfd,
502 (insn & 0xffff0000) | ((addend >> 16) & 0xffff),
503 contents + relhi->r_offset);
506 /* Do an R_M32R_LO16 relocation. This is a straightforward 16 bit
507 inplace relocation; this function exists in order to do the
508 R_M32R_HI16_[SU]LO relocation described above. */
510 bfd_reloc_status_type
511 m32r_elf_lo16_reloc (input_bfd, reloc_entry, symbol, data,
512 input_section, output_bfd, error_message)
513 bfd *input_bfd;
514 arelent *reloc_entry;
515 asymbol *symbol;
516 PTR data;
517 asection *input_section;
518 bfd *output_bfd;
519 char **error_message;
521 /* This part is from bfd_elf_generic_reloc.
522 If we're relocating, and this an external symbol, we don't want
523 to change anything. */
524 if (output_bfd != (bfd *) NULL
525 && (symbol->flags & BSF_SECTION_SYM) == 0
526 && reloc_entry->addend == 0)
528 reloc_entry->address += input_section->output_offset;
529 return bfd_reloc_ok;
532 if (m32r_hi16_list != NULL)
534 struct m32r_hi16 *l;
536 l = m32r_hi16_list;
537 while (l != NULL)
539 unsigned long insn;
540 unsigned long val;
541 unsigned long vallo;
542 struct m32r_hi16 *next;
544 /* Do the HI16 relocation. Note that we actually don't need
545 to know anything about the LO16 itself, except where to
546 find the low 16 bits of the addend needed by the LO16. */
547 insn = bfd_get_32 (input_bfd, l->addr);
548 vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address)
549 & 0xffff) ^ 0x8000) - 0x8000;
550 val = ((insn & 0xffff) << 16) + vallo;
551 val += l->addend;
553 /* Reaccount for sign extension of low part. */
554 if ((val & 0x8000) != 0)
555 val += 0x10000;
557 insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff);
558 bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr);
560 next = l->next;
561 free (l);
562 l = next;
565 m32r_hi16_list = NULL;
568 /* Now do the LO16 reloc in the usual way.
569 ??? It would be nice to call bfd_elf_generic_reloc here,
570 but we have partial_inplace == TRUE. bfd_elf_generic_reloc will
571 pass the handling back to bfd_install_relocation which will install
572 a section relative addend which is wrong. */
573 return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
574 input_section, output_bfd, error_message);
577 /* Do generic partial_inplace relocation.
578 This is a local replacement for bfd_elf_generic_reloc. */
580 bfd_reloc_status_type
581 m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
582 input_section, output_bfd, error_message)
583 bfd *input_bfd;
584 arelent *reloc_entry;
585 asymbol *symbol;
586 PTR data;
587 asection *input_section;
588 bfd *output_bfd;
589 char **error_message ATTRIBUTE_UNUSED;
591 bfd_reloc_status_type ret;
592 bfd_vma relocation;
593 bfd_byte *inplace_address;
595 /* This part is from bfd_elf_generic_reloc.
596 If we're relocating, and this an external symbol, we don't want
597 to change anything. */
598 if (output_bfd != (bfd *) NULL
599 && (symbol->flags & BSF_SECTION_SYM) == 0
600 && reloc_entry->addend == 0)
602 reloc_entry->address += input_section->output_offset;
603 return bfd_reloc_ok;
606 /* Now do the reloc in the usual way.
607 ??? It would be nice to call bfd_elf_generic_reloc here,
608 but we have partial_inplace == TRUE. bfd_elf_generic_reloc will
609 pass the handling back to bfd_install_relocation which will install
610 a section relative addend which is wrong. */
612 /* Sanity check the address (offset in section). */
613 if (reloc_entry->address > input_section->_cooked_size)
614 return bfd_reloc_outofrange;
616 ret = bfd_reloc_ok;
617 if (bfd_is_und_section (symbol->section)
618 && output_bfd == (bfd *) NULL)
619 ret = bfd_reloc_undefined;
621 if (bfd_is_com_section (symbol->section)
622 || output_bfd != (bfd *) NULL)
623 relocation = 0;
624 else
625 relocation = symbol->value;
627 /* Only do this for a final link. */
628 if (output_bfd == (bfd *) NULL)
630 relocation += symbol->section->output_section->vma;
631 relocation += symbol->section->output_offset;
634 relocation += reloc_entry->addend;
635 inplace_address = (bfd_byte *) data + reloc_entry->address;
637 #define DOIT(x) \
638 x = ( (x & ~reloc_entry->howto->dst_mask) | \
639 (((x & reloc_entry->howto->src_mask) + relocation) & \
640 reloc_entry->howto->dst_mask))
642 switch (reloc_entry->howto->size)
644 case 1:
646 short x = bfd_get_16 (input_bfd, inplace_address);
647 DOIT (x);
648 bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address);
650 break;
651 case 2:
653 unsigned long x = bfd_get_32 (input_bfd, inplace_address);
654 DOIT (x);
655 bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address);
657 break;
658 default:
659 BFD_ASSERT (0);
662 if (output_bfd != (bfd *) NULL)
663 reloc_entry->address += input_section->output_offset;
665 return ret;
668 /* Handle the R_M32R_SDA16 reloc.
669 This reloc is used to compute the address of objects in the small data area
670 and to perform loads and stores from that area.
671 The lower 16 bits are sign extended and added to the register specified
672 in the instruction, which is assumed to point to _SDA_BASE_. */
674 static bfd_reloc_status_type
675 m32r_elf_sda16_reloc (abfd, reloc_entry, symbol, data,
676 input_section, output_bfd, error_message)
677 bfd *abfd ATTRIBUTE_UNUSED;
678 arelent *reloc_entry;
679 asymbol *symbol;
680 PTR data ATTRIBUTE_UNUSED;
681 asection *input_section;
682 bfd *output_bfd;
683 char **error_message ATTRIBUTE_UNUSED;
685 /* This part is from bfd_elf_generic_reloc. */
686 if (output_bfd != (bfd *) NULL
687 && (symbol->flags & BSF_SECTION_SYM) == 0
688 && (! reloc_entry->howto->partial_inplace
689 || reloc_entry->addend == 0))
691 reloc_entry->address += input_section->output_offset;
692 return bfd_reloc_ok;
695 if (output_bfd != NULL)
697 /* FIXME: See bfd_perform_relocation. Is this right? */
698 return bfd_reloc_continue;
701 /* FIXME: not sure what to do here yet. But then again, the linker
702 may never call us. */
703 abort ();
706 /* Map BFD reloc types to M32R ELF reloc types. */
708 struct m32r_reloc_map
710 bfd_reloc_code_real_type bfd_reloc_val;
711 unsigned char elf_reloc_val;
714 static const struct m32r_reloc_map m32r_reloc_map[] =
716 { BFD_RELOC_NONE, R_M32R_NONE },
717 { BFD_RELOC_16, R_M32R_16 },
718 { BFD_RELOC_32, R_M32R_32 },
719 { BFD_RELOC_M32R_24, R_M32R_24 },
720 { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL },
721 { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL },
722 { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL },
723 { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO },
724 { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO },
725 { BFD_RELOC_M32R_LO16, R_M32R_LO16 },
726 { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 },
727 { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT },
728 { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY },
731 static reloc_howto_type *
732 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
733 bfd *abfd ATTRIBUTE_UNUSED;
734 bfd_reloc_code_real_type code;
736 unsigned int i;
738 for (i = 0;
739 i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map);
740 i++)
742 if (m32r_reloc_map[i].bfd_reloc_val == code)
743 return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val];
746 return NULL;
749 /* Set the howto pointer for an M32R ELF reloc. */
751 static void
752 m32r_info_to_howto_rel (abfd, cache_ptr, dst)
753 bfd *abfd ATTRIBUTE_UNUSED;
754 arelent *cache_ptr;
755 Elf32_Internal_Rel *dst;
757 unsigned int r_type;
759 r_type = ELF32_R_TYPE (dst->r_info);
760 BFD_ASSERT (r_type < (unsigned int) R_M32R_max);
761 cache_ptr->howto = &m32r_elf_howto_table[r_type];
764 /* Given a BFD section, try to locate the corresponding ELF section
765 index. */
767 boolean
768 _bfd_m32r_elf_section_from_bfd_section (abfd, sec, retval)
769 bfd *abfd ATTRIBUTE_UNUSED;
770 asection *sec;
771 int *retval;
773 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
775 *retval = SHN_M32R_SCOMMON;
776 return true;
778 return false;
781 /* M32R ELF uses two common sections. One is the usual one, and the other
782 is for small objects. All the small objects are kept together, and then
783 referenced via one register, which yields faster assembler code. It is
784 up to the compiler to emit an instruction to load the register with
785 _SDA_BASE. This is what we use for the small common section. This
786 approach is copied from elf32-mips.c. */
787 static asection m32r_elf_scom_section;
788 static asymbol m32r_elf_scom_symbol;
789 static asymbol *m32r_elf_scom_symbol_ptr;
791 /* Handle the special M32R section numbers that a symbol may use. */
793 void
794 _bfd_m32r_elf_symbol_processing (abfd, asym)
795 bfd *abfd ATTRIBUTE_UNUSED;
796 asymbol *asym;
798 elf_symbol_type *elfsym;
800 elfsym = (elf_symbol_type *) asym;
802 switch (elfsym->internal_elf_sym.st_shndx)
804 case SHN_M32R_SCOMMON:
805 if (m32r_elf_scom_section.name == NULL)
807 /* Initialize the small common section. */
808 m32r_elf_scom_section.name = ".scommon";
809 m32r_elf_scom_section.flags = SEC_IS_COMMON;
810 m32r_elf_scom_section.output_section = &m32r_elf_scom_section;
811 m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol;
812 m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr;
813 m32r_elf_scom_symbol.name = ".scommon";
814 m32r_elf_scom_symbol.flags = BSF_SECTION_SYM;
815 m32r_elf_scom_symbol.section = &m32r_elf_scom_section;
816 m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol;
818 asym->section = &m32r_elf_scom_section;
819 asym->value = elfsym->internal_elf_sym.st_size;
820 break;
824 /* Hook called by the linker routine which adds symbols from an object
825 file. We must handle the special M32R section numbers here.
826 We also keep watching for whether we need to create the sdata special
827 linker sections. */
829 static boolean
830 m32r_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
831 bfd *abfd;
832 struct bfd_link_info *info;
833 const Elf_Internal_Sym *sym;
834 const char **namep;
835 flagword *flagsp ATTRIBUTE_UNUSED;
836 asection **secp;
837 bfd_vma *valp;
839 if (! info->relocateable
840 && (*namep)[0] == '_' && (*namep)[1] == 'S'
841 && strcmp (*namep, "_SDA_BASE_") == 0
842 && info->hash->creator->flavour == bfd_target_elf_flavour)
844 /* This is simpler than using _bfd_elf_create_linker_section
845 (our needs are simpler than ppc's needs). Also
846 _bfd_elf_create_linker_section currently has a bug where if a .sdata
847 section already exists a new one is created that follows it which
848 screws of _SDA_BASE_ address calcs because output_offset != 0. */
849 struct elf_link_hash_entry *h;
850 struct bfd_link_hash_entry *bh;
851 asection *s = bfd_get_section_by_name (abfd, ".sdata");
853 /* The following code was cobbled from elf32-ppc.c and elflink.c. */
855 if (s == NULL)
857 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
858 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
860 s = bfd_make_section_anyway (abfd, ".sdata");
861 if (s == NULL)
862 return false;
863 bfd_set_section_flags (abfd, s, flags);
864 bfd_set_section_alignment (abfd, s, 2);
867 bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_",
868 false, false, false);
870 if ((bh == NULL || bh->type == bfd_link_hash_undefined)
871 && !(_bfd_generic_link_add_one_symbol (info,
872 abfd,
873 "_SDA_BASE_",
874 BSF_GLOBAL,
876 (bfd_vma) 32768,
877 (const char *) NULL,
878 false,
879 get_elf_backend_data (abfd)->collect,
880 &bh)))
881 return false;
882 h = (struct elf_link_hash_entry *) bh;
883 h->type = STT_OBJECT;
886 switch (sym->st_shndx)
888 case SHN_M32R_SCOMMON:
889 *secp = bfd_make_section_old_way (abfd, ".scommon");
890 (*secp)->flags |= SEC_IS_COMMON;
891 *valp = sym->st_size;
892 break;
895 return true;
898 /* We have to figure out the SDA_BASE value, so that we can adjust the
899 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
900 BFD. If we can't find it, we're stuck. We cache it in the ELF
901 target data. We don't need to adjust the symbol value for an
902 external symbol if we are producing relocateable output. */
904 static bfd_reloc_status_type
905 m32r_elf_final_sda_base (output_bfd, info, error_message, psb)
906 bfd *output_bfd;
907 struct bfd_link_info *info;
908 const char **error_message;
909 bfd_vma *psb;
911 if (elf_gp (output_bfd) == 0)
913 struct bfd_link_hash_entry *h;
915 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", false, false, true);
916 if (h != (struct bfd_link_hash_entry *) NULL
917 && h->type == bfd_link_hash_defined)
918 elf_gp (output_bfd) = (h->u.def.value
919 + h->u.def.section->output_section->vma
920 + h->u.def.section->output_offset);
921 else
923 /* Only get the error once. */
924 *psb = elf_gp (output_bfd) = 4;
925 *error_message =
926 (const char *) _("SDA relocation when _SDA_BASE_ not defined");
927 return bfd_reloc_dangerous;
930 *psb = elf_gp (output_bfd);
931 return bfd_reloc_ok;
934 /* Relocate an M32R/D ELF section.
935 There is some attempt to make this function usable for many architectures,
936 both for RELA and REL type relocs, if only to serve as a learning tool.
938 The RELOCATE_SECTION function is called by the new ELF backend linker
939 to handle the relocations for a section.
941 The relocs are always passed as Rela structures; if the section
942 actually uses Rel structures, the r_addend field will always be
943 zero.
945 This function is responsible for adjust the section contents as
946 necessary, and (if using Rela relocs and generating a
947 relocateable output file) adjusting the reloc addend as
948 necessary.
950 This function does not have to worry about setting the reloc
951 address or the reloc symbol index.
953 LOCAL_SYMS is a pointer to the swapped in local symbols.
955 LOCAL_SECTIONS is an array giving the section in the input file
956 corresponding to the st_shndx field of each local symbol.
958 The global hash table entry for the global symbols can be found
959 via elf_sym_hashes (input_bfd).
961 When generating relocateable output, this function must handle
962 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
963 going to be the section symbol corresponding to the output
964 section, which means that the addend must be adjusted
965 accordingly. */
967 static boolean
968 m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
969 contents, relocs, local_syms, local_sections)
970 bfd *output_bfd ATTRIBUTE_UNUSED;
971 struct bfd_link_info *info;
972 bfd *input_bfd;
973 asection *input_section;
974 bfd_byte *contents;
975 Elf_Internal_Rela *relocs;
976 Elf_Internal_Sym *local_syms;
977 asection **local_sections;
979 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
980 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
981 Elf_Internal_Rela *rel, *relend;
982 /* Assume success. */
983 boolean ret = true;
985 #ifndef USE_REL
986 if (info->relocateable)
987 return true;
988 #endif
990 rel = relocs;
991 relend = relocs + input_section->reloc_count;
992 for (; rel < relend; rel++)
994 int r_type;
995 reloc_howto_type *howto;
996 unsigned long r_symndx;
997 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
998 ensure it's zero (we use REL relocs, not RELA). Therefore this
999 should be assigning zero to `addend', but for clarity we use
1000 `r_addend'. */
1001 bfd_vma addend = rel->r_addend;
1002 bfd_vma offset = rel->r_offset;
1003 struct elf_link_hash_entry *h;
1004 Elf_Internal_Sym *sym;
1005 asection *sec;
1006 const char *sym_name;
1007 bfd_reloc_status_type r;
1008 const char *errmsg = NULL;
1010 h = NULL;
1011 r_type = ELF32_R_TYPE (rel->r_info);
1012 if (r_type < 0 || r_type >= (int) R_M32R_max)
1014 (*_bfd_error_handler) (_("%s: unknown relocation type %d"),
1015 bfd_archive_filename (input_bfd),
1016 (int) r_type);
1017 bfd_set_error (bfd_error_bad_value);
1018 ret = false;
1019 continue;
1022 if (r_type == R_M32R_GNU_VTENTRY
1023 || r_type == R_M32R_GNU_VTINHERIT)
1024 continue;
1026 howto = m32r_elf_howto_table + r_type;
1027 r_symndx = ELF32_R_SYM (rel->r_info);
1029 #ifdef USE_REL
1030 if (info->relocateable)
1032 /* This is a relocateable link. We don't have to change
1033 anything, unless the reloc is against a section symbol,
1034 in which case we have to adjust according to where the
1035 section symbol winds up in the output section. */
1036 sec = NULL;
1037 if (r_symndx >= symtab_hdr->sh_info)
1039 /* External symbol. */
1040 continue;
1043 /* Local symbol. */
1044 sym = local_syms + r_symndx;
1045 sym_name = "<local symbol>";
1046 /* STT_SECTION: symbol is associated with a section. */
1047 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
1049 /* Symbol isn't associated with a section. Nothing to do. */
1050 continue;
1053 sec = local_sections[r_symndx];
1054 addend += sec->output_offset + sym->st_value;
1056 /* If partial_inplace, we need to store any additional addend
1057 back in the section. */
1058 if (! howto->partial_inplace)
1059 continue;
1060 /* ??? Here is a nice place to call a special_function
1061 like handler. */
1062 if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
1063 r = _bfd_relocate_contents (howto, input_bfd,
1064 addend, contents + offset);
1065 else
1067 Elf_Internal_Rela *lorel;
1069 /* We allow an arbitrary number of HI16 relocs before the
1070 LO16 reloc. This permits gcc to emit the HI and LO relocs
1071 itself. */
1072 for (lorel = rel + 1;
1073 (lorel < relend
1074 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
1075 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
1076 lorel++)
1077 continue;
1078 if (lorel < relend
1079 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
1081 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
1082 contents, addend);
1083 r = bfd_reloc_ok;
1085 else
1086 r = _bfd_relocate_contents (howto, input_bfd,
1087 addend, contents + offset);
1090 else
1091 #endif /* USE_REL */
1093 bfd_vma relocation;
1095 /* This is a final link. */
1096 sym = NULL;
1097 sec = NULL;
1099 if (r_symndx < symtab_hdr->sh_info)
1101 /* Local symbol. */
1102 sym = local_syms + r_symndx;
1103 sec = local_sections[r_symndx];
1104 sym_name = "<local symbol>";
1105 #ifndef USE_REL
1106 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1107 addend = rel->r_addend;
1108 #else
1109 /* FIXME: This won't handle local relocations against SEC_MERGE
1110 symbols. See elf32-i386.c for how to do this. */
1111 relocation = (sec->output_section->vma
1112 + sec->output_offset
1113 + sym->st_value);
1114 #endif
1116 else
1118 /* External symbol. */
1119 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1120 while (h->root.type == bfd_link_hash_indirect
1121 || h->root.type == bfd_link_hash_warning)
1122 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1123 sym_name = h->root.root.string;
1125 if (h->root.type == bfd_link_hash_defined
1126 || h->root.type == bfd_link_hash_defweak)
1128 sec = h->root.u.def.section;
1129 if (sec->output_section == NULL)
1130 relocation = 0;
1131 else
1132 relocation = (h->root.u.def.value
1133 + sec->output_section->vma
1134 + sec->output_offset);
1136 else if (h->root.type == bfd_link_hash_undefweak)
1137 relocation = 0;
1138 else
1140 if (! ((*info->callbacks->undefined_symbol)
1141 (info, h->root.root.string, input_bfd,
1142 input_section, offset, true)))
1143 return false;
1144 relocation = 0;
1148 /* Sanity check the address. */
1149 if (offset > input_section->_raw_size)
1151 r = bfd_reloc_outofrange;
1152 goto check_reloc;
1155 switch ((int) r_type)
1157 case (int) R_M32R_10_PCREL :
1158 r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
1159 contents, offset,
1160 sec, relocation, addend);
1161 break;
1163 case (int) R_M32R_HI16_SLO :
1164 case (int) R_M32R_HI16_ULO :
1166 Elf_Internal_Rela *lorel;
1168 /* We allow an arbitrary number of HI16 relocs before the
1169 LO16 reloc. This permits gcc to emit the HI and LO relocs
1170 itself. */
1171 for (lorel = rel + 1;
1172 (lorel < relend
1173 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
1174 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
1175 lorel++)
1176 continue;
1177 if (lorel < relend
1178 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
1180 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
1181 contents, relocation + addend);
1182 r = bfd_reloc_ok;
1184 else
1185 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1186 contents, offset,
1187 relocation, addend);
1189 break;
1191 case (int) R_M32R_SDA16 :
1193 const char *name;
1195 BFD_ASSERT (sec != NULL);
1196 name = bfd_get_section_name (abfd, sec);
1198 if (strcmp (name, ".sdata") == 0
1199 || strcmp (name, ".sbss") == 0
1200 || strcmp (name, ".scommon") == 0)
1202 bfd_vma sda_base;
1203 bfd *out_bfd = sec->output_section->owner;
1205 r = m32r_elf_final_sda_base (out_bfd, info,
1206 &errmsg,
1207 &sda_base);
1208 if (r != bfd_reloc_ok)
1210 ret = false;
1211 goto check_reloc;
1214 /* At this point `relocation' contains the object's
1215 address. */
1216 relocation -= sda_base;
1217 /* Now it contains the offset from _SDA_BASE_. */
1219 else
1221 (*_bfd_error_handler)
1222 (_("%s: The target (%s) of an %s relocation is in the wrong section (%s)"),
1223 bfd_archive_filename (input_bfd),
1224 sym_name,
1225 m32r_elf_howto_table[(int) r_type].name,
1226 bfd_get_section_name (abfd, sec));
1227 /*bfd_set_error (bfd_error_bad_value); ??? why? */
1228 ret = false;
1229 continue;
1232 /* fall through */
1234 default :
1235 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1236 contents, offset,
1237 relocation, addend);
1238 break;
1242 check_reloc:
1244 if (r != bfd_reloc_ok)
1246 /* FIXME: This should be generic enough to go in a utility. */
1247 const char *name;
1249 if (h != NULL)
1250 name = h->root.root.string;
1251 else
1253 name = (bfd_elf_string_from_elf_section
1254 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1255 if (name == NULL || *name == '\0')
1256 name = bfd_section_name (input_bfd, sec);
1259 if (errmsg != NULL)
1260 goto common_error;
1262 switch (r)
1264 case bfd_reloc_overflow:
1265 if (! ((*info->callbacks->reloc_overflow)
1266 (info, name, howto->name, (bfd_vma) 0,
1267 input_bfd, input_section, offset)))
1268 return false;
1269 break;
1271 case bfd_reloc_undefined:
1272 if (! ((*info->callbacks->undefined_symbol)
1273 (info, name, input_bfd, input_section,
1274 offset, true)))
1275 return false;
1276 break;
1278 case bfd_reloc_outofrange:
1279 errmsg = _("internal error: out of range error");
1280 goto common_error;
1282 case bfd_reloc_notsupported:
1283 errmsg = _("internal error: unsupported relocation error");
1284 goto common_error;
1286 case bfd_reloc_dangerous:
1287 errmsg = _("internal error: dangerous error");
1288 goto common_error;
1290 default:
1291 errmsg = _("internal error: unknown error");
1292 /* fall through */
1294 common_error:
1295 if (!((*info->callbacks->warning)
1296 (info, errmsg, name, input_bfd, input_section,
1297 offset)))
1298 return false;
1299 break;
1304 return ret;
1307 #if 0 /* relaxing not supported yet */
1309 /* This function handles relaxing for the m32r.
1310 Relaxing on the m32r is tricky because of instruction alignment
1311 requirements (4 byte instructions must be aligned on 4 byte boundaries).
1313 The following relaxing opportunities are handled:
1315 seth/add3/jl -> bl24 or bl8
1316 seth/add3 -> ld24
1318 It would be nice to handle bl24 -> bl8 but given:
1320 - 4 byte insns must be on 4 byte boundaries
1321 - branch instructions only branch to insns on 4 byte boundaries
1323 this isn't much of a win because the insn in the 2 "deleted" bytes
1324 must become a nop. With some complexity some real relaxation could be
1325 done but the frequency just wouldn't make it worth it; it's better to
1326 try to do all the code compaction one can elsewhere.
1327 When the chip supports parallel 16 bit insns, things may change.
1330 static boolean
1331 m32r_elf_relax_section (abfd, sec, link_info, again)
1332 bfd *abfd;
1333 asection *sec;
1334 struct bfd_link_info *link_info;
1335 boolean *again;
1337 Elf_Internal_Shdr *symtab_hdr;
1338 /* The Rela structures are used here because that's what
1339 _bfd_elf32_link_read_relocs uses [for convenience - it sets the addend
1340 field to 0]. */
1341 Elf_Internal_Rela *internal_relocs = NULL;
1342 Elf_Internal_Rela *irel, *irelend;
1343 bfd_byte *contents = NULL;
1344 Elf_Internal_Sym *isymbuf = NULL;
1346 /* Assume nothing changes. */
1347 *again = false;
1349 /* We don't have to do anything for a relocateable link, if
1350 this section does not have relocs, or if this is not a
1351 code section. */
1352 if (link_info->relocateable
1353 || (sec->flags & SEC_RELOC) == 0
1354 || sec->reloc_count == 0
1355 || (sec->flags & SEC_CODE) == 0
1356 || 0 /* FIXME: check SHF_M32R_CAN_RELAX */)
1357 return true;
1359 /* If this is the first time we have been called for this section,
1360 initialize the cooked size. */
1361 if (sec->_cooked_size == 0)
1362 sec->_cooked_size = sec->_raw_size;
1364 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1366 /* Get a copy of the native relocations. */
1367 internal_relocs = (_bfd_elf32_link_read_relocs
1368 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1369 link_info->keep_memory));
1370 if (internal_relocs == NULL)
1371 goto error_return;
1373 /* Walk through them looking for relaxing opportunities. */
1374 irelend = internal_relocs + sec->reloc_count;
1375 for (irel = internal_relocs; irel < irelend; irel++)
1377 bfd_vma symval;
1379 /* If this isn't something that can be relaxed, then ignore
1380 this reloc. */
1381 if (ELF32_R_TYPE (irel->r_info) != (int) R_M32R_HI16_SLO)
1382 continue;
1384 /* Get the section contents if we haven't done so already. */
1385 if (contents == NULL)
1387 /* Get cached copy if it exists. */
1388 if (elf_section_data (sec)->this_hdr.contents != NULL)
1389 contents = elf_section_data (sec)->this_hdr.contents;
1390 else
1392 /* Go get them off disk. */
1393 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1394 if (contents == NULL)
1395 goto error_return;
1397 if (! bfd_get_section_contents (abfd, sec, contents,
1398 (file_ptr) 0, sec->_raw_size))
1399 goto error_return;
1403 /* Read this BFD's local symbols if we haven't done so already. */
1404 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1406 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1407 if (isymbuf == NULL)
1408 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1409 symtab_hdr->sh_info, 0,
1410 NULL, NULL, NULL);
1411 if (isymbuf == NULL)
1412 goto error_return;
1415 /* Get the value of the symbol referred to by the reloc. */
1416 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1418 /* A local symbol. */
1419 Elf_Internal_Sym *isym;
1420 asection *sym_sec;
1422 isym = isymbuf + ELF32_R_SYM (irel->r_info),
1423 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1424 symval = (isym->st_value
1425 + sym_sec->output_section->vma
1426 + sym_sec->output_offset);
1428 else
1430 unsigned long indx;
1431 struct elf_link_hash_entry *h;
1433 /* An external symbol. */
1434 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1435 h = elf_sym_hashes (abfd)[indx];
1436 BFD_ASSERT (h != NULL);
1437 if (h->root.type != bfd_link_hash_defined
1438 && h->root.type != bfd_link_hash_defweak)
1440 /* This appears to be a reference to an undefined
1441 symbol. Just ignore it--it will be caught by the
1442 regular reloc processing. */
1443 continue;
1446 symval = (h->root.u.def.value
1447 + h->root.u.def.section->output_section->vma
1448 + h->root.u.def.section->output_offset);
1451 /* For simplicity of coding, we are going to modify the section
1452 contents, the section relocs, and the BFD symbol table. We
1453 must tell the rest of the code not to free up this
1454 information. It would be possible to instead create a table
1455 of changes which have to be made, as is done in coff-mips.c;
1456 that would be more work, but would require less memory when
1457 the linker is run. */
1459 /* Try to change a seth/add3/jl subroutine call to bl24 or bl8.
1460 This sequence is generated by the compiler when compiling in
1461 32 bit mode. Also look for seth/add3 -> ld24. */
1463 if (ELF32_R_TYPE (irel->r_info) == (int) R_M32R_HI16_SLO)
1465 Elf_Internal_Rela *nrel;
1466 bfd_vma pc = (sec->output_section->vma + sec->output_offset
1467 + irel->r_offset);
1468 bfd_signed_vma pcrel_value = symval - pc;
1469 unsigned int code,reg;
1470 int addend,nop_p,bl8_p,to_delete;
1472 /* The tests are ordered so that we get out as quickly as possible
1473 if this isn't something we can relax, taking into account that
1474 we are looking for two separate possibilities (jl/ld24). */
1476 /* Do nothing if no room in the section for this to be what we're
1477 looking for. */
1478 if (irel->r_offset > sec->_cooked_size - 8)
1479 continue;
1481 /* Make sure the next relocation applies to the next
1482 instruction and that it's the add3's reloc. */
1483 nrel = irel + 1;
1484 if (nrel == irelend
1485 || irel->r_offset + 4 != nrel->r_offset
1486 || ELF32_R_TYPE (nrel->r_info) != (int) R_M32R_LO16)
1487 continue;
1489 /* See if the instructions are seth/add3. */
1490 /* FIXME: This is where macros from cgen can come in. */
1491 code = bfd_get_16 (abfd, contents + irel->r_offset + 0);
1492 if ((code & 0xf0ff) != 0xd0c0)
1493 continue; /* not seth rN,foo */
1494 reg = (code & 0x0f00) >> 8;
1495 code = bfd_get_16 (abfd, contents + irel->r_offset + 4);
1496 if (code != (0x80a0 | reg | (reg << 8)))
1497 continue; /* not add3 rN,rN,foo */
1499 /* At this point we've confirmed we have seth/add3. Now check
1500 whether the next insn is a jl, in which case try to change this
1501 to bl24 or bl8. */
1503 /* Ensure the branch target is in range.
1504 The bl24 instruction has a 24 bit operand which is the target
1505 address right shifted by 2, giving a signed range of 26 bits.
1506 Note that 4 bytes are added to the high value because the target
1507 will be at least 4 bytes closer if we can relax. It'll actually
1508 be 4 or 8 bytes closer, but we don't know which just yet and
1509 the difference isn't significant enough to worry about. */
1510 #ifndef USE_REL /* put in for learning purposes */
1511 pcrel_value += irel->r_addend;
1512 #else
1513 addend = bfd_get_signed_16 (abfd, contents + irel->r_offset + 2);
1514 pcrel_value += addend;
1515 #endif
1517 if (pcrel_value >= -(1 << 25) && pcrel_value < (1 << 25) + 4
1518 /* Do nothing if no room in the section for this to be what we're
1519 looking for. */
1520 && (irel->r_offset <= sec->_cooked_size - 12)
1521 /* Ensure the next insn is "jl rN". */
1522 && ((code = bfd_get_16 (abfd, contents + irel->r_offset + 8)),
1523 code != (0x1ec0 | reg)))
1525 /* We can relax to bl24/bl8. */
1527 /* See if there's a nop following the jl.
1528 Also see if we can use a bl8 insn. */
1529 code = bfd_get_16 (abfd, contents + irel->r_offset + 10);
1530 nop_p = (code & 0x7fff) == NOP_INSN;
1531 bl8_p = pcrel_value >= -0x200 && pcrel_value < 0x200;
1533 if (bl8_p)
1535 /* Change "seth rN,foo" to "bl8 foo || nop".
1536 We OR in CODE just in case it's not a nop (technically,
1537 CODE currently must be a nop, but for cleanness we
1538 allow it to be anything). */
1539 #ifndef USE_REL /* put in for learning purposes */
1540 code = 0x7e000000 | MAKE_PARALLEL (code);
1541 #else
1542 code = (0x7e000000 + (((addend >> 2) & 0xff) << 16)) | MAKE_PARALLEL (code);
1543 #endif
1544 to_delete = 8;
1546 else
1548 /* Change the seth rN,foo to a bl24 foo. */
1549 #ifndef USE_REL /* put in for learning purposes */
1550 code = 0xfe000000;
1551 #else
1552 code = 0xfe000000 + ((addend >> 2) & 0xffffff);
1553 #endif
1554 to_delete = nop_p ? 8 : 4;
1557 bfd_put_32 (abfd, code, contents + irel->r_offset);
1559 /* Set the new reloc type. */
1560 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1561 bl8_p ? R_M32R_10_PCREL : R_M32R_26_PCREL);
1563 /* Delete the add3 reloc by making it a null reloc. */
1564 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1565 R_M32R_NONE);
1567 else if (addend >= 0
1568 && symval + addend <= 0xffffff)
1570 /* We can relax to ld24. */
1572 code = 0xe0000000 | (reg << 24) | (addend & 0xffffff);
1573 bfd_put_32 (abfd, code, contents + irel->r_offset);
1574 to_delete = 4;
1575 /* Tell the following code a nop filler isn't needed. */
1576 nop_p = 1;
1578 else
1580 /* Can't do anything here. */
1581 continue;
1584 /* Note that we've changed the relocs, section contents, etc. */
1585 elf_section_data (sec)->relocs = internal_relocs;
1586 elf_section_data (sec)->this_hdr.contents = contents;
1587 symtab_hdr->contents = (unsigned char *) isymbuf;
1589 /* Delete TO_DELETE bytes of data. */
1590 if (!m32r_elf_relax_delete_bytes (abfd, sec,
1591 irel->r_offset + 4, to_delete))
1592 goto error_return;
1594 /* Now that the following bytes have been moved into place, see if
1595 we need to replace the jl with a nop. This happens when we had
1596 to use a bl24 insn and the insn following the jl isn't a nop.
1597 Technically, this situation can't happen (since the insn can
1598 never be executed) but to be clean we do this. When the chip
1599 supports parallel 16 bit insns things may change.
1600 We don't need to do this in the case of relaxing to ld24,
1601 and the above code sets nop_p so this isn't done. */
1602 if (! nop_p && to_delete == 4)
1603 bfd_put_16 (abfd, NOP_INSN, contents + irel->r_offset + 4);
1605 /* That will change things, so we should relax again.
1606 Note that this is not required, and it may be slow. */
1607 *again = true;
1609 continue;
1612 /* loop to try the next reloc */
1615 if (isymbuf != NULL
1616 && symtab_hdr->contents != (unsigned char *) isymbuf)
1618 if (! link_info->keep_memory)
1619 free (isymbuf);
1620 else
1622 /* Cache the symbols for elf_link_input_bfd. */
1623 symtab_hdr->contents = (unsigned char *) isymbuf;
1627 if (contents != NULL
1628 && elf_section_data (sec)->this_hdr.contents != contents)
1630 if (! link_info->keep_memory)
1631 free (contents);
1632 else
1634 /* Cache the section contents for elf_link_input_bfd. */
1635 elf_section_data (sec)->this_hdr.contents = contents;
1639 if (internal_relocs != NULL
1640 && elf_section_data (sec)->relocs != internal_relocs)
1641 free (internal_relocs);
1643 return true;
1645 error_return:
1646 if (isymbuf != NULL
1647 && symtab_hdr->contents != (unsigned char *) isymbuf)
1648 free (isymbuf);
1649 if (contents != NULL
1650 && elf_section_data (sec)->this_hdr.contents != contents)
1651 free (contents);
1652 if (internal_relocs != NULL
1653 && elf_section_data (sec)->relocs != internal_relocs)
1654 free (internal_relocs);
1656 return false;
1659 /* Delete some bytes from a section while relaxing. */
1661 static boolean
1662 m32r_elf_relax_delete_bytes (abfd, sec, addr, count)
1663 bfd *abfd;
1664 asection *sec;
1665 bfd_vma addr;
1666 int count;
1668 Elf_Internal_Shdr *symtab_hdr;
1669 int shndx;
1670 bfd_byte *contents;
1671 Elf_Internal_Rela *irel, *irelend;
1672 Elf_Internal_Rela *irelalign;
1673 bfd_vma toaddr;
1674 Elf_Internal_Sym *isym, *isymend;
1675 struct elf_link_hash_entry **sym_hashes;
1676 struct elf_link_hash_entry **end_hashes;
1677 unsigned int symcount;
1679 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1681 contents = elf_section_data (sec)->this_hdr.contents;
1683 /* The deletion must stop at the next ALIGN reloc for an aligment
1684 power larger than the number of bytes we are deleting. */
1686 irelalign = NULL;
1687 toaddr = sec->_cooked_size;
1689 irel = elf_section_data (sec)->relocs;
1690 irelend = irel + sec->reloc_count;
1692 /* Actually delete the bytes. */
1693 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1694 sec->_cooked_size -= count;
1696 /* Adjust all the relocs. */
1697 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1699 /* Get the new reloc address. */
1700 if ((irel->r_offset > addr
1701 && irel->r_offset < toaddr))
1702 irel->r_offset -= count;
1705 /* Adjust the local symbols defined in this section. */
1706 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1707 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1708 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1710 if (isym->st_shndx == shndx
1711 && isym->st_value > addr
1712 && isym->st_value < toaddr)
1713 isym->st_value -= count;
1716 /* Now adjust the global symbols defined in this section. */
1717 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1718 - symtab_hdr->sh_info);
1719 sym_hashes = elf_sym_hashes (abfd);
1720 end_hashes = sym_hashes + symcount;
1721 for (; sym_hashes < end_hashes; sym_hashes++)
1723 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1725 if ((sym_hash->root.type == bfd_link_hash_defined
1726 || sym_hash->root.type == bfd_link_hash_defweak)
1727 && sym_hash->root.u.def.section == sec
1728 && sym_hash->root.u.def.value > addr
1729 && sym_hash->root.u.def.value < toaddr)
1731 sym_hash->root.u.def.value -= count;
1735 return true;
1738 /* This is a version of bfd_generic_get_relocated_section_contents
1739 which uses m32r_elf_relocate_section. */
1741 static bfd_byte *
1742 m32r_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1743 data, relocateable, symbols)
1744 bfd *output_bfd;
1745 struct bfd_link_info *link_info;
1746 struct bfd_link_order *link_order;
1747 bfd_byte *data;
1748 boolean relocateable;
1749 asymbol **symbols;
1751 Elf_Internal_Shdr *symtab_hdr;
1752 asection *input_section = link_order->u.indirect.section;
1753 bfd *input_bfd = input_section->owner;
1754 asection **sections = NULL;
1755 Elf_Internal_Rela *internal_relocs = NULL;
1756 Elf_Internal_Sym *isymbuf = NULL;
1757 bfd_size_type amt;
1759 /* We only need to handle the case of relaxing, or of having a
1760 particular set of section contents, specially. */
1761 if (relocateable
1762 || elf_section_data (input_section)->this_hdr.contents == NULL)
1763 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1764 link_order, data,
1765 relocateable,
1766 symbols);
1768 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1770 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1771 input_section->_raw_size);
1773 if ((input_section->flags & SEC_RELOC) != 0
1774 && input_section->reloc_count > 0)
1776 Elf_Internal_Sym *isymp;
1777 asection **secpp;
1778 Elf32_External_Sym *esym, *esymend;
1780 internal_relocs = (_bfd_elf32_link_read_relocs
1781 (input_bfd, input_section, (PTR) NULL,
1782 (Elf_Internal_Rela *) NULL, false));
1783 if (internal_relocs == NULL)
1784 goto error_return;
1786 if (symtab_hdr->sh_info != 0)
1788 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1789 if (isymbuf == NULL)
1790 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1791 symtab_hdr->sh_info, 0,
1792 NULL, NULL, NULL);
1793 if (isymbuf == NULL)
1794 goto error_return;
1797 amt = symtab_hdr->sh_info;
1798 amt *= sizeof (asection *);
1799 sections = (asection **) bfd_malloc (amt);
1800 if (sections == NULL && symtab_hdr->sh_info > 0)
1801 goto error_return;
1803 isymend = isymbuf + symtab_hdr->sh_info;
1804 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1806 asection *isec;
1808 if (isym->st_shndx == SHN_UNDEF)
1809 isec = bfd_und_section_ptr;
1810 else if (isym->st_shndx == SHN_ABS)
1811 isec = bfd_abs_section_ptr;
1812 else if (isym->st_shndx == SHN_COMMON)
1813 isec = bfd_com_section_ptr;
1814 else if (isym->st_shndx == SHN_M32R_SCOMMON)
1815 isec = &m32r_elf_scom_section;
1816 else
1817 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1819 *secpp = isec;
1822 if (! m32r_elf_relocate_section (output_bfd, link_info, input_bfd,
1823 input_section, data, internal_relocs,
1824 isymbuf, sections))
1825 goto error_return;
1827 if (sections != NULL)
1828 free (sections);
1829 if (isymbuf != NULL
1830 && symtab_hdr->contents != (unsigned char *) isymbuf)
1831 free (isymbuf);
1832 if (elf_section_data (input_section)->relocs != internal_relocs)
1833 free (internal_relocs);
1836 return data;
1838 error_return:
1839 if (sections != NULL)
1840 free (sections);
1841 if (isymbuf != NULL
1842 && symtab_hdr->contents != (unsigned char *) isymbuf)
1843 free (isymbuf);
1844 if (internal_relocs != NULL
1845 && elf_section_data (input_section)->relocs != internal_relocs)
1846 free (internal_relocs);
1847 return NULL;
1850 #endif /* #if 0 */
1852 /* Set the right machine number. */
1853 static boolean
1854 m32r_elf_object_p (abfd)
1855 bfd *abfd;
1857 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
1859 default:
1860 case E_M32R_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r); break;
1861 case E_M32RX_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
1863 return true;
1866 /* Store the machine number in the flags field. */
1867 static void
1868 m32r_elf_final_write_processing (abfd, linker)
1869 bfd * abfd;
1870 boolean linker ATTRIBUTE_UNUSED;
1872 unsigned long val;
1874 switch (bfd_get_mach (abfd))
1876 default:
1877 case bfd_mach_m32r: val = E_M32R_ARCH; break;
1878 case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
1881 elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
1882 elf_elfheader (abfd)->e_flags |= val;
1885 /* Function to keep M32R specific file flags. */
1886 static boolean
1887 m32r_elf_set_private_flags (abfd, flags)
1888 bfd * abfd;
1889 flagword flags;
1891 BFD_ASSERT (!elf_flags_init (abfd)
1892 || elf_elfheader (abfd)->e_flags == flags);
1894 elf_elfheader (abfd)->e_flags = flags;
1895 elf_flags_init (abfd) = true;
1896 return true;
1899 /* Merge backend specific data from an object file to the output
1900 object file when linking. */
1901 static boolean
1902 m32r_elf_merge_private_bfd_data (ibfd, obfd)
1903 bfd * ibfd;
1904 bfd * obfd;
1906 flagword out_flags;
1907 flagword in_flags;
1909 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1910 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1911 return true;
1913 in_flags = elf_elfheader (ibfd)->e_flags;
1914 out_flags = elf_elfheader (obfd)->e_flags;
1916 if (! elf_flags_init (obfd))
1918 /* If the input is the default architecture then do not
1919 bother setting the flags for the output architecture,
1920 instead allow future merges to do this. If no future
1921 merges ever set these flags then they will retain their
1922 unitialised values, which surprise surprise, correspond
1923 to the default values. */
1924 if (bfd_get_arch_info (ibfd)->the_default)
1925 return true;
1927 elf_flags_init (obfd) = true;
1928 elf_elfheader (obfd)->e_flags = in_flags;
1930 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1931 && bfd_get_arch_info (obfd)->the_default)
1933 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1936 return true;
1939 /* Check flag compatibility. */
1940 if (in_flags == out_flags)
1941 return true;
1943 if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
1945 if ((in_flags & EF_M32R_ARCH) != E_M32R_ARCH)
1947 (*_bfd_error_handler)
1948 (_("%s: Instruction set mismatch with previous modules"),
1949 bfd_archive_filename (ibfd));
1951 bfd_set_error (bfd_error_bad_value);
1952 return false;
1956 return true;
1959 /* Display the flags field */
1960 static boolean
1961 m32r_elf_print_private_bfd_data (abfd, ptr)
1962 bfd * abfd;
1963 PTR ptr;
1965 FILE * file = (FILE *) ptr;
1967 BFD_ASSERT (abfd != NULL && ptr != NULL)
1969 _bfd_elf_print_private_bfd_data (abfd, ptr);
1971 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
1973 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
1975 default:
1976 case E_M32R_ARCH: fprintf (file, _(": m32r instructions")); break;
1977 case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
1980 fputc ('\n', file);
1982 return true;
1985 asection *
1986 m32r_elf_gc_mark_hook (sec, info, rel, h, sym)
1987 asection *sec;
1988 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1989 Elf_Internal_Rela *rel;
1990 struct elf_link_hash_entry *h;
1991 Elf_Internal_Sym *sym;
1993 if (h != NULL)
1995 switch (ELF32_R_TYPE (rel->r_info))
1997 case R_M32R_GNU_VTINHERIT:
1998 case R_M32R_GNU_VTENTRY:
1999 break;
2001 default:
2002 switch (h->root.type)
2004 case bfd_link_hash_defined:
2005 case bfd_link_hash_defweak:
2006 return h->root.u.def.section;
2008 case bfd_link_hash_common:
2009 return h->root.u.c.p->section;
2011 default:
2012 break;
2016 else
2017 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
2019 return NULL;
2022 static boolean
2023 m32r_elf_gc_sweep_hook (abfd, info, sec, relocs)
2024 bfd *abfd ATTRIBUTE_UNUSED;
2025 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2026 asection *sec ATTRIBUTE_UNUSED;
2027 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2029 /* we don't use got and plt entries for m32r */
2030 return true;
2033 /* Look through the relocs for a section during the first phase.
2034 Since we don't do .gots or .plts, we just need to consider the
2035 virtual table relocs for gc. */
2037 static boolean
2038 m32r_elf_check_relocs (abfd, info, sec, relocs)
2039 bfd *abfd;
2040 struct bfd_link_info *info;
2041 asection *sec;
2042 const Elf_Internal_Rela *relocs;
2044 Elf_Internal_Shdr *symtab_hdr;
2045 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2046 const Elf_Internal_Rela *rel;
2047 const Elf_Internal_Rela *rel_end;
2049 if (info->relocateable)
2050 return true;
2052 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2053 sym_hashes = elf_sym_hashes (abfd);
2054 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2055 if (!elf_bad_symtab (abfd))
2056 sym_hashes_end -= symtab_hdr->sh_info;
2058 rel_end = relocs + sec->reloc_count;
2059 for (rel = relocs; rel < rel_end; rel++)
2061 struct elf_link_hash_entry *h;
2062 unsigned long r_symndx;
2064 r_symndx = ELF32_R_SYM (rel->r_info);
2065 if (r_symndx < symtab_hdr->sh_info)
2066 h = NULL;
2067 else
2068 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2070 switch (ELF32_R_TYPE (rel->r_info))
2072 /* This relocation describes the C++ object vtable hierarchy.
2073 Reconstruct it for later use during GC. */
2074 case R_M32R_GNU_VTINHERIT:
2075 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2076 return false;
2077 break;
2079 /* This relocation describes which C++ vtable entries are actually
2080 used. Record for later use during GC. */
2081 case R_M32R_GNU_VTENTRY:
2082 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2083 return false;
2084 break;
2088 return true;
2091 #define ELF_ARCH bfd_arch_m32r
2092 #define ELF_MACHINE_CODE EM_M32R
2093 #define ELF_MACHINE_ALT1 EM_CYGNUS_M32R
2094 #define ELF_MAXPAGESIZE 0x1 /* Explicitly requested by Mitsubishi. */
2096 #define TARGET_BIG_SYM bfd_elf32_m32r_vec
2097 #define TARGET_BIG_NAME "elf32-m32r"
2099 #define elf_info_to_howto 0
2100 #define elf_info_to_howto_rel m32r_info_to_howto_rel
2101 #define elf_backend_section_from_bfd_section _bfd_m32r_elf_section_from_bfd_section
2102 #define elf_backend_symbol_processing _bfd_m32r_elf_symbol_processing
2103 #define elf_backend_add_symbol_hook m32r_elf_add_symbol_hook
2104 #define elf_backend_relocate_section m32r_elf_relocate_section
2105 #define elf_backend_gc_mark_hook m32r_elf_gc_mark_hook
2106 #define elf_backend_gc_sweep_hook m32r_elf_gc_sweep_hook
2107 #define elf_backend_check_relocs m32r_elf_check_relocs
2109 #define elf_backend_can_gc_sections 1
2110 #ifndef USE_REL
2111 #define elf_backend_rela_normal 1
2112 #endif
2113 #if 0 /* not yet */
2114 /* relax support */
2115 #define bfd_elf32_bfd_relax_section m32r_elf_relax_section
2116 #define bfd_elf32_bfd_get_relocated_section_contents \
2117 m32r_elf_get_relocated_section_contents
2118 #endif
2120 #define elf_backend_object_p m32r_elf_object_p
2121 #define elf_backend_final_write_processing m32r_elf_final_write_processing
2122 #define bfd_elf32_bfd_merge_private_bfd_data m32r_elf_merge_private_bfd_data
2123 #define bfd_elf32_bfd_set_private_flags m32r_elf_set_private_flags
2124 #define bfd_elf32_bfd_print_private_bfd_data m32r_elf_print_private_bfd_data
2126 #include "elf32-target.h"