Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/elf64-ppc.c
Line
Count
Source (jump to first uncovered line)
1
/* PowerPC64-specific support for 64-bit ELF.
2
   Copyright (C) 1999-2024 Free Software Foundation, Inc.
3
   Written by Linus Nordberg, Swox AB <info@swox.com>,
4
   based on elf32-ppc.c by Ian Lance Taylor.
5
   Largely rewritten by Alan Modra.
6
7
   This file is part of BFD, the Binary File Descriptor library.
8
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
19
   You should have received a copy of the GNU General Public License along
20
   with this program; if not, write to the Free Software Foundation, Inc.,
21
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
22
23
24
/* The 64-bit PowerPC ELF ABI may be found at
25
   http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26
   http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
27
28
/* The assembler should generate a full set of section symbols even
29
   when they appear unused.  The linux kernel build tool recordmcount
30
   needs them.  */
31
#define TARGET_KEEP_UNUSED_SECTION_SYMBOLS true
32
33
#include "sysdep.h"
34
#include <stdarg.h>
35
#include "bfd.h"
36
#include "bfdlink.h"
37
#include "libbfd.h"
38
#include "elf-bfd.h"
39
#include "elf/ppc64.h"
40
#include "elf64-ppc.h"
41
#include "dwarf2.h"
42
43
/* All users of this file have bfd_octets_per_byte (abfd, sec) == 1.  */
44
28
#define OCTETS_PER_BYTE(ABFD, SEC) 1
45
46
static bfd_reloc_status_type ppc64_elf_ha_reloc
47
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48
static bfd_reloc_status_type ppc64_elf_branch_reloc
49
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50
static bfd_reloc_status_type ppc64_elf_brtaken_reloc
51
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52
static bfd_reloc_status_type ppc64_elf_sectoff_reloc
53
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54
static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
55
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56
static bfd_reloc_status_type ppc64_elf_toc_reloc
57
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
58
static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
59
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
60
static bfd_reloc_status_type ppc64_elf_toc64_reloc
61
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
62
static bfd_reloc_status_type ppc64_elf_prefix_reloc
63
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
64
static bfd_reloc_status_type ppc64_elf_unhandled_reloc
65
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
66
static bfd_vma opd_entry_value
67
  (asection *, bfd_vma, asection **, bfd_vma *, bool);
68
69
#define TARGET_LITTLE_SYM powerpc_elf64_le_vec
70
#define TARGET_LITTLE_NAME  "elf64-powerpcle"
71
#define TARGET_BIG_SYM    powerpc_elf64_vec
72
#define TARGET_BIG_NAME   "elf64-powerpc"
73
#define ELF_ARCH    bfd_arch_powerpc
74
#define ELF_TARGET_ID   PPC64_ELF_DATA
75
#define ELF_MACHINE_CODE  EM_PPC64
76
#define ELF_MAXPAGESIZE   0x10000
77
#define ELF_COMMONPAGESIZE  0x1000
78
#define elf_info_to_howto ppc64_elf_info_to_howto
79
80
#define elf_backend_want_got_sym 0
81
#define elf_backend_want_plt_sym 0
82
#define elf_backend_plt_alignment 3
83
#define elf_backend_plt_not_loaded 1
84
#define elf_backend_got_header_size 8
85
#define elf_backend_want_dynrelro 1
86
#define elf_backend_can_gc_sections 1
87
#define elf_backend_can_refcount 1
88
#define elf_backend_rela_normal 1
89
#define elf_backend_dtrel_excludes_plt 1
90
#define elf_backend_default_execstack 0
91
92
#define bfd_elf64_mkobject          ppc64_elf_mkobject
93
#define bfd_elf64_bfd_free_cached_info        ppc64_elf_free_cached_info
94
#define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
95
#define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
96
#define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
97
#define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
98
#define bfd_elf64_new_section_hook        ppc64_elf_new_section_hook
99
#define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
100
#define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
101
#define bfd_elf64_bfd_link_just_syms        ppc64_elf_link_just_syms
102
#define bfd_elf64_bfd_gc_sections       ppc64_elf_gc_sections
103
104
#define elf_backend_object_p          ppc64_elf_object_p
105
#define elf_backend_grok_prstatus       ppc64_elf_grok_prstatus
106
#define elf_backend_grok_psinfo         ppc64_elf_grok_psinfo
107
#define elf_backend_write_core_note       ppc64_elf_write_core_note
108
#define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
109
#define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
110
#define elf_backend_add_symbol_hook       ppc64_elf_add_symbol_hook
111
#define elf_backend_check_directives        ppc64_elf_before_check_relocs
112
#define elf_backend_notice_as_needed        ppc64_elf_notice_as_needed
113
#define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
114
#define elf_backend_check_relocs        ppc64_elf_check_relocs
115
#define elf_backend_relocs_compatible       _bfd_elf_relocs_compatible
116
#define elf_backend_gc_keep         ppc64_elf_gc_keep
117
#define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
118
#define elf_backend_gc_mark_hook        ppc64_elf_gc_mark_hook
119
#define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
120
#define elf_backend_hide_symbol         ppc64_elf_hide_symbol
121
#define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
122
#define elf_backend_early_size_sections       ppc64_elf_edit
123
#define elf_backend_late_size_sections        ppc64_elf_late_size_sections
124
#define elf_backend_hash_symbol         ppc64_elf_hash_symbol
125
#define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
126
#define elf_backend_action_discarded        ppc64_elf_action_discarded
127
#define elf_backend_relocate_section        ppc64_elf_relocate_section
128
#define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
129
#define elf_backend_reloc_type_class        ppc64_elf_reloc_type_class
130
#define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
131
#define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
132
#define elf_backend_special_sections        ppc64_elf_special_sections
133
#define elf_backend_section_flags       ppc64_elf_section_flags
134
#define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
135
#define elf_backend_merge_symbol        ppc64_elf_merge_symbol
136
#define elf_backend_get_reloc_section       bfd_get_section_by_name
137
138
/* The name of the dynamic interpreter.  This is put in the .interp
139
   section.  */
140
0
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
141
142
/* The size in bytes of an entry in the procedure linkage table.  */
143
0
#define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
144
0
#define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
145
146
/* The initial size of the plt reserved for the dynamic linker.  */
147
0
#define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
148
149
/* Offsets to some stack save slots.  */
150
#define STK_LR 16
151
0
#define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
152
/* This one is dodgy.  ELFv2 does not have a linker word, so use the
153
   CR save slot.  Used only by optimised __tls_get_addr call stub,
154
   relying on __tls_get_addr_opt not saving CR..  */
155
0
#define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
156
157
/* TOC base pointers offset from start of TOC.  */
158
9
#define TOC_BASE_OFF  0x8000
159
/* TOC base alignment.  */
160
9
#define TOC_BASE_ALIGN  256
161
162
/* Offset of tp and dtp pointers from start of TLS block.  */
163
0
#define TP_OFFSET 0x7000
164
0
#define DTP_OFFSET  0x8000
165
166
/* .plt call stub instructions.  The normal stub is like this, but
167
   sometimes the .plt entry crosses a 64k boundary and we need to
168
   insert an addi to adjust r11.  */
169
#define STD_R2_0R1  0xf8410000  /* std   %r2,0+40(%r1)       */
170
#define ADDIS_R11_R2  0x3d620000  /* addis %r11,%r2,xxx@ha     */
171
#define LD_R12_0R11 0xe98b0000  /* ld  %r12,xxx+0@l(%r11)  */
172
#define MTCTR_R12 0x7d8903a6  /* mtctr %r12        */
173
#define LD_R2_0R11  0xe84b0000  /* ld  %r2,xxx+8@l(%r11)   */
174
#define LD_R11_0R11 0xe96b0000  /* ld  %r11,xxx+16@l(%r11) */
175
#define BCTR    0x4e800420  /* bctr          */
176
177
#define ADDI_R11_R11  0x396b0000  /* addi %r11,%r11,off@l  */
178
#define ADDI_R12_R11  0x398b0000  /* addi %r12,%r11,off@l  */
179
#define ADDI_R12_R12  0x398c0000  /* addi %r12,%r12,off@l  */
180
#define ADDIS_R2_R2 0x3c420000  /* addis %r2,%r2,off@ha  */
181
0
#define ADDI_R2_R2  0x38420000  /* addi  %r2,%r2,off@l   */
182
183
#define XOR_R2_R12_R12  0x7d826278  /* xor   %r2,%r12,%r12   */
184
#define ADD_R11_R11_R2  0x7d6b1214  /* add   %r11,%r11,%r2   */
185
#define XOR_R11_R12_R12 0x7d8b6278  /* xor   %r11,%r12,%r12  */
186
#define ADD_R2_R2_R11 0x7c425a14  /* add   %r2,%r2,%r11  */
187
#define CMPLDI_R2_0 0x28220000  /* cmpldi %r2,0    */
188
#define BNECTR    0x4ca20420  /* bnectr+     */
189
#define BNECTR_P4 0x4ce20420  /* bnectr+     */
190
191
#define LD_R12_0R2  0xe9820000  /* ld  %r12,xxx+0(%r2) */
192
#define LD_R11_0R2  0xe9620000  /* ld  %r11,xxx+0(%r2) */
193
#define LD_R2_0R2 0xe8420000  /* ld  %r2,xxx+0(%r2)  */
194
195
0
#define LD_R2_0R1 0xe8410000  /* ld  %r2,0(%r1)  */
196
0
#define LD_R2_0R12  0xe84c0000  /* ld  %r2,0(%r12)   */
197
0
#define ADD_R2_R2_R12 0x7c426214  /* add   %r2,%r2,%r12  */
198
199
#define LI_R11_0  0x39600000  /* li    %r11,0   */
200
#define LIS_R2    0x3c400000  /* lis %r2,xxx@ha   */
201
#define LIS_R11   0x3d600000  /* lis %r11,xxx@ha    */
202
#define LIS_R12   0x3d800000  /* lis %r12,xxx@ha    */
203
0
#define ADDIS_R2_R12  0x3c4c0000  /* addis %r2,%r12,xxx@ha  */
204
#define ADDIS_R12_R2  0x3d820000  /* addis %r12,%r2,xxx@ha  */
205
#define ADDIS_R12_R11 0x3d8b0000  /* addis %r12,%r11,xxx@ha */
206
#define ADDIS_R12_R12 0x3d8c0000  /* addis %r12,%r12,xxx@ha */
207
#define ORIS_R12_R12_0  0x658c0000  /* oris  %r12,%r12,xxx@hi */
208
#define ORI_R11_R11_0 0x616b0000  /* ori   %r11,%r11,xxx@l  */
209
#define ORI_R12_R12_0 0x618c0000  /* ori   %r12,%r12,xxx@l  */
210
#define LD_R12_0R12 0xe98c0000  /* ld  %r12,xxx@l(%r12) */
211
#define SLDI_R11_R11_34 0x796b1746  /* sldi  %r11,%r11,34     */
212
#define SLDI_R12_R12_32 0x799c07c6  /* sldi  %r12,%r12,32     */
213
#define LDX_R12_R11_R12 0x7d8b602a  /* ldx   %r12,%r11,%r12   */
214
#define ADD_R12_R11_R12 0x7d8b6214  /* add   %r12,%r11,%r12   */
215
0
#define PADDI_R12_PC  0x0610000039800000ULL
216
0
#define PLD_R12_PC  0x04100000e5800000ULL
217
0
#define PNOP    0x0700000000000000ULL
218
219
/* __glink_PLTresolve stub instructions.  We enter with the index in
220
   R0 for ELFv1, and the address of a glink branch in R12 for ELFv2.  */
221
#define GLINK_PLTRESOLVE_SIZE(htab)     \
222
0
  (8u + (htab->opd_abi ? 11 * 4 : htab->has_plt_localentry0 ? 14 * 4 : 13 * 4))
223
          /* 0:       */
224
          /*  .quad plt0-1f   */
225
          /* __glink:     */
226
#define MFLR_R12  0x7d8802a6  /*  mflr %12      */
227
#define BCL_20_31 0x429f0005  /*  bcl 20,31,1f    */
228
          /* 1:       */
229
#define MFLR_R11  0x7d6802a6  /*  mflr %11      */
230
          /*  ld %2,(0b-1b)(%11)    */
231
#define MTLR_R12  0x7d8803a6  /*  mtlr %12      */
232
#define ADD_R11_R2_R11  0x7d625a14  /*  add %11,%2,%11    */
233
          /*  ld %12,0(%11)   */
234
          /*  ld %2,8(%11)    */
235
          /*  mtctr %12     */
236
          /*  ld %11,16(%11)    */
237
          /*  bctr      */
238
239
#define MFLR_R0   0x7c0802a6  /* mflr %r0     */
240
#define MTLR_R0   0x7c0803a6  /* mtlr %r0     */
241
#define SUB_R12_R12_R11 0x7d8b6050  /* subf %r12,%r11,%r12    */
242
#define ADDI_R0_R12 0x380c0000  /* addi %r0,%r12,0    */
243
#define SRDI_R0_R0_2  0x7800f082  /* rldicl %r0,%r0,62,2    */
244
0
#define LD_R0_0R11  0xe80b0000  /* ld %r0,0(%r11)   */
245
#define ADD_R11_R0_R11  0x7d605a14  /* add %r11,%r0,%r11    */
246
247
/* Pad with this.  */
248
0
#define NOP   0x60000000
249
250
/* Some other nops.  */
251
0
#define CROR_151515 0x4def7b82
252
0
#define CROR_313131 0x4ffffb82
253
254
/* .glink entries for the first 32k functions are two instructions.  */
255
#define LI_R0_0   0x38000000  /* li    %r0,0    */
256
0
#define B_DOT   0x48000000  /* b     .    */
257
258
/* After that, we need two instructions to load the index, followed by
259
   a branch.  */
260
#define LIS_R0_0  0x3c000000  /* lis   %r0,0    */
261
#define ORI_R0_R0_0 0x60000000  /* ori   %r0,%r0,0  */
262
263
/* Instructions used by the save and restore reg functions.  */
264
#define STD_R0_0R1  0xf8010000  /* std   %r0,0(%r1) */
265
#define STD_R0_0R12 0xf80c0000  /* std   %r0,0(%r12)  */
266
#define LD_R0_0R1 0xe8010000  /* ld    %r0,0(%r1) */
267
#define LD_R0_0R12  0xe80c0000  /* ld    %r0,0(%r12)  */
268
#define STFD_FR0_0R1  0xd8010000  /* stfd  %fr0,0(%r1)  */
269
#define LFD_FR0_0R1 0xc8010000  /* lfd   %fr0,0(%r1)  */
270
#define LI_R12_0  0x39800000  /* li    %r12,0   */
271
#define STVX_VR0_R12_R0 0x7c0c01ce  /* stvx  %v0,%r12,%r0 */
272
#define LVX_VR0_R12_R0  0x7c0c00ce  /* lvx   %v0,%r12,%r0 */
273
#define MTLR_R0   0x7c0803a6  /* mtlr  %r0    */
274
#define BLR   0x4e800020  /* blr      */
275
276
/* Since .opd is an array of descriptors and each entry will end up
277
   with identical R_PPC64_RELATIVE relocs, there is really no need to
278
   propagate .opd relocs;  The dynamic linker should be taught to
279
   relocate .opd without reloc entries.  */
280
#ifndef NO_OPD_RELOCS
281
0
#define NO_OPD_RELOCS 0
282
#endif
283
284
#ifndef ARRAY_SIZE
285
1.05k
#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
286
#endif
287
288
static inline int
289
abiversion (bfd *abfd)
290
33
{
291
33
  return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
292
33
}
293
294
static inline void
295
set_abiversion (bfd *abfd, int ver)
296
0
{
297
0
  elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
298
0
  elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
299
0
}
300
301
#define is_ppc64_elf(bfd) \
302
5
  (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
303
5
   && elf_object_id (bfd) == PPC64_ELF_DATA)
304

305
/* Relocation HOWTO's.  */
306
/* Like other ELF RELA targets that don't apply multiple
307
   field-altering relocations to the same localation, src_mask is
308
   always zero and pcrel_offset is the same as pc_relative.
309
   PowerPC can always use a zero bitpos, even when the field is not at
310
   the LSB.  For example, a REL24 could use rightshift=2, bisize=24
311
   and bitpos=2 which matches the ABI description, or as we do here,
312
   rightshift=0, bitsize=26 and bitpos=0.  */
313
#define HOW(type, size, bitsize, mask, rightshift, pc_relative, \
314
      complain, special_func)       \
315
  HOWTO (type, rightshift, size, bitsize, pc_relative, 0, \
316
   complain_overflow_ ## complain, special_func,    \
317
   #type, false, 0, mask, pc_relative)
318
319
static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
320
321
static reloc_howto_type ppc64_elf_howto_raw[] =
322
{
323
  /* This reloc does nothing.  */
324
  HOW (R_PPC64_NONE, 0, 0, 0, 0, false, dont,
325
       bfd_elf_generic_reloc),
326
327
  /* A standard 32 bit relocation.  */
328
  HOW (R_PPC64_ADDR32, 4, 32, 0xffffffff, 0, false, bitfield,
329
       bfd_elf_generic_reloc),
330
331
  /* An absolute 26 bit branch; the lower two bits must be zero.
332
     FIXME: we don't check that, we just clear them.  */
333
  HOW (R_PPC64_ADDR24, 4, 26, 0x03fffffc, 0, false, bitfield,
334
       bfd_elf_generic_reloc),
335
336
  /* A standard 16 bit relocation.  */
337
  HOW (R_PPC64_ADDR16, 2, 16, 0xffff, 0, false, bitfield,
338
       bfd_elf_generic_reloc),
339
340
  /* A 16 bit relocation without overflow.  */
341
  HOW (R_PPC64_ADDR16_LO, 2, 16, 0xffff, 0, false, dont,
342
       bfd_elf_generic_reloc),
343
344
  /* Bits 16-31 of an address.  */
345
  HOW (R_PPC64_ADDR16_HI, 2, 16, 0xffff, 16, false, signed,
346
       bfd_elf_generic_reloc),
347
348
  /* Bits 16-31 of an address, plus 1 if the contents of the low 16
349
     bits, treated as a signed number, is negative.  */
350
  HOW (R_PPC64_ADDR16_HA, 2, 16, 0xffff, 16, false, signed,
351
       ppc64_elf_ha_reloc),
352
353
  /* An absolute 16 bit branch; the lower two bits must be zero.
354
     FIXME: we don't check that, we just clear them.  */
355
  HOW (R_PPC64_ADDR14, 4, 16, 0x0000fffc, 0, false, signed,
356
       ppc64_elf_branch_reloc),
357
358
  /* An absolute 16 bit branch, for which bit 10 should be set to
359
     indicate that the branch is expected to be taken.  The lower two
360
     bits must be zero.  */
361
  HOW (R_PPC64_ADDR14_BRTAKEN, 4, 16, 0x0000fffc, 0, false, signed,
362
       ppc64_elf_brtaken_reloc),
363
364
  /* An absolute 16 bit branch, for which bit 10 should be set to
365
     indicate that the branch is not expected to be taken.  The lower
366
     two bits must be zero.  */
367
  HOW (R_PPC64_ADDR14_BRNTAKEN, 4, 16, 0x0000fffc, 0, false, signed,
368
       ppc64_elf_brtaken_reloc),
369
370
  /* A relative 26 bit branch; the lower two bits must be zero.  */
371
  HOW (R_PPC64_REL24, 4, 26, 0x03fffffc, 0, true, signed,
372
       ppc64_elf_branch_reloc),
373
374
  /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer.  */
375
  HOW (R_PPC64_REL24_NOTOC, 4, 26, 0x03fffffc, 0, true, signed,
376
       ppc64_elf_branch_reloc),
377
378
  /* Another variant, when p10 insns can't be used on stubs.  */
379
  HOW (R_PPC64_REL24_P9NOTOC, 4, 26, 0x03fffffc, 0, true, signed,
380
       ppc64_elf_branch_reloc),
381
382
  /* A relative 16 bit branch; the lower two bits must be zero.  */
383
  HOW (R_PPC64_REL14, 4, 16, 0x0000fffc, 0, true, signed,
384
       ppc64_elf_branch_reloc),
385
386
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
387
     the branch is expected to be taken.  The lower two bits must be
388
     zero.  */
389
  HOW (R_PPC64_REL14_BRTAKEN, 4, 16, 0x0000fffc, 0, true, signed,
390
       ppc64_elf_brtaken_reloc),
391
392
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
393
     the branch is not expected to be taken.  The lower two bits must
394
     be zero.  */
395
  HOW (R_PPC64_REL14_BRNTAKEN, 4, 16, 0x0000fffc, 0, true, signed,
396
       ppc64_elf_brtaken_reloc),
397
398
  /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
399
     symbol.  */
400
  HOW (R_PPC64_GOT16, 2, 16, 0xffff, 0, false, signed,
401
       ppc64_elf_unhandled_reloc),
402
403
  /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
404
     the symbol.  */
405
  HOW (R_PPC64_GOT16_LO, 2, 16, 0xffff, 0, false, dont,
406
       ppc64_elf_unhandled_reloc),
407
408
  /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
409
     the symbol.  */
410
  HOW (R_PPC64_GOT16_HI, 2, 16, 0xffff, 16, false, signed,
411
       ppc64_elf_unhandled_reloc),
412
413
  /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
414
     the symbol.  */
415
  HOW (R_PPC64_GOT16_HA, 2, 16, 0xffff, 16, false, signed,
416
       ppc64_elf_unhandled_reloc),
417
418
  /* This is used only by the dynamic linker.  The symbol should exist
419
     both in the object being run and in some shared library.  The
420
     dynamic linker copies the data addressed by the symbol from the
421
     shared library into the object, because the object being
422
     run has to have the data at some particular address.  */
423
  HOW (R_PPC64_COPY, 0, 0, 0, 0, false, dont,
424
       ppc64_elf_unhandled_reloc),
425
426
  /* Like R_PPC64_ADDR64, but used when setting global offset table
427
     entries.  */
428
  HOW (R_PPC64_GLOB_DAT, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
429
       ppc64_elf_unhandled_reloc),
430
431
  /* Created by the link editor.  Marks a procedure linkage table
432
     entry for a symbol.  */
433
  HOW (R_PPC64_JMP_SLOT, 0, 0, 0, 0, false, dont,
434
       ppc64_elf_unhandled_reloc),
435
436
  /* Used only by the dynamic linker.  When the object is run, this
437
     doubleword64 is set to the load address of the object, plus the
438
     addend.  */
439
  HOW (R_PPC64_RELATIVE, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
440
       bfd_elf_generic_reloc),
441
442
  /* Like R_PPC64_ADDR32, but may be unaligned.  */
443
  HOW (R_PPC64_UADDR32, 4, 32, 0xffffffff, 0, false, bitfield,
444
       bfd_elf_generic_reloc),
445
446
  /* Like R_PPC64_ADDR16, but may be unaligned.  */
447
  HOW (R_PPC64_UADDR16, 2, 16, 0xffff, 0, false, bitfield,
448
       bfd_elf_generic_reloc),
449
450
  /* 32-bit PC relative.  */
451
  HOW (R_PPC64_REL32, 4, 32, 0xffffffff, 0, true, signed,
452
       bfd_elf_generic_reloc),
453
454
  /* 32-bit relocation to the symbol's procedure linkage table.  */
455
  HOW (R_PPC64_PLT32, 4, 32, 0xffffffff, 0, false, bitfield,
456
       ppc64_elf_unhandled_reloc),
457
458
  /* 32-bit PC relative relocation to the symbol's procedure linkage table.
459
     FIXME: R_PPC64_PLTREL32 not supported.  */
460
  HOW (R_PPC64_PLTREL32, 4, 32, 0xffffffff, 0, true, signed,
461
       ppc64_elf_unhandled_reloc),
462
463
  /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
464
     the symbol.  */
465
  HOW (R_PPC64_PLT16_LO, 2, 16, 0xffff, 0, false, dont,
466
       ppc64_elf_unhandled_reloc),
467
468
  /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
469
     the symbol.  */
470
  HOW (R_PPC64_PLT16_HI, 2, 16, 0xffff, 16, false, signed,
471
       ppc64_elf_unhandled_reloc),
472
473
  /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
474
     the symbol.  */
475
  HOW (R_PPC64_PLT16_HA, 2, 16, 0xffff, 16, false, signed,
476
       ppc64_elf_unhandled_reloc),
477
478
  /* 16-bit section relative relocation.  */
479
  HOW (R_PPC64_SECTOFF, 2, 16, 0xffff, 0, false, signed,
480
       ppc64_elf_sectoff_reloc),
481
482
  /* Like R_PPC64_SECTOFF, but no overflow warning.  */
483
  HOW (R_PPC64_SECTOFF_LO, 2, 16, 0xffff, 0, false, dont,
484
       ppc64_elf_sectoff_reloc),
485
486
  /* 16-bit upper half section relative relocation.  */
487
  HOW (R_PPC64_SECTOFF_HI, 2, 16, 0xffff, 16, false, signed,
488
       ppc64_elf_sectoff_reloc),
489
490
  /* 16-bit upper half adjusted section relative relocation.  */
491
  HOW (R_PPC64_SECTOFF_HA, 2, 16, 0xffff, 16, false, signed,
492
       ppc64_elf_sectoff_ha_reloc),
493
494
  /* Like R_PPC64_REL24 without touching the two least significant bits.  */
495
  HOW (R_PPC64_REL30, 4, 30, 0xfffffffc, 2, true, dont,
496
       bfd_elf_generic_reloc),
497
498
  /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
499
500
  /* A standard 64-bit relocation.  */
501
  HOW (R_PPC64_ADDR64, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
502
       bfd_elf_generic_reloc),
503
504
  /* The bits 32-47 of an address.  */
505
  HOW (R_PPC64_ADDR16_HIGHER, 2, 16, 0xffff, 32, false, dont,
506
       bfd_elf_generic_reloc),
507
508
  /* The bits 32-47 of an address, plus 1 if the contents of the low
509
     16 bits, treated as a signed number, is negative.  */
510
  HOW (R_PPC64_ADDR16_HIGHERA, 2, 16, 0xffff, 32, false, dont,
511
       ppc64_elf_ha_reloc),
512
513
  /* The bits 48-63 of an address.  */
514
  HOW (R_PPC64_ADDR16_HIGHEST, 2, 16, 0xffff, 48, false, dont,
515
       bfd_elf_generic_reloc),
516
517
  /* The bits 48-63 of an address, plus 1 if the contents of the low
518
     16 bits, treated as a signed number, is negative.  */
519
  HOW (R_PPC64_ADDR16_HIGHESTA, 2, 16, 0xffff, 48, false, dont,
520
       ppc64_elf_ha_reloc),
521
522
  /* Like ADDR64, but may be unaligned.  */
523
  HOW (R_PPC64_UADDR64, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
524
       bfd_elf_generic_reloc),
525
526
  /* 64-bit relative relocation.  */
527
  HOW (R_PPC64_REL64, 8, 64, 0xffffffffffffffffULL, 0, true, dont,
528
       bfd_elf_generic_reloc),
529
530
  /* 64-bit relocation to the symbol's procedure linkage table.  */
531
  HOW (R_PPC64_PLT64, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
532
       ppc64_elf_unhandled_reloc),
533
534
  /* 64-bit PC relative relocation to the symbol's procedure linkage
535
     table.  */
536
  /* FIXME: R_PPC64_PLTREL64 not supported.  */
537
  HOW (R_PPC64_PLTREL64, 8, 64, 0xffffffffffffffffULL, 0, true, dont,
538
       ppc64_elf_unhandled_reloc),
539
540
  /* 16 bit TOC-relative relocation.  */
541
  /* R_PPC64_TOC16    47     half16*  S + A - .TOC.  */
542
  HOW (R_PPC64_TOC16, 2, 16, 0xffff, 0, false, signed,
543
       ppc64_elf_toc_reloc),
544
545
  /* 16 bit TOC-relative relocation without overflow.  */
546
  /* R_PPC64_TOC16_LO   48     half16  #lo (S + A - .TOC.)  */
547
  HOW (R_PPC64_TOC16_LO, 2, 16, 0xffff, 0, false, dont,
548
       ppc64_elf_toc_reloc),
549
550
  /* 16 bit TOC-relative relocation, high 16 bits.  */
551
  /* R_PPC64_TOC16_HI   49     half16  #hi (S + A - .TOC.)  */
552
  HOW (R_PPC64_TOC16_HI, 2, 16, 0xffff, 16, false, signed,
553
       ppc64_elf_toc_reloc),
554
555
  /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
556
     contents of the low 16 bits, treated as a signed number, is
557
     negative.  */
558
  /* R_PPC64_TOC16_HA   50     half16  #ha (S + A - .TOC.)  */
559
  HOW (R_PPC64_TOC16_HA, 2, 16, 0xffff, 16, false, signed,
560
       ppc64_elf_toc_ha_reloc),
561
562
  /* 64-bit relocation; insert value of TOC base (.TOC.).  */
563
  /* R_PPC64_TOC      51     doubleword64  .TOC.  */
564
  HOW (R_PPC64_TOC, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
565
       ppc64_elf_toc64_reloc),
566
567
  /* Like R_PPC64_GOT16, but also informs the link editor that the
568
     value to relocate may (!) refer to a PLT entry which the link
569
     editor (a) may replace with the symbol value.  If the link editor
570
     is unable to fully resolve the symbol, it may (b) create a PLT
571
     entry and store the address to the new PLT entry in the GOT.
572
     This permits lazy resolution of function symbols at run time.
573
     The link editor may also skip all of this and just (c) emit a
574
     R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
575
  /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
576
    HOW (R_PPC64_PLTGOT16, 2, 16, 0xffff, 0, false,signed,
577
    ppc64_elf_unhandled_reloc),
578
579
  /* Like R_PPC64_PLTGOT16, but without overflow.  */
580
  /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
581
  HOW (R_PPC64_PLTGOT16_LO, 2, 16, 0xffff, 0, false, dont,
582
       ppc64_elf_unhandled_reloc),
583
584
  /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
585
  /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
586
  HOW (R_PPC64_PLTGOT16_HI, 2, 16, 0xffff, 16, false, signed,
587
       ppc64_elf_unhandled_reloc),
588
589
  /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
590
     1 if the contents of the low 16 bits, treated as a signed number,
591
     is negative.  */
592
  /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
593
  HOW (R_PPC64_PLTGOT16_HA, 2, 16, 0xffff, 16, false, signed,
594
       ppc64_elf_unhandled_reloc),
595
596
  /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
597
  HOW (R_PPC64_ADDR16_DS, 2, 16, 0xfffc, 0, false, signed,
598
       bfd_elf_generic_reloc),
599
600
  /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
601
  HOW (R_PPC64_ADDR16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
602
       bfd_elf_generic_reloc),
603
604
  /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
605
  HOW (R_PPC64_GOT16_DS, 2, 16, 0xfffc, 0, false, signed,
606
       ppc64_elf_unhandled_reloc),
607
608
  /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
609
  HOW (R_PPC64_GOT16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
610
       ppc64_elf_unhandled_reloc),
611
612
  /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
613
  HOW (R_PPC64_PLT16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
614
       ppc64_elf_unhandled_reloc),
615
616
  /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
617
  HOW (R_PPC64_SECTOFF_DS, 2, 16, 0xfffc, 0, false, signed,
618
       ppc64_elf_sectoff_reloc),
619
620
  /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
621
  HOW (R_PPC64_SECTOFF_LO_DS, 2, 16, 0xfffc, 0, false, dont,
622
       ppc64_elf_sectoff_reloc),
623
624
  /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
625
  HOW (R_PPC64_TOC16_DS, 2, 16, 0xfffc, 0, false, signed,
626
       ppc64_elf_toc_reloc),
627
628
  /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
629
  HOW (R_PPC64_TOC16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
630
       ppc64_elf_toc_reloc),
631
632
  /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
633
  /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
634
  HOW (R_PPC64_PLTGOT16_DS, 2, 16, 0xfffc, 0, false, signed,
635
       ppc64_elf_unhandled_reloc),
636
637
  /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
638
  /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
639
  HOW (R_PPC64_PLTGOT16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
640
       ppc64_elf_unhandled_reloc),
641
642
  /* Marker relocs for TLS.  */
643
  HOW (R_PPC64_TLS, 4, 32, 0, 0, false, dont,
644
       bfd_elf_generic_reloc),
645
646
  HOW (R_PPC64_TLSGD, 4, 32, 0, 0, false, dont,
647
       bfd_elf_generic_reloc),
648
649
  HOW (R_PPC64_TLSLD, 4, 32, 0, 0, false, dont,
650
       bfd_elf_generic_reloc),
651
652
  /* Marker reloc for optimizing r2 save in prologue rather than on
653
     each plt call stub.  */
654
  HOW (R_PPC64_TOCSAVE, 4, 32, 0, 0, false, dont,
655
       bfd_elf_generic_reloc),
656
657
  /* Marker relocs on inline plt call instructions.  */
658
  HOW (R_PPC64_PLTSEQ, 4, 32, 0, 0, false, dont,
659
       bfd_elf_generic_reloc),
660
661
  HOW (R_PPC64_PLTCALL, 4, 32, 0, 0, false, dont,
662
       bfd_elf_generic_reloc),
663
664
  /* Computes the load module index of the load module that contains the
665
     definition of its TLS sym.  */
666
  HOW (R_PPC64_DTPMOD64, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
667
       ppc64_elf_unhandled_reloc),
668
669
  /* Computes a dtv-relative displacement, the difference between the value
670
     of sym+add and the base address of the thread-local storage block that
671
     contains the definition of sym, minus 0x8000.  */
672
  HOW (R_PPC64_DTPREL64, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
673
       ppc64_elf_unhandled_reloc),
674
675
  /* A 16 bit dtprel reloc.  */
676
  HOW (R_PPC64_DTPREL16, 2, 16, 0xffff, 0, false, signed,
677
       ppc64_elf_unhandled_reloc),
678
679
  /* Like DTPREL16, but no overflow.  */
680
  HOW (R_PPC64_DTPREL16_LO, 2, 16, 0xffff, 0, false, dont,
681
       ppc64_elf_unhandled_reloc),
682
683
  /* Like DTPREL16_LO, but next higher group of 16 bits.  */
684
  HOW (R_PPC64_DTPREL16_HI, 2, 16, 0xffff, 16, false, signed,
685
       ppc64_elf_unhandled_reloc),
686
687
  /* Like DTPREL16_HI, but adjust for low 16 bits.  */
688
  HOW (R_PPC64_DTPREL16_HA, 2, 16, 0xffff, 16, false, signed,
689
       ppc64_elf_unhandled_reloc),
690
691
  /* Like DTPREL16_HI, but next higher group of 16 bits.  */
692
  HOW (R_PPC64_DTPREL16_HIGHER, 2, 16, 0xffff, 32, false, dont,
693
       ppc64_elf_unhandled_reloc),
694
695
  /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
696
  HOW (R_PPC64_DTPREL16_HIGHERA, 2, 16, 0xffff, 32, false, dont,
697
       ppc64_elf_unhandled_reloc),
698
699
  /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
700
  HOW (R_PPC64_DTPREL16_HIGHEST, 2, 16, 0xffff, 48, false, dont,
701
       ppc64_elf_unhandled_reloc),
702
703
  /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
704
  HOW (R_PPC64_DTPREL16_HIGHESTA, 2, 16, 0xffff, 48, false, dont,
705
       ppc64_elf_unhandled_reloc),
706
707
  /* Like DTPREL16, but for insns with a DS field.  */
708
  HOW (R_PPC64_DTPREL16_DS, 2, 16, 0xfffc, 0, false, signed,
709
       ppc64_elf_unhandled_reloc),
710
711
  /* Like DTPREL16_DS, but no overflow.  */
712
  HOW (R_PPC64_DTPREL16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
713
       ppc64_elf_unhandled_reloc),
714
715
  /* Computes a tp-relative displacement, the difference between the value of
716
     sym+add and the value of the thread pointer (r13).  */
717
  HOW (R_PPC64_TPREL64, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
718
       ppc64_elf_unhandled_reloc),
719
720
  /* A 16 bit tprel reloc.  */
721
  HOW (R_PPC64_TPREL16, 2, 16, 0xffff, 0, false, signed,
722
       ppc64_elf_unhandled_reloc),
723
724
  /* Like TPREL16, but no overflow.  */
725
  HOW (R_PPC64_TPREL16_LO, 2, 16, 0xffff, 0, false, dont,
726
       ppc64_elf_unhandled_reloc),
727
728
  /* Like TPREL16_LO, but next higher group of 16 bits.  */
729
  HOW (R_PPC64_TPREL16_HI, 2, 16, 0xffff, 16, false, signed,
730
       ppc64_elf_unhandled_reloc),
731
732
  /* Like TPREL16_HI, but adjust for low 16 bits.  */
733
  HOW (R_PPC64_TPREL16_HA, 2, 16, 0xffff, 16, false, signed,
734
       ppc64_elf_unhandled_reloc),
735
736
  /* Like TPREL16_HI, but next higher group of 16 bits.  */
737
  HOW (R_PPC64_TPREL16_HIGHER, 2, 16, 0xffff, 32, false, dont,
738
       ppc64_elf_unhandled_reloc),
739
740
  /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
741
  HOW (R_PPC64_TPREL16_HIGHERA, 2, 16, 0xffff, 32, false, dont,
742
       ppc64_elf_unhandled_reloc),
743
744
  /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
745
  HOW (R_PPC64_TPREL16_HIGHEST, 2, 16, 0xffff, 48, false, dont,
746
       ppc64_elf_unhandled_reloc),
747
748
  /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
749
  HOW (R_PPC64_TPREL16_HIGHESTA, 2, 16, 0xffff, 48, false, dont,
750
       ppc64_elf_unhandled_reloc),
751
752
  /* Like TPREL16, but for insns with a DS field.  */
753
  HOW (R_PPC64_TPREL16_DS, 2, 16, 0xfffc, 0, false, signed,
754
       ppc64_elf_unhandled_reloc),
755
756
  /* Like TPREL16_DS, but no overflow.  */
757
  HOW (R_PPC64_TPREL16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
758
       ppc64_elf_unhandled_reloc),
759
760
  /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
761
     with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
762
     to the first entry relative to the TOC base (r2).  */
763
  HOW (R_PPC64_GOT_TLSGD16, 2, 16, 0xffff, 0, false, signed,
764
       ppc64_elf_unhandled_reloc),
765
766
  /* Like GOT_TLSGD16, but no overflow.  */
767
  HOW (R_PPC64_GOT_TLSGD16_LO, 2, 16, 0xffff, 0, false, dont,
768
       ppc64_elf_unhandled_reloc),
769
770
  /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
771
  HOW (R_PPC64_GOT_TLSGD16_HI, 2, 16, 0xffff, 16, false, signed,
772
       ppc64_elf_unhandled_reloc),
773
774
  /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
775
  HOW (R_PPC64_GOT_TLSGD16_HA, 2, 16, 0xffff, 16, false, signed,
776
       ppc64_elf_unhandled_reloc),
777
778
  /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
779
     with values (sym+add)@dtpmod and zero, and computes the offset to the
780
     first entry relative to the TOC base (r2).  */
781
  HOW (R_PPC64_GOT_TLSLD16, 2, 16, 0xffff, 0, false, signed,
782
       ppc64_elf_unhandled_reloc),
783
784
  /* Like GOT_TLSLD16, but no overflow.  */
785
  HOW (R_PPC64_GOT_TLSLD16_LO, 2, 16, 0xffff, 0, false, dont,
786
       ppc64_elf_unhandled_reloc),
787
788
  /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
789
  HOW (R_PPC64_GOT_TLSLD16_HI, 2, 16, 0xffff, 16, false, signed,
790
       ppc64_elf_unhandled_reloc),
791
792
  /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
793
  HOW (R_PPC64_GOT_TLSLD16_HA, 2, 16, 0xffff, 16, false, signed,
794
       ppc64_elf_unhandled_reloc),
795
796
  /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
797
     the offset to the entry relative to the TOC base (r2).  */
798
  HOW (R_PPC64_GOT_DTPREL16_DS, 2, 16, 0xfffc, 0, false, signed,
799
       ppc64_elf_unhandled_reloc),
800
801
  /* Like GOT_DTPREL16_DS, but no overflow.  */
802
  HOW (R_PPC64_GOT_DTPREL16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
803
       ppc64_elf_unhandled_reloc),
804
805
  /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
806
  HOW (R_PPC64_GOT_DTPREL16_HI, 2, 16, 0xffff, 16, false, signed,
807
       ppc64_elf_unhandled_reloc),
808
809
  /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
810
  HOW (R_PPC64_GOT_DTPREL16_HA, 2, 16, 0xffff, 16, false, signed,
811
       ppc64_elf_unhandled_reloc),
812
813
  /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
814
     offset to the entry relative to the TOC base (r2).  */
815
  HOW (R_PPC64_GOT_TPREL16_DS, 2, 16, 0xfffc, 0, false, signed,
816
       ppc64_elf_unhandled_reloc),
817
818
  /* Like GOT_TPREL16_DS, but no overflow.  */
819
  HOW (R_PPC64_GOT_TPREL16_LO_DS, 2, 16, 0xfffc, 0, false, dont,
820
       ppc64_elf_unhandled_reloc),
821
822
  /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
823
  HOW (R_PPC64_GOT_TPREL16_HI, 2, 16, 0xffff, 16, false, signed,
824
       ppc64_elf_unhandled_reloc),
825
826
  /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
827
  HOW (R_PPC64_GOT_TPREL16_HA, 2, 16, 0xffff, 16, false, signed,
828
       ppc64_elf_unhandled_reloc),
829
830
  HOW (R_PPC64_JMP_IREL, 0, 0, 0, 0, false, dont,
831
       ppc64_elf_unhandled_reloc),
832
833
  HOW (R_PPC64_IRELATIVE, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
834
       bfd_elf_generic_reloc),
835
836
  /* A 16 bit relative relocation.  */
837
  HOW (R_PPC64_REL16, 2, 16, 0xffff, 0, true, signed,
838
       bfd_elf_generic_reloc),
839
840
  /* A 16 bit relative relocation without overflow.  */
841
  HOW (R_PPC64_REL16_LO, 2, 16, 0xffff, 0, true, dont,
842
       bfd_elf_generic_reloc),
843
844
  /* The high order 16 bits of a relative address.  */
845
  HOW (R_PPC64_REL16_HI, 2, 16, 0xffff, 16, true, signed,
846
       bfd_elf_generic_reloc),
847
848
  /* The high order 16 bits of a relative address, plus 1 if the contents of
849
     the low 16 bits, treated as a signed number, is negative.  */
850
  HOW (R_PPC64_REL16_HA, 2, 16, 0xffff, 16, true, signed,
851
       ppc64_elf_ha_reloc),
852
853
  HOW (R_PPC64_REL16_HIGH, 2, 16, 0xffff, 16, true, dont,
854
       bfd_elf_generic_reloc),
855
856
  HOW (R_PPC64_REL16_HIGHA, 2, 16, 0xffff, 16, true, dont,
857
       ppc64_elf_ha_reloc),
858
859
  HOW (R_PPC64_REL16_HIGHER, 2, 16, 0xffff, 32, true, dont,
860
       bfd_elf_generic_reloc),
861
862
  HOW (R_PPC64_REL16_HIGHERA, 2, 16, 0xffff, 32, true, dont,
863
       ppc64_elf_ha_reloc),
864
865
  HOW (R_PPC64_REL16_HIGHEST, 2, 16, 0xffff, 48, true, dont,
866
       bfd_elf_generic_reloc),
867
868
  HOW (R_PPC64_REL16_HIGHESTA, 2, 16, 0xffff, 48, true, dont,
869
       ppc64_elf_ha_reloc),
870
871
  /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
872
  HOW (R_PPC64_REL16DX_HA, 4, 16, 0x1fffc1, 16, true, signed,
873
       ppc64_elf_ha_reloc),
874
875
  /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
876
  HOW (R_PPC64_16DX_HA, 4, 16, 0x1fffc1, 16, false, signed,
877
       ppc64_elf_ha_reloc),
878
879
  /* Like R_PPC64_ADDR16_HI, but no overflow.  */
880
  HOW (R_PPC64_ADDR16_HIGH, 2, 16, 0xffff, 16, false, dont,
881
       bfd_elf_generic_reloc),
882
883
  /* Like R_PPC64_ADDR16_HA, but no overflow.  */
884
  HOW (R_PPC64_ADDR16_HIGHA, 2, 16, 0xffff, 16, false, dont,
885
       ppc64_elf_ha_reloc),
886
887
  /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
888
  HOW (R_PPC64_DTPREL16_HIGH, 2, 16, 0xffff, 16, false, dont,
889
       ppc64_elf_unhandled_reloc),
890
891
  /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
892
  HOW (R_PPC64_DTPREL16_HIGHA, 2, 16, 0xffff, 16, false, dont,
893
       ppc64_elf_unhandled_reloc),
894
895
  /* Like R_PPC64_TPREL16_HI, but no overflow.  */
896
  HOW (R_PPC64_TPREL16_HIGH, 2, 16, 0xffff, 16, false, dont,
897
       ppc64_elf_unhandled_reloc),
898
899
  /* Like R_PPC64_TPREL16_HA, but no overflow.  */
900
  HOW (R_PPC64_TPREL16_HIGHA, 2, 16, 0xffff, 16, false, dont,
901
       ppc64_elf_unhandled_reloc),
902
903
  /* Marker reloc on ELFv2 large-model function entry.  */
904
  HOW (R_PPC64_ENTRY, 4, 32, 0, 0, false, dont,
905
       bfd_elf_generic_reloc),
906
907
  /* Like ADDR64, but use local entry point of function.  */
908
  HOW (R_PPC64_ADDR64_LOCAL, 8, 64, 0xffffffffffffffffULL, 0, false, dont,
909
       bfd_elf_generic_reloc),
910
911
  HOW (R_PPC64_PLTSEQ_NOTOC, 4, 32, 0, 0, false, dont,
912
       bfd_elf_generic_reloc),
913
914
  HOW (R_PPC64_PLTCALL_NOTOC, 4, 32, 0, 0, false, dont,
915
       bfd_elf_generic_reloc),
916
917
  HOW (R_PPC64_PCREL_OPT, 4, 32, 0, 0, false, dont,
918
       bfd_elf_generic_reloc),
919
920
  HOW (R_PPC64_D34, 8, 34, 0x3ffff0000ffffULL, 0, false, signed,
921
       ppc64_elf_prefix_reloc),
922
923
  HOW (R_PPC64_D34_LO, 8, 34, 0x3ffff0000ffffULL, 0, false, dont,
924
       ppc64_elf_prefix_reloc),
925
926
  HOW (R_PPC64_D34_HI30, 8, 34, 0x3ffff0000ffffULL, 34, false, dont,
927
       ppc64_elf_prefix_reloc),
928
929
  HOW (R_PPC64_D34_HA30, 8, 34, 0x3ffff0000ffffULL, 34, false, dont,
930
       ppc64_elf_prefix_reloc),
931
932
  HOW (R_PPC64_PCREL34, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
933
       ppc64_elf_prefix_reloc),
934
935
  HOW (R_PPC64_GOT_PCREL34, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
936
       ppc64_elf_unhandled_reloc),
937
938
  HOW (R_PPC64_PLT_PCREL34, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
939
       ppc64_elf_unhandled_reloc),
940
941
  HOW (R_PPC64_PLT_PCREL34_NOTOC, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
942
       ppc64_elf_unhandled_reloc),
943
944
  HOW (R_PPC64_TPREL34, 8, 34, 0x3ffff0000ffffULL, 0, false, signed,
945
       ppc64_elf_unhandled_reloc),
946
947
  HOW (R_PPC64_DTPREL34, 8, 34, 0x3ffff0000ffffULL, 0, false, signed,
948
       ppc64_elf_unhandled_reloc),
949
950
  HOW (R_PPC64_GOT_TLSGD_PCREL34, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
951
       ppc64_elf_unhandled_reloc),
952
953
  HOW (R_PPC64_GOT_TLSLD_PCREL34, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
954
       ppc64_elf_unhandled_reloc),
955
956
  HOW (R_PPC64_GOT_TPREL_PCREL34, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
957
       ppc64_elf_unhandled_reloc),
958
959
  HOW (R_PPC64_GOT_DTPREL_PCREL34, 8, 34, 0x3ffff0000ffffULL, 0, true, signed,
960
       ppc64_elf_unhandled_reloc),
961
962
  HOW (R_PPC64_ADDR16_HIGHER34, 2, 16, 0xffff, 34, false, dont,
963
       bfd_elf_generic_reloc),
964
965
  HOW (R_PPC64_ADDR16_HIGHERA34, 2, 16, 0xffff, 34, false, dont,
966
       ppc64_elf_ha_reloc),
967
968
  HOW (R_PPC64_ADDR16_HIGHEST34, 2, 16, 0xffff, 50, false, dont,
969
       bfd_elf_generic_reloc),
970
971
  HOW (R_PPC64_ADDR16_HIGHESTA34, 2, 16, 0xffff, 50, false, dont,
972
       ppc64_elf_ha_reloc),
973
974
  HOW (R_PPC64_REL16_HIGHER34, 2, 16, 0xffff, 34, true, dont,
975
       bfd_elf_generic_reloc),
976
977
  HOW (R_PPC64_REL16_HIGHERA34, 2, 16, 0xffff, 34, true, dont,
978
       ppc64_elf_ha_reloc),
979
980
  HOW (R_PPC64_REL16_HIGHEST34, 2, 16, 0xffff, 50, true, dont,
981
       bfd_elf_generic_reloc),
982
983
  HOW (R_PPC64_REL16_HIGHESTA34, 2, 16, 0xffff, 50, true, dont,
984
       ppc64_elf_ha_reloc),
985
986
  HOW (R_PPC64_D28, 8, 28, 0xfff0000ffffULL, 0, false, signed,
987
       ppc64_elf_prefix_reloc),
988
989
  HOW (R_PPC64_PCREL28, 8, 28, 0xfff0000ffffULL, 0, true, signed,
990
       ppc64_elf_prefix_reloc),
991
992
  /* GNU extension to record C++ vtable hierarchy.  */
993
  HOW (R_PPC64_GNU_VTINHERIT, 0, 0, 0, 0, false, dont,
994
       NULL),
995
996
  /* GNU extension to record C++ vtable member usage.  */
997
  HOW (R_PPC64_GNU_VTENTRY, 0, 0, 0, 0, false, dont,
998
       NULL),
999
};
1000
1001

1002
/* Initialize the ppc64_elf_howto_table, so that linear accesses can
1003
   be done.  */
1004
1005
static void
1006
ppc_howto_init (void)
1007
2
{
1008
2
  unsigned int i, type;
1009
1010
326
  for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
1011
324
    {
1012
324
      type = ppc64_elf_howto_raw[i].type;
1013
324
      BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
1014
324
      ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1015
324
    }
1016
2
}
1017
1018
static reloc_howto_type *
1019
ppc64_elf_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
1020
0
{
1021
0
  enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1022
1023
0
  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1024
    /* Initialize howto table if needed.  */
1025
0
    ppc_howto_init ();
1026
1027
0
  switch (code)
1028
0
    {
1029
0
    default:
1030
      /* xgettext:c-format */
1031
0
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd,
1032
0
        (int) code);
1033
0
      bfd_set_error (bfd_error_bad_value);
1034
0
      return NULL;
1035
1036
0
    case BFD_RELOC_NONE:      r = R_PPC64_NONE;
1037
0
      break;
1038
0
    case BFD_RELOC_32:        r = R_PPC64_ADDR32;
1039
0
      break;
1040
0
    case BFD_RELOC_PPC_BA26:      r = R_PPC64_ADDR24;
1041
0
      break;
1042
0
    case BFD_RELOC_16:        r = R_PPC64_ADDR16;
1043
0
      break;
1044
0
    case BFD_RELOC_LO16:      r = R_PPC64_ADDR16_LO;
1045
0
      break;
1046
0
    case BFD_RELOC_HI16:      r = R_PPC64_ADDR16_HI;
1047
0
      break;
1048
0
    case BFD_RELOC_PPC64_ADDR16_HIGH:   r = R_PPC64_ADDR16_HIGH;
1049
0
      break;
1050
0
    case BFD_RELOC_HI16_S:      r = R_PPC64_ADDR16_HA;
1051
0
      break;
1052
0
    case BFD_RELOC_PPC64_ADDR16_HIGHA:    r = R_PPC64_ADDR16_HIGHA;
1053
0
      break;
1054
0
    case BFD_RELOC_PPC_BA16:      r = R_PPC64_ADDR14;
1055
0
      break;
1056
0
    case BFD_RELOC_PPC_BA16_BRTAKEN:    r = R_PPC64_ADDR14_BRTAKEN;
1057
0
      break;
1058
0
    case BFD_RELOC_PPC_BA16_BRNTAKEN:   r = R_PPC64_ADDR14_BRNTAKEN;
1059
0
      break;
1060
0
    case BFD_RELOC_PPC_B26:     r = R_PPC64_REL24;
1061
0
      break;
1062
0
    case BFD_RELOC_PPC64_REL24_NOTOC:   r = R_PPC64_REL24_NOTOC;
1063
0
      break;
1064
0
    case BFD_RELOC_PPC64_REL24_P9NOTOC:   r = R_PPC64_REL24_P9NOTOC;
1065
0
      break;
1066
0
    case BFD_RELOC_PPC_B16:     r = R_PPC64_REL14;
1067
0
      break;
1068
0
    case BFD_RELOC_PPC_B16_BRTAKEN:   r = R_PPC64_REL14_BRTAKEN;
1069
0
      break;
1070
0
    case BFD_RELOC_PPC_B16_BRNTAKEN:    r = R_PPC64_REL14_BRNTAKEN;
1071
0
      break;
1072
0
    case BFD_RELOC_16_GOTOFF:     r = R_PPC64_GOT16;
1073
0
      break;
1074
0
    case BFD_RELOC_LO16_GOTOFF:     r = R_PPC64_GOT16_LO;
1075
0
      break;
1076
0
    case BFD_RELOC_HI16_GOTOFF:     r = R_PPC64_GOT16_HI;
1077
0
      break;
1078
0
    case BFD_RELOC_HI16_S_GOTOFF:   r = R_PPC64_GOT16_HA;
1079
0
      break;
1080
0
    case BFD_RELOC_PPC_COPY:      r = R_PPC64_COPY;
1081
0
      break;
1082
0
    case BFD_RELOC_PPC_GLOB_DAT:    r = R_PPC64_GLOB_DAT;
1083
0
      break;
1084
0
    case BFD_RELOC_32_PCREL:      r = R_PPC64_REL32;
1085
0
      break;
1086
0
    case BFD_RELOC_32_PLTOFF:     r = R_PPC64_PLT32;
1087
0
      break;
1088
0
    case BFD_RELOC_32_PLT_PCREL:    r = R_PPC64_PLTREL32;
1089
0
      break;
1090
0
    case BFD_RELOC_LO16_PLTOFF:     r = R_PPC64_PLT16_LO;
1091
0
      break;
1092
0
    case BFD_RELOC_HI16_PLTOFF:     r = R_PPC64_PLT16_HI;
1093
0
      break;
1094
0
    case BFD_RELOC_HI16_S_PLTOFF:   r = R_PPC64_PLT16_HA;
1095
0
      break;
1096
0
    case BFD_RELOC_16_BASEREL:      r = R_PPC64_SECTOFF;
1097
0
      break;
1098
0
    case BFD_RELOC_LO16_BASEREL:    r = R_PPC64_SECTOFF_LO;
1099
0
      break;
1100
0
    case BFD_RELOC_HI16_BASEREL:    r = R_PPC64_SECTOFF_HI;
1101
0
      break;
1102
0
    case BFD_RELOC_HI16_S_BASEREL:    r = R_PPC64_SECTOFF_HA;
1103
0
      break;
1104
0
    case BFD_RELOC_CTOR:      r = R_PPC64_ADDR64;
1105
0
      break;
1106
0
    case BFD_RELOC_64:        r = R_PPC64_ADDR64;
1107
0
      break;
1108
0
    case BFD_RELOC_PPC64_HIGHER:    r = R_PPC64_ADDR16_HIGHER;
1109
0
      break;
1110
0
    case BFD_RELOC_PPC64_HIGHER_S:    r = R_PPC64_ADDR16_HIGHERA;
1111
0
      break;
1112
0
    case BFD_RELOC_PPC64_HIGHEST:   r = R_PPC64_ADDR16_HIGHEST;
1113
0
      break;
1114
0
    case BFD_RELOC_PPC64_HIGHEST_S:   r = R_PPC64_ADDR16_HIGHESTA;
1115
0
      break;
1116
0
    case BFD_RELOC_64_PCREL:      r = R_PPC64_REL64;
1117
0
      break;
1118
0
    case BFD_RELOC_64_PLTOFF:     r = R_PPC64_PLT64;
1119
0
      break;
1120
0
    case BFD_RELOC_64_PLT_PCREL:    r = R_PPC64_PLTREL64;
1121
0
      break;
1122
0
    case BFD_RELOC_PPC_TOC16:     r = R_PPC64_TOC16;
1123
0
      break;
1124
0
    case BFD_RELOC_PPC64_TOC16_LO:    r = R_PPC64_TOC16_LO;
1125
0
      break;
1126
0
    case BFD_RELOC_PPC64_TOC16_HI:    r = R_PPC64_TOC16_HI;
1127
0
      break;
1128
0
    case BFD_RELOC_PPC64_TOC16_HA:    r = R_PPC64_TOC16_HA;
1129
0
      break;
1130
0
    case BFD_RELOC_PPC64_TOC:     r = R_PPC64_TOC;
1131
0
      break;
1132
0
    case BFD_RELOC_PPC64_PLTGOT16:    r = R_PPC64_PLTGOT16;
1133
0
      break;
1134
0
    case BFD_RELOC_PPC64_PLTGOT16_LO:   r = R_PPC64_PLTGOT16_LO;
1135
0
      break;
1136
0
    case BFD_RELOC_PPC64_PLTGOT16_HI:   r = R_PPC64_PLTGOT16_HI;
1137
0
      break;
1138
0
    case BFD_RELOC_PPC64_PLTGOT16_HA:   r = R_PPC64_PLTGOT16_HA;
1139
0
      break;
1140
0
    case BFD_RELOC_PPC64_ADDR16_DS:   r = R_PPC64_ADDR16_DS;
1141
0
      break;
1142
0
    case BFD_RELOC_PPC64_ADDR16_LO_DS:    r = R_PPC64_ADDR16_LO_DS;
1143
0
      break;
1144
0
    case BFD_RELOC_PPC64_GOT16_DS:    r = R_PPC64_GOT16_DS;
1145
0
      break;
1146
0
    case BFD_RELOC_PPC64_GOT16_LO_DS:   r = R_PPC64_GOT16_LO_DS;
1147
0
      break;
1148
0
    case BFD_RELOC_PPC64_PLT16_LO_DS:   r = R_PPC64_PLT16_LO_DS;
1149
0
      break;
1150
0
    case BFD_RELOC_PPC64_SECTOFF_DS:    r = R_PPC64_SECTOFF_DS;
1151
0
      break;
1152
0
    case BFD_RELOC_PPC64_SECTOFF_LO_DS:   r = R_PPC64_SECTOFF_LO_DS;
1153
0
      break;
1154
0
    case BFD_RELOC_PPC64_TOC16_DS:    r = R_PPC64_TOC16_DS;
1155
0
      break;
1156
0
    case BFD_RELOC_PPC64_TOC16_LO_DS:   r = R_PPC64_TOC16_LO_DS;
1157
0
      break;
1158
0
    case BFD_RELOC_PPC64_PLTGOT16_DS:   r = R_PPC64_PLTGOT16_DS;
1159
0
      break;
1160
0
    case BFD_RELOC_PPC64_PLTGOT16_LO_DS:  r = R_PPC64_PLTGOT16_LO_DS;
1161
0
      break;
1162
0
    case BFD_RELOC_PPC64_TLS_PCREL:
1163
0
    case BFD_RELOC_PPC_TLS:     r = R_PPC64_TLS;
1164
0
      break;
1165
0
    case BFD_RELOC_PPC_TLSGD:     r = R_PPC64_TLSGD;
1166
0
      break;
1167
0
    case BFD_RELOC_PPC_TLSLD:     r = R_PPC64_TLSLD;
1168
0
      break;
1169
0
    case BFD_RELOC_PPC_DTPMOD:      r = R_PPC64_DTPMOD64;
1170
0
      break;
1171
0
    case BFD_RELOC_PPC_TPREL16:     r = R_PPC64_TPREL16;
1172
0
      break;
1173
0
    case BFD_RELOC_PPC_TPREL16_LO:    r = R_PPC64_TPREL16_LO;
1174
0
      break;
1175
0
    case BFD_RELOC_PPC_TPREL16_HI:    r = R_PPC64_TPREL16_HI;
1176
0
      break;
1177
0
    case BFD_RELOC_PPC64_TPREL16_HIGH:    r = R_PPC64_TPREL16_HIGH;
1178
0
      break;
1179
0
    case BFD_RELOC_PPC_TPREL16_HA:    r = R_PPC64_TPREL16_HA;
1180
0
      break;
1181
0
    case BFD_RELOC_PPC64_TPREL16_HIGHA:   r = R_PPC64_TPREL16_HIGHA;
1182
0
      break;
1183
0
    case BFD_RELOC_PPC_TPREL:     r = R_PPC64_TPREL64;
1184
0
      break;
1185
0
    case BFD_RELOC_PPC_DTPREL16:    r = R_PPC64_DTPREL16;
1186
0
      break;
1187
0
    case BFD_RELOC_PPC_DTPREL16_LO:   r = R_PPC64_DTPREL16_LO;
1188
0
      break;
1189
0
    case BFD_RELOC_PPC_DTPREL16_HI:   r = R_PPC64_DTPREL16_HI;
1190
0
      break;
1191
0
    case BFD_RELOC_PPC64_DTPREL16_HIGH:   r = R_PPC64_DTPREL16_HIGH;
1192
0
      break;
1193
0
    case BFD_RELOC_PPC_DTPREL16_HA:   r = R_PPC64_DTPREL16_HA;
1194
0
      break;
1195
0
    case BFD_RELOC_PPC64_DTPREL16_HIGHA:  r = R_PPC64_DTPREL16_HIGHA;
1196
0
      break;
1197
0
    case BFD_RELOC_PPC_DTPREL:      r = R_PPC64_DTPREL64;
1198
0
      break;
1199
0
    case BFD_RELOC_PPC_GOT_TLSGD16:   r = R_PPC64_GOT_TLSGD16;
1200
0
      break;
1201
0
    case BFD_RELOC_PPC_GOT_TLSGD16_LO:    r = R_PPC64_GOT_TLSGD16_LO;
1202
0
      break;
1203
0
    case BFD_RELOC_PPC_GOT_TLSGD16_HI:    r = R_PPC64_GOT_TLSGD16_HI;
1204
0
      break;
1205
0
    case BFD_RELOC_PPC_GOT_TLSGD16_HA:    r = R_PPC64_GOT_TLSGD16_HA;
1206
0
      break;
1207
0
    case BFD_RELOC_PPC_GOT_TLSLD16:   r = R_PPC64_GOT_TLSLD16;
1208
0
      break;
1209
0
    case BFD_RELOC_PPC_GOT_TLSLD16_LO:    r = R_PPC64_GOT_TLSLD16_LO;
1210
0
      break;
1211
0
    case BFD_RELOC_PPC_GOT_TLSLD16_HI:    r = R_PPC64_GOT_TLSLD16_HI;
1212
0
      break;
1213
0
    case BFD_RELOC_PPC_GOT_TLSLD16_HA:    r = R_PPC64_GOT_TLSLD16_HA;
1214
0
      break;
1215
0
    case BFD_RELOC_PPC_GOT_TPREL16:   r = R_PPC64_GOT_TPREL16_DS;
1216
0
      break;
1217
0
    case BFD_RELOC_PPC_GOT_TPREL16_LO:    r = R_PPC64_GOT_TPREL16_LO_DS;
1218
0
      break;
1219
0
    case BFD_RELOC_PPC_GOT_TPREL16_HI:    r = R_PPC64_GOT_TPREL16_HI;
1220
0
      break;
1221
0
    case BFD_RELOC_PPC_GOT_TPREL16_HA:    r = R_PPC64_GOT_TPREL16_HA;
1222
0
      break;
1223
0
    case BFD_RELOC_PPC_GOT_DTPREL16:    r = R_PPC64_GOT_DTPREL16_DS;
1224
0
      break;
1225
0
    case BFD_RELOC_PPC_GOT_DTPREL16_LO:   r = R_PPC64_GOT_DTPREL16_LO_DS;
1226
0
      break;
1227
0
    case BFD_RELOC_PPC_GOT_DTPREL16_HI:   r = R_PPC64_GOT_DTPREL16_HI;
1228
0
      break;
1229
0
    case BFD_RELOC_PPC_GOT_DTPREL16_HA:   r = R_PPC64_GOT_DTPREL16_HA;
1230
0
      break;
1231
0
    case BFD_RELOC_PPC64_TPREL16_DS:    r = R_PPC64_TPREL16_DS;
1232
0
      break;
1233
0
    case BFD_RELOC_PPC64_TPREL16_LO_DS:   r = R_PPC64_TPREL16_LO_DS;
1234
0
      break;
1235
0
    case BFD_RELOC_PPC64_TPREL16_HIGHER:  r = R_PPC64_TPREL16_HIGHER;
1236
0
      break;
1237
0
    case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
1238
0
      break;
1239
0
    case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
1240
0
      break;
1241
0
    case BFD_RELOC_PPC64_TPREL16_HIGHESTA:  r = R_PPC64_TPREL16_HIGHESTA;
1242
0
      break;
1243
0
    case BFD_RELOC_PPC64_DTPREL16_DS:   r = R_PPC64_DTPREL16_DS;
1244
0
      break;
1245
0
    case BFD_RELOC_PPC64_DTPREL16_LO_DS:  r = R_PPC64_DTPREL16_LO_DS;
1246
0
      break;
1247
0
    case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
1248
0
      break;
1249
0
    case BFD_RELOC_PPC64_DTPREL16_HIGHERA:  r = R_PPC64_DTPREL16_HIGHERA;
1250
0
      break;
1251
0
    case BFD_RELOC_PPC64_DTPREL16_HIGHEST:  r = R_PPC64_DTPREL16_HIGHEST;
1252
0
      break;
1253
0
    case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
1254
0
      break;
1255
0
    case BFD_RELOC_16_PCREL:      r = R_PPC64_REL16;
1256
0
      break;
1257
0
    case BFD_RELOC_LO16_PCREL:      r = R_PPC64_REL16_LO;
1258
0
      break;
1259
0
    case BFD_RELOC_HI16_PCREL:      r = R_PPC64_REL16_HI;
1260
0
      break;
1261
0
    case BFD_RELOC_HI16_S_PCREL:    r = R_PPC64_REL16_HA;
1262
0
      break;
1263
0
    case BFD_RELOC_PPC64_REL16_HIGH:    r = R_PPC64_REL16_HIGH;
1264
0
      break;
1265
0
    case BFD_RELOC_PPC64_REL16_HIGHA:   r = R_PPC64_REL16_HIGHA;
1266
0
      break;
1267
0
    case BFD_RELOC_PPC64_REL16_HIGHER:    r = R_PPC64_REL16_HIGHER;
1268
0
      break;
1269
0
    case BFD_RELOC_PPC64_REL16_HIGHERA:   r = R_PPC64_REL16_HIGHERA;
1270
0
      break;
1271
0
    case BFD_RELOC_PPC64_REL16_HIGHEST:   r = R_PPC64_REL16_HIGHEST;
1272
0
      break;
1273
0
    case BFD_RELOC_PPC64_REL16_HIGHESTA:  r = R_PPC64_REL16_HIGHESTA;
1274
0
      break;
1275
0
    case BFD_RELOC_PPC_16DX_HA:     r = R_PPC64_16DX_HA;
1276
0
      break;
1277
0
    case BFD_RELOC_PPC_REL16DX_HA:    r = R_PPC64_REL16DX_HA;
1278
0
      break;
1279
0
    case BFD_RELOC_PPC64_ENTRY:     r = R_PPC64_ENTRY;
1280
0
      break;
1281
0
    case BFD_RELOC_PPC64_ADDR64_LOCAL:    r = R_PPC64_ADDR64_LOCAL;
1282
0
      break;
1283
0
    case BFD_RELOC_PPC64_D34:     r = R_PPC64_D34;
1284
0
      break;
1285
0
    case BFD_RELOC_PPC64_D34_LO:    r = R_PPC64_D34_LO;
1286
0
      break;
1287
0
    case BFD_RELOC_PPC64_D34_HI30:    r = R_PPC64_D34_HI30;
1288
0
      break;
1289
0
    case BFD_RELOC_PPC64_D34_HA30:    r = R_PPC64_D34_HA30;
1290
0
      break;
1291
0
    case BFD_RELOC_PPC64_PCREL34:   r = R_PPC64_PCREL34;
1292
0
      break;
1293
0
    case BFD_RELOC_PPC64_GOT_PCREL34:   r = R_PPC64_GOT_PCREL34;
1294
0
      break;
1295
0
    case BFD_RELOC_PPC64_PLT_PCREL34:   r = R_PPC64_PLT_PCREL34;
1296
0
      break;
1297
0
    case BFD_RELOC_PPC64_TPREL34:   r = R_PPC64_TPREL34;
1298
0
      break;
1299
0
    case BFD_RELOC_PPC64_DTPREL34:    r = R_PPC64_DTPREL34;
1300
0
      break;
1301
0
    case BFD_RELOC_PPC64_GOT_TLSGD_PCREL34: r = R_PPC64_GOT_TLSGD_PCREL34;
1302
0
      break;
1303
0
    case BFD_RELOC_PPC64_GOT_TLSLD_PCREL34: r = R_PPC64_GOT_TLSLD_PCREL34;
1304
0
      break;
1305
0
    case BFD_RELOC_PPC64_GOT_TPREL_PCREL34: r = R_PPC64_GOT_TPREL_PCREL34;
1306
0
      break;
1307
0
    case BFD_RELOC_PPC64_GOT_DTPREL_PCREL34:  r = R_PPC64_GOT_DTPREL_PCREL34;
1308
0
      break;
1309
0
    case BFD_RELOC_PPC64_ADDR16_HIGHER34: r = R_PPC64_ADDR16_HIGHER34;
1310
0
      break;
1311
0
    case BFD_RELOC_PPC64_ADDR16_HIGHERA34:  r = R_PPC64_ADDR16_HIGHERA34;
1312
0
      break;
1313
0
    case BFD_RELOC_PPC64_ADDR16_HIGHEST34:  r = R_PPC64_ADDR16_HIGHEST34;
1314
0
      break;
1315
0
    case BFD_RELOC_PPC64_ADDR16_HIGHESTA34: r = R_PPC64_ADDR16_HIGHESTA34;
1316
0
      break;
1317
0
    case BFD_RELOC_PPC64_REL16_HIGHER34:  r = R_PPC64_REL16_HIGHER34;
1318
0
      break;
1319
0
    case BFD_RELOC_PPC64_REL16_HIGHERA34: r = R_PPC64_REL16_HIGHERA34;
1320
0
      break;
1321
0
    case BFD_RELOC_PPC64_REL16_HIGHEST34: r = R_PPC64_REL16_HIGHEST34;
1322
0
      break;
1323
0
    case BFD_RELOC_PPC64_REL16_HIGHESTA34:  r = R_PPC64_REL16_HIGHESTA34;
1324
0
      break;
1325
0
    case BFD_RELOC_PPC64_D28:     r = R_PPC64_D28;
1326
0
      break;
1327
0
    case BFD_RELOC_PPC64_PCREL28:   r = R_PPC64_PCREL28;
1328
0
      break;
1329
0
    case BFD_RELOC_VTABLE_INHERIT:    r = R_PPC64_GNU_VTINHERIT;
1330
0
      break;
1331
0
    case BFD_RELOC_VTABLE_ENTRY:    r = R_PPC64_GNU_VTENTRY;
1332
0
      break;
1333
0
    }
1334
1335
0
  return ppc64_elf_howto_table[r];
1336
0
};
1337
1338
static reloc_howto_type *
1339
ppc64_elf_reloc_name_lookup (bfd *abfd, const char *r_name)
1340
0
{
1341
0
  unsigned int i;
1342
0
  static char *compat_map[][2] = {
1343
0
    { "R_PPC64_GOT_TLSGD34", "R_PPC64_GOT_TLSGD_PCREL34" },
1344
0
    { "R_PPC64_GOT_TLSLD34", "R_PPC64_GOT_TLSLD_PCREL34" },
1345
0
    { "R_PPC64_GOT_TPREL34", "R_PPC64_GOT_TPREL_PCREL34" },
1346
0
    { "R_PPC64_GOT_DTPREL34", "R_PPC64_GOT_DTPREL_PCREL34" }
1347
0
  };
1348
1349
0
  for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
1350
0
    if (ppc64_elf_howto_raw[i].name != NULL
1351
0
  && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
1352
0
      return &ppc64_elf_howto_raw[i];
1353
1354
  /* Handle old names of relocations in case they were used by
1355
     .reloc directives.
1356
     FIXME: Remove this soon.  Mapping the reloc names is very likely
1357
     completely unnecessary.  */
1358
0
  for (i = 0; i < ARRAY_SIZE (compat_map); i++)
1359
0
    if (strcasecmp (compat_map[i][0], r_name) == 0)
1360
0
      {
1361
0
  _bfd_error_handler (_("warning: %s should be used rather than %s"),
1362
0
          compat_map[i][1], compat_map[i][0]);
1363
0
  return ppc64_elf_reloc_name_lookup (abfd, compat_map[i][1]);
1364
0
      }
1365
1366
0
  return NULL;
1367
0
}
1368
1369
/* Set the howto pointer for a PowerPC ELF reloc.  */
1370
1371
static bool
1372
ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
1373
       Elf_Internal_Rela *dst)
1374
729
{
1375
729
  unsigned int type;
1376
1377
  /* Initialize howto table if needed.  */
1378
729
  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1379
2
    ppc_howto_init ();
1380
1381
729
  type = ELF64_R_TYPE (dst->r_info);
1382
729
  if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
1383
103
    {
1384
      /* xgettext:c-format */
1385
103
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1386
103
        abfd, type);
1387
103
      bfd_set_error (bfd_error_bad_value);
1388
103
      return false;
1389
103
    }
1390
626
  cache_ptr->howto = ppc64_elf_howto_table[type];
1391
626
  if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
1392
11
    {
1393
      /* xgettext:c-format */
1394
11
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1395
11
        abfd, type);
1396
11
      bfd_set_error (bfd_error_bad_value);
1397
11
      return false;
1398
11
    }
1399
1400
615
  return true;
1401
626
}
1402
1403
/* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
1404
1405
static bfd_reloc_status_type
1406
ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1407
        void *data, asection *input_section,
1408
        bfd *output_bfd, char **error_message)
1409
13
{
1410
13
  enum elf_ppc64_reloc_type r_type;
1411
13
  long insn;
1412
13
  bfd_size_type octets;
1413
13
  bfd_vma value;
1414
1415
  /* If this is a relocatable link (output_bfd test tells us), just
1416
     call the generic function.  Any adjustment will be done at final
1417
     link time.  */
1418
13
  if (output_bfd != NULL)
1419
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1420
0
          input_section, output_bfd, error_message);
1421
1422
  /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1423
     We won't actually be using the low bits, so trashing them
1424
     doesn't matter.  */
1425
13
  r_type = reloc_entry->howto->type;
1426
13
  if (r_type == R_PPC64_ADDR16_HIGHERA34
1427
13
      || r_type == R_PPC64_ADDR16_HIGHESTA34
1428
13
      || r_type == R_PPC64_REL16_HIGHERA34
1429
13
      || r_type == R_PPC64_REL16_HIGHESTA34)
1430
3
    reloc_entry->addend += 1ULL << 33;
1431
10
  else
1432
10
    reloc_entry->addend += 1U << 15;
1433
13
  if (r_type != R_PPC64_REL16DX_HA)
1434
13
    return bfd_reloc_continue;
1435
1436
0
  value = 0;
1437
0
  if (!bfd_is_com_section (symbol->section))
1438
0
    value = symbol->value;
1439
0
  value += (reloc_entry->addend
1440
0
      + symbol->section->output_offset
1441
0
      + symbol->section->output_section->vma);
1442
0
  value -= (reloc_entry->address
1443
0
      + input_section->output_offset
1444
0
      + input_section->output_section->vma);
1445
0
  value = (bfd_signed_vma) value >> 16;
1446
1447
0
  octets = reloc_entry->address * OCTETS_PER_BYTE (abfd, input_section);
1448
0
  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
1449
0
          input_section, octets))
1450
0
    return bfd_reloc_outofrange;
1451
1452
0
  insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1453
0
  insn &= ~0x1fffc1;
1454
0
  insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
1455
0
  bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
1456
0
  if (value + 0x8000 > 0xffff)
1457
0
    return bfd_reloc_overflow;
1458
0
  return bfd_reloc_ok;
1459
0
}
1460
1461
static bfd_reloc_status_type
1462
ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1463
      void *data, asection *input_section,
1464
      bfd *output_bfd, char **error_message)
1465
33
{
1466
33
  if (output_bfd != NULL)
1467
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1468
0
          input_section, output_bfd, error_message);
1469
1470
33
  if (symbol->section->owner == NULL
1471
33
      || !is_ppc64_elf (symbol->section->owner))
1472
28
    return bfd_reloc_continue;
1473
1474
5
  if (strcmp (symbol->section->name, ".opd") == 0
1475
5
      && (symbol->section->owner->flags & DYNAMIC) == 0)
1476
0
    {
1477
0
      bfd_vma dest = opd_entry_value (symbol->section,
1478
0
              symbol->value + reloc_entry->addend,
1479
0
              NULL, NULL, false);
1480
0
      if (dest != (bfd_vma) -1)
1481
0
  reloc_entry->addend = dest - (symbol->value
1482
0
              + symbol->section->output_section->vma
1483
0
              + symbol->section->output_offset);
1484
0
    }
1485
5
  else
1486
5
    {
1487
5
      elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
1488
1489
5
      if (symbol->section->owner != abfd
1490
5
    && abiversion (symbol->section->owner) >= 2)
1491
0
  {
1492
0
    unsigned int i;
1493
1494
0
    for (i = 0; i < symbol->section->owner->symcount; ++i)
1495
0
      {
1496
0
        asymbol *symdef = symbol->section->owner->outsymbols[i];
1497
1498
0
        if (strcmp (symdef->name, symbol->name) == 0)
1499
0
    {
1500
0
      elfsym = (elf_symbol_type *) symdef;
1501
0
      break;
1502
0
    }
1503
0
      }
1504
0
  }
1505
5
      reloc_entry->addend
1506
5
  += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
1507
5
    }
1508
5
  return bfd_reloc_continue;
1509
33
}
1510
1511
static bfd_reloc_status_type
1512
ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1513
       void *data, asection *input_section,
1514
       bfd *output_bfd, char **error_message)
1515
20
{
1516
20
  long insn;
1517
20
  enum elf_ppc64_reloc_type r_type;
1518
20
  bfd_size_type octets;
1519
  /* Assume 'at' branch hints.  */
1520
20
  bool is_isa_v2 = true;
1521
1522
  /* If this is a relocatable link (output_bfd test tells us), just
1523
     call the generic function.  Any adjustment will be done at final
1524
     link time.  */
1525
20
  if (output_bfd != NULL)
1526
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1527
0
          input_section, output_bfd, error_message);
1528
1529
20
  octets = reloc_entry->address * OCTETS_PER_BYTE (abfd, input_section);
1530
20
  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
1531
20
          input_section, octets))
1532
4
    return bfd_reloc_outofrange;
1533
1534
16
  insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1535
16
  insn &= ~(0x01 << 21);
1536
16
  r_type = reloc_entry->howto->type;
1537
16
  if (r_type == R_PPC64_ADDR14_BRTAKEN
1538
16
      || r_type == R_PPC64_REL14_BRTAKEN)
1539
10
    insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
1540
1541
16
  if (is_isa_v2)
1542
16
    {
1543
      /* Set 'a' bit.  This is 0b00010 in BO field for branch
1544
   on CR(BI) insns (BO == 001at or 011at), and 0b01000
1545
   for branch on CTR insns (BO == 1a00t or 1a01t).  */
1546
16
      if ((insn & (0x14 << 21)) == (0x04 << 21))
1547
1
  insn |= 0x02 << 21;
1548
15
      else if ((insn & (0x14 << 21)) == (0x10 << 21))
1549
2
  insn |= 0x08 << 21;
1550
13
      else
1551
13
  goto out;
1552
16
    }
1553
0
  else
1554
0
    {
1555
0
      bfd_vma target = 0;
1556
0
      bfd_vma from;
1557
1558
0
      if (!bfd_is_com_section (symbol->section))
1559
0
  target = symbol->value;
1560
0
      target += symbol->section->output_section->vma;
1561
0
      target += symbol->section->output_offset;
1562
0
      target += reloc_entry->addend;
1563
1564
0
      from = (reloc_entry->address
1565
0
        + input_section->output_offset
1566
0
        + input_section->output_section->vma);
1567
1568
      /* Invert 'y' bit if not the default.  */
1569
0
      if ((bfd_signed_vma) (target - from) < 0)
1570
0
  insn ^= 0x01 << 21;
1571
0
    }
1572
3
  bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
1573
16
 out:
1574
16
  return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
1575
16
         input_section, output_bfd, error_message);
1576
3
}
1577
1578
static bfd_reloc_status_type
1579
ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1580
       void *data, asection *input_section,
1581
       bfd *output_bfd, char **error_message)
1582
9
{
1583
  /* If this is a relocatable link (output_bfd test tells us), just
1584
     call the generic function.  Any adjustment will be done at final
1585
     link time.  */
1586
9
  if (output_bfd != NULL)
1587
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1588
0
          input_section, output_bfd, error_message);
1589
1590
  /* Subtract the symbol section base address.  */
1591
9
  reloc_entry->addend -= symbol->section->output_section->vma;
1592
9
  return bfd_reloc_continue;
1593
9
}
1594
1595
static bfd_reloc_status_type
1596
ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1597
          void *data, asection *input_section,
1598
          bfd *output_bfd, char **error_message)
1599
0
{
1600
  /* If this is a relocatable link (output_bfd test tells us), just
1601
     call the generic function.  Any adjustment will be done at final
1602
     link time.  */
1603
0
  if (output_bfd != NULL)
1604
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1605
0
          input_section, output_bfd, error_message);
1606
1607
  /* Subtract the symbol section base address.  */
1608
0
  reloc_entry->addend -= symbol->section->output_section->vma;
1609
1610
  /* Adjust the addend for sign extension of the low 16 bits.  */
1611
0
  reloc_entry->addend += 0x8000;
1612
0
  return bfd_reloc_continue;
1613
0
}
1614
1615
static bfd_reloc_status_type
1616
ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1617
         void *data, asection *input_section,
1618
         bfd *output_bfd, char **error_message)
1619
5
{
1620
5
  bfd_vma TOCstart;
1621
1622
  /* If this is a relocatable link (output_bfd test tells us), just
1623
     call the generic function.  Any adjustment will be done at final
1624
     link time.  */
1625
5
  if (output_bfd != NULL)
1626
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1627
0
          input_section, output_bfd, error_message);
1628
1629
5
  TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1630
5
  if (TOCstart == 0)
1631
5
    TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1632
1633
  /* Subtract the TOC base address.  */
1634
5
  reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1635
5
  return bfd_reloc_continue;
1636
5
}
1637
1638
static bfd_reloc_status_type
1639
ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1640
      void *data, asection *input_section,
1641
      bfd *output_bfd, char **error_message)
1642
4
{
1643
4
  bfd_vma TOCstart;
1644
1645
  /* If this is a relocatable link (output_bfd test tells us), just
1646
     call the generic function.  Any adjustment will be done at final
1647
     link time.  */
1648
4
  if (output_bfd != NULL)
1649
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1650
0
          input_section, output_bfd, error_message);
1651
1652
4
  TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1653
4
  if (TOCstart == 0)
1654
4
    TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1655
1656
  /* Subtract the TOC base address.  */
1657
4
  reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1658
1659
  /* Adjust the addend for sign extension of the low 16 bits.  */
1660
4
  reloc_entry->addend += 0x8000;
1661
4
  return bfd_reloc_continue;
1662
4
}
1663
1664
static bfd_reloc_status_type
1665
ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1666
           void *data, asection *input_section,
1667
           bfd *output_bfd, char **error_message)
1668
0
{
1669
0
  bfd_vma TOCstart;
1670
0
  bfd_size_type octets;
1671
1672
  /* If this is a relocatable link (output_bfd test tells us), just
1673
     call the generic function.  Any adjustment will be done at final
1674
     link time.  */
1675
0
  if (output_bfd != NULL)
1676
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1677
0
          input_section, output_bfd, error_message);
1678
1679
0
  octets = reloc_entry->address * OCTETS_PER_BYTE (abfd, input_section);
1680
0
  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
1681
0
          input_section, octets))
1682
0
    return bfd_reloc_outofrange;
1683
1684
0
  TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1685
0
  if (TOCstart == 0)
1686
0
    TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
1687
1688
0
  bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
1689
0
  return bfd_reloc_ok;
1690
0
}
1691
1692
static bfd_reloc_status_type
1693
ppc64_elf_prefix_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1694
      void *data, asection *input_section,
1695
      bfd *output_bfd, char **error_message)
1696
8
{
1697
8
  uint64_t insn;
1698
8
  bfd_vma targ;
1699
8
  bfd_size_type octets;
1700
1701
8
  if (output_bfd != NULL)
1702
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1703
0
          input_section, output_bfd, error_message);
1704
1705
8
  octets = reloc_entry->address * OCTETS_PER_BYTE (abfd, input_section);
1706
8
  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
1707
8
          input_section, octets))
1708
1
    return bfd_reloc_outofrange;
1709
1710
7
  insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1711
7
  insn <<= 32;
1712
7
  insn |= bfd_get_32 (abfd, (bfd_byte *) data + octets + 4);
1713
1714
7
  targ = (symbol->section->output_section->vma
1715
7
    + symbol->section->output_offset
1716
7
    + reloc_entry->addend);
1717
7
  if (!bfd_is_com_section (symbol->section))
1718
7
    targ += symbol->value;
1719
7
  if (reloc_entry->howto->type == R_PPC64_D34_HA30)
1720
6
    targ += 1ULL << 33;
1721
7
  if (reloc_entry->howto->pc_relative)
1722
0
    {
1723
0
      bfd_vma from = (reloc_entry->address
1724
0
          + input_section->output_offset
1725
0
          + input_section->output_section->vma);
1726
0
      targ -=from;
1727
0
    }
1728
7
  targ >>= reloc_entry->howto->rightshift;
1729
7
  insn &= ~reloc_entry->howto->dst_mask;
1730
7
  insn |= ((targ << 16) | (targ & 0xffff)) & reloc_entry->howto->dst_mask;
1731
7
  bfd_put_32 (abfd, insn >> 32, (bfd_byte *) data + octets);
1732
7
  bfd_put_32 (abfd, insn, (bfd_byte *) data + octets + 4);
1733
7
  if (reloc_entry->howto->complain_on_overflow == complain_overflow_signed
1734
7
      && (targ + (1ULL << (reloc_entry->howto->bitsize - 1))
1735
1
    >= 1ULL << reloc_entry->howto->bitsize))
1736
1
    return bfd_reloc_overflow;
1737
6
  return bfd_reloc_ok;
1738
7
}
1739
1740
static bfd_reloc_status_type
1741
ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1742
         void *data, asection *input_section,
1743
         bfd *output_bfd, char **error_message)
1744
3
{
1745
  /* If this is a relocatable link (output_bfd test tells us), just
1746
     call the generic function.  Any adjustment will be done at final
1747
     link time.  */
1748
3
  if (output_bfd != NULL)
1749
0
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1750
0
          input_section, output_bfd, error_message);
1751
1752
3
  if (error_message != NULL)
1753
3
    *error_message = bfd_asprintf (_("generic linker can't handle %s"),
1754
3
           reloc_entry->howto->name);
1755
3
  return bfd_reloc_dangerous;
1756
3
}
1757
1758
/* Track GOT entries needed for a given symbol.  We might need more
1759
   than one got entry per symbol.  */
1760
struct got_entry
1761
{
1762
  struct got_entry *next;
1763
1764
  /* The symbol addend that we'll be placing in the GOT.  */
1765
  bfd_vma addend;
1766
1767
  /* Unlike other ELF targets, we use separate GOT entries for the same
1768
     symbol referenced from different input files.  This is to support
1769
     automatic multiple TOC/GOT sections, where the TOC base can vary
1770
     from one input file to another.  After partitioning into TOC groups
1771
     we merge entries within the group.
1772
1773
     Point to the BFD owning this GOT entry.  */
1774
  bfd *owner;
1775
1776
  /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1777
     TLS_TPREL or TLS_DTPREL for tls entries.  */
1778
  unsigned char tls_type;
1779
1780
  /* Non-zero if got.ent points to real entry.  */
1781
  unsigned char is_indirect;
1782
1783
  /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
1784
  union
1785
  {
1786
    bfd_signed_vma refcount;
1787
    bfd_vma offset;
1788
    struct got_entry *ent;
1789
  } got;
1790
};
1791
1792
/* The same for PLT.  */
1793
struct plt_entry
1794
{
1795
  struct plt_entry *next;
1796
1797
  bfd_vma addend;
1798
1799
  union
1800
  {
1801
    bfd_signed_vma refcount;
1802
    bfd_vma offset;
1803
  } plt;
1804
};
1805
1806
struct ppc64_elf_obj_tdata
1807
{
1808
  struct elf_obj_tdata elf;
1809
1810
  /* Shortcuts to dynamic linker sections.  */
1811
  asection *got;
1812
  asection *relgot;
1813
1814
  /* Used during garbage collection.  We attach global symbols defined
1815
     on removed .opd entries to this section so that the sym is removed.  */
1816
  asection *deleted_section;
1817
1818
  /* TLS local dynamic got entry handling.  Support for multiple GOT
1819
     sections means we potentially need one of these for each input bfd.  */
1820
  struct got_entry tlsld_got;
1821
1822
  /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1823
     the reloc to be in the range -32768 to 32767.  */
1824
  unsigned int has_small_toc_reloc : 1;
1825
1826
  /* Set if toc/got ha relocs detected not using r2, or lo reloc
1827
     instruction not one we handle.  */
1828
  unsigned int unexpected_toc_insn : 1;
1829
1830
  /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1831
     this file.  */
1832
  unsigned int has_optrel : 1;
1833
};
1834
1835
#define ppc64_elf_tdata(bfd) \
1836
0
  ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1837
1838
#define ppc64_tlsld_got(bfd) \
1839
0
  (&ppc64_elf_tdata (bfd)->tlsld_got)
1840
1841
/* Override the generic function because we store some extras.  */
1842
1843
static bool
1844
ppc64_elf_mkobject (bfd *abfd)
1845
272k
{
1846
272k
  return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
1847
272k
          PPC64_ELF_DATA);
1848
272k
}
1849
1850
/* Fix bad default arch selected for a 64 bit input bfd when the
1851
   default is 32 bit.  Also select arch based on apuinfo.  */
1852
1853
static bool
1854
ppc64_elf_object_p (bfd *abfd)
1855
3.86k
{
1856
3.86k
  if (!abfd->arch_info->the_default)
1857
0
    return true;
1858
1859
3.86k
  if (abfd->arch_info->bits_per_word == 32)
1860
0
    {
1861
0
      Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
1862
1863
0
      if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
1864
0
  {
1865
    /* Relies on arch after 32 bit default being 64 bit default.  */
1866
0
    abfd->arch_info = abfd->arch_info->next;
1867
0
    BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
1868
0
  }
1869
0
    }
1870
3.86k
  return _bfd_elf_ppc_set_arch (abfd);
1871
3.86k
}
1872
1873
/* Support for core dump NOTE sections.  */
1874
1875
static bool
1876
ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1877
2
{
1878
2
  size_t offset, size;
1879
1880
2
  if (note->descsz != 504)
1881
2
    return false;
1882
1883
  /* pr_cursig */
1884
0
  elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1885
1886
  /* pr_pid */
1887
0
  elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
1888
1889
  /* pr_reg */
1890
0
  offset = 112;
1891
0
  size = 384;
1892
1893
  /* Make a ".reg/999" section.  */
1894
0
  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1895
0
            size, note->descpos + offset);
1896
2
}
1897
1898
static bool
1899
ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1900
0
{
1901
0
  if (note->descsz != 136)
1902
0
    return false;
1903
1904
0
  elf_tdata (abfd)->core->pid
1905
0
    = bfd_get_32 (abfd, note->descdata + 24);
1906
0
  elf_tdata (abfd)->core->program
1907
0
    = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
1908
0
  elf_tdata (abfd)->core->command
1909
0
    = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
1910
1911
0
  return true;
1912
0
}
1913
1914
static char *
1915
ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
1916
         ...)
1917
0
{
1918
0
  switch (note_type)
1919
0
    {
1920
0
    default:
1921
0
      return NULL;
1922
1923
0
    case NT_PRPSINFO:
1924
0
      {
1925
0
  char data[136] ATTRIBUTE_NONSTRING;
1926
0
  va_list ap;
1927
1928
0
  va_start (ap, note_type);
1929
0
  memset (data, 0, sizeof (data));
1930
0
  strncpy (data + 40, va_arg (ap, const char *), 16);
1931
#if GCC_VERSION == 8000 || GCC_VERSION == 8001
1932
  DIAGNOSTIC_PUSH;
1933
  /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1934
     -Wstringop-truncation:
1935
     https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1936
   */
1937
  DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
1938
#endif
1939
0
  strncpy (data + 56, va_arg (ap, const char *), 80);
1940
#if GCC_VERSION == 8000 || GCC_VERSION == 8001
1941
  DIAGNOSTIC_POP;
1942
#endif
1943
0
  va_end (ap);
1944
0
  return elfcore_write_note (abfd, buf, bufsiz,
1945
0
           "CORE", note_type, data, sizeof (data));
1946
0
      }
1947
1948
0
    case NT_PRSTATUS:
1949
0
      {
1950
0
  char data[504];
1951
0
  va_list ap;
1952
0
  long pid;
1953
0
  int cursig;
1954
0
  const void *greg;
1955
1956
0
  va_start (ap, note_type);
1957
0
  memset (data, 0, 112);
1958
0
  pid = va_arg (ap, long);
1959
0
  bfd_put_32 (abfd, pid, data + 32);
1960
0
  cursig = va_arg (ap, int);
1961
0
  bfd_put_16 (abfd, cursig, data + 12);
1962
0
  greg = va_arg (ap, const void *);
1963
0
  memcpy (data + 112, greg, 384);
1964
0
  memset (data + 496, 0, 8);
1965
0
  va_end (ap);
1966
0
  return elfcore_write_note (abfd, buf, bufsiz,
1967
0
           "CORE", note_type, data, sizeof (data));
1968
0
      }
1969
0
    }
1970
0
}
1971
1972
/* Add extra PPC sections.  */
1973
1974
static const struct bfd_elf_special_section ppc64_elf_special_sections[] =
1975
{
1976
  { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
1977
  { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
1978
  { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1979
  { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1980
  { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1981
  { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
1982
  { NULL,         0,  0, 0,      0 }
1983
};
1984
1985
enum _ppc64_sec_type {
1986
  sec_normal = 0,
1987
  sec_opd = 1,
1988
  sec_toc = 2,
1989
  sec_stub = 3
1990
};
1991
1992
struct _ppc64_elf_section_data
1993
{
1994
  struct bfd_elf_section_data elf;
1995
1996
  union
1997
  {
1998
    /* An array with one entry for each opd function descriptor,
1999
       and some spares since opd entries may be either 16 or 24 bytes.  */
2000
0
#define OPD_NDX(OFF) ((OFF) >> 4)
2001
    struct _opd_sec_data
2002
    {
2003
      /* Points to the function code section for local opd entries.  */
2004
      asection **func_sec;
2005
2006
      /* After editing .opd, adjust references to opd local syms.  */
2007
      long *adjust;
2008
2009
      union
2010
      {
2011
  /* A copy of relocs before they are modified for --emit-relocs.  */
2012
  Elf_Internal_Rela *relocs;
2013
2014
  /* Section contents.  */
2015
  bfd_byte *contents;
2016
      } u;
2017
    } opd;
2018
2019
    /* An array for toc sections, indexed by offset/8.  */
2020
    struct _toc_sec_data
2021
    {
2022
      /* Specifies the relocation symbol index used at a given toc offset.  */
2023
      unsigned *symndx;
2024
2025
      /* And the relocation addend.  */
2026
      bfd_vma *add;
2027
    } toc;
2028
2029
    /* Stub debugging.  */
2030
    struct ppc_stub_hash_entry *last_ent;
2031
  } u;
2032
2033
  enum _ppc64_sec_type sec_type:2;
2034
2035
  /* Flag set when small branches are detected.  Used to
2036
     select suitable defaults for the stub group size.  */
2037
  unsigned int has_14bit_branch:1;
2038
2039
  /* Flag set when PLTCALL relocs are detected.  */
2040
  unsigned int has_pltcall:1;
2041
2042
  /* Flag set when section has PLT/GOT/TOC relocations that can be
2043
     optimised.  */
2044
  unsigned int has_optrel:1;
2045
};
2046
2047
#define ppc64_elf_section_data(sec) \
2048
0
  ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2049
2050
static bool
2051
ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2052
10.9k
{
2053
10.9k
  if (!sec->used_by_bfd)
2054
10.9k
    {
2055
10.9k
      struct _ppc64_elf_section_data *sdata;
2056
10.9k
      size_t amt = sizeof (*sdata);
2057
2058
10.9k
      sdata = bfd_zalloc (abfd, amt);
2059
10.9k
      if (sdata == NULL)
2060
0
  return false;
2061
10.9k
      sec->used_by_bfd = sdata;
2062
10.9k
    }
2063
2064
10.9k
  return _bfd_elf_new_section_hook (abfd, sec);
2065
10.9k
}
2066
2067
static bool
2068
ppc64_elf_section_flags (const Elf_Internal_Shdr *hdr)
2069
10.7k
{
2070
10.7k
  const char *name = hdr->bfd_section->name;
2071
2072
10.7k
  if (startswith (name, ".sbss")
2073
10.7k
      || startswith (name, ".sdata"))
2074
15
    hdr->bfd_section->flags |= SEC_SMALL_DATA;
2075
2076
10.7k
  return true;
2077
10.7k
}
2078
2079
static struct _opd_sec_data *
2080
get_opd_info (asection * sec)
2081
0
{
2082
0
  if (sec != NULL
2083
0
      && ppc64_elf_section_data (sec) != NULL
2084
0
      && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2085
0
    return &ppc64_elf_section_data (sec)->u.opd;
2086
0
  return NULL;
2087
0
}
2088

2089
/* Parameters for the qsort hook.  */
2090
static bool synthetic_relocatable;
2091
static const asection *synthetic_opd;
2092
2093
/* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2094
2095
static int
2096
compare_symbols (const void *ap, const void *bp)
2097
0
{
2098
0
  const asymbol *a = *(const asymbol **) ap;
2099
0
  const asymbol *b = *(const asymbol **) bp;
2100
2101
  /* Section symbols first.  */
2102
0
  if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2103
0
    return -1;
2104
0
  if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2105
0
    return 1;
2106
2107
  /* then .opd symbols.  */
2108
0
  if (synthetic_opd != NULL)
2109
0
    {
2110
0
      if (strcmp (a->section->name, ".opd") == 0
2111
0
    && strcmp (b->section->name, ".opd") != 0)
2112
0
  return -1;
2113
0
      if (strcmp (a->section->name, ".opd") != 0
2114
0
    && strcmp (b->section->name, ".opd") == 0)
2115
0
  return 1;
2116
0
    }
2117
2118
  /* then other code symbols.  */
2119
0
  if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2120
0
       == (SEC_CODE | SEC_ALLOC))
2121
0
      && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2122
0
    != (SEC_CODE | SEC_ALLOC)))
2123
0
    return -1;
2124
2125
0
  if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2126
0
       != (SEC_CODE | SEC_ALLOC))
2127
0
      && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2128
0
    == (SEC_CODE | SEC_ALLOC)))
2129
0
    return 1;
2130
2131
0
  if (synthetic_relocatable)
2132
0
    {
2133
0
      if (a->section->id < b->section->id)
2134
0
  return -1;
2135
2136
0
      if (a->section->id > b->section->id)
2137
0
  return 1;
2138
0
    }
2139
2140
0
  if (a->value + a->section->vma < b->value + b->section->vma)
2141
0
    return -1;
2142
2143
0
  if (a->value + a->section->vma > b->value + b->section->vma)
2144
0
    return 1;
2145
2146
  /* For syms with the same value, prefer strong dynamic global function
2147
     syms over other syms.  */
2148
0
  if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2149
0
    return -1;
2150
2151
0
  if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2152
0
    return 1;
2153
2154
0
  if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2155
0
    return -1;
2156
2157
0
  if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2158
0
    return 1;
2159
2160
0
  if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2161
0
    return -1;
2162
2163
0
  if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2164
0
    return 1;
2165
2166
0
  if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2167
0
    return -1;
2168
2169
0
  if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2170
0
    return 1;
2171
2172
  /* Finally, sort on where the symbol is in memory.  The symbols will
2173
     be in at most two malloc'd blocks, one for static syms, one for
2174
     dynamic syms, and we distinguish the two blocks above by testing
2175
     BSF_DYNAMIC.  Since we are sorting the symbol pointers which were
2176
     originally in the same order as the symbols (and we're not
2177
     sorting the symbols themselves), this ensures a stable sort.  */
2178
0
  if (a < b)
2179
0
    return -1;
2180
0
  if (a > b)
2181
0
    return 1;
2182
0
  return 0;
2183
0
}
2184
2185
/* Search SYMS for a symbol of the given VALUE.  */
2186
2187
static asymbol *
2188
sym_exists_at (asymbol **syms, size_t lo, size_t hi, unsigned int id,
2189
         bfd_vma value)
2190
0
{
2191
0
  size_t mid;
2192
2193
0
  if (id == (unsigned) -1)
2194
0
    {
2195
0
      while (lo < hi)
2196
0
  {
2197
0
    mid = (lo + hi) >> 1;
2198
0
    if (syms[mid]->value + syms[mid]->section->vma < value)
2199
0
      lo = mid + 1;
2200
0
    else if (syms[mid]->value + syms[mid]->section->vma > value)
2201
0
      hi = mid;
2202
0
    else
2203
0
      return syms[mid];
2204
0
  }
2205
0
    }
2206
0
  else
2207
0
    {
2208
0
      while (lo < hi)
2209
0
  {
2210
0
    mid = (lo + hi) >> 1;
2211
0
    if (syms[mid]->section->id < id)
2212
0
      lo = mid + 1;
2213
0
    else if (syms[mid]->section->id > id)
2214
0
      hi = mid;
2215
0
    else if (syms[mid]->value < value)
2216
0
      lo = mid + 1;
2217
0
    else if (syms[mid]->value > value)
2218
0
      hi = mid;
2219
0
    else
2220
0
      return syms[mid];
2221
0
  }
2222
0
    }
2223
0
  return NULL;
2224
0
}
2225
2226
static bool
2227
section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2228
0
{
2229
0
  bfd_vma vma = *(bfd_vma *) ptr;
2230
0
  return ((section->flags & SEC_ALLOC) != 0
2231
0
    && section->vma <= vma
2232
0
    && vma < section->vma + section->size);
2233
0
}
2234
2235
/* Create synthetic symbols, effectively restoring "dot-symbol" function
2236
   entry syms.  Also generate @plt symbols for the glink branch table.
2237
   Returns count of synthetic symbols in RET or -1 on error.  */
2238
2239
static long
2240
ppc64_elf_get_synthetic_symtab (bfd *abfd,
2241
        long static_count, asymbol **static_syms,
2242
        long dyn_count, asymbol **dyn_syms,
2243
        asymbol **ret)
2244
33
{
2245
33
  asymbol *s;
2246
33
  size_t i, j, count;
2247
33
  char *names;
2248
33
  size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2249
33
  asection *opd = NULL;
2250
33
  bool relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2251
33
  asymbol **syms;
2252
33
  int abi = abiversion (abfd);
2253
2254
33
  *ret = NULL;
2255
2256
33
  if (abi < 2)
2257
33
    {
2258
33
      opd = bfd_get_section_by_name (abfd, ".opd");
2259
33
      if (opd == NULL && abi == 1)
2260
6
  return 0;
2261
33
    }
2262
2263
27
  syms = NULL;
2264
27
  codesecsym = 0;
2265
27
  codesecsymend = 0;
2266
27
  secsymend = 0;
2267
27
  opdsymend = 0;
2268
27
  symcount = 0;
2269
27
  if (opd != NULL)
2270
0
    {
2271
0
      symcount = static_count;
2272
0
      if (!relocatable)
2273
0
  symcount += dyn_count;
2274
0
      if (symcount == 0)
2275
0
  return 0;
2276
2277
0
      syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2278
0
      if (syms == NULL)
2279
0
  return -1;
2280
2281
0
      if (!relocatable && static_count != 0 && dyn_count != 0)
2282
0
  {
2283
    /* Use both symbol tables.  */
2284
0
    memcpy (syms, static_syms, static_count * sizeof (*syms));
2285
0
    memcpy (syms + static_count, dyn_syms,
2286
0
      (dyn_count + 1) * sizeof (*syms));
2287
0
  }
2288
0
      else if (!relocatable && static_count == 0)
2289
0
  memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2290
0
      else
2291
0
  memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2292
2293
      /* Trim uninteresting symbols.  Interesting symbols are section,
2294
   function, and notype symbols.  */
2295
0
      for (i = 0, j = 0; i < symcount; ++i)
2296
0
  if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
2297
0
             | BSF_RELC | BSF_SRELC)) == 0)
2298
0
    syms[j++] = syms[i];
2299
0
      symcount = j;
2300
2301
0
      synthetic_relocatable = relocatable;
2302
0
      synthetic_opd = opd;
2303
0
      qsort (syms, symcount, sizeof (*syms), compare_symbols);
2304
2305
0
      if (!relocatable && symcount > 1)
2306
0
  {
2307
    /* Trim duplicate syms, since we may have merged the normal
2308
       and dynamic symbols.  Actually, we only care about syms
2309
       that have different values, so trim any with the same
2310
       value.  Don't consider ifunc and ifunc resolver symbols
2311
       duplicates however, because GDB wants to know whether a
2312
       text symbol is an ifunc resolver.  */
2313
0
    for (i = 1, j = 1; i < symcount; ++i)
2314
0
      {
2315
0
        const asymbol *s0 = syms[i - 1];
2316
0
        const asymbol *s1 = syms[i];
2317
2318
0
        if ((s0->value + s0->section->vma
2319
0
       != s1->value + s1->section->vma)
2320
0
      || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
2321
0
          != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
2322
0
    syms[j++] = syms[i];
2323
0
      }
2324
0
    symcount = j;
2325
0
  }
2326
2327
0
      i = 0;
2328
      /* Note that here and in compare_symbols we can't compare opd and
2329
   sym->section directly.  With separate debug info files, the
2330
   symbols will be extracted from the debug file while abfd passed
2331
   to this function is the real binary.  */
2332
0
      if ((syms[i]->flags & BSF_SECTION_SYM) != 0
2333
0
    && strcmp (syms[i]->section->name, ".opd") == 0)
2334
0
  ++i;
2335
0
      codesecsym = i;
2336
2337
0
      for (; i < symcount; ++i)
2338
0
  if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
2339
0
           | SEC_THREAD_LOCAL))
2340
0
       != (SEC_CODE | SEC_ALLOC))
2341
0
      || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2342
0
    break;
2343
0
      codesecsymend = i;
2344
2345
0
      for (; i < symcount; ++i)
2346
0
  if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2347
0
    break;
2348
0
      secsymend = i;
2349
2350
0
      for (; i < symcount; ++i)
2351
0
  if (strcmp (syms[i]->section->name, ".opd") != 0)
2352
0
    break;
2353
0
      opdsymend = i;
2354
2355
0
      for (; i < symcount; ++i)
2356
0
  if (((syms[i]->section->flags
2357
0
        & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)))
2358
0
      != (SEC_CODE | SEC_ALLOC))
2359
0
    break;
2360
0
      symcount = i;
2361
0
    }
2362
27
  count = 0;
2363
2364
27
  if (relocatable)
2365
23
    {
2366
23
      bool (*slurp_relocs) (bfd *, asection *, asymbol **, bool);
2367
23
      arelent *r;
2368
23
      size_t size;
2369
23
      size_t relcount;
2370
2371
23
      if (opdsymend == secsymend)
2372
23
  goto done;
2373
2374
0
      slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2375
0
      relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2376
0
      if (relcount == 0)
2377
0
  goto done;
2378
2379
0
      if (!(*slurp_relocs) (abfd, opd, static_syms, false))
2380
0
  {
2381
0
    count = -1;
2382
0
    goto done;
2383
0
  }
2384
2385
0
      size = 0;
2386
0
      for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2387
0
  {
2388
0
    asymbol *sym;
2389
2390
0
    while (r < opd->relocation + relcount
2391
0
     && r->address < syms[i]->value + opd->vma)
2392
0
      ++r;
2393
2394
0
    if (r == opd->relocation + relcount)
2395
0
      break;
2396
2397
0
    if (r->address != syms[i]->value + opd->vma)
2398
0
      continue;
2399
2400
0
    if (r->howto->type != R_PPC64_ADDR64)
2401
0
      continue;
2402
2403
0
    sym = *r->sym_ptr_ptr;
2404
0
    if (!sym_exists_at (syms, opdsymend, symcount,
2405
0
            sym->section->id, sym->value + r->addend))
2406
0
      {
2407
0
        ++count;
2408
0
        size += sizeof (asymbol);
2409
0
        size += strlen (syms[i]->name) + 2;
2410
0
      }
2411
0
  }
2412
2413
0
      if (size == 0)
2414
0
  goto done;
2415
0
      s = *ret = bfd_malloc (size);
2416
0
      if (s == NULL)
2417
0
  {
2418
0
    count = -1;
2419
0
    goto done;
2420
0
  }
2421
2422
0
      names = (char *) (s + count);
2423
2424
0
      for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2425
0
  {
2426
0
    asymbol *sym;
2427
2428
0
    while (r < opd->relocation + relcount
2429
0
     && r->address < syms[i]->value + opd->vma)
2430
0
      ++r;
2431
2432
0
    if (r == opd->relocation + relcount)
2433
0
      break;
2434
2435
0
    if (r->address != syms[i]->value + opd->vma)
2436
0
      continue;
2437
2438
0
    if (r->howto->type != R_PPC64_ADDR64)
2439
0
      continue;
2440
2441
0
    sym = *r->sym_ptr_ptr;
2442
0
    if (!sym_exists_at (syms, opdsymend, symcount,
2443
0
            sym->section->id, sym->value + r->addend))
2444
0
      {
2445
0
        size_t len;
2446
2447
0
        *s = *syms[i];
2448
0
        s->flags |= BSF_SYNTHETIC;
2449
0
        s->section = sym->section;
2450
0
        s->value = sym->value + r->addend;
2451
0
        s->name = names;
2452
0
        *names++ = '.';
2453
0
        len = strlen (syms[i]->name);
2454
0
        memcpy (names, syms[i]->name, len + 1);
2455
0
        names += len + 1;
2456
        /* Have udata.p point back to the original symbol this
2457
     synthetic symbol was derived from.  */
2458
0
        s->udata.p = syms[i];
2459
0
        s++;
2460
0
      }
2461
0
  }
2462
0
    }
2463
4
  else
2464
4
    {
2465
4
      bool (*slurp_relocs) (bfd *, asection *, asymbol **, bool);
2466
4
      bfd_byte *contents = NULL;
2467
4
      size_t size;
2468
4
      size_t plt_count = 0;
2469
4
      bfd_vma glink_vma = 0, resolv_vma = 0;
2470
4
      asection *dynamic, *glink = NULL, *relplt = NULL;
2471
4
      arelent *p;
2472
2473
4
      if (opd != NULL
2474
4
    && ((opd->flags & SEC_HAS_CONTENTS) == 0
2475
0
        || !bfd_malloc_and_get_section (abfd, opd, &contents)))
2476
0
  {
2477
0
  free_contents_and_exit_err:
2478
0
    count = -1;
2479
4
  free_contents_and_exit:
2480
4
    free (contents);
2481
4
    goto done;
2482
0
  }
2483
2484
4
      size = 0;
2485
4
      for (i = secsymend; i < opdsymend; ++i)
2486
0
  {
2487
0
    bfd_vma ent;
2488
2489
    /* Ignore bogus symbols.  */
2490
0
    if (syms[i]->value > opd->size - 8)
2491
0
      continue;
2492
2493
0
    ent = bfd_get_64 (abfd, contents + syms[i]->value);
2494
0
    if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2495
0
      {
2496
0
        ++count;
2497
0
        size += sizeof (asymbol);
2498
0
        size += strlen (syms[i]->name) + 2;
2499
0
      }
2500
0
  }
2501
2502
      /* Get start of .glink stubs from DT_PPC64_GLINK.  */
2503
4
      if (dyn_count != 0
2504
4
    && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
2505
2
  {
2506
2
    bfd_byte *dynbuf, *extdyn, *extdynend;
2507
2
    size_t extdynsize;
2508
2
    void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
2509
2510
2
    if ((dynamic->flags & SEC_HAS_CONTENTS) == 0
2511
2
        || !bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
2512
0
      goto free_contents_and_exit_err;
2513
2514
2
    extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
2515
2
    swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
2516
2517
2
    for (extdyn = dynbuf, extdynend = dynbuf + dynamic->size;
2518
2
         (size_t) (extdynend - extdyn) >= extdynsize;
2519
2
         extdyn += extdynsize)
2520
0
      {
2521
0
        Elf_Internal_Dyn dyn;
2522
0
        (*swap_dyn_in) (abfd, extdyn, &dyn);
2523
2524
0
        if (dyn.d_tag == DT_NULL)
2525
0
    break;
2526
2527
0
        if (dyn.d_tag == DT_PPC64_GLINK)
2528
0
    {
2529
      /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2530
         See comment in ppc64_elf_finish_dynamic_sections. */
2531
0
      glink_vma = dyn.d_un.d_val + 8 * 4;
2532
      /* The .glink section usually does not survive the final
2533
         link; search for the section (usually .text) where the
2534
         glink stubs now reside.  */
2535
0
      glink = bfd_sections_find_if (abfd, section_covers_vma,
2536
0
            &glink_vma);
2537
0
      break;
2538
0
    }
2539
0
      }
2540
2541
2
    free (dynbuf);
2542
2
  }
2543
2544
4
      if (glink != NULL)
2545
0
  {
2546
    /* Determine __glink trampoline by reading the relative branch
2547
       from the first glink stub.  */
2548
0
    bfd_byte buf[4];
2549
0
    unsigned int off = 0;
2550
2551
0
    while (bfd_get_section_contents (abfd, glink, buf,
2552
0
             glink_vma + off - glink->vma, 4))
2553
0
      {
2554
0
        unsigned int insn = bfd_get_32 (abfd, buf);
2555
0
        insn ^= B_DOT;
2556
0
        if ((insn & ~0x3fffffc) == 0)
2557
0
    {
2558
0
      resolv_vma
2559
0
        = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
2560
0
      break;
2561
0
    }
2562
0
        off += 4;
2563
0
        if (off > 4)
2564
0
    break;
2565
0
      }
2566
2567
0
    if (resolv_vma)
2568
0
      size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
2569
2570
0
    relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2571
0
    if (relplt != NULL)
2572
0
      {
2573
0
        slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2574
0
        if (!(*slurp_relocs) (abfd, relplt, dyn_syms, true))
2575
0
    goto free_contents_and_exit_err;
2576
2577
0
        plt_count = NUM_SHDR_ENTRIES (&elf_section_data (relplt)->this_hdr);
2578
0
        size += plt_count * sizeof (asymbol);
2579
2580
0
        p = relplt->relocation;
2581
0
        for (i = 0; i < plt_count; i++, p++)
2582
0
    {
2583
0
      size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2584
0
      if (p->addend != 0)
2585
0
        size += sizeof ("+0x") - 1 + 16;
2586
0
    }
2587
0
      }
2588
0
  }
2589
2590
4
      if (size == 0)
2591
4
  goto free_contents_and_exit;
2592
0
      s = *ret = bfd_malloc (size);
2593
0
      if (s == NULL)
2594
0
  goto free_contents_and_exit_err;
2595
2596
0
      names = (char *) (s + count + plt_count + (resolv_vma != 0));
2597
2598
0
      for (i = secsymend; i < opdsymend; ++i)
2599
0
  {
2600
0
    bfd_vma ent;
2601
2602
0
    if (syms[i]->value > opd->size - 8)
2603
0
      continue;
2604
2605
0
    ent = bfd_get_64 (abfd, contents + syms[i]->value);
2606
0
    if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2607
0
      {
2608
0
        size_t lo, hi;
2609
0
        size_t len;
2610
0
        asection *sec = abfd->sections;
2611
2612
0
        *s = *syms[i];
2613
0
        lo = codesecsym;
2614
0
        hi = codesecsymend;
2615
0
        while (lo < hi)
2616
0
    {
2617
0
      size_t mid = (lo + hi) >> 1;
2618
0
      if (syms[mid]->section->vma < ent)
2619
0
        lo = mid + 1;
2620
0
      else if (syms[mid]->section->vma > ent)
2621
0
        hi = mid;
2622
0
      else
2623
0
        {
2624
0
          sec = syms[mid]->section;
2625
0
          break;
2626
0
        }
2627
0
    }
2628
2629
0
        if (lo >= hi && lo > codesecsym)
2630
0
    sec = syms[lo - 1]->section;
2631
2632
0
        for (; sec != NULL; sec = sec->next)
2633
0
    {
2634
0
      if (sec->vma > ent)
2635
0
        break;
2636
      /* SEC_LOAD may not be set if SEC is from a separate debug
2637
         info file.  */
2638
0
      if ((sec->flags & SEC_ALLOC) == 0)
2639
0
        break;
2640
0
      if ((sec->flags & SEC_CODE) != 0)
2641
0
        s->section = sec;
2642
0
    }
2643
0
        s->flags |= BSF_SYNTHETIC;
2644
0
        s->value = ent - s->section->vma;
2645
0
        s->name = names;
2646
0
        *names++ = '.';
2647
0
        len = strlen (syms[i]->name);
2648
0
        memcpy (names, syms[i]->name, len + 1);
2649
0
        names += len + 1;
2650
        /* Have udata.p point back to the original symbol this
2651
     synthetic symbol was derived from.  */
2652
0
        s->udata.p = syms[i];
2653
0
        s++;
2654
0
      }
2655
0
  }
2656
0
      free (contents);
2657
2658
0
      if (glink != NULL && relplt != NULL)
2659
0
  {
2660
0
    if (resolv_vma)
2661
0
      {
2662
        /* Add a symbol for the main glink trampoline.  */
2663
0
        memset (s, 0, sizeof *s);
2664
0
        s->the_bfd = abfd;
2665
0
        s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
2666
0
        s->section = glink;
2667
0
        s->value = resolv_vma - glink->vma;
2668
0
        s->name = names;
2669
0
        memcpy (names, "__glink_PLTresolve",
2670
0
          sizeof ("__glink_PLTresolve"));
2671
0
        names += sizeof ("__glink_PLTresolve");
2672
0
        s++;
2673
0
        count++;
2674
0
      }
2675
2676
    /* FIXME: It would be very much nicer to put sym@plt on the
2677
       stub rather than on the glink branch table entry.  The
2678
       objdump disassembler would then use a sensible symbol
2679
       name on plt calls.  The difficulty in doing so is
2680
       a) finding the stubs, and,
2681
       b) matching stubs against plt entries, and,
2682
       c) there can be multiple stubs for a given plt entry.
2683
2684
       Solving (a) could be done by code scanning, but older
2685
       ppc64 binaries used different stubs to current code.
2686
       (b) is the tricky one since you need to known the toc
2687
       pointer for at least one function that uses a pic stub to
2688
       be able to calculate the plt address referenced.
2689
       (c) means gdb would need to set multiple breakpoints (or
2690
       find the glink branch itself) when setting breakpoints
2691
       for pending shared library loads.  */
2692
0
    p = relplt->relocation;
2693
0
    for (i = 0; i < plt_count; i++, p++)
2694
0
      {
2695
0
        size_t len;
2696
2697
0
        *s = **p->sym_ptr_ptr;
2698
        /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
2699
     we are defining a symbol, ensure one of them is set.  */
2700
0
        if ((s->flags & BSF_LOCAL) == 0)
2701
0
    s->flags |= BSF_GLOBAL;
2702
0
        s->flags |= BSF_SYNTHETIC;
2703
0
        s->section = glink;
2704
0
        s->value = glink_vma - glink->vma;
2705
0
        s->name = names;
2706
0
        s->udata.p = NULL;
2707
0
        len = strlen ((*p->sym_ptr_ptr)->name);
2708
0
        memcpy (names, (*p->sym_ptr_ptr)->name, len);
2709
0
        names += len;
2710
0
        if (p->addend != 0)
2711
0
    {
2712
0
      memcpy (names, "+0x", sizeof ("+0x") - 1);
2713
0
      names += sizeof ("+0x") - 1;
2714
0
      bfd_sprintf_vma (abfd, names, p->addend);
2715
0
      names += strlen (names);
2716
0
    }
2717
0
        memcpy (names, "@plt", sizeof ("@plt"));
2718
0
        names += sizeof ("@plt");
2719
0
        s++;
2720
0
        if (abi < 2)
2721
0
    {
2722
0
      glink_vma += 8;
2723
0
      if (i >= 0x8000)
2724
0
        glink_vma += 4;
2725
0
    }
2726
0
        else
2727
0
    glink_vma += 4;
2728
0
      }
2729
0
    count += plt_count;
2730
0
  }
2731
0
    }
2732
2733
27
 done:
2734
27
  free (syms);
2735
27
  return count;
2736
27
}
2737

2738
/* The following functions are specific to the ELF linker, while
2739
   functions above are used generally.  Those named ppc64_elf_* are
2740
   called by the main ELF linker code.  They appear in this file more
2741
   or less in the order in which they are called.  eg.
2742
   ppc64_elf_check_relocs is called early in the link process,
2743
   ppc64_elf_finish_dynamic_sections is one of the last functions
2744
   called.
2745
2746
   PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2747
   functions have both a function code symbol and a function descriptor
2748
   symbol.  A call to foo in a relocatable object file looks like:
2749
2750
   .    .text
2751
   .  x:
2752
   .    bl  .foo
2753
   .    nop
2754
2755
   The function definition in another object file might be:
2756
2757
   .    .section .opd
2758
   .  foo:  .quad .foo
2759
   .    .quad .TOC.@tocbase
2760
   .    .quad 0
2761
   .
2762
   .    .text
2763
   .  .foo: blr
2764
2765
   When the linker resolves the call during a static link, the branch
2766
   unsurprisingly just goes to .foo and the .opd information is unused.
2767
   If the function definition is in a shared library, things are a little
2768
   different:  The call goes via a plt call stub, the opd information gets
2769
   copied to the plt, and the linker patches the nop.
2770
2771
   .  x:
2772
   .    bl  .foo_stub
2773
   .    ld  2,40(1)
2774
   .
2775
   .
2776
   .  .foo_stub:
2777
   .    std 2,40(1)     # in practice, the call stub
2778
   .    addis 11,2,Lfoo@toc@ha  # is slightly optimized, but
2779
   .    addi  11,11,Lfoo@toc@l  # this is the general idea
2780
   .    ld  12,0(11)
2781
   .    ld  2,8(11)
2782
   .    mtctr 12
2783
   .    ld  11,16(11)
2784
   .    bctr
2785
   .
2786
   .    .section .plt
2787
   .  Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2788
2789
   The "reloc ()" notation is supposed to indicate that the linker emits
2790
   an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
2791
   copying.
2792
2793
   What are the difficulties here?  Well, firstly, the relocations
2794
   examined by the linker in check_relocs are against the function code
2795
   sym .foo, while the dynamic relocation in the plt is emitted against
2796
   the function descriptor symbol, foo.  Somewhere along the line, we need
2797
   to carefully copy dynamic link information from one symbol to the other.
2798
   Secondly, the generic part of the elf linker will make .foo a dynamic
2799
   symbol as is normal for most other backends.  We need foo dynamic
2800
   instead, at least for an application final link.  However, when
2801
   creating a shared library containing foo, we need to have both symbols
2802
   dynamic so that references to .foo are satisfied during the early
2803
   stages of linking.  Otherwise the linker might decide to pull in a
2804
   definition from some other object, eg. a static library.
2805
2806
   Update: As of August 2004, we support a new convention.  Function
2807
   calls may use the function descriptor symbol, ie. "bl foo".  This
2808
   behaves exactly as "bl .foo".  */
2809
2810
/* Of those relocs that might be copied as dynamic relocs, this
2811
   function selects those that must be copied when linking a shared
2812
   library or PIE, even when the symbol is local.  */
2813
2814
static int
2815
must_be_dyn_reloc (struct bfd_link_info *info,
2816
       enum elf_ppc64_reloc_type r_type)
2817
0
{
2818
0
  switch (r_type)
2819
0
    {
2820
0
    default:
2821
      /* Only relative relocs can be resolved when the object load
2822
   address isn't fixed.  DTPREL64 is excluded because the
2823
   dynamic linker needs to differentiate global dynamic from
2824
   local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
2825
0
      return 1;
2826
2827
0
    case R_PPC64_REL32:
2828
0
    case R_PPC64_REL64:
2829
0
    case R_PPC64_REL30:
2830
0
    case R_PPC64_TOC16:
2831
0
    case R_PPC64_TOC16_DS:
2832
0
    case R_PPC64_TOC16_LO:
2833
0
    case R_PPC64_TOC16_HI:
2834
0
    case R_PPC64_TOC16_HA:
2835
0
    case R_PPC64_TOC16_LO_DS:
2836
0
      return 0;
2837
2838
0
    case R_PPC64_TPREL16:
2839
0
    case R_PPC64_TPREL16_LO:
2840
0
    case R_PPC64_TPREL16_HI:
2841
0
    case R_PPC64_TPREL16_HA:
2842
0
    case R_PPC64_TPREL16_DS:
2843
0
    case R_PPC64_TPREL16_LO_DS:
2844
0
    case R_PPC64_TPREL16_HIGH:
2845
0
    case R_PPC64_TPREL16_HIGHA:
2846
0
    case R_PPC64_TPREL16_HIGHER:
2847
0
    case R_PPC64_TPREL16_HIGHERA:
2848
0
    case R_PPC64_TPREL16_HIGHEST:
2849
0
    case R_PPC64_TPREL16_HIGHESTA:
2850
0
    case R_PPC64_TPREL64:
2851
0
    case R_PPC64_TPREL34:
2852
      /* These relocations are relative but in a shared library the
2853
   linker doesn't know the thread pointer base.  */
2854
0
      return bfd_link_dll (info);
2855
0
    }
2856
0
}
2857
2858
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2859
   copying dynamic variables from a shared lib into an app's .dynbss
2860
   section, and instead use a dynamic relocation to point into the
2861
   shared lib.  With code that gcc generates it is vital that this be
2862
   enabled;  In the PowerPC64 ELFv1 ABI the address of a function is
2863
   actually the address of a function descriptor which resides in the
2864
   .opd section.  gcc uses the descriptor directly rather than going
2865
   via the GOT as some other ABIs do, which means that initialized
2866
   function pointers reference the descriptor.  Thus, a function
2867
   pointer initialized to the address of a function in a shared
2868
   library will either require a .dynbss copy and a copy reloc, or a
2869
   dynamic reloc.  Using a .dynbss copy redefines the function
2870
   descriptor symbol to point to the copy.  This presents a problem as
2871
   a PLT entry for that function is also initialized from the function
2872
   descriptor symbol and the copy may not be initialized first.  */
2873
0
#define ELIMINATE_COPY_RELOCS 1
2874
2875
/* Section name for stubs is the associated section name plus this
2876
   string.  */
2877
0
#define STUB_SUFFIX ".stub"
2878
2879
/* Linker stubs.
2880
   ppc_stub_long_branch:
2881
   Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2882
   destination, but a 24 bit branch in a stub section will reach.
2883
   .  b dest
2884
2885
   ppc_stub_plt_branch:
2886
   Similar to the above, but a 24 bit branch in the stub section won't
2887
   reach its destination.
2888
   .  addis %r12,%r2,xxx@toc@ha
2889
   .  ld  %r12,xxx@toc@l(%r12)
2890
   .  mtctr %r12
2891
   .  bctr
2892
2893
   ppc_stub_plt_call:
2894
   Used to call a function in a shared library.  If it so happens that
2895
   the plt entry referenced crosses a 64k boundary, then an extra
2896
   "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2897
   An r2save variant starts with "std %r2,40(%r1)".
2898
   .  addis %r11,%r2,xxx@toc@ha
2899
   .  ld  %r12,xxx+0@toc@l(%r11)
2900
   .  mtctr %r12
2901
   .  ld  %r2,xxx+8@toc@l(%r11)
2902
   .  ld  %r11,xxx+16@toc@l(%r11)
2903
   .  bctr
2904
2905
   ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2906
   code to adjust the value and save r2 to support multiple toc sections.
2907
   A ppc_stub_long_branch with an r2 offset looks like:
2908
   .  std %r2,40(%r1)
2909
   .  addis %r2,%r2,off@ha
2910
   .  addi  %r2,%r2,off@l
2911
   .  b dest
2912
2913
   A ppc_stub_plt_branch with an r2 offset looks like:
2914
   .  std %r2,40(%r1)
2915
   .  addis %r12,%r2,xxx@toc@ha
2916
   .  ld  %r12,xxx@toc@l(%r12)
2917
   .  addis %r2,%r2,off@ha
2918
   .  addi  %r2,%r2,off@l
2919
   .  mtctr %r12
2920
   .  bctr
2921
2922
   All of the above stubs are shown as their ELFv1 variants.  ELFv2
2923
   variants exist too, simpler for plt calls since a new toc pointer
2924
   and static chain are not loaded by the stub.  In addition, ELFv2
2925
   has some more complex stubs to handle calls marked with NOTOC
2926
   relocs from functions where r2 is not a valid toc pointer.
2927
   ppc_stub_long_branch_p9notoc:
2928
   .  mflr  %r12
2929
   .  bcl 20,31,1f
2930
   .  1:
2931
   .  mflr  %r11
2932
   .  mtlr  %r12
2933
   .  addis %r12,%r11,dest-1b@ha
2934
   .  addi  %r12,%r12,dest-1b@l
2935
   .  b dest
2936
2937
   ppc_stub_plt_branch_p9notoc:
2938
   .  mflr  %r12
2939
   .  bcl 20,31,1f
2940
   .  1:
2941
   .  mflr  %r11
2942
   .  mtlr  %r12
2943
   .  lis %r12,xxx-1b@highest
2944
   .  ori %r12,%r12,xxx-1b@higher
2945
   .  sldi  %r12,%r12,32
2946
   .  oris  %r12,%r12,xxx-1b@high
2947
   .  ori %r12,%r12,xxx-1b@l
2948
   .  add %r12,%r11,%r12
2949
   .  mtctr %r12
2950
   .  bctr
2951
2952
   ppc_stub_plt_call_p9notoc:
2953
   .  mflr  %r12
2954
   .  bcl 20,31,1f
2955
   .  1:
2956
   .  mflr  %r11
2957
   .  mtlr  %r12
2958
   .  lis %r12,xxx-1b@highest
2959
   .  ori %r12,%r12,xxx-1b@higher
2960
   .  sldi  %r12,%r12,32
2961
   .  oris  %r12,%r12,xxx-1b@high
2962
   .  ori %r12,%r12,xxx-1b@l
2963
   .  ldx %r12,%r11,%r12
2964
   .  mtctr %r12
2965
   .  bctr
2966
2967
   There are also ELFv1 power10 variants of these stubs.
2968
   ppc_stub_long_branch_notoc:
2969
   .  pla %r12,dest@pcrel
2970
   .  b dest
2971
   ppc_stub_plt_branch_notoc:
2972
   .  lis %r11,(dest-1f)@highesta34
2973
   .  ori %r11,%r11,(dest-1f)@highera34
2974
   .  sldi  %r11,%r11,34
2975
   . 1: pla %r12,dest@pcrel
2976
   .  add %r12,%r11,%r12
2977
   .  mtctr %r12
2978
   .  bctr
2979
   ppc_stub_plt_call_notoc:
2980
   .  lis %r11,(xxx-1f)@highesta34
2981
   .  ori %r11,%r11,(xxx-1f)@highera34
2982
   .  sldi  %r11,%r11,34
2983
   . 1: pla %r12,xxx@pcrel
2984
   .  ldx %r12,%r11,%r12
2985
   .  mtctr %r12
2986
   .  bctr
2987
2988
   In cases where the high instructions would add zero, they are
2989
   omitted and following instructions modified in some cases.
2990
   For example, a power10 ppc_stub_plt_call_notoc might simplify down
2991
   to
2992
   .  pld %r12,xxx@pcrel
2993
   .  mtctr %r12
2994
   .  bctr
2995
2996
   Stub variants may be merged.  For example, if printf is called from
2997
   code with the tocsave optimization (ie. r2 saved in function
2998
   prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2999
   and from other code without the tocsave optimization requiring a
3000
   ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
3001
   type will be created.  Calls with the tocsave optimization will
3002
   enter this stub after the instruction saving r2.  A similar
3003
   situation exists when calls are marked with R_PPC64_REL24_NOTOC
3004
   relocations.  These require a ppc_stub_plt_call_notoc linkage stub
3005
   to call an external function like printf.  If other calls to printf
3006
   require a ppc_stub_plt_call linkage stub then a single
3007
   ppc_stub_plt_call_notoc linkage stub may be used for both types of
3008
   call.  */
3009
3010
enum ppc_stub_main_type
3011
{
3012
  ppc_stub_none,
3013
  ppc_stub_long_branch,
3014
  ppc_stub_plt_branch,
3015
  ppc_stub_plt_call,
3016
  ppc_stub_global_entry,
3017
  ppc_stub_save_res
3018
};
3019
3020
/* ppc_stub_long_branch, ppc_stub_plt_branch and ppc_stub_plt_call have
3021
   these variations.  */
3022
3023
enum ppc_stub_sub_type
3024
{
3025
  ppc_stub_toc,
3026
  ppc_stub_notoc,
3027
  ppc_stub_p9notoc
3028
};
3029
3030
struct ppc_stub_type
3031
{
3032
  ENUM_BITFIELD (ppc_stub_main_type) main : 3;
3033
  ENUM_BITFIELD (ppc_stub_sub_type) sub : 2;
3034
  unsigned int r2save : 1;
3035
};
3036
3037
/* Information on stub grouping.  */
3038
struct map_stub
3039
{
3040
  /* The stub section.  */
3041
  asection *stub_sec;
3042
  /* This is the section to which stubs in the group will be attached.  */
3043
  asection *link_sec;
3044
  /* Next group.  */
3045
  struct map_stub *next;
3046
  /* Whether to emit a copy of register save/restore functions in this
3047
     group.  */
3048
  int needs_save_res;
3049
  /* Current offset within stubs after the insn restoring lr in a
3050
     _notoc or _both stub using bcl for pc-relative addressing, or
3051
     after the insn restoring lr in a __tls_get_addr_opt plt stub.  */
3052
  unsigned int lr_restore;
3053
  /* Accumulated size of EH info emitted to describe return address
3054
     if stubs modify lr.  Does not include 17 byte FDE header.  */
3055
  unsigned int eh_size;
3056
  /* Offset in glink_eh_frame to the start of EH info for this group.  */
3057
  unsigned int eh_base;
3058
};
3059
3060
struct ppc_stub_hash_entry
3061
{
3062
  /* Base hash table entry structure.  */
3063
  struct bfd_hash_entry root;
3064
3065
  struct ppc_stub_type type;
3066
3067
  /* Group information.  */
3068
  struct map_stub *group;
3069
3070
  /* Offset within stub_sec of the beginning of this stub.  */
3071
  bfd_vma stub_offset;
3072
3073
  /* Given the symbol's value and its section we can determine its final
3074
     value when building the stubs (so the stub knows where to jump.  */
3075
  bfd_vma target_value;
3076
  asection *target_section;
3077
3078
  /* The symbol table entry, if any, that this was derived from.  */
3079
  struct ppc_link_hash_entry *h;
3080
  struct plt_entry *plt_ent;
3081
3082
  /* Symbol type.  */
3083
  unsigned char symtype;
3084
3085
  /* Symbol st_other.  */
3086
  unsigned char other;
3087
3088
  /* Debug: Track hash table traversal.  */
3089
  unsigned int id;
3090
};
3091
3092
struct ppc_branch_hash_entry
3093
{
3094
  /* Base hash table entry structure.  */
3095
  struct bfd_hash_entry root;
3096
3097
  /* Offset within branch lookup table.  */
3098
  unsigned int offset;
3099
3100
  /* Generation marker.  */
3101
  unsigned int iter;
3102
};
3103
3104
/* Used to track dynamic relocations.  */
3105
struct ppc_dyn_relocs
3106
{
3107
  struct ppc_dyn_relocs *next;
3108
3109
  /* The input section of the reloc.  */
3110
  asection *sec;
3111
3112
  /* Total number of relocs copied for the input section.  */
3113
  unsigned int count;
3114
3115
  /* Number of pc-relative relocs copied for the input section.  */
3116
  unsigned int pc_count;
3117
3118
  /* Number of relocs that might become R_PPC64_RELATIVE.  */
3119
  unsigned int rel_count;
3120
};
3121
3122
struct ppc_local_dyn_relocs
3123
{
3124
  struct ppc_local_dyn_relocs *next;
3125
3126
  /* The input section of the reloc.  */
3127
  asection *sec;
3128
3129
  /* Total number of relocs copied for the input section.  */
3130
  unsigned int count;
3131
3132
  /* Number of relocs that might become R_PPC64_RELATIVE.  */
3133
  unsigned int rel_count : 31;
3134
3135
  /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3136
  unsigned int ifunc : 1;
3137
};
3138
3139
struct ppc_link_hash_entry
3140
{
3141
  struct elf_link_hash_entry elf;
3142
3143
  union
3144
  {
3145
    /* A pointer to the most recently used stub hash entry against this
3146
       symbol.  */
3147
    struct ppc_stub_hash_entry *stub_cache;
3148
3149
    /* A pointer to the next symbol starting with a '.'  */
3150
    struct ppc_link_hash_entry *next_dot_sym;
3151
  } u;
3152
3153
  /* Link between function code and descriptor symbols.  */
3154
  struct ppc_link_hash_entry *oh;
3155
3156
  /* Flag function code and descriptor symbols.  */
3157
  unsigned int is_func:1;
3158
  unsigned int is_func_descriptor:1;
3159
  unsigned int fake:1;
3160
3161
  /* Whether global opd/toc sym has been adjusted or not.
3162
     After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3163
     should be set for all globals defined in any opd/toc section.  */
3164
  unsigned int adjust_done:1;
3165
3166
  /* Set if this is an out-of-line register save/restore function,
3167
     with non-standard calling convention.  */
3168
  unsigned int save_res:1;
3169
3170
  /* Set if a duplicate symbol with non-zero localentry is detected,
3171
     even when the duplicate symbol does not provide a definition.  */
3172
  unsigned int non_zero_localentry:1;
3173
3174
  /* Contexts in which symbol is used in the GOT (or TOC).
3175
     Bits are or'd into the mask as the corresponding relocs are
3176
     encountered during check_relocs, with TLS_TLS being set when any
3177
     of the other TLS bits are set.  tls_optimize clears bits when
3178
     optimizing to indicate the corresponding GOT entry type is not
3179
     needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
3180
     set TLS_GDIE when a GD reloc turns into an IE one.
3181
     These flags are also kept for local symbols.  */
3182
0
#define TLS_TLS    1  /* Any TLS reloc.  */
3183
0
#define TLS_GD     2  /* GD reloc. */
3184
0
#define TLS_LD     4  /* LD reloc. */
3185
0
#define TLS_TPREL  8  /* TPREL reloc, => IE. */
3186
0
#define TLS_DTPREL  16  /* DTPREL reloc, => LD. */
3187
0
#define TLS_MARK  32  /* __tls_get_addr call marked. */
3188
0
#define TLS_GDIE  64  /* GOT TPREL reloc resulting from GD->IE. */
3189
0
#define TLS_EXPLICIT   256  /* TOC section TLS reloc, not stored. */
3190
  unsigned char tls_mask;
3191
3192
  /* The above field is also used to mark function symbols.  In which
3193
     case TLS_TLS will be 0.  */
3194
0
#define PLT_IFUNC  2  /* STT_GNU_IFUNC.  */
3195
0
#define PLT_KEEP   4  /* inline plt call requires plt entry.  */
3196
0
#define NON_GOT        256  /* local symbol plt, not stored.  */
3197
};
3198
3199
static inline struct ppc_link_hash_entry *
3200
ppc_elf_hash_entry (struct elf_link_hash_entry *ent)
3201
0
{
3202
0
  return (struct ppc_link_hash_entry *) ent;
3203
0
}
3204
3205
static inline struct elf_link_hash_entry *
3206
elf_hash_entry (struct ppc_link_hash_entry *ent)
3207
0
{
3208
0
  return (struct elf_link_hash_entry *) ent;
3209
0
}
3210
3211
/* ppc64 ELF linker hash table.  */
3212
3213
struct ppc_link_hash_table
3214
{
3215
  struct elf_link_hash_table elf;
3216
3217
  /* The stub hash table.  */
3218
  struct bfd_hash_table stub_hash_table;
3219
3220
  /* Another hash table for plt_branch stubs.  */
3221
  struct bfd_hash_table branch_hash_table;
3222
3223
  /* Hash table for function prologue tocsave.  */
3224
  htab_t tocsave_htab;
3225
3226
  /* Various options and other info passed from the linker.  */
3227
  struct ppc64_elf_params *params;
3228
3229
  /* The size of sec_info below.  */
3230
  unsigned int sec_info_arr_size;
3231
3232
  /* Per-section array of extra section info.  Done this way rather
3233
     than as part of ppc64_elf_section_data so we have the info for
3234
     non-ppc64 sections.  */
3235
  struct
3236
  {
3237
    /* Along with elf_gp, specifies the TOC pointer used by this section.  */
3238
    bfd_vma toc_off;
3239
3240
    union
3241
    {
3242
      /* The section group that this section belongs to.  */
3243
      struct map_stub *group;
3244
      /* A temp section list pointer.  */
3245
      asection *list;
3246
    } u;
3247
  } *sec_info;
3248
3249
  /* Linked list of groups.  */
3250
  struct map_stub *group;
3251
3252
  /* Temp used when calculating TOC pointers.  */
3253
  bfd_vma toc_curr;
3254
  bfd *toc_bfd;
3255
  asection *toc_first_sec;
3256
3257
  /* Used when adding symbols.  */
3258
  struct ppc_link_hash_entry *dot_syms;
3259
3260
  /* Shortcuts to get to dynamic linker sections.  */
3261
  asection *glink;
3262
  asection *global_entry;
3263
  asection *sfpr;
3264
  asection *pltlocal;
3265
  asection *relpltlocal;
3266
  asection *brlt;
3267
  asection *relbrlt;
3268
  asection *glink_eh_frame;
3269
3270
  /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3271
  struct ppc_link_hash_entry *tls_get_addr;
3272
  struct ppc_link_hash_entry *tls_get_addr_fd;
3273
  struct ppc_link_hash_entry *tga_desc;
3274
  struct ppc_link_hash_entry *tga_desc_fd;
3275
  struct map_stub *tga_group;
3276
3277
  /* The size of reliplt used by got entry relocs.  */
3278
  bfd_size_type got_reli_size;
3279
3280
  /* DT_RELR array of section/r_offset.  */
3281
  size_t relr_alloc;
3282
  size_t relr_count;
3283
  struct
3284
  {
3285
    asection *sec;
3286
    bfd_vma off;
3287
  } *relr;
3288
3289
  /* Statistics.  */
3290
  unsigned long stub_count[ppc_stub_save_res];
3291
3292
  /* Number of stubs against global syms.  */
3293
  unsigned long stub_globals;
3294
3295
  /* Set if we're linking code with function descriptors.  */
3296
  unsigned int opd_abi:1;
3297
3298
  /* Support for multiple toc sections.  */
3299
  unsigned int do_multi_toc:1;
3300
  unsigned int multi_toc_needed:1;
3301
  unsigned int second_toc_pass:1;
3302
  unsigned int do_toc_opt:1;
3303
3304
  /* Set if tls optimization is enabled.  */
3305
  unsigned int do_tls_opt:1;
3306
3307
  /* Set if inline plt calls should be converted to direct calls.  */
3308
  unsigned int can_convert_all_inline_plt:1;
3309
3310
  /* Set if a stub_offset changed.  */
3311
  unsigned int stub_changed:1;
3312
3313
  /* Set on error.  */
3314
  unsigned int stub_error:1;
3315
3316
  /* Whether func_desc_adjust needs to be run over symbols.  */
3317
  unsigned int need_func_desc_adj:1;
3318
3319
  /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
3320
  unsigned int has_plt_localentry0:1;
3321
3322
  /* Whether calls are made via the PLT from NOTOC functions.  */
3323
  unsigned int notoc_plt:1;
3324
3325
  /* Whether any code linked seems to be Power10.  */
3326
  unsigned int has_power10_relocs:1;
3327
3328
  /* Incremented once for each stub sized.  */
3329
  unsigned int stub_id;
3330
3331
  /* Incremented every time we size stubs.  */
3332
  unsigned int stub_iteration;
3333
3334
/* After 20 iterations of stub sizing we no longer allow stubs to
3335
   shrink.  This is to break out of a pathological case where adding
3336
   stubs or increasing their size on one iteration decreases section
3337
   gaps (perhaps due to alignment), which then results in smaller
3338
   stubs on the next iteration.  */
3339
0
#define STUB_SHRINK_ITER 20
3340
};
3341
3342
/* Rename some of the generic section flags to better document how they
3343
   are used here.  */
3344
3345
/* Nonzero if this section has TLS related relocations.  */
3346
0
#define has_tls_reloc sec_flg0
3347
3348
/* Nonzero if this section has a call to __tls_get_addr lacking marker
3349
   relocations.  */
3350
0
#define nomark_tls_get_addr sec_flg1
3351
3352
/* Nonzero if this section has any toc or got relocs.  */
3353
0
#define has_toc_reloc sec_flg2
3354
3355
/* Nonzero if this section has a call to another section that uses
3356
   the toc or got.  */
3357
0
#define makes_toc_func_call sec_flg3
3358
3359
/* Recursion protection when determining above flag.  */
3360
0
#define call_check_in_progress sec_flg4
3361
0
#define call_check_done sec_flg5
3362
3363
/* Get the ppc64 ELF linker hash table from a link_info structure.  */
3364
3365
#define ppc_hash_table(p) \
3366
0
  ((is_elf_hash_table ((p)->hash)          \
3367
0
    && elf_hash_table_id (elf_hash_table (p)) == PPC64_ELF_DATA) \
3368
0
   ? (struct ppc_link_hash_table *) (p)->hash : NULL)
3369
3370
#define ppc_stub_hash_lookup(table, string, create, copy) \
3371
0
  ((struct ppc_stub_hash_entry *) \
3372
0
   bfd_hash_lookup ((table), (string), (create), (copy)))
3373
3374
#define ppc_branch_hash_lookup(table, string, create, copy) \
3375
0
  ((struct ppc_branch_hash_entry *) \
3376
0
   bfd_hash_lookup ((table), (string), (create), (copy)))
3377
3378
/* Create an entry in the stub hash table.  */
3379
3380
static struct bfd_hash_entry *
3381
stub_hash_newfunc (struct bfd_hash_entry *entry,
3382
       struct bfd_hash_table *table,
3383
       const char *string)
3384
0
{
3385
  /* Allocate the structure if it has not already been allocated by a
3386
     subclass.  */
3387
0
  if (entry == NULL)
3388
0
    {
3389
0
      entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3390
0
      if (entry == NULL)
3391
0
  return entry;
3392
0
    }
3393
3394
  /* Call the allocation method of the superclass.  */
3395
0
  entry = bfd_hash_newfunc (entry, table, string);
3396
0
  if (entry != NULL)
3397
0
    {
3398
0
      struct ppc_stub_hash_entry *eh;
3399
3400
      /* Initialize the local fields.  */
3401
0
      eh = (struct ppc_stub_hash_entry *) entry;
3402
0
      eh->type.main = ppc_stub_none;
3403
0
      eh->type.sub = ppc_stub_toc;
3404
0
      eh->type.r2save = 0;
3405
0
      eh->group = NULL;
3406
0
      eh->stub_offset = 0;
3407
0
      eh->target_value = 0;
3408
0
      eh->target_section = NULL;
3409
0
      eh->h = NULL;
3410
0
      eh->plt_ent = NULL;
3411
0
      eh->symtype = 0;
3412
0
      eh->other = 0;
3413
0
      eh->id = 0;
3414
0
    }
3415
3416
0
  return entry;
3417
0
}
3418
3419
/* Create an entry in the branch hash table.  */
3420
3421
static struct bfd_hash_entry *
3422
branch_hash_newfunc (struct bfd_hash_entry *entry,
3423
         struct bfd_hash_table *table,
3424
         const char *string)
3425
0
{
3426
  /* Allocate the structure if it has not already been allocated by a
3427
     subclass.  */
3428
0
  if (entry == NULL)
3429
0
    {
3430
0
      entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3431
0
      if (entry == NULL)
3432
0
  return entry;
3433
0
    }
3434
3435
  /* Call the allocation method of the superclass.  */
3436
0
  entry = bfd_hash_newfunc (entry, table, string);
3437
0
  if (entry != NULL)
3438
0
    {
3439
0
      struct ppc_branch_hash_entry *eh;
3440
3441
      /* Initialize the local fields.  */
3442
0
      eh = (struct ppc_branch_hash_entry *) entry;
3443
0
      eh->offset = 0;
3444
0
      eh->iter = 0;
3445
0
    }
3446
3447
0
  return entry;
3448
0
}
3449
3450
/* Create an entry in a ppc64 ELF linker hash table.  */
3451
3452
static struct bfd_hash_entry *
3453
link_hash_newfunc (struct bfd_hash_entry *entry,
3454
       struct bfd_hash_table *table,
3455
       const char *string)
3456
0
{
3457
  /* Allocate the structure if it has not already been allocated by a
3458
     subclass.  */
3459
0
  if (entry == NULL)
3460
0
    {
3461
0
      entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3462
0
      if (entry == NULL)
3463
0
  return entry;
3464
0
    }
3465
3466
  /* Call the allocation method of the superclass.  */
3467
0
  entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3468
0
  if (entry != NULL)
3469
0
    {
3470
0
      struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3471
3472
0
      memset (&eh->u.stub_cache, 0,
3473
0
        (sizeof (struct ppc_link_hash_entry)
3474
0
         - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3475
3476
      /* When making function calls, old ABI code references function entry
3477
   points (dot symbols), while new ABI code references the function
3478
   descriptor symbol.  We need to make any combination of reference and
3479
   definition work together, without breaking archive linking.
3480
3481
   For a defined function "foo" and an undefined call to "bar":
3482
   An old object defines "foo" and ".foo", references ".bar" (possibly
3483
   "bar" too).
3484
   A new object defines "foo" and references "bar".
3485
3486
   A new object thus has no problem with its undefined symbols being
3487
   satisfied by definitions in an old object.  On the other hand, the
3488
   old object won't have ".bar" satisfied by a new object.
3489
3490
   Keep a list of newly added dot-symbols.  */
3491
3492
0
      if (string[0] == '.')
3493
0
  {
3494
0
    struct ppc_link_hash_table *htab;
3495
3496
0
    htab = (struct ppc_link_hash_table *) table;
3497
0
    eh->u.next_dot_sym = htab->dot_syms;
3498
0
    htab->dot_syms = eh;
3499
0
  }
3500
0
    }
3501
3502
0
  return entry;
3503
0
}
3504
3505
struct tocsave_entry
3506
{
3507
  asection *sec;
3508
  bfd_vma offset;
3509
};
3510
3511
static hashval_t
3512
tocsave_htab_hash (const void *p)
3513
0
{
3514
0
  const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3515
0
  return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
3516
0
}
3517
3518
static int
3519
tocsave_htab_eq (const void *p1, const void *p2)
3520
0
{
3521
0
  const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3522
0
  const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3523
0
  return e1->sec == e2->sec && e1->offset == e2->offset;
3524
0
}
3525
3526
/* Destroy a ppc64 ELF linker hash table.  */
3527
3528
static void
3529
ppc64_elf_link_hash_table_free (bfd *obfd)
3530
0
{
3531
0
  struct ppc_link_hash_table *htab;
3532
3533
0
  htab = (struct ppc_link_hash_table *) obfd->link.hash;
3534
0
  if (htab->tocsave_htab)
3535
0
    htab_delete (htab->tocsave_htab);
3536
0
  bfd_hash_table_free (&htab->branch_hash_table);
3537
0
  bfd_hash_table_free (&htab->stub_hash_table);
3538
0
  _bfd_elf_link_hash_table_free (obfd);
3539
0
}
3540
3541
/* Create a ppc64 ELF linker hash table.  */
3542
3543
static struct bfd_link_hash_table *
3544
ppc64_elf_link_hash_table_create (bfd *abfd)
3545
0
{
3546
0
  struct ppc_link_hash_table *htab;
3547
0
  size_t amt = sizeof (struct ppc_link_hash_table);
3548
3549
0
  htab = bfd_zmalloc (amt);
3550
0
  if (htab == NULL)
3551
0
    return NULL;
3552
3553
0
  if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3554
0
              sizeof (struct ppc_link_hash_entry),
3555
0
              PPC64_ELF_DATA))
3556
0
    {
3557
0
      free (htab);
3558
0
      return NULL;
3559
0
    }
3560
3561
  /* Init the stub hash table too.  */
3562
0
  if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3563
0
          sizeof (struct ppc_stub_hash_entry)))
3564
0
    {
3565
0
      _bfd_elf_link_hash_table_free (abfd);
3566
0
      return NULL;
3567
0
    }
3568
3569
  /* And the branch hash table.  */
3570
0
  if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3571
0
          sizeof (struct ppc_branch_hash_entry)))
3572
0
    {
3573
0
      bfd_hash_table_free (&htab->stub_hash_table);
3574
0
      _bfd_elf_link_hash_table_free (abfd);
3575
0
      return NULL;
3576
0
    }
3577
3578
0
  htab->tocsave_htab = htab_try_create (1024,
3579
0
          tocsave_htab_hash,
3580
0
          tocsave_htab_eq,
3581
0
          NULL);
3582
0
  if (htab->tocsave_htab == NULL)
3583
0
    {
3584
0
      ppc64_elf_link_hash_table_free (abfd);
3585
0
      return NULL;
3586
0
    }
3587
0
  htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
3588
3589
  /* Initializing two fields of the union is just cosmetic.  We really
3590
     only care about glist, but when compiled on a 32-bit host the
3591
     bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3592
     debugger inspection of these fields look nicer.  */
3593
0
  htab->elf.init_got_refcount.refcount = 0;
3594
0
  htab->elf.init_got_refcount.glist = NULL;
3595
0
  htab->elf.init_plt_refcount.refcount = 0;
3596
0
  htab->elf.init_plt_refcount.glist = NULL;
3597
0
  htab->elf.init_got_offset.offset = 0;
3598
0
  htab->elf.init_got_offset.glist = NULL;
3599
0
  htab->elf.init_plt_offset.offset = 0;
3600
0
  htab->elf.init_plt_offset.glist = NULL;
3601
3602
0
  return &htab->elf.root;
3603
0
}
3604
3605
/* Create sections for linker generated code.  */
3606
3607
static bool
3608
create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3609
0
{
3610
0
  struct ppc_link_hash_table *htab;
3611
0
  flagword flags;
3612
3613
0
  htab = ppc_hash_table (info);
3614
3615
0
  flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3616
0
     | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3617
0
  if (htab->params->save_restore_funcs)
3618
0
    {
3619
      /* Create .sfpr for code to save and restore fp regs.  */
3620
0
      htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
3621
0
                   flags);
3622
0
      if (htab->sfpr == NULL
3623
0
    || !bfd_set_section_alignment (htab->sfpr, 2))
3624
0
  return false;
3625
0
    }
3626
3627
0
  if (bfd_link_relocatable (info))
3628
0
    return true;
3629
3630
  /* Create .glink for lazy dynamic linking support.  */
3631
0
  htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3632
0
                flags);
3633
0
  if (htab->glink == NULL
3634
0
      || !bfd_set_section_alignment (htab->glink, 3))
3635
0
    return false;
3636
3637
  /* The part of .glink used by global entry stubs, separate so that
3638
     it can be aligned appropriately without affecting htab->glink.  */
3639
0
  htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3640
0
                 flags);
3641
0
  if (htab->global_entry == NULL
3642
0
      || !bfd_set_section_alignment (htab->global_entry, 2))
3643
0
    return false;
3644
3645
0
  if (!info->no_ld_generated_unwind_info)
3646
0
    {
3647
0
      flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
3648
0
         | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3649
0
      htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
3650
0
                 ".eh_frame",
3651
0
                 flags);
3652
0
      if (htab->glink_eh_frame == NULL
3653
0
    || !bfd_set_section_alignment (htab->glink_eh_frame, 2))
3654
0
  return false;
3655
0
    }
3656
3657
0
  flags = SEC_ALLOC | SEC_LINKER_CREATED;
3658
0
  htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
3659
0
  if (htab->elf.iplt == NULL
3660
0
      || !bfd_set_section_alignment (htab->elf.iplt, 3))
3661
0
    return false;
3662
3663
0
  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3664
0
     | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3665
0
  htab->elf.irelplt
3666
0
    = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
3667
0
  if (htab->elf.irelplt == NULL
3668
0
      || !bfd_set_section_alignment (htab->elf.irelplt, 3))
3669
0
    return false;
3670
3671
  /* Create branch lookup table for plt_branch stubs.  */
3672
0
  flags = (SEC_ALLOC | SEC_LOAD
3673
0
     | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3674
0
  htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
3675
0
               flags);
3676
0
  if (htab->brlt == NULL
3677
0
      || !bfd_set_section_alignment (htab->brlt, 3))
3678
0
    return false;
3679
3680
  /* Local plt entries, put in .branch_lt but a separate section for
3681
     convenience.  */
3682
0
  htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
3683
0
                   flags);
3684
0
  if (htab->pltlocal == NULL
3685
0
      || !bfd_set_section_alignment (htab->pltlocal, 3))
3686
0
    return false;
3687
3688
0
  if (!bfd_link_pic (info))
3689
0
    return true;
3690
3691
0
  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3692
0
     | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3693
0
  htab->relbrlt
3694
0
    = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
3695
0
  if (htab->relbrlt == NULL
3696
0
      || !bfd_set_section_alignment (htab->relbrlt, 3))
3697
0
    return false;
3698
3699
0
  htab->relpltlocal
3700
0
    = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
3701
0
  if (htab->relpltlocal == NULL
3702
0
      || !bfd_set_section_alignment (htab->relpltlocal, 3))
3703
0
    return false;
3704
3705
0
  return true;
3706
0
}
3707
3708
/* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3709
3710
bool
3711
ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
3712
       struct ppc64_elf_params *params)
3713
0
{
3714
0
  struct ppc_link_hash_table *htab;
3715
3716
0
  elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
3717
3718
/* Always hook our dynamic sections into the first bfd, which is the
3719
   linker created stub bfd.  This ensures that the GOT header is at
3720
   the start of the output TOC section.  */
3721
0
  htab = ppc_hash_table (info);
3722
0
  htab->elf.dynobj = params->stub_bfd;
3723
0
  htab->params = params;
3724
3725
0
  return create_linkage_sections (htab->elf.dynobj, info);
3726
0
}
3727
3728
/* Build a name for an entry in the stub hash table.  */
3729
3730
static char *
3731
ppc_stub_name (const asection *input_section,
3732
         const asection *sym_sec,
3733
         const struct ppc_link_hash_entry *h,
3734
         const Elf_Internal_Rela *rel)
3735
0
{
3736
0
  char *stub_name;
3737
0
  ssize_t len;
3738
3739
  /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3740
     offsets from a sym as a branch target?  In fact, we could
3741
     probably assume the addend is always zero.  */
3742
0
  BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3743
3744
0
  if (h)
3745
0
    {
3746
0
      len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3747
0
      stub_name = bfd_malloc (len);
3748
0
      if (stub_name == NULL)
3749
0
  return stub_name;
3750
3751
0
      len = sprintf (stub_name, "%08x.%s+%x",
3752
0
         input_section->id & 0xffffffff,
3753
0
         h->elf.root.root.string,
3754
0
         (int) rel->r_addend & 0xffffffff);
3755
0
    }
3756
0
  else
3757
0
    {
3758
0
      len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3759
0
      stub_name = bfd_malloc (len);
3760
0
      if (stub_name == NULL)
3761
0
  return stub_name;
3762
3763
0
      len = sprintf (stub_name, "%08x.%x:%x+%x",
3764
0
         input_section->id & 0xffffffff,
3765
0
         sym_sec->id & 0xffffffff,
3766
0
         (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3767
0
         (int) rel->r_addend & 0xffffffff);
3768
0
    }
3769
0
  if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3770
0
    stub_name[len - 2] = 0;
3771
0
  return stub_name;
3772
0
}
3773
3774
/* If mixing power10 with non-power10 code and --power10-stubs is not
3775
   specified (or is auto) then there may be multiple stub types for any
3776
   given symbol.  Up to three classes of stubs are stored in separate
3777
   stub_hash_table entries having the same key string.  The entries
3778
   will always be adjacent on entry->root.next chain, even if hash
3779
   table resizing occurs.  This function selects the correct entry to
3780
   use.  */
3781
3782
static struct ppc_stub_hash_entry *
3783
select_alt_stub (struct ppc_stub_hash_entry *entry,
3784
     enum elf_ppc64_reloc_type r_type)
3785
0
{
3786
0
  enum ppc_stub_sub_type subt;
3787
3788
0
  switch (r_type)
3789
0
    {
3790
0
    case R_PPC64_REL24_NOTOC:
3791
0
      subt = ppc_stub_notoc;
3792
0
      break;
3793
0
    case R_PPC64_REL24_P9NOTOC:
3794
0
      subt = ppc_stub_p9notoc;
3795
0
      break;
3796
0
    default:
3797
0
      subt = ppc_stub_toc;
3798
0
      break;
3799
0
    }
3800
3801
0
  while (entry != NULL && entry->type.sub != subt)
3802
0
    {
3803
0
      const char *stub_name = entry->root.string;
3804
3805
0
      entry = (struct ppc_stub_hash_entry *) entry->root.next;
3806
0
      if (entry != NULL
3807
0
    && entry->root.string != stub_name)
3808
0
  entry = NULL;
3809
0
    }
3810
3811
0
  return entry;
3812
0
}
3813
3814
/* Look up an entry in the stub hash.  Stub entries are cached because
3815
   creating the stub name takes a bit of time.  */
3816
3817
static struct ppc_stub_hash_entry *
3818
ppc_get_stub_entry (const asection *input_section,
3819
        const asection *sym_sec,
3820
        struct ppc_link_hash_entry *h,
3821
        const Elf_Internal_Rela *rel,
3822
        struct ppc_link_hash_table *htab)
3823
0
{
3824
0
  struct ppc_stub_hash_entry *stub_entry;
3825
0
  struct map_stub *group;
3826
3827
  /* If this input section is part of a group of sections sharing one
3828
     stub section, then use the id of the first section in the group.
3829
     Stub names need to include a section id, as there may well be
3830
     more than one stub used to reach say, printf, and we need to
3831
     distinguish between them.  */
3832
0
  group = htab->sec_info[input_section->id].u.group;
3833
0
  if (group == NULL)
3834
0
    return NULL;
3835
3836
0
  if (h != NULL && h->u.stub_cache != NULL
3837
0
      && h->u.stub_cache->h == h
3838
0
      && h->u.stub_cache->group == group)
3839
0
    {
3840
0
      stub_entry = h->u.stub_cache;
3841
0
    }
3842
0
  else
3843
0
    {
3844
0
      char *stub_name;
3845
3846
0
      stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
3847
0
      if (stub_name == NULL)
3848
0
  return NULL;
3849
3850
0
      stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3851
0
           stub_name, false, false);
3852
0
      if (h != NULL)
3853
0
  h->u.stub_cache = stub_entry;
3854
3855
0
      free (stub_name);
3856
0
    }
3857
3858
0
  if (stub_entry != NULL && htab->params->power10_stubs == -1)
3859
0
    stub_entry = select_alt_stub (stub_entry, ELF64_R_TYPE (rel->r_info));
3860
3861
0
  return stub_entry;
3862
0
}
3863
3864
/* Add a new stub entry to the stub hash.  Not all fields of the new
3865
   stub entry are initialised.  */
3866
3867
static struct ppc_stub_hash_entry *
3868
ppc_add_stub (const char *stub_name,
3869
        asection *section,
3870
        struct bfd_link_info *info)
3871
0
{
3872
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
3873
0
  struct map_stub *group;
3874
0
  asection *link_sec;
3875
0
  asection *stub_sec;
3876
0
  struct ppc_stub_hash_entry *stub_entry;
3877
3878
0
  group = htab->sec_info[section->id].u.group;
3879
0
  link_sec = group->link_sec;
3880
0
  stub_sec = group->stub_sec;
3881
0
  if (stub_sec == NULL)
3882
0
    {
3883
0
      size_t namelen;
3884
0
      bfd_size_type len;
3885
0
      char *s_name;
3886
3887
0
      namelen = strlen (link_sec->name);
3888
0
      len = namelen + sizeof (STUB_SUFFIX);
3889
0
      s_name = bfd_alloc (htab->params->stub_bfd, len);
3890
0
      if (s_name == NULL)
3891
0
  return NULL;
3892
3893
0
      memcpy (s_name, link_sec->name, namelen);
3894
0
      memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3895
0
      stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
3896
0
      if (stub_sec == NULL)
3897
0
  return NULL;
3898
0
      group->stub_sec = stub_sec;
3899
0
    }
3900
3901
  /* Enter this entry into the linker stub hash table.  */
3902
0
  stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3903
0
             true, false);
3904
0
  if (stub_entry == NULL)
3905
0
    {
3906
      /* xgettext:c-format */
3907
0
      _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3908
0
        section->owner, stub_name);
3909
0
      return NULL;
3910
0
    }
3911
3912
0
  stub_entry->group = group;
3913
0
  stub_entry->stub_offset = 0;
3914
0
  return stub_entry;
3915
0
}
3916
3917
/* A stub has already been created, but it may not be the required
3918
   type.  We shouldn't be transitioning from plt_call to long_branch
3919
   stubs or vice versa, but we might be upgrading from plt_call to
3920
   plt_call with r2save for example.  */
3921
3922
static bool
3923
ppc_merge_stub (struct ppc_link_hash_table *htab,
3924
    struct ppc_stub_hash_entry *stub_entry,
3925
    struct ppc_stub_type stub_type,
3926
    enum elf_ppc64_reloc_type r_type)
3927
0
{
3928
0
  struct ppc_stub_type old_type = stub_entry->type;
3929
3930
0
  if (old_type.main == ppc_stub_save_res)
3931
0
    return true;
3932
3933
0
  if (htab->params->power10_stubs == -1)
3934
0
    {
3935
      /* For --power10-stubs=auto, don't merge _notoc and other
3936
   varieties of stubs.  */
3937
0
      struct ppc_stub_hash_entry *alt_stub;
3938
3939
0
      alt_stub = select_alt_stub (stub_entry, r_type);
3940
0
      if (alt_stub == NULL)
3941
0
  {
3942
0
    alt_stub = ((struct ppc_stub_hash_entry *)
3943
0
          stub_hash_newfunc (NULL,
3944
0
           &htab->stub_hash_table,
3945
0
           stub_entry->root.string));
3946
0
    if (alt_stub == NULL)
3947
0
      return false;
3948
3949
0
    *alt_stub = *stub_entry;
3950
0
    stub_entry->root.next = &alt_stub->root;
3951
3952
    /* Sort notoc stubs first, then toc stubs, then p9notoc.
3953
       Not that it matters, this just puts smaller stubs first.  */
3954
0
    if (stub_type.sub == ppc_stub_notoc)
3955
0
      alt_stub = stub_entry;
3956
0
    else if (stub_type.sub == ppc_stub_p9notoc
3957
0
       && alt_stub->root.next
3958
0
       && alt_stub->root.next->string == alt_stub->root.string)
3959
0
      {
3960
0
        struct ppc_stub_hash_entry *next
3961
0
    = (struct ppc_stub_hash_entry *) alt_stub->root.next;
3962
0
        alt_stub->type = next->type;
3963
0
        alt_stub = next;
3964
0
      }
3965
0
    alt_stub->type = stub_type;
3966
0
    return true;
3967
0
  }
3968
0
      stub_entry = alt_stub;
3969
0
    }
3970
3971
0
  old_type = stub_entry->type;
3972
0
  if (old_type.main == ppc_stub_plt_branch)
3973
0
    old_type.main = ppc_stub_long_branch;
3974
3975
0
  if (old_type.main != stub_type.main
3976
0
      || (old_type.sub != stub_type.sub
3977
0
    && old_type.sub != ppc_stub_toc
3978
0
    && stub_type.sub != ppc_stub_toc))
3979
0
    abort ();
3980
3981
0
  stub_entry->type.sub |= stub_type.sub;
3982
0
  stub_entry->type.r2save |= stub_type.r2save;
3983
0
  return true;
3984
0
}
3985
3986
/* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3987
   not already done.  */
3988
3989
static bool
3990
create_got_section (bfd *abfd, struct bfd_link_info *info)
3991
0
{
3992
0
  asection *got, *relgot;
3993
0
  flagword flags;
3994
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
3995
3996
0
  if (!is_ppc64_elf (abfd))
3997
0
    return false;
3998
0
  if (htab == NULL)
3999
0
    return false;
4000
4001
0
  if (!htab->elf.sgot
4002
0
      && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4003
0
    return false;
4004
4005
0
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4006
0
     | SEC_LINKER_CREATED);
4007
4008
0
  got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4009
0
  if (!got
4010
0
      || !bfd_set_section_alignment (got, 3))
4011
0
    return false;
4012
4013
0
  relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4014
0
                 flags | SEC_READONLY);
4015
0
  if (!relgot
4016
0
      || !bfd_set_section_alignment (relgot, 3))
4017
0
    return false;
4018
4019
0
  ppc64_elf_tdata (abfd)->got = got;
4020
0
  ppc64_elf_tdata (abfd)->relgot = relgot;
4021
0
  return true;
4022
0
}
4023
4024
/* Follow indirect and warning symbol links.  */
4025
4026
static inline struct bfd_link_hash_entry *
4027
follow_link (struct bfd_link_hash_entry *h)
4028
0
{
4029
0
  while (h->type == bfd_link_hash_indirect
4030
0
   || h->type == bfd_link_hash_warning)
4031
0
    h = h->u.i.link;
4032
0
  return h;
4033
0
}
4034
4035
static inline struct elf_link_hash_entry *
4036
elf_follow_link (struct elf_link_hash_entry *h)
4037
0
{
4038
0
  return (struct elf_link_hash_entry *) follow_link (&h->root);
4039
0
}
4040
4041
static inline struct ppc_link_hash_entry *
4042
ppc_follow_link (struct ppc_link_hash_entry *h)
4043
0
{
4044
0
  return ppc_elf_hash_entry (elf_follow_link (&h->elf));
4045
0
}
4046
4047
/* Merge PLT info on FROM with that on TO.  */
4048
4049
static void
4050
move_plt_plist (struct ppc_link_hash_entry *from,
4051
    struct ppc_link_hash_entry *to)
4052
0
{
4053
0
  if (from->elf.plt.plist != NULL)
4054
0
    {
4055
0
      if (to->elf.plt.plist != NULL)
4056
0
  {
4057
0
    struct plt_entry **entp;
4058
0
    struct plt_entry *ent;
4059
4060
0
    for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4061
0
      {
4062
0
        struct plt_entry *dent;
4063
4064
0
        for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4065
0
    if (dent->addend == ent->addend)
4066
0
      {
4067
0
        dent->plt.refcount += ent->plt.refcount;
4068
0
        *entp = ent->next;
4069
0
        break;
4070
0
      }
4071
0
        if (dent == NULL)
4072
0
    entp = &ent->next;
4073
0
      }
4074
0
    *entp = to->elf.plt.plist;
4075
0
  }
4076
4077
0
      to->elf.plt.plist = from->elf.plt.plist;
4078
0
      from->elf.plt.plist = NULL;
4079
0
    }
4080
0
}
4081
4082
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
4083
4084
static void
4085
ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4086
        struct elf_link_hash_entry *dir,
4087
        struct elf_link_hash_entry *ind)
4088
0
{
4089
0
  struct ppc_link_hash_entry *edir, *eind;
4090
4091
0
  edir = ppc_elf_hash_entry (dir);
4092
0
  eind = ppc_elf_hash_entry (ind);
4093
4094
0
  edir->is_func |= eind->is_func;
4095
0
  edir->is_func_descriptor |= eind->is_func_descriptor;
4096
0
  edir->tls_mask |= eind->tls_mask;
4097
0
  if (eind->oh != NULL)
4098
0
    edir->oh = ppc_follow_link (eind->oh);
4099
4100
0
  if (edir->elf.versioned != versioned_hidden)
4101
0
    edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4102
0
  edir->elf.ref_regular |= eind->elf.ref_regular;
4103
0
  edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4104
0
  edir->elf.non_got_ref |= eind->elf.non_got_ref;
4105
0
  edir->elf.needs_plt |= eind->elf.needs_plt;
4106
0
  edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4107
4108
  /* If we were called to copy over info for a weak sym, don't copy
4109
     dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4110
     in order to simplify readonly_dynrelocs and save a field in the
4111
     symbol hash entry, but that means dyn_relocs can't be used in any
4112
     tests about a specific symbol, or affect other symbol flags which
4113
     are then tested.  */
4114
0
  if (eind->elf.root.type != bfd_link_hash_indirect)
4115
0
    return;
4116
4117
  /* Copy over any dynamic relocs we may have on the indirect sym.  */
4118
0
  if (ind->dyn_relocs != NULL)
4119
0
    {
4120
0
      if (dir->dyn_relocs != NULL)
4121
0
  {
4122
0
    struct ppc_dyn_relocs **pp;
4123
0
    struct ppc_dyn_relocs *p;
4124
4125
    /* Add reloc counts against the indirect sym to the direct sym
4126
       list.  Merge any entries against the same section.  */
4127
0
    for (pp = (struct ppc_dyn_relocs **) &ind->dyn_relocs;
4128
0
         (p = *pp) != NULL;
4129
0
         )
4130
0
      {
4131
0
        struct ppc_dyn_relocs *q;
4132
4133
0
        for (q = (struct ppc_dyn_relocs *) dir->dyn_relocs;
4134
0
       q != NULL;
4135
0
       q = q->next)
4136
0
    if (q->sec == p->sec)
4137
0
      {
4138
0
        q->count += p->count;
4139
0
        q->pc_count += p->pc_count;
4140
0
        q->rel_count += p->rel_count;
4141
0
        *pp = p->next;
4142
0
        break;
4143
0
      }
4144
0
        if (q == NULL)
4145
0
    pp = &p->next;
4146
0
      }
4147
0
    *pp = (struct ppc_dyn_relocs *) dir->dyn_relocs;
4148
0
  }
4149
4150
0
      dir->dyn_relocs = ind->dyn_relocs;
4151
0
      ind->dyn_relocs = NULL;
4152
0
    }
4153
4154
  /* Copy over got entries that we may have already seen to the
4155
     symbol which just became indirect.  */
4156
0
  if (eind->elf.got.glist != NULL)
4157
0
    {
4158
0
      if (edir->elf.got.glist != NULL)
4159
0
  {
4160
0
    struct got_entry **entp;
4161
0
    struct got_entry *ent;
4162
4163
0
    for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4164
0
      {
4165
0
        struct got_entry *dent;
4166
4167
0
        for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4168
0
    if (dent->addend == ent->addend
4169
0
        && dent->owner == ent->owner
4170
0
        && dent->tls_type == ent->tls_type)
4171
0
      {
4172
0
        dent->got.refcount += ent->got.refcount;
4173
0
        *entp = ent->next;
4174
0
        break;
4175
0
      }
4176
0
        if (dent == NULL)
4177
0
    entp = &ent->next;
4178
0
      }
4179
0
    *entp = edir->elf.got.glist;
4180
0
  }
4181
4182
0
      edir->elf.got.glist = eind->elf.got.glist;
4183
0
      eind->elf.got.glist = NULL;
4184
0
    }
4185
4186
  /* And plt entries.  */
4187
0
  move_plt_plist (eind, edir);
4188
4189
0
  if (eind->elf.dynindx != -1)
4190
0
    {
4191
0
      if (edir->elf.dynindx != -1)
4192
0
  _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4193
0
        edir->elf.dynstr_index);
4194
0
      edir->elf.dynindx = eind->elf.dynindx;
4195
0
      edir->elf.dynstr_index = eind->elf.dynstr_index;
4196
0
      eind->elf.dynindx = -1;
4197
0
      eind->elf.dynstr_index = 0;
4198
0
    }
4199
0
}
4200
4201
/* Find the function descriptor hash entry from the given function code
4202
   hash entry FH.  Link the entries via their OH fields.  */
4203
4204
static struct ppc_link_hash_entry *
4205
lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4206
0
{
4207
0
  struct ppc_link_hash_entry *fdh = fh->oh;
4208
4209
0
  if (fdh == NULL)
4210
0
    {
4211
0
      const char *fd_name = fh->elf.root.root.string + 1;
4212
4213
0
      fdh = ppc_elf_hash_entry (elf_link_hash_lookup (&htab->elf, fd_name,
4214
0
                  false, false, false));
4215
0
      if (fdh == NULL)
4216
0
  return fdh;
4217
4218
0
      fdh->is_func_descriptor = 1;
4219
0
      fdh->oh = fh;
4220
0
      fh->is_func = 1;
4221
0
      fh->oh = fdh;
4222
0
    }
4223
4224
0
  fdh = ppc_follow_link (fdh);
4225
0
  fdh->is_func_descriptor = 1;
4226
0
  fdh->oh = fh;
4227
0
  return fdh;
4228
0
}
4229
4230
/* Make a fake function descriptor sym for the undefined code sym FH.  */
4231
4232
static struct ppc_link_hash_entry *
4233
make_fdh (struct bfd_link_info *info,
4234
    struct ppc_link_hash_entry *fh)
4235
0
{
4236
0
  bfd *abfd = fh->elf.root.u.undef.abfd;
4237
0
  struct bfd_link_hash_entry *bh = NULL;
4238
0
  struct ppc_link_hash_entry *fdh;
4239
0
  flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4240
0
        ? BSF_WEAK
4241
0
        : BSF_GLOBAL);
4242
4243
0
  if (!_bfd_generic_link_add_one_symbol (info, abfd,
4244
0
           fh->elf.root.root.string + 1,
4245
0
           flags, bfd_und_section_ptr, 0,
4246
0
           NULL, false, false, &bh))
4247
0
    return NULL;
4248
4249
0
  fdh = (struct ppc_link_hash_entry *) bh;
4250
0
  fdh->elf.non_elf = 0;
4251
0
  fdh->fake = 1;
4252
0
  fdh->is_func_descriptor = 1;
4253
0
  fdh->oh = fh;
4254
0
  fh->is_func = 1;
4255
0
  fh->oh = fdh;
4256
0
  return fdh;
4257
0
}
4258
4259
/* Fix function descriptor symbols defined in .opd sections to be
4260
   function type.  */
4261
4262
static bool
4263
ppc64_elf_add_symbol_hook (bfd *ibfd,
4264
         struct bfd_link_info *info,
4265
         Elf_Internal_Sym *isym,
4266
         const char **name,
4267
         flagword *flags ATTRIBUTE_UNUSED,
4268
         asection **sec,
4269
         bfd_vma *value)
4270
0
{
4271
0
  if (*sec != NULL
4272
0
      && strcmp ((*sec)->name, ".opd") == 0)
4273
0
    {
4274
0
      asection *code_sec;
4275
4276
0
      if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4277
0
      || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4278
0
  isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4279
4280
      /* If the symbol is a function defined in .opd, and the function
4281
   code is in a discarded group, let it appear to be undefined.  */
4282
0
      if (!bfd_link_relocatable (info)
4283
0
    && (*sec)->reloc_count != 0
4284
0
    && opd_entry_value (*sec, *value, &code_sec, NULL,
4285
0
            false) != (bfd_vma) -1
4286
0
    && discarded_section (code_sec))
4287
0
  {
4288
0
    *sec = bfd_und_section_ptr;
4289
0
    isym->st_shndx = SHN_UNDEF;
4290
0
  }
4291
0
    }
4292
0
  else if (*sec != NULL
4293
0
     && strcmp ((*sec)->name, ".toc") == 0
4294
0
     && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4295
0
    {
4296
0
      struct ppc_link_hash_table *htab = ppc_hash_table (info);
4297
0
      if (htab != NULL)
4298
0
  htab->params->object_in_toc = 1;
4299
0
    }
4300
4301
0
  if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4302
0
    {
4303
0
      if (abiversion (ibfd) == 0)
4304
0
  set_abiversion (ibfd, 2);
4305
0
      else if (abiversion (ibfd) == 1)
4306
0
  {
4307
0
    _bfd_error_handler (_("symbol '%s' has invalid st_other"
4308
0
        " for ABI version 1"), *name);
4309
0
    bfd_set_error (bfd_error_bad_value);
4310
0
    return false;
4311
0
  }
4312
0
    }
4313
4314
0
  return true;
4315
0
}
4316
4317
/* Merge non-visibility st_other attributes: local entry point.  */
4318
4319
static void
4320
ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4321
          unsigned int st_other,
4322
          bool definition,
4323
          bool dynamic)
4324
0
{
4325
0
  if (definition && (!dynamic || !h->def_regular))
4326
0
    h->other = ((st_other & ~ELF_ST_VISIBILITY (-1))
4327
0
    | ELF_ST_VISIBILITY (h->other));
4328
0
}
4329
4330
/* Hook called on merging a symbol.  We use this to clear "fake" since
4331
   we now have a real symbol.  */
4332
4333
static bool
4334
ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
4335
      const Elf_Internal_Sym *isym,
4336
      asection **psec ATTRIBUTE_UNUSED,
4337
      bool newdef ATTRIBUTE_UNUSED,
4338
      bool olddef ATTRIBUTE_UNUSED,
4339
      bfd *oldbfd ATTRIBUTE_UNUSED,
4340
      const asection *oldsec ATTRIBUTE_UNUSED)
4341
0
{
4342
0
  ppc_elf_hash_entry (h)->fake = 0;
4343
0
  if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4344
0
    ppc_elf_hash_entry (h)->non_zero_localentry = 1;
4345
0
  return true;
4346
0
}
4347
4348
/* This function makes an old ABI object reference to ".bar" cause the
4349
   inclusion of a new ABI object archive that defines "bar".
4350
   NAME is a symbol defined in an archive.  Return a symbol in the hash
4351
   table that might be satisfied by the archive symbols.  */
4352
4353
static struct bfd_link_hash_entry *
4354
ppc64_elf_archive_symbol_lookup (bfd *abfd,
4355
         struct bfd_link_info *info,
4356
         const char *name)
4357
0
{
4358
0
  struct bfd_link_hash_entry *h;
4359
0
  char *dot_name;
4360
0
  size_t len;
4361
4362
0
  h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4363
0
  if (h != NULL
4364
0
      && ppc_hash_table (info) != NULL
4365
      /* Don't return this sym if it is a fake function descriptor
4366
   created by add_symbol_adjust.  */
4367
0
      && !((struct ppc_link_hash_entry *) h)->fake)
4368
0
    return h;
4369
4370
0
  if (name[0] == '.')
4371
0
    return h;
4372
4373
0
  len = strlen (name);
4374
0
  dot_name = bfd_alloc (abfd, len + 2);
4375
0
  if (dot_name == NULL)
4376
0
    return (struct bfd_link_hash_entry *) -1;
4377
0
  dot_name[0] = '.';
4378
0
  memcpy (dot_name + 1, name, len + 1);
4379
0
  h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4380
0
  bfd_release (abfd, dot_name);
4381
0
  if (h != NULL)
4382
0
    return h;
4383
4384
0
  if (strcmp (name, "__tls_get_addr_opt") == 0)
4385
0
    h = _bfd_elf_archive_symbol_lookup (abfd, info, "__tls_get_addr_desc");
4386
0
  return h;
4387
0
}
4388
4389
/* This function satisfies all old ABI object references to ".bar" if a
4390
   new ABI object defines "bar".  Well, at least, undefined dot symbols
4391
   are made weak.  This stops later archive searches from including an
4392
   object if we already have a function descriptor definition.  It also
4393
   prevents the linker complaining about undefined symbols.
4394
   We also check and correct mismatched symbol visibility here.  The
4395
   most restrictive visibility of the function descriptor and the
4396
   function entry symbol is used.  */
4397
4398
static bool
4399
add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4400
0
{
4401
0
  struct ppc_link_hash_table *htab;
4402
0
  struct ppc_link_hash_entry *fdh;
4403
4404
0
  if (eh->elf.root.type == bfd_link_hash_warning)
4405
0
    eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4406
4407
0
  if (eh->elf.root.type == bfd_link_hash_indirect)
4408
0
    return true;
4409
4410
0
  if (eh->elf.root.root.string[0] != '.')
4411
0
    abort ();
4412
4413
0
  htab = ppc_hash_table (info);
4414
0
  if (htab == NULL)
4415
0
    return false;
4416
4417
0
  fdh = lookup_fdh (eh, htab);
4418
0
  if (fdh == NULL
4419
0
      && !bfd_link_relocatable (info)
4420
0
      && (eh->elf.root.type == bfd_link_hash_undefined
4421
0
    || eh->elf.root.type == bfd_link_hash_undefweak)
4422
0
      && eh->elf.ref_regular)
4423
0
    {
4424
      /* Make an undefined function descriptor sym, in order to
4425
   pull in an --as-needed shared lib.  Archives are handled
4426
   elsewhere.  */
4427
0
      fdh = make_fdh (info, eh);
4428
0
      if (fdh == NULL)
4429
0
  return false;
4430
0
    }
4431
4432
0
  if (fdh != NULL)
4433
0
    {
4434
0
      unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4435
0
      unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4436
4437
      /* Make both descriptor and entry symbol have the most
4438
   constraining visibility of either symbol.  */
4439
0
      if (entry_vis < descr_vis)
4440
0
  fdh->elf.other += entry_vis - descr_vis;
4441
0
      else if (entry_vis > descr_vis)
4442
0
  eh->elf.other += descr_vis - entry_vis;
4443
4444
      /* Propagate reference flags from entry symbol to function
4445
   descriptor symbol.  */
4446
0
      fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
4447
0
      fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
4448
0
      fdh->elf.ref_regular |= eh->elf.ref_regular;
4449
0
      fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
4450
4451
0
      if (!fdh->elf.forced_local
4452
0
    && fdh->elf.dynindx == -1
4453
0
    && fdh->elf.versioned != versioned_hidden
4454
0
    && (bfd_link_dll (info)
4455
0
        || fdh->elf.def_dynamic
4456
0
        || fdh->elf.ref_dynamic)
4457
0
    && (eh->elf.ref_regular
4458
0
        || eh->elf.def_regular))
4459
0
  {
4460
0
    if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
4461
0
      return false;
4462
0
  }
4463
0
    }
4464
4465
0
  return true;
4466
0
}
4467
4468
/* Set up opd section info and abiversion for IBFD, and process list
4469
   of dot-symbols we made in link_hash_newfunc.  */
4470
4471
static bool
4472
ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4473
0
{
4474
0
  struct ppc_link_hash_table *htab;
4475
0
  struct ppc_link_hash_entry **p, *eh;
4476
0
  asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4477
4478
0
  if (opd != NULL && opd->size != 0)
4479
0
    {
4480
0
      if (ppc64_elf_section_data (opd)->sec_type == sec_normal)
4481
0
  ppc64_elf_section_data (opd)->sec_type = sec_opd;
4482
0
      else if (ppc64_elf_section_data (opd)->sec_type != sec_opd)
4483
0
  BFD_FAIL ();
4484
4485
0
      if (abiversion (ibfd) == 0)
4486
0
  set_abiversion (ibfd, 1);
4487
0
      else if (abiversion (ibfd) >= 2)
4488
0
  {
4489
    /* xgettext:c-format */
4490
0
    _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4491
0
            ibfd, abiversion (ibfd));
4492
0
    bfd_set_error (bfd_error_bad_value);
4493
0
    return false;
4494
0
  }
4495
0
    }
4496
4497
0
  if (is_ppc64_elf (info->output_bfd))
4498
0
    {
4499
      /* For input files without an explicit abiversion in e_flags
4500
   we should have flagged any with symbol st_other bits set
4501
   as ELFv2 and above flagged those with .opd as ELFv1.
4502
   Set the output abiversion if not yet set, and for any input
4503
   still ambiguous, take its abiversion from the output.
4504
   Differences in ABI are reported later.  */
4505
0
      if (abiversion (info->output_bfd) == 0)
4506
0
  set_abiversion (info->output_bfd, abiversion (ibfd));
4507
0
      else if (abiversion (ibfd) == 0)
4508
0
  set_abiversion (ibfd, abiversion (info->output_bfd));
4509
0
    }
4510
4511
0
  htab = ppc_hash_table (info);
4512
0
  if (htab == NULL)
4513
0
    return true;
4514
4515
0
  if (opd != NULL && opd->size != 0
4516
0
      && (ibfd->flags & DYNAMIC) == 0
4517
0
      && (opd->flags & SEC_RELOC) != 0
4518
0
      && opd->reloc_count != 0
4519
0
      && !bfd_is_abs_section (opd->output_section)
4520
0
      && info->gc_sections)
4521
0
    {
4522
      /* Garbage collection needs some extra help with .opd sections.
4523
   We don't want to necessarily keep everything referenced by
4524
   relocs in .opd, as that would keep all functions.  Instead,
4525
   if we reference an .opd symbol (a function descriptor), we
4526
   want to keep the function code symbol's section.  This is
4527
   easy for global symbols, but for local syms we need to keep
4528
   information about the associated function section.  */
4529
0
      bfd_size_type amt;
4530
0
      asection **opd_sym_map;
4531
0
      Elf_Internal_Shdr *symtab_hdr;
4532
0
      Elf_Internal_Rela *relocs, *rel_end, *rel;
4533
4534
0
      amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
4535
0
      opd_sym_map = bfd_zalloc (ibfd, amt);
4536
0
      if (opd_sym_map == NULL)
4537
0
  return false;
4538
0
      ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4539
0
      relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
4540
0
            info->keep_memory);
4541
0
      if (relocs == NULL)
4542
0
  return false;
4543
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
4544
0
      rel_end = relocs + opd->reloc_count - 1;
4545
0
      for (rel = relocs; rel < rel_end; rel++)
4546
0
  {
4547
0
    enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
4548
0
    unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
4549
4550
0
    if (r_type == R_PPC64_ADDR64
4551
0
        && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
4552
0
        && r_symndx < symtab_hdr->sh_info)
4553
0
      {
4554
0
        Elf_Internal_Sym *isym;
4555
0
        asection *s;
4556
4557
0
        isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, ibfd,
4558
0
              r_symndx);
4559
0
        if (isym == NULL)
4560
0
    {
4561
0
      if (elf_section_data (opd)->relocs != relocs)
4562
0
        free (relocs);
4563
0
      return false;
4564
0
    }
4565
4566
0
        s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
4567
0
        if (s != NULL && s != opd)
4568
0
    opd_sym_map[OPD_NDX (rel->r_offset)] = s;
4569
0
      }
4570
0
  }
4571
0
      if (elf_section_data (opd)->relocs != relocs)
4572
0
  free (relocs);
4573
0
    }
4574
4575
0
  p = &htab->dot_syms;
4576
0
  while ((eh = *p) != NULL)
4577
0
    {
4578
0
      *p = NULL;
4579
0
      if (&eh->elf == htab->elf.hgot)
4580
0
  ;
4581
0
      else if (htab->elf.hgot == NULL
4582
0
         && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4583
0
  htab->elf.hgot = &eh->elf;
4584
0
      else if (abiversion (ibfd) <= 1)
4585
0
  {
4586
0
    htab->need_func_desc_adj = 1;
4587
0
    if (!add_symbol_adjust (eh, info))
4588
0
      return false;
4589
0
  }
4590
0
      p = &eh->u.next_dot_sym;
4591
0
    }
4592
0
  return true;
4593
0
}
4594
4595
/* Undo hash table changes when an --as-needed input file is determined
4596
   not to be needed.  */
4597
4598
static bool
4599
ppc64_elf_notice_as_needed (bfd *ibfd,
4600
          struct bfd_link_info *info,
4601
          enum notice_asneeded_action act)
4602
0
{
4603
0
  if (act == notice_not_needed)
4604
0
    {
4605
0
      struct ppc_link_hash_table *htab = ppc_hash_table (info);
4606
4607
0
      if (htab == NULL)
4608
0
  return false;
4609
4610
0
      htab->dot_syms = NULL;
4611
0
    }
4612
0
  return _bfd_elf_notice_as_needed (ibfd, info, act);
4613
0
}
4614
4615
/* If --just-symbols against a final linked binary, then assume we need
4616
   toc adjusting stubs when calling functions defined there.  */
4617
4618
static void
4619
ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4620
0
{
4621
0
  if ((sec->flags & SEC_CODE) != 0
4622
0
      && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4623
0
      && is_ppc64_elf (sec->owner))
4624
0
    {
4625
0
      if (abiversion (sec->owner) >= 2
4626
0
    || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4627
0
  sec->has_toc_reloc = 1;
4628
0
    }
4629
0
  _bfd_elf_link_just_syms (sec, info);
4630
0
}
4631
4632
static struct plt_entry **
4633
update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4634
           unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4635
0
{
4636
0
  struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4637
0
  struct plt_entry **local_plt;
4638
0
  unsigned char *local_got_tls_masks;
4639
4640
0
  if (local_got_ents == NULL)
4641
0
    {
4642
0
      bfd_size_type size = symtab_hdr->sh_info;
4643
4644
0
      size *= (sizeof (*local_got_ents)
4645
0
         + sizeof (*local_plt)
4646
0
         + sizeof (*local_got_tls_masks));
4647
0
      local_got_ents = bfd_zalloc (abfd, size);
4648
0
      if (local_got_ents == NULL)
4649
0
  return NULL;
4650
0
      elf_local_got_ents (abfd) = local_got_ents;
4651
0
    }
4652
4653
0
  if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
4654
0
    {
4655
0
      struct got_entry *ent;
4656
4657
0
      for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4658
0
  if (ent->addend == r_addend
4659
0
      && ent->owner == abfd
4660
0
      && ent->tls_type == tls_type)
4661
0
    break;
4662
0
      if (ent == NULL)
4663
0
  {
4664
0
    size_t amt = sizeof (*ent);
4665
0
    ent = bfd_alloc (abfd, amt);
4666
0
    if (ent == NULL)
4667
0
      return false;
4668
0
    ent->next = local_got_ents[r_symndx];
4669
0
    ent->addend = r_addend;
4670
0
    ent->owner = abfd;
4671
0
    ent->tls_type = tls_type;
4672
0
    ent->is_indirect = false;
4673
0
    ent->got.refcount = 0;
4674
0
    local_got_ents[r_symndx] = ent;
4675
0
  }
4676
0
      ent->got.refcount += 1;
4677
0
    }
4678
4679
0
  local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4680
0
  local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4681
0
  local_got_tls_masks[r_symndx] |= tls_type & 0xff;
4682
4683
0
  return local_plt + r_symndx;
4684
0
}
4685
4686
static bool
4687
update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4688
0
{
4689
0
  struct plt_entry *ent;
4690
4691
0
  for (ent = *plist; ent != NULL; ent = ent->next)
4692
0
    if (ent->addend == addend)
4693
0
      break;
4694
0
  if (ent == NULL)
4695
0
    {
4696
0
      size_t amt = sizeof (*ent);
4697
0
      ent = bfd_alloc (abfd, amt);
4698
0
      if (ent == NULL)
4699
0
  return false;
4700
0
      ent->next = *plist;
4701
0
      ent->addend = addend;
4702
0
      ent->plt.refcount = 0;
4703
0
      *plist = ent;
4704
0
    }
4705
0
  ent->plt.refcount += 1;
4706
0
  return true;
4707
0
}
4708
4709
static bool
4710
is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4711
0
{
4712
0
  return (r_type == R_PPC64_REL24
4713
0
    || r_type == R_PPC64_REL24_NOTOC
4714
0
    || r_type == R_PPC64_REL24_P9NOTOC
4715
0
    || r_type == R_PPC64_REL14
4716
0
    || r_type == R_PPC64_REL14_BRTAKEN
4717
0
    || r_type == R_PPC64_REL14_BRNTAKEN
4718
0
    || r_type == R_PPC64_ADDR24
4719
0
    || r_type == R_PPC64_ADDR14
4720
0
    || r_type == R_PPC64_ADDR14_BRTAKEN
4721
0
    || r_type == R_PPC64_ADDR14_BRNTAKEN
4722
0
    || r_type == R_PPC64_PLTCALL
4723
0
    || r_type == R_PPC64_PLTCALL_NOTOC);
4724
0
}
4725
4726
/* Relocs on inline plt call sequence insns prior to the call.  */
4727
4728
static bool
4729
is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
4730
0
{
4731
0
  return (r_type == R_PPC64_PLT16_HA
4732
0
    || r_type == R_PPC64_PLT16_HI
4733
0
    || r_type == R_PPC64_PLT16_LO
4734
0
    || r_type == R_PPC64_PLT16_LO_DS
4735
0
    || r_type == R_PPC64_PLT_PCREL34
4736
0
    || r_type == R_PPC64_PLT_PCREL34_NOTOC
4737
0
    || r_type == R_PPC64_PLTSEQ
4738
0
    || r_type == R_PPC64_PLTSEQ_NOTOC);
4739
0
}
4740
4741
/* Of relocs which might appear paired with TLSGD and TLSLD marker
4742
   relocs, return true for those that operate on a dword.  */
4743
4744
static bool
4745
is_8byte_reloc (enum elf_ppc64_reloc_type r_type)
4746
0
{
4747
0
  return (r_type == R_PPC64_PLT_PCREL34
4748
0
    || r_type == R_PPC64_PLT_PCREL34_NOTOC
4749
0
    || r_type == R_PPC64_PLTCALL);
4750
0
}
4751
4752
/* The RELR encoding doesn't allow odd addresses, so RELR_ALIGN must
4753
   be at least 1.  R_PPC64_RELATIVE relocs require alignment of 2**3.
4754
   We use 3 here to avoid complexity in relocate_section, where for a
4755
   value of 1 we'd need to test for not just an output RELATIVE reloc
4756
   near the call to maybe_relr but also UADDR64 and some conditions on
4757
   the symbol.  See PR30824.  */
4758
0
#define RELR_ALIGN 3
4759
4760
static bool
4761
maybe_relr (enum elf_ppc64_reloc_type r_type,
4762
      const Elf_Internal_Rela *rel,
4763
      const asection *sec)
4764
0
{
4765
0
  return ((r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
4766
0
    && (rel->r_offset & ((1 << RELR_ALIGN) - 1)) == 0
4767
0
    && sec->alignment_power >= RELR_ALIGN);
4768
0
}
4769
4770
/* Like bfd_reloc_offset_in_range but without a howto.  Return true
4771
   iff a field of SIZE bytes at OFFSET is within SEC limits.  */
4772
4773
static bool
4774
offset_in_range (asection *sec, bfd_vma offset, size_t size)
4775
0
{
4776
0
  return offset <= sec->size && size <= sec->size - offset;
4777
0
}
4778
4779
/* Look through the relocs for a section during the first phase, and
4780
   calculate needed space in the global offset table, procedure
4781
   linkage table, and dynamic reloc sections.  */
4782
4783
static bool
4784
ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4785
      asection *sec, const Elf_Internal_Rela *relocs)
4786
0
{
4787
0
  struct ppc_link_hash_table *htab;
4788
0
  Elf_Internal_Shdr *symtab_hdr;
4789
0
  struct elf_link_hash_entry **sym_hashes;
4790
0
  const Elf_Internal_Rela *rel;
4791
0
  const Elf_Internal_Rela *rel_end;
4792
0
  asection *sreloc;
4793
0
  struct elf_link_hash_entry *tga, *dottga;
4794
0
  bool is_opd;
4795
4796
0
  if (bfd_link_relocatable (info))
4797
0
    return true;
4798
4799
0
  BFD_ASSERT (is_ppc64_elf (abfd));
4800
4801
0
  htab = ppc_hash_table (info);
4802
0
  if (htab == NULL)
4803
0
    return false;
4804
4805
0
  tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4806
0
            false, false, true);
4807
0
  dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4808
0
         false, false, true);
4809
0
  symtab_hdr = &elf_symtab_hdr (abfd);
4810
0
  sym_hashes = elf_sym_hashes (abfd);
4811
0
  sreloc = NULL;
4812
0
  is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
4813
0
  rel_end = relocs + sec->reloc_count;
4814
0
  for (rel = relocs; rel < rel_end; rel++)
4815
0
    {
4816
0
      unsigned long r_symndx;
4817
0
      struct elf_link_hash_entry *h;
4818
0
      Elf_Internal_Sym *isym;
4819
0
      enum elf_ppc64_reloc_type r_type;
4820
0
      int tls_type;
4821
0
      struct _ppc64_elf_section_data *ppc64_sec;
4822
0
      struct plt_entry **ifunc, **plt_list;
4823
4824
0
      r_symndx = ELF64_R_SYM (rel->r_info);
4825
0
      if (r_symndx < symtab_hdr->sh_info)
4826
0
  {
4827
0
    h = NULL;
4828
0
    isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, abfd, r_symndx);
4829
0
    if (isym == NULL)
4830
0
      return false;
4831
0
  }
4832
0
      else
4833
0
  {
4834
0
    isym = NULL;
4835
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4836
0
    h = elf_follow_link (h);
4837
4838
0
    if (h == htab->elf.hgot)
4839
0
      sec->has_toc_reloc = 1;
4840
0
  }
4841
4842
0
      r_type = ELF64_R_TYPE (rel->r_info);
4843
0
      switch (r_type)
4844
0
  {
4845
0
  case R_PPC64_D34:
4846
0
  case R_PPC64_D34_LO:
4847
0
  case R_PPC64_D34_HI30:
4848
0
  case R_PPC64_D34_HA30:
4849
0
  case R_PPC64_D28:
4850
0
  case R_PPC64_TPREL34:
4851
0
  case R_PPC64_DTPREL34:
4852
0
  case R_PPC64_PCREL34:
4853
0
  case R_PPC64_GOT_PCREL34:
4854
0
  case R_PPC64_GOT_TLSGD_PCREL34:
4855
0
  case R_PPC64_GOT_TLSLD_PCREL34:
4856
0
  case R_PPC64_GOT_TPREL_PCREL34:
4857
0
  case R_PPC64_GOT_DTPREL_PCREL34:
4858
0
  case R_PPC64_PLT_PCREL34:
4859
0
  case R_PPC64_PLT_PCREL34_NOTOC:
4860
0
  case R_PPC64_PCREL28:
4861
0
    htab->has_power10_relocs = 1;
4862
0
    break;
4863
0
  default:
4864
0
    break;
4865
0
  }
4866
4867
0
      switch (r_type)
4868
0
  {
4869
0
  case R_PPC64_PLT16_HA:
4870
0
  case R_PPC64_GOT_TLSLD16_HA:
4871
0
  case R_PPC64_GOT_TLSGD16_HA:
4872
0
  case R_PPC64_GOT_TPREL16_HA:
4873
0
  case R_PPC64_GOT_DTPREL16_HA:
4874
0
  case R_PPC64_GOT16_HA:
4875
0
  case R_PPC64_TOC16_HA:
4876
0
  case R_PPC64_PLT16_LO:
4877
0
  case R_PPC64_PLT16_LO_DS:
4878
0
  case R_PPC64_GOT_TLSLD16_LO:
4879
0
  case R_PPC64_GOT_TLSGD16_LO:
4880
0
  case R_PPC64_GOT_TPREL16_LO_DS:
4881
0
  case R_PPC64_GOT_DTPREL16_LO_DS:
4882
0
  case R_PPC64_GOT16_LO:
4883
0
  case R_PPC64_GOT16_LO_DS:
4884
0
  case R_PPC64_TOC16_LO:
4885
0
  case R_PPC64_TOC16_LO_DS:
4886
0
  case R_PPC64_GOT_PCREL34:
4887
0
    ppc64_elf_tdata (abfd)->has_optrel = 1;
4888
0
    ppc64_elf_section_data (sec)->has_optrel = 1;
4889
0
    break;
4890
0
  default:
4891
0
    break;
4892
0
  }
4893
4894
0
      ifunc = NULL;
4895
0
      if (h != NULL)
4896
0
  {
4897
0
    if (h->type == STT_GNU_IFUNC)
4898
0
      {
4899
0
        h->needs_plt = 1;
4900
0
        ifunc = &h->plt.plist;
4901
0
      }
4902
0
  }
4903
0
      else
4904
0
  {
4905
0
    if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4906
0
      {
4907
0
        ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4908
0
               rel->r_addend,
4909
0
               NON_GOT | PLT_IFUNC);
4910
0
        if (ifunc == NULL)
4911
0
    return false;
4912
0
      }
4913
0
  }
4914
4915
0
      tls_type = 0;
4916
0
      switch (r_type)
4917
0
  {
4918
0
  case R_PPC64_TLSGD:
4919
0
  case R_PPC64_TLSLD:
4920
    /* These special tls relocs tie a call to __tls_get_addr with
4921
       its parameter symbol.  */
4922
0
    if (h != NULL)
4923
0
      ppc_elf_hash_entry (h)->tls_mask |= TLS_TLS | TLS_MARK;
4924
0
    else
4925
0
      if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4926
0
          rel->r_addend,
4927
0
          NON_GOT | TLS_TLS | TLS_MARK))
4928
0
        return false;
4929
0
    sec->has_tls_reloc = 1;
4930
0
    break;
4931
4932
0
  case R_PPC64_GOT_TLSLD16:
4933
0
  case R_PPC64_GOT_TLSLD16_LO:
4934
0
  case R_PPC64_GOT_TLSLD16_HI:
4935
0
  case R_PPC64_GOT_TLSLD16_HA:
4936
0
  case R_PPC64_GOT_TLSLD_PCREL34:
4937
0
    tls_type = TLS_TLS | TLS_LD;
4938
0
    goto dogottls;
4939
4940
0
  case R_PPC64_GOT_TLSGD16:
4941
0
  case R_PPC64_GOT_TLSGD16_LO:
4942
0
  case R_PPC64_GOT_TLSGD16_HI:
4943
0
  case R_PPC64_GOT_TLSGD16_HA:
4944
0
  case R_PPC64_GOT_TLSGD_PCREL34:
4945
0
    tls_type = TLS_TLS | TLS_GD;
4946
0
    goto dogottls;
4947
4948
0
  case R_PPC64_GOT_TPREL16_DS:
4949
0
  case R_PPC64_GOT_TPREL16_LO_DS:
4950
0
  case R_PPC64_GOT_TPREL16_HI:
4951
0
  case R_PPC64_GOT_TPREL16_HA:
4952
0
  case R_PPC64_GOT_TPREL_PCREL34:
4953
0
    if (bfd_link_dll (info))
4954
0
      info->flags |= DF_STATIC_TLS;
4955
0
    tls_type = TLS_TLS | TLS_TPREL;
4956
0
    goto dogottls;
4957
4958
0
  case R_PPC64_GOT_DTPREL16_DS:
4959
0
  case R_PPC64_GOT_DTPREL16_LO_DS:
4960
0
  case R_PPC64_GOT_DTPREL16_HI:
4961
0
  case R_PPC64_GOT_DTPREL16_HA:
4962
0
  case R_PPC64_GOT_DTPREL_PCREL34:
4963
0
    tls_type = TLS_TLS | TLS_DTPREL;
4964
0
  dogottls:
4965
0
    sec->has_tls_reloc = 1;
4966
0
    goto dogot;
4967
4968
0
  case R_PPC64_GOT16:
4969
0
  case R_PPC64_GOT16_LO:
4970
0
  case R_PPC64_GOT16_HI:
4971
0
  case R_PPC64_GOT16_HA:
4972
0
  case R_PPC64_GOT16_DS:
4973
0
  case R_PPC64_GOT16_LO_DS:
4974
0
  case R_PPC64_GOT_PCREL34:
4975
0
  dogot:
4976
    /* This symbol requires a global offset table entry.  */
4977
0
    sec->has_toc_reloc = 1;
4978
0
    if (r_type == R_PPC64_GOT_TLSLD16
4979
0
        || r_type == R_PPC64_GOT_TLSGD16
4980
0
        || r_type == R_PPC64_GOT_TPREL16_DS
4981
0
        || r_type == R_PPC64_GOT_DTPREL16_DS
4982
0
        || r_type == R_PPC64_GOT16
4983
0
        || r_type == R_PPC64_GOT16_DS)
4984
0
      {
4985
0
        htab->do_multi_toc = 1;
4986
0
        ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
4987
0
      }
4988
4989
0
    if (ppc64_elf_tdata (abfd)->got == NULL
4990
0
        && !create_got_section (abfd, info))
4991
0
      return false;
4992
4993
0
    if (h != NULL)
4994
0
      {
4995
0
        struct ppc_link_hash_entry *eh;
4996
0
        struct got_entry *ent;
4997
4998
0
        eh = ppc_elf_hash_entry (h);
4999
0
        for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5000
0
    if (ent->addend == rel->r_addend
5001
0
        && ent->owner == abfd
5002
0
        && ent->tls_type == tls_type)
5003
0
      break;
5004
0
        if (ent == NULL)
5005
0
    {
5006
0
      size_t amt = sizeof (*ent);
5007
0
      ent = bfd_alloc (abfd, amt);
5008
0
      if (ent == NULL)
5009
0
        return false;
5010
0
      ent->next = eh->elf.got.glist;
5011
0
      ent->addend = rel->r_addend;
5012
0
      ent->owner = abfd;
5013
0
      ent->tls_type = tls_type;
5014
0
      ent->is_indirect = false;
5015
0
      ent->got.refcount = 0;
5016
0
      eh->elf.got.glist = ent;
5017
0
    }
5018
0
        ent->got.refcount += 1;
5019
0
        eh->tls_mask |= tls_type;
5020
0
      }
5021
0
    else
5022
      /* This is a global offset table entry for a local symbol.  */
5023
0
      if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5024
0
          rel->r_addend, tls_type))
5025
0
        return false;
5026
0
    break;
5027
5028
0
  case R_PPC64_PLT16_HA:
5029
0
  case R_PPC64_PLT16_HI:
5030
0
  case R_PPC64_PLT16_LO:
5031
0
  case R_PPC64_PLT16_LO_DS:
5032
0
  case R_PPC64_PLT_PCREL34:
5033
0
  case R_PPC64_PLT_PCREL34_NOTOC:
5034
0
  case R_PPC64_PLT32:
5035
0
  case R_PPC64_PLT64:
5036
    /* This symbol requires a procedure linkage table entry.  */
5037
0
    plt_list = ifunc;
5038
0
    if (h != NULL)
5039
0
      {
5040
0
        h->needs_plt = 1;
5041
0
        if (h->root.root.string[0] == '.'
5042
0
      && h->root.root.string[1] != '\0')
5043
0
    ppc_elf_hash_entry (h)->is_func = 1;
5044
0
        ppc_elf_hash_entry (h)->tls_mask |= PLT_KEEP;
5045
0
        plt_list = &h->plt.plist;
5046
0
      }
5047
0
    if (plt_list == NULL)
5048
0
      plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5049
0
                rel->r_addend,
5050
0
                NON_GOT | PLT_KEEP);
5051
0
    if (!update_plt_info (abfd, plt_list, rel->r_addend))
5052
0
      return false;
5053
0
    break;
5054
5055
    /* The following relocations don't need to propagate the
5056
       relocation if linking a shared object since they are
5057
       section relative.  */
5058
0
  case R_PPC64_SECTOFF:
5059
0
  case R_PPC64_SECTOFF_LO:
5060
0
  case R_PPC64_SECTOFF_HI:
5061
0
  case R_PPC64_SECTOFF_HA:
5062
0
  case R_PPC64_SECTOFF_DS:
5063
0
  case R_PPC64_SECTOFF_LO_DS:
5064
0
  case R_PPC64_DTPREL16:
5065
0
  case R_PPC64_DTPREL16_LO:
5066
0
  case R_PPC64_DTPREL16_HI:
5067
0
  case R_PPC64_DTPREL16_HA:
5068
0
  case R_PPC64_DTPREL16_DS:
5069
0
  case R_PPC64_DTPREL16_LO_DS:
5070
0
  case R_PPC64_DTPREL16_HIGH:
5071
0
  case R_PPC64_DTPREL16_HIGHA:
5072
0
  case R_PPC64_DTPREL16_HIGHER:
5073
0
  case R_PPC64_DTPREL16_HIGHERA:
5074
0
  case R_PPC64_DTPREL16_HIGHEST:
5075
0
  case R_PPC64_DTPREL16_HIGHESTA:
5076
0
    break;
5077
5078
    /* Nor do these.  */
5079
0
  case R_PPC64_REL16:
5080
0
  case R_PPC64_REL16_LO:
5081
0
  case R_PPC64_REL16_HI:
5082
0
  case R_PPC64_REL16_HA:
5083
0
  case R_PPC64_REL16_HIGH:
5084
0
  case R_PPC64_REL16_HIGHA:
5085
0
  case R_PPC64_REL16_HIGHER:
5086
0
  case R_PPC64_REL16_HIGHERA:
5087
0
  case R_PPC64_REL16_HIGHEST:
5088
0
  case R_PPC64_REL16_HIGHESTA:
5089
0
  case R_PPC64_REL16_HIGHER34:
5090
0
  case R_PPC64_REL16_HIGHERA34:
5091
0
  case R_PPC64_REL16_HIGHEST34:
5092
0
  case R_PPC64_REL16_HIGHESTA34:
5093
0
  case R_PPC64_REL16DX_HA:
5094
0
    break;
5095
5096
    /* Not supported as a dynamic relocation.  */
5097
0
  case R_PPC64_ADDR64_LOCAL:
5098
0
    if (bfd_link_pic (info))
5099
0
      {
5100
0
        if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5101
0
    ppc_howto_init ();
5102
        /* xgettext:c-format */
5103
0
        info->callbacks->einfo (_("%H: %s reloc unsupported "
5104
0
          "in shared libraries and PIEs\n"),
5105
0
              abfd, sec, rel->r_offset,
5106
0
              ppc64_elf_howto_table[r_type]->name);
5107
0
        bfd_set_error (bfd_error_bad_value);
5108
0
        return false;
5109
0
      }
5110
0
    break;
5111
5112
0
  case R_PPC64_TOC16:
5113
0
  case R_PPC64_TOC16_DS:
5114
0
    htab->do_multi_toc = 1;
5115
0
    ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5116
    /* Fall through.  */
5117
0
  case R_PPC64_TOC16_LO:
5118
0
  case R_PPC64_TOC16_HI:
5119
0
  case R_PPC64_TOC16_HA:
5120
0
  case R_PPC64_TOC16_LO_DS:
5121
0
    sec->has_toc_reloc = 1;
5122
0
    if (h != NULL && bfd_link_executable (info))
5123
0
      {
5124
        /* We may need a copy reloc.  */
5125
0
        h->non_got_ref = 1;
5126
        /* Strongly prefer a copy reloc over a dynamic reloc.
5127
     glibc ld.so as of 2019-08 will error out if one of
5128
     these relocations is emitted.  */
5129
0
        h->needs_copy = 1;
5130
0
        goto dodyn;
5131
0
      }
5132
0
    break;
5133
5134
    /* Marker reloc.  */
5135
0
  case R_PPC64_ENTRY:
5136
0
    break;
5137
5138
    /* This relocation describes the C++ object vtable hierarchy.
5139
       Reconstruct it for later use during GC.  */
5140
0
  case R_PPC64_GNU_VTINHERIT:
5141
0
    if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5142
0
      return false;
5143
0
    break;
5144
5145
    /* This relocation describes which C++ vtable entries are actually
5146
       used.  Record for later use during GC.  */
5147
0
  case R_PPC64_GNU_VTENTRY:
5148
0
    if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5149
0
      return false;
5150
0
    break;
5151
5152
0
  case R_PPC64_REL14:
5153
0
  case R_PPC64_REL14_BRTAKEN:
5154
0
  case R_PPC64_REL14_BRNTAKEN:
5155
0
    {
5156
0
      asection *dest = NULL;
5157
5158
      /* Heuristic: If jumping outside our section, chances are
5159
         we are going to need a stub.  */
5160
0
      if (h != NULL)
5161
0
        {
5162
    /* If the sym is weak it may be overridden later, so
5163
       don't assume we know where a weak sym lives.  */
5164
0
    if (h->root.type == bfd_link_hash_defined)
5165
0
      dest = h->root.u.def.section;
5166
0
        }
5167
0
      else
5168
0
        dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5169
5170
0
      if (dest != sec)
5171
0
        ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5172
0
    }
5173
0
    goto rel24;
5174
5175
0
  case R_PPC64_PLTCALL:
5176
0
  case R_PPC64_PLTCALL_NOTOC:
5177
0
    ppc64_elf_section_data (sec)->has_pltcall = 1;
5178
    /* Fall through.  */
5179
5180
0
  case R_PPC64_REL24:
5181
0
  case R_PPC64_REL24_NOTOC:
5182
0
  case R_PPC64_REL24_P9NOTOC:
5183
0
  rel24:
5184
0
    plt_list = ifunc;
5185
0
    if (h != NULL)
5186
0
      {
5187
0
        h->needs_plt = 1;
5188
0
        if (h->root.root.string[0] == '.'
5189
0
      && h->root.root.string[1] != '\0')
5190
0
    ppc_elf_hash_entry (h)->is_func = 1;
5191
5192
0
        if (h == tga || h == dottga)
5193
0
    {
5194
0
      sec->has_tls_reloc = 1;
5195
0
      if (rel != relocs
5196
0
          && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5197
0
        || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5198
        /* We have a new-style __tls_get_addr call with
5199
           a marker reloc.  */
5200
0
        ;
5201
0
      else
5202
        /* Mark this section as having an old-style call.  */
5203
0
        sec->nomark_tls_get_addr = 1;
5204
0
    }
5205
0
        plt_list = &h->plt.plist;
5206
0
      }
5207
5208
    /* We may need a .plt entry if the function this reloc
5209
       refers to is in a shared lib.  */
5210
0
    if (plt_list
5211
0
        && !update_plt_info (abfd, plt_list, rel->r_addend))
5212
0
      return false;
5213
0
    break;
5214
5215
0
  case R_PPC64_ADDR14:
5216
0
  case R_PPC64_ADDR14_BRNTAKEN:
5217
0
  case R_PPC64_ADDR14_BRTAKEN:
5218
0
  case R_PPC64_ADDR24:
5219
0
    goto dodyn;
5220
5221
0
  case R_PPC64_TPREL64:
5222
0
    tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5223
0
    if (bfd_link_dll (info))
5224
0
      info->flags |= DF_STATIC_TLS;
5225
0
    goto dotlstoc;
5226
5227
0
  case R_PPC64_DTPMOD64:
5228
0
    if (rel + 1 < rel_end
5229
0
        && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5230
0
        && rel[1].r_offset == rel->r_offset + 8)
5231
0
      tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5232
0
    else
5233
0
      tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5234
0
    goto dotlstoc;
5235
5236
0
  case R_PPC64_DTPREL64:
5237
0
    tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5238
0
    if (rel != relocs
5239
0
        && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5240
0
        && rel[-1].r_offset == rel->r_offset - 8)
5241
      /* This is the second reloc of a dtpmod, dtprel pair.
5242
         Don't mark with TLS_DTPREL.  */
5243
0
      goto dodyn;
5244
5245
0
  dotlstoc:
5246
0
    sec->has_tls_reloc = 1;
5247
0
    if (h != NULL)
5248
0
      ppc_elf_hash_entry (h)->tls_mask |= tls_type & 0xff;
5249
0
    else
5250
0
      if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5251
0
          rel->r_addend, tls_type))
5252
0
        return false;
5253
5254
0
    ppc64_sec = ppc64_elf_section_data (sec);
5255
0
    if (ppc64_sec->sec_type == sec_normal)
5256
0
      {
5257
0
        bfd_size_type amt;
5258
5259
        /* One extra to simplify get_tls_mask.  */
5260
0
        amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5261
0
        ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5262
0
        if (ppc64_sec->u.toc.symndx == NULL)
5263
0
    return false;
5264
0
        amt = sec->size * sizeof (bfd_vma) / 8;
5265
0
        ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5266
0
        if (ppc64_sec->u.toc.add == NULL)
5267
0
    return false;
5268
0
        ppc64_sec->sec_type = sec_toc;
5269
0
      }
5270
0
    if (ppc64_sec->sec_type != sec_toc
5271
0
        || rel->r_offset % 8 != 0)
5272
0
      {
5273
0
        info->callbacks->einfo (_("%H: %s reloc unsupported here\n"),
5274
0
              abfd, sec, rel->r_offset,
5275
0
              ppc64_elf_howto_table[r_type]->name);
5276
0
        bfd_set_error (bfd_error_bad_value);
5277
0
        return false;
5278
0
      }
5279
0
    ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5280
0
    ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5281
5282
    /* Mark the second slot of a GD or LD entry.
5283
       -1 to indicate GD and -2 to indicate LD.  */
5284
0
    if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5285
0
      ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5286
0
    else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5287
0
      ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5288
0
    goto dodyn;
5289
5290
0
  case R_PPC64_TPREL16_HI:
5291
0
  case R_PPC64_TPREL16_HA:
5292
0
  case R_PPC64_TPREL16_HIGH:
5293
0
  case R_PPC64_TPREL16_HIGHA:
5294
0
  case R_PPC64_TPREL16_HIGHER:
5295
0
  case R_PPC64_TPREL16_HIGHERA:
5296
0
  case R_PPC64_TPREL16_HIGHEST:
5297
0
  case R_PPC64_TPREL16_HIGHESTA:
5298
0
    sec->has_tls_reloc = 1;
5299
    /* Fall through.  */
5300
0
  case R_PPC64_TPREL34:
5301
0
  case R_PPC64_TPREL16:
5302
0
  case R_PPC64_TPREL16_DS:
5303
0
  case R_PPC64_TPREL16_LO:
5304
0
  case R_PPC64_TPREL16_LO_DS:
5305
0
    if (bfd_link_dll (info))
5306
0
      info->flags |= DF_STATIC_TLS;
5307
0
    goto dodyn;
5308
5309
0
  case R_PPC64_ADDR64:
5310
0
    if (is_opd
5311
0
        && rel + 1 < rel_end
5312
0
        && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5313
0
      {
5314
0
        if (h != NULL)
5315
0
    ppc_elf_hash_entry (h)->is_func = 1;
5316
0
      }
5317
    /* Fall through.  */
5318
5319
0
  case R_PPC64_ADDR16:
5320
0
  case R_PPC64_ADDR16_DS:
5321
0
  case R_PPC64_ADDR16_HA:
5322
0
  case R_PPC64_ADDR16_HI:
5323
0
  case R_PPC64_ADDR16_HIGH:
5324
0
  case R_PPC64_ADDR16_HIGHA:
5325
0
  case R_PPC64_ADDR16_HIGHER:
5326
0
  case R_PPC64_ADDR16_HIGHERA:
5327
0
  case R_PPC64_ADDR16_HIGHEST:
5328
0
  case R_PPC64_ADDR16_HIGHESTA:
5329
0
  case R_PPC64_ADDR16_LO:
5330
0
  case R_PPC64_ADDR16_LO_DS:
5331
0
  case R_PPC64_D34:
5332
0
  case R_PPC64_D34_LO:
5333
0
  case R_PPC64_D34_HI30:
5334
0
  case R_PPC64_D34_HA30:
5335
0
  case R_PPC64_ADDR16_HIGHER34:
5336
0
  case R_PPC64_ADDR16_HIGHERA34:
5337
0
  case R_PPC64_ADDR16_HIGHEST34:
5338
0
  case R_PPC64_ADDR16_HIGHESTA34:
5339
0
  case R_PPC64_D28:
5340
0
    if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5341
0
        && rel->r_addend == 0)
5342
0
      {
5343
        /* We may need a .plt entry if this reloc refers to a
5344
     function in a shared lib.  */
5345
0
        if (!update_plt_info (abfd, &h->plt.plist, 0))
5346
0
    return false;
5347
0
        h->pointer_equality_needed = 1;
5348
0
      }
5349
    /* Fall through.  */
5350
5351
0
  case R_PPC64_REL30:
5352
0
  case R_PPC64_REL32:
5353
0
  case R_PPC64_REL64:
5354
0
  case R_PPC64_ADDR32:
5355
0
  case R_PPC64_UADDR16:
5356
0
  case R_PPC64_UADDR32:
5357
0
  case R_PPC64_UADDR64:
5358
0
  case R_PPC64_TOC:
5359
0
    if (h != NULL && bfd_link_executable (info))
5360
      /* We may need a copy reloc.  */
5361
0
      h->non_got_ref = 1;
5362
5363
    /* Don't propagate .opd relocs.  */
5364
0
    if (NO_OPD_RELOCS && is_opd)
5365
0
      break;
5366
5367
    /* Set up information for symbols that might need dynamic
5368
       relocations.  At this point in linking we have read all
5369
       the input files and resolved most symbols, but have not
5370
       yet decided whether symbols are dynamic or finalized
5371
       symbol flags.  In some cases we might be setting dynamic
5372
       reloc info for symbols that do not end up needing such.
5373
       That's OK, adjust_dynamic_symbol and allocate_dynrelocs
5374
       work together with this code.  */
5375
0
  dodyn:
5376
0
    if ((h != NULL
5377
0
         && !SYMBOL_REFERENCES_LOCAL (info, h))
5378
0
        || (bfd_link_pic (info)
5379
0
      && (h != NULL
5380
0
          ? !bfd_is_abs_symbol (&h->root)
5381
0
          : isym->st_shndx != SHN_ABS)
5382
0
      && must_be_dyn_reloc (info, r_type))
5383
0
        || (!bfd_link_pic (info)
5384
0
      && ifunc != NULL))
5385
0
      {
5386
        /* We must copy these reloc types into the output file.
5387
     Create a reloc section in dynobj and make room for
5388
     this reloc.  */
5389
0
        if (sreloc == NULL)
5390
0
    {
5391
0
      sreloc = _bfd_elf_make_dynamic_reloc_section
5392
0
        (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ true);
5393
5394
0
      if (sreloc == NULL)
5395
0
        return false;
5396
0
    }
5397
5398
        /* If this is a global symbol, we count the number of
5399
     relocations we need for this symbol.  */
5400
0
        if (h != NULL)
5401
0
    {
5402
0
      struct ppc_dyn_relocs *p;
5403
0
      struct ppc_dyn_relocs **head;
5404
5405
0
      head = (struct ppc_dyn_relocs **) &h->dyn_relocs;
5406
0
      p = *head;
5407
0
      if (p == NULL || p->sec != sec)
5408
0
        {
5409
0
          p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5410
0
          if (p == NULL)
5411
0
      return false;
5412
0
          p->next = *head;
5413
0
          *head = p;
5414
0
          p->sec = sec;
5415
0
          p->count = 0;
5416
0
          p->pc_count = 0;
5417
0
          p->rel_count = 0;
5418
0
        }
5419
0
      p->count += 1;
5420
0
      if (!must_be_dyn_reloc (info, r_type))
5421
0
        p->pc_count += 1;
5422
0
      if (maybe_relr (r_type, rel, sec))
5423
0
        p->rel_count += 1;
5424
0
    }
5425
0
        else
5426
0
    {
5427
      /* Track dynamic relocs needed for local syms too.  */
5428
0
      struct ppc_local_dyn_relocs *p;
5429
0
      struct ppc_local_dyn_relocs **head;
5430
0
      bool is_ifunc;
5431
0
      asection *s;
5432
0
      void *vpp;
5433
5434
0
      s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5435
0
      if (s == NULL)
5436
0
        s = sec;
5437
5438
0
      vpp = &elf_section_data (s)->local_dynrel;
5439
0
      head = (struct ppc_local_dyn_relocs **) vpp;
5440
0
      is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5441
0
      p = *head;
5442
0
      if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5443
0
        p = p->next;
5444
0
      if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5445
0
        {
5446
0
          p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5447
0
          if (p == NULL)
5448
0
      return false;
5449
0
          p->next = *head;
5450
0
          *head = p;
5451
0
          p->sec = sec;
5452
0
          p->count = 0;
5453
0
          p->rel_count = 0;
5454
0
          p->ifunc = is_ifunc;
5455
0
        }
5456
0
      p->count += 1;
5457
0
      if (maybe_relr (r_type, rel, sec))
5458
0
        p->rel_count += 1;
5459
0
    }
5460
0
      }
5461
0
    break;
5462
5463
0
  default:
5464
0
    break;
5465
0
  }
5466
0
    }
5467
5468
0
  return true;
5469
0
}
5470
5471
/* Merge backend specific data from an object file to the output
5472
   object file when linking.  */
5473
5474
static bool
5475
ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
5476
0
{
5477
0
  bfd *obfd = info->output_bfd;
5478
0
  unsigned long iflags, oflags;
5479
5480
0
  if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5481
0
    return true;
5482
5483
0
  if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5484
0
    return true;
5485
5486
0
  if (!_bfd_generic_verify_endian_match (ibfd, info))
5487
0
    return false;
5488
5489
0
  iflags = elf_elfheader (ibfd)->e_flags;
5490
0
  oflags = elf_elfheader (obfd)->e_flags;
5491
5492
0
  if (iflags & ~EF_PPC64_ABI)
5493
0
    {
5494
0
      _bfd_error_handler
5495
  /* xgettext:c-format */
5496
0
  (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
5497
0
      bfd_set_error (bfd_error_bad_value);
5498
0
      return false;
5499
0
    }
5500
0
  else if (iflags != oflags && iflags != 0)
5501
0
    {
5502
0
      _bfd_error_handler
5503
  /* xgettext:c-format */
5504
0
  (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5505
0
   ibfd, iflags, oflags);
5506
0
      bfd_set_error (bfd_error_bad_value);
5507
0
      return false;
5508
0
    }
5509
5510
0
  if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
5511
0
    return false;
5512
5513
  /* Merge Tag_compatibility attributes and any common GNU ones.  */
5514
0
  return _bfd_elf_merge_object_attributes (ibfd, info);
5515
0
}
5516
5517
static bool
5518
ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5519
33
{
5520
  /* Print normal ELF private data.  */
5521
33
  _bfd_elf_print_private_bfd_data (abfd, ptr);
5522
5523
33
  if (elf_elfheader (abfd)->e_flags != 0)
5524
11
    {
5525
11
      FILE *file = ptr;
5526
5527
11
      fprintf (file, _("private flags = 0x%lx:"),
5528
11
         elf_elfheader (abfd)->e_flags);
5529
5530
11
      if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5531
6
  fprintf (file, _(" [abiv%ld]"),
5532
6
     elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5533
11
      fputc ('\n', file);
5534
11
    }
5535
5536
33
  return true;
5537
33
}
5538
5539
/* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5540
   of the code entry point, and its section, which must be in the same
5541
   object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
5542
5543
static bfd_vma
5544
opd_entry_value (asection *opd_sec,
5545
     bfd_vma offset,
5546
     asection **code_sec,
5547
     bfd_vma *code_off,
5548
     bool in_code_sec)
5549
0
{
5550
0
  bfd *opd_bfd = opd_sec->owner;
5551
0
  Elf_Internal_Rela *relocs;
5552
0
  Elf_Internal_Rela *lo, *hi, *look;
5553
0
  bfd_vma val;
5554
5555
0
  if (!is_ppc64_elf (opd_bfd))
5556
0
    return (bfd_vma) -1;
5557
5558
0
  if (ppc64_elf_section_data (opd_sec)->sec_type == sec_normal)
5559
0
    ppc64_elf_section_data (opd_sec)->sec_type = sec_opd;
5560
0
  else if (ppc64_elf_section_data (opd_sec)->sec_type != sec_opd)
5561
0
    return (bfd_vma) -1;
5562
5563
  /* No relocs implies we are linking a --just-symbols object, or looking
5564
     at a final linked executable with addr2line or somesuch.  */
5565
0
  if (opd_sec->reloc_count == 0)
5566
0
    {
5567
0
      bfd_byte *contents = ppc64_elf_section_data (opd_sec)->u.opd.u.contents;
5568
5569
0
      if (contents == NULL)
5570
0
  {
5571
0
    if ((opd_sec->flags & SEC_HAS_CONTENTS) == 0
5572
0
        || !bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5573
0
      return (bfd_vma) -1;
5574
0
    ppc64_elf_section_data (opd_sec)->u.opd.u.contents = contents;
5575
0
  }
5576
5577
      /* PR 17512: file: 64b9dfbb.  */
5578
0
      if (offset + 7 >= opd_sec->size || offset + 7 < offset)
5579
0
  return (bfd_vma) -1;
5580
5581
0
      val = bfd_get_64 (opd_bfd, contents + offset);
5582
0
      if (code_sec != NULL)
5583
0
  {
5584
0
    asection *sec, *likely = NULL;
5585
5586
0
    if (in_code_sec)
5587
0
      {
5588
0
        sec = *code_sec;
5589
0
        if (sec->vma <= val
5590
0
      && val < sec->vma + sec->size)
5591
0
    likely = sec;
5592
0
        else
5593
0
    val = -1;
5594
0
      }
5595
0
    else
5596
0
      for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5597
0
        if (sec->vma <= val
5598
0
      && (sec->flags & SEC_LOAD) != 0
5599
0
      && (sec->flags & SEC_ALLOC) != 0)
5600
0
    likely = sec;
5601
0
    if (likely != NULL)
5602
0
      {
5603
0
        *code_sec = likely;
5604
0
        if (code_off != NULL)
5605
0
    *code_off = val - likely->vma;
5606
0
      }
5607
0
  }
5608
0
      return val;
5609
0
    }
5610
5611
0
  relocs = ppc64_elf_section_data (opd_sec)->u.opd.u.relocs;
5612
0
  if (relocs == NULL)
5613
0
    relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, true);
5614
  /* PR 17512: file: df8e1fd6.  */
5615
0
  if (relocs == NULL)
5616
0
    return (bfd_vma) -1;
5617
5618
  /* Go find the opd reloc at the sym address.  */
5619
0
  lo = relocs;
5620
0
  hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5621
0
  val = (bfd_vma) -1;
5622
0
  while (lo < hi)
5623
0
    {
5624
0
      look = lo + (hi - lo) / 2;
5625
0
      if (look->r_offset < offset)
5626
0
  lo = look + 1;
5627
0
      else if (look->r_offset > offset)
5628
0
  hi = look;
5629
0
      else
5630
0
  {
5631
0
    Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5632
5633
0
    if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5634
0
        && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5635
0
      {
5636
0
        unsigned long symndx = ELF64_R_SYM (look->r_info);
5637
0
        asection *sec = NULL;
5638
5639
0
        if (symndx >= symtab_hdr->sh_info
5640
0
      && elf_sym_hashes (opd_bfd) != NULL)
5641
0
    {
5642
0
      struct elf_link_hash_entry **sym_hashes;
5643
0
      struct elf_link_hash_entry *rh;
5644
5645
0
      sym_hashes = elf_sym_hashes (opd_bfd);
5646
0
      rh = sym_hashes[symndx - symtab_hdr->sh_info];
5647
0
      if (rh != NULL)
5648
0
        {
5649
0
          rh = elf_follow_link (rh);
5650
0
          if (rh->root.type != bfd_link_hash_defined
5651
0
        && rh->root.type != bfd_link_hash_defweak)
5652
0
      break;
5653
0
          if (rh->root.u.def.section->owner == opd_bfd)
5654
0
      {
5655
0
        val = rh->root.u.def.value;
5656
0
        sec = rh->root.u.def.section;
5657
0
      }
5658
0
        }
5659
0
    }
5660
5661
0
        if (sec == NULL)
5662
0
    {
5663
0
      Elf_Internal_Sym *sym;
5664
5665
0
      if (symndx < symtab_hdr->sh_info)
5666
0
        {
5667
0
          sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5668
0
          if (sym == NULL)
5669
0
      {
5670
0
        size_t symcnt = symtab_hdr->sh_info;
5671
0
        sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5672
0
                  symcnt, 0,
5673
0
                  NULL, NULL, NULL);
5674
0
        if (sym == NULL)
5675
0
          break;
5676
0
        symtab_hdr->contents = (bfd_byte *) sym;
5677
0
      }
5678
0
          sym += symndx;
5679
0
        }
5680
0
      else
5681
0
        {
5682
0
          sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5683
0
              1, symndx,
5684
0
              NULL, NULL, NULL);
5685
0
          if (sym == NULL)
5686
0
      break;
5687
0
        }
5688
0
      sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5689
0
      if (sec == NULL)
5690
0
        break;
5691
0
      BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5692
0
      val = sym->st_value;
5693
0
    }
5694
5695
0
        val += look->r_addend;
5696
0
        if (code_off != NULL)
5697
0
    *code_off = val;
5698
0
        if (code_sec != NULL)
5699
0
    {
5700
0
      if (in_code_sec && *code_sec != sec)
5701
0
        return -1;
5702
0
      else
5703
0
        *code_sec = sec;
5704
0
    }
5705
0
        if (sec->output_section != NULL)
5706
0
    val += sec->output_section->vma + sec->output_offset;
5707
0
      }
5708
0
    break;
5709
0
  }
5710
0
    }
5711
5712
0
  return val;
5713
0
}
5714
5715
/* If the ELF symbol SYM might be a function in SEC, return the
5716
   function size and set *CODE_OFF to the function's entry point,
5717
   otherwise return zero.  */
5718
5719
static bfd_size_type
5720
ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5721
            bfd_vma *code_off)
5722
8.79k
{
5723
8.79k
  bfd_size_type size;
5724
8.79k
  elf_symbol_type * elf_sym = (elf_symbol_type *) sym;
5725
5726
8.79k
  if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5727
8.79k
         | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5728
1.65k
    return 0;
5729
5730
7.13k
  size = (sym->flags & BSF_SYNTHETIC) ? 0 : elf_sym->internal_elf_sym.st_size;
5731
5732
  /* In theory we should check that the symbol's type satisfies
5733
     _bfd_elf_is_function_type(), but there are some function-like
5734
     symbols which would fail this test.  (eg _start).  Instead
5735
     we check for hidden, local, notype symbols with zero size.
5736
     This type of symbol is generated by the annobin plugin for gcc
5737
     and clang, and should not be considered to be a function symbol.  */
5738
7.13k
  if (size == 0
5739
7.13k
      && ((sym->flags & (BSF_SYNTHETIC | BSF_LOCAL)) == BSF_LOCAL)
5740
7.13k
      && ELF_ST_TYPE (elf_sym->internal_elf_sym.st_info) == STT_NOTYPE
5741
7.13k
      && ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other) == STV_HIDDEN)
5742
36
    return 0;
5743
5744
7.09k
  if (strcmp (sym->section->name, ".opd") == 0)
5745
0
    {
5746
0
      struct _opd_sec_data *opd = get_opd_info (sym->section);
5747
0
      bfd_vma symval = sym->value;
5748
5749
0
      if (opd != NULL
5750
0
    && opd->adjust != NULL
5751
0
    && elf_section_data (sym->section)->relocs != NULL)
5752
0
  {
5753
    /* opd_entry_value will use cached relocs that have been
5754
       adjusted, but with raw symbols.  That means both local
5755
       and global symbols need adjusting.  */
5756
0
    long adjust = opd->adjust[OPD_NDX (symval)];
5757
0
    if (adjust == -1)
5758
0
      return 0;
5759
0
    symval += adjust;
5760
0
  }
5761
5762
0
      if (opd_entry_value (sym->section, symval,
5763
0
         &sec, code_off, true) == (bfd_vma) -1)
5764
0
  return 0;
5765
      /* An old ABI binary with dot-syms has a size of 24 on the .opd
5766
   symbol.  This size has nothing to do with the code size of the
5767
   function, which is what we're supposed to return, but the
5768
   code size isn't available without looking up the dot-sym.
5769
   However, doing that would be a waste of time particularly
5770
   since elf_find_function will look at the dot-sym anyway.
5771
   Now, elf_find_function will keep the largest size of any
5772
   function sym found at the code address of interest, so return
5773
   1 here to avoid it incorrectly caching a larger function size
5774
   for a small function.  This does mean we return the wrong
5775
   size for a new-ABI function of size 24, but all that does is
5776
   disable caching for such functions.  */
5777
0
      if (size == 24)
5778
0
  size = 1;
5779
0
    }
5780
7.09k
  else
5781
7.09k
    {
5782
7.09k
      if (sym->section != sec)
5783
7.06k
  return 0;
5784
33
      *code_off = sym->value;
5785
33
    }
5786
5787
  /* Do not return 0 for the function's size.  */
5788
33
  return size ? size : 1;
5789
7.09k
}
5790
5791
/* Return true if symbol is a strong function defined in an ELFv2
5792
   object with st_other localentry bits of zero, ie. its local entry
5793
   point coincides with its global entry point.  */
5794
5795
static bool
5796
is_elfv2_localentry0 (struct elf_link_hash_entry *h)
5797
0
{
5798
0
  return (h != NULL
5799
0
    && h->type == STT_FUNC
5800
0
    && h->root.type == bfd_link_hash_defined
5801
0
    && (STO_PPC64_LOCAL_MASK & h->other) == 0
5802
0
    && !ppc_elf_hash_entry (h)->non_zero_localentry
5803
0
    && is_ppc64_elf (h->root.u.def.section->owner)
5804
0
    && abiversion (h->root.u.def.section->owner) >= 2);
5805
0
}
5806
5807
/* Return true if symbol is defined in a regular object file.  */
5808
5809
static bool
5810
is_static_defined (struct elf_link_hash_entry *h)
5811
0
{
5812
0
  return ((h->root.type == bfd_link_hash_defined
5813
0
     || h->root.type == bfd_link_hash_defweak)
5814
0
    && h->root.u.def.section != NULL
5815
0
    && h->root.u.def.section->output_section != NULL);
5816
0
}
5817
5818
/* If FDH is a function descriptor symbol, return the associated code
5819
   entry symbol if it is defined.  Return NULL otherwise.  */
5820
5821
static struct ppc_link_hash_entry *
5822
defined_code_entry (struct ppc_link_hash_entry *fdh)
5823
0
{
5824
0
  if (fdh->is_func_descriptor)
5825
0
    {
5826
0
      struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5827
0
      if (fh->elf.root.type == bfd_link_hash_defined
5828
0
    || fh->elf.root.type == bfd_link_hash_defweak)
5829
0
  return fh;
5830
0
    }
5831
0
  return NULL;
5832
0
}
5833
5834
/* If FH is a function code entry symbol, return the associated
5835
   function descriptor symbol if it is defined.  Return NULL otherwise.  */
5836
5837
static struct ppc_link_hash_entry *
5838
defined_func_desc (struct ppc_link_hash_entry *fh)
5839
0
{
5840
0
  if (fh->oh != NULL
5841
0
      && fh->oh->is_func_descriptor)
5842
0
    {
5843
0
      struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5844
0
      if (fdh->elf.root.type == bfd_link_hash_defined
5845
0
    || fdh->elf.root.type == bfd_link_hash_defweak)
5846
0
  return fdh;
5847
0
    }
5848
0
  return NULL;
5849
0
}
5850
5851
/* Given H is a symbol that satisfies is_static_defined, return the
5852
   value in the output file.  */
5853
5854
static bfd_vma
5855
defined_sym_val (struct elf_link_hash_entry *h)
5856
0
{
5857
0
  return (h->root.u.def.section->output_section->vma
5858
0
    + h->root.u.def.section->output_offset
5859
0
    + h->root.u.def.value);
5860
0
}
5861
5862
/* Return true if H matches __tls_get_addr or one of its variants.  */
5863
5864
static bool
5865
is_tls_get_addr (struct elf_link_hash_entry *h,
5866
     struct ppc_link_hash_table *htab)
5867
0
{
5868
0
  return (h == elf_hash_entry (htab->tls_get_addr_fd)
5869
0
    || h == elf_hash_entry (htab->tga_desc_fd)
5870
0
    || h == elf_hash_entry (htab->tls_get_addr)
5871
0
    || h == elf_hash_entry (htab->tga_desc));
5872
0
}
5873
5874
static bool func_desc_adjust (struct elf_link_hash_entry *, void *);
5875
5876
/* Garbage collect sections, after first dealing with dot-symbols.  */
5877
5878
static bool
5879
ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
5880
0
{
5881
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
5882
5883
0
  if (htab != NULL && htab->need_func_desc_adj)
5884
0
    {
5885
0
      elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5886
0
      htab->need_func_desc_adj = 0;
5887
0
    }
5888
0
  return bfd_elf_gc_sections (abfd, info);
5889
0
}
5890
5891
/* Mark all our entry sym sections, both opd and code section.  */
5892
5893
static void
5894
ppc64_elf_gc_keep (struct bfd_link_info *info)
5895
0
{
5896
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
5897
0
  struct bfd_sym_chain *sym;
5898
5899
0
  if (htab == NULL)
5900
0
    return;
5901
5902
0
  for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5903
0
    {
5904
0
      struct ppc_link_hash_entry *eh, *fh;
5905
0
      asection *sec;
5906
5907
0
      eh = ppc_elf_hash_entry (elf_link_hash_lookup (&htab->elf, sym->name,
5908
0
                 false, false, true));
5909
0
      if (eh == NULL)
5910
0
  continue;
5911
0
      if (eh->elf.root.type != bfd_link_hash_defined
5912
0
    && eh->elf.root.type != bfd_link_hash_defweak)
5913
0
  continue;
5914
5915
0
      fh = defined_code_entry (eh);
5916
0
      if (fh != NULL)
5917
0
  {
5918
0
    sec = fh->elf.root.u.def.section;
5919
0
    sec->flags |= SEC_KEEP;
5920
0
  }
5921
0
      else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5922
0
         && opd_entry_value (eh->elf.root.u.def.section,
5923
0
           eh->elf.root.u.def.value,
5924
0
           &sec, NULL, false) != (bfd_vma) -1)
5925
0
  sec->flags |= SEC_KEEP;
5926
5927
0
      sec = eh->elf.root.u.def.section;
5928
0
      sec->flags |= SEC_KEEP;
5929
0
    }
5930
0
}
5931
5932
/* Mark sections containing dynamically referenced symbols.  When
5933
   building shared libraries, we must assume that any visible symbol is
5934
   referenced.  */
5935
5936
static bool
5937
ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5938
0
{
5939
0
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
5940
0
  struct ppc_link_hash_entry *eh = ppc_elf_hash_entry (h);
5941
0
  struct ppc_link_hash_entry *fdh;
5942
0
  struct bfd_elf_dynamic_list *d = info->dynamic_list;
5943
5944
  /* Dynamic linking info is on the func descriptor sym.  */
5945
0
  fdh = defined_func_desc (eh);
5946
0
  if (fdh != NULL)
5947
0
    eh = fdh;
5948
5949
0
  if ((eh->elf.root.type == bfd_link_hash_defined
5950
0
       || eh->elf.root.type == bfd_link_hash_defweak)
5951
0
      && (!eh->elf.start_stop
5952
0
    || eh->elf.root.ldscript_def
5953
0
    || !info->start_stop_gc)
5954
0
      && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
5955
0
    || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
5956
0
        && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5957
0
        && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5958
0
        && (!bfd_link_executable (info)
5959
0
      || info->gc_keep_exported
5960
0
      || info->export_dynamic
5961
0
      || (eh->elf.dynamic
5962
0
          && d != NULL
5963
0
          && (*d->match) (&d->head, NULL,
5964
0
              eh->elf.root.root.string)))
5965
0
        && (eh->elf.versioned >= versioned
5966
0
      || !bfd_hide_sym_by_version (info->version_info,
5967
0
                 eh->elf.root.root.string)))))
5968
0
    {
5969
0
      asection *code_sec;
5970
0
      struct ppc_link_hash_entry *fh;
5971
5972
0
      eh->elf.root.u.def.section->flags |= SEC_KEEP;
5973
5974
      /* Function descriptor syms cause the associated
5975
   function code sym section to be marked.  */
5976
0
      fh = defined_code_entry (eh);
5977
0
      if (fh != NULL)
5978
0
  {
5979
0
    code_sec = fh->elf.root.u.def.section;
5980
0
    code_sec->flags |= SEC_KEEP;
5981
0
  }
5982
0
      else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5983
0
         && opd_entry_value (eh->elf.root.u.def.section,
5984
0
           eh->elf.root.u.def.value,
5985
0
           &code_sec, NULL, false) != (bfd_vma) -1)
5986
0
  code_sec->flags |= SEC_KEEP;
5987
0
    }
5988
5989
0
  return true;
5990
0
}
5991
5992
/* Return the section that should be marked against GC for a given
5993
   relocation.  */
5994
5995
static asection *
5996
ppc64_elf_gc_mark_hook (asection *sec,
5997
      struct bfd_link_info *info,
5998
      Elf_Internal_Rela *rel,
5999
      struct elf_link_hash_entry *h,
6000
      Elf_Internal_Sym *sym)
6001
0
{
6002
0
  asection *rsec;
6003
6004
  /* Syms return NULL if we're marking .opd, so we avoid marking all
6005
     function sections, as all functions are referenced in .opd.  */
6006
0
  rsec = NULL;
6007
0
  if (get_opd_info (sec) != NULL)
6008
0
    return rsec;
6009
6010
0
  if (h != NULL)
6011
0
    {
6012
0
      enum elf_ppc64_reloc_type r_type;
6013
0
      struct ppc_link_hash_entry *eh, *fh, *fdh;
6014
6015
0
      r_type = ELF64_R_TYPE (rel->r_info);
6016
0
      switch (r_type)
6017
0
  {
6018
0
  case R_PPC64_GNU_VTINHERIT:
6019
0
  case R_PPC64_GNU_VTENTRY:
6020
0
    break;
6021
6022
0
  default:
6023
0
    switch (h->root.type)
6024
0
      {
6025
0
      case bfd_link_hash_defined:
6026
0
      case bfd_link_hash_defweak:
6027
0
        eh = ppc_elf_hash_entry (h);
6028
0
        fdh = defined_func_desc (eh);
6029
0
        if (fdh != NULL)
6030
0
    {
6031
      /* -mcall-aixdesc code references the dot-symbol on
6032
         a call reloc.  Mark the function descriptor too
6033
         against garbage collection.  */
6034
0
      fdh->elf.mark = 1;
6035
0
      if (fdh->elf.is_weakalias)
6036
0
        weakdef (&fdh->elf)->mark = 1;
6037
0
      eh = fdh;
6038
0
    }
6039
6040
        /* Function descriptor syms cause the associated
6041
     function code sym section to be marked.  */
6042
0
        fh = defined_code_entry (eh);
6043
0
        if (fh != NULL)
6044
0
    {
6045
      /* They also mark their opd section.  */
6046
0
      eh->elf.root.u.def.section->gc_mark = 1;
6047
6048
0
      rsec = fh->elf.root.u.def.section;
6049
0
    }
6050
0
        else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6051
0
           && opd_entry_value (eh->elf.root.u.def.section,
6052
0
             eh->elf.root.u.def.value,
6053
0
             &rsec, NULL, false) != (bfd_vma) -1)
6054
0
    eh->elf.root.u.def.section->gc_mark = 1;
6055
0
        else
6056
0
    rsec = h->root.u.def.section;
6057
0
        break;
6058
6059
0
      case bfd_link_hash_common:
6060
0
        rsec = h->root.u.c.p->section;
6061
0
        break;
6062
6063
0
      default:
6064
0
        return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6065
0
      }
6066
0
  }
6067
0
    }
6068
0
  else
6069
0
    {
6070
0
      struct _opd_sec_data *opd;
6071
6072
0
      rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6073
0
      opd = get_opd_info (rsec);
6074
0
      if (opd != NULL && opd->func_sec != NULL)
6075
0
  {
6076
0
    rsec->gc_mark = 1;
6077
6078
0
    rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6079
0
  }
6080
0
    }
6081
6082
0
  return rsec;
6083
0
}
6084
6085
/* The maximum size of .sfpr.  */
6086
0
#define SFPR_MAX (218*4)
6087
6088
struct sfpr_def_parms
6089
{
6090
  const char name[12];
6091
  unsigned char lo, hi;
6092
  bfd_byte *(*write_ent) (bfd *, bfd_byte *, int);
6093
  bfd_byte *(*write_tail) (bfd *, bfd_byte *, int);
6094
};
6095
6096
/* Auto-generate _save*, _rest* functions in .sfpr.
6097
   If STUB_SEC is non-null, define alias symbols in STUB_SEC
6098
   instead.  */
6099
6100
static bool
6101
sfpr_define (struct bfd_link_info *info,
6102
       const struct sfpr_def_parms *parm,
6103
       asection *stub_sec)
6104
0
{
6105
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
6106
0
  unsigned int i;
6107
0
  size_t len = strlen (parm->name);
6108
0
  bool writing = false;
6109
0
  char sym[16];
6110
6111
0
  if (htab == NULL)
6112
0
    return false;
6113
6114
0
  memcpy (sym, parm->name, len);
6115
0
  sym[len + 2] = 0;
6116
6117
0
  for (i = parm->lo; i <= parm->hi; i++)
6118
0
    {
6119
0
      struct ppc_link_hash_entry *h;
6120
6121
0
      sym[len + 0] = i / 10 + '0';
6122
0
      sym[len + 1] = i % 10 + '0';
6123
0
      h = ppc_elf_hash_entry (elf_link_hash_lookup (&htab->elf, sym,
6124
0
                writing, true, true));
6125
0
      if (stub_sec != NULL)
6126
0
  {
6127
0
    if (h != NULL
6128
0
        && h->elf.root.type == bfd_link_hash_defined
6129
0
        && h->elf.root.u.def.section == htab->sfpr)
6130
0
      {
6131
0
        struct elf_link_hash_entry *s;
6132
0
        char buf[32];
6133
0
        sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6134
0
        s = elf_link_hash_lookup (&htab->elf, buf, true, true, false);
6135
0
        if (s == NULL)
6136
0
    return false;
6137
0
        if (s->root.type == bfd_link_hash_new)
6138
0
    {
6139
0
      s->root.type = bfd_link_hash_defined;
6140
0
      s->root.u.def.section = stub_sec;
6141
0
      s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6142
0
           + h->elf.root.u.def.value);
6143
0
      s->ref_regular = 1;
6144
0
      s->def_regular = 1;
6145
0
      s->ref_regular_nonweak = 1;
6146
0
      s->forced_local = 1;
6147
0
      s->non_elf = 0;
6148
0
      s->root.linker_def = 1;
6149
0
    }
6150
0
      }
6151
0
    continue;
6152
0
  }
6153
0
      if (h != NULL)
6154
0
  {
6155
0
    h->save_res = 1;
6156
0
    if (!h->elf.def_regular)
6157
0
      {
6158
0
        h->elf.root.type = bfd_link_hash_defined;
6159
0
        h->elf.root.u.def.section = htab->sfpr;
6160
0
        h->elf.root.u.def.value = htab->sfpr->size;
6161
0
        h->elf.type = STT_FUNC;
6162
0
        h->elf.def_regular = 1;
6163
0
        h->elf.non_elf = 0;
6164
0
        _bfd_elf_link_hash_hide_symbol (info, &h->elf, true);
6165
0
        writing = true;
6166
0
        if (htab->sfpr->contents == NULL)
6167
0
    {
6168
0
      htab->sfpr->contents
6169
0
        = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6170
0
      if (htab->sfpr->contents == NULL)
6171
0
        return false;
6172
0
    }
6173
0
      }
6174
0
  }
6175
0
      if (writing)
6176
0
  {
6177
0
    bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6178
0
    if (i != parm->hi)
6179
0
      p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6180
0
    else
6181
0
      p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6182
0
    htab->sfpr->size = p - htab->sfpr->contents;
6183
0
  }
6184
0
    }
6185
6186
0
  return true;
6187
0
}
6188
6189
static bfd_byte *
6190
savegpr0 (bfd *abfd, bfd_byte *p, int r)
6191
0
{
6192
0
  bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6193
0
  return p + 4;
6194
0
}
6195
6196
static bfd_byte *
6197
savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6198
0
{
6199
0
  p = savegpr0 (abfd, p, r);
6200
0
  bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6201
0
  p = p + 4;
6202
0
  bfd_put_32 (abfd, BLR, p);
6203
0
  return p + 4;
6204
0
}
6205
6206
static bfd_byte *
6207
restgpr0 (bfd *abfd, bfd_byte *p, int r)
6208
0
{
6209
0
  bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6210
0
  return p + 4;
6211
0
}
6212
6213
static bfd_byte *
6214
restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6215
0
{
6216
0
  bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6217
0
  p = p + 4;
6218
0
  p = restgpr0 (abfd, p, r);
6219
0
  bfd_put_32 (abfd, MTLR_R0, p);
6220
0
  p = p + 4;
6221
0
  if (r == 29)
6222
0
    {
6223
0
      p = restgpr0 (abfd, p, 30);
6224
0
      p = restgpr0 (abfd, p, 31);
6225
0
    }
6226
0
  bfd_put_32 (abfd, BLR, p);
6227
0
  return p + 4;
6228
0
}
6229
6230
static bfd_byte *
6231
savegpr1 (bfd *abfd, bfd_byte *p, int r)
6232
0
{
6233
0
  bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6234
0
  return p + 4;
6235
0
}
6236
6237
static bfd_byte *
6238
savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6239
0
{
6240
0
  p = savegpr1 (abfd, p, r);
6241
0
  bfd_put_32 (abfd, BLR, p);
6242
0
  return p + 4;
6243
0
}
6244
6245
static bfd_byte *
6246
restgpr1 (bfd *abfd, bfd_byte *p, int r)
6247
0
{
6248
0
  bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6249
0
  return p + 4;
6250
0
}
6251
6252
static bfd_byte *
6253
restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6254
0
{
6255
0
  p = restgpr1 (abfd, p, r);
6256
0
  bfd_put_32 (abfd, BLR, p);
6257
0
  return p + 4;
6258
0
}
6259
6260
static bfd_byte *
6261
savefpr (bfd *abfd, bfd_byte *p, int r)
6262
0
{
6263
0
  bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6264
0
  return p + 4;
6265
0
}
6266
6267
static bfd_byte *
6268
savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6269
0
{
6270
0
  p = savefpr (abfd, p, r);
6271
0
  bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6272
0
  p = p + 4;
6273
0
  bfd_put_32 (abfd, BLR, p);
6274
0
  return p + 4;
6275
0
}
6276
6277
static bfd_byte *
6278
restfpr (bfd *abfd, bfd_byte *p, int r)
6279
0
{
6280
0
  bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6281
0
  return p + 4;
6282
0
}
6283
6284
static bfd_byte *
6285
restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6286
0
{
6287
0
  bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6288
0
  p = p + 4;
6289
0
  p = restfpr (abfd, p, r);
6290
0
  bfd_put_32 (abfd, MTLR_R0, p);
6291
0
  p = p + 4;
6292
0
  if (r == 29)
6293
0
    {
6294
0
      p = restfpr (abfd, p, 30);
6295
0
      p = restfpr (abfd, p, 31);
6296
0
    }
6297
0
  bfd_put_32 (abfd, BLR, p);
6298
0
  return p + 4;
6299
0
}
6300
6301
static bfd_byte *
6302
savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6303
0
{
6304
0
  p = savefpr (abfd, p, r);
6305
0
  bfd_put_32 (abfd, BLR, p);
6306
0
  return p + 4;
6307
0
}
6308
6309
static bfd_byte *
6310
restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6311
0
{
6312
0
  p = restfpr (abfd, p, r);
6313
0
  bfd_put_32 (abfd, BLR, p);
6314
0
  return p + 4;
6315
0
}
6316
6317
static bfd_byte *
6318
savevr (bfd *abfd, bfd_byte *p, int r)
6319
0
{
6320
0
  bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6321
0
  p = p + 4;
6322
0
  bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6323
0
  return p + 4;
6324
0
}
6325
6326
static bfd_byte *
6327
savevr_tail (bfd *abfd, bfd_byte *p, int r)
6328
0
{
6329
0
  p = savevr (abfd, p, r);
6330
0
  bfd_put_32 (abfd, BLR, p);
6331
0
  return p + 4;
6332
0
}
6333
6334
static bfd_byte *
6335
restvr (bfd *abfd, bfd_byte *p, int r)
6336
0
{
6337
0
  bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6338
0
  p = p + 4;
6339
0
  bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6340
0
  return p + 4;
6341
0
}
6342
6343
static bfd_byte *
6344
restvr_tail (bfd *abfd, bfd_byte *p, int r)
6345
0
{
6346
0
  p = restvr (abfd, p, r);
6347
0
  bfd_put_32 (abfd, BLR, p);
6348
0
  return p + 4;
6349
0
}
6350
6351
#define STDU_R1_0R1 0xf8210001
6352
#define ADDI_R1_R1  0x38210000
6353
6354
/* Emit prologue of wrapper preserving regs around a call to
6355
   __tls_get_addr_opt.  */
6356
6357
static bfd_byte *
6358
tls_get_addr_prologue (bfd *obfd, bfd_byte *p, struct ppc_link_hash_table *htab)
6359
0
{
6360
0
  unsigned int i;
6361
6362
0
  bfd_put_32 (obfd, MFLR_R0, p);
6363
0
  p += 4;
6364
0
  bfd_put_32 (obfd, STD_R0_0R1 + 16, p);
6365
0
  p += 4;
6366
6367
0
  if (htab->opd_abi)
6368
0
    {
6369
0
      for (i = 4; i < 12; i++)
6370
0
  {
6371
0
    bfd_put_32 (obfd,
6372
0
          STD_R0_0R1 | i << 21 | (-(13 - i) * 8 & 0xffff), p);
6373
0
    p += 4;
6374
0
  }
6375
0
      bfd_put_32 (obfd, STDU_R1_0R1 | (-128 & 0xffff), p);
6376
0
      p += 4;
6377
0
    }
6378
0
  else
6379
0
    {
6380
0
      for (i = 4; i < 12; i++)
6381
0
  {
6382
0
    bfd_put_32 (obfd,
6383
0
          STD_R0_0R1 | i << 21 | (-(12 - i) * 8 & 0xffff), p);
6384
0
    p += 4;
6385
0
  }
6386
0
      bfd_put_32 (obfd, STDU_R1_0R1 | (-96 & 0xffff), p);
6387
0
      p += 4;
6388
0
    }
6389
0
  return p;
6390
0
}
6391
6392
/* Emit epilogue of wrapper preserving regs around a call to
6393
   __tls_get_addr_opt.  */
6394
6395
static bfd_byte *
6396
tls_get_addr_epilogue (bfd *obfd, bfd_byte *p, struct ppc_link_hash_table *htab)
6397
0
{
6398
0
  unsigned int i;
6399
6400
0
  if (htab->opd_abi)
6401
0
    {
6402
0
      for (i = 4; i < 12; i++)
6403
0
  {
6404
0
    bfd_put_32 (obfd, LD_R0_0R1 | i << 21 | (128 - (13 - i) * 8), p);
6405
0
    p += 4;
6406
0
  }
6407
0
      bfd_put_32 (obfd, ADDI_R1_R1 | 128, p);
6408
0
      p += 4;
6409
0
    }
6410
0
  else
6411
0
    {
6412
0
      for (i = 4; i < 12; i++)
6413
0
  {
6414
0
    bfd_put_32 (obfd, LD_R0_0R1 | i << 21 | (96 - (12 - i) * 8), p);
6415
0
    p += 4;
6416
0
  }
6417
0
      bfd_put_32 (obfd, ADDI_R1_R1 | 96, p);
6418
0
      p += 4;
6419
0
    }
6420
0
  bfd_put_32 (obfd, LD_R0_0R1 | 16, p);
6421
0
  p += 4;
6422
0
  bfd_put_32 (obfd, MTLR_R0, p);
6423
0
  p += 4;
6424
0
  bfd_put_32 (obfd, BLR, p);
6425
0
  p += 4;
6426
0
  return p;
6427
0
}
6428
6429
/* Called via elf_link_hash_traverse to transfer dynamic linking
6430
   information on function code symbol entries to their corresponding
6431
   function descriptor symbol entries.  Must not be called twice for
6432
   any given code symbol.  */
6433
6434
static bool
6435
func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6436
0
{
6437
0
  struct bfd_link_info *info;
6438
0
  struct ppc_link_hash_table *htab;
6439
0
  struct ppc_link_hash_entry *fh;
6440
0
  struct ppc_link_hash_entry *fdh;
6441
0
  bool force_local;
6442
6443
0
  fh = ppc_elf_hash_entry (h);
6444
0
  if (fh->elf.root.type == bfd_link_hash_indirect)
6445
0
    return true;
6446
6447
0
  if (!fh->is_func)
6448
0
    return true;
6449
6450
0
  if (fh->elf.root.root.string[0] != '.'
6451
0
      || fh->elf.root.root.string[1] == '\0')
6452
0
    return true;
6453
6454
0
  info = inf;
6455
0
  htab = ppc_hash_table (info);
6456
0
  if (htab == NULL)
6457
0
    return false;
6458
6459
  /* Find the corresponding function descriptor symbol.  */
6460
0
  fdh = lookup_fdh (fh, htab);
6461
6462
  /* Resolve undefined references to dot-symbols as the value
6463
     in the function descriptor, if we have one in a regular object.
6464
     This is to satisfy cases like ".quad .foo".  Calls to functions
6465
     in dynamic objects are handled elsewhere.  */
6466
0
  if ((fh->elf.root.type == bfd_link_hash_undefined
6467
0
       || fh->elf.root.type == bfd_link_hash_undefweak)
6468
0
      && (fdh->elf.root.type == bfd_link_hash_defined
6469
0
    || fdh->elf.root.type == bfd_link_hash_defweak)
6470
0
      && get_opd_info (fdh->elf.root.u.def.section) != NULL
6471
0
      && opd_entry_value (fdh->elf.root.u.def.section,
6472
0
        fdh->elf.root.u.def.value,
6473
0
        &fh->elf.root.u.def.section,
6474
0
        &fh->elf.root.u.def.value, false) != (bfd_vma) -1)
6475
0
    {
6476
0
      fh->elf.root.type = fdh->elf.root.type;
6477
0
      fh->elf.forced_local = 1;
6478
0
      fh->elf.def_regular = fdh->elf.def_regular;
6479
0
      fh->elf.def_dynamic = fdh->elf.def_dynamic;
6480
0
    }
6481
6482
0
  if (!fh->elf.dynamic)
6483
0
    {
6484
0
      struct plt_entry *ent;
6485
6486
0
      for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6487
0
  if (ent->plt.refcount > 0)
6488
0
    break;
6489
0
      if (ent == NULL)
6490
0
  {
6491
0
    if (fdh != NULL && fdh->fake)
6492
0
      _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, true);
6493
0
    return true;
6494
0
  }
6495
0
    }
6496
6497
  /* Create a descriptor as undefined if necessary.  */
6498
0
  if (fdh == NULL
6499
0
      && !bfd_link_executable (info)
6500
0
      && (fh->elf.root.type == bfd_link_hash_undefined
6501
0
    || fh->elf.root.type == bfd_link_hash_undefweak))
6502
0
    {
6503
0
      fdh = make_fdh (info, fh);
6504
0
      if (fdh == NULL)
6505
0
  return false;
6506
0
    }
6507
6508
  /* We can't support overriding of symbols on a fake descriptor.  */
6509
0
  if (fdh != NULL
6510
0
      && fdh->fake
6511
0
      && (fh->elf.root.type == bfd_link_hash_defined
6512
0
    || fh->elf.root.type == bfd_link_hash_defweak))
6513
0
    _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, true);
6514
6515
  /* Transfer dynamic linking information to the function descriptor.  */
6516
0
  if (fdh != NULL)
6517
0
    {
6518
0
      fdh->elf.ref_regular |= fh->elf.ref_regular;
6519
0
      fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6520
0
      fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6521
0
      fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6522
0
      fdh->elf.dynamic |= fh->elf.dynamic;
6523
0
      fdh->elf.needs_plt |= (fh->elf.needs_plt
6524
0
           || fh->elf.type == STT_FUNC
6525
0
           || fh->elf.type == STT_GNU_IFUNC);
6526
0
      move_plt_plist (fh, fdh);
6527
6528
0
      if (!fdh->elf.forced_local
6529
0
    && fh->elf.dynindx != -1)
6530
0
  if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6531
0
    return false;
6532
0
    }
6533
6534
  /* Now that the info is on the function descriptor, clear the
6535
     function code sym info.  Any function code syms for which we
6536
     don't have a definition in a regular file, we force local.
6537
     This prevents a shared library from exporting syms that have
6538
     been imported from another library.  Function code syms that
6539
     are really in the library we must leave global to prevent the
6540
     linker dragging in a definition from a static library.  */
6541
0
  force_local = (!fh->elf.def_regular
6542
0
     || fdh == NULL
6543
0
     || !fdh->elf.def_regular
6544
0
     || fdh->elf.forced_local);
6545
0
  _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6546
6547
0
  return true;
6548
0
}
6549
6550
static const struct sfpr_def_parms save_res_funcs[] =
6551
  {
6552
    { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6553
    { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6554
    { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6555
    { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6556
    { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6557
    { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6558
    { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6559
    { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6560
    { "._savef", 14, 31, savefpr, savefpr1_tail },
6561
    { "._restf", 14, 31, restfpr, restfpr1_tail },
6562
    { "_savevr_", 20, 31, savevr, savevr_tail },
6563
    { "_restvr_", 20, 31, restvr, restvr_tail }
6564
  };
6565
6566
/* Called near the start of bfd_elf_size_dynamic_sections.  We use
6567
   this hook to a) run the edit functions in this file, b) provide
6568
   some gcc support functions, and c) transfer dynamic linking
6569
   information gathered so far on function code symbol entries, to
6570
   their corresponding function descriptor symbol entries.  */
6571
6572
static bool
6573
ppc64_elf_edit (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6574
0
{
6575
0
  struct ppc_link_hash_table *htab;
6576
6577
0
  htab = ppc_hash_table (info);
6578
0
  if (htab == NULL)
6579
0
    return false;
6580
6581
  /* Call back into the linker, which then runs the edit functions.  */
6582
0
  htab->params->edit ();
6583
6584
  /* Provide any missing _save* and _rest* functions.  */
6585
0
  if (htab->sfpr != NULL)
6586
0
    {
6587
0
      unsigned int i;
6588
6589
0
      htab->sfpr->size = 0;
6590
0
      for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
6591
0
  if (!sfpr_define (info, &save_res_funcs[i], NULL))
6592
0
    return false;
6593
0
      if (htab->sfpr->size == 0)
6594
0
  htab->sfpr->flags |= SEC_EXCLUDE;
6595
0
    }
6596
6597
0
  if (bfd_link_relocatable (info))
6598
0
    return true;
6599
6600
0
  if (htab->elf.hgot != NULL)
6601
0
    {
6602
0
      _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, true);
6603
      /* Make .TOC. defined so as to prevent it being made dynamic.
6604
   The wrong value here is fixed later in ppc64_elf_set_toc.  */
6605
0
      if (!htab->elf.hgot->def_regular
6606
0
    || htab->elf.hgot->root.type != bfd_link_hash_defined)
6607
0
  {
6608
0
    htab->elf.hgot->root.type = bfd_link_hash_defined;
6609
0
    htab->elf.hgot->root.u.def.value = 0;
6610
0
    htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6611
0
    htab->elf.hgot->def_regular = 1;
6612
0
    htab->elf.hgot->root.linker_def = 1;
6613
0
  }
6614
0
      htab->elf.hgot->type = STT_OBJECT;
6615
0
      htab->elf.hgot->other
6616
0
  = (htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
6617
0
    }
6618
6619
0
  return true;
6620
0
}
6621
6622
/* Return true if we have dynamic relocs against H or any of its weak
6623
   aliases, that apply to read-only sections.  Cannot be used after
6624
   size_dynamic_sections.  */
6625
6626
static bool
6627
alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
6628
0
{
6629
0
  struct ppc_link_hash_entry *eh = ppc_elf_hash_entry (h);
6630
0
  do
6631
0
    {
6632
0
      if (_bfd_elf_readonly_dynrelocs (&eh->elf))
6633
0
  return true;
6634
0
      eh = ppc_elf_hash_entry (eh->elf.u.alias);
6635
0
    }
6636
0
  while (eh != NULL && &eh->elf != h);
6637
6638
0
  return false;
6639
0
}
6640
6641
/* Return whether EH has pc-relative dynamic relocs.  */
6642
6643
static bool
6644
pc_dynrelocs (struct ppc_link_hash_entry *eh)
6645
0
{
6646
0
  struct ppc_dyn_relocs *p;
6647
6648
0
  for (p = (struct ppc_dyn_relocs *) eh->elf.dyn_relocs; p != NULL; p = p->next)
6649
0
    if (p->pc_count != 0)
6650
0
      return true;
6651
0
  return false;
6652
0
}
6653
6654
/* Return true if a global entry stub will be created for H.  Valid
6655
   for ELFv2 before plt entries have been allocated.  */
6656
6657
static bool
6658
global_entry_stub (struct elf_link_hash_entry *h)
6659
0
{
6660
0
  struct plt_entry *pent;
6661
6662
0
  if (!h->pointer_equality_needed
6663
0
      || h->def_regular)
6664
0
    return false;
6665
6666
0
  for (pent = h->plt.plist; pent != NULL; pent = pent->next)
6667
0
    if (pent->plt.refcount > 0
6668
0
  && pent->addend == 0)
6669
0
      return true;
6670
6671
0
  return false;
6672
0
}
6673
6674
/* Adjust a symbol defined by a dynamic object and referenced by a
6675
   regular object.  The current definition is in some section of the
6676
   dynamic object, but we're not including those sections.  We have to
6677
   change the definition to something the rest of the link can
6678
   understand.  */
6679
6680
static bool
6681
ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6682
         struct elf_link_hash_entry *h)
6683
0
{
6684
0
  struct ppc_link_hash_table *htab;
6685
0
  asection *s, *srel;
6686
6687
0
  htab = ppc_hash_table (info);
6688
0
  if (htab == NULL)
6689
0
    return false;
6690
6691
  /* Deal with function syms.  */
6692
0
  if (h->type == STT_FUNC
6693
0
      || h->type == STT_GNU_IFUNC
6694
0
      || h->needs_plt)
6695
0
    {
6696
0
      bool local = (ppc_elf_hash_entry (h)->save_res
6697
0
        || SYMBOL_CALLS_LOCAL (info, h)
6698
0
        || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
6699
      /* Discard dyn_relocs when non-pic if we've decided that a
6700
   function symbol is local and not an ifunc.  We keep dynamic
6701
   relocs for ifuncs when local rather than always emitting a
6702
   plt call stub for them and defining the symbol on the call
6703
   stub.  We can't do that for ELFv1 anyway (a function symbol
6704
   is defined on a descriptor, not code) and it can be faster at
6705
   run-time due to not needing to bounce through a stub.  The
6706
   dyn_relocs for ifuncs will be applied even in a static
6707
   executable.  */
6708
0
      if (!bfd_link_pic (info)
6709
0
    && h->type != STT_GNU_IFUNC
6710
0
    && local)
6711
0
  h->dyn_relocs = NULL;
6712
6713
      /* Clear procedure linkage table information for any symbol that
6714
   won't need a .plt entry.  */
6715
0
      struct plt_entry *ent;
6716
0
      for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6717
0
  if (ent->plt.refcount > 0)
6718
0
    break;
6719
0
      if (ent == NULL
6720
0
    || (h->type != STT_GNU_IFUNC
6721
0
        && local
6722
0
        && (htab->can_convert_all_inline_plt
6723
0
      || (ppc_elf_hash_entry (h)->tls_mask
6724
0
          & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
6725
0
  {
6726
0
    h->plt.plist = NULL;
6727
0
    h->needs_plt = 0;
6728
0
    h->pointer_equality_needed = 0;
6729
0
  }
6730
0
      else if (abiversion (info->output_bfd) >= 2)
6731
0
  {
6732
    /* Taking a function's address in a read/write section
6733
       doesn't require us to define the function symbol in the
6734
       executable on a global entry stub.  A dynamic reloc can
6735
       be used instead.  The reason we prefer a few more dynamic
6736
       relocs is that calling via a global entry stub costs a
6737
       few more instructions, and pointer_equality_needed causes
6738
       extra work in ld.so when resolving these symbols.  */
6739
0
    if (global_entry_stub (h))
6740
0
      {
6741
0
        if (!_bfd_elf_readonly_dynrelocs (h))
6742
0
    {
6743
0
      h->pointer_equality_needed = 0;
6744
      /* If we haven't seen a branch reloc and the symbol
6745
         isn't an ifunc then we don't need a plt entry.  */
6746
0
      if (!h->needs_plt)
6747
0
        h->plt.plist = NULL;
6748
0
    }
6749
0
        else if (!bfd_link_pic (info))
6750
    /* We are going to be defining the function symbol on the
6751
       plt stub, so no dyn_relocs needed when non-pic.  */
6752
0
    h->dyn_relocs = NULL;
6753
0
      }
6754
6755
    /* ELFv2 function symbols can't have copy relocs.  */
6756
0
    return true;
6757
0
  }
6758
0
      else if (!h->needs_plt
6759
0
         && !_bfd_elf_readonly_dynrelocs (h))
6760
0
  {
6761
    /* If we haven't seen a branch reloc and the symbol isn't an
6762
       ifunc then we don't need a plt entry.  */
6763
0
    h->plt.plist = NULL;
6764
0
    h->pointer_equality_needed = 0;
6765
0
    return true;
6766
0
  }
6767
0
    }
6768
0
  else
6769
0
    h->plt.plist = NULL;
6770
6771
  /* If this is a weak symbol, and there is a real definition, the
6772
     processor independent code will have arranged for us to see the
6773
     real definition first, and we can just use the same value.  */
6774
0
  if (h->is_weakalias)
6775
0
    {
6776
0
      struct elf_link_hash_entry *def = weakdef (h);
6777
0
      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
6778
0
      h->root.u.def.section = def->root.u.def.section;
6779
0
      h->root.u.def.value = def->root.u.def.value;
6780
0
      if (def->root.u.def.section == htab->elf.sdynbss
6781
0
    || def->root.u.def.section == htab->elf.sdynrelro)
6782
0
  h->dyn_relocs = NULL;
6783
0
      return true;
6784
0
    }
6785
6786
  /* If we are creating a shared library, we must presume that the
6787
     only references to the symbol are via the global offset table.
6788
     For such cases we need not do anything here; the relocations will
6789
     be handled correctly by relocate_section.  */
6790
0
  if (!bfd_link_executable (info))
6791
0
    return true;
6792
6793
  /* If there are no references to this symbol that do not use the
6794
     GOT, we don't need to generate a copy reloc.  */
6795
0
  if (!h->non_got_ref)
6796
0
    return true;
6797
6798
  /* Don't generate a copy reloc for symbols defined in the executable.  */
6799
0
  if (!h->def_dynamic || !h->ref_regular || h->def_regular
6800
6801
      /* If -z nocopyreloc was given, don't generate them either.  */
6802
0
      || info->nocopyreloc
6803
6804
      /* If we don't find any dynamic relocs in read-only sections, then
6805
   we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6806
0
      || (ELIMINATE_COPY_RELOCS
6807
0
    && !h->needs_copy
6808
0
    && !alias_readonly_dynrelocs (h))
6809
6810
      /* Protected variables do not work with .dynbss.  The copy in
6811
   .dynbss won't be used by the shared library with the protected
6812
   definition for the variable.  Text relocations are preferable
6813
   to an incorrect program.  */
6814
0
      || h->protected_def)
6815
0
    return true;
6816
6817
0
  if (h->type == STT_FUNC
6818
0
      || h->type == STT_GNU_IFUNC)
6819
0
    {
6820
      /* .dynbss copies of function symbols only work if we have
6821
   ELFv1 dot-symbols.  ELFv1 compilers since 2004 default to not
6822
   use dot-symbols and set the function symbol size to the text
6823
   size of the function rather than the size of the descriptor.
6824
   That's wrong for copying a descriptor.  */
6825
0
      if (ppc_elf_hash_entry (h)->oh == NULL
6826
0
    || !(h->size == 24 || h->size == 16))
6827
0
  return true;
6828
6829
      /* We should never get here, but unfortunately there are old
6830
   versions of gcc (circa gcc-3.2) that improperly for the
6831
   ELFv1 ABI put initialized function pointers, vtable refs and
6832
   suchlike in read-only sections.  Allow them to proceed, but
6833
   warn that this might break at runtime.  */
6834
0
      info->callbacks->einfo
6835
0
  (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6836
0
     "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6837
0
   h->root.root.string);
6838
0
    }
6839
6840
  /* This is a reference to a symbol defined by a dynamic object which
6841
     is not a function.  */
6842
6843
  /* We must allocate the symbol in our .dynbss section, which will
6844
     become part of the .bss section of the executable.  There will be
6845
     an entry for this symbol in the .dynsym section.  The dynamic
6846
     object will contain position independent code, so all references
6847
     from the dynamic object to this symbol will go through the global
6848
     offset table.  The dynamic linker will use the .dynsym entry to
6849
     determine the address it must put in the global offset table, so
6850
     both the dynamic object and the regular object will refer to the
6851
     same memory location for the variable.  */
6852
0
  if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
6853
0
    {
6854
0
      s = htab->elf.sdynrelro;
6855
0
      srel = htab->elf.sreldynrelro;
6856
0
    }
6857
0
  else
6858
0
    {
6859
0
      s = htab->elf.sdynbss;
6860
0
      srel = htab->elf.srelbss;
6861
0
    }
6862
0
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6863
0
    {
6864
      /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6865
   linker to copy the initial value out of the dynamic object
6866
   and into the runtime process image.  */
6867
0
      srel->size += sizeof (Elf64_External_Rela);
6868
0
      h->needs_copy = 1;
6869
0
    }
6870
6871
  /* We no longer want dyn_relocs.  */
6872
0
  h->dyn_relocs = NULL;
6873
0
  return _bfd_elf_adjust_dynamic_copy (info, h, s);
6874
0
}
6875
6876
/* If given a function descriptor symbol, hide both the function code
6877
   sym and the descriptor.  */
6878
static void
6879
ppc64_elf_hide_symbol (struct bfd_link_info *info,
6880
           struct elf_link_hash_entry *h,
6881
           bool force_local)
6882
0
{
6883
0
  struct ppc_link_hash_entry *eh;
6884
0
  _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6885
6886
0
  if (ppc_hash_table (info) == NULL)
6887
0
    return;
6888
6889
0
  eh = ppc_elf_hash_entry (h);
6890
0
  if (eh->is_func_descriptor)
6891
0
    {
6892
0
      struct ppc_link_hash_entry *fh = eh->oh;
6893
6894
0
      if (fh == NULL)
6895
0
  {
6896
0
    const char *p, *q;
6897
0
    struct elf_link_hash_table *htab = elf_hash_table (info);
6898
0
    char save;
6899
6900
    /* We aren't supposed to use alloca in BFD because on
6901
       systems which do not have alloca the version in libiberty
6902
       calls xmalloc, which might cause the program to crash
6903
       when it runs out of memory.  This function doesn't have a
6904
       return status, so there's no way to gracefully return an
6905
       error.  So cheat.  We know that string[-1] can be safely
6906
       accessed;  It's either a string in an ELF string table,
6907
       or allocated in an objalloc structure.  */
6908
6909
0
    p = eh->elf.root.root.string - 1;
6910
0
    save = *p;
6911
0
    *(char *) p = '.';
6912
0
    fh = ppc_elf_hash_entry (elf_link_hash_lookup (htab, p, false,
6913
0
               false, false));
6914
0
    *(char *) p = save;
6915
6916
    /* Unfortunately, if it so happens that the string we were
6917
       looking for was allocated immediately before this string,
6918
       then we overwrote the string terminator.  That's the only
6919
       reason the lookup should fail.  */
6920
0
    if (fh == NULL)
6921
0
      {
6922
0
        q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6923
0
        while (q >= eh->elf.root.root.string && *q == *p)
6924
0
    --q, --p;
6925
0
        if (q < eh->elf.root.root.string && *p == '.')
6926
0
    fh = ppc_elf_hash_entry (elf_link_hash_lookup (htab, p, false,
6927
0
                     false, false));
6928
0
      }
6929
0
    if (fh != NULL)
6930
0
      {
6931
0
        eh->oh = fh;
6932
0
        fh->oh = eh;
6933
0
      }
6934
0
  }
6935
0
      if (fh != NULL)
6936
0
  _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6937
0
    }
6938
0
}
6939
6940
static bool
6941
get_sym_h (struct elf_link_hash_entry **hp,
6942
     Elf_Internal_Sym **symp,
6943
     asection **symsecp,
6944
     unsigned char **tls_maskp,
6945
     Elf_Internal_Sym **locsymsp,
6946
     unsigned long r_symndx,
6947
     bfd *ibfd)
6948
0
{
6949
0
  Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6950
6951
0
  if (r_symndx >= symtab_hdr->sh_info)
6952
0
    {
6953
0
      struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6954
0
      struct elf_link_hash_entry *h;
6955
6956
0
      h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6957
0
      h = elf_follow_link (h);
6958
6959
0
      if (hp != NULL)
6960
0
  *hp = h;
6961
6962
0
      if (symp != NULL)
6963
0
  *symp = NULL;
6964
6965
0
      if (symsecp != NULL)
6966
0
  {
6967
0
    asection *symsec = NULL;
6968
0
    if (h->root.type == bfd_link_hash_defined
6969
0
        || h->root.type == bfd_link_hash_defweak)
6970
0
      symsec = h->root.u.def.section;
6971
0
    *symsecp = symsec;
6972
0
  }
6973
6974
0
      if (tls_maskp != NULL)
6975
0
  *tls_maskp = &ppc_elf_hash_entry (h)->tls_mask;
6976
0
    }
6977
0
  else
6978
0
    {
6979
0
      Elf_Internal_Sym *sym;
6980
0
      Elf_Internal_Sym *locsyms = *locsymsp;
6981
6982
0
      if (locsyms == NULL)
6983
0
  {
6984
0
    locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6985
0
    if (locsyms == NULL)
6986
0
      locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6987
0
              symtab_hdr->sh_info,
6988
0
              0, NULL, NULL, NULL);
6989
0
    if (locsyms == NULL)
6990
0
      return false;
6991
0
    *locsymsp = locsyms;
6992
0
  }
6993
0
      sym = locsyms + r_symndx;
6994
6995
0
      if (hp != NULL)
6996
0
  *hp = NULL;
6997
6998
0
      if (symp != NULL)
6999
0
  *symp = sym;
7000
7001
0
      if (symsecp != NULL)
7002
0
  *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7003
7004
0
      if (tls_maskp != NULL)
7005
0
  {
7006
0
    struct got_entry **lgot_ents;
7007
0
    unsigned char *tls_mask;
7008
7009
0
    tls_mask = NULL;
7010
0
    lgot_ents = elf_local_got_ents (ibfd);
7011
0
    if (lgot_ents != NULL)
7012
0
      {
7013
0
        struct plt_entry **local_plt = (struct plt_entry **)
7014
0
    (lgot_ents + symtab_hdr->sh_info);
7015
0
        unsigned char *lgot_masks = (unsigned char *)
7016
0
    (local_plt + symtab_hdr->sh_info);
7017
0
        tls_mask = &lgot_masks[r_symndx];
7018
0
      }
7019
0
    *tls_maskp = tls_mask;
7020
0
  }
7021
0
    }
7022
0
  return true;
7023
0
}
7024
7025
/* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7026
   error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7027
   type suitable for optimization, and 1 otherwise.  */
7028
7029
static int
7030
get_tls_mask (unsigned char **tls_maskp,
7031
        unsigned long *toc_symndx,
7032
        bfd_vma *toc_addend,
7033
        Elf_Internal_Sym **locsymsp,
7034
        const Elf_Internal_Rela *rel,
7035
        bfd *ibfd)
7036
0
{
7037
0
  unsigned long r_symndx;
7038
0
  int next_r;
7039
0
  struct elf_link_hash_entry *h;
7040
0
  Elf_Internal_Sym *sym;
7041
0
  asection *sec;
7042
0
  bfd_vma off;
7043
7044
0
  r_symndx = ELF64_R_SYM (rel->r_info);
7045
0
  if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7046
0
    return 0;
7047
7048
0
  if ((*tls_maskp != NULL
7049
0
       && (**tls_maskp & TLS_TLS) != 0
7050
0
       && **tls_maskp != (TLS_TLS | TLS_MARK))
7051
0
      || sec == NULL
7052
0
      || ppc64_elf_section_data (sec) == NULL
7053
0
      || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7054
0
    return 1;
7055
7056
  /* Look inside a TOC section too.  */
7057
0
  if (h != NULL)
7058
0
    {
7059
0
      BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7060
0
      off = h->root.u.def.value;
7061
0
    }
7062
0
  else
7063
0
    off = sym->st_value;
7064
0
  off += rel->r_addend;
7065
0
  BFD_ASSERT (off % 8 == 0);
7066
0
  r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7067
0
  next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7068
0
  if (toc_symndx != NULL)
7069
0
    *toc_symndx = r_symndx;
7070
0
  if (toc_addend != NULL)
7071
0
    *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7072
0
  if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7073
0
    return 0;
7074
0
  if ((h == NULL || is_static_defined (h))
7075
0
      && (next_r == -1 || next_r == -2))
7076
0
    return 1 - next_r;
7077
0
  return 1;
7078
0
}
7079
7080
/* Find (or create) an entry in the tocsave hash table.  */
7081
7082
static struct tocsave_entry *
7083
tocsave_find (struct ppc_link_hash_table *htab,
7084
        enum insert_option insert,
7085
        Elf_Internal_Sym **local_syms,
7086
        const Elf_Internal_Rela *irela,
7087
        bfd *ibfd)
7088
0
{
7089
0
  unsigned long r_indx;
7090
0
  struct elf_link_hash_entry *h;
7091
0
  Elf_Internal_Sym *sym;
7092
0
  struct tocsave_entry ent, *p;
7093
0
  hashval_t hash;
7094
0
  struct tocsave_entry **slot;
7095
7096
0
  r_indx = ELF64_R_SYM (irela->r_info);
7097
0
  if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7098
0
    return NULL;
7099
0
  if (ent.sec == NULL || ent.sec->output_section == NULL)
7100
0
    {
7101
0
      _bfd_error_handler
7102
0
  (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7103
0
      return NULL;
7104
0
    }
7105
7106
0
  if (h != NULL)
7107
0
    ent.offset = h->root.u.def.value;
7108
0
  else
7109
0
    ent.offset = sym->st_value;
7110
0
  ent.offset += irela->r_addend;
7111
7112
0
  hash = tocsave_htab_hash (&ent);
7113
0
  slot = ((struct tocsave_entry **)
7114
0
    htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7115
0
  if (slot == NULL)
7116
0
    return NULL;
7117
7118
0
  if (*slot == NULL)
7119
0
    {
7120
0
      p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7121
0
      if (p == NULL)
7122
0
  return NULL;
7123
0
      *p = ent;
7124
0
      *slot = p;
7125
0
    }
7126
0
  return *slot;
7127
0
}
7128
7129
/* Adjust all global syms defined in opd sections.  In gcc generated
7130
   code for the old ABI, these will already have been done.  */
7131
7132
static bool
7133
adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7134
0
{
7135
0
  struct ppc_link_hash_entry *eh;
7136
0
  asection *sym_sec;
7137
0
  struct _opd_sec_data *opd;
7138
7139
0
  if (h->root.type == bfd_link_hash_indirect)
7140
0
    return true;
7141
7142
0
  if (h->root.type != bfd_link_hash_defined
7143
0
      && h->root.type != bfd_link_hash_defweak)
7144
0
    return true;
7145
7146
0
  eh = ppc_elf_hash_entry (h);
7147
0
  if (eh->adjust_done)
7148
0
    return true;
7149
7150
0
  sym_sec = eh->elf.root.u.def.section;
7151
0
  opd = get_opd_info (sym_sec);
7152
0
  if (opd != NULL && opd->adjust != NULL)
7153
0
    {
7154
0
      long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7155
0
      if (adjust == -1)
7156
0
  {
7157
    /* This entry has been deleted.  */
7158
0
    asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7159
0
    if (dsec == NULL)
7160
0
      {
7161
0
        for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7162
0
    if (discarded_section (dsec))
7163
0
      {
7164
0
        ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7165
0
        break;
7166
0
      }
7167
0
      }
7168
0
    eh->elf.root.u.def.value = 0;
7169
0
    eh->elf.root.u.def.section = dsec;
7170
0
  }
7171
0
      else
7172
0
  eh->elf.root.u.def.value += adjust;
7173
0
      eh->adjust_done = 1;
7174
0
    }
7175
0
  return true;
7176
0
}
7177
7178
/* Handles decrementing dynamic reloc counts for the reloc specified by
7179
   R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7180
   have already been determined.  */
7181
7182
static bool
7183
dec_dynrel_count (const Elf_Internal_Rela *rel,
7184
      asection *sec,
7185
      struct bfd_link_info *info,
7186
      Elf_Internal_Sym **local_syms,
7187
      struct elf_link_hash_entry *h,
7188
      Elf_Internal_Sym *sym)
7189
0
{
7190
0
  enum elf_ppc64_reloc_type r_type;
7191
0
  asection *sym_sec = NULL;
7192
7193
  /* Can this reloc be dynamic?  This switch, and later tests here
7194
     should be kept in sync with the code in check_relocs.  */
7195
0
  r_type = ELF64_R_TYPE (rel->r_info);
7196
0
  switch (r_type)
7197
0
    {
7198
0
    default:
7199
0
      return true;
7200
7201
0
    case R_PPC64_TOC16:
7202
0
    case R_PPC64_TOC16_DS:
7203
0
    case R_PPC64_TOC16_LO:
7204
0
    case R_PPC64_TOC16_HI:
7205
0
    case R_PPC64_TOC16_HA:
7206
0
    case R_PPC64_TOC16_LO_DS:
7207
0
      if (h == NULL)
7208
0
  return true;
7209
0
      break;
7210
7211
0
    case R_PPC64_TPREL16:
7212
0
    case R_PPC64_TPREL16_LO:
7213
0
    case R_PPC64_TPREL16_HI:
7214
0
    case R_PPC64_TPREL16_HA:
7215
0
    case R_PPC64_TPREL16_DS:
7216
0
    case R_PPC64_TPREL16_LO_DS:
7217
0
    case R_PPC64_TPREL16_HIGH:
7218
0
    case R_PPC64_TPREL16_HIGHA:
7219
0
    case R_PPC64_TPREL16_HIGHER:
7220
0
    case R_PPC64_TPREL16_HIGHERA:
7221
0
    case R_PPC64_TPREL16_HIGHEST:
7222
0
    case R_PPC64_TPREL16_HIGHESTA:
7223
0
    case R_PPC64_TPREL64:
7224
0
    case R_PPC64_TPREL34:
7225
0
    case R_PPC64_DTPMOD64:
7226
0
    case R_PPC64_DTPREL64:
7227
0
    case R_PPC64_ADDR64:
7228
0
    case R_PPC64_REL30:
7229
0
    case R_PPC64_REL32:
7230
0
    case R_PPC64_REL64:
7231
0
    case R_PPC64_ADDR14:
7232
0
    case R_PPC64_ADDR14_BRNTAKEN:
7233
0
    case R_PPC64_ADDR14_BRTAKEN:
7234
0
    case R_PPC64_ADDR16:
7235
0
    case R_PPC64_ADDR16_DS:
7236
0
    case R_PPC64_ADDR16_HA:
7237
0
    case R_PPC64_ADDR16_HI:
7238
0
    case R_PPC64_ADDR16_HIGH:
7239
0
    case R_PPC64_ADDR16_HIGHA:
7240
0
    case R_PPC64_ADDR16_HIGHER:
7241
0
    case R_PPC64_ADDR16_HIGHERA:
7242
0
    case R_PPC64_ADDR16_HIGHEST:
7243
0
    case R_PPC64_ADDR16_HIGHESTA:
7244
0
    case R_PPC64_ADDR16_LO:
7245
0
    case R_PPC64_ADDR16_LO_DS:
7246
0
    case R_PPC64_ADDR24:
7247
0
    case R_PPC64_ADDR32:
7248
0
    case R_PPC64_UADDR16:
7249
0
    case R_PPC64_UADDR32:
7250
0
    case R_PPC64_UADDR64:
7251
0
    case R_PPC64_TOC:
7252
0
    case R_PPC64_D34:
7253
0
    case R_PPC64_D34_LO:
7254
0
    case R_PPC64_D34_HI30:
7255
0
    case R_PPC64_D34_HA30:
7256
0
    case R_PPC64_ADDR16_HIGHER34:
7257
0
    case R_PPC64_ADDR16_HIGHERA34:
7258
0
    case R_PPC64_ADDR16_HIGHEST34:
7259
0
    case R_PPC64_ADDR16_HIGHESTA34:
7260
0
    case R_PPC64_D28:
7261
0
      break;
7262
0
    }
7263
7264
0
  if (local_syms != NULL)
7265
0
    {
7266
0
      unsigned long r_symndx;
7267
0
      bfd *ibfd = sec->owner;
7268
7269
0
      r_symndx = ELF64_R_SYM (rel->r_info);
7270
0
      if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7271
0
  return false;
7272
0
    }
7273
7274
0
  if ((h != NULL
7275
0
       && !SYMBOL_REFERENCES_LOCAL (info, h))
7276
0
      || (bfd_link_pic (info)
7277
0
    && (h != NULL
7278
0
        ? !bfd_is_abs_symbol (&h->root)
7279
0
        : sym_sec != bfd_abs_section_ptr)
7280
0
    && must_be_dyn_reloc (info, r_type))
7281
0
      || (!bfd_link_pic (info)
7282
0
    && (h != NULL
7283
0
        ? h->type == STT_GNU_IFUNC
7284
0
        : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
7285
0
    ;
7286
0
  else
7287
0
    return true;
7288
7289
0
  if (h != NULL)
7290
0
    {
7291
0
      struct ppc_dyn_relocs *p;
7292
0
      struct ppc_dyn_relocs **pp;
7293
0
      pp = (struct ppc_dyn_relocs **) &h->dyn_relocs;
7294
7295
      /* elf_gc_sweep may have already removed all dyn relocs associated
7296
   with local syms for a given section.  Also, symbol flags are
7297
   changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7298
   report a dynreloc miscount.  */
7299
0
      if (*pp == NULL && info->gc_sections)
7300
0
  return true;
7301
7302
0
      while ((p = *pp) != NULL)
7303
0
  {
7304
0
    if (p->sec == sec)
7305
0
      {
7306
0
        if (!must_be_dyn_reloc (info, r_type))
7307
0
    p->pc_count -= 1;
7308
0
        if (maybe_relr (r_type, rel, sec))
7309
0
    p->rel_count -= 1;
7310
0
        p->count -= 1;
7311
0
        if (p->count == 0)
7312
0
    *pp = p->next;
7313
0
        return true;
7314
0
      }
7315
0
    pp = &p->next;
7316
0
  }
7317
0
    }
7318
0
  else
7319
0
    {
7320
0
      struct ppc_local_dyn_relocs *p;
7321
0
      struct ppc_local_dyn_relocs **pp;
7322
0
      void *vpp;
7323
0
      bool is_ifunc;
7324
7325
0
      if (local_syms == NULL)
7326
0
  sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7327
0
      if (sym_sec == NULL)
7328
0
  sym_sec = sec;
7329
7330
0
      vpp = &elf_section_data (sym_sec)->local_dynrel;
7331
0
      pp = (struct ppc_local_dyn_relocs **) vpp;
7332
7333
0
      if (*pp == NULL && info->gc_sections)
7334
0
  return true;
7335
7336
0
      is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7337
0
      while ((p = *pp) != NULL)
7338
0
  {
7339
0
    if (p->sec == sec && p->ifunc == is_ifunc)
7340
0
      {
7341
0
        if (maybe_relr (r_type, rel, sec))
7342
0
    p->rel_count -= 1;
7343
0
        p->count -= 1;
7344
0
        if (p->count == 0)
7345
0
    *pp = p->next;
7346
0
        return true;
7347
0
      }
7348
0
    pp = &p->next;
7349
0
  }
7350
0
    }
7351
7352
  /* xgettext:c-format */
7353
0
  _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7354
0
          sec->owner, sec);
7355
0
  bfd_set_error (bfd_error_bad_value);
7356
0
  return false;
7357
0
}
7358
7359
/* Remove unused Official Procedure Descriptor entries.  Currently we
7360
   only remove those associated with functions in discarded link-once
7361
   sections, or weakly defined functions that have been overridden.  It
7362
   would be possible to remove many more entries for statically linked
7363
   applications.  */
7364
7365
bool
7366
ppc64_elf_edit_opd (struct bfd_link_info *info)
7367
0
{
7368
0
  bfd *ibfd;
7369
0
  bool some_edited = false;
7370
0
  asection *need_pad = NULL;
7371
0
  struct ppc_link_hash_table *htab;
7372
7373
0
  htab = ppc_hash_table (info);
7374
0
  if (htab == NULL)
7375
0
    return false;
7376
7377
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7378
0
    {
7379
0
      asection *sec;
7380
0
      Elf_Internal_Rela *relstart, *rel, *relend;
7381
0
      Elf_Internal_Shdr *symtab_hdr;
7382
0
      Elf_Internal_Sym *local_syms;
7383
0
      struct _opd_sec_data *opd;
7384
0
      bool need_edit, add_aux_fields, broken;
7385
0
      bfd_size_type cnt_16b = 0;
7386
7387
0
      if (!is_ppc64_elf (ibfd))
7388
0
  continue;
7389
7390
0
      sec = bfd_get_section_by_name (ibfd, ".opd");
7391
0
      if (sec == NULL
7392
0
    || sec->size == 0
7393
0
    || (sec->flags & SEC_HAS_CONTENTS) == 0)
7394
0
  continue;
7395
7396
0
      if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7397
0
  continue;
7398
7399
0
      if (sec->output_section == bfd_abs_section_ptr)
7400
0
  continue;
7401
7402
      /* Look through the section relocs.  */
7403
0
      if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7404
0
  continue;
7405
7406
0
      local_syms = NULL;
7407
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
7408
7409
      /* Read the relocations.  */
7410
0
      relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7411
0
              info->keep_memory);
7412
0
      if (relstart == NULL)
7413
0
  return false;
7414
7415
      /* First run through the relocs to check they are sane, and to
7416
   determine whether we need to edit this opd section.  */
7417
0
      need_edit = false;
7418
0
      broken = false;
7419
0
      need_pad = sec;
7420
0
      relend = relstart + sec->reloc_count;
7421
0
      for (rel = relstart; rel < relend; )
7422
0
  {
7423
0
    enum elf_ppc64_reloc_type r_type;
7424
0
    unsigned long r_symndx;
7425
0
    asection *sym_sec;
7426
0
    struct elf_link_hash_entry *h;
7427
0
    Elf_Internal_Sym *sym;
7428
0
    bfd_vma offset;
7429
7430
    /* .opd contains an array of 16 or 24 byte entries.  We're
7431
       only interested in the reloc pointing to a function entry
7432
       point.  */
7433
0
    offset = rel->r_offset;
7434
0
    if (rel + 1 == relend
7435
0
        || rel[1].r_offset != offset + 8)
7436
0
      {
7437
        /* If someone messes with .opd alignment then after a
7438
     "ld -r" we might have padding in the middle of .opd.
7439
     Also, there's nothing to prevent someone putting
7440
     something silly in .opd with the assembler.  No .opd
7441
     optimization for them!  */
7442
0
      broken_opd:
7443
0
        _bfd_error_handler
7444
0
    (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7445
0
        broken = true;
7446
0
        break;
7447
0
      }
7448
7449
0
    if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7450
0
        || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7451
0
      {
7452
0
        _bfd_error_handler
7453
    /* xgettext:c-format */
7454
0
    (_("%pB: unexpected reloc type %u in .opd section"),
7455
0
     ibfd, r_type);
7456
0
        broken = true;
7457
0
        break;
7458
0
      }
7459
7460
0
    r_symndx = ELF64_R_SYM (rel->r_info);
7461
0
    if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7462
0
        r_symndx, ibfd))
7463
0
      goto error_ret;
7464
7465
0
    if (sym_sec == NULL || sym_sec->owner == NULL)
7466
0
      {
7467
0
        const char *sym_name;
7468
0
        if (h != NULL)
7469
0
    sym_name = h->root.root.string;
7470
0
        else
7471
0
    sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7472
0
               sym_sec);
7473
7474
0
        _bfd_error_handler
7475
    /* xgettext:c-format */
7476
0
    (_("%pB: undefined sym `%s' in .opd section"),
7477
0
     ibfd, sym_name);
7478
0
        broken = true;
7479
0
        break;
7480
0
      }
7481
7482
    /* opd entries are always for functions defined in the
7483
       current input bfd.  If the symbol isn't defined in the
7484
       input bfd, then we won't be using the function in this
7485
       bfd;  It must be defined in a linkonce section in another
7486
       bfd, or is weak.  It's also possible that we are
7487
       discarding the function due to a linker script /DISCARD/,
7488
       which we test for via the output_section.  */
7489
0
    if (sym_sec->owner != ibfd
7490
0
        || sym_sec->output_section == bfd_abs_section_ptr)
7491
0
      need_edit = true;
7492
7493
0
    rel += 2;
7494
0
    if (rel + 1 == relend
7495
0
        || (rel + 2 < relend
7496
0
      && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7497
0
      ++rel;
7498
7499
0
    if (rel == relend)
7500
0
      {
7501
0
        if (sec->size == offset + 24)
7502
0
    {
7503
0
      need_pad = NULL;
7504
0
      break;
7505
0
    }
7506
0
        if (sec->size == offset + 16)
7507
0
    {
7508
0
      cnt_16b++;
7509
0
      break;
7510
0
    }
7511
0
        goto broken_opd;
7512
0
      }
7513
0
    else if (rel + 1 < relend
7514
0
       && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7515
0
       && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7516
0
      {
7517
0
        if (rel[0].r_offset == offset + 16)
7518
0
    cnt_16b++;
7519
0
        else if (rel[0].r_offset != offset + 24)
7520
0
    goto broken_opd;
7521
0
      }
7522
0
    else
7523
0
      goto broken_opd;
7524
0
  }
7525
7526
0
      add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7527
7528
0
      if (!broken && (need_edit || add_aux_fields))
7529
0
  {
7530
0
    Elf_Internal_Rela *write_rel;
7531
0
    Elf_Internal_Shdr *rel_hdr;
7532
0
    bfd_byte *rptr, *wptr;
7533
0
    bfd_byte *new_contents;
7534
0
    bfd_size_type amt;
7535
7536
0
    new_contents = NULL;
7537
0
    amt = OPD_NDX (sec->size) * sizeof (long);
7538
0
    opd = &ppc64_elf_section_data (sec)->u.opd;
7539
0
    opd->adjust = bfd_zalloc (sec->owner, amt);
7540
0
    if (opd->adjust == NULL)
7541
0
      return false;
7542
7543
    /* This seems a waste of time as input .opd sections are all
7544
       zeros as generated by gcc, but I suppose there's no reason
7545
       this will always be so.  We might start putting something in
7546
       the third word of .opd entries.  */
7547
0
    if ((sec->flags & SEC_IN_MEMORY) == 0)
7548
0
      {
7549
0
        bfd_byte *loc;
7550
0
        if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7551
0
    {
7552
0
      free (loc);
7553
0
    error_ret:
7554
0
      if (symtab_hdr->contents != (unsigned char *) local_syms)
7555
0
        free (local_syms);
7556
0
      if (elf_section_data (sec)->relocs != relstart)
7557
0
        free (relstart);
7558
0
      return false;
7559
0
    }
7560
0
        sec->contents = loc;
7561
0
        sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7562
0
      }
7563
7564
0
    elf_section_data (sec)->relocs = relstart;
7565
7566
0
    new_contents = sec->contents;
7567
0
    if (add_aux_fields)
7568
0
      {
7569
0
        new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7570
0
        if (new_contents == NULL)
7571
0
    return false;
7572
0
        need_pad = NULL;
7573
0
      }
7574
0
    wptr = new_contents;
7575
0
    rptr = sec->contents;
7576
0
    write_rel = relstart;
7577
0
    for (rel = relstart; rel < relend; )
7578
0
      {
7579
0
        unsigned long r_symndx;
7580
0
        asection *sym_sec;
7581
0
        struct elf_link_hash_entry *h;
7582
0
        struct ppc_link_hash_entry *fdh = NULL;
7583
0
        Elf_Internal_Sym *sym;
7584
0
        long opd_ent_size;
7585
0
        Elf_Internal_Rela *next_rel;
7586
0
        bool skip;
7587
7588
0
        r_symndx = ELF64_R_SYM (rel->r_info);
7589
0
        if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7590
0
            r_symndx, ibfd))
7591
0
    goto error_ret;
7592
7593
0
        next_rel = rel + 2;
7594
0
        if (next_rel + 1 == relend
7595
0
      || (next_rel + 2 < relend
7596
0
          && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7597
0
    ++next_rel;
7598
7599
        /* See if the .opd entry is full 24 byte or
7600
     16 byte (with fd_aux entry overlapped with next
7601
     fd_func).  */
7602
0
        opd_ent_size = 24;
7603
0
        if (next_rel == relend)
7604
0
    {
7605
0
      if (sec->size == rel->r_offset + 16)
7606
0
        opd_ent_size = 16;
7607
0
    }
7608
0
        else if (next_rel->r_offset == rel->r_offset + 16)
7609
0
    opd_ent_size = 16;
7610
7611
0
        if (h != NULL
7612
0
      && h->root.root.string[0] == '.')
7613
0
    {
7614
0
      fdh = ppc_elf_hash_entry (h)->oh;
7615
0
      if (fdh != NULL)
7616
0
        {
7617
0
          fdh = ppc_follow_link (fdh);
7618
0
          if (fdh->elf.root.type != bfd_link_hash_defined
7619
0
        && fdh->elf.root.type != bfd_link_hash_defweak)
7620
0
      fdh = NULL;
7621
0
        }
7622
0
    }
7623
7624
0
        skip = (sym_sec->owner != ibfd
7625
0
          || sym_sec->output_section == bfd_abs_section_ptr);
7626
0
        if (skip)
7627
0
    {
7628
0
      if (fdh != NULL && sym_sec->owner == ibfd)
7629
0
        {
7630
          /* Arrange for the function descriptor sym
7631
       to be dropped.  */
7632
0
          fdh->elf.root.u.def.value = 0;
7633
0
          fdh->elf.root.u.def.section = sym_sec;
7634
0
        }
7635
0
      opd->adjust[OPD_NDX (rel->r_offset)] = -1;
7636
7637
0
      if (NO_OPD_RELOCS || bfd_link_relocatable (info))
7638
0
        rel = next_rel;
7639
0
      else
7640
0
        while (1)
7641
0
          {
7642
0
      if (!dec_dynrel_count (rel, sec, info,
7643
0
                 NULL, h, sym))
7644
0
        goto error_ret;
7645
7646
0
      if (++rel == next_rel)
7647
0
        break;
7648
7649
0
      r_symndx = ELF64_R_SYM (rel->r_info);
7650
0
      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7651
0
          r_symndx, ibfd))
7652
0
        goto error_ret;
7653
0
          }
7654
0
    }
7655
0
        else
7656
0
    {
7657
      /* We'll be keeping this opd entry.  */
7658
0
      long adjust;
7659
7660
0
      if (fdh != NULL)
7661
0
        {
7662
          /* Redefine the function descriptor symbol to
7663
       this location in the opd section.  It is
7664
       necessary to update the value here rather
7665
       than using an array of adjustments as we do
7666
       for local symbols, because various places
7667
       in the generic ELF code use the value
7668
       stored in u.def.value.  */
7669
0
          fdh->elf.root.u.def.value = wptr - new_contents;
7670
0
          fdh->adjust_done = 1;
7671
0
        }
7672
7673
      /* Local syms are a bit tricky.  We could
7674
         tweak them as they can be cached, but
7675
         we'd need to look through the local syms
7676
         for the function descriptor sym which we
7677
         don't have at the moment.  So keep an
7678
         array of adjustments.  */
7679
0
      adjust = (wptr - new_contents) - (rptr - sec->contents);
7680
0
      opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
7681
7682
0
      if (wptr != rptr)
7683
0
        memcpy (wptr, rptr, opd_ent_size);
7684
0
      wptr += opd_ent_size;
7685
0
      if (add_aux_fields && opd_ent_size == 16)
7686
0
        {
7687
0
          memset (wptr, '\0', 8);
7688
0
          wptr += 8;
7689
0
        }
7690
7691
      /* We need to adjust any reloc offsets to point to the
7692
         new opd entries.  */
7693
0
      for ( ; rel != next_rel; ++rel)
7694
0
        {
7695
0
          rel->r_offset += adjust;
7696
0
          if (write_rel != rel)
7697
0
      memcpy (write_rel, rel, sizeof (*rel));
7698
0
          ++write_rel;
7699
0
        }
7700
0
    }
7701
7702
0
        rptr += opd_ent_size;
7703
0
      }
7704
7705
0
    sec->size = wptr - new_contents;
7706
0
    sec->reloc_count = write_rel - relstart;
7707
0
    if (add_aux_fields)
7708
0
      {
7709
0
        free (sec->contents);
7710
0
        sec->contents = new_contents;
7711
0
      }
7712
7713
    /* Fudge the header size too, as this is used later in
7714
       elf_bfd_final_link if we are emitting relocs.  */
7715
0
    rel_hdr = _bfd_elf_single_rel_hdr (sec);
7716
0
    rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7717
0
    some_edited = true;
7718
0
  }
7719
0
      else if (elf_section_data (sec)->relocs != relstart)
7720
0
  free (relstart);
7721
7722
0
      if (local_syms != NULL
7723
0
    && symtab_hdr->contents != (unsigned char *) local_syms)
7724
0
  {
7725
0
    if (!info->keep_memory)
7726
0
      free (local_syms);
7727
0
    else
7728
0
      symtab_hdr->contents = (unsigned char *) local_syms;
7729
0
  }
7730
0
    }
7731
7732
0
  if (some_edited)
7733
0
    elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7734
7735
  /* If we are doing a final link and the last .opd entry is just 16 byte
7736
     long, add a 8 byte padding after it.  */
7737
0
  if (need_pad != NULL && !bfd_link_relocatable (info))
7738
0
    {
7739
0
      bfd_byte *p;
7740
7741
0
      if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7742
0
  {
7743
0
    BFD_ASSERT (need_pad->size > 0);
7744
7745
0
    p = bfd_malloc (need_pad->size + 8);
7746
0
    if (p == NULL)
7747
0
      return false;
7748
7749
0
    if (!bfd_get_section_contents (need_pad->owner, need_pad,
7750
0
           p, 0, need_pad->size))
7751
0
      return false;
7752
7753
0
    need_pad->contents = p;
7754
0
    need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7755
0
  }
7756
0
      else
7757
0
  {
7758
0
    p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7759
0
    if (p == NULL)
7760
0
      return false;
7761
7762
0
    need_pad->contents = p;
7763
0
  }
7764
7765
0
      memset (need_pad->contents + need_pad->size, 0, 8);
7766
0
      need_pad->size += 8;
7767
0
    }
7768
7769
0
  return true;
7770
0
}
7771
7772
/* Analyze inline PLT call relocations to see whether calls to locally
7773
   defined functions can be converted to direct calls.  */
7774
7775
bool
7776
ppc64_elf_inline_plt (struct bfd_link_info *info)
7777
0
{
7778
0
  struct ppc_link_hash_table *htab;
7779
0
  bfd *ibfd;
7780
0
  asection *sec;
7781
0
  bfd_vma low_vma, high_vma, limit;
7782
7783
0
  htab = ppc_hash_table (info);
7784
0
  if (htab == NULL)
7785
0
    return false;
7786
7787
  /* A bl insn can reach -0x2000000 to 0x1fffffc.  The limit is
7788
     reduced somewhat to cater for possible stubs that might be added
7789
     between the call and its destination.  */
7790
0
  if (htab->params->group_size < 0)
7791
0
    {
7792
0
      limit = -htab->params->group_size;
7793
0
      if (limit == 1)
7794
0
  limit = 0x1e00000;
7795
0
    }
7796
0
  else
7797
0
    {
7798
0
      limit = htab->params->group_size;
7799
0
      if (limit == 1)
7800
0
  limit = 0x1c00000;
7801
0
    }
7802
7803
0
  low_vma = -1;
7804
0
  high_vma = 0;
7805
0
  for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
7806
0
    if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
7807
0
      {
7808
0
  if (low_vma > sec->vma)
7809
0
    low_vma = sec->vma;
7810
0
  if (high_vma < sec->vma + sec->size)
7811
0
    high_vma = sec->vma + sec->size;
7812
0
      }
7813
7814
  /* If a "bl" can reach anywhere in local code sections, then we can
7815
     convert all inline PLT sequences to direct calls when the symbol
7816
     is local.  */
7817
0
  if (high_vma - low_vma < limit)
7818
0
    {
7819
0
      htab->can_convert_all_inline_plt = 1;
7820
0
      return true;
7821
0
    }
7822
7823
  /* Otherwise, go looking through relocs for cases where a direct
7824
     call won't reach.  Mark the symbol on any such reloc to disable
7825
     the optimization and keep the PLT entry as it seems likely that
7826
     this will be better than creating trampolines.  Note that this
7827
     will disable the optimization for all inline PLT calls to a
7828
     particular symbol, not just those that won't reach.  The
7829
     difficulty in doing a more precise optimization is that the
7830
     linker needs to make a decision depending on whether a
7831
     particular R_PPC64_PLTCALL insn can be turned into a direct
7832
     call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7833
     the sequence, and there is nothing that ties those relocs
7834
     together except their symbol.  */
7835
7836
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7837
0
    {
7838
0
      Elf_Internal_Shdr *symtab_hdr;
7839
0
      Elf_Internal_Sym *local_syms;
7840
7841
0
      if (!is_ppc64_elf (ibfd))
7842
0
  continue;
7843
7844
0
      local_syms = NULL;
7845
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
7846
7847
0
      for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7848
0
  if (ppc64_elf_section_data (sec)->has_pltcall
7849
0
      && !bfd_is_abs_section (sec->output_section))
7850
0
    {
7851
0
      Elf_Internal_Rela *relstart, *rel, *relend;
7852
7853
      /* Read the relocations.  */
7854
0
      relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7855
0
              info->keep_memory);
7856
0
      if (relstart == NULL)
7857
0
        return false;
7858
7859
0
      relend = relstart + sec->reloc_count;
7860
0
      for (rel = relstart; rel < relend; rel++)
7861
0
        {
7862
0
    enum elf_ppc64_reloc_type r_type;
7863
0
    unsigned long r_symndx;
7864
0
    asection *sym_sec;
7865
0
    struct elf_link_hash_entry *h;
7866
0
    Elf_Internal_Sym *sym;
7867
0
    unsigned char *tls_maskp;
7868
7869
0
    r_type = ELF64_R_TYPE (rel->r_info);
7870
0
    if (r_type != R_PPC64_PLTCALL
7871
0
        && r_type != R_PPC64_PLTCALL_NOTOC)
7872
0
      continue;
7873
7874
0
    r_symndx = ELF64_R_SYM (rel->r_info);
7875
0
    if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
7876
0
        r_symndx, ibfd))
7877
0
      {
7878
0
        if (elf_section_data (sec)->relocs != relstart)
7879
0
          free (relstart);
7880
0
        if (symtab_hdr->contents != (bfd_byte *) local_syms)
7881
0
          free (local_syms);
7882
0
        return false;
7883
0
      }
7884
7885
0
    if (sym_sec != NULL && sym_sec->output_section != NULL)
7886
0
      {
7887
0
        bfd_vma from, to;
7888
0
        if (h != NULL)
7889
0
          to = h->root.u.def.value;
7890
0
        else
7891
0
          to = sym->st_value;
7892
0
        to += (rel->r_addend
7893
0
         + sym_sec->output_offset
7894
0
         + sym_sec->output_section->vma);
7895
0
        from = (rel->r_offset
7896
0
          + sec->output_offset
7897
0
          + sec->output_section->vma);
7898
0
        if (to - from + limit < 2 * limit
7899
0
      && !(r_type == R_PPC64_PLTCALL_NOTOC
7900
0
           && (((h ? h->other : sym->st_other)
7901
0
          & STO_PPC64_LOCAL_MASK)
7902
0
         > 1 << STO_PPC64_LOCAL_BIT)))
7903
0
          *tls_maskp &= ~PLT_KEEP;
7904
0
      }
7905
0
        }
7906
0
      if (elf_section_data (sec)->relocs != relstart)
7907
0
        free (relstart);
7908
0
    }
7909
7910
0
      if (local_syms != NULL
7911
0
    && symtab_hdr->contents != (unsigned char *) local_syms)
7912
0
  {
7913
0
    if (!info->keep_memory)
7914
0
      free (local_syms);
7915
0
    else
7916
0
      symtab_hdr->contents = (unsigned char *) local_syms;
7917
0
  }
7918
0
    }
7919
7920
0
  return true;
7921
0
}
7922
7923
/* Set htab->tls_get_addr and various other info specific to TLS.
7924
   This needs to run before dynamic symbols are processed in
7925
   bfd_elf_size_dynamic_sections.  */
7926
7927
bool
7928
ppc64_elf_tls_setup (struct bfd_link_info *info)
7929
0
{
7930
0
  struct ppc_link_hash_table *htab;
7931
0
  struct elf_link_hash_entry *tga, *tga_fd, *desc, *desc_fd;
7932
7933
0
  htab = ppc_hash_table (info);
7934
0
  if (htab == NULL)
7935
0
    return false;
7936
7937
  /* Move dynamic linking info to the function descriptor sym.  */
7938
0
  if (htab->need_func_desc_adj)
7939
0
    {
7940
0
      elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7941
0
      htab->need_func_desc_adj = 0;
7942
0
    }
7943
7944
0
  if (abiversion (info->output_bfd) == 1)
7945
0
    htab->opd_abi = 1;
7946
7947
0
  if (htab->params->no_multi_toc)
7948
0
    htab->do_multi_toc = 0;
7949
0
  else if (!htab->do_multi_toc)
7950
0
    htab->params->no_multi_toc = 1;
7951
7952
  /* Default to --no-plt-localentry, as this option can cause problems
7953
     with symbol interposition.  For example, glibc libpthread.so and
7954
     libc.so duplicate many pthread symbols, with a fallback
7955
     implementation in libc.so.  In some cases the fallback does more
7956
     work than the pthread implementation.  __pthread_condattr_destroy
7957
     is one such symbol: the libpthread.so implementation is
7958
     localentry:0 while the libc.so implementation is localentry:8.
7959
     An app that "cleverly" uses dlopen to only load necessary
7960
     libraries at runtime may omit loading libpthread.so when not
7961
     running multi-threaded, which then results in the libc.so
7962
     fallback symbols being used and ld.so complaining.  Now there
7963
     are workarounds in ld (see non_zero_localentry) to detect the
7964
     pthread situation, but that may not be the only case where
7965
     --plt-localentry can cause trouble.  */
7966
0
  if (htab->params->plt_localentry0 < 0)
7967
0
    htab->params->plt_localentry0 = 0;
7968
0
  if (htab->params->plt_localentry0 && htab->has_power10_relocs)
7969
0
    {
7970
      /* The issue is that __glink_PLTresolve saves r2, which is done
7971
   because glibc ld.so _dl_runtime_resolve restores r2 to support
7972
   a glibc plt call optimisation where global entry code is
7973
   skipped on calls that resolve to the same binary.  The
7974
   __glink_PLTresolve save of r2 is incompatible with code
7975
   making tail calls, because the tail call might go via the
7976
   resolver and thus overwrite the proper saved r2.  */
7977
0
      _bfd_error_handler (_("warning: --plt-localentry is incompatible with "
7978
0
          "power10 pc-relative code"));
7979
0
      htab->params->plt_localentry0 = 0;
7980
0
    }
7981
0
  if (htab->params->plt_localentry0
7982
0
      && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
7983
0
             false, false, false) == NULL)
7984
0
    _bfd_error_handler
7985
0
      (_("warning: --plt-localentry is especially dangerous without "
7986
0
   "ld.so support to detect ABI violations"));
7987
7988
0
  tga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7989
0
            false, false, true);
7990
0
  htab->tls_get_addr = ppc_elf_hash_entry (tga);
7991
0
  tga_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7992
0
         false, false, true);
7993
0
  htab->tls_get_addr_fd = ppc_elf_hash_entry (tga_fd);
7994
7995
0
  desc = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_desc",
7996
0
             false, false, true);
7997
0
  htab->tga_desc = ppc_elf_hash_entry (desc);
7998
0
  desc_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_desc",
7999
0
          false, false, true);
8000
0
  htab->tga_desc_fd = ppc_elf_hash_entry (desc_fd);
8001
8002
0
  if (htab->params->tls_get_addr_opt)
8003
0
    {
8004
0
      struct elf_link_hash_entry *opt, *opt_fd;
8005
8006
0
      opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8007
0
          false, false, true);
8008
0
      opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8009
0
             false, false, true);
8010
0
      if (opt_fd != NULL
8011
0
    && (opt_fd->root.type == bfd_link_hash_defined
8012
0
        || opt_fd->root.type == bfd_link_hash_defweak))
8013
0
  {
8014
    /* If glibc supports an optimized __tls_get_addr call stub,
8015
       signalled by the presence of __tls_get_addr_opt, and we'll
8016
       be calling __tls_get_addr via a plt call stub, then
8017
       make __tls_get_addr point to __tls_get_addr_opt.  */
8018
0
    if (!(htab->elf.dynamic_sections_created
8019
0
    && tga_fd != NULL
8020
0
    && (tga_fd->type == STT_FUNC
8021
0
        || tga_fd->needs_plt)
8022
0
    && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8023
0
         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd))))
8024
0
      tga_fd = NULL;
8025
0
    if (!(htab->elf.dynamic_sections_created
8026
0
    && desc_fd != NULL
8027
0
    && (desc_fd->type == STT_FUNC
8028
0
        || desc_fd->needs_plt)
8029
0
    && !(SYMBOL_CALLS_LOCAL (info, desc_fd)
8030
0
         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, desc_fd))))
8031
0
      desc_fd = NULL;
8032
8033
0
    if (tga_fd != NULL || desc_fd != NULL)
8034
0
      {
8035
0
        struct plt_entry *ent = NULL;
8036
8037
0
        if (tga_fd != NULL)
8038
0
    for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8039
0
      if (ent->plt.refcount > 0)
8040
0
        break;
8041
0
        if (ent == NULL && desc_fd != NULL)
8042
0
    for (ent = desc_fd->plt.plist; ent != NULL; ent = ent->next)
8043
0
      if (ent->plt.refcount > 0)
8044
0
        break;
8045
0
        if (ent != NULL)
8046
0
    {
8047
0
      if (tga_fd != NULL)
8048
0
        {
8049
0
          tga_fd->root.type = bfd_link_hash_indirect;
8050
0
          tga_fd->root.u.i.link = &opt_fd->root;
8051
0
          tga_fd->root.u.i.warning = NULL;
8052
0
          ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8053
0
        }
8054
0
      if (desc_fd != NULL)
8055
0
        {
8056
0
          desc_fd->root.type = bfd_link_hash_indirect;
8057
0
          desc_fd->root.u.i.link = &opt_fd->root;
8058
0
          desc_fd->root.u.i.warning = NULL;
8059
0
          ppc64_elf_copy_indirect_symbol (info, opt_fd, desc_fd);
8060
0
        }
8061
0
      opt_fd->mark = 1;
8062
0
      if (opt_fd->dynindx != -1)
8063
0
        {
8064
          /* Use __tls_get_addr_opt in dynamic relocations.  */
8065
0
          opt_fd->dynindx = -1;
8066
0
          _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8067
0
                opt_fd->dynstr_index);
8068
0
          if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8069
0
      return false;
8070
0
        }
8071
0
      if (tga_fd != NULL)
8072
0
        {
8073
0
          htab->tls_get_addr_fd = ppc_elf_hash_entry (opt_fd);
8074
0
          tga = elf_hash_entry (htab->tls_get_addr);
8075
0
          if (opt != NULL && tga != NULL)
8076
0
      {
8077
0
        tga->root.type = bfd_link_hash_indirect;
8078
0
        tga->root.u.i.link = &opt->root;
8079
0
        tga->root.u.i.warning = NULL;
8080
0
        ppc64_elf_copy_indirect_symbol (info, opt, tga);
8081
0
        opt->mark = 1;
8082
0
        _bfd_elf_link_hash_hide_symbol (info, opt,
8083
0
                tga->forced_local);
8084
0
        htab->tls_get_addr = ppc_elf_hash_entry (opt);
8085
0
      }
8086
0
          htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8087
0
          htab->tls_get_addr_fd->is_func_descriptor = 1;
8088
0
          if (htab->tls_get_addr != NULL)
8089
0
      {
8090
0
        htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8091
0
        htab->tls_get_addr->is_func = 1;
8092
0
      }
8093
0
        }
8094
0
      if (desc_fd != NULL)
8095
0
        {
8096
0
          htab->tga_desc_fd = ppc_elf_hash_entry (opt_fd);
8097
0
          if (opt != NULL && desc != NULL)
8098
0
      {
8099
0
        desc->root.type = bfd_link_hash_indirect;
8100
0
        desc->root.u.i.link = &opt->root;
8101
0
        desc->root.u.i.warning = NULL;
8102
0
        ppc64_elf_copy_indirect_symbol (info, opt, desc);
8103
0
        opt->mark = 1;
8104
0
        _bfd_elf_link_hash_hide_symbol (info, opt,
8105
0
                desc->forced_local);
8106
0
        htab->tga_desc = ppc_elf_hash_entry (opt);
8107
0
      }
8108
0
          htab->tga_desc_fd->oh = htab->tga_desc;
8109
0
          htab->tga_desc_fd->is_func_descriptor = 1;
8110
0
          if (htab->tga_desc != NULL)
8111
0
      {
8112
0
        htab->tga_desc->oh = htab->tga_desc_fd;
8113
0
        htab->tga_desc->is_func = 1;
8114
0
      }
8115
0
        }
8116
0
    }
8117
0
      }
8118
0
  }
8119
0
      else if (htab->params->tls_get_addr_opt < 0)
8120
0
  htab->params->tls_get_addr_opt = 0;
8121
0
    }
8122
8123
0
  if (htab->tga_desc_fd != NULL
8124
0
      && htab->params->tls_get_addr_opt
8125
0
      && htab->params->no_tls_get_addr_regsave == -1)
8126
0
    htab->params->no_tls_get_addr_regsave = 0;
8127
8128
0
  return true;
8129
0
}
8130
8131
/* Return TRUE iff REL is a branch reloc with a global symbol matching
8132
   any of HASH1, HASH2, HASH3, or HASH4.  */
8133
8134
static bool
8135
branch_reloc_hash_match (bfd *ibfd,
8136
       Elf_Internal_Rela *rel,
8137
       struct ppc_link_hash_entry *hash1,
8138
       struct ppc_link_hash_entry *hash2,
8139
       struct ppc_link_hash_entry *hash3,
8140
       struct ppc_link_hash_entry *hash4)
8141
0
{
8142
0
  Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8143
0
  enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8144
0
  unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8145
8146
0
  if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8147
0
    {
8148
0
      struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8149
0
      struct elf_link_hash_entry *h;
8150
8151
0
      h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8152
0
      h = elf_follow_link (h);
8153
0
      if (h == elf_hash_entry (hash1)
8154
0
    || h == elf_hash_entry (hash2)
8155
0
    || h == elf_hash_entry (hash3)
8156
0
    || h == elf_hash_entry (hash4))
8157
0
  return true;
8158
0
    }
8159
0
  return false;
8160
0
}
8161
8162
/* Run through all the TLS relocs looking for optimization
8163
   opportunities.  The linker has been hacked (see ppc64elf.em) to do
8164
   a preliminary section layout so that we know the TLS segment
8165
   offsets.  We can't optimize earlier because some optimizations need
8166
   to know the tp offset, and we need to optimize before allocating
8167
   dynamic relocations.  */
8168
8169
bool
8170
ppc64_elf_tls_optimize (struct bfd_link_info *info)
8171
0
{
8172
0
  bfd *ibfd;
8173
0
  asection *sec;
8174
0
  struct ppc_link_hash_table *htab;
8175
0
  unsigned char *toc_ref;
8176
0
  int pass;
8177
8178
0
  if (!bfd_link_executable (info))
8179
0
    return true;
8180
8181
0
  htab = ppc_hash_table (info);
8182
0
  if (htab == NULL)
8183
0
    return false;
8184
8185
0
  htab->do_tls_opt = 1;
8186
8187
  /* Make two passes over the relocs.  On the first pass, mark toc
8188
     entries involved with tls relocs, and check that tls relocs
8189
     involved in setting up a tls_get_addr call are indeed followed by
8190
     such a call.  If they are not, we can't do any tls optimization.
8191
     On the second pass twiddle tls_mask flags to notify
8192
     relocate_section that optimization can be done, and adjust got
8193
     and plt refcounts.  */
8194
0
  toc_ref = NULL;
8195
0
  for (pass = 0; pass < 2; ++pass)
8196
0
    for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8197
0
      {
8198
0
  Elf_Internal_Sym *locsyms = NULL;
8199
0
  asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8200
8201
0
  for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8202
0
    if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8203
0
      {
8204
0
        Elf_Internal_Rela *relstart, *rel, *relend;
8205
0
        bool found_tls_get_addr_arg = 0;
8206
8207
        /* Read the relocations.  */
8208
0
        relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8209
0
                info->keep_memory);
8210
0
        if (relstart == NULL)
8211
0
    {
8212
0
      free (toc_ref);
8213
0
      return false;
8214
0
    }
8215
8216
0
        relend = relstart + sec->reloc_count;
8217
0
        for (rel = relstart; rel < relend; rel++)
8218
0
    {
8219
0
      enum elf_ppc64_reloc_type r_type;
8220
0
      unsigned long r_symndx;
8221
0
      struct elf_link_hash_entry *h;
8222
0
      Elf_Internal_Sym *sym;
8223
0
      asection *sym_sec;
8224
0
      unsigned char *tls_mask;
8225
0
      unsigned int tls_set, tls_clear, tls_type = 0;
8226
0
      bfd_vma value;
8227
0
      bool ok_tprel, is_local;
8228
0
      long toc_ref_index = 0;
8229
0
      int expecting_tls_get_addr = 0;
8230
0
      bool ret = false;
8231
8232
0
      r_symndx = ELF64_R_SYM (rel->r_info);
8233
0
      if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8234
0
          r_symndx, ibfd))
8235
0
        {
8236
0
        err_free_rel:
8237
0
          if (elf_section_data (sec)->relocs != relstart)
8238
0
      free (relstart);
8239
0
          free (toc_ref);
8240
0
          if (elf_symtab_hdr (ibfd).contents
8241
0
        != (unsigned char *) locsyms)
8242
0
      free (locsyms);
8243
0
          return ret;
8244
0
        }
8245
8246
0
      if (h != NULL)
8247
0
        {
8248
0
          if (h->root.type == bfd_link_hash_defined
8249
0
        || h->root.type == bfd_link_hash_defweak)
8250
0
      value = h->root.u.def.value;
8251
0
          else if (h->root.type == bfd_link_hash_undefweak)
8252
0
      value = 0;
8253
0
          else
8254
0
      {
8255
0
        found_tls_get_addr_arg = 0;
8256
0
        continue;
8257
0
      }
8258
0
        }
8259
0
      else
8260
        /* Symbols referenced by TLS relocs must be of type
8261
           STT_TLS.  So no need for .opd local sym adjust.  */
8262
0
        value = sym->st_value;
8263
8264
0
      ok_tprel = false;
8265
0
      is_local = SYMBOL_REFERENCES_LOCAL (info, h);
8266
0
      if (is_local)
8267
0
        {
8268
0
          if (h != NULL
8269
0
        && h->root.type == bfd_link_hash_undefweak)
8270
0
      ok_tprel = true;
8271
0
          else if (sym_sec != NULL
8272
0
             && sym_sec->output_section != NULL)
8273
0
      {
8274
0
        value += sym_sec->output_offset;
8275
0
        value += sym_sec->output_section->vma;
8276
0
        value -= htab->elf.tls_sec->vma + TP_OFFSET;
8277
        /* Note that even though the prefix insns
8278
           allow a 1<<33 offset we use the same test
8279
           as for addis;addi.  There may be a mix of
8280
           pcrel and non-pcrel code and the decision
8281
           to optimise is per symbol, not per TLS
8282
           sequence.  */
8283
0
        ok_tprel = value + 0x80008000ULL < 1ULL << 32;
8284
0
      }
8285
0
        }
8286
8287
0
      r_type = ELF64_R_TYPE (rel->r_info);
8288
      /* If this section has old-style __tls_get_addr calls
8289
         without marker relocs, then check that each
8290
         __tls_get_addr call reloc is preceded by a reloc
8291
         that conceivably belongs to the __tls_get_addr arg
8292
         setup insn.  If we don't find matching arg setup
8293
         relocs, don't do any tls optimization.  */
8294
0
      if (pass == 0
8295
0
          && sec->nomark_tls_get_addr
8296
0
          && h != NULL
8297
0
          && is_tls_get_addr (h, htab)
8298
0
          && !found_tls_get_addr_arg
8299
0
          && is_branch_reloc (r_type))
8300
0
        {
8301
0
          info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8302
0
            "TLS optimization disabled\n"),
8303
0
                ibfd, sec, rel->r_offset);
8304
0
          ret = true;
8305
0
          goto err_free_rel;
8306
0
        }
8307
8308
0
      found_tls_get_addr_arg = 0;
8309
0
      switch (r_type)
8310
0
        {
8311
0
        case R_PPC64_GOT_TLSLD16:
8312
0
        case R_PPC64_GOT_TLSLD16_LO:
8313
0
        case R_PPC64_GOT_TLSLD_PCREL34:
8314
0
          expecting_tls_get_addr = 1;
8315
0
          found_tls_get_addr_arg = 1;
8316
          /* Fall through.  */
8317
8318
0
        case R_PPC64_GOT_TLSLD16_HI:
8319
0
        case R_PPC64_GOT_TLSLD16_HA:
8320
          /* These relocs should never be against a symbol
8321
       defined in a shared lib.  Leave them alone if
8322
       that turns out to be the case.  */
8323
0
          if (!is_local)
8324
0
      continue;
8325
8326
          /* LD -> LE */
8327
0
          tls_set = 0;
8328
0
          tls_clear = TLS_LD;
8329
0
          tls_type = TLS_TLS | TLS_LD;
8330
0
          break;
8331
8332
0
        case R_PPC64_GOT_TLSGD16:
8333
0
        case R_PPC64_GOT_TLSGD16_LO:
8334
0
        case R_PPC64_GOT_TLSGD_PCREL34:
8335
0
          expecting_tls_get_addr = 1;
8336
0
          found_tls_get_addr_arg = 1;
8337
          /* Fall through. */
8338
8339
0
        case R_PPC64_GOT_TLSGD16_HI:
8340
0
        case R_PPC64_GOT_TLSGD16_HA:
8341
0
          if (ok_tprel)
8342
      /* GD -> LE */
8343
0
      tls_set = 0;
8344
0
          else
8345
      /* GD -> IE */
8346
0
      tls_set = TLS_TLS | TLS_GDIE;
8347
0
          tls_clear = TLS_GD;
8348
0
          tls_type = TLS_TLS | TLS_GD;
8349
0
          break;
8350
8351
0
        case R_PPC64_GOT_TPREL_PCREL34:
8352
0
        case R_PPC64_GOT_TPREL16_DS:
8353
0
        case R_PPC64_GOT_TPREL16_LO_DS:
8354
0
        case R_PPC64_GOT_TPREL16_HI:
8355
0
        case R_PPC64_GOT_TPREL16_HA:
8356
0
          if (ok_tprel)
8357
0
      {
8358
        /* IE -> LE */
8359
0
        tls_set = 0;
8360
0
        tls_clear = TLS_TPREL;
8361
0
        tls_type = TLS_TLS | TLS_TPREL;
8362
0
        break;
8363
0
      }
8364
0
          continue;
8365
8366
0
        case R_PPC64_TLSLD:
8367
0
          if (!is_local)
8368
0
      continue;
8369
          /* Fall through.  */
8370
0
        case R_PPC64_TLSGD:
8371
0
          if (rel + 1 < relend
8372
0
        && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8373
0
      {
8374
0
        if (pass != 0
8375
0
            && (ELF64_R_TYPE (rel[1].r_info)
8376
0
          != R_PPC64_PLTSEQ)
8377
0
            && (ELF64_R_TYPE (rel[1].r_info)
8378
0
          != R_PPC64_PLTSEQ_NOTOC))
8379
0
          {
8380
0
            r_symndx = ELF64_R_SYM (rel[1].r_info);
8381
0
            if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8382
0
                r_symndx, ibfd))
8383
0
        goto err_free_rel;
8384
0
            if (h != NULL)
8385
0
        {
8386
0
          struct plt_entry *ent = NULL;
8387
8388
0
          for (ent = h->plt.plist;
8389
0
               ent != NULL;
8390
0
               ent = ent->next)
8391
0
            if (ent->addend == rel[1].r_addend)
8392
0
              break;
8393
8394
0
          if (ent != NULL
8395
0
              && ent->plt.refcount > 0)
8396
0
            ent->plt.refcount -= 1;
8397
0
        }
8398
0
          }
8399
0
        continue;
8400
0
      }
8401
0
          found_tls_get_addr_arg = 1;
8402
          /* Fall through.  */
8403
8404
0
        case R_PPC64_TLS:
8405
0
        case R_PPC64_TOC16:
8406
0
        case R_PPC64_TOC16_LO:
8407
0
          if (sym_sec == NULL || sym_sec != toc)
8408
0
      continue;
8409
8410
          /* Mark this toc entry as referenced by a TLS
8411
       code sequence.  We can do that now in the
8412
       case of R_PPC64_TLS, and after checking for
8413
       tls_get_addr for the TOC16 relocs.  */
8414
0
          if (toc_ref == NULL)
8415
0
      toc_ref
8416
0
        = bfd_zmalloc (toc->output_section->rawsize / 8);
8417
0
          if (toc_ref == NULL)
8418
0
      goto err_free_rel;
8419
8420
0
          if (h != NULL)
8421
0
      value = h->root.u.def.value;
8422
0
          else
8423
0
      value = sym->st_value;
8424
0
          value += rel->r_addend;
8425
0
          if (value % 8 != 0)
8426
0
      continue;
8427
0
          BFD_ASSERT (value < toc->size
8428
0
          && toc->output_offset % 8 == 0);
8429
0
          toc_ref_index = (value + toc->output_offset) / 8;
8430
0
          if (r_type == R_PPC64_TLS
8431
0
        || r_type == R_PPC64_TLSGD
8432
0
        || r_type == R_PPC64_TLSLD)
8433
0
      {
8434
0
        toc_ref[toc_ref_index] = 1;
8435
0
        continue;
8436
0
      }
8437
8438
0
          if (pass != 0 && toc_ref[toc_ref_index] == 0)
8439
0
      continue;
8440
8441
0
          tls_set = 0;
8442
0
          tls_clear = 0;
8443
0
          expecting_tls_get_addr = 2;
8444
0
          break;
8445
8446
0
        case R_PPC64_TPREL64:
8447
0
          if (pass == 0
8448
0
        || sec != toc
8449
0
        || toc_ref == NULL
8450
0
        || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8451
0
      continue;
8452
0
          if (ok_tprel)
8453
0
      {
8454
        /* IE -> LE */
8455
0
        tls_set = TLS_EXPLICIT;
8456
0
        tls_clear = TLS_TPREL;
8457
0
        break;
8458
0
      }
8459
0
          continue;
8460
8461
0
        case R_PPC64_DTPMOD64:
8462
0
          if (pass == 0
8463
0
        || sec != toc
8464
0
        || toc_ref == NULL
8465
0
        || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8466
0
      continue;
8467
0
          if (rel + 1 < relend
8468
0
        && (rel[1].r_info
8469
0
            == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8470
0
        && rel[1].r_offset == rel->r_offset + 8)
8471
0
      {
8472
0
        if (ok_tprel)
8473
          /* GD -> LE */
8474
0
          tls_set = TLS_EXPLICIT | TLS_GD;
8475
0
        else
8476
          /* GD -> IE */
8477
0
          tls_set = TLS_EXPLICIT | TLS_GD | TLS_GDIE;
8478
0
        tls_clear = TLS_GD;
8479
0
      }
8480
0
          else
8481
0
      {
8482
0
        if (!is_local)
8483
0
          continue;
8484
8485
        /* LD -> LE */
8486
0
        tls_set = TLS_EXPLICIT;
8487
0
        tls_clear = TLS_LD;
8488
0
      }
8489
0
          break;
8490
8491
0
        case R_PPC64_TPREL16_HA:
8492
0
          if (pass == 0)
8493
0
      {
8494
0
        unsigned char buf[4];
8495
0
        unsigned int insn;
8496
0
        bfd_vma off = rel->r_offset & ~3;
8497
0
        if (!bfd_get_section_contents (ibfd, sec, buf,
8498
0
               off, 4))
8499
0
          goto err_free_rel;
8500
0
        insn = bfd_get_32 (ibfd, buf);
8501
        /* addis rt,13,imm */
8502
0
        if ((insn & ((0x3fu << 26) | 0x1f << 16))
8503
0
            != ((15u << 26) | (13 << 16)))
8504
0
          {
8505
            /* xgettext:c-format */
8506
0
            info->callbacks->minfo
8507
0
        (_("%H: warning: %s unexpected insn %#x.\n"),
8508
0
         ibfd, sec, off, "R_PPC64_TPREL16_HA", insn);
8509
0
            htab->do_tls_opt = 0;
8510
0
          }
8511
0
      }
8512
0
          continue;
8513
8514
0
        case R_PPC64_TPREL16_HI:
8515
0
        case R_PPC64_TPREL16_HIGH:
8516
0
        case R_PPC64_TPREL16_HIGHA:
8517
0
        case R_PPC64_TPREL16_HIGHER:
8518
0
        case R_PPC64_TPREL16_HIGHERA:
8519
0
        case R_PPC64_TPREL16_HIGHEST:
8520
0
        case R_PPC64_TPREL16_HIGHESTA:
8521
          /* These can all be used in sequences along with
8522
       TPREL16_LO or TPREL16_LO_DS in ways we aren't
8523
       able to verify easily.  */
8524
0
          htab->do_tls_opt = 0;
8525
0
          continue;
8526
8527
0
        default:
8528
0
          continue;
8529
0
        }
8530
8531
0
      if (pass == 0)
8532
0
        {
8533
0
          if (!expecting_tls_get_addr
8534
0
        || !sec->nomark_tls_get_addr)
8535
0
      continue;
8536
8537
0
          if (rel + 1 < relend
8538
0
        && branch_reloc_hash_match (ibfd, rel + 1,
8539
0
                  htab->tls_get_addr_fd,
8540
0
                  htab->tga_desc_fd,
8541
0
                  htab->tls_get_addr,
8542
0
                  htab->tga_desc))
8543
0
      {
8544
0
        if (expecting_tls_get_addr == 2)
8545
0
          {
8546
            /* Check for toc tls entries.  */
8547
0
            unsigned char *toc_tls;
8548
0
            int retval;
8549
8550
0
            retval = get_tls_mask (&toc_tls, NULL, NULL,
8551
0
                 &locsyms,
8552
0
                 rel, ibfd);
8553
0
            if (retval == 0)
8554
0
        goto err_free_rel;
8555
0
            if (toc_tls != NULL)
8556
0
        {
8557
0
          if ((*toc_tls & TLS_TLS) != 0
8558
0
              && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8559
0
            found_tls_get_addr_arg = 1;
8560
0
          if (retval > 1)
8561
0
            toc_ref[toc_ref_index] = 1;
8562
0
        }
8563
0
          }
8564
0
        continue;
8565
0
      }
8566
8567
          /* Uh oh, we didn't find the expected call.  We
8568
       could just mark this symbol to exclude it
8569
       from tls optimization but it's safer to skip
8570
       the entire optimization.  */
8571
          /* xgettext:c-format */
8572
0
          info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8573
0
            "TLS optimization disabled\n"),
8574
0
                ibfd, sec, rel->r_offset);
8575
0
          ret = true;
8576
0
          goto err_free_rel;
8577
0
        }
8578
8579
      /* If we don't have old-style __tls_get_addr calls
8580
         without TLSGD/TLSLD marker relocs, and we haven't
8581
         found a new-style __tls_get_addr call with a
8582
         marker for this symbol, then we either have a
8583
         broken object file or an -mlongcall style
8584
         indirect call to __tls_get_addr without a marker.
8585
         Disable optimization in this case.  */
8586
0
      if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8587
0
          && (tls_set & TLS_EXPLICIT) == 0
8588
0
          && !sec->nomark_tls_get_addr
8589
0
          && ((*tls_mask & (TLS_TLS | TLS_MARK))
8590
0
        != (TLS_TLS | TLS_MARK)))
8591
0
        continue;
8592
8593
0
      if (expecting_tls_get_addr == 1 + !sec->nomark_tls_get_addr)
8594
0
        {
8595
0
          struct plt_entry *ent = NULL;
8596
8597
0
          if (htab->tls_get_addr_fd != NULL)
8598
0
      for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8599
0
           ent != NULL;
8600
0
           ent = ent->next)
8601
0
        if (ent->addend == 0)
8602
0
          break;
8603
8604
0
          if (ent == NULL && htab->tga_desc_fd != NULL)
8605
0
      for (ent = htab->tga_desc_fd->elf.plt.plist;
8606
0
           ent != NULL;
8607
0
           ent = ent->next)
8608
0
        if (ent->addend == 0)
8609
0
          break;
8610
8611
0
          if (ent == NULL && htab->tls_get_addr != NULL)
8612
0
      for (ent = htab->tls_get_addr->elf.plt.plist;
8613
0
           ent != NULL;
8614
0
           ent = ent->next)
8615
0
        if (ent->addend == 0)
8616
0
          break;
8617
8618
0
          if (ent == NULL && htab->tga_desc != NULL)
8619
0
      for (ent = htab->tga_desc->elf.plt.plist;
8620
0
           ent != NULL;
8621
0
           ent = ent->next)
8622
0
        if (ent->addend == 0)
8623
0
          break;
8624
8625
0
          if (ent != NULL
8626
0
        && ent->plt.refcount > 0)
8627
0
      ent->plt.refcount -= 1;
8628
0
        }
8629
8630
0
      if (tls_clear == 0)
8631
0
        continue;
8632
8633
0
      if ((tls_set & TLS_EXPLICIT) == 0)
8634
0
        {
8635
0
          struct got_entry *ent;
8636
8637
          /* Adjust got entry for this reloc.  */
8638
0
          if (h != NULL)
8639
0
      ent = h->got.glist;
8640
0
          else
8641
0
      ent = elf_local_got_ents (ibfd)[r_symndx];
8642
8643
0
          for (; ent != NULL; ent = ent->next)
8644
0
      if (ent->addend == rel->r_addend
8645
0
          && ent->owner == ibfd
8646
0
          && ent->tls_type == tls_type)
8647
0
        break;
8648
0
          if (ent == NULL)
8649
0
      abort ();
8650
8651
0
          if (tls_set == 0)
8652
0
      {
8653
        /* We managed to get rid of a got entry.  */
8654
0
        if (ent->got.refcount > 0)
8655
0
          ent->got.refcount -= 1;
8656
0
      }
8657
0
        }
8658
0
      else
8659
0
        {
8660
          /* If we got rid of a DTPMOD/DTPREL reloc pair then
8661
       we'll lose one or two dyn relocs.  */
8662
0
          if (!dec_dynrel_count (rel, sec, info,
8663
0
               NULL, h, sym))
8664
0
      return false;
8665
8666
0
          if (tls_set == (TLS_EXPLICIT | TLS_GD))
8667
0
      {
8668
0
        if (!dec_dynrel_count (rel + 1, sec, info,
8669
0
             NULL, h, sym))
8670
0
          return false;
8671
0
      }
8672
0
        }
8673
8674
0
      *tls_mask |= tls_set & 0xff;
8675
0
      *tls_mask &= ~tls_clear;
8676
0
    }
8677
8678
0
        if (elf_section_data (sec)->relocs != relstart)
8679
0
    free (relstart);
8680
0
      }
8681
8682
0
  if (locsyms != NULL
8683
0
      && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8684
0
    {
8685
0
      if (!info->keep_memory)
8686
0
        free (locsyms);
8687
0
      else
8688
0
        elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8689
0
    }
8690
0
      }
8691
8692
0
  free (toc_ref);
8693
0
  return true;
8694
0
}
8695
8696
/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8697
   the values of any global symbols in a toc section that has been
8698
   edited.  Globals in toc sections should be a rarity, so this function
8699
   sets a flag if any are found in toc sections other than the one just
8700
   edited, so that further hash table traversals can be avoided.  */
8701
8702
struct adjust_toc_info
8703
{
8704
  asection *toc;
8705
  unsigned long *skip;
8706
  bool global_toc_syms;
8707
};
8708
8709
enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8710
8711
static bool
8712
adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8713
0
{
8714
0
  struct ppc_link_hash_entry *eh;
8715
0
  struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8716
0
  unsigned long i;
8717
8718
0
  if (h->root.type != bfd_link_hash_defined
8719
0
      && h->root.type != bfd_link_hash_defweak)
8720
0
    return true;
8721
8722
0
  eh = ppc_elf_hash_entry (h);
8723
0
  if (eh->adjust_done)
8724
0
    return true;
8725
8726
0
  if (eh->elf.root.u.def.section == toc_inf->toc)
8727
0
    {
8728
0
      if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8729
0
  i = toc_inf->toc->rawsize >> 3;
8730
0
      else
8731
0
  i = eh->elf.root.u.def.value >> 3;
8732
8733
0
      if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8734
0
  {
8735
0
    _bfd_error_handler
8736
0
      (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8737
0
    do
8738
0
      ++i;
8739
0
    while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8740
0
    eh->elf.root.u.def.value = (bfd_vma) i << 3;
8741
0
  }
8742
8743
0
      eh->elf.root.u.def.value -= toc_inf->skip[i];
8744
0
      eh->adjust_done = 1;
8745
0
    }
8746
0
  else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8747
0
    toc_inf->global_toc_syms = true;
8748
8749
0
  return true;
8750
0
}
8751
8752
/* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8753
   on a _LO variety toc/got reloc.  */
8754
8755
static bool
8756
ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8757
0
{
8758
0
  return ((insn & (0x3fu << 26)) == 12u << 26 /* addic */
8759
0
    || (insn & (0x3fu << 26)) == 14u << 26 /* addi */
8760
0
    || (insn & (0x3fu << 26)) == 32u << 26 /* lwz */
8761
0
    || (insn & (0x3fu << 26)) == 34u << 26 /* lbz */
8762
0
    || (insn & (0x3fu << 26)) == 36u << 26 /* stw */
8763
0
    || (insn & (0x3fu << 26)) == 38u << 26 /* stb */
8764
0
    || (insn & (0x3fu << 26)) == 40u << 26 /* lhz */
8765
0
    || (insn & (0x3fu << 26)) == 42u << 26 /* lha */
8766
0
    || (insn & (0x3fu << 26)) == 44u << 26 /* sth */
8767
0
    || (insn & (0x3fu << 26)) == 46u << 26 /* lmw */
8768
0
    || (insn & (0x3fu << 26)) == 47u << 26 /* stmw */
8769
0
    || (insn & (0x3fu << 26)) == 48u << 26 /* lfs */
8770
0
    || (insn & (0x3fu << 26)) == 50u << 26 /* lfd */
8771
0
    || (insn & (0x3fu << 26)) == 52u << 26 /* stfs */
8772
0
    || (insn & (0x3fu << 26)) == 54u << 26 /* stfd */
8773
0
    || (insn & (0x3fu << 26)) == 56u << 26 /* lq,lfq */
8774
0
    || ((insn & (0x3fu << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8775
        /* Exclude lfqu by testing reloc.  If relocs are ever
8776
     defined for the reduced D field in psq_lu then those
8777
     will need testing too.  */
8778
0
        && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8779
0
    || ((insn & (0x3fu << 26)) == 58u << 26 /* ld,lwa */
8780
0
        && (insn & 1) == 0)
8781
0
    || (insn & (0x3fu << 26)) == 60u << 26 /* stfq */
8782
0
    || ((insn & (0x3fu << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8783
        /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8784
0
        && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8785
0
    || ((insn & (0x3fu << 26)) == 62u << 26 /* std,stq */
8786
0
        && (insn & 1) == 0));
8787
0
}
8788
8789
/* PCREL_OPT in one instance flags to the linker that a pair of insns:
8790
     pld ra,symbol@got@pcrel
8791
     load/store rt,off(ra)
8792
   or
8793
     pla ra,symbol@pcrel
8794
     load/store rt,off(ra)
8795
   may be translated to
8796
     pload/pstore rt,symbol+off@pcrel
8797
     nop.
8798
   This function returns true if the optimization is possible, placing
8799
   the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8800
8801
   On entry to this function, the linker has already determined that
8802
   the pld can be replaced with pla: *PINSN1 is that pla insn,
8803
   while *PINSN2 is the second instruction.  */
8804
8805
static bool
8806
xlate_pcrel_opt (uint64_t *pinsn1, uint64_t *pinsn2, bfd_signed_vma *poff)
8807
0
{
8808
0
  uint64_t insn1 = *pinsn1;
8809
0
  uint64_t insn2 = *pinsn2;
8810
0
  bfd_signed_vma off;
8811
8812
0
  if ((insn2 & (63ULL << 58)) == 1ULL << 58)
8813
0
    {
8814
      /* Check that regs match.  */
8815
0
      if (((insn2 >> 16) & 31) != ((insn1 >> 21) & 31))
8816
0
  return false;
8817
8818
      /* P8LS or PMLS form, non-pcrel.  */
8819
0
      if ((insn2 & (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8820
0
  return false;
8821
8822
0
      *pinsn1 = (insn2 & ~(31 << 16) & ~0x3ffff0000ffffULL) | (1ULL << 52);
8823
0
      *pinsn2 = PNOP;
8824
0
      off = ((insn2 >> 16) & 0x3ffff0000ULL) | (insn2 & 0xffff);
8825
0
      *poff = (off ^ 0x200000000ULL) - 0x200000000ULL;
8826
0
      return true;
8827
0
    }
8828
8829
0
  insn2 >>= 32;
8830
8831
  /* Check that regs match.  */
8832
0
  if (((insn2 >> 16) & 31) != ((insn1 >> 21) & 31))
8833
0
    return false;
8834
8835
0
  switch ((insn2 >> 26) & 63)
8836
0
    {
8837
0
    default:
8838
0
      return false;
8839
8840
0
    case 32: /* lwz */
8841
0
    case 34: /* lbz */
8842
0
    case 36: /* stw */
8843
0
    case 38: /* stb */
8844
0
    case 40: /* lhz */
8845
0
    case 42: /* lha */
8846
0
    case 44: /* sth */
8847
0
    case 48: /* lfs */
8848
0
    case 50: /* lfd */
8849
0
    case 52: /* stfs */
8850
0
    case 54: /* stfd */
8851
      /* These are the PMLS cases, where we just need to tack a prefix
8852
   on the insn.  */
8853
0
      insn1 = ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8854
0
         | (insn2 & ((63ULL << 26) | (31ULL << 21))));
8855
0
      off = insn2 & 0xffff;
8856
0
      break;
8857
8858
0
    case 58: /* lwa, ld */
8859
0
      if ((insn2 & 1) != 0)
8860
0
  return false;
8861
0
      insn1 = ((1ULL << 58) | (1ULL << 52)
8862
0
         | (insn2 & 2 ? 41ULL << 26 : 57ULL << 26)
8863
0
         | (insn2 & (31ULL << 21)));
8864
0
      off = insn2 & 0xfffc;
8865
0
      break;
8866
8867
0
    case 57: /* lxsd, lxssp */
8868
0
      if ((insn2 & 3) < 2)
8869
0
  return false;
8870
0
      insn1 = ((1ULL << 58) | (1ULL << 52)
8871
0
         | ((40ULL | (insn2 & 3)) << 26)
8872
0
         | (insn2 & (31ULL << 21)));
8873
0
      off = insn2 & 0xfffc;
8874
0
      break;
8875
8876
0
    case 61: /* stxsd, stxssp, lxv, stxv  */
8877
0
      if ((insn2 & 3) == 0)
8878
0
  return false;
8879
0
      else if ((insn2 & 3) >= 2)
8880
0
  {
8881
0
    insn1 = ((1ULL << 58) | (1ULL << 52)
8882
0
       | ((44ULL | (insn2 & 3)) << 26)
8883
0
       | (insn2 & (31ULL << 21)));
8884
0
    off = insn2 & 0xfffc;
8885
0
  }
8886
0
      else
8887
0
  {
8888
0
    insn1 = ((1ULL << 58) | (1ULL << 52)
8889
0
       | ((50ULL | (insn2 & 4) | ((insn2 & 8) >> 3)) << 26)
8890
0
       | (insn2 & (31ULL << 21)));
8891
0
    off = insn2 & 0xfff0;
8892
0
  }
8893
0
      break;
8894
8895
0
    case 56: /* lq */
8896
0
      insn1 = ((1ULL << 58) | (1ULL << 52)
8897
0
         | (insn2 & ((63ULL << 26) | (31ULL << 21))));
8898
0
      off = insn2 & 0xffff;
8899
0
      break;
8900
8901
0
    case 6: /* lxvp, stxvp */
8902
0
      if ((insn2 & 0xe) != 0)
8903
0
  return false;
8904
0
      insn1 = ((1ULL << 58) | (1ULL << 52)
8905
0
         | ((insn2 & 1) == 0 ? 58ULL << 26 : 62ULL << 26)
8906
0
         | (insn2 & (31ULL << 21)));
8907
0
      off = insn2 & 0xfff0;
8908
0
      break;
8909
8910
0
    case 62: /* std, stq */
8911
0
      if ((insn2 & 1) != 0)
8912
0
  return false;
8913
0
      insn1 = ((1ULL << 58) | (1ULL << 52)
8914
0
         | ((insn2 & 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8915
0
         | (insn2 & (31ULL << 21)));
8916
0
      off = insn2 & 0xfffc;
8917
0
      break;
8918
0
    }
8919
8920
0
  *pinsn1 = insn1;
8921
0
  *pinsn2 = (uint64_t) NOP << 32;
8922
0
  *poff = (off ^ 0x8000) - 0x8000;
8923
0
  return true;
8924
0
}
8925
8926
/* Examine all relocs referencing .toc sections in order to remove
8927
   unused .toc entries.  */
8928
8929
bool
8930
ppc64_elf_edit_toc (struct bfd_link_info *info)
8931
0
{
8932
0
  bfd *ibfd;
8933
0
  struct adjust_toc_info toc_inf;
8934
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
8935
8936
0
  htab->do_toc_opt = 1;
8937
0
  toc_inf.global_toc_syms = true;
8938
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8939
0
    {
8940
0
      asection *toc, *sec;
8941
0
      Elf_Internal_Shdr *symtab_hdr;
8942
0
      Elf_Internal_Sym *local_syms;
8943
0
      Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8944
0
      unsigned long *skip, *drop;
8945
0
      unsigned char *used;
8946
0
      unsigned char *keep, last, some_unused;
8947
8948
0
      if (!is_ppc64_elf (ibfd))
8949
0
  continue;
8950
8951
0
      toc = bfd_get_section_by_name (ibfd, ".toc");
8952
0
      if (toc == NULL
8953
0
    || toc->size == 0
8954
0
    || (toc->flags & SEC_HAS_CONTENTS) == 0
8955
0
    || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8956
0
    || discarded_section (toc))
8957
0
  continue;
8958
8959
0
      toc_relocs = NULL;
8960
0
      local_syms = NULL;
8961
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
8962
8963
      /* Look at sections dropped from the final link.  */
8964
0
      skip = NULL;
8965
0
      relstart = NULL;
8966
0
      for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8967
0
  {
8968
0
    if (sec->reloc_count == 0
8969
0
        || !discarded_section (sec)
8970
0
        || get_opd_info (sec)
8971
0
        || (sec->flags & SEC_ALLOC) == 0
8972
0
        || (sec->flags & SEC_DEBUGGING) != 0)
8973
0
      continue;
8974
8975
0
    relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, false);
8976
0
    if (relstart == NULL)
8977
0
      goto error_ret;
8978
8979
    /* Run through the relocs to see which toc entries might be
8980
       unused.  */
8981
0
    for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8982
0
      {
8983
0
        enum elf_ppc64_reloc_type r_type;
8984
0
        unsigned long r_symndx;
8985
0
        asection *sym_sec;
8986
0
        struct elf_link_hash_entry *h;
8987
0
        Elf_Internal_Sym *sym;
8988
0
        bfd_vma val;
8989
8990
0
        r_type = ELF64_R_TYPE (rel->r_info);
8991
0
        switch (r_type)
8992
0
    {
8993
0
    default:
8994
0
      continue;
8995
8996
0
    case R_PPC64_TOC16:
8997
0
    case R_PPC64_TOC16_LO:
8998
0
    case R_PPC64_TOC16_HI:
8999
0
    case R_PPC64_TOC16_HA:
9000
0
    case R_PPC64_TOC16_DS:
9001
0
    case R_PPC64_TOC16_LO_DS:
9002
0
      break;
9003
0
    }
9004
9005
0
        r_symndx = ELF64_R_SYM (rel->r_info);
9006
0
        if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9007
0
            r_symndx, ibfd))
9008
0
    goto error_ret;
9009
9010
0
        if (sym_sec != toc)
9011
0
    continue;
9012
9013
0
        if (h != NULL)
9014
0
    val = h->root.u.def.value;
9015
0
        else
9016
0
    val = sym->st_value;
9017
0
        val += rel->r_addend;
9018
9019
0
        if (val >= toc->size)
9020
0
    continue;
9021
9022
        /* Anything in the toc ought to be aligned to 8 bytes.
9023
     If not, don't mark as unused.  */
9024
0
        if (val & 7)
9025
0
    continue;
9026
9027
0
        if (skip == NULL)
9028
0
    {
9029
0
      skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9030
0
      if (skip == NULL)
9031
0
        goto error_ret;
9032
0
    }
9033
9034
0
        skip[val >> 3] = ref_from_discarded;
9035
0
      }
9036
9037
0
    if (elf_section_data (sec)->relocs != relstart)
9038
0
      free (relstart);
9039
0
  }
9040
9041
      /* For largetoc loads of address constants, we can convert
9042
   .  addis rx,2,addr@got@ha
9043
   .  ld ry,addr@got@l(rx)
9044
   to
9045
   .  addis rx,2,addr@toc@ha
9046
   .  addi ry,rx,addr@toc@l
9047
   when addr is within 2G of the toc pointer.  This then means
9048
   that the word storing "addr" in the toc is no longer needed.  */
9049
9050
0
      if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9051
0
    && toc->output_section->rawsize < (bfd_vma) 1 << 31
9052
0
    && toc->reloc_count != 0)
9053
0
  {
9054
    /* Read toc relocs.  */
9055
0
    toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9056
0
              info->keep_memory);
9057
0
    if (toc_relocs == NULL)
9058
0
      goto error_ret;
9059
9060
0
    for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9061
0
      {
9062
0
        enum elf_ppc64_reloc_type r_type;
9063
0
        unsigned long r_symndx;
9064
0
        asection *sym_sec;
9065
0
        struct elf_link_hash_entry *h;
9066
0
        Elf_Internal_Sym *sym;
9067
0
        bfd_vma val, addr;
9068
9069
0
        r_type = ELF64_R_TYPE (rel->r_info);
9070
0
        if (r_type != R_PPC64_ADDR64)
9071
0
    continue;
9072
9073
0
        r_symndx = ELF64_R_SYM (rel->r_info);
9074
0
        if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9075
0
            r_symndx, ibfd))
9076
0
    goto error_ret;
9077
9078
0
        if (sym_sec == NULL
9079
0
      || sym_sec->output_section == NULL
9080
0
      || discarded_section (sym_sec))
9081
0
    continue;
9082
9083
0
        if (!SYMBOL_REFERENCES_LOCAL (info, h)
9084
0
      || (bfd_link_pic (info)
9085
0
          && sym_sec == bfd_abs_section_ptr))
9086
0
    continue;
9087
9088
0
        if (h != NULL)
9089
0
    {
9090
0
      if (h->type == STT_GNU_IFUNC)
9091
0
        continue;
9092
0
      val = h->root.u.def.value;
9093
0
    }
9094
0
        else
9095
0
    {
9096
0
      if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9097
0
        continue;
9098
0
      val = sym->st_value;
9099
0
    }
9100
0
        val += rel->r_addend;
9101
0
        val += sym_sec->output_section->vma + sym_sec->output_offset;
9102
9103
        /* We don't yet know the exact toc pointer value, but we
9104
     know it will be somewhere in the toc section.  Don't
9105
     optimize if the difference from any possible toc
9106
     pointer is outside [ff..f80008000, 7fff7fff].  */
9107
0
        addr = toc->output_section->vma + TOC_BASE_OFF;
9108
0
        if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9109
0
    continue;
9110
9111
0
        addr = toc->output_section->vma + toc->output_section->rawsize;
9112
0
        if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9113
0
    continue;
9114
9115
0
        if (skip == NULL)
9116
0
    {
9117
0
      skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9118
0
      if (skip == NULL)
9119
0
        goto error_ret;
9120
0
    }
9121
9122
0
        skip[rel->r_offset >> 3]
9123
0
    |= can_optimize | ((rel - toc_relocs) << 2);
9124
0
      }
9125
0
  }
9126
9127
0
      if (skip == NULL)
9128
0
  continue;
9129
9130
0
      used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9131
0
      if (used == NULL)
9132
0
  {
9133
0
  error_ret:
9134
0
    if (symtab_hdr->contents != (unsigned char *) local_syms)
9135
0
      free (local_syms);
9136
0
    if (sec != NULL
9137
0
        && elf_section_data (sec)->relocs != relstart)
9138
0
      free (relstart);
9139
0
    if (elf_section_data (toc)->relocs != toc_relocs)
9140
0
      free (toc_relocs);
9141
0
    free (skip);
9142
0
    return false;
9143
0
  }
9144
9145
      /* Now check all kept sections that might reference the toc.
9146
   Check the toc itself last.  */
9147
0
      for (sec = (ibfd->sections == toc && toc->next ? toc->next
9148
0
      : ibfd->sections);
9149
0
     sec != NULL;
9150
0
     sec = (sec == toc ? NULL
9151
0
      : sec->next == NULL ? toc
9152
0
      : sec->next == toc && toc->next ? toc->next
9153
0
      : sec->next))
9154
0
  {
9155
0
    int repeat;
9156
9157
0
    if (sec->reloc_count == 0
9158
0
        || discarded_section (sec)
9159
0
        || get_opd_info (sec)
9160
0
        || (sec->flags & SEC_ALLOC) == 0
9161
0
        || (sec->flags & SEC_DEBUGGING) != 0)
9162
0
      continue;
9163
9164
0
    relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9165
0
            info->keep_memory);
9166
0
    if (relstart == NULL)
9167
0
      {
9168
0
        free (used);
9169
0
        goto error_ret;
9170
0
      }
9171
9172
    /* Mark toc entries referenced as used.  */
9173
0
    do
9174
0
      {
9175
0
        repeat = 0;
9176
0
        for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9177
0
    {
9178
0
      enum elf_ppc64_reloc_type r_type;
9179
0
      unsigned long r_symndx;
9180
0
      asection *sym_sec;
9181
0
      struct elf_link_hash_entry *h;
9182
0
      Elf_Internal_Sym *sym;
9183
0
      bfd_vma val;
9184
9185
0
      r_type = ELF64_R_TYPE (rel->r_info);
9186
0
      switch (r_type)
9187
0
        {
9188
0
        case R_PPC64_TOC16:
9189
0
        case R_PPC64_TOC16_LO:
9190
0
        case R_PPC64_TOC16_HI:
9191
0
        case R_PPC64_TOC16_HA:
9192
0
        case R_PPC64_TOC16_DS:
9193
0
        case R_PPC64_TOC16_LO_DS:
9194
          /* In case we're taking addresses of toc entries.  */
9195
0
        case R_PPC64_ADDR64:
9196
0
          break;
9197
9198
0
        default:
9199
0
          continue;
9200
0
        }
9201
9202
0
      r_symndx = ELF64_R_SYM (rel->r_info);
9203
0
      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9204
0
          r_symndx, ibfd))
9205
0
        {
9206
0
          free (used);
9207
0
          goto error_ret;
9208
0
        }
9209
9210
0
      if (sym_sec != toc)
9211
0
        continue;
9212
9213
0
      if (h != NULL)
9214
0
        val = h->root.u.def.value;
9215
0
      else
9216
0
        val = sym->st_value;
9217
0
      val += rel->r_addend;
9218
9219
0
      if (val >= toc->size)
9220
0
        continue;
9221
9222
0
      if ((skip[val >> 3] & can_optimize) != 0)
9223
0
        {
9224
0
          bfd_vma off;
9225
0
          unsigned char opc;
9226
9227
0
          switch (r_type)
9228
0
      {
9229
0
      case R_PPC64_TOC16_HA:
9230
0
        break;
9231
9232
0
      case R_PPC64_TOC16_LO_DS:
9233
0
        off = rel->r_offset;
9234
0
        off += (bfd_big_endian (ibfd) ? -2 : 3);
9235
0
        if (!bfd_get_section_contents (ibfd, sec, &opc,
9236
0
               off, 1))
9237
0
          {
9238
0
            free (used);
9239
0
            goto error_ret;
9240
0
          }
9241
0
        if ((opc & (0x3f << 2)) == (58u << 2))
9242
0
          break;
9243
        /* Fall through.  */
9244
9245
0
      default:
9246
        /* Wrong sort of reloc, or not a ld.  We may
9247
           as well clear ref_from_discarded too.  */
9248
0
        skip[val >> 3] = 0;
9249
0
      }
9250
0
        }
9251
9252
0
      if (sec != toc)
9253
0
        used[val >> 3] = 1;
9254
      /* For the toc section, we only mark as used if this
9255
         entry itself isn't unused.  */
9256
0
      else if ((used[rel->r_offset >> 3]
9257
0
          || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9258
0
         && !used[val >> 3])
9259
0
        {
9260
          /* Do all the relocs again, to catch reference
9261
       chains.  */
9262
0
          repeat = 1;
9263
0
          used[val >> 3] = 1;
9264
0
        }
9265
0
    }
9266
0
      }
9267
0
    while (repeat);
9268
9269
0
    if (elf_section_data (sec)->relocs != relstart)
9270
0
      free (relstart);
9271
0
  }
9272
9273
      /* Merge the used and skip arrays.  Assume that TOC
9274
   doublewords not appearing as either used or unused belong
9275
   to an entry more than one doubleword in size.  */
9276
0
      for (drop = skip, keep = used, last = 0, some_unused = 0;
9277
0
     drop < skip + (toc->size + 7) / 8;
9278
0
     ++drop, ++keep)
9279
0
  {
9280
0
    if (*keep)
9281
0
      {
9282
0
        *drop &= ~ref_from_discarded;
9283
0
        if ((*drop & can_optimize) != 0)
9284
0
    some_unused = 1;
9285
0
        last = 0;
9286
0
      }
9287
0
    else if ((*drop & ref_from_discarded) != 0)
9288
0
      {
9289
0
        some_unused = 1;
9290
0
        last = ref_from_discarded;
9291
0
      }
9292
0
    else
9293
0
      *drop = last;
9294
0
  }
9295
9296
0
      free (used);
9297
9298
0
      if (some_unused)
9299
0
  {
9300
0
    bfd_byte *contents, *src;
9301
0
    unsigned long off;
9302
0
    Elf_Internal_Sym *sym;
9303
0
    bool local_toc_syms = false;
9304
9305
    /* Shuffle the toc contents, and at the same time convert the
9306
       skip array from booleans into offsets.  */
9307
0
    if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9308
0
      goto error_ret;
9309
9310
0
    elf_section_data (toc)->this_hdr.contents = contents;
9311
9312
0
    for (src = contents, off = 0, drop = skip;
9313
0
         src < contents + toc->size;
9314
0
         src += 8, ++drop)
9315
0
      {
9316
0
        if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9317
0
    off += 8;
9318
0
        else if (off != 0)
9319
0
    {
9320
0
      *drop = off;
9321
0
      memcpy (src - off, src, 8);
9322
0
    }
9323
0
      }
9324
0
    *drop = off;
9325
0
    toc->rawsize = toc->size;
9326
0
    toc->size = src - contents - off;
9327
9328
    /* Adjust addends for relocs against the toc section sym,
9329
       and optimize any accesses we can.  */
9330
0
    for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9331
0
      {
9332
0
        if (sec->reloc_count == 0
9333
0
      || discarded_section (sec))
9334
0
    continue;
9335
9336
0
        relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9337
0
                info->keep_memory);
9338
0
        if (relstart == NULL)
9339
0
    goto error_ret;
9340
9341
0
        for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9342
0
    {
9343
0
      enum elf_ppc64_reloc_type r_type;
9344
0
      unsigned long r_symndx;
9345
0
      asection *sym_sec;
9346
0
      struct elf_link_hash_entry *h;
9347
0
      bfd_vma val;
9348
9349
0
      r_type = ELF64_R_TYPE (rel->r_info);
9350
0
      switch (r_type)
9351
0
        {
9352
0
        default:
9353
0
          continue;
9354
9355
0
        case R_PPC64_TOC16:
9356
0
        case R_PPC64_TOC16_LO:
9357
0
        case R_PPC64_TOC16_HI:
9358
0
        case R_PPC64_TOC16_HA:
9359
0
        case R_PPC64_TOC16_DS:
9360
0
        case R_PPC64_TOC16_LO_DS:
9361
0
        case R_PPC64_ADDR64:
9362
0
          break;
9363
0
        }
9364
9365
0
      r_symndx = ELF64_R_SYM (rel->r_info);
9366
0
      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9367
0
          r_symndx, ibfd))
9368
0
        goto error_ret;
9369
9370
0
      if (sym_sec != toc)
9371
0
        continue;
9372
9373
0
      if (h != NULL)
9374
0
        val = h->root.u.def.value;
9375
0
      else
9376
0
        {
9377
0
          val = sym->st_value;
9378
0
          if (val != 0)
9379
0
      local_toc_syms = true;
9380
0
        }
9381
9382
0
      val += rel->r_addend;
9383
9384
0
      if (val > toc->rawsize)
9385
0
        val = toc->rawsize;
9386
0
      else if ((skip[val >> 3] & ref_from_discarded) != 0)
9387
0
        continue;
9388
0
      else if ((skip[val >> 3] & can_optimize) != 0)
9389
0
        {
9390
0
          Elf_Internal_Rela *tocrel
9391
0
      = toc_relocs + (skip[val >> 3] >> 2);
9392
0
          unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9393
9394
0
          switch (r_type)
9395
0
      {
9396
0
      case R_PPC64_TOC16_HA:
9397
0
        rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9398
0
        break;
9399
9400
0
      case R_PPC64_TOC16_LO_DS:
9401
0
        rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9402
0
        break;
9403
9404
0
      default:
9405
0
        if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9406
0
          ppc_howto_init ();
9407
0
        info->callbacks->einfo
9408
          /* xgettext:c-format */
9409
0
          (_("%H: %s references "
9410
0
             "optimized away TOC entry\n"),
9411
0
           ibfd, sec, rel->r_offset,
9412
0
           ppc64_elf_howto_table[r_type]->name);
9413
0
        bfd_set_error (bfd_error_bad_value);
9414
0
        goto error_ret;
9415
0
      }
9416
0
          rel->r_addend = tocrel->r_addend;
9417
0
          elf_section_data (sec)->relocs = relstart;
9418
0
          continue;
9419
0
        }
9420
9421
0
      if (h != NULL || sym->st_value != 0)
9422
0
        continue;
9423
9424
0
      rel->r_addend -= skip[val >> 3];
9425
0
      elf_section_data (sec)->relocs = relstart;
9426
0
    }
9427
9428
0
        if (elf_section_data (sec)->relocs != relstart)
9429
0
    free (relstart);
9430
0
      }
9431
9432
    /* We shouldn't have local or global symbols defined in the TOC,
9433
       but handle them anyway.  */
9434
0
    if (local_syms != NULL)
9435
0
      for (sym = local_syms;
9436
0
     sym < local_syms + symtab_hdr->sh_info;
9437
0
     ++sym)
9438
0
        if (sym->st_value != 0
9439
0
      && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9440
0
    {
9441
0
      unsigned long i;
9442
9443
0
      if (sym->st_value > toc->rawsize)
9444
0
        i = toc->rawsize >> 3;
9445
0
      else
9446
0
        i = sym->st_value >> 3;
9447
9448
0
      if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9449
0
        {
9450
0
          if (local_toc_syms)
9451
0
      _bfd_error_handler
9452
0
        (_("%s defined on removed toc entry"),
9453
0
         bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9454
0
          do
9455
0
      ++i;
9456
0
          while ((skip[i] & (ref_from_discarded | can_optimize)));
9457
0
          sym->st_value = (bfd_vma) i << 3;
9458
0
        }
9459
9460
0
      sym->st_value -= skip[i];
9461
0
      symtab_hdr->contents = (unsigned char *) local_syms;
9462
0
    }
9463
9464
    /* Adjust any global syms defined in this toc input section.  */
9465
0
    if (toc_inf.global_toc_syms)
9466
0
      {
9467
0
        toc_inf.toc = toc;
9468
0
        toc_inf.skip = skip;
9469
0
        toc_inf.global_toc_syms = false;
9470
0
        elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9471
0
              &toc_inf);
9472
0
      }
9473
9474
0
    if (toc->reloc_count != 0)
9475
0
      {
9476
0
        Elf_Internal_Shdr *rel_hdr;
9477
0
        Elf_Internal_Rela *wrel;
9478
0
        bfd_size_type sz;
9479
9480
        /* Remove unused toc relocs, and adjust those we keep.  */
9481
0
        if (toc_relocs == NULL)
9482
0
    toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9483
0
              info->keep_memory);
9484
0
        if (toc_relocs == NULL)
9485
0
    goto error_ret;
9486
9487
0
        wrel = toc_relocs;
9488
0
        for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9489
0
    if ((skip[rel->r_offset >> 3]
9490
0
         & (ref_from_discarded | can_optimize)) == 0)
9491
0
      {
9492
0
        wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9493
0
        wrel->r_info = rel->r_info;
9494
0
        wrel->r_addend = rel->r_addend;
9495
0
        ++wrel;
9496
0
      }
9497
0
    else if (!dec_dynrel_count (rel, toc, info,
9498
0
              &local_syms, NULL, NULL))
9499
0
      goto error_ret;
9500
9501
0
        elf_section_data (toc)->relocs = toc_relocs;
9502
0
        toc->reloc_count = wrel - toc_relocs;
9503
0
        rel_hdr = _bfd_elf_single_rel_hdr (toc);
9504
0
        sz = rel_hdr->sh_entsize;
9505
0
        rel_hdr->sh_size = toc->reloc_count * sz;
9506
0
      }
9507
0
  }
9508
0
      else if (elf_section_data (toc)->relocs != toc_relocs)
9509
0
  free (toc_relocs);
9510
9511
0
      if (local_syms != NULL
9512
0
    && symtab_hdr->contents != (unsigned char *) local_syms)
9513
0
  {
9514
0
    if (!info->keep_memory)
9515
0
      free (local_syms);
9516
0
    else
9517
0
      symtab_hdr->contents = (unsigned char *) local_syms;
9518
0
  }
9519
0
      free (skip);
9520
0
    }
9521
9522
  /* Look for cases where we can change an indirect GOT access to
9523
     a GOT relative or PC relative access, possibly reducing the
9524
     number of GOT entries.  */
9525
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9526
0
    {
9527
0
      asection *sec;
9528
0
      Elf_Internal_Shdr *symtab_hdr;
9529
0
      Elf_Internal_Sym *local_syms;
9530
0
      Elf_Internal_Rela *relstart, *rel;
9531
0
      bfd_vma got;
9532
9533
0
      if (!is_ppc64_elf (ibfd))
9534
0
  continue;
9535
9536
0
      if (!ppc64_elf_tdata (ibfd)->has_optrel)
9537
0
  continue;
9538
9539
0
      sec = ppc64_elf_tdata (ibfd)->got;
9540
0
      got = 0;
9541
0
      if (sec != NULL)
9542
0
  got = sec->output_section->vma + sec->output_offset + 0x8000;
9543
9544
0
      local_syms = NULL;
9545
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
9546
9547
0
      for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9548
0
  {
9549
0
    if (sec->reloc_count == 0
9550
0
        || !ppc64_elf_section_data (sec)->has_optrel
9551
0
        || discarded_section (sec))
9552
0
      continue;
9553
9554
0
    relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9555
0
            info->keep_memory);
9556
0
    if (relstart == NULL)
9557
0
      {
9558
0
      got_error_ret:
9559
0
        if (symtab_hdr->contents != (unsigned char *) local_syms)
9560
0
    free (local_syms);
9561
0
        if (sec != NULL
9562
0
      && elf_section_data (sec)->relocs != relstart)
9563
0
    free (relstart);
9564
0
        return false;
9565
0
      }
9566
9567
0
    for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9568
0
      {
9569
0
        enum elf_ppc64_reloc_type r_type;
9570
0
        unsigned long r_symndx;
9571
0
        Elf_Internal_Sym *sym;
9572
0
        asection *sym_sec;
9573
0
        struct elf_link_hash_entry *h;
9574
0
        struct got_entry *ent;
9575
0
        bfd_vma val, pc;
9576
0
        unsigned char buf[8];
9577
0
        unsigned int insn;
9578
0
        enum {no_check, check_lo, check_ha} insn_check;
9579
9580
0
        r_type = ELF64_R_TYPE (rel->r_info);
9581
0
        switch (r_type)
9582
0
    {
9583
0
    default:
9584
0
      insn_check = no_check;
9585
0
      break;
9586
9587
0
    case R_PPC64_PLT16_HA:
9588
0
    case R_PPC64_GOT_TLSLD16_HA:
9589
0
    case R_PPC64_GOT_TLSGD16_HA:
9590
0
    case R_PPC64_GOT_TPREL16_HA:
9591
0
    case R_PPC64_GOT_DTPREL16_HA:
9592
0
    case R_PPC64_GOT16_HA:
9593
0
    case R_PPC64_TOC16_HA:
9594
0
      insn_check = check_ha;
9595
0
      break;
9596
9597
0
    case R_PPC64_PLT16_LO:
9598
0
    case R_PPC64_PLT16_LO_DS:
9599
0
    case R_PPC64_GOT_TLSLD16_LO:
9600
0
    case R_PPC64_GOT_TLSGD16_LO:
9601
0
    case R_PPC64_GOT_TPREL16_LO_DS:
9602
0
    case R_PPC64_GOT_DTPREL16_LO_DS:
9603
0
    case R_PPC64_GOT16_LO:
9604
0
    case R_PPC64_GOT16_LO_DS:
9605
0
    case R_PPC64_TOC16_LO:
9606
0
    case R_PPC64_TOC16_LO_DS:
9607
0
      insn_check = check_lo;
9608
0
      break;
9609
0
    }
9610
9611
0
        if (insn_check != no_check)
9612
0
    {
9613
0
      bfd_vma off = rel->r_offset & ~3;
9614
9615
0
      if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9616
0
        goto got_error_ret;
9617
9618
0
      insn = bfd_get_32 (ibfd, buf);
9619
0
      if (insn_check == check_lo
9620
0
          ? !ok_lo_toc_insn (insn, r_type)
9621
0
          : ((insn & ((0x3fu << 26) | 0x1f << 16))
9622
0
       != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9623
0
        {
9624
0
          char str[12];
9625
9626
0
          ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9627
0
          sprintf (str, "%#08x", insn);
9628
0
          info->callbacks->einfo
9629
      /* xgettext:c-format */
9630
0
      (_("%H: got/toc optimization is not supported for"
9631
0
         " %s instruction\n"),
9632
0
       ibfd, sec, rel->r_offset & ~3, str);
9633
0
          continue;
9634
0
        }
9635
0
    }
9636
9637
0
        switch (r_type)
9638
0
    {
9639
    /* Note that we don't delete GOT entries for
9640
       R_PPC64_GOT16_DS since we'd need a lot more
9641
       analysis.  For starters, the preliminary layout is
9642
       before the GOT, PLT, dynamic sections and stubs are
9643
       laid out.  Then we'd need to allow for changes in
9644
       distance between sections caused by alignment.  */
9645
0
    default:
9646
0
      continue;
9647
9648
0
    case R_PPC64_GOT16_HA:
9649
0
    case R_PPC64_GOT16_LO_DS:
9650
0
    case R_PPC64_GOT_PCREL34:
9651
0
      break;
9652
0
    }
9653
9654
0
        r_symndx = ELF64_R_SYM (rel->r_info);
9655
0
        if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9656
0
            r_symndx, ibfd))
9657
0
    goto got_error_ret;
9658
9659
0
        if (sym_sec == NULL
9660
0
      || sym_sec->output_section == NULL
9661
0
      || discarded_section (sym_sec))
9662
0
    continue;
9663
9664
0
        if ((h ? h->type : ELF_ST_TYPE (sym->st_info)) == STT_GNU_IFUNC)
9665
0
    continue;
9666
9667
0
        if (!SYMBOL_REFERENCES_LOCAL (info, h)
9668
0
      || (bfd_link_pic (info)
9669
0
          && sym_sec == bfd_abs_section_ptr))
9670
0
    continue;
9671
9672
0
        if (h != NULL)
9673
0
    val = h->root.u.def.value;
9674
0
        else
9675
0
    val = sym->st_value;
9676
0
        val += rel->r_addend;
9677
0
        val += sym_sec->output_section->vma + sym_sec->output_offset;
9678
9679
/* Fudge factor to allow for the fact that the preliminary layout
9680
   isn't exact.  Reduce limits by this factor.  */
9681
0
#define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9682
9683
0
        switch (r_type)
9684
0
    {
9685
0
    default:
9686
0
      continue;
9687
9688
0
    case R_PPC64_GOT16_HA:
9689
0
      if (val - got + LIMIT_ADJUST (0x80008000ULL)
9690
0
          >= LIMIT_ADJUST (0x100000000ULL))
9691
0
        continue;
9692
9693
0
      if (!bfd_get_section_contents (ibfd, sec, buf,
9694
0
             rel->r_offset & ~3, 4))
9695
0
        goto got_error_ret;
9696
0
      insn = bfd_get_32 (ibfd, buf);
9697
0
      if (((insn & ((0x3fu << 26) | 0x1f << 16))
9698
0
           != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9699
0
        continue;
9700
0
      break;
9701
9702
0
    case R_PPC64_GOT16_LO_DS:
9703
0
      if (val - got + LIMIT_ADJUST (0x80008000ULL)
9704
0
          >= LIMIT_ADJUST (0x100000000ULL))
9705
0
        continue;
9706
0
      if (!bfd_get_section_contents (ibfd, sec, buf,
9707
0
             rel->r_offset & ~3, 4))
9708
0
        goto got_error_ret;
9709
0
      insn = bfd_get_32 (ibfd, buf);
9710
0
      if ((insn & (0x3fu << 26 | 0x3)) != 58u << 26 /* ld */)
9711
0
        continue;
9712
0
      break;
9713
9714
0
    case R_PPC64_GOT_PCREL34:
9715
0
      pc = rel->r_offset;
9716
0
      pc += sec->output_section->vma + sec->output_offset;
9717
0
      if (val - pc + LIMIT_ADJUST (1ULL << 33)
9718
0
          >= LIMIT_ADJUST (1ULL << 34))
9719
0
        continue;
9720
0
      if (!bfd_get_section_contents (ibfd, sec, buf,
9721
0
             rel->r_offset & ~3, 8))
9722
0
        goto got_error_ret;
9723
0
      insn = bfd_get_32 (ibfd, buf);
9724
0
      if ((insn & (-1u << 18)) != ((1u << 26) | (1u << 20)))
9725
0
        continue;
9726
0
      insn = bfd_get_32 (ibfd, buf + 4);
9727
0
      if ((insn & (0x3fu << 26)) != 57u << 26)
9728
0
        continue;
9729
0
      break;
9730
0
    }
9731
0
#undef LIMIT_ADJUST
9732
9733
0
        if (h != NULL)
9734
0
    ent = h->got.glist;
9735
0
        else
9736
0
    {
9737
0
      struct got_entry **local_got_ents = elf_local_got_ents (ibfd);
9738
0
      ent = local_got_ents[r_symndx];
9739
0
    }
9740
0
        for (; ent != NULL; ent = ent->next)
9741
0
    if (ent->addend == rel->r_addend
9742
0
        && ent->owner == ibfd
9743
0
        && ent->tls_type == 0)
9744
0
      break;
9745
0
        BFD_ASSERT (ent && ent->got.refcount > 0);
9746
0
        ent->got.refcount -= 1;
9747
0
      }
9748
9749
0
    if (elf_section_data (sec)->relocs != relstart)
9750
0
      free (relstart);
9751
0
  }
9752
9753
0
      if (local_syms != NULL
9754
0
    && symtab_hdr->contents != (unsigned char *) local_syms)
9755
0
  {
9756
0
    if (!info->keep_memory)
9757
0
      free (local_syms);
9758
0
    else
9759
0
      symtab_hdr->contents = (unsigned char *) local_syms;
9760
0
  }
9761
0
    }
9762
9763
0
  return true;
9764
0
}
9765
9766
/* Return true iff input section I references the TOC using
9767
   instructions limited to +/-32k offsets.  */
9768
9769
bool
9770
ppc64_elf_has_small_toc_reloc (asection *i)
9771
0
{
9772
0
  return (is_ppc64_elf (i->owner)
9773
0
    && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9774
0
}
9775
9776
/* Allocate space for one GOT entry.  */
9777
9778
static void
9779
allocate_got (struct elf_link_hash_entry *h,
9780
        struct bfd_link_info *info,
9781
        struct got_entry *gent)
9782
0
{
9783
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
9784
0
  struct ppc_link_hash_entry *eh = ppc_elf_hash_entry (h);
9785
0
  int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9786
0
     ? 16 : 8);
9787
0
  int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9788
0
      ? 2 : 1) * sizeof (Elf64_External_Rela);
9789
0
  asection *got = ppc64_elf_tdata (gent->owner)->got;
9790
9791
0
  gent->got.offset = got->size;
9792
0
  got->size += entsize;
9793
9794
0
  if (h->type == STT_GNU_IFUNC)
9795
0
    {
9796
0
      htab->elf.irelplt->size += rentsize;
9797
0
      htab->got_reli_size += rentsize;
9798
0
    }
9799
0
  else if (((bfd_link_pic (info)
9800
0
       && (gent->tls_type == 0
9801
0
     ? !info->enable_dt_relr
9802
0
     : !(bfd_link_executable (info)
9803
0
         && SYMBOL_REFERENCES_LOCAL (info, h)))
9804
0
       && !bfd_is_abs_symbol (&h->root))
9805
0
      || (htab->elf.dynamic_sections_created
9806
0
    && h->dynindx != -1
9807
0
    && !SYMBOL_REFERENCES_LOCAL (info, h)))
9808
0
     && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9809
0
    {
9810
0
      asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9811
0
      relgot->size += rentsize;
9812
0
    }
9813
0
}
9814
9815
/* This function merges got entries in the same toc group.  */
9816
9817
static void
9818
merge_got_entries (struct got_entry **pent)
9819
0
{
9820
0
  struct got_entry *ent, *ent2;
9821
9822
0
  for (ent = *pent; ent != NULL; ent = ent->next)
9823
0
    if (!ent->is_indirect)
9824
0
      for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9825
0
  if (!ent2->is_indirect
9826
0
      && ent2->addend == ent->addend
9827
0
      && ent2->tls_type == ent->tls_type
9828
0
      && elf_gp (ent2->owner) == elf_gp (ent->owner))
9829
0
    {
9830
0
      ent2->is_indirect = true;
9831
0
      ent2->got.ent = ent;
9832
0
    }
9833
0
}
9834
9835
/* If H is undefined, make it dynamic if that makes sense.  */
9836
9837
static bool
9838
ensure_undef_dynamic (struct bfd_link_info *info,
9839
          struct elf_link_hash_entry *h)
9840
0
{
9841
0
  struct elf_link_hash_table *htab = elf_hash_table (info);
9842
9843
0
  if (htab->dynamic_sections_created
9844
0
      && ((info->dynamic_undefined_weak != 0
9845
0
     && h->root.type == bfd_link_hash_undefweak)
9846
0
    || h->root.type == bfd_link_hash_undefined)
9847
0
      && h->dynindx == -1
9848
0
      && !h->forced_local
9849
0
      && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9850
0
    return bfd_elf_link_record_dynamic_symbol (info, h);
9851
0
  return true;
9852
0
}
9853
9854
/* Choose whether to use htab->iplt or htab->pltlocal rather than the
9855
   usual htab->elf.splt section for a PLT entry.  */
9856
9857
static inline
9858
bool use_local_plt (struct bfd_link_info *info,
9859
         struct elf_link_hash_entry *h)
9860
0
{
9861
0
  return (h == NULL
9862
0
    || h->dynindx == -1
9863
0
    || !elf_hash_table (info)->dynamic_sections_created);
9864
0
}
9865
9866
/* Allocate space in .plt, .got and associated reloc sections for
9867
   dynamic relocs.  */
9868
9869
static bool
9870
allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9871
0
{
9872
0
  struct bfd_link_info *info;
9873
0
  struct ppc_link_hash_table *htab;
9874
0
  asection *s;
9875
0
  struct ppc_link_hash_entry *eh;
9876
0
  struct got_entry **pgent, *gent;
9877
9878
0
  if (h->root.type == bfd_link_hash_indirect)
9879
0
    return true;
9880
9881
0
  info = (struct bfd_link_info *) inf;
9882
0
  htab = ppc_hash_table (info);
9883
0
  if (htab == NULL)
9884
0
    return false;
9885
9886
0
  eh = ppc_elf_hash_entry (h);
9887
  /* Run through the TLS GD got entries first if we're changing them
9888
     to TPREL.  */
9889
0
  if ((eh->tls_mask & (TLS_TLS | TLS_GDIE)) == (TLS_TLS | TLS_GDIE))
9890
0
    for (gent = h->got.glist; gent != NULL; gent = gent->next)
9891
0
      if (gent->got.refcount > 0
9892
0
    && (gent->tls_type & TLS_GD) != 0)
9893
0
  {
9894
    /* This was a GD entry that has been converted to TPREL.  If
9895
       there happens to be a TPREL entry we can use that one.  */
9896
0
    struct got_entry *ent;
9897
0
    for (ent = h->got.glist; ent != NULL; ent = ent->next)
9898
0
      if (ent->got.refcount > 0
9899
0
    && (ent->tls_type & TLS_TPREL) != 0
9900
0
    && ent->addend == gent->addend
9901
0
    && ent->owner == gent->owner)
9902
0
        {
9903
0
    gent->got.refcount = 0;
9904
0
    break;
9905
0
        }
9906
9907
    /* If not, then we'll be using our own TPREL entry.  */
9908
0
    if (gent->got.refcount != 0)
9909
0
      gent->tls_type = TLS_TLS | TLS_TPREL;
9910
0
  }
9911
9912
  /* Remove any list entry that won't generate a word in the GOT before
9913
     we call merge_got_entries.  Otherwise we risk merging to empty
9914
     entries.  */
9915
0
  pgent = &h->got.glist;
9916
0
  while ((gent = *pgent) != NULL)
9917
0
    if (gent->got.refcount > 0)
9918
0
      {
9919
0
  if ((gent->tls_type & TLS_LD) != 0
9920
0
      && SYMBOL_REFERENCES_LOCAL (info, h))
9921
0
    {
9922
0
      ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9923
0
      *pgent = gent->next;
9924
0
    }
9925
0
  else
9926
0
    pgent = &gent->next;
9927
0
      }
9928
0
    else
9929
0
      *pgent = gent->next;
9930
9931
0
  if (!htab->do_multi_toc)
9932
0
    merge_got_entries (&h->got.glist);
9933
9934
0
  for (gent = h->got.glist; gent != NULL; gent = gent->next)
9935
0
    if (!gent->is_indirect)
9936
0
      {
9937
  /* Ensure we catch all the cases where this symbol should
9938
     be made dynamic.  */
9939
0
  if (!ensure_undef_dynamic (info, h))
9940
0
    return false;
9941
9942
0
  if (!is_ppc64_elf (gent->owner))
9943
0
    abort ();
9944
9945
0
  allocate_got (h, info, gent);
9946
0
      }
9947
9948
  /* If no dynamic sections we can't have dynamic relocs, except for
9949
     IFUNCs which are handled even in static executables.  */
9950
0
  if (!htab->elf.dynamic_sections_created
9951
0
      && h->type != STT_GNU_IFUNC)
9952
0
    h->dyn_relocs = NULL;
9953
9954
  /* Discard relocs on undefined symbols that must be local.  */
9955
0
  else if (h->root.type == bfd_link_hash_undefined
9956
0
     && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9957
0
    h->dyn_relocs = NULL;
9958
9959
  /* Also discard relocs on undefined weak syms with non-default
9960
     visibility, or when dynamic_undefined_weak says so.  */
9961
0
  else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9962
0
    h->dyn_relocs = NULL;
9963
9964
0
  if (h->dyn_relocs != NULL)
9965
0
    {
9966
0
      struct ppc_dyn_relocs *p, **pp;
9967
9968
      /* In the shared -Bsymbolic case, discard space allocated for
9969
   dynamic pc-relative relocs against symbols which turn out to
9970
   be defined in regular objects.  For the normal shared case,
9971
   discard space for relocs that have become local due to symbol
9972
   visibility changes.  */
9973
0
      if (bfd_link_pic (info))
9974
0
  {
9975
    /* Relocs that use pc_count are those that appear on a call
9976
       insn, or certain REL relocs (see must_be_dyn_reloc) that
9977
       can be generated via assembly.  We want calls to
9978
       protected symbols to resolve directly to the function
9979
       rather than going via the plt.  If people want function
9980
       pointer comparisons to work as expected then they should
9981
       avoid writing weird assembly.  */
9982
0
    if (SYMBOL_CALLS_LOCAL (info, h))
9983
0
      {
9984
0
        for (pp = (struct ppc_dyn_relocs **) &h->dyn_relocs;
9985
0
       (p = *pp) != NULL;
9986
0
       )
9987
0
    {
9988
0
      p->count -= p->pc_count;
9989
0
      p->pc_count = 0;
9990
0
      if (p->count == 0)
9991
0
        *pp = p->next;
9992
0
      else
9993
0
        pp = &p->next;
9994
0
    }
9995
0
      }
9996
9997
0
    if (h->dyn_relocs != NULL)
9998
0
      {
9999
        /* Ensure we catch all the cases where this symbol
10000
     should be made dynamic.  */
10001
0
        if (!ensure_undef_dynamic (info, h))
10002
0
    return false;
10003
0
      }
10004
0
  }
10005
10006
      /* For a fixed position executable, discard space for
10007
   relocs against symbols which are not dynamic.  */
10008
0
      else if (h->type != STT_GNU_IFUNC)
10009
0
  {
10010
0
    if ((h->dynamic_adjusted
10011
0
         || (h->ref_regular
10012
0
       && h->root.type == bfd_link_hash_undefweak
10013
0
       && (info->dynamic_undefined_weak > 0
10014
0
           || !_bfd_elf_readonly_dynrelocs (h))))
10015
0
        && !h->def_regular
10016
0
        && !ELF_COMMON_DEF_P (h))
10017
0
      {
10018
        /* Ensure we catch all the cases where this symbol
10019
     should be made dynamic.  */
10020
0
        if (!ensure_undef_dynamic (info, h))
10021
0
    return false;
10022
10023
        /* But if that didn't work out, discard dynamic relocs.  */
10024
0
        if (h->dynindx == -1)
10025
0
    h->dyn_relocs = NULL;
10026
0
      }
10027
0
    else
10028
0
      h->dyn_relocs = NULL;
10029
0
  }
10030
10031
      /* Finally, allocate space.  */
10032
0
      for (p = (struct ppc_dyn_relocs *) h->dyn_relocs; p != NULL; p = p->next)
10033
0
  if (!discarded_section (p->sec))
10034
0
    {
10035
0
      unsigned int count;
10036
0
      asection *sreloc = elf_section_data (p->sec)->sreloc;
10037
0
      if (eh->elf.type == STT_GNU_IFUNC)
10038
0
        sreloc = htab->elf.irelplt;
10039
0
      count = p->count;
10040
0
      if (info->enable_dt_relr
10041
0
    && ((!NO_OPD_RELOCS
10042
0
         && ppc64_elf_section_data (p->sec)->sec_type == sec_opd)
10043
0
        || (eh->elf.type != STT_GNU_IFUNC
10044
0
      && SYMBOL_REFERENCES_LOCAL (info, h))))
10045
0
        count -= p->rel_count;
10046
0
      sreloc->size += count * sizeof (Elf64_External_Rela);
10047
0
    }
10048
0
    }
10049
10050
  /* We might need a PLT entry when the symbol
10051
     a) is dynamic, or
10052
     b) is an ifunc, or
10053
     c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10054
     d) has plt16 relocs and we are linking statically.  */
10055
0
  if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10056
0
      || h->type == STT_GNU_IFUNC
10057
0
      || (h->needs_plt && h->dynamic_adjusted)
10058
0
      || (h->needs_plt
10059
0
    && h->def_regular
10060
0
    && !htab->elf.dynamic_sections_created
10061
0
    && !htab->can_convert_all_inline_plt
10062
0
    && (ppc_elf_hash_entry (h)->tls_mask
10063
0
        & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10064
0
    {
10065
0
      struct plt_entry *pent;
10066
0
      bool doneone = false;
10067
0
      for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10068
0
  if (pent->plt.refcount > 0)
10069
0
    {
10070
0
      if (!ensure_undef_dynamic (info, h))
10071
0
        return false;
10072
10073
0
      if (use_local_plt (info, h))
10074
0
        {
10075
0
    if (h->type == STT_GNU_IFUNC)
10076
0
      {
10077
0
        s = htab->elf.iplt;
10078
0
        pent->plt.offset = s->size;
10079
0
        s->size += PLT_ENTRY_SIZE (htab);
10080
0
        s = htab->elf.irelplt;
10081
0
      }
10082
0
    else
10083
0
      {
10084
0
        s = htab->pltlocal;
10085
0
        pent->plt.offset = s->size;
10086
0
        s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10087
0
        s = NULL;
10088
0
        if (bfd_link_pic (info)
10089
0
      && !(info->enable_dt_relr && !htab->opd_abi))
10090
0
          s = htab->relpltlocal;
10091
0
      }
10092
0
        }
10093
0
      else
10094
0
        {
10095
    /* If this is the first .plt entry, make room for the special
10096
       first entry.  */
10097
0
    s = htab->elf.splt;
10098
0
    if (s->size == 0)
10099
0
      s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10100
10101
0
    pent->plt.offset = s->size;
10102
10103
    /* Make room for this entry.  */
10104
0
    s->size += PLT_ENTRY_SIZE (htab);
10105
10106
    /* Make room for the .glink code.  */
10107
0
    s = htab->glink;
10108
0
    if (s->size == 0)
10109
0
      s->size += GLINK_PLTRESOLVE_SIZE (htab);
10110
0
    if (htab->opd_abi)
10111
0
      {
10112
        /* We need bigger stubs past index 32767.  */
10113
0
        if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10114
0
          s->size += 4;
10115
0
        s->size += 2*4;
10116
0
      }
10117
0
    else
10118
0
      s->size += 4;
10119
10120
    /* We also need to make an entry in the .rela.plt section.  */
10121
0
    s = htab->elf.srelplt;
10122
0
        }
10123
0
      if (s != NULL)
10124
0
        s->size += sizeof (Elf64_External_Rela);
10125
0
      doneone = true;
10126
0
    }
10127
0
  else
10128
0
    pent->plt.offset = (bfd_vma) -1;
10129
0
      if (!doneone)
10130
0
  {
10131
0
    h->plt.plist = NULL;
10132
0
    h->needs_plt = 0;
10133
0
  }
10134
0
    }
10135
0
  else
10136
0
    {
10137
0
      h->plt.plist = NULL;
10138
0
      h->needs_plt = 0;
10139
0
    }
10140
10141
0
  return true;
10142
0
}
10143
10144
0
#define PPC_LO(v) ((v) & 0xffff)
10145
0
#define PPC_HI(v) (((v) >> 16) & 0xffff)
10146
0
#define PPC_HA(v) PPC_HI ((v) + 0x8000)
10147
#define D34(v) \
10148
0
  ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
10149
#define HA34(v) ((v + (1ULL << 33)) >> 34)
10150
10151
/* Called via elf_link_hash_traverse from ppc64_elf_late_size_sections
10152
   to set up space for global entry stubs.  These are put in glink,
10153
   after the branch table.  */
10154
10155
static bool
10156
size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10157
0
{
10158
0
  struct bfd_link_info *info;
10159
0
  struct ppc_link_hash_table *htab;
10160
0
  struct plt_entry *pent;
10161
0
  asection *s, *plt;
10162
10163
0
  if (h->root.type == bfd_link_hash_indirect)
10164
0
    return true;
10165
10166
0
  if (!h->pointer_equality_needed)
10167
0
    return true;
10168
10169
0
  if (h->def_regular)
10170
0
    return true;
10171
10172
0
  info = inf;
10173
0
  htab = ppc_hash_table (info);
10174
0
  if (htab == NULL)
10175
0
    return false;
10176
10177
0
  s = htab->global_entry;
10178
0
  plt = htab->elf.splt;
10179
0
  for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10180
0
    if (pent->plt.offset != (bfd_vma) -1
10181
0
  && pent->addend == 0)
10182
0
      {
10183
  /* For ELFv2, if this symbol is not defined in a regular file
10184
     and we are not generating a shared library or pie, then we
10185
     need to define the symbol in the executable on a call stub.
10186
     This is to avoid text relocations.  */
10187
0
  bfd_vma off, stub_align, stub_off, stub_size;
10188
0
  unsigned int align_power;
10189
10190
0
  stub_size = 16;
10191
0
  stub_off = s->size;
10192
0
  if (htab->params->plt_stub_align >= 0)
10193
0
    align_power = htab->params->plt_stub_align;
10194
0
  else
10195
0
    align_power = -htab->params->plt_stub_align;
10196
  /* Setting section alignment is delayed until we know it is
10197
     non-empty.  Otherwise the .text output section will be
10198
     aligned at least to plt_stub_align even when no global
10199
     entry stubs are needed.  */
10200
0
  if (s->alignment_power < align_power)
10201
0
    s->alignment_power = align_power;
10202
0
  stub_align = (bfd_vma) 1 << align_power;
10203
0
  if (htab->params->plt_stub_align >= 0
10204
0
      || ((((stub_off + stub_size - 1) & -stub_align)
10205
0
     - (stub_off & -stub_align))
10206
0
    > ((stub_size - 1) & -stub_align)))
10207
0
    stub_off = (stub_off + stub_align - 1) & -stub_align;
10208
0
  off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10209
0
  off -= stub_off + s->output_offset + s->output_section->vma;
10210
  /* Note that for --plt-stub-align negative we have a possible
10211
     dependency between stub offset and size.  Break that
10212
     dependency by assuming the max stub size when calculating
10213
     the stub offset.  */
10214
0
  if (PPC_HA (off) == 0)
10215
0
    stub_size -= 4;
10216
0
  h->root.type = bfd_link_hash_defined;
10217
0
  h->root.u.def.section = s;
10218
0
  h->root.u.def.value = stub_off;
10219
0
  s->size = stub_off + stub_size;
10220
0
  break;
10221
0
      }
10222
0
  return true;
10223
0
}
10224
10225
/* Set the sizes of the dynamic sections.  */
10226
10227
static bool
10228
ppc64_elf_late_size_sections (bfd *output_bfd,
10229
            struct bfd_link_info *info)
10230
0
{
10231
0
  struct ppc_link_hash_table *htab;
10232
0
  bfd *dynobj;
10233
0
  asection *s;
10234
0
  bool relocs;
10235
0
  bfd *ibfd;
10236
0
  struct got_entry *first_tlsld;
10237
10238
0
  htab = ppc_hash_table (info);
10239
0
  if (htab == NULL)
10240
0
    return false;
10241
10242
0
  dynobj = htab->elf.dynobj;
10243
0
  if (dynobj == NULL)
10244
0
    return true;
10245
10246
0
  if (htab->elf.dynamic_sections_created)
10247
0
    {
10248
      /* Set the contents of the .interp section to the interpreter.  */
10249
0
      if (bfd_link_executable (info) && !info->nointerp)
10250
0
  {
10251
0
    s = bfd_get_linker_section (dynobj, ".interp");
10252
0
    if (s == NULL)
10253
0
      abort ();
10254
0
    s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10255
0
    s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10256
0
  }
10257
0
    }
10258
10259
  /* Set up .got offsets for local syms, and space for local dynamic
10260
     relocs.  */
10261
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10262
0
    {
10263
0
      struct got_entry **lgot_ents;
10264
0
      struct got_entry **end_lgot_ents;
10265
0
      struct plt_entry **local_plt;
10266
0
      struct plt_entry **end_local_plt;
10267
0
      unsigned char *lgot_masks;
10268
0
      bfd_size_type locsymcount;
10269
0
      Elf_Internal_Shdr *symtab_hdr;
10270
0
      Elf_Internal_Sym *local_syms;
10271
0
      Elf_Internal_Sym *isym;
10272
10273
0
      if (!is_ppc64_elf (ibfd))
10274
0
  continue;
10275
10276
0
      for (s = ibfd->sections; s != NULL; s = s->next)
10277
0
  {
10278
0
    struct ppc_local_dyn_relocs *p;
10279
10280
0
    for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10281
0
      {
10282
0
        if (discarded_section (p->sec))
10283
0
    {
10284
      /* Input section has been discarded, either because
10285
         it is a copy of a linkonce section or due to
10286
         linker script /DISCARD/, so we'll be discarding
10287
         the relocs too.  */
10288
0
    }
10289
0
        else if (p->count != 0)
10290
0
    {
10291
0
      unsigned int count;
10292
0
      asection *srel;
10293
10294
0
      count = p->count;
10295
0
      if (info->enable_dt_relr
10296
0
          && ((!NO_OPD_RELOCS
10297
0
         && (ppc64_elf_section_data (p->sec)->sec_type
10298
0
             == sec_opd))
10299
0
        || !p->ifunc))
10300
0
        count -= p->rel_count;
10301
0
      srel = elf_section_data (p->sec)->sreloc;
10302
0
      if (p->ifunc)
10303
0
        srel = htab->elf.irelplt;
10304
0
      srel->size += count * sizeof (Elf64_External_Rela);
10305
0
      if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10306
0
        info->flags |= DF_TEXTREL;
10307
0
    }
10308
0
      }
10309
0
  }
10310
10311
0
      lgot_ents = elf_local_got_ents (ibfd);
10312
0
      if (!lgot_ents)
10313
0
  continue;
10314
10315
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
10316
0
      locsymcount = symtab_hdr->sh_info;
10317
0
      end_lgot_ents = lgot_ents + locsymcount;
10318
0
      local_plt = (struct plt_entry **) end_lgot_ents;
10319
0
      end_local_plt = local_plt + locsymcount;
10320
0
      lgot_masks = (unsigned char *) end_local_plt;
10321
0
      local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
10322
0
      if (local_syms == NULL && locsymcount != 0)
10323
0
  {
10324
0
    local_syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, locsymcount,
10325
0
               0, NULL, NULL, NULL);
10326
0
    if (local_syms == NULL)
10327
0
      return false;
10328
0
  }
10329
0
      s = ppc64_elf_tdata (ibfd)->got;
10330
0
      for (isym = local_syms;
10331
0
     lgot_ents < end_lgot_ents;
10332
0
     ++lgot_ents, ++lgot_masks, isym++)
10333
0
  {
10334
0
    struct got_entry **pent, *ent;
10335
10336
0
    pent = lgot_ents;
10337
0
    while ((ent = *pent) != NULL)
10338
0
      if (ent->got.refcount > 0)
10339
0
        {
10340
0
    if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10341
0
      {
10342
0
        ppc64_tlsld_got (ibfd)->got.refcount += 1;
10343
0
        *pent = ent->next;
10344
0
      }
10345
0
    else
10346
0
      {
10347
0
        unsigned int ent_size = 8;
10348
0
        unsigned int rel_size = sizeof (Elf64_External_Rela);
10349
10350
0
        ent->got.offset = s->size;
10351
0
        if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10352
0
          {
10353
0
      ent_size *= 2;
10354
0
      rel_size *= 2;
10355
0
          }
10356
0
        s->size += ent_size;
10357
0
        if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10358
0
          {
10359
0
      htab->elf.irelplt->size += rel_size;
10360
0
      htab->got_reli_size += rel_size;
10361
0
          }
10362
0
        else if (bfd_link_pic (info)
10363
0
           && (ent->tls_type == 0
10364
0
         ? !info->enable_dt_relr
10365
0
         : !bfd_link_executable (info))
10366
0
           && isym->st_shndx != SHN_ABS)
10367
0
          {
10368
0
      asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10369
0
      srel->size += rel_size;
10370
0
          }
10371
0
        pent = &ent->next;
10372
0
      }
10373
0
        }
10374
0
      else
10375
0
        *pent = ent->next;
10376
0
  }
10377
0
      if (local_syms != NULL
10378
0
    && symtab_hdr->contents != (unsigned char *) local_syms)
10379
0
  {
10380
0
    if (!info->keep_memory)
10381
0
      free (local_syms);
10382
0
    else
10383
0
      symtab_hdr->contents = (unsigned char *) local_syms;
10384
0
  }
10385
10386
      /* Allocate space for plt calls to local syms.  */
10387
0
      lgot_masks = (unsigned char *) end_local_plt;
10388
0
      for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10389
0
  {
10390
0
    struct plt_entry *ent;
10391
10392
0
    for (ent = *local_plt; ent != NULL; ent = ent->next)
10393
0
      if (ent->plt.refcount > 0)
10394
0
        {
10395
0
    if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10396
0
      {
10397
0
        s = htab->elf.iplt;
10398
0
        ent->plt.offset = s->size;
10399
0
        s->size += PLT_ENTRY_SIZE (htab);
10400
0
        htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10401
0
      }
10402
0
    else if (htab->can_convert_all_inline_plt
10403
0
       || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10404
0
      ent->plt.offset = (bfd_vma) -1;
10405
0
    else
10406
0
      {
10407
0
        s = htab->pltlocal;
10408
0
        ent->plt.offset = s->size;
10409
0
        s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10410
0
        if (bfd_link_pic (info)
10411
0
      && !(info->enable_dt_relr && !htab->opd_abi))
10412
0
          htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10413
0
      }
10414
0
        }
10415
0
      else
10416
0
        ent->plt.offset = (bfd_vma) -1;
10417
0
  }
10418
0
    }
10419
10420
  /* Allocate global sym .plt and .got entries, and space for global
10421
     sym dynamic relocs.  */
10422
0
  elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10423
10424
0
  if (!htab->opd_abi && !bfd_link_pic (info))
10425
0
    elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10426
10427
0
  first_tlsld = NULL;
10428
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10429
0
    {
10430
0
      struct got_entry *ent;
10431
10432
0
      if (!is_ppc64_elf (ibfd))
10433
0
  continue;
10434
10435
0
      ent = ppc64_tlsld_got (ibfd);
10436
0
      if (ent->got.refcount > 0)
10437
0
  {
10438
0
    if (!htab->do_multi_toc && first_tlsld != NULL)
10439
0
      {
10440
0
        ent->is_indirect = true;
10441
0
        ent->got.ent = first_tlsld;
10442
0
      }
10443
0
    else
10444
0
      {
10445
0
        if (first_tlsld == NULL)
10446
0
    first_tlsld = ent;
10447
0
        s = ppc64_elf_tdata (ibfd)->got;
10448
0
        ent->got.offset = s->size;
10449
0
        ent->owner = ibfd;
10450
0
        s->size += 16;
10451
0
        if (bfd_link_dll (info))
10452
0
    {
10453
0
      asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10454
0
      srel->size += sizeof (Elf64_External_Rela);
10455
0
    }
10456
0
      }
10457
0
  }
10458
0
      else
10459
0
  ent->got.offset = (bfd_vma) -1;
10460
0
    }
10461
10462
  /* We now have determined the sizes of the various dynamic sections.
10463
     Allocate memory for them.  */
10464
0
  relocs = false;
10465
0
  for (s = dynobj->sections; s != NULL; s = s->next)
10466
0
    {
10467
0
      if ((s->flags & SEC_LINKER_CREATED) == 0)
10468
0
  continue;
10469
10470
0
      if (s == htab->brlt || s == htab->relbrlt || s == htab->elf.srelrdyn)
10471
  /* These haven't been allocated yet;  don't strip.  */
10472
0
  continue;
10473
0
      else if (s == htab->elf.sgot
10474
0
         || s == htab->elf.splt
10475
0
         || s == htab->elf.iplt
10476
0
         || s == htab->pltlocal
10477
0
         || s == htab->glink
10478
0
         || s == htab->global_entry
10479
0
         || s == htab->elf.sdynbss
10480
0
         || s == htab->elf.sdynrelro)
10481
0
  {
10482
    /* Strip this section if we don't need it; see the
10483
       comment below.  */
10484
0
  }
10485
0
      else if (s == htab->glink_eh_frame)
10486
0
  {
10487
0
    if (!bfd_is_abs_section (s->output_section))
10488
      /* Not sized yet.  */
10489
0
      continue;
10490
0
  }
10491
0
      else if (startswith (s->name, ".rela"))
10492
0
  {
10493
0
    if (s->size != 0)
10494
0
      {
10495
0
        if (s != htab->elf.srelplt)
10496
0
    relocs = true;
10497
10498
        /* We use the reloc_count field as a counter if we need
10499
     to copy relocs into the output file.  */
10500
0
        s->reloc_count = 0;
10501
0
      }
10502
0
  }
10503
0
      else
10504
0
  {
10505
    /* It's not one of our sections, so don't allocate space.  */
10506
0
    continue;
10507
0
  }
10508
10509
0
      if (s->size == 0)
10510
0
  {
10511
    /* If we don't need this section, strip it from the
10512
       output file.  This is mostly to handle .rela.bss and
10513
       .rela.plt.  We must create both sections in
10514
       create_dynamic_sections, because they must be created
10515
       before the linker maps input sections to output
10516
       sections.  The linker does that before
10517
       adjust_dynamic_symbol is called, and it is that
10518
       function which decides whether anything needs to go
10519
       into these sections.  */
10520
0
    s->flags |= SEC_EXCLUDE;
10521
0
    continue;
10522
0
  }
10523
10524
0
      if (bfd_is_abs_section (s->output_section))
10525
0
  _bfd_error_handler (_("warning: discarding dynamic section %s"),
10526
0
          s->name);
10527
10528
0
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
10529
0
  continue;
10530
10531
      /* Allocate memory for the section contents.  We use bfd_zalloc
10532
   here in case unused entries are not reclaimed before the
10533
   section's contents are written out.  This should not happen,
10534
   but this way if it does we get a R_PPC64_NONE reloc in .rela
10535
   sections instead of garbage.
10536
   We also rely on the section contents being zero when writing
10537
   the GOT and .dynrelro.  */
10538
0
      s->contents = bfd_zalloc (dynobj, s->size);
10539
0
      if (s->contents == NULL)
10540
0
  return false;
10541
0
    }
10542
10543
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10544
0
    {
10545
0
      if (!is_ppc64_elf (ibfd))
10546
0
  continue;
10547
10548
0
      s = ppc64_elf_tdata (ibfd)->got;
10549
0
      if (s != NULL && s != htab->elf.sgot)
10550
0
  {
10551
0
    if (s->size == 0)
10552
0
      s->flags |= SEC_EXCLUDE;
10553
0
    else
10554
0
      {
10555
0
        s->contents = bfd_zalloc (ibfd, s->size);
10556
0
        if (s->contents == NULL)
10557
0
    return false;
10558
0
      }
10559
0
  }
10560
0
      s = ppc64_elf_tdata (ibfd)->relgot;
10561
0
      if (s != NULL)
10562
0
  {
10563
0
    if (s->size == 0)
10564
0
      s->flags |= SEC_EXCLUDE;
10565
0
    else
10566
0
      {
10567
0
        s->contents = bfd_zalloc (ibfd, s->size);
10568
0
        if (s->contents == NULL)
10569
0
    return false;
10570
0
        relocs = true;
10571
0
        s->reloc_count = 0;
10572
0
      }
10573
0
  }
10574
0
    }
10575
10576
0
  if (htab->elf.dynamic_sections_created)
10577
0
    {
10578
0
      bool tls_opt;
10579
10580
      /* Add some entries to the .dynamic section.  We fill in the
10581
   values later, in ppc64_elf_finish_dynamic_sections, but we
10582
   must add the entries now so that we get the correct size for
10583
   the .dynamic section.  The DT_DEBUG entry is filled in by the
10584
   dynamic linker and used by the debugger.  */
10585
0
#define add_dynamic_entry(TAG, VAL) \
10586
0
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10587
10588
0
      if (bfd_link_executable (info))
10589
0
  {
10590
0
    if (!add_dynamic_entry (DT_DEBUG, 0))
10591
0
      return false;
10592
0
  }
10593
10594
0
      if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10595
0
  {
10596
0
    if (!add_dynamic_entry (DT_PLTGOT, 0)
10597
0
        || !add_dynamic_entry (DT_PLTRELSZ, 0)
10598
0
        || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10599
0
        || !add_dynamic_entry (DT_JMPREL, 0)
10600
0
        || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10601
0
      return false;
10602
0
  }
10603
10604
0
      if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10605
0
  {
10606
0
    if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10607
0
        || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10608
0
      return false;
10609
0
  }
10610
10611
0
      tls_opt = (htab->params->tls_get_addr_opt
10612
0
     && ((htab->tls_get_addr_fd != NULL
10613
0
          && htab->tls_get_addr_fd->elf.plt.plist != NULL)
10614
0
         || (htab->tga_desc_fd != NULL
10615
0
       && htab->tga_desc_fd->elf.plt.plist != NULL)));
10616
0
      if (tls_opt || !htab->opd_abi)
10617
0
  {
10618
0
    if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10619
0
      return false;
10620
0
  }
10621
10622
0
      if (relocs)
10623
0
  {
10624
0
    if (!add_dynamic_entry (DT_RELA, 0)
10625
0
        || !add_dynamic_entry (DT_RELASZ, 0)
10626
0
        || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10627
0
      return false;
10628
10629
    /* If any dynamic relocs apply to a read-only section,
10630
       then we need a DT_TEXTREL entry.  */
10631
0
    if ((info->flags & DF_TEXTREL) == 0)
10632
0
      elf_link_hash_traverse (&htab->elf,
10633
0
            _bfd_elf_maybe_set_textrel, info);
10634
10635
0
    if ((info->flags & DF_TEXTREL) != 0)
10636
0
      {
10637
0
        if (!add_dynamic_entry (DT_TEXTREL, 0))
10638
0
    return false;
10639
0
      }
10640
0
  }
10641
0
    }
10642
0
#undef add_dynamic_entry
10643
10644
0
  return true;
10645
0
}
10646
10647
/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10648
10649
static bool
10650
ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10651
0
{
10652
0
  if (h->plt.plist != NULL
10653
0
      && !h->def_regular
10654
0
      && !h->pointer_equality_needed)
10655
0
    return false;
10656
10657
0
  return _bfd_elf_hash_symbol (h);
10658
0
}
10659
10660
/* Determine the type of stub needed, if any, for a call.  */
10661
10662
static inline enum ppc_stub_main_type
10663
ppc_type_of_stub (asection *input_sec,
10664
      const Elf_Internal_Rela *rel,
10665
      struct ppc_link_hash_entry **hash,
10666
      struct plt_entry **plt_ent,
10667
      bfd_vma destination,
10668
      unsigned long local_off)
10669
0
{
10670
0
  struct ppc_link_hash_entry *h = *hash;
10671
0
  bfd_vma location;
10672
0
  bfd_vma branch_offset;
10673
0
  bfd_vma max_branch_offset;
10674
0
  enum elf_ppc64_reloc_type r_type;
10675
10676
0
  if (h != NULL)
10677
0
    {
10678
0
      struct plt_entry *ent;
10679
0
      struct ppc_link_hash_entry *fdh = h;
10680
0
      if (h->oh != NULL
10681
0
    && h->oh->is_func_descriptor)
10682
0
  {
10683
0
    fdh = ppc_follow_link (h->oh);
10684
0
    *hash = fdh;
10685
0
  }
10686
10687
0
      for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10688
0
  if (ent->addend == rel->r_addend
10689
0
      && ent->plt.offset != (bfd_vma) -1)
10690
0
    {
10691
0
      *plt_ent = ent;
10692
0
      return ppc_stub_plt_call;
10693
0
    }
10694
10695
      /* Here, we know we don't have a plt entry.  If we don't have a
10696
   either a defined function descriptor or a defined entry symbol
10697
   in a regular object file, then it is pointless trying to make
10698
   any other type of stub.  */
10699
0
      if (!is_static_defined (&fdh->elf)
10700
0
    && !is_static_defined (&h->elf))
10701
0
  return ppc_stub_none;
10702
0
    }
10703
0
  else if (elf_local_got_ents (input_sec->owner) != NULL)
10704
0
    {
10705
0
      Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10706
0
      struct plt_entry **local_plt = (struct plt_entry **)
10707
0
  elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10708
0
      unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10709
10710
0
      if (local_plt[r_symndx] != NULL)
10711
0
  {
10712
0
    struct plt_entry *ent;
10713
10714
0
    for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10715
0
      if (ent->addend == rel->r_addend
10716
0
    && ent->plt.offset != (bfd_vma) -1)
10717
0
        {
10718
0
    *plt_ent = ent;
10719
0
    return ppc_stub_plt_call;
10720
0
        }
10721
0
  }
10722
0
    }
10723
10724
  /* Determine where the call point is.  */
10725
0
  location = (input_sec->output_offset
10726
0
        + input_sec->output_section->vma
10727
0
        + rel->r_offset);
10728
10729
0
  branch_offset = destination - location;
10730
0
  r_type = ELF64_R_TYPE (rel->r_info);
10731
10732
  /* Determine if a long branch stub is needed.  */
10733
0
  max_branch_offset = 1 << 25;
10734
0
  if (r_type == R_PPC64_REL14
10735
0
      || r_type == R_PPC64_REL14_BRTAKEN
10736
0
      || r_type == R_PPC64_REL14_BRNTAKEN)
10737
0
    max_branch_offset = 1 << 15;
10738
10739
0
  if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10740
    /* We need a stub.  Figure out whether a long_branch or plt_branch
10741
       is needed later.  */
10742
0
    return ppc_stub_long_branch;
10743
10744
0
  return ppc_stub_none;
10745
0
}
10746
10747
/* Gets the address of a label (1:) in r11 and builds an offset in r12,
10748
   then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10749
   .  mflr  %r12
10750
   .  bcl 20,31,1f
10751
   .1:  mflr  %r11
10752
   .  mtlr  %r12
10753
   .  lis %r12,xxx-1b@highest
10754
   .  ori %r12,%r12,xxx-1b@higher
10755
   .  sldi  %r12,%r12,32
10756
   .  oris  %r12,%r12,xxx-1b@high
10757
   .  ori %r12,%r12,xxx-1b@l
10758
   .  add/ldx %r12,%r11,%r12  */
10759
10760
static bfd_byte *
10761
build_offset (bfd *abfd, bfd_byte *p, bfd_vma off, bool load)
10762
0
{
10763
0
  bfd_put_32 (abfd, MFLR_R12, p);
10764
0
  p += 4;
10765
0
  bfd_put_32 (abfd, BCL_20_31, p);
10766
0
  p += 4;
10767
0
  bfd_put_32 (abfd, MFLR_R11, p);
10768
0
  p += 4;
10769
0
  bfd_put_32 (abfd, MTLR_R12, p);
10770
0
  p += 4;
10771
0
  if (off + 0x8000 < 0x10000)
10772
0
    {
10773
0
      if (load)
10774
0
  bfd_put_32 (abfd, LD_R12_0R11 + PPC_LO (off), p);
10775
0
      else
10776
0
  bfd_put_32 (abfd, ADDI_R12_R11 + PPC_LO (off), p);
10777
0
      p += 4;
10778
0
    }
10779
0
  else if (off + 0x80008000ULL < 0x100000000ULL)
10780
0
    {
10781
0
      bfd_put_32 (abfd, ADDIS_R12_R11 + PPC_HA (off), p);
10782
0
      p += 4;
10783
0
      if (load)
10784
0
  bfd_put_32 (abfd, LD_R12_0R12 + PPC_LO (off), p);
10785
0
      else
10786
0
  bfd_put_32 (abfd, ADDI_R12_R12 + PPC_LO (off), p);
10787
0
      p += 4;
10788
0
    }
10789
0
  else
10790
0
    {
10791
0
      if (off + 0x800000000000ULL < 0x1000000000000ULL)
10792
0
  {
10793
0
    bfd_put_32 (abfd, LI_R12_0 + ((off >> 32) & 0xffff), p);
10794
0
    p += 4;
10795
0
  }
10796
0
      else
10797
0
  {
10798
0
    bfd_put_32 (abfd, LIS_R12 + ((off >> 48) & 0xffff), p);
10799
0
    p += 4;
10800
0
    if (((off >> 32) & 0xffff) != 0)
10801
0
      {
10802
0
        bfd_put_32 (abfd, ORI_R12_R12_0 + ((off >> 32) & 0xffff), p);
10803
0
        p += 4;
10804
0
      }
10805
0
  }
10806
0
      if (((off >> 32) & 0xffffffffULL) != 0)
10807
0
  {
10808
0
    bfd_put_32 (abfd, SLDI_R12_R12_32, p);
10809
0
    p += 4;
10810
0
  }
10811
0
      if (PPC_HI (off) != 0)
10812
0
  {
10813
0
    bfd_put_32 (abfd, ORIS_R12_R12_0 + PPC_HI (off), p);
10814
0
    p += 4;
10815
0
  }
10816
0
      if (PPC_LO (off) != 0)
10817
0
  {
10818
0
    bfd_put_32 (abfd, ORI_R12_R12_0 + PPC_LO (off), p);
10819
0
    p += 4;
10820
0
  }
10821
0
      if (load)
10822
0
  bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10823
0
      else
10824
0
  bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10825
0
      p += 4;
10826
0
    }
10827
0
  return p;
10828
0
}
10829
10830
static unsigned int
10831
size_offset (bfd_vma off)
10832
0
{
10833
0
  unsigned int size;
10834
0
  if (off + 0x8000 < 0x10000)
10835
0
    size = 4;
10836
0
  else if (off + 0x80008000ULL < 0x100000000ULL)
10837
0
    size = 8;
10838
0
  else
10839
0
    {
10840
0
      if (off + 0x800000000000ULL < 0x1000000000000ULL)
10841
0
  size = 4;
10842
0
      else
10843
0
  {
10844
0
    size = 4;
10845
0
    if (((off >> 32) & 0xffff) != 0)
10846
0
      size += 4;
10847
0
  }
10848
0
      if (((off >> 32) & 0xffffffffULL) != 0)
10849
0
  size += 4;
10850
0
      if (PPC_HI (off) != 0)
10851
0
  size += 4;
10852
0
      if (PPC_LO (off) != 0)
10853
0
  size += 4;
10854
0
      size += 4;
10855
0
    }
10856
0
  return size + 16;
10857
0
}
10858
10859
static unsigned int
10860
num_relocs_for_offset (bfd_vma off)
10861
0
{
10862
0
  unsigned int num_rel;
10863
0
  if (off + 0x8000 < 0x10000)
10864
0
    num_rel = 1;
10865
0
  else if (off + 0x80008000ULL < 0x100000000ULL)
10866
0
    num_rel = 2;
10867
0
  else
10868
0
    {
10869
0
      num_rel = 1;
10870
0
      if (off + 0x800000000000ULL >= 0x1000000000000ULL
10871
0
    && ((off >> 32) & 0xffff) != 0)
10872
0
  num_rel += 1;
10873
0
      if (PPC_HI (off) != 0)
10874
0
  num_rel += 1;
10875
0
      if (PPC_LO (off) != 0)
10876
0
  num_rel += 1;
10877
0
    }
10878
0
  return num_rel;
10879
0
}
10880
10881
static Elf_Internal_Rela *
10882
emit_relocs_for_offset (struct bfd_link_info *info, Elf_Internal_Rela *r,
10883
      bfd_vma roff, bfd_vma targ, bfd_vma off)
10884
0
{
10885
0
  bfd_vma relative_targ = targ - (roff - 8);
10886
0
  if (bfd_big_endian (info->output_bfd))
10887
0
    roff += 2;
10888
0
  r->r_offset = roff;
10889
0
  r->r_addend = relative_targ + roff;
10890
0
  if (off + 0x8000 < 0x10000)
10891
0
    r->r_info = ELF64_R_INFO (0, R_PPC64_REL16);
10892
0
  else if (off + 0x80008000ULL < 0x100000000ULL)
10893
0
    {
10894
0
      r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HA);
10895
0
      ++r;
10896
0
      roff += 4;
10897
0
      r->r_offset = roff;
10898
0
      r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_LO);
10899
0
      r->r_addend = relative_targ + roff;
10900
0
    }
10901
0
  else
10902
0
    {
10903
0
      if (off + 0x800000000000ULL < 0x1000000000000ULL)
10904
0
  r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHER);
10905
0
      else
10906
0
  {
10907
0
    r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST);
10908
0
    if (((off >> 32) & 0xffff) != 0)
10909
0
      {
10910
0
        ++r;
10911
0
        roff += 4;
10912
0
        r->r_offset = roff;
10913
0
        r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHER);
10914
0
        r->r_addend = relative_targ + roff;
10915
0
      }
10916
0
  }
10917
0
      if (((off >> 32) & 0xffffffffULL) != 0)
10918
0
  roff += 4;
10919
0
      if (PPC_HI (off) != 0)
10920
0
  {
10921
0
    ++r;
10922
0
    roff += 4;
10923
0
    r->r_offset = roff;
10924
0
    r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGH);
10925
0
    r->r_addend = relative_targ + roff;
10926
0
  }
10927
0
      if (PPC_LO (off) != 0)
10928
0
  {
10929
0
    ++r;
10930
0
    roff += 4;
10931
0
    r->r_offset = roff;
10932
0
    r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_LO);
10933
0
    r->r_addend = relative_targ + roff;
10934
0
  }
10935
0
    }
10936
0
  return r;
10937
0
}
10938
10939
static bfd_byte *
10940
build_power10_offset (bfd *abfd, bfd_byte *p, bfd_vma off, int odd,
10941
          bool load)
10942
0
{
10943
0
  uint64_t insn;
10944
0
  if (off - odd + (1ULL << 33) < 1ULL << 34)
10945
0
    {
10946
0
      off -= odd;
10947
0
      if (odd)
10948
0
  {
10949
0
    bfd_put_32 (abfd, NOP, p);
10950
0
    p += 4;
10951
0
  }
10952
0
      if (load)
10953
0
  insn = PLD_R12_PC;
10954
0
      else
10955
0
  insn = PADDI_R12_PC;
10956
0
      insn |= D34 (off);
10957
0
      bfd_put_32 (abfd, insn >> 32, p);
10958
0
      p += 4;
10959
0
      bfd_put_32 (abfd, insn, p);
10960
0
    }
10961
  /* The minimum value for paddi is -0x200000000.  The minimum value
10962
     for li is -0x8000, which when shifted by 34 and added gives a
10963
     minimum value of -0x2000200000000.  The maximum value is
10964
     0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1.  */
10965
0
  else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
10966
0
    {
10967
0
      off -= 8 - odd;
10968
0
      bfd_put_32 (abfd, LI_R11_0 | (HA34 (off) & 0xffff), p);
10969
0
      p += 4;
10970
0
      if (!odd)
10971
0
  {
10972
0
    bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10973
0
    p += 4;
10974
0
  }
10975
0
      insn = PADDI_R12_PC | D34 (off);
10976
0
      bfd_put_32 (abfd, insn >> 32, p);
10977
0
      p += 4;
10978
0
      bfd_put_32 (abfd, insn, p);
10979
0
      p += 4;
10980
0
      if (odd)
10981
0
  {
10982
0
    bfd_put_32 (abfd, SLDI_R11_R11_34, p);
10983
0
    p += 4;
10984
0
  }
10985
0
      if (load)
10986
0
  bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10987
0
      else
10988
0
  bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10989
0
    }
10990
0
  else
10991
0
    {
10992
0
      off -= odd + 8;
10993
0
      bfd_put_32 (abfd, LIS_R11 | ((HA34 (off) >> 16) & 0x3fff), p);
10994
0
      p += 4;
10995
0
      bfd_put_32 (abfd, ORI_R11_R11_0 | (HA34 (off) & 0xffff), p);
10996
0
      p += 4;
10997
0
      if (odd)
10998
0
  {
10999
0
    bfd_put_32 (abfd, SLDI_R11_R11_34, p);
11000
0
    p += 4;
11001
0
  }
11002
0
      insn = PADDI_R12_PC | D34 (off);
11003
0
      bfd_put_32 (abfd, insn >> 32, p);
11004
0
      p += 4;
11005
0
      bfd_put_32 (abfd, insn, p);
11006
0
      p += 4;
11007
0
      if (!odd)
11008
0
  {
11009
0
    bfd_put_32 (abfd, SLDI_R11_R11_34, p);
11010
0
    p += 4;
11011
0
  }
11012
0
      if (load)
11013
0
  bfd_put_32 (abfd, LDX_R12_R11_R12, p);
11014
0
      else
11015
0
  bfd_put_32 (abfd, ADD_R12_R11_R12, p);
11016
0
    }
11017
0
  p += 4;
11018
0
  return p;
11019
0
}
11020
11021
static unsigned int
11022
size_power10_offset (bfd_vma off, int odd)
11023
0
{
11024
0
  if (off - odd + (1ULL << 33) < 1ULL << 34)
11025
0
    return odd + 8;
11026
0
  else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
11027
0
    return 20;
11028
0
  else
11029
0
    return 24;
11030
0
}
11031
11032
static unsigned int
11033
num_relocs_for_power10_offset (bfd_vma off, int odd)
11034
0
{
11035
0
  if (off - odd + (1ULL << 33) < 1ULL << 34)
11036
0
    return 1;
11037
0
  else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
11038
0
    return 2;
11039
0
  else
11040
0
    return 3;
11041
0
}
11042
11043
static Elf_Internal_Rela *
11044
emit_relocs_for_power10_offset (struct bfd_link_info *info,
11045
        Elf_Internal_Rela *r, bfd_vma roff,
11046
        bfd_vma targ, bfd_vma off, int odd)
11047
0
{
11048
0
  if (off - odd + (1ULL << 33) < 1ULL << 34)
11049
0
    roff += odd;
11050
0
  else if (off - (8 - odd) + (0x20002ULL << 32) < 0x40004ULL << 32)
11051
0
    {
11052
0
      int d_offset = bfd_big_endian (info->output_bfd) ? 2 : 0;
11053
0
      r->r_offset = roff + d_offset;
11054
0
      r->r_addend = targ + 8 - odd - d_offset;
11055
0
      r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34);
11056
0
      ++r;
11057
0
      roff += 8 - odd;
11058
0
    }
11059
0
  else
11060
0
    {
11061
0
      int d_offset = bfd_big_endian (info->output_bfd) ? 2 : 0;
11062
0
      r->r_offset = roff + d_offset;
11063
0
      r->r_addend = targ + 8 + odd - d_offset;
11064
0
      r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34);
11065
0
      ++r;
11066
0
      roff += 4;
11067
0
      r->r_offset = roff + d_offset;
11068
0
      r->r_addend = targ + 4 + odd - d_offset;
11069
0
      r->r_info = ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34);
11070
0
      ++r;
11071
0
      roff += 4 + odd;
11072
0
    }
11073
0
  r->r_offset = roff;
11074
0
  r->r_addend = targ;
11075
0
  r->r_info = ELF64_R_INFO (0, R_PPC64_PCREL34);
11076
0
  return r;
11077
0
}
11078
11079
/* Emit .eh_frame opcode to advance pc by DELTA.  */
11080
11081
static bfd_byte *
11082
eh_advance (bfd *abfd, bfd_byte *eh, unsigned int delta)
11083
0
{
11084
0
  delta /= 4;
11085
0
  if (delta < 64)
11086
0
    *eh++ = DW_CFA_advance_loc + delta;
11087
0
  else if (delta < 256)
11088
0
    {
11089
0
      *eh++ = DW_CFA_advance_loc1;
11090
0
      *eh++ = delta;
11091
0
    }
11092
0
  else if (delta < 65536)
11093
0
    {
11094
0
      *eh++ = DW_CFA_advance_loc2;
11095
0
      bfd_put_16 (abfd, delta, eh);
11096
0
      eh += 2;
11097
0
    }
11098
0
  else
11099
0
    {
11100
0
      *eh++ = DW_CFA_advance_loc4;
11101
0
      bfd_put_32 (abfd, delta, eh);
11102
0
      eh += 4;
11103
0
    }
11104
0
  return eh;
11105
0
}
11106
11107
/* Size of required .eh_frame opcode to advance pc by DELTA.  */
11108
11109
static unsigned int
11110
eh_advance_size (unsigned int delta)
11111
0
{
11112
0
  if (delta < 64 * 4)
11113
    /* DW_CFA_advance_loc+[1..63].  */
11114
0
    return 1;
11115
0
  if (delta < 256 * 4)
11116
    /* DW_CFA_advance_loc1, byte.  */
11117
0
    return 2;
11118
0
  if (delta < 65536 * 4)
11119
    /* DW_CFA_advance_loc2, 2 bytes.  */
11120
0
    return 3;
11121
  /* DW_CFA_advance_loc4, 4 bytes.  */
11122
0
  return 5;
11123
0
}
11124
11125
/* With power7 weakly ordered memory model, it is possible for ld.so
11126
   to update a plt entry in one thread and have another thread see a
11127
   stale zero toc entry.  To avoid this we need some sort of acquire
11128
   barrier in the call stub.  One solution is to make the load of the
11129
   toc word seem to appear to depend on the load of the function entry
11130
   word.  Another solution is to test for r2 being zero, and branch to
11131
   the appropriate glink entry if so.
11132
11133
   .  fake dep barrier  compare
11134
   .  ld 12,xxx(2)    ld 12,xxx(2)
11135
   .  mtctr 12    mtctr 12
11136
   .  xor 11,12,12    ld 2,xxx+8(2)
11137
   .  add 2,2,11    cmpldi 2,0
11138
   .  ld 2,xxx+8(2)   bnectr+
11139
   .  bctr      b <glink_entry>
11140
11141
   The solution involving the compare turns out to be faster, so
11142
   that's what we use unless the branch won't reach.  */
11143
11144
0
#define ALWAYS_USE_FAKE_DEP 0
11145
0
#define ALWAYS_EMIT_R2SAVE 0
11146
11147
static inline unsigned int
11148
plt_stub_size (struct ppc_link_hash_table *htab,
11149
         struct ppc_stub_hash_entry *stub_entry,
11150
         bfd_vma off,
11151
         unsigned int odd)
11152
0
{
11153
0
  unsigned size;
11154
11155
0
  if (stub_entry->type.sub == ppc_stub_notoc)
11156
0
    {
11157
0
      size = 8 + size_power10_offset (off, odd);
11158
0
      if (stub_entry->type.r2save)
11159
0
  size += 4;
11160
0
    }
11161
0
  else if (stub_entry->type.sub == ppc_stub_p9notoc)
11162
0
    {
11163
0
      size = 8 + size_offset (off - 8);
11164
0
      if (stub_entry->type.r2save)
11165
0
  size += 4;
11166
0
    }
11167
0
  else
11168
0
    {
11169
0
      size = 12;
11170
0
      if (ALWAYS_EMIT_R2SAVE || stub_entry->type.r2save)
11171
0
  size += 4;
11172
0
      if (PPC_HA (off) != 0)
11173
0
  size += 4;
11174
0
      if (htab->opd_abi)
11175
0
  {
11176
0
    size += 4;
11177
0
    if (htab->params->plt_static_chain)
11178
0
      size += 4;
11179
0
    if (htab->params->plt_thread_safe
11180
0
        && htab->elf.dynamic_sections_created
11181
0
        && stub_entry->h != NULL
11182
0
        && stub_entry->h->elf.dynindx != -1)
11183
0
      size += 8;
11184
0
    if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain)
11185
0
        != PPC_HA (off))
11186
0
      size += 4;
11187
0
  }
11188
0
    }
11189
0
  if (stub_entry->h != NULL
11190
0
      && is_tls_get_addr (&stub_entry->h->elf, htab)
11191
0
      && htab->params->tls_get_addr_opt)
11192
0
    {
11193
0
      if (!htab->params->no_tls_get_addr_regsave)
11194
0
  {
11195
0
    size += 30 * 4;
11196
0
    if (stub_entry->type.r2save)
11197
0
      size += 4;
11198
0
  }
11199
0
      else
11200
0
  {
11201
0
    size += 7 * 4;
11202
0
    if (stub_entry->type.r2save)
11203
0
      size += 6 * 4;
11204
0
  }
11205
0
    }
11206
0
  return size;
11207
0
}
11208
11209
/* Depending on the sign of plt_stub_align:
11210
   If positive, return the padding to align to a 2**plt_stub_align
11211
   boundary.
11212
   If negative, if this stub would cross fewer 2**plt_stub_align
11213
   boundaries if we align, then return the padding needed to do so.  */
11214
11215
static inline unsigned int
11216
plt_stub_pad (int plt_stub_align,
11217
        bfd_vma stub_off,
11218
        unsigned int stub_size)
11219
0
{
11220
0
  unsigned int stub_align;
11221
11222
0
  if (plt_stub_align >= 0)
11223
0
    stub_align = 1u << plt_stub_align;
11224
0
  else
11225
0
    {
11226
0
      stub_align = 1u << -plt_stub_align;
11227
0
      if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
11228
0
    <= ((stub_size - 1) & -stub_align))
11229
0
  return 0;
11230
0
    }
11231
0
  return stub_align - 1 - ((stub_off - 1) & (stub_align - 1));
11232
0
}
11233
11234
/* Build a toc using .plt call stub.  */
11235
11236
static inline bfd_byte *
11237
build_plt_stub (struct ppc_link_hash_table *htab,
11238
    struct ppc_stub_hash_entry *stub_entry,
11239
    bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11240
0
{
11241
0
  bfd *obfd = htab->params->stub_bfd;
11242
0
  bool plt_load_toc = htab->opd_abi;
11243
0
  bool plt_static_chain = htab->params->plt_static_chain;
11244
0
  bool plt_thread_safe = (htab->params->plt_thread_safe
11245
0
        && htab->elf.dynamic_sections_created
11246
0
        && stub_entry->h != NULL
11247
0
        && stub_entry->h->elf.dynindx != -1);
11248
0
  bool use_fake_dep = plt_thread_safe;
11249
0
  bfd_vma cmp_branch_off = 0;
11250
11251
0
  if (!ALWAYS_USE_FAKE_DEP
11252
0
      && plt_load_toc
11253
0
      && plt_thread_safe
11254
0
      && !(stub_entry->h != NULL
11255
0
     && is_tls_get_addr (&stub_entry->h->elf, htab)
11256
0
     && htab->params->tls_get_addr_opt))
11257
0
    {
11258
0
      bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
11259
0
      bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
11260
0
        / PLT_ENTRY_SIZE (htab));
11261
0
      bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
11262
0
      bfd_vma to, from;
11263
11264
0
      if (pltindex > 32768)
11265
0
  glinkoff += (pltindex - 32768) * 4;
11266
0
      to = (glinkoff
11267
0
      + htab->glink->output_offset
11268
0
      + htab->glink->output_section->vma);
11269
0
      from = (p - stub_entry->group->stub_sec->contents
11270
0
        + 4 * (ALWAYS_EMIT_R2SAVE || stub_entry->type.r2save)
11271
0
        + 4 * (PPC_HA (offset) != 0)
11272
0
        + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
11273
0
         != PPC_HA (offset))
11274
0
        + 4 * (plt_static_chain != 0)
11275
0
        + 20
11276
0
        + stub_entry->group->stub_sec->output_offset
11277
0
        + stub_entry->group->stub_sec->output_section->vma);
11278
0
      cmp_branch_off = to - from;
11279
0
      use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
11280
0
    }
11281
11282
0
  if (PPC_HA (offset) != 0)
11283
0
    {
11284
0
      if (r != NULL)
11285
0
  {
11286
0
    if (ALWAYS_EMIT_R2SAVE || stub_entry->type.r2save)
11287
0
      r[0].r_offset += 4;
11288
0
    r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11289
0
    r[1].r_offset = r[0].r_offset + 4;
11290
0
    r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11291
0
    r[1].r_addend = r[0].r_addend;
11292
0
    if (plt_load_toc)
11293
0
      {
11294
0
        if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11295
0
    {
11296
0
      r[2].r_offset = r[1].r_offset + 4;
11297
0
      r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
11298
0
      r[2].r_addend = r[0].r_addend;
11299
0
    }
11300
0
        else
11301
0
    {
11302
0
      r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
11303
0
      r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11304
0
      r[2].r_addend = r[0].r_addend + 8;
11305
0
      if (plt_static_chain)
11306
0
        {
11307
0
          r[3].r_offset = r[2].r_offset + 4;
11308
0
          r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11309
0
          r[3].r_addend = r[0].r_addend + 16;
11310
0
        }
11311
0
    }
11312
0
      }
11313
0
  }
11314
0
      if (ALWAYS_EMIT_R2SAVE || stub_entry->type.r2save)
11315
0
  bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),  p += 4;
11316
0
      if (plt_load_toc)
11317
0
  {
11318
0
    bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
11319
0
    bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
11320
0
  }
11321
0
      else
11322
0
  {
11323
0
    bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
11324
0
    bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
11325
0
  }
11326
0
      if (plt_load_toc
11327
0
    && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11328
0
  {
11329
0
    bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
11330
0
    offset = 0;
11331
0
  }
11332
0
      bfd_put_32 (obfd, MTCTR_R12, p),        p += 4;
11333
0
      if (plt_load_toc)
11334
0
  {
11335
0
    if (use_fake_dep)
11336
0
      {
11337
0
        bfd_put_32 (obfd, XOR_R2_R12_R12, p),   p += 4;
11338
0
        bfd_put_32 (obfd, ADD_R11_R11_R2, p),   p += 4;
11339
0
      }
11340
0
    bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
11341
0
    if (plt_static_chain)
11342
0
      bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
11343
0
  }
11344
0
    }
11345
0
  else
11346
0
    {
11347
0
      if (r != NULL)
11348
0
  {
11349
0
    if (ALWAYS_EMIT_R2SAVE || stub_entry->type.r2save)
11350
0
      r[0].r_offset += 4;
11351
0
    r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11352
0
    if (plt_load_toc)
11353
0
      {
11354
0
        if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11355
0
    {
11356
0
      r[1].r_offset = r[0].r_offset + 4;
11357
0
      r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
11358
0
      r[1].r_addend = r[0].r_addend;
11359
0
    }
11360
0
        else
11361
0
    {
11362
0
      r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
11363
0
      r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11364
0
      r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
11365
0
      if (plt_static_chain)
11366
0
        {
11367
0
          r[2].r_offset = r[1].r_offset + 4;
11368
0
          r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11369
0
          r[2].r_addend = r[0].r_addend + 8;
11370
0
        }
11371
0
    }
11372
0
      }
11373
0
  }
11374
0
      if (ALWAYS_EMIT_R2SAVE || stub_entry->type.r2save)
11375
0
  bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),  p += 4;
11376
0
      bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
11377
0
      if (plt_load_toc
11378
0
    && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11379
0
  {
11380
0
    bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
11381
0
    offset = 0;
11382
0
  }
11383
0
      bfd_put_32 (obfd, MTCTR_R12, p),        p += 4;
11384
0
      if (plt_load_toc)
11385
0
  {
11386
0
    if (use_fake_dep)
11387
0
      {
11388
0
        bfd_put_32 (obfd, XOR_R11_R12_R12, p),    p += 4;
11389
0
        bfd_put_32 (obfd, ADD_R2_R2_R11, p),    p += 4;
11390
0
      }
11391
0
    if (plt_static_chain)
11392
0
      bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11393
0
    bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11394
0
  }
11395
0
    }
11396
0
  if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11397
0
    {
11398
0
      bfd_put_32 (obfd, CMPLDI_R2_0, p),      p += 4;
11399
0
      bfd_put_32 (obfd, BNECTR_P4, p),        p += 4;
11400
0
      bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11401
0
    }
11402
0
  else
11403
0
    bfd_put_32 (obfd, BCTR, p),         p += 4;
11404
0
  return p;
11405
0
}
11406
11407
/* Build a special .plt call stub for __tls_get_addr.  */
11408
11409
#define LD_R0_0R3 0xe8030000
11410
#define LD_R12_0R3  0xe9830000
11411
#define MR_R0_R3  0x7c601b78
11412
#define CMPDI_R0_0  0x2c200000
11413
#define ADD_R3_R12_R13  0x7c6c6a14
11414
#define BEQLR   0x4d820020
11415
#define MR_R3_R0  0x7c030378
11416
#define BCTRL   0x4e800421
11417
11418
static bfd_byte *
11419
build_tls_get_addr_head (struct ppc_link_hash_table *htab,
11420
       struct ppc_stub_hash_entry *stub_entry,
11421
       bfd_byte *p)
11422
0
{
11423
0
  bfd *obfd = htab->params->stub_bfd;
11424
11425
0
  bfd_put_32 (obfd, LD_R0_0R3 + 0, p),    p += 4;
11426
0
  bfd_put_32 (obfd, LD_R12_0R3 + 8, p),   p += 4;
11427
0
  bfd_put_32 (obfd, CMPDI_R0_0, p),   p += 4;
11428
0
  bfd_put_32 (obfd, MR_R0_R3, p),   p += 4;
11429
0
  bfd_put_32 (obfd, ADD_R3_R12_R13, p),   p += 4;
11430
0
  bfd_put_32 (obfd, BEQLR, p),      p += 4;
11431
0
  bfd_put_32 (obfd, MR_R3_R0, p),   p += 4;
11432
11433
0
  if (!htab->params->no_tls_get_addr_regsave)
11434
0
    p = tls_get_addr_prologue (obfd, p, htab);
11435
0
  else if (stub_entry->type.r2save)
11436
0
    {
11437
0
      bfd_put_32 (obfd, MFLR_R0, p);
11438
0
      p += 4;
11439
0
      bfd_put_32 (obfd, STD_R0_0R1 + STK_LINKER (htab), p);
11440
0
      p += 4;
11441
0
    }
11442
0
  return p;
11443
0
}
11444
11445
static bfd_byte *
11446
build_tls_get_addr_tail (struct ppc_link_hash_table *htab,
11447
       struct ppc_stub_hash_entry *stub_entry,
11448
       bfd_byte *p,
11449
       bfd_byte *loc)
11450
0
{
11451
0
  bfd *obfd = htab->params->stub_bfd;
11452
11453
0
  if (!htab->params->no_tls_get_addr_regsave)
11454
0
    {
11455
0
      bfd_put_32 (obfd, BCTRL, p - 4);
11456
11457
0
      if (stub_entry->type.r2save)
11458
0
  {
11459
0
    bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p);
11460
0
    p += 4;
11461
0
  }
11462
0
      p = tls_get_addr_epilogue (obfd, p, htab);
11463
0
    }
11464
0
  else if (stub_entry->type.r2save)
11465
0
    {
11466
0
      bfd_put_32 (obfd, BCTRL, p - 4);
11467
11468
0
      bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p);
11469
0
      p += 4;
11470
0
      bfd_put_32 (obfd, LD_R0_0R1 + STK_LINKER (htab), p);
11471
0
      p += 4;
11472
0
      bfd_put_32 (obfd, MTLR_R0, p);
11473
0
      p += 4;
11474
0
      bfd_put_32 (obfd, BLR, p);
11475
0
      p += 4;
11476
0
    }
11477
11478
0
  if (htab->glink_eh_frame != NULL
11479
0
      && htab->glink_eh_frame->size != 0)
11480
0
    {
11481
0
      bfd_byte *base, *eh;
11482
11483
0
      base = htab->glink_eh_frame->contents + stub_entry->group->eh_base + 17;
11484
0
      eh = base + stub_entry->group->eh_size;
11485
11486
0
      if (!htab->params->no_tls_get_addr_regsave)
11487
0
  {
11488
0
    unsigned int cfa_updt, delta, i;
11489
11490
    /* After the bctrl, lr has been modified so we need to emit
11491
       .eh_frame info saying the return address is on the stack.  In
11492
       fact we must put the EH info at or before the call rather
11493
       than after it, because the EH info for a call needs to be
11494
       specified by that point.
11495
       See libgcc/unwind-dw2.c execute_cfa_program.
11496
       Any stack pointer update must be described immediately after
11497
       the instruction making the change, and since the stdu occurs
11498
       after saving regs we put all the reg saves and the cfa
11499
       change there.  */
11500
0
    cfa_updt = stub_entry->stub_offset + 18 * 4;
11501
0
    delta = cfa_updt - stub_entry->group->lr_restore;
11502
0
    stub_entry->group->lr_restore
11503
0
      = stub_entry->stub_offset + (p - loc) - 4;
11504
0
    eh = eh_advance (htab->elf.dynobj, eh, delta);
11505
0
    *eh++ = DW_CFA_def_cfa_offset;
11506
0
    if (htab->opd_abi)
11507
0
      {
11508
0
        *eh++ = 128;
11509
0
        *eh++ = 1;
11510
0
      }
11511
0
    else
11512
0
      *eh++ = 96;
11513
0
    *eh++ = DW_CFA_offset_extended_sf;
11514
0
    *eh++ = 65;
11515
0
    *eh++ = (-16 / 8) & 0x7f;
11516
0
    for (i = 4; i < 12; i++)
11517
0
      {
11518
0
        *eh++ = DW_CFA_offset + i;
11519
0
        *eh++ = (htab->opd_abi ? 13 : 12) - i;
11520
0
      }
11521
0
    *eh++ = (DW_CFA_advance_loc
11522
0
       + (stub_entry->group->lr_restore - 8 - cfa_updt) / 4);
11523
0
    *eh++ = DW_CFA_def_cfa_offset;
11524
0
    *eh++ = 0;
11525
0
    for (i = 4; i < 12; i++)
11526
0
      *eh++ = DW_CFA_restore + i;
11527
0
    *eh++ = DW_CFA_advance_loc + 2;
11528
0
    *eh++ = DW_CFA_restore_extended;
11529
0
    *eh++ = 65;
11530
0
    stub_entry->group->eh_size = eh - base;
11531
0
  }
11532
0
      else if (stub_entry->type.r2save)
11533
0
  {
11534
0
    unsigned int lr_used, delta;
11535
11536
0
    lr_used = stub_entry->stub_offset + (p - 20 - loc);
11537
0
    delta = lr_used - stub_entry->group->lr_restore;
11538
0
    stub_entry->group->lr_restore = lr_used + 16;
11539
0
    eh = eh_advance (htab->elf.dynobj, eh, delta);
11540
0
    *eh++ = DW_CFA_offset_extended_sf;
11541
0
    *eh++ = 65;
11542
0
    *eh++ = -(STK_LINKER (htab) / 8) & 0x7f;
11543
0
    *eh++ = DW_CFA_advance_loc + 4;
11544
0
    *eh++ = DW_CFA_restore_extended;
11545
0
    *eh++ = 65;
11546
0
    stub_entry->group->eh_size = eh - base;
11547
0
  }
11548
0
    }
11549
0
  return p;
11550
0
}
11551
11552
static Elf_Internal_Rela *
11553
get_relocs (asection *sec, int count)
11554
0
{
11555
0
  Elf_Internal_Rela *relocs;
11556
0
  struct bfd_elf_section_data *elfsec_data;
11557
11558
0
  elfsec_data = elf_section_data (sec);
11559
0
  relocs = elfsec_data->relocs;
11560
0
  if (relocs == NULL)
11561
0
    {
11562
0
      bfd_size_type relsize;
11563
0
      relsize = sec->reloc_count * sizeof (*relocs);
11564
0
      relocs = bfd_alloc (sec->owner, relsize);
11565
0
      if (relocs == NULL)
11566
0
  return NULL;
11567
0
      elfsec_data->relocs = relocs;
11568
0
      elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11569
0
            sizeof (Elf_Internal_Shdr));
11570
0
      if (elfsec_data->rela.hdr == NULL)
11571
0
  return NULL;
11572
0
      elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11573
0
          * sizeof (Elf64_External_Rela));
11574
0
      elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11575
0
      sec->reloc_count = 0;
11576
0
    }
11577
0
  relocs += sec->reloc_count;
11578
0
  sec->reloc_count += count;
11579
0
  return relocs;
11580
0
}
11581
11582
static bool
11583
swap_reloc_out (bfd *obfd, Elf_Internal_Rela *rel, bfd_byte *loc, asection *s)
11584
0
{
11585
0
  if ((size_t) (loc - s->contents) >= s->size)
11586
0
    return false;
11587
0
  bfd_elf64_swap_reloca_out (obfd, rel, loc);
11588
0
  return true;
11589
0
}
11590
11591
static bool
11592
count_and_swap_reloc_out (bfd *obfd, Elf_Internal_Rela *rel, asection *s)
11593
0
{
11594
0
  bfd_byte *loc = s->contents;
11595
0
  loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
11596
0
  return swap_reloc_out (obfd, rel, loc, s);
11597
0
}
11598
11599
11600
/* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
11601
   forms, to the equivalent relocs against the global symbol given by
11602
   STUB_ENTRY->H.  */
11603
11604
static bool
11605
use_global_in_relocs (struct ppc_link_hash_table *htab,
11606
          struct ppc_stub_hash_entry *stub_entry,
11607
          Elf_Internal_Rela *r, unsigned int num_rel)
11608
0
{
11609
0
  struct elf_link_hash_entry **hashes;
11610
0
  unsigned long symndx;
11611
0
  struct ppc_link_hash_entry *h;
11612
0
  bfd_vma symval;
11613
11614
  /* Relocs are always against symbols in their own object file.  Fake
11615
     up global sym hashes for the stub bfd (which has no symbols).  */
11616
0
  hashes = elf_sym_hashes (htab->params->stub_bfd);
11617
0
  if (hashes == NULL)
11618
0
    {
11619
0
      bfd_size_type hsize;
11620
11621
      /* When called the first time, stub_globals will contain the
11622
   total number of symbols seen during stub sizing.  After
11623
   allocating, stub_globals is used as an index to fill the
11624
   hashes array.  */
11625
0
      hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11626
0
      hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11627
0
      if (hashes == NULL)
11628
0
  return false;
11629
0
      elf_sym_hashes (htab->params->stub_bfd) = hashes;
11630
0
      htab->stub_globals = 1;
11631
0
    }
11632
0
  symndx = htab->stub_globals++;
11633
0
  h = stub_entry->h;
11634
0
  hashes[symndx] = &h->elf;
11635
0
  if (h->oh != NULL && h->oh->is_func)
11636
0
    h = ppc_follow_link (h->oh);
11637
0
  BFD_ASSERT (h->elf.root.type == bfd_link_hash_defined
11638
0
        || h->elf.root.type == bfd_link_hash_defweak);
11639
0
  symval = defined_sym_val (&h->elf);
11640
0
  while (num_rel-- != 0)
11641
0
    {
11642
0
      r->r_info = ELF64_R_INFO (symndx, ELF64_R_TYPE (r->r_info));
11643
0
      if (h->elf.root.u.def.section != stub_entry->target_section)
11644
0
  {
11645
    /* H is an opd symbol.  The addend must be zero, and the
11646
       branch reloc is the only one we can convert.  */
11647
0
    r->r_addend = 0;
11648
0
    break;
11649
0
  }
11650
0
      else
11651
0
  r->r_addend -= symval;
11652
0
      --r;
11653
0
    }
11654
0
  return true;
11655
0
}
11656
11657
static bfd_vma
11658
get_r2off (struct bfd_link_info *info,
11659
     struct ppc_stub_hash_entry *stub_entry)
11660
0
{
11661
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
11662
0
  bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11663
11664
0
  if (r2off == 0)
11665
0
    {
11666
      /* Support linking -R objects.  Get the toc pointer from the
11667
   opd entry.  */
11668
0
      char buf[8];
11669
0
      if (!htab->opd_abi)
11670
0
  return r2off;
11671
0
      asection *opd = stub_entry->h->elf.root.u.def.section;
11672
0
      bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11673
11674
0
      if (strcmp (opd->name, ".opd") != 0
11675
0
    || opd->reloc_count != 0)
11676
0
  {
11677
0
    info->callbacks->einfo
11678
0
      (_("%P: cannot find opd entry toc for `%pT'\n"),
11679
0
       stub_entry->h->elf.root.root.string);
11680
0
    bfd_set_error (bfd_error_bad_value);
11681
0
    return (bfd_vma) -1;
11682
0
  }
11683
0
      if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11684
0
  return (bfd_vma) -1;
11685
0
      r2off = bfd_get_64 (opd->owner, buf);
11686
0
      r2off -= elf_gp (info->output_bfd);
11687
0
    }
11688
0
  r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11689
0
  return r2off;
11690
0
}
11691
11692
/* Debug dump.  */
11693
11694
static void
11695
dump_stub (const char *header,
11696
     struct ppc_stub_hash_entry *stub_entry,
11697
     size_t end_offset)
11698
0
{
11699
0
  const char *t1, *t2, *t3;
11700
0
  switch (stub_entry->type.main)
11701
0
    {
11702
0
    case ppc_stub_none:   t1 = "none";    break;
11703
0
    case ppc_stub_long_branch:  t1 = "long_branch"; break;
11704
0
    case ppc_stub_plt_branch: t1 = "plt_branch";  break;
11705
0
    case ppc_stub_plt_call: t1 = "plt_call";  break;
11706
0
    case ppc_stub_global_entry: t1 = "global_entry";  break;
11707
0
    case ppc_stub_save_res: t1 = "save_res";  break;
11708
0
    default:      t1 = "???";   break;
11709
0
    }
11710
0
  switch (stub_entry->type.sub)
11711
0
    {
11712
0
    case ppc_stub_toc:    t2 = "toc";   break;
11713
0
    case ppc_stub_notoc:  t2 = "notoc";   break;
11714
0
    case ppc_stub_p9notoc:  t2 = "p9notoc";   break;
11715
0
    default:      t2 = "???";   break;
11716
0
    }
11717
0
  t3 = stub_entry->type.r2save ? "r2save" : "";
11718
0
  fprintf (stderr, "%s id = %u type = %s:%s:%s\n",
11719
0
     header, stub_entry->id, t1, t2, t3);
11720
0
  fprintf (stderr, "name = %s\n", stub_entry->root.string);
11721
0
  fprintf (stderr, "offset = 0x%" PRIx64 ":", stub_entry->stub_offset);
11722
0
  for (size_t i = stub_entry->stub_offset; i < end_offset; i += 4)
11723
0
    {
11724
0
      asection *stub_sec = stub_entry->group->stub_sec;
11725
0
      uint32_t *p = (uint32_t *) (stub_sec->contents + i);
11726
0
      fprintf (stderr, " %08x", (uint32_t) bfd_get_32 (stub_sec->owner, p));
11727
0
    }
11728
0
  fprintf (stderr, "\n");
11729
0
}
11730
11731
static bool
11732
ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11733
0
{
11734
0
  struct ppc_stub_hash_entry *stub_entry;
11735
0
  struct ppc_branch_hash_entry *br_entry;
11736
0
  struct bfd_link_info *info;
11737
0
  struct ppc_link_hash_table *htab;
11738
0
  bfd *obfd;
11739
0
  bfd_byte *loc;
11740
0
  bfd_byte *p, *relp;
11741
0
  bfd_vma targ, off;
11742
0
  Elf_Internal_Rela *r;
11743
0
  asection *plt;
11744
0
  int num_rel;
11745
0
  int odd;
11746
0
  bool is_tga;
11747
11748
  /* Massage our args to the form they really have.  */
11749
0
  stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11750
0
  info = in_arg;
11751
11752
0
  htab = ppc_hash_table (info);
11753
0
  if (htab == NULL)
11754
0
    return false;
11755
11756
0
  struct _ppc64_elf_section_data *esd
11757
0
    = ppc64_elf_section_data (stub_entry->group->stub_sec);
11758
0
  ++htab->stub_id;
11759
0
  if (stub_entry->id != htab->stub_id
11760
0
      || (stub_entry->type.main != ppc_stub_save_res
11761
0
    && stub_entry->stub_offset < stub_entry->group->stub_sec->size))
11762
0
    {
11763
0
      BFD_ASSERT (0);
11764
0
      if (stub_entry->id != htab->stub_id)
11765
0
  fprintf (stderr, "Expected id %u, got %u\n",
11766
0
     htab->stub_id, stub_entry->id);
11767
0
      if (stub_entry->stub_offset < stub_entry->group->stub_sec->size)
11768
0
  fprintf (stderr, "Expected offset >= %" PRIx64 ", got %"
11769
0
     PRIx64 "\n", stub_entry->group->stub_sec->size,
11770
0
     stub_entry->stub_offset);
11771
0
      if (esd->sec_type == sec_stub)
11772
0
  dump_stub ("Previous:", esd->u.last_ent, stub_entry->stub_offset);
11773
0
      dump_stub ("Current:", stub_entry, 0);
11774
0
    }
11775
0
  if (esd->sec_type == sec_normal)
11776
0
    esd->sec_type = sec_stub;
11777
0
  if (esd->sec_type == sec_stub)
11778
0
    esd->u.last_ent = stub_entry;
11779
0
  loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11780
11781
0
  htab->stub_count[stub_entry->type.main - 1] += 1;
11782
0
  if (stub_entry->type.main == ppc_stub_long_branch
11783
0
      && stub_entry->type.sub == ppc_stub_toc)
11784
0
    {
11785
      /* Branches are relative.  This is where we are going to.  */
11786
0
      targ = (stub_entry->target_value
11787
0
        + stub_entry->target_section->output_offset
11788
0
        + stub_entry->target_section->output_section->vma);
11789
0
      targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11790
11791
      /* And this is where we are coming from.  */
11792
0
      off = (stub_entry->stub_offset
11793
0
       + stub_entry->group->stub_sec->output_offset
11794
0
       + stub_entry->group->stub_sec->output_section->vma);
11795
0
      off = targ - off;
11796
11797
0
      p = loc;
11798
0
      obfd = htab->params->stub_bfd;
11799
0
      if (stub_entry->type.r2save)
11800
0
  {
11801
0
    bfd_vma r2off = get_r2off (info, stub_entry);
11802
11803
0
    if (r2off == (bfd_vma) -1)
11804
0
      {
11805
0
        htab->stub_error = true;
11806
0
        return false;
11807
0
      }
11808
0
    bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p);
11809
0
    p += 4;
11810
0
    if (PPC_HA (r2off) != 0)
11811
0
      {
11812
0
        bfd_put_32 (obfd, ADDIS_R2_R2 | PPC_HA (r2off), p);
11813
0
        p += 4;
11814
0
      }
11815
0
    if (PPC_LO (r2off) != 0)
11816
0
      {
11817
0
        bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (r2off), p);
11818
0
        p += 4;
11819
0
      }
11820
0
    off -= p - loc;
11821
0
  }
11822
0
      bfd_put_32 (obfd, B_DOT | (off & 0x3fffffc), p);
11823
0
      p += 4;
11824
11825
0
      if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11826
0
  {
11827
0
    _bfd_error_handler
11828
0
      (_("long branch stub `%s' offset overflow"),
11829
0
       stub_entry->root.string);
11830
0
    htab->stub_error = true;
11831
0
    return false;
11832
0
  }
11833
11834
0
      if (info->emitrelocations)
11835
0
  {
11836
0
    r = get_relocs (stub_entry->group->stub_sec, 1);
11837
0
    if (r == NULL)
11838
0
      return false;
11839
0
    r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11840
0
    r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11841
0
    r->r_addend = targ;
11842
0
    if (stub_entry->h != NULL
11843
0
        && !use_global_in_relocs (htab, stub_entry, r, 1))
11844
0
      return false;
11845
0
  }
11846
0
    }
11847
0
  else if (stub_entry->type.main == ppc_stub_plt_branch
11848
0
     && stub_entry->type.sub == ppc_stub_toc)
11849
0
    {
11850
0
      br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11851
0
           stub_entry->root.string + 9,
11852
0
           false, false);
11853
0
      if (br_entry == NULL)
11854
0
  {
11855
0
    _bfd_error_handler (_("can't find branch stub `%s'"),
11856
0
            stub_entry->root.string);
11857
0
    htab->stub_error = true;
11858
0
    return false;
11859
0
  }
11860
11861
0
      targ = (stub_entry->target_value
11862
0
        + stub_entry->target_section->output_offset
11863
0
        + stub_entry->target_section->output_section->vma);
11864
0
      if (!stub_entry->type.r2save)
11865
0
  targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11866
11867
0
      bfd_put_64 (htab->brlt->owner, targ,
11868
0
      htab->brlt->contents + br_entry->offset);
11869
11870
0
      if (br_entry->iter == htab->stub_iteration)
11871
0
  {
11872
0
    br_entry->iter = 0;
11873
11874
0
    if (htab->relbrlt != NULL && !info->enable_dt_relr)
11875
0
      {
11876
        /* Create a reloc for the branch lookup table entry.  */
11877
0
        Elf_Internal_Rela rela;
11878
11879
0
        rela.r_offset = (br_entry->offset
11880
0
             + htab->brlt->output_offset
11881
0
             + htab->brlt->output_section->vma);
11882
0
        rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11883
0
        rela.r_addend = targ;
11884
11885
0
        BFD_ASSERT (count_and_swap_reloc_out (htab->relbrlt->owner, &rela,
11886
0
                htab->relbrlt));
11887
0
      }
11888
0
    else if (info->emitrelocations)
11889
0
      {
11890
0
        r = get_relocs (htab->brlt, 1);
11891
0
        if (r == NULL)
11892
0
    return false;
11893
        /* brlt, being SEC_LINKER_CREATED does not go through the
11894
     normal reloc processing.  Symbols and offsets are not
11895
     translated from input file to output file form, so
11896
     set up the offset per the output file.  */
11897
0
        r->r_offset = (br_entry->offset
11898
0
           + htab->brlt->output_offset
11899
0
           + htab->brlt->output_section->vma);
11900
0
        r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11901
0
        r->r_addend = targ;
11902
0
      }
11903
0
  }
11904
11905
0
      targ = (br_entry->offset
11906
0
        + htab->brlt->output_offset
11907
0
        + htab->brlt->output_section->vma);
11908
11909
0
      off = (elf_gp (info->output_bfd)
11910
0
       + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11911
0
      off = targ - off;
11912
11913
0
      if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11914
0
  {
11915
0
    info->callbacks->einfo
11916
0
      (_("%P: linkage table error against `%pT'\n"),
11917
0
       stub_entry->root.string);
11918
0
    bfd_set_error (bfd_error_bad_value);
11919
0
    htab->stub_error = true;
11920
0
    return false;
11921
0
  }
11922
11923
0
      if (info->emitrelocations)
11924
0
  {
11925
0
    r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11926
0
    if (r == NULL)
11927
0
      return false;
11928
0
    r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11929
0
    if (bfd_big_endian (info->output_bfd))
11930
0
      r[0].r_offset += 2;
11931
0
    if (stub_entry->type.r2save)
11932
0
      r[0].r_offset += 4;
11933
0
    r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11934
0
    r[0].r_addend = targ;
11935
0
    if (PPC_HA (off) != 0)
11936
0
      {
11937
0
        r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11938
0
        r[1].r_offset = r[0].r_offset + 4;
11939
0
        r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11940
0
        r[1].r_addend = r[0].r_addend;
11941
0
      }
11942
0
  }
11943
11944
0
      p = loc;
11945
0
      obfd = htab->params->stub_bfd;
11946
0
      if (!stub_entry->type.r2save)
11947
0
  {
11948
0
    if (PPC_HA (off) != 0)
11949
0
      {
11950
0
        bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (off), p);
11951
0
        p += 4;
11952
0
        bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (off), p);
11953
0
      }
11954
0
    else
11955
0
      bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (off), p);
11956
0
  }
11957
0
      else
11958
0
  {
11959
0
    bfd_vma r2off = get_r2off (info, stub_entry);
11960
11961
0
    if (r2off == (bfd_vma) -1)
11962
0
      {
11963
0
        htab->stub_error = true;
11964
0
        return false;
11965
0
      }
11966
11967
0
    bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p);
11968
0
    p += 4;
11969
0
    if (PPC_HA (off) != 0)
11970
0
      {
11971
0
        bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (off), p);
11972
0
        p += 4;
11973
0
        bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (off), p);
11974
0
      }
11975
0
    else
11976
0
      bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (off), p);
11977
11978
0
    if (PPC_HA (r2off) != 0)
11979
0
      {
11980
0
        p += 4;
11981
0
        bfd_put_32 (obfd, ADDIS_R2_R2 | PPC_HA (r2off), p);
11982
0
      }
11983
0
    if (PPC_LO (r2off) != 0)
11984
0
      {
11985
0
        p += 4;
11986
0
        bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (r2off), p);
11987
0
      }
11988
0
  }
11989
0
      p += 4;
11990
0
      bfd_put_32 (obfd, MTCTR_R12, p);
11991
0
      p += 4;
11992
0
      bfd_put_32 (obfd, BCTR, p);
11993
0
      p += 4;
11994
0
    }
11995
0
  else if (stub_entry->type.sub >= ppc_stub_notoc)
11996
0
    {
11997
0
      bool is_plt = stub_entry->type.main == ppc_stub_plt_call;
11998
0
      p = loc;
11999
0
      off = (stub_entry->stub_offset
12000
0
       + stub_entry->group->stub_sec->output_offset
12001
0
       + stub_entry->group->stub_sec->output_section->vma);
12002
0
      obfd = htab->params->stub_bfd;
12003
0
      is_tga = (is_plt
12004
0
    && stub_entry->h != NULL
12005
0
    && is_tls_get_addr (&stub_entry->h->elf, htab)
12006
0
    && htab->params->tls_get_addr_opt);
12007
0
      if (is_tga)
12008
0
  {
12009
0
    p = build_tls_get_addr_head (htab, stub_entry, p);
12010
0
    off += p - loc;
12011
0
  }
12012
0
      if (stub_entry->type.r2save)
12013
0
  {
12014
0
    off += 4;
12015
0
    bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p);
12016
0
    p += 4;
12017
0
  }
12018
0
      if (is_plt)
12019
0
  {
12020
0
    targ = stub_entry->plt_ent->plt.offset & ~1;
12021
0
    if (targ >= (bfd_vma) -2)
12022
0
      abort ();
12023
12024
0
    plt = htab->elf.splt;
12025
0
    if (use_local_plt (info, elf_hash_entry (stub_entry->h)))
12026
0
      {
12027
0
        if (stub_entry->symtype == STT_GNU_IFUNC)
12028
0
    plt = htab->elf.iplt;
12029
0
        else
12030
0
    plt = htab->pltlocal;
12031
0
      }
12032
0
    targ += plt->output_offset + plt->output_section->vma;
12033
0
  }
12034
0
      else
12035
0
  targ = (stub_entry->target_value
12036
0
    + stub_entry->target_section->output_offset
12037
0
    + stub_entry->target_section->output_section->vma);
12038
0
      odd = off & 4;
12039
0
      off = targ - off;
12040
12041
0
      relp = p;
12042
0
      num_rel = 0;
12043
0
      if (stub_entry->type.sub == ppc_stub_notoc)
12044
0
  p = build_power10_offset (obfd, p, off, odd, is_plt);
12045
0
      else
12046
0
  {
12047
0
    if (htab->glink_eh_frame != NULL
12048
0
        && htab->glink_eh_frame->size != 0)
12049
0
      {
12050
0
        bfd_byte *base, *eh;
12051
0
        unsigned int lr_used, delta;
12052
12053
0
        base = (htab->glink_eh_frame->contents
12054
0
          + stub_entry->group->eh_base + 17);
12055
0
        eh = base + stub_entry->group->eh_size;
12056
0
        lr_used = stub_entry->stub_offset + (p - loc) + 8;
12057
0
        delta = lr_used - stub_entry->group->lr_restore;
12058
0
        stub_entry->group->lr_restore = lr_used + 8;
12059
0
        eh = eh_advance (htab->elf.dynobj, eh, delta);
12060
0
        *eh++ = DW_CFA_register;
12061
0
        *eh++ = 65;
12062
0
        *eh++ = 12;
12063
0
        *eh++ = DW_CFA_advance_loc + 2;
12064
0
        *eh++ = DW_CFA_restore_extended;
12065
0
        *eh++ = 65;
12066
0
        stub_entry->group->eh_size = eh - base;
12067
0
      }
12068
12069
    /* The notoc stubs calculate their target (either a PLT entry or
12070
       the global entry point of a function) relative to the PC
12071
       returned by the "bcl" two instructions past the start of the
12072
       sequence emitted by build_offset.  The offset is therefore 8
12073
       less than calculated from the start of the sequence.  */
12074
0
    off -= 8;
12075
0
    p = build_offset (obfd, p, off, is_plt);
12076
0
  }
12077
12078
0
      if (stub_entry->type.main == ppc_stub_long_branch)
12079
0
  {
12080
0
    bfd_vma from;
12081
0
    num_rel = 1;
12082
0
    from = (stub_entry->stub_offset
12083
0
      + stub_entry->group->stub_sec->output_offset
12084
0
      + stub_entry->group->stub_sec->output_section->vma
12085
0
      + (p - loc));
12086
0
    bfd_put_32 (obfd, B_DOT | ((targ - from) & 0x3fffffc), p);
12087
0
  }
12088
0
      else
12089
0
  {
12090
0
    bfd_put_32 (obfd, MTCTR_R12, p);
12091
0
    p += 4;
12092
0
    bfd_put_32 (obfd, BCTR, p);
12093
0
  }
12094
0
      p += 4;
12095
12096
0
      if (is_tga)
12097
0
  p = build_tls_get_addr_tail (htab, stub_entry, p, loc);
12098
12099
0
      if (info->emitrelocations)
12100
0
  {
12101
0
    bfd_vma roff = relp - stub_entry->group->stub_sec->contents;
12102
0
    if (stub_entry->type.sub == ppc_stub_notoc)
12103
0
      num_rel += num_relocs_for_power10_offset (off, odd);
12104
0
    else
12105
0
      {
12106
0
        num_rel += num_relocs_for_offset (off);
12107
0
        roff += 16;
12108
0
      }
12109
0
    r = get_relocs (stub_entry->group->stub_sec, num_rel);
12110
0
    if (r == NULL)
12111
0
      return false;
12112
0
    if (stub_entry->type.sub == ppc_stub_notoc)
12113
0
      r = emit_relocs_for_power10_offset (info, r, roff, targ, off, odd);
12114
0
    else
12115
0
      r = emit_relocs_for_offset (info, r, roff, targ, off);
12116
0
    if (stub_entry->type.main == ppc_stub_long_branch)
12117
0
      {
12118
0
        ++r;
12119
0
        roff = p - 4 - stub_entry->group->stub_sec->contents;
12120
0
        r->r_offset = roff;
12121
0
        r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
12122
0
        r->r_addend = targ;
12123
0
        if (stub_entry->h != NULL
12124
0
      && !use_global_in_relocs (htab, stub_entry, r, num_rel))
12125
0
    return false;
12126
0
      }
12127
0
  }
12128
0
    }
12129
0
  else if (stub_entry->type.main == ppc_stub_plt_call)
12130
0
    {
12131
0
      if (stub_entry->h != NULL
12132
0
    && stub_entry->h->is_func_descriptor
12133
0
    && stub_entry->h->oh != NULL)
12134
0
  {
12135
0
    struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
12136
12137
    /* If the old-ABI "dot-symbol" is undefined make it weak so
12138
       we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
12139
0
    if (fh->elf.root.type == bfd_link_hash_undefined
12140
0
        && (stub_entry->h->elf.root.type == bfd_link_hash_defined
12141
0
      || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
12142
0
      fh->elf.root.type = bfd_link_hash_undefweak;
12143
0
  }
12144
12145
      /* Now build the stub.  */
12146
0
      targ = stub_entry->plt_ent->plt.offset & ~1;
12147
0
      if (targ >= (bfd_vma) -2)
12148
0
  abort ();
12149
12150
0
      plt = htab->elf.splt;
12151
0
      if (use_local_plt (info, elf_hash_entry (stub_entry->h)))
12152
0
  {
12153
0
    if (stub_entry->symtype == STT_GNU_IFUNC)
12154
0
      plt = htab->elf.iplt;
12155
0
    else
12156
0
      plt = htab->pltlocal;
12157
0
  }
12158
0
      targ += plt->output_offset + plt->output_section->vma;
12159
12160
0
      off = (elf_gp (info->output_bfd)
12161
0
       + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12162
0
      off = targ - off;
12163
12164
0
      if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
12165
0
  {
12166
0
    info->callbacks->einfo
12167
      /* xgettext:c-format */
12168
0
      (_("%P: linkage table error against `%pT'\n"),
12169
0
       stub_entry->h != NULL
12170
0
       ? stub_entry->h->elf.root.root.string
12171
0
       : "<local sym>");
12172
0
    bfd_set_error (bfd_error_bad_value);
12173
0
    htab->stub_error = true;
12174
0
    return false;
12175
0
  }
12176
12177
0
      r = NULL;
12178
0
      if (info->emitrelocations)
12179
0
  {
12180
0
    r = get_relocs (stub_entry->group->stub_sec,
12181
0
        ((PPC_HA (off) != 0)
12182
0
         + (htab->opd_abi
12183
0
            ? 2 + (htab->params->plt_static_chain
12184
0
             && PPC_HA (off + 16) == PPC_HA (off))
12185
0
            : 1)));
12186
0
    if (r == NULL)
12187
0
      return false;
12188
0
    r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
12189
0
    if (bfd_big_endian (info->output_bfd))
12190
0
      r[0].r_offset += 2;
12191
0
    r[0].r_addend = targ;
12192
0
  }
12193
0
      p = loc;
12194
0
      obfd = htab->params->stub_bfd;
12195
0
      is_tga = (stub_entry->h != NULL
12196
0
    && is_tls_get_addr (&stub_entry->h->elf, htab)
12197
0
    && htab->params->tls_get_addr_opt);
12198
0
      if (is_tga)
12199
0
  {
12200
0
    p = build_tls_get_addr_head (htab, stub_entry, p);
12201
0
    if (r != NULL)
12202
0
      r[0].r_offset += p - loc;
12203
0
  }
12204
0
      p = build_plt_stub (htab, stub_entry, p, off, r);
12205
0
      if (is_tga)
12206
0
  p = build_tls_get_addr_tail (htab, stub_entry, p, loc);
12207
0
    }
12208
0
  else if (stub_entry->type.main == ppc_stub_save_res)
12209
0
    return true;
12210
0
  else
12211
0
    {
12212
0
      BFD_FAIL ();
12213
0
      return false;
12214
0
    }
12215
12216
0
  stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
12217
12218
0
  if (htab->params->emit_stub_syms)
12219
0
    {
12220
0
      struct elf_link_hash_entry *h;
12221
0
      size_t len1, len2;
12222
0
      char *name;
12223
0
      const char *const stub_str[] = { "long_branch",
12224
0
               "plt_branch",
12225
0
               "plt_call" };
12226
12227
0
      len1 = strlen (stub_str[stub_entry->type.main - 1]);
12228
0
      len2 = strlen (stub_entry->root.string);
12229
0
      name = bfd_malloc (len1 + len2 + 2);
12230
0
      if (name == NULL)
12231
0
  return false;
12232
0
      memcpy (name, stub_entry->root.string, 9);
12233
0
      memcpy (name + 9, stub_str[stub_entry->type.main - 1], len1);
12234
0
      memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
12235
0
      h = elf_link_hash_lookup (&htab->elf, name, true, false, false);
12236
0
      if (h == NULL)
12237
0
  return false;
12238
0
      if (h->root.type == bfd_link_hash_new)
12239
0
  {
12240
0
    h->root.type = bfd_link_hash_defined;
12241
0
    h->root.u.def.section = stub_entry->group->stub_sec;
12242
0
    h->root.u.def.value = stub_entry->stub_offset;
12243
0
    h->ref_regular = 1;
12244
0
    h->def_regular = 1;
12245
0
    h->ref_regular_nonweak = 1;
12246
0
    h->forced_local = 1;
12247
0
    h->non_elf = 0;
12248
0
    h->root.linker_def = 1;
12249
0
  }
12250
0
    }
12251
12252
0
  return true;
12253
0
}
12254
12255
/* As above, but don't actually build the stub.  Just bump offset so
12256
   we know stub section sizes, and select plt_branch stubs where
12257
   long_branch stubs won't do.  */
12258
12259
static bool
12260
ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
12261
0
{
12262
0
  struct ppc_stub_hash_entry *stub_entry;
12263
0
  struct bfd_link_info *info;
12264
0
  struct ppc_link_hash_table *htab;
12265
0
  asection *plt;
12266
0
  bfd_vma targ, off, r2off;
12267
0
  unsigned int size, pad, extra, lr_used, delta, odd;
12268
0
  bfd_vma stub_offset;
12269
12270
  /* Massage our args to the form they really have.  */
12271
0
  stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
12272
0
  info = in_arg;
12273
12274
0
  htab = ppc_hash_table (info);
12275
0
  if (htab == NULL)
12276
0
    return false;
12277
12278
  /* Fail if the target section could not be assigned to an output
12279
     section.  The user should fix his linker script.  */
12280
0
  if (stub_entry->target_section != NULL
12281
0
      && stub_entry->target_section->output_section == NULL
12282
0
      && info->non_contiguous_regions)
12283
0
    info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output section. "
12284
0
            "Retry without --enable-non-contiguous-regions.\n"),
12285
0
          stub_entry->target_section);
12286
12287
  /* Same for the group.  */
12288
0
  if (stub_entry->group->stub_sec != NULL
12289
0
      && stub_entry->group->stub_sec->output_section == NULL
12290
0
      && info->non_contiguous_regions)
12291
0
    info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output section. "
12292
0
            "Retry without --enable-non-contiguous-regions.\n"),
12293
0
          stub_entry->group->stub_sec);
12294
12295
  /* Make a note of the offset within the stubs for this entry.  */
12296
0
  stub_offset = stub_entry->group->stub_sec->size;
12297
0
  if (htab->stub_iteration > STUB_SHRINK_ITER
12298
0
      && stub_entry->stub_offset > stub_offset)
12299
0
    stub_offset = stub_entry->stub_offset;
12300
0
  stub_entry->id = ++htab->stub_id;
12301
12302
0
  if (stub_entry->h != NULL
12303
0
      && stub_entry->h->save_res
12304
0
      && stub_entry->h->elf.root.type == bfd_link_hash_defined
12305
0
      && stub_entry->h->elf.root.u.def.section == htab->sfpr)
12306
0
    {
12307
      /* Don't make stubs to out-of-line register save/restore
12308
   functions.  Instead, emit copies of the functions.  */
12309
0
      stub_entry->group->needs_save_res = 1;
12310
0
      stub_entry->type.main = ppc_stub_save_res;
12311
0
      stub_entry->type.sub = ppc_stub_toc;
12312
0
      stub_entry->type.r2save = 0;
12313
0
      return true;
12314
0
    }
12315
12316
0
  if (stub_entry->type.main == ppc_stub_plt_branch)
12317
0
    {
12318
      /* Reset the stub type from the plt branch variant in case we now
12319
   can reach with a shorter stub.  */
12320
0
      stub_entry->type.main = ppc_stub_long_branch;
12321
0
    }
12322
12323
0
  if (stub_entry->type.main == ppc_stub_long_branch
12324
0
      && stub_entry->type.sub == ppc_stub_toc)
12325
0
    {
12326
0
      targ = (stub_entry->target_value
12327
0
        + stub_entry->target_section->output_offset
12328
0
        + stub_entry->target_section->output_section->vma);
12329
0
      targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
12330
0
      off = (stub_offset
12331
0
       + stub_entry->group->stub_sec->output_offset
12332
0
       + stub_entry->group->stub_sec->output_section->vma);
12333
12334
0
      size = 4;
12335
0
      r2off = 0;
12336
0
      if (stub_entry->type.r2save)
12337
0
  {
12338
0
    r2off = get_r2off (info, stub_entry);
12339
0
    if (r2off == (bfd_vma) -1)
12340
0
      {
12341
0
        htab->stub_error = true;
12342
0
        return false;
12343
0
      }
12344
0
    size = 8;
12345
0
    if (PPC_HA (r2off) != 0)
12346
0
      size += 4;
12347
0
    if (PPC_LO (r2off) != 0)
12348
0
      size += 4;
12349
0
    off += size - 4;
12350
0
  }
12351
0
      off = targ - off;
12352
12353
      /* If the branch offset is too big, use a ppc_stub_plt_branch.
12354
   Do the same for -R objects without function descriptors.  */
12355
0
      if ((stub_entry->type.r2save
12356
0
     && r2off == 0
12357
0
     && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
12358
0
    || off + (1 << 25) >= (bfd_vma) (1 << 26))
12359
0
  {
12360
0
    struct ppc_branch_hash_entry *br_entry;
12361
12362
0
    br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
12363
0
               stub_entry->root.string + 9,
12364
0
               true, false);
12365
0
    if (br_entry == NULL)
12366
0
      {
12367
0
        _bfd_error_handler (_("can't build branch stub `%s'"),
12368
0
          stub_entry->root.string);
12369
0
        htab->stub_error = true;
12370
0
        return false;
12371
0
      }
12372
12373
0
    if (br_entry->iter != htab->stub_iteration)
12374
0
      {
12375
0
        br_entry->iter = htab->stub_iteration;
12376
0
        br_entry->offset = htab->brlt->size;
12377
0
        htab->brlt->size += 8;
12378
12379
0
        if (htab->relbrlt != NULL && !info->enable_dt_relr)
12380
0
    htab->relbrlt->size += sizeof (Elf64_External_Rela);
12381
0
        else if (info->emitrelocations)
12382
0
    {
12383
0
      htab->brlt->reloc_count += 1;
12384
0
      htab->brlt->flags |= SEC_RELOC;
12385
0
    }
12386
0
      }
12387
12388
0
    targ = (br_entry->offset
12389
0
      + htab->brlt->output_offset
12390
0
      + htab->brlt->output_section->vma);
12391
0
    off = (elf_gp (info->output_bfd)
12392
0
     + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12393
0
    off = targ - off;
12394
12395
0
    if (info->emitrelocations)
12396
0
      {
12397
0
        stub_entry->group->stub_sec->reloc_count
12398
0
    += 1 + (PPC_HA (off) != 0);
12399
0
        stub_entry->group->stub_sec->flags |= SEC_RELOC;
12400
0
      }
12401
12402
0
    stub_entry->type.main = ppc_stub_plt_branch;
12403
0
    if (!stub_entry->type.r2save)
12404
0
      {
12405
0
        size = 12;
12406
0
        if (PPC_HA (off) != 0)
12407
0
    size = 16;
12408
0
      }
12409
0
    else
12410
0
      {
12411
0
        size = 16;
12412
0
        if (PPC_HA (off) != 0)
12413
0
    size += 4;
12414
12415
0
        if (PPC_HA (r2off) != 0)
12416
0
    size += 4;
12417
0
        if (PPC_LO (r2off) != 0)
12418
0
    size += 4;
12419
0
      }
12420
0
    pad = plt_stub_pad (htab->params->plt_stub_align, stub_offset, size);
12421
0
    stub_offset += pad;
12422
0
  }
12423
0
      else if (info->emitrelocations)
12424
0
  {
12425
0
    stub_entry->group->stub_sec->reloc_count += 1;
12426
0
    stub_entry->group->stub_sec->flags |= SEC_RELOC;
12427
0
  }
12428
0
    }
12429
0
  else if (stub_entry->type.main == ppc_stub_long_branch)
12430
0
    {
12431
0
      off = (stub_offset
12432
0
       + stub_entry->group->stub_sec->output_offset
12433
0
       + stub_entry->group->stub_sec->output_section->vma);
12434
0
      size = 0;
12435
0
      if (stub_entry->type.r2save)
12436
0
  size = 4;
12437
0
      off += size;
12438
0
      targ = (stub_entry->target_value
12439
0
        + stub_entry->target_section->output_offset
12440
0
        + stub_entry->target_section->output_section->vma);
12441
0
      odd = off & 4;
12442
0
      off = targ - off;
12443
12444
0
      if (stub_entry->type.sub == ppc_stub_notoc)
12445
0
  extra = size_power10_offset (off, odd);
12446
0
      else
12447
0
  extra = size_offset (off - 8);
12448
      /* Include branch insn plus those in the offset sequence.  */
12449
0
      size += 4 + extra;
12450
12451
      /* If the branch can't reach, use a plt_branch.
12452
   The branch insn is at the end, or "extra" bytes along.  So
12453
   its offset will be "extra" bytes less that that already
12454
   calculated.  */
12455
0
      if (off - extra + (1 << 25) >= (bfd_vma) (1 << 26))
12456
0
  {
12457
0
    stub_entry->type.main = ppc_stub_plt_branch;
12458
0
    size += 4;
12459
0
    pad = plt_stub_pad (htab->params->plt_stub_align, stub_offset, size);
12460
0
    if (pad != 0)
12461
0
      {
12462
0
        stub_offset += pad;
12463
0
        off -= pad;
12464
0
        odd ^= pad & 4;
12465
0
        size -= extra;
12466
0
        if (stub_entry->type.sub == ppc_stub_notoc)
12467
0
    extra = size_power10_offset (off, odd);
12468
0
        else
12469
0
    extra = size_offset (off - 8);
12470
0
        size += extra;
12471
0
      }
12472
0
  }
12473
0
      else if (info->emitrelocations)
12474
0
  stub_entry->group->stub_sec->reloc_count +=1;
12475
12476
0
      if (info->emitrelocations)
12477
0
  {
12478
0
    unsigned int num_rel;
12479
0
    if (stub_entry->type.sub == ppc_stub_notoc)
12480
0
      num_rel = num_relocs_for_power10_offset (off, odd);
12481
0
    else
12482
0
      num_rel = num_relocs_for_offset (off - 8);
12483
0
    stub_entry->group->stub_sec->reloc_count += num_rel;
12484
0
    stub_entry->group->stub_sec->flags |= SEC_RELOC;
12485
0
  }
12486
12487
0
      if (stub_entry->type.sub != ppc_stub_notoc)
12488
0
  {
12489
    /* After the bcl, lr has been modified so we need to emit
12490
       .eh_frame info saying the return address is in r12.  */
12491
0
    lr_used = stub_offset + 8;
12492
0
    if (stub_entry->type.r2save)
12493
0
      lr_used += 4;
12494
    /* The eh_frame info will consist of a DW_CFA_advance_loc or
12495
       variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12496
       DW_CFA_restore_extended 65.  */
12497
0
    delta = lr_used - stub_entry->group->lr_restore;
12498
0
    stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12499
0
    stub_entry->group->lr_restore = lr_used + 8;
12500
0
  }
12501
0
    }
12502
0
  else if (stub_entry->type.sub >= ppc_stub_notoc)
12503
0
    {
12504
0
      BFD_ASSERT (stub_entry->type.main == ppc_stub_plt_call);
12505
0
      lr_used = 0;
12506
0
      if (stub_entry->h != NULL
12507
0
    && is_tls_get_addr (&stub_entry->h->elf, htab)
12508
0
    && htab->params->tls_get_addr_opt)
12509
0
  {
12510
0
    lr_used += 7 * 4;
12511
0
    if (!htab->params->no_tls_get_addr_regsave)
12512
0
      lr_used += 11 * 4;
12513
0
    else if (stub_entry->type.r2save)
12514
0
      lr_used += 2 * 4;
12515
0
  }
12516
0
      if (stub_entry->type.r2save)
12517
0
  lr_used += 4;
12518
0
      targ = stub_entry->plt_ent->plt.offset & ~1;
12519
0
      if (targ >= (bfd_vma) -2)
12520
0
  abort ();
12521
12522
0
      plt = htab->elf.splt;
12523
0
      if (use_local_plt (info, elf_hash_entry (stub_entry->h)))
12524
0
  {
12525
0
    if (stub_entry->symtype == STT_GNU_IFUNC)
12526
0
      plt = htab->elf.iplt;
12527
0
    else
12528
0
      plt = htab->pltlocal;
12529
0
  }
12530
0
      targ += plt->output_offset + plt->output_section->vma;
12531
0
      off = (stub_offset
12532
0
       + stub_entry->group->stub_sec->output_offset
12533
0
       + stub_entry->group->stub_sec->output_section->vma
12534
0
       + lr_used);
12535
0
      odd = off & 4;
12536
0
      off = targ - off;
12537
12538
0
      size = plt_stub_size (htab, stub_entry, off, odd);
12539
0
      pad = plt_stub_pad (htab->params->plt_stub_align, stub_offset, size);
12540
0
      if (pad != 0)
12541
0
  {
12542
0
    stub_offset += pad;
12543
0
    off -= pad;
12544
0
    odd ^= pad & 4;
12545
0
    size = plt_stub_size (htab, stub_entry, off, odd);
12546
0
  }
12547
12548
0
      if (info->emitrelocations)
12549
0
  {
12550
0
    unsigned int num_rel;
12551
0
    if (stub_entry->type.sub == ppc_stub_notoc)
12552
0
      num_rel = num_relocs_for_power10_offset (off, odd);
12553
0
    else
12554
0
      num_rel = num_relocs_for_offset (off - 8);
12555
0
    stub_entry->group->stub_sec->reloc_count += num_rel;
12556
0
    stub_entry->group->stub_sec->flags |= SEC_RELOC;
12557
0
  }
12558
12559
0
      if (stub_entry->type.sub != ppc_stub_notoc)
12560
0
  {
12561
    /* After the bcl, lr has been modified so we need to emit
12562
       .eh_frame info saying the return address is in r12.  */
12563
0
    lr_used += stub_offset + 8;
12564
    /* The eh_frame info will consist of a DW_CFA_advance_loc or
12565
       variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12566
       DW_CFA_restore_extended 65.  */
12567
0
    delta = lr_used - stub_entry->group->lr_restore;
12568
0
    stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12569
0
    stub_entry->group->lr_restore = lr_used + 8;
12570
0
  }
12571
0
      if (stub_entry->h != NULL
12572
0
    && is_tls_get_addr (&stub_entry->h->elf, htab)
12573
0
    && htab->params->tls_get_addr_opt)
12574
0
  {
12575
0
    if (!htab->params->no_tls_get_addr_regsave)
12576
0
      {
12577
0
        unsigned int cfa_updt = stub_offset + 18 * 4;
12578
0
        delta = cfa_updt - stub_entry->group->lr_restore;
12579
0
        stub_entry->group->eh_size += eh_advance_size (delta);
12580
0
        stub_entry->group->eh_size += htab->opd_abi ? 36 : 35;
12581
0
        stub_entry->group->lr_restore = stub_offset + size - 4;
12582
0
      }
12583
0
    else if (stub_entry->type.r2save)
12584
0
      {
12585
0
        lr_used = stub_offset + size - 20;
12586
0
        delta = lr_used - stub_entry->group->lr_restore;
12587
0
        stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12588
0
        stub_entry->group->lr_restore = stub_offset + size - 4;
12589
0
      }
12590
0
  }
12591
0
    }
12592
0
  else if (stub_entry->type.main == ppc_stub_plt_call)
12593
0
    {
12594
0
      targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
12595
0
      if (targ >= (bfd_vma) -2)
12596
0
  abort ();
12597
0
      plt = htab->elf.splt;
12598
0
      if (use_local_plt (info, elf_hash_entry (stub_entry->h)))
12599
0
  {
12600
0
    if (stub_entry->symtype == STT_GNU_IFUNC)
12601
0
      plt = htab->elf.iplt;
12602
0
    else
12603
0
      plt = htab->pltlocal;
12604
0
  }
12605
0
      targ += plt->output_offset + plt->output_section->vma;
12606
12607
0
      off = (elf_gp (info->output_bfd)
12608
0
       + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12609
0
      off = targ - off;
12610
12611
0
      size = plt_stub_size (htab, stub_entry, off, 0);
12612
0
      pad = plt_stub_pad (htab->params->plt_stub_align, stub_offset, size);
12613
0
      stub_offset += pad;
12614
12615
0
      if (info->emitrelocations)
12616
0
  {
12617
0
    stub_entry->group->stub_sec->reloc_count
12618
0
      += ((PPC_HA (off) != 0)
12619
0
    + (htab->opd_abi
12620
0
       ? 2 + (htab->params->plt_static_chain
12621
0
        && PPC_HA (off + 16) == PPC_HA (off))
12622
0
       : 1));
12623
0
    stub_entry->group->stub_sec->flags |= SEC_RELOC;
12624
0
  }
12625
12626
0
      if (stub_entry->h != NULL
12627
0
    && is_tls_get_addr (&stub_entry->h->elf, htab)
12628
0
    && htab->params->tls_get_addr_opt
12629
0
    && stub_entry->type.r2save)
12630
0
  {
12631
0
    if (!htab->params->no_tls_get_addr_regsave)
12632
0
      {
12633
        /* Adjustments to r1 need to be described.  */
12634
0
        unsigned int cfa_updt = stub_offset + 18 * 4;
12635
0
        delta = cfa_updt - stub_entry->group->lr_restore;
12636
0
        stub_entry->group->eh_size += eh_advance_size (delta);
12637
0
        stub_entry->group->eh_size += htab->opd_abi ? 36 : 35;
12638
0
      }
12639
0
    else
12640
0
      {
12641
0
        lr_used = stub_offset + size - 20;
12642
        /* The eh_frame info will consist of a DW_CFA_advance_loc
12643
     or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12644
     DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65.  */
12645
0
        delta = lr_used - stub_entry->group->lr_restore;
12646
0
        stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12647
0
      }
12648
0
    stub_entry->group->lr_restore = stub_offset + size - 4;
12649
0
  }
12650
0
    }
12651
0
  else
12652
0
    {
12653
0
      BFD_FAIL ();
12654
0
      return false;
12655
0
    }
12656
12657
0
  if (stub_entry->stub_offset != stub_offset)
12658
0
    htab->stub_changed = true;
12659
0
  stub_entry->stub_offset = stub_offset;
12660
0
  stub_entry->group->stub_sec->size = stub_offset + size;
12661
0
  return true;
12662
0
}
12663
12664
/* Set up various things so that we can make a list of input sections
12665
   for each output section included in the link.  Returns -1 on error,
12666
   0 when no stubs will be needed, and 1 on success.  */
12667
12668
int
12669
ppc64_elf_setup_section_lists (struct bfd_link_info *info)
12670
0
{
12671
0
  unsigned int id;
12672
0
  size_t amt;
12673
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
12674
12675
0
  if (htab == NULL)
12676
0
    return -1;
12677
12678
0
  htab->sec_info_arr_size = _bfd_section_id;
12679
0
  amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
12680
0
  htab->sec_info = bfd_zmalloc (amt);
12681
0
  if (htab->sec_info == NULL)
12682
0
    return -1;
12683
12684
  /* Set toc_off for com, und, abs and ind sections.  */
12685
0
  for (id = 0; id < 3; id++)
12686
0
    htab->sec_info[id].toc_off = TOC_BASE_OFF;
12687
12688
0
  return 1;
12689
0
}
12690
12691
/* Set up for first pass at multitoc partitioning.  */
12692
12693
void
12694
ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
12695
0
{
12696
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
12697
12698
0
  htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
12699
0
  htab->toc_bfd = NULL;
12700
0
  htab->toc_first_sec = NULL;
12701
0
}
12702
12703
/* The linker repeatedly calls this function for each TOC input section
12704
   and linker generated GOT section.  Group input bfds such that the toc
12705
   within a group is less than 64k in size.  */
12706
12707
bool
12708
ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
12709
0
{
12710
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
12711
0
  bfd_vma addr, off, limit;
12712
12713
0
  if (htab == NULL)
12714
0
    return false;
12715
12716
0
  if (!htab->second_toc_pass)
12717
0
    {
12718
      /* Keep track of the first .toc or .got section for this input bfd.  */
12719
0
      bool new_bfd = htab->toc_bfd != isec->owner;
12720
12721
0
      if (new_bfd)
12722
0
  {
12723
0
    htab->toc_bfd = isec->owner;
12724
0
    htab->toc_first_sec = isec;
12725
0
  }
12726
12727
0
      addr = isec->output_offset + isec->output_section->vma;
12728
0
      off = addr - htab->toc_curr;
12729
0
      limit = 0x80008000;
12730
0
      if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
12731
0
  limit = 0x10000;
12732
0
      if (off + isec->size > limit)
12733
0
  {
12734
0
    addr = (htab->toc_first_sec->output_offset
12735
0
      + htab->toc_first_sec->output_section->vma);
12736
0
    htab->toc_curr = addr;
12737
0
    htab->toc_curr &= -TOC_BASE_ALIGN;
12738
0
  }
12739
12740
      /* toc_curr is the base address of this toc group.  Set elf_gp
12741
   for the input section to be the offset relative to the
12742
   output toc base plus 0x8000.  Making the input elf_gp an
12743
   offset allows us to move the toc as a whole without
12744
   recalculating input elf_gp.  */
12745
0
      off = htab->toc_curr - elf_gp (info->output_bfd);
12746
0
      off += TOC_BASE_OFF;
12747
12748
      /* Die if someone uses a linker script that doesn't keep input
12749
   file .toc and .got together.  */
12750
0
      if (new_bfd
12751
0
    && elf_gp (isec->owner) != 0
12752
0
    && elf_gp (isec->owner) != off)
12753
0
  return false;
12754
12755
0
      elf_gp (isec->owner) = off;
12756
0
      return true;
12757
0
    }
12758
12759
  /* During the second pass toc_first_sec points to the start of
12760
     a toc group, and toc_curr is used to track the old elf_gp.
12761
     We use toc_bfd to ensure we only look at each bfd once.  */
12762
0
  if (htab->toc_bfd == isec->owner)
12763
0
    return true;
12764
0
  htab->toc_bfd = isec->owner;
12765
12766
0
  if (htab->toc_first_sec == NULL
12767
0
      || htab->toc_curr != elf_gp (isec->owner))
12768
0
    {
12769
0
      htab->toc_curr = elf_gp (isec->owner);
12770
0
      htab->toc_first_sec = isec;
12771
0
    }
12772
0
  addr = (htab->toc_first_sec->output_offset
12773
0
    + htab->toc_first_sec->output_section->vma);
12774
0
  off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
12775
0
  elf_gp (isec->owner) = off;
12776
12777
0
  return true;
12778
0
}
12779
12780
/* Called via elf_link_hash_traverse to merge GOT entries for global
12781
   symbol H.  */
12782
12783
static bool
12784
merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12785
0
{
12786
0
  if (h->root.type == bfd_link_hash_indirect)
12787
0
    return true;
12788
12789
0
  merge_got_entries (&h->got.glist);
12790
12791
0
  return true;
12792
0
}
12793
12794
/* Called via elf_link_hash_traverse to allocate GOT entries for global
12795
   symbol H.  */
12796
12797
static bool
12798
reallocate_got (struct elf_link_hash_entry *h, void *inf)
12799
0
{
12800
0
  struct got_entry *gent;
12801
12802
0
  if (h->root.type == bfd_link_hash_indirect)
12803
0
    return true;
12804
12805
0
  for (gent = h->got.glist; gent != NULL; gent = gent->next)
12806
0
    if (!gent->is_indirect)
12807
0
      allocate_got (h, (struct bfd_link_info *) inf, gent);
12808
0
  return true;
12809
0
}
12810
12811
/* Called on the first multitoc pass after the last call to
12812
   ppc64_elf_next_toc_section.  This function removes duplicate GOT
12813
   entries.  */
12814
12815
bool
12816
ppc64_elf_layout_multitoc (struct bfd_link_info *info)
12817
0
{
12818
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
12819
0
  struct bfd *ibfd, *ibfd2;
12820
0
  bool done_something;
12821
12822
0
  htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
12823
12824
0
  if (!htab->do_multi_toc)
12825
0
    return false;
12826
12827
  /* Merge global sym got entries within a toc group.  */
12828
0
  elf_link_hash_traverse (&htab->elf, merge_global_got, info);
12829
12830
  /* And tlsld_got.  */
12831
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12832
0
    {
12833
0
      struct got_entry *ent, *ent2;
12834
12835
0
      if (!is_ppc64_elf (ibfd))
12836
0
  continue;
12837
12838
0
      ent = ppc64_tlsld_got (ibfd);
12839
0
      if (!ent->is_indirect
12840
0
    && ent->got.offset != (bfd_vma) -1)
12841
0
  {
12842
0
    for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
12843
0
      {
12844
0
        if (!is_ppc64_elf (ibfd2))
12845
0
    continue;
12846
12847
0
        ent2 = ppc64_tlsld_got (ibfd2);
12848
0
        if (!ent2->is_indirect
12849
0
      && ent2->got.offset != (bfd_vma) -1
12850
0
      && elf_gp (ibfd2) == elf_gp (ibfd))
12851
0
    {
12852
0
      ent2->is_indirect = true;
12853
0
      ent2->got.ent = ent;
12854
0
    }
12855
0
      }
12856
0
  }
12857
0
    }
12858
12859
  /* Zap sizes of got sections.  */
12860
0
  htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
12861
0
  htab->elf.irelplt->size -= htab->got_reli_size;
12862
0
  htab->got_reli_size = 0;
12863
12864
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12865
0
    {
12866
0
      asection *got, *relgot;
12867
12868
0
      if (!is_ppc64_elf (ibfd))
12869
0
  continue;
12870
12871
0
      got = ppc64_elf_tdata (ibfd)->got;
12872
0
      if (got != NULL)
12873
0
  {
12874
0
    got->rawsize = got->size;
12875
0
    got->size = 0;
12876
0
    relgot = ppc64_elf_tdata (ibfd)->relgot;
12877
0
    relgot->rawsize = relgot->size;
12878
0
    relgot->size = 0;
12879
0
  }
12880
0
    }
12881
12882
  /* Now reallocate the got, local syms first.  We don't need to
12883
     allocate section contents again since we never increase size.  */
12884
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12885
0
    {
12886
0
      struct got_entry **lgot_ents;
12887
0
      struct got_entry **end_lgot_ents;
12888
0
      struct plt_entry **local_plt;
12889
0
      struct plt_entry **end_local_plt;
12890
0
      unsigned char *lgot_masks;
12891
0
      bfd_size_type locsymcount;
12892
0
      Elf_Internal_Shdr *symtab_hdr;
12893
0
      asection *s;
12894
0
      Elf_Internal_Sym *local_syms;
12895
0
      Elf_Internal_Sym *isym;
12896
12897
0
      if (!is_ppc64_elf (ibfd))
12898
0
  continue;
12899
12900
0
      lgot_ents = elf_local_got_ents (ibfd);
12901
0
      if (!lgot_ents)
12902
0
  continue;
12903
12904
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
12905
0
      locsymcount = symtab_hdr->sh_info;
12906
0
      end_lgot_ents = lgot_ents + locsymcount;
12907
0
      local_plt = (struct plt_entry **) end_lgot_ents;
12908
0
      end_local_plt = local_plt + locsymcount;
12909
0
      lgot_masks = (unsigned char *) end_local_plt;
12910
0
      local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
12911
0
      if (local_syms == NULL && locsymcount != 0)
12912
0
  {
12913
0
    local_syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, locsymcount,
12914
0
               0, NULL, NULL, NULL);
12915
0
    if (local_syms == NULL)
12916
0
      return false;
12917
0
  }
12918
0
      s = ppc64_elf_tdata (ibfd)->got;
12919
0
      for (isym = local_syms;
12920
0
     lgot_ents < end_lgot_ents;
12921
0
     ++lgot_ents, ++lgot_masks, isym++)
12922
0
  {
12923
0
    struct got_entry *ent;
12924
12925
0
    for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12926
0
      {
12927
0
        unsigned int ent_size = 8;
12928
0
        unsigned int rel_size = sizeof (Elf64_External_Rela);
12929
12930
0
        ent->got.offset = s->size;
12931
0
        if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12932
0
    {
12933
0
      ent_size *= 2;
12934
0
      rel_size *= 2;
12935
0
    }
12936
0
        s->size += ent_size;
12937
0
        if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12938
0
    {
12939
0
      htab->elf.irelplt->size += rel_size;
12940
0
      htab->got_reli_size += rel_size;
12941
0
    }
12942
0
        else if (bfd_link_pic (info)
12943
0
           && (ent->tls_type == 0
12944
0
         ? !info->enable_dt_relr
12945
0
         : !bfd_link_executable (info))
12946
0
           && isym->st_shndx != SHN_ABS)
12947
0
    {
12948
0
      asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12949
0
      srel->size += rel_size;
12950
0
    }
12951
0
      }
12952
0
  }
12953
0
    }
12954
12955
0
  elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12956
12957
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12958
0
    {
12959
0
      struct got_entry *ent;
12960
12961
0
      if (!is_ppc64_elf (ibfd))
12962
0
  continue;
12963
12964
0
      ent = ppc64_tlsld_got (ibfd);
12965
0
      if (!ent->is_indirect
12966
0
    && ent->got.offset != (bfd_vma) -1)
12967
0
  {
12968
0
    asection *s = ppc64_elf_tdata (ibfd)->got;
12969
0
    ent->got.offset = s->size;
12970
0
    s->size += 16;
12971
0
    if (bfd_link_dll (info))
12972
0
      {
12973
0
        asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12974
0
        srel->size += sizeof (Elf64_External_Rela);
12975
0
      }
12976
0
  }
12977
0
    }
12978
12979
0
  done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12980
0
  if (!done_something)
12981
0
    for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12982
0
      {
12983
0
  asection *got;
12984
12985
0
  if (!is_ppc64_elf (ibfd))
12986
0
    continue;
12987
12988
0
  got = ppc64_elf_tdata (ibfd)->got;
12989
0
  if (got != NULL)
12990
0
    {
12991
0
      done_something = got->rawsize != got->size;
12992
0
      if (done_something)
12993
0
        break;
12994
0
    }
12995
0
      }
12996
12997
0
  if (done_something)
12998
0
    (*htab->params->layout_sections_again) ();
12999
13000
  /* Set up for second pass over toc sections to recalculate elf_gp
13001
     on input sections.  */
13002
0
  htab->toc_bfd = NULL;
13003
0
  htab->toc_first_sec = NULL;
13004
0
  htab->second_toc_pass = true;
13005
0
  return done_something;
13006
0
}
13007
13008
/* Called after second pass of multitoc partitioning.  */
13009
13010
void
13011
ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
13012
0
{
13013
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
13014
13015
  /* After the second pass, toc_curr tracks the TOC offset used
13016
     for code sections below in ppc64_elf_next_input_section.  */
13017
0
  htab->toc_curr = TOC_BASE_OFF;
13018
0
}
13019
13020
/* No toc references were found in ISEC.  If the code in ISEC makes no
13021
   calls, then there's no need to use toc adjusting stubs when branching
13022
   into ISEC.  Actually, indirect calls from ISEC are OK as they will
13023
   load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
13024
   needed, and 2 if a cyclical call-graph was found but no other reason
13025
   for a stub was detected.  If called from the top level, a return of
13026
   2 means the same as a return of 0.  */
13027
13028
static int
13029
toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
13030
0
{
13031
0
  int ret;
13032
13033
  /* Mark this section as checked.  */
13034
0
  isec->call_check_done = 1;
13035
13036
  /* We know none of our code bearing sections will need toc stubs.  */
13037
0
  if ((isec->flags & SEC_LINKER_CREATED) != 0)
13038
0
    return 0;
13039
13040
0
  if (isec->size == 0)
13041
0
    return 0;
13042
13043
0
  if (isec->output_section == NULL)
13044
0
    return 0;
13045
13046
0
  ret = 0;
13047
0
  if (isec->reloc_count != 0)
13048
0
    {
13049
0
      Elf_Internal_Rela *relstart, *rel;
13050
0
      Elf_Internal_Sym *local_syms;
13051
0
      struct ppc_link_hash_table *htab;
13052
13053
0
      relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
13054
0
              info->keep_memory);
13055
0
      if (relstart == NULL)
13056
0
  return -1;
13057
13058
      /* Look for branches to outside of this section.  */
13059
0
      local_syms = NULL;
13060
0
      htab = ppc_hash_table (info);
13061
0
      if (htab == NULL)
13062
0
  return -1;
13063
13064
0
      for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
13065
0
  {
13066
0
    enum elf_ppc64_reloc_type r_type;
13067
0
    unsigned long r_symndx;
13068
0
    struct elf_link_hash_entry *h;
13069
0
    struct ppc_link_hash_entry *eh;
13070
0
    Elf_Internal_Sym *sym;
13071
0
    asection *sym_sec;
13072
0
    struct _opd_sec_data *opd;
13073
0
    bfd_vma sym_value;
13074
0
    bfd_vma dest;
13075
13076
0
    r_type = ELF64_R_TYPE (rel->r_info);
13077
0
    if (r_type != R_PPC64_REL24
13078
0
        && r_type != R_PPC64_REL24_NOTOC
13079
0
        && r_type != R_PPC64_REL24_P9NOTOC
13080
0
        && r_type != R_PPC64_REL14
13081
0
        && r_type != R_PPC64_REL14_BRTAKEN
13082
0
        && r_type != R_PPC64_REL14_BRNTAKEN
13083
0
        && r_type != R_PPC64_PLTCALL
13084
0
        && r_type != R_PPC64_PLTCALL_NOTOC)
13085
0
      continue;
13086
13087
0
    r_symndx = ELF64_R_SYM (rel->r_info);
13088
0
    if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
13089
0
        isec->owner))
13090
0
      {
13091
0
        ret = -1;
13092
0
        break;
13093
0
      }
13094
13095
    /* Calls to dynamic lib functions go through a plt call stub
13096
       that uses r2.  */
13097
0
    eh = ppc_elf_hash_entry (h);
13098
0
    if (eh != NULL
13099
0
        && (eh->elf.plt.plist != NULL
13100
0
      || (eh->oh != NULL
13101
0
          && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
13102
0
      {
13103
0
        ret = 1;
13104
0
        break;
13105
0
      }
13106
13107
0
    if (sym_sec == NULL)
13108
      /* Ignore other undefined symbols.  */
13109
0
      continue;
13110
13111
    /* Assume branches to other sections not included in the
13112
       link need stubs too, to cover -R and absolute syms.  */
13113
0
    if (sym_sec->output_section == NULL)
13114
0
      {
13115
0
        ret = 1;
13116
0
        break;
13117
0
      }
13118
13119
0
    if (h == NULL)
13120
0
      sym_value = sym->st_value;
13121
0
    else
13122
0
      {
13123
0
        if (h->root.type != bfd_link_hash_defined
13124
0
      && h->root.type != bfd_link_hash_defweak)
13125
0
    abort ();
13126
0
        sym_value = h->root.u.def.value;
13127
0
      }
13128
0
    sym_value += rel->r_addend;
13129
13130
    /* If this branch reloc uses an opd sym, find the code section.  */
13131
0
    opd = get_opd_info (sym_sec);
13132
0
    if (opd != NULL)
13133
0
      {
13134
0
        if (h == NULL && opd->adjust != NULL)
13135
0
    {
13136
0
      long adjust;
13137
13138
0
      adjust = opd->adjust[OPD_NDX (sym_value)];
13139
0
      if (adjust == -1)
13140
        /* Assume deleted functions won't ever be called.  */
13141
0
        continue;
13142
0
      sym_value += adjust;
13143
0
    }
13144
13145
0
        dest = opd_entry_value (sym_sec, sym_value,
13146
0
              &sym_sec, NULL, false);
13147
0
        if (dest == (bfd_vma) -1)
13148
0
    continue;
13149
0
      }
13150
0
    else
13151
0
      dest = (sym_value
13152
0
        + sym_sec->output_offset
13153
0
        + sym_sec->output_section->vma);
13154
13155
    /* Ignore branch to self.  */
13156
0
    if (sym_sec == isec)
13157
0
      continue;
13158
13159
    /* If the called function uses the toc, we need a stub.  */
13160
0
    if (sym_sec->has_toc_reloc
13161
0
        || sym_sec->makes_toc_func_call)
13162
0
      {
13163
0
        ret = 1;
13164
0
        break;
13165
0
      }
13166
13167
    /* Assume any branch that needs a long branch stub might in fact
13168
       need a plt_branch stub.  A plt_branch stub uses r2.  */
13169
0
    else if (dest - (isec->output_offset
13170
0
         + isec->output_section->vma
13171
0
         + rel->r_offset) + (1 << 25)
13172
0
       >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
13173
0
                   ? h->other
13174
0
                   : sym->st_other))
13175
0
      {
13176
0
        ret = 1;
13177
0
        break;
13178
0
      }
13179
13180
    /* If calling back to a section in the process of being
13181
       tested, we can't say for sure that no toc adjusting stubs
13182
       are needed, so don't return zero.  */
13183
0
    else if (sym_sec->call_check_in_progress)
13184
0
      ret = 2;
13185
13186
    /* Branches to another section that itself doesn't have any TOC
13187
       references are OK.  Recursively call ourselves to check.  */
13188
0
    else if (!sym_sec->call_check_done)
13189
0
      {
13190
0
        int recur;
13191
13192
        /* Mark current section as indeterminate, so that other
13193
     sections that call back to current won't be marked as
13194
     known.  */
13195
0
        isec->call_check_in_progress = 1;
13196
0
        recur = toc_adjusting_stub_needed (info, sym_sec);
13197
0
        isec->call_check_in_progress = 0;
13198
13199
0
        if (recur != 0)
13200
0
    {
13201
0
      ret = recur;
13202
0
      if (recur != 2)
13203
0
        break;
13204
0
    }
13205
0
      }
13206
0
  }
13207
13208
0
      if (elf_symtab_hdr (isec->owner).contents
13209
0
    != (unsigned char *) local_syms)
13210
0
  free (local_syms);
13211
0
      if (elf_section_data (isec)->relocs != relstart)
13212
0
  free (relstart);
13213
0
    }
13214
13215
0
  if ((ret & 1) == 0
13216
0
      && isec->map_head.s != NULL
13217
0
      && (strcmp (isec->output_section->name, ".init") == 0
13218
0
    || strcmp (isec->output_section->name, ".fini") == 0))
13219
0
    {
13220
0
      if (isec->map_head.s->has_toc_reloc
13221
0
    || isec->map_head.s->makes_toc_func_call)
13222
0
  ret = 1;
13223
0
      else if (!isec->map_head.s->call_check_done)
13224
0
  {
13225
0
    int recur;
13226
0
    isec->call_check_in_progress = 1;
13227
0
    recur = toc_adjusting_stub_needed (info, isec->map_head.s);
13228
0
    isec->call_check_in_progress = 0;
13229
0
    if (recur != 0)
13230
0
      ret = recur;
13231
0
  }
13232
0
    }
13233
13234
0
  if (ret == 1)
13235
0
    isec->makes_toc_func_call = 1;
13236
13237
0
  return ret;
13238
0
}
13239
13240
/* The linker repeatedly calls this function for each input section,
13241
   in the order that input sections are linked into output sections.
13242
   Build lists of input sections to determine groupings between which
13243
   we may insert linker stubs.  */
13244
13245
bool
13246
ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
13247
0
{
13248
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
13249
13250
0
  if (htab == NULL)
13251
0
    return false;
13252
13253
0
  if ((isec->output_section->flags & SEC_CODE) != 0
13254
0
      && isec->output_section->id < htab->sec_info_arr_size)
13255
0
    {
13256
      /* This happens to make the list in reverse order,
13257
   which is what we want.  */
13258
0
      htab->sec_info[isec->id].u.list
13259
0
  = htab->sec_info[isec->output_section->id].u.list;
13260
0
      htab->sec_info[isec->output_section->id].u.list = isec;
13261
0
    }
13262
13263
0
  if (htab->multi_toc_needed)
13264
0
    {
13265
      /* Analyse sections that aren't already flagged as needing a
13266
   valid toc pointer.  Exclude .fixup for the linux kernel.
13267
   .fixup contains branches, but only back to the function that
13268
   hit an exception.  */
13269
0
      if (!(isec->has_toc_reloc
13270
0
      || (isec->flags & SEC_CODE) == 0
13271
0
      || strcmp (isec->name, ".fixup") == 0
13272
0
      || isec->call_check_done))
13273
0
  {
13274
0
    if (toc_adjusting_stub_needed (info, isec) < 0)
13275
0
      return false;
13276
0
  }
13277
      /* Make all sections use the TOC assigned for this object file.
13278
   This will be wrong for pasted sections;  We fix that in
13279
   check_pasted_section().  */
13280
0
      if (elf_gp (isec->owner) != 0)
13281
0
  htab->toc_curr = elf_gp (isec->owner);
13282
0
    }
13283
13284
0
  htab->sec_info[isec->id].toc_off = htab->toc_curr;
13285
0
  return true;
13286
0
}
13287
13288
/* Check that all .init and .fini sections use the same toc, if they
13289
   have toc relocs.  */
13290
13291
static bool
13292
check_pasted_section (struct bfd_link_info *info, const char *name)
13293
0
{
13294
0
  asection *o = bfd_get_section_by_name (info->output_bfd, name);
13295
13296
0
  if (o != NULL)
13297
0
    {
13298
0
      struct ppc_link_hash_table *htab = ppc_hash_table (info);
13299
0
      bfd_vma toc_off = 0;
13300
0
      asection *i;
13301
13302
0
      for (i = o->map_head.s; i != NULL; i = i->map_head.s)
13303
0
  if (i->has_toc_reloc)
13304
0
    {
13305
0
      if (toc_off == 0)
13306
0
        toc_off = htab->sec_info[i->id].toc_off;
13307
0
      else if (toc_off != htab->sec_info[i->id].toc_off)
13308
0
        return false;
13309
0
    }
13310
13311
0
      if (toc_off == 0)
13312
0
  for (i = o->map_head.s; i != NULL; i = i->map_head.s)
13313
0
    if (i->makes_toc_func_call)
13314
0
      {
13315
0
        toc_off = htab->sec_info[i->id].toc_off;
13316
0
        break;
13317
0
      }
13318
13319
      /* Make sure the whole pasted function uses the same toc offset.  */
13320
0
      if (toc_off != 0)
13321
0
  for (i = o->map_head.s; i != NULL; i = i->map_head.s)
13322
0
    htab->sec_info[i->id].toc_off = toc_off;
13323
0
    }
13324
0
  return true;
13325
0
}
13326
13327
bool
13328
ppc64_elf_check_init_fini (struct bfd_link_info *info)
13329
0
{
13330
0
  bool ret1 = check_pasted_section (info, ".init");
13331
0
  bool ret2 = check_pasted_section (info, ".fini");
13332
13333
0
  return ret1 && ret2;
13334
0
}
13335
13336
/* See whether we can group stub sections together.  Grouping stub
13337
   sections may result in fewer stubs.  More importantly, we need to
13338
   put all .init* and .fini* stubs at the beginning of the .init or
13339
   .fini output sections respectively, because glibc splits the
13340
   _init and _fini functions into multiple parts.  Putting a stub in
13341
   the middle of a function is not a good idea.  */
13342
13343
static bool
13344
group_sections (struct bfd_link_info *info,
13345
    bfd_size_type stub_group_size,
13346
    bool stubs_always_before_branch)
13347
0
{
13348
0
  struct ppc_link_hash_table *htab;
13349
0
  asection *osec;
13350
0
  bool suppress_size_errors;
13351
13352
0
  htab = ppc_hash_table (info);
13353
0
  if (htab == NULL)
13354
0
    return false;
13355
13356
0
  suppress_size_errors = false;
13357
0
  if (stub_group_size == 1)
13358
0
    {
13359
      /* Default values.  */
13360
0
      if (stubs_always_before_branch)
13361
0
  stub_group_size = 0x1e00000;
13362
0
      else
13363
0
  stub_group_size = 0x1c00000;
13364
0
      suppress_size_errors = true;
13365
0
    }
13366
13367
0
  for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
13368
0
    {
13369
0
      asection *tail;
13370
13371
0
      if (osec->id >= htab->sec_info_arr_size)
13372
0
  continue;
13373
13374
0
      tail = htab->sec_info[osec->id].u.list;
13375
0
      while (tail != NULL)
13376
0
  {
13377
0
    asection *curr;
13378
0
    asection *prev;
13379
0
    bfd_size_type total;
13380
0
    bool big_sec;
13381
0
    bfd_vma curr_toc;
13382
0
    struct map_stub *group;
13383
0
    bfd_size_type group_size;
13384
13385
0
    curr = tail;
13386
0
    total = tail->size;
13387
0
    group_size = (ppc64_elf_section_data (tail) != NULL
13388
0
      && ppc64_elf_section_data (tail)->has_14bit_branch
13389
0
      ? stub_group_size >> 10 : stub_group_size);
13390
13391
0
    big_sec = total > group_size;
13392
0
    if (big_sec && !suppress_size_errors)
13393
      /* xgettext:c-format */
13394
0
      _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
13395
0
        tail->owner, tail);
13396
0
    curr_toc = htab->sec_info[tail->id].toc_off;
13397
13398
0
    while ((prev = htab->sec_info[curr->id].u.list) != NULL
13399
0
     && ((total += curr->output_offset - prev->output_offset)
13400
0
         < (ppc64_elf_section_data (prev) != NULL
13401
0
      && ppc64_elf_section_data (prev)->has_14bit_branch
13402
0
      ? (group_size = stub_group_size >> 10) : group_size))
13403
0
     && htab->sec_info[prev->id].toc_off == curr_toc)
13404
0
      curr = prev;
13405
13406
    /* OK, the size from the start of CURR to the end is less
13407
       than group_size and thus can be handled by one stub
13408
       section.  (or the tail section is itself larger than
13409
       group_size, in which case we may be toast.)  We should
13410
       really be keeping track of the total size of stubs added
13411
       here, as stubs contribute to the final output section
13412
       size.  That's a little tricky, and this way will only
13413
       break if stubs added make the total size more than 2^25,
13414
       ie. for the default stub_group_size, if stubs total more
13415
       than 2097152 bytes, or nearly 75000 plt call stubs.  */
13416
0
    group = bfd_alloc (curr->owner, sizeof (*group));
13417
0
    if (group == NULL)
13418
0
      return false;
13419
0
    group->link_sec = curr;
13420
0
    group->stub_sec = NULL;
13421
0
    group->needs_save_res = 0;
13422
0
    group->lr_restore = 0;
13423
0
    group->eh_size = 0;
13424
0
    group->eh_base = 0;
13425
0
    group->next = htab->group;
13426
0
    htab->group = group;
13427
0
    do
13428
0
      {
13429
0
        prev = htab->sec_info[tail->id].u.list;
13430
        /* Set up this stub group.  */
13431
0
        htab->sec_info[tail->id].u.group = group;
13432
0
      }
13433
0
    while (tail != curr && (tail = prev) != NULL);
13434
13435
    /* But wait, there's more!  Input sections up to group_size
13436
       bytes before the stub section can be handled by it too.
13437
       Don't do this if we have a really large section after the
13438
       stubs, as adding more stubs increases the chance that
13439
       branches may not reach into the stub section.  */
13440
0
    if (!stubs_always_before_branch && !big_sec)
13441
0
      {
13442
0
        total = 0;
13443
0
        while (prev != NULL
13444
0
         && ((total += tail->output_offset - prev->output_offset)
13445
0
       < (ppc64_elf_section_data (prev) != NULL
13446
0
          && ppc64_elf_section_data (prev)->has_14bit_branch
13447
0
          ? (group_size = stub_group_size >> 10)
13448
0
          : group_size))
13449
0
         && htab->sec_info[prev->id].toc_off == curr_toc)
13450
0
    {
13451
0
      tail = prev;
13452
0
      prev = htab->sec_info[tail->id].u.list;
13453
0
      htab->sec_info[tail->id].u.group = group;
13454
0
    }
13455
0
      }
13456
0
    tail = prev;
13457
0
  }
13458
0
    }
13459
0
  return true;
13460
0
}
13461
13462
static const unsigned char glink_eh_frame_cie[] =
13463
{
13464
  0, 0, 0, 16,        /* length.  */
13465
  0, 0, 0, 0,       /* id.  */
13466
  1,          /* CIE version.  */
13467
  'z', 'R', 0,        /* Augmentation string.  */
13468
  4,          /* Code alignment.  */
13469
  0x78,         /* Data alignment.  */
13470
  65,         /* RA reg.  */
13471
  1,          /* Augmentation size.  */
13472
  DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding.  */
13473
  DW_CFA_def_cfa, 1, 0      /* def_cfa: r1 offset 0.  */
13474
};
13475
13476
/* Stripping output sections is normally done before dynamic section
13477
   symbols have been allocated.  This function is called later, and
13478
   handles cases like htab->brlt which is mapped to its own output
13479
   section.  */
13480
13481
static void
13482
maybe_strip_output (struct bfd_link_info *info, asection *isec)
13483
0
{
13484
0
  if (isec->size == 0
13485
0
      && isec->output_section->size == 0
13486
0
      && !(isec->output_section->flags & SEC_KEEP)
13487
0
      && !bfd_section_removed_from_list (info->output_bfd,
13488
0
           isec->output_section)
13489
0
      && elf_section_data (isec->output_section)->dynindx == 0)
13490
0
    {
13491
0
      isec->output_section->flags |= SEC_EXCLUDE;
13492
0
      bfd_section_list_remove (info->output_bfd, isec->output_section);
13493
0
      info->output_bfd->section_count--;
13494
0
    }
13495
0
}
13496
13497
/* Stash R_PPC64_RELATIVE reloc at input section SEC, r_offset OFF to
13498
   the array of such relocs.  */
13499
13500
static bool
13501
append_relr_off (struct ppc_link_hash_table *htab, asection *sec, bfd_vma off)
13502
0
{
13503
0
  if (htab->relr_count >= htab->relr_alloc)
13504
0
    {
13505
0
      if (htab->relr_alloc == 0)
13506
0
  htab->relr_alloc = 4096;
13507
0
      else
13508
0
  htab->relr_alloc *= 2;
13509
0
      htab->relr = bfd_realloc (htab->relr,
13510
0
        htab->relr_alloc * sizeof (*htab->relr));
13511
0
      if (htab->relr == NULL)
13512
0
  return false;
13513
0
    }
13514
0
  htab->relr[htab->relr_count].sec = sec;
13515
0
  htab->relr[htab->relr_count].off = off;
13516
0
  htab->relr_count++;
13517
0
  return true;
13518
0
}
13519
13520
/* qsort comparator for bfd_vma args.  */
13521
13522
static int
13523
compare_relr_address (const void *arg1, const void *arg2)
13524
0
{
13525
0
  bfd_vma a = *(bfd_vma *) arg1;
13526
0
  bfd_vma b = *(bfd_vma *) arg2;
13527
0
  return a < b ? -1 : a > b ? 1 : 0;
13528
0
}
13529
13530
/* Produce a malloc'd sorted array of reloc addresses from the info
13531
   stored by append_relr_off.  */
13532
13533
static bfd_vma *
13534
sort_relr (struct ppc_link_hash_table *htab)
13535
0
{
13536
0
  bfd_vma *addr = bfd_malloc (htab->relr_count * sizeof (*addr));
13537
0
  if (addr == NULL)
13538
0
    return NULL;
13539
13540
0
  for (size_t i = 0; i < htab->relr_count; i++)
13541
0
    addr[i] = (htab->relr[i].sec->output_section->vma
13542
0
         + htab->relr[i].sec->output_offset
13543
0
         + htab->relr[i].off);
13544
13545
0
  if (htab->relr_count > 1)
13546
0
    qsort (addr, htab->relr_count, sizeof (*addr), compare_relr_address);
13547
13548
0
  return addr;
13549
0
}
13550
13551
/* Look over GOT and PLT entries saved on elf_local_got_ents for all
13552
   input files, stashing info about needed relative relocs.  */
13553
13554
static bool
13555
got_and_plt_relr_for_local_syms (struct bfd_link_info *info)
13556
0
{
13557
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
13558
0
  bfd *ibfd;
13559
13560
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13561
0
    {
13562
0
      struct got_entry **lgot_ents, **lgot, **end_lgot_ents;
13563
0
      struct plt_entry **local_plt, **lplt, **end_local_plt;
13564
0
      Elf_Internal_Shdr *symtab_hdr;
13565
0
      bfd_size_type locsymcount;
13566
0
      Elf_Internal_Sym *local_syms;
13567
0
      Elf_Internal_Sym *isym;
13568
0
      struct plt_entry *pent;
13569
0
      struct got_entry *gent;
13570
13571
0
      if (!is_ppc64_elf (ibfd))
13572
0
  continue;
13573
13574
0
      lgot_ents = elf_local_got_ents (ibfd);
13575
0
      if (!lgot_ents)
13576
0
  continue;
13577
13578
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
13579
0
      locsymcount = symtab_hdr->sh_info;
13580
0
      local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
13581
0
      if (local_syms == NULL && locsymcount != 0)
13582
0
  {
13583
0
    local_syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, locsymcount,
13584
0
               0, NULL, NULL, NULL);
13585
0
    if (local_syms == NULL)
13586
0
      return false;
13587
0
  }
13588
0
      end_lgot_ents = lgot_ents + locsymcount;
13589
0
      local_plt = (struct plt_entry **) end_lgot_ents;
13590
0
      end_local_plt = local_plt + locsymcount;
13591
0
      for (lgot = lgot_ents, isym = local_syms;
13592
0
     lgot < end_lgot_ents;
13593
0
     ++lgot, ++isym)
13594
0
  for (gent = *lgot; gent != NULL; gent = gent->next)
13595
0
    if (!gent->is_indirect
13596
0
        && gent->tls_type == 0
13597
0
        && gent->got.offset != (bfd_vma) -1
13598
0
        && isym->st_shndx != SHN_ABS)
13599
0
      {
13600
0
        asection *got = ppc64_elf_tdata (gent->owner)->got;
13601
0
        if (!append_relr_off (htab, got, gent->got.offset))
13602
0
    {
13603
0
      htab->stub_error = true;
13604
0
      return false;
13605
0
    }
13606
0
      }
13607
13608
0
      if (!htab->opd_abi)
13609
0
  for (lplt = local_plt, isym = local_syms;
13610
0
       lplt < end_local_plt;
13611
0
       ++lplt, ++isym)
13612
0
    for (pent = *lplt; pent != NULL; pent = pent->next)
13613
0
      if (pent->plt.offset != (bfd_vma) -1
13614
0
    && ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC)
13615
0
        {
13616
0
    if (!append_relr_off (htab, htab->pltlocal, pent->plt.offset))
13617
0
      {
13618
0
        if (symtab_hdr->contents != (unsigned char *) local_syms)
13619
0
          free (local_syms);
13620
0
        return false;
13621
0
      }
13622
0
        }
13623
13624
0
      if (local_syms != NULL
13625
0
    && symtab_hdr->contents != (unsigned char *) local_syms)
13626
0
  {
13627
0
    if (!info->keep_memory)
13628
0
      free (local_syms);
13629
0
    else
13630
0
      symtab_hdr->contents = (unsigned char *) local_syms;
13631
0
  }
13632
0
    }
13633
0
  return true;
13634
0
}
13635
13636
/* Stash info about needed GOT and PLT entry relative relocs for
13637
   global symbol H.  */
13638
13639
static bool
13640
got_and_plt_relr (struct elf_link_hash_entry *h, void *inf)
13641
0
{
13642
0
  struct bfd_link_info *info;
13643
0
  struct ppc_link_hash_table *htab;
13644
0
  struct plt_entry *pent;
13645
0
  struct got_entry *gent;
13646
13647
0
  if (h->root.type == bfd_link_hash_indirect)
13648
0
    return true;
13649
13650
0
  info = (struct bfd_link_info *) inf;
13651
0
  htab = ppc_hash_table (info);
13652
0
  if (htab == NULL)
13653
0
    return false;
13654
13655
0
  if (h->type != STT_GNU_IFUNC
13656
0
      && h->def_regular
13657
0
      && (h->root.type == bfd_link_hash_defined
13658
0
    || h->root.type == bfd_link_hash_defweak))
13659
0
    {
13660
0
      if ((!htab->elf.dynamic_sections_created
13661
0
     || h->dynindx == -1
13662
0
     || SYMBOL_REFERENCES_LOCAL (info, h))
13663
0
    && !bfd_is_abs_symbol (&h->root))
13664
0
  for (gent = h->got.glist; gent != NULL; gent = gent->next)
13665
0
    if (!gent->is_indirect
13666
0
        && gent->tls_type == 0
13667
0
        && gent->got.offset != (bfd_vma) -1)
13668
0
      {
13669
0
        asection *got = ppc64_elf_tdata (gent->owner)->got;
13670
0
        if (!append_relr_off (htab, got, gent->got.offset))
13671
0
    {
13672
0
      htab->stub_error = true;
13673
0
      return false;
13674
0
    }
13675
0
      }
13676
13677
0
      if (!htab->opd_abi
13678
0
    && use_local_plt (info, h))
13679
0
  for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13680
0
    if (pent->plt.offset != (bfd_vma) -1)
13681
0
      {
13682
0
        if (!append_relr_off (htab, htab->pltlocal, pent->plt.offset))
13683
0
    {
13684
0
      htab->stub_error = true;
13685
0
      return false;
13686
0
    }
13687
0
      }
13688
0
    }
13689
0
  return true;
13690
0
}
13691
13692
/* Determine and set the size of the stub section for a final link.
13693
13694
   The basic idea here is to examine all the relocations looking for
13695
   PC-relative calls to a target that is unreachable with a "bl"
13696
   instruction.  */
13697
13698
bool
13699
ppc64_elf_size_stubs (struct bfd_link_info *info)
13700
0
{
13701
0
  bfd_size_type stub_group_size;
13702
0
  bool stubs_always_before_branch;
13703
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
13704
13705
0
  if (htab == NULL)
13706
0
    return false;
13707
13708
0
  if (htab->params->power10_stubs == -1 && !htab->has_power10_relocs)
13709
0
    htab->params->power10_stubs = 0;
13710
13711
0
  if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
13712
0
    htab->params->plt_thread_safe = 1;
13713
0
  if (!htab->opd_abi)
13714
0
    htab->params->plt_thread_safe = 0;
13715
0
  else if (htab->params->plt_thread_safe == -1)
13716
0
    {
13717
0
      static const char *const thread_starter[] =
13718
0
  {
13719
0
    "pthread_create",
13720
    /* libstdc++ */
13721
0
    "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13722
    /* librt */
13723
0
    "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13724
0
    "mq_notify", "create_timer",
13725
    /* libanl */
13726
0
    "getaddrinfo_a",
13727
    /* libgomp */
13728
0
    "GOMP_parallel",
13729
0
    "GOMP_parallel_start",
13730
0
    "GOMP_parallel_loop_static",
13731
0
    "GOMP_parallel_loop_static_start",
13732
0
    "GOMP_parallel_loop_dynamic",
13733
0
    "GOMP_parallel_loop_dynamic_start",
13734
0
    "GOMP_parallel_loop_guided",
13735
0
    "GOMP_parallel_loop_guided_start",
13736
0
    "GOMP_parallel_loop_runtime",
13737
0
    "GOMP_parallel_loop_runtime_start",
13738
0
    "GOMP_parallel_sections",
13739
0
    "GOMP_parallel_sections_start",
13740
    /* libgo */
13741
0
    "__go_go",
13742
0
  };
13743
0
      unsigned i;
13744
13745
0
      for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
13746
0
  {
13747
0
    struct elf_link_hash_entry *h;
13748
0
    h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
13749
0
            false, false, true);
13750
0
    htab->params->plt_thread_safe = h != NULL && h->ref_regular;
13751
0
    if (htab->params->plt_thread_safe)
13752
0
      break;
13753
0
  }
13754
0
    }
13755
0
  stubs_always_before_branch = htab->params->group_size < 0;
13756
0
  if (htab->params->group_size < 0)
13757
0
    stub_group_size = -htab->params->group_size;
13758
0
  else
13759
0
    stub_group_size = htab->params->group_size;
13760
13761
0
  if (!group_sections (info, stub_group_size, stubs_always_before_branch))
13762
0
    return false;
13763
13764
0
  htab->tga_group = NULL;
13765
0
  if (!htab->params->no_tls_get_addr_regsave
13766
0
      && htab->tga_desc_fd != NULL
13767
0
      && (htab->tga_desc_fd->elf.root.type == bfd_link_hash_undefined
13768
0
    || htab->tga_desc_fd->elf.root.type == bfd_link_hash_undefweak)
13769
0
      && htab->tls_get_addr_fd != NULL
13770
0
      && is_static_defined (&htab->tls_get_addr_fd->elf))
13771
0
    {
13772
0
      asection *sym_sec, *code_sec, *stub_sec;
13773
0
      bfd_vma sym_value;
13774
0
      struct _opd_sec_data *opd;
13775
13776
0
      sym_sec = htab->tls_get_addr_fd->elf.root.u.def.section;
13777
0
      sym_value = defined_sym_val (&htab->tls_get_addr_fd->elf);
13778
0
      code_sec = sym_sec;
13779
0
      opd = get_opd_info (sym_sec);
13780
0
      if (opd != NULL)
13781
0
  opd_entry_value (sym_sec, sym_value, &code_sec, NULL, false);
13782
0
      htab->tga_group = htab->sec_info[code_sec->id].u.group;
13783
0
      stub_sec = (*htab->params->add_stub_section) (".tga_desc.stub",
13784
0
                htab->tga_group->link_sec);
13785
0
      if (stub_sec == NULL)
13786
0
  return false;
13787
0
      htab->tga_group->stub_sec = stub_sec;
13788
13789
0
      htab->tga_desc_fd->elf.root.type = bfd_link_hash_defined;
13790
0
      htab->tga_desc_fd->elf.root.u.def.section = stub_sec;
13791
0
      htab->tga_desc_fd->elf.root.u.def.value = 0;
13792
0
      htab->tga_desc_fd->elf.type = STT_FUNC;
13793
0
      htab->tga_desc_fd->elf.def_regular = 1;
13794
0
      htab->tga_desc_fd->elf.non_elf = 0;
13795
0
      _bfd_elf_link_hash_hide_symbol (info, &htab->tga_desc_fd->elf, true);
13796
0
    }
13797
13798
  /* Loop until no stubs added.  After iteration 20 of this loop we may
13799
     exit on a stub section shrinking.  */
13800
13801
0
  while (1)
13802
0
    {
13803
0
      bfd *input_bfd;
13804
0
      unsigned int bfd_indx;
13805
0
      struct map_stub *group;
13806
13807
0
      htab->stub_iteration += 1;
13808
0
      htab->relr_count = 0;
13809
13810
0
      for (input_bfd = info->input_bfds, bfd_indx = 0;
13811
0
     input_bfd != NULL;
13812
0
     input_bfd = input_bfd->link.next, bfd_indx++)
13813
0
  {
13814
0
    Elf_Internal_Shdr *symtab_hdr;
13815
0
    asection *section;
13816
0
    Elf_Internal_Sym *local_syms = NULL;
13817
13818
0
    if (!is_ppc64_elf (input_bfd))
13819
0
      continue;
13820
13821
    /* We'll need the symbol table in a second.  */
13822
0
    symtab_hdr = &elf_symtab_hdr (input_bfd);
13823
0
    if (symtab_hdr->sh_info == 0)
13824
0
      continue;
13825
13826
    /* Walk over each section attached to the input bfd.  */
13827
0
    for (section = input_bfd->sections;
13828
0
         section != NULL;
13829
0
         section = section->next)
13830
0
      {
13831
0
        Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
13832
0
        bool is_opd;
13833
13834
        /* If there aren't any relocs, then there's nothing more
13835
     to do.  */
13836
0
        if ((section->flags & SEC_RELOC) == 0
13837
0
      || (section->flags & SEC_ALLOC) == 0
13838
0
      || (section->flags & SEC_LOAD) == 0
13839
0
      || section->reloc_count == 0)
13840
0
    continue;
13841
13842
0
        if (!info->enable_dt_relr
13843
0
      && (section->flags & SEC_CODE) == 0)
13844
0
    continue;
13845
13846
        /* If this section is a link-once section that will be
13847
     discarded, then don't create any stubs.  */
13848
0
        if (section->output_section == NULL
13849
0
      || section->output_section->owner != info->output_bfd)
13850
0
    continue;
13851
13852
        /* Get the relocs.  */
13853
0
        internal_relocs
13854
0
    = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
13855
0
               info->keep_memory);
13856
0
        if (internal_relocs == NULL)
13857
0
    goto error_ret_free_local;
13858
13859
0
        is_opd = ppc64_elf_section_data (section)->sec_type == sec_opd;
13860
13861
        /* Now examine each relocation.  */
13862
0
        irela = internal_relocs;
13863
0
        irelaend = irela + section->reloc_count;
13864
0
        for (; irela < irelaend; irela++)
13865
0
    {
13866
0
      enum elf_ppc64_reloc_type r_type;
13867
0
      unsigned int r_indx;
13868
0
      struct ppc_stub_type stub_type;
13869
0
      struct ppc_stub_hash_entry *stub_entry;
13870
0
      asection *sym_sec, *code_sec;
13871
0
      bfd_vma sym_value, code_value;
13872
0
      bfd_vma destination;
13873
0
      unsigned long local_off;
13874
0
      bool ok_dest;
13875
0
      struct ppc_link_hash_entry *hash;
13876
0
      struct ppc_link_hash_entry *fdh;
13877
0
      struct elf_link_hash_entry *h;
13878
0
      Elf_Internal_Sym *sym;
13879
0
      char *stub_name;
13880
0
      const asection *id_sec;
13881
0
      struct _opd_sec_data *opd;
13882
0
      struct plt_entry *plt_ent;
13883
13884
0
      r_type = ELF64_R_TYPE (irela->r_info);
13885
0
      r_indx = ELF64_R_SYM (irela->r_info);
13886
13887
0
      if (r_type >= R_PPC64_max)
13888
0
        {
13889
0
          bfd_set_error (bfd_error_bad_value);
13890
0
          goto error_ret_free_internal;
13891
0
        }
13892
13893
      /* Only look for stubs on branch instructions.  */
13894
0
      switch (r_type)
13895
0
        {
13896
0
        default:
13897
0
          if (info->enable_dt_relr
13898
0
        && maybe_relr (r_type, irela, section))
13899
0
      break;
13900
0
          continue;
13901
13902
0
        case R_PPC64_REL24:
13903
0
        case R_PPC64_REL24_NOTOC:
13904
0
        case R_PPC64_REL24_P9NOTOC:
13905
0
        case R_PPC64_REL14:
13906
0
        case R_PPC64_REL14_BRTAKEN:
13907
0
        case R_PPC64_REL14_BRNTAKEN:
13908
0
          if ((section->flags & SEC_CODE) != 0)
13909
0
      break;
13910
0
          continue;
13911
0
        }
13912
13913
      /* Now determine the call target, its name, value,
13914
         section.  */
13915
0
      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
13916
0
          r_indx, input_bfd))
13917
0
        goto error_ret_free_internal;
13918
13919
0
      if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13920
0
        {
13921
          /* Only locally defined symbols can possibly use
13922
       relative relocations.  */
13923
0
          bfd_vma r_offset;
13924
0
          if ((sym_sec == NULL
13925
0
         || sym_sec->output_section == NULL)
13926
        /* No symbol is OK too.  */
13927
0
        && !(sym != NULL && sym->st_shndx == 0)
13928
        /* Hack for __ehdr_start, which is undefined
13929
           at this point.  */
13930
0
        && !(h != NULL && h->root.linker_def))
13931
0
      continue;
13932
0
          if (NO_OPD_RELOCS && is_opd)
13933
0
      continue;
13934
0
          if (!is_opd
13935
0
        && r_type == R_PPC64_ADDR64)
13936
0
      {
13937
0
        if (h != NULL
13938
0
            ? h->type == STT_GNU_IFUNC
13939
0
            : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13940
0
          continue;
13941
0
        if (h != NULL
13942
0
            ? bfd_is_abs_symbol (&h->root)
13943
0
            : sym->st_shndx == SHN_ABS)
13944
0
          continue;
13945
0
        if (h != NULL
13946
0
            && !SYMBOL_REFERENCES_LOCAL (info, h))
13947
0
          continue;
13948
0
      }
13949
0
          r_offset = _bfd_elf_section_offset (info->output_bfd,
13950
0
                info,
13951
0
                section,
13952
0
                irela->r_offset);
13953
0
          if (r_offset >= (bfd_vma) -2)
13954
0
      continue;
13955
0
          if (!append_relr_off (htab, section, r_offset))
13956
0
      goto error_ret_free_internal;
13957
0
          continue;
13958
0
        }
13959
13960
0
      hash = ppc_elf_hash_entry (h);
13961
0
      ok_dest = false;
13962
0
      fdh = NULL;
13963
0
      sym_value = 0;
13964
0
      if (hash == NULL)
13965
0
        {
13966
0
          sym_value = sym->st_value;
13967
0
          if (sym_sec != NULL
13968
0
        && sym_sec->output_section != NULL)
13969
0
      ok_dest = true;
13970
0
        }
13971
0
      else if (hash->elf.root.type == bfd_link_hash_defined
13972
0
         || hash->elf.root.type == bfd_link_hash_defweak)
13973
0
        {
13974
0
          sym_value = hash->elf.root.u.def.value;
13975
0
          if (sym_sec->output_section != NULL)
13976
0
      ok_dest = true;
13977
0
        }
13978
0
      else if (hash->elf.root.type == bfd_link_hash_undefweak
13979
0
         || hash->elf.root.type == bfd_link_hash_undefined)
13980
0
        {
13981
          /* Recognise an old ABI func code entry sym, and
13982
       use the func descriptor sym instead if it is
13983
       defined.  */
13984
0
          if (hash->elf.root.root.string[0] == '.'
13985
0
        && hash->oh != NULL)
13986
0
      {
13987
0
        fdh = ppc_follow_link (hash->oh);
13988
0
        if (fdh->elf.root.type == bfd_link_hash_defined
13989
0
            || fdh->elf.root.type == bfd_link_hash_defweak)
13990
0
          {
13991
0
            sym_sec = fdh->elf.root.u.def.section;
13992
0
            sym_value = fdh->elf.root.u.def.value;
13993
0
            if (sym_sec->output_section != NULL)
13994
0
        ok_dest = true;
13995
0
          }
13996
0
        else
13997
0
          fdh = NULL;
13998
0
      }
13999
0
        }
14000
0
      else
14001
0
        {
14002
0
          bfd_set_error (bfd_error_bad_value);
14003
0
          goto error_ret_free_internal;
14004
0
        }
14005
14006
0
      destination = 0;
14007
0
      local_off = 0;
14008
0
      if (ok_dest)
14009
0
        {
14010
0
          sym_value += irela->r_addend;
14011
0
          destination = (sym_value
14012
0
             + sym_sec->output_offset
14013
0
             + sym_sec->output_section->vma);
14014
0
          local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
14015
0
                  ? hash->elf.other
14016
0
                  : sym->st_other);
14017
0
        }
14018
14019
0
      code_sec = sym_sec;
14020
0
      code_value = sym_value;
14021
0
      opd = get_opd_info (sym_sec);
14022
0
      if (opd != NULL)
14023
0
        {
14024
0
          bfd_vma dest;
14025
14026
0
          if (hash == NULL && opd->adjust != NULL)
14027
0
      {
14028
0
        long adjust = opd->adjust[OPD_NDX (sym_value)];
14029
0
        if (adjust == -1)
14030
0
          continue;
14031
0
        code_value += adjust;
14032
0
        sym_value += adjust;
14033
0
      }
14034
0
          dest = opd_entry_value (sym_sec, sym_value,
14035
0
                &code_sec, &code_value, false);
14036
0
          if (dest != (bfd_vma) -1)
14037
0
      {
14038
0
        destination = dest;
14039
0
        if (fdh != NULL)
14040
0
          {
14041
            /* Fixup old ABI sym to point at code
14042
         entry.  */
14043
0
            hash->elf.root.type = bfd_link_hash_defweak;
14044
0
            hash->elf.root.u.def.section = code_sec;
14045
0
            hash->elf.root.u.def.value = code_value;
14046
0
          }
14047
0
      }
14048
0
        }
14049
14050
      /* Determine what (if any) linker stub is needed.  */
14051
0
      plt_ent = NULL;
14052
0
      stub_type.main = ppc_type_of_stub (section, irela, &hash,
14053
0
                 &plt_ent, destination,
14054
0
                 local_off);
14055
0
      stub_type.sub = ppc_stub_toc;
14056
0
      stub_type.r2save = 0;
14057
14058
0
      if (r_type == R_PPC64_REL24_NOTOC
14059
0
          || r_type == R_PPC64_REL24_P9NOTOC)
14060
0
        {
14061
0
          enum ppc_stub_sub_type notoc = ppc_stub_notoc;
14062
0
          if (htab->params->power10_stubs == 0
14063
0
        || (r_type == R_PPC64_REL24_P9NOTOC
14064
0
            && htab->params->power10_stubs != 1))
14065
0
      notoc = ppc_stub_p9notoc;
14066
0
          if (stub_type.main == ppc_stub_plt_call)
14067
0
      stub_type.sub = notoc;
14068
0
          else if (stub_type.main == ppc_stub_long_branch
14069
0
             || (code_sec != NULL
14070
0
           && code_sec->output_section != NULL
14071
0
           && (((hash ? hash->elf.other : sym->st_other)
14072
0
          & STO_PPC64_LOCAL_MASK)
14073
0
               > 1 << STO_PPC64_LOCAL_BIT)))
14074
0
      {
14075
0
        stub_type.main = ppc_stub_long_branch;
14076
0
        stub_type.sub = notoc;
14077
0
        stub_type.r2save = 0;
14078
0
      }
14079
0
        }
14080
0
      else if (stub_type.main != ppc_stub_plt_call)
14081
0
        {
14082
          /* Check whether we need a TOC adjusting stub.
14083
       Since the linker pastes together pieces from
14084
       different object files when creating the
14085
       _init and _fini functions, it may be that a
14086
       call to what looks like a local sym is in
14087
       fact a call needing a TOC adjustment.  */
14088
0
          if ((code_sec != NULL
14089
0
         && code_sec->output_section != NULL
14090
0
         && (code_sec->has_toc_reloc
14091
0
             || code_sec->makes_toc_func_call)
14092
0
         && (htab->sec_info[code_sec->id].toc_off
14093
0
             != htab->sec_info[section->id].toc_off))
14094
0
        || (((hash ? hash->elf.other : sym->st_other)
14095
0
             & STO_PPC64_LOCAL_MASK)
14096
0
            == 1 << STO_PPC64_LOCAL_BIT))
14097
0
      {
14098
0
        stub_type.main = ppc_stub_long_branch;
14099
0
        stub_type.sub = ppc_stub_toc;
14100
0
        stub_type.r2save = 1;
14101
0
      }
14102
0
        }
14103
14104
0
      if (stub_type.main == ppc_stub_none)
14105
0
        continue;
14106
14107
      /* __tls_get_addr calls might be eliminated.  */
14108
0
      if (stub_type.main != ppc_stub_plt_call
14109
0
          && hash != NULL
14110
0
          && is_tls_get_addr (&hash->elf, htab)
14111
0
          && section->has_tls_reloc
14112
0
          && irela != internal_relocs)
14113
0
        {
14114
          /* Get tls info.  */
14115
0
          unsigned char *tls_mask;
14116
14117
0
          if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
14118
0
           irela - 1, input_bfd))
14119
0
      goto error_ret_free_internal;
14120
0
          if ((*tls_mask & TLS_TLS) != 0
14121
0
        && (*tls_mask & (TLS_GD | TLS_LD)) == 0)
14122
0
      continue;
14123
0
        }
14124
14125
0
      if (stub_type.main == ppc_stub_plt_call
14126
0
          && stub_type.sub == ppc_stub_toc)
14127
0
        {
14128
0
          if (!htab->opd_abi
14129
0
        && htab->params->plt_localentry0 != 0
14130
0
        && is_elfv2_localentry0 (&hash->elf))
14131
0
      htab->has_plt_localentry0 = 1;
14132
0
          else if (irela + 1 < irelaend
14133
0
             && irela[1].r_offset == irela->r_offset + 4
14134
0
             && (ELF64_R_TYPE (irela[1].r_info)
14135
0
           == R_PPC64_TOCSAVE))
14136
0
      {
14137
0
        if (!tocsave_find (htab, INSERT,
14138
0
               &local_syms, irela + 1, input_bfd))
14139
0
          goto error_ret_free_internal;
14140
0
      }
14141
0
          else
14142
0
      stub_type.r2save = 1;
14143
0
        }
14144
14145
      /* Support for grouping stub sections.  */
14146
0
      id_sec = htab->sec_info[section->id].u.group->link_sec;
14147
14148
      /* Get the name of this stub.  */
14149
0
      stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
14150
0
      if (!stub_name)
14151
0
        goto error_ret_free_internal;
14152
14153
0
      stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
14154
0
                 stub_name, false, false);
14155
0
      if (stub_entry != NULL)
14156
0
        {
14157
0
          free (stub_name);
14158
0
          if (!ppc_merge_stub (htab, stub_entry, stub_type, r_type))
14159
0
      {
14160
        /* xgettext:c-format */
14161
0
        _bfd_error_handler
14162
0
          (_("%pB: cannot create stub entry %s"),
14163
0
           section->owner, stub_entry->root.string);
14164
0
        goto error_ret_free_internal;
14165
0
      }
14166
0
          continue;
14167
0
        }
14168
14169
0
      stub_entry = ppc_add_stub (stub_name, section, info);
14170
0
      if (stub_entry == NULL)
14171
0
        {
14172
0
          free (stub_name);
14173
0
        error_ret_free_internal:
14174
0
          if (elf_section_data (section)->relocs == NULL)
14175
0
      free (internal_relocs);
14176
0
        error_ret_free_local:
14177
0
          if (symtab_hdr->contents
14178
0
        != (unsigned char *) local_syms)
14179
0
      free (local_syms);
14180
0
          return false;
14181
0
        }
14182
14183
0
      stub_entry->type = stub_type;
14184
0
      if (stub_type.main == ppc_stub_plt_call)
14185
0
        {
14186
0
          stub_entry->target_value = sym_value;
14187
0
          stub_entry->target_section = sym_sec;
14188
0
        }
14189
0
      else
14190
0
        {
14191
0
          stub_entry->target_value = code_value;
14192
0
          stub_entry->target_section = code_sec;
14193
0
        }
14194
0
      stub_entry->h = hash;
14195
0
      stub_entry->plt_ent = plt_ent;
14196
0
      stub_entry->symtype
14197
0
        = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
14198
0
      stub_entry->other = hash ? hash->elf.other : sym->st_other;
14199
14200
0
      if (hash != NULL
14201
0
          && (hash->elf.root.type == bfd_link_hash_defined
14202
0
        || hash->elf.root.type == bfd_link_hash_defweak))
14203
0
        htab->stub_globals += 1;
14204
0
    }
14205
14206
        /* We're done with the internal relocs, free them.  */
14207
0
        if (elf_section_data (section)->relocs != internal_relocs)
14208
0
    free (internal_relocs);
14209
0
      }
14210
14211
0
    if (local_syms != NULL
14212
0
        && symtab_hdr->contents != (unsigned char *) local_syms)
14213
0
      {
14214
0
        if (!info->keep_memory)
14215
0
    free (local_syms);
14216
0
        else
14217
0
    symtab_hdr->contents = (unsigned char *) local_syms;
14218
0
      }
14219
0
  }
14220
14221
      /* We may have added some stubs.  Find out the new size of the
14222
   stub sections.  */
14223
0
      for (group = htab->group; group != NULL; group = group->next)
14224
0
  {
14225
0
    group->lr_restore = 0;
14226
0
    group->eh_size = 0;
14227
0
    if (group->stub_sec != NULL)
14228
0
      {
14229
0
        asection *stub_sec = group->stub_sec;
14230
14231
0
        stub_sec->rawsize = stub_sec->size;
14232
0
        stub_sec->size = 0;
14233
0
        stub_sec->reloc_count = 0;
14234
0
        stub_sec->flags &= ~SEC_RELOC;
14235
0
      }
14236
0
  }
14237
0
      if (htab->tga_group != NULL)
14238
0
  {
14239
    /* See emit_tga_desc and emit_tga_desc_eh_frame.  */
14240
0
    htab->tga_group->eh_size
14241
0
      = 1 + 2 + (htab->opd_abi != 0) + 3 + 8 * 2 + 3 + 8 + 3;
14242
0
    htab->tga_group->lr_restore = 23 * 4;
14243
0
    htab->tga_group->stub_sec->size = 24 * 4;
14244
0
  }
14245
14246
0
      htab->brlt->rawsize = htab->brlt->size;
14247
0
      htab->brlt->size = 0;
14248
0
      htab->brlt->reloc_count = 0;
14249
0
      htab->brlt->flags &= ~SEC_RELOC;
14250
0
      if (htab->relbrlt != NULL)
14251
0
  htab->relbrlt->size = 0;
14252
14253
0
      if (htab->elf.srelrdyn != NULL)
14254
0
  {
14255
0
    htab->elf.srelrdyn->rawsize = htab->elf.srelrdyn->size;
14256
0
    htab->elf.srelrdyn->size = 0;
14257
0
  }
14258
14259
0
      htab->stub_changed = false;
14260
0
      htab->stub_id = 0;
14261
0
      bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
14262
14263
0
      for (group = htab->group; group != NULL; group = group->next)
14264
0
  if (group->needs_save_res)
14265
0
    group->stub_sec->size += htab->sfpr->size;
14266
14267
0
      if (info->emitrelocations
14268
0
    && htab->glink != NULL && htab->glink->size != 0)
14269
0
  {
14270
0
    htab->glink->reloc_count = 1;
14271
0
    htab->glink->flags |= SEC_RELOC;
14272
0
  }
14273
14274
0
      if (htab->glink_eh_frame != NULL
14275
0
    && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
14276
0
    && htab->glink_eh_frame->output_section->size > 8)
14277
0
  {
14278
0
    size_t size = 0, align = 4;
14279
14280
0
    for (group = htab->group; group != NULL; group = group->next)
14281
0
      if (group->eh_size != 0)
14282
0
        size += (group->eh_size + 17 + align - 1) & -align;
14283
0
    if (htab->glink != NULL && htab->glink->size != 0)
14284
0
      size += (24 + align - 1) & -align;
14285
0
    if (size != 0)
14286
0
      size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
14287
0
    align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
14288
0
    size = (size + align - 1) & -align;
14289
0
    htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
14290
0
    htab->glink_eh_frame->size = size;
14291
0
  }
14292
14293
0
      if (htab->params->plt_stub_align != 0)
14294
0
  for (group = htab->group; group != NULL; group = group->next)
14295
0
    if (group->stub_sec != NULL)
14296
0
      {
14297
0
        int align = abs (htab->params->plt_stub_align);
14298
0
        group->stub_sec->size
14299
0
    = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
14300
0
      }
14301
14302
0
      if (htab->elf.srelrdyn != NULL)
14303
0
  {
14304
0
    bfd_vma r_offset;
14305
14306
0
    for (r_offset = 0; r_offset < htab->brlt->size; r_offset += 8)
14307
0
      if (!append_relr_off (htab, htab->brlt, r_offset))
14308
0
        return false;
14309
14310
0
    if (!got_and_plt_relr_for_local_syms (info))
14311
0
      return false;
14312
0
    elf_link_hash_traverse (&htab->elf, got_and_plt_relr, info);
14313
0
    if (htab->stub_error)
14314
0
      return false;
14315
14316
0
    bfd_vma *relr_addr = sort_relr (htab);
14317
0
    if (htab->relr_count != 0 && relr_addr == NULL)
14318
0
      return false;
14319
14320
0
    size_t i = 0;
14321
0
    while (i < htab->relr_count)
14322
0
      {
14323
0
        bfd_vma base = relr_addr[i];
14324
0
        htab->elf.srelrdyn->size += 8;
14325
0
        i++;
14326
        /* Handle possible duplicate address.  This can happen
14327
     as sections increase in size when adding stubs.  */
14328
0
        while (i < htab->relr_count
14329
0
         && relr_addr[i] == base)
14330
0
    i++;
14331
0
        base += 8;
14332
0
        while (1)
14333
0
    {
14334
0
      size_t start_i = i;
14335
0
      while (i < htab->relr_count
14336
0
       && relr_addr[i] - base < 63 * 8
14337
0
       && (relr_addr[i] - base) % 8 == 0)
14338
0
        i++;
14339
0
      if (i == start_i)
14340
0
        break;
14341
0
      htab->elf.srelrdyn->size += 8;
14342
0
      base += 63 * 8;
14343
0
    }
14344
0
      }
14345
0
    free (relr_addr);
14346
0
  }
14347
14348
0
      for (group = htab->group; group != NULL; group = group->next)
14349
0
  if (group->stub_sec != NULL
14350
0
      && group->stub_sec->rawsize != group->stub_sec->size
14351
0
      && (htab->stub_iteration <= STUB_SHRINK_ITER
14352
0
    || group->stub_sec->rawsize < group->stub_sec->size))
14353
0
    break;
14354
14355
0
      if (group == NULL
14356
0
    && (!htab->stub_changed
14357
0
        || htab->stub_iteration > STUB_SHRINK_ITER)
14358
0
    && (htab->brlt->rawsize == htab->brlt->size
14359
0
        || (htab->stub_iteration > STUB_SHRINK_ITER
14360
0
      && htab->brlt->rawsize > htab->brlt->size))
14361
0
    && (htab->elf.srelrdyn == NULL
14362
0
        || htab->elf.srelrdyn->rawsize == htab->elf.srelrdyn->size
14363
0
        || (htab->stub_iteration > STUB_SHRINK_ITER
14364
0
      && htab->elf.srelrdyn->rawsize > htab->elf.srelrdyn->size))
14365
0
    && (htab->glink_eh_frame == NULL
14366
0
        || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size)
14367
0
    && (htab->tga_group == NULL
14368
0
        || htab->stub_iteration > 1))
14369
0
  break;
14370
14371
0
      if (htab->stub_iteration > STUB_SHRINK_ITER)
14372
0
  {
14373
0
    for (group = htab->group; group != NULL; group = group->next)
14374
0
      if (group->stub_sec != NULL
14375
0
    && group->stub_sec->size < group->stub_sec->rawsize)
14376
0
        group->stub_sec->size = group->stub_sec->rawsize;
14377
14378
0
    if (htab->brlt->size < htab->brlt->rawsize)
14379
0
      htab->brlt->size = htab->brlt->rawsize;
14380
14381
0
    if (htab->elf.srelrdyn != NULL
14382
0
        && htab->elf.srelrdyn->size < htab->elf.srelrdyn->rawsize)
14383
0
      htab->elf.srelrdyn->size = htab->elf.srelrdyn->rawsize;
14384
0
  }
14385
14386
      /* Ask the linker to do its stuff.  */
14387
0
      (*htab->params->layout_sections_again) ();
14388
0
    }
14389
14390
0
  if (htab->glink_eh_frame != NULL
14391
0
      && htab->glink_eh_frame->size != 0)
14392
0
    {
14393
0
      bfd_vma val;
14394
0
      bfd_byte *p, *last_fde;
14395
0
      size_t last_fde_len, size, align, pad;
14396
0
      struct map_stub *group;
14397
14398
      /* It is necessary to at least have a rough outline of the
14399
   linker generated CIEs and FDEs written before
14400
   bfd_elf_discard_info is run, in order for these FDEs to be
14401
   indexed in .eh_frame_hdr.  */
14402
0
      p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
14403
0
      if (p == NULL)
14404
0
  return false;
14405
0
      htab->glink_eh_frame->contents = p;
14406
0
      last_fde = p;
14407
0
      align = 4;
14408
14409
0
      memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
14410
      /* CIE length (rewrite in case little-endian).  */
14411
0
      last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
14412
0
      bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
14413
0
      p += last_fde_len + 4;
14414
14415
0
      for (group = htab->group; group != NULL; group = group->next)
14416
0
  if (group->eh_size != 0)
14417
0
    {
14418
0
      group->eh_base = p - htab->glink_eh_frame->contents;
14419
0
      last_fde = p;
14420
0
      last_fde_len = ((group->eh_size + 17 + align - 1) & -align) - 4;
14421
      /* FDE length.  */
14422
0
      bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
14423
0
      p += 4;
14424
      /* CIE pointer.  */
14425
0
      val = p - htab->glink_eh_frame->contents;
14426
0
      bfd_put_32 (htab->elf.dynobj, val, p);
14427
0
      p += 4;
14428
      /* Offset to stub section, written later.  */
14429
0
      p += 4;
14430
      /* stub section size.  */
14431
0
      bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
14432
0
      p += 4;
14433
      /* Augmentation.  */
14434
0
      p += 1;
14435
      /* Make sure we don't have all nops.  This is enough for
14436
         elf-eh-frame.c to detect the last non-nop opcode.  */
14437
0
      p[group->eh_size - 1] = DW_CFA_advance_loc + 1;
14438
0
      p = last_fde + last_fde_len + 4;
14439
0
    }
14440
0
      if (htab->glink != NULL && htab->glink->size != 0)
14441
0
  {
14442
0
    last_fde = p;
14443
0
    last_fde_len = ((24 + align - 1) & -align) - 4;
14444
    /* FDE length.  */
14445
0
    bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
14446
0
    p += 4;
14447
    /* CIE pointer.  */
14448
0
    val = p - htab->glink_eh_frame->contents;
14449
0
    bfd_put_32 (htab->elf.dynobj, val, p);
14450
0
    p += 4;
14451
    /* Offset to .glink, written later.  */
14452
0
    p += 4;
14453
    /* .glink size.  */
14454
0
    bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
14455
0
    p += 4;
14456
    /* Augmentation.  */
14457
0
    p += 1;
14458
14459
0
    *p++ = DW_CFA_advance_loc + (htab->has_plt_localentry0 ? 3 : 2);
14460
0
    *p++ = DW_CFA_register;
14461
0
    *p++ = 65;
14462
0
    *p++ = htab->opd_abi ? 12 : 0;
14463
0
    *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 4 : 2);
14464
0
    *p++ = DW_CFA_restore_extended;
14465
0
    *p++ = 65;
14466
0
    p += ((24 + align - 1) & -align) - 24;
14467
0
  }
14468
      /* Subsume any padding into the last FDE if user .eh_frame
14469
   sections are aligned more than glink_eh_frame.  Otherwise any
14470
   zero padding will be seen as a terminator.  */
14471
0
      align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
14472
0
      size = p - htab->glink_eh_frame->contents;
14473
0
      pad = ((size + align - 1) & -align) - size;
14474
0
      htab->glink_eh_frame->size = size + pad;
14475
0
      bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
14476
0
    }
14477
14478
0
  maybe_strip_output (info, htab->brlt);
14479
0
  if (htab->relbrlt != NULL)
14480
0
    maybe_strip_output (info, htab->relbrlt);
14481
0
  if (htab->glink_eh_frame != NULL)
14482
0
    maybe_strip_output (info, htab->glink_eh_frame);
14483
0
  if (htab->elf.srelrdyn != NULL)
14484
0
    maybe_strip_output (info, htab->elf.srelrdyn);
14485
14486
0
  return true;
14487
0
}
14488
14489
/* Called after we have determined section placement.  If sections
14490
   move, we'll be called again.  Provide a value for TOCstart.  */
14491
14492
bfd_vma
14493
ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
14494
9
{
14495
9
  asection *s;
14496
9
  bfd_vma TOCstart, adjust;
14497
14498
9
  if (info != NULL)
14499
0
    {
14500
0
      struct elf_link_hash_entry *h;
14501
0
      struct elf_link_hash_table *htab = elf_hash_table (info);
14502
14503
0
      if (is_elf_hash_table (&htab->root)
14504
0
    && htab->hgot != NULL)
14505
0
  h = htab->hgot;
14506
0
      else
14507
0
  {
14508
0
    h = (struct elf_link_hash_entry *)
14509
0
      bfd_link_hash_lookup (&htab->root, ".TOC.", false, false, true);
14510
0
    if (is_elf_hash_table (&htab->root))
14511
0
      htab->hgot = h;
14512
0
  }
14513
0
      if (h != NULL
14514
0
    && h->root.type == bfd_link_hash_defined
14515
0
    && !h->root.linker_def
14516
0
    && (!is_elf_hash_table (&htab->root)
14517
0
        || h->def_regular))
14518
0
  {
14519
0
    TOCstart = defined_sym_val (h) - TOC_BASE_OFF;
14520
0
    _bfd_set_gp_value (obfd, TOCstart);
14521
0
    return TOCstart;
14522
0
  }
14523
0
    }
14524
14525
  /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
14526
     order.  The TOC starts where the first of these sections starts.  */
14527
9
  s = bfd_get_section_by_name (obfd, ".got");
14528
9
  if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
14529
9
    s = bfd_get_section_by_name (obfd, ".toc");
14530
9
  if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
14531
9
    s = bfd_get_section_by_name (obfd, ".tocbss");
14532
9
  if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
14533
9
    s = bfd_get_section_by_name (obfd, ".plt");
14534
9
  if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
14535
9
    {
14536
      /* This may happen for
14537
   o  references to TOC base (SYM@toc / TOC[tc0]) without a
14538
   .toc directive
14539
   o  bad linker script
14540
   o --gc-sections and empty TOC sections
14541
14542
   FIXME: Warn user?  */
14543
14544
      /* Look for a likely section.  We probably won't even be
14545
   using TOCstart.  */
14546
189
      for (s = obfd->sections; s != NULL; s = s->next)
14547
180
  if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
14548
180
       | SEC_EXCLUDE))
14549
180
      == (SEC_ALLOC | SEC_SMALL_DATA))
14550
0
    break;
14551
9
      if (s == NULL)
14552
189
  for (s = obfd->sections; s != NULL; s = s->next)
14553
180
    if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
14554
180
        == (SEC_ALLOC | SEC_SMALL_DATA))
14555
0
      break;
14556
9
      if (s == NULL)
14557
9
  for (s = obfd->sections; s != NULL; s = s->next)
14558
9
    if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
14559
9
        == SEC_ALLOC)
14560
9
      break;
14561
9
      if (s == NULL)
14562
0
  for (s = obfd->sections; s != NULL; s = s->next)
14563
0
    if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
14564
0
      break;
14565
9
    }
14566
14567
9
  TOCstart = 0;
14568
9
  if (s != NULL)
14569
9
    TOCstart = s->output_section->vma + s->output_offset;
14570
14571
  /* Force alignment.  */
14572
9
  adjust = TOCstart & (TOC_BASE_ALIGN - 1);
14573
9
  TOCstart -= adjust;
14574
9
  _bfd_set_gp_value (obfd, TOCstart);
14575
14576
9
  if (info != NULL && s != NULL)
14577
0
    {
14578
0
      struct ppc_link_hash_table *htab = ppc_hash_table (info);
14579
14580
0
      if (htab != NULL)
14581
0
  {
14582
0
    if (htab->elf.hgot != NULL)
14583
0
      {
14584
0
        htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
14585
0
        htab->elf.hgot->root.u.def.section = s;
14586
0
      }
14587
0
  }
14588
0
      else
14589
0
  {
14590
0
    struct bfd_link_hash_entry *bh = NULL;
14591
0
    _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
14592
0
              s, TOC_BASE_OFF - adjust,
14593
0
              NULL, false, false, &bh);
14594
0
  }
14595
0
    }
14596
9
  return TOCstart;
14597
9
}
14598
14599
/* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
14600
   write out any global entry stubs, and PLT relocations.  */
14601
14602
static bool
14603
build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
14604
0
{
14605
0
  struct bfd_link_info *info;
14606
0
  struct ppc_link_hash_table *htab;
14607
0
  struct plt_entry *ent;
14608
0
  asection *s;
14609
14610
0
  if (h->root.type == bfd_link_hash_indirect)
14611
0
    return true;
14612
14613
0
  info = inf;
14614
0
  htab = ppc_hash_table (info);
14615
0
  if (htab == NULL)
14616
0
    return false;
14617
14618
0
  for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14619
0
    if (ent->plt.offset != (bfd_vma) -1)
14620
0
      {
14621
  /* This symbol has an entry in the procedure linkage
14622
     table.  Set it up.  */
14623
0
  Elf_Internal_Rela rela;
14624
0
  asection *plt, *relplt;
14625
0
  bfd_byte *loc;
14626
14627
0
  if (use_local_plt (info, h))
14628
0
    {
14629
0
      if (!(h->def_regular
14630
0
      && (h->root.type == bfd_link_hash_defined
14631
0
          || h->root.type == bfd_link_hash_defweak)))
14632
0
        continue;
14633
0
      if (h->type == STT_GNU_IFUNC)
14634
0
        {
14635
0
    plt = htab->elf.iplt;
14636
0
    relplt = htab->elf.irelplt;
14637
0
    htab->elf.ifunc_resolvers = true;
14638
0
    if (htab->opd_abi)
14639
0
      rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14640
0
    else
14641
0
      rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14642
0
        }
14643
0
      else
14644
0
        {
14645
0
    plt = htab->pltlocal;
14646
0
    relplt = NULL;
14647
0
    if (bfd_link_pic (info)
14648
0
        && !(info->enable_dt_relr && !htab->opd_abi))
14649
0
      {
14650
0
        relplt = htab->relpltlocal;
14651
0
        if (htab->opd_abi)
14652
0
          rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
14653
0
        else
14654
0
          rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14655
0
      }
14656
0
        }
14657
0
      rela.r_addend = defined_sym_val (h) + ent->addend;
14658
14659
0
      if (relplt == NULL)
14660
0
        {
14661
0
    loc = plt->contents + ent->plt.offset;
14662
0
    bfd_put_64 (info->output_bfd, rela.r_addend, loc);
14663
0
    if (htab->opd_abi)
14664
0
      {
14665
0
        bfd_vma toc = elf_gp (info->output_bfd);
14666
0
        toc += htab->sec_info[h->root.u.def.section->id].toc_off;
14667
0
        bfd_put_64 (info->output_bfd, toc, loc + 8);
14668
0
      }
14669
0
        }
14670
0
      else
14671
0
        {
14672
0
    rela.r_offset = (plt->output_section->vma
14673
0
         + plt->output_offset
14674
0
         + ent->plt.offset);
14675
0
    BFD_ASSERT (count_and_swap_reloc_out (info->output_bfd, &rela,
14676
0
                  relplt));
14677
0
        }
14678
0
    }
14679
0
  else
14680
0
    {
14681
0
      rela.r_offset = (htab->elf.splt->output_section->vma
14682
0
           + htab->elf.splt->output_offset
14683
0
           + ent->plt.offset);
14684
0
      rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14685
0
      rela.r_addend = ent->addend;
14686
0
      loc = (htab->elf.srelplt->contents
14687
0
       + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14688
0
          / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14689
0
      if (h->type == STT_GNU_IFUNC && is_static_defined (h))
14690
0
        htab->elf.ifunc_resolvers = true;
14691
0
      BFD_ASSERT (swap_reloc_out (info->output_bfd, &rela,
14692
0
          loc, htab->elf.srelplt));
14693
0
    }
14694
0
      }
14695
14696
0
  if (!h->pointer_equality_needed)
14697
0
    return true;
14698
14699
0
  if (h->def_regular)
14700
0
    return true;
14701
14702
0
  s = htab->global_entry;
14703
0
  if (s == NULL || s->size == 0)
14704
0
    return true;
14705
14706
0
  for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14707
0
    if (ent->plt.offset != (bfd_vma) -1
14708
0
  && ent->addend == 0)
14709
0
      {
14710
0
  bfd_byte *p;
14711
0
  asection *plt;
14712
0
  bfd_vma off;
14713
14714
0
  p = s->contents + h->root.u.def.value;
14715
0
  plt = htab->elf.splt;
14716
0
  if (use_local_plt (info, h))
14717
0
    {
14718
0
      if (h->type == STT_GNU_IFUNC)
14719
0
        plt = htab->elf.iplt;
14720
0
      else
14721
0
        plt = htab->pltlocal;
14722
0
    }
14723
0
  off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
14724
0
  off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
14725
14726
0
  if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
14727
0
    {
14728
0
      info->callbacks->einfo
14729
0
        (_("%P: linkage table error against `%pT'\n"),
14730
0
         h->root.root.string);
14731
0
      bfd_set_error (bfd_error_bad_value);
14732
0
      htab->stub_error = true;
14733
0
    }
14734
14735
0
  htab->stub_count[ppc_stub_global_entry - 1] += 1;
14736
0
  if (htab->params->emit_stub_syms)
14737
0
    {
14738
0
      size_t len = strlen (h->root.root.string);
14739
0
      char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
14740
14741
0
      if (name == NULL)
14742
0
        return false;
14743
14744
0
      sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
14745
0
      h = elf_link_hash_lookup (&htab->elf, name, true, false, false);
14746
0
      if (h == NULL)
14747
0
        return false;
14748
0
      if (h->root.type == bfd_link_hash_new)
14749
0
        {
14750
0
    h->root.type = bfd_link_hash_defined;
14751
0
    h->root.u.def.section = s;
14752
0
    h->root.u.def.value = p - s->contents;
14753
0
    h->ref_regular = 1;
14754
0
    h->def_regular = 1;
14755
0
    h->ref_regular_nonweak = 1;
14756
0
    h->forced_local = 1;
14757
0
    h->non_elf = 0;
14758
0
    h->root.linker_def = 1;
14759
0
        }
14760
0
    }
14761
14762
0
  if (PPC_HA (off) != 0)
14763
0
    {
14764
0
      bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
14765
0
      p += 4;
14766
0
    }
14767
0
  bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
14768
0
  p += 4;
14769
0
  bfd_put_32 (s->owner, MTCTR_R12, p);
14770
0
  p += 4;
14771
0
  bfd_put_32 (s->owner, BCTR, p);
14772
0
  break;
14773
0
      }
14774
0
  return true;
14775
0
}
14776
14777
/* Write PLT relocs for locals.  */
14778
14779
static bool
14780
write_plt_relocs_for_local_syms (struct bfd_link_info *info)
14781
0
{
14782
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
14783
0
  bfd *ibfd;
14784
14785
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
14786
0
    {
14787
0
      struct got_entry **lgot_ents, **end_lgot_ents;
14788
0
      struct plt_entry **local_plt, **lplt, **end_local_plt;
14789
0
      Elf_Internal_Shdr *symtab_hdr;
14790
0
      bfd_size_type locsymcount;
14791
0
      Elf_Internal_Sym *local_syms = NULL;
14792
0
      struct plt_entry *ent;
14793
14794
0
      if (!is_ppc64_elf (ibfd))
14795
0
  continue;
14796
14797
0
      lgot_ents = elf_local_got_ents (ibfd);
14798
0
      if (!lgot_ents)
14799
0
  continue;
14800
14801
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
14802
0
      locsymcount = symtab_hdr->sh_info;
14803
0
      end_lgot_ents = lgot_ents + locsymcount;
14804
0
      local_plt = (struct plt_entry **) end_lgot_ents;
14805
0
      end_local_plt = local_plt + locsymcount;
14806
0
      for (lplt = local_plt; lplt < end_local_plt; ++lplt)
14807
0
  for (ent = *lplt; ent != NULL; ent = ent->next)
14808
0
    if (ent->plt.offset != (bfd_vma) -1)
14809
0
      {
14810
0
        Elf_Internal_Sym *sym;
14811
0
        asection *sym_sec;
14812
0
        asection *plt, *relplt;
14813
0
        bfd_vma val;
14814
14815
0
        if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
14816
0
            lplt - local_plt, ibfd))
14817
0
    {
14818
0
      if (symtab_hdr->contents != (unsigned char *) local_syms)
14819
0
        free (local_syms);
14820
0
      return false;
14821
0
    }
14822
14823
0
        val = sym->st_value + ent->addend;
14824
0
        if (sym_sec != NULL && sym_sec->output_section != NULL)
14825
0
    val += sym_sec->output_offset + sym_sec->output_section->vma;
14826
14827
0
        if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14828
0
    {
14829
0
      htab->elf.ifunc_resolvers = true;
14830
0
      plt = htab->elf.iplt;
14831
0
      relplt = htab->elf.irelplt;
14832
0
    }
14833
0
        else
14834
0
    {
14835
0
      plt = htab->pltlocal;
14836
0
      relplt = NULL;
14837
0
      if (bfd_link_pic (info)
14838
0
          && !(info->enable_dt_relr && !htab->opd_abi))
14839
0
        relplt = htab->relpltlocal;
14840
0
    }
14841
14842
0
        if (relplt == NULL)
14843
0
    {
14844
0
      bfd_byte *loc = plt->contents + ent->plt.offset;
14845
0
      bfd_put_64 (info->output_bfd, val, loc);
14846
0
      if (htab->opd_abi)
14847
0
        {
14848
0
          bfd_vma toc = elf_gp (ibfd);
14849
0
          bfd_put_64 (info->output_bfd, toc, loc + 8);
14850
0
        }
14851
0
    }
14852
0
        else
14853
0
    {
14854
0
      Elf_Internal_Rela rela;
14855
0
      rela.r_offset = (ent->plt.offset
14856
0
           + plt->output_offset
14857
0
           + plt->output_section->vma);
14858
0
      if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14859
0
        {
14860
0
          if (htab->opd_abi)
14861
0
      rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14862
0
          else
14863
0
      rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14864
0
        }
14865
0
      else
14866
0
        {
14867
0
          if (htab->opd_abi)
14868
0
      rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
14869
0
          else
14870
0
      rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14871
0
        }
14872
0
      rela.r_addend = val;
14873
0
      BFD_ASSERT (count_and_swap_reloc_out (info->output_bfd,
14874
0
               &rela, relplt));
14875
0
    }
14876
0
      }
14877
14878
0
      if (local_syms != NULL
14879
0
    && symtab_hdr->contents != (unsigned char *) local_syms)
14880
0
  {
14881
0
    if (!info->keep_memory)
14882
0
      free (local_syms);
14883
0
    else
14884
0
      symtab_hdr->contents = (unsigned char *) local_syms;
14885
0
  }
14886
0
    }
14887
0
  return true;
14888
0
}
14889
14890
/* Emit the static wrapper function preserving registers around a
14891
   __tls_get_addr_opt call.  */
14892
14893
static bool
14894
emit_tga_desc (struct ppc_link_hash_table *htab)
14895
0
{
14896
0
  asection *stub_sec = htab->tga_group->stub_sec;
14897
0
  unsigned int cfa_updt = 11 * 4;
14898
0
  bfd_byte *p;
14899
0
  bfd_vma to, from, delta;
14900
14901
0
  BFD_ASSERT (htab->tga_desc_fd->elf.root.type == bfd_link_hash_defined
14902
0
        && htab->tga_desc_fd->elf.root.u.def.section == stub_sec
14903
0
        && htab->tga_desc_fd->elf.root.u.def.value == 0);
14904
0
  to = defined_sym_val (&htab->tls_get_addr_fd->elf);
14905
0
  from = defined_sym_val (&htab->tga_desc_fd->elf) + cfa_updt;
14906
0
  delta = to - from;
14907
0
  if (delta + (1 << 25) >= 1 << 26)
14908
0
    {
14909
0
      _bfd_error_handler (_("__tls_get_addr call offset overflow"));
14910
0
      htab->stub_error = true;
14911
0
      return false;
14912
0
    }
14913
14914
0
  p = stub_sec->contents;
14915
0
  p = tls_get_addr_prologue (htab->elf.dynobj, p, htab);
14916
0
  bfd_put_32 (stub_sec->owner, B_DOT | 1 | (delta & 0x3fffffc), p);
14917
0
  p += 4;
14918
0
  p = tls_get_addr_epilogue (htab->elf.dynobj, p, htab);
14919
0
  return stub_sec->size == (bfd_size_type) (p - stub_sec->contents);
14920
0
}
14921
14922
/* Emit eh_frame describing the static wrapper function.  */
14923
14924
static bfd_byte *
14925
emit_tga_desc_eh_frame (struct ppc_link_hash_table *htab, bfd_byte *p)
14926
0
{
14927
0
  unsigned int cfa_updt = 11 * 4;
14928
0
  unsigned int i;
14929
14930
0
  *p++ = DW_CFA_advance_loc + cfa_updt / 4;
14931
0
  *p++ = DW_CFA_def_cfa_offset;
14932
0
  if (htab->opd_abi)
14933
0
    {
14934
0
      *p++ = 128;
14935
0
      *p++ = 1;
14936
0
    }
14937
0
  else
14938
0
    *p++ = 96;
14939
0
  *p++ = DW_CFA_offset_extended_sf;
14940
0
  *p++ = 65;
14941
0
  *p++ = (-16 / 8) & 0x7f;
14942
0
  for (i = 4; i < 12; i++)
14943
0
    {
14944
0
      *p++ = DW_CFA_offset + i;
14945
0
      *p++ = (htab->opd_abi ? 13 : 12) - i;
14946
0
    }
14947
0
  *p++ = DW_CFA_advance_loc + 10;
14948
0
  *p++ = DW_CFA_def_cfa_offset;
14949
0
  *p++ = 0;
14950
0
  for (i = 4; i < 12; i++)
14951
0
    *p++ = DW_CFA_restore + i;
14952
0
  *p++ = DW_CFA_advance_loc + 2;
14953
0
  *p++ = DW_CFA_restore_extended;
14954
0
  *p++ = 65;
14955
0
  return p;
14956
0
}
14957
14958
/* Build all the stubs associated with the current output file.
14959
   The stubs are kept in a hash table attached to the main linker
14960
   hash table.  This function is called via gldelf64ppc_finish.  */
14961
14962
bool
14963
ppc64_elf_build_stubs (struct bfd_link_info *info,
14964
           char **stats)
14965
0
{
14966
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
14967
0
  struct map_stub *group;
14968
0
  asection *stub_sec;
14969
0
  bfd_byte *p;
14970
0
  int stub_sec_count = 0;
14971
14972
0
  if (htab == NULL)
14973
0
    return false;
14974
14975
  /* Allocate memory to hold the linker stubs.  */
14976
0
  for (group = htab->group; group != NULL; group = group->next)
14977
0
    {
14978
0
      group->eh_size = 0;
14979
0
      group->lr_restore = 0;
14980
0
      if ((stub_sec = group->stub_sec) != NULL
14981
0
    && stub_sec->size != 0)
14982
0
  {
14983
0
    stub_sec->contents = bfd_zalloc (htab->params->stub_bfd,
14984
0
             stub_sec->size);
14985
0
    if (stub_sec->contents == NULL)
14986
0
      return false;
14987
0
    stub_sec->size = 0;
14988
0
  }
14989
0
    }
14990
14991
0
  if (htab->glink != NULL && htab->glink->size != 0)
14992
0
    {
14993
0
      unsigned int indx;
14994
0
      bfd_vma plt0;
14995
14996
      /* Build the .glink plt call stub.  */
14997
0
      if (htab->params->emit_stub_syms)
14998
0
  {
14999
0
    struct elf_link_hash_entry *h;
15000
0
    h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
15001
0
            true, false, false);
15002
0
    if (h == NULL)
15003
0
      return false;
15004
0
    if (h->root.type == bfd_link_hash_new)
15005
0
      {
15006
0
        h->root.type = bfd_link_hash_defined;
15007
0
        h->root.u.def.section = htab->glink;
15008
0
        h->root.u.def.value = 8;
15009
0
        h->ref_regular = 1;
15010
0
        h->def_regular = 1;
15011
0
        h->ref_regular_nonweak = 1;
15012
0
        h->forced_local = 1;
15013
0
        h->non_elf = 0;
15014
0
        h->root.linker_def = 1;
15015
0
      }
15016
0
  }
15017
0
      plt0 = (htab->elf.splt->output_section->vma
15018
0
        + htab->elf.splt->output_offset
15019
0
        - 16);
15020
0
      if (info->emitrelocations)
15021
0
  {
15022
0
    Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
15023
0
    if (r == NULL)
15024
0
      return false;
15025
0
    r->r_offset = (htab->glink->output_offset
15026
0
       + htab->glink->output_section->vma);
15027
0
    r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
15028
0
    r->r_addend = plt0;
15029
0
  }
15030
0
      p = htab->glink->contents;
15031
0
      plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
15032
0
      bfd_put_64 (htab->glink->owner, plt0, p);
15033
0
      p += 8;
15034
0
      if (htab->opd_abi)
15035
0
  {
15036
0
    bfd_put_32 (htab->glink->owner, MFLR_R12, p);
15037
0
    p += 4;
15038
0
    bfd_put_32 (htab->glink->owner, BCL_20_31, p);
15039
0
    p += 4;
15040
0
    bfd_put_32 (htab->glink->owner, MFLR_R11, p);
15041
0
    p += 4;
15042
0
    bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
15043
0
    p += 4;
15044
0
    bfd_put_32 (htab->glink->owner, MTLR_R12, p);
15045
0
    p += 4;
15046
0
    bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
15047
0
    p += 4;
15048
0
    bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
15049
0
    p += 4;
15050
0
    bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
15051
0
    p += 4;
15052
0
    bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
15053
0
    p += 4;
15054
0
    bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
15055
0
    p += 4;
15056
0
  }
15057
0
      else
15058
0
  {
15059
0
    unsigned int insn;
15060
15061
    /* 0:
15062
       .  .quad plt0-1f   # plt0 entry relative to 1:
15063
       #
15064
       # We get here with r12 initially @ a glink branch
15065
       # Load the address of _dl_runtime_resolve from plt0 and
15066
       # jump to it, with r0 set to the index of the PLT entry
15067
       # to be resolved and r11 the link map.
15068
       __glink_PLTresolve:
15069
       .  std %r2,24(%r1)   # optional
15070
       .  mflr %r0
15071
       .  bcl 20,31,1f
15072
       1:
15073
       .  mflr %r11
15074
       .  mtlr %r0
15075
       .  ld %r0,(0b-1b)(%r11)
15076
       .  sub %r12,%r12,%r11
15077
       .  add %r11,%r0,%r11
15078
       .  addi %r0,%r12,1b-2f
15079
       .  ld %r12,0(%r11)
15080
       .  srdi %r0,%r0,2
15081
       .  mtctr %r12
15082
       .  ld %r11,8(%r11)
15083
       .  bctr
15084
       2:
15085
       .  b __glink_PLTresolve
15086
       .  ...
15087
       .  b __glink_PLTresolve  */
15088
15089
0
    if (htab->has_plt_localentry0)
15090
0
      {
15091
0
        bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
15092
0
        p += 4;
15093
0
      }
15094
0
    bfd_put_32 (htab->glink->owner, MFLR_R0, p);
15095
0
    p += 4;
15096
0
    bfd_put_32 (htab->glink->owner, BCL_20_31, p);
15097
0
    p += 4;
15098
0
    bfd_put_32 (htab->glink->owner, MFLR_R11, p);
15099
0
    p += 4;
15100
0
    bfd_put_32 (htab->glink->owner, MTLR_R0, p);
15101
0
    p += 4;
15102
0
    if (htab->has_plt_localentry0)
15103
0
      insn = LD_R0_0R11 | (-20 & 0xfffc);
15104
0
    else
15105
0
      insn = LD_R0_0R11 | (-16 & 0xfffc);
15106
0
    bfd_put_32 (htab->glink->owner, insn, p);
15107
0
    p += 4;
15108
0
    bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
15109
0
    p += 4;
15110
0
    bfd_put_32 (htab->glink->owner, ADD_R11_R0_R11, p);
15111
0
    p += 4;
15112
0
    bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-44 & 0xffff), p);
15113
0
    p += 4;
15114
0
    bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
15115
0
    p += 4;
15116
0
    bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
15117
0
    p += 4;
15118
0
    bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
15119
0
    p += 4;
15120
0
    bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
15121
0
    p += 4;
15122
0
  }
15123
0
      bfd_put_32 (htab->glink->owner, BCTR, p);
15124
0
      p += 4;
15125
0
      BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
15126
15127
      /* Build the .glink lazy link call stubs.  */
15128
0
      indx = 0;
15129
0
      while (p < htab->glink->contents + htab->glink->size)
15130
0
  {
15131
0
    if (htab->opd_abi)
15132
0
      {
15133
0
        if (indx < 0x8000)
15134
0
    {
15135
0
      bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
15136
0
      p += 4;
15137
0
    }
15138
0
        else
15139
0
    {
15140
0
      bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
15141
0
      p += 4;
15142
0
      bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
15143
0
            p);
15144
0
      p += 4;
15145
0
    }
15146
0
      }
15147
0
    bfd_put_32 (htab->glink->owner,
15148
0
          B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
15149
0
    indx++;
15150
0
    p += 4;
15151
0
  }
15152
0
    }
15153
15154
0
  if (htab->tga_group != NULL)
15155
0
    {
15156
0
      htab->tga_group->lr_restore = 23 * 4;
15157
0
      htab->tga_group->stub_sec->size = 24 * 4;
15158
0
      if (!emit_tga_desc (htab))
15159
0
  return false;
15160
0
      if (htab->glink_eh_frame != NULL
15161
0
    && htab->glink_eh_frame->size != 0)
15162
0
  {
15163
0
    size_t align = 4;
15164
15165
0
    p = htab->glink_eh_frame->contents;
15166
0
    p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15167
0
    p += 17;
15168
0
    htab->tga_group->eh_size = emit_tga_desc_eh_frame (htab, p) - p;
15169
0
  }
15170
0
    }
15171
15172
  /* Build .glink global entry stubs, and PLT relocs for globals.  */
15173
0
  elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
15174
15175
0
  if (!write_plt_relocs_for_local_syms (info))
15176
0
    return false;
15177
15178
0
  if (htab->brlt != NULL && htab->brlt->size != 0)
15179
0
    {
15180
0
      htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
15181
0
           htab->brlt->size);
15182
0
      if (htab->brlt->contents == NULL)
15183
0
  return false;
15184
0
    }
15185
0
  if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
15186
0
    {
15187
0
      htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
15188
0
              htab->relbrlt->size);
15189
0
      if (htab->relbrlt->contents == NULL)
15190
0
  return false;
15191
0
    }
15192
15193
  /* Build the stubs as directed by the stub hash table.  */
15194
0
  htab->stub_id = 0;
15195
0
  bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
15196
15197
0
  for (group = htab->group; group != NULL; group = group->next)
15198
0
    if (group->needs_save_res)
15199
0
      group->stub_sec->size += htab->sfpr->size;
15200
15201
0
  if (htab->relbrlt != NULL)
15202
0
    htab->relbrlt->reloc_count = 0;
15203
15204
0
  if (htab->params->plt_stub_align != 0)
15205
0
    for (group = htab->group; group != NULL; group = group->next)
15206
0
      if ((stub_sec = group->stub_sec) != NULL)
15207
0
  {
15208
0
    int align = abs (htab->params->plt_stub_align);
15209
0
    stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
15210
0
  }
15211
15212
0
  for (group = htab->group; group != NULL; group = group->next)
15213
0
    if (group->needs_save_res)
15214
0
      {
15215
0
  stub_sec = group->stub_sec;
15216
0
  memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
15217
0
    htab->sfpr->contents, htab->sfpr->size);
15218
0
  if (htab->params->emit_stub_syms)
15219
0
    {
15220
0
      unsigned int i;
15221
15222
0
      for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
15223
0
        if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
15224
0
    return false;
15225
0
    }
15226
0
      }
15227
15228
0
  if (htab->glink_eh_frame != NULL
15229
0
      && htab->glink_eh_frame->size != 0)
15230
0
    {
15231
0
      bfd_vma val;
15232
0
      size_t align = 4;
15233
15234
0
      p = htab->glink_eh_frame->contents;
15235
0
      p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15236
15237
0
      for (group = htab->group; group != NULL; group = group->next)
15238
0
  if (group->eh_size != 0)
15239
0
    {
15240
      /* Offset to stub section.  */
15241
0
      val = (group->stub_sec->output_section->vma
15242
0
       + group->stub_sec->output_offset);
15243
0
      val -= (htab->glink_eh_frame->output_section->vma
15244
0
        + htab->glink_eh_frame->output_offset
15245
0
        + (p + 8 - htab->glink_eh_frame->contents));
15246
0
      if (val + 0x80000000 > 0xffffffff)
15247
0
        {
15248
0
    _bfd_error_handler
15249
0
      (_("%s offset too large for .eh_frame sdata4 encoding"),
15250
0
       group->stub_sec->name);
15251
0
    return false;
15252
0
        }
15253
0
      bfd_put_32 (htab->elf.dynobj, val, p + 8);
15254
0
      p += (group->eh_size + 17 + 3) & -4;
15255
0
    }
15256
0
      if (htab->glink != NULL && htab->glink->size != 0)
15257
0
  {
15258
    /* Offset to .glink.  */
15259
0
    val = (htab->glink->output_section->vma
15260
0
     + htab->glink->output_offset
15261
0
     + 8);
15262
0
    val -= (htab->glink_eh_frame->output_section->vma
15263
0
      + htab->glink_eh_frame->output_offset
15264
0
      + (p + 8 - htab->glink_eh_frame->contents));
15265
0
    if (val + 0x80000000 > 0xffffffff)
15266
0
      {
15267
0
        _bfd_error_handler
15268
0
    (_("%s offset too large for .eh_frame sdata4 encoding"),
15269
0
     htab->glink->name);
15270
0
        return false;
15271
0
      }
15272
0
    bfd_put_32 (htab->elf.dynobj, val, p + 8);
15273
0
    p += (24 + align - 1) & -align;
15274
0
  }
15275
0
    }
15276
15277
0
  if (htab->elf.srelrdyn != NULL && htab->elf.srelrdyn->size != 0)
15278
0
    {
15279
0
      htab->elf.srelrdyn->contents
15280
0
  = bfd_alloc (htab->elf.dynobj, htab->elf.srelrdyn->size);
15281
0
      if (htab->elf.srelrdyn->contents == NULL)
15282
0
  return false;
15283
15284
0
      bfd_vma *relr_addr = sort_relr (htab);
15285
0
      if (htab->relr_count != 0 && relr_addr == NULL)
15286
0
  return false;
15287
15288
0
      size_t i = 0;
15289
0
      bfd_byte *loc = htab->elf.srelrdyn->contents;
15290
0
      while (i < htab->relr_count)
15291
0
  {
15292
0
    bfd_vma base = relr_addr[i];
15293
0
    BFD_ASSERT ((base & ((1 << RELR_ALIGN) - 1)) == 0);
15294
0
    bfd_put_64 (htab->elf.dynobj, base, loc);
15295
0
    loc += 8;
15296
0
    i++;
15297
0
    while (i < htab->relr_count
15298
0
     && relr_addr[i] == base)
15299
0
      {
15300
0
        htab->stub_error = true;
15301
0
        i++;
15302
0
      }
15303
0
    base += 8;
15304
0
    while (1)
15305
0
      {
15306
0
        bfd_vma bits = 0;
15307
0
        while (i < htab->relr_count
15308
0
         && relr_addr[i] - base < 63 * 8
15309
0
         && (relr_addr[i] - base) % 8 == 0)
15310
0
    {
15311
0
      bits |= (bfd_vma) 1 << ((relr_addr[i] - base) / 8);
15312
0
      i++;
15313
0
    }
15314
0
        if (bits == 0)
15315
0
    break;
15316
0
        bfd_put_64 (htab->elf.dynobj, (bits << 1) | 1, loc);
15317
0
        loc += 8;
15318
0
        base += 63 * 8;
15319
0
      }
15320
0
  }
15321
0
      free (relr_addr);
15322
      /* Pad any excess with 1's, a do-nothing encoding.  */
15323
0
      while ((size_t) (loc - htab->elf.srelrdyn->contents)
15324
0
       < htab->elf.srelrdyn->size)
15325
0
  {
15326
0
    bfd_put_64 (htab->elf.dynobj, 1, loc);
15327
0
    loc += 8;
15328
0
  }
15329
0
    }
15330
15331
0
  for (group = htab->group; group != NULL; group = group->next)
15332
0
    if ((stub_sec = group->stub_sec) != NULL)
15333
0
      {
15334
0
  stub_sec_count += 1;
15335
0
  if (stub_sec->rawsize != stub_sec->size
15336
0
      && (htab->stub_iteration <= STUB_SHRINK_ITER
15337
0
    || stub_sec->rawsize < stub_sec->size))
15338
0
    break;
15339
0
      }
15340
15341
0
  if (group != NULL)
15342
0
    htab->stub_error = true;
15343
15344
0
  if (htab->stub_error)
15345
0
    {
15346
0
      _bfd_error_handler (_("stubs don't match calculated size"));
15347
0
      return false;
15348
0
    }
15349
15350
0
  if (stats != NULL)
15351
0
    {
15352
0
      char *groupmsg;
15353
0
      if (asprintf (&groupmsg,
15354
0
        ngettext ("linker stubs in %u group",
15355
0
            "linker stubs in %u groups",
15356
0
            stub_sec_count),
15357
0
        stub_sec_count) < 0)
15358
0
  *stats = NULL;
15359
0
      else
15360
0
  {
15361
0
    if (asprintf (stats, _("%s, iter %u\n"
15362
0
         "  branch         %lu\n"
15363
0
         "  long branch    %lu\n"
15364
0
         "  plt call       %lu\n"
15365
0
         "  global entry   %lu"),
15366
0
      groupmsg, htab->stub_iteration,
15367
0
      htab->stub_count[ppc_stub_long_branch - 1],
15368
0
      htab->stub_count[ppc_stub_plt_branch - 1],
15369
0
      htab->stub_count[ppc_stub_plt_call - 1],
15370
0
      htab->stub_count[ppc_stub_global_entry - 1]) < 0)
15371
0
      *stats = NULL;
15372
0
    free (groupmsg);
15373
0
  }
15374
0
    }
15375
0
  return true;
15376
0
}
15377
15378
/* What to do when ld finds relocations against symbols defined in
15379
   discarded sections.  */
15380
15381
static unsigned int
15382
ppc64_elf_action_discarded (asection *sec)
15383
0
{
15384
0
  if (strcmp (".opd", sec->name) == 0)
15385
0
    return 0;
15386
15387
0
  if (strcmp (".toc", sec->name) == 0)
15388
0
    return 0;
15389
15390
0
  if (strcmp (".toc1", sec->name) == 0)
15391
0
    return 0;
15392
15393
0
  return _bfd_elf_default_action_discarded (sec);
15394
0
}
15395
15396
/* These are the dynamic relocations supported by glibc.  */
15397
15398
static bool
15399
ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type)
15400
0
{
15401
0
  switch (r_type)
15402
0
    {
15403
0
    case R_PPC64_RELATIVE:
15404
0
    case R_PPC64_NONE:
15405
0
    case R_PPC64_ADDR64:
15406
0
    case R_PPC64_GLOB_DAT:
15407
0
    case R_PPC64_IRELATIVE:
15408
0
    case R_PPC64_JMP_IREL:
15409
0
    case R_PPC64_JMP_SLOT:
15410
0
    case R_PPC64_DTPMOD64:
15411
0
    case R_PPC64_DTPREL64:
15412
0
    case R_PPC64_TPREL64:
15413
0
    case R_PPC64_TPREL16_LO_DS:
15414
0
    case R_PPC64_TPREL16_DS:
15415
0
    case R_PPC64_TPREL16:
15416
0
    case R_PPC64_TPREL16_LO:
15417
0
    case R_PPC64_TPREL16_HI:
15418
0
    case R_PPC64_TPREL16_HIGH:
15419
0
    case R_PPC64_TPREL16_HA:
15420
0
    case R_PPC64_TPREL16_HIGHA:
15421
0
    case R_PPC64_TPREL16_HIGHER:
15422
0
    case R_PPC64_TPREL16_HIGHEST:
15423
0
    case R_PPC64_TPREL16_HIGHERA:
15424
0
    case R_PPC64_TPREL16_HIGHESTA:
15425
0
    case R_PPC64_ADDR16_LO_DS:
15426
0
    case R_PPC64_ADDR16_LO:
15427
0
    case R_PPC64_ADDR16_HI:
15428
0
    case R_PPC64_ADDR16_HIGH:
15429
0
    case R_PPC64_ADDR16_HA:
15430
0
    case R_PPC64_ADDR16_HIGHA:
15431
0
    case R_PPC64_REL30:
15432
0
    case R_PPC64_COPY:
15433
0
    case R_PPC64_UADDR64:
15434
0
    case R_PPC64_UADDR32:
15435
0
    case R_PPC64_ADDR32:
15436
0
    case R_PPC64_ADDR24:
15437
0
    case R_PPC64_ADDR16:
15438
0
    case R_PPC64_UADDR16:
15439
0
    case R_PPC64_ADDR16_DS:
15440
0
    case R_PPC64_ADDR16_HIGHER:
15441
0
    case R_PPC64_ADDR16_HIGHEST:
15442
0
    case R_PPC64_ADDR16_HIGHERA:
15443
0
    case R_PPC64_ADDR16_HIGHESTA:
15444
0
    case R_PPC64_ADDR14:
15445
0
    case R_PPC64_ADDR14_BRTAKEN:
15446
0
    case R_PPC64_ADDR14_BRNTAKEN:
15447
0
    case R_PPC64_REL32:
15448
0
    case R_PPC64_REL64:
15449
0
      return true;
15450
15451
0
    default:
15452
0
      return false;
15453
0
    }
15454
0
}
15455
15456
/* The RELOCATE_SECTION function is called by the ELF backend linker
15457
   to handle the relocations for a section.
15458
15459
   The relocs are always passed as Rela structures; if the section
15460
   actually uses Rel structures, the r_addend field will always be
15461
   zero.
15462
15463
   This function is responsible for adjust the section contents as
15464
   necessary, and (if using Rela relocs and generating a
15465
   relocatable output file) adjusting the reloc addend as
15466
   necessary.
15467
15468
   This function does not have to worry about setting the reloc
15469
   address or the reloc symbol index.
15470
15471
   LOCAL_SYMS is a pointer to the swapped in local symbols.
15472
15473
   LOCAL_SECTIONS is an array giving the section in the input file
15474
   corresponding to the st_shndx field of each local symbol.
15475
15476
   The global hash table entry for the global symbols can be found
15477
   via elf_sym_hashes (input_bfd).
15478
15479
   When generating relocatable output, this function must handle
15480
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
15481
   going to be the section symbol corresponding to the output
15482
   section, which means that the addend must be adjusted
15483
   accordingly.  */
15484
15485
static int
15486
ppc64_elf_relocate_section (bfd *output_bfd,
15487
          struct bfd_link_info *info,
15488
          bfd *input_bfd,
15489
          asection *input_section,
15490
          bfd_byte *contents,
15491
          Elf_Internal_Rela *relocs,
15492
          Elf_Internal_Sym *local_syms,
15493
          asection **local_sections)
15494
0
{
15495
0
  struct ppc_link_hash_table *htab;
15496
0
  Elf_Internal_Shdr *symtab_hdr;
15497
0
  struct elf_link_hash_entry **sym_hashes;
15498
0
  Elf_Internal_Rela *rel;
15499
0
  Elf_Internal_Rela *wrel;
15500
0
  Elf_Internal_Rela *relend;
15501
0
  Elf_Internal_Rela outrel;
15502
0
  bfd_byte *loc;
15503
0
  struct got_entry **local_got_ents;
15504
0
  bfd_vma TOCstart;
15505
0
  bool ret = true;
15506
0
  bool is_opd;
15507
  /* Assume 'at' branch hints.  */
15508
0
  bool is_isa_v2 = true;
15509
0
  bool warned_dynamic = false;
15510
0
  bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
15511
15512
  /* Initialize howto table if needed.  */
15513
0
  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
15514
0
    ppc_howto_init ();
15515
15516
0
  htab = ppc_hash_table (info);
15517
0
  if (htab == NULL)
15518
0
    return false;
15519
15520
  /* Don't relocate stub sections.  */
15521
0
  if (input_section->owner == htab->params->stub_bfd)
15522
0
    return true;
15523
15524
0
  if (!is_ppc64_elf (input_bfd))
15525
0
    {
15526
0
      bfd_set_error (bfd_error_wrong_format);
15527
0
      return false;
15528
0
    }
15529
15530
0
  local_got_ents = elf_local_got_ents (input_bfd);
15531
0
  TOCstart = elf_gp (output_bfd);
15532
0
  symtab_hdr = &elf_symtab_hdr (input_bfd);
15533
0
  sym_hashes = elf_sym_hashes (input_bfd);
15534
0
  is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
15535
15536
0
  rel = wrel = relocs;
15537
0
  relend = relocs + input_section->reloc_count;
15538
0
  for (; rel < relend; wrel++, rel++)
15539
0
    {
15540
0
      enum elf_ppc64_reloc_type r_type;
15541
0
      bfd_vma addend;
15542
0
      bfd_reloc_status_type r;
15543
0
      Elf_Internal_Sym *sym;
15544
0
      asection *sec;
15545
0
      struct elf_link_hash_entry *h_elf;
15546
0
      struct ppc_link_hash_entry *h;
15547
0
      struct ppc_link_hash_entry *fdh;
15548
0
      const char *sym_name;
15549
0
      unsigned long r_symndx, toc_symndx;
15550
0
      bfd_vma toc_addend;
15551
0
      unsigned char tls_mask, tls_gd, tls_type;
15552
0
      unsigned char sym_type;
15553
0
      bfd_vma relocation;
15554
0
      bool unresolved_reloc, save_unresolved_reloc;
15555
0
      bool warned;
15556
0
      enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
15557
0
      unsigned int insn;
15558
0
      unsigned int mask;
15559
0
      struct ppc_stub_hash_entry *stub_entry;
15560
0
      bfd_vma max_br_offset;
15561
0
      bfd_vma from;
15562
0
      Elf_Internal_Rela orig_rel;
15563
0
      reloc_howto_type *howto;
15564
0
      struct reloc_howto_struct alt_howto;
15565
0
      uint64_t pinsn;
15566
0
      bfd_vma offset;
15567
15568
0
    again:
15569
0
      orig_rel = *rel;
15570
15571
0
      r_type = ELF64_R_TYPE (rel->r_info);
15572
0
      r_symndx = ELF64_R_SYM (rel->r_info);
15573
15574
      /* For old style R_PPC64_TOC relocs with a zero symbol, use the
15575
   symbol of the previous ADDR64 reloc.  The symbol gives us the
15576
   proper TOC base to use.  */
15577
0
      if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
15578
0
    && wrel != relocs
15579
0
    && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
15580
0
    && is_opd)
15581
0
  r_symndx = ELF64_R_SYM (wrel[-1].r_info);
15582
15583
0
      sym = NULL;
15584
0
      sec = NULL;
15585
0
      h_elf = NULL;
15586
0
      sym_name = NULL;
15587
0
      unresolved_reloc = false;
15588
0
      warned = false;
15589
15590
0
      if (r_symndx < symtab_hdr->sh_info)
15591
0
  {
15592
    /* It's a local symbol.  */
15593
0
    struct _opd_sec_data *opd;
15594
15595
0
    sym = local_syms + r_symndx;
15596
0
    sec = local_sections[r_symndx];
15597
0
    sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
15598
0
    sym_type = ELF64_ST_TYPE (sym->st_info);
15599
0
    relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
15600
0
    opd = get_opd_info (sec);
15601
0
    if (opd != NULL && opd->adjust != NULL)
15602
0
      {
15603
0
        long adjust = opd->adjust[OPD_NDX (sym->st_value
15604
0
             + rel->r_addend)];
15605
0
        if (adjust == -1)
15606
0
    relocation = 0;
15607
0
        else
15608
0
    {
15609
      /* If this is a relocation against the opd section sym
15610
         and we have edited .opd, adjust the reloc addend so
15611
         that ld -r and ld --emit-relocs output is correct.
15612
         If it is a reloc against some other .opd symbol,
15613
         then the symbol value will be adjusted later.  */
15614
0
      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
15615
0
        rel->r_addend += adjust;
15616
0
      else
15617
0
        relocation += adjust;
15618
0
    }
15619
0
      }
15620
0
  }
15621
0
      else
15622
0
  {
15623
0
    bool ignored;
15624
15625
0
    RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
15626
0
           r_symndx, symtab_hdr, sym_hashes,
15627
0
           h_elf, sec, relocation,
15628
0
           unresolved_reloc, warned, ignored);
15629
0
    sym_name = h_elf->root.root.string;
15630
0
    sym_type = h_elf->type;
15631
0
    if (sec != NULL
15632
0
        && sec->owner == output_bfd
15633
0
        && strcmp (sec->name, ".opd") == 0)
15634
0
      {
15635
        /* This is a symbol defined in a linker script.  All
15636
     such are defined in output sections, even those
15637
     defined by simple assignment from a symbol defined in
15638
     an input section.  Transfer the symbol to an
15639
     appropriate input .opd section, so that a branch to
15640
     this symbol will be mapped to the location specified
15641
     by the opd entry.  */
15642
0
        struct bfd_link_order *lo;
15643
0
        for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
15644
0
    if (lo->type == bfd_indirect_link_order)
15645
0
      {
15646
0
        asection *isec = lo->u.indirect.section;
15647
0
        if (h_elf->root.u.def.value >= isec->output_offset
15648
0
      && h_elf->root.u.def.value < (isec->output_offset
15649
0
                  + isec->size))
15650
0
          {
15651
0
      h_elf->root.u.def.value -= isec->output_offset;
15652
0
      h_elf->root.u.def.section = isec;
15653
0
      sec = isec;
15654
0
      break;
15655
0
          }
15656
0
      }
15657
0
      }
15658
0
  }
15659
0
      h = ppc_elf_hash_entry (h_elf);
15660
15661
0
      if (sec != NULL && discarded_section (sec))
15662
0
  {
15663
0
    _bfd_clear_contents (ppc64_elf_howto_table[r_type],
15664
0
             input_bfd, input_section,
15665
0
             contents, rel->r_offset);
15666
0
    wrel->r_offset = rel->r_offset;
15667
0
    wrel->r_info = 0;
15668
0
    wrel->r_addend = 0;
15669
15670
    /* For ld -r, remove relocations in debug sections against
15671
       symbols defined in discarded sections.  Not done for
15672
       non-debug to preserve relocs in .eh_frame which the
15673
       eh_frame editing code expects to be present.  */
15674
0
    if (bfd_link_relocatable (info)
15675
0
        && (input_section->flags & SEC_DEBUGGING))
15676
0
      wrel--;
15677
15678
0
    continue;
15679
0
  }
15680
15681
0
      if (bfd_link_relocatable (info))
15682
0
  goto copy_reloc;
15683
15684
0
      if (h != NULL && &h->elf == htab->elf.hgot)
15685
0
  {
15686
0
    relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
15687
0
    sec = bfd_abs_section_ptr;
15688
0
    unresolved_reloc = false;
15689
0
  }
15690
15691
      /* TLS optimizations.  Replace instruction sequences and relocs
15692
   based on information we collected in tls_optimize.  We edit
15693
   RELOCS so that --emit-relocs will output something sensible
15694
   for the final instruction stream.  */
15695
0
      tls_mask = 0;
15696
0
      tls_gd = 0;
15697
0
      toc_symndx = 0;
15698
0
      if (h != NULL)
15699
0
  tls_mask = h->tls_mask;
15700
0
      else if (local_got_ents != NULL)
15701
0
  {
15702
0
    struct plt_entry **local_plt = (struct plt_entry **)
15703
0
      (local_got_ents + symtab_hdr->sh_info);
15704
0
    unsigned char *lgot_masks = (unsigned char *)
15705
0
      (local_plt + symtab_hdr->sh_info);
15706
0
    tls_mask = lgot_masks[r_symndx];
15707
0
  }
15708
0
      if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
15709
0
    && (r_type == R_PPC64_TLS
15710
0
        || r_type == R_PPC64_TLSGD
15711
0
        || r_type == R_PPC64_TLSLD))
15712
0
  {
15713
    /* Check for toc tls entries.  */
15714
0
    unsigned char *toc_tls;
15715
15716
0
    if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
15717
0
           &local_syms, rel, input_bfd))
15718
0
      return false;
15719
15720
0
    if (toc_tls)
15721
0
      tls_mask = *toc_tls;
15722
0
  }
15723
15724
      /* Check that tls relocs are used with tls syms, and non-tls
15725
   relocs are used with non-tls syms.  */
15726
0
      if (r_symndx != STN_UNDEF
15727
0
    && r_type != R_PPC64_NONE
15728
0
    && (h == NULL
15729
0
        || h->elf.root.type == bfd_link_hash_defined
15730
0
        || h->elf.root.type == bfd_link_hash_defweak)
15731
0
    && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
15732
0
  {
15733
0
    if ((tls_mask & TLS_TLS) != 0
15734
0
        && (r_type == R_PPC64_TLS
15735
0
      || r_type == R_PPC64_TLSGD
15736
0
      || r_type == R_PPC64_TLSLD))
15737
      /* R_PPC64_TLS is OK against a symbol in the TOC.  */
15738
0
      ;
15739
0
    else
15740
0
      info->callbacks->einfo
15741
0
        (!IS_PPC64_TLS_RELOC (r_type)
15742
         /* xgettext:c-format */
15743
0
         ? _("%H: %s used with TLS symbol `%pT'\n")
15744
         /* xgettext:c-format */
15745
0
         : _("%H: %s used with non-TLS symbol `%pT'\n"),
15746
0
         input_bfd, input_section, rel->r_offset,
15747
0
         ppc64_elf_howto_table[r_type]->name,
15748
0
         sym_name);
15749
0
  }
15750
15751
      /* Ensure reloc mapping code below stays sane.  */
15752
0
      if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
15753
0
    || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
15754
0
    || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
15755
0
    || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
15756
0
    || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
15757
0
    || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
15758
0
    || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
15759
0
    || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
15760
0
    || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
15761
0
    || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
15762
0
  abort ();
15763
15764
0
      switch (r_type)
15765
0
  {
15766
0
  default:
15767
0
    break;
15768
15769
0
  case R_PPC64_LO_DS_OPT:
15770
0
    if (offset_in_range (input_section, rel->r_offset - d_offset, 4))
15771
0
      {
15772
0
        insn = bfd_get_32 (input_bfd,
15773
0
         contents + rel->r_offset - d_offset);
15774
0
        if ((insn & (0x3fu << 26)) != 58u << 26)
15775
0
    abort ();
15776
0
        insn += (14u << 26) - (58u << 26);
15777
0
        bfd_put_32 (input_bfd, insn,
15778
0
        contents + rel->r_offset - d_offset);
15779
0
        r_type = R_PPC64_TOC16_LO;
15780
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15781
0
      }
15782
0
    break;
15783
15784
0
  case R_PPC64_TOC16:
15785
0
  case R_PPC64_TOC16_LO:
15786
0
  case R_PPC64_TOC16_DS:
15787
0
  case R_PPC64_TOC16_LO_DS:
15788
0
    {
15789
      /* Check for toc tls entries.  */
15790
0
      unsigned char *toc_tls;
15791
0
      int retval;
15792
15793
0
      retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
15794
0
           &local_syms, rel, input_bfd);
15795
0
      if (retval == 0)
15796
0
        return false;
15797
15798
0
      if (toc_tls)
15799
0
        {
15800
0
    tls_mask = *toc_tls;
15801
0
    if (r_type == R_PPC64_TOC16_DS
15802
0
        || r_type == R_PPC64_TOC16_LO_DS)
15803
0
      {
15804
0
        if ((tls_mask & TLS_TLS) != 0
15805
0
      && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
15806
0
          goto toctprel;
15807
0
      }
15808
0
    else
15809
0
      {
15810
        /* If we found a GD reloc pair, then we might be
15811
           doing a GD->IE transition.  */
15812
0
        if (retval == 2)
15813
0
          {
15814
0
      tls_gd = TLS_GDIE;
15815
0
      if ((tls_mask & TLS_TLS) != 0
15816
0
          && (tls_mask & TLS_GD) == 0)
15817
0
        goto tls_ldgd_opt;
15818
0
          }
15819
0
        else if (retval == 3)
15820
0
          {
15821
0
      if ((tls_mask & TLS_TLS) != 0
15822
0
          && (tls_mask & TLS_LD) == 0)
15823
0
        goto tls_ldgd_opt;
15824
0
          }
15825
0
      }
15826
0
        }
15827
0
    }
15828
0
    break;
15829
15830
0
  case R_PPC64_GOT_TPREL16_HI:
15831
0
  case R_PPC64_GOT_TPREL16_HA:
15832
0
    if ((tls_mask & TLS_TLS) != 0
15833
0
        && (tls_mask & TLS_TPREL) == 0
15834
0
        && offset_in_range (input_section, rel->r_offset - d_offset, 4))
15835
0
      {
15836
0
        rel->r_offset -= d_offset;
15837
0
        bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15838
0
        r_type = R_PPC64_NONE;
15839
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15840
0
      }
15841
0
    break;
15842
15843
0
  case R_PPC64_GOT_TPREL16_DS:
15844
0
  case R_PPC64_GOT_TPREL16_LO_DS:
15845
0
    if ((tls_mask & TLS_TLS) != 0
15846
0
        && (tls_mask & TLS_TPREL) == 0
15847
0
        && offset_in_range (input_section, rel->r_offset - d_offset, 4))
15848
0
      {
15849
0
      toctprel:
15850
0
        insn = bfd_get_32 (input_bfd,
15851
0
         contents + rel->r_offset - d_offset);
15852
0
        insn &= 31 << 21;
15853
0
        insn |= 0x3c0d0000; /* addis 0,13,0 */
15854
0
        bfd_put_32 (input_bfd, insn,
15855
0
        contents + rel->r_offset - d_offset);
15856
0
        r_type = R_PPC64_TPREL16_HA;
15857
0
        if (toc_symndx != 0)
15858
0
    {
15859
0
      rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
15860
0
      rel->r_addend = toc_addend;
15861
      /* We changed the symbol.  Start over in order to
15862
         get h, sym, sec etc. right.  */
15863
0
      goto again;
15864
0
    }
15865
0
        else
15866
0
    rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15867
0
      }
15868
0
    break;
15869
15870
0
  case R_PPC64_GOT_TPREL_PCREL34:
15871
0
    if ((tls_mask & TLS_TLS) != 0
15872
0
        && (tls_mask & TLS_TPREL) == 0
15873
0
        && offset_in_range (input_section, rel->r_offset, 8))
15874
0
      {
15875
        /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel  */
15876
0
        pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15877
0
        pinsn <<= 32;
15878
0
        pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15879
0
        pinsn += ((2ULL << 56) + (-1ULL << 52)
15880
0
      + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
15881
0
        bfd_put_32 (input_bfd, pinsn >> 32,
15882
0
        contents + rel->r_offset);
15883
0
        bfd_put_32 (input_bfd, pinsn & 0xffffffff,
15884
0
        contents + rel->r_offset + 4);
15885
0
        r_type = R_PPC64_TPREL34;
15886
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15887
0
      }
15888
0
    break;
15889
15890
0
  case R_PPC64_TLS:
15891
0
    if ((tls_mask & TLS_TLS) != 0
15892
0
        && (tls_mask & TLS_TPREL) == 0
15893
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
15894
0
      {
15895
0
        insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15896
0
        insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
15897
0
        if (insn == 0)
15898
0
    break;
15899
0
        if ((rel->r_offset & 3) == 0)
15900
0
    {
15901
0
      bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15902
      /* Was PPC64_TLS which sits on insn boundary, now
15903
         PPC64_TPREL16_LO which is at low-order half-word.  */
15904
0
      rel->r_offset += d_offset;
15905
0
      r_type = R_PPC64_TPREL16_LO;
15906
0
      if (toc_symndx != 0)
15907
0
        {
15908
0
          rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
15909
0
          rel->r_addend = toc_addend;
15910
          /* We changed the symbol.  Start over in order to
15911
       get h, sym, sec etc. right.  */
15912
0
          goto again;
15913
0
        }
15914
0
      else
15915
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15916
0
    }
15917
0
        else if ((rel->r_offset & 3) == 1)
15918
0
    {
15919
      /* For pcrel IE to LE we already have the full
15920
         offset and thus don't need an addi here.  A nop
15921
         or mr will do.  */
15922
0
      if ((insn & (0x3fu << 26)) == 14 << 26)
15923
0
        {
15924
          /* Extract regs from addi rt,ra,si.  */
15925
0
          unsigned int rt = (insn >> 21) & 0x1f;
15926
0
          unsigned int ra = (insn >> 16) & 0x1f;
15927
0
          if (rt == ra)
15928
0
      insn = NOP;
15929
0
          else
15930
0
      {
15931
        /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs.  */
15932
0
        insn = (rt << 16) | (ra << 21) | (ra << 11);
15933
0
        insn |= (31u << 26) | (444u << 1);
15934
0
      }
15935
0
        }
15936
0
      bfd_put_32 (input_bfd, insn, contents + rel->r_offset - 1);
15937
0
    }
15938
0
      }
15939
0
    break;
15940
15941
0
  case R_PPC64_GOT_TLSGD16_HI:
15942
0
  case R_PPC64_GOT_TLSGD16_HA:
15943
0
    tls_gd = TLS_GDIE;
15944
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
15945
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
15946
0
      goto tls_gdld_hi;
15947
0
    break;
15948
15949
0
  case R_PPC64_GOT_TLSLD16_HI:
15950
0
  case R_PPC64_GOT_TLSLD16_HA:
15951
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
15952
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
15953
0
      {
15954
0
      tls_gdld_hi:
15955
0
        if ((tls_mask & tls_gd) != 0)
15956
0
    r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
15957
0
        + R_PPC64_GOT_TPREL16_DS);
15958
0
        else
15959
0
    {
15960
0
      rel->r_offset -= d_offset;
15961
0
      bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15962
0
      r_type = R_PPC64_NONE;
15963
0
    }
15964
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15965
0
      }
15966
0
    break;
15967
15968
0
  case R_PPC64_GOT_TLSGD16:
15969
0
  case R_PPC64_GOT_TLSGD16_LO:
15970
0
    tls_gd = TLS_GDIE;
15971
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
15972
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
15973
0
      goto tls_ldgd_opt;
15974
0
    break;
15975
15976
0
  case R_PPC64_GOT_TLSLD16:
15977
0
  case R_PPC64_GOT_TLSLD16_LO:
15978
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
15979
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
15980
0
      {
15981
0
        unsigned int insn1, insn2;
15982
15983
0
      tls_ldgd_opt:
15984
0
        offset = (bfd_vma) -1;
15985
        /* If not using the newer R_PPC64_TLSGD/LD to mark
15986
     __tls_get_addr calls, we must trust that the call
15987
     stays with its arg setup insns, ie. that the next
15988
     reloc is the __tls_get_addr call associated with
15989
     the current reloc.  Edit both insns.  */
15990
0
        if (input_section->nomark_tls_get_addr
15991
0
      && rel + 1 < relend
15992
0
      && branch_reloc_hash_match (input_bfd, rel + 1,
15993
0
                htab->tls_get_addr_fd,
15994
0
                htab->tga_desc_fd,
15995
0
                htab->tls_get_addr,
15996
0
                htab->tga_desc))
15997
0
    offset = rel[1].r_offset;
15998
        /* We read the low GOT_TLS (or TOC16) insn because we
15999
     need to keep the destination reg.  It may be
16000
     something other than the usual r3, and moved to r3
16001
     before the call by intervening code.  */
16002
0
        insn1 = bfd_get_32 (input_bfd,
16003
0
          contents + rel->r_offset - d_offset);
16004
0
        if ((tls_mask & tls_gd) != 0)
16005
0
    {
16006
      /* IE */
16007
0
      insn1 &= (0x1f << 21) | (0x1f << 16);
16008
0
      insn1 |= 58u << 26; /* ld */
16009
0
      insn2 = 0x7c636a14; /* add 3,3,13 */
16010
0
      if (offset != (bfd_vma) -1)
16011
0
        rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
16012
0
      if (r_type == R_PPC64_TOC16
16013
0
          || r_type == R_PPC64_TOC16_LO)
16014
0
        r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
16015
0
      else
16016
0
        r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 1)) & 1)
16017
0
            + R_PPC64_GOT_TPREL16_DS);
16018
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16019
0
    }
16020
0
        else
16021
0
    {
16022
      /* LE */
16023
0
      insn1 &= 0x1f << 21;
16024
0
      insn1 |= 0x3c0d0000;  /* addis r,13,0 */
16025
0
      insn2 = 0x38630000; /* addi 3,3,0 */
16026
0
      if (tls_gd == 0)
16027
0
        {
16028
          /* Was an LD reloc.  */
16029
0
          r_symndx = STN_UNDEF;
16030
0
          rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
16031
0
        }
16032
0
      else if (toc_symndx != 0)
16033
0
        {
16034
0
          r_symndx = toc_symndx;
16035
0
          rel->r_addend = toc_addend;
16036
0
        }
16037
0
      r_type = R_PPC64_TPREL16_HA;
16038
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16039
0
      if (offset != (bfd_vma) -1)
16040
0
        {
16041
0
          rel[1].r_info = ELF64_R_INFO (r_symndx,
16042
0
                R_PPC64_TPREL16_LO);
16043
0
          rel[1].r_offset = offset + d_offset;
16044
0
          rel[1].r_addend = rel->r_addend;
16045
0
        }
16046
0
    }
16047
0
        bfd_put_32 (input_bfd, insn1,
16048
0
        contents + rel->r_offset - d_offset);
16049
0
        if (offset != (bfd_vma) -1
16050
0
      && offset_in_range (input_section, offset, 4))
16051
0
    {
16052
0
      bfd_put_32 (input_bfd, insn2, contents + offset);
16053
0
      if (offset_in_range (input_section, offset + 4, 4))
16054
0
        {
16055
0
          insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
16056
0
          if (insn2 == LD_R2_0R1 + STK_TOC (htab))
16057
0
      bfd_put_32 (input_bfd, NOP, contents + offset + 4);
16058
0
        }
16059
0
    }
16060
0
        if ((tls_mask & tls_gd) == 0
16061
0
      && (tls_gd == 0 || toc_symndx != 0))
16062
0
    {
16063
      /* We changed the symbol.  Start over in order
16064
         to get h, sym, sec etc. right.  */
16065
0
      goto again;
16066
0
    }
16067
0
      }
16068
0
    break;
16069
16070
0
  case R_PPC64_GOT_TLSGD_PCREL34:
16071
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
16072
0
        && offset_in_range (input_section, rel->r_offset, 8))
16073
0
      {
16074
0
        pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16075
0
        pinsn <<= 32;
16076
0
        pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
16077
0
        if ((tls_mask & TLS_GDIE) != 0)
16078
0
    {
16079
      /* IE, pla -> pld  */
16080
0
      pinsn += (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
16081
0
      r_type = R_PPC64_GOT_TPREL_PCREL34;
16082
0
    }
16083
0
        else
16084
0
    {
16085
      /* LE, pla pcrel -> paddi r13  */
16086
0
      pinsn += (-1ULL << 52) + (13ULL << 16);
16087
0
      r_type = R_PPC64_TPREL34;
16088
0
    }
16089
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16090
0
        bfd_put_32 (input_bfd, pinsn >> 32,
16091
0
        contents + rel->r_offset);
16092
0
        bfd_put_32 (input_bfd, pinsn & 0xffffffff,
16093
0
        contents + rel->r_offset + 4);
16094
0
      }
16095
0
    break;
16096
16097
0
  case R_PPC64_GOT_TLSLD_PCREL34:
16098
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
16099
0
        && offset_in_range (input_section, rel->r_offset, 8))
16100
0
      {
16101
0
        pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16102
0
        pinsn <<= 32;
16103
0
        pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
16104
0
        pinsn += (-1ULL << 52) + (13ULL << 16);
16105
0
        bfd_put_32 (input_bfd, pinsn >> 32,
16106
0
        contents + rel->r_offset);
16107
0
        bfd_put_32 (input_bfd, pinsn & 0xffffffff,
16108
0
        contents + rel->r_offset + 4);
16109
0
        rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
16110
0
        r_symndx = STN_UNDEF;
16111
0
        r_type = R_PPC64_TPREL34;
16112
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16113
0
        goto again;
16114
0
      }
16115
0
    break;
16116
16117
0
  case R_PPC64_TLSGD:
16118
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
16119
0
        && rel + 1 < relend
16120
0
        && offset_in_range (input_section, rel->r_offset,
16121
0
          is_8byte_reloc (ELF64_R_TYPE (rel[1].r_info))
16122
0
          ? 8 : 4))
16123
0
      {
16124
0
        unsigned int insn2;
16125
0
        enum elf_ppc64_reloc_type r_type1 = ELF64_R_TYPE (rel[1].r_info);
16126
16127
0
        offset = rel->r_offset;
16128
0
        if (is_plt_seq_reloc (r_type1))
16129
0
    {
16130
0
      bfd_put_32 (output_bfd, NOP, contents + offset);
16131
0
      if (r_type1 == R_PPC64_PLT_PCREL34
16132
0
          || r_type1 == R_PPC64_PLT_PCREL34_NOTOC)
16133
0
        bfd_put_32 (output_bfd, NOP, contents + offset + 4);
16134
0
      rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
16135
0
      break;
16136
0
    }
16137
16138
0
        if (r_type1 == R_PPC64_PLTCALL)
16139
0
    bfd_put_32 (output_bfd, NOP, contents + offset + 4);
16140
16141
0
        if ((tls_mask & TLS_GDIE) != 0)
16142
0
    {
16143
      /* IE */
16144
0
      r_type = R_PPC64_NONE;
16145
0
      insn2 = 0x7c636a14; /* add 3,3,13 */
16146
0
    }
16147
0
        else
16148
0
    {
16149
      /* LE */
16150
0
      if (toc_symndx != 0)
16151
0
        {
16152
0
          r_symndx = toc_symndx;
16153
0
          rel->r_addend = toc_addend;
16154
0
        }
16155
0
      if (r_type1 == R_PPC64_REL24_NOTOC
16156
0
          || r_type1 == R_PPC64_REL24_P9NOTOC
16157
0
          || r_type1 == R_PPC64_PLTCALL_NOTOC)
16158
0
        {
16159
0
          r_type = R_PPC64_NONE;
16160
0
          insn2 = NOP;
16161
0
        }
16162
0
      else
16163
0
        {
16164
0
          rel->r_offset = offset + d_offset;
16165
0
          r_type = R_PPC64_TPREL16_LO;
16166
0
          insn2 = 0x38630000; /* addi 3,3,0 */
16167
0
        }
16168
0
    }
16169
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16170
        /* Zap the reloc on the _tls_get_addr call too.  */
16171
0
        BFD_ASSERT (offset == rel[1].r_offset);
16172
0
        rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
16173
0
        bfd_put_32 (input_bfd, insn2, contents + offset);
16174
0
        if ((tls_mask & TLS_GDIE) == 0
16175
0
      && toc_symndx != 0
16176
0
      && r_type != R_PPC64_NONE)
16177
0
    goto again;
16178
0
      }
16179
0
    break;
16180
16181
0
  case R_PPC64_TLSLD:
16182
0
    if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
16183
0
        && rel + 1 < relend
16184
0
        && offset_in_range (input_section, rel->r_offset,
16185
0
          is_8byte_reloc (ELF64_R_TYPE (rel[1].r_info))
16186
0
          ? 8 : 4))
16187
0
      {
16188
0
        unsigned int insn2;
16189
0
        enum elf_ppc64_reloc_type r_type1 = ELF64_R_TYPE (rel[1].r_info);
16190
16191
0
        offset = rel->r_offset;
16192
0
        if (is_plt_seq_reloc (r_type1))
16193
0
    {
16194
0
      bfd_put_32 (output_bfd, NOP, contents + offset);
16195
0
      if (r_type1 == R_PPC64_PLT_PCREL34
16196
0
          || r_type1 == R_PPC64_PLT_PCREL34_NOTOC)
16197
0
        bfd_put_32 (output_bfd, NOP, contents + offset + 4);
16198
0
      rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
16199
0
      break;
16200
0
    }
16201
16202
0
        if (r_type1 == R_PPC64_PLTCALL)
16203
0
    bfd_put_32 (output_bfd, NOP, contents + offset + 4);
16204
16205
0
        if (r_type1 == R_PPC64_REL24_NOTOC
16206
0
      || r_type1 == R_PPC64_REL24_P9NOTOC
16207
0
      || r_type1 == R_PPC64_PLTCALL_NOTOC)
16208
0
    {
16209
0
      r_type = R_PPC64_NONE;
16210
0
      insn2 = NOP;
16211
0
    }
16212
0
        else
16213
0
    {
16214
0
      rel->r_offset = offset + d_offset;
16215
0
      r_symndx = STN_UNDEF;
16216
0
      r_type = R_PPC64_TPREL16_LO;
16217
0
      rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
16218
0
      insn2 = 0x38630000; /* addi 3,3,0 */
16219
0
    }
16220
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16221
        /* Zap the reloc on the _tls_get_addr call too.  */
16222
0
        BFD_ASSERT (offset == rel[1].r_offset);
16223
0
        rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
16224
0
        bfd_put_32 (input_bfd, insn2, contents + offset);
16225
0
        if (r_type != R_PPC64_NONE)
16226
0
    goto again;
16227
0
      }
16228
0
    break;
16229
16230
0
  case R_PPC64_DTPMOD64:
16231
0
    if (rel + 1 < relend
16232
0
        && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
16233
0
        && rel[1].r_offset == rel->r_offset + 8)
16234
0
      {
16235
0
        if ((tls_mask & TLS_GD) == 0
16236
0
      && offset_in_range (input_section, rel->r_offset, 8))
16237
0
    {
16238
0
      rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
16239
0
      if ((tls_mask & TLS_GDIE) != 0)
16240
0
        r_type = R_PPC64_TPREL64;
16241
0
      else
16242
0
        {
16243
0
          bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
16244
0
          r_type = R_PPC64_NONE;
16245
0
        }
16246
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16247
0
    }
16248
0
      }
16249
0
    else
16250
0
      {
16251
0
        if ((tls_mask & TLS_LD) == 0
16252
0
      && offset_in_range (input_section, rel->r_offset, 8))
16253
0
    {
16254
0
      bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
16255
0
      r_type = R_PPC64_NONE;
16256
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16257
0
    }
16258
0
      }
16259
0
    break;
16260
16261
0
  case R_PPC64_TPREL64:
16262
0
    if ((tls_mask & TLS_TPREL) == 0)
16263
0
      {
16264
0
        r_type = R_PPC64_NONE;
16265
0
        rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16266
0
      }
16267
0
    break;
16268
16269
0
  case R_PPC64_ENTRY:
16270
0
    relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
16271
0
    if (!bfd_link_pic (info)
16272
0
        && !info->traditional_format
16273
0
        && relocation + 0x80008000 <= 0xffffffff
16274
0
        && offset_in_range (input_section, rel->r_offset, 8))
16275
0
      {
16276
0
        unsigned int insn1, insn2;
16277
16278
0
        insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
16279
0
        insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
16280
0
        if ((insn1 & ~0xfffc) == LD_R2_0R12
16281
0
      && insn2 == ADD_R2_R2_R12)
16282
0
    {
16283
0
      bfd_put_32 (input_bfd,
16284
0
            LIS_R2 + PPC_HA (relocation),
16285
0
            contents + rel->r_offset);
16286
0
      bfd_put_32 (input_bfd,
16287
0
            ADDI_R2_R2 + PPC_LO (relocation),
16288
0
            contents + rel->r_offset + 4);
16289
0
    }
16290
0
      }
16291
0
    else
16292
0
      {
16293
0
        relocation -= (rel->r_offset
16294
0
           + input_section->output_offset
16295
0
           + input_section->output_section->vma);
16296
0
        if (relocation + 0x80008000 <= 0xffffffff
16297
0
      && offset_in_range (input_section, rel->r_offset, 8))
16298
0
    {
16299
0
      unsigned int insn1, insn2;
16300
16301
0
      insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
16302
0
      insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
16303
0
      if ((insn1 & ~0xfffc) == LD_R2_0R12
16304
0
          && insn2 == ADD_R2_R2_R12)
16305
0
        {
16306
0
          bfd_put_32 (input_bfd,
16307
0
          ADDIS_R2_R12 + PPC_HA (relocation),
16308
0
          contents + rel->r_offset);
16309
0
          bfd_put_32 (input_bfd,
16310
0
          ADDI_R2_R2 + PPC_LO (relocation),
16311
0
          contents + rel->r_offset + 4);
16312
0
        }
16313
0
    }
16314
0
      }
16315
0
    break;
16316
16317
0
  case R_PPC64_REL16_HA:
16318
    /* If we are generating a non-PIC executable, edit
16319
       .  0:  addis 2,12,.TOC.-0b@ha
16320
       .    addi 2,2,.TOC.-0b@l
16321
       used by ELFv2 global entry points to set up r2, to
16322
       .    lis 2,.TOC.@ha
16323
       .    addi 2,2,.TOC.@l
16324
       if .TOC. is in range.  */
16325
0
    if (!bfd_link_pic (info)
16326
0
        && !info->traditional_format
16327
0
        && !htab->opd_abi
16328
0
        && rel->r_addend == d_offset
16329
0
        && h != NULL && &h->elf == htab->elf.hgot
16330
0
        && rel + 1 < relend
16331
0
        && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
16332
0
        && rel[1].r_offset == rel->r_offset + 4
16333
0
        && rel[1].r_addend == rel->r_addend + 4
16334
0
        && relocation + 0x80008000 <= 0xffffffff
16335
0
        && offset_in_range (input_section, rel->r_offset - d_offset, 8))
16336
0
      {
16337
0
        unsigned int insn1, insn2;
16338
0
        offset = rel->r_offset - d_offset;
16339
0
        insn1 = bfd_get_32 (input_bfd, contents + offset);
16340
0
        insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
16341
0
        if ((insn1 & 0xffff0000) == ADDIS_R2_R12
16342
0
      && (insn2 & 0xffff0000) == ADDI_R2_R2)
16343
0
    {
16344
0
      r_type = R_PPC64_ADDR16_HA;
16345
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16346
0
      rel->r_addend -= d_offset;
16347
0
      rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
16348
0
      rel[1].r_addend -= d_offset + 4;
16349
0
      bfd_put_32 (input_bfd, LIS_R2, contents + offset);
16350
0
    }
16351
0
      }
16352
0
    break;
16353
0
  }
16354
16355
      /* Handle other relocations that tweak non-addend part of insn.  */
16356
0
      insn = 0;
16357
0
      max_br_offset = 1 << 25;
16358
0
      addend = rel->r_addend;
16359
0
      reloc_dest = DEST_NORMAL;
16360
0
      switch (r_type)
16361
0
  {
16362
0
  default:
16363
0
    break;
16364
16365
0
  case R_PPC64_TOCSAVE:
16366
0
    if (relocation + addend == (rel->r_offset
16367
0
              + input_section->output_offset
16368
0
              + input_section->output_section->vma)
16369
0
        && tocsave_find (htab, NO_INSERT,
16370
0
             &local_syms, rel, input_bfd)
16371
0
        && offset_in_range (input_section, rel->r_offset, 4))
16372
0
      {
16373
0
        insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16374
0
        if (insn == NOP
16375
0
      || insn == CROR_151515 || insn == CROR_313131)
16376
0
    bfd_put_32 (input_bfd,
16377
0
          STD_R2_0R1 + STK_TOC (htab),
16378
0
          contents + rel->r_offset);
16379
0
      }
16380
0
    break;
16381
16382
    /* Branch taken prediction relocations.  */
16383
0
  case R_PPC64_ADDR14_BRTAKEN:
16384
0
  case R_PPC64_REL14_BRTAKEN:
16385
0
    insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
16386
    /* Fall through.  */
16387
16388
    /* Branch not taken prediction relocations.  */
16389
0
  case R_PPC64_ADDR14_BRNTAKEN:
16390
0
  case R_PPC64_REL14_BRNTAKEN:
16391
0
    if (!offset_in_range (input_section, rel->r_offset, 4))
16392
0
      break;
16393
0
    insn |= bfd_get_32 (input_bfd,
16394
0
            contents + rel->r_offset) & ~(0x01 << 21);
16395
    /* Fall through.  */
16396
16397
0
  case R_PPC64_REL14:
16398
0
    max_br_offset = 1 << 15;
16399
    /* Fall through.  */
16400
16401
0
  case R_PPC64_REL24:
16402
0
  case R_PPC64_REL24_NOTOC:
16403
0
  case R_PPC64_REL24_P9NOTOC:
16404
0
  case R_PPC64_PLTCALL:
16405
0
  case R_PPC64_PLTCALL_NOTOC:
16406
    /* Calls to functions with a different TOC, such as calls to
16407
       shared objects, need to alter the TOC pointer.  This is
16408
       done using a linkage stub.  A REL24 branching to these
16409
       linkage stubs needs to be followed by a nop, as the nop
16410
       will be replaced with an instruction to restore the TOC
16411
       base pointer.  */
16412
0
    fdh = h;
16413
0
    if (h != NULL
16414
0
        && h->oh != NULL
16415
0
        && h->oh->is_func_descriptor)
16416
0
      fdh = ppc_follow_link (h->oh);
16417
0
    stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
16418
0
             htab);
16419
0
    if ((r_type == R_PPC64_PLTCALL
16420
0
         || r_type == R_PPC64_PLTCALL_NOTOC)
16421
0
        && stub_entry != NULL
16422
0
        && stub_entry->type.main == ppc_stub_plt_call)
16423
0
      stub_entry = NULL;
16424
16425
0
    if (stub_entry != NULL
16426
0
        && (stub_entry->type.main == ppc_stub_plt_call
16427
0
      || stub_entry->type.r2save))
16428
0
      {
16429
0
        bool can_plt_call = false;
16430
16431
0
        if (r_type == R_PPC64_REL24_NOTOC
16432
0
      || r_type == R_PPC64_REL24_P9NOTOC)
16433
0
    {
16434
      /* NOTOC calls don't need to restore r2.  */
16435
0
      can_plt_call = true;
16436
0
    }
16437
0
        else if (stub_entry->type.main == ppc_stub_plt_call
16438
0
           && !htab->opd_abi
16439
0
           && htab->params->plt_localentry0 != 0
16440
0
           && h != NULL
16441
0
           && is_elfv2_localentry0 (&h->elf))
16442
0
    {
16443
      /* The function doesn't use or change r2.  */
16444
0
      can_plt_call = true;
16445
0
    }
16446
16447
        /* All of these stubs may modify r2, so there must be a
16448
     branch and link followed by a nop.  The nop is
16449
     replaced by an insn to restore r2.  */
16450
0
        else if (offset_in_range (input_section, rel->r_offset, 8))
16451
0
    {
16452
0
      unsigned long br;
16453
16454
0
      br = bfd_get_32 (input_bfd,
16455
0
           contents + rel->r_offset);
16456
0
      if ((br & 1) != 0)
16457
0
        {
16458
0
          unsigned long nop;
16459
16460
0
          nop = bfd_get_32 (input_bfd,
16461
0
          contents + rel->r_offset + 4);
16462
0
          if (nop == LD_R2_0R1 + STK_TOC (htab))
16463
0
      can_plt_call = true;
16464
0
          else if (nop == NOP
16465
0
             || nop == CROR_151515
16466
0
             || nop == CROR_313131)
16467
0
      {
16468
0
        if (h != NULL
16469
0
            && is_tls_get_addr (&h->elf, htab)
16470
0
            && htab->params->tls_get_addr_opt)
16471
0
          {
16472
            /* Special stub used, leave nop alone.  */
16473
0
          }
16474
0
        else
16475
0
          bfd_put_32 (input_bfd,
16476
0
          LD_R2_0R1 + STK_TOC (htab),
16477
0
          contents + rel->r_offset + 4);
16478
0
        can_plt_call = true;
16479
0
      }
16480
0
        }
16481
0
    }
16482
16483
0
        if (!can_plt_call && h != NULL)
16484
0
    {
16485
0
      const char *name = h->elf.root.root.string;
16486
16487
0
      if (*name == '.')
16488
0
        ++name;
16489
16490
0
      if (startswith (name, "__libc_start_main")
16491
0
          && (name[17] == 0 || name[17] == '@'))
16492
0
        {
16493
          /* Allow crt1 branch to go via a toc adjusting
16494
       stub.  Other calls that never return could do
16495
       the same, if we could detect such.  */
16496
0
          can_plt_call = true;
16497
0
        }
16498
0
    }
16499
16500
0
        if (!can_plt_call)
16501
0
    {
16502
      /* g++ as of 20130507 emits self-calls without a
16503
         following nop.  This is arguably wrong since we
16504
         have conflicting information.  On the one hand a
16505
         global symbol and on the other a local call
16506
         sequence, but don't error for this special case.
16507
         It isn't possible to cheaply verify we have
16508
         exactly such a call.  Allow all calls to the same
16509
         section.  */
16510
0
      asection *code_sec = sec;
16511
16512
0
      if (get_opd_info (sec) != NULL)
16513
0
        {
16514
0
          bfd_vma off = (relocation + addend
16515
0
             - sec->output_section->vma
16516
0
             - sec->output_offset);
16517
16518
0
          opd_entry_value (sec, off, &code_sec, NULL, false);
16519
0
        }
16520
0
      if (code_sec == input_section)
16521
0
        can_plt_call = true;
16522
0
    }
16523
16524
0
        if (!can_plt_call)
16525
0
    {
16526
0
      if (stub_entry->type.main == ppc_stub_plt_call)
16527
0
        info->callbacks->einfo
16528
          /* xgettext:c-format */
16529
0
          (_("%H: call to `%pT' lacks nop, can't restore toc; "
16530
0
       "(plt call stub)\n"),
16531
0
           input_bfd, input_section, rel->r_offset, sym_name);
16532
0
      else
16533
0
        info->callbacks->einfo
16534
          /* xgettext:c-format */
16535
0
          (_("%H: call to `%pT' lacks nop, can't restore toc; "
16536
0
       "(toc save/adjust stub)\n"),
16537
0
           input_bfd, input_section, rel->r_offset, sym_name);
16538
16539
0
      bfd_set_error (bfd_error_bad_value);
16540
0
      ret = false;
16541
0
    }
16542
16543
0
        if (can_plt_call
16544
0
      && stub_entry->type.main == ppc_stub_plt_call)
16545
0
    unresolved_reloc = false;
16546
0
      }
16547
16548
0
    if ((stub_entry == NULL
16549
0
         || stub_entry->type.main == ppc_stub_long_branch
16550
0
         || stub_entry->type.main == ppc_stub_plt_branch)
16551
0
        && get_opd_info (sec) != NULL)
16552
0
      {
16553
        /* The branch destination is the value of the opd entry. */
16554
0
        bfd_vma off = (relocation + addend
16555
0
           - sec->output_section->vma
16556
0
           - sec->output_offset);
16557
0
        bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, false);
16558
0
        if (dest != (bfd_vma) -1)
16559
0
    {
16560
0
      relocation = dest;
16561
0
      addend = 0;
16562
0
      reloc_dest = DEST_OPD;
16563
0
    }
16564
0
      }
16565
16566
    /* If the branch is out of reach we ought to have a long
16567
       branch stub.  */
16568
0
    from = (rel->r_offset
16569
0
      + input_section->output_offset
16570
0
      + input_section->output_section->vma);
16571
16572
0
    relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
16573
0
              ? fdh->elf.other
16574
0
              : sym->st_other);
16575
16576
0
    if (stub_entry != NULL
16577
0
        && (stub_entry->type.main == ppc_stub_long_branch
16578
0
      || stub_entry->type.main == ppc_stub_plt_branch))
16579
0
      {
16580
0
        if (stub_entry->type.sub == ppc_stub_toc
16581
0
      && !stub_entry->type.r2save
16582
0
      && (r_type == R_PPC64_ADDR14_BRTAKEN
16583
0
          || r_type == R_PPC64_ADDR14_BRNTAKEN
16584
0
          || (relocation + addend - from + max_br_offset
16585
0
        < 2 * max_br_offset)))
16586
    /* Don't use the stub if this branch is in range.  */
16587
0
    stub_entry = NULL;
16588
16589
0
        if (stub_entry != NULL
16590
0
      && stub_entry->type.sub >= ppc_stub_notoc
16591
0
      && ((r_type != R_PPC64_REL24_NOTOC
16592
0
           && r_type != R_PPC64_REL24_P9NOTOC)
16593
0
          || ((fdh ? fdh->elf.other : sym->st_other)
16594
0
        & STO_PPC64_LOCAL_MASK) <= 1 << STO_PPC64_LOCAL_BIT)
16595
0
      && (relocation + addend - from + max_br_offset
16596
0
          < 2 * max_br_offset))
16597
0
    stub_entry = NULL;
16598
16599
0
        if (stub_entry != NULL
16600
0
      && stub_entry->type.r2save
16601
0
      && (r_type == R_PPC64_REL24_NOTOC
16602
0
          || r_type == R_PPC64_REL24_P9NOTOC)
16603
0
      && (relocation + addend - from + max_br_offset
16604
0
          < 2 * max_br_offset))
16605
0
    stub_entry = NULL;
16606
0
      }
16607
16608
0
    if (stub_entry != NULL)
16609
0
      {
16610
        /* Munge up the value and addend so that we call the stub
16611
     rather than the procedure directly.  */
16612
0
        asection *stub_sec = stub_entry->group->stub_sec;
16613
16614
0
        if (stub_entry->type.main == ppc_stub_save_res)
16615
0
    relocation += (stub_sec->output_offset
16616
0
             + stub_sec->output_section->vma
16617
0
             + stub_sec->size - htab->sfpr->size
16618
0
             - htab->sfpr->output_offset
16619
0
             - htab->sfpr->output_section->vma);
16620
0
        else
16621
0
    relocation = (stub_entry->stub_offset
16622
0
            + stub_sec->output_offset
16623
0
            + stub_sec->output_section->vma);
16624
0
        addend = 0;
16625
0
        reloc_dest = DEST_STUB;
16626
16627
0
        if (((stub_entry->type.r2save
16628
0
        && (r_type == R_PPC64_REL24_NOTOC
16629
0
      || r_type == R_PPC64_REL24_P9NOTOC))
16630
0
       || ((stub_entry->type.main == ppc_stub_plt_call
16631
0
      && (ALWAYS_EMIT_R2SAVE || stub_entry->type.r2save))
16632
0
           && rel + 1 < relend
16633
0
           && rel[1].r_offset == rel->r_offset + 4
16634
0
           && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE))
16635
0
      && !(stub_entry->type.main == ppc_stub_plt_call
16636
0
           && htab->params->tls_get_addr_opt
16637
0
           && h != NULL
16638
0
           && is_tls_get_addr (&h->elf, htab)))
16639
0
    {
16640
      /* Skip over the r2 store at the start of the stub.  */
16641
0
      relocation += 4;
16642
0
    }
16643
16644
0
        if ((r_type == R_PPC64_REL24_NOTOC
16645
0
       || r_type == R_PPC64_REL24_P9NOTOC)
16646
0
      && stub_entry->type.main == ppc_stub_plt_call
16647
0
      && stub_entry->type.sub >= ppc_stub_notoc)
16648
0
    htab->notoc_plt = 1;
16649
0
      }
16650
16651
0
    if (insn != 0)
16652
0
      {
16653
0
        if (is_isa_v2)
16654
0
    {
16655
      /* Set 'a' bit.  This is 0b00010 in BO field for branch
16656
         on CR(BI) insns (BO == 001at or 011at), and 0b01000
16657
         for branch on CTR insns (BO == 1a00t or 1a01t).  */
16658
0
      if ((insn & (0x14 << 21)) == (0x04 << 21))
16659
0
        insn |= 0x02 << 21;
16660
0
      else if ((insn & (0x14 << 21)) == (0x10 << 21))
16661
0
        insn |= 0x08 << 21;
16662
0
      else
16663
0
        break;
16664
0
    }
16665
0
        else
16666
0
    {
16667
      /* Invert 'y' bit if not the default.  */
16668
0
      if ((bfd_signed_vma) (relocation + addend - from) < 0)
16669
0
        insn ^= 0x01 << 21;
16670
0
    }
16671
16672
0
        bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16673
0
      }
16674
16675
    /* NOP out calls to undefined weak functions.
16676
       We can thus call a weak function without first
16677
       checking whether the function is defined.  */
16678
0
    else if (h != NULL
16679
0
       && h->elf.root.type == bfd_link_hash_undefweak
16680
0
       && h->elf.dynindx == -1
16681
0
       && (r_type == R_PPC64_REL24
16682
0
           || r_type == R_PPC64_REL24_NOTOC
16683
0
           || r_type == R_PPC64_REL24_P9NOTOC)
16684
0
       && relocation == 0
16685
0
       && addend == 0
16686
0
       && offset_in_range (input_section, rel->r_offset, 4))
16687
0
      {
16688
0
        bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
16689
0
        goto copy_reloc;
16690
0
      }
16691
0
    break;
16692
16693
0
  case R_PPC64_GOT16_DS:
16694
0
    if ((h ? h->elf.type : ELF_ST_TYPE (sym->st_info)) == STT_GNU_IFUNC
16695
0
        || (bfd_link_pic (info)
16696
0
      && sec == bfd_abs_section_ptr)
16697
0
        || !htab->do_toc_opt)
16698
0
      break;
16699
0
    from = TOCstart + htab->sec_info[input_section->id].toc_off;
16700
0
    if (relocation + addend - from + 0x8000 < 0x10000
16701
0
        && sec != NULL
16702
0
        && sec->output_section != NULL
16703
0
        && !discarded_section (sec)
16704
0
        && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, &h->elf))
16705
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
16706
0
      {
16707
0
        insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16708
0
        if ((insn & (0x3fu << 26 | 0x3)) == 58u << 26 /* ld */)
16709
0
    {
16710
0
      insn += (14u << 26) - (58u << 26);
16711
0
      bfd_put_32 (input_bfd, insn, contents + (rel->r_offset & ~3));
16712
0
      r_type = R_PPC64_TOC16;
16713
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16714
0
    }
16715
0
      }
16716
0
    break;
16717
16718
0
  case R_PPC64_GOT16_LO_DS:
16719
0
  case R_PPC64_GOT16_HA:
16720
0
    if ((h ? h->elf.type : ELF_ST_TYPE (sym->st_info)) == STT_GNU_IFUNC
16721
0
        || (bfd_link_pic (info)
16722
0
      && sec == bfd_abs_section_ptr)
16723
0
        || !htab->do_toc_opt)
16724
0
      break;
16725
0
    from = TOCstart + htab->sec_info[input_section->id].toc_off;
16726
0
    if (relocation + addend - from + 0x80008000ULL < 0x100000000ULL
16727
0
        && sec != NULL
16728
0
        && sec->output_section != NULL
16729
0
        && !discarded_section (sec)
16730
0
        && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, &h->elf))
16731
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
16732
0
      {
16733
0
        insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16734
0
        if (r_type == R_PPC64_GOT16_LO_DS
16735
0
      && (insn & (0x3fu << 26 | 0x3)) == 58u << 26 /* ld */)
16736
0
    {
16737
0
      insn += (14u << 26) - (58u << 26);
16738
0
      bfd_put_32 (input_bfd, insn, contents + (rel->r_offset & ~3));
16739
0
      r_type = R_PPC64_TOC16_LO;
16740
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16741
0
    }
16742
0
        else if (r_type == R_PPC64_GOT16_HA
16743
0
           && (insn & (0x3fu << 26)) == 15u << 26 /* addis */)
16744
0
    {
16745
0
      r_type = R_PPC64_TOC16_HA;
16746
0
      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16747
0
    }
16748
0
      }
16749
0
    break;
16750
16751
0
  case R_PPC64_GOT_PCREL34:
16752
0
    if ((h ? h->elf.type : ELF_ST_TYPE (sym->st_info)) == STT_GNU_IFUNC
16753
0
        || (bfd_link_pic (info)
16754
0
      && sec == bfd_abs_section_ptr)
16755
0
        || !htab->do_toc_opt)
16756
0
      break;
16757
0
    from = (rel->r_offset
16758
0
      + input_section->output_section->vma
16759
0
      + input_section->output_offset);
16760
0
    if (!(relocation - from + (1ULL << 33) < 1ULL << 34
16761
0
    && sec != NULL
16762
0
    && sec->output_section != NULL
16763
0
    && !discarded_section (sec)
16764
0
    && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, &h->elf))
16765
0
    && offset_in_range (input_section, rel->r_offset, 8)))
16766
0
      break;
16767
16768
0
    offset = rel->r_offset;
16769
0
    pinsn = bfd_get_32 (input_bfd, contents + offset);
16770
0
    pinsn <<= 32;
16771
0
    pinsn |= bfd_get_32 (input_bfd, contents + offset + 4);
16772
0
    if ((pinsn & ((-1ULL << 50) | (63ULL << 26)))
16773
0
        != ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
16774
0
      break;
16775
16776
    /* Replace with paddi.  */
16777
0
    pinsn += (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
16778
0
    r_type = R_PPC64_PCREL34;
16779
0
    rel->r_info = ELF64_R_INFO (r_symndx, r_type);
16780
0
    bfd_put_32 (input_bfd, pinsn >> 32, contents + offset);
16781
0
    bfd_put_32 (input_bfd, pinsn, contents + offset + 4);
16782
    /* Fall through.  */
16783
16784
0
  case R_PPC64_PCREL34:
16785
0
    if (!htab->params->no_pcrel_opt
16786
0
        && rel + 1 < relend
16787
0
        && rel[1].r_offset == rel->r_offset
16788
0
        && rel[1].r_info == ELF64_R_INFO (0, R_PPC64_PCREL_OPT)
16789
0
        && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, &h->elf))
16790
0
        && offset_in_range (input_section, rel->r_offset, 8))
16791
0
      {
16792
0
        offset = rel->r_offset;
16793
0
        pinsn = bfd_get_32 (input_bfd, contents + offset);
16794
0
        pinsn <<= 32;
16795
0
        pinsn |= bfd_get_32 (input_bfd, contents + offset + 4);
16796
0
        if ((pinsn & ((-1ULL << 50) | (63ULL << 26)))
16797
0
       == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
16798
0
           | (14ULL << 26) /* paddi */))
16799
0
    {
16800
0
      bfd_vma off2 = rel[1].r_addend;
16801
0
      if (off2 == 0)
16802
        /* zero means next insn.  */
16803
0
        off2 = 8;
16804
0
      off2 += offset;
16805
0
      if (offset_in_range (input_section, off2, 4))
16806
0
        {
16807
0
          uint64_t pinsn2;
16808
0
          bfd_signed_vma addend_off;
16809
0
          pinsn2 = bfd_get_32 (input_bfd, contents + off2);
16810
0
          pinsn2 <<= 32;
16811
0
          if ((pinsn2 & (63ULL << 58)) == 1ULL << 58)
16812
0
      {
16813
0
        if (!offset_in_range (input_section, off2, 8))
16814
0
          break;
16815
0
        pinsn2 |= bfd_get_32 (input_bfd,
16816
0
            contents + off2 + 4);
16817
0
      }
16818
0
          if (xlate_pcrel_opt (&pinsn, &pinsn2, &addend_off))
16819
0
      {
16820
0
        addend += addend_off;
16821
0
        rel->r_addend = addend;
16822
0
        bfd_put_32 (input_bfd, pinsn >> 32,
16823
0
              contents + offset);
16824
0
        bfd_put_32 (input_bfd, pinsn,
16825
0
              contents + offset + 4);
16826
0
        bfd_put_32 (input_bfd, pinsn2 >> 32,
16827
0
              contents + off2);
16828
0
        if ((pinsn2 & (63ULL << 58)) == 1ULL << 58)
16829
0
          bfd_put_32 (input_bfd, pinsn2,
16830
0
          contents + off2 + 4);
16831
0
      }
16832
0
        }
16833
0
    }
16834
0
      }
16835
0
    break;
16836
0
  }
16837
16838
0
      tls_type = 0;
16839
0
      save_unresolved_reloc = unresolved_reloc;
16840
0
      switch (r_type)
16841
0
  {
16842
0
  default:
16843
    /* xgettext:c-format */
16844
0
    _bfd_error_handler (_("%pB: %s unsupported"),
16845
0
            input_bfd, ppc64_elf_howto_table[r_type]->name);
16846
16847
0
    bfd_set_error (bfd_error_bad_value);
16848
0
    ret = false;
16849
0
    goto copy_reloc;
16850
16851
0
  case R_PPC64_NONE:
16852
0
  case R_PPC64_TLS:
16853
0
  case R_PPC64_TLSGD:
16854
0
  case R_PPC64_TLSLD:
16855
0
  case R_PPC64_TOCSAVE:
16856
0
  case R_PPC64_GNU_VTINHERIT:
16857
0
  case R_PPC64_GNU_VTENTRY:
16858
0
  case R_PPC64_ENTRY:
16859
0
  case R_PPC64_PCREL_OPT:
16860
0
    goto copy_reloc;
16861
16862
    /* GOT16 relocations.  Like an ADDR16 using the symbol's
16863
       address in the GOT as relocation value instead of the
16864
       symbol's value itself.  Also, create a GOT entry for the
16865
       symbol and put the symbol value there.  */
16866
0
  case R_PPC64_GOT_TLSGD16:
16867
0
  case R_PPC64_GOT_TLSGD16_LO:
16868
0
  case R_PPC64_GOT_TLSGD16_HI:
16869
0
  case R_PPC64_GOT_TLSGD16_HA:
16870
0
  case R_PPC64_GOT_TLSGD_PCREL34:
16871
0
    tls_type = TLS_TLS | TLS_GD;
16872
0
    goto dogot;
16873
16874
0
  case R_PPC64_GOT_TLSLD16:
16875
0
  case R_PPC64_GOT_TLSLD16_LO:
16876
0
  case R_PPC64_GOT_TLSLD16_HI:
16877
0
  case R_PPC64_GOT_TLSLD16_HA:
16878
0
  case R_PPC64_GOT_TLSLD_PCREL34:
16879
0
    tls_type = TLS_TLS | TLS_LD;
16880
0
    goto dogot;
16881
16882
0
  case R_PPC64_GOT_TPREL16_DS:
16883
0
  case R_PPC64_GOT_TPREL16_LO_DS:
16884
0
  case R_PPC64_GOT_TPREL16_HI:
16885
0
  case R_PPC64_GOT_TPREL16_HA:
16886
0
  case R_PPC64_GOT_TPREL_PCREL34:
16887
0
    tls_type = TLS_TLS | TLS_TPREL;
16888
0
    goto dogot;
16889
16890
0
  case R_PPC64_GOT_DTPREL16_DS:
16891
0
  case R_PPC64_GOT_DTPREL16_LO_DS:
16892
0
  case R_PPC64_GOT_DTPREL16_HI:
16893
0
  case R_PPC64_GOT_DTPREL16_HA:
16894
0
  case R_PPC64_GOT_DTPREL_PCREL34:
16895
0
    tls_type = TLS_TLS | TLS_DTPREL;
16896
0
    goto dogot;
16897
16898
0
  case R_PPC64_GOT16:
16899
0
  case R_PPC64_GOT16_LO:
16900
0
  case R_PPC64_GOT16_HI:
16901
0
  case R_PPC64_GOT16_HA:
16902
0
  case R_PPC64_GOT16_DS:
16903
0
  case R_PPC64_GOT16_LO_DS:
16904
0
  case R_PPC64_GOT_PCREL34:
16905
0
  dogot:
16906
0
    {
16907
      /* Relocation is to the entry for this symbol in the global
16908
         offset table.  */
16909
0
      asection *got;
16910
0
      bfd_vma *offp;
16911
0
      bfd_vma off;
16912
0
      unsigned long indx = 0;
16913
0
      struct got_entry *ent;
16914
16915
0
      if (tls_type == (TLS_TLS | TLS_LD)
16916
0
    && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
16917
0
        ent = ppc64_tlsld_got (input_bfd);
16918
0
      else
16919
0
        {
16920
0
    if (h != NULL)
16921
0
      {
16922
0
        if (!htab->elf.dynamic_sections_created
16923
0
      || h->elf.dynindx == -1
16924
0
      || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
16925
0
      || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
16926
          /* This is actually a static link, or it is a
16927
       -Bsymbolic link and the symbol is defined
16928
       locally, or the symbol was forced to be local
16929
       because of a version file.  */
16930
0
          ;
16931
0
        else
16932
0
          {
16933
0
      indx = h->elf.dynindx;
16934
0
      unresolved_reloc = false;
16935
0
          }
16936
0
        ent = h->elf.got.glist;
16937
0
      }
16938
0
    else
16939
0
      {
16940
0
        if (local_got_ents == NULL)
16941
0
          abort ();
16942
0
        ent = local_got_ents[r_symndx];
16943
0
      }
16944
16945
0
    for (; ent != NULL; ent = ent->next)
16946
0
      if (ent->addend == orig_rel.r_addend
16947
0
          && ent->owner == input_bfd
16948
0
          && ent->tls_type == tls_type)
16949
0
        break;
16950
0
        }
16951
16952
0
      if (ent == NULL)
16953
0
        abort ();
16954
0
      if (ent->is_indirect)
16955
0
        ent = ent->got.ent;
16956
0
      offp = &ent->got.offset;
16957
0
      got = ppc64_elf_tdata (ent->owner)->got;
16958
0
      if (got == NULL)
16959
0
        abort ();
16960
16961
      /* The offset must always be a multiple of 8.  We use the
16962
         least significant bit to record whether we have already
16963
         processed this entry.  */
16964
0
      off = *offp;
16965
0
      if ((off & 1) != 0)
16966
0
        off &= ~1;
16967
0
      else
16968
0
        {
16969
    /* Generate relocs for the dynamic linker, except in
16970
       the case of TLSLD where we'll use one entry per
16971
       module.  */
16972
0
    asection *relgot;
16973
0
    bool ifunc;
16974
16975
0
    *offp = off | 1;
16976
0
    relgot = NULL;
16977
0
    ifunc = (h != NULL
16978
0
       ? h->elf.type == STT_GNU_IFUNC
16979
0
       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
16980
0
    if (ifunc)
16981
0
      {
16982
0
        relgot = htab->elf.irelplt;
16983
0
        if (indx == 0 || is_static_defined (&h->elf))
16984
0
          htab->elf.ifunc_resolvers = true;
16985
0
      }
16986
0
    else if (indx != 0
16987
0
       || (bfd_link_pic (info)
16988
0
           && (h == NULL
16989
0
         || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
16990
0
           && !(tls_type != 0
16991
0
          && bfd_link_executable (info)
16992
0
          && (h == NULL
16993
0
              || SYMBOL_REFERENCES_LOCAL (info,
16994
0
                  &h->elf)))
16995
0
           && (h != NULL
16996
0
         ? !bfd_is_abs_symbol (&h->elf.root)
16997
0
         : sym->st_shndx != SHN_ABS)))
16998
16999
0
      relgot = ppc64_elf_tdata (ent->owner)->relgot;
17000
0
    if (relgot != NULL)
17001
0
      {
17002
0
        outrel.r_offset = (got->output_section->vma
17003
0
               + got->output_offset
17004
0
               + off);
17005
0
        outrel.r_addend = orig_rel.r_addend;
17006
0
        if (tls_type & (TLS_LD | TLS_GD))
17007
0
          {
17008
0
      outrel.r_addend = 0;
17009
0
      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
17010
0
      if (tls_type == (TLS_TLS | TLS_GD))
17011
0
        {
17012
0
          BFD_ASSERT (count_and_swap_reloc_out (output_bfd,
17013
0
                  &outrel,
17014
0
                  relgot));
17015
0
          outrel.r_offset += 8;
17016
0
          outrel.r_addend = orig_rel.r_addend;
17017
0
          outrel.r_info
17018
0
            = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
17019
0
        }
17020
0
          }
17021
0
        else if (tls_type == (TLS_TLS | TLS_DTPREL))
17022
0
          outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
17023
0
        else if (tls_type == (TLS_TLS | TLS_TPREL))
17024
0
          outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
17025
0
        else if (indx != 0)
17026
0
          outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
17027
0
        else
17028
0
          {
17029
0
      if (ifunc)
17030
0
        outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
17031
0
      else
17032
0
        outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
17033
17034
      /* Write the .got section contents for the sake
17035
         of prelink.  */
17036
0
      loc = got->contents + off;
17037
0
      bfd_put_64 (output_bfd, outrel.r_addend + relocation,
17038
0
            loc);
17039
0
          }
17040
17041
0
        if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
17042
0
          {
17043
0
      outrel.r_addend += relocation;
17044
0
      if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
17045
0
        {
17046
0
          if (htab->elf.tls_sec == NULL)
17047
0
            outrel.r_addend = 0;
17048
0
          else
17049
0
            outrel.r_addend -= htab->elf.tls_sec->vma;
17050
0
        }
17051
0
          }
17052
0
        if (!(info->enable_dt_relr
17053
0
        && ELF64_R_TYPE (outrel.r_info) == R_PPC64_RELATIVE))
17054
0
          BFD_ASSERT (count_and_swap_reloc_out (output_bfd,
17055
0
                  &outrel, relgot));
17056
0
      }
17057
17058
    /* Init the .got section contents here if we're not
17059
       emitting a reloc.  */
17060
0
    else
17061
0
      {
17062
0
        relocation += orig_rel.r_addend;
17063
0
        if (tls_type != 0)
17064
0
          {
17065
0
      if (htab->elf.tls_sec == NULL)
17066
0
        relocation = 0;
17067
0
      else
17068
0
        {
17069
0
          if (tls_type & TLS_LD)
17070
0
            relocation = 0;
17071
0
          else
17072
0
            relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
17073
0
          if (tls_type & TLS_TPREL)
17074
0
            relocation += DTP_OFFSET - TP_OFFSET;
17075
0
        }
17076
17077
0
      if (tls_type & (TLS_GD | TLS_LD))
17078
0
        {
17079
0
          bfd_put_64 (output_bfd, relocation,
17080
0
          got->contents + off + 8);
17081
0
          relocation = 1;
17082
0
        }
17083
0
          }
17084
0
        bfd_put_64 (output_bfd, relocation,
17085
0
        got->contents + off);
17086
0
      }
17087
0
        }
17088
17089
0
      if (off >= (bfd_vma) -2)
17090
0
        abort ();
17091
17092
0
      relocation = got->output_section->vma + got->output_offset + off;
17093
0
      addend = 0;
17094
0
      if (!(r_type == R_PPC64_GOT_PCREL34
17095
0
      || r_type == R_PPC64_GOT_TLSGD_PCREL34
17096
0
      || r_type == R_PPC64_GOT_TLSLD_PCREL34
17097
0
      || r_type == R_PPC64_GOT_TPREL_PCREL34
17098
0
      || r_type == R_PPC64_GOT_DTPREL_PCREL34))
17099
0
        addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
17100
0
    }
17101
0
    break;
17102
17103
0
  case R_PPC64_PLT16_HA:
17104
0
  case R_PPC64_PLT16_HI:
17105
0
  case R_PPC64_PLT16_LO:
17106
0
  case R_PPC64_PLT16_LO_DS:
17107
0
  case R_PPC64_PLT_PCREL34:
17108
0
  case R_PPC64_PLT_PCREL34_NOTOC:
17109
0
  case R_PPC64_PLT32:
17110
0
  case R_PPC64_PLT64:
17111
0
  case R_PPC64_PLTSEQ:
17112
0
  case R_PPC64_PLTSEQ_NOTOC:
17113
0
  case R_PPC64_PLTCALL:
17114
0
  case R_PPC64_PLTCALL_NOTOC:
17115
    /* Relocation is to the entry for this symbol in the
17116
       procedure linkage table.  */
17117
0
    unresolved_reloc = true;
17118
0
    {
17119
0
      struct plt_entry **plt_list = NULL;
17120
0
      if (h != NULL)
17121
0
        plt_list = &h->elf.plt.plist;
17122
0
      else if (local_got_ents != NULL)
17123
0
        {
17124
0
    struct plt_entry **local_plt = (struct plt_entry **)
17125
0
      (local_got_ents + symtab_hdr->sh_info);
17126
0
    plt_list = local_plt + r_symndx;
17127
0
        }
17128
0
      if (plt_list)
17129
0
        {
17130
0
    struct plt_entry *ent;
17131
17132
0
    for (ent = *plt_list; ent != NULL; ent = ent->next)
17133
0
      if (ent->plt.offset != (bfd_vma) -1
17134
0
          && ent->addend == orig_rel.r_addend)
17135
0
        {
17136
0
          asection *plt;
17137
0
          bfd_vma got;
17138
17139
0
          plt = htab->elf.splt;
17140
0
          if (use_local_plt (info, elf_hash_entry (h)))
17141
0
      {
17142
0
        if (h != NULL
17143
0
            ? h->elf.type == STT_GNU_IFUNC
17144
0
            : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
17145
0
          plt = htab->elf.iplt;
17146
0
        else
17147
0
          plt = htab->pltlocal;
17148
0
      }
17149
0
          relocation = (plt->output_section->vma
17150
0
            + plt->output_offset
17151
0
            + ent->plt.offset);
17152
0
          if (r_type == R_PPC64_PLT16_HA
17153
0
        || r_type == R_PPC64_PLT16_HI
17154
0
        || r_type == R_PPC64_PLT16_LO
17155
0
        || r_type == R_PPC64_PLT16_LO_DS)
17156
0
      {
17157
0
        got = (elf_gp (output_bfd)
17158
0
         + htab->sec_info[input_section->id].toc_off);
17159
0
        relocation -= got;
17160
0
      }
17161
0
          addend = 0;
17162
0
          unresolved_reloc = false;
17163
0
          break;
17164
0
        }
17165
0
        }
17166
0
    }
17167
0
    break;
17168
17169
0
  case R_PPC64_TOC:
17170
    /* Relocation value is TOC base.  */
17171
0
    relocation = TOCstart;
17172
0
    if (r_symndx == STN_UNDEF)
17173
0
      relocation += htab->sec_info[input_section->id].toc_off;
17174
0
    else if (unresolved_reloc)
17175
0
      ;
17176
0
    else if (sec != NULL && sec->id < htab->sec_info_arr_size)
17177
0
      relocation += htab->sec_info[sec->id].toc_off;
17178
0
    else
17179
0
      unresolved_reloc = true;
17180
0
    if (unresolved_reloc
17181
0
        || (!is_opd
17182
0
      && h != NULL
17183
0
      && !SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
17184
0
      info->callbacks->einfo
17185
        /* xgettext:c-format */
17186
0
        (_("%H: %s against %pT is not supported\n"),
17187
0
         input_bfd, input_section, rel->r_offset,
17188
0
         ppc64_elf_howto_table[r_type]->name, sym_name);
17189
0
    goto dodyn;
17190
17191
    /* TOC16 relocs.  We want the offset relative to the TOC base,
17192
       which is the address of the start of the TOC plus 0x8000.
17193
       The TOC consists of sections .got, .toc, .tocbss, and .plt,
17194
       in this order.  */
17195
0
  case R_PPC64_TOC16:
17196
0
  case R_PPC64_TOC16_LO:
17197
0
  case R_PPC64_TOC16_HI:
17198
0
  case R_PPC64_TOC16_DS:
17199
0
  case R_PPC64_TOC16_LO_DS:
17200
0
  case R_PPC64_TOC16_HA:
17201
0
    addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
17202
0
    if (h != NULL)
17203
0
      goto dodyn;
17204
0
    break;
17205
17206
    /* Relocate against the beginning of the section.  */
17207
0
  case R_PPC64_SECTOFF:
17208
0
  case R_PPC64_SECTOFF_LO:
17209
0
  case R_PPC64_SECTOFF_HI:
17210
0
  case R_PPC64_SECTOFF_DS:
17211
0
  case R_PPC64_SECTOFF_LO_DS:
17212
0
  case R_PPC64_SECTOFF_HA:
17213
0
    if (sec != NULL)
17214
0
      addend -= sec->output_section->vma;
17215
0
    break;
17216
17217
0
  case R_PPC64_REL16:
17218
0
  case R_PPC64_REL16_LO:
17219
0
  case R_PPC64_REL16_HI:
17220
0
  case R_PPC64_REL16_HA:
17221
0
  case R_PPC64_REL16_HIGH:
17222
0
  case R_PPC64_REL16_HIGHA:
17223
0
  case R_PPC64_REL16_HIGHER:
17224
0
  case R_PPC64_REL16_HIGHERA:
17225
0
  case R_PPC64_REL16_HIGHEST:
17226
0
  case R_PPC64_REL16_HIGHESTA:
17227
0
  case R_PPC64_REL16_HIGHER34:
17228
0
  case R_PPC64_REL16_HIGHERA34:
17229
0
  case R_PPC64_REL16_HIGHEST34:
17230
0
  case R_PPC64_REL16_HIGHESTA34:
17231
0
  case R_PPC64_REL16DX_HA:
17232
0
  case R_PPC64_REL14:
17233
0
  case R_PPC64_REL14_BRNTAKEN:
17234
0
  case R_PPC64_REL14_BRTAKEN:
17235
0
  case R_PPC64_REL24:
17236
0
  case R_PPC64_REL24_NOTOC:
17237
0
  case R_PPC64_REL24_P9NOTOC:
17238
0
  case R_PPC64_PCREL34:
17239
0
  case R_PPC64_PCREL28:
17240
0
    break;
17241
17242
0
  case R_PPC64_TPREL16:
17243
0
  case R_PPC64_TPREL16_LO:
17244
0
  case R_PPC64_TPREL16_HI:
17245
0
  case R_PPC64_TPREL16_HA:
17246
0
  case R_PPC64_TPREL16_DS:
17247
0
  case R_PPC64_TPREL16_LO_DS:
17248
0
  case R_PPC64_TPREL16_HIGH:
17249
0
  case R_PPC64_TPREL16_HIGHA:
17250
0
  case R_PPC64_TPREL16_HIGHER:
17251
0
  case R_PPC64_TPREL16_HIGHERA:
17252
0
  case R_PPC64_TPREL16_HIGHEST:
17253
0
  case R_PPC64_TPREL16_HIGHESTA:
17254
0
    if (h != NULL
17255
0
        && h->elf.root.type == bfd_link_hash_undefweak
17256
0
        && h->elf.dynindx == -1
17257
0
        && offset_in_range (input_section, rel->r_offset - d_offset, 4))
17258
0
      {
17259
        /* Make this relocation against an undefined weak symbol
17260
     resolve to zero.  This is really just a tweak, since
17261
     code using weak externs ought to check that they are
17262
     defined before using them.  */
17263
0
        bfd_byte *p = contents + rel->r_offset - d_offset;
17264
17265
0
        insn = bfd_get_32 (input_bfd, p);
17266
0
        insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
17267
0
        if (insn != 0)
17268
0
    bfd_put_32 (input_bfd, insn, p);
17269
0
        break;
17270
0
      }
17271
    /* Fall through.  */
17272
17273
0
  case R_PPC64_TPREL34:
17274
0
    if (htab->elf.tls_sec != NULL)
17275
0
      addend -= htab->elf.tls_sec->vma + TP_OFFSET;
17276
    /* The TPREL16 relocs shouldn't really be used in shared
17277
       libs or with non-local symbols as that will result in
17278
       DT_TEXTREL being set, but support them anyway.  */
17279
0
    goto dodyn;
17280
17281
0
  case R_PPC64_DTPREL16:
17282
0
  case R_PPC64_DTPREL16_LO:
17283
0
  case R_PPC64_DTPREL16_HI:
17284
0
  case R_PPC64_DTPREL16_HA:
17285
0
  case R_PPC64_DTPREL16_DS:
17286
0
  case R_PPC64_DTPREL16_LO_DS:
17287
0
  case R_PPC64_DTPREL16_HIGH:
17288
0
  case R_PPC64_DTPREL16_HIGHA:
17289
0
  case R_PPC64_DTPREL16_HIGHER:
17290
0
  case R_PPC64_DTPREL16_HIGHERA:
17291
0
  case R_PPC64_DTPREL16_HIGHEST:
17292
0
  case R_PPC64_DTPREL16_HIGHESTA:
17293
0
  case R_PPC64_DTPREL34:
17294
0
    if (htab->elf.tls_sec != NULL)
17295
0
      addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
17296
0
    break;
17297
17298
0
  case R_PPC64_ADDR64_LOCAL:
17299
0
    addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
17300
0
                ? h->elf.other
17301
0
                : sym->st_other);
17302
0
    break;
17303
17304
0
  case R_PPC64_DTPMOD64:
17305
0
    relocation = 1;
17306
0
    addend = 0;
17307
0
    goto dodyn;
17308
17309
0
  case R_PPC64_TPREL64:
17310
0
    if (htab->elf.tls_sec != NULL)
17311
0
      addend -= htab->elf.tls_sec->vma + TP_OFFSET;
17312
0
    goto dodyn;
17313
17314
0
  case R_PPC64_DTPREL64:
17315
0
    if (htab->elf.tls_sec != NULL)
17316
0
      addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
17317
    /* Fall through.  */
17318
17319
    /* Relocations that may need to be propagated if this is a
17320
       dynamic object.  */
17321
0
  case R_PPC64_REL30:
17322
0
  case R_PPC64_REL32:
17323
0
  case R_PPC64_REL64:
17324
0
  case R_PPC64_ADDR14:
17325
0
  case R_PPC64_ADDR14_BRNTAKEN:
17326
0
  case R_PPC64_ADDR14_BRTAKEN:
17327
0
  case R_PPC64_ADDR16:
17328
0
  case R_PPC64_ADDR16_DS:
17329
0
  case R_PPC64_ADDR16_HA:
17330
0
  case R_PPC64_ADDR16_HI:
17331
0
  case R_PPC64_ADDR16_HIGH:
17332
0
  case R_PPC64_ADDR16_HIGHA:
17333
0
  case R_PPC64_ADDR16_HIGHER:
17334
0
  case R_PPC64_ADDR16_HIGHERA:
17335
0
  case R_PPC64_ADDR16_HIGHEST:
17336
0
  case R_PPC64_ADDR16_HIGHESTA:
17337
0
  case R_PPC64_ADDR16_LO:
17338
0
  case R_PPC64_ADDR16_LO_DS:
17339
0
  case R_PPC64_ADDR16_HIGHER34:
17340
0
  case R_PPC64_ADDR16_HIGHERA34:
17341
0
  case R_PPC64_ADDR16_HIGHEST34:
17342
0
  case R_PPC64_ADDR16_HIGHESTA34:
17343
0
  case R_PPC64_ADDR24:
17344
0
  case R_PPC64_ADDR32:
17345
0
  case R_PPC64_ADDR64:
17346
0
  case R_PPC64_UADDR16:
17347
0
  case R_PPC64_UADDR32:
17348
0
  case R_PPC64_UADDR64:
17349
0
  case R_PPC64_D34:
17350
0
  case R_PPC64_D34_LO:
17351
0
  case R_PPC64_D34_HI30:
17352
0
  case R_PPC64_D34_HA30:
17353
0
  case R_PPC64_D28:
17354
0
  dodyn:
17355
0
    if ((input_section->flags & SEC_ALLOC) == 0)
17356
0
      break;
17357
17358
0
    if (NO_OPD_RELOCS && is_opd)
17359
0
      break;
17360
17361
0
    if (bfd_link_pic (info)
17362
0
        ? ((h == NULL
17363
0
      || h->elf.dyn_relocs != NULL)
17364
0
     && ((h != NULL && pc_dynrelocs (h))
17365
0
         || must_be_dyn_reloc (info, r_type)))
17366
0
        : (h != NULL
17367
0
     ? h->elf.dyn_relocs != NULL
17368
0
     : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
17369
0
      {
17370
0
        bool skip, relocate;
17371
0
        asection *sreloc;
17372
0
        bfd_vma out_off;
17373
0
        long indx = 0;
17374
17375
        /* When generating a dynamic object, these relocations
17376
     are copied into the output file to be resolved at run
17377
     time.  */
17378
17379
0
        skip = false;
17380
0
        relocate = false;
17381
17382
0
        out_off = _bfd_elf_section_offset (output_bfd, info,
17383
0
             input_section, rel->r_offset);
17384
0
        if (out_off == (bfd_vma) -1)
17385
0
    skip = true;
17386
0
        else if (out_off == (bfd_vma) -2)
17387
0
    skip = true, relocate = true;
17388
0
        out_off += (input_section->output_section->vma
17389
0
        + input_section->output_offset);
17390
0
        outrel.r_offset = out_off;
17391
0
        outrel.r_addend = rel->r_addend;
17392
17393
        /* Optimize unaligned reloc use.  */
17394
0
        if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
17395
0
      || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
17396
0
    r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
17397
0
        else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
17398
0
           || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
17399
0
    r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
17400
0
        else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
17401
0
           || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
17402
0
    r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
17403
17404
0
        if (skip)
17405
0
    memset (&outrel, 0, sizeof outrel);
17406
0
        else if (h != NULL
17407
0
           && !SYMBOL_REFERENCES_LOCAL (info, &h->elf)
17408
0
           && !is_opd
17409
0
           && r_type != R_PPC64_TOC)
17410
0
    {
17411
0
      indx = h->elf.dynindx;
17412
0
      BFD_ASSERT (indx != -1);
17413
0
      outrel.r_info = ELF64_R_INFO (indx, r_type);
17414
0
    }
17415
0
        else
17416
0
    {
17417
      /* This symbol is local, or marked to become local,
17418
         or this is an opd section reloc which must point
17419
         at a local function.  */
17420
0
      outrel.r_addend += relocation;
17421
0
      if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
17422
0
        {
17423
0
          if (is_opd && h != NULL)
17424
0
      {
17425
        /* Lie about opd entries.  This case occurs
17426
           when building shared libraries and we
17427
           reference a function in another shared
17428
           lib.  The same thing happens for a weak
17429
           definition in an application that's
17430
           overridden by a strong definition in a
17431
           shared lib.  (I believe this is a generic
17432
           bug in binutils handling of weak syms.)
17433
           In these cases we won't use the opd
17434
           entry in this lib.  */
17435
0
        unresolved_reloc = false;
17436
0
      }
17437
0
          if (!is_opd
17438
0
        && r_type == R_PPC64_ADDR64
17439
0
        && (h != NULL
17440
0
            ? h->elf.type == STT_GNU_IFUNC
17441
0
            : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
17442
0
      outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
17443
0
          else
17444
0
      {
17445
0
        outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
17446
17447
        /* We need to relocate .opd contents for ld.so.
17448
           Prelink also wants simple and consistent rules
17449
           for relocs.  This make all RELATIVE relocs have
17450
           *r_offset equal to r_addend.  */
17451
0
        relocate = true;
17452
0
      }
17453
0
        }
17454
0
      else
17455
0
        {
17456
0
          if (h != NULL
17457
0
        ? h->elf.type == STT_GNU_IFUNC
17458
0
        : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
17459
0
      {
17460
0
        info->callbacks->einfo
17461
          /* xgettext:c-format */
17462
0
          (_("%H: %s for indirect "
17463
0
             "function `%pT' unsupported\n"),
17464
0
           input_bfd, input_section, rel->r_offset,
17465
0
           ppc64_elf_howto_table[r_type]->name,
17466
0
           sym_name);
17467
0
        ret = false;
17468
0
      }
17469
0
          else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
17470
0
      ;
17471
0
          else if (sec == NULL || sec->owner == NULL)
17472
0
      {
17473
0
        bfd_set_error (bfd_error_bad_value);
17474
0
        return false;
17475
0
      }
17476
0
          else
17477
0
      {
17478
0
        asection *osec = sec->output_section;
17479
17480
0
        if ((osec->flags & SEC_THREAD_LOCAL) != 0)
17481
0
          {
17482
            /* TLS symbol values are relative to the
17483
         TLS segment.  Dynamic relocations for
17484
         local TLS symbols therefore can't be
17485
         reduced to a relocation against their
17486
         section symbol because it holds the
17487
         address of the section, not a value
17488
         relative to the TLS segment.  We could
17489
         change the .tdata dynamic section symbol
17490
         to be zero value but STN_UNDEF works
17491
         and is used elsewhere, eg. for TPREL64
17492
         GOT relocs against local TLS symbols.  */
17493
0
            osec = htab->elf.tls_sec;
17494
0
            indx = 0;
17495
0
          }
17496
0
        else
17497
0
          {
17498
0
            indx = elf_section_data (osec)->dynindx;
17499
0
            if (indx == 0)
17500
0
        {
17501
0
          if ((osec->flags & SEC_READONLY) == 0
17502
0
              && htab->elf.data_index_section != NULL)
17503
0
            osec = htab->elf.data_index_section;
17504
0
          else
17505
0
            osec = htab->elf.text_index_section;
17506
0
          indx = elf_section_data (osec)->dynindx;
17507
0
        }
17508
0
            BFD_ASSERT (indx != 0);
17509
0
          }
17510
17511
        /* We are turning this relocation into one
17512
           against a section symbol, so subtract out
17513
           the output section's address but not the
17514
           offset of the input section in the output
17515
           section.  */
17516
0
        outrel.r_addend -= osec->vma;
17517
0
      }
17518
17519
0
          outrel.r_info = ELF64_R_INFO (indx, r_type);
17520
0
        }
17521
0
    }
17522
17523
0
        if (!(info->enable_dt_relr
17524
0
        && ELF64_R_TYPE (outrel.r_info) == R_PPC64_RELATIVE
17525
0
        && maybe_relr (ELF64_R_TYPE (orig_rel.r_info),
17526
0
           rel, input_section)))
17527
0
    {
17528
0
      sreloc = elf_section_data (input_section)->sreloc;
17529
0
      if (h != NULL
17530
0
          ? h->elf.type == STT_GNU_IFUNC
17531
0
          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
17532
0
        {
17533
0
          sreloc = htab->elf.irelplt;
17534
0
          if (indx == 0 || is_static_defined (&h->elf))
17535
0
      htab->elf.ifunc_resolvers = true;
17536
0
        }
17537
0
      if (sreloc == NULL)
17538
0
        abort ();
17539
17540
0
      BFD_ASSERT (count_and_swap_reloc_out (output_bfd, &outrel,
17541
0
              sreloc));
17542
0
    }
17543
17544
0
        if (!warned_dynamic
17545
0
      && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel.r_info)))
17546
0
    {
17547
0
      info->callbacks->einfo
17548
        /* xgettext:c-format */
17549
0
        (_("%X%P: %pB: %s against %pT "
17550
0
           "is not supported by glibc as a dynamic relocation\n"),
17551
0
         input_bfd,
17552
0
         ppc64_elf_howto_table[ELF64_R_TYPE (outrel.r_info)]->name,
17553
0
         sym_name);
17554
0
      warned_dynamic = true;
17555
0
    }
17556
17557
        /* If this reloc is against an external symbol, it will
17558
     be computed at runtime, so there's no need to do
17559
     anything now.  However, for the sake of prelink ensure
17560
     that the section contents are a known value.  */
17561
0
        if (!relocate)
17562
0
    {
17563
0
      unresolved_reloc = false;
17564
      /* The value chosen here is quite arbitrary as ld.so
17565
         ignores section contents except for the special
17566
         case of .opd where the contents might be accessed
17567
         before relocation.  Choose zero, as that won't
17568
         cause reloc overflow.  */
17569
0
      relocation = 0;
17570
0
      addend = 0;
17571
      /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
17572
         to improve backward compatibility with older
17573
         versions of ld.  */
17574
0
      if (r_type == R_PPC64_ADDR64)
17575
0
        addend = outrel.r_addend;
17576
      /* Adjust pc_relative relocs to have zero in *r_offset.  */
17577
0
      else if (ppc64_elf_howto_table[r_type]->pc_relative)
17578
0
        addend = outrel.r_offset;
17579
0
    }
17580
0
      }
17581
0
    break;
17582
17583
0
  case R_PPC64_COPY:
17584
0
  case R_PPC64_GLOB_DAT:
17585
0
  case R_PPC64_JMP_SLOT:
17586
0
  case R_PPC64_JMP_IREL:
17587
0
  case R_PPC64_RELATIVE:
17588
    /* We shouldn't ever see these dynamic relocs in relocatable
17589
       files.  */
17590
    /* Fall through.  */
17591
17592
0
  case R_PPC64_PLTGOT16:
17593
0
  case R_PPC64_PLTGOT16_DS:
17594
0
  case R_PPC64_PLTGOT16_HA:
17595
0
  case R_PPC64_PLTGOT16_HI:
17596
0
  case R_PPC64_PLTGOT16_LO:
17597
0
  case R_PPC64_PLTGOT16_LO_DS:
17598
0
  case R_PPC64_PLTREL32:
17599
0
  case R_PPC64_PLTREL64:
17600
    /* These ones haven't been implemented yet.  */
17601
17602
0
    info->callbacks->einfo
17603
      /* xgettext:c-format */
17604
0
      (_("%P: %pB: %s is not supported for `%pT'\n"),
17605
0
       input_bfd,
17606
0
       ppc64_elf_howto_table[r_type]->name, sym_name);
17607
17608
0
    bfd_set_error (bfd_error_invalid_operation);
17609
0
    ret = false;
17610
0
    goto copy_reloc;
17611
0
  }
17612
17613
      /* Multi-instruction sequences that access the TOC can be
17614
   optimized, eg. addis ra,r2,0; addi rb,ra,x;
17615
   to   nop;         addi rb,r2,x;  */
17616
0
      switch (r_type)
17617
0
  {
17618
0
  default:
17619
0
    break;
17620
17621
0
  case R_PPC64_GOT_TLSLD16_HI:
17622
0
  case R_PPC64_GOT_TLSGD16_HI:
17623
0
  case R_PPC64_GOT_TPREL16_HI:
17624
0
  case R_PPC64_GOT_DTPREL16_HI:
17625
0
  case R_PPC64_GOT16_HI:
17626
0
  case R_PPC64_TOC16_HI:
17627
    /* These relocs would only be useful if building up an
17628
       offset to later add to r2, perhaps in an indexed
17629
       addressing mode instruction.  Don't try to optimize.
17630
       Unfortunately, the possibility of someone building up an
17631
       offset like this or even with the HA relocs, means that
17632
       we need to check the high insn when optimizing the low
17633
       insn.  */
17634
0
    break;
17635
17636
0
  case R_PPC64_PLTCALL_NOTOC:
17637
0
    if (!unresolved_reloc)
17638
0
      htab->notoc_plt = 1;
17639
    /* Fall through.  */
17640
0
  case R_PPC64_PLTCALL:
17641
0
    if (unresolved_reloc
17642
0
        && offset_in_range (input_section, rel->r_offset,
17643
0
          r_type == R_PPC64_PLTCALL ? 8 : 4))
17644
0
      {
17645
        /* No plt entry.  Make this into a direct call.  */
17646
0
        bfd_byte *p = contents + rel->r_offset;
17647
0
        insn = bfd_get_32 (input_bfd, p);
17648
0
        insn &= 1;
17649
0
        bfd_put_32 (input_bfd, B_DOT | insn, p);
17650
0
        if (r_type == R_PPC64_PLTCALL)
17651
0
    bfd_put_32 (input_bfd, NOP, p + 4);
17652
0
        unresolved_reloc = save_unresolved_reloc;
17653
0
        r_type = R_PPC64_REL24;
17654
0
      }
17655
0
    break;
17656
17657
0
  case R_PPC64_PLTSEQ_NOTOC:
17658
0
  case R_PPC64_PLTSEQ:
17659
0
    if (unresolved_reloc)
17660
0
      {
17661
0
        unresolved_reloc = false;
17662
0
        goto nop_it;
17663
0
      }
17664
0
    break;
17665
17666
0
  case R_PPC64_PLT_PCREL34_NOTOC:
17667
0
    if (!unresolved_reloc)
17668
0
      htab->notoc_plt = 1;
17669
    /* Fall through.  */
17670
0
  case R_PPC64_PLT_PCREL34:
17671
0
    if (unresolved_reloc
17672
0
        && offset_in_range (input_section, rel->r_offset, 8))
17673
0
      {
17674
0
        bfd_byte *p = contents + rel->r_offset;
17675
0
        bfd_put_32 (input_bfd, PNOP >> 32, p);
17676
0
        bfd_put_32 (input_bfd, PNOP, p + 4);
17677
0
        unresolved_reloc = false;
17678
0
        goto copy_reloc;
17679
0
      }
17680
0
    break;
17681
17682
0
  case R_PPC64_PLT16_HA:
17683
0
    if (unresolved_reloc)
17684
0
      {
17685
0
        unresolved_reloc = false;
17686
0
        goto nop_it;
17687
0
      }
17688
    /* Fall through.  */
17689
0
  case R_PPC64_GOT_TLSLD16_HA:
17690
0
  case R_PPC64_GOT_TLSGD16_HA:
17691
0
  case R_PPC64_GOT_TPREL16_HA:
17692
0
  case R_PPC64_GOT_DTPREL16_HA:
17693
0
  case R_PPC64_GOT16_HA:
17694
0
  case R_PPC64_TOC16_HA:
17695
0
    if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
17696
0
        && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn
17697
0
        && !(bfd_link_pic (info)
17698
0
       && (h != NULL
17699
0
           ? bfd_is_abs_symbol (&h->elf.root)
17700
0
           : sec == bfd_abs_section_ptr)))
17701
0
      {
17702
0
        bfd_byte *p;
17703
0
      nop_it:
17704
0
        if (offset_in_range (input_section, rel->r_offset & ~3, 4))
17705
0
    {
17706
0
      p = contents + (rel->r_offset & ~3);
17707
0
      bfd_put_32 (input_bfd, NOP, p);
17708
0
      goto copy_reloc;
17709
0
    }
17710
0
      }
17711
0
    break;
17712
17713
0
  case R_PPC64_PLT16_LO:
17714
0
  case R_PPC64_PLT16_LO_DS:
17715
0
    if (unresolved_reloc)
17716
0
      {
17717
0
        unresolved_reloc = false;
17718
0
        goto nop_it;
17719
0
      }
17720
    /* Fall through.  */
17721
0
  case R_PPC64_GOT_TLSLD16_LO:
17722
0
  case R_PPC64_GOT_TLSGD16_LO:
17723
0
  case R_PPC64_GOT_TPREL16_LO_DS:
17724
0
  case R_PPC64_GOT_DTPREL16_LO_DS:
17725
0
  case R_PPC64_GOT16_LO:
17726
0
  case R_PPC64_GOT16_LO_DS:
17727
0
  case R_PPC64_TOC16_LO:
17728
0
  case R_PPC64_TOC16_LO_DS:
17729
0
    if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
17730
0
        && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn
17731
0
        && !(bfd_link_pic (info)
17732
0
       && (h != NULL
17733
0
           ? bfd_is_abs_symbol (&h->elf.root)
17734
0
           : sec == bfd_abs_section_ptr))
17735
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
17736
0
      {
17737
0
        bfd_byte *p = contents + (rel->r_offset & ~3);
17738
0
        insn = bfd_get_32 (input_bfd, p);
17739
0
        if ((insn & (0x3fu << 26)) == 12u << 26 /* addic */)
17740
0
    {
17741
      /* Transform addic to addi when we change reg.  */
17742
0
      insn &= ~((0x3fu << 26) | (0x1f << 16));
17743
0
      insn |= (14u << 26) | (2 << 16);
17744
0
    }
17745
0
        else
17746
0
    {
17747
0
      insn &= ~(0x1f << 16);
17748
0
      insn |= 2 << 16;
17749
0
    }
17750
0
        bfd_put_32 (input_bfd, insn, p);
17751
0
      }
17752
0
    break;
17753
17754
0
  case R_PPC64_TPREL16_HA:
17755
0
    if (htab->do_tls_opt
17756
0
        && relocation + addend + 0x8000 < 0x10000
17757
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
17758
0
      {
17759
0
        bfd_byte *p = contents + (rel->r_offset & ~3);
17760
0
        bfd_put_32 (input_bfd, NOP, p);
17761
0
        goto copy_reloc;
17762
0
      }
17763
0
    break;
17764
17765
0
  case R_PPC64_TPREL16_LO:
17766
0
  case R_PPC64_TPREL16_LO_DS:
17767
0
    if (htab->do_tls_opt
17768
0
        && relocation + addend + 0x8000 < 0x10000
17769
0
        && offset_in_range (input_section, rel->r_offset & ~3, 4))
17770
0
      {
17771
0
        bfd_byte *p = contents + (rel->r_offset & ~3);
17772
0
        insn = bfd_get_32 (input_bfd, p);
17773
0
        insn &= ~(0x1f << 16);
17774
0
        insn |= 13 << 16;
17775
0
        bfd_put_32 (input_bfd, insn, p);
17776
0
      }
17777
0
    break;
17778
0
  }
17779
17780
      /* Do any further special processing.  */
17781
0
      switch (r_type)
17782
0
  {
17783
0
  default:
17784
0
    break;
17785
17786
0
  case R_PPC64_REL16_HA:
17787
0
  case R_PPC64_REL16_HIGHA:
17788
0
  case R_PPC64_REL16_HIGHERA:
17789
0
  case R_PPC64_REL16_HIGHESTA:
17790
0
  case R_PPC64_REL16DX_HA:
17791
0
  case R_PPC64_ADDR16_HA:
17792
0
  case R_PPC64_ADDR16_HIGHA:
17793
0
  case R_PPC64_ADDR16_HIGHERA:
17794
0
  case R_PPC64_ADDR16_HIGHESTA:
17795
0
  case R_PPC64_TOC16_HA:
17796
0
  case R_PPC64_SECTOFF_HA:
17797
0
  case R_PPC64_TPREL16_HA:
17798
0
  case R_PPC64_TPREL16_HIGHA:
17799
0
  case R_PPC64_TPREL16_HIGHERA:
17800
0
  case R_PPC64_TPREL16_HIGHESTA:
17801
0
  case R_PPC64_DTPREL16_HA:
17802
0
  case R_PPC64_DTPREL16_HIGHA:
17803
0
  case R_PPC64_DTPREL16_HIGHERA:
17804
0
  case R_PPC64_DTPREL16_HIGHESTA:
17805
    /* It's just possible that this symbol is a weak symbol
17806
       that's not actually defined anywhere. In that case,
17807
       'sec' would be NULL, and we should leave the symbol
17808
       alone (it will be set to zero elsewhere in the link).  */
17809
0
    if (sec == NULL)
17810
0
      break;
17811
    /* Fall through.  */
17812
17813
0
  case R_PPC64_GOT16_HA:
17814
0
  case R_PPC64_PLTGOT16_HA:
17815
0
  case R_PPC64_PLT16_HA:
17816
0
  case R_PPC64_GOT_TLSGD16_HA:
17817
0
  case R_PPC64_GOT_TLSLD16_HA:
17818
0
  case R_PPC64_GOT_TPREL16_HA:
17819
0
  case R_PPC64_GOT_DTPREL16_HA:
17820
    /* Add 0x10000 if sign bit in 0:15 is set.
17821
       Bits 0:15 are not used.  */
17822
0
    addend += 0x8000;
17823
0
    break;
17824
17825
0
  case R_PPC64_D34_HA30:
17826
0
  case R_PPC64_ADDR16_HIGHERA34:
17827
0
  case R_PPC64_ADDR16_HIGHESTA34:
17828
0
  case R_PPC64_REL16_HIGHERA34:
17829
0
  case R_PPC64_REL16_HIGHESTA34:
17830
0
    if (sec != NULL)
17831
0
      addend += 1ULL << 33;
17832
0
    break;
17833
17834
0
  case R_PPC64_ADDR16_DS:
17835
0
  case R_PPC64_ADDR16_LO_DS:
17836
0
  case R_PPC64_GOT16_DS:
17837
0
  case R_PPC64_GOT16_LO_DS:
17838
0
  case R_PPC64_PLT16_LO_DS:
17839
0
  case R_PPC64_SECTOFF_DS:
17840
0
  case R_PPC64_SECTOFF_LO_DS:
17841
0
  case R_PPC64_TOC16_DS:
17842
0
  case R_PPC64_TOC16_LO_DS:
17843
0
  case R_PPC64_PLTGOT16_DS:
17844
0
  case R_PPC64_PLTGOT16_LO_DS:
17845
0
  case R_PPC64_GOT_TPREL16_DS:
17846
0
  case R_PPC64_GOT_TPREL16_LO_DS:
17847
0
  case R_PPC64_GOT_DTPREL16_DS:
17848
0
  case R_PPC64_GOT_DTPREL16_LO_DS:
17849
0
  case R_PPC64_TPREL16_DS:
17850
0
  case R_PPC64_TPREL16_LO_DS:
17851
0
  case R_PPC64_DTPREL16_DS:
17852
0
  case R_PPC64_DTPREL16_LO_DS:
17853
0
    if (!offset_in_range (input_section, rel->r_offset & ~3, 4))
17854
0
      break;
17855
0
    insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
17856
0
    mask = 3;
17857
    /* If this reloc is against an lq, lxv, or stxv insn, then
17858
       the value must be a multiple of 16.  This is somewhat of
17859
       a hack, but the "correct" way to do this by defining _DQ
17860
       forms of all the _DS relocs bloats all reloc switches in
17861
       this file.  It doesn't make much sense to use these
17862
       relocs in data, so testing the insn should be safe.  */
17863
0
    if ((insn & (0x3fu << 26)) == (56u << 26)
17864
0
        || ((insn & (0x3fu << 26)) == (61u << 26) && (insn & 3) == 1))
17865
0
      mask = 15;
17866
0
    relocation += addend;
17867
0
    addend = insn & (mask ^ 3);
17868
0
    if ((relocation & mask) != 0)
17869
0
      {
17870
0
        relocation ^= relocation & mask;
17871
0
        info->callbacks->einfo
17872
    /* xgettext:c-format */
17873
0
    (_("%H: error: %s not a multiple of %u\n"),
17874
0
     input_bfd, input_section, rel->r_offset,
17875
0
     ppc64_elf_howto_table[r_type]->name,
17876
0
     mask + 1);
17877
0
        bfd_set_error (bfd_error_bad_value);
17878
0
        ret = false;
17879
0
        goto copy_reloc;
17880
0
      }
17881
0
    break;
17882
0
  }
17883
17884
      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
17885
   because such sections are not SEC_ALLOC and thus ld.so will
17886
   not process them.  */
17887
0
      howto = ppc64_elf_howto_table[(int) r_type];
17888
0
      if (unresolved_reloc
17889
0
    && !((input_section->flags & SEC_DEBUGGING) != 0
17890
0
         && h->elf.def_dynamic)
17891
0
    && _bfd_elf_section_offset (output_bfd, info, input_section,
17892
0
              rel->r_offset) != (bfd_vma) -1)
17893
0
  {
17894
0
    info->callbacks->einfo
17895
      /* xgettext:c-format */
17896
0
      (_("%H: unresolvable %s against `%pT'\n"),
17897
0
       input_bfd, input_section, rel->r_offset,
17898
0
       howto->name,
17899
0
       h->elf.root.root.string);
17900
0
    ret = false;
17901
0
  }
17902
17903
      /* 16-bit fields in insns mostly have signed values, but a
17904
   few insns have 16-bit unsigned values.  Really, we should
17905
   have different reloc types.  */
17906
0
      if (howto->complain_on_overflow != complain_overflow_dont
17907
0
    && howto->dst_mask == 0xffff
17908
0
    && (input_section->flags & SEC_CODE) != 0
17909
0
    && offset_in_range (input_section, rel->r_offset & ~3, 4))
17910
0
  {
17911
0
    enum complain_overflow complain = complain_overflow_signed;
17912
17913
0
    insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
17914
0
    if ((insn & (0x3fu << 26)) == 10u << 26 /* cmpli */)
17915
0
      complain = complain_overflow_bitfield;
17916
0
    else if (howto->rightshift == 0
17917
0
       ? ((insn & (0x3fu << 26)) == 28u << 26 /* andi */
17918
0
          || (insn & (0x3fu << 26)) == 24u << 26 /* ori */
17919
0
          || (insn & (0x3fu << 26)) == 26u << 26 /* xori */)
17920
0
       : ((insn & (0x3fu << 26)) == 29u << 26 /* andis */
17921
0
          || (insn & (0x3fu << 26)) == 25u << 26 /* oris */
17922
0
          || (insn & (0x3fu << 26)) == 27u << 26 /* xoris */))
17923
0
      complain = complain_overflow_unsigned;
17924
0
    if (howto->complain_on_overflow != complain)
17925
0
      {
17926
0
        alt_howto = *howto;
17927
0
        alt_howto.complain_on_overflow = complain;
17928
0
        howto = &alt_howto;
17929
0
      }
17930
0
  }
17931
17932
0
      switch (r_type)
17933
0
  {
17934
    /* Split field relocs aren't handled by _bfd_final_link_relocate.  */
17935
0
  case R_PPC64_D34:
17936
0
  case R_PPC64_D34_LO:
17937
0
  case R_PPC64_D34_HI30:
17938
0
  case R_PPC64_D34_HA30:
17939
0
  case R_PPC64_PCREL34:
17940
0
  case R_PPC64_GOT_PCREL34:
17941
0
  case R_PPC64_TPREL34:
17942
0
  case R_PPC64_DTPREL34:
17943
0
  case R_PPC64_GOT_TLSGD_PCREL34:
17944
0
  case R_PPC64_GOT_TLSLD_PCREL34:
17945
0
  case R_PPC64_GOT_TPREL_PCREL34:
17946
0
  case R_PPC64_GOT_DTPREL_PCREL34:
17947
0
  case R_PPC64_PLT_PCREL34:
17948
0
  case R_PPC64_PLT_PCREL34_NOTOC:
17949
0
  case R_PPC64_D28:
17950
0
  case R_PPC64_PCREL28:
17951
0
    if (!offset_in_range (input_section, rel->r_offset, 8))
17952
0
      r = bfd_reloc_outofrange;
17953
0
    else
17954
0
      {
17955
0
        relocation += addend;
17956
0
        if (howto->pc_relative)
17957
0
    relocation -= (rel->r_offset
17958
0
             + input_section->output_offset
17959
0
             + input_section->output_section->vma);
17960
0
        relocation >>= howto->rightshift;
17961
17962
0
        pinsn = bfd_get_32 (input_bfd, contents + rel->r_offset);
17963
0
        pinsn <<= 32;
17964
0
        pinsn |= bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
17965
17966
0
        pinsn &= ~howto->dst_mask;
17967
0
        pinsn |= (((relocation << 16) | (relocation & 0xffff))
17968
0
      & howto->dst_mask);
17969
0
        bfd_put_32 (input_bfd, pinsn >> 32, contents + rel->r_offset);
17970
0
        bfd_put_32 (input_bfd, pinsn, contents + rel->r_offset + 4);
17971
0
        r = bfd_reloc_ok;
17972
0
        if (howto->complain_on_overflow == complain_overflow_signed
17973
0
      && (relocation + (1ULL << (howto->bitsize - 1))
17974
0
          >= 1ULL << howto->bitsize))
17975
0
    r = bfd_reloc_overflow;
17976
0
      }
17977
0
    break;
17978
17979
0
  case R_PPC64_REL16DX_HA:
17980
0
    if (!offset_in_range (input_section, rel->r_offset, 4))
17981
0
      r = bfd_reloc_outofrange;
17982
0
    else
17983
0
      {
17984
0
        relocation += addend;
17985
0
        relocation -= (rel->r_offset
17986
0
           + input_section->output_offset
17987
0
           + input_section->output_section->vma);
17988
0
        relocation = (bfd_signed_vma) relocation >> 16;
17989
0
        insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
17990
0
        insn &= ~0x1fffc1;
17991
0
        insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
17992
0
        bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
17993
0
        r = bfd_reloc_ok;
17994
0
        if (relocation + 0x8000 > 0xffff)
17995
0
    r = bfd_reloc_overflow;
17996
0
      }
17997
0
    break;
17998
17999
0
  default:
18000
0
    r = _bfd_final_link_relocate (howto, input_bfd, input_section,
18001
0
          contents, rel->r_offset,
18002
0
          relocation, addend);
18003
0
  }
18004
18005
0
      if (r != bfd_reloc_ok)
18006
0
  {
18007
0
    char *more_info = NULL;
18008
0
    const char *reloc_name = howto->name;
18009
18010
0
    if (reloc_dest != DEST_NORMAL)
18011
0
      {
18012
0
        more_info = bfd_malloc (strlen (reloc_name) + 8);
18013
0
        if (more_info != NULL)
18014
0
    {
18015
0
      strcpy (more_info, reloc_name);
18016
0
      strcat (more_info, (reloc_dest == DEST_OPD
18017
0
              ? " (OPD)" : " (stub)"));
18018
0
      reloc_name = more_info;
18019
0
    }
18020
0
      }
18021
18022
0
    if (r == bfd_reloc_overflow)
18023
0
      {
18024
        /* On code like "if (foo) foo();" don't report overflow
18025
     on a branch to zero when foo is undefined.  */
18026
0
        if (!warned
18027
0
      && (reloc_dest == DEST_STUB
18028
0
          || !(h != NULL
18029
0
         && (h->elf.root.type == bfd_link_hash_undefweak
18030
0
             || h->elf.root.type == bfd_link_hash_undefined)
18031
0
         && is_branch_reloc (r_type))))
18032
0
    info->callbacks->reloc_overflow
18033
0
      (info, (struct bfd_link_hash_entry *) h, sym_name,
18034
0
       reloc_name, orig_rel.r_addend, input_bfd, input_section,
18035
0
       rel->r_offset);
18036
0
      }
18037
0
    else
18038
0
      {
18039
0
        info->callbacks->einfo
18040
    /* xgettext:c-format */
18041
0
    (_("%H: %s against `%pT': error %d\n"),
18042
0
     input_bfd, input_section, rel->r_offset,
18043
0
     reloc_name, sym_name, (int) r);
18044
0
        ret = false;
18045
0
      }
18046
0
    free (more_info);
18047
0
  }
18048
0
    copy_reloc:
18049
0
      if (wrel != rel)
18050
0
  *wrel = *rel;
18051
0
    }
18052
18053
0
  if (wrel != rel)
18054
0
    {
18055
0
      Elf_Internal_Shdr *rel_hdr;
18056
0
      size_t deleted = rel - wrel;
18057
18058
0
      rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
18059
0
      rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
18060
0
      if (rel_hdr->sh_size == 0)
18061
0
  {
18062
    /* It is too late to remove an empty reloc section.  Leave
18063
       one NONE reloc.
18064
       ??? What is wrong with an empty section???  */
18065
0
    rel_hdr->sh_size = rel_hdr->sh_entsize;
18066
0
    deleted -= 1;
18067
0
  }
18068
0
      rel_hdr = _bfd_elf_single_rel_hdr (input_section);
18069
0
      rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
18070
0
      input_section->reloc_count -= deleted;
18071
0
    }
18072
18073
  /* If we're emitting relocations, then shortly after this function
18074
     returns, reloc offsets and addends for this section will be
18075
     adjusted.  Worse, reloc symbol indices will be for the output
18076
     file rather than the input.  Save a copy of the relocs for
18077
     opd_entry_value.  */
18078
0
  if (is_opd
18079
0
      && (info->emitrelocations || bfd_link_relocatable (info))
18080
0
      && input_section->reloc_count != 0)
18081
0
    {
18082
0
      bfd_size_type amt;
18083
0
      amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
18084
0
      rel = bfd_alloc (input_bfd, amt);
18085
0
      ppc64_elf_section_data (input_section)->u.opd.u.relocs = rel;
18086
0
      if (rel == NULL)
18087
0
  return false;
18088
0
      memcpy (rel, relocs, amt);
18089
0
    }
18090
0
  return ret;
18091
0
}
18092
18093
/* Adjust the value of any local symbols in opd sections.  */
18094
18095
static int
18096
ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
18097
            const char *name ATTRIBUTE_UNUSED,
18098
            Elf_Internal_Sym *elfsym,
18099
            asection *input_sec,
18100
            struct elf_link_hash_entry *h)
18101
0
{
18102
0
  struct _opd_sec_data *opd;
18103
0
  long adjust;
18104
0
  bfd_vma value;
18105
18106
0
  if (h != NULL)
18107
0
    return 1;
18108
18109
0
  opd = get_opd_info (input_sec);
18110
0
  if (opd == NULL || opd->adjust == NULL)
18111
0
    return 1;
18112
18113
0
  value = elfsym->st_value - input_sec->output_offset;
18114
0
  if (!bfd_link_relocatable (info))
18115
0
    value -= input_sec->output_section->vma;
18116
18117
0
  adjust = opd->adjust[OPD_NDX (value)];
18118
0
  if (adjust == -1)
18119
0
    return 2;
18120
18121
0
  elfsym->st_value += adjust;
18122
0
  return 1;
18123
0
}
18124
18125
/* Finish up dynamic symbol handling.  We set the contents of various
18126
   dynamic sections here.  */
18127
18128
static bool
18129
ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
18130
         struct bfd_link_info *info,
18131
         struct elf_link_hash_entry *h,
18132
         Elf_Internal_Sym *sym)
18133
0
{
18134
0
  struct ppc_link_hash_table *htab;
18135
0
  struct plt_entry *ent;
18136
18137
0
  htab = ppc_hash_table (info);
18138
18139
0
  if (!htab->opd_abi && !h->def_regular)
18140
0
    for (ent = h->plt.plist; ent != NULL; ent = ent->next)
18141
0
      if (ent->plt.offset != (bfd_vma) -1)
18142
0
  {
18143
    /* Mark the symbol as undefined, rather than as
18144
       defined in glink.  Leave the value if there were
18145
       any relocations where pointer equality matters
18146
       (this is a clue for the dynamic linker, to make
18147
       function pointer comparisons work between an
18148
       application and shared library), otherwise set it
18149
       to zero.  */
18150
0
    sym->st_shndx = SHN_UNDEF;
18151
0
    if (!h->pointer_equality_needed)
18152
0
      sym->st_value = 0;
18153
0
    else if (!h->ref_regular_nonweak)
18154
0
      {
18155
        /* This breaks function pointer comparisons, but
18156
     that is better than breaking tests for a NULL
18157
     function pointer.  */
18158
0
        sym->st_value = 0;
18159
0
      }
18160
0
    break;
18161
0
  }
18162
18163
0
  if (h->needs_copy
18164
0
      && (h->root.type == bfd_link_hash_defined
18165
0
    || h->root.type == bfd_link_hash_defweak)
18166
0
      && (h->root.u.def.section == htab->elf.sdynbss
18167
0
    || h->root.u.def.section == htab->elf.sdynrelro))
18168
0
    {
18169
      /* This symbol needs a copy reloc.  Set it up.  */
18170
0
      Elf_Internal_Rela rela;
18171
0
      asection *srel;
18172
18173
0
      if (h->dynindx == -1)
18174
0
  abort ();
18175
18176
0
      rela.r_offset = defined_sym_val (h);
18177
0
      rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
18178
0
      rela.r_addend = 0;
18179
0
      if (h->root.u.def.section == htab->elf.sdynrelro)
18180
0
  srel = htab->elf.sreldynrelro;
18181
0
      else
18182
0
  srel = htab->elf.srelbss;
18183
0
      BFD_ASSERT (count_and_swap_reloc_out (output_bfd, &rela, srel));
18184
0
    }
18185
18186
0
  return true;
18187
0
}
18188
18189
/* Used to decide how to sort relocs in an optimal manner for the
18190
   dynamic linker, before writing them out.  */
18191
18192
static enum elf_reloc_type_class
18193
ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
18194
          const asection *rel_sec,
18195
          const Elf_Internal_Rela *rela)
18196
0
{
18197
0
  enum elf_ppc64_reloc_type r_type;
18198
0
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
18199
18200
0
  if (rel_sec == htab->elf.irelplt)
18201
0
    return reloc_class_ifunc;
18202
18203
0
  r_type = ELF64_R_TYPE (rela->r_info);
18204
0
  switch (r_type)
18205
0
    {
18206
0
    case R_PPC64_RELATIVE:
18207
0
      return reloc_class_relative;
18208
0
    case R_PPC64_JMP_SLOT:
18209
0
      return reloc_class_plt;
18210
0
    case R_PPC64_COPY:
18211
0
      return reloc_class_copy;
18212
0
    default:
18213
0
      return reloc_class_normal;
18214
0
    }
18215
0
}
18216
18217
/* Finish up the dynamic sections.  */
18218
18219
static bool
18220
ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
18221
           struct bfd_link_info *info)
18222
0
{
18223
0
  struct ppc_link_hash_table *htab;
18224
0
  bfd *dynobj;
18225
0
  asection *sdyn;
18226
18227
0
  htab = ppc_hash_table (info);
18228
0
  if (htab == NULL)
18229
0
    return false;
18230
18231
0
  dynobj = htab->elf.dynobj;
18232
0
  sdyn = bfd_get_linker_section (dynobj, ".dynamic");
18233
18234
0
  if (htab->elf.dynamic_sections_created)
18235
0
    {
18236
0
      Elf64_External_Dyn *dyncon, *dynconend;
18237
18238
0
      if (sdyn == NULL || htab->elf.sgot == NULL)
18239
0
  abort ();
18240
18241
0
      dyncon = (Elf64_External_Dyn *) sdyn->contents;
18242
0
      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
18243
0
      for (; dyncon < dynconend; dyncon++)
18244
0
  {
18245
0
    Elf_Internal_Dyn dyn;
18246
0
    asection *s;
18247
18248
0
    bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
18249
18250
0
    switch (dyn.d_tag)
18251
0
      {
18252
0
      default:
18253
0
        continue;
18254
18255
0
      case DT_PPC64_GLINK:
18256
0
        s = htab->glink;
18257
0
        dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
18258
        /* We stupidly defined DT_PPC64_GLINK to be the start
18259
     of glink rather than the first entry point, which is
18260
     what ld.so needs, and now have a bigger stub to
18261
     support automatic multiple TOCs.  */
18262
0
        dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
18263
0
        break;
18264
18265
0
      case DT_PPC64_OPD:
18266
0
        s = bfd_get_section_by_name (output_bfd, ".opd");
18267
0
        if (s == NULL)
18268
0
    continue;
18269
0
        dyn.d_un.d_ptr = s->vma;
18270
0
        break;
18271
18272
0
      case DT_PPC64_OPT:
18273
0
        if ((htab->do_multi_toc && htab->multi_toc_needed)
18274
0
      || htab->notoc_plt)
18275
0
    dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
18276
0
        if (htab->has_plt_localentry0)
18277
0
    dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
18278
0
        break;
18279
18280
0
      case DT_PPC64_OPDSZ:
18281
0
        s = bfd_get_section_by_name (output_bfd, ".opd");
18282
0
        if (s == NULL)
18283
0
    continue;
18284
0
        dyn.d_un.d_val = s->size;
18285
0
        break;
18286
18287
0
      case DT_PLTGOT:
18288
0
        s = htab->elf.splt;
18289
0
        dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
18290
0
        break;
18291
18292
0
      case DT_JMPREL:
18293
0
        s = htab->elf.srelplt;
18294
0
        dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
18295
0
        break;
18296
18297
0
      case DT_PLTRELSZ:
18298
0
        dyn.d_un.d_val = htab->elf.srelplt->size;
18299
0
        break;
18300
18301
0
      case DT_TEXTREL:
18302
0
        if (htab->elf.ifunc_resolvers)
18303
0
    info->callbacks->einfo
18304
0
      (_("%P: warning: text relocations and GNU indirect "
18305
0
         "functions may result in a segfault at runtime\n"));
18306
0
        continue;
18307
0
      }
18308
18309
0
    bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
18310
0
  }
18311
0
    }
18312
18313
0
  if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
18314
0
      && htab->elf.sgot->output_section != bfd_abs_section_ptr)
18315
0
    {
18316
      /* Fill in the first entry in the global offset table.
18317
   We use it to hold the link-time TOCbase.  */
18318
0
      bfd_put_64 (output_bfd,
18319
0
      elf_gp (output_bfd) + TOC_BASE_OFF,
18320
0
      htab->elf.sgot->contents);
18321
18322
      /* Set .got entry size.  */
18323
0
      elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
18324
0
  = 8;
18325
0
    }
18326
18327
0
  if (htab->elf.splt != NULL && htab->elf.splt->size != 0
18328
0
      && htab->elf.splt->output_section != bfd_abs_section_ptr)
18329
0
    {
18330
      /* Set .plt entry size.  */
18331
0
      elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
18332
0
  = PLT_ENTRY_SIZE (htab);
18333
0
    }
18334
18335
  /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
18336
     brlt ourselves if emitrelocations.  */
18337
0
  if (htab->brlt != NULL
18338
0
      && htab->brlt->reloc_count != 0
18339
0
      && !_bfd_elf_link_output_relocs (output_bfd,
18340
0
               htab->brlt,
18341
0
               elf_section_data (htab->brlt)->rela.hdr,
18342
0
               elf_section_data (htab->brlt)->relocs,
18343
0
               NULL))
18344
0
    return false;
18345
18346
0
  if (htab->glink != NULL
18347
0
      && htab->glink->reloc_count != 0
18348
0
      && !_bfd_elf_link_output_relocs (output_bfd,
18349
0
               htab->glink,
18350
0
               elf_section_data (htab->glink)->rela.hdr,
18351
0
               elf_section_data (htab->glink)->relocs,
18352
0
               NULL))
18353
0
    return false;
18354
18355
18356
0
  if (htab->glink_eh_frame != NULL
18357
0
      && htab->glink_eh_frame->size != 0
18358
0
      && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
18359
0
      && !_bfd_elf_write_section_eh_frame (output_bfd, info,
18360
0
             htab->glink_eh_frame,
18361
0
             htab->glink_eh_frame->contents))
18362
0
    return false;
18363
18364
  /* We need to handle writing out multiple GOT sections ourselves,
18365
     since we didn't add them to DYNOBJ.  We know dynobj is the first
18366
     bfd.  */
18367
0
  while ((dynobj = dynobj->link.next) != NULL)
18368
0
    {
18369
0
      asection *s;
18370
18371
0
      if (!is_ppc64_elf (dynobj))
18372
0
  continue;
18373
18374
0
      s = ppc64_elf_tdata (dynobj)->got;
18375
0
      if (s != NULL
18376
0
    && s->size != 0
18377
0
    && s->output_section != bfd_abs_section_ptr
18378
0
    && !bfd_set_section_contents (output_bfd, s->output_section,
18379
0
          s->contents, s->output_offset,
18380
0
          s->size))
18381
0
  return false;
18382
0
      s = ppc64_elf_tdata (dynobj)->relgot;
18383
0
      if (s != NULL
18384
0
    && s->size != 0
18385
0
    && s->output_section != bfd_abs_section_ptr
18386
0
    && !bfd_set_section_contents (output_bfd, s->output_section,
18387
0
          s->contents, s->output_offset,
18388
0
          s->size))
18389
0
  return false;
18390
0
    }
18391
18392
0
  return true;
18393
0
}
18394
18395
static bool
18396
ppc64_elf_free_cached_info (bfd *abfd)
18397
8.88k
{
18398
8.88k
  if (abfd->sections)
18399
845
    for (asection *opd = bfd_get_section_by_name (abfd, ".opd");
18400
845
   opd != NULL;
18401
845
   opd = bfd_get_next_section_by_name (NULL, opd))
18402
0
      if (opd->reloc_count == 0)
18403
0
  free (ppc64_elf_section_data (opd)->u.opd.u.contents);
18404
18405
8.88k
  return _bfd_elf_free_cached_info (abfd);
18406
8.88k
}
18407
18408
#include "elf64-target.h"
18409
18410
/* FreeBSD support */
18411
18412
#undef  TARGET_LITTLE_SYM
18413
#define TARGET_LITTLE_SYM powerpc_elf64_fbsd_le_vec
18414
#undef  TARGET_LITTLE_NAME
18415
#define TARGET_LITTLE_NAME "elf64-powerpcle-freebsd"
18416
18417
#undef  TARGET_BIG_SYM
18418
#define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
18419
#undef  TARGET_BIG_NAME
18420
#define TARGET_BIG_NAME "elf64-powerpc-freebsd"
18421
18422
#undef  ELF_OSABI
18423
#define ELF_OSABI       ELFOSABI_FREEBSD
18424
18425
#undef  elf64_bed
18426
#define elf64_bed elf64_powerpc_fbsd_bed
18427
18428
#include "elf64-target.h"