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