Coverage Report

Created: 2024-05-21 06:29

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