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