projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gdb: defer commit resume until all available events are consumed
[deliverable/binutils-gdb.git] / bfd / elf32-ppc.c
1 /* PowerPC-specific support for 32-bit ELF
2 Copyright (C) 1994-2020 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the
19 Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22
23 /* This file is based on a preliminary PowerPC ELF ABI. The
24 information may not match the final PowerPC ELF ABI. It includes
25 suggestions from the in-progress Embedded PowerPC ABI, and that
26 information may also not match. */
27
28 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc.h"
35 #include "elf32-ppc.h"
36 #include "elf-vxworks.h"
37 #include "dwarf2.h"
38 #include "opcode/ppc.h"
39
40 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
41 #define OCTETS_PER_BYTE(ABFD, SEC) 1
42
43 typedef enum split16_format_type
44 {
45 split16a_type = 0,
46 split16d_type
47 }
48 split16_format_type;
49
50 /* RELA relocations are used here. */
51
52 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56
57 /* Branch prediction bit for branch taken relocs. */
58 #define BRANCH_PREDICT_BIT 0x200000
59 /* Mask to set RA in memory instructions. */
60 #define RA_REGISTER_MASK 0x001f0000
61 /* Value to shift register by to insert RA. */
62 #define RA_REGISTER_SHIFT 16
63
64 /* The name of the dynamic interpreter. This is put in the .interp
65 section. */
66 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
67
68 /* For old-style PLT. */
69 /* The number of single-slot PLT entries (the rest use two slots). */
70 #define PLT_NUM_SINGLE_ENTRIES 8192
71
72 /* For new-style .glink and .plt. */
73 #define GLINK_PLTRESOLVE 16*4
74 #define GLINK_ENTRY_SIZE(htab, h) \
75 ((4*4 \
76 + (h != NULL \
77 && h == htab->tls_get_addr \
78 && !htab->params->no_tls_get_addr_opt ? 8*4 : 0) \
79 + (1u << htab->params->plt_stub_align) - 1) \
80 & -(1u << htab->params->plt_stub_align))
81
82 /* VxWorks uses its own plt layout, filled in by the static linker. */
83
84 /* The standard VxWorks PLT entry. */
85 #define VXWORKS_PLT_ENTRY_SIZE 32
86 static const bfd_vma ppc_elf_vxworks_plt_entry
87 [VXWORKS_PLT_ENTRY_SIZE / 4] =
88 {
89 0x3d800000, /* lis r12,0 */
90 0x818c0000, /* lwz r12,0(r12) */
91 0x7d8903a6, /* mtctr r12 */
92 0x4e800420, /* bctr */
93 0x39600000, /* li r11,0 */
94 0x48000000, /* b 14 <.PLT0resolve+0x4> */
95 0x60000000, /* nop */
96 0x60000000, /* nop */
97 };
98 static const bfd_vma ppc_elf_vxworks_pic_plt_entry
99 [VXWORKS_PLT_ENTRY_SIZE / 4] =
100 {
101 0x3d9e0000, /* addis r12,r30,0 */
102 0x818c0000, /* lwz r12,0(r12) */
103 0x7d8903a6, /* mtctr r12 */
104 0x4e800420, /* bctr */
105 0x39600000, /* li r11,0 */
106 0x48000000, /* b 14 <.PLT0resolve+0x4> 14: R_PPC_REL24 .PLTresolve */
107 0x60000000, /* nop */
108 0x60000000, /* nop */
109 };
110
111 /* The initial VxWorks PLT entry. */
112 #define VXWORKS_PLT_INITIAL_ENTRY_SIZE 32
113 static const bfd_vma ppc_elf_vxworks_plt0_entry
114 [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] =
115 {
116 0x3d800000, /* lis r12,0 */
117 0x398c0000, /* addi r12,r12,0 */
118 0x800c0008, /* lwz r0,8(r12) */
119 0x7c0903a6, /* mtctr r0 */
120 0x818c0004, /* lwz r12,4(r12) */
121 0x4e800420, /* bctr */
122 0x60000000, /* nop */
123 0x60000000, /* nop */
124 };
125 static const bfd_vma ppc_elf_vxworks_pic_plt0_entry
126 [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] =
127 {
128 0x819e0008, /* lwz r12,8(r30) */
129 0x7d8903a6, /* mtctr r12 */
130 0x819e0004, /* lwz r12,4(r30) */
131 0x4e800420, /* bctr */
132 0x60000000, /* nop */
133 0x60000000, /* nop */
134 0x60000000, /* nop */
135 0x60000000, /* nop */
136 };
137
138 /* For executables, we have some additional relocations in
139 .rela.plt.unloaded, for the kernel loader. */
140
141 /* The number of non-JMP_SLOT relocations per PLT0 slot. */
142 #define VXWORKS_PLT_NON_JMP_SLOT_RELOCS 3
143 /* The number of relocations in the PLTResolve slot. */
144 #define VXWORKS_PLTRESOLVE_RELOCS 2
145 /* The number of relocations in the PLTResolve slot when creating
146 a shared library. */
147 #define VXWORKS_PLTRESOLVE_RELOCS_SHLIB 0
148
149 /* Some instructions. */
150 #define ADDIS_11_11 0x3d6b0000
151 #define ADDIS_11_30 0x3d7e0000
152 #define ADDIS_12_12 0x3d8c0000
153 #define ADDI_11_11 0x396b0000
154 #define ADD_0_11_11 0x7c0b5a14
155 #define ADD_3_12_2 0x7c6c1214
156 #define ADD_11_0_11 0x7d605a14
157 #define B 0x48000000
158 #define BA 0x48000002
159 #define BCL_20_31 0x429f0005
160 #define BCTR 0x4e800420
161 #define BEQLR 0x4d820020
162 #define CMPWI_11_0 0x2c0b0000
163 #define LIS_11 0x3d600000
164 #define LIS_12 0x3d800000
165 #define LWZU_0_12 0x840c0000
166 #define LWZ_0_12 0x800c0000
167 #define LWZ_11_3 0x81630000
168 #define LWZ_11_11 0x816b0000
169 #define LWZ_11_30 0x817e0000
170 #define LWZ_12_3 0x81830000
171 #define LWZ_12_12 0x818c0000
172 #define MR_0_3 0x7c601b78
173 #define MR_3_0 0x7c030378
174 #define MFLR_0 0x7c0802a6
175 #define MFLR_12 0x7d8802a6
176 #define MTCTR_0 0x7c0903a6
177 #define MTCTR_11 0x7d6903a6
178 #define MTLR_0 0x7c0803a6
179 #define NOP 0x60000000
180 #define SUB_11_11_12 0x7d6c5850
181
182 /* Offset of tp and dtp pointers from start of TLS block. */
183 #define TP_OFFSET 0x7000
184 #define DTP_OFFSET 0x8000
185
186 /* The value of a defined global symbol. */
187 #define SYM_VAL(SYM) \
188 ((SYM)->root.u.def.section->output_section->vma \
189 + (SYM)->root.u.def.section->output_offset \
190 + (SYM)->root.u.def.value)
191 \f
192 /* Relocation HOWTO's. */
193 /* Like other ELF RELA targets that don't apply multiple
194 field-altering relocations to the same localation, src_mask is
195 always zero and pcrel_offset is the same as pc_relative.
196 PowerPC can always use a zero bitpos, even when the field is not at
197 the LSB. For example, a REL24 could use rightshift=2, bisize=24
198 and bitpos=2 which matches the ABI description, or as we do here,
199 rightshift=0, bitsize=26 and bitpos=0. */
200 #define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
201 complain, special_func) \
202 HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
203 complain_overflow_ ## complain, special_func, \
204 #type, FALSE, 0, mask, pc_relative)
205
206 static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
207
208 static reloc_howto_type ppc_elf_howto_raw[] = {
209 /* This reloc does nothing. */
210 HOW (R_PPC_NONE, 3, 0, 0, 0, FALSE, dont,
211 bfd_elf_generic_reloc),
212
213 /* A standard 32 bit relocation. */
214 HOW (R_PPC_ADDR32, 2, 32, 0xffffffff, 0, FALSE, dont,
215 bfd_elf_generic_reloc),
216
217 /* An absolute 26 bit branch; the lower two bits must be zero.
218 FIXME: we don't check that, we just clear them. */
219 HOW (R_PPC_ADDR24, 2, 26, 0x3fffffc, 0, FALSE, signed,
220 bfd_elf_generic_reloc),
221
222 /* A standard 16 bit relocation. */
223 HOW (R_PPC_ADDR16, 1, 16, 0xffff, 0, FALSE, bitfield,
224 bfd_elf_generic_reloc),
225
226 /* A 16 bit relocation without overflow. */
227 HOW (R_PPC_ADDR16_LO, 1, 16, 0xffff, 0, FALSE, dont,
228 bfd_elf_generic_reloc),
229
230 /* The high order 16 bits of an address. */
231 HOW (R_PPC_ADDR16_HI, 1, 16, 0xffff, 16, FALSE, dont,
232 bfd_elf_generic_reloc),
233
234 /* The high order 16 bits of an address, plus 1 if the contents of
235 the low 16 bits, treated as a signed number, is negative. */
236 HOW (R_PPC_ADDR16_HA, 1, 16, 0xffff, 16, FALSE, dont,
237 ppc_elf_addr16_ha_reloc),
238
239 /* An absolute 16 bit branch; the lower two bits must be zero.
240 FIXME: we don't check that, we just clear them. */
241 HOW (R_PPC_ADDR14, 2, 16, 0xfffc, 0, FALSE, signed,
242 bfd_elf_generic_reloc),
243
244 /* An absolute 16 bit branch, for which bit 10 should be set to
245 indicate that the branch is expected to be taken. The lower two
246 bits must be zero. */
247 HOW (R_PPC_ADDR14_BRTAKEN, 2, 16, 0xfffc, 0, FALSE, signed,
248 bfd_elf_generic_reloc),
249
250 /* An absolute 16 bit branch, for which bit 10 should be set to
251 indicate that the branch is not expected to be taken. The lower
252 two bits must be zero. */
253 HOW (R_PPC_ADDR14_BRNTAKEN, 2, 16, 0xfffc, 0, FALSE, signed,
254 bfd_elf_generic_reloc),
255
256 /* A relative 26 bit branch; the lower two bits must be zero. */
257 HOW (R_PPC_REL24, 2, 26, 0x3fffffc, 0, TRUE, signed,
258 bfd_elf_generic_reloc),
259
260 /* A relative 16 bit branch; the lower two bits must be zero. */
261 HOW (R_PPC_REL14, 2, 16, 0xfffc, 0, TRUE, signed,
262 bfd_elf_generic_reloc),
263
264 /* A relative 16 bit branch. Bit 10 should be set to indicate that
265 the branch is expected to be taken. The lower two bits must be
266 zero. */
267 HOW (R_PPC_REL14_BRTAKEN, 2, 16, 0xfffc, 0, TRUE, signed,
268 bfd_elf_generic_reloc),
269
270 /* A relative 16 bit branch. Bit 10 should be set to indicate that
271 the branch is not expected to be taken. The lower two bits must
272 be zero. */
273 HOW (R_PPC_REL14_BRNTAKEN, 2, 16, 0xfffc, 0, TRUE, signed,
274 bfd_elf_generic_reloc),
275
276 /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
277 symbol. */
278 HOW (R_PPC_GOT16, 1, 16, 0xffff, 0, FALSE, signed,
279 ppc_elf_unhandled_reloc),
280
281 /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
282 the symbol. */
283 HOW (R_PPC_GOT16_LO, 1, 16, 0xffff, 0, FALSE, dont,
284 ppc_elf_unhandled_reloc),
285
286 /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
287 the symbol. */
288 HOW (R_PPC_GOT16_HI, 1, 16, 0xffff, 16, FALSE, dont,
289 ppc_elf_unhandled_reloc),
290
291 /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
292 the symbol. */
293 HOW (R_PPC_GOT16_HA, 1, 16, 0xffff, 16, FALSE, dont,
294 ppc_elf_unhandled_reloc),
295
296 /* Like R_PPC_REL24, but referring to the procedure linkage table
297 entry for the symbol. */
298 HOW (R_PPC_PLTREL24, 2, 26, 0x3fffffc, 0, TRUE, signed,
299 ppc_elf_unhandled_reloc),
300
301 /* This is used only by the dynamic linker. The symbol should exist
302 both in the object being run and in some shared library. The
303 dynamic linker copies the data addressed by the symbol from the
304 shared library into the object, because the object being
305 run has to have the data at some particular address. */
306 HOW (R_PPC_COPY, 2, 32, 0, 0, FALSE, dont,
307 ppc_elf_unhandled_reloc),
308
309 /* Like R_PPC_ADDR32, but used when setting global offset table
310 entries. */
311 HOW (R_PPC_GLOB_DAT, 2, 32, 0xffffffff, 0, FALSE, dont,
312 ppc_elf_unhandled_reloc),
313
314 /* Marks a procedure linkage table entry for a symbol. */
315 HOW (R_PPC_JMP_SLOT, 2, 32, 0, 0, FALSE, dont,
316 ppc_elf_unhandled_reloc),
317
318 /* Used only by the dynamic linker. When the object is run, this
319 longword is set to the load address of the object, plus the
320 addend. */
321 HOW (R_PPC_RELATIVE, 2, 32, 0xffffffff, 0, FALSE, dont,
322 bfd_elf_generic_reloc),
323
324 /* Like R_PPC_REL24, but uses the value of the symbol within the
325 object rather than the final value. Normally used for
326 _GLOBAL_OFFSET_TABLE_. */
327 HOW (R_PPC_LOCAL24PC, 2, 26, 0x3fffffc, 0, TRUE, signed,
328 bfd_elf_generic_reloc),
329
330 /* Like R_PPC_ADDR32, but may be unaligned. */
331 HOW (R_PPC_UADDR32, 2, 32, 0xffffffff, 0, FALSE, dont,
332 bfd_elf_generic_reloc),
333
334 /* Like R_PPC_ADDR16, but may be unaligned. */
335 HOW (R_PPC_UADDR16, 1, 16, 0xffff, 0, FALSE, bitfield,
336 bfd_elf_generic_reloc),
337
338 /* 32-bit PC relative */
339 HOW (R_PPC_REL32, 2, 32, 0xffffffff, 0, TRUE, dont,
340 bfd_elf_generic_reloc),
341
342 /* 32-bit relocation to the symbol's procedure linkage table.
343 FIXME: not supported. */
344 HOW (R_PPC_PLT32, 2, 32, 0, 0, FALSE, dont,
345 ppc_elf_unhandled_reloc),
346
347 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
348 FIXME: not supported. */
349 HOW (R_PPC_PLTREL32, 2, 32, 0, 0, TRUE, dont,
350 ppc_elf_unhandled_reloc),
351
352 /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
353 the symbol. */
354 HOW (R_PPC_PLT16_LO, 1, 16, 0xffff, 0, FALSE, dont,
355 ppc_elf_unhandled_reloc),
356
357 /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
358 the symbol. */
359 HOW (R_PPC_PLT16_HI, 1, 16, 0xffff, 16, FALSE, dont,
360 ppc_elf_unhandled_reloc),
361
362 /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
363 the symbol. */
364 HOW (R_PPC_PLT16_HA, 1, 16, 0xffff, 16, FALSE, dont,
365 ppc_elf_unhandled_reloc),
366
367 /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
368 small data items. */
369 HOW (R_PPC_SDAREL16, 1, 16, 0xffff, 0, FALSE, signed,
370 ppc_elf_unhandled_reloc),
371
372 /* 16-bit section relative relocation. */
373 HOW (R_PPC_SECTOFF, 1, 16, 0xffff, 0, FALSE, signed,
374 ppc_elf_unhandled_reloc),
375
376 /* 16-bit lower half section relative relocation. */
377 HOW (R_PPC_SECTOFF_LO, 1, 16, 0xffff, 0, FALSE, dont,
378 ppc_elf_unhandled_reloc),
379
380 /* 16-bit upper half section relative relocation. */
381 HOW (R_PPC_SECTOFF_HI, 1, 16, 0xffff, 16, FALSE, dont,
382 ppc_elf_unhandled_reloc),
383
384 /* 16-bit upper half adjusted section relative relocation. */
385 HOW (R_PPC_SECTOFF_HA, 1, 16, 0xffff, 16, FALSE, dont,
386 ppc_elf_unhandled_reloc),
387
388 /* Marker relocs for TLS. */
389 HOW (R_PPC_TLS, 2, 32, 0, 0, FALSE, dont,
390 bfd_elf_generic_reloc),
391
392 HOW (R_PPC_TLSGD, 2, 32, 0, 0, FALSE, dont,
393 bfd_elf_generic_reloc),
394
395 HOW (R_PPC_TLSLD, 2, 32, 0, 0, FALSE, dont,
396 bfd_elf_generic_reloc),
397
398 /* Marker relocs on inline plt call instructions. */
399 HOW (R_PPC_PLTSEQ, 2, 32, 0, 0, FALSE, dont,
400 bfd_elf_generic_reloc),
401
402 HOW (R_PPC_PLTCALL, 2, 32, 0, 0, FALSE, dont,
403 bfd_elf_generic_reloc),
404
405 /* Computes the load module index of the load module that contains the
406 definition of its TLS sym. */
407 HOW (R_PPC_DTPMOD32, 2, 32, 0xffffffff, 0, FALSE, dont,
408 ppc_elf_unhandled_reloc),
409
410 /* Computes a dtv-relative displacement, the difference between the value
411 of sym+add and the base address of the thread-local storage block that
412 contains the definition of sym, minus 0x8000. */
413 HOW (R_PPC_DTPREL32, 2, 32, 0xffffffff, 0, FALSE, dont,
414 ppc_elf_unhandled_reloc),
415
416 /* A 16 bit dtprel reloc. */
417 HOW (R_PPC_DTPREL16, 1, 16, 0xffff, 0, FALSE, signed,
418 ppc_elf_unhandled_reloc),
419
420 /* Like DTPREL16, but no overflow. */
421 HOW (R_PPC_DTPREL16_LO, 1, 16, 0xffff, 0, FALSE, dont,
422 ppc_elf_unhandled_reloc),
423
424 /* Like DTPREL16_LO, but next higher group of 16 bits. */
425 HOW (R_PPC_DTPREL16_HI, 1, 16, 0xffff, 16, FALSE, dont,
426 ppc_elf_unhandled_reloc),
427
428 /* Like DTPREL16_HI, but adjust for low 16 bits. */
429 HOW (R_PPC_DTPREL16_HA, 1, 16, 0xffff, 16, FALSE, dont,
430 ppc_elf_unhandled_reloc),
431
432 /* Computes a tp-relative displacement, the difference between the value of
433 sym+add and the value of the thread pointer (r13). */
434 HOW (R_PPC_TPREL32, 2, 32, 0xffffffff, 0, FALSE, dont,
435 ppc_elf_unhandled_reloc),
436
437 /* A 16 bit tprel reloc. */
438 HOW (R_PPC_TPREL16, 1, 16, 0xffff, 0, FALSE, signed,
439 ppc_elf_unhandled_reloc),
440
441 /* Like TPREL16, but no overflow. */
442 HOW (R_PPC_TPREL16_LO, 1, 16, 0xffff, 0, FALSE, dont,
443 ppc_elf_unhandled_reloc),
444
445 /* Like TPREL16_LO, but next higher group of 16 bits. */
446 HOW (R_PPC_TPREL16_HI, 1, 16, 0xffff, 16, FALSE, dont,
447 ppc_elf_unhandled_reloc),
448
449 /* Like TPREL16_HI, but adjust for low 16 bits. */
450 HOW (R_PPC_TPREL16_HA, 1, 16, 0xffff, 16, FALSE, dont,
451 ppc_elf_unhandled_reloc),
452
453 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
454 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
455 to the first entry. */
456 HOW (R_PPC_GOT_TLSGD16, 1, 16, 0xffff, 0, FALSE, signed,
457 ppc_elf_unhandled_reloc),
458
459 /* Like GOT_TLSGD16, but no overflow. */
460 HOW (R_PPC_GOT_TLSGD16_LO, 1, 16, 0xffff, 0, FALSE, dont,
461 ppc_elf_unhandled_reloc),
462
463 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
464 HOW (R_PPC_GOT_TLSGD16_HI, 1, 16, 0xffff, 16, FALSE, dont,
465 ppc_elf_unhandled_reloc),
466
467 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
468 HOW (R_PPC_GOT_TLSGD16_HA, 1, 16, 0xffff, 16, FALSE, dont,
469 ppc_elf_unhandled_reloc),
470
471 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
472 with values (sym+add)@dtpmod and zero, and computes the offset to the
473 first entry. */
474 HOW (R_PPC_GOT_TLSLD16, 1, 16, 0xffff, 0, FALSE, signed,
475 ppc_elf_unhandled_reloc),
476
477 /* Like GOT_TLSLD16, but no overflow. */
478 HOW (R_PPC_GOT_TLSLD16_LO, 1, 16, 0xffff, 0, FALSE, dont,
479 ppc_elf_unhandled_reloc),
480
481 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
482 HOW (R_PPC_GOT_TLSLD16_HI, 1, 16, 0xffff, 16, FALSE, dont,
483 ppc_elf_unhandled_reloc),
484
485 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
486 HOW (R_PPC_GOT_TLSLD16_HA, 1, 16, 0xffff, 16, FALSE, dont,
487 ppc_elf_unhandled_reloc),
488
489 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
490 the offset to the entry. */
491 HOW (R_PPC_GOT_DTPREL16, 1, 16, 0xffff, 0, FALSE, signed,
492 ppc_elf_unhandled_reloc),
493
494 /* Like GOT_DTPREL16, but no overflow. */
495 HOW (R_PPC_GOT_DTPREL16_LO, 1, 16, 0xffff, 0, FALSE, dont,
496 ppc_elf_unhandled_reloc),
497
498 /* Like GOT_DTPREL16_LO, but next higher group of 16 bits. */
499 HOW (R_PPC_GOT_DTPREL16_HI, 1, 16, 0xffff, 16, FALSE, dont,
500 ppc_elf_unhandled_reloc),
501
502 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
503 HOW (R_PPC_GOT_DTPREL16_HA, 1, 16, 0xffff, 16, FALSE, dont,
504 ppc_elf_unhandled_reloc),
505
506 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
507 offset to the entry. */
508 HOW (R_PPC_GOT_TPREL16, 1, 16, 0xffff, 0, FALSE, signed,
509 ppc_elf_unhandled_reloc),
510
511 /* Like GOT_TPREL16, but no overflow. */
512 HOW (R_PPC_GOT_TPREL16_LO, 1, 16, 0xffff, 0, FALSE, dont,
513 ppc_elf_unhandled_reloc),
514
515 /* Like GOT_TPREL16_LO, but next higher group of 16 bits. */
516 HOW (R_PPC_GOT_TPREL16_HI, 1, 16, 0xffff, 16, FALSE, dont,
517 ppc_elf_unhandled_reloc),
518
519 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
520 HOW (R_PPC_GOT_TPREL16_HA, 1, 16, 0xffff, 16, FALSE, dont,
521 ppc_elf_unhandled_reloc),
522
523 /* The remaining relocs are from the Embedded ELF ABI, and are not
524 in the SVR4 ELF ABI. */
525
526 /* 32 bit value resulting from the addend minus the symbol. */
527 HOW (R_PPC_EMB_NADDR32, 2, 32, 0xffffffff, 0, FALSE, dont,
528 ppc_elf_unhandled_reloc),
529
530 /* 16 bit value resulting from the addend minus the symbol. */
531 HOW (R_PPC_EMB_NADDR16, 1, 16, 0xffff, 0, FALSE, signed,
532 ppc_elf_unhandled_reloc),
533
534 /* 16 bit value resulting from the addend minus the symbol. */
535 HOW (R_PPC_EMB_NADDR16_LO, 1, 16, 0xffff, 0, FALSE, dont,
536 ppc_elf_unhandled_reloc),
537
538 /* The high order 16 bits of the addend minus the symbol. */
539 HOW (R_PPC_EMB_NADDR16_HI, 1, 16, 0xffff, 16, FALSE, dont,
540 ppc_elf_unhandled_reloc),
541
542 /* The high order 16 bits of the result of the addend minus the address,
543 plus 1 if the contents of the low 16 bits, treated as a signed number,
544 is negative. */
545 HOW (R_PPC_EMB_NADDR16_HA, 1, 16, 0xffff, 16, FALSE, dont,
546 ppc_elf_unhandled_reloc),
547
548 /* 16 bit value resulting from allocating a 4 byte word to hold an
549 address in the .sdata section, and returning the offset from
550 _SDA_BASE_ for that relocation. */
551 HOW (R_PPC_EMB_SDAI16, 1, 16, 0xffff, 0, FALSE, signed,
552 ppc_elf_unhandled_reloc),
553
554 /* 16 bit value resulting from allocating a 4 byte word to hold an
555 address in the .sdata2 section, and returning the offset from
556 _SDA2_BASE_ for that relocation. */
557 HOW (R_PPC_EMB_SDA2I16, 1, 16, 0xffff, 0, FALSE, signed,
558 ppc_elf_unhandled_reloc),
559
560 /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
561 small data items. */
562 HOW (R_PPC_EMB_SDA2REL, 1, 16, 0xffff, 0, FALSE, signed,
563 ppc_elf_unhandled_reloc),
564
565 /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
566 signed offset from the appropriate base, and filling in the register
567 field with the appropriate register (0, 2, or 13). */
568 HOW (R_PPC_EMB_SDA21, 2, 16, 0xffff, 0, FALSE, signed,
569 ppc_elf_unhandled_reloc),
570
571 /* Relocation not handled: R_PPC_EMB_MRKREF */
572 /* Relocation not handled: R_PPC_EMB_RELSEC16 */
573 /* Relocation not handled: R_PPC_EMB_RELST_LO */
574 /* Relocation not handled: R_PPC_EMB_RELST_HI */
575 /* Relocation not handled: R_PPC_EMB_RELST_HA */
576 /* Relocation not handled: R_PPC_EMB_BIT_FLD */
577
578 /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
579 in the 16 bit signed offset from the appropriate base, and filling in the
580 register field with the appropriate register (0, 2, or 13). */
581 HOW (R_PPC_EMB_RELSDA, 1, 16, 0xffff, 0, FALSE, signed,
582 ppc_elf_unhandled_reloc),
583
584 /* A relative 8 bit branch. */
585 HOW (R_PPC_VLE_REL8, 1, 8, 0xff, 1, TRUE, signed,
586 bfd_elf_generic_reloc),
587
588 /* A relative 15 bit branch. */
589 HOW (R_PPC_VLE_REL15, 2, 16, 0xfffe, 0, TRUE, signed,
590 bfd_elf_generic_reloc),
591
592 /* A relative 24 bit branch. */
593 HOW (R_PPC_VLE_REL24, 2, 25, 0x1fffffe, 0, TRUE, signed,
594 bfd_elf_generic_reloc),
595
596 /* The 16 LSBS in split16a format. */
597 HOW (R_PPC_VLE_LO16A, 2, 16, 0x1f07ff, 0, FALSE, dont,
598 ppc_elf_unhandled_reloc),
599
600 /* The 16 LSBS in split16d format. */
601 HOW (R_PPC_VLE_LO16D, 2, 16, 0x3e007ff, 0, FALSE, dont,
602 ppc_elf_unhandled_reloc),
603
604 /* Bits 16-31 split16a format. */
605 HOW (R_PPC_VLE_HI16A, 2, 16, 0x1f07ff, 16, FALSE, dont,
606 ppc_elf_unhandled_reloc),
607
608 /* Bits 16-31 split16d format. */
609 HOW (R_PPC_VLE_HI16D, 2, 16, 0x3e007ff, 16, FALSE, dont,
610 ppc_elf_unhandled_reloc),
611
612 /* Bits 16-31 (High Adjusted) in split16a format. */
613 HOW (R_PPC_VLE_HA16A, 2, 16, 0x1f07ff, 16, FALSE, dont,
614 ppc_elf_unhandled_reloc),
615
616 /* Bits 16-31 (High Adjusted) in split16d format. */
617 HOW (R_PPC_VLE_HA16D, 2, 16, 0x3e007ff, 16, FALSE, dont,
618 ppc_elf_unhandled_reloc),
619
620 /* This reloc is like R_PPC_EMB_SDA21 but only applies to e_add16i
621 instructions. If the register base is 0 then the linker changes
622 the e_add16i to an e_li instruction. */
623 HOW (R_PPC_VLE_SDA21, 2, 16, 0xffff, 0, FALSE, signed,
624 ppc_elf_unhandled_reloc),
625
626 /* Like R_PPC_VLE_SDA21 but ignore overflow. */
627 HOW (R_PPC_VLE_SDA21_LO, 2, 16, 0xffff, 0, FALSE, dont,
628 ppc_elf_unhandled_reloc),
629
630 /* The 16 LSBS relative to _SDA_BASE_ in split16a format. */
631 HOW (R_PPC_VLE_SDAREL_LO16A, 2, 16, 0x1f07ff, 0, FALSE, dont,
632 ppc_elf_unhandled_reloc),
633
634 /* The 16 LSBS relative to _SDA_BASE_ in split16d format. */
635 HOW (R_PPC_VLE_SDAREL_LO16D, 2, 16, 0x3e007ff, 0, FALSE, dont,
636 ppc_elf_unhandled_reloc),
637
638 /* Bits 16-31 relative to _SDA_BASE_ in split16a format. */
639 HOW (R_PPC_VLE_SDAREL_HI16A, 2, 16, 0x1f07ff, 16, FALSE, dont,
640 ppc_elf_unhandled_reloc),
641
642 /* Bits 16-31 relative to _SDA_BASE_ in split16d format. */
643 HOW (R_PPC_VLE_SDAREL_HI16D, 2, 16, 0x3e007ff, 16, FALSE, dont,
644 ppc_elf_unhandled_reloc),
645
646 /* Bits 16-31 (HA) relative to _SDA_BASE split16a format. */
647 HOW (R_PPC_VLE_SDAREL_HA16A, 2, 16, 0x1f07ff, 16, FALSE, dont,
648 ppc_elf_unhandled_reloc),
649
650 /* Bits 16-31 (HA) relative to _SDA_BASE split16d format. */
651 HOW (R_PPC_VLE_SDAREL_HA16D, 2, 16, 0x3e007ff, 16, FALSE, dont,
652 ppc_elf_unhandled_reloc),
653
654 /* e_li split20 format. */
655 HOW (R_PPC_VLE_ADDR20, 2, 20, 0x1f7fff, 0, FALSE, dont,
656 ppc_elf_unhandled_reloc),
657
658 HOW (R_PPC_IRELATIVE, 2, 32, 0xffffffff, 0, FALSE, dont,
659 ppc_elf_unhandled_reloc),
660
661 /* A 16 bit relative relocation. */
662 HOW (R_PPC_REL16, 1, 16, 0xffff, 0, TRUE, signed,
663 bfd_elf_generic_reloc),
664
665 /* A 16 bit relative relocation without overflow. */
666 HOW (R_PPC_REL16_LO, 1, 16, 0xffff, 0, TRUE, dont,
667 bfd_elf_generic_reloc),
668
669 /* The high order 16 bits of a relative address. */
670 HOW (R_PPC_REL16_HI, 1, 16, 0xffff, 16, TRUE, dont,
671 bfd_elf_generic_reloc),
672
673 /* The high order 16 bits of a relative address, plus 1 if the contents of
674 the low 16 bits, treated as a signed number, is negative. */
675 HOW (R_PPC_REL16_HA, 1, 16, 0xffff, 16, TRUE, dont,
676 ppc_elf_addr16_ha_reloc),
677
678 /* Like R_PPC_REL16_HA but for split field in addpcis. */
679 HOW (R_PPC_REL16DX_HA, 2, 16, 0x1fffc1, 16, TRUE, signed,
680 ppc_elf_addr16_ha_reloc),
681
682 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
683 HOW (R_PPC_16DX_HA, 2, 16, 0x1fffc1, 16, FALSE, signed,
684 ppc_elf_addr16_ha_reloc),
685
686 /* GNU extension to record C++ vtable hierarchy. */
687 HOW (R_PPC_GNU_VTINHERIT, 0, 0, 0, 0, FALSE, dont,
688 NULL),
689
690 /* GNU extension to record C++ vtable member usage. */
691 HOW (R_PPC_GNU_VTENTRY, 0, 0, 0, 0, FALSE, dont,
692 NULL),
693
694 /* Phony reloc to handle AIX style TOC entries. */
695 HOW (R_PPC_TOC16, 1, 16, 0xffff, 0, FALSE, signed,
696 ppc_elf_unhandled_reloc),
697 };
698 \f
699 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */
700
701 static void
702 ppc_elf_howto_init (void)
703 {
704 unsigned int i, type;
705
706 for (i = 0;
707 i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]);
708 i++)
709 {
710 type = ppc_elf_howto_raw[i].type;
711 if (type >= (sizeof (ppc_elf_howto_table)
712 / sizeof (ppc_elf_howto_table[0])))
713 abort ();
714 ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
715 }
716 }
717
718 static reloc_howto_type *
719 ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
720 bfd_reloc_code_real_type code)
721 {
722 enum elf_ppc_reloc_type r;
723
724 /* Initialize howto table if not already done. */
725 if (!ppc_elf_howto_table[R_PPC_ADDR32])
726 ppc_elf_howto_init ();
727
728 switch (code)
729 {
730 default:
731 return NULL;
732
733 case BFD_RELOC_NONE: r = R_PPC_NONE; break;
734 case BFD_RELOC_32: r = R_PPC_ADDR32; break;
735 case BFD_RELOC_PPC_BA26: r = R_PPC_ADDR24; break;
736 case BFD_RELOC_PPC64_ADDR16_DS:
737 case BFD_RELOC_16: r = R_PPC_ADDR16; break;
738 case BFD_RELOC_PPC64_ADDR16_LO_DS:
739 case BFD_RELOC_LO16: r = R_PPC_ADDR16_LO; break;
740 case BFD_RELOC_HI16: r = R_PPC_ADDR16_HI; break;
741 case BFD_RELOC_HI16_S: r = R_PPC_ADDR16_HA; break;
742 case BFD_RELOC_PPC_BA16: r = R_PPC_ADDR14; break;
743 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC_ADDR14_BRTAKEN; break;
744 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC_ADDR14_BRNTAKEN; break;
745 case BFD_RELOC_PPC_B26: r = R_PPC_REL24; break;
746 case BFD_RELOC_PPC_B16: r = R_PPC_REL14; break;
747 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC_REL14_BRTAKEN; break;
748 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC_REL14_BRNTAKEN; break;
749 case BFD_RELOC_PPC64_GOT16_DS:
750 case BFD_RELOC_16_GOTOFF: r = R_PPC_GOT16; break;
751 case BFD_RELOC_PPC64_GOT16_LO_DS:
752 case BFD_RELOC_LO16_GOTOFF: r = R_PPC_GOT16_LO; break;
753 case BFD_RELOC_HI16_GOTOFF: r = R_PPC_GOT16_HI; break;
754 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC_GOT16_HA; break;
755 case BFD_RELOC_24_PLT_PCREL: r = R_PPC_PLTREL24; break;
756 case BFD_RELOC_PPC_COPY: r = R_PPC_COPY; break;
757 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC_GLOB_DAT; break;
758 case BFD_RELOC_PPC_LOCAL24PC: r = R_PPC_LOCAL24PC; break;
759 case BFD_RELOC_32_PCREL: r = R_PPC_REL32; break;
760 case BFD_RELOC_32_PLTOFF: r = R_PPC_PLT32; break;
761 case BFD_RELOC_32_PLT_PCREL: r = R_PPC_PLTREL32; break;
762 case BFD_RELOC_PPC64_PLT16_LO_DS:
763 case BFD_RELOC_LO16_PLTOFF: r = R_PPC_PLT16_LO; break;
764 case BFD_RELOC_HI16_PLTOFF: r = R_PPC_PLT16_HI; break;
765 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC_PLT16_HA; break;
766 case BFD_RELOC_GPREL16: r = R_PPC_SDAREL16; break;
767 case BFD_RELOC_PPC64_SECTOFF_DS:
768 case BFD_RELOC_16_BASEREL: r = R_PPC_SECTOFF; break;
769 case BFD_RELOC_PPC64_SECTOFF_LO_DS:
770 case BFD_RELOC_LO16_BASEREL: r = R_PPC_SECTOFF_LO; break;
771 case BFD_RELOC_HI16_BASEREL: r = R_PPC_SECTOFF_HI; break;
772 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC_SECTOFF_HA; break;
773 case BFD_RELOC_CTOR: r = R_PPC_ADDR32; break;
774 case BFD_RELOC_PPC64_TOC16_DS:
775 case BFD_RELOC_PPC_TOC16: r = R_PPC_TOC16; break;
776 case BFD_RELOC_PPC_TLS: r = R_PPC_TLS; break;
777 case BFD_RELOC_PPC_TLSGD: r = R_PPC_TLSGD; break;
778 case BFD_RELOC_PPC_TLSLD: r = R_PPC_TLSLD; break;
779 case BFD_RELOC_PPC_DTPMOD: r = R_PPC_DTPMOD32; break;
780 case BFD_RELOC_PPC64_TPREL16_DS:
781 case BFD_RELOC_PPC_TPREL16: r = R_PPC_TPREL16; break;
782 case BFD_RELOC_PPC64_TPREL16_LO_DS:
783 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC_TPREL16_LO; break;
784 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC_TPREL16_HI; break;
785 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC_TPREL16_HA; break;
786 case BFD_RELOC_PPC_TPREL: r = R_PPC_TPREL32; break;
787 case BFD_RELOC_PPC64_DTPREL16_DS:
788 case BFD_RELOC_PPC_DTPREL16: r = R_PPC_DTPREL16; break;
789 case BFD_RELOC_PPC64_DTPREL16_LO_DS:
790 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC_DTPREL16_LO; break;
791 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC_DTPREL16_HI; break;
792 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC_DTPREL16_HA; break;
793 case BFD_RELOC_PPC_DTPREL: r = R_PPC_DTPREL32; break;
794 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC_GOT_TLSGD16; break;
795 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC_GOT_TLSGD16_LO; break;
796 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC_GOT_TLSGD16_HI; break;
797 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC_GOT_TLSGD16_HA; break;
798 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC_GOT_TLSLD16; break;
799 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC_GOT_TLSLD16_LO; break;
800 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC_GOT_TLSLD16_HI; break;
801 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC_GOT_TLSLD16_HA; break;
802 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC_GOT_TPREL16; break;
803 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC_GOT_TPREL16_LO; break;
804 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC_GOT_TPREL16_HI; break;
805 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC_GOT_TPREL16_HA; break;
806 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC_GOT_DTPREL16; break;
807 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC_GOT_DTPREL16_LO; break;
808 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC_GOT_DTPREL16_HI; break;
809 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC_GOT_DTPREL16_HA; break;
810 case BFD_RELOC_PPC_EMB_NADDR32: r = R_PPC_EMB_NADDR32; break;
811 case BFD_RELOC_PPC_EMB_NADDR16: r = R_PPC_EMB_NADDR16; break;
812 case BFD_RELOC_PPC_EMB_NADDR16_LO: r = R_PPC_EMB_NADDR16_LO; break;
813 case BFD_RELOC_PPC_EMB_NADDR16_HI: r = R_PPC_EMB_NADDR16_HI; break;
814 case BFD_RELOC_PPC_EMB_NADDR16_HA: r = R_PPC_EMB_NADDR16_HA; break;
815 case BFD_RELOC_PPC_EMB_SDAI16: r = R_PPC_EMB_SDAI16; break;
816 case BFD_RELOC_PPC_EMB_SDA2I16: r = R_PPC_EMB_SDA2I16; break;
817 case BFD_RELOC_PPC_EMB_SDA2REL: r = R_PPC_EMB_SDA2REL; break;
818 case BFD_RELOC_PPC_EMB_SDA21: r = R_PPC_EMB_SDA21; break;
819 case BFD_RELOC_PPC_EMB_MRKREF: r = R_PPC_EMB_MRKREF; break;
820 case BFD_RELOC_PPC_EMB_RELSEC16: r = R_PPC_EMB_RELSEC16; break;
821 case BFD_RELOC_PPC_EMB_RELST_LO: r = R_PPC_EMB_RELST_LO; break;
822 case BFD_RELOC_PPC_EMB_RELST_HI: r = R_PPC_EMB_RELST_HI; break;
823 case BFD_RELOC_PPC_EMB_RELST_HA: r = R_PPC_EMB_RELST_HA; break;
824 case BFD_RELOC_PPC_EMB_BIT_FLD: r = R_PPC_EMB_BIT_FLD; break;
825 case BFD_RELOC_PPC_EMB_RELSDA: r = R_PPC_EMB_RELSDA; break;
826 case BFD_RELOC_PPC_VLE_REL8: r = R_PPC_VLE_REL8; break;
827 case BFD_RELOC_PPC_VLE_REL15: r = R_PPC_VLE_REL15; break;
828 case BFD_RELOC_PPC_VLE_REL24: r = R_PPC_VLE_REL24; break;
829 case BFD_RELOC_PPC_VLE_LO16A: r = R_PPC_VLE_LO16A; break;
830 case BFD_RELOC_PPC_VLE_LO16D: r = R_PPC_VLE_LO16D; break;
831 case BFD_RELOC_PPC_VLE_HI16A: r = R_PPC_VLE_HI16A; break;
832 case BFD_RELOC_PPC_VLE_HI16D: r = R_PPC_VLE_HI16D; break;
833 case BFD_RELOC_PPC_VLE_HA16A: r = R_PPC_VLE_HA16A; break;
834 case BFD_RELOC_PPC_VLE_HA16D: r = R_PPC_VLE_HA16D; break;
835 case BFD_RELOC_PPC_VLE_SDA21: r = R_PPC_VLE_SDA21; break;
836 case BFD_RELOC_PPC_VLE_SDA21_LO: r = R_PPC_VLE_SDA21_LO; break;
837 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
838 r = R_PPC_VLE_SDAREL_LO16A;
839 break;
840 case BFD_RELOC_PPC_VLE_SDAREL_LO16D:
841 r = R_PPC_VLE_SDAREL_LO16D;
842 break;
843 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
844 r = R_PPC_VLE_SDAREL_HI16A;
845 break;
846 case BFD_RELOC_PPC_VLE_SDAREL_HI16D:
847 r = R_PPC_VLE_SDAREL_HI16D;
848 break;
849 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
850 r = R_PPC_VLE_SDAREL_HA16A;
851 break;
852 case BFD_RELOC_PPC_VLE_SDAREL_HA16D:
853 r = R_PPC_VLE_SDAREL_HA16D;
854 break;
855 case BFD_RELOC_16_PCREL: r = R_PPC_REL16; break;
856 case BFD_RELOC_LO16_PCREL: r = R_PPC_REL16_LO; break;
857 case BFD_RELOC_HI16_PCREL: r = R_PPC_REL16_HI; break;
858 case BFD_RELOC_HI16_S_PCREL: r = R_PPC_REL16_HA; break;
859 case BFD_RELOC_PPC_16DX_HA: r = R_PPC_16DX_HA; break;
860 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC_REL16DX_HA; break;
861 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC_GNU_VTINHERIT; break;
862 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC_GNU_VTENTRY; break;
863 }
864
865 return ppc_elf_howto_table[r];
866 };
867
868 static reloc_howto_type *
869 ppc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
870 const char *r_name)
871 {
872 unsigned int i;
873
874 for (i = 0;
875 i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]);
876 i++)
877 if (ppc_elf_howto_raw[i].name != NULL
878 && strcasecmp (ppc_elf_howto_raw[i].name, r_name) == 0)
879 return &ppc_elf_howto_raw[i];
880
881 return NULL;
882 }
883
884 /* Set the howto pointer for a PowerPC ELF reloc. */
885
886 static bfd_boolean
887 ppc_elf_info_to_howto (bfd *abfd,
888 arelent *cache_ptr,
889 Elf_Internal_Rela *dst)
890 {
891 unsigned int r_type;
892
893 /* Initialize howto table if not already done. */
894 if (!ppc_elf_howto_table[R_PPC_ADDR32])
895 ppc_elf_howto_init ();
896
897 r_type = ELF32_R_TYPE (dst->r_info);
898 if (r_type >= R_PPC_max)
899 {
900 /* xgettext:c-format */
901 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
902 abfd, r_type);
903 bfd_set_error (bfd_error_bad_value);
904 return FALSE;
905 }
906
907 cache_ptr->howto = ppc_elf_howto_table[r_type];
908
909 /* Just because the above assert didn't trigger doesn't mean that
910 ELF32_R_TYPE (dst->r_info) is necessarily a valid relocation. */
911 if (cache_ptr->howto == NULL)
912 {
913 /* xgettext:c-format */
914 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
915 abfd, r_type);
916 bfd_set_error (bfd_error_bad_value);
917
918 return FALSE;
919 }
920
921 return TRUE;
922 }
923
924 /* Handle the R_PPC_ADDR16_HA and R_PPC_REL16_HA relocs. */
925
926 static bfd_reloc_status_type
927 ppc_elf_addr16_ha_reloc (bfd *abfd,
928 arelent *reloc_entry,
929 asymbol *symbol,
930 void *data,
931 asection *input_section,
932 bfd *output_bfd,
933 char **error_message ATTRIBUTE_UNUSED)
934 {
935 enum elf_ppc_reloc_type r_type;
936 long insn;
937 bfd_size_type octets;
938 bfd_vma value;
939
940 if (output_bfd != NULL)
941 {
942 reloc_entry->address += input_section->output_offset;
943 return bfd_reloc_ok;
944 }
945
946 reloc_entry->addend += 0x8000;
947 r_type = reloc_entry->howto->type;
948 if (r_type != R_PPC_REL16DX_HA)
949 return bfd_reloc_continue;
950
951 value = 0;
952 if (!bfd_is_com_section (symbol->section))
953 value = symbol->value;
954 value += (reloc_entry->addend
955 + symbol->section->output_offset
956 + symbol->section->output_section->vma);
957 value -= (reloc_entry->address
958 + input_section->output_offset
959 + input_section->output_section->vma);
960 value >>= 16;
961
962 octets = reloc_entry->address * OCTETS_PER_BYTE (abfd, input_section);
963 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
964 insn &= ~0x1fffc1;
965 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
966 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
967 return bfd_reloc_ok;
968 }
969
970 static bfd_reloc_status_type
971 ppc_elf_unhandled_reloc (bfd *abfd,
972 arelent *reloc_entry,
973 asymbol *symbol,
974 void *data,
975 asection *input_section,
976 bfd *output_bfd,
977 char **error_message)
978 {
979 /* If this is a relocatable link (output_bfd test tells us), just
980 call the generic function. Any adjustment will be done at final
981 link time. */
982 if (output_bfd != NULL)
983 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
984 input_section, output_bfd, error_message);
985
986 if (error_message != NULL)
987 {
988 static char buf[60];
989 sprintf (buf, _("generic linker can't handle %s"),
990 reloc_entry->howto->name);
991 *error_message = buf;
992 }
993 return bfd_reloc_dangerous;
994 }
995 \f
996 /* Sections created by the linker. */
997
998 typedef struct elf_linker_section
999 {
1000 /* Pointer to the bfd section. */
1001 asection *section;
1002 /* Section name. */
1003 const char *name;
1004 /* Associated bss section name. */
1005 const char *bss_name;
1006 /* Associated symbol name. */
1007 const char *sym_name;
1008 /* Associated symbol. */
1009 struct elf_link_hash_entry *sym;
1010 } elf_linker_section_t;
1011
1012 /* Linked list of allocated pointer entries. This hangs off of the
1013 symbol lists, and provides allows us to return different pointers,
1014 based on different addend's. */
1015
1016 typedef struct elf_linker_section_pointers
1017 {
1018 /* next allocated pointer for this symbol */
1019 struct elf_linker_section_pointers *next;
1020 /* offset of pointer from beginning of section */
1021 bfd_vma offset;
1022 /* addend used */
1023 bfd_vma addend;
1024 /* which linker section this is */
1025 elf_linker_section_t *lsect;
1026 } elf_linker_section_pointers_t;
1027
1028 struct ppc_elf_obj_tdata
1029 {
1030 struct elf_obj_tdata elf;
1031
1032 /* A mapping from local symbols to offsets into the various linker
1033 sections added. This is index by the symbol index. */
1034 elf_linker_section_pointers_t **linker_section_pointers;
1035
1036 /* Flags used to auto-detect plt type. */
1037 unsigned int makes_plt_call : 1;
1038 unsigned int has_rel16 : 1;
1039 };
1040
1041 #define ppc_elf_tdata(bfd) \
1042 ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any)
1043
1044 #define elf_local_ptr_offsets(bfd) \
1045 (ppc_elf_tdata (bfd)->linker_section_pointers)
1046
1047 #define is_ppc_elf(bfd) \
1048 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1049 && elf_object_id (bfd) == PPC32_ELF_DATA)
1050
1051 /* Override the generic function because we store some extras. */
1052
1053 static bfd_boolean
1054 ppc_elf_mkobject (bfd *abfd)
1055 {
1056 return bfd_elf_allocate_object (abfd, sizeof (struct ppc_elf_obj_tdata),
1057 PPC32_ELF_DATA);
1058 }
1059
1060 /* When defaulting arch/mach, decode apuinfo to find a better match. */
1061
1062 bfd_boolean
1063 _bfd_elf_ppc_set_arch (bfd *abfd)
1064 {
1065 unsigned long mach = 0;
1066 asection *s;
1067 unsigned char *contents;
1068
1069 if (abfd->arch_info->bits_per_word == 32
1070 && bfd_big_endian (abfd))
1071 {
1072
1073 for (s = abfd->sections; s != NULL; s = s->next)
1074 if ((elf_section_data (s)->this_hdr.sh_flags & SHF_PPC_VLE) != 0)
1075 break;
1076 if (s != NULL)
1077 mach = bfd_mach_ppc_vle;
1078 }
1079
1080 if (mach == 0)
1081 {
1082 s = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
1083 if (s != NULL
1084 && s->size >= 24
1085 && bfd_malloc_and_get_section (abfd, s, &contents))
1086 {
1087 unsigned int apuinfo_size = bfd_get_32 (abfd, contents + 4);
1088 unsigned int i;
1089
1090 for (i = 20; i < apuinfo_size + 20 && i + 4 <= s->size; i += 4)
1091 {
1092 unsigned int val = bfd_get_32 (abfd, contents + i);
1093 switch (val >> 16)
1094 {
1095 case PPC_APUINFO_PMR:
1096 case PPC_APUINFO_RFMCI:
1097 if (mach == 0)
1098 mach = bfd_mach_ppc_titan;
1099 break;
1100
1101 case PPC_APUINFO_ISEL:
1102 case PPC_APUINFO_CACHELCK:
1103 if (mach == bfd_mach_ppc_titan)
1104 mach = bfd_mach_ppc_e500mc;
1105 break;
1106
1107 case PPC_APUINFO_SPE:
1108 case PPC_APUINFO_EFS:
1109 case PPC_APUINFO_BRLOCK:
1110 if (mach != bfd_mach_ppc_vle)
1111 mach = bfd_mach_ppc_e500;
1112 break;
1113
1114 case PPC_APUINFO_VLE:
1115 mach = bfd_mach_ppc_vle;
1116 break;
1117
1118 default:
1119 mach = -1ul;
1120 }
1121 }
1122 free (contents);
1123 }
1124 }
1125
1126 if (mach != 0 && mach != -1ul)
1127 {
1128 const bfd_arch_info_type *arch;
1129
1130 for (arch = abfd->arch_info->next; arch; arch = arch->next)
1131 if (arch->mach == mach)
1132 {
1133 abfd->arch_info = arch;
1134 break;
1135 }
1136 }
1137 return TRUE;
1138 }
1139
1140 /* Fix bad default arch selected for a 32 bit input bfd when the
1141 default is 64 bit. Also select arch based on apuinfo. */
1142
1143 static bfd_boolean
1144 ppc_elf_object_p (bfd *abfd)
1145 {
1146 if (!abfd->arch_info->the_default)
1147 return TRUE;
1148
1149 if (abfd->arch_info->bits_per_word == 64)
1150 {
1151 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
1152
1153 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS32)
1154 {
1155 /* Relies on arch after 64 bit default being 32 bit default. */
1156 abfd->arch_info = abfd->arch_info->next;
1157 BFD_ASSERT (abfd->arch_info->bits_per_word == 32);
1158 }
1159 }
1160 return _bfd_elf_ppc_set_arch (abfd);
1161 }
1162
1163 /* Function to set whether a module needs the -mrelocatable bit set. */
1164
1165 static bfd_boolean
1166 ppc_elf_set_private_flags (bfd *abfd, flagword flags)
1167 {
1168 BFD_ASSERT (!elf_flags_init (abfd)
1169 || elf_elfheader (abfd)->e_flags == flags);
1170
1171 elf_elfheader (abfd)->e_flags = flags;
1172 elf_flags_init (abfd) = TRUE;
1173 return TRUE;
1174 }
1175
1176 /* Support for core dump NOTE sections. */
1177
1178 static bfd_boolean
1179 ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1180 {
1181 int offset;
1182 unsigned int size;
1183
1184 switch (note->descsz)
1185 {
1186 default:
1187 return FALSE;
1188
1189 case 268: /* Linux/PPC. */
1190 /* pr_cursig */
1191 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1192
1193 /* pr_pid */
1194 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
1195
1196 /* pr_reg */
1197 offset = 72;
1198 size = 192;
1199
1200 break;
1201 }
1202
1203 /* Make a ".reg/999" section. */
1204 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1205 size, note->descpos + offset);
1206 }
1207
1208 static bfd_boolean
1209 ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1210 {
1211 switch (note->descsz)
1212 {
1213 default:
1214 return FALSE;
1215
1216 case 128: /* Linux/PPC elf_prpsinfo. */
1217 elf_tdata (abfd)->core->pid
1218 = bfd_get_32 (abfd, note->descdata + 16);
1219 elf_tdata (abfd)->core->program
1220 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
1221 elf_tdata (abfd)->core->command
1222 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
1223 }
1224
1225 /* Note that for some reason, a spurious space is tacked
1226 onto the end of the args in some (at least one anyway)
1227 implementations, so strip it off if it exists. */
1228
1229 {
1230 char *command = elf_tdata (abfd)->core->command;
1231 int n = strlen (command);
1232
1233 if (0 < n && command[n - 1] == ' ')
1234 command[n - 1] = '\0';
1235 }
1236
1237 return TRUE;
1238 }
1239
1240 static char *
1241 ppc_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...)
1242 {
1243 switch (note_type)
1244 {
1245 default:
1246 return NULL;
1247
1248 case NT_PRPSINFO:
1249 {
1250 char data[128] ATTRIBUTE_NONSTRING;
1251 va_list ap;
1252
1253 va_start (ap, note_type);
1254 memset (data, 0, sizeof (data));
1255 strncpy (data + 32, va_arg (ap, const char *), 16);
1256 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1257 DIAGNOSTIC_PUSH;
1258 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1259 -Wstringop-truncation:
1260 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1261 */
1262 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
1263 #endif
1264 strncpy (data + 48, va_arg (ap, const char *), 80);
1265 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1266 DIAGNOSTIC_POP;
1267 #endif
1268 va_end (ap);
1269 return elfcore_write_note (abfd, buf, bufsiz,
1270 "CORE", note_type, data, sizeof (data));
1271 }
1272
1273 case NT_PRSTATUS:
1274 {
1275 char data[268];
1276 va_list ap;
1277 long pid;
1278 int cursig;
1279 const void *greg;
1280
1281 va_start (ap, note_type);
1282 memset (data, 0, 72);
1283 pid = va_arg (ap, long);
1284 bfd_put_32 (abfd, pid, data + 24);
1285 cursig = va_arg (ap, int);
1286 bfd_put_16 (abfd, cursig, data + 12);
1287 greg = va_arg (ap, const void *);
1288 memcpy (data + 72, greg, 192);
1289 memset (data + 264, 0, 4);
1290 va_end (ap);
1291 return elfcore_write_note (abfd, buf, bufsiz,
1292 "CORE", note_type, data, sizeof (data));
1293 }
1294 }
1295 }
1296
1297 static flagword
1298 ppc_elf_lookup_section_flags (char *flag_name)
1299 {
1300
1301 if (!strcmp (flag_name, "SHF_PPC_VLE"))
1302 return SHF_PPC_VLE;
1303
1304 return 0;
1305 }
1306
1307 /* Return address for Ith PLT stub in section PLT, for relocation REL
1308 or (bfd_vma) -1 if it should not be included. */
1309
1310 static bfd_vma
1311 ppc_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
1312 const asection *plt ATTRIBUTE_UNUSED,
1313 const arelent *rel)
1314 {
1315 return rel->address;
1316 }
1317
1318 /* Handle a PowerPC specific section when reading an object file. This
1319 is called when bfd_section_from_shdr finds a section with an unknown
1320 type. */
1321
1322 static bfd_boolean
1323 ppc_elf_section_from_shdr (bfd *abfd,
1324 Elf_Internal_Shdr *hdr,
1325 const char *name,
1326 int shindex)
1327 {
1328 asection *newsect;
1329 flagword flags;
1330
1331 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1332 return FALSE;
1333
1334 newsect = hdr->bfd_section;
1335 flags = 0;
1336 if (hdr->sh_flags & SHF_EXCLUDE)
1337 flags |= SEC_EXCLUDE;
1338
1339 if (hdr->sh_type == SHT_ORDERED)
1340 flags |= SEC_SORT_ENTRIES;
1341
1342 if (strncmp (name, ".PPC.EMB", 8) == 0)
1343 name += 8;
1344 if (strncmp (name, ".sbss", 5) == 0
1345 || strncmp (name, ".sdata", 6) == 0)
1346 flags |= SEC_SMALL_DATA;
1347
1348 return (flags == 0
1349 || bfd_set_section_flags (newsect, newsect->flags | flags));
1350 }
1351
1352 /* Set up any other section flags and such that may be necessary. */
1353
1354 static bfd_boolean
1355 ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
1356 Elf_Internal_Shdr *shdr,
1357 asection *asect)
1358 {
1359 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
1360 shdr->sh_type = SHT_ORDERED;
1361
1362 return TRUE;
1363 }
1364
1365 /* If we have .sbss2 or .PPC.EMB.sbss0 output sections, we
1366 need to bump up the number of section headers. */
1367
1368 static int
1369 ppc_elf_additional_program_headers (bfd *abfd,
1370 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1371 {
1372 asection *s;
1373 int ret = 0;
1374
1375 s = bfd_get_section_by_name (abfd, ".sbss2");
1376 if (s != NULL && (s->flags & SEC_ALLOC) != 0)
1377 ++ret;
1378
1379 s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
1380 if (s != NULL && (s->flags & SEC_ALLOC) != 0)
1381 ++ret;
1382
1383 return ret;
1384 }
1385
1386 /* Modify the segment map for VLE executables. */
1387
1388 bfd_boolean
1389 ppc_elf_modify_segment_map (bfd *abfd,
1390 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1391 {
1392 struct elf_segment_map *m;
1393
1394 /* At this point in the link, output sections have already been sorted by
1395 LMA and assigned to segments. All that is left to do is to ensure
1396 there is no mixing of VLE & non-VLE sections in a text segment.
1397 If we find that case, we split the segment.
1398 We maintain the original output section order. */
1399
1400 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
1401 {
1402 struct elf_segment_map *n;
1403 size_t amt;
1404 unsigned int j, k;
1405 unsigned int p_flags;
1406
1407 if (m->p_type != PT_LOAD || m->count == 0)
1408 continue;
1409
1410 for (p_flags = PF_R, j = 0; j != m->count; ++j)
1411 {
1412 if ((m->sections[j]->flags & SEC_READONLY) == 0)
1413 p_flags |= PF_W;
1414 if ((m->sections[j]->flags & SEC_CODE) != 0)
1415 {
1416 p_flags |= PF_X;
1417 if ((elf_section_flags (m->sections[j]) & SHF_PPC_VLE) != 0)
1418 p_flags |= PF_PPC_VLE;
1419 break;
1420 }
1421 }
1422 if (j != m->count)
1423 while (++j != m->count)
1424 {
1425 unsigned int p_flags1 = PF_R;
1426
1427 if ((m->sections[j]->flags & SEC_READONLY) == 0)
1428 p_flags1 |= PF_W;
1429 if ((m->sections[j]->flags & SEC_CODE) != 0)
1430 {
1431 p_flags1 |= PF_X;
1432 if ((elf_section_flags (m->sections[j]) & SHF_PPC_VLE) != 0)
1433 p_flags1 |= PF_PPC_VLE;
1434 if (((p_flags1 ^ p_flags) & PF_PPC_VLE) != 0)
1435 break;
1436 }
1437 p_flags |= p_flags1;
1438 }
1439 /* If we're splitting a segment which originally contained rw
1440 sections then those sections might now only be in one of the
1441 two parts. So always set p_flags if splitting, even if we
1442 are being called for objcopy with p_flags_valid set. */
1443 if (j != m->count || !m->p_flags_valid)
1444 {
1445 m->p_flags_valid = 1;
1446 m->p_flags = p_flags;
1447 }
1448 if (j == m->count)
1449 continue;
1450
1451 /* Sections 0..j-1 stay in this (current) segment,
1452 the remainder are put in a new segment.
1453 The scan resumes with the new segment. */
1454
1455 amt = sizeof (struct elf_segment_map);
1456 amt += (m->count - j - 1) * sizeof (asection *);
1457 n = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
1458 if (n == NULL)
1459 return FALSE;
1460
1461 n->p_type = PT_LOAD;
1462 n->count = m->count - j;
1463 for (k = 0; k < n->count; ++k)
1464 n->sections[k] = m->sections[j + k];
1465 m->count = j;
1466 m->p_size_valid = 0;
1467 n->next = m->next;
1468 m->next = n;
1469 }
1470
1471 return TRUE;
1472 }
1473
1474 /* Add extra PPC sections -- Note, for now, make .sbss2 and
1475 .PPC.EMB.sbss0 a normal section, and not a bss section so
1476 that the linker doesn't crater when trying to make more than
1477 2 sections. */
1478
1479 static const struct bfd_elf_special_section ppc_elf_special_sections[] =
1480 {
1481 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, SHF_ALLOC + SHF_EXECINSTR },
1482 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1483 { STRING_COMMA_LEN (".sbss2"), -2, SHT_PROGBITS, SHF_ALLOC },
1484 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1485 { STRING_COMMA_LEN (".sdata2"), -2, SHT_PROGBITS, SHF_ALLOC },
1486 { STRING_COMMA_LEN (".tags"), 0, SHT_ORDERED, SHF_ALLOC },
1487 { STRING_COMMA_LEN (APUINFO_SECTION_NAME), 0, SHT_NOTE, 0 },
1488 { STRING_COMMA_LEN (".PPC.EMB.sbss0"), 0, SHT_PROGBITS, SHF_ALLOC },
1489 { STRING_COMMA_LEN (".PPC.EMB.sdata0"), 0, SHT_PROGBITS, SHF_ALLOC },
1490 { NULL, 0, 0, 0, 0 }
1491 };
1492
1493 /* This is what we want for new plt/got. */
1494 static struct bfd_elf_special_section ppc_alt_plt =
1495 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC };
1496
1497 static const struct bfd_elf_special_section *
1498 ppc_elf_get_sec_type_attr (bfd *abfd, asection *sec)
1499 {
1500 const struct bfd_elf_special_section *ssect;
1501
1502 /* See if this is one of the special sections. */
1503 if (sec->name == NULL)
1504 return NULL;
1505
1506 ssect = _bfd_elf_get_special_section (sec->name, ppc_elf_special_sections,
1507 sec->use_rela_p);
1508 if (ssect != NULL)
1509 {
1510 if (ssect == ppc_elf_special_sections && (sec->flags & SEC_LOAD) != 0)
1511 ssect = &ppc_alt_plt;
1512 return ssect;
1513 }
1514
1515 return _bfd_elf_get_sec_type_attr (abfd, sec);
1516 }
1517 \f
1518 /* Very simple linked list structure for recording apuinfo values. */
1519 typedef struct apuinfo_list
1520 {
1521 struct apuinfo_list *next;
1522 unsigned long value;
1523 }
1524 apuinfo_list;
1525
1526 static apuinfo_list *head;
1527 static bfd_boolean apuinfo_set;
1528
1529 static void
1530 apuinfo_list_init (void)
1531 {
1532 head = NULL;
1533 apuinfo_set = FALSE;
1534 }
1535
1536 static void
1537 apuinfo_list_add (unsigned long value)
1538 {
1539 apuinfo_list *entry = head;
1540
1541 while (entry != NULL)
1542 {
1543 if (entry->value == value)
1544 return;
1545 entry = entry->next;
1546 }
1547
1548 entry = bfd_malloc (sizeof (* entry));
1549 if (entry == NULL)
1550 return;
1551
1552 entry->value = value;
1553 entry->next = head;
1554 head = entry;
1555 }
1556
1557 static unsigned
1558 apuinfo_list_length (void)
1559 {
1560 apuinfo_list *entry;
1561 unsigned long count;
1562
1563 for (entry = head, count = 0;
1564 entry;
1565 entry = entry->next)
1566 ++ count;
1567
1568 return count;
1569 }
1570
1571 static inline unsigned long
1572 apuinfo_list_element (unsigned long number)
1573 {
1574 apuinfo_list * entry;
1575
1576 for (entry = head;
1577 entry && number --;
1578 entry = entry->next)
1579 ;
1580
1581 return entry ? entry->value : 0;
1582 }
1583
1584 static void
1585 apuinfo_list_finish (void)
1586 {
1587 apuinfo_list *entry;
1588
1589 for (entry = head; entry;)
1590 {
1591 apuinfo_list *next = entry->next;
1592 free (entry);
1593 entry = next;
1594 }
1595
1596 head = NULL;
1597 }
1598
1599 /* Scan the input BFDs and create a linked list of
1600 the APUinfo values that will need to be emitted. */
1601
1602 static void
1603 ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info)
1604 {
1605 bfd *ibfd;
1606 asection *asec;
1607 char *buffer = NULL;
1608 bfd_size_type largest_input_size = 0;
1609 unsigned i;
1610 unsigned long length;
1611 const char *error_message = NULL;
1612
1613 if (link_info == NULL)
1614 return;
1615
1616 apuinfo_list_init ();
1617
1618 /* Read in the input sections contents. */
1619 for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link.next)
1620 {
1621 unsigned long datum;
1622
1623 asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
1624 if (asec == NULL)
1625 continue;
1626
1627 /* xgettext:c-format */
1628 error_message = _("corrupt %s section in %pB");
1629 length = asec->size;
1630 if (length < 20)
1631 goto fail;
1632
1633 apuinfo_set = TRUE;
1634 if (largest_input_size < asec->size)
1635 {
1636 free (buffer);
1637 largest_input_size = asec->size;
1638 buffer = bfd_malloc (largest_input_size);
1639 if (!buffer)
1640 return;
1641 }
1642
1643 if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0
1644 || (bfd_bread (buffer, length, ibfd) != length))
1645 {
1646 /* xgettext:c-format */
1647 error_message = _("unable to read in %s section from %pB");
1648 goto fail;
1649 }
1650
1651 /* Verify the contents of the header. Note - we have to
1652 extract the values this way in order to allow for a
1653 host whose endian-ness is different from the target. */
1654 datum = bfd_get_32 (ibfd, buffer);
1655 if (datum != sizeof APUINFO_LABEL)
1656 goto fail;
1657
1658 datum = bfd_get_32 (ibfd, buffer + 8);
1659 if (datum != 0x2)
1660 goto fail;
1661
1662 if (strcmp (buffer + 12, APUINFO_LABEL) != 0)
1663 goto fail;
1664
1665 /* Get the number of bytes used for apuinfo entries. */
1666 datum = bfd_get_32 (ibfd, buffer + 4);
1667 if (datum + 20 != length)
1668 goto fail;
1669
1670 /* Scan the apuinfo section, building a list of apuinfo numbers. */
1671 for (i = 0; i < datum; i += 4)
1672 apuinfo_list_add (bfd_get_32 (ibfd, buffer + 20 + i));
1673 }
1674
1675 error_message = NULL;
1676
1677 if (apuinfo_set)
1678 {
1679 /* Compute the size of the output section. */
1680 unsigned num_entries = apuinfo_list_length ();
1681
1682 /* Set the output section size, if it exists. */
1683 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
1684
1685 if (asec && !bfd_set_section_size (asec, 20 + num_entries * 4))
1686 {
1687 ibfd = abfd;
1688 /* xgettext:c-format */
1689 error_message = _("warning: unable to set size of %s section in %pB");
1690 }
1691 }
1692
1693 fail:
1694 free (buffer);
1695
1696 if (error_message)
1697 _bfd_error_handler (error_message, APUINFO_SECTION_NAME, ibfd);
1698 }
1699
1700 /* Prevent the output section from accumulating the input sections'
1701 contents. We have already stored this in our linked list structure. */
1702
1703 static bfd_boolean
1704 ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED,
1705 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
1706 asection *asec,
1707 bfd_byte *contents ATTRIBUTE_UNUSED)
1708 {
1709 return apuinfo_set && strcmp (asec->name, APUINFO_SECTION_NAME) == 0;
1710 }
1711
1712 /* Finally we can generate the output section. */
1713
1714 static void
1715 ppc_final_write_processing (bfd *abfd)
1716 {
1717 bfd_byte *buffer;
1718 asection *asec;
1719 unsigned i;
1720 unsigned num_entries;
1721 bfd_size_type length;
1722
1723 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
1724 if (asec == NULL)
1725 return;
1726
1727 if (!apuinfo_set)
1728 return;
1729
1730 length = asec->size;
1731 if (length < 20)
1732 return;
1733
1734 buffer = bfd_malloc (length);
1735 if (buffer == NULL)
1736 {
1737 _bfd_error_handler
1738 (_("failed to allocate space for new APUinfo section"));
1739 return;
1740 }
1741
1742 /* Create the apuinfo header. */
1743 num_entries = apuinfo_list_length ();
1744 bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer);
1745 bfd_put_32 (abfd, num_entries * 4, buffer + 4);
1746 bfd_put_32 (abfd, 0x2, buffer + 8);
1747 strcpy ((char *) buffer + 12, APUINFO_LABEL);
1748
1749 length = 20;
1750 for (i = 0; i < num_entries; i++)
1751 {
1752 bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
1753 length += 4;
1754 }
1755
1756 if (length != asec->size)
1757 _bfd_error_handler (_("failed to compute new APUinfo section"));
1758
1759 if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
1760 _bfd_error_handler (_("failed to install new APUinfo section"));
1761
1762 free (buffer);
1763
1764 apuinfo_list_finish ();
1765 }
1766
1767 static bfd_boolean
1768 ppc_elf_final_write_processing (bfd *abfd)
1769 {
1770 ppc_final_write_processing (abfd);
1771 return _bfd_elf_final_write_processing (abfd);
1772 }
1773 \f
1774 static bfd_boolean
1775 is_nonpic_glink_stub (bfd *abfd, asection *glink, bfd_vma off)
1776 {
1777 bfd_byte buf[4 * 4];
1778
1779 if (!bfd_get_section_contents (abfd, glink, buf, off, sizeof buf))
1780 return FALSE;
1781
1782 return ((bfd_get_32 (abfd, buf + 0) & 0xffff0000) == LIS_11
1783 && (bfd_get_32 (abfd, buf + 4) & 0xffff0000) == LWZ_11_11
1784 && bfd_get_32 (abfd, buf + 8) == MTCTR_11
1785 && bfd_get_32 (abfd, buf + 12) == BCTR);
1786 }
1787
1788 static bfd_boolean
1789 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
1790 {
1791 bfd_vma vma = *(bfd_vma *) ptr;
1792 return ((section->flags & SEC_ALLOC) != 0
1793 && section->vma <= vma
1794 && vma < section->vma + section->size);
1795 }
1796
1797 static long
1798 ppc_elf_get_synthetic_symtab (bfd *abfd, long symcount, asymbol **syms,
1799 long dynsymcount, asymbol **dynsyms,
1800 asymbol **ret)
1801 {
1802 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
1803 asection *plt, *relplt, *dynamic, *glink;
1804 bfd_vma glink_vma = 0;
1805 bfd_vma resolv_vma = 0;
1806 bfd_vma stub_off;
1807 asymbol *s;
1808 arelent *p;
1809 size_t count, i, stub_delta;
1810 size_t size;
1811 char *names;
1812 bfd_byte buf[4];
1813
1814 *ret = NULL;
1815
1816 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
1817 return 0;
1818
1819 if (dynsymcount <= 0)
1820 return 0;
1821
1822 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
1823 if (relplt == NULL)
1824 return 0;
1825
1826 plt = bfd_get_section_by_name (abfd, ".plt");
1827 if (plt == NULL)
1828 return 0;
1829
1830 /* Call common code to handle old-style executable PLTs. */
1831 if (elf_section_flags (plt) & SHF_EXECINSTR)
1832 return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms,
1833 dynsymcount, dynsyms, ret);
1834
1835 /* If this object was prelinked, the prelinker stored the address
1836 of .glink at got[1]. If it wasn't prelinked, got[1] will be zero. */
1837 dynamic = bfd_get_section_by_name (abfd, ".dynamic");
1838 if (dynamic != NULL)
1839 {
1840 bfd_byte *dynbuf, *extdyn, *extdynend;
1841 size_t extdynsize;
1842 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1843
1844 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
1845 return -1;
1846
1847 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1848 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1849
1850 extdyn = dynbuf;
1851 extdynend = extdyn + dynamic->size;
1852 for (; extdyn < extdynend; extdyn += extdynsize)
1853 {
1854 Elf_Internal_Dyn dyn;
1855 (*swap_dyn_in) (abfd, extdyn, &dyn);
1856
1857 if (dyn.d_tag == DT_NULL)
1858 break;
1859
1860 if (dyn.d_tag == DT_PPC_GOT)
1861 {
1862 unsigned int g_o_t = dyn.d_un.d_val;
1863 asection *got = bfd_get_section_by_name (abfd, ".got");
1864 if (got != NULL
1865 && bfd_get_section_contents (abfd, got, buf,
1866 g_o_t - got->vma + 4, 4))
1867 glink_vma = bfd_get_32 (abfd, buf);
1868 break;
1869 }
1870 }
1871 free (dynbuf);
1872 }
1873
1874 /* Otherwise we read the first plt entry. */
1875 if (glink_vma == 0)
1876 {
1877 if (bfd_get_section_contents (abfd, plt, buf, 0, 4))
1878 glink_vma = bfd_get_32 (abfd, buf);
1879 }
1880
1881 if (glink_vma == 0)
1882 return 0;
1883
1884 /* The .glink section usually does not survive the final
1885 link; search for the section (usually .text) where the
1886 glink stubs now reside. */
1887 glink = bfd_sections_find_if (abfd, section_covers_vma, &glink_vma);
1888 if (glink == NULL)
1889 return 0;
1890
1891 /* Determine glink PLT resolver by reading the relative branch
1892 from the first glink stub. */
1893 if (bfd_get_section_contents (abfd, glink, buf,
1894 glink_vma - glink->vma, 4))
1895 {
1896 unsigned int insn = bfd_get_32 (abfd, buf);
1897
1898 /* The first glink stub may either branch to the resolver ... */
1899 insn ^= B;
1900 if ((insn & ~0x3fffffc) == 0)
1901 resolv_vma = glink_vma + (insn ^ 0x2000000) - 0x2000000;
1902
1903 /* ... or fall through a bunch of NOPs. */
1904 else if ((insn ^ B ^ NOP) == 0)
1905 for (i = 4;
1906 bfd_get_section_contents (abfd, glink, buf,
1907 glink_vma - glink->vma + i, 4);
1908 i += 4)
1909 if (bfd_get_32 (abfd, buf) != NOP)
1910 {
1911 resolv_vma = glink_vma + i;
1912 break;
1913 }
1914 }
1915
1916 count = relplt->size / sizeof (Elf32_External_Rela);
1917 /* If the stubs are those for -shared/-pie then we might have
1918 multiple stubs for each plt entry. If that is the case then
1919 there is no way to associate stubs with their plt entries short
1920 of figuring out the GOT pointer value used in the stub.
1921 The offsets tested here need to cover all possible values of
1922 GLINK_ENTRY_SIZE for other than __tls_get_addr_opt. */
1923 stub_off = glink_vma - glink->vma;
1924 for (stub_delta = 16; stub_delta <= 32; stub_delta += 8)
1925 if (is_nonpic_glink_stub (abfd, glink, stub_off - stub_delta))
1926 break;
1927 if (stub_delta > 32)
1928 return 0;
1929
1930 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
1931 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
1932 return -1;
1933
1934 size = count * sizeof (asymbol);
1935 p = relplt->relocation;
1936 for (i = 0; i < count; i++, p++)
1937 {
1938 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
1939 if (p->addend != 0)
1940 size += sizeof ("+0x") - 1 + 8;
1941 }
1942
1943 size += sizeof (asymbol) + sizeof ("__glink");
1944
1945 if (resolv_vma)
1946 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
1947
1948 s = *ret = bfd_malloc (size);
1949 if (s == NULL)
1950 return -1;
1951
1952 stub_off = glink_vma - glink->vma;
1953 names = (char *) (s + count + 1 + (resolv_vma != 0));
1954 p = relplt->relocation + count - 1;
1955 for (i = 0; i < count; i++)
1956 {
1957 size_t len;
1958
1959 stub_off -= stub_delta;
1960 if (strcmp ((*p->sym_ptr_ptr)->name, "__tls_get_addr_opt") == 0)
1961 stub_off -= 32;
1962 *s = **p->sym_ptr_ptr;
1963 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
1964 we are defining a symbol, ensure one of them is set. */
1965 if ((s->flags & BSF_LOCAL) == 0)
1966 s->flags |= BSF_GLOBAL;
1967 s->flags |= BSF_SYNTHETIC;
1968 s->section = glink;
1969 s->value = stub_off;
1970 s->name = names;
1971 s->udata.p = NULL;
1972 len = strlen ((*p->sym_ptr_ptr)->name);
1973 memcpy (names, (*p->sym_ptr_ptr)->name, len);
1974 names += len;
1975 if (p->addend != 0)
1976 {
1977 memcpy (names, "+0x", sizeof ("+0x") - 1);
1978 names += sizeof ("+0x") - 1;
1979 bfd_sprintf_vma (abfd, names, p->addend);
1980 names += strlen (names);
1981 }
1982 memcpy (names, "@plt", sizeof ("@plt"));
1983 names += sizeof ("@plt");
1984 ++s;
1985 --p;
1986 }
1987
1988 /* Add a symbol at the start of the glink branch table. */
1989 memset (s, 0, sizeof *s);
1990 s->the_bfd = abfd;
1991 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
1992 s->section = glink;
1993 s->value = glink_vma - glink->vma;
1994 s->name = names;
1995 memcpy (names, "__glink", sizeof ("__glink"));
1996 names += sizeof ("__glink");
1997 s++;
1998 count++;
1999
2000 if (resolv_vma)
2001 {
2002 /* Add a symbol for the glink PLT resolver. */
2003 memset (s, 0, sizeof *s);
2004 s->the_bfd = abfd;
2005 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
2006 s->section = glink;
2007 s->value = resolv_vma - glink->vma;
2008 s->name = names;
2009 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
2010 names += sizeof ("__glink_PLTresolve");
2011 s++;
2012 count++;
2013 }
2014
2015 return count;
2016 }
2017 \f
2018 /* The following functions are specific to the ELF linker, while
2019 functions above are used generally. They appear in this file more
2020 or less in the order in which they are called. eg.
2021 ppc_elf_check_relocs is called early in the link process,
2022 ppc_elf_finish_dynamic_sections is one of the last functions
2023 called. */
2024
2025 /* Track PLT entries needed for a given symbol. We might need more
2026 than one glink entry per symbol when generating a pic binary. */
2027 struct plt_entry
2028 {
2029 struct plt_entry *next;
2030
2031 /* -fPIC uses multiple GOT sections, one per file, called ".got2".
2032 This field stores the offset into .got2 used to initialise the
2033 GOT pointer reg. It will always be at least 32768. (Current
2034 gcc always uses an offset of 32768, but ld -r will pack .got2
2035 sections together resulting in larger offsets). */
2036 bfd_vma addend;
2037
2038 /* The .got2 section. */
2039 asection *sec;
2040
2041 /* PLT refcount or offset. */
2042 union
2043 {
2044 bfd_signed_vma refcount;
2045 bfd_vma offset;
2046 } plt;
2047
2048 /* .glink stub offset. */
2049 bfd_vma glink_offset;
2050 };
2051
2052 /* Of those relocs that might be copied as dynamic relocs, this
2053 function selects those that must be copied when linking a shared
2054 library or PIE, even when the symbol is local. */
2055
2056 static int
2057 must_be_dyn_reloc (struct bfd_link_info *info,
2058 enum elf_ppc_reloc_type r_type)
2059 {
2060 switch (r_type)
2061 {
2062 default:
2063 /* Only relative relocs can be resolved when the object load
2064 address isn't fixed. DTPREL32 is excluded because the
2065 dynamic linker needs to differentiate global dynamic from
2066 local dynamic __tls_index pairs when PPC_OPT_TLS is set. */
2067 return 1;
2068
2069 case R_PPC_REL24:
2070 case R_PPC_REL14:
2071 case R_PPC_REL14_BRTAKEN:
2072 case R_PPC_REL14_BRNTAKEN:
2073 case R_PPC_REL32:
2074 return 0;
2075
2076 case R_PPC_TPREL32:
2077 case R_PPC_TPREL16:
2078 case R_PPC_TPREL16_LO:
2079 case R_PPC_TPREL16_HI:
2080 case R_PPC_TPREL16_HA:
2081 /* These relocations are relative but in a shared library the
2082 linker doesn't know the thread pointer base. */
2083 return bfd_link_dll (info);
2084 }
2085 }
2086
2087 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2088 copying dynamic variables from a shared lib into an app's dynbss
2089 section, and instead use a dynamic relocation to point into the
2090 shared lib. */
2091 #define ELIMINATE_COPY_RELOCS 1
2092
2093 /* Used to track dynamic relocations for local symbols. */
2094 struct ppc_dyn_relocs
2095 {
2096 struct ppc_dyn_relocs *next;
2097
2098 /* The input section of the reloc. */
2099 asection *sec;
2100
2101 /* Total number of relocs copied for the input section. */
2102 unsigned int count : 31;
2103
2104 /* Whether this entry is for STT_GNU_IFUNC symbols. */
2105 unsigned int ifunc : 1;
2106 };
2107
2108 /* PPC ELF linker hash entry. */
2109
2110 struct ppc_elf_link_hash_entry
2111 {
2112 struct elf_link_hash_entry elf;
2113
2114 /* If this symbol is used in the linker created sections, the processor
2115 specific backend uses this field to map the field into the offset
2116 from the beginning of the section. */
2117 elf_linker_section_pointers_t *linker_section_pointer;
2118
2119 /* Contexts in which symbol is used in the GOT.
2120 Bits are or'd into the mask as the corresponding relocs are
2121 encountered during check_relocs, with TLS_TLS being set when any
2122 of the other TLS bits are set. tls_optimize clears bits when
2123 optimizing to indicate the corresponding GOT entry type is not
2124 needed. If set, TLS_TLS is never cleared. tls_optimize may also
2125 set TLS_GDIE when a GD reloc turns into an IE one.
2126 These flags are also kept for local symbols. */
2127 #define TLS_TLS 1 /* Any TLS reloc. */
2128 #define TLS_GD 2 /* GD reloc. */
2129 #define TLS_LD 4 /* LD reloc. */
2130 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
2131 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
2132 #define TLS_MARK 32 /* __tls_get_addr call marked. */
2133 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
2134 unsigned char tls_mask;
2135
2136 /* The above field is also used to mark function symbols. In which
2137 case TLS_TLS will be 0. */
2138 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
2139 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
2140 #define NON_GOT 256 /* local symbol plt, not stored. */
2141
2142 /* Nonzero if we have seen a small data relocation referring to this
2143 symbol. */
2144 unsigned char has_sda_refs : 1;
2145
2146 /* Flag use of given relocations. */
2147 unsigned char has_addr16_ha : 1;
2148 unsigned char has_addr16_lo : 1;
2149 };
2150
2151 #define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent))
2152
2153 /* PPC ELF linker hash table. */
2154
2155 struct ppc_elf_link_hash_table
2156 {
2157 struct elf_link_hash_table elf;
2158
2159 /* Various options passed from the linker. */
2160 struct ppc_elf_params *params;
2161
2162 /* Short-cuts to get to dynamic linker sections. */
2163 asection *glink;
2164 asection *dynsbss;
2165 asection *relsbss;
2166 elf_linker_section_t sdata[2];
2167 asection *sbss;
2168 asection *glink_eh_frame;
2169 asection *pltlocal;
2170 asection *relpltlocal;
2171
2172 /* The (unloaded but important) .rela.plt.unloaded on VxWorks. */
2173 asection *srelplt2;
2174
2175 /* Shortcut to __tls_get_addr. */
2176 struct elf_link_hash_entry *tls_get_addr;
2177
2178 /* The bfd that forced an old-style PLT. */
2179 bfd *old_bfd;
2180
2181 /* TLS local dynamic got entry handling. */
2182 union {
2183 bfd_signed_vma refcount;
2184 bfd_vma offset;
2185 } tlsld_got;
2186
2187 /* Offset of branch table to PltResolve function in glink. */
2188 bfd_vma glink_pltresolve;
2189
2190 /* Size of reserved GOT entries. */
2191 unsigned int got_header_size;
2192 /* Non-zero if allocating the header left a gap. */
2193 unsigned int got_gap;
2194
2195 /* The type of PLT we have chosen to use. */
2196 enum ppc_elf_plt_type plt_type;
2197
2198 /* Whether there exist local gnu indirect function resolvers,
2199 referenced by dynamic relocations. */
2200 unsigned int local_ifunc_resolver:1;
2201 unsigned int maybe_local_ifunc_resolver:1;
2202
2203 /* Set if tls optimization is enabled. */
2204 unsigned int do_tls_opt:1;
2205
2206 /* Set if inline plt calls should be converted to direct calls. */
2207 unsigned int can_convert_all_inline_plt:1;
2208
2209 /* The size of PLT entries. */
2210 int plt_entry_size;
2211 /* The distance between adjacent PLT slots. */
2212 int plt_slot_size;
2213 /* The size of the first PLT entry. */
2214 int plt_initial_entry_size;
2215
2216 /* Small local sym cache. */
2217 struct sym_cache sym_cache;
2218 };
2219
2220 /* Rename some of the generic section flags to better document how they
2221 are used for ppc32. The flags are only valid for ppc32 elf objects. */
2222
2223 /* Nonzero if this section has TLS related relocations. */
2224 #define has_tls_reloc sec_flg0
2225
2226 /* Nonzero if this section has a call to __tls_get_addr lacking marker
2227 relocs. */
2228 #define nomark_tls_get_addr sec_flg1
2229
2230 /* Flag set when PLTCALL relocs are detected. */
2231 #define has_pltcall sec_flg2
2232
2233 /* Get the PPC ELF linker hash table from a link_info structure. */
2234
2235 #define ppc_elf_hash_table(p) \
2236 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2237 == PPC32_ELF_DATA ? ((struct ppc_elf_link_hash_table *) ((p)->hash)) : NULL)
2238
2239 /* Create an entry in a PPC ELF linker hash table. */
2240
2241 static struct bfd_hash_entry *
2242 ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
2243 struct bfd_hash_table *table,
2244 const char *string)
2245 {
2246 /* Allocate the structure if it has not already been allocated by a
2247 subclass. */
2248 if (entry == NULL)
2249 {
2250 entry = bfd_hash_allocate (table,
2251 sizeof (struct ppc_elf_link_hash_entry));
2252 if (entry == NULL)
2253 return entry;
2254 }
2255
2256 /* Call the allocation method of the superclass. */
2257 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2258 if (entry != NULL)
2259 {
2260 ppc_elf_hash_entry (entry)->linker_section_pointer = NULL;
2261 ppc_elf_hash_entry (entry)->tls_mask = 0;
2262 ppc_elf_hash_entry (entry)->has_sda_refs = 0;
2263 }
2264
2265 return entry;
2266 }
2267
2268 /* Create a PPC ELF linker hash table. */
2269
2270 static struct bfd_link_hash_table *
2271 ppc_elf_link_hash_table_create (bfd *abfd)
2272 {
2273 struct ppc_elf_link_hash_table *ret;
2274 static struct ppc_elf_params default_params
2275 = { PLT_OLD, 0, 0, 1, 0, 0, 12, 0, 0, 0 };
2276
2277 ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table));
2278 if (ret == NULL)
2279 return NULL;
2280
2281 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
2282 ppc_elf_link_hash_newfunc,
2283 sizeof (struct ppc_elf_link_hash_entry),
2284 PPC32_ELF_DATA))
2285 {
2286 free (ret);
2287 return NULL;
2288 }
2289
2290 ret->elf.init_plt_refcount.refcount = 0;
2291 ret->elf.init_plt_refcount.glist = NULL;
2292 ret->elf.init_plt_offset.offset = 0;
2293 ret->elf.init_plt_offset.glist = NULL;
2294
2295 ret->params = &default_params;
2296
2297 ret->sdata[0].name = ".sdata";
2298 ret->sdata[0].sym_name = "_SDA_BASE_";
2299 ret->sdata[0].bss_name = ".sbss";
2300
2301 ret->sdata[1].name = ".sdata2";
2302 ret->sdata[1].sym_name = "_SDA2_BASE_";
2303 ret->sdata[1].bss_name = ".sbss2";
2304
2305 ret->plt_entry_size = 12;
2306 ret->plt_slot_size = 8;
2307 ret->plt_initial_entry_size = 72;
2308
2309 return &ret->elf.root;
2310 }
2311
2312 /* Hook linker params into hash table. */
2313
2314 void
2315 ppc_elf_link_params (struct bfd_link_info *info, struct ppc_elf_params *params)
2316 {
2317 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
2318
2319 if (htab)
2320 htab->params = params;
2321 params->pagesize_p2 = bfd_log2 (params->pagesize);
2322 }
2323
2324 /* Create .got and the related sections. */
2325
2326 static bfd_boolean
2327 ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info)
2328 {
2329 struct ppc_elf_link_hash_table *htab;
2330
2331 if (!_bfd_elf_create_got_section (abfd, info))
2332 return FALSE;
2333
2334 htab = ppc_elf_hash_table (info);
2335 if (htab->elf.target_os != is_vxworks)
2336 {
2337 /* The powerpc .got has a blrl instruction in it. Mark it
2338 executable. */
2339 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS
2340 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2341 if (!bfd_set_section_flags (htab->elf.sgot, flags))
2342 return FALSE;
2343 }
2344
2345 return TRUE;
2346 }
2347
2348 /* Create a special linker section, used for R_PPC_EMB_SDAI16 and
2349 R_PPC_EMB_SDA2I16 pointers. These sections become part of .sdata
2350 and .sdata2. Create _SDA_BASE_ and _SDA2_BASE too. */
2351
2352 static bfd_boolean
2353 ppc_elf_create_linker_section (bfd *abfd,
2354 struct bfd_link_info *info,
2355 flagword flags,
2356 elf_linker_section_t *lsect)
2357 {
2358 asection *s;
2359
2360 flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2361 | SEC_LINKER_CREATED);
2362
2363 s = bfd_make_section_anyway_with_flags (abfd, lsect->name, flags);
2364 if (s == NULL)
2365 return FALSE;
2366 lsect->section = s;
2367
2368 /* Define the sym on the first section of this name. */
2369 s = bfd_get_section_by_name (abfd, lsect->name);
2370
2371 lsect->sym = _bfd_elf_define_linkage_sym (abfd, info, s, lsect->sym_name);
2372 if (lsect->sym == NULL)
2373 return FALSE;
2374 lsect->sym->root.u.def.value = 0x8000;
2375 return TRUE;
2376 }
2377
2378 static bfd_boolean
2379 ppc_elf_create_glink (bfd *abfd, struct bfd_link_info *info)
2380 {
2381 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
2382 asection *s;
2383 flagword flags;
2384 int p2align;
2385
2386 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS
2387 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2388 s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags);
2389 htab->glink = s;
2390 p2align = htab->params->ppc476_workaround ? 6 : 4;
2391 if (p2align < htab->params->plt_stub_align)
2392 p2align = htab->params->plt_stub_align;
2393 if (s == NULL
2394 || !bfd_set_section_alignment (s, p2align))
2395 return FALSE;
2396
2397 if (!info->no_ld_generated_unwind_info)
2398 {
2399 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
2400 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2401 s = bfd_make_section_anyway_with_flags (abfd, ".eh_frame", flags);
2402 htab->glink_eh_frame = s;
2403 if (s == NULL
2404 || !bfd_set_section_alignment (s, 2))
2405 return FALSE;
2406 }
2407
2408 flags = SEC_ALLOC | SEC_LINKER_CREATED;
2409 s = bfd_make_section_anyway_with_flags (abfd, ".iplt", flags);
2410 htab->elf.iplt = s;
2411 if (s == NULL
2412 || !bfd_set_section_alignment (s, 4))
2413 return FALSE;
2414
2415 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
2416 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2417 s = bfd_make_section_anyway_with_flags (abfd, ".rela.iplt", flags);
2418 htab->elf.irelplt = s;
2419 if (s == NULL
2420 || ! bfd_set_section_alignment (s, 2))
2421 return FALSE;
2422
2423 /* Local plt entries. */
2424 flags = (SEC_ALLOC | SEC_LOAD
2425 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2426 htab->pltlocal = bfd_make_section_anyway_with_flags (abfd, ".branch_lt",
2427 flags);
2428 if (htab->pltlocal == NULL
2429 || !bfd_set_section_alignment (htab->pltlocal, 2))
2430 return FALSE;
2431
2432 if (bfd_link_pic (info))
2433 {
2434 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2435 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2436 htab->relpltlocal
2437 = bfd_make_section_anyway_with_flags (abfd, ".rela.branch_lt", flags);
2438 if (htab->relpltlocal == NULL
2439 || !bfd_set_section_alignment (htab->relpltlocal, 2))
2440 return FALSE;
2441 }
2442
2443 if (!ppc_elf_create_linker_section (abfd, info, 0,
2444 &htab->sdata[0]))
2445 return FALSE;
2446
2447 if (!ppc_elf_create_linker_section (abfd, info, SEC_READONLY,
2448 &htab->sdata[1]))
2449 return FALSE;
2450
2451 return TRUE;
2452 }
2453
2454 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
2455 to output sections (just like _bfd_elf_create_dynamic_sections has
2456 to create .dynbss and .rela.bss). */
2457
2458 static bfd_boolean
2459 ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2460 {
2461 struct ppc_elf_link_hash_table *htab;
2462 asection *s;
2463 flagword flags;
2464
2465 htab = ppc_elf_hash_table (info);
2466
2467 if (htab->elf.sgot == NULL
2468 && !ppc_elf_create_got (abfd, info))
2469 return FALSE;
2470
2471 if (!_bfd_elf_create_dynamic_sections (abfd, info))
2472 return FALSE;
2473
2474 if (htab->glink == NULL
2475 && !ppc_elf_create_glink (abfd, info))
2476 return FALSE;
2477
2478 s = bfd_make_section_anyway_with_flags (abfd, ".dynsbss",
2479 SEC_ALLOC | SEC_LINKER_CREATED);
2480 htab->dynsbss = s;
2481 if (s == NULL)
2482 return FALSE;
2483
2484 if (! bfd_link_pic (info))
2485 {
2486 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
2487 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2488 s = bfd_make_section_anyway_with_flags (abfd, ".rela.sbss", flags);
2489 htab->relsbss = s;
2490 if (s == NULL
2491 || !bfd_set_section_alignment (s, 2))
2492 return FALSE;
2493 }
2494
2495 if (htab->elf.target_os == is_vxworks
2496 && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
2497 return FALSE;
2498
2499 s = htab->elf.splt;
2500 flags = SEC_ALLOC | SEC_CODE | SEC_LINKER_CREATED;
2501 if (htab->plt_type == PLT_VXWORKS)
2502 /* The VxWorks PLT is a loaded section with contents. */
2503 flags |= SEC_HAS_CONTENTS | SEC_LOAD | SEC_READONLY;
2504 return bfd_set_section_flags (s, flags);
2505 }
2506
2507 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2508
2509 static void
2510 ppc_elf_copy_indirect_symbol (struct bfd_link_info *info,
2511 struct elf_link_hash_entry *dir,
2512 struct elf_link_hash_entry *ind)
2513 {
2514 struct ppc_elf_link_hash_entry *edir, *eind;
2515
2516 edir = (struct ppc_elf_link_hash_entry *) dir;
2517 eind = (struct ppc_elf_link_hash_entry *) ind;
2518
2519 edir->tls_mask |= eind->tls_mask;
2520 edir->has_sda_refs |= eind->has_sda_refs;
2521
2522 if (edir->elf.versioned != versioned_hidden)
2523 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
2524 edir->elf.ref_regular |= eind->elf.ref_regular;
2525 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
2526 edir->elf.non_got_ref |= eind->elf.non_got_ref;
2527 edir->elf.needs_plt |= eind->elf.needs_plt;
2528 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
2529
2530 /* If we were called to copy over info for a weak sym, that's all. */
2531 if (eind->elf.root.type != bfd_link_hash_indirect)
2532 return;
2533
2534 if (ind->dyn_relocs != NULL)
2535 {
2536 if (dir->dyn_relocs != NULL)
2537 {
2538 struct elf_dyn_relocs **pp;
2539 struct elf_dyn_relocs *p;
2540
2541 /* Add reloc counts against the indirect sym to the direct sym
2542 list. Merge any entries against the same section. */
2543 for (pp = &ind->dyn_relocs; (p = *pp) != NULL; )
2544 {
2545 struct elf_dyn_relocs *q;
2546
2547 for (q = dir->dyn_relocs; q != NULL; q = q->next)
2548 if (q->sec == p->sec)
2549 {
2550 q->pc_count += p->pc_count;
2551 q->count += p->count;
2552 *pp = p->next;
2553 break;
2554 }
2555 if (q == NULL)
2556 pp = &p->next;
2557 }
2558 *pp = dir->dyn_relocs;
2559 }
2560
2561 dir->dyn_relocs = ind->dyn_relocs;
2562 ind->dyn_relocs = NULL;
2563 }
2564
2565 /* Copy over the GOT refcount entries that we may have already seen to
2566 the symbol which just became indirect. */
2567 edir->elf.got.refcount += eind->elf.got.refcount;
2568 eind->elf.got.refcount = 0;
2569
2570 /* And plt entries. */
2571 if (eind->elf.plt.plist != NULL)
2572 {
2573 if (edir->elf.plt.plist != NULL)
2574 {
2575 struct plt_entry **entp;
2576 struct plt_entry *ent;
2577
2578 for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; )
2579 {
2580 struct plt_entry *dent;
2581
2582 for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next)
2583 if (dent->sec == ent->sec && dent->addend == ent->addend)
2584 {
2585 dent->plt.refcount += ent->plt.refcount;
2586 *entp = ent->next;
2587 break;
2588 }
2589 if (dent == NULL)
2590 entp = &ent->next;
2591 }
2592 *entp = edir->elf.plt.plist;
2593 }
2594
2595 edir->elf.plt.plist = eind->elf.plt.plist;
2596 eind->elf.plt.plist = NULL;
2597 }
2598
2599 if (eind->elf.dynindx != -1)
2600 {
2601 if (edir->elf.dynindx != -1)
2602 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2603 edir->elf.dynstr_index);
2604 edir->elf.dynindx = eind->elf.dynindx;
2605 edir->elf.dynstr_index = eind->elf.dynstr_index;
2606 eind->elf.dynindx = -1;
2607 eind->elf.dynstr_index = 0;
2608 }
2609 }
2610
2611 /* Hook called by the linker routine which adds symbols from an object
2612 file. We use it to put .comm items in .sbss, and not .bss. */
2613
2614 static bfd_boolean
2615 ppc_elf_add_symbol_hook (bfd *abfd,
2616 struct bfd_link_info *info,
2617 Elf_Internal_Sym *sym,
2618 const char **namep ATTRIBUTE_UNUSED,
2619 flagword *flagsp ATTRIBUTE_UNUSED,
2620 asection **secp,
2621 bfd_vma *valp)
2622 {
2623 if (sym->st_shndx == SHN_COMMON
2624 && !bfd_link_relocatable (info)
2625 && is_ppc_elf (info->output_bfd)
2626 && sym->st_size <= elf_gp_size (abfd))
2627 {
2628 /* Common symbols less than or equal to -G nn bytes are automatically
2629 put into .sbss. */
2630 struct ppc_elf_link_hash_table *htab;
2631
2632 htab = ppc_elf_hash_table (info);
2633 if (htab->sbss == NULL)
2634 {
2635 flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
2636
2637 if (!htab->elf.dynobj)
2638 htab->elf.dynobj = abfd;
2639
2640 htab->sbss = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2641 ".sbss",
2642 flags);
2643 if (htab->sbss == NULL)
2644 return FALSE;
2645 }
2646
2647 *secp = htab->sbss;
2648 *valp = sym->st_size;
2649 }
2650
2651 return TRUE;
2652 }
2653 \f
2654 /* Find a linker generated pointer with a given addend and type. */
2655
2656 static elf_linker_section_pointers_t *
2657 elf_find_pointer_linker_section
2658 (elf_linker_section_pointers_t *linker_pointers,
2659 bfd_vma addend,
2660 elf_linker_section_t *lsect)
2661 {
2662 for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
2663 if (lsect == linker_pointers->lsect && addend == linker_pointers->addend)
2664 return linker_pointers;
2665
2666 return NULL;
2667 }
2668
2669 /* Allocate a pointer to live in a linker created section. */
2670
2671 static bfd_boolean
2672 elf_allocate_pointer_linker_section (bfd *abfd,
2673 elf_linker_section_t *lsect,
2674 struct elf_link_hash_entry *h,
2675 const Elf_Internal_Rela *rel)
2676 {
2677 elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
2678 elf_linker_section_pointers_t *linker_section_ptr;
2679 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
2680 bfd_size_type amt;
2681
2682 BFD_ASSERT (lsect != NULL);
2683
2684 /* Is this a global symbol? */
2685 if (h != NULL)
2686 {
2687 struct ppc_elf_link_hash_entry *eh;
2688
2689 /* Has this symbol already been allocated? If so, our work is done. */
2690 eh = (struct ppc_elf_link_hash_entry *) h;
2691 if (elf_find_pointer_linker_section (eh->linker_section_pointer,
2692 rel->r_addend,
2693 lsect))
2694 return TRUE;
2695
2696 ptr_linker_section_ptr = &eh->linker_section_pointer;
2697 }
2698 else
2699 {
2700 BFD_ASSERT (is_ppc_elf (abfd));
2701
2702 /* Allocation of a pointer to a local symbol. */
2703 elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
2704
2705 /* Allocate a table to hold the local symbols if first time. */
2706 if (!ptr)
2707 {
2708 unsigned int num_symbols = elf_symtab_hdr (abfd).sh_info;
2709
2710 amt = num_symbols;
2711 amt *= sizeof (elf_linker_section_pointers_t *);
2712 ptr = bfd_zalloc (abfd, amt);
2713
2714 if (!ptr)
2715 return FALSE;
2716
2717 elf_local_ptr_offsets (abfd) = ptr;
2718 }
2719
2720 /* Has this symbol already been allocated? If so, our work is done. */
2721 if (elf_find_pointer_linker_section (ptr[r_symndx],
2722 rel->r_addend,
2723 lsect))
2724 return TRUE;
2725
2726 ptr_linker_section_ptr = &ptr[r_symndx];
2727 }
2728
2729 /* Allocate space for a pointer in the linker section, and allocate
2730 a new pointer record from internal memory. */
2731 BFD_ASSERT (ptr_linker_section_ptr != NULL);
2732 amt = sizeof (elf_linker_section_pointers_t);
2733 linker_section_ptr = bfd_alloc (abfd, amt);
2734
2735 if (!linker_section_ptr)
2736 return FALSE;
2737
2738 linker_section_ptr->next = *ptr_linker_section_ptr;
2739 linker_section_ptr->addend = rel->r_addend;
2740 linker_section_ptr->lsect = lsect;
2741 *ptr_linker_section_ptr = linker_section_ptr;
2742
2743 if (!bfd_set_section_alignment (lsect->section, 2))
2744 return FALSE;
2745 linker_section_ptr->offset = lsect->section->size;
2746 lsect->section->size += 4;
2747
2748 #ifdef DEBUG
2749 fprintf (stderr,
2750 "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
2751 lsect->name, (long) linker_section_ptr->offset,
2752 (long) lsect->section->size);
2753 #endif
2754
2755 return TRUE;
2756 }
2757
2758 static struct plt_entry **
2759 update_local_sym_info (bfd *abfd,
2760 Elf_Internal_Shdr *symtab_hdr,
2761 unsigned long r_symndx,
2762 int tls_type)
2763 {
2764 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
2765 struct plt_entry **local_plt;
2766 unsigned char *local_got_tls_masks;
2767
2768 if (local_got_refcounts == NULL)
2769 {
2770 bfd_size_type size = symtab_hdr->sh_info;
2771
2772 size *= (sizeof (*local_got_refcounts)
2773 + sizeof (*local_plt)
2774 + sizeof (*local_got_tls_masks));
2775 local_got_refcounts = bfd_zalloc (abfd, size);
2776 if (local_got_refcounts == NULL)
2777 return NULL;
2778 elf_local_got_refcounts (abfd) = local_got_refcounts;
2779 }
2780
2781 local_plt = (struct plt_entry **) (local_got_refcounts + symtab_hdr->sh_info);
2782 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
2783 local_got_tls_masks[r_symndx] |= tls_type & 0xff;
2784 if ((tls_type & NON_GOT) == 0)
2785 local_got_refcounts[r_symndx] += 1;
2786 return local_plt + r_symndx;
2787 }
2788
2789 static bfd_boolean
2790 update_plt_info (bfd *abfd, struct plt_entry **plist,
2791 asection *sec, bfd_vma addend)
2792 {
2793 struct plt_entry *ent;
2794
2795 if (addend < 32768)
2796 sec = NULL;
2797 for (ent = *plist; ent != NULL; ent = ent->next)
2798 if (ent->sec == sec && ent->addend == addend)
2799 break;
2800 if (ent == NULL)
2801 {
2802 size_t amt = sizeof (*ent);
2803 ent = bfd_alloc (abfd, amt);
2804 if (ent == NULL)
2805 return FALSE;
2806 ent->next = *plist;
2807 ent->sec = sec;
2808 ent->addend = addend;
2809 ent->plt.refcount = 0;
2810 *plist = ent;
2811 }
2812 ent->plt.refcount += 1;
2813 return TRUE;
2814 }
2815
2816 static struct plt_entry *
2817 find_plt_ent (struct plt_entry **plist, asection *sec, bfd_vma addend)
2818 {
2819 struct plt_entry *ent;
2820
2821 if (addend < 32768)
2822 sec = NULL;
2823 for (ent = *plist; ent != NULL; ent = ent->next)
2824 if (ent->sec == sec && ent->addend == addend)
2825 break;
2826 return ent;
2827 }
2828
2829 static bfd_boolean
2830 is_branch_reloc (enum elf_ppc_reloc_type r_type)
2831 {
2832 return (r_type == R_PPC_PLTREL24
2833 || r_type == R_PPC_LOCAL24PC
2834 || r_type == R_PPC_REL24
2835 || r_type == R_PPC_REL14
2836 || r_type == R_PPC_REL14_BRTAKEN
2837 || r_type == R_PPC_REL14_BRNTAKEN
2838 || r_type == R_PPC_ADDR24
2839 || r_type == R_PPC_ADDR14
2840 || r_type == R_PPC_ADDR14_BRTAKEN
2841 || r_type == R_PPC_ADDR14_BRNTAKEN
2842 || r_type == R_PPC_VLE_REL24);
2843 }
2844
2845 /* Relocs on inline plt call sequence insns prior to the call. */
2846
2847 static bfd_boolean
2848 is_plt_seq_reloc (enum elf_ppc_reloc_type r_type)
2849 {
2850 return (r_type == R_PPC_PLT16_HA
2851 || r_type == R_PPC_PLT16_HI
2852 || r_type == R_PPC_PLT16_LO
2853 || r_type == R_PPC_PLTSEQ);
2854 }
2855
2856 static void
2857 bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
2858 {
2859 _bfd_error_handler
2860 /* xgettext:c-format */
2861 (_("%pB: relocation %s cannot be used when making a shared object"),
2862 abfd,
2863 ppc_elf_howto_table[r_type]->name);
2864 bfd_set_error (bfd_error_bad_value);
2865 }
2866
2867 /* Look through the relocs for a section during the first phase, and
2868 allocate space in the global offset table or procedure linkage
2869 table. */
2870
2871 static bfd_boolean
2872 ppc_elf_check_relocs (bfd *abfd,
2873 struct bfd_link_info *info,
2874 asection *sec,
2875 const Elf_Internal_Rela *relocs)
2876 {
2877 struct ppc_elf_link_hash_table *htab;
2878 Elf_Internal_Shdr *symtab_hdr;
2879 struct elf_link_hash_entry **sym_hashes;
2880 const Elf_Internal_Rela *rel;
2881 const Elf_Internal_Rela *rel_end;
2882 asection *got2, *sreloc;
2883 struct elf_link_hash_entry *tga;
2884
2885 if (bfd_link_relocatable (info))
2886 return TRUE;
2887
2888 #ifdef DEBUG
2889 _bfd_error_handler ("ppc_elf_check_relocs called for section %pA in %pB",
2890 sec, abfd);
2891 #endif
2892
2893 BFD_ASSERT (is_ppc_elf (abfd));
2894
2895 /* Initialize howto table if not already done. */
2896 if (!ppc_elf_howto_table[R_PPC_ADDR32])
2897 ppc_elf_howto_init ();
2898
2899 htab = ppc_elf_hash_table (info);
2900 if (htab->glink == NULL)
2901 {
2902 if (htab->elf.dynobj == NULL)
2903 htab->elf.dynobj = abfd;
2904 if (!ppc_elf_create_glink (htab->elf.dynobj, info))
2905 return FALSE;
2906 }
2907 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
2908 FALSE, FALSE, TRUE);
2909 symtab_hdr = &elf_symtab_hdr (abfd);
2910 sym_hashes = elf_sym_hashes (abfd);
2911 got2 = bfd_get_section_by_name (abfd, ".got2");
2912 sreloc = NULL;
2913
2914 rel_end = relocs + sec->reloc_count;
2915 for (rel = relocs; rel < rel_end; rel++)
2916 {
2917 unsigned long r_symndx;
2918 enum elf_ppc_reloc_type r_type;
2919 struct elf_link_hash_entry *h;
2920 int tls_type;
2921 struct plt_entry **ifunc;
2922 struct plt_entry **pltent;
2923 bfd_vma addend;
2924
2925 r_symndx = ELF32_R_SYM (rel->r_info);
2926 if (r_symndx < symtab_hdr->sh_info)
2927 h = NULL;
2928 else
2929 {
2930 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2931 while (h->root.type == bfd_link_hash_indirect
2932 || h->root.type == bfd_link_hash_warning)
2933 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2934 }
2935
2936 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
2937 This shows up in particular in an R_PPC_ADDR32 in the eabi
2938 startup code. */
2939 if (h != NULL
2940 && htab->elf.sgot == NULL
2941 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2942 {
2943 if (htab->elf.dynobj == NULL)
2944 htab->elf.dynobj = abfd;
2945 if (!ppc_elf_create_got (htab->elf.dynobj, info))
2946 return FALSE;
2947 BFD_ASSERT (h == htab->elf.hgot);
2948 }
2949
2950 tls_type = 0;
2951 r_type = ELF32_R_TYPE (rel->r_info);
2952 ifunc = NULL;
2953 if (h == NULL && htab->elf.target_os != is_vxworks)
2954 {
2955 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2956 abfd, r_symndx);
2957 if (isym == NULL)
2958 return FALSE;
2959
2960 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2961 {
2962 /* Set PLT_IFUNC flag for this sym, no GOT entry yet. */
2963 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
2964 NON_GOT | PLT_IFUNC);
2965 if (ifunc == NULL)
2966 return FALSE;
2967
2968 /* STT_GNU_IFUNC symbols must have a PLT entry;
2969 In a non-pie executable even when there are
2970 no plt calls. */
2971 if (!bfd_link_pic (info)
2972 || is_branch_reloc (r_type)
2973 || r_type == R_PPC_PLT16_LO
2974 || r_type == R_PPC_PLT16_HI
2975 || r_type == R_PPC_PLT16_HA)
2976 {
2977 addend = 0;
2978 if (r_type == R_PPC_PLTREL24)
2979 ppc_elf_tdata (abfd)->makes_plt_call = 1;
2980 if (bfd_link_pic (info)
2981 && (r_type == R_PPC_PLTREL24
2982 || r_type == R_PPC_PLT16_LO
2983 || r_type == R_PPC_PLT16_HI
2984 || r_type == R_PPC_PLT16_HA))
2985 addend = rel->r_addend;
2986 if (!update_plt_info (abfd, ifunc, got2, addend))
2987 return FALSE;
2988 }
2989 }
2990 }
2991
2992 if (htab->elf.target_os != is_vxworks
2993 && is_branch_reloc (r_type)
2994 && h != NULL
2995 && h == tga)
2996 {
2997 if (rel != relocs
2998 && (ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSGD
2999 || ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSLD))
3000 /* We have a new-style __tls_get_addr call with a marker
3001 reloc. */
3002 ;
3003 else
3004 /* Mark this section as having an old-style call. */
3005 sec->nomark_tls_get_addr = 1;
3006 }
3007
3008 switch (r_type)
3009 {
3010 case R_PPC_TLSGD:
3011 case R_PPC_TLSLD:
3012 /* These special tls relocs tie a call to __tls_get_addr with
3013 its parameter symbol. */
3014 if (h != NULL)
3015 ppc_elf_hash_entry (h)->tls_mask |= TLS_TLS | TLS_MARK;
3016 else
3017 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
3018 NON_GOT | TLS_TLS | TLS_MARK))
3019 return FALSE;
3020 break;
3021
3022 case R_PPC_PLTSEQ:
3023 break;
3024
3025 case R_PPC_GOT_TLSLD16:
3026 case R_PPC_GOT_TLSLD16_LO:
3027 case R_PPC_GOT_TLSLD16_HI:
3028 case R_PPC_GOT_TLSLD16_HA:
3029 tls_type = TLS_TLS | TLS_LD;
3030 goto dogottls;
3031
3032 case R_PPC_GOT_TLSGD16:
3033 case R_PPC_GOT_TLSGD16_LO:
3034 case R_PPC_GOT_TLSGD16_HI:
3035 case R_PPC_GOT_TLSGD16_HA:
3036 tls_type = TLS_TLS | TLS_GD;
3037 goto dogottls;
3038
3039 case R_PPC_GOT_TPREL16:
3040 case R_PPC_GOT_TPREL16_LO:
3041 case R_PPC_GOT_TPREL16_HI:
3042 case R_PPC_GOT_TPREL16_HA:
3043 if (bfd_link_dll (info))
3044 info->flags |= DF_STATIC_TLS;
3045 tls_type = TLS_TLS | TLS_TPREL;
3046 goto dogottls;
3047
3048 case R_PPC_GOT_DTPREL16:
3049 case R_PPC_GOT_DTPREL16_LO:
3050 case R_PPC_GOT_DTPREL16_HI:
3051 case R_PPC_GOT_DTPREL16_HA:
3052 tls_type = TLS_TLS | TLS_DTPREL;
3053 dogottls:
3054 sec->has_tls_reloc = 1;
3055 /* Fall through. */
3056
3057 /* GOT16 relocations */
3058 case R_PPC_GOT16:
3059 case R_PPC_GOT16_LO:
3060 case R_PPC_GOT16_HI:
3061 case R_PPC_GOT16_HA:
3062 /* This symbol requires a global offset table entry. */
3063 if (htab->elf.sgot == NULL)
3064 {
3065 if (htab->elf.dynobj == NULL)
3066 htab->elf.dynobj = abfd;
3067 if (!ppc_elf_create_got (htab->elf.dynobj, info))
3068 return FALSE;
3069 }
3070 if (h != NULL)
3071 {
3072 h->got.refcount += 1;
3073 ppc_elf_hash_entry (h)->tls_mask |= tls_type;
3074 }
3075 else
3076 /* This is a global offset table entry for a local symbol. */
3077 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
3078 return FALSE;
3079
3080 /* We may also need a plt entry if the symbol turns out to be
3081 an ifunc. */
3082 if (h != NULL && !bfd_link_pic (info))
3083 {
3084 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
3085 return FALSE;
3086 }
3087 break;
3088
3089 /* Indirect .sdata relocation. */
3090 case R_PPC_EMB_SDAI16:
3091 htab->sdata[0].sym->ref_regular = 1;
3092 if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[0],
3093 h, rel))
3094 return FALSE;
3095 if (h != NULL)
3096 {
3097 ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3098 h->non_got_ref = TRUE;
3099 }
3100 break;
3101
3102 /* Indirect .sdata2 relocation. */
3103 case R_PPC_EMB_SDA2I16:
3104 if (!bfd_link_executable (info))
3105 {
3106 bad_shared_reloc (abfd, r_type);
3107 return FALSE;
3108 }
3109 htab->sdata[1].sym->ref_regular = 1;
3110 if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[1],
3111 h, rel))
3112 return FALSE;
3113 if (h != NULL)
3114 {
3115 ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3116 h->non_got_ref = TRUE;
3117 }
3118 break;
3119
3120 case R_PPC_SDAREL16:
3121 htab->sdata[0].sym->ref_regular = 1;
3122 /* Fall through. */
3123
3124 case R_PPC_VLE_SDAREL_LO16A:
3125 case R_PPC_VLE_SDAREL_LO16D:
3126 case R_PPC_VLE_SDAREL_HI16A:
3127 case R_PPC_VLE_SDAREL_HI16D:
3128 case R_PPC_VLE_SDAREL_HA16A:
3129 case R_PPC_VLE_SDAREL_HA16D:
3130 if (h != NULL)
3131 {
3132 ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3133 h->non_got_ref = TRUE;
3134 }
3135 break;
3136
3137 case R_PPC_VLE_REL8:
3138 case R_PPC_VLE_REL15:
3139 case R_PPC_VLE_REL24:
3140 case R_PPC_VLE_LO16A:
3141 case R_PPC_VLE_LO16D:
3142 case R_PPC_VLE_HI16A:
3143 case R_PPC_VLE_HI16D:
3144 case R_PPC_VLE_HA16A:
3145 case R_PPC_VLE_HA16D:
3146 case R_PPC_VLE_ADDR20:
3147 break;
3148
3149 case R_PPC_EMB_SDA2REL:
3150 if (!bfd_link_executable (info))
3151 {
3152 bad_shared_reloc (abfd, r_type);
3153 return FALSE;
3154 }
3155 htab->sdata[1].sym->ref_regular = 1;
3156 if (h != NULL)
3157 {
3158 ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3159 h->non_got_ref = TRUE;
3160 }
3161 break;
3162
3163 case R_PPC_VLE_SDA21_LO:
3164 case R_PPC_VLE_SDA21:
3165 case R_PPC_EMB_SDA21:
3166 case R_PPC_EMB_RELSDA:
3167 if (h != NULL)
3168 {
3169 ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3170 h->non_got_ref = TRUE;
3171 }
3172 break;
3173
3174 case R_PPC_EMB_NADDR32:
3175 case R_PPC_EMB_NADDR16:
3176 case R_PPC_EMB_NADDR16_LO:
3177 case R_PPC_EMB_NADDR16_HI:
3178 case R_PPC_EMB_NADDR16_HA:
3179 if (h != NULL)
3180 h->non_got_ref = TRUE;
3181 break;
3182
3183 case R_PPC_PLTREL24:
3184 if (h == NULL)
3185 break;
3186 ppc_elf_tdata (abfd)->makes_plt_call = 1;
3187 goto pltentry;
3188
3189 case R_PPC_PLTCALL:
3190 sec->has_pltcall = 1;
3191 /* Fall through. */
3192
3193 case R_PPC_PLT32:
3194 case R_PPC_PLTREL32:
3195 case R_PPC_PLT16_LO:
3196 case R_PPC_PLT16_HI:
3197 case R_PPC_PLT16_HA:
3198 pltentry:
3199 #ifdef DEBUG
3200 fprintf (stderr, "Reloc requires a PLT entry\n");
3201 #endif
3202 /* This symbol requires a procedure linkage table entry. */
3203 if (h == NULL)
3204 {
3205 pltent = update_local_sym_info (abfd, symtab_hdr, r_symndx,
3206 NON_GOT | PLT_KEEP);
3207 if (pltent == NULL)
3208 return FALSE;
3209 }
3210 else
3211 {
3212 if (r_type != R_PPC_PLTREL24)
3213 ppc_elf_hash_entry (h)->tls_mask |= PLT_KEEP;
3214 h->needs_plt = 1;
3215 pltent = &h->plt.plist;
3216 }
3217 addend = 0;
3218 if (bfd_link_pic (info)
3219 && (r_type == R_PPC_PLTREL24
3220 || r_type == R_PPC_PLT16_LO
3221 || r_type == R_PPC_PLT16_HI
3222 || r_type == R_PPC_PLT16_HA))
3223 addend = rel->r_addend;
3224 if (!update_plt_info (abfd, pltent, got2, addend))
3225 return FALSE;
3226 break;
3227
3228 /* The following relocations don't need to propagate the
3229 relocation if linking a shared object since they are
3230 section relative. */
3231 case R_PPC_SECTOFF:
3232 case R_PPC_SECTOFF_LO:
3233 case R_PPC_SECTOFF_HI:
3234 case R_PPC_SECTOFF_HA:
3235 case R_PPC_DTPREL16:
3236 case R_PPC_DTPREL16_LO:
3237 case R_PPC_DTPREL16_HI:
3238 case R_PPC_DTPREL16_HA:
3239 case R_PPC_TOC16:
3240 break;
3241
3242 case R_PPC_REL16:
3243 case R_PPC_REL16_LO:
3244 case R_PPC_REL16_HI:
3245 case R_PPC_REL16_HA:
3246 case R_PPC_REL16DX_HA:
3247 ppc_elf_tdata (abfd)->has_rel16 = 1;
3248 break;
3249
3250 /* These are just markers. */
3251 case R_PPC_TLS:
3252 case R_PPC_EMB_MRKREF:
3253 case R_PPC_NONE:
3254 case R_PPC_max:
3255 case R_PPC_RELAX:
3256 case R_PPC_RELAX_PLT:
3257 case R_PPC_RELAX_PLTREL24:
3258 case R_PPC_16DX_HA:
3259 break;
3260
3261 /* These should only appear in dynamic objects. */
3262 case R_PPC_COPY:
3263 case R_PPC_GLOB_DAT:
3264 case R_PPC_JMP_SLOT:
3265 case R_PPC_RELATIVE:
3266 case R_PPC_IRELATIVE:
3267 break;
3268
3269 /* These aren't handled yet. We'll report an error later. */
3270 case R_PPC_ADDR30:
3271 case R_PPC_EMB_RELSEC16:
3272 case R_PPC_EMB_RELST_LO:
3273 case R_PPC_EMB_RELST_HI:
3274 case R_PPC_EMB_RELST_HA:
3275 case R_PPC_EMB_BIT_FLD:
3276 break;
3277
3278 /* This refers only to functions defined in the shared library. */
3279 case R_PPC_LOCAL24PC:
3280 if (h != NULL && h == htab->elf.hgot && htab->plt_type == PLT_UNSET)
3281 {
3282 htab->plt_type = PLT_OLD;
3283 htab->old_bfd = abfd;
3284 }
3285 if (h != NULL && h->type == STT_GNU_IFUNC)
3286 {
3287 h->needs_plt = 1;
3288 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
3289 return FALSE;
3290 }
3291 break;
3292
3293 /* This relocation describes the C++ object vtable hierarchy.
3294 Reconstruct it for later use during GC. */
3295 case R_PPC_GNU_VTINHERIT:
3296 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3297 return FALSE;
3298 break;
3299
3300 /* This relocation describes which C++ vtable entries are actually
3301 used. Record for later use during GC. */
3302 case R_PPC_GNU_VTENTRY:
3303 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3304 return FALSE;
3305 break;
3306
3307 /* We shouldn't really be seeing TPREL32. */
3308 case R_PPC_TPREL32:
3309 case R_PPC_TPREL16:
3310 case R_PPC_TPREL16_LO:
3311 case R_PPC_TPREL16_HI:
3312 case R_PPC_TPREL16_HA:
3313 if (bfd_link_dll (info))
3314 info->flags |= DF_STATIC_TLS;
3315 goto dodyn;
3316
3317 /* Nor these. */
3318 case R_PPC_DTPMOD32:
3319 case R_PPC_DTPREL32:
3320 goto dodyn;
3321
3322 case R_PPC_REL32:
3323 if (h == NULL
3324 && got2 != NULL
3325 && (sec->flags & SEC_CODE) != 0
3326 && bfd_link_pic (info)
3327 && htab->plt_type == PLT_UNSET)
3328 {
3329 /* Old -fPIC gcc code has .long LCTOC1-LCFx just before
3330 the start of a function, which assembles to a REL32
3331 reference to .got2. If we detect one of these, then
3332 force the old PLT layout because the linker cannot
3333 reliably deduce the GOT pointer value needed for
3334 PLT call stubs. */
3335 asection *s;
3336 Elf_Internal_Sym *isym;
3337
3338 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3339 abfd, r_symndx);
3340 if (isym == NULL)
3341 return FALSE;
3342
3343 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3344 if (s == got2)
3345 {
3346 htab->plt_type = PLT_OLD;
3347 htab->old_bfd = abfd;
3348 }
3349 }
3350 if (h == NULL || h == htab->elf.hgot)
3351 break;
3352 /* fall through */
3353
3354 case R_PPC_ADDR32:
3355 case R_PPC_ADDR16:
3356 case R_PPC_ADDR16_LO:
3357 case R_PPC_ADDR16_HI:
3358 case R_PPC_ADDR16_HA:
3359 case R_PPC_UADDR32:
3360 case R_PPC_UADDR16:
3361 if (h != NULL && !bfd_link_pic (info))
3362 {
3363 /* We may need a plt entry if the symbol turns out to be
3364 a function defined in a dynamic object. */
3365 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
3366 return FALSE;
3367
3368 /* We may need a copy reloc too. */
3369 h->non_got_ref = 1;
3370 h->pointer_equality_needed = 1;
3371 if (r_type == R_PPC_ADDR16_HA)
3372 ppc_elf_hash_entry (h)->has_addr16_ha = 1;
3373 if (r_type == R_PPC_ADDR16_LO)
3374 ppc_elf_hash_entry (h)->has_addr16_lo = 1;
3375 }
3376 goto dodyn;
3377
3378 case R_PPC_REL24:
3379 case R_PPC_REL14:
3380 case R_PPC_REL14_BRTAKEN:
3381 case R_PPC_REL14_BRNTAKEN:
3382 if (h == NULL)
3383 break;
3384 if (h == htab->elf.hgot)
3385 {
3386 if (htab->plt_type == PLT_UNSET)
3387 {
3388 htab->plt_type = PLT_OLD;
3389 htab->old_bfd = abfd;
3390 }
3391 break;
3392 }
3393 /* fall through */
3394
3395 case R_PPC_ADDR24:
3396 case R_PPC_ADDR14:
3397 case R_PPC_ADDR14_BRTAKEN:
3398 case R_PPC_ADDR14_BRNTAKEN:
3399 if (h != NULL && !bfd_link_pic (info))
3400 {
3401 /* We may need a plt entry if the symbol turns out to be
3402 a function defined in a dynamic object. */
3403 h->needs_plt = 1;
3404 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
3405 return FALSE;
3406 break;
3407 }
3408
3409 dodyn:
3410 /* If we are creating a shared library, and this is a reloc
3411 against a global symbol, or a non PC relative reloc
3412 against a local symbol, then we need to copy the reloc
3413 into the shared library. However, if we are linking with
3414 -Bsymbolic, we do not need to copy a reloc against a
3415 global symbol which is defined in an object we are
3416 including in the link (i.e., DEF_REGULAR is set). At
3417 this point we have not seen all the input files, so it is
3418 possible that DEF_REGULAR is not set now but will be set
3419 later (it is never cleared). In case of a weak definition,
3420 DEF_REGULAR may be cleared later by a strong definition in
3421 a shared library. We account for that possibility below by
3422 storing information in the dyn_relocs field of the hash
3423 table entry. A similar situation occurs when creating
3424 shared libraries and symbol visibility changes render the
3425 symbol local.
3426
3427 If on the other hand, we are creating an executable, we
3428 may need to keep relocations for symbols satisfied by a
3429 dynamic library if we manage to avoid copy relocs for the
3430 symbol. */
3431 if ((bfd_link_pic (info)
3432 && (must_be_dyn_reloc (info, r_type)
3433 || (h != NULL
3434 && (!SYMBOLIC_BIND (info, h)
3435 || h->root.type == bfd_link_hash_defweak
3436 || !h->def_regular))))
3437 || (ELIMINATE_COPY_RELOCS
3438 && !bfd_link_pic (info)
3439 && h != NULL
3440 && (h->root.type == bfd_link_hash_defweak
3441 || !h->def_regular)))
3442 {
3443 #ifdef DEBUG
3444 fprintf (stderr,
3445 "ppc_elf_check_relocs needs to "
3446 "create relocation for %s\n",
3447 (h && h->root.root.string
3448 ? h->root.root.string : "<unknown>"));
3449 #endif
3450 if (sreloc == NULL)
3451 {
3452 if (htab->elf.dynobj == NULL)
3453 htab->elf.dynobj = abfd;
3454
3455 sreloc = _bfd_elf_make_dynamic_reloc_section
3456 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
3457
3458 if (sreloc == NULL)
3459 return FALSE;
3460 }
3461
3462 /* If this is a global symbol, we count the number of
3463 relocations we need for this symbol. */
3464 if (h != NULL)
3465 {
3466 struct elf_dyn_relocs *p;
3467 struct elf_dyn_relocs **rel_head;
3468
3469 rel_head = &h->dyn_relocs;
3470 p = *rel_head;
3471 if (p == NULL || p->sec != sec)
3472 {
3473 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
3474 if (p == NULL)
3475 return FALSE;
3476 p->next = *rel_head;
3477 *rel_head = p;
3478 p->sec = sec;
3479 p->count = 0;
3480 p->pc_count = 0;
3481 }
3482 p->count += 1;
3483 if (!must_be_dyn_reloc (info, r_type))
3484 p->pc_count += 1;
3485 }
3486 else
3487 {
3488 /* Track dynamic relocs needed for local syms too.
3489 We really need local syms available to do this
3490 easily. Oh well. */
3491 struct ppc_dyn_relocs *p;
3492 struct ppc_dyn_relocs **rel_head;
3493 bfd_boolean is_ifunc;
3494 asection *s;
3495 void *vpp;
3496 Elf_Internal_Sym *isym;
3497
3498 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3499 abfd, r_symndx);
3500 if (isym == NULL)
3501 return FALSE;
3502
3503 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3504 if (s == NULL)
3505 s = sec;
3506
3507 vpp = &elf_section_data (s)->local_dynrel;
3508 rel_head = (struct ppc_dyn_relocs **) vpp;
3509 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
3510 p = *rel_head;
3511 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
3512 p = p->next;
3513 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
3514 {
3515 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
3516 if (p == NULL)
3517 return FALSE;
3518 p->next = *rel_head;
3519 *rel_head = p;
3520 p->sec = sec;
3521 p->ifunc = is_ifunc;
3522 p->count = 0;
3523 }
3524 p->count += 1;
3525 }
3526 }
3527
3528 break;
3529 }
3530 }
3531
3532 return TRUE;
3533 }
3534 \f
3535 /* Warn for conflicting Tag_GNU_Power_ABI_FP attributes between IBFD
3536 and OBFD, and merge non-conflicting ones. */
3537 bfd_boolean
3538 _bfd_elf_ppc_merge_fp_attributes (bfd *ibfd, struct bfd_link_info *info)
3539 {
3540 bfd *obfd = info->output_bfd;
3541 obj_attribute *in_attr, *in_attrs;
3542 obj_attribute *out_attr, *out_attrs;
3543 bfd_boolean ret = TRUE;
3544 bfd_boolean warn_only;
3545
3546 /* We only warn about shared library mismatches, because common
3547 libraries advertise support for a particular long double variant
3548 but actually support more than one variant. For example, glibc
3549 typically supports 128-bit IBM long double in the shared library
3550 but has a compatibility static archive for 64-bit long double.
3551 The linker doesn't have the smarts to see that an app using
3552 object files marked as 64-bit long double call the compatibility
3553 layer objects and only from there call into the shared library. */
3554 warn_only = (ibfd->flags & DYNAMIC) != 0;
3555
3556 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
3557 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
3558
3559 in_attr = &in_attrs[Tag_GNU_Power_ABI_FP];
3560 out_attr = &out_attrs[Tag_GNU_Power_ABI_FP];
3561
3562 if (in_attr->i != out_attr->i)
3563 {
3564 int in_fp = in_attr->i & 3;
3565 int out_fp = out_attr->i & 3;
3566 static bfd *last_fp, *last_ld;
3567
3568 if (in_fp == 0)
3569 ;
3570 else if (out_fp == 0)
3571 {
3572 if (!warn_only)
3573 {
3574 out_attr->type = ATTR_TYPE_FLAG_INT_VAL;
3575 out_attr->i ^= in_fp;
3576 last_fp = ibfd;
3577 }
3578 }
3579 else if (out_fp != 2 && in_fp == 2)
3580 {
3581 _bfd_error_handler
3582 /* xgettext:c-format */
3583 (_("%pB uses hard float, %pB uses soft float"),
3584 last_fp, ibfd);
3585 ret = warn_only;
3586 }
3587 else if (out_fp == 2 && in_fp != 2)
3588 {
3589 _bfd_error_handler
3590 /* xgettext:c-format */
3591 (_("%pB uses hard float, %pB uses soft float"),
3592 ibfd, last_fp);
3593 ret = warn_only;
3594 }
3595 else if (out_fp == 1 && in_fp == 3)
3596 {
3597 _bfd_error_handler
3598 /* xgettext:c-format */
3599 (_("%pB uses double-precision hard float, "
3600 "%pB uses single-precision hard float"), last_fp, ibfd);
3601 ret = warn_only;
3602 }
3603 else if (out_fp == 3 && in_fp == 1)
3604 {
3605 _bfd_error_handler
3606 /* xgettext:c-format */
3607 (_("%pB uses double-precision hard float, "
3608 "%pB uses single-precision hard float"), ibfd, last_fp);
3609 ret = warn_only;
3610 }
3611
3612 in_fp = in_attr->i & 0xc;
3613 out_fp = out_attr->i & 0xc;
3614 if (in_fp == 0)
3615 ;
3616 else if (out_fp == 0)
3617 {
3618 if (!warn_only)
3619 {
3620 out_attr->type = ATTR_TYPE_FLAG_INT_VAL;
3621 out_attr->i ^= in_fp;
3622 last_ld = ibfd;
3623 }
3624 }
3625 else if (out_fp != 2 * 4 && in_fp == 2 * 4)
3626 {
3627 _bfd_error_handler
3628 /* xgettext:c-format */
3629 (_("%pB uses 64-bit long double, "
3630 "%pB uses 128-bit long double"), ibfd, last_ld);
3631 ret = warn_only;
3632 }
3633 else if (in_fp != 2 * 4 && out_fp == 2 * 4)
3634 {
3635 _bfd_error_handler
3636 /* xgettext:c-format */
3637 (_("%pB uses 64-bit long double, "
3638 "%pB uses 128-bit long double"), last_ld, ibfd);
3639 ret = warn_only;
3640 }
3641 else if (out_fp == 1 * 4 && in_fp == 3 * 4)
3642 {
3643 _bfd_error_handler
3644 /* xgettext:c-format */
3645 (_("%pB uses IBM long double, "
3646 "%pB uses IEEE long double"), last_ld, ibfd);
3647 ret = warn_only;
3648 }
3649 else if (out_fp == 3 * 4 && in_fp == 1 * 4)
3650 {
3651 _bfd_error_handler
3652 /* xgettext:c-format */
3653 (_("%pB uses IBM long double, "
3654 "%pB uses IEEE long double"), ibfd, last_ld);
3655 ret = warn_only;
3656 }
3657 }
3658
3659 if (!ret)
3660 {
3661 out_attr->type = ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_ERROR;
3662 bfd_set_error (bfd_error_bad_value);
3663 }
3664 return ret;
3665 }
3666
3667 /* Merge object attributes from IBFD into OBFD. Warn if
3668 there are conflicting attributes. */
3669 static bfd_boolean
3670 ppc_elf_merge_obj_attributes (bfd *ibfd, struct bfd_link_info *info)
3671 {
3672 bfd *obfd;
3673 obj_attribute *in_attr, *in_attrs;
3674 obj_attribute *out_attr, *out_attrs;
3675 bfd_boolean ret;
3676
3677 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
3678 return FALSE;
3679
3680 obfd = info->output_bfd;
3681 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
3682 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
3683
3684 /* Check for conflicting Tag_GNU_Power_ABI_Vector attributes and
3685 merge non-conflicting ones. */
3686 in_attr = &in_attrs[Tag_GNU_Power_ABI_Vector];
3687 out_attr = &out_attrs[Tag_GNU_Power_ABI_Vector];
3688 ret = TRUE;
3689 if (in_attr->i != out_attr->i)
3690 {
3691 int in_vec = in_attr->i & 3;
3692 int out_vec = out_attr->i & 3;
3693 static bfd *last_vec;
3694
3695 if (in_vec == 0)
3696 ;
3697 else if (out_vec == 0)
3698 {
3699 out_attr->type = ATTR_TYPE_FLAG_INT_VAL;
3700 out_attr->i = in_vec;
3701 last_vec = ibfd;
3702 }
3703 /* For now, allow generic to transition to AltiVec or SPE
3704 without a warning. If GCC marked files with their stack
3705 alignment and used don't-care markings for files which are
3706 not affected by the vector ABI, we could warn about this
3707 case too. */
3708 else if (in_vec == 1)
3709 ;
3710 else if (out_vec == 1)
3711 {
3712 out_attr->type = ATTR_TYPE_FLAG_INT_VAL;
3713 out_attr->i = in_vec;
3714 last_vec = ibfd;
3715 }
3716 else if (out_vec < in_vec)
3717 {
3718 _bfd_error_handler
3719 /* xgettext:c-format */
3720 (_("%pB uses AltiVec vector ABI, %pB uses SPE vector ABI"),
3721 last_vec, ibfd);
3722 out_attr->type = ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_ERROR;
3723 ret = FALSE;
3724 }
3725 else if (out_vec > in_vec)
3726 {
3727 _bfd_error_handler
3728 /* xgettext:c-format */
3729 (_("%pB uses AltiVec vector ABI, %pB uses SPE vector ABI"),
3730 ibfd, last_vec);
3731 out_attr->type = ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_ERROR;
3732 ret = FALSE;
3733 }
3734 }
3735
3736 /* Check for conflicting Tag_GNU_Power_ABI_Struct_Return attributes
3737 and merge non-conflicting ones. */
3738 in_attr = &in_attrs[Tag_GNU_Power_ABI_Struct_Return];
3739 out_attr = &out_attrs[Tag_GNU_Power_ABI_Struct_Return];
3740 if (in_attr->i != out_attr->i)
3741 {
3742 int in_struct = in_attr->i & 3;
3743 int out_struct = out_attr->i & 3;
3744 static bfd *last_struct;
3745
3746 if (in_struct == 0 || in_struct == 3)
3747 ;
3748 else if (out_struct == 0)
3749 {
3750 out_attr->type = ATTR_TYPE_FLAG_INT_VAL;
3751 out_attr->i = in_struct;
3752 last_struct = ibfd;
3753 }
3754 else if (out_struct < in_struct)
3755 {
3756 _bfd_error_handler
3757 /* xgettext:c-format */
3758 (_("%pB uses r3/r4 for small structure returns, "
3759 "%pB uses memory"), last_struct, ibfd);
3760 out_attr->type = ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_ERROR;
3761 ret = FALSE;
3762 }
3763 else if (out_struct > in_struct)
3764 {
3765 _bfd_error_handler
3766 /* xgettext:c-format */
3767 (_("%pB uses r3/r4 for small structure returns, "
3768 "%pB uses memory"), ibfd, last_struct);
3769 out_attr->type = ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_ERROR;
3770 ret = FALSE;
3771 }
3772 }
3773 if (!ret)
3774 {
3775 bfd_set_error (bfd_error_bad_value);
3776 return FALSE;
3777 }
3778
3779 /* Merge Tag_compatibility attributes and any common GNU ones. */
3780 return _bfd_elf_merge_object_attributes (ibfd, info);
3781 }
3782
3783 /* Merge backend specific data from an object file to the output
3784 object file when linking. */
3785
3786 static bfd_boolean
3787 ppc_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3788 {
3789 bfd *obfd = info->output_bfd;
3790 flagword old_flags;
3791 flagword new_flags;
3792 bfd_boolean error;
3793
3794 if (!is_ppc_elf (ibfd) || !is_ppc_elf (obfd))
3795 return TRUE;
3796
3797 /* Check if we have the same endianness. */
3798 if (! _bfd_generic_verify_endian_match (ibfd, info))
3799 return FALSE;
3800
3801 if (!ppc_elf_merge_obj_attributes (ibfd, info))
3802 return FALSE;
3803
3804 if ((ibfd->flags & DYNAMIC) != 0)
3805 return TRUE;
3806
3807 new_flags = elf_elfheader (ibfd)->e_flags;
3808 old_flags = elf_elfheader (obfd)->e_flags;
3809 if (!elf_flags_init (obfd))
3810 {
3811 /* First call, no flags set. */
3812 elf_flags_init (obfd) = TRUE;
3813 elf_elfheader (obfd)->e_flags = new_flags;
3814 }
3815
3816 /* Compatible flags are ok. */
3817 else if (new_flags == old_flags)
3818 ;
3819
3820 /* Incompatible flags. */
3821 else
3822 {
3823 /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib
3824 to be linked with either. */
3825 error = FALSE;
3826 if ((new_flags & EF_PPC_RELOCATABLE) != 0
3827 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
3828 {
3829 error = TRUE;
3830 _bfd_error_handler
3831 (_("%pB: compiled with -mrelocatable and linked with "
3832 "modules compiled normally"), ibfd);
3833 }
3834 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
3835 && (old_flags & EF_PPC_RELOCATABLE) != 0)
3836 {
3837 error = TRUE;
3838 _bfd_error_handler
3839 (_("%pB: compiled normally and linked with "
3840 "modules compiled with -mrelocatable"), ibfd);
3841 }
3842
3843 /* The output is -mrelocatable-lib iff both the input files are. */
3844 if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
3845 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
3846
3847 /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
3848 but each input file is either -mrelocatable or -mrelocatable-lib. */
3849 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
3850 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
3851 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
3852 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
3853
3854 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if
3855 any module uses it. */
3856 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
3857
3858 new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
3859 old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
3860
3861 /* Warn about any other mismatches. */
3862 if (new_flags != old_flags)
3863 {
3864 error = TRUE;
3865 _bfd_error_handler
3866 /* xgettext:c-format */
3867 (_("%pB: uses different e_flags (%#x) fields "
3868 "than previous modules (%#x)"),
3869 ibfd, new_flags, old_flags);
3870 }
3871
3872 if (error)
3873 {
3874 bfd_set_error (bfd_error_bad_value);
3875 return FALSE;
3876 }
3877 }
3878
3879 return TRUE;
3880 }
3881
3882 static void
3883 ppc_elf_vle_split16 (bfd *input_bfd,
3884 asection *input_section,
3885 unsigned long offset,
3886 bfd_byte *loc,
3887 bfd_vma value,
3888 split16_format_type split16_format,
3889 bfd_boolean fixup)
3890 {
3891 unsigned int insn, opcode;
3892
3893 insn = bfd_get_32 (input_bfd, loc);
3894 opcode = insn & E_OPCODE_MASK;
3895 if (opcode == E_OR2I_INSN
3896 || opcode == E_AND2I_DOT_INSN
3897 || opcode == E_OR2IS_INSN
3898 || opcode == E_LIS_INSN
3899 || opcode == E_AND2IS_DOT_INSN)
3900 {
3901 if (split16_format != split16a_type)
3902 {
3903 if (fixup)
3904 split16_format = split16a_type;
3905 else
3906 _bfd_error_handler
3907 /* xgettext:c-format */
3908 (_("%pB(%pA+0x%lx): expected 16A style relocation on 0x%08x insn"),
3909 input_bfd, input_section, offset, opcode);
3910 }
3911 }
3912 else if (opcode == E_ADD2I_DOT_INSN
3913 || opcode == E_ADD2IS_INSN
3914 || opcode == E_CMP16I_INSN
3915 || opcode == E_MULL2I_INSN
3916 || opcode == E_CMPL16I_INSN
3917 || opcode == E_CMPH16I_INSN
3918 || opcode == E_CMPHL16I_INSN)
3919 {
3920 if (split16_format != split16d_type)
3921 {
3922 if (fixup)
3923 split16_format = split16d_type;
3924 else
3925 _bfd_error_handler
3926 /* xgettext:c-format */
3927 (_("%pB(%pA+0x%lx): expected 16D style relocation on 0x%08x insn"),
3928 input_bfd, input_section, offset, opcode);
3929 }
3930 }
3931 if (split16_format == split16a_type)
3932 {
3933 insn &= ~((0xf800 << 5) | 0x7ff);
3934 insn |= (value & 0xf800) << 5;
3935 if ((insn & E_LI_MASK) == E_LI_INSN)
3936 {
3937 /* Hack for e_li. Extend sign. */
3938 insn &= ~(0xf0000 >> 5);
3939 insn |= (-(value & 0x8000) & 0xf0000) >> 5;
3940 }
3941 }
3942 else
3943 {
3944 insn &= ~((0xf800 << 10) | 0x7ff);
3945 insn |= (value & 0xf800) << 10;
3946 }
3947 insn |= value & 0x7ff;
3948 bfd_put_32 (input_bfd, insn, loc);
3949 }
3950
3951 static void
3952 ppc_elf_vle_split20 (bfd *output_bfd, bfd_byte *loc, bfd_vma value)
3953 {
3954 unsigned int insn;
3955
3956 insn = bfd_get_32 (output_bfd, loc);
3957 /* We have an li20 field, bits 17..20, 11..15, 21..31. */
3958 /* Top 4 bits of value to 17..20. */
3959 insn |= (value & 0xf0000) >> 5;
3960 /* Next 5 bits of the value to 11..15. */
3961 insn |= (value & 0xf800) << 5;
3962 /* And the final 11 bits of the value to bits 21 to 31. */
3963 insn |= value & 0x7ff;
3964 bfd_put_32 (output_bfd, insn, loc);
3965 }
3966
3967 \f
3968 /* Choose which PLT scheme to use, and set .plt flags appropriately.
3969 Returns -1 on error, 0 for old PLT, 1 for new PLT. */
3970 int
3971 ppc_elf_select_plt_layout (bfd *output_bfd ATTRIBUTE_UNUSED,
3972 struct bfd_link_info *info)
3973 {
3974 struct ppc_elf_link_hash_table *htab;
3975 flagword flags;
3976
3977 htab = ppc_elf_hash_table (info);
3978
3979 if (htab->plt_type == PLT_UNSET)
3980 {
3981 struct elf_link_hash_entry *h;
3982
3983 if (htab->params->plt_style == PLT_OLD)
3984 htab->plt_type = PLT_OLD;
3985 else if (bfd_link_pic (info)
3986 && htab->elf.dynamic_sections_created
3987 && (h = elf_link_hash_lookup (&htab->elf, "_mcount",
3988 FALSE, FALSE, TRUE)) != NULL
3989 && (h->type == STT_FUNC
3990 || h->needs_plt)
3991 && h->ref_regular
3992 && !(SYMBOL_CALLS_LOCAL (info, h)
3993 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
3994 {
3995 /* Profiling of shared libs (and pies) is not supported with
3996 secure plt, because ppc32 does profiling before a
3997 function prologue and a secure plt pic call stubs needs
3998 r30 to be set up. */
3999 htab->plt_type = PLT_OLD;
4000 }
4001 else
4002 {
4003 bfd *ibfd;
4004 enum ppc_elf_plt_type plt_type = htab->params->plt_style;
4005
4006 /* Look through the reloc flags left by ppc_elf_check_relocs.
4007 Use the old style bss plt if a file makes plt calls
4008 without using the new relocs, and if ld isn't given
4009 --secure-plt and we never see REL16 relocs. */
4010 if (plt_type == PLT_UNSET)
4011 plt_type = PLT_OLD;
4012 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
4013 if (is_ppc_elf (ibfd))
4014 {
4015 if (ppc_elf_tdata (ibfd)->has_rel16)
4016 plt_type = PLT_NEW;
4017 else if (ppc_elf_tdata (ibfd)->makes_plt_call)
4018 {
4019 plt_type = PLT_OLD;
4020 htab->old_bfd = ibfd;
4021 break;
4022 }
4023 }
4024 htab->plt_type = plt_type;
4025 }
4026 }
4027 if (htab->plt_type == PLT_OLD && htab->params->plt_style == PLT_NEW)
4028 {
4029 if (htab->old_bfd != NULL)
4030 _bfd_error_handler (_("bss-plt forced due to %pB"), htab->old_bfd);
4031 else
4032 _bfd_error_handler (_("bss-plt forced by profiling"));
4033 }
4034
4035 BFD_ASSERT (htab->plt_type != PLT_VXWORKS);
4036
4037 if (htab->plt_type == PLT_NEW)
4038 {
4039 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4040 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4041
4042 /* The new PLT is a loaded section. */
4043 if (htab->elf.splt != NULL
4044 && !bfd_set_section_flags (htab->elf.splt, flags))
4045 return -1;
4046
4047 /* The new GOT is not executable. */
4048 if (htab->elf.sgot != NULL
4049 && !bfd_set_section_flags (htab->elf.sgot, flags))
4050 return -1;
4051 }
4052 else
4053 {
4054 /* Stop an unused .glink section from affecting .text alignment. */
4055 if (htab->glink != NULL
4056 && !bfd_set_section_alignment (htab->glink, 0))
4057 return -1;
4058 }
4059 return htab->plt_type == PLT_NEW;
4060 }
4061 \f
4062 /* Return the section that should be marked against GC for a given
4063 relocation. */
4064
4065 static asection *
4066 ppc_elf_gc_mark_hook (asection *sec,
4067 struct bfd_link_info *info,
4068 Elf_Internal_Rela *rel,
4069 struct elf_link_hash_entry *h,
4070 Elf_Internal_Sym *sym)
4071 {
4072 if (h != NULL)
4073 switch (ELF32_R_TYPE (rel->r_info))
4074 {
4075 case R_PPC_GNU_VTINHERIT:
4076 case R_PPC_GNU_VTENTRY:
4077 return NULL;
4078 }
4079
4080 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4081 }
4082
4083 static bfd_boolean
4084 get_sym_h (struct elf_link_hash_entry **hp,
4085 Elf_Internal_Sym **symp,
4086 asection **symsecp,
4087 unsigned char **tls_maskp,
4088 Elf_Internal_Sym **locsymsp,
4089 unsigned long r_symndx,
4090 bfd *ibfd)
4091 {
4092 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
4093
4094 if (r_symndx >= symtab_hdr->sh_info)
4095 {
4096 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
4097 struct elf_link_hash_entry *h;
4098
4099 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4100 while (h->root.type == bfd_link_hash_indirect
4101 || h->root.type == bfd_link_hash_warning)
4102 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4103
4104 if (hp != NULL)
4105 *hp = h;
4106
4107 if (symp != NULL)
4108 *symp = NULL;
4109
4110 if (symsecp != NULL)
4111 {
4112 asection *symsec = NULL;
4113 if (h->root.type == bfd_link_hash_defined
4114 || h->root.type == bfd_link_hash_defweak)
4115 symsec = h->root.u.def.section;
4116 *symsecp = symsec;
4117 }
4118
4119 if (tls_maskp != NULL)
4120 *tls_maskp = &ppc_elf_hash_entry (h)->tls_mask;
4121 }
4122 else
4123 {
4124 Elf_Internal_Sym *sym;
4125 Elf_Internal_Sym *locsyms = *locsymsp;
4126
4127 if (locsyms == NULL)
4128 {
4129 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
4130 if (locsyms == NULL)
4131 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
4132 symtab_hdr->sh_info,
4133 0, NULL, NULL, NULL);
4134 if (locsyms == NULL)
4135 return FALSE;
4136 *locsymsp = locsyms;
4137 }
4138 sym = locsyms + r_symndx;
4139
4140 if (hp != NULL)
4141 *hp = NULL;
4142
4143 if (symp != NULL)
4144 *symp = sym;
4145
4146 if (symsecp != NULL)
4147 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
4148
4149 if (tls_maskp != NULL)
4150 {
4151 bfd_signed_vma *local_got;
4152 unsigned char *tls_mask;
4153
4154 tls_mask = NULL;
4155 local_got = elf_local_got_refcounts (ibfd);
4156 if (local_got != NULL)
4157 {
4158 struct plt_entry **local_plt = (struct plt_entry **)
4159 (local_got + symtab_hdr->sh_info);
4160 unsigned char *lgot_masks = (unsigned char *)
4161 (local_plt + symtab_hdr->sh_info);
4162 tls_mask = &lgot_masks[r_symndx];
4163 }
4164 *tls_maskp = tls_mask;
4165 }
4166 }
4167 return TRUE;
4168 }
4169 \f
4170 /* Analyze inline PLT call relocations to see whether calls to locally
4171 defined functions can be converted to direct calls. */
4172
4173 bfd_boolean
4174 ppc_elf_inline_plt (struct bfd_link_info *info)
4175 {
4176 struct ppc_elf_link_hash_table *htab;
4177 bfd *ibfd;
4178 asection *sec;
4179 bfd_vma low_vma, high_vma, limit;
4180
4181 htab = ppc_elf_hash_table (info);
4182 if (htab == NULL)
4183 return FALSE;
4184
4185 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
4186 reduced somewhat to cater for possible stubs that might be added
4187 between the call and its destination. */
4188 limit = 0x1e00000;
4189 low_vma = -1;
4190 high_vma = 0;
4191 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
4192 if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
4193 {
4194 if (low_vma > sec->vma)
4195 low_vma = sec->vma;
4196 if (high_vma < sec->vma + sec->size)
4197 high_vma = sec->vma + sec->size;
4198 }
4199
4200 /* If a "bl" can reach anywhere in local code sections, then we can
4201 convert all inline PLT sequences to direct calls when the symbol
4202 is local. */
4203 if (high_vma - low_vma < limit)
4204 {
4205 htab->can_convert_all_inline_plt = 1;
4206 return TRUE;
4207 }
4208
4209 /* Otherwise, go looking through relocs for cases where a direct
4210 call won't reach. Mark the symbol on any such reloc to disable
4211 the optimization and keep the PLT entry as it seems likely that
4212 this will be better than creating trampolines. Note that this
4213 will disable the optimization for all inline PLT calls to a
4214 particular symbol, not just those that won't reach. The
4215 difficulty in doing a more precise optimization is that the
4216 linker needs to make a decision depending on whether a
4217 particular R_PPC_PLTCALL insn can be turned into a direct
4218 call, for each of the R_PPC_PLTSEQ and R_PPC_PLT16* insns in
4219 the sequence, and there is nothing that ties those relocs
4220 together except their symbol. */
4221
4222 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4223 {
4224 Elf_Internal_Shdr *symtab_hdr;
4225 Elf_Internal_Sym *local_syms;
4226
4227 if (!is_ppc_elf (ibfd))
4228 continue;
4229
4230 local_syms = NULL;
4231 symtab_hdr = &elf_symtab_hdr (ibfd);
4232
4233 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4234 if (sec->has_pltcall
4235 && !bfd_is_abs_section (sec->output_section))
4236 {
4237 Elf_Internal_Rela *relstart, *rel, *relend;
4238
4239 /* Read the relocations. */
4240 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
4241 info->keep_memory);
4242 if (relstart == NULL)
4243 return FALSE;
4244
4245 relend = relstart + sec->reloc_count;
4246 for (rel = relstart; rel < relend; )
4247 {
4248 enum elf_ppc_reloc_type r_type;
4249 unsigned long r_symndx;
4250 asection *sym_sec;
4251 struct elf_link_hash_entry *h;
4252 Elf_Internal_Sym *sym;
4253 unsigned char *tls_maskp;
4254
4255 r_type = ELF32_R_TYPE (rel->r_info);
4256 if (r_type != R_PPC_PLTCALL)
4257 continue;
4258
4259 r_symndx = ELF32_R_SYM (rel->r_info);
4260 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
4261 r_symndx, ibfd))
4262 {
4263 if (elf_section_data (sec)->relocs != relstart)
4264 free (relstart);
4265 if (symtab_hdr->contents != (unsigned char *) local_syms)
4266 free (local_syms);
4267 return FALSE;
4268 }
4269
4270 if (sym_sec != NULL && sym_sec->output_section != NULL)
4271 {
4272 bfd_vma from, to;
4273 if (h != NULL)
4274 to = h->root.u.def.value;
4275 else
4276 to = sym->st_value;
4277 to += (rel->r_addend
4278 + sym_sec->output_offset
4279 + sym_sec->output_section->vma);
4280 from = (rel->r_offset
4281 + sec->output_offset
4282 + sec->output_section->vma);
4283 if (to - from + limit < 2 * limit)
4284 *tls_maskp &= ~PLT_KEEP;
4285 }
4286 }
4287 if (elf_section_data (sec)->relocs != relstart)
4288 free (relstart);
4289 }
4290
4291 if (local_syms != NULL
4292 && symtab_hdr->contents != (unsigned char *) local_syms)
4293 {
4294 if (!info->keep_memory)
4295 free (local_syms);
4296 else
4297 symtab_hdr->contents = (unsigned char *) local_syms;
4298 }
4299 }
4300
4301 return TRUE;
4302 }
4303
4304 /* Set plt output section type, htab->tls_get_addr, and call the
4305 generic ELF tls_setup function. */
4306
4307 asection *
4308 ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
4309 {
4310 struct ppc_elf_link_hash_table *htab;
4311
4312 htab = ppc_elf_hash_table (info);
4313 htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4314 FALSE, FALSE, TRUE);
4315 if (htab->plt_type != PLT_NEW)
4316 htab->params->no_tls_get_addr_opt = TRUE;
4317
4318 if (!htab->params->no_tls_get_addr_opt)
4319 {
4320 struct elf_link_hash_entry *opt, *tga;
4321 opt = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
4322 FALSE, FALSE, TRUE);
4323 if (opt != NULL
4324 && (opt->root.type == bfd_link_hash_defined
4325 || opt->root.type == bfd_link_hash_defweak))
4326 {
4327 /* If glibc supports an optimized __tls_get_addr call stub,
4328 signalled by the presence of __tls_get_addr_opt, and we'll
4329 be calling __tls_get_addr via a plt call stub, then
4330 make __tls_get_addr point to __tls_get_addr_opt. */
4331 tga = htab->tls_get_addr;
4332 if (htab->elf.dynamic_sections_created
4333 && tga != NULL
4334 && (tga->type == STT_FUNC
4335 || tga->needs_plt)
4336 && !(SYMBOL_CALLS_LOCAL (info, tga)
4337 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga)))
4338 {
4339 struct plt_entry *ent;
4340 for (ent = tga->plt.plist; ent != NULL; ent = ent->next)
4341 if (ent->plt.refcount > 0)
4342 break;
4343 if (ent != NULL)
4344 {
4345 tga->root.type = bfd_link_hash_indirect;
4346 tga->root.u.i.link = &opt->root;
4347 ppc_elf_copy_indirect_symbol (info, opt, tga);
4348 opt->mark = 1;
4349 if (opt->dynindx != -1)
4350 {
4351 /* Use __tls_get_addr_opt in dynamic relocations. */
4352 opt->dynindx = -1;
4353 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4354 opt->dynstr_index);
4355 if (!bfd_elf_link_record_dynamic_symbol (info, opt))
4356 return FALSE;
4357 }
4358 htab->tls_get_addr = opt;
4359 }
4360 }
4361 }
4362 else
4363 htab->params->no_tls_get_addr_opt = TRUE;
4364 }
4365 if (htab->plt_type == PLT_NEW
4366 && htab->elf.splt != NULL
4367 && htab->elf.splt->output_section != NULL)
4368 {
4369 elf_section_type (htab->elf.splt->output_section) = SHT_PROGBITS;
4370 elf_section_flags (htab->elf.splt->output_section) = SHF_ALLOC + SHF_WRITE;
4371 }
4372
4373 return _bfd_elf_tls_setup (obfd, info);
4374 }
4375
4376 /* Return TRUE iff REL is a branch reloc with a global symbol matching
4377 HASH. */
4378
4379 static bfd_boolean
4380 branch_reloc_hash_match (const bfd *ibfd,
4381 const Elf_Internal_Rela *rel,
4382 const struct elf_link_hash_entry *hash)
4383 {
4384 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
4385 enum elf_ppc_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
4386 unsigned int r_symndx = ELF32_R_SYM (rel->r_info);
4387
4388 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
4389 {
4390 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
4391 struct elf_link_hash_entry *h;
4392
4393 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4394 while (h->root.type == bfd_link_hash_indirect
4395 || h->root.type == bfd_link_hash_warning)
4396 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4397 if (h == hash)
4398 return TRUE;
4399 }
4400 return FALSE;
4401 }
4402
4403 /* Run through all the TLS relocs looking for optimization
4404 opportunities. */
4405
4406 bfd_boolean
4407 ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED,
4408 struct bfd_link_info *info)
4409 {
4410 bfd *ibfd;
4411 asection *sec;
4412 struct ppc_elf_link_hash_table *htab;
4413 int pass;
4414
4415 if (!bfd_link_executable (info))
4416 return TRUE;
4417
4418 htab = ppc_elf_hash_table (info);
4419 if (htab == NULL)
4420 return FALSE;
4421
4422 /* Make two passes through the relocs. First time check that tls
4423 relocs involved in setting up a tls_get_addr call are indeed
4424 followed by such a call. If they are not, don't do any tls
4425 optimization. On the second pass twiddle tls_mask flags to
4426 notify relocate_section that optimization can be done, and
4427 adjust got and plt refcounts. */
4428 for (pass = 0; pass < 2; ++pass)
4429 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4430 {
4431 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
4432 asection *got2 = bfd_get_section_by_name (ibfd, ".got2");
4433
4434 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4435 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
4436 {
4437 Elf_Internal_Rela *relstart, *rel, *relend;
4438 int expecting_tls_get_addr = 0;
4439
4440 /* Read the relocations. */
4441 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
4442 info->keep_memory);
4443 if (relstart == NULL)
4444 return FALSE;
4445
4446 relend = relstart + sec->reloc_count;
4447 for (rel = relstart; rel < relend; rel++)
4448 {
4449 enum elf_ppc_reloc_type r_type;
4450 unsigned long r_symndx;
4451 struct elf_link_hash_entry *h = NULL;
4452 unsigned char *tls_mask;
4453 unsigned char tls_set, tls_clear;
4454 bfd_boolean is_local;
4455 bfd_signed_vma *got_count;
4456
4457 r_symndx = ELF32_R_SYM (rel->r_info);
4458 if (r_symndx >= symtab_hdr->sh_info)
4459 {
4460 struct elf_link_hash_entry **sym_hashes;
4461
4462 sym_hashes = elf_sym_hashes (ibfd);
4463 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4464 while (h->root.type == bfd_link_hash_indirect
4465 || h->root.type == bfd_link_hash_warning)
4466 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4467 }
4468
4469 is_local = SYMBOL_REFERENCES_LOCAL (info, h);
4470 r_type = ELF32_R_TYPE (rel->r_info);
4471 /* If this section has old-style __tls_get_addr calls
4472 without marker relocs, then check that each
4473 __tls_get_addr call reloc is preceded by a reloc
4474 that conceivably belongs to the __tls_get_addr arg
4475 setup insn. If we don't find matching arg setup
4476 relocs, don't do any tls optimization. */
4477 if (pass == 0
4478 && sec->nomark_tls_get_addr
4479 && h != NULL
4480 && h == htab->tls_get_addr
4481 && !expecting_tls_get_addr
4482 && is_branch_reloc (r_type))
4483 {
4484 info->callbacks->minfo ("%H __tls_get_addr lost arg, "
4485 "TLS optimization disabled\n",
4486 ibfd, sec, rel->r_offset);
4487 if (elf_section_data (sec)->relocs != relstart)
4488 free (relstart);
4489 return TRUE;
4490 }
4491
4492 expecting_tls_get_addr = 0;
4493 switch (r_type)
4494 {
4495 case R_PPC_GOT_TLSLD16:
4496 case R_PPC_GOT_TLSLD16_LO:
4497 expecting_tls_get_addr = 1;
4498 /* Fall through. */
4499
4500 case R_PPC_GOT_TLSLD16_HI:
4501 case R_PPC_GOT_TLSLD16_HA:
4502 /* These relocs should never be against a symbol
4503 defined in a shared lib. Leave them alone if
4504 that turns out to be the case. */
4505 if (!is_local)
4506 continue;
4507
4508 /* LD -> LE */
4509 tls_set = 0;
4510 tls_clear = TLS_LD;
4511 break;
4512
4513 case R_PPC_GOT_TLSGD16:
4514 case R_PPC_GOT_TLSGD16_LO:
4515 expecting_tls_get_addr = 1;
4516 /* Fall through. */
4517
4518 case R_PPC_GOT_TLSGD16_HI:
4519 case R_PPC_GOT_TLSGD16_HA:
4520 if (is_local)
4521 /* GD -> LE */
4522 tls_set = 0;
4523 else
4524 /* GD -> IE */
4525 tls_set = TLS_TLS | TLS_GDIE;
4526 tls_clear = TLS_GD;
4527 break;
4528
4529 case R_PPC_GOT_TPREL16:
4530 case R_PPC_GOT_TPREL16_LO:
4531 case R_PPC_GOT_TPREL16_HI:
4532 case R_PPC_GOT_TPREL16_HA:
4533 if (is_local)
4534 {
4535 /* IE -> LE */
4536 tls_set = 0;
4537 tls_clear = TLS_TPREL;
4538 break;
4539 }
4540 else
4541 continue;
4542
4543 case R_PPC_TLSLD:
4544 if (!is_local)
4545 continue;
4546 /* Fall through. */
4547 case R_PPC_TLSGD:
4548 if (rel + 1 < relend
4549 && is_plt_seq_reloc (ELF32_R_TYPE (rel[1].r_info)))
4550 {
4551 if (pass != 0
4552 && ELF32_R_TYPE (rel[1].r_info) != R_PPC_PLTSEQ)
4553 {
4554 r_type = ELF32_R_TYPE (rel[1].r_info);
4555 r_symndx = ELF32_R_SYM (rel[1].r_info);
4556 if (r_symndx >= symtab_hdr->sh_info)
4557 {
4558 struct elf_link_hash_entry **sym_hashes;
4559
4560 sym_hashes = elf_sym_hashes (ibfd);
4561 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4562 while (h->root.type == bfd_link_hash_indirect
4563 || h->root.type == bfd_link_hash_warning)
4564 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4565 if (h != NULL)
4566 {
4567 struct plt_entry *ent = NULL;
4568 bfd_vma addend = 0;
4569
4570 if (bfd_link_pic (info))
4571 addend = rel->r_addend;
4572 ent = find_plt_ent (&h->plt.plist,
4573 got2, addend);
4574 if (ent != NULL
4575 && ent->plt.refcount > 0)
4576 ent->plt.refcount -= 1;
4577 }
4578 }
4579 }
4580 continue;
4581 }
4582 expecting_tls_get_addr = 2;
4583 tls_set = 0;
4584 tls_clear = 0;
4585 break;
4586
4587 default:
4588 continue;
4589 }
4590
4591 if (pass == 0)
4592 {
4593 if (!expecting_tls_get_addr
4594 || !sec->nomark_tls_get_addr)
4595 continue;
4596
4597 if (rel + 1 < relend
4598 && branch_reloc_hash_match (ibfd, rel + 1,
4599 htab->tls_get_addr))
4600 continue;
4601
4602 /* Uh oh, we didn't find the expected call. We
4603 could just mark this symbol to exclude it
4604 from tls optimization but it's safer to skip
4605 the entire optimization. */
4606 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
4607 "TLS optimization disabled\n"),
4608 ibfd, sec, rel->r_offset);
4609 if (elf_section_data (sec)->relocs != relstart)
4610 free (relstart);
4611 return TRUE;
4612 }
4613
4614 if (h != NULL)
4615 {
4616 tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
4617 got_count = &h->got.refcount;
4618 }
4619 else
4620 {
4621 bfd_signed_vma *lgot_refs;
4622 struct plt_entry **local_plt;
4623 unsigned char *lgot_masks;
4624
4625 lgot_refs = elf_local_got_refcounts (ibfd);
4626 if (lgot_refs == NULL)
4627 abort ();
4628 local_plt = (struct plt_entry **)
4629 (lgot_refs + symtab_hdr->sh_info);
4630 lgot_masks = (unsigned char *)
4631 (local_plt + symtab_hdr->sh_info);
4632 tls_mask = &lgot_masks[r_symndx];
4633 got_count = &lgot_refs[r_symndx];
4634 }
4635
4636 /* If we don't have old-style __tls_get_addr calls
4637 without TLSGD/TLSLD marker relocs, and we haven't
4638 found a new-style __tls_get_addr call with a
4639 marker for this symbol, then we either have a
4640 broken object file or an -mlongcall style
4641 indirect call to __tls_get_addr without a marker.
4642 Disable optimization in this case. */
4643 if ((tls_clear & (TLS_GD | TLS_LD)) != 0
4644 && !sec->nomark_tls_get_addr
4645 && ((*tls_mask & (TLS_TLS | TLS_MARK))
4646 != (TLS_TLS | TLS_MARK)))
4647 continue;
4648
4649 if (expecting_tls_get_addr == 1 + !sec->nomark_tls_get_addr)
4650 {
4651 struct plt_entry *ent;
4652 bfd_vma addend = 0;
4653
4654 if (bfd_link_pic (info)
4655 && (ELF32_R_TYPE (rel[1].r_info) == R_PPC_PLTREL24
4656 || ELF32_R_TYPE (rel[1].r_info) == R_PPC_PLTCALL))
4657 addend = rel[1].r_addend;
4658 ent = find_plt_ent (&htab->tls_get_addr->plt.plist,
4659 got2, addend);
4660 if (ent != NULL && ent->plt.refcount > 0)
4661 ent->plt.refcount -= 1;
4662 }
4663 if (tls_clear == 0)
4664 continue;
4665
4666 if (tls_set == 0)
4667 {
4668 /* We managed to get rid of a got entry. */
4669 if (*got_count > 0)
4670 *got_count -= 1;
4671 }
4672
4673 *tls_mask |= tls_set;
4674 *tls_mask &= ~tls_clear;
4675 }
4676
4677 if (elf_section_data (sec)->relocs != relstart)
4678 free (relstart);
4679 }
4680 }
4681 htab->do_tls_opt = 1;
4682 return TRUE;
4683 }
4684 \f
4685 /* Return true if we have dynamic relocs against H or any of its weak
4686 aliases, that apply to read-only sections. Cannot be used after
4687 size_dynamic_sections. */
4688
4689 static bfd_boolean
4690 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
4691 {
4692 struct ppc_elf_link_hash_entry *eh = ppc_elf_hash_entry (h);
4693 do
4694 {
4695 if (_bfd_elf_readonly_dynrelocs (&eh->elf))
4696 return TRUE;
4697 eh = ppc_elf_hash_entry (eh->elf.u.alias);
4698 } while (eh != NULL && &eh->elf != h);
4699
4700 return FALSE;
4701 }
4702
4703 /* Return whether H has pc-relative dynamic relocs. */
4704
4705 static bfd_boolean
4706 pc_dynrelocs (struct elf_link_hash_entry *h)
4707 {
4708 struct elf_dyn_relocs *p;
4709
4710 for (p = h->dyn_relocs; p != NULL; p = p->next)
4711 if (p->pc_count != 0)
4712 return TRUE;
4713 return FALSE;
4714 }
4715
4716 /* Adjust a symbol defined by a dynamic object and referenced by a
4717 regular object. The current definition is in some section of the
4718 dynamic object, but we're not including those sections. We have to
4719 change the definition to something the rest of the link can
4720 understand. */
4721
4722 static bfd_boolean
4723 ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
4724 struct elf_link_hash_entry *h)
4725 {
4726 struct ppc_elf_link_hash_table *htab;
4727 asection *s;
4728
4729 #ifdef DEBUG
4730 fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n",
4731 h->root.root.string);
4732 #endif
4733
4734 /* Make sure we know what is going on here. */
4735 htab = ppc_elf_hash_table (info);
4736 BFD_ASSERT (htab->elf.dynobj != NULL
4737 && (h->needs_plt
4738 || h->type == STT_GNU_IFUNC
4739 || h->is_weakalias
4740 || (h->def_dynamic
4741 && h->ref_regular
4742 && !h->def_regular)));
4743
4744 /* Deal with function syms. */
4745 if (h->type == STT_FUNC
4746 || h->type == STT_GNU_IFUNC
4747 || h->needs_plt)
4748 {
4749 bfd_boolean local = (SYMBOL_CALLS_LOCAL (info, h)
4750 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
4751 /* Discard dyn_relocs when non-pic if we've decided that a
4752 function symbol is local. */
4753 if (!bfd_link_pic (info) && local)
4754 h->dyn_relocs = NULL;
4755
4756 /* Clear procedure linkage table information for any symbol that
4757 won't need a .plt entry. */
4758 struct plt_entry *ent;
4759 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
4760 if (ent->plt.refcount > 0)
4761 break;
4762 if (ent == NULL
4763 || (h->type != STT_GNU_IFUNC
4764 && local
4765 && (htab->can_convert_all_inline_plt
4766 || (ppc_elf_hash_entry (h)->tls_mask
4767 & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
4768 {
4769 /* A PLT entry is not required/allowed when:
4770
4771 1. We are not using ld.so; because then the PLT entry
4772 can't be set up, so we can't use one. In this case,
4773 ppc_elf_adjust_dynamic_symbol won't even be called.
4774
4775 2. GC has rendered the entry unused.
4776
4777 3. We know for certain that a call to this symbol
4778 will go to this object, or will remain undefined. */
4779 h->plt.plist = NULL;
4780 h->needs_plt = 0;
4781 h->pointer_equality_needed = 0;
4782 }
4783 else
4784 {
4785 /* Taking a function's address in a read/write section
4786 doesn't require us to define the function symbol in the
4787 executable on a plt call stub. A dynamic reloc can
4788 be used instead, giving better runtime performance.
4789 (Calls via that function pointer don't need to bounce
4790 through the plt call stub.) Similarly, use a dynamic
4791 reloc for a weak reference when possible, allowing the
4792 resolution of the symbol to be set at load time rather
4793 than link time. */
4794 if ((h->pointer_equality_needed
4795 || (h->non_got_ref
4796 && !h->ref_regular_nonweak
4797 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
4798 && htab->elf.target_os != is_vxworks
4799 && !ppc_elf_hash_entry (h)->has_sda_refs
4800 && !_bfd_elf_readonly_dynrelocs (h))
4801 {
4802 h->pointer_equality_needed = 0;
4803 /* If we haven't seen a branch reloc and the symbol
4804 isn't an ifunc then we don't need a plt entry. */
4805 if (!h->needs_plt && h->type != STT_GNU_IFUNC)
4806 h->plt.plist = NULL;
4807 }
4808 else if (!bfd_link_pic (info))
4809 /* We are going to be defining the function symbol on the
4810 plt stub, so no dyn_relocs needed when non-pic. */
4811 h->dyn_relocs = NULL;
4812 }
4813 h->protected_def = 0;
4814 /* Function symbols can't have copy relocs. */
4815 return TRUE;
4816 }
4817 else
4818 h->plt.plist = NULL;
4819
4820 /* If this is a weak symbol, and there is a real definition, the
4821 processor independent code will have arranged for us to see the
4822 real definition first, and we can just use the same value. */
4823 if (h->is_weakalias)
4824 {
4825 struct elf_link_hash_entry *def = weakdef (h);
4826 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
4827 h->root.u.def.section = def->root.u.def.section;
4828 h->root.u.def.value = def->root.u.def.value;
4829 if (def->root.u.def.section == htab->elf.sdynbss
4830 || def->root.u.def.section == htab->elf.sdynrelro
4831 || def->root.u.def.section == htab->dynsbss)
4832 h->dyn_relocs = NULL;
4833 return TRUE;
4834 }
4835
4836 /* This is a reference to a symbol defined by a dynamic object which
4837 is not a function. */
4838
4839 /* If we are creating a shared library, we must presume that the
4840 only references to the symbol are via the global offset table.
4841 For such cases we need not do anything here; the relocations will
4842 be handled correctly by relocate_section. */
4843 if (bfd_link_pic (info))
4844 {
4845 h->protected_def = 0;
4846 return TRUE;
4847 }
4848
4849 /* If there are no references to this symbol that do not use the
4850 GOT, we don't need to generate a copy reloc. */
4851 if (!h->non_got_ref)
4852 {
4853 h->protected_def = 0;
4854 return TRUE;
4855 }
4856
4857 /* Protected variables do not work with .dynbss. The copy in
4858 .dynbss won't be used by the shared library with the protected
4859 definition for the variable. Editing to PIC, or text relocations
4860 are preferable to an incorrect program. */
4861 if (h->protected_def)
4862 {
4863 if (ELIMINATE_COPY_RELOCS
4864 && ppc_elf_hash_entry (h)->has_addr16_ha
4865 && ppc_elf_hash_entry (h)->has_addr16_lo
4866 && htab->params->pic_fixup == 0
4867 && info->disable_target_specific_optimizations <= 1)
4868 htab->params->pic_fixup = 1;
4869 return TRUE;
4870 }
4871
4872 /* If -z nocopyreloc was given, we won't generate them either. */
4873 if (info->nocopyreloc)
4874 return TRUE;
4875
4876 /* If we don't find any dynamic relocs in read-only sections, then
4877 we'll be keeping the dynamic relocs and avoiding the copy reloc.
4878 We can't do this if there are any small data relocations. This
4879 doesn't work on VxWorks, where we can not have dynamic
4880 relocations (other than copy and jump slot relocations) in an
4881 executable. */
4882 if (ELIMINATE_COPY_RELOCS
4883 && !ppc_elf_hash_entry (h)->has_sda_refs
4884 && htab->elf.target_os != is_vxworks
4885 && !h->def_regular
4886 && !alias_readonly_dynrelocs (h))
4887 return TRUE;
4888
4889 /* We must allocate the symbol in our .dynbss section, which will
4890 become part of the .bss section of the executable. There will be
4891 an entry for this symbol in the .dynsym section. The dynamic
4892 object will contain position independent code, so all references
4893 from the dynamic object to this symbol will go through the global
4894 offset table. The dynamic linker will use the .dynsym entry to
4895 determine the address it must put in the global offset table, so
4896 both the dynamic object and the regular object will refer to the
4897 same memory location for the variable.
4898
4899 Of course, if the symbol is referenced using SDAREL relocs, we
4900 must instead allocate it in .sbss. */
4901 if (ppc_elf_hash_entry (h)->has_sda_refs)
4902 s = htab->dynsbss;
4903 else if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
4904 s = htab->elf.sdynrelro;
4905 else
4906 s = htab->elf.sdynbss;
4907 BFD_ASSERT (s != NULL);
4908
4909 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
4910 {
4911 asection *srel;
4912
4913 /* We must generate a R_PPC_COPY reloc to tell the dynamic
4914 linker to copy the initial value out of the dynamic object
4915 and into the runtime process image. */
4916 if (ppc_elf_hash_entry (h)->has_sda_refs)
4917 srel = htab->relsbss;
4918 else if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
4919 srel = htab->elf.sreldynrelro;
4920 else
4921 srel = htab->elf.srelbss;
4922 BFD_ASSERT (srel != NULL);
4923 srel->size += sizeof (Elf32_External_Rela);
4924 h->needs_copy = 1;
4925 }
4926
4927 /* We no longer want dyn_relocs. */
4928 h->dyn_relocs = NULL;
4929 return _bfd_elf_adjust_dynamic_copy (info, h, s);
4930 }
4931 \f
4932 /* Generate a symbol to mark plt call stubs. For non-PIC code the sym is
4933 xxxxxxxx.plt_call32.<callee> where xxxxxxxx is a hex number, usually 0,
4934 specifying the addend on the plt relocation. For -fpic code, the sym
4935 is xxxxxxxx.plt_pic32.<callee>, and for -fPIC
4936 xxxxxxxx.got2.plt_pic32.<callee>. */
4937
4938 static bfd_boolean
4939 add_stub_sym (struct plt_entry *ent,
4940 struct elf_link_hash_entry *h,
4941 struct bfd_link_info *info)
4942 {
4943 struct elf_link_hash_entry *sh;
4944 size_t len1, len2, len3;
4945 char *name;
4946 const char *stub;
4947 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
4948
4949 if (bfd_link_pic (info))
4950 stub = ".plt_pic32.";
4951 else
4952 stub = ".plt_call32.";
4953
4954 len1 = strlen (h->root.root.string);
4955 len2 = strlen (stub);
4956 len3 = 0;
4957 if (ent->sec)
4958 len3 = strlen (ent->sec->name);
4959 name = bfd_malloc (len1 + len2 + len3 + 9);
4960 if (name == NULL)
4961 return FALSE;
4962 sprintf (name, "%08x", (unsigned) ent->addend & 0xffffffff);
4963 if (ent->sec)
4964 memcpy (name + 8, ent->sec->name, len3);
4965 memcpy (name + 8 + len3, stub, len2);
4966 memcpy (name + 8 + len3 + len2, h->root.root.string, len1 + 1);
4967 sh = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
4968 if (sh == NULL)
4969 return FALSE;
4970 if (sh->root.type == bfd_link_hash_new)
4971 {
4972 sh->root.type = bfd_link_hash_defined;
4973 sh->root.u.def.section = htab->glink;
4974 sh->root.u.def.value = ent->glink_offset;
4975 sh->ref_regular = 1;
4976 sh->def_regular = 1;
4977 sh->ref_regular_nonweak = 1;
4978 sh->forced_local = 1;
4979 sh->non_elf = 0;
4980 sh->root.linker_def = 1;
4981 }
4982 return TRUE;
4983 }
4984
4985 /* Allocate NEED contiguous space in .got, and return the offset.
4986 Handles allocation of the got header when crossing 32k. */
4987
4988 static bfd_vma
4989 allocate_got (struct ppc_elf_link_hash_table *htab, unsigned int need)
4990 {
4991 bfd_vma where;
4992 unsigned int max_before_header;
4993
4994 if (htab->plt_type == PLT_VXWORKS)
4995 {
4996 where = htab->elf.sgot->size;
4997 htab->elf.sgot->size += need;
4998 }
4999 else
5000 {
5001 max_before_header = htab->plt_type == PLT_NEW ? 32768 : 32764;
5002 if (need <= htab->got_gap)
5003 {
5004 where = max_before_header - htab->got_gap;
5005 htab->got_gap -= need;
5006 }
5007 else
5008 {
5009 if (htab->elf.sgot->size + need > max_before_header
5010 && htab->elf.sgot->size <= max_before_header)
5011 {
5012 htab->got_gap = max_before_header - htab->elf.sgot->size;
5013 htab->elf.sgot->size = max_before_header + htab->got_header_size;
5014 }
5015 where = htab->elf.sgot->size;
5016 htab->elf.sgot->size += need;
5017 }
5018 }
5019 return where;
5020 }
5021
5022 /* Calculate size of GOT entries for symbol given its TLS_MASK.
5023 TLS_LD is excluded because those go in a special GOT slot. */
5024
5025 static inline unsigned int
5026 got_entries_needed (int tls_mask)
5027 {
5028 unsigned int need;
5029 if ((tls_mask & TLS_TLS) == 0)
5030 need = 4;
5031 else
5032 {
5033 need = 0;
5034 if ((tls_mask & TLS_GD) != 0)
5035 need += 8;
5036 if ((tls_mask & (TLS_TPREL | TLS_GDIE)) != 0)
5037 need += 4;
5038 if ((tls_mask & TLS_DTPREL) != 0)
5039 need += 4;
5040 }
5041 return need;
5042 }
5043
5044 /* If H is undefined, make it dynamic if that makes sense. */
5045
5046 static bfd_boolean
5047 ensure_undef_dynamic (struct bfd_link_info *info,
5048 struct elf_link_hash_entry *h)
5049 {
5050 struct elf_link_hash_table *htab = elf_hash_table (info);
5051
5052 if (htab->dynamic_sections_created
5053 && ((info->dynamic_undefined_weak != 0
5054 && h->root.type == bfd_link_hash_undefweak)
5055 || h->root.type == bfd_link_hash_undefined)
5056 && h->dynindx == -1
5057 && !h->forced_local
5058 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
5059 return bfd_elf_link_record_dynamic_symbol (info, h);
5060 return TRUE;
5061 }
5062
5063 /* Allocate space in associated reloc sections for dynamic relocs. */
5064
5065 static bfd_boolean
5066 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5067 {
5068 struct bfd_link_info *info = inf;
5069 struct ppc_elf_link_hash_entry *eh;
5070 struct ppc_elf_link_hash_table *htab;
5071 struct elf_dyn_relocs *p;
5072 bfd_boolean dyn;
5073
5074 if (h->root.type == bfd_link_hash_indirect)
5075 return TRUE;
5076
5077 htab = ppc_elf_hash_table (info);
5078 eh = (struct ppc_elf_link_hash_entry *) h;
5079 if (eh->elf.got.refcount > 0
5080 || (ELIMINATE_COPY_RELOCS
5081 && !eh->elf.def_regular
5082 && eh->elf.protected_def
5083 && eh->has_addr16_ha
5084 && eh->has_addr16_lo
5085 && htab->params->pic_fixup > 0))
5086 {
5087 unsigned int need;
5088
5089 /* Make sure this symbol is output as a dynamic symbol. */
5090 if (!ensure_undef_dynamic (info, &eh->elf))
5091 return FALSE;
5092
5093 need = 0;
5094 if ((eh->tls_mask & (TLS_TLS | TLS_LD)) == (TLS_TLS | TLS_LD))
5095 {
5096 if (SYMBOL_REFERENCES_LOCAL (info, &eh->elf))
5097 /* We'll just use htab->tlsld_got.offset. This should
5098 always be the case. It's a little odd if we have
5099 a local dynamic reloc against a non-local symbol. */
5100 htab->tlsld_got.refcount += 1;
5101 else
5102 need += 8;
5103 }
5104 need += got_entries_needed (eh->tls_mask);
5105 if (need == 0)
5106 eh->elf.got.offset = (bfd_vma) -1;
5107 else
5108 {
5109 eh->elf.got.offset = allocate_got (htab, need);
5110 if (((bfd_link_pic (info)
5111 && !((eh->tls_mask & TLS_TLS) != 0
5112 && bfd_link_executable (info)
5113 && SYMBOL_REFERENCES_LOCAL (info, &eh->elf)))
5114 || (htab->elf.dynamic_sections_created
5115 && eh->elf.dynindx != -1
5116 && !SYMBOL_REFERENCES_LOCAL (info, &eh->elf)))
5117 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &eh->elf))
5118 {
5119 asection *rsec;
5120
5121 need *= sizeof (Elf32_External_Rela) / 4;
5122 if ((eh->tls_mask & (TLS_TLS | TLS_LD)) == (TLS_TLS | TLS_LD))
5123 need -= sizeof (Elf32_External_Rela);
5124 rsec = htab->elf.srelgot;
5125 if (eh->elf.type == STT_GNU_IFUNC)
5126 rsec = htab->elf.irelplt;
5127 rsec->size += need;
5128 }
5129 }
5130 }
5131 else
5132 eh->elf.got.offset = (bfd_vma) -1;
5133
5134 /* If no dynamic sections we can't have dynamic relocs, except for
5135 IFUNCs which are handled even in static executables. */
5136 if (!htab->elf.dynamic_sections_created
5137 && h->type != STT_GNU_IFUNC)
5138 h->dyn_relocs = NULL;
5139
5140 /* Discard relocs on undefined symbols that must be local. */
5141 else if (h->root.type == bfd_link_hash_undefined
5142 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5143 h->dyn_relocs = NULL;
5144
5145 /* Also discard relocs on undefined weak syms with non-default
5146 visibility, or when dynamic_undefined_weak says so. */
5147 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5148 h->dyn_relocs = NULL;
5149
5150 if (h->dyn_relocs == NULL)
5151 ;
5152
5153 /* In the shared -Bsymbolic case, discard space allocated for
5154 dynamic pc-relative relocs against symbols which turn out to be
5155 defined in regular objects. For the normal shared case, discard
5156 space for relocs that have become local due to symbol visibility
5157 changes. */
5158 else if (bfd_link_pic (info))
5159 {
5160 /* Relocs that use pc_count are those that appear on a call insn,
5161 or certain REL relocs (see must_be_dyn_reloc) that can be
5162 generated via assembly. We want calls to protected symbols to
5163 resolve directly to the function rather than going via the plt.
5164 If people want function pointer comparisons to work as expected
5165 then they should avoid writing weird assembly. */
5166 if (SYMBOL_CALLS_LOCAL (info, h))
5167 {
5168 struct elf_dyn_relocs **pp;
5169
5170 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
5171 {
5172 p->count -= p->pc_count;
5173 p->pc_count = 0;
5174 if (p->count == 0)
5175 *pp = p->next;
5176 else
5177 pp = &p->next;
5178 }
5179 }
5180
5181 if (htab->elf.target_os == is_vxworks)
5182 {
5183 struct elf_dyn_relocs **pp;
5184
5185 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
5186 {
5187 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
5188 *pp = p->next;
5189 else
5190 pp = &p->next;
5191 }
5192 }
5193
5194 if (h->dyn_relocs != NULL)
5195 {
5196 /* Make sure this symbol is output as a dynamic symbol. */
5197 if (!ensure_undef_dynamic (info, h))
5198 return FALSE;
5199 }
5200 }
5201 else if (ELIMINATE_COPY_RELOCS)
5202 {
5203 /* For the non-pic case, discard space for relocs against
5204 symbols which turn out to need copy relocs or are not
5205 dynamic. */
5206 if (h->dynamic_adjusted
5207 && !h->def_regular
5208 && !ELF_COMMON_DEF_P (h)
5209 && !(h->protected_def
5210 && eh->has_addr16_ha
5211 && eh->has_addr16_lo
5212 && htab->params->pic_fixup > 0))
5213 {
5214 /* Make sure this symbol is output as a dynamic symbol. */
5215 if (!ensure_undef_dynamic (info, h))
5216 return FALSE;
5217
5218 if (h->dynindx == -1)
5219 h->dyn_relocs = NULL;
5220 }
5221 else
5222 h->dyn_relocs = NULL;
5223 }
5224
5225 /* Allocate space. */
5226 for (p = h->dyn_relocs; p != NULL; p = p->next)
5227 {
5228 asection *sreloc = elf_section_data (p->sec)->sreloc;
5229 if (eh->elf.type == STT_GNU_IFUNC)
5230 sreloc = htab->elf.irelplt;
5231 sreloc->size += p->count * sizeof (Elf32_External_Rela);
5232 }
5233
5234 /* Handle PLT relocs. Done last, after dynindx has settled.
5235 We might need a PLT entry when the symbol
5236 a) is dynamic, or
5237 b) is an ifunc, or
5238 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
5239 d) has plt16 relocs and we are linking statically. */
5240 dyn = htab->elf.dynamic_sections_created && h->dynindx != -1;
5241 if (dyn
5242 || h->type == STT_GNU_IFUNC
5243 || (h->needs_plt && h->dynamic_adjusted)
5244 || (h->needs_plt
5245 && h->def_regular
5246 && !htab->elf.dynamic_sections_created
5247 && !htab->can_convert_all_inline_plt
5248 && (ppc_elf_hash_entry (h)->tls_mask
5249 & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
5250 {
5251 struct plt_entry *ent;
5252 bfd_boolean doneone = FALSE;
5253 bfd_vma plt_offset = 0, glink_offset = (bfd_vma) -1;
5254
5255 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5256 if (ent->plt.refcount > 0)
5257 {
5258 asection *s = htab->elf.splt;
5259
5260 if (!dyn)
5261 {
5262 if (h->type == STT_GNU_IFUNC)
5263 s = htab->elf.iplt;
5264 else
5265 s = htab->pltlocal;
5266 }
5267
5268 if (htab->plt_type == PLT_NEW || !dyn)
5269 {
5270 if (!doneone)
5271 {
5272 plt_offset = s->size;
5273 s->size += 4;
5274 }
5275 ent->plt.offset = plt_offset;
5276
5277 if (s == htab->pltlocal)
5278 ent->glink_offset = glink_offset;
5279 else
5280 {
5281 s = htab->glink;
5282 if (!doneone || bfd_link_pic (info))
5283 {
5284 glink_offset = s->size;
5285 s->size += GLINK_ENTRY_SIZE (htab, h);
5286 }
5287 if (!doneone
5288 && !bfd_link_pic (info)
5289 && h->def_dynamic
5290 && !h->def_regular)
5291 {
5292 h->root.u.def.section = s;
5293 h->root.u.def.value = glink_offset;
5294 }
5295 ent->glink_offset = glink_offset;
5296
5297 if (htab->params->emit_stub_syms
5298 && !add_stub_sym (ent, h, info))
5299 return FALSE;
5300 }
5301 }
5302 else
5303 {
5304 if (!doneone)
5305 {
5306 /* If this is the first .plt entry, make room
5307 for the special first entry. */
5308 if (s->size == 0)
5309 s->size += htab->plt_initial_entry_size;
5310
5311 /* The PowerPC PLT is actually composed of two
5312 parts, the first part is 2 words (for a load
5313 and a jump), and then there is a remaining
5314 word available at the end. */
5315 plt_offset = (htab->plt_initial_entry_size
5316 + (htab->plt_slot_size
5317 * ((s->size
5318 - htab->plt_initial_entry_size)
5319 / htab->plt_entry_size)));
5320
5321 /* If this symbol is not defined in a regular
5322 file, and we are not generating a shared
5323 library, then set the symbol to this location
5324 in the .plt. This is to avoid text
5325 relocations, and is required to make
5326 function pointers compare as equal between
5327 the normal executable and the shared library. */
5328 if (! bfd_link_pic (info)
5329 && h->def_dynamic
5330 && !h->def_regular)
5331 {
5332 h->root.u.def.section = s;
5333 h->root.u.def.value = plt_offset;
5334 }
5335
5336 /* Make room for this entry. */
5337 s->size += htab->plt_entry_size;
5338 /* After the 8192nd entry, room for two entries
5339 is allocated. */
5340 if (htab->plt_type == PLT_OLD
5341 && (s->size - htab->plt_initial_entry_size)
5342 / htab->plt_entry_size
5343 > PLT_NUM_SINGLE_ENTRIES)
5344 s->size += htab->plt_entry_size;
5345 }
5346 ent->plt.offset = plt_offset;
5347 }
5348
5349 /* We also need to make an entry in the .rela.plt section. */
5350 if (!doneone)
5351 {
5352 if (!dyn)
5353 {
5354 if (h->type == STT_GNU_IFUNC)
5355 {
5356 s = htab->elf.irelplt;
5357 s->size += sizeof (Elf32_External_Rela);
5358 }
5359 else if (bfd_link_pic (info))
5360 {
5361 s = htab->relpltlocal;
5362 s->size += sizeof (Elf32_External_Rela);
5363 }
5364 }
5365 else
5366 {
5367 htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
5368
5369 if (htab->plt_type == PLT_VXWORKS)
5370 {
5371 /* Allocate space for the unloaded relocations. */
5372 if (!bfd_link_pic (info)
5373 && htab->elf.dynamic_sections_created)
5374 {
5375 if (ent->plt.offset
5376 == (bfd_vma) htab->plt_initial_entry_size)
5377 {
5378 htab->srelplt2->size
5379 += (sizeof (Elf32_External_Rela)
5380 * VXWORKS_PLTRESOLVE_RELOCS);
5381 }
5382
5383 htab->srelplt2->size
5384 += (sizeof (Elf32_External_Rela)
5385 * VXWORKS_PLT_NON_JMP_SLOT_RELOCS);
5386 }
5387
5388 /* Every PLT entry has an associated GOT entry in
5389 .got.plt. */
5390 htab->elf.sgotplt->size += 4;
5391 }
5392 }
5393 doneone = TRUE;
5394 }
5395 }
5396 else
5397 ent->plt.offset = (bfd_vma) -1;
5398
5399 if (!doneone)
5400 {
5401 h->plt.plist = NULL;
5402 h->needs_plt = 0;
5403 }
5404 }
5405 else
5406 {
5407 h->plt.plist = NULL;
5408 h->needs_plt = 0;
5409 }
5410
5411 return TRUE;
5412 }
5413
5414 static const unsigned char glink_eh_frame_cie[] =
5415 {
5416 0, 0, 0, 16, /* length. */
5417 0, 0, 0, 0, /* id. */
5418 1, /* CIE version. */
5419 'z', 'R', 0, /* Augmentation string. */
5420 4, /* Code alignment. */
5421 0x7c, /* Data alignment. */
5422 65, /* RA reg. */
5423 1, /* Augmentation size. */
5424 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
5425 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
5426 };
5427
5428 /* Set the sizes of the dynamic sections. */
5429
5430 static bfd_boolean
5431 ppc_elf_size_dynamic_sections (bfd *output_bfd,
5432 struct bfd_link_info *info)
5433 {
5434 struct ppc_elf_link_hash_table *htab;
5435 asection *s;
5436 bfd_boolean relocs;
5437 bfd *ibfd;
5438
5439 #ifdef DEBUG
5440 fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
5441 #endif
5442
5443 htab = ppc_elf_hash_table (info);
5444 BFD_ASSERT (htab->elf.dynobj != NULL);
5445
5446 if (elf_hash_table (info)->dynamic_sections_created)
5447 {
5448 /* Set the contents of the .interp section to the interpreter. */
5449 if (bfd_link_executable (info) && !info->nointerp)
5450 {
5451 s = bfd_get_linker_section (htab->elf.dynobj, ".interp");
5452 BFD_ASSERT (s != NULL);
5453 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5454 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5455 }
5456 }
5457
5458 if (htab->plt_type == PLT_OLD)
5459 htab->got_header_size = 16;
5460 else if (htab->plt_type == PLT_NEW)
5461 htab->got_header_size = 12;
5462
5463 /* Set up .got offsets for local syms, and space for local dynamic
5464 relocs. */
5465 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5466 {
5467 bfd_signed_vma *local_got;
5468 bfd_signed_vma *end_local_got;
5469 struct plt_entry **local_plt;
5470 struct plt_entry **end_local_plt;
5471 char *lgot_masks;
5472 bfd_size_type locsymcount;
5473 Elf_Internal_Shdr *symtab_hdr;
5474
5475 if (!is_ppc_elf (ibfd))
5476 continue;
5477
5478 for (s = ibfd->sections; s != NULL; s = s->next)
5479 {
5480 struct ppc_dyn_relocs *p;
5481
5482 for (p = ((struct ppc_dyn_relocs *)
5483 elf_section_data (s)->local_dynrel);
5484 p != NULL;
5485 p = p->next)
5486 {
5487 if (!bfd_is_abs_section (p->sec)
5488 && bfd_is_abs_section (p->sec->output_section))
5489 {
5490 /* Input section has been discarded, either because
5491 it is a copy of a linkonce section or due to
5492 linker script /DISCARD/, so we'll be discarding
5493 the relocs too. */
5494 }
5495 else if (htab->elf.target_os == is_vxworks
5496 && strcmp (p->sec->output_section->name,
5497 ".tls_vars") == 0)
5498 {
5499 /* Relocations in vxworks .tls_vars sections are
5500 handled specially by the loader. */
5501 }
5502 else if (p->count != 0)
5503 {
5504 asection *sreloc = elf_section_data (p->sec)->sreloc;
5505 if (p->ifunc)
5506 sreloc = htab->elf.irelplt;
5507 sreloc->size += p->count * sizeof (Elf32_External_Rela);
5508 if ((p->sec->output_section->flags
5509 & (SEC_READONLY | SEC_ALLOC))
5510 == (SEC_READONLY | SEC_ALLOC))
5511 {
5512 info->flags |= DF_TEXTREL;
5513 info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
5514 p->sec->owner, p->sec);
5515 }
5516 }
5517 }
5518 }
5519
5520 local_got = elf_local_got_refcounts (ibfd);
5521 if (!local_got)
5522 continue;
5523
5524 symtab_hdr = &elf_symtab_hdr (ibfd);
5525 locsymcount = symtab_hdr->sh_info;
5526 end_local_got = local_got + locsymcount;
5527 local_plt = (struct plt_entry **) end_local_got;
5528 end_local_plt = local_plt + locsymcount;
5529 lgot_masks = (char *) end_local_plt;
5530
5531 for (; local_got < end_local_got; ++local_got, ++lgot_masks)
5532 if (*local_got > 0)
5533 {
5534 unsigned int need;
5535 if ((*lgot_masks & (TLS_TLS | TLS_LD)) == (TLS_TLS | TLS_LD))
5536 htab->tlsld_got.refcount += 1;
5537 need = got_entries_needed (*lgot_masks);
5538 if (need == 0)
5539 *local_got = (bfd_vma) -1;
5540 else
5541 {
5542 *local_got = allocate_got (htab, need);
5543 if (bfd_link_pic (info)
5544 && !((*lgot_masks & TLS_TLS) != 0
5545 && bfd_link_executable (info)))
5546 {
5547 asection *srel;
5548
5549 need *= sizeof (Elf32_External_Rela) / 4;
5550 srel = htab->elf.srelgot;
5551 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
5552 srel = htab->elf.irelplt;
5553 srel->size += need;
5554 }
5555 }
5556 }
5557 else
5558 *local_got = (bfd_vma) -1;
5559
5560 if (htab->elf.target_os == is_vxworks)
5561 continue;
5562
5563 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
5564 lgot_masks = (char *) end_local_plt;
5565 for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
5566 {
5567 struct plt_entry *ent;
5568 bfd_boolean doneone = FALSE;
5569 bfd_vma plt_offset = 0, glink_offset = (bfd_vma) -1;
5570
5571 for (ent = *local_plt; ent != NULL; ent = ent->next)
5572 if (ent->plt.refcount > 0)
5573 {
5574 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
5575 s = htab->elf.iplt;
5576 else if (htab->can_convert_all_inline_plt
5577 || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
5578 {
5579 ent->plt.offset = (bfd_vma) -1;
5580 continue;
5581 }
5582 else
5583 s = htab->pltlocal;
5584
5585 if (!doneone)
5586 {
5587 plt_offset = s->size;
5588 s->size += 4;
5589 }
5590 ent->plt.offset = plt_offset;
5591
5592 if (s != htab->pltlocal && (!doneone || bfd_link_pic (info)))
5593 {
5594 s = htab->glink;
5595 glink_offset = s->size;
5596 s->size += GLINK_ENTRY_SIZE (htab, NULL);
5597 }
5598 ent->glink_offset = glink_offset;
5599
5600 if (!doneone)
5601 {
5602 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
5603 {
5604 s = htab->elf.irelplt;
5605 s->size += sizeof (Elf32_External_Rela);
5606 }
5607 else if (bfd_link_pic (info))
5608 {
5609 s = htab->relpltlocal;
5610 s->size += sizeof (Elf32_External_Rela);
5611 }
5612 doneone = TRUE;
5613 }
5614 }
5615 else
5616 ent->plt.offset = (bfd_vma) -1;
5617 }
5618 }
5619
5620 /* Allocate space for global sym dynamic relocs. */
5621 elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
5622
5623 if (htab->tlsld_got.refcount > 0)
5624 {
5625 htab->tlsld_got.offset = allocate_got (htab, 8);
5626 if (bfd_link_dll (info))
5627 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
5628 }
5629 else
5630 htab->tlsld_got.offset = (bfd_vma) -1;
5631
5632 if (htab->elf.sgot != NULL && htab->plt_type != PLT_VXWORKS)
5633 {
5634 unsigned int g_o_t = 32768;
5635
5636 /* If we haven't allocated the header, do so now. When we get here,
5637 for old plt/got the got size will be 0 to 32764 (not allocated),
5638 or 32780 to 65536 (header allocated). For new plt/got, the
5639 corresponding ranges are 0 to 32768 and 32780 to 65536. */
5640 if (htab->elf.sgot->size <= 32768)
5641 {
5642 g_o_t = htab->elf.sgot->size;
5643 if (htab->plt_type == PLT_OLD)
5644 g_o_t += 4;
5645 htab->elf.sgot->size += htab->got_header_size;
5646 }
5647
5648 htab->elf.hgot->root.u.def.value = g_o_t;
5649 }
5650 if (bfd_link_pic (info))
5651 {
5652 struct elf_link_hash_entry *sda = htab->sdata[0].sym;
5653
5654 sda->root.u.def.section = htab->elf.hgot->root.u.def.section;
5655 sda->root.u.def.value = htab->elf.hgot->root.u.def.value;
5656 }
5657 if (info->emitrelocations)
5658 {
5659 struct elf_link_hash_entry *sda = htab->sdata[0].sym;
5660
5661 if (sda != NULL && sda->ref_regular)
5662 sda->root.u.def.section->flags |= SEC_KEEP;
5663 sda = htab->sdata[1].sym;
5664 if (sda != NULL && sda->ref_regular)
5665 sda->root.u.def.section->flags |= SEC_KEEP;
5666 }
5667
5668 if (htab->glink != NULL
5669 && htab->glink->size != 0
5670 && htab->elf.dynamic_sections_created)
5671 {
5672 htab->glink_pltresolve = htab->glink->size;
5673 /* Space for the branch table. */
5674 htab->glink->size
5675 += htab->elf.srelplt->size / (sizeof (Elf32_External_Rela) / 4) - 4;
5676 /* Pad out to align the start of PLTresolve. */
5677 htab->glink->size += -htab->glink->size & (htab->params->ppc476_workaround
5678 ? 63 : 15);
5679 htab->glink->size += GLINK_PLTRESOLVE;
5680
5681 if (htab->params->emit_stub_syms)
5682 {
5683 struct elf_link_hash_entry *sh;
5684 sh = elf_link_hash_lookup (&htab->elf, "__glink",
5685 TRUE, FALSE, FALSE);
5686 if (sh == NULL)
5687 return FALSE;
5688 if (sh->root.type == bfd_link_hash_new)
5689 {
5690 sh->root.type = bfd_link_hash_defined;
5691 sh->root.u.def.section = htab->glink;
5692 sh->root.u.def.value = htab->glink_pltresolve;
5693 sh->ref_regular = 1;
5694 sh->def_regular = 1;
5695 sh->ref_regular_nonweak = 1;
5696 sh->forced_local = 1;
5697 sh->non_elf = 0;
5698 sh->root.linker_def = 1;
5699 }
5700 sh = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
5701 TRUE, FALSE, FALSE);
5702 if (sh == NULL)
5703 return FALSE;
5704 if (sh->root.type == bfd_link_hash_new)
5705 {
5706 sh->root.type = bfd_link_hash_defined;
5707 sh->root.u.def.section = htab->glink;
5708 sh->root.u.def.value = htab->glink->size - GLINK_PLTRESOLVE;
5709 sh->ref_regular = 1;
5710 sh->def_regular = 1;
5711 sh->ref_regular_nonweak = 1;
5712 sh->forced_local = 1;
5713 sh->non_elf = 0;
5714 sh->root.linker_def = 1;
5715 }
5716 }
5717 }
5718
5719 if (htab->glink != NULL
5720 && htab->glink->size != 0
5721 && htab->glink_eh_frame != NULL
5722 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
5723 && _bfd_elf_eh_frame_present (info))
5724 {
5725 s = htab->glink_eh_frame;
5726 s->size = sizeof (glink_eh_frame_cie) + 20;
5727 if (bfd_link_pic (info))
5728 {
5729 s->size += 4;
5730 if (htab->glink->size - GLINK_PLTRESOLVE + 8 >= 256)
5731 s->size += 4;
5732 }
5733 }
5734
5735 /* We've now determined the sizes of the various dynamic sections.
5736 Allocate memory for them. */
5737 relocs = FALSE;
5738 for (s = htab->elf.dynobj->sections; s != NULL; s = s->next)
5739 {
5740 bfd_boolean strip_section = TRUE;
5741
5742 if ((s->flags & SEC_LINKER_CREATED) == 0)
5743 continue;
5744
5745 if (s == htab->elf.splt
5746 || s == htab->elf.sgot)
5747 {
5748 /* We'd like to strip these sections if they aren't needed, but if
5749 we've exported dynamic symbols from them we must leave them.
5750 It's too late to tell BFD to get rid of the symbols. */
5751 if (htab->elf.hplt != NULL)
5752 strip_section = FALSE;
5753 /* Strip this section if we don't need it; see the
5754 comment below. */
5755 }
5756 else if (s == htab->elf.iplt
5757 || s == htab->pltlocal
5758 || s == htab->glink
5759 || s == htab->glink_eh_frame
5760 || s == htab->elf.sgotplt
5761 || s == htab->sbss
5762 || s == htab->elf.sdynbss
5763 || s == htab->elf.sdynrelro
5764 || s == htab->dynsbss)
5765 {
5766 /* Strip these too. */
5767 }
5768 else if (s == htab->sdata[0].section
5769 || s == htab->sdata[1].section)
5770 {
5771 strip_section = (s->flags & SEC_KEEP) == 0;
5772 }
5773 else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
5774 {
5775 if (s->size != 0)
5776 {
5777 /* Remember whether there are any relocation sections. */
5778 relocs = TRUE;
5779
5780 /* We use the reloc_count field as a counter if we need
5781 to copy relocs into the output file. */
5782 s->reloc_count = 0;
5783 }
5784 }
5785 else
5786 {
5787 /* It's not one of our sections, so don't allocate space. */
5788 continue;
5789 }
5790
5791 if (s->size == 0 && strip_section)
5792 {
5793 /* If we don't need this section, strip it from the
5794 output file. This is mostly to handle .rela.bss and
5795 .rela.plt. We must create both sections in
5796 create_dynamic_sections, because they must be created
5797 before the linker maps input sections to output
5798 sections. The linker does that before
5799 adjust_dynamic_symbol is called, and it is that
5800 function which decides whether anything needs to go
5801 into these sections. */
5802 s->flags |= SEC_EXCLUDE;
5803 continue;
5804 }
5805
5806 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5807 continue;
5808
5809 /* Allocate memory for the section contents. */
5810 s->contents = bfd_zalloc (htab->elf.dynobj, s->size);
5811 if (s->contents == NULL)
5812 return FALSE;
5813 }
5814
5815 if (htab->elf.dynamic_sections_created)
5816 {
5817 /* Add some entries to the .dynamic section. We fill in the
5818 values later, in ppc_elf_finish_dynamic_sections, but we
5819 must add the entries now so that we get the correct size for
5820 the .dynamic section. The DT_DEBUG entry is filled in by the
5821 dynamic linker and used by the debugger. */
5822 #define add_dynamic_entry(TAG, VAL) \
5823 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5824
5825 if (!_bfd_elf_maybe_vxworks_add_dynamic_tags (output_bfd, info,
5826 relocs))
5827 return FALSE;
5828
5829 if (htab->plt_type == PLT_NEW
5830 && htab->glink != NULL
5831 && htab->glink->size != 0)
5832 {
5833 if (!add_dynamic_entry (DT_PPC_GOT, 0))
5834 return FALSE;
5835 if (!htab->params->no_tls_get_addr_opt
5836 && htab->tls_get_addr != NULL
5837 && htab->tls_get_addr->plt.plist != NULL
5838 && !add_dynamic_entry (DT_PPC_OPT, PPC_OPT_TLS))
5839 return FALSE;
5840 }
5841 }
5842 #undef add_dynamic_entry
5843
5844 if (htab->glink_eh_frame != NULL
5845 && htab->glink_eh_frame->contents != NULL)
5846 {
5847 unsigned char *p = htab->glink_eh_frame->contents;
5848 bfd_vma val;
5849
5850 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
5851 /* CIE length (rewrite in case little-endian). */
5852 bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
5853 p += sizeof (glink_eh_frame_cie);
5854 /* FDE length. */
5855 val = htab->glink_eh_frame->size - 4 - sizeof (glink_eh_frame_cie);
5856 bfd_put_32 (htab->elf.dynobj, val, p);
5857 p += 4;
5858 /* CIE pointer. */
5859 val = p - htab->glink_eh_frame->contents;
5860 bfd_put_32 (htab->elf.dynobj, val, p);
5861 p += 4;
5862 /* Offset to .glink. Set later. */
5863 p += 4;
5864 /* .glink size. */
5865 bfd_put_32 (htab->elf.dynobj, htab->glink->size, p);
5866 p += 4;
5867 /* Augmentation. */
5868 p += 1;
5869
5870 if (bfd_link_pic (info)
5871 && htab->elf.dynamic_sections_created)
5872 {
5873 bfd_vma adv = (htab->glink->size - GLINK_PLTRESOLVE + 8) >> 2;
5874 if (adv < 64)
5875 *p++ = DW_CFA_advance_loc + adv;
5876 else if (adv < 256)
5877 {
5878 *p++ = DW_CFA_advance_loc1;
5879 *p++ = adv;
5880 }
5881 else if (adv < 65536)
5882 {
5883 *p++ = DW_CFA_advance_loc2;
5884 bfd_put_16 (htab->elf.dynobj, adv, p);
5885 p += 2;
5886 }
5887 else
5888 {
5889 *p++ = DW_CFA_advance_loc4;
5890 bfd_put_32 (htab->elf.dynobj, adv, p);
5891 p += 4;
5892 }
5893 *p++ = DW_CFA_register;
5894 *p++ = 65;
5895 p++;
5896 *p++ = DW_CFA_advance_loc + 4;
5897 *p++ = DW_CFA_restore_extended;
5898 *p++ = 65;
5899 }
5900 BFD_ASSERT ((bfd_vma) ((p + 3 - htab->glink_eh_frame->contents) & -4)
5901 == htab->glink_eh_frame->size);
5902 }
5903
5904 return TRUE;
5905 }
5906
5907 /* Arrange to have _SDA_BASE_ or _SDA2_BASE_ stripped from the output
5908 if it looks like nothing is using them. */
5909
5910 static void
5911 maybe_strip_sdasym (bfd *output_bfd, elf_linker_section_t *lsect)
5912 {
5913 struct elf_link_hash_entry *sda = lsect->sym;
5914
5915 if (sda != NULL && !sda->ref_regular && sda->dynindx == -1)
5916 {
5917 asection *s;
5918
5919 s = bfd_get_section_by_name (output_bfd, lsect->name);
5920 if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
5921 {
5922 s = bfd_get_section_by_name (output_bfd, lsect->bss_name);
5923 if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
5924 {
5925 sda->def_regular = 0;
5926 /* This is somewhat magic. See elf_link_output_extsym. */
5927 sda->ref_dynamic = 1;
5928 sda->forced_local = 0;
5929 }
5930 }
5931 }
5932 }
5933
5934 void
5935 ppc_elf_maybe_strip_sdata_syms (struct bfd_link_info *info)
5936 {
5937 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
5938
5939 if (htab != NULL)
5940 {
5941 maybe_strip_sdasym (info->output_bfd, &htab->sdata[0]);
5942 maybe_strip_sdasym (info->output_bfd, &htab->sdata[1]);
5943 }
5944 }
5945
5946
5947 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5948
5949 static bfd_boolean
5950 ppc_elf_hash_symbol (struct elf_link_hash_entry *h)
5951 {
5952 if (h->plt.plist != NULL
5953 && !h->def_regular
5954 && (!h->pointer_equality_needed
5955 || !h->ref_regular_nonweak))
5956 return FALSE;
5957
5958 return _bfd_elf_hash_symbol (h);
5959 }
5960 \f
5961 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
5962
5963 /* Relaxation trampolines. r12 is available for clobbering (r11, is
5964 used for some functions that are allowed to break the ABI). */
5965 static const int shared_stub_entry[] =
5966 {
5967 0x7c0802a6, /* mflr 0 */
5968 0x429f0005, /* bcl 20, 31, .Lxxx */
5969 0x7d8802a6, /* mflr 12 */
5970 0x3d8c0000, /* addis 12, 12, (xxx-.Lxxx)@ha */
5971 0x398c0000, /* addi 12, 12, (xxx-.Lxxx)@l */
5972 0x7c0803a6, /* mtlr 0 */
5973 0x7d8903a6, /* mtctr 12 */
5974 0x4e800420, /* bctr */
5975 };
5976
5977 static const int stub_entry[] =
5978 {
5979 0x3d800000, /* lis 12,xxx@ha */
5980 0x398c0000, /* addi 12,12,xxx@l */
5981 0x7d8903a6, /* mtctr 12 */
5982 0x4e800420, /* bctr */
5983 };
5984
5985 struct ppc_elf_relax_info
5986 {
5987 unsigned int workaround_size;
5988 unsigned int picfixup_size;
5989 };
5990
5991 /* This function implements long branch trampolines, and the ppc476
5992 icache bug workaround. Any section needing trampolines or patch
5993 space for the workaround has its size extended so that we can
5994 add trampolines at the end of the section. */
5995
5996 static bfd_boolean
5997 ppc_elf_relax_section (bfd *abfd,
5998 asection *isec,
5999 struct bfd_link_info *link_info,
6000 bfd_boolean *again)
6001 {
6002 struct one_branch_fixup
6003 {
6004 struct one_branch_fixup *next;
6005 asection *tsec;
6006 /* Final link, can use the symbol offset. For a
6007 relocatable link we use the symbol's index. */
6008 bfd_vma toff;
6009 bfd_vma trampoff;
6010 };
6011
6012 Elf_Internal_Shdr *symtab_hdr;
6013 bfd_byte *contents = NULL;
6014 Elf_Internal_Sym *isymbuf = NULL;
6015 Elf_Internal_Rela *internal_relocs = NULL;
6016 Elf_Internal_Rela *irel, *irelend = NULL;
6017 struct one_branch_fixup *branch_fixups = NULL;
6018 struct ppc_elf_relax_info *relax_info = NULL;
6019 unsigned changes = 0;
6020 bfd_boolean workaround_change;
6021 struct ppc_elf_link_hash_table *htab;
6022 bfd_size_type trampbase, trampoff, newsize, picfixup_size;
6023 asection *got2;
6024 bfd_boolean maybe_pasted;
6025
6026 *again = FALSE;
6027
6028 /* No need to do anything with non-alloc or non-code sections. */
6029 if ((isec->flags & SEC_ALLOC) == 0
6030 || (isec->flags & SEC_CODE) == 0
6031 || (isec->flags & SEC_LINKER_CREATED) != 0
6032 || isec->size < 4)
6033 return TRUE;
6034
6035 /* We cannot represent the required PIC relocs in the output, so don't
6036 do anything. The linker doesn't support mixing -shared and -r
6037 anyway. */
6038 if (bfd_link_relocatable (link_info) && bfd_link_pic (link_info))
6039 return TRUE;
6040
6041 htab = ppc_elf_hash_table (link_info);
6042 if (htab == NULL)
6043 return TRUE;
6044
6045 isec->size = (isec->size + 3) & -4;
6046 if (isec->rawsize == 0)
6047 isec->rawsize = isec->size;
6048 trampbase = isec->size;
6049
6050 BFD_ASSERT (isec->sec_info_type == SEC_INFO_TYPE_NONE
6051 || isec->sec_info_type == SEC_INFO_TYPE_TARGET);
6052 isec->sec_info_type = SEC_INFO_TYPE_TARGET;
6053
6054 if (htab->params->ppc476_workaround
6055 || htab->params->pic_fixup > 0)
6056 {
6057 if (elf_section_data (isec)->sec_info == NULL)
6058 {
6059 elf_section_data (isec)->sec_info
6060 = bfd_zalloc (abfd, sizeof (struct ppc_elf_relax_info));
6061 if (elf_section_data (isec)->sec_info == NULL)
6062 return FALSE;
6063 }
6064 relax_info = elf_section_data (isec)->sec_info;
6065 trampbase -= relax_info->workaround_size;
6066 }
6067
6068 maybe_pasted = (strcmp (isec->output_section->name, ".init") == 0
6069 || strcmp (isec->output_section->name, ".fini") == 0);
6070 /* Space for a branch around any trampolines. */
6071 trampoff = trampbase;
6072 if (maybe_pasted && trampbase == isec->rawsize)
6073 trampoff += 4;
6074
6075 symtab_hdr = &elf_symtab_hdr (abfd);
6076 picfixup_size = 0;
6077 if (htab->params->branch_trampolines
6078 || htab->params->pic_fixup > 0)
6079 {
6080 /* Get a copy of the native relocations. */
6081 if (isec->reloc_count != 0)
6082 {
6083 internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL,
6084 link_info->keep_memory);
6085 if (internal_relocs == NULL)
6086 goto error_return;
6087 }
6088
6089 got2 = bfd_get_section_by_name (abfd, ".got2");
6090
6091 irelend = internal_relocs + isec->reloc_count;
6092 for (irel = internal_relocs; irel < irelend; irel++)
6093 {
6094 unsigned long r_type = ELF32_R_TYPE (irel->r_info);
6095 bfd_vma toff, roff;
6096 asection *tsec;
6097 struct one_branch_fixup *f;
6098 size_t insn_offset = 0;
6099 bfd_vma max_branch_offset = 0, val;
6100 bfd_byte *hit_addr;
6101 unsigned long t0;
6102 struct elf_link_hash_entry *h;
6103 Elf_Internal_Sym *isym;
6104 struct plt_entry **plist;
6105 unsigned char sym_type;
6106
6107 switch (r_type)
6108 {
6109 case R_PPC_REL24:
6110 case R_PPC_LOCAL24PC:
6111 case R_PPC_PLTREL24:
6112 case R_PPC_PLTCALL:
6113 max_branch_offset = 1 << 25;
6114 break;
6115
6116 case R_PPC_REL14:
6117 case R_PPC_REL14_BRTAKEN:
6118 case R_PPC_REL14_BRNTAKEN:
6119 max_branch_offset = 1 << 15;
6120 break;
6121
6122 case R_PPC_ADDR16_HA:
6123 if (htab->params->pic_fixup > 0)
6124 break;
6125 continue;
6126
6127 default:
6128 continue;
6129 }
6130
6131 /* Get the value of the symbol referred to by the reloc. */
6132 if (!get_sym_h (&h, &isym, &tsec, NULL, &isymbuf,
6133 ELF32_R_SYM (irel->r_info), abfd))
6134 goto error_return;
6135
6136 if (isym != NULL)
6137 {
6138 if (tsec != NULL)
6139 ;
6140 else if (isym->st_shndx == SHN_ABS)
6141 tsec = bfd_abs_section_ptr;
6142 else
6143 continue;
6144
6145 toff = isym->st_value;
6146 sym_type = ELF_ST_TYPE (isym->st_info);
6147 }
6148 else
6149 {
6150 if (tsec != NULL)
6151 toff = h->root.u.def.value;
6152 else if (h->root.type == bfd_link_hash_undefined
6153 || h->root.type == bfd_link_hash_undefweak)
6154 {
6155 unsigned long indx;
6156
6157 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6158 tsec = bfd_und_section_ptr;
6159 toff = bfd_link_relocatable (link_info) ? indx : 0;
6160 }
6161 else
6162 continue;
6163
6164 /* If this branch is to __tls_get_addr then we may later
6165 optimise away the call. We won't be needing a long-
6166 branch stub in that case. */
6167 if (bfd_link_executable (link_info)
6168 && h == htab->tls_get_addr
6169 && irel != internal_relocs)
6170 {
6171 unsigned long t_symndx = ELF32_R_SYM (irel[-1].r_info);
6172 unsigned long t_rtype = ELF32_R_TYPE (irel[-1].r_info);
6173 unsigned int tls_mask = 0;
6174
6175 /* The previous reloc should be one of R_PPC_TLSGD or
6176 R_PPC_TLSLD, or for older object files, a reloc
6177 on the __tls_get_addr arg setup insn. Get tls
6178 mask bits from the symbol on that reloc. */
6179 if (t_symndx < symtab_hdr->sh_info)
6180 {
6181 bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
6182
6183 if (local_got_offsets != NULL)
6184 {
6185 struct plt_entry **local_plt = (struct plt_entry **)
6186 (local_got_offsets + symtab_hdr->sh_info);
6187 char *lgot_masks = (char *)
6188 (local_plt + symtab_hdr->sh_info);
6189 tls_mask = lgot_masks[t_symndx];
6190 }
6191 }
6192 else
6193 {
6194 struct elf_link_hash_entry *th
6195 = elf_sym_hashes (abfd)[t_symndx - symtab_hdr->sh_info];
6196
6197 while (th->root.type == bfd_link_hash_indirect
6198 || th->root.type == bfd_link_hash_warning)
6199 th = (struct elf_link_hash_entry *) th->root.u.i.link;
6200
6201 tls_mask
6202 = ((struct ppc_elf_link_hash_entry *) th)->tls_mask;
6203 }
6204
6205 /* The mask bits tell us if the call will be
6206 optimised away. */
6207 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
6208 && (t_rtype == R_PPC_TLSGD
6209 || t_rtype == R_PPC_GOT_TLSGD16
6210 || t_rtype == R_PPC_GOT_TLSGD16_LO))
6211 continue;
6212 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
6213 && (t_rtype == R_PPC_TLSLD
6214 || t_rtype == R_PPC_GOT_TLSLD16
6215 || t_rtype == R_PPC_GOT_TLSLD16_LO))
6216 continue;
6217 }
6218
6219 sym_type = h->type;
6220 }
6221
6222 if (r_type == R_PPC_ADDR16_HA)
6223 {
6224 if (h != NULL
6225 && !h->def_regular
6226 && h->protected_def
6227 && ppc_elf_hash_entry (h)->has_addr16_ha
6228 && ppc_elf_hash_entry (h)->has_addr16_lo)
6229 picfixup_size += 12;
6230 continue;
6231 }
6232
6233 /* The condition here under which we call find_plt_ent must
6234 match that in relocate_section. If we call find_plt_ent here
6235 but not in relocate_section, or vice versa, then the branch
6236 destination used here may be incorrect. */
6237 plist = NULL;
6238 if (h != NULL)
6239 {
6240 /* We know is_branch_reloc (r_type) is true. */
6241 if (h->type == STT_GNU_IFUNC
6242 || r_type == R_PPC_PLTREL24)
6243 plist = &h->plt.plist;
6244 }
6245 else if (sym_type == STT_GNU_IFUNC
6246 && elf_local_got_offsets (abfd) != NULL)
6247 {
6248 bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
6249 struct plt_entry **local_plt = (struct plt_entry **)
6250 (local_got_offsets + symtab_hdr->sh_info);
6251 plist = local_plt + ELF32_R_SYM (irel->r_info);
6252 }
6253 if (plist != NULL)
6254 {
6255 bfd_vma addend = 0;
6256 struct plt_entry *ent;
6257
6258 if (r_type == R_PPC_PLTREL24 && bfd_link_pic (link_info))
6259 addend = irel->r_addend;
6260 ent = find_plt_ent (plist, got2, addend);
6261 if (ent != NULL)
6262 {
6263 if (htab->plt_type == PLT_NEW
6264 || h == NULL
6265 || !htab->elf.dynamic_sections_created
6266 || h->dynindx == -1)
6267 {
6268 tsec = htab->glink;
6269 toff = ent->glink_offset;
6270 }
6271 else
6272 {
6273 tsec = htab->elf.splt;
6274 toff = ent->plt.offset;
6275 }
6276 }
6277 }
6278
6279 /* If the branch and target are in the same section, you have
6280 no hope of adding stubs. We'll error out later should the
6281 branch overflow. */
6282 if (tsec == isec)
6283 continue;
6284
6285 /* toff is used for the symbol index when the symbol is
6286 undefined and we're doing a relocatable link, so we can't
6287 support addends. It would be possible to do so by
6288 putting the addend in one_branch_fixup but addends on
6289 branches are rare so it hardly seems worth supporting. */
6290 if (bfd_link_relocatable (link_info)
6291 && tsec == bfd_und_section_ptr
6292 && r_type != R_PPC_PLTREL24
6293 && irel->r_addend != 0)
6294 continue;
6295
6296 /* There probably isn't any reason to handle symbols in
6297 SEC_MERGE sections; SEC_MERGE doesn't seem a likely
6298 attribute for a code section, and we are only looking at
6299 branches. However, implement it correctly here as a
6300 reference for other target relax_section functions. */
6301 if (0 && tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
6302 {
6303 /* At this stage in linking, no SEC_MERGE symbol has been
6304 adjusted, so all references to such symbols need to be
6305 passed through _bfd_merged_section_offset. (Later, in
6306 relocate_section, all SEC_MERGE symbols *except* for
6307 section symbols have been adjusted.)
6308
6309 gas may reduce relocations against symbols in SEC_MERGE
6310 sections to a relocation against the section symbol when
6311 the original addend was zero. When the reloc is against
6312 a section symbol we should include the addend in the
6313 offset passed to _bfd_merged_section_offset, since the
6314 location of interest is the original symbol. On the
6315 other hand, an access to "sym+addend" where "sym" is not
6316 a section symbol should not include the addend; Such an
6317 access is presumed to be an offset from "sym"; The
6318 location of interest is just "sym". */
6319 if (sym_type == STT_SECTION
6320 && r_type != R_PPC_PLTREL24)
6321 toff += irel->r_addend;
6322
6323 toff
6324 = _bfd_merged_section_offset (abfd, &tsec,
6325 elf_section_data (tsec)->sec_info,
6326 toff);
6327
6328 if (sym_type != STT_SECTION
6329 && r_type != R_PPC_PLTREL24)
6330 toff += irel->r_addend;
6331 }
6332 /* PLTREL24 addends are special. */
6333 else if (r_type != R_PPC_PLTREL24)
6334 toff += irel->r_addend;
6335
6336 /* Attempted -shared link of non-pic code loses. */
6337 if ((!bfd_link_relocatable (link_info)
6338 && tsec == bfd_und_section_ptr)
6339 || tsec->output_section == NULL
6340 || (tsec->owner != NULL
6341 && (tsec->owner->flags & BFD_PLUGIN) != 0))
6342 continue;
6343
6344 roff = irel->r_offset;
6345
6346 /* Avoid creating a lot of unnecessary fixups when
6347 relocatable if the output section size is such that a
6348 fixup can be created at final link.
6349 The max_branch_offset adjustment allows for some number
6350 of other fixups being needed at final link. */
6351 if (bfd_link_relocatable (link_info)
6352 && (isec->output_section->rawsize - (isec->output_offset + roff)
6353 < max_branch_offset - (max_branch_offset >> 4)))
6354 continue;
6355
6356 /* If the branch is in range, no need to do anything. */
6357 if (tsec != bfd_und_section_ptr
6358 && (!bfd_link_relocatable (link_info)
6359 /* A relocatable link may have sections moved during
6360 final link, so do not presume they remain in range. */
6361 || tsec->output_section == isec->output_section))
6362 {
6363 bfd_vma symaddr, reladdr;
6364
6365 symaddr = tsec->output_section->vma + tsec->output_offset + toff;
6366 reladdr = isec->output_section->vma + isec->output_offset + roff;
6367 if (symaddr - reladdr + max_branch_offset
6368 < 2 * max_branch_offset)
6369 continue;
6370 }
6371
6372 /* Look for an existing fixup to this address. */
6373 for (f = branch_fixups; f ; f = f->next)
6374 if (f->tsec == tsec && f->toff == toff)
6375 break;
6376
6377 if (f == NULL)
6378 {
6379 size_t size;
6380 unsigned long stub_rtype;
6381
6382 val = trampoff - roff;
6383 if (val >= max_branch_offset)
6384 /* Oh dear, we can't reach a trampoline. Don't try to add
6385 one. We'll report an error later. */
6386 continue;
6387
6388 if (bfd_link_pic (link_info))
6389 {
6390 size = 4 * ARRAY_SIZE (shared_stub_entry);
6391 insn_offset = 12;
6392 }
6393 else
6394 {
6395 size = 4 * ARRAY_SIZE (stub_entry);
6396 insn_offset = 0;
6397 }
6398 stub_rtype = R_PPC_RELAX;
6399 if (tsec == htab->elf.splt
6400 || tsec == htab->glink)
6401 {
6402 stub_rtype = R_PPC_RELAX_PLT;
6403 if (r_type == R_PPC_PLTREL24)
6404 stub_rtype = R_PPC_RELAX_PLTREL24;
6405 }
6406
6407 /* Hijack the old relocation. Since we need two
6408 relocations for this use a "composite" reloc. */
6409 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
6410 stub_rtype);
6411 irel->r_offset = trampoff + insn_offset;
6412 if (r_type == R_PPC_PLTREL24
6413 && stub_rtype != R_PPC_RELAX_PLTREL24)
6414 irel->r_addend = 0;
6415
6416 /* Record the fixup so we don't do it again this section. */
6417 f = bfd_malloc (sizeof (*f));
6418 f->next = branch_fixups;
6419 f->tsec = tsec;
6420 f->toff = toff;
6421 f->trampoff = trampoff;
6422 branch_fixups = f;
6423
6424 trampoff += size;
6425 changes++;
6426 }
6427 else
6428 {
6429 val = f->trampoff - roff;
6430 if (val >= max_branch_offset)
6431 continue;
6432
6433 /* Nop out the reloc, since we're finalizing things here. */
6434 irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
6435 }
6436
6437 /* Get the section contents. */
6438 if (contents == NULL)
6439 {
6440 /* Get cached copy if it exists. */
6441 if (elf_section_data (isec)->this_hdr.contents != NULL)
6442 contents = elf_section_data (isec)->this_hdr.contents;
6443 /* Go get them off disk. */
6444 else if (!bfd_malloc_and_get_section (abfd, isec, &contents))
6445 goto error_return;
6446 }
6447
6448 /* Fix up the existing branch to hit the trampoline. */
6449 hit_addr = contents + roff;
6450 switch (r_type)
6451 {
6452 case R_PPC_REL24:
6453 case R_PPC_LOCAL24PC:
6454 case R_PPC_PLTREL24:
6455 t0 = bfd_get_32 (abfd, hit_addr);
6456 t0 &= ~0x3fffffc;
6457 t0 |= val & 0x3fffffc;
6458 bfd_put_32 (abfd, t0, hit_addr);
6459 break;
6460
6461 case R_PPC_REL14:
6462 case R_PPC_REL14_BRTAKEN:
6463 case R_PPC_REL14_BRNTAKEN:
6464 t0 = bfd_get_32 (abfd, hit_addr);
6465 t0 &= ~0xfffc;
6466 t0 |= val & 0xfffc;
6467 bfd_put_32 (abfd, t0, hit_addr);
6468 break;
6469 }
6470 }
6471
6472 while (branch_fixups != NULL)
6473 {
6474 struct one_branch_fixup *f = branch_fixups;
6475 branch_fixups = branch_fixups->next;
6476 free (f);
6477 }
6478 }
6479
6480 workaround_change = FALSE;
6481 newsize = trampoff;
6482 if (htab->params->ppc476_workaround
6483 && (!bfd_link_relocatable (link_info)
6484 || isec->output_section->alignment_power >= htab->params->pagesize_p2))
6485 {
6486 bfd_vma addr, end_addr;
6487 unsigned int crossings;
6488 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
6489
6490 addr = isec->output_section->vma + isec->output_offset;
6491 end_addr = addr + trampoff;
6492 addr &= -pagesize;
6493 crossings = ((end_addr & -pagesize) - addr) >> htab->params->pagesize_p2;
6494 if (crossings != 0)
6495 {
6496 /* Keep space aligned, to ensure the patch code itself does
6497 not cross a page. Don't decrease size calculated on a
6498 previous pass as otherwise we might never settle on a layout. */
6499 newsize = 15 - ((end_addr - 1) & 15);
6500 newsize += crossings * 16;
6501 if (relax_info->workaround_size < newsize)
6502 {
6503 relax_info->workaround_size = newsize;
6504 workaround_change = TRUE;
6505 }
6506 /* Ensure relocate_section is called. */
6507 isec->flags |= SEC_RELOC;
6508 }
6509 newsize = trampoff + relax_info->workaround_size;
6510 }
6511
6512 if (htab->params->pic_fixup > 0)
6513 {
6514 picfixup_size -= relax_info->picfixup_size;
6515 if (picfixup_size != 0)
6516 relax_info->picfixup_size += picfixup_size;
6517 newsize += relax_info->picfixup_size;
6518 }
6519
6520 if (changes != 0 || picfixup_size != 0 || workaround_change)
6521 isec->size = newsize;
6522
6523 if (isymbuf != NULL
6524 && symtab_hdr->contents != (unsigned char *) isymbuf)
6525 {
6526 if (! link_info->keep_memory)
6527 free (isymbuf);
6528 else
6529 {
6530 /* Cache the symbols for elf_link_input_bfd. */
6531 symtab_hdr->contents = (unsigned char *) isymbuf;
6532 }
6533 }
6534
6535 if (contents != NULL
6536 && elf_section_data (isec)->this_hdr.contents != contents)
6537 {
6538 if (!changes && !link_info->keep_memory)
6539 free (contents);
6540 else
6541 {
6542 /* Cache the section contents for elf_link_input_bfd. */
6543 elf_section_data (isec)->this_hdr.contents = contents;
6544 }
6545 }
6546
6547 changes += picfixup_size;
6548 if (changes != 0)
6549 {
6550 /* Append sufficient NOP relocs so we can write out relocation
6551 information for the trampolines. */
6552 Elf_Internal_Shdr *rel_hdr;
6553 Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count)
6554 * sizeof (*new_relocs));
6555 unsigned ix;
6556
6557 if (!new_relocs)
6558 goto error_return;
6559 memcpy (new_relocs, internal_relocs,
6560 isec->reloc_count * sizeof (*new_relocs));
6561 for (ix = changes; ix--;)
6562 {
6563 irel = new_relocs + ix + isec->reloc_count;
6564
6565 irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
6566 }
6567 if (internal_relocs != elf_section_data (isec)->relocs)
6568 free (internal_relocs);
6569 elf_section_data (isec)->relocs = new_relocs;
6570 isec->reloc_count += changes;
6571 rel_hdr = _bfd_elf_single_rel_hdr (isec);
6572 rel_hdr->sh_size += changes * rel_hdr->sh_entsize;
6573 }
6574 else if (elf_section_data (isec)->relocs != internal_relocs)
6575 free (internal_relocs);
6576
6577 *again = changes != 0 || workaround_change;
6578 return TRUE;
6579
6580 error_return:
6581 while (branch_fixups != NULL)
6582 {
6583 struct one_branch_fixup *f = branch_fixups;
6584 branch_fixups = branch_fixups->next;
6585 free (f);
6586 }
6587 if ((unsigned char *) isymbuf != symtab_hdr->contents)
6588 free (isymbuf);
6589 if (elf_section_data (isec)->this_hdr.contents != contents)
6590 free (contents);
6591 if (elf_section_data (isec)->relocs != internal_relocs)
6592 free (internal_relocs);
6593 return FALSE;
6594 }
6595 \f
6596 /* What to do when ld finds relocations against symbols defined in
6597 discarded sections. */
6598
6599 static unsigned int
6600 ppc_elf_action_discarded (asection *sec)
6601 {
6602 if (strcmp (".fixup", sec->name) == 0)
6603 return 0;
6604
6605 if (strcmp (".got2", sec->name) == 0)
6606 return 0;
6607
6608 return _bfd_elf_default_action_discarded (sec);
6609 }
6610 \f
6611 /* Fill in the address for a pointer generated in a linker section. */
6612
6613 static bfd_vma
6614 elf_finish_pointer_linker_section (bfd *input_bfd,
6615 elf_linker_section_t *lsect,
6616 struct elf_link_hash_entry *h,
6617 bfd_vma relocation,
6618 const Elf_Internal_Rela *rel)
6619 {
6620 elf_linker_section_pointers_t *linker_section_ptr;
6621
6622 BFD_ASSERT (lsect != NULL);
6623
6624 if (h != NULL)
6625 {
6626 /* Handle global symbol. */
6627 struct ppc_elf_link_hash_entry *eh;
6628
6629 eh = (struct ppc_elf_link_hash_entry *) h;
6630 BFD_ASSERT (eh->elf.def_regular);
6631 linker_section_ptr = eh->linker_section_pointer;
6632 }
6633 else
6634 {
6635 /* Handle local symbol. */
6636 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
6637
6638 BFD_ASSERT (is_ppc_elf (input_bfd));
6639 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
6640 linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx];
6641 }
6642
6643 linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr,
6644 rel->r_addend,
6645 lsect);
6646 BFD_ASSERT (linker_section_ptr != NULL);
6647
6648 /* Offset will always be a multiple of four, so use the bottom bit
6649 as a "written" flag. */
6650 if ((linker_section_ptr->offset & 1) == 0)
6651 {
6652 bfd_put_32 (lsect->section->owner,
6653 relocation + linker_section_ptr->addend,
6654 lsect->section->contents + linker_section_ptr->offset);
6655 linker_section_ptr->offset += 1;
6656 }
6657
6658 relocation = (lsect->section->output_section->vma
6659 + lsect->section->output_offset
6660 + linker_section_ptr->offset - 1
6661 - SYM_VAL (lsect->sym));
6662
6663 #ifdef DEBUG
6664 fprintf (stderr,
6665 "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
6666 lsect->name, (long) relocation, (long) relocation);
6667 #endif
6668
6669 return relocation;
6670 }
6671
6672 #define PPC_LO(v) ((v) & 0xffff)
6673 #define PPC_HI(v) (((v) >> 16) & 0xffff)
6674 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
6675
6676 static void
6677 write_glink_stub (struct elf_link_hash_entry *h, struct plt_entry *ent,
6678 asection *plt_sec, unsigned char *p,
6679 struct bfd_link_info *info)
6680 {
6681 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
6682 bfd *output_bfd = info->output_bfd;
6683 bfd_vma plt;
6684 unsigned char *end = p + GLINK_ENTRY_SIZE (htab, h);
6685
6686 if (h != NULL
6687 && h == htab->tls_get_addr
6688 && !htab->params->no_tls_get_addr_opt)
6689 {
6690 bfd_put_32 (output_bfd, LWZ_11_3, p);
6691 p += 4;
6692 bfd_put_32 (output_bfd, LWZ_12_3 + 4, p);
6693 p += 4;
6694 bfd_put_32 (output_bfd, MR_0_3, p);
6695 p += 4;
6696 bfd_put_32 (output_bfd, CMPWI_11_0, p);
6697 p += 4;
6698 bfd_put_32 (output_bfd, ADD_3_12_2, p);
6699 p += 4;
6700 bfd_put_32 (output_bfd, BEQLR, p);
6701 p += 4;
6702 bfd_put_32 (output_bfd, MR_3_0, p);
6703 p += 4;
6704 bfd_put_32 (output_bfd, NOP, p);
6705 p += 4;
6706 }
6707
6708 plt = ((ent->plt.offset & ~1)
6709 + plt_sec->output_section->vma
6710 + plt_sec->output_offset);
6711
6712 if (bfd_link_pic (info))
6713 {
6714 bfd_vma got = 0;
6715
6716 if (ent->addend >= 32768)
6717 got = (ent->addend
6718 + ent->sec->output_section->vma
6719 + ent->sec->output_offset);
6720 else if (htab->elf.hgot != NULL)
6721 got = SYM_VAL (htab->elf.hgot);
6722
6723 plt -= got;
6724
6725 if (plt + 0x8000 < 0x10000)
6726 bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p);
6727 else
6728 {
6729 bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p);
6730 p += 4;
6731 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
6732 }
6733 }
6734 else
6735 {
6736 bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p);
6737 p += 4;
6738 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
6739 }
6740 p += 4;
6741 bfd_put_32 (output_bfd, MTCTR_11, p);
6742 p += 4;
6743 bfd_put_32 (output_bfd, BCTR, p);
6744 p += 4;
6745 while (p < end)
6746 {
6747 bfd_put_32 (output_bfd, htab->params->ppc476_workaround ? BA : NOP, p);
6748 p += 4;
6749 }
6750 }
6751
6752 /* Return true if symbol is defined statically. */
6753
6754 static bfd_boolean
6755 is_static_defined (struct elf_link_hash_entry *h)
6756 {
6757 return ((h->root.type == bfd_link_hash_defined
6758 || h->root.type == bfd_link_hash_defweak)
6759 && h->root.u.def.section != NULL
6760 && h->root.u.def.section->output_section != NULL);
6761 }
6762
6763 /* If INSN is an opcode that may be used with an @tls operand, return
6764 the transformed insn for TLS optimisation, otherwise return 0. If
6765 REG is non-zero only match an insn with RB or RA equal to REG. */
6766
6767 unsigned int
6768 _bfd_elf_ppc_at_tls_transform (unsigned int insn, unsigned int reg)
6769 {
6770 unsigned int rtra;
6771
6772 if ((insn & (0x3fu << 26)) != 31 << 26)
6773 return 0;
6774
6775 if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
6776 rtra = insn & ((1 << 26) - (1 << 16));
6777 else if (((insn >> 16) & 0x1f) == reg)
6778 rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
6779 else
6780 return 0;
6781
6782 if ((insn & (0x3ff << 1)) == 266 << 1)
6783 /* add -> addi. */
6784 insn = 14 << 26;
6785 else if ((insn & (0x1f << 1)) == 23 << 1
6786 && ((insn & (0x1f << 6)) < 14 << 6
6787 || ((insn & (0x1f << 6)) >= 16 << 6
6788 && (insn & (0x1f << 6)) < 24 << 6)))
6789 /* load and store indexed -> dform. */
6790 insn = (32u | ((insn >> 6) & 0x1f)) << 26;
6791 else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
6792 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
6793 insn = ((58u | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
6794 else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
6795 /* lwax -> lwa. */
6796 insn = (58u << 26) | 2;
6797 else
6798 return 0;
6799 insn |= rtra;
6800 return insn;
6801 }
6802
6803 /* If INSN is an opcode that may be used with an @tprel operand, return
6804 the transformed insn for an undefined weak symbol, ie. with the
6805 thread pointer REG operand removed. Otherwise return 0. */
6806
6807 unsigned int
6808 _bfd_elf_ppc_at_tprel_transform (unsigned int insn, unsigned int reg)
6809 {
6810 if ((insn & (0x1f << 16)) == reg << 16
6811 && ((insn & (0x3fu << 26)) == 14u << 26 /* addi */
6812 || (insn & (0x3fu << 26)) == 15u << 26 /* addis */
6813 || (insn & (0x3fu << 26)) == 32u << 26 /* lwz */
6814 || (insn & (0x3fu << 26)) == 34u << 26 /* lbz */
6815 || (insn & (0x3fu << 26)) == 36u << 26 /* stw */
6816 || (insn & (0x3fu << 26)) == 38u << 26 /* stb */
6817 || (insn & (0x3fu << 26)) == 40u << 26 /* lhz */
6818 || (insn & (0x3fu << 26)) == 42u << 26 /* lha */
6819 || (insn & (0x3fu << 26)) == 44u << 26 /* sth */
6820 || (insn & (0x3fu << 26)) == 46u << 26 /* lmw */
6821 || (insn & (0x3fu << 26)) == 47u << 26 /* stmw */
6822 || (insn & (0x3fu << 26)) == 48u << 26 /* lfs */
6823 || (insn & (0x3fu << 26)) == 50u << 26 /* lfd */
6824 || (insn & (0x3fu << 26)) == 52u << 26 /* stfs */
6825 || (insn & (0x3fu << 26)) == 54u << 26 /* stfd */
6826 || ((insn & (0x3fu << 26)) == 58u << 26 /* lwa,ld,lmd */
6827 && (insn & 3) != 1)
6828 || ((insn & (0x3fu << 26)) == 62u << 26 /* std, stmd */
6829 && ((insn & 3) == 0 || (insn & 3) == 3))))
6830 {
6831 insn &= ~(0x1f << 16);
6832 }
6833 else if ((insn & (0x1f << 21)) == reg << 21
6834 && ((insn & (0x3eu << 26)) == 24u << 26 /* ori, oris */
6835 || (insn & (0x3eu << 26)) == 26u << 26 /* xori,xoris */
6836 || (insn & (0x3eu << 26)) == 28u << 26 /* andi,andis */))
6837 {
6838 insn &= ~(0x1f << 21);
6839 insn |= (insn & (0x1f << 16)) << 5;
6840 if ((insn & (0x3eu << 26)) == 26u << 26 /* xori,xoris */)
6841 insn -= 2 >> 26; /* convert to ori,oris */
6842 }
6843 else
6844 insn = 0;
6845 return insn;
6846 }
6847
6848 static bfd_boolean
6849 is_insn_ds_form (unsigned int insn)
6850 {
6851 return ((insn & (0x3fu << 26)) == 58u << 26 /* ld,ldu,lwa */
6852 || (insn & (0x3fu << 26)) == 62u << 26 /* std,stdu,stq */
6853 || (insn & (0x3fu << 26)) == 57u << 26 /* lfdp */
6854 || (insn & (0x3fu << 26)) == 61u << 26 /* stfdp */);
6855 }
6856
6857 static bfd_boolean
6858 is_insn_dq_form (unsigned int insn)
6859 {
6860 return ((insn & (0x3fu << 26)) == 56u << 26 /* lq */
6861 || ((insn & (0x3fu << 26)) == (61u << 26) /* lxv, stxv */
6862 && (insn & 3) == 1));
6863 }
6864
6865 /* The RELOCATE_SECTION function is called by the ELF backend linker
6866 to handle the relocations for a section.
6867
6868 The relocs are always passed as Rela structures; if the section
6869 actually uses Rel structures, the r_addend field will always be
6870 zero.
6871
6872 This function is responsible for adjust the section contents as
6873 necessary, and (if using Rela relocs and generating a
6874 relocatable output file) adjusting the reloc addend as
6875 necessary.
6876
6877 This function does not have to worry about setting the reloc
6878 address or the reloc symbol index.
6879
6880 LOCAL_SYMS is a pointer to the swapped in local symbols.
6881
6882 LOCAL_SECTIONS is an array giving the section in the input file
6883 corresponding to the st_shndx field of each local symbol.
6884
6885 The global hash table entry for the global symbols can be found
6886 via elf_sym_hashes (input_bfd).
6887
6888 When generating relocatable output, this function must handle
6889 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
6890 going to be the section symbol corresponding to the output
6891 section, which means that the addend must be adjusted
6892 accordingly. */
6893
6894 static bfd_boolean
6895 ppc_elf_relocate_section (bfd *output_bfd,
6896 struct bfd_link_info *info,
6897 bfd *input_bfd,
6898 asection *input_section,
6899 bfd_byte *contents,
6900 Elf_Internal_Rela *relocs,
6901 Elf_Internal_Sym *local_syms,
6902 asection **local_sections)
6903 {
6904 Elf_Internal_Shdr *symtab_hdr;
6905 struct elf_link_hash_entry **sym_hashes;
6906 struct ppc_elf_link_hash_table *htab;
6907 Elf_Internal_Rela *rel;
6908 Elf_Internal_Rela *wrel;
6909 Elf_Internal_Rela *relend;
6910 Elf_Internal_Rela outrel;
6911 asection *got2;
6912 bfd_vma *local_got_offsets;
6913 bfd_boolean ret = TRUE;
6914 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
6915 bfd_boolean is_vxworks_tls;
6916 unsigned int picfixup_size = 0;
6917 struct ppc_elf_relax_info *relax_info = NULL;
6918
6919 #ifdef DEBUG
6920 _bfd_error_handler ("ppc_elf_relocate_section called for %pB section %pA, "
6921 "%ld relocations%s",
6922 input_bfd, input_section,
6923 (long) input_section->reloc_count,
6924 (bfd_link_relocatable (info)) ? " (relocatable)" : "");
6925 #endif
6926
6927 if (!is_ppc_elf (input_bfd))
6928 {
6929 bfd_set_error (bfd_error_wrong_format);
6930 return FALSE;
6931 }
6932
6933 got2 = bfd_get_section_by_name (input_bfd, ".got2");
6934
6935 /* Initialize howto table if not already done. */
6936 if (!ppc_elf_howto_table[R_PPC_ADDR32])
6937 ppc_elf_howto_init ();
6938
6939 htab = ppc_elf_hash_table (info);
6940 local_got_offsets = elf_local_got_offsets (input_bfd);
6941 symtab_hdr = &elf_symtab_hdr (input_bfd);
6942 sym_hashes = elf_sym_hashes (input_bfd);
6943 /* We have to handle relocations in vxworks .tls_vars sections
6944 specially, because the dynamic loader is 'weird'. */
6945 is_vxworks_tls = (htab->elf.target_os == is_vxworks && bfd_link_pic (info)
6946 && !strcmp (input_section->output_section->name,
6947 ".tls_vars"));
6948 if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET)
6949 relax_info = elf_section_data (input_section)->sec_info;
6950 rel = wrel = relocs;
6951 relend = relocs + input_section->reloc_count;
6952 for (; rel < relend; wrel++, rel++)
6953 {
6954 enum elf_ppc_reloc_type r_type;
6955 bfd_vma addend;
6956 bfd_reloc_status_type r;
6957 Elf_Internal_Sym *sym;
6958 asection *sec;
6959 struct elf_link_hash_entry *h;
6960 const char *sym_name;
6961 reloc_howto_type *howto;
6962 unsigned long r_symndx;
6963 bfd_vma relocation;
6964 bfd_vma branch_bit, from;
6965 bfd_boolean unresolved_reloc, save_unresolved_reloc;
6966 bfd_boolean warned;
6967 unsigned int tls_type, tls_mask, tls_gd;
6968 struct plt_entry **ifunc, **plt_list;
6969 struct reloc_howto_struct alt_howto;
6970
6971 again:
6972 r_type = ELF32_R_TYPE (rel->r_info);
6973 sym = NULL;
6974 sec = NULL;
6975 h = NULL;
6976 unresolved_reloc = FALSE;
6977 warned = FALSE;
6978 r_symndx = ELF32_R_SYM (rel->r_info);
6979
6980 if (r_symndx < symtab_hdr->sh_info)
6981 {
6982 sym = local_syms + r_symndx;
6983 sec = local_sections[r_symndx];
6984 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
6985
6986 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
6987 }
6988 else
6989 {
6990 bfd_boolean ignored;
6991
6992 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
6993 r_symndx, symtab_hdr, sym_hashes,
6994 h, sec, relocation,
6995 unresolved_reloc, warned, ignored);
6996
6997 sym_name = h->root.root.string;
6998 }
6999
7000 if (sec != NULL && discarded_section (sec))
7001 {
7002 /* For relocs against symbols from removed linkonce sections,
7003 or sections discarded by a linker script, we just want the
7004 section contents zeroed. Avoid any special processing. */
7005 howto = NULL;
7006 if (r_type < R_PPC_max)
7007 howto = ppc_elf_howto_table[r_type];
7008
7009 _bfd_clear_contents (howto, input_bfd, input_section,
7010 contents, rel->r_offset);
7011 wrel->r_offset = rel->r_offset;
7012 wrel->r_info = 0;
7013 wrel->r_addend = 0;
7014
7015 /* For ld -r, remove relocations in debug sections against
7016 symbols defined in discarded sections. Not done for
7017 non-debug to preserve relocs in .eh_frame which the
7018 eh_frame editing code expects to be present. */
7019 if (bfd_link_relocatable (info)
7020 && (input_section->flags & SEC_DEBUGGING))
7021 wrel--;
7022
7023 continue;
7024 }
7025
7026 if (bfd_link_relocatable (info))
7027 {
7028 if (got2 != NULL
7029 && r_type == R_PPC_PLTREL24
7030 && rel->r_addend != 0)
7031 {
7032 /* R_PPC_PLTREL24 is rather special. If non-zero, the
7033 addend specifies the GOT pointer offset within .got2. */
7034 rel->r_addend += got2->output_offset;
7035 }
7036 if (r_type != R_PPC_RELAX_PLT
7037 && r_type != R_PPC_RELAX_PLTREL24
7038 && r_type != R_PPC_RELAX)
7039 goto copy_reloc;
7040 }
7041
7042 /* TLS optimizations. Replace instruction sequences and relocs
7043 based on information we collected in tls_optimize. We edit
7044 RELOCS so that --emit-relocs will output something sensible
7045 for the final instruction stream. */
7046 tls_mask = 0;
7047 tls_gd = 0;
7048 if (h != NULL)
7049 tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
7050 else if (local_got_offsets != NULL)
7051 {
7052 struct plt_entry **local_plt;
7053 char *lgot_masks;
7054 local_plt
7055 = (struct plt_entry **) (local_got_offsets + symtab_hdr->sh_info);
7056 lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
7057 tls_mask = lgot_masks[r_symndx];
7058 }
7059
7060 /* Ensure reloc mapping code below stays sane. */
7061 if ((R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TLSGD16 & 3)
7062 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
7063 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
7064 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3)
7065 || (R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TPREL16 & 3)
7066 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3)
7067 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3)
7068 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3))
7069 abort ();
7070 switch (r_type)
7071 {
7072 default:
7073 break;
7074
7075 case R_PPC_GOT_TPREL16:
7076 case R_PPC_GOT_TPREL16_LO:
7077 if ((tls_mask & TLS_TLS) != 0
7078 && (tls_mask & TLS_TPREL) == 0)
7079 {
7080 bfd_vma insn;
7081
7082 insn = bfd_get_32 (input_bfd,
7083 contents + rel->r_offset - d_offset);
7084 insn &= 31 << 21;
7085 insn |= 0x3c020000; /* addis 0,2,0 */
7086 bfd_put_32 (input_bfd, insn,
7087 contents + rel->r_offset - d_offset);
7088 r_type = R_PPC_TPREL16_HA;
7089 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7090 }
7091 break;
7092
7093 case R_PPC_TLS:
7094 if ((tls_mask & TLS_TLS) != 0
7095 && (tls_mask & TLS_TPREL) == 0)
7096 {
7097 bfd_vma insn;
7098
7099 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7100 insn = _bfd_elf_ppc_at_tls_transform (insn, 2);
7101 if (insn == 0)
7102 abort ();
7103 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7104 r_type = R_PPC_TPREL16_LO;
7105 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7106
7107 /* Was PPC_TLS which sits on insn boundary, now
7108 PPC_TPREL16_LO which is at low-order half-word. */
7109 rel->r_offset += d_offset;
7110 }
7111 break;
7112
7113 case R_PPC_GOT_TLSGD16_HI:
7114 case R_PPC_GOT_TLSGD16_HA:
7115 tls_gd = TLS_GDIE;
7116 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7117 goto tls_gdld_hi;
7118 break;
7119
7120 case R_PPC_GOT_TLSLD16_HI:
7121 case R_PPC_GOT_TLSLD16_HA:
7122 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7123 {
7124 tls_gdld_hi:
7125 if ((tls_mask & tls_gd) != 0)
7126 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7127 + R_PPC_GOT_TPREL16);
7128 else
7129 {
7130 rel->r_offset -= d_offset;
7131 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
7132 r_type = R_PPC_NONE;
7133 }
7134 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7135 }
7136 break;
7137
7138 case R_PPC_GOT_TLSGD16:
7139 case R_PPC_GOT_TLSGD16_LO:
7140 tls_gd = TLS_GDIE;
7141 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7142 goto tls_ldgd_opt;
7143 break;
7144
7145 case R_PPC_GOT_TLSLD16:
7146 case R_PPC_GOT_TLSLD16_LO:
7147 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7148 {
7149 unsigned int insn1, insn2;
7150 bfd_vma offset;
7151
7152 tls_ldgd_opt:
7153 offset = (bfd_vma) -1;
7154 /* If not using the newer R_PPC_TLSGD/LD to mark
7155 __tls_get_addr calls, we must trust that the call
7156 stays with its arg setup insns, ie. that the next
7157 reloc is the __tls_get_addr call associated with
7158 the current reloc. Edit both insns. */
7159 if (input_section->nomark_tls_get_addr
7160 && rel + 1 < relend
7161 && branch_reloc_hash_match (input_bfd, rel + 1,
7162 htab->tls_get_addr))
7163 offset = rel[1].r_offset;
7164 /* We read the low GOT_TLS insn because we need to keep
7165 the destination reg. It may be something other than
7166 the usual r3, and moved to r3 before the call by
7167 intervening code. */
7168 insn1 = bfd_get_32 (input_bfd,
7169 contents + rel->r_offset - d_offset);
7170 if ((tls_mask & tls_gd) != 0)
7171 {
7172 /* IE */
7173 insn1 &= (0x1f << 21) | (0x1f << 16);
7174 insn1 |= 32u << 26; /* lwz */
7175 if (offset != (bfd_vma) -1)
7176 {
7177 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7178 insn2 = 0x7c631214; /* add 3,3,2 */
7179 bfd_put_32 (input_bfd, insn2, contents + offset);
7180 }
7181 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7182 + R_PPC_GOT_TPREL16);
7183 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7184 }
7185 else
7186 {
7187 /* LE */
7188 insn1 &= 0x1f << 21;
7189 insn1 |= 0x3c020000; /* addis r,2,0 */
7190 if (tls_gd == 0)
7191 {
7192 /* Was an LD reloc. */
7193 for (r_symndx = 0;
7194 r_symndx < symtab_hdr->sh_info;
7195 r_symndx++)
7196 if (local_sections[r_symndx] == sec)
7197 break;
7198 if (r_symndx >= symtab_hdr->sh_info)
7199 r_symndx = STN_UNDEF;
7200 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
7201 if (r_symndx != STN_UNDEF)
7202 rel->r_addend -= (local_syms[r_symndx].st_value
7203 + sec->output_offset
7204 + sec->output_section->vma);
7205 }
7206 r_type = R_PPC_TPREL16_HA;
7207 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7208 if (offset != (bfd_vma) -1)
7209 {
7210 rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7211 rel[1].r_offset = offset + d_offset;
7212 rel[1].r_addend = rel->r_addend;
7213 insn2 = 0x38630000; /* addi 3,3,0 */
7214 bfd_put_32 (input_bfd, insn2, contents + offset);
7215 }
7216 }
7217 bfd_put_32 (input_bfd, insn1,
7218 contents + rel->r_offset - d_offset);
7219 if (tls_gd == 0)
7220 {
7221 /* We changed the symbol on an LD reloc. Start over
7222 in order to get h, sym, sec etc. right. */
7223 goto again;
7224 }
7225 }
7226 break;
7227
7228 case R_PPC_TLSGD:
7229 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
7230 && rel + 1 < relend)
7231 {
7232 unsigned int insn2;
7233 bfd_vma offset = rel->r_offset;
7234
7235 if (is_plt_seq_reloc (ELF32_R_TYPE (rel[1].r_info)))
7236 {
7237 bfd_put_32 (input_bfd, NOP, contents + offset);
7238 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7239 break;
7240 }
7241
7242 if ((tls_mask & TLS_GDIE) != 0)
7243 {
7244 /* IE */
7245 r_type = R_PPC_NONE;
7246 insn2 = 0x7c631214; /* add 3,3,2 */
7247 }
7248 else
7249 {
7250 /* LE */
7251 r_type = R_PPC_TPREL16_LO;
7252 rel->r_offset += d_offset;
7253 insn2 = 0x38630000; /* addi 3,3,0 */
7254 }
7255 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7256 bfd_put_32 (input_bfd, insn2, contents + offset);
7257 /* Zap the reloc on the _tls_get_addr call too. */
7258 BFD_ASSERT (offset == rel[1].r_offset);
7259 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7260 }
7261 break;
7262
7263 case R_PPC_TLSLD:
7264 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
7265 && rel + 1 < relend)
7266 {
7267 unsigned int insn2;
7268
7269 if (is_plt_seq_reloc (ELF32_R_TYPE (rel[1].r_info)))
7270 {
7271 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
7272 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7273 break;
7274 }
7275
7276 for (r_symndx = 0;
7277 r_symndx < symtab_hdr->sh_info;
7278 r_symndx++)
7279 if (local_sections[r_symndx] == sec)
7280 break;
7281 if (r_symndx >= symtab_hdr->sh_info)
7282 r_symndx = STN_UNDEF;
7283 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
7284 if (r_symndx != STN_UNDEF)
7285 rel->r_addend -= (local_syms[r_symndx].st_value
7286 + sec->output_offset
7287 + sec->output_section->vma);
7288
7289 rel->r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7290 rel->r_offset += d_offset;
7291 insn2 = 0x38630000; /* addi 3,3,0 */
7292 bfd_put_32 (input_bfd, insn2,
7293 contents + rel->r_offset - d_offset);
7294 /* Zap the reloc on the _tls_get_addr call too. */
7295 BFD_ASSERT (rel->r_offset - d_offset == rel[1].r_offset);
7296 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7297 goto again;
7298 }
7299 break;
7300 }
7301
7302 /* Handle other relocations that tweak non-addend part of insn. */
7303 branch_bit = 0;
7304 switch (r_type)
7305 {
7306 default:
7307 break;
7308
7309 /* Branch taken prediction relocations. */
7310 case R_PPC_ADDR14_BRTAKEN:
7311 case R_PPC_REL14_BRTAKEN:
7312 branch_bit = BRANCH_PREDICT_BIT;
7313 /* Fall through. */
7314
7315 /* Branch not taken prediction relocations. */
7316 case R_PPC_ADDR14_BRNTAKEN:
7317 case R_PPC_REL14_BRNTAKEN:
7318 {
7319 unsigned int insn;
7320
7321 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7322 insn &= ~BRANCH_PREDICT_BIT;
7323 insn |= branch_bit;
7324
7325 from = (rel->r_offset
7326 + input_section->output_offset
7327 + input_section->output_section->vma);
7328
7329 /* Invert 'y' bit if not the default. */
7330 if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
7331 insn ^= BRANCH_PREDICT_BIT;
7332
7333 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7334 }
7335 break;
7336
7337 case R_PPC_PLT16_HA:
7338 {
7339 unsigned int insn;
7340
7341 insn = bfd_get_32 (input_bfd,
7342 contents + rel->r_offset - d_offset);
7343 if ((insn & (0x3fu << 26)) == 15u << 26
7344 && (insn & (0x1f << 16)) != 0)
7345 {
7346 if (!bfd_link_pic (info))
7347 {
7348 /* Convert addis to lis. */
7349 insn &= ~(0x1f << 16);
7350 bfd_put_32 (input_bfd, insn,
7351 contents + rel->r_offset - d_offset);
7352 }
7353 }
7354 else if (bfd_link_pic (info))
7355 info->callbacks->einfo
7356 (_("%P: %H: error: %s with unexpected instruction %x\n"),
7357 input_bfd, input_section, rel->r_offset,
7358 "R_PPC_PLT16_HA", insn);
7359 }
7360 break;
7361 }
7362
7363 if (ELIMINATE_COPY_RELOCS
7364 && h != NULL
7365 && !h->def_regular
7366 && h->protected_def
7367 && ppc_elf_hash_entry (h)->has_addr16_ha
7368 && ppc_elf_hash_entry (h)->has_addr16_lo
7369 && htab->params->pic_fixup > 0)
7370 {
7371 /* Convert lis;addi or lis;load/store accessing a protected
7372 variable defined in a shared library to PIC. */
7373 unsigned int insn;
7374
7375 if (r_type == R_PPC_ADDR16_HA)
7376 {
7377 insn = bfd_get_32 (input_bfd,
7378 contents + rel->r_offset - d_offset);
7379 if ((insn & (0x3fu << 26)) == (15u << 26)
7380 && (insn & (0x1f << 16)) == 0 /* lis */)
7381 {
7382 bfd_byte *p;
7383 bfd_vma off;
7384 bfd_vma got_addr;
7385
7386 p = (contents + input_section->size
7387 - relax_info->workaround_size
7388 - relax_info->picfixup_size
7389 + picfixup_size);
7390 off = (p - contents) - (rel->r_offset - d_offset);
7391 if (off > 0x1fffffc || (off & 3) != 0)
7392 info->callbacks->einfo
7393 (_("%H: fixup branch overflow\n"),
7394 input_bfd, input_section, rel->r_offset);
7395
7396 bfd_put_32 (input_bfd, B | off,
7397 contents + rel->r_offset - d_offset);
7398 got_addr = (htab->elf.sgot->output_section->vma
7399 + htab->elf.sgot->output_offset
7400 + (h->got.offset & ~1));
7401 wrel->r_offset = (p - contents) + d_offset;
7402 wrel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_HA);
7403 wrel->r_addend = got_addr;
7404 insn &= ~0xffff;
7405 insn |= ((unsigned int) (got_addr + 0x8000) >> 16) & 0xffff;
7406 bfd_put_32 (input_bfd, insn, p);
7407
7408 /* Convert lis to lwz, loading address from GOT. */
7409 insn &= ~0xffff;
7410 insn ^= (32u ^ 15u) << 26;
7411 insn |= (insn & (0x1f << 21)) >> 5;
7412 insn |= got_addr & 0xffff;
7413 bfd_put_32 (input_bfd, insn, p + 4);
7414
7415 bfd_put_32 (input_bfd, B | ((-4 - off) & 0x3ffffff), p + 8);
7416 picfixup_size += 12;
7417
7418 /* Use one of the spare relocs, so --emit-relocs
7419 output is reasonable. */
7420 memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel));
7421 wrel++, rel++;
7422 rel->r_offset = wrel[-1].r_offset + 4;
7423 rel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_LO);
7424 rel->r_addend = wrel[-1].r_addend;
7425
7426 /* Continue on as if we had a got reloc, to output
7427 dynamic reloc. */
7428 r_type = R_PPC_GOT16_LO;
7429 }
7430 else
7431 _bfd_error_handler
7432 /* xgettext:c-format */
7433 (_("%pB(%pA+%#" PRIx64 "): error: "
7434 "%s with unexpected instruction %#x"),
7435 input_bfd, input_section, (uint64_t) rel->r_offset,
7436 "R_PPC_ADDR16_HA", insn);
7437 }
7438 else if (r_type == R_PPC_ADDR16_LO)
7439 {
7440 insn = bfd_get_32 (input_bfd,
7441 contents + rel->r_offset - d_offset);
7442 if ((insn & (0x3fu << 26)) == 14u << 26 /* addi */
7443 || (insn & (0x3fu << 26)) == 32u << 26 /* lwz */
7444 || (insn & (0x3fu << 26)) == 34u << 26 /* lbz */
7445 || (insn & (0x3fu << 26)) == 36u << 26 /* stw */
7446 || (insn & (0x3fu << 26)) == 38u << 26 /* stb */
7447 || (insn & (0x3fu << 26)) == 40u << 26 /* lhz */
7448 || (insn & (0x3fu << 26)) == 42u << 26 /* lha */
7449 || (insn & (0x3fu << 26)) == 44u << 26 /* sth */
7450 || (insn & (0x3fu << 26)) == 46u << 26 /* lmw */
7451 || (insn & (0x3fu << 26)) == 47u << 26 /* stmw */
7452 || (insn & (0x3fu << 26)) == 48u << 26 /* lfs */
7453 || (insn & (0x3fu << 26)) == 50u << 26 /* lfd */
7454 || (insn & (0x3fu << 26)) == 52u << 26 /* stfs */
7455 || (insn & (0x3fu << 26)) == 54u << 26 /* stfd */
7456 || ((insn & (0x3fu << 26)) == 58u << 26 /* lwa,ld,lmd */
7457 && (insn & 3) != 1)
7458 || ((insn & (0x3fu << 26)) == 62u << 26 /* std, stmd */
7459 && ((insn & 3) == 0 || (insn & 3) == 3)))
7460 {
7461 /* Arrange to apply the reloc addend, if any. */
7462 relocation = 0;
7463 unresolved_reloc = FALSE;
7464 rel->r_info = ELF32_R_INFO (0, r_type);
7465 }
7466 else
7467 _bfd_error_handler
7468 /* xgettext:c-format */
7469 (_("%pB(%pA+%#" PRIx64 "): error: "
7470 "%s with unexpected instruction %#x"),
7471 input_bfd, input_section, (uint64_t) rel->r_offset,
7472 "R_PPC_ADDR16_LO", insn);
7473 }
7474 }
7475
7476 ifunc = NULL;
7477 if (htab->elf.target_os != is_vxworks)
7478 {
7479 struct plt_entry *ent;
7480
7481 if (h != NULL)
7482 {
7483 if (h->type == STT_GNU_IFUNC)
7484 ifunc = &h->plt.plist;
7485 }
7486 else if (local_got_offsets != NULL
7487 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
7488 {
7489 struct plt_entry **local_plt;
7490
7491 local_plt = (struct plt_entry **) (local_got_offsets
7492 + symtab_hdr->sh_info);
7493 ifunc = local_plt + r_symndx;
7494 }
7495
7496 ent = NULL;
7497 if (ifunc != NULL
7498 && (!bfd_link_pic (info)
7499 || is_branch_reloc (r_type)
7500 || r_type == R_PPC_PLT16_LO
7501 || r_type == R_PPC_PLT16_HI
7502 || r_type == R_PPC_PLT16_HA))
7503 {
7504 addend = 0;
7505 if (bfd_link_pic (info)
7506 && (r_type == R_PPC_PLTREL24
7507 || r_type == R_PPC_PLT16_LO
7508 || r_type == R_PPC_PLT16_HI
7509 || r_type == R_PPC_PLT16_HA))
7510 addend = rel->r_addend;
7511 ent = find_plt_ent (ifunc, got2, addend);
7512 }
7513 if (ent != NULL)
7514 {
7515 if (bfd_link_pic (info)
7516 && ent->sec != got2
7517 && htab->plt_type != PLT_NEW
7518 && (!htab->elf.dynamic_sections_created
7519 || h == NULL
7520 || h->dynindx == -1))
7521 {
7522 /* Uh oh, we are going to create a pic glink stub
7523 for an ifunc (here for h == NULL and later in
7524 finish_dynamic_symbol for h != NULL), and
7525 apparently are using code compiled with
7526 -mbss-plt. The difficulty is that -mbss-plt code
7527 gives no indication via a magic PLTREL24 addend
7528 whether r30 is equal to _GLOBAL_OFFSET_TABLE_ or
7529 is pointing into a .got2 section (and how far
7530 into .got2). */
7531 info->callbacks->einfo
7532 /* xgettext:c-format */
7533 (_("%X%H: unsupported bss-plt -fPIC ifunc %s\n"),
7534 input_bfd, input_section, rel->r_offset, sym_name);
7535 }
7536
7537 unresolved_reloc = FALSE;
7538 if (htab->plt_type == PLT_NEW
7539 || !htab->elf.dynamic_sections_created
7540 || h == NULL
7541 || h->dynindx == -1)
7542 relocation = (htab->glink->output_section->vma
7543 + htab->glink->output_offset
7544 + (ent->glink_offset & ~1));
7545 else
7546 relocation = (htab->elf.splt->output_section->vma
7547 + htab->elf.splt->output_offset
7548 + ent->plt.offset);
7549 }
7550 }
7551
7552 addend = rel->r_addend;
7553 save_unresolved_reloc = unresolved_reloc;
7554 howto = NULL;
7555 if (r_type < R_PPC_max)
7556 howto = ppc_elf_howto_table[r_type];
7557
7558 switch (r_type)
7559 {
7560 default:
7561 break;
7562
7563 case R_PPC_TPREL16_HA:
7564 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
7565 {
7566 bfd_byte *p = contents + (rel->r_offset & ~3);
7567 unsigned int insn = bfd_get_32 (input_bfd, p);
7568 if ((insn & ((0x3fu << 26) | 0x1f << 16))
7569 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */)
7570 /* xgettext:c-format */
7571 info->callbacks->minfo
7572 (_("%H: warning: %s unexpected insn %#x.\n"),
7573 input_bfd, input_section, rel->r_offset, howto->name, insn);
7574 else
7575 bfd_put_32 (input_bfd, NOP, p);
7576 }
7577 break;
7578
7579 case R_PPC_TPREL16_LO:
7580 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
7581 {
7582 bfd_byte *p = contents + (rel->r_offset & ~3);
7583 unsigned int insn = bfd_get_32 (input_bfd, p);
7584 insn &= ~(0x1f << 16);
7585 insn |= 2 << 16;
7586 bfd_put_32 (input_bfd, insn, p);
7587 }
7588 break;
7589 }
7590
7591 tls_type = 0;
7592 switch (r_type)
7593 {
7594 default:
7595 /* xgettext:c-format */
7596 _bfd_error_handler (_("%pB: %s unsupported"),
7597 input_bfd, howto->name);
7598
7599 bfd_set_error (bfd_error_bad_value);
7600 ret = FALSE;
7601 goto copy_reloc;
7602
7603 case R_PPC_NONE:
7604 case R_PPC_TLS:
7605 case R_PPC_TLSGD:
7606 case R_PPC_TLSLD:
7607 case R_PPC_EMB_MRKREF:
7608 case R_PPC_GNU_VTINHERIT:
7609 case R_PPC_GNU_VTENTRY:
7610 goto copy_reloc;
7611
7612 /* GOT16 relocations. Like an ADDR16 using the symbol's
7613 address in the GOT as relocation value instead of the
7614 symbol's value itself. Also, create a GOT entry for the
7615 symbol and put the symbol value there. */
7616 case R_PPC_GOT_TLSGD16:
7617 case R_PPC_GOT_TLSGD16_LO:
7618 case R_PPC_GOT_TLSGD16_HI:
7619 case R_PPC_GOT_TLSGD16_HA:
7620 tls_type = TLS_TLS | TLS_GD;
7621 goto dogot;
7622
7623 case R_PPC_GOT_TLSLD16:
7624 case R_PPC_GOT_TLSLD16_LO:
7625 case R_PPC_GOT_TLSLD16_HI:
7626 case R_PPC_GOT_TLSLD16_HA:
7627 tls_type = TLS_TLS | TLS_LD;
7628 goto dogot;
7629
7630 case R_PPC_GOT_TPREL16:
7631 case R_PPC_GOT_TPREL16_LO:
7632 case R_PPC_GOT_TPREL16_HI:
7633 case R_PPC_GOT_TPREL16_HA:
7634 tls_type = TLS_TLS | TLS_TPREL;
7635 goto dogot;
7636
7637 case R_PPC_GOT_DTPREL16:
7638 case R_PPC_GOT_DTPREL16_LO:
7639 case R_PPC_GOT_DTPREL16_HI:
7640 case R_PPC_GOT_DTPREL16_HA:
7641 tls_type = TLS_TLS | TLS_DTPREL;
7642 goto dogot;
7643
7644 case R_PPC_GOT16:
7645 case R_PPC_GOT16_LO:
7646 case R_PPC_GOT16_HI:
7647 case R_PPC_GOT16_HA:
7648 tls_mask = 0;
7649 dogot:
7650 {
7651 /* Relocation is to the entry for this symbol in the global
7652 offset table. */
7653 bfd_vma off;
7654 bfd_vma *offp;
7655 unsigned long indx;
7656
7657 if (htab->elf.sgot == NULL)
7658 abort ();
7659
7660 indx = 0;
7661 if (tls_type == (TLS_TLS | TLS_LD)
7662 && SYMBOL_REFERENCES_LOCAL (info, h))
7663 offp = &htab->tlsld_got.offset;
7664 else if (h != NULL)
7665 {
7666 if (!htab->elf.dynamic_sections_created
7667 || h->dynindx == -1
7668 || SYMBOL_REFERENCES_LOCAL (info, h)
7669 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
7670 /* This is actually a static link, or it is a
7671 -Bsymbolic link and the symbol is defined
7672 locally, or the symbol was forced to be local
7673 because of a version file. */
7674 ;
7675 else
7676 {
7677 indx = h->dynindx;
7678 unresolved_reloc = FALSE;
7679 }
7680 offp = &h->got.offset;
7681 }
7682 else
7683 {
7684 if (local_got_offsets == NULL)
7685 abort ();
7686 offp = &local_got_offsets[r_symndx];
7687 }
7688
7689 /* The offset must always be a multiple of 4. We use the
7690 least significant bit to record whether we have already
7691 processed this entry. */
7692 off = *offp;
7693 if ((off & 1) != 0)
7694 off &= ~1;
7695 else
7696 {
7697 unsigned int tls_m = ((tls_mask & TLS_TLS) != 0
7698 ? tls_mask & (TLS_LD | TLS_GD | TLS_DTPREL
7699 | TLS_TPREL | TLS_GDIE)
7700 : 0);
7701
7702 if (offp == &htab->tlsld_got.offset)
7703 tls_m = TLS_LD;
7704 else if ((tls_m & TLS_LD) != 0
7705 && SYMBOL_REFERENCES_LOCAL (info, h))
7706 tls_m &= ~TLS_LD;
7707
7708 /* We might have multiple got entries for this sym.
7709 Initialize them all. */
7710 do
7711 {
7712 int tls_ty = 0;
7713
7714 if ((tls_m & TLS_LD) != 0)
7715 {
7716 tls_ty = TLS_TLS | TLS_LD;
7717 tls_m &= ~TLS_LD;
7718 }
7719 else if ((tls_m & TLS_GD) != 0)
7720 {
7721 tls_ty = TLS_TLS | TLS_GD;
7722 tls_m &= ~TLS_GD;
7723 }
7724 else if ((tls_m & TLS_DTPREL) != 0)
7725 {
7726 tls_ty = TLS_TLS | TLS_DTPREL;
7727 tls_m &= ~TLS_DTPREL;
7728 }
7729 else if ((tls_m & (TLS_TPREL | TLS_GDIE)) != 0)
7730 {
7731 tls_ty = TLS_TLS | TLS_TPREL;
7732 tls_m = 0;
7733 }
7734
7735 /* Generate relocs for the dynamic linker. */
7736 if (indx != 0
7737 || (bfd_link_pic (info)
7738 && (h == NULL
7739 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
7740 && !(tls_ty != 0
7741 && bfd_link_executable (info)
7742 && SYMBOL_REFERENCES_LOCAL (info, h))))
7743 {
7744 asection *rsec = htab->elf.srelgot;
7745 bfd_byte * loc;
7746
7747 if (ifunc != NULL)
7748 {
7749 rsec = htab->elf.irelplt;
7750 if (indx == 0)
7751 htab->local_ifunc_resolver = 1;
7752 else if (is_static_defined (h))
7753 htab->maybe_local_ifunc_resolver = 1;
7754 }
7755 outrel.r_offset = (htab->elf.sgot->output_section->vma
7756 + htab->elf.sgot->output_offset
7757 + off);
7758 outrel.r_addend = 0;
7759 if (tls_ty & (TLS_LD | TLS_GD))
7760 {
7761 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
7762 if (tls_ty == (TLS_TLS | TLS_GD))
7763 {
7764 loc = rsec->contents;
7765 loc += (rsec->reloc_count++
7766 * sizeof (Elf32_External_Rela));
7767 bfd_elf32_swap_reloca_out (output_bfd,
7768 &outrel, loc);
7769 outrel.r_offset += 4;
7770 outrel.r_info
7771 = ELF32_R_INFO (indx, R_PPC_DTPREL32);
7772 }
7773 }
7774 else if (tls_ty == (TLS_TLS | TLS_DTPREL))
7775 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
7776 else if (tls_ty == (TLS_TLS | TLS_TPREL))
7777 outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
7778 else if (indx != 0)
7779 outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
7780 else if (ifunc != NULL)
7781 outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
7782 else
7783 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
7784 if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD))
7785 {
7786 outrel.r_addend += relocation;
7787 if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
7788 {
7789 if (htab->elf.tls_sec == NULL)
7790 outrel.r_addend = 0;
7791 else
7792 outrel.r_addend -= htab->elf.tls_sec->vma;
7793 }
7794 }
7795 loc = rsec->contents;
7796 loc += (rsec->reloc_count++
7797 * sizeof (Elf32_External_Rela));
7798 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
7799 }
7800
7801 /* Init the .got section contents if we're not
7802 emitting a reloc. */
7803 else
7804 {
7805 bfd_vma value = relocation;
7806
7807 if (tls_ty != 0)
7808 {
7809 if (htab->elf.tls_sec == NULL)
7810 value = 0;
7811 else
7812 {
7813 if (tls_ty & TLS_LD)
7814 value = 0;
7815 else
7816 value -= htab->elf.tls_sec->vma + DTP_OFFSET;
7817 if (tls_ty & TLS_TPREL)
7818 value += DTP_OFFSET - TP_OFFSET;
7819 }
7820
7821 if (tls_ty & (TLS_LD | TLS_GD))
7822 {
7823 bfd_put_32 (input_bfd, value,
7824 htab->elf.sgot->contents + off + 4);
7825 value = 1;
7826 }
7827 }
7828 bfd_put_32 (input_bfd, value,
7829 htab->elf.sgot->contents + off);
7830 }
7831
7832 off += 4;
7833 if (tls_ty & (TLS_LD | TLS_GD))
7834 off += 4;
7835 }
7836 while (tls_m != 0);
7837
7838 off = *offp;
7839 *offp = off | 1;
7840 }
7841
7842 if (off >= (bfd_vma) -2)
7843 abort ();
7844
7845 if ((tls_type & TLS_TLS) != 0)
7846 {
7847 if (tls_type != (TLS_TLS | TLS_LD))
7848 {
7849 if ((tls_mask & TLS_LD) != 0
7850 && !SYMBOL_REFERENCES_LOCAL (info, h))
7851 off += 8;
7852 if (tls_type != (TLS_TLS | TLS_GD))
7853 {
7854 if ((tls_mask & TLS_GD) != 0)
7855 off += 8;
7856 if (tls_type != (TLS_TLS | TLS_DTPREL))
7857 {
7858 if ((tls_mask & TLS_DTPREL) != 0)
7859 off += 4;
7860 }
7861 }
7862 }
7863 }
7864
7865 /* If here for a picfixup, we're done. */
7866 if (r_type != ELF32_R_TYPE (rel->r_info))
7867 goto copy_reloc;
7868
7869 relocation = (htab->elf.sgot->output_section->vma
7870 + htab->elf.sgot->output_offset
7871 + off
7872 - SYM_VAL (htab->elf.hgot));
7873
7874 /* Addends on got relocations don't make much sense.
7875 x+off@got is actually x@got+off, and since the got is
7876 generated by a hash table traversal, the value in the
7877 got at entry m+n bears little relation to the entry m. */
7878 if (addend != 0)
7879 info->callbacks->einfo
7880 /* xgettext:c-format */
7881 (_("%H: non-zero addend on %s reloc against `%s'\n"),
7882 input_bfd, input_section, rel->r_offset,
7883 howto->name,
7884 sym_name);
7885 }
7886 break;
7887
7888 /* Relocations that need no special processing. */
7889 case R_PPC_LOCAL24PC:
7890 /* It makes no sense to point a local relocation
7891 at a symbol not in this object. */
7892 if (unresolved_reloc)
7893 {
7894 (*info->callbacks->undefined_symbol) (info,
7895 h->root.root.string,
7896 input_bfd,
7897 input_section,
7898 rel->r_offset,
7899 TRUE);
7900 goto copy_reloc;
7901 }
7902 if (h != NULL && h->type == STT_GNU_IFUNC && bfd_link_pic (info))
7903 {
7904 /* @local on an ifunc does not really make sense since
7905 the ifunc resolver can take you anywhere. More
7906 seriously, calls to ifuncs must go through a plt call
7907 stub, and for pic the plt call stubs uses r30 to
7908 access the PLT. The problem is that a call that is
7909 local won't have the +32k reloc addend trick marking
7910 -fPIC code, so the linker won't know whether r30 is
7911 _GLOBAL_OFFSET_TABLE_ or pointing into a .got2 section. */
7912 /* xgettext:c-format */
7913 info->callbacks->einfo (_("%X%H: @local call to ifunc %s\n"),
7914 input_bfd, input_section, rel->r_offset,
7915 h->root.root.string);
7916 }
7917 break;
7918
7919 case R_PPC_DTPREL16:
7920 case R_PPC_DTPREL16_LO:
7921 case R_PPC_DTPREL16_HI:
7922 case R_PPC_DTPREL16_HA:
7923 if (htab->elf.tls_sec != NULL)
7924 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
7925 break;
7926
7927 /* Relocations that may need to be propagated if this is a shared
7928 object. */
7929 case R_PPC_TPREL16:
7930 case R_PPC_TPREL16_LO:
7931 case R_PPC_TPREL16_HI:
7932 case R_PPC_TPREL16_HA:
7933 if (h != NULL
7934 && h->root.type == bfd_link_hash_undefweak
7935 && h->dynindx == -1)
7936 {
7937 /* Make this relocation against an undefined weak symbol
7938 resolve to zero. This is really just a tweak, since
7939 code using weak externs ought to check that they are
7940 defined before using them. */
7941 bfd_byte *p = contents + rel->r_offset - d_offset;
7942 unsigned int insn = bfd_get_32 (input_bfd, p);
7943 insn = _bfd_elf_ppc_at_tprel_transform (insn, 2);
7944 if (insn != 0)
7945 bfd_put_32 (input_bfd, insn, p);
7946 break;
7947 }
7948 if (htab->elf.tls_sec != NULL)
7949 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
7950 /* The TPREL16 relocs shouldn't really be used in shared
7951 libs or with non-local symbols as that will result in
7952 DT_TEXTREL being set, but support them anyway. */
7953 goto dodyn;
7954
7955 case R_PPC_TPREL32:
7956 if (htab->elf.tls_sec != NULL)
7957 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
7958 goto dodyn;
7959
7960 case R_PPC_DTPREL32:
7961 if (htab->elf.tls_sec != NULL)
7962 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
7963 goto dodyn;
7964
7965 case R_PPC_DTPMOD32:
7966 relocation = 1;
7967 addend = 0;
7968 goto dodyn;
7969
7970 case R_PPC_REL16:
7971 case R_PPC_REL16_LO:
7972 case R_PPC_REL16_HI:
7973 case R_PPC_REL16_HA:
7974 case R_PPC_REL16DX_HA:
7975 break;
7976
7977 case R_PPC_REL32:
7978 if (h == NULL || h == htab->elf.hgot)
7979 break;
7980 /* fall through */
7981
7982 case R_PPC_ADDR32:
7983 case R_PPC_ADDR16:
7984 case R_PPC_ADDR16_LO:
7985 case R_PPC_ADDR16_HI:
7986 case R_PPC_ADDR16_HA:
7987 case R_PPC_UADDR32:
7988 case R_PPC_UADDR16:
7989 goto dodyn;
7990
7991 case R_PPC_VLE_REL8:
7992 case R_PPC_VLE_REL15:
7993 case R_PPC_VLE_REL24:
7994 case R_PPC_REL24:
7995 case R_PPC_REL14:
7996 case R_PPC_REL14_BRTAKEN:
7997 case R_PPC_REL14_BRNTAKEN:
7998 /* If these relocations are not to a named symbol, they can be
7999 handled right here, no need to bother the dynamic linker. */
8000 if (SYMBOL_CALLS_LOCAL (info, h)
8001 || h == htab->elf.hgot)
8002 break;
8003 /* fall through */
8004
8005 case R_PPC_ADDR24:
8006 case R_PPC_ADDR14:
8007 case R_PPC_ADDR14_BRTAKEN:
8008 case R_PPC_ADDR14_BRNTAKEN:
8009 if (h != NULL && !bfd_link_pic (info))
8010 break;
8011 /* fall through */
8012
8013 dodyn:
8014 if ((input_section->flags & SEC_ALLOC) == 0
8015 || is_vxworks_tls)
8016 break;
8017
8018 if (bfd_link_pic (info)
8019 ? ((h == NULL
8020 || h->dyn_relocs != NULL)
8021 && ((h != NULL && pc_dynrelocs (h))
8022 || must_be_dyn_reloc (info, r_type)))
8023 : (h != NULL
8024 && h->dyn_relocs != NULL))
8025 {
8026 int skip;
8027 bfd_byte *loc;
8028 asection *sreloc;
8029 long indx = 0;
8030
8031 #ifdef DEBUG
8032 fprintf (stderr, "ppc_elf_relocate_section needs to "
8033 "create relocation for %s\n",
8034 (h && h->root.root.string
8035 ? h->root.root.string : "<unknown>"));
8036 #endif
8037
8038 /* When generating a shared object, these relocations
8039 are copied into the output file to be resolved at run
8040 time. */
8041 skip = 0;
8042 outrel.r_offset = _bfd_elf_section_offset (output_bfd, info,
8043 input_section,
8044 rel->r_offset);
8045 if (outrel.r_offset == (bfd_vma) -1
8046 || outrel.r_offset == (bfd_vma) -2)
8047 skip = (int) outrel.r_offset;
8048 outrel.r_offset += (input_section->output_section->vma
8049 + input_section->output_offset);
8050
8051 /* Optimize unaligned reloc use. */
8052 if ((r_type == R_PPC_ADDR32 && (outrel.r_offset & 3) != 0)
8053 || (r_type == R_PPC_UADDR32 && (outrel.r_offset & 3) == 0))
8054 r_type ^= R_PPC_ADDR32 ^ R_PPC_UADDR32;
8055 if ((r_type == R_PPC_ADDR16 && (outrel.r_offset & 1) != 0)
8056 || (r_type == R_PPC_UADDR16 && (outrel.r_offset & 1) == 0))
8057 r_type ^= R_PPC_ADDR16 ^ R_PPC_UADDR16;
8058
8059 if (skip)
8060 memset (&outrel, 0, sizeof outrel);
8061 else if (!SYMBOL_REFERENCES_LOCAL (info, h))
8062 {
8063 indx = h->dynindx;
8064 BFD_ASSERT (indx != -1);
8065 unresolved_reloc = FALSE;
8066 outrel.r_info = ELF32_R_INFO (indx, r_type);
8067 outrel.r_addend = rel->r_addend;
8068 }
8069 else
8070 {
8071 outrel.r_addend = relocation + rel->r_addend;
8072
8073 if (r_type != R_PPC_ADDR32)
8074 {
8075 if (ifunc != NULL)
8076 {
8077 /* If we get here when building a static
8078 executable, then the libc startup function
8079 responsible for applying indirect function
8080 relocations is going to complain about
8081 the reloc type.
8082 If we get here when building a dynamic
8083 executable, it will be because we have
8084 a text relocation. The dynamic loader
8085 will set the text segment writable and
8086 non-executable to apply text relocations.
8087 So we'll segfault when trying to run the
8088 indirection function to resolve the reloc. */
8089 info->callbacks->einfo
8090 /* xgettext:c-format */
8091 (_("%H: relocation %s for indirect "
8092 "function %s unsupported\n"),
8093 input_bfd, input_section, rel->r_offset,
8094 howto->name,
8095 sym_name);
8096 ret = FALSE;
8097 }
8098 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
8099 ;
8100 else if (sec == NULL || sec->owner == NULL)
8101 {
8102 bfd_set_error (bfd_error_bad_value);
8103 ret = FALSE;
8104 }
8105 else
8106 {
8107 asection *osec;
8108
8109 /* We are turning this relocation into one
8110 against a section symbol. It would be
8111 proper to subtract the symbol's value,
8112 osec->vma, from the emitted reloc addend,
8113 but ld.so expects buggy relocs.
8114 FIXME: Why not always use a zero index? */
8115 osec = sec->output_section;
8116 if ((osec->flags & SEC_THREAD_LOCAL) != 0)
8117 {
8118 osec = htab->elf.tls_sec;
8119 indx = 0;
8120 }
8121 else
8122 {
8123 indx = elf_section_data (osec)->dynindx;
8124 if (indx == 0)
8125 {
8126 osec = htab->elf.text_index_section;
8127 indx = elf_section_data (osec)->dynindx;
8128 }
8129 BFD_ASSERT (indx != 0);
8130 }
8131
8132 /* ld.so doesn't expect buggy TLS relocs.
8133 Don't leave the symbol value in the
8134 addend for them. */
8135 if (IS_PPC_TLS_RELOC (r_type))
8136 outrel.r_addend -= osec->vma;
8137 }
8138
8139 outrel.r_info = ELF32_R_INFO (indx, r_type);
8140 }
8141 else if (ifunc != NULL)
8142 outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8143 else
8144 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
8145 }
8146
8147 sreloc = elf_section_data (input_section)->sreloc;
8148 if (ifunc)
8149 {
8150 sreloc = htab->elf.irelplt;
8151 if (indx == 0)
8152 htab->local_ifunc_resolver = 1;
8153 else if (is_static_defined (h))
8154 htab->maybe_local_ifunc_resolver = 1;
8155 }
8156 if (sreloc == NULL)
8157 return FALSE;
8158
8159 loc = sreloc->contents;
8160 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
8161 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
8162
8163 if (skip == -1)
8164 goto copy_reloc;
8165
8166 /* This reloc will be computed at runtime. Clear the memory
8167 so that it contains a predictable value for prelink. */
8168 if (!skip)
8169 {
8170 relocation = howto->pc_relative ? outrel.r_offset : 0;
8171 addend = 0;
8172 break;
8173 }
8174 }
8175 break;
8176
8177 case R_PPC_RELAX_PLT:
8178 case R_PPC_RELAX_PLTREL24:
8179 if (h != NULL)
8180 {
8181 struct plt_entry *ent;
8182 bfd_vma got2_addend = 0;
8183
8184 if (r_type == R_PPC_RELAX_PLTREL24)
8185 {
8186 if (bfd_link_pic (info))
8187 got2_addend = addend;
8188 addend = 0;
8189 }
8190 ent = find_plt_ent (&h->plt.plist, got2, got2_addend);
8191 if (htab->plt_type == PLT_NEW)
8192 relocation = (htab->glink->output_section->vma
8193 + htab->glink->output_offset
8194 + ent->glink_offset);
8195 else
8196 relocation = (htab->elf.splt->output_section->vma
8197 + htab->elf.splt->output_offset
8198 + ent->plt.offset);
8199 }
8200 /* Fall through. */
8201
8202 case R_PPC_RELAX:
8203 {
8204 const int *stub;
8205 size_t size;
8206 size_t insn_offset = rel->r_offset;
8207 unsigned int insn;
8208
8209 if (bfd_link_pic (info))
8210 {
8211 relocation -= (input_section->output_section->vma
8212 + input_section->output_offset
8213 + rel->r_offset - 4);
8214 stub = shared_stub_entry;
8215 bfd_put_32 (input_bfd, stub[0], contents + insn_offset - 12);
8216 bfd_put_32 (input_bfd, stub[1], contents + insn_offset - 8);
8217 bfd_put_32 (input_bfd, stub[2], contents + insn_offset - 4);
8218 stub += 3;
8219 size = ARRAY_SIZE (shared_stub_entry) - 3;
8220 }
8221 else
8222 {
8223 stub = stub_entry;
8224 size = ARRAY_SIZE (stub_entry);
8225 }
8226
8227 relocation += addend;
8228 if (bfd_link_relocatable (info))
8229 relocation = 0;
8230
8231 /* First insn is HA, second is LO. */
8232 insn = *stub++;
8233 insn |= ((relocation + 0x8000) >> 16) & 0xffff;
8234 bfd_put_32 (input_bfd, insn, contents + insn_offset);
8235 insn_offset += 4;
8236
8237 insn = *stub++;
8238 insn |= relocation & 0xffff;
8239 bfd_put_32 (input_bfd, insn, contents + insn_offset);
8240 insn_offset += 4;
8241 size -= 2;
8242
8243 while (size != 0)
8244 {
8245 insn = *stub++;
8246 --size;
8247 bfd_put_32 (input_bfd, insn, contents + insn_offset);
8248 insn_offset += 4;
8249 }
8250
8251 /* Rewrite the reloc and convert one of the trailing nop
8252 relocs to describe this relocation. */
8253 BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE);
8254 /* The relocs are at the bottom 2 bytes */
8255 wrel->r_offset = rel->r_offset + d_offset;
8256 wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
8257 wrel->r_addend = rel->r_addend;
8258 memmove (wrel + 1, wrel, (relend - wrel - 1) * sizeof (*wrel));
8259 wrel++, rel++;
8260 wrel->r_offset += 4;
8261 wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
8262 }
8263 continue;
8264
8265 /* Indirect .sdata relocation. */
8266 case R_PPC_EMB_SDAI16:
8267 BFD_ASSERT (htab->sdata[0].section != NULL);
8268 if (!is_static_defined (htab->sdata[0].sym))
8269 {
8270 unresolved_reloc = TRUE;
8271 break;
8272 }
8273 relocation
8274 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0],
8275 h, relocation, rel);
8276 addend = 0;
8277 break;
8278
8279 /* Indirect .sdata2 relocation. */
8280 case R_PPC_EMB_SDA2I16:
8281 BFD_ASSERT (htab->sdata[1].section != NULL);
8282 if (!is_static_defined (htab->sdata[1].sym))
8283 {
8284 unresolved_reloc = TRUE;
8285 break;
8286 }
8287 relocation
8288 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1],
8289 h, relocation, rel);
8290 addend = 0;
8291 break;
8292
8293 /* Handle the TOC16 reloc. We want to use the offset within the .got
8294 section, not the actual VMA. This is appropriate when generating
8295 an embedded ELF object, for which the .got section acts like the
8296 AIX .toc section. */
8297 case R_PPC_TOC16: /* phony GOT16 relocations */
8298 if (sec == NULL || sec->output_section == NULL)
8299 {
8300 unresolved_reloc = TRUE;
8301 break;
8302 }
8303 BFD_ASSERT (strcmp (bfd_section_name (sec), ".got") == 0
8304 || strcmp (bfd_section_name (sec), ".cgot") == 0);
8305
8306 addend -= sec->output_section->vma + sec->output_offset + 0x8000;
8307 break;
8308
8309 case R_PPC_PLTREL24:
8310 if (h != NULL && ifunc == NULL)
8311 {
8312 struct plt_entry *ent;
8313
8314 ent = find_plt_ent (&h->plt.plist, got2,
8315 bfd_link_pic (info) ? addend : 0);
8316 if (ent == NULL
8317 || htab->elf.splt == NULL)
8318 {
8319 /* We didn't make a PLT entry for this symbol. This
8320 happens when statically linking PIC code, or when
8321 using -Bsymbolic. */
8322 }
8323 else
8324 {
8325 /* Relocation is to the entry for this symbol in the
8326 procedure linkage table. */
8327 unresolved_reloc = FALSE;
8328 if (htab->plt_type == PLT_NEW)
8329 relocation = (htab->glink->output_section->vma
8330 + htab->glink->output_offset
8331 + ent->glink_offset);
8332 else
8333 relocation = (htab->elf.splt->output_section->vma
8334 + htab->elf.splt->output_offset
8335 + ent->plt.offset);
8336 }
8337 }
8338
8339 /* R_PPC_PLTREL24 is rather special. If non-zero, the
8340 addend specifies the GOT pointer offset within .got2.
8341 Don't apply it to the relocation field. */
8342 addend = 0;
8343 break;
8344
8345 case R_PPC_PLTSEQ:
8346 case R_PPC_PLTCALL:
8347 case R_PPC_PLT16_LO:
8348 case R_PPC_PLT16_HI:
8349 case R_PPC_PLT16_HA:
8350 plt_list = NULL;
8351 if (h != NULL)
8352 plt_list = &h->plt.plist;
8353 else if (ifunc != NULL)
8354 plt_list = ifunc;
8355 else if (local_got_offsets != NULL)
8356 {
8357 struct plt_entry **local_plt;
8358 local_plt = (struct plt_entry **) (local_got_offsets
8359 + symtab_hdr->sh_info);
8360 plt_list = local_plt + r_symndx;
8361 }
8362 unresolved_reloc = TRUE;
8363 if (plt_list != NULL)
8364 {
8365 struct plt_entry *ent;
8366
8367 ent = find_plt_ent (plt_list, got2,
8368 bfd_link_pic (info) ? addend : 0);
8369 if (ent != NULL && ent->plt.offset != (bfd_vma) -1)
8370 {
8371 asection *plt;
8372
8373 unresolved_reloc = FALSE;
8374 plt = htab->elf.splt;
8375 if (!htab->elf.dynamic_sections_created
8376 || h == NULL
8377 || h->dynindx == -1)
8378 {
8379 if (ifunc != NULL)
8380 plt = htab->elf.iplt;
8381 else
8382 plt = htab->pltlocal;
8383 }
8384 relocation = (plt->output_section->vma
8385 + plt->output_offset
8386 + ent->plt.offset);
8387 if (bfd_link_pic (info))
8388 {
8389 bfd_vma got = 0;
8390
8391 if (ent->addend >= 32768)
8392 got = (ent->addend
8393 + ent->sec->output_section->vma
8394 + ent->sec->output_offset);
8395 else
8396 got = SYM_VAL (htab->elf.hgot);
8397 relocation -= got;
8398 }
8399 }
8400 }
8401 addend = 0;
8402 break;
8403
8404 /* Relocate against _SDA_BASE_. */
8405 case R_PPC_SDAREL16:
8406 {
8407 const char *name;
8408 struct elf_link_hash_entry *sda = htab->sdata[0].sym;
8409
8410 if (sec == NULL
8411 || sec->output_section == NULL
8412 || !is_static_defined (sda))
8413 {
8414 unresolved_reloc = TRUE;
8415 break;
8416 }
8417 addend -= SYM_VAL (sda);
8418
8419 name = bfd_section_name (sec->output_section);
8420 if (!(strcmp (name, ".sdata") == 0
8421 || strcmp (name, ".sbss") == 0))
8422 {
8423 _bfd_error_handler
8424 /* xgettext:c-format */
8425 (_("%pB: the target (%s) of a %s relocation is "
8426 "in the wrong output section (%s)"),
8427 input_bfd,
8428 sym_name,
8429 howto->name,
8430 name);
8431 }
8432 }
8433 break;
8434
8435 /* Relocate against _SDA2_BASE_. */
8436 case R_PPC_EMB_SDA2REL:
8437 {
8438 const char *name;
8439 struct elf_link_hash_entry *sda = htab->sdata[1].sym;
8440
8441 if (sec == NULL
8442 || sec->output_section == NULL
8443 || !is_static_defined (sda))
8444 {
8445 unresolved_reloc = TRUE;
8446 break;
8447 }
8448 addend -= SYM_VAL (sda);
8449
8450 name = bfd_section_name (sec->output_section);
8451 if (!(strcmp (name, ".sdata2") == 0
8452 || strcmp (name, ".sbss2") == 0))
8453 {
8454 _bfd_error_handler
8455 /* xgettext:c-format */
8456 (_("%pB: the target (%s) of a %s relocation is "
8457 "in the wrong output section (%s)"),
8458 input_bfd,
8459 sym_name,
8460 howto->name,
8461 name);
8462 }
8463 }
8464 break;
8465
8466 case R_PPC_VLE_LO16A:
8467 relocation = relocation + addend;
8468 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8469 contents + rel->r_offset, relocation,
8470 split16a_type, htab->params->vle_reloc_fixup);
8471 goto copy_reloc;
8472
8473 case R_PPC_VLE_LO16D:
8474 relocation = relocation + addend;
8475 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8476 contents + rel->r_offset, relocation,
8477 split16d_type, htab->params->vle_reloc_fixup);
8478 goto copy_reloc;
8479
8480 case R_PPC_VLE_HI16A:
8481 relocation = (relocation + addend) >> 16;
8482 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8483 contents + rel->r_offset, relocation,
8484 split16a_type, htab->params->vle_reloc_fixup);
8485 goto copy_reloc;
8486
8487 case R_PPC_VLE_HI16D:
8488 relocation = (relocation + addend) >> 16;
8489 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8490 contents + rel->r_offset, relocation,
8491 split16d_type, htab->params->vle_reloc_fixup);
8492 goto copy_reloc;
8493
8494 case R_PPC_VLE_HA16A:
8495 relocation = (relocation + addend + 0x8000) >> 16;
8496 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8497 contents + rel->r_offset, relocation,
8498 split16a_type, htab->params->vle_reloc_fixup);
8499 goto copy_reloc;
8500
8501 case R_PPC_VLE_HA16D:
8502 relocation = (relocation + addend + 0x8000) >> 16;
8503 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8504 contents + rel->r_offset, relocation,
8505 split16d_type, htab->params->vle_reloc_fixup);
8506 goto copy_reloc;
8507
8508 /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0. */
8509 case R_PPC_EMB_SDA21:
8510 case R_PPC_VLE_SDA21:
8511 case R_PPC_EMB_RELSDA:
8512 case R_PPC_VLE_SDA21_LO:
8513 {
8514 const char *name;
8515 int reg;
8516 unsigned int insn;
8517 struct elf_link_hash_entry *sda = NULL;
8518
8519 if (sec == NULL || sec->output_section == NULL)
8520 {
8521 unresolved_reloc = TRUE;
8522 break;
8523 }
8524
8525 name = bfd_section_name (sec->output_section);
8526 if (strcmp (name, ".sdata") == 0
8527 || strcmp (name, ".sbss") == 0)
8528 {
8529 reg = 13;
8530 sda = htab->sdata[0].sym;
8531 }
8532 else if (strcmp (name, ".sdata2") == 0
8533 || strcmp (name, ".sbss2") == 0)
8534 {
8535 reg = 2;
8536 sda = htab->sdata[1].sym;
8537 }
8538 else if (strcmp (name, ".PPC.EMB.sdata0") == 0
8539 || strcmp (name, ".PPC.EMB.sbss0") == 0)
8540 {
8541 reg = 0;
8542 }
8543 else
8544 {
8545 _bfd_error_handler
8546 /* xgettext:c-format */
8547 (_("%pB: the target (%s) of a %s relocation is "
8548 "in the wrong output section (%s)"),
8549 input_bfd,
8550 sym_name,
8551 howto->name,
8552 name);
8553
8554 bfd_set_error (bfd_error_bad_value);
8555 ret = FALSE;
8556 goto copy_reloc;
8557 }
8558
8559 if (sda != NULL)
8560 {
8561 if (!is_static_defined (sda))
8562 {
8563 unresolved_reloc = TRUE;
8564 break;
8565 }
8566 addend -= SYM_VAL (sda);
8567 }
8568
8569 if (r_type == R_PPC_EMB_RELSDA)
8570 break;
8571
8572 /* The PowerPC Embedded Application Binary Interface
8573 version 1.0 insanely chose to specify R_PPC_EMB_SDA21
8574 operating on a 24-bit field at r_offset. GNU as and
8575 GNU ld have always assumed R_PPC_EMB_SDA21 operates on
8576 a 32-bit bit insn at r_offset. Cope with object file
8577 producers that possibly comply with the EABI in
8578 generating an odd r_offset for big-endian objects. */
8579 if (r_type == R_PPC_EMB_SDA21)
8580 rel->r_offset &= ~1;
8581
8582 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
8583 if (reg == 0
8584 && (r_type == R_PPC_VLE_SDA21
8585 || r_type == R_PPC_VLE_SDA21_LO))
8586 {
8587 relocation = relocation + addend;
8588 addend = 0;
8589
8590 /* Force e_li insn, keeping RT from original insn. */
8591 insn &= 0x1f << 21;
8592 insn |= 28u << 26;
8593
8594 /* We have an li20 field, bits 17..20, 11..15, 21..31. */
8595 /* Top 4 bits of value to 17..20. */
8596 insn |= (relocation & 0xf0000) >> 5;
8597 /* Next 5 bits of the value to 11..15. */
8598 insn |= (relocation & 0xf800) << 5;
8599 /* And the final 11 bits of the value to bits 21 to 31. */
8600 insn |= relocation & 0x7ff;
8601
8602 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
8603
8604 if (r_type == R_PPC_VLE_SDA21
8605 && ((relocation + 0x80000) & 0xffffffff) > 0x100000)
8606 goto overflow;
8607 goto copy_reloc;
8608 }
8609 /* Fill in register field. */
8610 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
8611 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
8612 }
8613 break;
8614
8615 case R_PPC_VLE_SDAREL_LO16A:
8616 case R_PPC_VLE_SDAREL_LO16D:
8617 case R_PPC_VLE_SDAREL_HI16A:
8618 case R_PPC_VLE_SDAREL_HI16D:
8619 case R_PPC_VLE_SDAREL_HA16A:
8620 case R_PPC_VLE_SDAREL_HA16D:
8621 {
8622 bfd_vma value;
8623 const char *name;
8624 struct elf_link_hash_entry *sda = NULL;
8625
8626 if (sec == NULL || sec->output_section == NULL)
8627 {
8628 unresolved_reloc = TRUE;
8629 break;
8630 }
8631
8632 name = bfd_section_name (sec->output_section);
8633 if (strcmp (name, ".sdata") == 0
8634 || strcmp (name, ".sbss") == 0)
8635 sda = htab->sdata[0].sym;
8636 else if (strcmp (name, ".sdata2") == 0
8637 || strcmp (name, ".sbss2") == 0)
8638 sda = htab->sdata[1].sym;
8639 else
8640 {
8641 _bfd_error_handler
8642 /* xgettext:c-format */
8643 (_("%pB: the target (%s) of a %s relocation is "
8644 "in the wrong output section (%s)"),
8645 input_bfd,
8646 sym_name,
8647 howto->name,
8648 name);
8649
8650 bfd_set_error (bfd_error_bad_value);
8651 ret = FALSE;
8652 goto copy_reloc;
8653 }
8654
8655 if (sda == NULL || !is_static_defined (sda))
8656 {
8657 unresolved_reloc = TRUE;
8658 break;
8659 }
8660 value = relocation + addend - SYM_VAL (sda);
8661
8662 if (r_type == R_PPC_VLE_SDAREL_LO16A)
8663 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8664 contents + rel->r_offset, value,
8665 split16a_type,
8666 htab->params->vle_reloc_fixup);
8667 else if (r_type == R_PPC_VLE_SDAREL_LO16D)
8668 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8669 contents + rel->r_offset, value,
8670 split16d_type,
8671 htab->params->vle_reloc_fixup);
8672 else if (r_type == R_PPC_VLE_SDAREL_HI16A)
8673 {
8674 value = value >> 16;
8675 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8676 contents + rel->r_offset, value,
8677 split16a_type,
8678 htab->params->vle_reloc_fixup);
8679 }
8680 else if (r_type == R_PPC_VLE_SDAREL_HI16D)
8681 {
8682 value = value >> 16;
8683 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8684 contents + rel->r_offset, value,
8685 split16d_type,
8686 htab->params->vle_reloc_fixup);
8687 }
8688 else if (r_type == R_PPC_VLE_SDAREL_HA16A)
8689 {
8690 value = (value + 0x8000) >> 16;
8691 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8692 contents + rel->r_offset, value,
8693 split16a_type,
8694 htab->params->vle_reloc_fixup);
8695 }
8696 else if (r_type == R_PPC_VLE_SDAREL_HA16D)
8697 {
8698 value = (value + 0x8000) >> 16;
8699 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8700 contents + rel->r_offset, value,
8701 split16d_type,
8702 htab->params->vle_reloc_fixup);
8703 }
8704 }
8705 goto copy_reloc;
8706
8707 case R_PPC_VLE_ADDR20:
8708 ppc_elf_vle_split20 (output_bfd, contents + rel->r_offset, relocation);
8709 goto copy_reloc;
8710
8711 /* Relocate against the beginning of the section. */
8712 case R_PPC_SECTOFF:
8713 case R_PPC_SECTOFF_LO:
8714 case R_PPC_SECTOFF_HI:
8715 case R_PPC_SECTOFF_HA:
8716 if (sec == NULL || sec->output_section == NULL)
8717 {
8718 unresolved_reloc = TRUE;
8719 break;
8720 }
8721 addend -= sec->output_section->vma;
8722 break;
8723
8724 /* Negative relocations. */
8725 case R_PPC_EMB_NADDR32:
8726 case R_PPC_EMB_NADDR16:
8727 case R_PPC_EMB_NADDR16_LO:
8728 case R_PPC_EMB_NADDR16_HI:
8729 case R_PPC_EMB_NADDR16_HA:
8730 addend -= 2 * relocation;
8731 break;
8732
8733 case R_PPC_COPY:
8734 case R_PPC_GLOB_DAT:
8735 case R_PPC_JMP_SLOT:
8736 case R_PPC_RELATIVE:
8737 case R_PPC_IRELATIVE:
8738 case R_PPC_PLT32:
8739 case R_PPC_PLTREL32:
8740 case R_PPC_ADDR30:
8741 case R_PPC_EMB_RELSEC16:
8742 case R_PPC_EMB_RELST_LO:
8743 case R_PPC_EMB_RELST_HI:
8744 case R_PPC_EMB_RELST_HA:
8745 case R_PPC_EMB_BIT_FLD:
8746 /* xgettext:c-format */
8747 _bfd_error_handler (_("%pB: %s unsupported"),
8748 input_bfd, howto->name);
8749
8750 bfd_set_error (bfd_error_invalid_operation);
8751 ret = FALSE;
8752 goto copy_reloc;
8753 }
8754
8755 switch (r_type)
8756 {
8757 default:
8758 break;
8759
8760 case R_PPC_PLTCALL:
8761 if (unresolved_reloc)
8762 {
8763 bfd_byte *p = contents + rel->r_offset;
8764 unsigned int insn = bfd_get_32 (input_bfd, p);
8765 insn &= 1;
8766 bfd_put_32 (input_bfd, B | insn, p);
8767 unresolved_reloc = save_unresolved_reloc;
8768 r_type = R_PPC_REL24;
8769 howto = ppc_elf_howto_table[r_type];
8770 }
8771 else if (htab->plt_type != PLT_NEW)
8772 info->callbacks->einfo
8773 (_("%X%P: %H: %s relocation unsupported for bss-plt\n"),
8774 input_bfd, input_section, rel->r_offset,
8775 howto->name);
8776 break;
8777
8778 case R_PPC_PLTSEQ:
8779 case R_PPC_PLT16_HA:
8780 case R_PPC_PLT16_LO:
8781 if (unresolved_reloc)
8782 {
8783 bfd_byte *p = contents + (rel->r_offset & ~3);
8784 bfd_put_32 (input_bfd, NOP, p);
8785 unresolved_reloc = FALSE;
8786 r_type = R_PPC_NONE;
8787 howto = ppc_elf_howto_table[r_type];
8788 }
8789 else if (htab->plt_type != PLT_NEW)
8790 info->callbacks->einfo
8791 (_("%X%P: %H: %s relocation unsupported for bss-plt\n"),
8792 input_bfd, input_section, rel->r_offset,
8793 howto->name);
8794 break;
8795 }
8796
8797 /* Do any further special processing. */
8798 switch (r_type)
8799 {
8800 default:
8801 break;
8802
8803 case R_PPC_ADDR16_HA:
8804 case R_PPC_REL16_HA:
8805 case R_PPC_REL16DX_HA:
8806 case R_PPC_SECTOFF_HA:
8807 case R_PPC_TPREL16_HA:
8808 case R_PPC_DTPREL16_HA:
8809 case R_PPC_EMB_NADDR16_HA:
8810 case R_PPC_EMB_RELST_HA:
8811 /* It's just possible that this symbol is a weak symbol
8812 that's not actually defined anywhere. In that case,
8813 'sec' would be NULL, and we should leave the symbol
8814 alone (it will be set to zero elsewhere in the link). */
8815 if (sec == NULL)
8816 break;
8817 /* Fall through. */
8818
8819 case R_PPC_PLT16_HA:
8820 case R_PPC_GOT16_HA:
8821 case R_PPC_GOT_TLSGD16_HA:
8822 case R_PPC_GOT_TLSLD16_HA:
8823 case R_PPC_GOT_TPREL16_HA:
8824 case R_PPC_GOT_DTPREL16_HA:
8825 /* Add 0x10000 if sign bit in 0:15 is set.
8826 Bits 0:15 are not used. */
8827 addend += 0x8000;
8828 break;
8829
8830 case R_PPC_ADDR16:
8831 case R_PPC_ADDR16_LO:
8832 case R_PPC_GOT16:
8833 case R_PPC_GOT16_LO:
8834 case R_PPC_SDAREL16:
8835 case R_PPC_SECTOFF:
8836 case R_PPC_SECTOFF_LO:
8837 case R_PPC_DTPREL16:
8838 case R_PPC_DTPREL16_LO:
8839 case R_PPC_TPREL16:
8840 case R_PPC_TPREL16_LO:
8841 case R_PPC_GOT_TLSGD16:
8842 case R_PPC_GOT_TLSGD16_LO:
8843 case R_PPC_GOT_TLSLD16:
8844 case R_PPC_GOT_TLSLD16_LO:
8845 case R_PPC_GOT_DTPREL16:
8846 case R_PPC_GOT_DTPREL16_LO:
8847 case R_PPC_GOT_TPREL16:
8848 case R_PPC_GOT_TPREL16_LO:
8849 {
8850 /* The 32-bit ABI lacks proper relocations to deal with
8851 certain 64-bit instructions. Prevent damage to bits
8852 that make up part of the insn opcode. */
8853 unsigned int insn, mask, lobit;
8854
8855 insn = bfd_get_32 (input_bfd,
8856 contents + rel->r_offset - d_offset);
8857 mask = 0;
8858 if (is_insn_ds_form (insn))
8859 mask = 3;
8860 else if (is_insn_dq_form (insn))
8861 mask = 15;
8862 else
8863 break;
8864 relocation += addend;
8865 addend = insn & mask;
8866 lobit = mask & relocation;
8867 if (lobit != 0)
8868 {
8869 relocation ^= lobit;
8870 info->callbacks->einfo
8871 /* xgettext:c-format */
8872 (_("%H: error: %s against `%s' not a multiple of %u\n"),
8873 input_bfd, input_section, rel->r_offset,
8874 howto->name, sym_name, mask + 1);
8875 bfd_set_error (bfd_error_bad_value);
8876 ret = FALSE;
8877 }
8878 }
8879 break;
8880 }
8881
8882 #ifdef DEBUG
8883 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, "
8884 "offset = %ld, addend = %ld\n",
8885 howto->name,
8886 (int) r_type,
8887 sym_name,
8888 r_symndx,
8889 (long) rel->r_offset,
8890 (long) addend);
8891 #endif
8892
8893 if (unresolved_reloc
8894 && !((input_section->flags & SEC_DEBUGGING) != 0
8895 && h->def_dynamic)
8896 && _bfd_elf_section_offset (output_bfd, info, input_section,
8897 rel->r_offset) != (bfd_vma) -1)
8898 {
8899 info->callbacks->einfo
8900 /* xgettext:c-format */
8901 (_("%H: unresolvable %s relocation against symbol `%s'\n"),
8902 input_bfd, input_section, rel->r_offset,
8903 howto->name,
8904 sym_name);
8905 ret = FALSE;
8906 }
8907
8908 /* 16-bit fields in insns mostly have signed values, but a
8909 few insns have 16-bit unsigned values. Really, we should
8910 have different reloc types. */
8911 if (howto->complain_on_overflow != complain_overflow_dont
8912 && howto->dst_mask == 0xffff
8913 && (input_section->flags & SEC_CODE) != 0)
8914 {
8915 enum complain_overflow complain = complain_overflow_signed;
8916
8917 if ((elf_section_flags (input_section) & SHF_PPC_VLE) == 0)
8918 {
8919 unsigned int insn;
8920
8921 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
8922 if ((insn & (0x3fu << 26)) == 10u << 26 /* cmpli */)
8923 complain = complain_overflow_bitfield;
8924 else if ((insn & (0x3fu << 26)) == 28u << 26 /* andi */
8925 || (insn & (0x3fu << 26)) == 24u << 26 /* ori */
8926 || (insn & (0x3fu << 26)) == 26u << 26 /* xori */)
8927 complain = complain_overflow_unsigned;
8928 }
8929 if (howto->complain_on_overflow != complain)
8930 {
8931 alt_howto = *howto;
8932 alt_howto.complain_on_overflow = complain;
8933 howto = &alt_howto;
8934 }
8935 }
8936
8937 if (r_type == R_PPC_REL16DX_HA)
8938 {
8939 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
8940 if (rel->r_offset + 4 > input_section->size)
8941 r = bfd_reloc_outofrange;
8942 else
8943 {
8944 unsigned int insn;
8945
8946 relocation += addend;
8947 relocation -= (rel->r_offset
8948 + input_section->output_offset
8949 + input_section->output_section->vma);
8950 relocation >>= 16;
8951 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
8952 insn &= ~0x1fffc1;
8953 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
8954 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
8955 r = bfd_reloc_ok;
8956 }
8957 }
8958 else
8959 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
8960 rel->r_offset, relocation, addend);
8961
8962 if (r != bfd_reloc_ok)
8963 {
8964 if (r == bfd_reloc_overflow)
8965 {
8966 overflow:
8967 /* On code like "if (foo) foo();" don't report overflow
8968 on a branch to zero when foo is undefined. */
8969 if (!warned
8970 && !(h != NULL
8971 && (h->root.type == bfd_link_hash_undefweak
8972 || h->root.type == bfd_link_hash_undefined)
8973 && is_branch_reloc (r_type)))
8974 info->callbacks->reloc_overflow
8975 (info, (h ? &h->root : NULL), sym_name, howto->name,
8976 rel->r_addend, input_bfd, input_section, rel->r_offset);
8977 }
8978 else
8979 {
8980 info->callbacks->einfo
8981 /* xgettext:c-format */
8982 (_("%H: %s reloc against `%s': error %d\n"),
8983 input_bfd, input_section, rel->r_offset,
8984 howto->name, sym_name, (int) r);
8985 ret = FALSE;
8986 }
8987 }
8988 copy_reloc:
8989 if (wrel != rel)
8990 *wrel = *rel;
8991 }
8992
8993 if (wrel != rel)
8994 {
8995 Elf_Internal_Shdr *rel_hdr;
8996 size_t deleted = rel - wrel;
8997
8998 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
8999 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9000 if (rel_hdr->sh_size == 0)
9001 {
9002 /* It is too late to remove an empty reloc section. Leave
9003 one NONE reloc.
9004 ??? What is wrong with an empty section??? */
9005 rel_hdr->sh_size = rel_hdr->sh_entsize;
9006 deleted -= 1;
9007 wrel++;
9008 }
9009 relend = wrel;
9010 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
9011 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9012 input_section->reloc_count -= deleted;
9013 }
9014
9015 #ifdef DEBUG
9016 fprintf (stderr, "\n");
9017 #endif
9018
9019 if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9020 && input_section->size != input_section->rawsize
9021 && (strcmp (input_section->output_section->name, ".init") == 0
9022 || strcmp (input_section->output_section->name, ".fini") == 0))
9023 {
9024 /* Branch around the trampolines. */
9025 unsigned int insn = B + input_section->size - input_section->rawsize;
9026 bfd_put_32 (input_bfd, insn, contents + input_section->rawsize);
9027 }
9028
9029 if (htab->params->ppc476_workaround
9030 && input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9031 && (!bfd_link_relocatable (info)
9032 || (input_section->output_section->alignment_power
9033 >= htab->params->pagesize_p2)))
9034 {
9035 bfd_vma start_addr, end_addr, addr;
9036 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
9037
9038 if (relax_info->workaround_size != 0)
9039 {
9040 bfd_byte *p;
9041 unsigned int n;
9042 bfd_byte fill[4];
9043
9044 bfd_put_32 (input_bfd, BA, fill);
9045 p = contents + input_section->size - relax_info->workaround_size;
9046 n = relax_info->workaround_size >> 2;
9047 while (n--)
9048 {
9049 memcpy (p, fill, 4);
9050 p += 4;
9051 }
9052 }
9053
9054 /* The idea is: Replace the last instruction on a page with a
9055 branch to a patch area. Put the insn there followed by a
9056 branch back to the next page. Complicated a little by
9057 needing to handle moved conditional branches, and by not
9058 wanting to touch data-in-text. */
9059
9060 start_addr = (input_section->output_section->vma
9061 + input_section->output_offset);
9062 end_addr = (start_addr + input_section->size
9063 - relax_info->workaround_size);
9064 for (addr = ((start_addr & -pagesize) + pagesize - 4);
9065 addr < end_addr;
9066 addr += pagesize)
9067 {
9068 bfd_vma offset = addr - start_addr;
9069 Elf_Internal_Rela *lo, *hi;
9070 bfd_boolean is_data;
9071 bfd_vma patch_off, patch_addr;
9072 unsigned int insn;
9073
9074 /* Do we have a data reloc at this offset? If so, leave
9075 the word alone. */
9076 is_data = FALSE;
9077 lo = relocs;
9078 hi = relend;
9079 rel = NULL;
9080 while (lo < hi)
9081 {
9082 rel = lo + (hi - lo) / 2;
9083 if (rel->r_offset < offset)
9084 lo = rel + 1;
9085 else if (rel->r_offset > offset + 3)
9086 hi = rel;
9087 else
9088 {
9089 switch (ELF32_R_TYPE (rel->r_info))
9090 {
9091 case R_PPC_ADDR32:
9092 case R_PPC_UADDR32:
9093 case R_PPC_REL32:
9094 case R_PPC_ADDR30:
9095 is_data = TRUE;
9096 break;
9097 default:
9098 break;
9099 }
9100 break;
9101 }
9102 }
9103 if (is_data)
9104 continue;
9105
9106 /* Some instructions can be left alone too. Unconditional
9107 branches, except for bcctr with BO=0x14 (bctr, bctrl),
9108 avoid the icache failure.
9109
9110 The problem occurs due to prefetch across a page boundary
9111 where stale instructions can be fetched from the next
9112 page, and the mechanism for flushing these bad
9113 instructions fails under certain circumstances. The
9114 unconditional branches:
9115 1) Branch: b, bl, ba, bla,
9116 2) Branch Conditional: bc, bca, bcl, bcla,
9117 3) Branch Conditional to Link Register: bclr, bclrl,
9118 where (2) and (3) have BO=0x14 making them unconditional,
9119 prevent the bad prefetch because the prefetch itself is
9120 affected by these instructions. This happens even if the
9121 instruction is not executed.
9122
9123 A bctr example:
9124 .
9125 . lis 9,new_page@ha
9126 . addi 9,9,new_page@l
9127 . mtctr 9
9128 . bctr
9129 . nop
9130 . nop
9131 . new_page:
9132 .
9133 The bctr is not predicted taken due to ctr not being
9134 ready, so prefetch continues on past the bctr into the
9135 new page which might have stale instructions. If they
9136 fail to be flushed, then they will be executed after the
9137 bctr executes. Either of the following modifications
9138 prevent the bad prefetch from happening in the first
9139 place:
9140 .
9141 . lis 9,new_page@ha lis 9,new_page@ha
9142 . addi 9,9,new_page@l addi 9,9,new_page@l
9143 . mtctr 9 mtctr 9
9144 . bctr bctr
9145 . nop b somewhere_else
9146 . b somewhere_else nop
9147 . new_page: new_page:
9148 . */
9149 insn = bfd_get_32 (input_bfd, contents + offset);
9150 if ((insn & (0x3fu << 26)) == (18u << 26) /* b,bl,ba,bla */
9151 || ((insn & (0x3fu << 26)) == (16u << 26) /* bc,bcl,bca,bcla*/
9152 && (insn & (0x14 << 21)) == (0x14 << 21)) /* with BO=0x14 */
9153 || ((insn & (0x3fu << 26)) == (19u << 26)
9154 && (insn & (0x3ff << 1)) == (16u << 1) /* bclr,bclrl */
9155 && (insn & (0x14 << 21)) == (0x14 << 21)))/* with BO=0x14 */
9156 continue;
9157
9158 patch_addr = (start_addr + input_section->size
9159 - relax_info->workaround_size);
9160 patch_addr = (patch_addr + 15) & -16;
9161 patch_off = patch_addr - start_addr;
9162 bfd_put_32 (input_bfd, B + patch_off - offset, contents + offset);
9163
9164 if (rel != NULL
9165 && rel->r_offset >= offset
9166 && rel->r_offset < offset + 4)
9167 {
9168 asection *sreloc;
9169
9170 /* If the insn we are patching had a reloc, adjust the
9171 reloc r_offset so that the reloc applies to the moved
9172 location. This matters for -r and --emit-relocs. */
9173 if (rel + 1 != relend)
9174 {
9175 Elf_Internal_Rela tmp = *rel;
9176
9177 /* Keep the relocs sorted by r_offset. */
9178 memmove (rel, rel + 1, (relend - (rel + 1)) * sizeof (*rel));
9179 relend[-1] = tmp;
9180 }
9181 relend[-1].r_offset += patch_off - offset;
9182
9183 /* Adjust REL16 addends too. */
9184 switch (ELF32_R_TYPE (relend[-1].r_info))
9185 {
9186 case R_PPC_REL16:
9187 case R_PPC_REL16_LO:
9188 case R_PPC_REL16_HI:
9189 case R_PPC_REL16_HA:
9190 relend[-1].r_addend += patch_off - offset;
9191 break;
9192 default:
9193 break;
9194 }
9195
9196 /* If we are building a PIE or shared library with
9197 non-PIC objects, perhaps we had a dynamic reloc too?
9198 If so, the dynamic reloc must move with the insn. */
9199 sreloc = elf_section_data (input_section)->sreloc;
9200 if (sreloc != NULL)
9201 {
9202 Elf32_External_Rela *slo, *shi, *srelend;
9203 bfd_vma soffset;
9204
9205 slo = (Elf32_External_Rela *) sreloc->contents;
9206 shi = srelend = slo + sreloc->reloc_count;
9207 soffset = (offset + input_section->output_section->vma
9208 + input_section->output_offset);
9209 while (slo < shi)
9210 {
9211 Elf32_External_Rela *srel = slo + (shi - slo) / 2;
9212 bfd_elf32_swap_reloca_in (output_bfd, (bfd_byte *) srel,
9213 &outrel);
9214 if (outrel.r_offset < soffset)
9215 slo = srel + 1;
9216 else if (outrel.r_offset > soffset + 3)
9217 shi = srel;
9218 else
9219 {
9220 if (srel + 1 != srelend)
9221 {
9222 memmove (srel, srel + 1,
9223 (srelend - (srel + 1)) * sizeof (*srel));
9224 srel = srelend - 1;
9225 }
9226 outrel.r_offset += patch_off - offset;
9227 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
9228 (bfd_byte *) srel);
9229 break;
9230 }
9231 }
9232 }
9233 }
9234 else
9235 rel = NULL;
9236
9237 if ((insn & (0x3fu << 26)) == (16u << 26) /* bc */
9238 && (insn & 2) == 0 /* relative */)
9239 {
9240 bfd_vma delta = ((insn & 0xfffc) ^ 0x8000) - 0x8000;
9241
9242 delta += offset - patch_off;
9243 if (bfd_link_relocatable (info) && rel != NULL)
9244 delta = 0;
9245 if (!bfd_link_relocatable (info) && rel != NULL)
9246 {
9247 enum elf_ppc_reloc_type r_type;
9248
9249 r_type = ELF32_R_TYPE (relend[-1].r_info);
9250 if (r_type == R_PPC_REL14_BRTAKEN)
9251 insn |= BRANCH_PREDICT_BIT;
9252 else if (r_type == R_PPC_REL14_BRNTAKEN)
9253 insn &= ~BRANCH_PREDICT_BIT;
9254 else
9255 BFD_ASSERT (r_type == R_PPC_REL14);
9256
9257 if ((r_type == R_PPC_REL14_BRTAKEN
9258 || r_type == R_PPC_REL14_BRNTAKEN)
9259 && delta + 0x8000 < 0x10000
9260 && (bfd_signed_vma) delta < 0)
9261 insn ^= BRANCH_PREDICT_BIT;
9262 }
9263 if (delta + 0x8000 < 0x10000)
9264 {
9265 bfd_put_32 (input_bfd,
9266 (insn & ~0xfffc) | (delta & 0xfffc),
9267 contents + patch_off);
9268 patch_off += 4;
9269 bfd_put_32 (input_bfd,
9270 B | ((offset + 4 - patch_off) & 0x3fffffc),
9271 contents + patch_off);
9272 patch_off += 4;
9273 }
9274 else
9275 {
9276 if (rel != NULL)
9277 {
9278 unsigned int r_sym = ELF32_R_SYM (relend[-1].r_info);
9279
9280 relend[-1].r_offset += 8;
9281 relend[-1].r_info = ELF32_R_INFO (r_sym, R_PPC_REL24);
9282 }
9283 bfd_put_32 (input_bfd,
9284 (insn & ~0xfffc) | 8,
9285 contents + patch_off);
9286 patch_off += 4;
9287 bfd_put_32 (input_bfd,
9288 B | ((offset + 4 - patch_off) & 0x3fffffc),
9289 contents + patch_off);
9290 patch_off += 4;
9291 bfd_put_32 (input_bfd,
9292 B | ((delta - 8) & 0x3fffffc),
9293 contents + patch_off);
9294 patch_off += 4;
9295 }
9296 }
9297 else
9298 {
9299 bfd_put_32 (input_bfd, insn, contents + patch_off);
9300 patch_off += 4;
9301 bfd_put_32 (input_bfd,
9302 B | ((offset + 4 - patch_off) & 0x3fffffc),
9303 contents + patch_off);
9304 patch_off += 4;
9305 }
9306 BFD_ASSERT (patch_off <= input_section->size);
9307 relax_info->workaround_size = input_section->size - patch_off;
9308 }
9309 }
9310
9311 return ret;
9312 }
9313 \f
9314 /* Write out the PLT relocs and entries for H. */
9315
9316 static bfd_boolean
9317 write_global_sym_plt (struct elf_link_hash_entry *h, void *inf)
9318 {
9319 struct bfd_link_info *info = (struct bfd_link_info *) inf;
9320 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9321 struct plt_entry *ent;
9322 bfd_boolean doneone;
9323
9324 doneone = FALSE;
9325 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
9326 if (ent->plt.offset != (bfd_vma) -1)
9327 {
9328 if (!doneone)
9329 {
9330 Elf_Internal_Rela rela;
9331 bfd_byte *loc;
9332 bfd_vma reloc_index;
9333 asection *plt = htab->elf.splt;
9334 asection *relplt = htab->elf.srelplt;
9335
9336 if (htab->plt_type == PLT_NEW
9337 || !htab->elf.dynamic_sections_created
9338 || h->dynindx == -1)
9339 reloc_index = ent->plt.offset / 4;
9340 else
9341 {
9342 reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size)
9343 / htab->plt_slot_size);
9344 if (reloc_index > PLT_NUM_SINGLE_ENTRIES
9345 && htab->plt_type == PLT_OLD)
9346 reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
9347 }
9348
9349 /* This symbol has an entry in the procedure linkage table.
9350 Set it up. */
9351 if (htab->plt_type == PLT_VXWORKS
9352 && htab->elf.dynamic_sections_created
9353 && h->dynindx != -1)
9354 {
9355 bfd_vma got_offset;
9356 const bfd_vma *plt_entry;
9357
9358 /* The first three entries in .got.plt are reserved. */
9359 got_offset = (reloc_index + 3) * 4;
9360
9361 /* Use the right PLT. */
9362 plt_entry = bfd_link_pic (info) ? ppc_elf_vxworks_pic_plt_entry
9363 : ppc_elf_vxworks_plt_entry;
9364
9365 /* Fill in the .plt on VxWorks. */
9366 if (bfd_link_pic (info))
9367 {
9368 bfd_put_32 (info->output_bfd,
9369 plt_entry[0] | PPC_HA (got_offset),
9370 plt->contents + ent->plt.offset + 0);
9371 bfd_put_32 (info->output_bfd,
9372 plt_entry[1] | PPC_LO (got_offset),
9373 plt->contents + ent->plt.offset + 4);
9374 }
9375 else
9376 {
9377 bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot);
9378
9379 bfd_put_32 (info->output_bfd,
9380 plt_entry[0] | PPC_HA (got_loc),
9381 plt->contents + ent->plt.offset + 0);
9382 bfd_put_32 (info->output_bfd,
9383 plt_entry[1] | PPC_LO (got_loc),
9384 plt->contents + ent->plt.offset + 4);
9385 }
9386
9387 bfd_put_32 (info->output_bfd, plt_entry[2],
9388 plt->contents + ent->plt.offset + 8);
9389 bfd_put_32 (info->output_bfd, plt_entry[3],
9390 plt->contents + ent->plt.offset + 12);
9391
9392 /* This instruction is an immediate load. The value loaded is
9393 the byte offset of the R_PPC_JMP_SLOT relocation from the
9394 start of the .rela.plt section. The value is stored in the
9395 low-order 16 bits of the load instruction. */
9396 /* NOTE: It appears that this is now an index rather than a
9397 prescaled offset. */
9398 bfd_put_32 (info->output_bfd,
9399 plt_entry[4] | reloc_index,
9400 plt->contents + ent->plt.offset + 16);
9401 /* This instruction is a PC-relative branch whose target is
9402 the start of the PLT section. The address of this branch
9403 instruction is 20 bytes beyond the start of this PLT entry.
9404 The address is encoded in bits 6-29, inclusive. The value
9405 stored is right-shifted by two bits, permitting a 26-bit
9406 offset. */
9407 bfd_put_32 (info->output_bfd,
9408 (plt_entry[5]
9409 | (-(ent->plt.offset + 20) & 0x03fffffc)),
9410 plt->contents + ent->plt.offset + 20);
9411 bfd_put_32 (info->output_bfd, plt_entry[6],
9412 plt->contents + ent->plt.offset + 24);
9413 bfd_put_32 (info->output_bfd, plt_entry[7],
9414 plt->contents + ent->plt.offset + 28);
9415
9416 /* Fill in the GOT entry corresponding to this PLT slot with
9417 the address immediately after the "bctr" instruction
9418 in this PLT entry. */
9419 bfd_put_32 (info->output_bfd, (plt->output_section->vma
9420 + plt->output_offset
9421 + ent->plt.offset + 16),
9422 htab->elf.sgotplt->contents + got_offset);
9423
9424 if (!bfd_link_pic (info))
9425 {
9426 /* Fill in a couple of entries in .rela.plt.unloaded. */
9427 loc = htab->srelplt2->contents
9428 + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index
9429 * VXWORKS_PLT_NON_JMP_SLOT_RELOCS)
9430 * sizeof (Elf32_External_Rela));
9431
9432 /* Provide the @ha relocation for the first instruction. */
9433 rela.r_offset = (plt->output_section->vma
9434 + plt->output_offset
9435 + ent->plt.offset + 2);
9436 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9437 R_PPC_ADDR16_HA);
9438 rela.r_addend = got_offset;
9439 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9440 loc += sizeof (Elf32_External_Rela);
9441
9442 /* Provide the @l relocation for the second instruction. */
9443 rela.r_offset = (plt->output_section->vma
9444 + plt->output_offset
9445 + ent->plt.offset + 6);
9446 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9447 R_PPC_ADDR16_LO);
9448 rela.r_addend = got_offset;
9449 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9450 loc += sizeof (Elf32_External_Rela);
9451
9452 /* Provide a relocation for the GOT entry corresponding to this
9453 PLT slot. Point it at the middle of the .plt entry. */
9454 rela.r_offset = (htab->elf.sgotplt->output_section->vma
9455 + htab->elf.sgotplt->output_offset
9456 + got_offset);
9457 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
9458 R_PPC_ADDR32);
9459 rela.r_addend = ent->plt.offset + 16;
9460 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9461 }
9462
9463 /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT.
9464 In particular, the offset for the relocation is not the
9465 address of the PLT entry for this function, as specified
9466 by the ABI. Instead, the offset is set to the address of
9467 the GOT slot for this function. See EABI 4.4.4.1. */
9468 rela.r_offset = (htab->elf.sgotplt->output_section->vma
9469 + htab->elf.sgotplt->output_offset
9470 + got_offset);
9471 rela.r_addend = 0;
9472 }
9473 else
9474 {
9475 rela.r_addend = 0;
9476 if (!htab->elf.dynamic_sections_created
9477 || h->dynindx == -1)
9478 {
9479 if (h->type == STT_GNU_IFUNC)
9480 {
9481 plt = htab->elf.iplt;
9482 relplt = htab->elf.irelplt;
9483 }
9484 else
9485 {
9486 plt = htab->pltlocal;
9487 relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
9488 }
9489 if (h->def_regular
9490 && (h->root.type == bfd_link_hash_defined
9491 || h->root.type == bfd_link_hash_defweak))
9492 rela.r_addend = SYM_VAL (h);
9493 }
9494
9495 if (relplt == NULL)
9496 {
9497 loc = plt->contents + ent->plt.offset;
9498 bfd_put_32 (info->output_bfd, rela.r_addend, loc);
9499 }
9500 else
9501 {
9502 rela.r_offset = (plt->output_section->vma
9503 + plt->output_offset
9504 + ent->plt.offset);
9505
9506 if (htab->plt_type == PLT_OLD
9507 || !htab->elf.dynamic_sections_created
9508 || h->dynindx == -1)
9509 {
9510 /* We don't need to fill in the .plt. The ppc dynamic
9511 linker will fill it in. */
9512 }
9513 else
9514 {
9515 bfd_vma val = (htab->glink_pltresolve + ent->plt.offset
9516 + htab->glink->output_section->vma
9517 + htab->glink->output_offset);
9518 bfd_put_32 (info->output_bfd, val,
9519 plt->contents + ent->plt.offset);
9520 }
9521 }
9522 }
9523
9524 if (relplt != NULL)
9525 {
9526 /* Fill in the entry in the .rela.plt section. */
9527 if (!htab->elf.dynamic_sections_created
9528 || h->dynindx == -1)
9529 {
9530 if (h->type == STT_GNU_IFUNC)
9531 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
9532 else
9533 rela.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
9534 loc = relplt->contents + (relplt->reloc_count++
9535 * sizeof (Elf32_External_Rela));
9536 htab->local_ifunc_resolver = 1;
9537 }
9538 else
9539 {
9540 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
9541 loc = relplt->contents + (reloc_index
9542 * sizeof (Elf32_External_Rela));
9543 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
9544 htab->maybe_local_ifunc_resolver = 1;
9545 }
9546 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9547 }
9548 doneone = TRUE;
9549 }
9550
9551 if (htab->plt_type == PLT_NEW
9552 || !htab->elf.dynamic_sections_created
9553 || h->dynindx == -1)
9554 {
9555 unsigned char *p;
9556 asection *plt = htab->elf.splt;
9557
9558 if (!htab->elf.dynamic_sections_created
9559 || h->dynindx == -1)
9560 {
9561 if (h->type == STT_GNU_IFUNC)
9562 plt = htab->elf.iplt;
9563 else
9564 break;
9565 }
9566
9567 p = (unsigned char *) htab->glink->contents + ent->glink_offset;
9568 write_glink_stub (h, ent, plt, p, info);
9569
9570 if (!bfd_link_pic (info))
9571 /* We only need one non-PIC glink stub. */
9572 break;
9573 }
9574 else
9575 break;
9576 }
9577 return TRUE;
9578 }
9579
9580 /* Finish up PLT handling. */
9581
9582 bfd_boolean
9583 ppc_finish_symbols (struct bfd_link_info *info)
9584 {
9585 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9586 bfd *ibfd;
9587
9588 if (!htab)
9589 return TRUE;
9590
9591 elf_link_hash_traverse (&htab->elf, write_global_sym_plt, info);
9592
9593 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9594 {
9595 bfd_vma *local_got, *end_local_got;
9596 struct plt_entry **local_plt, **lplt, **end_local_plt;
9597 Elf_Internal_Shdr *symtab_hdr;
9598 bfd_size_type locsymcount;
9599 Elf_Internal_Sym *local_syms = NULL;
9600 struct plt_entry *ent;
9601
9602 if (!is_ppc_elf (ibfd))
9603 continue;
9604
9605 local_got = elf_local_got_offsets (ibfd);
9606 if (!local_got)
9607 continue;
9608
9609 symtab_hdr = &elf_symtab_hdr (ibfd);
9610 locsymcount = symtab_hdr->sh_info;
9611 end_local_got = local_got + locsymcount;
9612 local_plt = (struct plt_entry **) end_local_got;
9613 end_local_plt = local_plt + locsymcount;
9614 for (lplt = local_plt; lplt < end_local_plt; ++lplt)
9615 for (ent = *lplt; ent != NULL; ent = ent->next)
9616 {
9617 if (ent->plt.offset != (bfd_vma) -1)
9618 {
9619 Elf_Internal_Sym *sym;
9620 asection *sym_sec;
9621 asection *plt, *relplt;
9622 bfd_byte *loc;
9623 bfd_vma val;
9624 Elf_Internal_Rela rela;
9625 unsigned char *p;
9626
9627 if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
9628 lplt - local_plt, ibfd))
9629 {
9630 if (symtab_hdr->contents != (unsigned char *) local_syms)
9631 free (local_syms);
9632 return FALSE;
9633 }
9634
9635 val = sym->st_value;
9636 if (sym_sec != NULL && sym_sec->output_section != NULL)
9637 val += sym_sec->output_offset + sym_sec->output_section->vma;
9638
9639 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9640 {
9641 htab->local_ifunc_resolver = 1;
9642 plt = htab->elf.iplt;
9643 relplt = htab->elf.irelplt;
9644 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
9645 }
9646 else
9647 {
9648 plt = htab->pltlocal;
9649 if (bfd_link_pic (info))
9650 {
9651 relplt = htab->relpltlocal;
9652 rela.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
9653 }
9654 else
9655 {
9656 loc = plt->contents + ent->plt.offset;
9657 bfd_put_32 (info->output_bfd, val, loc);
9658 continue;
9659 }
9660 }
9661
9662 rela.r_offset = (ent->plt.offset
9663 + plt->output_offset
9664 + plt->output_section->vma);
9665 rela.r_addend = val;
9666 loc = relplt->contents + (relplt->reloc_count++
9667 * sizeof (Elf32_External_Rela));
9668 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9669
9670 p = (unsigned char *) htab->glink->contents + ent->glink_offset;
9671 write_glink_stub (NULL, ent, htab->elf.iplt, p, info);
9672 }
9673 }
9674
9675 if (local_syms != NULL
9676 && symtab_hdr->contents != (unsigned char *) local_syms)
9677 {
9678 if (!info->keep_memory)
9679 free (local_syms);
9680 else
9681 symtab_hdr->contents = (unsigned char *) local_syms;
9682 }
9683 }
9684 return TRUE;
9685 }
9686
9687 /* Finish up dynamic symbol handling. We set the contents of various
9688 dynamic sections here. */
9689
9690 static bfd_boolean
9691 ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
9692 struct bfd_link_info *info,
9693 struct elf_link_hash_entry *h,
9694 Elf_Internal_Sym *sym)
9695 {
9696 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9697 struct plt_entry *ent;
9698
9699 #ifdef DEBUG
9700 fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
9701 h->root.root.string);
9702 #endif
9703
9704 if (!h->def_regular
9705 || (h->type == STT_GNU_IFUNC && !bfd_link_pic (info)))
9706 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
9707 if (ent->plt.offset != (bfd_vma) -1)
9708 {
9709 if (!h->def_regular)
9710 {
9711 /* Mark the symbol as undefined, rather than as
9712 defined in the .plt section. Leave the value if
9713 there were any relocations where pointer equality
9714 matters (this is a clue for the dynamic linker, to
9715 make function pointer comparisons work between an
9716 application and shared library), otherwise set it
9717 to zero. */
9718 sym->st_shndx = SHN_UNDEF;
9719 if (!h->pointer_equality_needed)
9720 sym->st_value = 0;
9721 else if (!h->ref_regular_nonweak)
9722 {
9723 /* This breaks function pointer comparisons, but
9724 that is better than breaking tests for a NULL
9725 function pointer. */
9726 sym->st_value = 0;
9727 }
9728 }
9729 else
9730 {
9731 /* Set the value of ifunc symbols in a non-pie
9732 executable to the glink entry. This is to avoid
9733 text relocations. We can't do this for ifunc in
9734 allocate_dynrelocs, as we do for normal dynamic
9735 function symbols with plt entries, because we need
9736 to keep the original value around for the ifunc
9737 relocation. */
9738 sym->st_shndx
9739 = (_bfd_elf_section_from_bfd_section
9740 (info->output_bfd, htab->glink->output_section));
9741 sym->st_value = (ent->glink_offset
9742 + htab->glink->output_offset
9743 + htab->glink->output_section->vma);
9744 }
9745 break;
9746 }
9747
9748 if (h->needs_copy)
9749 {
9750 asection *s;
9751 Elf_Internal_Rela rela;
9752 bfd_byte *loc;
9753
9754 /* This symbols needs a copy reloc. Set it up. */
9755
9756 #ifdef DEBUG
9757 fprintf (stderr, ", copy");
9758 #endif
9759
9760 BFD_ASSERT (h->dynindx != -1);
9761
9762 if (ppc_elf_hash_entry (h)->has_sda_refs)
9763 s = htab->relsbss;
9764 else if (h->root.u.def.section == htab->elf.sdynrelro)
9765 s = htab->elf.sreldynrelro;
9766 else
9767 s = htab->elf.srelbss;
9768 BFD_ASSERT (s != NULL);
9769
9770 rela.r_offset = SYM_VAL (h);
9771 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
9772 rela.r_addend = 0;
9773 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
9774 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9775 }
9776
9777 #ifdef DEBUG
9778 fprintf (stderr, "\n");
9779 #endif
9780
9781 return TRUE;
9782 }
9783 \f
9784 static enum elf_reloc_type_class
9785 ppc_elf_reloc_type_class (const struct bfd_link_info *info,
9786 const asection *rel_sec,
9787 const Elf_Internal_Rela *rela)
9788 {
9789 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9790
9791 if (rel_sec == htab->elf.irelplt)
9792 return reloc_class_ifunc;
9793
9794 switch (ELF32_R_TYPE (rela->r_info))
9795 {
9796 case R_PPC_RELATIVE:
9797 return reloc_class_relative;
9798 case R_PPC_JMP_SLOT:
9799 return reloc_class_plt;
9800 case R_PPC_COPY:
9801 return reloc_class_copy;
9802 default:
9803 return reloc_class_normal;
9804 }
9805 }
9806 \f
9807 /* Finish up the dynamic sections. */
9808
9809 static bfd_boolean
9810 ppc_elf_finish_dynamic_sections (bfd *output_bfd,
9811 struct bfd_link_info *info)
9812 {
9813 asection *sdyn;
9814 struct ppc_elf_link_hash_table *htab;
9815 bfd_vma got;
9816 bfd *dynobj;
9817 bfd_boolean ret = TRUE;
9818
9819 #ifdef DEBUG
9820 fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
9821 #endif
9822
9823 htab = ppc_elf_hash_table (info);
9824 dynobj = htab->elf.dynobj;
9825 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
9826
9827 got = 0;
9828 if (htab->elf.hgot != NULL)
9829 got = SYM_VAL (htab->elf.hgot);
9830
9831 if (htab->elf.dynamic_sections_created)
9832 {
9833 Elf32_External_Dyn *dyncon, *dynconend;
9834
9835 BFD_ASSERT (htab->elf.splt != NULL && sdyn != NULL);
9836
9837 dyncon = (Elf32_External_Dyn *) sdyn->contents;
9838 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
9839 for (; dyncon < dynconend; dyncon++)
9840 {
9841 Elf_Internal_Dyn dyn;
9842 asection *s;
9843
9844 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
9845
9846 switch (dyn.d_tag)
9847 {
9848 case DT_PLTGOT:
9849 if (htab->elf.target_os == is_vxworks)
9850 s = htab->elf.sgotplt;
9851 else
9852 s = htab->elf.splt;
9853 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9854 break;
9855
9856 case DT_PLTRELSZ:
9857 dyn.d_un.d_val = htab->elf.srelplt->size;
9858 break;
9859
9860 case DT_JMPREL:
9861 s = htab->elf.srelplt;
9862 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9863 break;
9864
9865 case DT_PPC_GOT:
9866 dyn.d_un.d_ptr = got;
9867 break;
9868
9869 case DT_TEXTREL:
9870 if (htab->local_ifunc_resolver)
9871 info->callbacks->einfo
9872 (_("%X%P: text relocations and GNU indirect "
9873 "functions will result in a segfault at runtime\n"));
9874 else if (htab->maybe_local_ifunc_resolver)
9875 info->callbacks->einfo
9876 (_("%P: warning: text relocations and GNU indirect "
9877 "functions may result in a segfault at runtime\n"));
9878 continue;
9879
9880 default:
9881 if (htab->elf.target_os == is_vxworks
9882 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
9883 break;
9884 continue;
9885 }
9886
9887 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
9888 }
9889 }
9890
9891 if (htab->elf.sgot != NULL
9892 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
9893 {
9894 if (htab->elf.hgot->root.u.def.section == htab->elf.sgot
9895 || htab->elf.hgot->root.u.def.section == htab->elf.sgotplt)
9896 {
9897 unsigned char *p = htab->elf.hgot->root.u.def.section->contents;
9898
9899 p += htab->elf.hgot->root.u.def.value;
9900 if (htab->plt_type == PLT_OLD)
9901 {
9902 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4
9903 so that a function can easily find the address of
9904 _GLOBAL_OFFSET_TABLE_. */
9905 BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4
9906 < htab->elf.hgot->root.u.def.section->size);
9907 bfd_put_32 (output_bfd, 0x4e800021, p - 4);
9908 }
9909
9910 if (sdyn != NULL)
9911 {
9912 bfd_vma val = sdyn->output_section->vma + sdyn->output_offset;
9913 BFD_ASSERT (htab->elf.hgot->root.u.def.value
9914 < htab->elf.hgot->root.u.def.section->size);
9915 bfd_put_32 (output_bfd, val, p);
9916 }
9917 }
9918 else
9919 {
9920 /* xgettext:c-format */
9921 _bfd_error_handler (_("%s not defined in linker created %pA"),
9922 htab->elf.hgot->root.root.string,
9923 (htab->elf.sgotplt != NULL
9924 ? htab->elf.sgotplt : htab->elf.sgot));
9925 bfd_set_error (bfd_error_bad_value);
9926 ret = FALSE;
9927 }
9928
9929 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
9930 }
9931
9932 /* Fill in the first entry in the VxWorks procedure linkage table. */
9933 if (htab->elf.target_os == is_vxworks
9934 && htab->elf.splt != NULL
9935 && htab->elf.splt->size != 0
9936 && htab->elf.splt->output_section != bfd_abs_section_ptr)
9937 {
9938 asection *splt = htab->elf.splt;
9939 /* Use the right PLT. */
9940 const bfd_vma *plt_entry = (bfd_link_pic (info)
9941 ? ppc_elf_vxworks_pic_plt0_entry
9942 : ppc_elf_vxworks_plt0_entry);
9943
9944 if (!bfd_link_pic (info))
9945 {
9946 bfd_vma got_value = SYM_VAL (htab->elf.hgot);
9947
9948 bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value),
9949 splt->contents + 0);
9950 bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value),
9951 splt->contents + 4);
9952 }
9953 else
9954 {
9955 bfd_put_32 (output_bfd, plt_entry[0], splt->contents + 0);
9956 bfd_put_32 (output_bfd, plt_entry[1], splt->contents + 4);
9957 }
9958 bfd_put_32 (output_bfd, plt_entry[2], splt->contents + 8);
9959 bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12);
9960 bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16);
9961 bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20);
9962 bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24);
9963 bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28);
9964
9965 if (! bfd_link_pic (info))
9966 {
9967 Elf_Internal_Rela rela;
9968 bfd_byte *loc;
9969
9970 loc = htab->srelplt2->contents;
9971
9972 /* Output the @ha relocation for the first instruction. */
9973 rela.r_offset = (htab->elf.splt->output_section->vma
9974 + htab->elf.splt->output_offset
9975 + 2);
9976 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
9977 rela.r_addend = 0;
9978 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9979 loc += sizeof (Elf32_External_Rela);
9980
9981 /* Output the @l relocation for the second instruction. */
9982 rela.r_offset = (htab->elf.splt->output_section->vma
9983 + htab->elf.splt->output_offset
9984 + 6);
9985 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
9986 rela.r_addend = 0;
9987 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9988 loc += sizeof (Elf32_External_Rela);
9989
9990 /* Fix up the remaining relocations. They may have the wrong
9991 symbol index for _G_O_T_ or _P_L_T_ depending on the order
9992 in which symbols were output. */
9993 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
9994 {
9995 Elf_Internal_Rela rel;
9996
9997 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
9998 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
9999 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10000 loc += sizeof (Elf32_External_Rela);
10001
10002 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10003 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
10004 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10005 loc += sizeof (Elf32_External_Rela);
10006
10007 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10008 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32);
10009 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10010 loc += sizeof (Elf32_External_Rela);
10011 }
10012 }
10013 }
10014
10015 if (htab->glink != NULL
10016 && htab->glink->contents != NULL
10017 && htab->elf.dynamic_sections_created)
10018 {
10019 unsigned char *p;
10020 unsigned char *endp;
10021 bfd_vma res0;
10022
10023 /*
10024 * PIC glink code is the following:
10025 *
10026 * # ith PLT code stub.
10027 * addis 11,30,(plt+(i-1)*4-got)@ha
10028 * lwz 11,(plt+(i-1)*4-got)@l(11)
10029 * mtctr 11
10030 * bctr
10031 *
10032 * # A table of branches, one for each plt entry.
10033 * # The idea is that the plt call stub loads ctr and r11 with these
10034 * # addresses, so (r11 - res_0) gives the plt index * 4.
10035 * res_0: b PLTresolve
10036 * res_1: b PLTresolve
10037 * .
10038 * # Some number of entries towards the end can be nops
10039 * res_n_m3: nop
10040 * res_n_m2: nop
10041 * res_n_m1:
10042 *
10043 * PLTresolve:
10044 * addis 11,11,(1f-res_0)@ha
10045 * mflr 0
10046 * bcl 20,31,1f
10047 * 1: addi 11,11,(1b-res_0)@l
10048 * mflr 12
10049 * mtlr 0
10050 * sub 11,11,12 # r11 = index * 4
10051 * addis 12,12,(got+4-1b)@ha
10052 * lwz 0,(got+4-1b)@l(12) # got[1] address of dl_runtime_resolve
10053 * lwz 12,(got+8-1b)@l(12) # got[2] contains the map address
10054 * mtctr 0
10055 * add 0,11,11
10056 * add 11,0,11 # r11 = index * 12 = reloc offset.
10057 * bctr
10058 *
10059 * Non-PIC glink code is a little simpler.
10060 *
10061 * # ith PLT code stub.
10062 * lis 11,(plt+(i-1)*4)@ha
10063 * lwz 11,(plt+(i-1)*4)@l(11)
10064 * mtctr 11
10065 * bctr
10066 *
10067 * The branch table is the same, then comes
10068 *
10069 * PLTresolve:
10070 * lis 12,(got+4)@ha
10071 * addis 11,11,(-res_0)@ha
10072 * lwz 0,(got+4)@l(12) # got[1] address of dl_runtime_resolve
10073 * addi 11,11,(-res_0)@l # r11 = index * 4
10074 * mtctr 0
10075 * add 0,11,11
10076 * lwz 12,(got+8)@l(12) # got[2] contains the map address
10077 * add 11,0,11 # r11 = index * 12 = reloc offset.
10078 * bctr
10079 */
10080
10081 /* Build the branch table, one for each plt entry (less one),
10082 and perhaps some padding. */
10083 p = htab->glink->contents;
10084 p += htab->glink_pltresolve;
10085 endp = htab->glink->contents;
10086 endp += htab->glink->size - GLINK_PLTRESOLVE;
10087 while (p < endp - (htab->params->ppc476_workaround ? 0 : 8 * 4))
10088 {
10089 bfd_put_32 (output_bfd, B + endp - p, p);
10090 p += 4;
10091 }
10092 while (p < endp)
10093 {
10094 bfd_put_32 (output_bfd, NOP, p);
10095 p += 4;
10096 }
10097
10098 res0 = (htab->glink_pltresolve
10099 + htab->glink->output_section->vma
10100 + htab->glink->output_offset);
10101
10102 if (htab->params->ppc476_workaround)
10103 {
10104 /* Ensure that a call stub at the end of a page doesn't
10105 result in prefetch over the end of the page into the
10106 glink branch table. */
10107 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
10108 bfd_vma page_addr;
10109 bfd_vma glink_start = (htab->glink->output_section->vma
10110 + htab->glink->output_offset);
10111
10112 for (page_addr = res0 & -pagesize;
10113 page_addr > glink_start;
10114 page_addr -= pagesize)
10115 {
10116 /* We have a plt call stub that may need fixing. */
10117 bfd_byte *loc;
10118 unsigned int insn;
10119
10120 loc = htab->glink->contents + page_addr - 4 - glink_start;
10121 insn = bfd_get_32 (output_bfd, loc);
10122 if (insn == BCTR)
10123 {
10124 /* By alignment, we know that there must be at least
10125 one other call stub before this one. */
10126 insn = bfd_get_32 (output_bfd, loc - 16);
10127 if (insn == BCTR)
10128 bfd_put_32 (output_bfd, B | (-16 & 0x3fffffc), loc);
10129 else
10130 bfd_put_32 (output_bfd, B | (-20 & 0x3fffffc), loc);
10131 }
10132 }
10133 }
10134
10135 /* Last comes the PLTresolve stub. */
10136 endp = p + GLINK_PLTRESOLVE;
10137 if (bfd_link_pic (info))
10138 {
10139 bfd_vma bcl;
10140
10141 bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4
10142 + htab->glink->output_section->vma
10143 + htab->glink->output_offset);
10144
10145 bfd_put_32 (output_bfd, ADDIS_11_11 + PPC_HA (bcl - res0), p);
10146 p += 4;
10147 bfd_put_32 (output_bfd, MFLR_0, p);
10148 p += 4;
10149 bfd_put_32 (output_bfd, BCL_20_31, p);
10150 p += 4;
10151 bfd_put_32 (output_bfd, ADDI_11_11 + PPC_LO (bcl - res0), p);
10152 p += 4;
10153 bfd_put_32 (output_bfd, MFLR_12, p);
10154 p += 4;
10155 bfd_put_32 (output_bfd, MTLR_0, p);
10156 p += 4;
10157 bfd_put_32 (output_bfd, SUB_11_11_12, p);
10158 p += 4;
10159 bfd_put_32 (output_bfd, ADDIS_12_12 + PPC_HA (got + 4 - bcl), p);
10160 p += 4;
10161 if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl))
10162 {
10163 bfd_put_32 (output_bfd, LWZ_0_12 + PPC_LO (got + 4 - bcl), p);
10164 p += 4;
10165 bfd_put_32 (output_bfd, LWZ_12_12 + PPC_LO (got + 8 - bcl), p);
10166 p += 4;
10167 }
10168 else
10169 {
10170 bfd_put_32 (output_bfd, LWZU_0_12 + PPC_LO (got + 4 - bcl), p);
10171 p += 4;
10172 bfd_put_32 (output_bfd, LWZ_12_12 + 4, p);
10173 p += 4;
10174 }
10175 bfd_put_32 (output_bfd, MTCTR_0, p);
10176 p += 4;
10177 bfd_put_32 (output_bfd, ADD_0_11_11, p);
10178 }
10179 else
10180 {
10181 bfd_put_32 (output_bfd, LIS_12 + PPC_HA (got + 4), p);
10182 p += 4;
10183 bfd_put_32 (output_bfd, ADDIS_11_11 + PPC_HA (-res0), p);
10184 p += 4;
10185 if (PPC_HA (got + 4) == PPC_HA (got + 8))
10186 bfd_put_32 (output_bfd, LWZ_0_12 + PPC_LO (got + 4), p);
10187 else
10188 bfd_put_32 (output_bfd, LWZU_0_12 + PPC_LO (got + 4), p);
10189 p += 4;
10190 bfd_put_32 (output_bfd, ADDI_11_11 + PPC_LO (-res0), p);
10191 p += 4;
10192 bfd_put_32 (output_bfd, MTCTR_0, p);
10193 p += 4;
10194 bfd_put_32 (output_bfd, ADD_0_11_11, p);
10195 p += 4;
10196 if (PPC_HA (got + 4) == PPC_HA (got + 8))
10197 bfd_put_32 (output_bfd, LWZ_12_12 + PPC_LO (got + 8), p);
10198 else
10199 bfd_put_32 (output_bfd, LWZ_12_12 + 4, p);
10200 }
10201 p += 4;
10202 bfd_put_32 (output_bfd, ADD_11_0_11, p);
10203 p += 4;
10204 bfd_put_32 (output_bfd, BCTR, p);
10205 p += 4;
10206 while (p < endp)
10207 {
10208 bfd_put_32 (output_bfd,
10209 htab->params->ppc476_workaround ? BA : NOP, p);
10210 p += 4;
10211 }
10212 BFD_ASSERT (p == endp);
10213 }
10214
10215 if (htab->glink_eh_frame != NULL
10216 && htab->glink_eh_frame->contents != NULL)
10217 {
10218 unsigned char *p = htab->glink_eh_frame->contents;
10219 bfd_vma val;
10220
10221 p += sizeof (glink_eh_frame_cie);
10222 /* FDE length. */
10223 p += 4;
10224 /* CIE pointer. */
10225 p += 4;
10226 /* Offset to .glink. */
10227 val = (htab->glink->output_section->vma
10228 + htab->glink->output_offset);
10229 val -= (htab->glink_eh_frame->output_section->vma
10230 + htab->glink_eh_frame->output_offset);
10231 val -= p - htab->glink_eh_frame->contents;
10232 bfd_put_32 (htab->elf.dynobj, val, p);
10233
10234 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
10235 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
10236 htab->glink_eh_frame,
10237 htab->glink_eh_frame->contents))
10238 return FALSE;
10239 }
10240
10241 return ret;
10242 }
10243 \f
10244 #define TARGET_LITTLE_SYM powerpc_elf32_le_vec
10245 #define TARGET_LITTLE_NAME "elf32-powerpcle"
10246 #define TARGET_BIG_SYM powerpc_elf32_vec
10247 #define TARGET_BIG_NAME "elf32-powerpc"
10248 #define ELF_ARCH bfd_arch_powerpc
10249 #define ELF_TARGET_ID PPC32_ELF_DATA
10250 #define ELF_MACHINE_CODE EM_PPC
10251 #define ELF_MAXPAGESIZE 0x10000
10252 #define ELF_COMMONPAGESIZE 0x1000
10253 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
10254 #define elf_info_to_howto ppc_elf_info_to_howto
10255
10256 #ifdef EM_CYGNUS_POWERPC
10257 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
10258 #endif
10259
10260 #ifdef EM_PPC_OLD
10261 #define ELF_MACHINE_ALT2 EM_PPC_OLD
10262 #endif
10263
10264 #define elf_backend_plt_not_loaded 1
10265 #define elf_backend_want_dynrelro 1
10266 #define elf_backend_can_gc_sections 1
10267 #define elf_backend_can_refcount 1
10268 #define elf_backend_rela_normal 1
10269 #define elf_backend_caches_rawsize 1
10270
10271 #define bfd_elf32_mkobject ppc_elf_mkobject
10272 #define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data
10273 #define bfd_elf32_bfd_relax_section ppc_elf_relax_section
10274 #define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup
10275 #define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup
10276 #define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
10277 #define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create
10278 #define bfd_elf32_get_synthetic_symtab ppc_elf_get_synthetic_symtab
10279
10280 #define elf_backend_object_p ppc_elf_object_p
10281 #define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook
10282 #define elf_backend_section_from_shdr ppc_elf_section_from_shdr
10283 #define elf_backend_relocate_section ppc_elf_relocate_section
10284 #define elf_backend_create_dynamic_sections ppc_elf_create_dynamic_sections
10285 #define elf_backend_check_relocs ppc_elf_check_relocs
10286 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
10287 #define elf_backend_copy_indirect_symbol ppc_elf_copy_indirect_symbol
10288 #define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol
10289 #define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook
10290 #define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections
10291 #define elf_backend_hash_symbol ppc_elf_hash_symbol
10292 #define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol
10293 #define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections
10294 #define elf_backend_fake_sections ppc_elf_fake_sections
10295 #define elf_backend_additional_program_headers ppc_elf_additional_program_headers
10296 #define elf_backend_modify_segment_map ppc_elf_modify_segment_map
10297 #define elf_backend_grok_prstatus ppc_elf_grok_prstatus
10298 #define elf_backend_grok_psinfo ppc_elf_grok_psinfo
10299 #define elf_backend_write_core_note ppc_elf_write_core_note
10300 #define elf_backend_reloc_type_class ppc_elf_reloc_type_class
10301 #define elf_backend_begin_write_processing ppc_elf_begin_write_processing
10302 #define elf_backend_final_write_processing ppc_elf_final_write_processing
10303 #define elf_backend_write_section ppc_elf_write_section
10304 #define elf_backend_get_sec_type_attr ppc_elf_get_sec_type_attr
10305 #define elf_backend_plt_sym_val ppc_elf_plt_sym_val
10306 #define elf_backend_action_discarded ppc_elf_action_discarded
10307 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
10308 #define elf_backend_lookup_section_flags_hook ppc_elf_lookup_section_flags
10309
10310 #include "elf32-target.h"
10311
10312 /* FreeBSD Target */
10313
10314 #undef TARGET_LITTLE_SYM
10315 #undef TARGET_LITTLE_NAME
10316
10317 #undef TARGET_BIG_SYM
10318 #define TARGET_BIG_SYM powerpc_elf32_fbsd_vec
10319 #undef TARGET_BIG_NAME
10320 #define TARGET_BIG_NAME "elf32-powerpc-freebsd"
10321
10322 #undef ELF_OSABI
10323 #define ELF_OSABI ELFOSABI_FREEBSD
10324
10325 #undef elf32_bed
10326 #define elf32_bed elf32_powerpc_fbsd_bed
10327
10328 #include "elf32-target.h"
10329
10330 /* VxWorks Target */
10331
10332 #undef TARGET_LITTLE_SYM
10333 #undef TARGET_LITTLE_NAME
10334
10335 #undef TARGET_BIG_SYM
10336 #define TARGET_BIG_SYM powerpc_elf32_vxworks_vec
10337 #undef TARGET_BIG_NAME
10338 #define TARGET_BIG_NAME "elf32-powerpc-vxworks"
10339
10340 #undef ELF_OSABI
10341
10342 #undef ELF_TARGET_OS
10343 #define ELF_TARGET_OS is_vxworks
10344
10345 /* VxWorks uses the elf default section flags for .plt. */
10346 static const struct bfd_elf_special_section *
10347 ppc_elf_vxworks_get_sec_type_attr (bfd *abfd, asection *sec)
10348 {
10349 if (sec->name == NULL)
10350 return NULL;
10351
10352 if (strcmp (sec->name, ".plt") == 0)
10353 return _bfd_elf_get_sec_type_attr (abfd, sec);
10354
10355 return ppc_elf_get_sec_type_attr (abfd, sec);
10356 }
10357
10358 /* Like ppc_elf_link_hash_table_create, but overrides
10359 appropriately for VxWorks. */
10360 static struct bfd_link_hash_table *
10361 ppc_elf_vxworks_link_hash_table_create (bfd *abfd)
10362 {
10363 struct bfd_link_hash_table *ret;
10364
10365 ret = ppc_elf_link_hash_table_create (abfd);
10366 if (ret)
10367 {
10368 struct ppc_elf_link_hash_table *htab
10369 = (struct ppc_elf_link_hash_table *)ret;
10370 htab->plt_type = PLT_VXWORKS;
10371 htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE;
10372 htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE;
10373 htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE;
10374 }
10375 return ret;
10376 }
10377
10378 /* Tweak magic VxWorks symbols as they are loaded. */
10379 static bfd_boolean
10380 ppc_elf_vxworks_add_symbol_hook (bfd *abfd,
10381 struct bfd_link_info *info,
10382 Elf_Internal_Sym *sym,
10383 const char **namep,
10384 flagword *flagsp,
10385 asection **secp,
10386 bfd_vma *valp)
10387 {
10388 if (!elf_vxworks_add_symbol_hook (abfd, info, sym, namep, flagsp, secp,
10389 valp))
10390 return FALSE;
10391
10392 return ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp);
10393 }
10394
10395 static bfd_boolean
10396 ppc_elf_vxworks_final_write_processing (bfd *abfd)
10397 {
10398 ppc_final_write_processing (abfd);
10399 return elf_vxworks_final_write_processing (abfd);
10400 }
10401
10402 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
10403 define it. */
10404 #undef elf_backend_want_plt_sym
10405 #define elf_backend_want_plt_sym 1
10406 #undef elf_backend_want_got_plt
10407 #define elf_backend_want_got_plt 1
10408 #undef elf_backend_got_symbol_offset
10409 #define elf_backend_got_symbol_offset 0
10410 #undef elf_backend_plt_not_loaded
10411 #define elf_backend_plt_not_loaded 0
10412 #undef elf_backend_plt_readonly
10413 #define elf_backend_plt_readonly 1
10414 #undef elf_backend_got_header_size
10415 #define elf_backend_got_header_size 12
10416 #undef elf_backend_dtrel_excludes_plt
10417 #define elf_backend_dtrel_excludes_plt 1
10418
10419 #undef bfd_elf32_get_synthetic_symtab
10420
10421 #undef bfd_elf32_bfd_link_hash_table_create
10422 #define bfd_elf32_bfd_link_hash_table_create \
10423 ppc_elf_vxworks_link_hash_table_create
10424 #undef elf_backend_add_symbol_hook
10425 #define elf_backend_add_symbol_hook \
10426 ppc_elf_vxworks_add_symbol_hook
10427 #undef elf_backend_link_output_symbol_hook
10428 #define elf_backend_link_output_symbol_hook \
10429 elf_vxworks_link_output_symbol_hook
10430 #undef elf_backend_final_write_processing
10431 #define elf_backend_final_write_processing \
10432 ppc_elf_vxworks_final_write_processing
10433 #undef elf_backend_get_sec_type_attr
10434 #define elf_backend_get_sec_type_attr \
10435 ppc_elf_vxworks_get_sec_type_attr
10436 #undef elf_backend_emit_relocs
10437 #define elf_backend_emit_relocs \
10438 elf_vxworks_emit_relocs
10439
10440 #undef elf32_bed
10441 #define elf32_bed ppc_elf_vxworks_bed
10442
10443 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.246972 seconds and 4 git commands to generate.