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