projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PR26132, ar creates invalid libraries for some targets with plugins enabled
[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_link_executable (info))
5826 {
5827 if (!add_dynamic_entry (DT_DEBUG, 0))
5828 return FALSE;
5829 }
5830
5831 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
5832 {
5833 if (!add_dynamic_entry (DT_PLTGOT, 0)
5834 || !add_dynamic_entry (DT_PLTRELSZ, 0)
5835 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5836 || !add_dynamic_entry (DT_JMPREL, 0))
5837 return FALSE;
5838 }
5839
5840 if (htab->plt_type == PLT_NEW
5841 && htab->glink != NULL
5842 && htab->glink->size != 0)
5843 {
5844 if (!add_dynamic_entry (DT_PPC_GOT, 0))
5845 return FALSE;
5846 if (!htab->params->no_tls_get_addr_opt
5847 && htab->tls_get_addr != NULL
5848 && htab->tls_get_addr->plt.plist != NULL
5849 && !add_dynamic_entry (DT_PPC_OPT, PPC_OPT_TLS))
5850 return FALSE;
5851 }
5852
5853 if (relocs)
5854 {
5855 if (!add_dynamic_entry (DT_RELA, 0)
5856 || !add_dynamic_entry (DT_RELASZ, 0)
5857 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
5858 return FALSE;
5859 }
5860
5861 /* If any dynamic relocs apply to a read-only section, then we
5862 need a DT_TEXTREL entry. */
5863 if ((info->flags & DF_TEXTREL) == 0)
5864 elf_link_hash_traverse (elf_hash_table (info),
5865 _bfd_elf_maybe_set_textrel,
5866 info);
5867
5868 if ((info->flags & DF_TEXTREL) != 0)
5869 {
5870 if (!add_dynamic_entry (DT_TEXTREL, 0))
5871 return FALSE;
5872 }
5873 if (htab->elf.target_os == is_vxworks
5874 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
5875 return FALSE;
5876 }
5877 #undef add_dynamic_entry
5878
5879 if (htab->glink_eh_frame != NULL
5880 && htab->glink_eh_frame->contents != NULL)
5881 {
5882 unsigned char *p = htab->glink_eh_frame->contents;
5883 bfd_vma val;
5884
5885 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
5886 /* CIE length (rewrite in case little-endian). */
5887 bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
5888 p += sizeof (glink_eh_frame_cie);
5889 /* FDE length. */
5890 val = htab->glink_eh_frame->size - 4 - sizeof (glink_eh_frame_cie);
5891 bfd_put_32 (htab->elf.dynobj, val, p);
5892 p += 4;
5893 /* CIE pointer. */
5894 val = p - htab->glink_eh_frame->contents;
5895 bfd_put_32 (htab->elf.dynobj, val, p);
5896 p += 4;
5897 /* Offset to .glink. Set later. */
5898 p += 4;
5899 /* .glink size. */
5900 bfd_put_32 (htab->elf.dynobj, htab->glink->size, p);
5901 p += 4;
5902 /* Augmentation. */
5903 p += 1;
5904
5905 if (bfd_link_pic (info)
5906 && htab->elf.dynamic_sections_created)
5907 {
5908 bfd_vma adv = (htab->glink->size - GLINK_PLTRESOLVE + 8) >> 2;
5909 if (adv < 64)
5910 *p++ = DW_CFA_advance_loc + adv;
5911 else if (adv < 256)
5912 {
5913 *p++ = DW_CFA_advance_loc1;
5914 *p++ = adv;
5915 }
5916 else if (adv < 65536)
5917 {
5918 *p++ = DW_CFA_advance_loc2;
5919 bfd_put_16 (htab->elf.dynobj, adv, p);
5920 p += 2;
5921 }
5922 else
5923 {
5924 *p++ = DW_CFA_advance_loc4;
5925 bfd_put_32 (htab->elf.dynobj, adv, p);
5926 p += 4;
5927 }
5928 *p++ = DW_CFA_register;
5929 *p++ = 65;
5930 p++;
5931 *p++ = DW_CFA_advance_loc + 4;
5932 *p++ = DW_CFA_restore_extended;
5933 *p++ = 65;
5934 }
5935 BFD_ASSERT ((bfd_vma) ((p + 3 - htab->glink_eh_frame->contents) & -4)
5936 == htab->glink_eh_frame->size);
5937 }
5938
5939 return TRUE;
5940 }
5941
5942 /* Arrange to have _SDA_BASE_ or _SDA2_BASE_ stripped from the output
5943 if it looks like nothing is using them. */
5944
5945 static void
5946 maybe_strip_sdasym (bfd *output_bfd, elf_linker_section_t *lsect)
5947 {
5948 struct elf_link_hash_entry *sda = lsect->sym;
5949
5950 if (sda != NULL && !sda->ref_regular && sda->dynindx == -1)
5951 {
5952 asection *s;
5953
5954 s = bfd_get_section_by_name (output_bfd, lsect->name);
5955 if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
5956 {
5957 s = bfd_get_section_by_name (output_bfd, lsect->bss_name);
5958 if (s == NULL || bfd_section_removed_from_list (output_bfd, s))
5959 {
5960 sda->def_regular = 0;
5961 /* This is somewhat magic. See elf_link_output_extsym. */
5962 sda->ref_dynamic = 1;
5963 sda->forced_local = 0;
5964 }
5965 }
5966 }
5967 }
5968
5969 void
5970 ppc_elf_maybe_strip_sdata_syms (struct bfd_link_info *info)
5971 {
5972 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
5973
5974 if (htab != NULL)
5975 {
5976 maybe_strip_sdasym (info->output_bfd, &htab->sdata[0]);
5977 maybe_strip_sdasym (info->output_bfd, &htab->sdata[1]);
5978 }
5979 }
5980
5981
5982 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5983
5984 static bfd_boolean
5985 ppc_elf_hash_symbol (struct elf_link_hash_entry *h)
5986 {
5987 if (h->plt.plist != NULL
5988 && !h->def_regular
5989 && (!h->pointer_equality_needed
5990 || !h->ref_regular_nonweak))
5991 return FALSE;
5992
5993 return _bfd_elf_hash_symbol (h);
5994 }
5995 \f
5996 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
5997
5998 /* Relaxation trampolines. r12 is available for clobbering (r11, is
5999 used for some functions that are allowed to break the ABI). */
6000 static const int shared_stub_entry[] =
6001 {
6002 0x7c0802a6, /* mflr 0 */
6003 0x429f0005, /* bcl 20, 31, .Lxxx */
6004 0x7d8802a6, /* mflr 12 */
6005 0x3d8c0000, /* addis 12, 12, (xxx-.Lxxx)@ha */
6006 0x398c0000, /* addi 12, 12, (xxx-.Lxxx)@l */
6007 0x7c0803a6, /* mtlr 0 */
6008 0x7d8903a6, /* mtctr 12 */
6009 0x4e800420, /* bctr */
6010 };
6011
6012 static const int stub_entry[] =
6013 {
6014 0x3d800000, /* lis 12,xxx@ha */
6015 0x398c0000, /* addi 12,12,xxx@l */
6016 0x7d8903a6, /* mtctr 12 */
6017 0x4e800420, /* bctr */
6018 };
6019
6020 struct ppc_elf_relax_info
6021 {
6022 unsigned int workaround_size;
6023 unsigned int picfixup_size;
6024 };
6025
6026 /* This function implements long branch trampolines, and the ppc476
6027 icache bug workaround. Any section needing trampolines or patch
6028 space for the workaround has its size extended so that we can
6029 add trampolines at the end of the section. */
6030
6031 static bfd_boolean
6032 ppc_elf_relax_section (bfd *abfd,
6033 asection *isec,
6034 struct bfd_link_info *link_info,
6035 bfd_boolean *again)
6036 {
6037 struct one_branch_fixup
6038 {
6039 struct one_branch_fixup *next;
6040 asection *tsec;
6041 /* Final link, can use the symbol offset. For a
6042 relocatable link we use the symbol's index. */
6043 bfd_vma toff;
6044 bfd_vma trampoff;
6045 };
6046
6047 Elf_Internal_Shdr *symtab_hdr;
6048 bfd_byte *contents = NULL;
6049 Elf_Internal_Sym *isymbuf = NULL;
6050 Elf_Internal_Rela *internal_relocs = NULL;
6051 Elf_Internal_Rela *irel, *irelend = NULL;
6052 struct one_branch_fixup *branch_fixups = NULL;
6053 struct ppc_elf_relax_info *relax_info = NULL;
6054 unsigned changes = 0;
6055 bfd_boolean workaround_change;
6056 struct ppc_elf_link_hash_table *htab;
6057 bfd_size_type trampbase, trampoff, newsize, picfixup_size;
6058 asection *got2;
6059 bfd_boolean maybe_pasted;
6060
6061 *again = FALSE;
6062
6063 /* No need to do anything with non-alloc or non-code sections. */
6064 if ((isec->flags & SEC_ALLOC) == 0
6065 || (isec->flags & SEC_CODE) == 0
6066 || (isec->flags & SEC_LINKER_CREATED) != 0
6067 || isec->size < 4)
6068 return TRUE;
6069
6070 /* We cannot represent the required PIC relocs in the output, so don't
6071 do anything. The linker doesn't support mixing -shared and -r
6072 anyway. */
6073 if (bfd_link_relocatable (link_info) && bfd_link_pic (link_info))
6074 return TRUE;
6075
6076 htab = ppc_elf_hash_table (link_info);
6077 if (htab == NULL)
6078 return TRUE;
6079
6080 isec->size = (isec->size + 3) & -4;
6081 if (isec->rawsize == 0)
6082 isec->rawsize = isec->size;
6083 trampbase = isec->size;
6084
6085 BFD_ASSERT (isec->sec_info_type == SEC_INFO_TYPE_NONE
6086 || isec->sec_info_type == SEC_INFO_TYPE_TARGET);
6087 isec->sec_info_type = SEC_INFO_TYPE_TARGET;
6088
6089 if (htab->params->ppc476_workaround
6090 || htab->params->pic_fixup > 0)
6091 {
6092 if (elf_section_data (isec)->sec_info == NULL)
6093 {
6094 elf_section_data (isec)->sec_info
6095 = bfd_zalloc (abfd, sizeof (struct ppc_elf_relax_info));
6096 if (elf_section_data (isec)->sec_info == NULL)
6097 return FALSE;
6098 }
6099 relax_info = elf_section_data (isec)->sec_info;
6100 trampbase -= relax_info->workaround_size;
6101 }
6102
6103 maybe_pasted = (strcmp (isec->output_section->name, ".init") == 0
6104 || strcmp (isec->output_section->name, ".fini") == 0);
6105 /* Space for a branch around any trampolines. */
6106 trampoff = trampbase;
6107 if (maybe_pasted && trampbase == isec->rawsize)
6108 trampoff += 4;
6109
6110 symtab_hdr = &elf_symtab_hdr (abfd);
6111 picfixup_size = 0;
6112 if (htab->params->branch_trampolines
6113 || htab->params->pic_fixup > 0)
6114 {
6115 /* Get a copy of the native relocations. */
6116 if (isec->reloc_count != 0)
6117 {
6118 internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL,
6119 link_info->keep_memory);
6120 if (internal_relocs == NULL)
6121 goto error_return;
6122 }
6123
6124 got2 = bfd_get_section_by_name (abfd, ".got2");
6125
6126 irelend = internal_relocs + isec->reloc_count;
6127 for (irel = internal_relocs; irel < irelend; irel++)
6128 {
6129 unsigned long r_type = ELF32_R_TYPE (irel->r_info);
6130 bfd_vma toff, roff;
6131 asection *tsec;
6132 struct one_branch_fixup *f;
6133 size_t insn_offset = 0;
6134 bfd_vma max_branch_offset = 0, val;
6135 bfd_byte *hit_addr;
6136 unsigned long t0;
6137 struct elf_link_hash_entry *h;
6138 Elf_Internal_Sym *isym;
6139 struct plt_entry **plist;
6140 unsigned char sym_type;
6141
6142 switch (r_type)
6143 {
6144 case R_PPC_REL24:
6145 case R_PPC_LOCAL24PC:
6146 case R_PPC_PLTREL24:
6147 case R_PPC_PLTCALL:
6148 max_branch_offset = 1 << 25;
6149 break;
6150
6151 case R_PPC_REL14:
6152 case R_PPC_REL14_BRTAKEN:
6153 case R_PPC_REL14_BRNTAKEN:
6154 max_branch_offset = 1 << 15;
6155 break;
6156
6157 case R_PPC_ADDR16_HA:
6158 if (htab->params->pic_fixup > 0)
6159 break;
6160 continue;
6161
6162 default:
6163 continue;
6164 }
6165
6166 /* Get the value of the symbol referred to by the reloc. */
6167 if (!get_sym_h (&h, &isym, &tsec, NULL, &isymbuf,
6168 ELF32_R_SYM (irel->r_info), abfd))
6169 goto error_return;
6170
6171 if (isym != NULL)
6172 {
6173 if (tsec != NULL)
6174 ;
6175 else if (isym->st_shndx == SHN_ABS)
6176 tsec = bfd_abs_section_ptr;
6177 else
6178 continue;
6179
6180 toff = isym->st_value;
6181 sym_type = ELF_ST_TYPE (isym->st_info);
6182 }
6183 else
6184 {
6185 if (tsec != NULL)
6186 toff = h->root.u.def.value;
6187 else if (h->root.type == bfd_link_hash_undefined
6188 || h->root.type == bfd_link_hash_undefweak)
6189 {
6190 unsigned long indx;
6191
6192 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6193 tsec = bfd_und_section_ptr;
6194 toff = bfd_link_relocatable (link_info) ? indx : 0;
6195 }
6196 else
6197 continue;
6198
6199 /* If this branch is to __tls_get_addr then we may later
6200 optimise away the call. We won't be needing a long-
6201 branch stub in that case. */
6202 if (bfd_link_executable (link_info)
6203 && h == htab->tls_get_addr
6204 && irel != internal_relocs)
6205 {
6206 unsigned long t_symndx = ELF32_R_SYM (irel[-1].r_info);
6207 unsigned long t_rtype = ELF32_R_TYPE (irel[-1].r_info);
6208 unsigned int tls_mask = 0;
6209
6210 /* The previous reloc should be one of R_PPC_TLSGD or
6211 R_PPC_TLSLD, or for older object files, a reloc
6212 on the __tls_get_addr arg setup insn. Get tls
6213 mask bits from the symbol on that reloc. */
6214 if (t_symndx < symtab_hdr->sh_info)
6215 {
6216 bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
6217
6218 if (local_got_offsets != NULL)
6219 {
6220 struct plt_entry **local_plt = (struct plt_entry **)
6221 (local_got_offsets + symtab_hdr->sh_info);
6222 char *lgot_masks = (char *)
6223 (local_plt + symtab_hdr->sh_info);
6224 tls_mask = lgot_masks[t_symndx];
6225 }
6226 }
6227 else
6228 {
6229 struct elf_link_hash_entry *th
6230 = elf_sym_hashes (abfd)[t_symndx - symtab_hdr->sh_info];
6231
6232 while (th->root.type == bfd_link_hash_indirect
6233 || th->root.type == bfd_link_hash_warning)
6234 th = (struct elf_link_hash_entry *) th->root.u.i.link;
6235
6236 tls_mask
6237 = ((struct ppc_elf_link_hash_entry *) th)->tls_mask;
6238 }
6239
6240 /* The mask bits tell us if the call will be
6241 optimised away. */
6242 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
6243 && (t_rtype == R_PPC_TLSGD
6244 || t_rtype == R_PPC_GOT_TLSGD16
6245 || t_rtype == R_PPC_GOT_TLSGD16_LO))
6246 continue;
6247 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
6248 && (t_rtype == R_PPC_TLSLD
6249 || t_rtype == R_PPC_GOT_TLSLD16
6250 || t_rtype == R_PPC_GOT_TLSLD16_LO))
6251 continue;
6252 }
6253
6254 sym_type = h->type;
6255 }
6256
6257 if (r_type == R_PPC_ADDR16_HA)
6258 {
6259 if (h != NULL
6260 && !h->def_regular
6261 && h->protected_def
6262 && ppc_elf_hash_entry (h)->has_addr16_ha
6263 && ppc_elf_hash_entry (h)->has_addr16_lo)
6264 picfixup_size += 12;
6265 continue;
6266 }
6267
6268 /* The condition here under which we call find_plt_ent must
6269 match that in relocate_section. If we call find_plt_ent here
6270 but not in relocate_section, or vice versa, then the branch
6271 destination used here may be incorrect. */
6272 plist = NULL;
6273 if (h != NULL)
6274 {
6275 /* We know is_branch_reloc (r_type) is true. */
6276 if (h->type == STT_GNU_IFUNC
6277 || r_type == R_PPC_PLTREL24)
6278 plist = &h->plt.plist;
6279 }
6280 else if (sym_type == STT_GNU_IFUNC
6281 && elf_local_got_offsets (abfd) != NULL)
6282 {
6283 bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
6284 struct plt_entry **local_plt = (struct plt_entry **)
6285 (local_got_offsets + symtab_hdr->sh_info);
6286 plist = local_plt + ELF32_R_SYM (irel->r_info);
6287 }
6288 if (plist != NULL)
6289 {
6290 bfd_vma addend = 0;
6291 struct plt_entry *ent;
6292
6293 if (r_type == R_PPC_PLTREL24 && bfd_link_pic (link_info))
6294 addend = irel->r_addend;
6295 ent = find_plt_ent (plist, got2, addend);
6296 if (ent != NULL)
6297 {
6298 if (htab->plt_type == PLT_NEW
6299 || h == NULL
6300 || !htab->elf.dynamic_sections_created
6301 || h->dynindx == -1)
6302 {
6303 tsec = htab->glink;
6304 toff = ent->glink_offset;
6305 }
6306 else
6307 {
6308 tsec = htab->elf.splt;
6309 toff = ent->plt.offset;
6310 }
6311 }
6312 }
6313
6314 /* If the branch and target are in the same section, you have
6315 no hope of adding stubs. We'll error out later should the
6316 branch overflow. */
6317 if (tsec == isec)
6318 continue;
6319
6320 /* toff is used for the symbol index when the symbol is
6321 undefined and we're doing a relocatable link, so we can't
6322 support addends. It would be possible to do so by
6323 putting the addend in one_branch_fixup but addends on
6324 branches are rare so it hardly seems worth supporting. */
6325 if (bfd_link_relocatable (link_info)
6326 && tsec == bfd_und_section_ptr
6327 && r_type != R_PPC_PLTREL24
6328 && irel->r_addend != 0)
6329 continue;
6330
6331 /* There probably isn't any reason to handle symbols in
6332 SEC_MERGE sections; SEC_MERGE doesn't seem a likely
6333 attribute for a code section, and we are only looking at
6334 branches. However, implement it correctly here as a
6335 reference for other target relax_section functions. */
6336 if (0 && tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
6337 {
6338 /* At this stage in linking, no SEC_MERGE symbol has been
6339 adjusted, so all references to such symbols need to be
6340 passed through _bfd_merged_section_offset. (Later, in
6341 relocate_section, all SEC_MERGE symbols *except* for
6342 section symbols have been adjusted.)
6343
6344 gas may reduce relocations against symbols in SEC_MERGE
6345 sections to a relocation against the section symbol when
6346 the original addend was zero. When the reloc is against
6347 a section symbol we should include the addend in the
6348 offset passed to _bfd_merged_section_offset, since the
6349 location of interest is the original symbol. On the
6350 other hand, an access to "sym+addend" where "sym" is not
6351 a section symbol should not include the addend; Such an
6352 access is presumed to be an offset from "sym"; The
6353 location of interest is just "sym". */
6354 if (sym_type == STT_SECTION
6355 && r_type != R_PPC_PLTREL24)
6356 toff += irel->r_addend;
6357
6358 toff
6359 = _bfd_merged_section_offset (abfd, &tsec,
6360 elf_section_data (tsec)->sec_info,
6361 toff);
6362
6363 if (sym_type != STT_SECTION
6364 && r_type != R_PPC_PLTREL24)
6365 toff += irel->r_addend;
6366 }
6367 /* PLTREL24 addends are special. */
6368 else if (r_type != R_PPC_PLTREL24)
6369 toff += irel->r_addend;
6370
6371 /* Attempted -shared link of non-pic code loses. */
6372 if ((!bfd_link_relocatable (link_info)
6373 && tsec == bfd_und_section_ptr)
6374 || tsec->output_section == NULL
6375 || (tsec->owner != NULL
6376 && (tsec->owner->flags & BFD_PLUGIN) != 0))
6377 continue;
6378
6379 roff = irel->r_offset;
6380
6381 /* Avoid creating a lot of unnecessary fixups when
6382 relocatable if the output section size is such that a
6383 fixup can be created at final link.
6384 The max_branch_offset adjustment allows for some number
6385 of other fixups being needed at final link. */
6386 if (bfd_link_relocatable (link_info)
6387 && (isec->output_section->rawsize - (isec->output_offset + roff)
6388 < max_branch_offset - (max_branch_offset >> 4)))
6389 continue;
6390
6391 /* If the branch is in range, no need to do anything. */
6392 if (tsec != bfd_und_section_ptr
6393 && (!bfd_link_relocatable (link_info)
6394 /* A relocatable link may have sections moved during
6395 final link, so do not presume they remain in range. */
6396 || tsec->output_section == isec->output_section))
6397 {
6398 bfd_vma symaddr, reladdr;
6399
6400 symaddr = tsec->output_section->vma + tsec->output_offset + toff;
6401 reladdr = isec->output_section->vma + isec->output_offset + roff;
6402 if (symaddr - reladdr + max_branch_offset
6403 < 2 * max_branch_offset)
6404 continue;
6405 }
6406
6407 /* Look for an existing fixup to this address. */
6408 for (f = branch_fixups; f ; f = f->next)
6409 if (f->tsec == tsec && f->toff == toff)
6410 break;
6411
6412 if (f == NULL)
6413 {
6414 size_t size;
6415 unsigned long stub_rtype;
6416
6417 val = trampoff - roff;
6418 if (val >= max_branch_offset)
6419 /* Oh dear, we can't reach a trampoline. Don't try to add
6420 one. We'll report an error later. */
6421 continue;
6422
6423 if (bfd_link_pic (link_info))
6424 {
6425 size = 4 * ARRAY_SIZE (shared_stub_entry);
6426 insn_offset = 12;
6427 }
6428 else
6429 {
6430 size = 4 * ARRAY_SIZE (stub_entry);
6431 insn_offset = 0;
6432 }
6433 stub_rtype = R_PPC_RELAX;
6434 if (tsec == htab->elf.splt
6435 || tsec == htab->glink)
6436 {
6437 stub_rtype = R_PPC_RELAX_PLT;
6438 if (r_type == R_PPC_PLTREL24)
6439 stub_rtype = R_PPC_RELAX_PLTREL24;
6440 }
6441
6442 /* Hijack the old relocation. Since we need two
6443 relocations for this use a "composite" reloc. */
6444 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
6445 stub_rtype);
6446 irel->r_offset = trampoff + insn_offset;
6447 if (r_type == R_PPC_PLTREL24
6448 && stub_rtype != R_PPC_RELAX_PLTREL24)
6449 irel->r_addend = 0;
6450
6451 /* Record the fixup so we don't do it again this section. */
6452 f = bfd_malloc (sizeof (*f));
6453 f->next = branch_fixups;
6454 f->tsec = tsec;
6455 f->toff = toff;
6456 f->trampoff = trampoff;
6457 branch_fixups = f;
6458
6459 trampoff += size;
6460 changes++;
6461 }
6462 else
6463 {
6464 val = f->trampoff - roff;
6465 if (val >= max_branch_offset)
6466 continue;
6467
6468 /* Nop out the reloc, since we're finalizing things here. */
6469 irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
6470 }
6471
6472 /* Get the section contents. */
6473 if (contents == NULL)
6474 {
6475 /* Get cached copy if it exists. */
6476 if (elf_section_data (isec)->this_hdr.contents != NULL)
6477 contents = elf_section_data (isec)->this_hdr.contents;
6478 /* Go get them off disk. */
6479 else if (!bfd_malloc_and_get_section (abfd, isec, &contents))
6480 goto error_return;
6481 }
6482
6483 /* Fix up the existing branch to hit the trampoline. */
6484 hit_addr = contents + roff;
6485 switch (r_type)
6486 {
6487 case R_PPC_REL24:
6488 case R_PPC_LOCAL24PC:
6489 case R_PPC_PLTREL24:
6490 t0 = bfd_get_32 (abfd, hit_addr);
6491 t0 &= ~0x3fffffc;
6492 t0 |= val & 0x3fffffc;
6493 bfd_put_32 (abfd, t0, hit_addr);
6494 break;
6495
6496 case R_PPC_REL14:
6497 case R_PPC_REL14_BRTAKEN:
6498 case R_PPC_REL14_BRNTAKEN:
6499 t0 = bfd_get_32 (abfd, hit_addr);
6500 t0 &= ~0xfffc;
6501 t0 |= val & 0xfffc;
6502 bfd_put_32 (abfd, t0, hit_addr);
6503 break;
6504 }
6505 }
6506
6507 while (branch_fixups != NULL)
6508 {
6509 struct one_branch_fixup *f = branch_fixups;
6510 branch_fixups = branch_fixups->next;
6511 free (f);
6512 }
6513 }
6514
6515 workaround_change = FALSE;
6516 newsize = trampoff;
6517 if (htab->params->ppc476_workaround
6518 && (!bfd_link_relocatable (link_info)
6519 || isec->output_section->alignment_power >= htab->params->pagesize_p2))
6520 {
6521 bfd_vma addr, end_addr;
6522 unsigned int crossings;
6523 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
6524
6525 addr = isec->output_section->vma + isec->output_offset;
6526 end_addr = addr + trampoff;
6527 addr &= -pagesize;
6528 crossings = ((end_addr & -pagesize) - addr) >> htab->params->pagesize_p2;
6529 if (crossings != 0)
6530 {
6531 /* Keep space aligned, to ensure the patch code itself does
6532 not cross a page. Don't decrease size calculated on a
6533 previous pass as otherwise we might never settle on a layout. */
6534 newsize = 15 - ((end_addr - 1) & 15);
6535 newsize += crossings * 16;
6536 if (relax_info->workaround_size < newsize)
6537 {
6538 relax_info->workaround_size = newsize;
6539 workaround_change = TRUE;
6540 }
6541 /* Ensure relocate_section is called. */
6542 isec->flags |= SEC_RELOC;
6543 }
6544 newsize = trampoff + relax_info->workaround_size;
6545 }
6546
6547 if (htab->params->pic_fixup > 0)
6548 {
6549 picfixup_size -= relax_info->picfixup_size;
6550 if (picfixup_size != 0)
6551 relax_info->picfixup_size += picfixup_size;
6552 newsize += relax_info->picfixup_size;
6553 }
6554
6555 if (changes != 0 || picfixup_size != 0 || workaround_change)
6556 isec->size = newsize;
6557
6558 if (isymbuf != NULL
6559 && symtab_hdr->contents != (unsigned char *) isymbuf)
6560 {
6561 if (! link_info->keep_memory)
6562 free (isymbuf);
6563 else
6564 {
6565 /* Cache the symbols for elf_link_input_bfd. */
6566 symtab_hdr->contents = (unsigned char *) isymbuf;
6567 }
6568 }
6569
6570 if (contents != NULL
6571 && elf_section_data (isec)->this_hdr.contents != contents)
6572 {
6573 if (!changes && !link_info->keep_memory)
6574 free (contents);
6575 else
6576 {
6577 /* Cache the section contents for elf_link_input_bfd. */
6578 elf_section_data (isec)->this_hdr.contents = contents;
6579 }
6580 }
6581
6582 changes += picfixup_size;
6583 if (changes != 0)
6584 {
6585 /* Append sufficient NOP relocs so we can write out relocation
6586 information for the trampolines. */
6587 Elf_Internal_Shdr *rel_hdr;
6588 Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count)
6589 * sizeof (*new_relocs));
6590 unsigned ix;
6591
6592 if (!new_relocs)
6593 goto error_return;
6594 memcpy (new_relocs, internal_relocs,
6595 isec->reloc_count * sizeof (*new_relocs));
6596 for (ix = changes; ix--;)
6597 {
6598 irel = new_relocs + ix + isec->reloc_count;
6599
6600 irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
6601 }
6602 if (internal_relocs != elf_section_data (isec)->relocs)
6603 free (internal_relocs);
6604 elf_section_data (isec)->relocs = new_relocs;
6605 isec->reloc_count += changes;
6606 rel_hdr = _bfd_elf_single_rel_hdr (isec);
6607 rel_hdr->sh_size += changes * rel_hdr->sh_entsize;
6608 }
6609 else if (elf_section_data (isec)->relocs != internal_relocs)
6610 free (internal_relocs);
6611
6612 *again = changes != 0 || workaround_change;
6613 return TRUE;
6614
6615 error_return:
6616 while (branch_fixups != NULL)
6617 {
6618 struct one_branch_fixup *f = branch_fixups;
6619 branch_fixups = branch_fixups->next;
6620 free (f);
6621 }
6622 if ((unsigned char *) isymbuf != symtab_hdr->contents)
6623 free (isymbuf);
6624 if (elf_section_data (isec)->this_hdr.contents != contents)
6625 free (contents);
6626 if (elf_section_data (isec)->relocs != internal_relocs)
6627 free (internal_relocs);
6628 return FALSE;
6629 }
6630 \f
6631 /* What to do when ld finds relocations against symbols defined in
6632 discarded sections. */
6633
6634 static unsigned int
6635 ppc_elf_action_discarded (asection *sec)
6636 {
6637 if (strcmp (".fixup", sec->name) == 0)
6638 return 0;
6639
6640 if (strcmp (".got2", sec->name) == 0)
6641 return 0;
6642
6643 return _bfd_elf_default_action_discarded (sec);
6644 }
6645 \f
6646 /* Fill in the address for a pointer generated in a linker section. */
6647
6648 static bfd_vma
6649 elf_finish_pointer_linker_section (bfd *input_bfd,
6650 elf_linker_section_t *lsect,
6651 struct elf_link_hash_entry *h,
6652 bfd_vma relocation,
6653 const Elf_Internal_Rela *rel)
6654 {
6655 elf_linker_section_pointers_t *linker_section_ptr;
6656
6657 BFD_ASSERT (lsect != NULL);
6658
6659 if (h != NULL)
6660 {
6661 /* Handle global symbol. */
6662 struct ppc_elf_link_hash_entry *eh;
6663
6664 eh = (struct ppc_elf_link_hash_entry *) h;
6665 BFD_ASSERT (eh->elf.def_regular);
6666 linker_section_ptr = eh->linker_section_pointer;
6667 }
6668 else
6669 {
6670 /* Handle local symbol. */
6671 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
6672
6673 BFD_ASSERT (is_ppc_elf (input_bfd));
6674 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
6675 linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx];
6676 }
6677
6678 linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr,
6679 rel->r_addend,
6680 lsect);
6681 BFD_ASSERT (linker_section_ptr != NULL);
6682
6683 /* Offset will always be a multiple of four, so use the bottom bit
6684 as a "written" flag. */
6685 if ((linker_section_ptr->offset & 1) == 0)
6686 {
6687 bfd_put_32 (lsect->section->owner,
6688 relocation + linker_section_ptr->addend,
6689 lsect->section->contents + linker_section_ptr->offset);
6690 linker_section_ptr->offset += 1;
6691 }
6692
6693 relocation = (lsect->section->output_section->vma
6694 + lsect->section->output_offset
6695 + linker_section_ptr->offset - 1
6696 - SYM_VAL (lsect->sym));
6697
6698 #ifdef DEBUG
6699 fprintf (stderr,
6700 "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
6701 lsect->name, (long) relocation, (long) relocation);
6702 #endif
6703
6704 return relocation;
6705 }
6706
6707 #define PPC_LO(v) ((v) & 0xffff)
6708 #define PPC_HI(v) (((v) >> 16) & 0xffff)
6709 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
6710
6711 static void
6712 write_glink_stub (struct elf_link_hash_entry *h, struct plt_entry *ent,
6713 asection *plt_sec, unsigned char *p,
6714 struct bfd_link_info *info)
6715 {
6716 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
6717 bfd *output_bfd = info->output_bfd;
6718 bfd_vma plt;
6719 unsigned char *end = p + GLINK_ENTRY_SIZE (htab, h);
6720
6721 if (h != NULL
6722 && h == htab->tls_get_addr
6723 && !htab->params->no_tls_get_addr_opt)
6724 {
6725 bfd_put_32 (output_bfd, LWZ_11_3, p);
6726 p += 4;
6727 bfd_put_32 (output_bfd, LWZ_12_3 + 4, p);
6728 p += 4;
6729 bfd_put_32 (output_bfd, MR_0_3, p);
6730 p += 4;
6731 bfd_put_32 (output_bfd, CMPWI_11_0, p);
6732 p += 4;
6733 bfd_put_32 (output_bfd, ADD_3_12_2, p);
6734 p += 4;
6735 bfd_put_32 (output_bfd, BEQLR, p);
6736 p += 4;
6737 bfd_put_32 (output_bfd, MR_3_0, p);
6738 p += 4;
6739 bfd_put_32 (output_bfd, NOP, p);
6740 p += 4;
6741 }
6742
6743 plt = ((ent->plt.offset & ~1)
6744 + plt_sec->output_section->vma
6745 + plt_sec->output_offset);
6746
6747 if (bfd_link_pic (info))
6748 {
6749 bfd_vma got = 0;
6750
6751 if (ent->addend >= 32768)
6752 got = (ent->addend
6753 + ent->sec->output_section->vma
6754 + ent->sec->output_offset);
6755 else if (htab->elf.hgot != NULL)
6756 got = SYM_VAL (htab->elf.hgot);
6757
6758 plt -= got;
6759
6760 if (plt + 0x8000 < 0x10000)
6761 bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p);
6762 else
6763 {
6764 bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p);
6765 p += 4;
6766 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
6767 }
6768 }
6769 else
6770 {
6771 bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p);
6772 p += 4;
6773 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
6774 }
6775 p += 4;
6776 bfd_put_32 (output_bfd, MTCTR_11, p);
6777 p += 4;
6778 bfd_put_32 (output_bfd, BCTR, p);
6779 p += 4;
6780 while (p < end)
6781 {
6782 bfd_put_32 (output_bfd, htab->params->ppc476_workaround ? BA : NOP, p);
6783 p += 4;
6784 }
6785 }
6786
6787 /* Return true if symbol is defined statically. */
6788
6789 static bfd_boolean
6790 is_static_defined (struct elf_link_hash_entry *h)
6791 {
6792 return ((h->root.type == bfd_link_hash_defined
6793 || h->root.type == bfd_link_hash_defweak)
6794 && h->root.u.def.section != NULL
6795 && h->root.u.def.section->output_section != NULL);
6796 }
6797
6798 /* If INSN is an opcode that may be used with an @tls operand, return
6799 the transformed insn for TLS optimisation, otherwise return 0. If
6800 REG is non-zero only match an insn with RB or RA equal to REG. */
6801
6802 unsigned int
6803 _bfd_elf_ppc_at_tls_transform (unsigned int insn, unsigned int reg)
6804 {
6805 unsigned int rtra;
6806
6807 if ((insn & (0x3fu << 26)) != 31 << 26)
6808 return 0;
6809
6810 if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
6811 rtra = insn & ((1 << 26) - (1 << 16));
6812 else if (((insn >> 16) & 0x1f) == reg)
6813 rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
6814 else
6815 return 0;
6816
6817 if ((insn & (0x3ff << 1)) == 266 << 1)
6818 /* add -> addi. */
6819 insn = 14 << 26;
6820 else if ((insn & (0x1f << 1)) == 23 << 1
6821 && ((insn & (0x1f << 6)) < 14 << 6
6822 || ((insn & (0x1f << 6)) >= 16 << 6
6823 && (insn & (0x1f << 6)) < 24 << 6)))
6824 /* load and store indexed -> dform. */
6825 insn = (32u | ((insn >> 6) & 0x1f)) << 26;
6826 else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
6827 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
6828 insn = ((58u | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
6829 else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
6830 /* lwax -> lwa. */
6831 insn = (58u << 26) | 2;
6832 else
6833 return 0;
6834 insn |= rtra;
6835 return insn;
6836 }
6837
6838 /* If INSN is an opcode that may be used with an @tprel operand, return
6839 the transformed insn for an undefined weak symbol, ie. with the
6840 thread pointer REG operand removed. Otherwise return 0. */
6841
6842 unsigned int
6843 _bfd_elf_ppc_at_tprel_transform (unsigned int insn, unsigned int reg)
6844 {
6845 if ((insn & (0x1f << 16)) == reg << 16
6846 && ((insn & (0x3fu << 26)) == 14u << 26 /* addi */
6847 || (insn & (0x3fu << 26)) == 15u << 26 /* addis */
6848 || (insn & (0x3fu << 26)) == 32u << 26 /* lwz */
6849 || (insn & (0x3fu << 26)) == 34u << 26 /* lbz */
6850 || (insn & (0x3fu << 26)) == 36u << 26 /* stw */
6851 || (insn & (0x3fu << 26)) == 38u << 26 /* stb */
6852 || (insn & (0x3fu << 26)) == 40u << 26 /* lhz */
6853 || (insn & (0x3fu << 26)) == 42u << 26 /* lha */
6854 || (insn & (0x3fu << 26)) == 44u << 26 /* sth */
6855 || (insn & (0x3fu << 26)) == 46u << 26 /* lmw */
6856 || (insn & (0x3fu << 26)) == 47u << 26 /* stmw */
6857 || (insn & (0x3fu << 26)) == 48u << 26 /* lfs */
6858 || (insn & (0x3fu << 26)) == 50u << 26 /* lfd */
6859 || (insn & (0x3fu << 26)) == 52u << 26 /* stfs */
6860 || (insn & (0x3fu << 26)) == 54u << 26 /* stfd */
6861 || ((insn & (0x3fu << 26)) == 58u << 26 /* lwa,ld,lmd */
6862 && (insn & 3) != 1)
6863 || ((insn & (0x3fu << 26)) == 62u << 26 /* std, stmd */
6864 && ((insn & 3) == 0 || (insn & 3) == 3))))
6865 {
6866 insn &= ~(0x1f << 16);
6867 }
6868 else if ((insn & (0x1f << 21)) == reg << 21
6869 && ((insn & (0x3eu << 26)) == 24u << 26 /* ori, oris */
6870 || (insn & (0x3eu << 26)) == 26u << 26 /* xori,xoris */
6871 || (insn & (0x3eu << 26)) == 28u << 26 /* andi,andis */))
6872 {
6873 insn &= ~(0x1f << 21);
6874 insn |= (insn & (0x1f << 16)) << 5;
6875 if ((insn & (0x3eu << 26)) == 26u << 26 /* xori,xoris */)
6876 insn -= 2 >> 26; /* convert to ori,oris */
6877 }
6878 else
6879 insn = 0;
6880 return insn;
6881 }
6882
6883 static bfd_boolean
6884 is_insn_ds_form (unsigned int insn)
6885 {
6886 return ((insn & (0x3fu << 26)) == 58u << 26 /* ld,ldu,lwa */
6887 || (insn & (0x3fu << 26)) == 62u << 26 /* std,stdu,stq */
6888 || (insn & (0x3fu << 26)) == 57u << 26 /* lfdp */
6889 || (insn & (0x3fu << 26)) == 61u << 26 /* stfdp */);
6890 }
6891
6892 static bfd_boolean
6893 is_insn_dq_form (unsigned int insn)
6894 {
6895 return ((insn & (0x3fu << 26)) == 56u << 26 /* lq */
6896 || ((insn & (0x3fu << 26)) == (61u << 26) /* lxv, stxv */
6897 && (insn & 3) == 1));
6898 }
6899
6900 /* The RELOCATE_SECTION function is called by the ELF backend linker
6901 to handle the relocations for a section.
6902
6903 The relocs are always passed as Rela structures; if the section
6904 actually uses Rel structures, the r_addend field will always be
6905 zero.
6906
6907 This function is responsible for adjust the section contents as
6908 necessary, and (if using Rela relocs and generating a
6909 relocatable output file) adjusting the reloc addend as
6910 necessary.
6911
6912 This function does not have to worry about setting the reloc
6913 address or the reloc symbol index.
6914
6915 LOCAL_SYMS is a pointer to the swapped in local symbols.
6916
6917 LOCAL_SECTIONS is an array giving the section in the input file
6918 corresponding to the st_shndx field of each local symbol.
6919
6920 The global hash table entry for the global symbols can be found
6921 via elf_sym_hashes (input_bfd).
6922
6923 When generating relocatable output, this function must handle
6924 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
6925 going to be the section symbol corresponding to the output
6926 section, which means that the addend must be adjusted
6927 accordingly. */
6928
6929 static bfd_boolean
6930 ppc_elf_relocate_section (bfd *output_bfd,
6931 struct bfd_link_info *info,
6932 bfd *input_bfd,
6933 asection *input_section,
6934 bfd_byte *contents,
6935 Elf_Internal_Rela *relocs,
6936 Elf_Internal_Sym *local_syms,
6937 asection **local_sections)
6938 {
6939 Elf_Internal_Shdr *symtab_hdr;
6940 struct elf_link_hash_entry **sym_hashes;
6941 struct ppc_elf_link_hash_table *htab;
6942 Elf_Internal_Rela *rel;
6943 Elf_Internal_Rela *wrel;
6944 Elf_Internal_Rela *relend;
6945 Elf_Internal_Rela outrel;
6946 asection *got2;
6947 bfd_vma *local_got_offsets;
6948 bfd_boolean ret = TRUE;
6949 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
6950 bfd_boolean is_vxworks_tls;
6951 unsigned int picfixup_size = 0;
6952 struct ppc_elf_relax_info *relax_info = NULL;
6953
6954 #ifdef DEBUG
6955 _bfd_error_handler ("ppc_elf_relocate_section called for %pB section %pA, "
6956 "%ld relocations%s",
6957 input_bfd, input_section,
6958 (long) input_section->reloc_count,
6959 (bfd_link_relocatable (info)) ? " (relocatable)" : "");
6960 #endif
6961
6962 if (!is_ppc_elf (input_bfd))
6963 {
6964 bfd_set_error (bfd_error_wrong_format);
6965 return FALSE;
6966 }
6967
6968 got2 = bfd_get_section_by_name (input_bfd, ".got2");
6969
6970 /* Initialize howto table if not already done. */
6971 if (!ppc_elf_howto_table[R_PPC_ADDR32])
6972 ppc_elf_howto_init ();
6973
6974 htab = ppc_elf_hash_table (info);
6975 local_got_offsets = elf_local_got_offsets (input_bfd);
6976 symtab_hdr = &elf_symtab_hdr (input_bfd);
6977 sym_hashes = elf_sym_hashes (input_bfd);
6978 /* We have to handle relocations in vxworks .tls_vars sections
6979 specially, because the dynamic loader is 'weird'. */
6980 is_vxworks_tls = (htab->elf.target_os == is_vxworks && bfd_link_pic (info)
6981 && !strcmp (input_section->output_section->name,
6982 ".tls_vars"));
6983 if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET)
6984 relax_info = elf_section_data (input_section)->sec_info;
6985 rel = wrel = relocs;
6986 relend = relocs + input_section->reloc_count;
6987 for (; rel < relend; wrel++, rel++)
6988 {
6989 enum elf_ppc_reloc_type r_type;
6990 bfd_vma addend;
6991 bfd_reloc_status_type r;
6992 Elf_Internal_Sym *sym;
6993 asection *sec;
6994 struct elf_link_hash_entry *h;
6995 const char *sym_name;
6996 reloc_howto_type *howto;
6997 unsigned long r_symndx;
6998 bfd_vma relocation;
6999 bfd_vma branch_bit, from;
7000 bfd_boolean unresolved_reloc, save_unresolved_reloc;
7001 bfd_boolean warned;
7002 unsigned int tls_type, tls_mask, tls_gd;
7003 struct plt_entry **ifunc, **plt_list;
7004 struct reloc_howto_struct alt_howto;
7005
7006 again:
7007 r_type = ELF32_R_TYPE (rel->r_info);
7008 sym = NULL;
7009 sec = NULL;
7010 h = NULL;
7011 unresolved_reloc = FALSE;
7012 warned = FALSE;
7013 r_symndx = ELF32_R_SYM (rel->r_info);
7014
7015 if (r_symndx < symtab_hdr->sh_info)
7016 {
7017 sym = local_syms + r_symndx;
7018 sec = local_sections[r_symndx];
7019 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
7020
7021 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
7022 }
7023 else
7024 {
7025 bfd_boolean ignored;
7026
7027 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
7028 r_symndx, symtab_hdr, sym_hashes,
7029 h, sec, relocation,
7030 unresolved_reloc, warned, ignored);
7031
7032 sym_name = h->root.root.string;
7033 }
7034
7035 if (sec != NULL && discarded_section (sec))
7036 {
7037 /* For relocs against symbols from removed linkonce sections,
7038 or sections discarded by a linker script, we just want the
7039 section contents zeroed. Avoid any special processing. */
7040 howto = NULL;
7041 if (r_type < R_PPC_max)
7042 howto = ppc_elf_howto_table[r_type];
7043
7044 _bfd_clear_contents (howto, input_bfd, input_section,
7045 contents, rel->r_offset);
7046 wrel->r_offset = rel->r_offset;
7047 wrel->r_info = 0;
7048 wrel->r_addend = 0;
7049
7050 /* For ld -r, remove relocations in debug sections against
7051 symbols defined in discarded sections. Not done for
7052 non-debug to preserve relocs in .eh_frame which the
7053 eh_frame editing code expects to be present. */
7054 if (bfd_link_relocatable (info)
7055 && (input_section->flags & SEC_DEBUGGING))
7056 wrel--;
7057
7058 continue;
7059 }
7060
7061 if (bfd_link_relocatable (info))
7062 {
7063 if (got2 != NULL
7064 && r_type == R_PPC_PLTREL24
7065 && rel->r_addend != 0)
7066 {
7067 /* R_PPC_PLTREL24 is rather special. If non-zero, the
7068 addend specifies the GOT pointer offset within .got2. */
7069 rel->r_addend += got2->output_offset;
7070 }
7071 if (r_type != R_PPC_RELAX_PLT
7072 && r_type != R_PPC_RELAX_PLTREL24
7073 && r_type != R_PPC_RELAX)
7074 goto copy_reloc;
7075 }
7076
7077 /* TLS optimizations. Replace instruction sequences and relocs
7078 based on information we collected in tls_optimize. We edit
7079 RELOCS so that --emit-relocs will output something sensible
7080 for the final instruction stream. */
7081 tls_mask = 0;
7082 tls_gd = 0;
7083 if (h != NULL)
7084 tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
7085 else if (local_got_offsets != NULL)
7086 {
7087 struct plt_entry **local_plt;
7088 char *lgot_masks;
7089 local_plt
7090 = (struct plt_entry **) (local_got_offsets + symtab_hdr->sh_info);
7091 lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
7092 tls_mask = lgot_masks[r_symndx];
7093 }
7094
7095 /* Ensure reloc mapping code below stays sane. */
7096 if ((R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TLSGD16 & 3)
7097 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
7098 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
7099 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3)
7100 || (R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TPREL16 & 3)
7101 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3)
7102 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3)
7103 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3))
7104 abort ();
7105 switch (r_type)
7106 {
7107 default:
7108 break;
7109
7110 case R_PPC_GOT_TPREL16:
7111 case R_PPC_GOT_TPREL16_LO:
7112 if ((tls_mask & TLS_TLS) != 0
7113 && (tls_mask & TLS_TPREL) == 0)
7114 {
7115 bfd_vma insn;
7116
7117 insn = bfd_get_32 (input_bfd,
7118 contents + rel->r_offset - d_offset);
7119 insn &= 31 << 21;
7120 insn |= 0x3c020000; /* addis 0,2,0 */
7121 bfd_put_32 (input_bfd, insn,
7122 contents + rel->r_offset - d_offset);
7123 r_type = R_PPC_TPREL16_HA;
7124 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7125 }
7126 break;
7127
7128 case R_PPC_TLS:
7129 if ((tls_mask & TLS_TLS) != 0
7130 && (tls_mask & TLS_TPREL) == 0)
7131 {
7132 bfd_vma insn;
7133
7134 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7135 insn = _bfd_elf_ppc_at_tls_transform (insn, 2);
7136 if (insn == 0)
7137 abort ();
7138 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7139 r_type = R_PPC_TPREL16_LO;
7140 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7141
7142 /* Was PPC_TLS which sits on insn boundary, now
7143 PPC_TPREL16_LO which is at low-order half-word. */
7144 rel->r_offset += d_offset;
7145 }
7146 break;
7147
7148 case R_PPC_GOT_TLSGD16_HI:
7149 case R_PPC_GOT_TLSGD16_HA:
7150 tls_gd = TLS_GDIE;
7151 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7152 goto tls_gdld_hi;
7153 break;
7154
7155 case R_PPC_GOT_TLSLD16_HI:
7156 case R_PPC_GOT_TLSLD16_HA:
7157 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7158 {
7159 tls_gdld_hi:
7160 if ((tls_mask & tls_gd) != 0)
7161 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7162 + R_PPC_GOT_TPREL16);
7163 else
7164 {
7165 rel->r_offset -= d_offset;
7166 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
7167 r_type = R_PPC_NONE;
7168 }
7169 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7170 }
7171 break;
7172
7173 case R_PPC_GOT_TLSGD16:
7174 case R_PPC_GOT_TLSGD16_LO:
7175 tls_gd = TLS_GDIE;
7176 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7177 goto tls_ldgd_opt;
7178 break;
7179
7180 case R_PPC_GOT_TLSLD16:
7181 case R_PPC_GOT_TLSLD16_LO:
7182 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7183 {
7184 unsigned int insn1, insn2;
7185 bfd_vma offset;
7186
7187 tls_ldgd_opt:
7188 offset = (bfd_vma) -1;
7189 /* If not using the newer R_PPC_TLSGD/LD to mark
7190 __tls_get_addr calls, we must trust that the call
7191 stays with its arg setup insns, ie. that the next
7192 reloc is the __tls_get_addr call associated with
7193 the current reloc. Edit both insns. */
7194 if (input_section->nomark_tls_get_addr
7195 && rel + 1 < relend
7196 && branch_reloc_hash_match (input_bfd, rel + 1,
7197 htab->tls_get_addr))
7198 offset = rel[1].r_offset;
7199 /* We read the low GOT_TLS insn because we need to keep
7200 the destination reg. It may be something other than
7201 the usual r3, and moved to r3 before the call by
7202 intervening code. */
7203 insn1 = bfd_get_32 (input_bfd,
7204 contents + rel->r_offset - d_offset);
7205 if ((tls_mask & tls_gd) != 0)
7206 {
7207 /* IE */
7208 insn1 &= (0x1f << 21) | (0x1f << 16);
7209 insn1 |= 32u << 26; /* lwz */
7210 if (offset != (bfd_vma) -1)
7211 {
7212 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7213 insn2 = 0x7c631214; /* add 3,3,2 */
7214 bfd_put_32 (input_bfd, insn2, contents + offset);
7215 }
7216 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
7217 + R_PPC_GOT_TPREL16);
7218 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7219 }
7220 else
7221 {
7222 /* LE */
7223 insn1 &= 0x1f << 21;
7224 insn1 |= 0x3c020000; /* addis r,2,0 */
7225 if (tls_gd == 0)
7226 {
7227 /* Was an LD reloc. */
7228 for (r_symndx = 0;
7229 r_symndx < symtab_hdr->sh_info;
7230 r_symndx++)
7231 if (local_sections[r_symndx] == sec)
7232 break;
7233 if (r_symndx >= symtab_hdr->sh_info)
7234 r_symndx = STN_UNDEF;
7235 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
7236 if (r_symndx != STN_UNDEF)
7237 rel->r_addend -= (local_syms[r_symndx].st_value
7238 + sec->output_offset
7239 + sec->output_section->vma);
7240 }
7241 r_type = R_PPC_TPREL16_HA;
7242 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7243 if (offset != (bfd_vma) -1)
7244 {
7245 rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7246 rel[1].r_offset = offset + d_offset;
7247 rel[1].r_addend = rel->r_addend;
7248 insn2 = 0x38630000; /* addi 3,3,0 */
7249 bfd_put_32 (input_bfd, insn2, contents + offset);
7250 }
7251 }
7252 bfd_put_32 (input_bfd, insn1,
7253 contents + rel->r_offset - d_offset);
7254 if (tls_gd == 0)
7255 {
7256 /* We changed the symbol on an LD reloc. Start over
7257 in order to get h, sym, sec etc. right. */
7258 goto again;
7259 }
7260 }
7261 break;
7262
7263 case R_PPC_TLSGD:
7264 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
7265 && rel + 1 < relend)
7266 {
7267 unsigned int insn2;
7268 bfd_vma offset = rel->r_offset;
7269
7270 if (is_plt_seq_reloc (ELF32_R_TYPE (rel[1].r_info)))
7271 {
7272 bfd_put_32 (input_bfd, NOP, contents + offset);
7273 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7274 break;
7275 }
7276
7277 if ((tls_mask & TLS_GDIE) != 0)
7278 {
7279 /* IE */
7280 r_type = R_PPC_NONE;
7281 insn2 = 0x7c631214; /* add 3,3,2 */
7282 }
7283 else
7284 {
7285 /* LE */
7286 r_type = R_PPC_TPREL16_LO;
7287 rel->r_offset += d_offset;
7288 insn2 = 0x38630000; /* addi 3,3,0 */
7289 }
7290 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7291 bfd_put_32 (input_bfd, insn2, contents + offset);
7292 /* Zap the reloc on the _tls_get_addr call too. */
7293 BFD_ASSERT (offset == rel[1].r_offset);
7294 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7295 }
7296 break;
7297
7298 case R_PPC_TLSLD:
7299 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
7300 && rel + 1 < relend)
7301 {
7302 unsigned int insn2;
7303
7304 if (is_plt_seq_reloc (ELF32_R_TYPE (rel[1].r_info)))
7305 {
7306 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
7307 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7308 break;
7309 }
7310
7311 for (r_symndx = 0;
7312 r_symndx < symtab_hdr->sh_info;
7313 r_symndx++)
7314 if (local_sections[r_symndx] == sec)
7315 break;
7316 if (r_symndx >= symtab_hdr->sh_info)
7317 r_symndx = STN_UNDEF;
7318 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
7319 if (r_symndx != STN_UNDEF)
7320 rel->r_addend -= (local_syms[r_symndx].st_value
7321 + sec->output_offset
7322 + sec->output_section->vma);
7323
7324 rel->r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7325 rel->r_offset += d_offset;
7326 insn2 = 0x38630000; /* addi 3,3,0 */
7327 bfd_put_32 (input_bfd, insn2,
7328 contents + rel->r_offset - d_offset);
7329 /* Zap the reloc on the _tls_get_addr call too. */
7330 BFD_ASSERT (rel->r_offset - d_offset == rel[1].r_offset);
7331 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7332 goto again;
7333 }
7334 break;
7335 }
7336
7337 /* Handle other relocations that tweak non-addend part of insn. */
7338 branch_bit = 0;
7339 switch (r_type)
7340 {
7341 default:
7342 break;
7343
7344 /* Branch taken prediction relocations. */
7345 case R_PPC_ADDR14_BRTAKEN:
7346 case R_PPC_REL14_BRTAKEN:
7347 branch_bit = BRANCH_PREDICT_BIT;
7348 /* Fall through. */
7349
7350 /* Branch not taken prediction relocations. */
7351 case R_PPC_ADDR14_BRNTAKEN:
7352 case R_PPC_REL14_BRNTAKEN:
7353 {
7354 unsigned int insn;
7355
7356 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7357 insn &= ~BRANCH_PREDICT_BIT;
7358 insn |= branch_bit;
7359
7360 from = (rel->r_offset
7361 + input_section->output_offset
7362 + input_section->output_section->vma);
7363
7364 /* Invert 'y' bit if not the default. */
7365 if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
7366 insn ^= BRANCH_PREDICT_BIT;
7367
7368 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7369 }
7370 break;
7371
7372 case R_PPC_PLT16_HA:
7373 {
7374 unsigned int insn;
7375
7376 insn = bfd_get_32 (input_bfd,
7377 contents + rel->r_offset - d_offset);
7378 if ((insn & (0x3fu << 26)) == 15u << 26
7379 && (insn & (0x1f << 16)) != 0)
7380 {
7381 if (!bfd_link_pic (info))
7382 {
7383 /* Convert addis to lis. */
7384 insn &= ~(0x1f << 16);
7385 bfd_put_32 (input_bfd, insn,
7386 contents + rel->r_offset - d_offset);
7387 }
7388 }
7389 else if (bfd_link_pic (info))
7390 info->callbacks->einfo
7391 (_("%P: %H: error: %s with unexpected instruction %x\n"),
7392 input_bfd, input_section, rel->r_offset,
7393 "R_PPC_PLT16_HA", insn);
7394 }
7395 break;
7396 }
7397
7398 if (ELIMINATE_COPY_RELOCS
7399 && h != NULL
7400 && !h->def_regular
7401 && h->protected_def
7402 && ppc_elf_hash_entry (h)->has_addr16_ha
7403 && ppc_elf_hash_entry (h)->has_addr16_lo
7404 && htab->params->pic_fixup > 0)
7405 {
7406 /* Convert lis;addi or lis;load/store accessing a protected
7407 variable defined in a shared library to PIC. */
7408 unsigned int insn;
7409
7410 if (r_type == R_PPC_ADDR16_HA)
7411 {
7412 insn = bfd_get_32 (input_bfd,
7413 contents + rel->r_offset - d_offset);
7414 if ((insn & (0x3fu << 26)) == (15u << 26)
7415 && (insn & (0x1f << 16)) == 0 /* lis */)
7416 {
7417 bfd_byte *p;
7418 bfd_vma off;
7419 bfd_vma got_addr;
7420
7421 p = (contents + input_section->size
7422 - relax_info->workaround_size
7423 - relax_info->picfixup_size
7424 + picfixup_size);
7425 off = (p - contents) - (rel->r_offset - d_offset);
7426 if (off > 0x1fffffc || (off & 3) != 0)
7427 info->callbacks->einfo
7428 (_("%H: fixup branch overflow\n"),
7429 input_bfd, input_section, rel->r_offset);
7430
7431 bfd_put_32 (input_bfd, B | off,
7432 contents + rel->r_offset - d_offset);
7433 got_addr = (htab->elf.sgot->output_section->vma
7434 + htab->elf.sgot->output_offset
7435 + (h->got.offset & ~1));
7436 wrel->r_offset = (p - contents) + d_offset;
7437 wrel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_HA);
7438 wrel->r_addend = got_addr;
7439 insn &= ~0xffff;
7440 insn |= ((unsigned int) (got_addr + 0x8000) >> 16) & 0xffff;
7441 bfd_put_32 (input_bfd, insn, p);
7442
7443 /* Convert lis to lwz, loading address from GOT. */
7444 insn &= ~0xffff;
7445 insn ^= (32u ^ 15u) << 26;
7446 insn |= (insn & (0x1f << 21)) >> 5;
7447 insn |= got_addr & 0xffff;
7448 bfd_put_32 (input_bfd, insn, p + 4);
7449
7450 bfd_put_32 (input_bfd, B | ((-4 - off) & 0x3ffffff), p + 8);
7451 picfixup_size += 12;
7452
7453 /* Use one of the spare relocs, so --emit-relocs
7454 output is reasonable. */
7455 memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel));
7456 wrel++, rel++;
7457 rel->r_offset = wrel[-1].r_offset + 4;
7458 rel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_LO);
7459 rel->r_addend = wrel[-1].r_addend;
7460
7461 /* Continue on as if we had a got reloc, to output
7462 dynamic reloc. */
7463 r_type = R_PPC_GOT16_LO;
7464 }
7465 else
7466 _bfd_error_handler
7467 /* xgettext:c-format */
7468 (_("%pB(%pA+%#" PRIx64 "): error: "
7469 "%s with unexpected instruction %#x"),
7470 input_bfd, input_section, (uint64_t) rel->r_offset,
7471 "R_PPC_ADDR16_HA", insn);
7472 }
7473 else if (r_type == R_PPC_ADDR16_LO)
7474 {
7475 insn = bfd_get_32 (input_bfd,
7476 contents + rel->r_offset - d_offset);
7477 if ((insn & (0x3fu << 26)) == 14u << 26 /* addi */
7478 || (insn & (0x3fu << 26)) == 32u << 26 /* lwz */
7479 || (insn & (0x3fu << 26)) == 34u << 26 /* lbz */
7480 || (insn & (0x3fu << 26)) == 36u << 26 /* stw */
7481 || (insn & (0x3fu << 26)) == 38u << 26 /* stb */
7482 || (insn & (0x3fu << 26)) == 40u << 26 /* lhz */
7483 || (insn & (0x3fu << 26)) == 42u << 26 /* lha */
7484 || (insn & (0x3fu << 26)) == 44u << 26 /* sth */
7485 || (insn & (0x3fu << 26)) == 46u << 26 /* lmw */
7486 || (insn & (0x3fu << 26)) == 47u << 26 /* stmw */
7487 || (insn & (0x3fu << 26)) == 48u << 26 /* lfs */
7488 || (insn & (0x3fu << 26)) == 50u << 26 /* lfd */
7489 || (insn & (0x3fu << 26)) == 52u << 26 /* stfs */
7490 || (insn & (0x3fu << 26)) == 54u << 26 /* stfd */
7491 || ((insn & (0x3fu << 26)) == 58u << 26 /* lwa,ld,lmd */
7492 && (insn & 3) != 1)
7493 || ((insn & (0x3fu << 26)) == 62u << 26 /* std, stmd */
7494 && ((insn & 3) == 0 || (insn & 3) == 3)))
7495 {
7496 /* Arrange to apply the reloc addend, if any. */
7497 relocation = 0;
7498 unresolved_reloc = FALSE;
7499 rel->r_info = ELF32_R_INFO (0, r_type);
7500 }
7501 else
7502 _bfd_error_handler
7503 /* xgettext:c-format */
7504 (_("%pB(%pA+%#" PRIx64 "): error: "
7505 "%s with unexpected instruction %#x"),
7506 input_bfd, input_section, (uint64_t) rel->r_offset,
7507 "R_PPC_ADDR16_LO", insn);
7508 }
7509 }
7510
7511 ifunc = NULL;
7512 if (htab->elf.target_os != is_vxworks)
7513 {
7514 struct plt_entry *ent;
7515
7516 if (h != NULL)
7517 {
7518 if (h->type == STT_GNU_IFUNC)
7519 ifunc = &h->plt.plist;
7520 }
7521 else if (local_got_offsets != NULL
7522 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
7523 {
7524 struct plt_entry **local_plt;
7525
7526 local_plt = (struct plt_entry **) (local_got_offsets
7527 + symtab_hdr->sh_info);
7528 ifunc = local_plt + r_symndx;
7529 }
7530
7531 ent = NULL;
7532 if (ifunc != NULL
7533 && (!bfd_link_pic (info)
7534 || is_branch_reloc (r_type)
7535 || r_type == R_PPC_PLT16_LO
7536 || r_type == R_PPC_PLT16_HI
7537 || r_type == R_PPC_PLT16_HA))
7538 {
7539 addend = 0;
7540 if (bfd_link_pic (info)
7541 && (r_type == R_PPC_PLTREL24
7542 || r_type == R_PPC_PLT16_LO
7543 || r_type == R_PPC_PLT16_HI
7544 || r_type == R_PPC_PLT16_HA))
7545 addend = rel->r_addend;
7546 ent = find_plt_ent (ifunc, got2, addend);
7547 }
7548 if (ent != NULL)
7549 {
7550 if (bfd_link_pic (info)
7551 && ent->sec != got2
7552 && htab->plt_type != PLT_NEW
7553 && (!htab->elf.dynamic_sections_created
7554 || h == NULL
7555 || h->dynindx == -1))
7556 {
7557 /* Uh oh, we are going to create a pic glink stub
7558 for an ifunc (here for h == NULL and later in
7559 finish_dynamic_symbol for h != NULL), and
7560 apparently are using code compiled with
7561 -mbss-plt. The difficulty is that -mbss-plt code
7562 gives no indication via a magic PLTREL24 addend
7563 whether r30 is equal to _GLOBAL_OFFSET_TABLE_ or
7564 is pointing into a .got2 section (and how far
7565 into .got2). */
7566 info->callbacks->einfo
7567 /* xgettext:c-format */
7568 (_("%X%H: unsupported bss-plt -fPIC ifunc %s\n"),
7569 input_bfd, input_section, rel->r_offset, sym_name);
7570 }
7571
7572 unresolved_reloc = FALSE;
7573 if (htab->plt_type == PLT_NEW
7574 || !htab->elf.dynamic_sections_created
7575 || h == NULL
7576 || h->dynindx == -1)
7577 relocation = (htab->glink->output_section->vma
7578 + htab->glink->output_offset
7579 + (ent->glink_offset & ~1));
7580 else
7581 relocation = (htab->elf.splt->output_section->vma
7582 + htab->elf.splt->output_offset
7583 + ent->plt.offset);
7584 }
7585 }
7586
7587 addend = rel->r_addend;
7588 save_unresolved_reloc = unresolved_reloc;
7589 howto = NULL;
7590 if (r_type < R_PPC_max)
7591 howto = ppc_elf_howto_table[r_type];
7592
7593 switch (r_type)
7594 {
7595 default:
7596 break;
7597
7598 case R_PPC_TPREL16_HA:
7599 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
7600 {
7601 bfd_byte *p = contents + (rel->r_offset & ~3);
7602 unsigned int insn = bfd_get_32 (input_bfd, p);
7603 if ((insn & ((0x3fu << 26) | 0x1f << 16))
7604 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */)
7605 /* xgettext:c-format */
7606 info->callbacks->minfo
7607 (_("%H: warning: %s unexpected insn %#x.\n"),
7608 input_bfd, input_section, rel->r_offset, howto->name, insn);
7609 else
7610 bfd_put_32 (input_bfd, NOP, p);
7611 }
7612 break;
7613
7614 case R_PPC_TPREL16_LO:
7615 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
7616 {
7617 bfd_byte *p = contents + (rel->r_offset & ~3);
7618 unsigned int insn = bfd_get_32 (input_bfd, p);
7619 insn &= ~(0x1f << 16);
7620 insn |= 2 << 16;
7621 bfd_put_32 (input_bfd, insn, p);
7622 }
7623 break;
7624 }
7625
7626 tls_type = 0;
7627 switch (r_type)
7628 {
7629 default:
7630 /* xgettext:c-format */
7631 _bfd_error_handler (_("%pB: %s unsupported"),
7632 input_bfd, howto->name);
7633
7634 bfd_set_error (bfd_error_bad_value);
7635 ret = FALSE;
7636 goto copy_reloc;
7637
7638 case R_PPC_NONE:
7639 case R_PPC_TLS:
7640 case R_PPC_TLSGD:
7641 case R_PPC_TLSLD:
7642 case R_PPC_EMB_MRKREF:
7643 case R_PPC_GNU_VTINHERIT:
7644 case R_PPC_GNU_VTENTRY:
7645 goto copy_reloc;
7646
7647 /* GOT16 relocations. Like an ADDR16 using the symbol's
7648 address in the GOT as relocation value instead of the
7649 symbol's value itself. Also, create a GOT entry for the
7650 symbol and put the symbol value there. */
7651 case R_PPC_GOT_TLSGD16:
7652 case R_PPC_GOT_TLSGD16_LO:
7653 case R_PPC_GOT_TLSGD16_HI:
7654 case R_PPC_GOT_TLSGD16_HA:
7655 tls_type = TLS_TLS | TLS_GD;
7656 goto dogot;
7657
7658 case R_PPC_GOT_TLSLD16:
7659 case R_PPC_GOT_TLSLD16_LO:
7660 case R_PPC_GOT_TLSLD16_HI:
7661 case R_PPC_GOT_TLSLD16_HA:
7662 tls_type = TLS_TLS | TLS_LD;
7663 goto dogot;
7664
7665 case R_PPC_GOT_TPREL16:
7666 case R_PPC_GOT_TPREL16_LO:
7667 case R_PPC_GOT_TPREL16_HI:
7668 case R_PPC_GOT_TPREL16_HA:
7669 tls_type = TLS_TLS | TLS_TPREL;
7670 goto dogot;
7671
7672 case R_PPC_GOT_DTPREL16:
7673 case R_PPC_GOT_DTPREL16_LO:
7674 case R_PPC_GOT_DTPREL16_HI:
7675 case R_PPC_GOT_DTPREL16_HA:
7676 tls_type = TLS_TLS | TLS_DTPREL;
7677 goto dogot;
7678
7679 case R_PPC_GOT16:
7680 case R_PPC_GOT16_LO:
7681 case R_PPC_GOT16_HI:
7682 case R_PPC_GOT16_HA:
7683 tls_mask = 0;
7684 dogot:
7685 {
7686 /* Relocation is to the entry for this symbol in the global
7687 offset table. */
7688 bfd_vma off;
7689 bfd_vma *offp;
7690 unsigned long indx;
7691
7692 if (htab->elf.sgot == NULL)
7693 abort ();
7694
7695 indx = 0;
7696 if (tls_type == (TLS_TLS | TLS_LD)
7697 && SYMBOL_REFERENCES_LOCAL (info, h))
7698 offp = &htab->tlsld_got.offset;
7699 else if (h != NULL)
7700 {
7701 if (!htab->elf.dynamic_sections_created
7702 || h->dynindx == -1
7703 || SYMBOL_REFERENCES_LOCAL (info, h)
7704 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
7705 /* This is actually a static link, or it is a
7706 -Bsymbolic link and the symbol is defined
7707 locally, or the symbol was forced to be local
7708 because of a version file. */
7709 ;
7710 else
7711 {
7712 indx = h->dynindx;
7713 unresolved_reloc = FALSE;
7714 }
7715 offp = &h->got.offset;
7716 }
7717 else
7718 {
7719 if (local_got_offsets == NULL)
7720 abort ();
7721 offp = &local_got_offsets[r_symndx];
7722 }
7723
7724 /* The offset must always be a multiple of 4. We use the
7725 least significant bit to record whether we have already
7726 processed this entry. */
7727 off = *offp;
7728 if ((off & 1) != 0)
7729 off &= ~1;
7730 else
7731 {
7732 unsigned int tls_m = ((tls_mask & TLS_TLS) != 0
7733 ? tls_mask & (TLS_LD | TLS_GD | TLS_DTPREL
7734 | TLS_TPREL | TLS_GDIE)
7735 : 0);
7736
7737 if (offp == &htab->tlsld_got.offset)
7738 tls_m = TLS_LD;
7739 else if ((tls_m & TLS_LD) != 0
7740 && SYMBOL_REFERENCES_LOCAL (info, h))
7741 tls_m &= ~TLS_LD;
7742
7743 /* We might have multiple got entries for this sym.
7744 Initialize them all. */
7745 do
7746 {
7747 int tls_ty = 0;
7748
7749 if ((tls_m & TLS_LD) != 0)
7750 {
7751 tls_ty = TLS_TLS | TLS_LD;
7752 tls_m &= ~TLS_LD;
7753 }
7754 else if ((tls_m & TLS_GD) != 0)
7755 {
7756 tls_ty = TLS_TLS | TLS_GD;
7757 tls_m &= ~TLS_GD;
7758 }
7759 else if ((tls_m & TLS_DTPREL) != 0)
7760 {
7761 tls_ty = TLS_TLS | TLS_DTPREL;
7762 tls_m &= ~TLS_DTPREL;
7763 }
7764 else if ((tls_m & (TLS_TPREL | TLS_GDIE)) != 0)
7765 {
7766 tls_ty = TLS_TLS | TLS_TPREL;
7767 tls_m = 0;
7768 }
7769
7770 /* Generate relocs for the dynamic linker. */
7771 if (indx != 0
7772 || (bfd_link_pic (info)
7773 && (h == NULL
7774 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
7775 && !(tls_ty != 0
7776 && bfd_link_executable (info)
7777 && SYMBOL_REFERENCES_LOCAL (info, h))))
7778 {
7779 asection *rsec = htab->elf.srelgot;
7780 bfd_byte * loc;
7781
7782 if (ifunc != NULL)
7783 {
7784 rsec = htab->elf.irelplt;
7785 if (indx == 0)
7786 htab->local_ifunc_resolver = 1;
7787 else if (is_static_defined (h))
7788 htab->maybe_local_ifunc_resolver = 1;
7789 }
7790 outrel.r_offset = (htab->elf.sgot->output_section->vma
7791 + htab->elf.sgot->output_offset
7792 + off);
7793 outrel.r_addend = 0;
7794 if (tls_ty & (TLS_LD | TLS_GD))
7795 {
7796 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
7797 if (tls_ty == (TLS_TLS | TLS_GD))
7798 {
7799 loc = rsec->contents;
7800 loc += (rsec->reloc_count++
7801 * sizeof (Elf32_External_Rela));
7802 bfd_elf32_swap_reloca_out (output_bfd,
7803 &outrel, loc);
7804 outrel.r_offset += 4;
7805 outrel.r_info
7806 = ELF32_R_INFO (indx, R_PPC_DTPREL32);
7807 }
7808 }
7809 else if (tls_ty == (TLS_TLS | TLS_DTPREL))
7810 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
7811 else if (tls_ty == (TLS_TLS | TLS_TPREL))
7812 outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
7813 else if (indx != 0)
7814 outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
7815 else if (ifunc != NULL)
7816 outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
7817 else
7818 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
7819 if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD))
7820 {
7821 outrel.r_addend += relocation;
7822 if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
7823 {
7824 if (htab->elf.tls_sec == NULL)
7825 outrel.r_addend = 0;
7826 else
7827 outrel.r_addend -= htab->elf.tls_sec->vma;
7828 }
7829 }
7830 loc = rsec->contents;
7831 loc += (rsec->reloc_count++
7832 * sizeof (Elf32_External_Rela));
7833 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
7834 }
7835
7836 /* Init the .got section contents if we're not
7837 emitting a reloc. */
7838 else
7839 {
7840 bfd_vma value = relocation;
7841
7842 if (tls_ty != 0)
7843 {
7844 if (htab->elf.tls_sec == NULL)
7845 value = 0;
7846 else
7847 {
7848 if (tls_ty & TLS_LD)
7849 value = 0;
7850 else
7851 value -= htab->elf.tls_sec->vma + DTP_OFFSET;
7852 if (tls_ty & TLS_TPREL)
7853 value += DTP_OFFSET - TP_OFFSET;
7854 }
7855
7856 if (tls_ty & (TLS_LD | TLS_GD))
7857 {
7858 bfd_put_32 (input_bfd, value,
7859 htab->elf.sgot->contents + off + 4);
7860 value = 1;
7861 }
7862 }
7863 bfd_put_32 (input_bfd, value,
7864 htab->elf.sgot->contents + off);
7865 }
7866
7867 off += 4;
7868 if (tls_ty & (TLS_LD | TLS_GD))
7869 off += 4;
7870 }
7871 while (tls_m != 0);
7872
7873 off = *offp;
7874 *offp = off | 1;
7875 }
7876
7877 if (off >= (bfd_vma) -2)
7878 abort ();
7879
7880 if ((tls_type & TLS_TLS) != 0)
7881 {
7882 if (tls_type != (TLS_TLS | TLS_LD))
7883 {
7884 if ((tls_mask & TLS_LD) != 0
7885 && !SYMBOL_REFERENCES_LOCAL (info, h))
7886 off += 8;
7887 if (tls_type != (TLS_TLS | TLS_GD))
7888 {
7889 if ((tls_mask & TLS_GD) != 0)
7890 off += 8;
7891 if (tls_type != (TLS_TLS | TLS_DTPREL))
7892 {
7893 if ((tls_mask & TLS_DTPREL) != 0)
7894 off += 4;
7895 }
7896 }
7897 }
7898 }
7899
7900 /* If here for a picfixup, we're done. */
7901 if (r_type != ELF32_R_TYPE (rel->r_info))
7902 goto copy_reloc;
7903
7904 relocation = (htab->elf.sgot->output_section->vma
7905 + htab->elf.sgot->output_offset
7906 + off
7907 - SYM_VAL (htab->elf.hgot));
7908
7909 /* Addends on got relocations don't make much sense.
7910 x+off@got is actually x@got+off, and since the got is
7911 generated by a hash table traversal, the value in the
7912 got at entry m+n bears little relation to the entry m. */
7913 if (addend != 0)
7914 info->callbacks->einfo
7915 /* xgettext:c-format */
7916 (_("%H: non-zero addend on %s reloc against `%s'\n"),
7917 input_bfd, input_section, rel->r_offset,
7918 howto->name,
7919 sym_name);
7920 }
7921 break;
7922
7923 /* Relocations that need no special processing. */
7924 case R_PPC_LOCAL24PC:
7925 /* It makes no sense to point a local relocation
7926 at a symbol not in this object. */
7927 if (unresolved_reloc)
7928 {
7929 (*info->callbacks->undefined_symbol) (info,
7930 h->root.root.string,
7931 input_bfd,
7932 input_section,
7933 rel->r_offset,
7934 TRUE);
7935 goto copy_reloc;
7936 }
7937 if (h != NULL && h->type == STT_GNU_IFUNC && bfd_link_pic (info))
7938 {
7939 /* @local on an ifunc does not really make sense since
7940 the ifunc resolver can take you anywhere. More
7941 seriously, calls to ifuncs must go through a plt call
7942 stub, and for pic the plt call stubs uses r30 to
7943 access the PLT. The problem is that a call that is
7944 local won't have the +32k reloc addend trick marking
7945 -fPIC code, so the linker won't know whether r30 is
7946 _GLOBAL_OFFSET_TABLE_ or pointing into a .got2 section. */
7947 /* xgettext:c-format */
7948 info->callbacks->einfo (_("%X%H: @local call to ifunc %s\n"),
7949 input_bfd, input_section, rel->r_offset,
7950 h->root.root.string);
7951 }
7952 break;
7953
7954 case R_PPC_DTPREL16:
7955 case R_PPC_DTPREL16_LO:
7956 case R_PPC_DTPREL16_HI:
7957 case R_PPC_DTPREL16_HA:
7958 if (htab->elf.tls_sec != NULL)
7959 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
7960 break;
7961
7962 /* Relocations that may need to be propagated if this is a shared
7963 object. */
7964 case R_PPC_TPREL16:
7965 case R_PPC_TPREL16_LO:
7966 case R_PPC_TPREL16_HI:
7967 case R_PPC_TPREL16_HA:
7968 if (h != NULL
7969 && h->root.type == bfd_link_hash_undefweak
7970 && h->dynindx == -1)
7971 {
7972 /* Make this relocation against an undefined weak symbol
7973 resolve to zero. This is really just a tweak, since
7974 code using weak externs ought to check that they are
7975 defined before using them. */
7976 bfd_byte *p = contents + rel->r_offset - d_offset;
7977 unsigned int insn = bfd_get_32 (input_bfd, p);
7978 insn = _bfd_elf_ppc_at_tprel_transform (insn, 2);
7979 if (insn != 0)
7980 bfd_put_32 (input_bfd, insn, p);
7981 break;
7982 }
7983 if (htab->elf.tls_sec != NULL)
7984 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
7985 /* The TPREL16 relocs shouldn't really be used in shared
7986 libs or with non-local symbols as that will result in
7987 DT_TEXTREL being set, but support them anyway. */
7988 goto dodyn;
7989
7990 case R_PPC_TPREL32:
7991 if (htab->elf.tls_sec != NULL)
7992 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
7993 goto dodyn;
7994
7995 case R_PPC_DTPREL32:
7996 if (htab->elf.tls_sec != NULL)
7997 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
7998 goto dodyn;
7999
8000 case R_PPC_DTPMOD32:
8001 relocation = 1;
8002 addend = 0;
8003 goto dodyn;
8004
8005 case R_PPC_REL16:
8006 case R_PPC_REL16_LO:
8007 case R_PPC_REL16_HI:
8008 case R_PPC_REL16_HA:
8009 case R_PPC_REL16DX_HA:
8010 break;
8011
8012 case R_PPC_REL32:
8013 if (h == NULL || h == htab->elf.hgot)
8014 break;
8015 /* fall through */
8016
8017 case R_PPC_ADDR32:
8018 case R_PPC_ADDR16:
8019 case R_PPC_ADDR16_LO:
8020 case R_PPC_ADDR16_HI:
8021 case R_PPC_ADDR16_HA:
8022 case R_PPC_UADDR32:
8023 case R_PPC_UADDR16:
8024 goto dodyn;
8025
8026 case R_PPC_VLE_REL8:
8027 case R_PPC_VLE_REL15:
8028 case R_PPC_VLE_REL24:
8029 case R_PPC_REL24:
8030 case R_PPC_REL14:
8031 case R_PPC_REL14_BRTAKEN:
8032 case R_PPC_REL14_BRNTAKEN:
8033 /* If these relocations are not to a named symbol, they can be
8034 handled right here, no need to bother the dynamic linker. */
8035 if (SYMBOL_CALLS_LOCAL (info, h)
8036 || h == htab->elf.hgot)
8037 break;
8038 /* fall through */
8039
8040 case R_PPC_ADDR24:
8041 case R_PPC_ADDR14:
8042 case R_PPC_ADDR14_BRTAKEN:
8043 case R_PPC_ADDR14_BRNTAKEN:
8044 if (h != NULL && !bfd_link_pic (info))
8045 break;
8046 /* fall through */
8047
8048 dodyn:
8049 if ((input_section->flags & SEC_ALLOC) == 0
8050 || is_vxworks_tls)
8051 break;
8052
8053 if (bfd_link_pic (info)
8054 ? ((h == NULL
8055 || h->dyn_relocs != NULL)
8056 && ((h != NULL && pc_dynrelocs (h))
8057 || must_be_dyn_reloc (info, r_type)))
8058 : (h != NULL
8059 && h->dyn_relocs != NULL))
8060 {
8061 int skip;
8062 bfd_byte *loc;
8063 asection *sreloc;
8064 long indx = 0;
8065
8066 #ifdef DEBUG
8067 fprintf (stderr, "ppc_elf_relocate_section needs to "
8068 "create relocation for %s\n",
8069 (h && h->root.root.string
8070 ? h->root.root.string : "<unknown>"));
8071 #endif
8072
8073 /* When generating a shared object, these relocations
8074 are copied into the output file to be resolved at run
8075 time. */
8076 skip = 0;
8077 outrel.r_offset = _bfd_elf_section_offset (output_bfd, info,
8078 input_section,
8079 rel->r_offset);
8080 if (outrel.r_offset == (bfd_vma) -1
8081 || outrel.r_offset == (bfd_vma) -2)
8082 skip = (int) outrel.r_offset;
8083 outrel.r_offset += (input_section->output_section->vma
8084 + input_section->output_offset);
8085
8086 /* Optimize unaligned reloc use. */
8087 if ((r_type == R_PPC_ADDR32 && (outrel.r_offset & 3) != 0)
8088 || (r_type == R_PPC_UADDR32 && (outrel.r_offset & 3) == 0))
8089 r_type ^= R_PPC_ADDR32 ^ R_PPC_UADDR32;
8090 if ((r_type == R_PPC_ADDR16 && (outrel.r_offset & 1) != 0)
8091 || (r_type == R_PPC_UADDR16 && (outrel.r_offset & 1) == 0))
8092 r_type ^= R_PPC_ADDR16 ^ R_PPC_UADDR16;
8093
8094 if (skip)
8095 memset (&outrel, 0, sizeof outrel);
8096 else if (!SYMBOL_REFERENCES_LOCAL (info, h))
8097 {
8098 indx = h->dynindx;
8099 BFD_ASSERT (indx != -1);
8100 unresolved_reloc = FALSE;
8101 outrel.r_info = ELF32_R_INFO (indx, r_type);
8102 outrel.r_addend = rel->r_addend;
8103 }
8104 else
8105 {
8106 outrel.r_addend = relocation + rel->r_addend;
8107
8108 if (r_type != R_PPC_ADDR32)
8109 {
8110 if (ifunc != NULL)
8111 {
8112 /* If we get here when building a static
8113 executable, then the libc startup function
8114 responsible for applying indirect function
8115 relocations is going to complain about
8116 the reloc type.
8117 If we get here when building a dynamic
8118 executable, it will be because we have
8119 a text relocation. The dynamic loader
8120 will set the text segment writable and
8121 non-executable to apply text relocations.
8122 So we'll segfault when trying to run the
8123 indirection function to resolve the reloc. */
8124 info->callbacks->einfo
8125 /* xgettext:c-format */
8126 (_("%H: relocation %s for indirect "
8127 "function %s unsupported\n"),
8128 input_bfd, input_section, rel->r_offset,
8129 howto->name,
8130 sym_name);
8131 ret = FALSE;
8132 }
8133 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
8134 ;
8135 else if (sec == NULL || sec->owner == NULL)
8136 {
8137 bfd_set_error (bfd_error_bad_value);
8138 ret = FALSE;
8139 }
8140 else
8141 {
8142 asection *osec;
8143
8144 /* We are turning this relocation into one
8145 against a section symbol. It would be
8146 proper to subtract the symbol's value,
8147 osec->vma, from the emitted reloc addend,
8148 but ld.so expects buggy relocs.
8149 FIXME: Why not always use a zero index? */
8150 osec = sec->output_section;
8151 if ((osec->flags & SEC_THREAD_LOCAL) != 0)
8152 {
8153 osec = htab->elf.tls_sec;
8154 indx = 0;
8155 }
8156 else
8157 {
8158 indx = elf_section_data (osec)->dynindx;
8159 if (indx == 0)
8160 {
8161 osec = htab->elf.text_index_section;
8162 indx = elf_section_data (osec)->dynindx;
8163 }
8164 BFD_ASSERT (indx != 0);
8165 }
8166
8167 /* ld.so doesn't expect buggy TLS relocs.
8168 Don't leave the symbol value in the
8169 addend for them. */
8170 if (IS_PPC_TLS_RELOC (r_type))
8171 outrel.r_addend -= osec->vma;
8172 }
8173
8174 outrel.r_info = ELF32_R_INFO (indx, r_type);
8175 }
8176 else if (ifunc != NULL)
8177 outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8178 else
8179 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
8180 }
8181
8182 sreloc = elf_section_data (input_section)->sreloc;
8183 if (ifunc)
8184 {
8185 sreloc = htab->elf.irelplt;
8186 if (indx == 0)
8187 htab->local_ifunc_resolver = 1;
8188 else if (is_static_defined (h))
8189 htab->maybe_local_ifunc_resolver = 1;
8190 }
8191 if (sreloc == NULL)
8192 return FALSE;
8193
8194 loc = sreloc->contents;
8195 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
8196 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
8197
8198 if (skip == -1)
8199 goto copy_reloc;
8200
8201 /* This reloc will be computed at runtime. Clear the memory
8202 so that it contains a predictable value for prelink. */
8203 if (!skip)
8204 {
8205 relocation = howto->pc_relative ? outrel.r_offset : 0;
8206 addend = 0;
8207 break;
8208 }
8209 }
8210 break;
8211
8212 case R_PPC_RELAX_PLT:
8213 case R_PPC_RELAX_PLTREL24:
8214 if (h != NULL)
8215 {
8216 struct plt_entry *ent;
8217 bfd_vma got2_addend = 0;
8218
8219 if (r_type == R_PPC_RELAX_PLTREL24)
8220 {
8221 if (bfd_link_pic (info))
8222 got2_addend = addend;
8223 addend = 0;
8224 }
8225 ent = find_plt_ent (&h->plt.plist, got2, got2_addend);
8226 if (htab->plt_type == PLT_NEW)
8227 relocation = (htab->glink->output_section->vma
8228 + htab->glink->output_offset
8229 + ent->glink_offset);
8230 else
8231 relocation = (htab->elf.splt->output_section->vma
8232 + htab->elf.splt->output_offset
8233 + ent->plt.offset);
8234 }
8235 /* Fall through. */
8236
8237 case R_PPC_RELAX:
8238 {
8239 const int *stub;
8240 size_t size;
8241 size_t insn_offset = rel->r_offset;
8242 unsigned int insn;
8243
8244 if (bfd_link_pic (info))
8245 {
8246 relocation -= (input_section->output_section->vma
8247 + input_section->output_offset
8248 + rel->r_offset - 4);
8249 stub = shared_stub_entry;
8250 bfd_put_32 (input_bfd, stub[0], contents + insn_offset - 12);
8251 bfd_put_32 (input_bfd, stub[1], contents + insn_offset - 8);
8252 bfd_put_32 (input_bfd, stub[2], contents + insn_offset - 4);
8253 stub += 3;
8254 size = ARRAY_SIZE (shared_stub_entry) - 3;
8255 }
8256 else
8257 {
8258 stub = stub_entry;
8259 size = ARRAY_SIZE (stub_entry);
8260 }
8261
8262 relocation += addend;
8263 if (bfd_link_relocatable (info))
8264 relocation = 0;
8265
8266 /* First insn is HA, second is LO. */
8267 insn = *stub++;
8268 insn |= ((relocation + 0x8000) >> 16) & 0xffff;
8269 bfd_put_32 (input_bfd, insn, contents + insn_offset);
8270 insn_offset += 4;
8271
8272 insn = *stub++;
8273 insn |= relocation & 0xffff;
8274 bfd_put_32 (input_bfd, insn, contents + insn_offset);
8275 insn_offset += 4;
8276 size -= 2;
8277
8278 while (size != 0)
8279 {
8280 insn = *stub++;
8281 --size;
8282 bfd_put_32 (input_bfd, insn, contents + insn_offset);
8283 insn_offset += 4;
8284 }
8285
8286 /* Rewrite the reloc and convert one of the trailing nop
8287 relocs to describe this relocation. */
8288 BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE);
8289 /* The relocs are at the bottom 2 bytes */
8290 wrel->r_offset = rel->r_offset + d_offset;
8291 wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
8292 wrel->r_addend = rel->r_addend;
8293 memmove (wrel + 1, wrel, (relend - wrel - 1) * sizeof (*wrel));
8294 wrel++, rel++;
8295 wrel->r_offset += 4;
8296 wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
8297 }
8298 continue;
8299
8300 /* Indirect .sdata relocation. */
8301 case R_PPC_EMB_SDAI16:
8302 BFD_ASSERT (htab->sdata[0].section != NULL);
8303 if (!is_static_defined (htab->sdata[0].sym))
8304 {
8305 unresolved_reloc = TRUE;
8306 break;
8307 }
8308 relocation
8309 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0],
8310 h, relocation, rel);
8311 addend = 0;
8312 break;
8313
8314 /* Indirect .sdata2 relocation. */
8315 case R_PPC_EMB_SDA2I16:
8316 BFD_ASSERT (htab->sdata[1].section != NULL);
8317 if (!is_static_defined (htab->sdata[1].sym))
8318 {
8319 unresolved_reloc = TRUE;
8320 break;
8321 }
8322 relocation
8323 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1],
8324 h, relocation, rel);
8325 addend = 0;
8326 break;
8327
8328 /* Handle the TOC16 reloc. We want to use the offset within the .got
8329 section, not the actual VMA. This is appropriate when generating
8330 an embedded ELF object, for which the .got section acts like the
8331 AIX .toc section. */
8332 case R_PPC_TOC16: /* phony GOT16 relocations */
8333 if (sec == NULL || sec->output_section == NULL)
8334 {
8335 unresolved_reloc = TRUE;
8336 break;
8337 }
8338 BFD_ASSERT (strcmp (bfd_section_name (sec), ".got") == 0
8339 || strcmp (bfd_section_name (sec), ".cgot") == 0);
8340
8341 addend -= sec->output_section->vma + sec->output_offset + 0x8000;
8342 break;
8343
8344 case R_PPC_PLTREL24:
8345 if (h != NULL && ifunc == NULL)
8346 {
8347 struct plt_entry *ent;
8348
8349 ent = find_plt_ent (&h->plt.plist, got2,
8350 bfd_link_pic (info) ? addend : 0);
8351 if (ent == NULL
8352 || htab->elf.splt == NULL)
8353 {
8354 /* We didn't make a PLT entry for this symbol. This
8355 happens when statically linking PIC code, or when
8356 using -Bsymbolic. */
8357 }
8358 else
8359 {
8360 /* Relocation is to the entry for this symbol in the
8361 procedure linkage table. */
8362 unresolved_reloc = FALSE;
8363 if (htab->plt_type == PLT_NEW)
8364 relocation = (htab->glink->output_section->vma
8365 + htab->glink->output_offset
8366 + ent->glink_offset);
8367 else
8368 relocation = (htab->elf.splt->output_section->vma
8369 + htab->elf.splt->output_offset
8370 + ent->plt.offset);
8371 }
8372 }
8373
8374 /* R_PPC_PLTREL24 is rather special. If non-zero, the
8375 addend specifies the GOT pointer offset within .got2.
8376 Don't apply it to the relocation field. */
8377 addend = 0;
8378 break;
8379
8380 case R_PPC_PLTSEQ:
8381 case R_PPC_PLTCALL:
8382 case R_PPC_PLT16_LO:
8383 case R_PPC_PLT16_HI:
8384 case R_PPC_PLT16_HA:
8385 plt_list = NULL;
8386 if (h != NULL)
8387 plt_list = &h->plt.plist;
8388 else if (ifunc != NULL)
8389 plt_list = ifunc;
8390 else if (local_got_offsets != NULL)
8391 {
8392 struct plt_entry **local_plt;
8393 local_plt = (struct plt_entry **) (local_got_offsets
8394 + symtab_hdr->sh_info);
8395 plt_list = local_plt + r_symndx;
8396 }
8397 unresolved_reloc = TRUE;
8398 if (plt_list != NULL)
8399 {
8400 struct plt_entry *ent;
8401
8402 ent = find_plt_ent (plt_list, got2,
8403 bfd_link_pic (info) ? addend : 0);
8404 if (ent != NULL && ent->plt.offset != (bfd_vma) -1)
8405 {
8406 asection *plt;
8407
8408 unresolved_reloc = FALSE;
8409 plt = htab->elf.splt;
8410 if (!htab->elf.dynamic_sections_created
8411 || h == NULL
8412 || h->dynindx == -1)
8413 {
8414 if (ifunc != NULL)
8415 plt = htab->elf.iplt;
8416 else
8417 plt = htab->pltlocal;
8418 }
8419 relocation = (plt->output_section->vma
8420 + plt->output_offset
8421 + ent->plt.offset);
8422 if (bfd_link_pic (info))
8423 {
8424 bfd_vma got = 0;
8425
8426 if (ent->addend >= 32768)
8427 got = (ent->addend
8428 + ent->sec->output_section->vma
8429 + ent->sec->output_offset);
8430 else
8431 got = SYM_VAL (htab->elf.hgot);
8432 relocation -= got;
8433 }
8434 }
8435 }
8436 addend = 0;
8437 break;
8438
8439 /* Relocate against _SDA_BASE_. */
8440 case R_PPC_SDAREL16:
8441 {
8442 const char *name;
8443 struct elf_link_hash_entry *sda = htab->sdata[0].sym;
8444
8445 if (sec == NULL
8446 || sec->output_section == NULL
8447 || !is_static_defined (sda))
8448 {
8449 unresolved_reloc = TRUE;
8450 break;
8451 }
8452 addend -= SYM_VAL (sda);
8453
8454 name = bfd_section_name (sec->output_section);
8455 if (!(strcmp (name, ".sdata") == 0
8456 || strcmp (name, ".sbss") == 0))
8457 {
8458 _bfd_error_handler
8459 /* xgettext:c-format */
8460 (_("%pB: the target (%s) of a %s relocation is "
8461 "in the wrong output section (%s)"),
8462 input_bfd,
8463 sym_name,
8464 howto->name,
8465 name);
8466 }
8467 }
8468 break;
8469
8470 /* Relocate against _SDA2_BASE_. */
8471 case R_PPC_EMB_SDA2REL:
8472 {
8473 const char *name;
8474 struct elf_link_hash_entry *sda = htab->sdata[1].sym;
8475
8476 if (sec == NULL
8477 || sec->output_section == NULL
8478 || !is_static_defined (sda))
8479 {
8480 unresolved_reloc = TRUE;
8481 break;
8482 }
8483 addend -= SYM_VAL (sda);
8484
8485 name = bfd_section_name (sec->output_section);
8486 if (!(strcmp (name, ".sdata2") == 0
8487 || strcmp (name, ".sbss2") == 0))
8488 {
8489 _bfd_error_handler
8490 /* xgettext:c-format */
8491 (_("%pB: the target (%s) of a %s relocation is "
8492 "in the wrong output section (%s)"),
8493 input_bfd,
8494 sym_name,
8495 howto->name,
8496 name);
8497 }
8498 }
8499 break;
8500
8501 case R_PPC_VLE_LO16A:
8502 relocation = relocation + addend;
8503 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8504 contents + rel->r_offset, relocation,
8505 split16a_type, htab->params->vle_reloc_fixup);
8506 goto copy_reloc;
8507
8508 case R_PPC_VLE_LO16D:
8509 relocation = relocation + addend;
8510 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8511 contents + rel->r_offset, relocation,
8512 split16d_type, htab->params->vle_reloc_fixup);
8513 goto copy_reloc;
8514
8515 case R_PPC_VLE_HI16A:
8516 relocation = (relocation + addend) >> 16;
8517 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8518 contents + rel->r_offset, relocation,
8519 split16a_type, htab->params->vle_reloc_fixup);
8520 goto copy_reloc;
8521
8522 case R_PPC_VLE_HI16D:
8523 relocation = (relocation + addend) >> 16;
8524 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8525 contents + rel->r_offset, relocation,
8526 split16d_type, htab->params->vle_reloc_fixup);
8527 goto copy_reloc;
8528
8529 case R_PPC_VLE_HA16A:
8530 relocation = (relocation + addend + 0x8000) >> 16;
8531 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8532 contents + rel->r_offset, relocation,
8533 split16a_type, htab->params->vle_reloc_fixup);
8534 goto copy_reloc;
8535
8536 case R_PPC_VLE_HA16D:
8537 relocation = (relocation + addend + 0x8000) >> 16;
8538 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8539 contents + rel->r_offset, relocation,
8540 split16d_type, htab->params->vle_reloc_fixup);
8541 goto copy_reloc;
8542
8543 /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0. */
8544 case R_PPC_EMB_SDA21:
8545 case R_PPC_VLE_SDA21:
8546 case R_PPC_EMB_RELSDA:
8547 case R_PPC_VLE_SDA21_LO:
8548 {
8549 const char *name;
8550 int reg;
8551 unsigned int insn;
8552 struct elf_link_hash_entry *sda = NULL;
8553
8554 if (sec == NULL || sec->output_section == NULL)
8555 {
8556 unresolved_reloc = TRUE;
8557 break;
8558 }
8559
8560 name = bfd_section_name (sec->output_section);
8561 if (strcmp (name, ".sdata") == 0
8562 || strcmp (name, ".sbss") == 0)
8563 {
8564 reg = 13;
8565 sda = htab->sdata[0].sym;
8566 }
8567 else if (strcmp (name, ".sdata2") == 0
8568 || strcmp (name, ".sbss2") == 0)
8569 {
8570 reg = 2;
8571 sda = htab->sdata[1].sym;
8572 }
8573 else if (strcmp (name, ".PPC.EMB.sdata0") == 0
8574 || strcmp (name, ".PPC.EMB.sbss0") == 0)
8575 {
8576 reg = 0;
8577 }
8578 else
8579 {
8580 _bfd_error_handler
8581 /* xgettext:c-format */
8582 (_("%pB: the target (%s) of a %s relocation is "
8583 "in the wrong output section (%s)"),
8584 input_bfd,
8585 sym_name,
8586 howto->name,
8587 name);
8588
8589 bfd_set_error (bfd_error_bad_value);
8590 ret = FALSE;
8591 goto copy_reloc;
8592 }
8593
8594 if (sda != NULL)
8595 {
8596 if (!is_static_defined (sda))
8597 {
8598 unresolved_reloc = TRUE;
8599 break;
8600 }
8601 addend -= SYM_VAL (sda);
8602 }
8603
8604 if (r_type == R_PPC_EMB_RELSDA)
8605 break;
8606
8607 /* The PowerPC Embedded Application Binary Interface
8608 version 1.0 insanely chose to specify R_PPC_EMB_SDA21
8609 operating on a 24-bit field at r_offset. GNU as and
8610 GNU ld have always assumed R_PPC_EMB_SDA21 operates on
8611 a 32-bit bit insn at r_offset. Cope with object file
8612 producers that possibly comply with the EABI in
8613 generating an odd r_offset for big-endian objects. */
8614 if (r_type == R_PPC_EMB_SDA21)
8615 rel->r_offset &= ~1;
8616
8617 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
8618 if (reg == 0
8619 && (r_type == R_PPC_VLE_SDA21
8620 || r_type == R_PPC_VLE_SDA21_LO))
8621 {
8622 relocation = relocation + addend;
8623 addend = 0;
8624
8625 /* Force e_li insn, keeping RT from original insn. */
8626 insn &= 0x1f << 21;
8627 insn |= 28u << 26;
8628
8629 /* We have an li20 field, bits 17..20, 11..15, 21..31. */
8630 /* Top 4 bits of value to 17..20. */
8631 insn |= (relocation & 0xf0000) >> 5;
8632 /* Next 5 bits of the value to 11..15. */
8633 insn |= (relocation & 0xf800) << 5;
8634 /* And the final 11 bits of the value to bits 21 to 31. */
8635 insn |= relocation & 0x7ff;
8636
8637 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
8638
8639 if (r_type == R_PPC_VLE_SDA21
8640 && ((relocation + 0x80000) & 0xffffffff) > 0x100000)
8641 goto overflow;
8642 goto copy_reloc;
8643 }
8644 /* Fill in register field. */
8645 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
8646 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
8647 }
8648 break;
8649
8650 case R_PPC_VLE_SDAREL_LO16A:
8651 case R_PPC_VLE_SDAREL_LO16D:
8652 case R_PPC_VLE_SDAREL_HI16A:
8653 case R_PPC_VLE_SDAREL_HI16D:
8654 case R_PPC_VLE_SDAREL_HA16A:
8655 case R_PPC_VLE_SDAREL_HA16D:
8656 {
8657 bfd_vma value;
8658 const char *name;
8659 struct elf_link_hash_entry *sda = NULL;
8660
8661 if (sec == NULL || sec->output_section == NULL)
8662 {
8663 unresolved_reloc = TRUE;
8664 break;
8665 }
8666
8667 name = bfd_section_name (sec->output_section);
8668 if (strcmp (name, ".sdata") == 0
8669 || strcmp (name, ".sbss") == 0)
8670 sda = htab->sdata[0].sym;
8671 else if (strcmp (name, ".sdata2") == 0
8672 || strcmp (name, ".sbss2") == 0)
8673 sda = htab->sdata[1].sym;
8674 else
8675 {
8676 _bfd_error_handler
8677 /* xgettext:c-format */
8678 (_("%pB: the target (%s) of a %s relocation is "
8679 "in the wrong output section (%s)"),
8680 input_bfd,
8681 sym_name,
8682 howto->name,
8683 name);
8684
8685 bfd_set_error (bfd_error_bad_value);
8686 ret = FALSE;
8687 goto copy_reloc;
8688 }
8689
8690 if (sda == NULL || !is_static_defined (sda))
8691 {
8692 unresolved_reloc = TRUE;
8693 break;
8694 }
8695 value = relocation + addend - SYM_VAL (sda);
8696
8697 if (r_type == R_PPC_VLE_SDAREL_LO16A)
8698 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8699 contents + rel->r_offset, value,
8700 split16a_type,
8701 htab->params->vle_reloc_fixup);
8702 else if (r_type == R_PPC_VLE_SDAREL_LO16D)
8703 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8704 contents + rel->r_offset, value,
8705 split16d_type,
8706 htab->params->vle_reloc_fixup);
8707 else if (r_type == R_PPC_VLE_SDAREL_HI16A)
8708 {
8709 value = value >> 16;
8710 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8711 contents + rel->r_offset, value,
8712 split16a_type,
8713 htab->params->vle_reloc_fixup);
8714 }
8715 else if (r_type == R_PPC_VLE_SDAREL_HI16D)
8716 {
8717 value = value >> 16;
8718 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8719 contents + rel->r_offset, value,
8720 split16d_type,
8721 htab->params->vle_reloc_fixup);
8722 }
8723 else if (r_type == R_PPC_VLE_SDAREL_HA16A)
8724 {
8725 value = (value + 0x8000) >> 16;
8726 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8727 contents + rel->r_offset, value,
8728 split16a_type,
8729 htab->params->vle_reloc_fixup);
8730 }
8731 else if (r_type == R_PPC_VLE_SDAREL_HA16D)
8732 {
8733 value = (value + 0x8000) >> 16;
8734 ppc_elf_vle_split16 (input_bfd, input_section, rel->r_offset,
8735 contents + rel->r_offset, value,
8736 split16d_type,
8737 htab->params->vle_reloc_fixup);
8738 }
8739 }
8740 goto copy_reloc;
8741
8742 case R_PPC_VLE_ADDR20:
8743 ppc_elf_vle_split20 (output_bfd, contents + rel->r_offset, relocation);
8744 goto copy_reloc;
8745
8746 /* Relocate against the beginning of the section. */
8747 case R_PPC_SECTOFF:
8748 case R_PPC_SECTOFF_LO:
8749 case R_PPC_SECTOFF_HI:
8750 case R_PPC_SECTOFF_HA:
8751 if (sec == NULL || sec->output_section == NULL)
8752 {
8753 unresolved_reloc = TRUE;
8754 break;
8755 }
8756 addend -= sec->output_section->vma;
8757 break;
8758
8759 /* Negative relocations. */
8760 case R_PPC_EMB_NADDR32:
8761 case R_PPC_EMB_NADDR16:
8762 case R_PPC_EMB_NADDR16_LO:
8763 case R_PPC_EMB_NADDR16_HI:
8764 case R_PPC_EMB_NADDR16_HA:
8765 addend -= 2 * relocation;
8766 break;
8767
8768 case R_PPC_COPY:
8769 case R_PPC_GLOB_DAT:
8770 case R_PPC_JMP_SLOT:
8771 case R_PPC_RELATIVE:
8772 case R_PPC_IRELATIVE:
8773 case R_PPC_PLT32:
8774 case R_PPC_PLTREL32:
8775 case R_PPC_ADDR30:
8776 case R_PPC_EMB_RELSEC16:
8777 case R_PPC_EMB_RELST_LO:
8778 case R_PPC_EMB_RELST_HI:
8779 case R_PPC_EMB_RELST_HA:
8780 case R_PPC_EMB_BIT_FLD:
8781 /* xgettext:c-format */
8782 _bfd_error_handler (_("%pB: %s unsupported"),
8783 input_bfd, howto->name);
8784
8785 bfd_set_error (bfd_error_invalid_operation);
8786 ret = FALSE;
8787 goto copy_reloc;
8788 }
8789
8790 switch (r_type)
8791 {
8792 default:
8793 break;
8794
8795 case R_PPC_PLTCALL:
8796 if (unresolved_reloc)
8797 {
8798 bfd_byte *p = contents + rel->r_offset;
8799 unsigned int insn = bfd_get_32 (input_bfd, p);
8800 insn &= 1;
8801 bfd_put_32 (input_bfd, B | insn, p);
8802 unresolved_reloc = save_unresolved_reloc;
8803 r_type = R_PPC_REL24;
8804 howto = ppc_elf_howto_table[r_type];
8805 }
8806 else if (htab->plt_type != PLT_NEW)
8807 info->callbacks->einfo
8808 (_("%X%P: %H: %s relocation unsupported for bss-plt\n"),
8809 input_bfd, input_section, rel->r_offset,
8810 howto->name);
8811 break;
8812
8813 case R_PPC_PLTSEQ:
8814 case R_PPC_PLT16_HA:
8815 case R_PPC_PLT16_LO:
8816 if (unresolved_reloc)
8817 {
8818 bfd_byte *p = contents + (rel->r_offset & ~3);
8819 bfd_put_32 (input_bfd, NOP, p);
8820 unresolved_reloc = FALSE;
8821 r_type = R_PPC_NONE;
8822 howto = ppc_elf_howto_table[r_type];
8823 }
8824 else if (htab->plt_type != PLT_NEW)
8825 info->callbacks->einfo
8826 (_("%X%P: %H: %s relocation unsupported for bss-plt\n"),
8827 input_bfd, input_section, rel->r_offset,
8828 howto->name);
8829 break;
8830 }
8831
8832 /* Do any further special processing. */
8833 switch (r_type)
8834 {
8835 default:
8836 break;
8837
8838 case R_PPC_ADDR16_HA:
8839 case R_PPC_REL16_HA:
8840 case R_PPC_REL16DX_HA:
8841 case R_PPC_SECTOFF_HA:
8842 case R_PPC_TPREL16_HA:
8843 case R_PPC_DTPREL16_HA:
8844 case R_PPC_EMB_NADDR16_HA:
8845 case R_PPC_EMB_RELST_HA:
8846 /* It's just possible that this symbol is a weak symbol
8847 that's not actually defined anywhere. In that case,
8848 'sec' would be NULL, and we should leave the symbol
8849 alone (it will be set to zero elsewhere in the link). */
8850 if (sec == NULL)
8851 break;
8852 /* Fall through. */
8853
8854 case R_PPC_PLT16_HA:
8855 case R_PPC_GOT16_HA:
8856 case R_PPC_GOT_TLSGD16_HA:
8857 case R_PPC_GOT_TLSLD16_HA:
8858 case R_PPC_GOT_TPREL16_HA:
8859 case R_PPC_GOT_DTPREL16_HA:
8860 /* Add 0x10000 if sign bit in 0:15 is set.
8861 Bits 0:15 are not used. */
8862 addend += 0x8000;
8863 break;
8864
8865 case R_PPC_ADDR16:
8866 case R_PPC_ADDR16_LO:
8867 case R_PPC_GOT16:
8868 case R_PPC_GOT16_LO:
8869 case R_PPC_SDAREL16:
8870 case R_PPC_SECTOFF:
8871 case R_PPC_SECTOFF_LO:
8872 case R_PPC_DTPREL16:
8873 case R_PPC_DTPREL16_LO:
8874 case R_PPC_TPREL16:
8875 case R_PPC_TPREL16_LO:
8876 case R_PPC_GOT_TLSGD16:
8877 case R_PPC_GOT_TLSGD16_LO:
8878 case R_PPC_GOT_TLSLD16:
8879 case R_PPC_GOT_TLSLD16_LO:
8880 case R_PPC_GOT_DTPREL16:
8881 case R_PPC_GOT_DTPREL16_LO:
8882 case R_PPC_GOT_TPREL16:
8883 case R_PPC_GOT_TPREL16_LO:
8884 {
8885 /* The 32-bit ABI lacks proper relocations to deal with
8886 certain 64-bit instructions. Prevent damage to bits
8887 that make up part of the insn opcode. */
8888 unsigned int insn, mask, lobit;
8889
8890 insn = bfd_get_32 (input_bfd,
8891 contents + rel->r_offset - d_offset);
8892 mask = 0;
8893 if (is_insn_ds_form (insn))
8894 mask = 3;
8895 else if (is_insn_dq_form (insn))
8896 mask = 15;
8897 else
8898 break;
8899 relocation += addend;
8900 addend = insn & mask;
8901 lobit = mask & relocation;
8902 if (lobit != 0)
8903 {
8904 relocation ^= lobit;
8905 info->callbacks->einfo
8906 /* xgettext:c-format */
8907 (_("%H: error: %s against `%s' not a multiple of %u\n"),
8908 input_bfd, input_section, rel->r_offset,
8909 howto->name, sym_name, mask + 1);
8910 bfd_set_error (bfd_error_bad_value);
8911 ret = FALSE;
8912 }
8913 }
8914 break;
8915 }
8916
8917 #ifdef DEBUG
8918 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, "
8919 "offset = %ld, addend = %ld\n",
8920 howto->name,
8921 (int) r_type,
8922 sym_name,
8923 r_symndx,
8924 (long) rel->r_offset,
8925 (long) addend);
8926 #endif
8927
8928 if (unresolved_reloc
8929 && !((input_section->flags & SEC_DEBUGGING) != 0
8930 && h->def_dynamic)
8931 && _bfd_elf_section_offset (output_bfd, info, input_section,
8932 rel->r_offset) != (bfd_vma) -1)
8933 {
8934 info->callbacks->einfo
8935 /* xgettext:c-format */
8936 (_("%H: unresolvable %s relocation against symbol `%s'\n"),
8937 input_bfd, input_section, rel->r_offset,
8938 howto->name,
8939 sym_name);
8940 ret = FALSE;
8941 }
8942
8943 /* 16-bit fields in insns mostly have signed values, but a
8944 few insns have 16-bit unsigned values. Really, we should
8945 have different reloc types. */
8946 if (howto->complain_on_overflow != complain_overflow_dont
8947 && howto->dst_mask == 0xffff
8948 && (input_section->flags & SEC_CODE) != 0)
8949 {
8950 enum complain_overflow complain = complain_overflow_signed;
8951
8952 if ((elf_section_flags (input_section) & SHF_PPC_VLE) == 0)
8953 {
8954 unsigned int insn;
8955
8956 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
8957 if ((insn & (0x3fu << 26)) == 10u << 26 /* cmpli */)
8958 complain = complain_overflow_bitfield;
8959 else if ((insn & (0x3fu << 26)) == 28u << 26 /* andi */
8960 || (insn & (0x3fu << 26)) == 24u << 26 /* ori */
8961 || (insn & (0x3fu << 26)) == 26u << 26 /* xori */)
8962 complain = complain_overflow_unsigned;
8963 }
8964 if (howto->complain_on_overflow != complain)
8965 {
8966 alt_howto = *howto;
8967 alt_howto.complain_on_overflow = complain;
8968 howto = &alt_howto;
8969 }
8970 }
8971
8972 if (r_type == R_PPC_REL16DX_HA)
8973 {
8974 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
8975 if (rel->r_offset + 4 > input_section->size)
8976 r = bfd_reloc_outofrange;
8977 else
8978 {
8979 unsigned int insn;
8980
8981 relocation += addend;
8982 relocation -= (rel->r_offset
8983 + input_section->output_offset
8984 + input_section->output_section->vma);
8985 relocation >>= 16;
8986 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
8987 insn &= ~0x1fffc1;
8988 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
8989 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
8990 r = bfd_reloc_ok;
8991 }
8992 }
8993 else
8994 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
8995 rel->r_offset, relocation, addend);
8996
8997 if (r != bfd_reloc_ok)
8998 {
8999 if (r == bfd_reloc_overflow)
9000 {
9001 overflow:
9002 /* On code like "if (foo) foo();" don't report overflow
9003 on a branch to zero when foo is undefined. */
9004 if (!warned
9005 && !(h != NULL
9006 && (h->root.type == bfd_link_hash_undefweak
9007 || h->root.type == bfd_link_hash_undefined)
9008 && is_branch_reloc (r_type)))
9009 info->callbacks->reloc_overflow
9010 (info, (h ? &h->root : NULL), sym_name, howto->name,
9011 rel->r_addend, input_bfd, input_section, rel->r_offset);
9012 }
9013 else
9014 {
9015 info->callbacks->einfo
9016 /* xgettext:c-format */
9017 (_("%H: %s reloc against `%s': error %d\n"),
9018 input_bfd, input_section, rel->r_offset,
9019 howto->name, sym_name, (int) r);
9020 ret = FALSE;
9021 }
9022 }
9023 copy_reloc:
9024 if (wrel != rel)
9025 *wrel = *rel;
9026 }
9027
9028 if (wrel != rel)
9029 {
9030 Elf_Internal_Shdr *rel_hdr;
9031 size_t deleted = rel - wrel;
9032
9033 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
9034 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9035 if (rel_hdr->sh_size == 0)
9036 {
9037 /* It is too late to remove an empty reloc section. Leave
9038 one NONE reloc.
9039 ??? What is wrong with an empty section??? */
9040 rel_hdr->sh_size = rel_hdr->sh_entsize;
9041 deleted -= 1;
9042 wrel++;
9043 }
9044 relend = wrel;
9045 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
9046 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
9047 input_section->reloc_count -= deleted;
9048 }
9049
9050 #ifdef DEBUG
9051 fprintf (stderr, "\n");
9052 #endif
9053
9054 if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9055 && input_section->size != input_section->rawsize
9056 && (strcmp (input_section->output_section->name, ".init") == 0
9057 || strcmp (input_section->output_section->name, ".fini") == 0))
9058 {
9059 /* Branch around the trampolines. */
9060 unsigned int insn = B + input_section->size - input_section->rawsize;
9061 bfd_put_32 (input_bfd, insn, contents + input_section->rawsize);
9062 }
9063
9064 if (htab->params->ppc476_workaround
9065 && input_section->sec_info_type == SEC_INFO_TYPE_TARGET
9066 && (!bfd_link_relocatable (info)
9067 || (input_section->output_section->alignment_power
9068 >= htab->params->pagesize_p2)))
9069 {
9070 bfd_vma start_addr, end_addr, addr;
9071 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
9072
9073 if (relax_info->workaround_size != 0)
9074 {
9075 bfd_byte *p;
9076 unsigned int n;
9077 bfd_byte fill[4];
9078
9079 bfd_put_32 (input_bfd, BA, fill);
9080 p = contents + input_section->size - relax_info->workaround_size;
9081 n = relax_info->workaround_size >> 2;
9082 while (n--)
9083 {
9084 memcpy (p, fill, 4);
9085 p += 4;
9086 }
9087 }
9088
9089 /* The idea is: Replace the last instruction on a page with a
9090 branch to a patch area. Put the insn there followed by a
9091 branch back to the next page. Complicated a little by
9092 needing to handle moved conditional branches, and by not
9093 wanting to touch data-in-text. */
9094
9095 start_addr = (input_section->output_section->vma
9096 + input_section->output_offset);
9097 end_addr = (start_addr + input_section->size
9098 - relax_info->workaround_size);
9099 for (addr = ((start_addr & -pagesize) + pagesize - 4);
9100 addr < end_addr;
9101 addr += pagesize)
9102 {
9103 bfd_vma offset = addr - start_addr;
9104 Elf_Internal_Rela *lo, *hi;
9105 bfd_boolean is_data;
9106 bfd_vma patch_off, patch_addr;
9107 unsigned int insn;
9108
9109 /* Do we have a data reloc at this offset? If so, leave
9110 the word alone. */
9111 is_data = FALSE;
9112 lo = relocs;
9113 hi = relend;
9114 rel = NULL;
9115 while (lo < hi)
9116 {
9117 rel = lo + (hi - lo) / 2;
9118 if (rel->r_offset < offset)
9119 lo = rel + 1;
9120 else if (rel->r_offset > offset + 3)
9121 hi = rel;
9122 else
9123 {
9124 switch (ELF32_R_TYPE (rel->r_info))
9125 {
9126 case R_PPC_ADDR32:
9127 case R_PPC_UADDR32:
9128 case R_PPC_REL32:
9129 case R_PPC_ADDR30:
9130 is_data = TRUE;
9131 break;
9132 default:
9133 break;
9134 }
9135 break;
9136 }
9137 }
9138 if (is_data)
9139 continue;
9140
9141 /* Some instructions can be left alone too. Unconditional
9142 branches, except for bcctr with BO=0x14 (bctr, bctrl),
9143 avoid the icache failure.
9144
9145 The problem occurs due to prefetch across a page boundary
9146 where stale instructions can be fetched from the next
9147 page, and the mechanism for flushing these bad
9148 instructions fails under certain circumstances. The
9149 unconditional branches:
9150 1) Branch: b, bl, ba, bla,
9151 2) Branch Conditional: bc, bca, bcl, bcla,
9152 3) Branch Conditional to Link Register: bclr, bclrl,
9153 where (2) and (3) have BO=0x14 making them unconditional,
9154 prevent the bad prefetch because the prefetch itself is
9155 affected by these instructions. This happens even if the
9156 instruction is not executed.
9157
9158 A bctr example:
9159 .
9160 . lis 9,new_page@ha
9161 . addi 9,9,new_page@l
9162 . mtctr 9
9163 . bctr
9164 . nop
9165 . nop
9166 . new_page:
9167 .
9168 The bctr is not predicted taken due to ctr not being
9169 ready, so prefetch continues on past the bctr into the
9170 new page which might have stale instructions. If they
9171 fail to be flushed, then they will be executed after the
9172 bctr executes. Either of the following modifications
9173 prevent the bad prefetch from happening in the first
9174 place:
9175 .
9176 . lis 9,new_page@ha lis 9,new_page@ha
9177 . addi 9,9,new_page@l addi 9,9,new_page@l
9178 . mtctr 9 mtctr 9
9179 . bctr bctr
9180 . nop b somewhere_else
9181 . b somewhere_else nop
9182 . new_page: new_page:
9183 . */
9184 insn = bfd_get_32 (input_bfd, contents + offset);
9185 if ((insn & (0x3fu << 26)) == (18u << 26) /* b,bl,ba,bla */
9186 || ((insn & (0x3fu << 26)) == (16u << 26) /* bc,bcl,bca,bcla*/
9187 && (insn & (0x14 << 21)) == (0x14 << 21)) /* with BO=0x14 */
9188 || ((insn & (0x3fu << 26)) == (19u << 26)
9189 && (insn & (0x3ff << 1)) == (16u << 1) /* bclr,bclrl */
9190 && (insn & (0x14 << 21)) == (0x14 << 21)))/* with BO=0x14 */
9191 continue;
9192
9193 patch_addr = (start_addr + input_section->size
9194 - relax_info->workaround_size);
9195 patch_addr = (patch_addr + 15) & -16;
9196 patch_off = patch_addr - start_addr;
9197 bfd_put_32 (input_bfd, B + patch_off - offset, contents + offset);
9198
9199 if (rel != NULL
9200 && rel->r_offset >= offset
9201 && rel->r_offset < offset + 4)
9202 {
9203 asection *sreloc;
9204
9205 /* If the insn we are patching had a reloc, adjust the
9206 reloc r_offset so that the reloc applies to the moved
9207 location. This matters for -r and --emit-relocs. */
9208 if (rel + 1 != relend)
9209 {
9210 Elf_Internal_Rela tmp = *rel;
9211
9212 /* Keep the relocs sorted by r_offset. */
9213 memmove (rel, rel + 1, (relend - (rel + 1)) * sizeof (*rel));
9214 relend[-1] = tmp;
9215 }
9216 relend[-1].r_offset += patch_off - offset;
9217
9218 /* Adjust REL16 addends too. */
9219 switch (ELF32_R_TYPE (relend[-1].r_info))
9220 {
9221 case R_PPC_REL16:
9222 case R_PPC_REL16_LO:
9223 case R_PPC_REL16_HI:
9224 case R_PPC_REL16_HA:
9225 relend[-1].r_addend += patch_off - offset;
9226 break;
9227 default:
9228 break;
9229 }
9230
9231 /* If we are building a PIE or shared library with
9232 non-PIC objects, perhaps we had a dynamic reloc too?
9233 If so, the dynamic reloc must move with the insn. */
9234 sreloc = elf_section_data (input_section)->sreloc;
9235 if (sreloc != NULL)
9236 {
9237 Elf32_External_Rela *slo, *shi, *srelend;
9238 bfd_vma soffset;
9239
9240 slo = (Elf32_External_Rela *) sreloc->contents;
9241 shi = srelend = slo + sreloc->reloc_count;
9242 soffset = (offset + input_section->output_section->vma
9243 + input_section->output_offset);
9244 while (slo < shi)
9245 {
9246 Elf32_External_Rela *srel = slo + (shi - slo) / 2;
9247 bfd_elf32_swap_reloca_in (output_bfd, (bfd_byte *) srel,
9248 &outrel);
9249 if (outrel.r_offset < soffset)
9250 slo = srel + 1;
9251 else if (outrel.r_offset > soffset + 3)
9252 shi = srel;
9253 else
9254 {
9255 if (srel + 1 != srelend)
9256 {
9257 memmove (srel, srel + 1,
9258 (srelend - (srel + 1)) * sizeof (*srel));
9259 srel = srelend - 1;
9260 }
9261 outrel.r_offset += patch_off - offset;
9262 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
9263 (bfd_byte *) srel);
9264 break;
9265 }
9266 }
9267 }
9268 }
9269 else
9270 rel = NULL;
9271
9272 if ((insn & (0x3fu << 26)) == (16u << 26) /* bc */
9273 && (insn & 2) == 0 /* relative */)
9274 {
9275 bfd_vma delta = ((insn & 0xfffc) ^ 0x8000) - 0x8000;
9276
9277 delta += offset - patch_off;
9278 if (bfd_link_relocatable (info) && rel != NULL)
9279 delta = 0;
9280 if (!bfd_link_relocatable (info) && rel != NULL)
9281 {
9282 enum elf_ppc_reloc_type r_type;
9283
9284 r_type = ELF32_R_TYPE (relend[-1].r_info);
9285 if (r_type == R_PPC_REL14_BRTAKEN)
9286 insn |= BRANCH_PREDICT_BIT;
9287 else if (r_type == R_PPC_REL14_BRNTAKEN)
9288 insn &= ~BRANCH_PREDICT_BIT;
9289 else
9290 BFD_ASSERT (r_type == R_PPC_REL14);
9291
9292 if ((r_type == R_PPC_REL14_BRTAKEN
9293 || r_type == R_PPC_REL14_BRNTAKEN)
9294 && delta + 0x8000 < 0x10000
9295 && (bfd_signed_vma) delta < 0)
9296 insn ^= BRANCH_PREDICT_BIT;
9297 }
9298 if (delta + 0x8000 < 0x10000)
9299 {
9300 bfd_put_32 (input_bfd,
9301 (insn & ~0xfffc) | (delta & 0xfffc),
9302 contents + patch_off);
9303 patch_off += 4;
9304 bfd_put_32 (input_bfd,
9305 B | ((offset + 4 - patch_off) & 0x3fffffc),
9306 contents + patch_off);
9307 patch_off += 4;
9308 }
9309 else
9310 {
9311 if (rel != NULL)
9312 {
9313 unsigned int r_sym = ELF32_R_SYM (relend[-1].r_info);
9314
9315 relend[-1].r_offset += 8;
9316 relend[-1].r_info = ELF32_R_INFO (r_sym, R_PPC_REL24);
9317 }
9318 bfd_put_32 (input_bfd,
9319 (insn & ~0xfffc) | 8,
9320 contents + patch_off);
9321 patch_off += 4;
9322 bfd_put_32 (input_bfd,
9323 B | ((offset + 4 - patch_off) & 0x3fffffc),
9324 contents + patch_off);
9325 patch_off += 4;
9326 bfd_put_32 (input_bfd,
9327 B | ((delta - 8) & 0x3fffffc),
9328 contents + patch_off);
9329 patch_off += 4;
9330 }
9331 }
9332 else
9333 {
9334 bfd_put_32 (input_bfd, insn, contents + patch_off);
9335 patch_off += 4;
9336 bfd_put_32 (input_bfd,
9337 B | ((offset + 4 - patch_off) & 0x3fffffc),
9338 contents + patch_off);
9339 patch_off += 4;
9340 }
9341 BFD_ASSERT (patch_off <= input_section->size);
9342 relax_info->workaround_size = input_section->size - patch_off;
9343 }
9344 }
9345
9346 return ret;
9347 }
9348 \f
9349 /* Write out the PLT relocs and entries for H. */
9350
9351 static bfd_boolean
9352 write_global_sym_plt (struct elf_link_hash_entry *h, void *inf)
9353 {
9354 struct bfd_link_info *info = (struct bfd_link_info *) inf;
9355 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9356 struct plt_entry *ent;
9357 bfd_boolean doneone;
9358
9359 doneone = FALSE;
9360 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
9361 if (ent->plt.offset != (bfd_vma) -1)
9362 {
9363 if (!doneone)
9364 {
9365 Elf_Internal_Rela rela;
9366 bfd_byte *loc;
9367 bfd_vma reloc_index;
9368 asection *plt = htab->elf.splt;
9369 asection *relplt = htab->elf.srelplt;
9370
9371 if (htab->plt_type == PLT_NEW
9372 || !htab->elf.dynamic_sections_created
9373 || h->dynindx == -1)
9374 reloc_index = ent->plt.offset / 4;
9375 else
9376 {
9377 reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size)
9378 / htab->plt_slot_size);
9379 if (reloc_index > PLT_NUM_SINGLE_ENTRIES
9380 && htab->plt_type == PLT_OLD)
9381 reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
9382 }
9383
9384 /* This symbol has an entry in the procedure linkage table.
9385 Set it up. */
9386 if (htab->plt_type == PLT_VXWORKS
9387 && htab->elf.dynamic_sections_created
9388 && h->dynindx != -1)
9389 {
9390 bfd_vma got_offset;
9391 const bfd_vma *plt_entry;
9392
9393 /* The first three entries in .got.plt are reserved. */
9394 got_offset = (reloc_index + 3) * 4;
9395
9396 /* Use the right PLT. */
9397 plt_entry = bfd_link_pic (info) ? ppc_elf_vxworks_pic_plt_entry
9398 : ppc_elf_vxworks_plt_entry;
9399
9400 /* Fill in the .plt on VxWorks. */
9401 if (bfd_link_pic (info))
9402 {
9403 bfd_put_32 (info->output_bfd,
9404 plt_entry[0] | PPC_HA (got_offset),
9405 plt->contents + ent->plt.offset + 0);
9406 bfd_put_32 (info->output_bfd,
9407 plt_entry[1] | PPC_LO (got_offset),
9408 plt->contents + ent->plt.offset + 4);
9409 }
9410 else
9411 {
9412 bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot);
9413
9414 bfd_put_32 (info->output_bfd,
9415 plt_entry[0] | PPC_HA (got_loc),
9416 plt->contents + ent->plt.offset + 0);
9417 bfd_put_32 (info->output_bfd,
9418 plt_entry[1] | PPC_LO (got_loc),
9419 plt->contents + ent->plt.offset + 4);
9420 }
9421
9422 bfd_put_32 (info->output_bfd, plt_entry[2],
9423 plt->contents + ent->plt.offset + 8);
9424 bfd_put_32 (info->output_bfd, plt_entry[3],
9425 plt->contents + ent->plt.offset + 12);
9426
9427 /* This instruction is an immediate load. The value loaded is
9428 the byte offset of the R_PPC_JMP_SLOT relocation from the
9429 start of the .rela.plt section. The value is stored in the
9430 low-order 16 bits of the load instruction. */
9431 /* NOTE: It appears that this is now an index rather than a
9432 prescaled offset. */
9433 bfd_put_32 (info->output_bfd,
9434 plt_entry[4] | reloc_index,
9435 plt->contents + ent->plt.offset + 16);
9436 /* This instruction is a PC-relative branch whose target is
9437 the start of the PLT section. The address of this branch
9438 instruction is 20 bytes beyond the start of this PLT entry.
9439 The address is encoded in bits 6-29, inclusive. The value
9440 stored is right-shifted by two bits, permitting a 26-bit
9441 offset. */
9442 bfd_put_32 (info->output_bfd,
9443 (plt_entry[5]
9444 | (-(ent->plt.offset + 20) & 0x03fffffc)),
9445 plt->contents + ent->plt.offset + 20);
9446 bfd_put_32 (info->output_bfd, plt_entry[6],
9447 plt->contents + ent->plt.offset + 24);
9448 bfd_put_32 (info->output_bfd, plt_entry[7],
9449 plt->contents + ent->plt.offset + 28);
9450
9451 /* Fill in the GOT entry corresponding to this PLT slot with
9452 the address immediately after the "bctr" instruction
9453 in this PLT entry. */
9454 bfd_put_32 (info->output_bfd, (plt->output_section->vma
9455 + plt->output_offset
9456 + ent->plt.offset + 16),
9457 htab->elf.sgotplt->contents + got_offset);
9458
9459 if (!bfd_link_pic (info))
9460 {
9461 /* Fill in a couple of entries in .rela.plt.unloaded. */
9462 loc = htab->srelplt2->contents
9463 + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index
9464 * VXWORKS_PLT_NON_JMP_SLOT_RELOCS)
9465 * sizeof (Elf32_External_Rela));
9466
9467 /* Provide the @ha relocation for the first instruction. */
9468 rela.r_offset = (plt->output_section->vma
9469 + plt->output_offset
9470 + ent->plt.offset + 2);
9471 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9472 R_PPC_ADDR16_HA);
9473 rela.r_addend = got_offset;
9474 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9475 loc += sizeof (Elf32_External_Rela);
9476
9477 /* Provide the @l relocation for the second instruction. */
9478 rela.r_offset = (plt->output_section->vma
9479 + plt->output_offset
9480 + ent->plt.offset + 6);
9481 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
9482 R_PPC_ADDR16_LO);
9483 rela.r_addend = got_offset;
9484 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9485 loc += sizeof (Elf32_External_Rela);
9486
9487 /* Provide a relocation for the GOT entry corresponding to this
9488 PLT slot. Point it at the middle of the .plt entry. */
9489 rela.r_offset = (htab->elf.sgotplt->output_section->vma
9490 + htab->elf.sgotplt->output_offset
9491 + got_offset);
9492 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
9493 R_PPC_ADDR32);
9494 rela.r_addend = ent->plt.offset + 16;
9495 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9496 }
9497
9498 /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT.
9499 In particular, the offset for the relocation is not the
9500 address of the PLT entry for this function, as specified
9501 by the ABI. Instead, the offset is set to the address of
9502 the GOT slot for this function. See EABI 4.4.4.1. */
9503 rela.r_offset = (htab->elf.sgotplt->output_section->vma
9504 + htab->elf.sgotplt->output_offset
9505 + got_offset);
9506 rela.r_addend = 0;
9507 }
9508 else
9509 {
9510 rela.r_addend = 0;
9511 if (!htab->elf.dynamic_sections_created
9512 || h->dynindx == -1)
9513 {
9514 if (h->type == STT_GNU_IFUNC)
9515 {
9516 plt = htab->elf.iplt;
9517 relplt = htab->elf.irelplt;
9518 }
9519 else
9520 {
9521 plt = htab->pltlocal;
9522 relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
9523 }
9524 if (h->def_regular
9525 && (h->root.type == bfd_link_hash_defined
9526 || h->root.type == bfd_link_hash_defweak))
9527 rela.r_addend = SYM_VAL (h);
9528 }
9529
9530 if (relplt == NULL)
9531 {
9532 loc = plt->contents + ent->plt.offset;
9533 bfd_put_32 (info->output_bfd, rela.r_addend, loc);
9534 }
9535 else
9536 {
9537 rela.r_offset = (plt->output_section->vma
9538 + plt->output_offset
9539 + ent->plt.offset);
9540
9541 if (htab->plt_type == PLT_OLD
9542 || !htab->elf.dynamic_sections_created
9543 || h->dynindx == -1)
9544 {
9545 /* We don't need to fill in the .plt. The ppc dynamic
9546 linker will fill it in. */
9547 }
9548 else
9549 {
9550 bfd_vma val = (htab->glink_pltresolve + ent->plt.offset
9551 + htab->glink->output_section->vma
9552 + htab->glink->output_offset);
9553 bfd_put_32 (info->output_bfd, val,
9554 plt->contents + ent->plt.offset);
9555 }
9556 }
9557 }
9558
9559 if (relplt != NULL)
9560 {
9561 /* Fill in the entry in the .rela.plt section. */
9562 if (!htab->elf.dynamic_sections_created
9563 || h->dynindx == -1)
9564 {
9565 if (h->type == STT_GNU_IFUNC)
9566 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
9567 else
9568 rela.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
9569 loc = relplt->contents + (relplt->reloc_count++
9570 * sizeof (Elf32_External_Rela));
9571 htab->local_ifunc_resolver = 1;
9572 }
9573 else
9574 {
9575 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
9576 loc = relplt->contents + (reloc_index
9577 * sizeof (Elf32_External_Rela));
9578 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
9579 htab->maybe_local_ifunc_resolver = 1;
9580 }
9581 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9582 }
9583 doneone = TRUE;
9584 }
9585
9586 if (htab->plt_type == PLT_NEW
9587 || !htab->elf.dynamic_sections_created
9588 || h->dynindx == -1)
9589 {
9590 unsigned char *p;
9591 asection *plt = htab->elf.splt;
9592
9593 if (!htab->elf.dynamic_sections_created
9594 || h->dynindx == -1)
9595 {
9596 if (h->type == STT_GNU_IFUNC)
9597 plt = htab->elf.iplt;
9598 else
9599 break;
9600 }
9601
9602 p = (unsigned char *) htab->glink->contents + ent->glink_offset;
9603 write_glink_stub (h, ent, plt, p, info);
9604
9605 if (!bfd_link_pic (info))
9606 /* We only need one non-PIC glink stub. */
9607 break;
9608 }
9609 else
9610 break;
9611 }
9612 return TRUE;
9613 }
9614
9615 /* Finish up PLT handling. */
9616
9617 bfd_boolean
9618 ppc_finish_symbols (struct bfd_link_info *info)
9619 {
9620 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9621 bfd *ibfd;
9622
9623 if (!htab)
9624 return TRUE;
9625
9626 elf_link_hash_traverse (&htab->elf, write_global_sym_plt, info);
9627
9628 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9629 {
9630 bfd_vma *local_got, *end_local_got;
9631 struct plt_entry **local_plt, **lplt, **end_local_plt;
9632 Elf_Internal_Shdr *symtab_hdr;
9633 bfd_size_type locsymcount;
9634 Elf_Internal_Sym *local_syms = NULL;
9635 struct plt_entry *ent;
9636
9637 if (!is_ppc_elf (ibfd))
9638 continue;
9639
9640 local_got = elf_local_got_offsets (ibfd);
9641 if (!local_got)
9642 continue;
9643
9644 symtab_hdr = &elf_symtab_hdr (ibfd);
9645 locsymcount = symtab_hdr->sh_info;
9646 end_local_got = local_got + locsymcount;
9647 local_plt = (struct plt_entry **) end_local_got;
9648 end_local_plt = local_plt + locsymcount;
9649 for (lplt = local_plt; lplt < end_local_plt; ++lplt)
9650 for (ent = *lplt; ent != NULL; ent = ent->next)
9651 {
9652 if (ent->plt.offset != (bfd_vma) -1)
9653 {
9654 Elf_Internal_Sym *sym;
9655 asection *sym_sec;
9656 asection *plt, *relplt;
9657 bfd_byte *loc;
9658 bfd_vma val;
9659 Elf_Internal_Rela rela;
9660 unsigned char *p;
9661
9662 if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
9663 lplt - local_plt, ibfd))
9664 {
9665 if (symtab_hdr->contents != (unsigned char *) local_syms)
9666 free (local_syms);
9667 return FALSE;
9668 }
9669
9670 val = sym->st_value;
9671 if (sym_sec != NULL && sym_sec->output_section != NULL)
9672 val += sym_sec->output_offset + sym_sec->output_section->vma;
9673
9674 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9675 {
9676 htab->local_ifunc_resolver = 1;
9677 plt = htab->elf.iplt;
9678 relplt = htab->elf.irelplt;
9679 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
9680 }
9681 else
9682 {
9683 plt = htab->pltlocal;
9684 if (bfd_link_pic (info))
9685 {
9686 relplt = htab->relpltlocal;
9687 rela.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
9688 }
9689 else
9690 {
9691 loc = plt->contents + ent->plt.offset;
9692 bfd_put_32 (info->output_bfd, val, loc);
9693 continue;
9694 }
9695 }
9696
9697 rela.r_offset = (ent->plt.offset
9698 + plt->output_offset
9699 + plt->output_section->vma);
9700 rela.r_addend = val;
9701 loc = relplt->contents + (relplt->reloc_count++
9702 * sizeof (Elf32_External_Rela));
9703 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, loc);
9704
9705 p = (unsigned char *) htab->glink->contents + ent->glink_offset;
9706 write_glink_stub (NULL, ent, htab->elf.iplt, p, info);
9707 }
9708 }
9709
9710 if (local_syms != NULL
9711 && symtab_hdr->contents != (unsigned char *) local_syms)
9712 {
9713 if (!info->keep_memory)
9714 free (local_syms);
9715 else
9716 symtab_hdr->contents = (unsigned char *) local_syms;
9717 }
9718 }
9719 return TRUE;
9720 }
9721
9722 /* Finish up dynamic symbol handling. We set the contents of various
9723 dynamic sections here. */
9724
9725 static bfd_boolean
9726 ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
9727 struct bfd_link_info *info,
9728 struct elf_link_hash_entry *h,
9729 Elf_Internal_Sym *sym)
9730 {
9731 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9732 struct plt_entry *ent;
9733
9734 #ifdef DEBUG
9735 fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
9736 h->root.root.string);
9737 #endif
9738
9739 if (!h->def_regular
9740 || (h->type == STT_GNU_IFUNC && !bfd_link_pic (info)))
9741 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
9742 if (ent->plt.offset != (bfd_vma) -1)
9743 {
9744 if (!h->def_regular)
9745 {
9746 /* Mark the symbol as undefined, rather than as
9747 defined in the .plt section. Leave the value if
9748 there were any relocations where pointer equality
9749 matters (this is a clue for the dynamic linker, to
9750 make function pointer comparisons work between an
9751 application and shared library), otherwise set it
9752 to zero. */
9753 sym->st_shndx = SHN_UNDEF;
9754 if (!h->pointer_equality_needed)
9755 sym->st_value = 0;
9756 else if (!h->ref_regular_nonweak)
9757 {
9758 /* This breaks function pointer comparisons, but
9759 that is better than breaking tests for a NULL
9760 function pointer. */
9761 sym->st_value = 0;
9762 }
9763 }
9764 else
9765 {
9766 /* Set the value of ifunc symbols in a non-pie
9767 executable to the glink entry. This is to avoid
9768 text relocations. We can't do this for ifunc in
9769 allocate_dynrelocs, as we do for normal dynamic
9770 function symbols with plt entries, because we need
9771 to keep the original value around for the ifunc
9772 relocation. */
9773 sym->st_shndx
9774 = (_bfd_elf_section_from_bfd_section
9775 (info->output_bfd, htab->glink->output_section));
9776 sym->st_value = (ent->glink_offset
9777 + htab->glink->output_offset
9778 + htab->glink->output_section->vma);
9779 }
9780 break;
9781 }
9782
9783 if (h->needs_copy)
9784 {
9785 asection *s;
9786 Elf_Internal_Rela rela;
9787 bfd_byte *loc;
9788
9789 /* This symbols needs a copy reloc. Set it up. */
9790
9791 #ifdef DEBUG
9792 fprintf (stderr, ", copy");
9793 #endif
9794
9795 BFD_ASSERT (h->dynindx != -1);
9796
9797 if (ppc_elf_hash_entry (h)->has_sda_refs)
9798 s = htab->relsbss;
9799 else if (h->root.u.def.section == htab->elf.sdynrelro)
9800 s = htab->elf.sreldynrelro;
9801 else
9802 s = htab->elf.srelbss;
9803 BFD_ASSERT (s != NULL);
9804
9805 rela.r_offset = SYM_VAL (h);
9806 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
9807 rela.r_addend = 0;
9808 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
9809 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9810 }
9811
9812 #ifdef DEBUG
9813 fprintf (stderr, "\n");
9814 #endif
9815
9816 return TRUE;
9817 }
9818 \f
9819 static enum elf_reloc_type_class
9820 ppc_elf_reloc_type_class (const struct bfd_link_info *info,
9821 const asection *rel_sec,
9822 const Elf_Internal_Rela *rela)
9823 {
9824 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
9825
9826 if (rel_sec == htab->elf.irelplt)
9827 return reloc_class_ifunc;
9828
9829 switch (ELF32_R_TYPE (rela->r_info))
9830 {
9831 case R_PPC_RELATIVE:
9832 return reloc_class_relative;
9833 case R_PPC_JMP_SLOT:
9834 return reloc_class_plt;
9835 case R_PPC_COPY:
9836 return reloc_class_copy;
9837 default:
9838 return reloc_class_normal;
9839 }
9840 }
9841 \f
9842 /* Finish up the dynamic sections. */
9843
9844 static bfd_boolean
9845 ppc_elf_finish_dynamic_sections (bfd *output_bfd,
9846 struct bfd_link_info *info)
9847 {
9848 asection *sdyn;
9849 struct ppc_elf_link_hash_table *htab;
9850 bfd_vma got;
9851 bfd *dynobj;
9852 bfd_boolean ret = TRUE;
9853
9854 #ifdef DEBUG
9855 fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
9856 #endif
9857
9858 htab = ppc_elf_hash_table (info);
9859 dynobj = htab->elf.dynobj;
9860 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
9861
9862 got = 0;
9863 if (htab->elf.hgot != NULL)
9864 got = SYM_VAL (htab->elf.hgot);
9865
9866 if (htab->elf.dynamic_sections_created)
9867 {
9868 Elf32_External_Dyn *dyncon, *dynconend;
9869
9870 BFD_ASSERT (htab->elf.splt != NULL && sdyn != NULL);
9871
9872 dyncon = (Elf32_External_Dyn *) sdyn->contents;
9873 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
9874 for (; dyncon < dynconend; dyncon++)
9875 {
9876 Elf_Internal_Dyn dyn;
9877 asection *s;
9878
9879 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
9880
9881 switch (dyn.d_tag)
9882 {
9883 case DT_PLTGOT:
9884 if (htab->elf.target_os == is_vxworks)
9885 s = htab->elf.sgotplt;
9886 else
9887 s = htab->elf.splt;
9888 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9889 break;
9890
9891 case DT_PLTRELSZ:
9892 dyn.d_un.d_val = htab->elf.srelplt->size;
9893 break;
9894
9895 case DT_JMPREL:
9896 s = htab->elf.srelplt;
9897 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9898 break;
9899
9900 case DT_PPC_GOT:
9901 dyn.d_un.d_ptr = got;
9902 break;
9903
9904 case DT_TEXTREL:
9905 if (htab->local_ifunc_resolver)
9906 info->callbacks->einfo
9907 (_("%X%P: text relocations and GNU indirect "
9908 "functions will result in a segfault at runtime\n"));
9909 else if (htab->maybe_local_ifunc_resolver)
9910 info->callbacks->einfo
9911 (_("%P: warning: text relocations and GNU indirect "
9912 "functions may result in a segfault at runtime\n"));
9913 continue;
9914
9915 default:
9916 if (htab->elf.target_os == is_vxworks
9917 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
9918 break;
9919 continue;
9920 }
9921
9922 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
9923 }
9924 }
9925
9926 if (htab->elf.sgot != NULL
9927 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
9928 {
9929 if (htab->elf.hgot->root.u.def.section == htab->elf.sgot
9930 || htab->elf.hgot->root.u.def.section == htab->elf.sgotplt)
9931 {
9932 unsigned char *p = htab->elf.hgot->root.u.def.section->contents;
9933
9934 p += htab->elf.hgot->root.u.def.value;
9935 if (htab->plt_type == PLT_OLD)
9936 {
9937 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4
9938 so that a function can easily find the address of
9939 _GLOBAL_OFFSET_TABLE_. */
9940 BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4
9941 < htab->elf.hgot->root.u.def.section->size);
9942 bfd_put_32 (output_bfd, 0x4e800021, p - 4);
9943 }
9944
9945 if (sdyn != NULL)
9946 {
9947 bfd_vma val = sdyn->output_section->vma + sdyn->output_offset;
9948 BFD_ASSERT (htab->elf.hgot->root.u.def.value
9949 < htab->elf.hgot->root.u.def.section->size);
9950 bfd_put_32 (output_bfd, val, p);
9951 }
9952 }
9953 else
9954 {
9955 /* xgettext:c-format */
9956 _bfd_error_handler (_("%s not defined in linker created %pA"),
9957 htab->elf.hgot->root.root.string,
9958 (htab->elf.sgotplt != NULL
9959 ? htab->elf.sgotplt : htab->elf.sgot));
9960 bfd_set_error (bfd_error_bad_value);
9961 ret = FALSE;
9962 }
9963
9964 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
9965 }
9966
9967 /* Fill in the first entry in the VxWorks procedure linkage table. */
9968 if (htab->elf.target_os == is_vxworks
9969 && htab->elf.splt != NULL
9970 && htab->elf.splt->size != 0
9971 && htab->elf.splt->output_section != bfd_abs_section_ptr)
9972 {
9973 asection *splt = htab->elf.splt;
9974 /* Use the right PLT. */
9975 const bfd_vma *plt_entry = (bfd_link_pic (info)
9976 ? ppc_elf_vxworks_pic_plt0_entry
9977 : ppc_elf_vxworks_plt0_entry);
9978
9979 if (!bfd_link_pic (info))
9980 {
9981 bfd_vma got_value = SYM_VAL (htab->elf.hgot);
9982
9983 bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value),
9984 splt->contents + 0);
9985 bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value),
9986 splt->contents + 4);
9987 }
9988 else
9989 {
9990 bfd_put_32 (output_bfd, plt_entry[0], splt->contents + 0);
9991 bfd_put_32 (output_bfd, plt_entry[1], splt->contents + 4);
9992 }
9993 bfd_put_32 (output_bfd, plt_entry[2], splt->contents + 8);
9994 bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12);
9995 bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16);
9996 bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20);
9997 bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24);
9998 bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28);
9999
10000 if (! bfd_link_pic (info))
10001 {
10002 Elf_Internal_Rela rela;
10003 bfd_byte *loc;
10004
10005 loc = htab->srelplt2->contents;
10006
10007 /* Output the @ha relocation for the first instruction. */
10008 rela.r_offset = (htab->elf.splt->output_section->vma
10009 + htab->elf.splt->output_offset
10010 + 2);
10011 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
10012 rela.r_addend = 0;
10013 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10014 loc += sizeof (Elf32_External_Rela);
10015
10016 /* Output the @l relocation for the second instruction. */
10017 rela.r_offset = (htab->elf.splt->output_section->vma
10018 + htab->elf.splt->output_offset
10019 + 6);
10020 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
10021 rela.r_addend = 0;
10022 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10023 loc += sizeof (Elf32_External_Rela);
10024
10025 /* Fix up the remaining relocations. They may have the wrong
10026 symbol index for _G_O_T_ or _P_L_T_ depending on the order
10027 in which symbols were output. */
10028 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
10029 {
10030 Elf_Internal_Rela rel;
10031
10032 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10033 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
10034 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10035 loc += sizeof (Elf32_External_Rela);
10036
10037 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10038 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
10039 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10040 loc += sizeof (Elf32_External_Rela);
10041
10042 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
10043 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32);
10044 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
10045 loc += sizeof (Elf32_External_Rela);
10046 }
10047 }
10048 }
10049
10050 if (htab->glink != NULL
10051 && htab->glink->contents != NULL
10052 && htab->elf.dynamic_sections_created)
10053 {
10054 unsigned char *p;
10055 unsigned char *endp;
10056 bfd_vma res0;
10057
10058 /*
10059 * PIC glink code is the following:
10060 *
10061 * # ith PLT code stub.
10062 * addis 11,30,(plt+(i-1)*4-got)@ha
10063 * lwz 11,(plt+(i-1)*4-got)@l(11)
10064 * mtctr 11
10065 * bctr
10066 *
10067 * # A table of branches, one for each plt entry.
10068 * # The idea is that the plt call stub loads ctr and r11 with these
10069 * # addresses, so (r11 - res_0) gives the plt index * 4.
10070 * res_0: b PLTresolve
10071 * res_1: b PLTresolve
10072 * .
10073 * # Some number of entries towards the end can be nops
10074 * res_n_m3: nop
10075 * res_n_m2: nop
10076 * res_n_m1:
10077 *
10078 * PLTresolve:
10079 * addis 11,11,(1f-res_0)@ha
10080 * mflr 0
10081 * bcl 20,31,1f
10082 * 1: addi 11,11,(1b-res_0)@l
10083 * mflr 12
10084 * mtlr 0
10085 * sub 11,11,12 # r11 = index * 4
10086 * addis 12,12,(got+4-1b)@ha
10087 * lwz 0,(got+4-1b)@l(12) # got[1] address of dl_runtime_resolve
10088 * lwz 12,(got+8-1b)@l(12) # got[2] contains the map address
10089 * mtctr 0
10090 * add 0,11,11
10091 * add 11,0,11 # r11 = index * 12 = reloc offset.
10092 * bctr
10093 *
10094 * Non-PIC glink code is a little simpler.
10095 *
10096 * # ith PLT code stub.
10097 * lis 11,(plt+(i-1)*4)@ha
10098 * lwz 11,(plt+(i-1)*4)@l(11)
10099 * mtctr 11
10100 * bctr
10101 *
10102 * The branch table is the same, then comes
10103 *
10104 * PLTresolve:
10105 * lis 12,(got+4)@ha
10106 * addis 11,11,(-res_0)@ha
10107 * lwz 0,(got+4)@l(12) # got[1] address of dl_runtime_resolve
10108 * addi 11,11,(-res_0)@l # r11 = index * 4
10109 * mtctr 0
10110 * add 0,11,11
10111 * lwz 12,(got+8)@l(12) # got[2] contains the map address
10112 * add 11,0,11 # r11 = index * 12 = reloc offset.
10113 * bctr
10114 */
10115
10116 /* Build the branch table, one for each plt entry (less one),
10117 and perhaps some padding. */
10118 p = htab->glink->contents;
10119 p += htab->glink_pltresolve;
10120 endp = htab->glink->contents;
10121 endp += htab->glink->size - GLINK_PLTRESOLVE;
10122 while (p < endp - (htab->params->ppc476_workaround ? 0 : 8 * 4))
10123 {
10124 bfd_put_32 (output_bfd, B + endp - p, p);
10125 p += 4;
10126 }
10127 while (p < endp)
10128 {
10129 bfd_put_32 (output_bfd, NOP, p);
10130 p += 4;
10131 }
10132
10133 res0 = (htab->glink_pltresolve
10134 + htab->glink->output_section->vma
10135 + htab->glink->output_offset);
10136
10137 if (htab->params->ppc476_workaround)
10138 {
10139 /* Ensure that a call stub at the end of a page doesn't
10140 result in prefetch over the end of the page into the
10141 glink branch table. */
10142 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2;
10143 bfd_vma page_addr;
10144 bfd_vma glink_start = (htab->glink->output_section->vma
10145 + htab->glink->output_offset);
10146
10147 for (page_addr = res0 & -pagesize;
10148 page_addr > glink_start;
10149 page_addr -= pagesize)
10150 {
10151 /* We have a plt call stub that may need fixing. */
10152 bfd_byte *loc;
10153 unsigned int insn;
10154
10155 loc = htab->glink->contents + page_addr - 4 - glink_start;
10156 insn = bfd_get_32 (output_bfd, loc);
10157 if (insn == BCTR)
10158 {
10159 /* By alignment, we know that there must be at least
10160 one other call stub before this one. */
10161 insn = bfd_get_32 (output_bfd, loc - 16);
10162 if (insn == BCTR)
10163 bfd_put_32 (output_bfd, B | (-16 & 0x3fffffc), loc);
10164 else
10165 bfd_put_32 (output_bfd, B | (-20 & 0x3fffffc), loc);
10166 }
10167 }
10168 }
10169
10170 /* Last comes the PLTresolve stub. */
10171 endp = p + GLINK_PLTRESOLVE;
10172 if (bfd_link_pic (info))
10173 {
10174 bfd_vma bcl;
10175
10176 bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4
10177 + htab->glink->output_section->vma
10178 + htab->glink->output_offset);
10179
10180 bfd_put_32 (output_bfd, ADDIS_11_11 + PPC_HA (bcl - res0), p);
10181 p += 4;
10182 bfd_put_32 (output_bfd, MFLR_0, p);
10183 p += 4;
10184 bfd_put_32 (output_bfd, BCL_20_31, p);
10185 p += 4;
10186 bfd_put_32 (output_bfd, ADDI_11_11 + PPC_LO (bcl - res0), p);
10187 p += 4;
10188 bfd_put_32 (output_bfd, MFLR_12, p);
10189 p += 4;
10190 bfd_put_32 (output_bfd, MTLR_0, p);
10191 p += 4;
10192 bfd_put_32 (output_bfd, SUB_11_11_12, p);
10193 p += 4;
10194 bfd_put_32 (output_bfd, ADDIS_12_12 + PPC_HA (got + 4 - bcl), p);
10195 p += 4;
10196 if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl))
10197 {
10198 bfd_put_32 (output_bfd, LWZ_0_12 + PPC_LO (got + 4 - bcl), p);
10199 p += 4;
10200 bfd_put_32 (output_bfd, LWZ_12_12 + PPC_LO (got + 8 - bcl), p);
10201 p += 4;
10202 }
10203 else
10204 {
10205 bfd_put_32 (output_bfd, LWZU_0_12 + PPC_LO (got + 4 - bcl), p);
10206 p += 4;
10207 bfd_put_32 (output_bfd, LWZ_12_12 + 4, p);
10208 p += 4;
10209 }
10210 bfd_put_32 (output_bfd, MTCTR_0, p);
10211 p += 4;
10212 bfd_put_32 (output_bfd, ADD_0_11_11, p);
10213 }
10214 else
10215 {
10216 bfd_put_32 (output_bfd, LIS_12 + PPC_HA (got + 4), p);
10217 p += 4;
10218 bfd_put_32 (output_bfd, ADDIS_11_11 + PPC_HA (-res0), p);
10219 p += 4;
10220 if (PPC_HA (got + 4) == PPC_HA (got + 8))
10221 bfd_put_32 (output_bfd, LWZ_0_12 + PPC_LO (got + 4), p);
10222 else
10223 bfd_put_32 (output_bfd, LWZU_0_12 + PPC_LO (got + 4), p);
10224 p += 4;
10225 bfd_put_32 (output_bfd, ADDI_11_11 + PPC_LO (-res0), p);
10226 p += 4;
10227 bfd_put_32 (output_bfd, MTCTR_0, p);
10228 p += 4;
10229 bfd_put_32 (output_bfd, ADD_0_11_11, p);
10230 p += 4;
10231 if (PPC_HA (got + 4) == PPC_HA (got + 8))
10232 bfd_put_32 (output_bfd, LWZ_12_12 + PPC_LO (got + 8), p);
10233 else
10234 bfd_put_32 (output_bfd, LWZ_12_12 + 4, p);
10235 }
10236 p += 4;
10237 bfd_put_32 (output_bfd, ADD_11_0_11, p);
10238 p += 4;
10239 bfd_put_32 (output_bfd, BCTR, p);
10240 p += 4;
10241 while (p < endp)
10242 {
10243 bfd_put_32 (output_bfd,
10244 htab->params->ppc476_workaround ? BA : NOP, p);
10245 p += 4;
10246 }
10247 BFD_ASSERT (p == endp);
10248 }
10249
10250 if (htab->glink_eh_frame != NULL
10251 && htab->glink_eh_frame->contents != NULL)
10252 {
10253 unsigned char *p = htab->glink_eh_frame->contents;
10254 bfd_vma val;
10255
10256 p += sizeof (glink_eh_frame_cie);
10257 /* FDE length. */
10258 p += 4;
10259 /* CIE pointer. */
10260 p += 4;
10261 /* Offset to .glink. */
10262 val = (htab->glink->output_section->vma
10263 + htab->glink->output_offset);
10264 val -= (htab->glink_eh_frame->output_section->vma
10265 + htab->glink_eh_frame->output_offset);
10266 val -= p - htab->glink_eh_frame->contents;
10267 bfd_put_32 (htab->elf.dynobj, val, p);
10268
10269 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
10270 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
10271 htab->glink_eh_frame,
10272 htab->glink_eh_frame->contents))
10273 return FALSE;
10274 }
10275
10276 return ret;
10277 }
10278 \f
10279 #define TARGET_LITTLE_SYM powerpc_elf32_le_vec
10280 #define TARGET_LITTLE_NAME "elf32-powerpcle"
10281 #define TARGET_BIG_SYM powerpc_elf32_vec
10282 #define TARGET_BIG_NAME "elf32-powerpc"
10283 #define ELF_ARCH bfd_arch_powerpc
10284 #define ELF_TARGET_ID PPC32_ELF_DATA
10285 #define ELF_MACHINE_CODE EM_PPC
10286 #define ELF_MAXPAGESIZE 0x10000
10287 #define ELF_COMMONPAGESIZE 0x1000
10288 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
10289 #define elf_info_to_howto ppc_elf_info_to_howto
10290
10291 #ifdef EM_CYGNUS_POWERPC
10292 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
10293 #endif
10294
10295 #ifdef EM_PPC_OLD
10296 #define ELF_MACHINE_ALT2 EM_PPC_OLD
10297 #endif
10298
10299 #define elf_backend_plt_not_loaded 1
10300 #define elf_backend_want_dynrelro 1
10301 #define elf_backend_can_gc_sections 1
10302 #define elf_backend_can_refcount 1
10303 #define elf_backend_rela_normal 1
10304 #define elf_backend_caches_rawsize 1
10305
10306 #define bfd_elf32_mkobject ppc_elf_mkobject
10307 #define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data
10308 #define bfd_elf32_bfd_relax_section ppc_elf_relax_section
10309 #define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup
10310 #define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup
10311 #define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
10312 #define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create
10313 #define bfd_elf32_get_synthetic_symtab ppc_elf_get_synthetic_symtab
10314
10315 #define elf_backend_object_p ppc_elf_object_p
10316 #define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook
10317 #define elf_backend_section_from_shdr ppc_elf_section_from_shdr
10318 #define elf_backend_relocate_section ppc_elf_relocate_section
10319 #define elf_backend_create_dynamic_sections ppc_elf_create_dynamic_sections
10320 #define elf_backend_check_relocs ppc_elf_check_relocs
10321 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
10322 #define elf_backend_copy_indirect_symbol ppc_elf_copy_indirect_symbol
10323 #define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol
10324 #define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook
10325 #define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections
10326 #define elf_backend_hash_symbol ppc_elf_hash_symbol
10327 #define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol
10328 #define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections
10329 #define elf_backend_fake_sections ppc_elf_fake_sections
10330 #define elf_backend_additional_program_headers ppc_elf_additional_program_headers
10331 #define elf_backend_modify_segment_map ppc_elf_modify_segment_map
10332 #define elf_backend_grok_prstatus ppc_elf_grok_prstatus
10333 #define elf_backend_grok_psinfo ppc_elf_grok_psinfo
10334 #define elf_backend_write_core_note ppc_elf_write_core_note
10335 #define elf_backend_reloc_type_class ppc_elf_reloc_type_class
10336 #define elf_backend_begin_write_processing ppc_elf_begin_write_processing
10337 #define elf_backend_final_write_processing ppc_elf_final_write_processing
10338 #define elf_backend_write_section ppc_elf_write_section
10339 #define elf_backend_get_sec_type_attr ppc_elf_get_sec_type_attr
10340 #define elf_backend_plt_sym_val ppc_elf_plt_sym_val
10341 #define elf_backend_action_discarded ppc_elf_action_discarded
10342 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
10343 #define elf_backend_lookup_section_flags_hook ppc_elf_lookup_section_flags
10344
10345 #include "elf32-target.h"
10346
10347 /* FreeBSD Target */
10348
10349 #undef TARGET_LITTLE_SYM
10350 #undef TARGET_LITTLE_NAME
10351
10352 #undef TARGET_BIG_SYM
10353 #define TARGET_BIG_SYM powerpc_elf32_fbsd_vec
10354 #undef TARGET_BIG_NAME
10355 #define TARGET_BIG_NAME "elf32-powerpc-freebsd"
10356
10357 #undef ELF_OSABI
10358 #define ELF_OSABI ELFOSABI_FREEBSD
10359
10360 #undef elf32_bed
10361 #define elf32_bed elf32_powerpc_fbsd_bed
10362
10363 #include "elf32-target.h"
10364
10365 /* VxWorks Target */
10366
10367 #undef TARGET_LITTLE_SYM
10368 #undef TARGET_LITTLE_NAME
10369
10370 #undef TARGET_BIG_SYM
10371 #define TARGET_BIG_SYM powerpc_elf32_vxworks_vec
10372 #undef TARGET_BIG_NAME
10373 #define TARGET_BIG_NAME "elf32-powerpc-vxworks"
10374
10375 #undef ELF_OSABI
10376
10377 #undef ELF_TARGET_OS
10378 #define ELF_TARGET_OS is_vxworks
10379
10380 /* VxWorks uses the elf default section flags for .plt. */
10381 static const struct bfd_elf_special_section *
10382 ppc_elf_vxworks_get_sec_type_attr (bfd *abfd, asection *sec)
10383 {
10384 if (sec->name == NULL)
10385 return NULL;
10386
10387 if (strcmp (sec->name, ".plt") == 0)
10388 return _bfd_elf_get_sec_type_attr (abfd, sec);
10389
10390 return ppc_elf_get_sec_type_attr (abfd, sec);
10391 }
10392
10393 /* Like ppc_elf_link_hash_table_create, but overrides
10394 appropriately for VxWorks. */
10395 static struct bfd_link_hash_table *
10396 ppc_elf_vxworks_link_hash_table_create (bfd *abfd)
10397 {
10398 struct bfd_link_hash_table *ret;
10399
10400 ret = ppc_elf_link_hash_table_create (abfd);
10401 if (ret)
10402 {
10403 struct ppc_elf_link_hash_table *htab
10404 = (struct ppc_elf_link_hash_table *)ret;
10405 htab->plt_type = PLT_VXWORKS;
10406 htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE;
10407 htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE;
10408 htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE;
10409 }
10410 return ret;
10411 }
10412
10413 /* Tweak magic VxWorks symbols as they are loaded. */
10414 static bfd_boolean
10415 ppc_elf_vxworks_add_symbol_hook (bfd *abfd,
10416 struct bfd_link_info *info,
10417 Elf_Internal_Sym *sym,
10418 const char **namep,
10419 flagword *flagsp,
10420 asection **secp,
10421 bfd_vma *valp)
10422 {
10423 if (!elf_vxworks_add_symbol_hook (abfd, info, sym, namep, flagsp, secp,
10424 valp))
10425 return FALSE;
10426
10427 return ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp);
10428 }
10429
10430 static bfd_boolean
10431 ppc_elf_vxworks_final_write_processing (bfd *abfd)
10432 {
10433 ppc_final_write_processing (abfd);
10434 return elf_vxworks_final_write_processing (abfd);
10435 }
10436
10437 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
10438 define it. */
10439 #undef elf_backend_want_plt_sym
10440 #define elf_backend_want_plt_sym 1
10441 #undef elf_backend_want_got_plt
10442 #define elf_backend_want_got_plt 1
10443 #undef elf_backend_got_symbol_offset
10444 #define elf_backend_got_symbol_offset 0
10445 #undef elf_backend_plt_not_loaded
10446 #define elf_backend_plt_not_loaded 0
10447 #undef elf_backend_plt_readonly
10448 #define elf_backend_plt_readonly 1
10449 #undef elf_backend_got_header_size
10450 #define elf_backend_got_header_size 12
10451 #undef elf_backend_dtrel_excludes_plt
10452 #define elf_backend_dtrel_excludes_plt 1
10453
10454 #undef bfd_elf32_get_synthetic_symtab
10455
10456 #undef bfd_elf32_bfd_link_hash_table_create
10457 #define bfd_elf32_bfd_link_hash_table_create \
10458 ppc_elf_vxworks_link_hash_table_create
10459 #undef elf_backend_add_symbol_hook
10460 #define elf_backend_add_symbol_hook \
10461 ppc_elf_vxworks_add_symbol_hook
10462 #undef elf_backend_link_output_symbol_hook
10463 #define elf_backend_link_output_symbol_hook \
10464 elf_vxworks_link_output_symbol_hook
10465 #undef elf_backend_final_write_processing
10466 #define elf_backend_final_write_processing \
10467 ppc_elf_vxworks_final_write_processing
10468 #undef elf_backend_get_sec_type_attr
10469 #define elf_backend_get_sec_type_attr \
10470 ppc_elf_vxworks_get_sec_type_attr
10471 #undef elf_backend_emit_relocs
10472 #define elf_backend_emit_relocs \
10473 elf_vxworks_emit_relocs
10474
10475 #undef elf32_bed
10476 #define elf32_bed ppc_elf_vxworks_bed
10477
10478 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.247234 seconds and 4 git commands to generate.