xref: /netbsd-src/external/gpl3/gdb/dist/bfd/elf64-ppc.c (revision fc4f42693f9b1c31f39f9cf50af1bf2010325808) 
1 /* PowerPC64-specific support for 64-bit ELF.
2    Copyright (C) 1999-2017 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 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
36 #include "dwarf2.h"
37 
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
58 
59 #define TARGET_LITTLE_SYM	powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME	"elf64-powerpcle"
61 #define TARGET_BIG_SYM		powerpc_elf64_vec
62 #define TARGET_BIG_NAME		"elf64-powerpc"
63 #define ELF_ARCH		bfd_arch_powerpc
64 #define ELF_TARGET_ID		PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE	EM_PPC64
66 #define ELF_MAXPAGESIZE		0x10000
67 #define ELF_COMMONPAGESIZE	0x10000
68 #define elf_info_to_howto	ppc64_elf_info_to_howto
69 
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_want_dynrelro 1
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_dtrel_excludes_plt 1
80 #define elf_backend_default_execstack 0
81 
82 #define bfd_elf64_mkobject		      ppc64_elf_mkobject
83 #define bfd_elf64_bfd_reloc_type_lookup	      ppc64_elf_reloc_type_lookup
84 #define bfd_elf64_bfd_reloc_name_lookup	      ppc64_elf_reloc_name_lookup
85 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
86 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
87 #define bfd_elf64_new_section_hook	      ppc64_elf_new_section_hook
88 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
89 #define bfd_elf64_get_synthetic_symtab	      ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms	      ppc64_elf_link_just_syms
91 #define bfd_elf64_bfd_gc_sections	      ppc64_elf_gc_sections
92 
93 #define elf_backend_object_p		      ppc64_elf_object_p
94 #define elf_backend_grok_prstatus	      ppc64_elf_grok_prstatus
95 #define elf_backend_grok_psinfo		      ppc64_elf_grok_psinfo
96 #define elf_backend_write_core_note	      ppc64_elf_write_core_note
97 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
98 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
99 #define elf_backend_add_symbol_hook	      ppc64_elf_add_symbol_hook
100 #define elf_backend_check_directives	      ppc64_elf_before_check_relocs
101 #define elf_backend_notice_as_needed	      ppc64_elf_notice_as_needed
102 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
103 #define elf_backend_check_relocs	      ppc64_elf_check_relocs
104 #define elf_backend_gc_keep		      ppc64_elf_gc_keep
105 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
106 #define elf_backend_gc_mark_hook	      ppc64_elf_gc_mark_hook
107 #define elf_backend_gc_sweep_hook	      ppc64_elf_gc_sweep_hook
108 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
109 #define elf_backend_hide_symbol		      ppc64_elf_hide_symbol
110 #define elf_backend_maybe_function_sym	      ppc64_elf_maybe_function_sym
111 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
112 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
113 #define elf_backend_hash_symbol		      ppc64_elf_hash_symbol
114 #define elf_backend_init_index_section	      _bfd_elf_init_2_index_sections
115 #define elf_backend_action_discarded	      ppc64_elf_action_discarded
116 #define elf_backend_relocate_section	      ppc64_elf_relocate_section
117 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
118 #define elf_backend_reloc_type_class	      ppc64_elf_reloc_type_class
119 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
120 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
121 #define elf_backend_special_sections	      ppc64_elf_special_sections
122 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
123 #define elf_backend_merge_symbol	      ppc64_elf_merge_symbol
124 
125 /* The name of the dynamic interpreter.  This is put in the .interp
126    section.  */
127 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
128 
129 /* The size in bytes of an entry in the procedure linkage table.  */
130 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
131 
132 /* The initial size of the plt reserved for the dynamic linker.  */
133 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
134 
135 /* Offsets to some stack save slots.  */
136 #define STK_LR 16
137 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
138 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
139    CR save slot.  Used only by optimised __tls_get_addr call stub,
140    relying on __tls_get_addr_opt not saving CR..  */
141 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
142 
143 /* TOC base pointers offset from start of TOC.  */
144 #define TOC_BASE_OFF	0x8000
145 /* TOC base alignment.  */
146 #define TOC_BASE_ALIGN	256
147 
148 /* Offset of tp and dtp pointers from start of TLS block.  */
149 #define TP_OFFSET	0x7000
150 #define DTP_OFFSET	0x8000
151 
152 /* .plt call stub instructions.  The normal stub is like this, but
153    sometimes the .plt entry crosses a 64k boundary and we need to
154    insert an addi to adjust r11.  */
155 #define STD_R2_0R1	0xf8410000	/* std	 %r2,0+40(%r1)	     */
156 #define ADDIS_R11_R2	0x3d620000	/* addis %r11,%r2,xxx@ha     */
157 #define LD_R12_0R11	0xe98b0000	/* ld	 %r12,xxx+0@l(%r11)  */
158 #define MTCTR_R12	0x7d8903a6	/* mtctr %r12		     */
159 #define LD_R2_0R11	0xe84b0000	/* ld	 %r2,xxx+8@l(%r11)   */
160 #define LD_R11_0R11	0xe96b0000	/* ld	 %r11,xxx+16@l(%r11) */
161 #define BCTR		0x4e800420	/* bctr			     */
162 
163 #define ADDI_R11_R11	0x396b0000	/* addi %r11,%r11,off@l  */
164 #define ADDIS_R2_R2	0x3c420000	/* addis %r2,%r2,off@ha  */
165 #define ADDI_R2_R2	0x38420000	/* addi  %r2,%r2,off@l   */
166 
167 #define XOR_R2_R12_R12	0x7d826278	/* xor   %r2,%r12,%r12   */
168 #define ADD_R11_R11_R2	0x7d6b1214	/* add   %r11,%r11,%r2   */
169 #define XOR_R11_R12_R12	0x7d8b6278	/* xor   %r11,%r12,%r12  */
170 #define ADD_R2_R2_R11	0x7c425a14	/* add   %r2,%r2,%r11    */
171 #define CMPLDI_R2_0	0x28220000	/* cmpldi %r2,0          */
172 #define BNECTR		0x4ca20420	/* bnectr+               */
173 #define BNECTR_P4	0x4ce20420	/* bnectr+               */
174 
175 #define LD_R12_0R2	0xe9820000	/* ld	 %r12,xxx+0(%r2) */
176 #define LD_R11_0R2	0xe9620000	/* ld	 %r11,xxx+0(%r2) */
177 #define LD_R2_0R2	0xe8420000	/* ld	 %r2,xxx+0(%r2)  */
178 
179 #define LD_R2_0R1	0xe8410000	/* ld    %r2,0(%r1)      */
180 #define LD_R2_0R12	0xe84c0000	/* ld    %r2,0(%r12)     */
181 #define ADD_R2_R2_R12	0x7c426214	/* add   %r2,%r2,%r12    */
182 
183 #define LIS_R2		0x3c400000	/* lis %r2,xxx@ha         */
184 #define ADDIS_R2_R12	0x3c4c0000	/* addis %r2,%r12,xxx@ha  */
185 #define ADDIS_R12_R2	0x3d820000	/* addis %r12,%r2,xxx@ha  */
186 #define ADDIS_R12_R12	0x3d8c0000	/* addis %r12,%r12,xxx@ha */
187 #define LD_R12_0R12	0xe98c0000	/* ld    %r12,xxx@l(%r12) */
188 
189 /* glink call stub instructions.  We enter with the index in R0.  */
190 #define GLINK_CALL_STUB_SIZE (16*4)
191 					/* 0:				*/
192 					/*  .quad plt0-1f		*/
193 					/* __glink:			*/
194 #define MFLR_R12	0x7d8802a6	/*  mflr %12			*/
195 #define BCL_20_31	0x429f0005	/*  bcl 20,31,1f		*/
196 					/* 1:				*/
197 #define MFLR_R11	0x7d6802a6	/*  mflr %11			*/
198 					/*  ld %2,(0b-1b)(%11)		*/
199 #define MTLR_R12	0x7d8803a6	/*  mtlr %12			*/
200 #define ADD_R11_R2_R11	0x7d625a14	/*  add %11,%2,%11		*/
201 					/*  ld %12,0(%11)		*/
202 					/*  ld %2,8(%11)		*/
203 					/*  mtctr %12			*/
204 					/*  ld %11,16(%11)		*/
205 					/*  bctr			*/
206 #define MFLR_R0		0x7c0802a6	/*  mflr %r0			*/
207 #define MTLR_R0		0x7c0803a6	/*  mtlr %r0			*/
208 #define SUB_R12_R12_R11	0x7d8b6050	/*  subf %r12,%r11,%r12		*/
209 #define ADDI_R0_R12	0x380c0000	/*  addi %r0,%r12,0		*/
210 #define SRDI_R0_R0_2	0x7800f082	/*  rldicl %r0,%r0,62,2		*/
211 
212 /* Pad with this.  */
213 #define NOP		0x60000000
214 
215 /* Some other nops.  */
216 #define CROR_151515	0x4def7b82
217 #define CROR_313131	0x4ffffb82
218 
219 /* .glink entries for the first 32k functions are two instructions.  */
220 #define LI_R0_0		0x38000000	/* li    %r0,0		*/
221 #define B_DOT		0x48000000	/* b     .		*/
222 
223 /* After that, we need two instructions to load the index, followed by
224    a branch.  */
225 #define LIS_R0_0	0x3c000000	/* lis   %r0,0		*/
226 #define ORI_R0_R0_0	0x60000000	/* ori	 %r0,%r0,0	*/
227 
228 /* Instructions used by the save and restore reg functions.  */
229 #define STD_R0_0R1	0xf8010000	/* std   %r0,0(%r1)	*/
230 #define STD_R0_0R12	0xf80c0000	/* std   %r0,0(%r12)	*/
231 #define LD_R0_0R1	0xe8010000	/* ld    %r0,0(%r1)	*/
232 #define LD_R0_0R12	0xe80c0000	/* ld    %r0,0(%r12)	*/
233 #define STFD_FR0_0R1	0xd8010000	/* stfd  %fr0,0(%r1)	*/
234 #define LFD_FR0_0R1	0xc8010000	/* lfd   %fr0,0(%r1)	*/
235 #define LI_R12_0	0x39800000	/* li    %r12,0		*/
236 #define STVX_VR0_R12_R0	0x7c0c01ce	/* stvx  %v0,%r12,%r0	*/
237 #define LVX_VR0_R12_R0	0x7c0c00ce	/* lvx   %v0,%r12,%r0	*/
238 #define MTLR_R0		0x7c0803a6	/* mtlr  %r0		*/
239 #define BLR		0x4e800020	/* blr			*/
240 
241 /* Since .opd is an array of descriptors and each entry will end up
242    with identical R_PPC64_RELATIVE relocs, there is really no need to
243    propagate .opd relocs;  The dynamic linker should be taught to
244    relocate .opd without reloc entries.  */
245 #ifndef NO_OPD_RELOCS
246 #define NO_OPD_RELOCS 0
247 #endif
248 
249 #ifndef ARRAY_SIZE
250 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
251 #endif
252 
253 static inline int
254 abiversion (bfd *abfd)
255 {
256   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
257 }
258 
259 static inline void
260 set_abiversion (bfd *abfd, int ver)
261 {
262   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
263   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
264 }
265 
266 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
267 
268 /* Relocation HOWTO's.  */
269 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
270 
271 static reloc_howto_type ppc64_elf_howto_raw[] = {
272   /* This reloc does nothing.  */
273   HOWTO (R_PPC64_NONE,		/* type */
274 	 0,			/* rightshift */
275 	 3,			/* size (0 = byte, 1 = short, 2 = long) */
276 	 0,			/* bitsize */
277 	 FALSE,			/* pc_relative */
278 	 0,			/* bitpos */
279 	 complain_overflow_dont, /* complain_on_overflow */
280 	 bfd_elf_generic_reloc,	/* special_function */
281 	 "R_PPC64_NONE",	/* name */
282 	 FALSE,			/* partial_inplace */
283 	 0,			/* src_mask */
284 	 0,			/* dst_mask */
285 	 FALSE),		/* pcrel_offset */
286 
287   /* A standard 32 bit relocation.  */
288   HOWTO (R_PPC64_ADDR32,	/* type */
289 	 0,			/* rightshift */
290 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
291 	 32,			/* bitsize */
292 	 FALSE,			/* pc_relative */
293 	 0,			/* bitpos */
294 	 complain_overflow_bitfield, /* complain_on_overflow */
295 	 bfd_elf_generic_reloc,	/* special_function */
296 	 "R_PPC64_ADDR32",	/* name */
297 	 FALSE,			/* partial_inplace */
298 	 0,			/* src_mask */
299 	 0xffffffff,		/* dst_mask */
300 	 FALSE),		/* pcrel_offset */
301 
302   /* An absolute 26 bit branch; the lower two bits must be zero.
303      FIXME: we don't check that, we just clear them.  */
304   HOWTO (R_PPC64_ADDR24,	/* type */
305 	 0,			/* rightshift */
306 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
307 	 26,			/* bitsize */
308 	 FALSE,			/* pc_relative */
309 	 0,			/* bitpos */
310 	 complain_overflow_bitfield, /* complain_on_overflow */
311 	 bfd_elf_generic_reloc,	/* special_function */
312 	 "R_PPC64_ADDR24",	/* name */
313 	 FALSE,			/* partial_inplace */
314 	 0,			/* src_mask */
315 	 0x03fffffc,		/* dst_mask */
316 	 FALSE),		/* pcrel_offset */
317 
318   /* A standard 16 bit relocation.  */
319   HOWTO (R_PPC64_ADDR16,	/* type */
320 	 0,			/* rightshift */
321 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
322 	 16,			/* bitsize */
323 	 FALSE,			/* pc_relative */
324 	 0,			/* bitpos */
325 	 complain_overflow_bitfield, /* complain_on_overflow */
326 	 bfd_elf_generic_reloc,	/* special_function */
327 	 "R_PPC64_ADDR16",	/* name */
328 	 FALSE,			/* partial_inplace */
329 	 0,			/* src_mask */
330 	 0xffff,		/* dst_mask */
331 	 FALSE),		/* pcrel_offset */
332 
333   /* A 16 bit relocation without overflow.  */
334   HOWTO (R_PPC64_ADDR16_LO,	/* type */
335 	 0,			/* rightshift */
336 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
337 	 16,			/* bitsize */
338 	 FALSE,			/* pc_relative */
339 	 0,			/* bitpos */
340 	 complain_overflow_dont,/* complain_on_overflow */
341 	 bfd_elf_generic_reloc,	/* special_function */
342 	 "R_PPC64_ADDR16_LO",	/* name */
343 	 FALSE,			/* partial_inplace */
344 	 0,			/* src_mask */
345 	 0xffff,		/* dst_mask */
346 	 FALSE),		/* pcrel_offset */
347 
348   /* Bits 16-31 of an address.  */
349   HOWTO (R_PPC64_ADDR16_HI,	/* type */
350 	 16,			/* rightshift */
351 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
352 	 16,			/* bitsize */
353 	 FALSE,			/* pc_relative */
354 	 0,			/* bitpos */
355 	 complain_overflow_signed, /* complain_on_overflow */
356 	 bfd_elf_generic_reloc,	/* special_function */
357 	 "R_PPC64_ADDR16_HI",	/* name */
358 	 FALSE,			/* partial_inplace */
359 	 0,			/* src_mask */
360 	 0xffff,		/* dst_mask */
361 	 FALSE),		/* pcrel_offset */
362 
363   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
364      bits, treated as a signed number, is negative.  */
365   HOWTO (R_PPC64_ADDR16_HA,	/* type */
366 	 16,			/* rightshift */
367 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
368 	 16,			/* bitsize */
369 	 FALSE,			/* pc_relative */
370 	 0,			/* bitpos */
371 	 complain_overflow_signed, /* complain_on_overflow */
372 	 ppc64_elf_ha_reloc,	/* special_function */
373 	 "R_PPC64_ADDR16_HA",	/* name */
374 	 FALSE,			/* partial_inplace */
375 	 0,			/* src_mask */
376 	 0xffff,		/* dst_mask */
377 	 FALSE),		/* pcrel_offset */
378 
379   /* An absolute 16 bit branch; the lower two bits must be zero.
380      FIXME: we don't check that, we just clear them.  */
381   HOWTO (R_PPC64_ADDR14,	/* type */
382 	 0,			/* rightshift */
383 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
384 	 16,			/* bitsize */
385 	 FALSE,			/* pc_relative */
386 	 0,			/* bitpos */
387 	 complain_overflow_signed, /* complain_on_overflow */
388 	 ppc64_elf_branch_reloc, /* special_function */
389 	 "R_PPC64_ADDR14",	/* name */
390 	 FALSE,			/* partial_inplace */
391 	 0,			/* src_mask */
392 	 0x0000fffc,		/* dst_mask */
393 	 FALSE),		/* pcrel_offset */
394 
395   /* An absolute 16 bit branch, for which bit 10 should be set to
396      indicate that the branch is expected to be taken.  The lower two
397      bits must be zero.  */
398   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
399 	 0,			/* rightshift */
400 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
401 	 16,			/* bitsize */
402 	 FALSE,			/* pc_relative */
403 	 0,			/* bitpos */
404 	 complain_overflow_signed, /* complain_on_overflow */
405 	 ppc64_elf_brtaken_reloc, /* special_function */
406 	 "R_PPC64_ADDR14_BRTAKEN",/* name */
407 	 FALSE,			/* partial_inplace */
408 	 0,			/* src_mask */
409 	 0x0000fffc,		/* dst_mask */
410 	 FALSE),		/* pcrel_offset */
411 
412   /* An absolute 16 bit branch, for which bit 10 should be set to
413      indicate that the branch is not expected to be taken.  The lower
414      two bits must be zero.  */
415   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
416 	 0,			/* rightshift */
417 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
418 	 16,			/* bitsize */
419 	 FALSE,			/* pc_relative */
420 	 0,			/* bitpos */
421 	 complain_overflow_signed, /* complain_on_overflow */
422 	 ppc64_elf_brtaken_reloc, /* special_function */
423 	 "R_PPC64_ADDR14_BRNTAKEN",/* name */
424 	 FALSE,			/* partial_inplace */
425 	 0,			/* src_mask */
426 	 0x0000fffc,		/* dst_mask */
427 	 FALSE),		/* pcrel_offset */
428 
429   /* A relative 26 bit branch; the lower two bits must be zero.  */
430   HOWTO (R_PPC64_REL24,		/* type */
431 	 0,			/* rightshift */
432 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
433 	 26,			/* bitsize */
434 	 TRUE,			/* pc_relative */
435 	 0,			/* bitpos */
436 	 complain_overflow_signed, /* complain_on_overflow */
437 	 ppc64_elf_branch_reloc, /* special_function */
438 	 "R_PPC64_REL24",	/* name */
439 	 FALSE,			/* partial_inplace */
440 	 0,			/* src_mask */
441 	 0x03fffffc,		/* dst_mask */
442 	 TRUE),			/* pcrel_offset */
443 
444   /* A relative 16 bit branch; the lower two bits must be zero.  */
445   HOWTO (R_PPC64_REL14,		/* type */
446 	 0,			/* rightshift */
447 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
448 	 16,			/* bitsize */
449 	 TRUE,			/* pc_relative */
450 	 0,			/* bitpos */
451 	 complain_overflow_signed, /* complain_on_overflow */
452 	 ppc64_elf_branch_reloc, /* special_function */
453 	 "R_PPC64_REL14",	/* name */
454 	 FALSE,			/* partial_inplace */
455 	 0,			/* src_mask */
456 	 0x0000fffc,		/* dst_mask */
457 	 TRUE),			/* pcrel_offset */
458 
459   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
460      the branch is expected to be taken.  The lower two bits must be
461      zero.  */
462   HOWTO (R_PPC64_REL14_BRTAKEN,	/* type */
463 	 0,			/* rightshift */
464 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
465 	 16,			/* bitsize */
466 	 TRUE,			/* pc_relative */
467 	 0,			/* bitpos */
468 	 complain_overflow_signed, /* complain_on_overflow */
469 	 ppc64_elf_brtaken_reloc, /* special_function */
470 	 "R_PPC64_REL14_BRTAKEN", /* name */
471 	 FALSE,			/* partial_inplace */
472 	 0,			/* src_mask */
473 	 0x0000fffc,		/* dst_mask */
474 	 TRUE),			/* pcrel_offset */
475 
476   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
477      the branch is not expected to be taken.  The lower two bits must
478      be zero.  */
479   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
480 	 0,			/* rightshift */
481 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
482 	 16,			/* bitsize */
483 	 TRUE,			/* pc_relative */
484 	 0,			/* bitpos */
485 	 complain_overflow_signed, /* complain_on_overflow */
486 	 ppc64_elf_brtaken_reloc, /* special_function */
487 	 "R_PPC64_REL14_BRNTAKEN",/* name */
488 	 FALSE,			/* partial_inplace */
489 	 0,			/* src_mask */
490 	 0x0000fffc,		/* dst_mask */
491 	 TRUE),			/* pcrel_offset */
492 
493   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
494      symbol.  */
495   HOWTO (R_PPC64_GOT16,		/* type */
496 	 0,			/* rightshift */
497 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
498 	 16,			/* bitsize */
499 	 FALSE,			/* pc_relative */
500 	 0,			/* bitpos */
501 	 complain_overflow_signed, /* complain_on_overflow */
502 	 ppc64_elf_unhandled_reloc, /* special_function */
503 	 "R_PPC64_GOT16",	/* name */
504 	 FALSE,			/* partial_inplace */
505 	 0,			/* src_mask */
506 	 0xffff,		/* dst_mask */
507 	 FALSE),		/* pcrel_offset */
508 
509   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
510      the symbol.  */
511   HOWTO (R_PPC64_GOT16_LO,	/* type */
512 	 0,			/* rightshift */
513 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
514 	 16,			/* bitsize */
515 	 FALSE,			/* pc_relative */
516 	 0,			/* bitpos */
517 	 complain_overflow_dont, /* complain_on_overflow */
518 	 ppc64_elf_unhandled_reloc, /* special_function */
519 	 "R_PPC64_GOT16_LO",	/* name */
520 	 FALSE,			/* partial_inplace */
521 	 0,			/* src_mask */
522 	 0xffff,		/* dst_mask */
523 	 FALSE),		/* pcrel_offset */
524 
525   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
526      the symbol.  */
527   HOWTO (R_PPC64_GOT16_HI,	/* type */
528 	 16,			/* rightshift */
529 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
530 	 16,			/* bitsize */
531 	 FALSE,			/* pc_relative */
532 	 0,			/* bitpos */
533 	 complain_overflow_signed,/* complain_on_overflow */
534 	 ppc64_elf_unhandled_reloc, /* special_function */
535 	 "R_PPC64_GOT16_HI",	/* name */
536 	 FALSE,			/* partial_inplace */
537 	 0,			/* src_mask */
538 	 0xffff,		/* dst_mask */
539 	 FALSE),		/* pcrel_offset */
540 
541   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
542      the symbol.  */
543   HOWTO (R_PPC64_GOT16_HA,	/* type */
544 	 16,			/* rightshift */
545 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
546 	 16,			/* bitsize */
547 	 FALSE,			/* pc_relative */
548 	 0,			/* bitpos */
549 	 complain_overflow_signed,/* complain_on_overflow */
550 	 ppc64_elf_unhandled_reloc, /* special_function */
551 	 "R_PPC64_GOT16_HA",	/* name */
552 	 FALSE,			/* partial_inplace */
553 	 0,			/* src_mask */
554 	 0xffff,		/* dst_mask */
555 	 FALSE),		/* pcrel_offset */
556 
557   /* This is used only by the dynamic linker.  The symbol should exist
558      both in the object being run and in some shared library.  The
559      dynamic linker copies the data addressed by the symbol from the
560      shared library into the object, because the object being
561      run has to have the data at some particular address.  */
562   HOWTO (R_PPC64_COPY,		/* type */
563 	 0,			/* rightshift */
564 	 0,			/* this one is variable size */
565 	 0,			/* bitsize */
566 	 FALSE,			/* pc_relative */
567 	 0,			/* bitpos */
568 	 complain_overflow_dont, /* complain_on_overflow */
569 	 ppc64_elf_unhandled_reloc, /* special_function */
570 	 "R_PPC64_COPY",	/* name */
571 	 FALSE,			/* partial_inplace */
572 	 0,			/* src_mask */
573 	 0,			/* dst_mask */
574 	 FALSE),		/* pcrel_offset */
575 
576   /* Like R_PPC64_ADDR64, but used when setting global offset table
577      entries.  */
578   HOWTO (R_PPC64_GLOB_DAT,	/* type */
579 	 0,			/* rightshift */
580 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
581 	 64,			/* bitsize */
582 	 FALSE,			/* pc_relative */
583 	 0,			/* bitpos */
584 	 complain_overflow_dont, /* complain_on_overflow */
585 	 ppc64_elf_unhandled_reloc,  /* special_function */
586 	 "R_PPC64_GLOB_DAT",	/* name */
587 	 FALSE,			/* partial_inplace */
588 	 0,			/* src_mask */
589 	 ONES (64),		/* dst_mask */
590 	 FALSE),		/* pcrel_offset */
591 
592   /* Created by the link editor.  Marks a procedure linkage table
593      entry for a symbol.  */
594   HOWTO (R_PPC64_JMP_SLOT,	/* type */
595 	 0,			/* rightshift */
596 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
597 	 0,			/* bitsize */
598 	 FALSE,			/* pc_relative */
599 	 0,			/* bitpos */
600 	 complain_overflow_dont, /* complain_on_overflow */
601 	 ppc64_elf_unhandled_reloc, /* special_function */
602 	 "R_PPC64_JMP_SLOT",	/* name */
603 	 FALSE,			/* partial_inplace */
604 	 0,			/* src_mask */
605 	 0,			/* dst_mask */
606 	 FALSE),		/* pcrel_offset */
607 
608   /* Used only by the dynamic linker.  When the object is run, this
609      doubleword64 is set to the load address of the object, plus the
610      addend.  */
611   HOWTO (R_PPC64_RELATIVE,	/* type */
612 	 0,			/* rightshift */
613 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
614 	 64,			/* bitsize */
615 	 FALSE,			/* pc_relative */
616 	 0,			/* bitpos */
617 	 complain_overflow_dont, /* complain_on_overflow */
618 	 bfd_elf_generic_reloc,	/* special_function */
619 	 "R_PPC64_RELATIVE",	/* name */
620 	 FALSE,			/* partial_inplace */
621 	 0,			/* src_mask */
622 	 ONES (64),		/* dst_mask */
623 	 FALSE),		/* pcrel_offset */
624 
625   /* Like R_PPC64_ADDR32, but may be unaligned.  */
626   HOWTO (R_PPC64_UADDR32,	/* type */
627 	 0,			/* rightshift */
628 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
629 	 32,			/* bitsize */
630 	 FALSE,			/* pc_relative */
631 	 0,			/* bitpos */
632 	 complain_overflow_bitfield, /* complain_on_overflow */
633 	 bfd_elf_generic_reloc,	/* special_function */
634 	 "R_PPC64_UADDR32",	/* name */
635 	 FALSE,			/* partial_inplace */
636 	 0,			/* src_mask */
637 	 0xffffffff,		/* dst_mask */
638 	 FALSE),		/* pcrel_offset */
639 
640   /* Like R_PPC64_ADDR16, but may be unaligned.  */
641   HOWTO (R_PPC64_UADDR16,	/* type */
642 	 0,			/* rightshift */
643 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
644 	 16,			/* bitsize */
645 	 FALSE,			/* pc_relative */
646 	 0,			/* bitpos */
647 	 complain_overflow_bitfield, /* complain_on_overflow */
648 	 bfd_elf_generic_reloc,	/* special_function */
649 	 "R_PPC64_UADDR16",	/* name */
650 	 FALSE,			/* partial_inplace */
651 	 0,			/* src_mask */
652 	 0xffff,		/* dst_mask */
653 	 FALSE),		/* pcrel_offset */
654 
655   /* 32-bit PC relative.  */
656   HOWTO (R_PPC64_REL32,		/* type */
657 	 0,			/* rightshift */
658 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
659 	 32,			/* bitsize */
660 	 TRUE,			/* pc_relative */
661 	 0,			/* bitpos */
662 	 complain_overflow_signed, /* complain_on_overflow */
663 	 bfd_elf_generic_reloc,	/* special_function */
664 	 "R_PPC64_REL32",	/* name */
665 	 FALSE,			/* partial_inplace */
666 	 0,			/* src_mask */
667 	 0xffffffff,		/* dst_mask */
668 	 TRUE),			/* pcrel_offset */
669 
670   /* 32-bit relocation to the symbol's procedure linkage table.  */
671   HOWTO (R_PPC64_PLT32,		/* type */
672 	 0,			/* rightshift */
673 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
674 	 32,			/* bitsize */
675 	 FALSE,			/* pc_relative */
676 	 0,			/* bitpos */
677 	 complain_overflow_bitfield, /* complain_on_overflow */
678 	 ppc64_elf_unhandled_reloc, /* special_function */
679 	 "R_PPC64_PLT32",	/* name */
680 	 FALSE,			/* partial_inplace */
681 	 0,			/* src_mask */
682 	 0xffffffff,		/* dst_mask */
683 	 FALSE),		/* pcrel_offset */
684 
685   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
686      FIXME: R_PPC64_PLTREL32 not supported.  */
687   HOWTO (R_PPC64_PLTREL32,	/* type */
688 	 0,			/* rightshift */
689 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
690 	 32,			/* bitsize */
691 	 TRUE,			/* pc_relative */
692 	 0,			/* bitpos */
693 	 complain_overflow_signed, /* complain_on_overflow */
694 	 ppc64_elf_unhandled_reloc, /* special_function */
695 	 "R_PPC64_PLTREL32",	/* name */
696 	 FALSE,			/* partial_inplace */
697 	 0,			/* src_mask */
698 	 0xffffffff,		/* dst_mask */
699 	 TRUE),			/* pcrel_offset */
700 
701   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
702      the symbol.  */
703   HOWTO (R_PPC64_PLT16_LO,	/* type */
704 	 0,			/* rightshift */
705 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
706 	 16,			/* bitsize */
707 	 FALSE,			/* pc_relative */
708 	 0,			/* bitpos */
709 	 complain_overflow_dont, /* complain_on_overflow */
710 	 ppc64_elf_unhandled_reloc, /* special_function */
711 	 "R_PPC64_PLT16_LO",	/* name */
712 	 FALSE,			/* partial_inplace */
713 	 0,			/* src_mask */
714 	 0xffff,		/* dst_mask */
715 	 FALSE),		/* pcrel_offset */
716 
717   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
718      the symbol.  */
719   HOWTO (R_PPC64_PLT16_HI,	/* type */
720 	 16,			/* rightshift */
721 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
722 	 16,			/* bitsize */
723 	 FALSE,			/* pc_relative */
724 	 0,			/* bitpos */
725 	 complain_overflow_signed, /* complain_on_overflow */
726 	 ppc64_elf_unhandled_reloc, /* special_function */
727 	 "R_PPC64_PLT16_HI",	/* name */
728 	 FALSE,			/* partial_inplace */
729 	 0,			/* src_mask */
730 	 0xffff,		/* dst_mask */
731 	 FALSE),		/* pcrel_offset */
732 
733   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
734      the symbol.  */
735   HOWTO (R_PPC64_PLT16_HA,	/* type */
736 	 16,			/* rightshift */
737 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
738 	 16,			/* bitsize */
739 	 FALSE,			/* pc_relative */
740 	 0,			/* bitpos */
741 	 complain_overflow_signed, /* complain_on_overflow */
742 	 ppc64_elf_unhandled_reloc, /* special_function */
743 	 "R_PPC64_PLT16_HA",	/* name */
744 	 FALSE,			/* partial_inplace */
745 	 0,			/* src_mask */
746 	 0xffff,		/* dst_mask */
747 	 FALSE),		/* pcrel_offset */
748 
749   /* 16-bit section relative relocation.  */
750   HOWTO (R_PPC64_SECTOFF,	/* type */
751 	 0,			/* rightshift */
752 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
753 	 16,			/* bitsize */
754 	 FALSE,			/* pc_relative */
755 	 0,			/* bitpos */
756 	 complain_overflow_signed, /* complain_on_overflow */
757 	 ppc64_elf_sectoff_reloc, /* special_function */
758 	 "R_PPC64_SECTOFF",	/* name */
759 	 FALSE,			/* partial_inplace */
760 	 0,			/* src_mask */
761 	 0xffff,		/* dst_mask */
762 	 FALSE),		/* pcrel_offset */
763 
764   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
765   HOWTO (R_PPC64_SECTOFF_LO,	/* type */
766 	 0,			/* rightshift */
767 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
768 	 16,			/* bitsize */
769 	 FALSE,			/* pc_relative */
770 	 0,			/* bitpos */
771 	 complain_overflow_dont, /* complain_on_overflow */
772 	 ppc64_elf_sectoff_reloc, /* special_function */
773 	 "R_PPC64_SECTOFF_LO",	/* name */
774 	 FALSE,			/* partial_inplace */
775 	 0,			/* src_mask */
776 	 0xffff,		/* dst_mask */
777 	 FALSE),		/* pcrel_offset */
778 
779   /* 16-bit upper half section relative relocation.  */
780   HOWTO (R_PPC64_SECTOFF_HI,	/* type */
781 	 16,			/* rightshift */
782 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
783 	 16,			/* bitsize */
784 	 FALSE,			/* pc_relative */
785 	 0,			/* bitpos */
786 	 complain_overflow_signed, /* complain_on_overflow */
787 	 ppc64_elf_sectoff_reloc, /* special_function */
788 	 "R_PPC64_SECTOFF_HI",	/* name */
789 	 FALSE,			/* partial_inplace */
790 	 0,			/* src_mask */
791 	 0xffff,		/* dst_mask */
792 	 FALSE),		/* pcrel_offset */
793 
794   /* 16-bit upper half adjusted section relative relocation.  */
795   HOWTO (R_PPC64_SECTOFF_HA,	/* type */
796 	 16,			/* rightshift */
797 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
798 	 16,			/* bitsize */
799 	 FALSE,			/* pc_relative */
800 	 0,			/* bitpos */
801 	 complain_overflow_signed, /* complain_on_overflow */
802 	 ppc64_elf_sectoff_ha_reloc, /* special_function */
803 	 "R_PPC64_SECTOFF_HA",	/* name */
804 	 FALSE,			/* partial_inplace */
805 	 0,			/* src_mask */
806 	 0xffff,		/* dst_mask */
807 	 FALSE),		/* pcrel_offset */
808 
809   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
810   HOWTO (R_PPC64_REL30,		/* type */
811 	 2,			/* rightshift */
812 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
813 	 30,			/* bitsize */
814 	 TRUE,			/* pc_relative */
815 	 0,			/* bitpos */
816 	 complain_overflow_dont, /* complain_on_overflow */
817 	 bfd_elf_generic_reloc, /* special_function */
818 	 "R_PPC64_REL30",	/* name */
819 	 FALSE,			/* partial_inplace */
820 	 0,			/* src_mask */
821 	 0xfffffffc,		/* dst_mask */
822 	 TRUE),			/* pcrel_offset */
823 
824   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
825 
826   /* A standard 64-bit relocation.  */
827   HOWTO (R_PPC64_ADDR64,	/* type */
828 	 0,			/* rightshift */
829 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
830 	 64,			/* bitsize */
831 	 FALSE,			/* pc_relative */
832 	 0,			/* bitpos */
833 	 complain_overflow_dont, /* complain_on_overflow */
834 	 bfd_elf_generic_reloc,	/* special_function */
835 	 "R_PPC64_ADDR64",	/* name */
836 	 FALSE,			/* partial_inplace */
837 	 0,			/* src_mask */
838 	 ONES (64),		/* dst_mask */
839 	 FALSE),		/* pcrel_offset */
840 
841   /* The bits 32-47 of an address.  */
842   HOWTO (R_PPC64_ADDR16_HIGHER,	/* type */
843 	 32,			/* rightshift */
844 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
845 	 16,			/* bitsize */
846 	 FALSE,			/* pc_relative */
847 	 0,			/* bitpos */
848 	 complain_overflow_dont, /* complain_on_overflow */
849 	 bfd_elf_generic_reloc,	/* special_function */
850 	 "R_PPC64_ADDR16_HIGHER", /* name */
851 	 FALSE,			/* partial_inplace */
852 	 0,			/* src_mask */
853 	 0xffff,		/* dst_mask */
854 	 FALSE),		/* pcrel_offset */
855 
856   /* The bits 32-47 of an address, plus 1 if the contents of the low
857      16 bits, treated as a signed number, is negative.  */
858   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
859 	 32,			/* rightshift */
860 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
861 	 16,			/* bitsize */
862 	 FALSE,			/* pc_relative */
863 	 0,			/* bitpos */
864 	 complain_overflow_dont, /* complain_on_overflow */
865 	 ppc64_elf_ha_reloc,	/* special_function */
866 	 "R_PPC64_ADDR16_HIGHERA", /* name */
867 	 FALSE,			/* partial_inplace */
868 	 0,			/* src_mask */
869 	 0xffff,		/* dst_mask */
870 	 FALSE),		/* pcrel_offset */
871 
872   /* The bits 48-63 of an address.  */
873   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
874 	 48,			/* rightshift */
875 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
876 	 16,			/* bitsize */
877 	 FALSE,			/* pc_relative */
878 	 0,			/* bitpos */
879 	 complain_overflow_dont, /* complain_on_overflow */
880 	 bfd_elf_generic_reloc,	/* special_function */
881 	 "R_PPC64_ADDR16_HIGHEST", /* name */
882 	 FALSE,			/* partial_inplace */
883 	 0,			/* src_mask */
884 	 0xffff,		/* dst_mask */
885 	 FALSE),		/* pcrel_offset */
886 
887   /* The bits 48-63 of an address, plus 1 if the contents of the low
888      16 bits, treated as a signed number, is negative.  */
889   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
890 	 48,			/* rightshift */
891 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
892 	 16,			/* bitsize */
893 	 FALSE,			/* pc_relative */
894 	 0,			/* bitpos */
895 	 complain_overflow_dont, /* complain_on_overflow */
896 	 ppc64_elf_ha_reloc,	/* special_function */
897 	 "R_PPC64_ADDR16_HIGHESTA", /* name */
898 	 FALSE,			/* partial_inplace */
899 	 0,			/* src_mask */
900 	 0xffff,		/* dst_mask */
901 	 FALSE),		/* pcrel_offset */
902 
903   /* Like ADDR64, but may be unaligned.  */
904   HOWTO (R_PPC64_UADDR64,	/* type */
905 	 0,			/* rightshift */
906 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
907 	 64,			/* bitsize */
908 	 FALSE,			/* pc_relative */
909 	 0,			/* bitpos */
910 	 complain_overflow_dont, /* complain_on_overflow */
911 	 bfd_elf_generic_reloc,	/* special_function */
912 	 "R_PPC64_UADDR64",	/* name */
913 	 FALSE,			/* partial_inplace */
914 	 0,			/* src_mask */
915 	 ONES (64),		/* dst_mask */
916 	 FALSE),		/* pcrel_offset */
917 
918   /* 64-bit relative relocation.  */
919   HOWTO (R_PPC64_REL64,		/* type */
920 	 0,			/* rightshift */
921 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
922 	 64,			/* bitsize */
923 	 TRUE,			/* pc_relative */
924 	 0,			/* bitpos */
925 	 complain_overflow_dont, /* complain_on_overflow */
926 	 bfd_elf_generic_reloc,	/* special_function */
927 	 "R_PPC64_REL64",	/* name */
928 	 FALSE,			/* partial_inplace */
929 	 0,			/* src_mask */
930 	 ONES (64),		/* dst_mask */
931 	 TRUE),			/* pcrel_offset */
932 
933   /* 64-bit relocation to the symbol's procedure linkage table.  */
934   HOWTO (R_PPC64_PLT64,		/* type */
935 	 0,			/* rightshift */
936 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
937 	 64,			/* bitsize */
938 	 FALSE,			/* pc_relative */
939 	 0,			/* bitpos */
940 	 complain_overflow_dont, /* complain_on_overflow */
941 	 ppc64_elf_unhandled_reloc, /* special_function */
942 	 "R_PPC64_PLT64",	/* name */
943 	 FALSE,			/* partial_inplace */
944 	 0,			/* src_mask */
945 	 ONES (64),		/* dst_mask */
946 	 FALSE),		/* pcrel_offset */
947 
948   /* 64-bit PC relative relocation to the symbol's procedure linkage
949      table.  */
950   /* FIXME: R_PPC64_PLTREL64 not supported.  */
951   HOWTO (R_PPC64_PLTREL64,	/* type */
952 	 0,			/* rightshift */
953 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
954 	 64,			/* bitsize */
955 	 TRUE,			/* pc_relative */
956 	 0,			/* bitpos */
957 	 complain_overflow_dont, /* complain_on_overflow */
958 	 ppc64_elf_unhandled_reloc, /* special_function */
959 	 "R_PPC64_PLTREL64",	/* name */
960 	 FALSE,			/* partial_inplace */
961 	 0,			/* src_mask */
962 	 ONES (64),		/* dst_mask */
963 	 TRUE),			/* pcrel_offset */
964 
965   /* 16 bit TOC-relative relocation.  */
966 
967   /* R_PPC64_TOC16	  47	   half16*	S + A - .TOC.  */
968   HOWTO (R_PPC64_TOC16,		/* type */
969 	 0,			/* rightshift */
970 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
971 	 16,			/* bitsize */
972 	 FALSE,			/* pc_relative */
973 	 0,			/* bitpos */
974 	 complain_overflow_signed, /* complain_on_overflow */
975 	 ppc64_elf_toc_reloc,	/* special_function */
976 	 "R_PPC64_TOC16",	/* name */
977 	 FALSE,			/* partial_inplace */
978 	 0,			/* src_mask */
979 	 0xffff,		/* dst_mask */
980 	 FALSE),		/* pcrel_offset */
981 
982   /* 16 bit TOC-relative relocation without overflow.  */
983 
984   /* R_PPC64_TOC16_LO	  48	   half16	 #lo (S + A - .TOC.)  */
985   HOWTO (R_PPC64_TOC16_LO,	/* type */
986 	 0,			/* rightshift */
987 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
988 	 16,			/* bitsize */
989 	 FALSE,			/* pc_relative */
990 	 0,			/* bitpos */
991 	 complain_overflow_dont, /* complain_on_overflow */
992 	 ppc64_elf_toc_reloc,	/* special_function */
993 	 "R_PPC64_TOC16_LO",	/* name */
994 	 FALSE,			/* partial_inplace */
995 	 0,			/* src_mask */
996 	 0xffff,		/* dst_mask */
997 	 FALSE),		/* pcrel_offset */
998 
999   /* 16 bit TOC-relative relocation, high 16 bits.  */
1000 
1001   /* R_PPC64_TOC16_HI	  49	   half16	 #hi (S + A - .TOC.)  */
1002   HOWTO (R_PPC64_TOC16_HI,	/* type */
1003 	 16,			/* rightshift */
1004 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1005 	 16,			/* bitsize */
1006 	 FALSE,			/* pc_relative */
1007 	 0,			/* bitpos */
1008 	 complain_overflow_signed, /* complain_on_overflow */
1009 	 ppc64_elf_toc_reloc,	/* special_function */
1010 	 "R_PPC64_TOC16_HI",	/* name */
1011 	 FALSE,			/* partial_inplace */
1012 	 0,			/* src_mask */
1013 	 0xffff,		/* dst_mask */
1014 	 FALSE),		/* pcrel_offset */
1015 
1016   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1017      contents of the low 16 bits, treated as a signed number, is
1018      negative.  */
1019 
1020   /* R_PPC64_TOC16_HA	  50	   half16	 #ha (S + A - .TOC.)  */
1021   HOWTO (R_PPC64_TOC16_HA,	/* type */
1022 	 16,			/* rightshift */
1023 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1024 	 16,			/* bitsize */
1025 	 FALSE,			/* pc_relative */
1026 	 0,			/* bitpos */
1027 	 complain_overflow_signed, /* complain_on_overflow */
1028 	 ppc64_elf_toc_ha_reloc, /* special_function */
1029 	 "R_PPC64_TOC16_HA",	/* name */
1030 	 FALSE,			/* partial_inplace */
1031 	 0,			/* src_mask */
1032 	 0xffff,		/* dst_mask */
1033 	 FALSE),		/* pcrel_offset */
1034 
1035   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1036 
1037   /* R_PPC64_TOC		  51	   doubleword64	 .TOC.  */
1038   HOWTO (R_PPC64_TOC,		/* type */
1039 	 0,			/* rightshift */
1040 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
1041 	 64,			/* bitsize */
1042 	 FALSE,			/* pc_relative */
1043 	 0,			/* bitpos */
1044 	 complain_overflow_dont, /* complain_on_overflow */
1045 	 ppc64_elf_toc64_reloc,	/* special_function */
1046 	 "R_PPC64_TOC",		/* name */
1047 	 FALSE,			/* partial_inplace */
1048 	 0,			/* src_mask */
1049 	 ONES (64),		/* dst_mask */
1050 	 FALSE),		/* pcrel_offset */
1051 
1052   /* Like R_PPC64_GOT16, but also informs the link editor that the
1053      value to relocate may (!) refer to a PLT entry which the link
1054      editor (a) may replace with the symbol value.  If the link editor
1055      is unable to fully resolve the symbol, it may (b) create a PLT
1056      entry and store the address to the new PLT entry in the GOT.
1057      This permits lazy resolution of function symbols at run time.
1058      The link editor may also skip all of this and just (c) emit a
1059      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1060   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1061     HOWTO (R_PPC64_PLTGOT16,	/* type */
1062 	 0,			/* rightshift */
1063 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1064 	 16,			/* bitsize */
1065 	 FALSE,			/* pc_relative */
1066 	 0,			/* bitpos */
1067 	 complain_overflow_signed, /* complain_on_overflow */
1068 	 ppc64_elf_unhandled_reloc, /* special_function */
1069 	 "R_PPC64_PLTGOT16",	/* name */
1070 	 FALSE,			/* partial_inplace */
1071 	 0,			/* src_mask */
1072 	 0xffff,		/* dst_mask */
1073 	 FALSE),		/* pcrel_offset */
1074 
1075   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1076   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1077   HOWTO (R_PPC64_PLTGOT16_LO,	/* type */
1078 	 0,			/* rightshift */
1079 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1080 	 16,			/* bitsize */
1081 	 FALSE,			/* pc_relative */
1082 	 0,			/* bitpos */
1083 	 complain_overflow_dont, /* complain_on_overflow */
1084 	 ppc64_elf_unhandled_reloc, /* special_function */
1085 	 "R_PPC64_PLTGOT16_LO",	/* name */
1086 	 FALSE,			/* partial_inplace */
1087 	 0,			/* src_mask */
1088 	 0xffff,		/* dst_mask */
1089 	 FALSE),		/* pcrel_offset */
1090 
1091   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1092   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1093   HOWTO (R_PPC64_PLTGOT16_HI,	/* type */
1094 	 16,			/* rightshift */
1095 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1096 	 16,			/* bitsize */
1097 	 FALSE,			/* pc_relative */
1098 	 0,			/* bitpos */
1099 	 complain_overflow_signed, /* complain_on_overflow */
1100 	 ppc64_elf_unhandled_reloc, /* special_function */
1101 	 "R_PPC64_PLTGOT16_HI",	/* name */
1102 	 FALSE,			/* partial_inplace */
1103 	 0,			/* src_mask */
1104 	 0xffff,		/* dst_mask */
1105 	 FALSE),		/* pcrel_offset */
1106 
1107   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1108      1 if the contents of the low 16 bits, treated as a signed number,
1109      is negative.  */
1110   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1111   HOWTO (R_PPC64_PLTGOT16_HA,	/* type */
1112 	 16,			/* rightshift */
1113 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1114 	 16,			/* bitsize */
1115 	 FALSE,			/* pc_relative */
1116 	 0,			/* bitpos */
1117 	 complain_overflow_signed, /* complain_on_overflow */
1118 	 ppc64_elf_unhandled_reloc, /* special_function */
1119 	 "R_PPC64_PLTGOT16_HA",	/* name */
1120 	 FALSE,			/* partial_inplace */
1121 	 0,			/* src_mask */
1122 	 0xffff,		/* dst_mask */
1123 	 FALSE),		/* pcrel_offset */
1124 
1125   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1126   HOWTO (R_PPC64_ADDR16_DS,	/* type */
1127 	 0,			/* rightshift */
1128 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1129 	 16,			/* bitsize */
1130 	 FALSE,			/* pc_relative */
1131 	 0,			/* bitpos */
1132 	 complain_overflow_signed, /* complain_on_overflow */
1133 	 bfd_elf_generic_reloc,	/* special_function */
1134 	 "R_PPC64_ADDR16_DS",	/* name */
1135 	 FALSE,			/* partial_inplace */
1136 	 0,			/* src_mask */
1137 	 0xfffc,		/* dst_mask */
1138 	 FALSE),		/* pcrel_offset */
1139 
1140   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1141   HOWTO (R_PPC64_ADDR16_LO_DS,	/* type */
1142 	 0,			/* rightshift */
1143 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1144 	 16,			/* bitsize */
1145 	 FALSE,			/* pc_relative */
1146 	 0,			/* bitpos */
1147 	 complain_overflow_dont,/* complain_on_overflow */
1148 	 bfd_elf_generic_reloc,	/* special_function */
1149 	 "R_PPC64_ADDR16_LO_DS",/* name */
1150 	 FALSE,			/* partial_inplace */
1151 	 0,			/* src_mask */
1152 	 0xfffc,		/* dst_mask */
1153 	 FALSE),		/* pcrel_offset */
1154 
1155   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1156   HOWTO (R_PPC64_GOT16_DS,	/* type */
1157 	 0,			/* rightshift */
1158 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1159 	 16,			/* bitsize */
1160 	 FALSE,			/* pc_relative */
1161 	 0,			/* bitpos */
1162 	 complain_overflow_signed, /* complain_on_overflow */
1163 	 ppc64_elf_unhandled_reloc, /* special_function */
1164 	 "R_PPC64_GOT16_DS",	/* name */
1165 	 FALSE,			/* partial_inplace */
1166 	 0,			/* src_mask */
1167 	 0xfffc,		/* dst_mask */
1168 	 FALSE),		/* pcrel_offset */
1169 
1170   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1171   HOWTO (R_PPC64_GOT16_LO_DS,	/* type */
1172 	 0,			/* rightshift */
1173 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1174 	 16,			/* bitsize */
1175 	 FALSE,			/* pc_relative */
1176 	 0,			/* bitpos */
1177 	 complain_overflow_dont, /* complain_on_overflow */
1178 	 ppc64_elf_unhandled_reloc, /* special_function */
1179 	 "R_PPC64_GOT16_LO_DS",	/* name */
1180 	 FALSE,			/* partial_inplace */
1181 	 0,			/* src_mask */
1182 	 0xfffc,		/* dst_mask */
1183 	 FALSE),		/* pcrel_offset */
1184 
1185   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1186   HOWTO (R_PPC64_PLT16_LO_DS,	/* type */
1187 	 0,			/* rightshift */
1188 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1189 	 16,			/* bitsize */
1190 	 FALSE,			/* pc_relative */
1191 	 0,			/* bitpos */
1192 	 complain_overflow_dont, /* complain_on_overflow */
1193 	 ppc64_elf_unhandled_reloc, /* special_function */
1194 	 "R_PPC64_PLT16_LO_DS",	/* name */
1195 	 FALSE,			/* partial_inplace */
1196 	 0,			/* src_mask */
1197 	 0xfffc,		/* dst_mask */
1198 	 FALSE),		/* pcrel_offset */
1199 
1200   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1201   HOWTO (R_PPC64_SECTOFF_DS,	/* type */
1202 	 0,			/* rightshift */
1203 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1204 	 16,			/* bitsize */
1205 	 FALSE,			/* pc_relative */
1206 	 0,			/* bitpos */
1207 	 complain_overflow_signed, /* complain_on_overflow */
1208 	 ppc64_elf_sectoff_reloc, /* special_function */
1209 	 "R_PPC64_SECTOFF_DS",	/* name */
1210 	 FALSE,			/* partial_inplace */
1211 	 0,			/* src_mask */
1212 	 0xfffc,		/* dst_mask */
1213 	 FALSE),		/* pcrel_offset */
1214 
1215   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1216   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1217 	 0,			/* rightshift */
1218 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1219 	 16,			/* bitsize */
1220 	 FALSE,			/* pc_relative */
1221 	 0,			/* bitpos */
1222 	 complain_overflow_dont, /* complain_on_overflow */
1223 	 ppc64_elf_sectoff_reloc, /* special_function */
1224 	 "R_PPC64_SECTOFF_LO_DS",/* name */
1225 	 FALSE,			/* partial_inplace */
1226 	 0,			/* src_mask */
1227 	 0xfffc,		/* dst_mask */
1228 	 FALSE),		/* pcrel_offset */
1229 
1230   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1231   HOWTO (R_PPC64_TOC16_DS,	/* type */
1232 	 0,			/* rightshift */
1233 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1234 	 16,			/* bitsize */
1235 	 FALSE,			/* pc_relative */
1236 	 0,			/* bitpos */
1237 	 complain_overflow_signed, /* complain_on_overflow */
1238 	 ppc64_elf_toc_reloc,	/* special_function */
1239 	 "R_PPC64_TOC16_DS",	/* name */
1240 	 FALSE,			/* partial_inplace */
1241 	 0,			/* src_mask */
1242 	 0xfffc,		/* dst_mask */
1243 	 FALSE),		/* pcrel_offset */
1244 
1245   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1246   HOWTO (R_PPC64_TOC16_LO_DS,	/* type */
1247 	 0,			/* rightshift */
1248 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1249 	 16,			/* bitsize */
1250 	 FALSE,			/* pc_relative */
1251 	 0,			/* bitpos */
1252 	 complain_overflow_dont, /* complain_on_overflow */
1253 	 ppc64_elf_toc_reloc,	/* special_function */
1254 	 "R_PPC64_TOC16_LO_DS",	/* name */
1255 	 FALSE,			/* partial_inplace */
1256 	 0,			/* src_mask */
1257 	 0xfffc,		/* dst_mask */
1258 	 FALSE),		/* pcrel_offset */
1259 
1260   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1261   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1262   HOWTO (R_PPC64_PLTGOT16_DS,	/* type */
1263 	 0,			/* rightshift */
1264 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1265 	 16,			/* bitsize */
1266 	 FALSE,			/* pc_relative */
1267 	 0,			/* bitpos */
1268 	 complain_overflow_signed, /* complain_on_overflow */
1269 	 ppc64_elf_unhandled_reloc, /* special_function */
1270 	 "R_PPC64_PLTGOT16_DS",	/* name */
1271 	 FALSE,			/* partial_inplace */
1272 	 0,			/* src_mask */
1273 	 0xfffc,		/* dst_mask */
1274 	 FALSE),		/* pcrel_offset */
1275 
1276   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1277   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1278   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1279 	 0,			/* rightshift */
1280 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1281 	 16,			/* bitsize */
1282 	 FALSE,			/* pc_relative */
1283 	 0,			/* bitpos */
1284 	 complain_overflow_dont, /* complain_on_overflow */
1285 	 ppc64_elf_unhandled_reloc, /* special_function */
1286 	 "R_PPC64_PLTGOT16_LO_DS",/* name */
1287 	 FALSE,			/* partial_inplace */
1288 	 0,			/* src_mask */
1289 	 0xfffc,		/* dst_mask */
1290 	 FALSE),		/* pcrel_offset */
1291 
1292   /* Marker relocs for TLS.  */
1293   HOWTO (R_PPC64_TLS,
1294 	 0,			/* rightshift */
1295 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1296 	 32,			/* bitsize */
1297 	 FALSE,			/* pc_relative */
1298 	 0,			/* bitpos */
1299 	 complain_overflow_dont, /* complain_on_overflow */
1300 	 bfd_elf_generic_reloc,	/* special_function */
1301 	 "R_PPC64_TLS",		/* name */
1302 	 FALSE,			/* partial_inplace */
1303 	 0,			/* src_mask */
1304 	 0,			/* dst_mask */
1305 	 FALSE),		/* pcrel_offset */
1306 
1307   HOWTO (R_PPC64_TLSGD,
1308 	 0,			/* rightshift */
1309 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1310 	 32,			/* bitsize */
1311 	 FALSE,			/* pc_relative */
1312 	 0,			/* bitpos */
1313 	 complain_overflow_dont, /* complain_on_overflow */
1314 	 bfd_elf_generic_reloc,	/* special_function */
1315 	 "R_PPC64_TLSGD",	/* name */
1316 	 FALSE,			/* partial_inplace */
1317 	 0,			/* src_mask */
1318 	 0,			/* dst_mask */
1319 	 FALSE),		/* pcrel_offset */
1320 
1321   HOWTO (R_PPC64_TLSLD,
1322 	 0,			/* rightshift */
1323 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1324 	 32,			/* bitsize */
1325 	 FALSE,			/* pc_relative */
1326 	 0,			/* bitpos */
1327 	 complain_overflow_dont, /* complain_on_overflow */
1328 	 bfd_elf_generic_reloc,	/* special_function */
1329 	 "R_PPC64_TLSLD",	/* name */
1330 	 FALSE,			/* partial_inplace */
1331 	 0,			/* src_mask */
1332 	 0,			/* dst_mask */
1333 	 FALSE),		/* pcrel_offset */
1334 
1335   HOWTO (R_PPC64_TOCSAVE,
1336 	 0,			/* rightshift */
1337 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1338 	 32,			/* bitsize */
1339 	 FALSE,			/* pc_relative */
1340 	 0,			/* bitpos */
1341 	 complain_overflow_dont, /* complain_on_overflow */
1342 	 bfd_elf_generic_reloc,	/* special_function */
1343 	 "R_PPC64_TOCSAVE",	/* name */
1344 	 FALSE,			/* partial_inplace */
1345 	 0,			/* src_mask */
1346 	 0,			/* dst_mask */
1347 	 FALSE),		/* pcrel_offset */
1348 
1349   /* Computes the load module index of the load module that contains the
1350      definition of its TLS sym.  */
1351   HOWTO (R_PPC64_DTPMOD64,
1352 	 0,			/* rightshift */
1353 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
1354 	 64,			/* bitsize */
1355 	 FALSE,			/* pc_relative */
1356 	 0,			/* bitpos */
1357 	 complain_overflow_dont, /* complain_on_overflow */
1358 	 ppc64_elf_unhandled_reloc, /* special_function */
1359 	 "R_PPC64_DTPMOD64",	/* name */
1360 	 FALSE,			/* partial_inplace */
1361 	 0,			/* src_mask */
1362 	 ONES (64),		/* dst_mask */
1363 	 FALSE),		/* pcrel_offset */
1364 
1365   /* Computes a dtv-relative displacement, the difference between the value
1366      of sym+add and the base address of the thread-local storage block that
1367      contains the definition of sym, minus 0x8000.  */
1368   HOWTO (R_PPC64_DTPREL64,
1369 	 0,			/* rightshift */
1370 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
1371 	 64,			/* bitsize */
1372 	 FALSE,			/* pc_relative */
1373 	 0,			/* bitpos */
1374 	 complain_overflow_dont, /* complain_on_overflow */
1375 	 ppc64_elf_unhandled_reloc, /* special_function */
1376 	 "R_PPC64_DTPREL64",	/* name */
1377 	 FALSE,			/* partial_inplace */
1378 	 0,			/* src_mask */
1379 	 ONES (64),		/* dst_mask */
1380 	 FALSE),		/* pcrel_offset */
1381 
1382   /* A 16 bit dtprel reloc.  */
1383   HOWTO (R_PPC64_DTPREL16,
1384 	 0,			/* rightshift */
1385 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1386 	 16,			/* bitsize */
1387 	 FALSE,			/* pc_relative */
1388 	 0,			/* bitpos */
1389 	 complain_overflow_signed, /* complain_on_overflow */
1390 	 ppc64_elf_unhandled_reloc, /* special_function */
1391 	 "R_PPC64_DTPREL16",	/* name */
1392 	 FALSE,			/* partial_inplace */
1393 	 0,			/* src_mask */
1394 	 0xffff,		/* dst_mask */
1395 	 FALSE),		/* pcrel_offset */
1396 
1397   /* Like DTPREL16, but no overflow.  */
1398   HOWTO (R_PPC64_DTPREL16_LO,
1399 	 0,			/* rightshift */
1400 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1401 	 16,			/* bitsize */
1402 	 FALSE,			/* pc_relative */
1403 	 0,			/* bitpos */
1404 	 complain_overflow_dont, /* complain_on_overflow */
1405 	 ppc64_elf_unhandled_reloc, /* special_function */
1406 	 "R_PPC64_DTPREL16_LO",	/* name */
1407 	 FALSE,			/* partial_inplace */
1408 	 0,			/* src_mask */
1409 	 0xffff,		/* dst_mask */
1410 	 FALSE),		/* pcrel_offset */
1411 
1412   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1413   HOWTO (R_PPC64_DTPREL16_HI,
1414 	 16,			/* rightshift */
1415 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1416 	 16,			/* bitsize */
1417 	 FALSE,			/* pc_relative */
1418 	 0,			/* bitpos */
1419 	 complain_overflow_signed, /* complain_on_overflow */
1420 	 ppc64_elf_unhandled_reloc, /* special_function */
1421 	 "R_PPC64_DTPREL16_HI",	/* name */
1422 	 FALSE,			/* partial_inplace */
1423 	 0,			/* src_mask */
1424 	 0xffff,		/* dst_mask */
1425 	 FALSE),		/* pcrel_offset */
1426 
1427   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1428   HOWTO (R_PPC64_DTPREL16_HA,
1429 	 16,			/* rightshift */
1430 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1431 	 16,			/* bitsize */
1432 	 FALSE,			/* pc_relative */
1433 	 0,			/* bitpos */
1434 	 complain_overflow_signed, /* complain_on_overflow */
1435 	 ppc64_elf_unhandled_reloc, /* special_function */
1436 	 "R_PPC64_DTPREL16_HA",	/* name */
1437 	 FALSE,			/* partial_inplace */
1438 	 0,			/* src_mask */
1439 	 0xffff,		/* dst_mask */
1440 	 FALSE),		/* pcrel_offset */
1441 
1442   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1443   HOWTO (R_PPC64_DTPREL16_HIGHER,
1444 	 32,			/* rightshift */
1445 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1446 	 16,			/* bitsize */
1447 	 FALSE,			/* pc_relative */
1448 	 0,			/* bitpos */
1449 	 complain_overflow_dont, /* complain_on_overflow */
1450 	 ppc64_elf_unhandled_reloc, /* special_function */
1451 	 "R_PPC64_DTPREL16_HIGHER", /* name */
1452 	 FALSE,			/* partial_inplace */
1453 	 0,			/* src_mask */
1454 	 0xffff,		/* dst_mask */
1455 	 FALSE),		/* pcrel_offset */
1456 
1457   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1458   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1459 	 32,			/* rightshift */
1460 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1461 	 16,			/* bitsize */
1462 	 FALSE,			/* pc_relative */
1463 	 0,			/* bitpos */
1464 	 complain_overflow_dont, /* complain_on_overflow */
1465 	 ppc64_elf_unhandled_reloc, /* special_function */
1466 	 "R_PPC64_DTPREL16_HIGHERA", /* name */
1467 	 FALSE,			/* partial_inplace */
1468 	 0,			/* src_mask */
1469 	 0xffff,		/* dst_mask */
1470 	 FALSE),		/* pcrel_offset */
1471 
1472   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1473   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1474 	 48,			/* rightshift */
1475 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1476 	 16,			/* bitsize */
1477 	 FALSE,			/* pc_relative */
1478 	 0,			/* bitpos */
1479 	 complain_overflow_dont, /* complain_on_overflow */
1480 	 ppc64_elf_unhandled_reloc, /* special_function */
1481 	 "R_PPC64_DTPREL16_HIGHEST", /* name */
1482 	 FALSE,			/* partial_inplace */
1483 	 0,			/* src_mask */
1484 	 0xffff,		/* dst_mask */
1485 	 FALSE),		/* pcrel_offset */
1486 
1487   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1488   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1489 	 48,			/* rightshift */
1490 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1491 	 16,			/* bitsize */
1492 	 FALSE,			/* pc_relative */
1493 	 0,			/* bitpos */
1494 	 complain_overflow_dont, /* complain_on_overflow */
1495 	 ppc64_elf_unhandled_reloc, /* special_function */
1496 	 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1497 	 FALSE,			/* partial_inplace */
1498 	 0,			/* src_mask */
1499 	 0xffff,		/* dst_mask */
1500 	 FALSE),		/* pcrel_offset */
1501 
1502   /* Like DTPREL16, but for insns with a DS field.  */
1503   HOWTO (R_PPC64_DTPREL16_DS,
1504 	 0,			/* rightshift */
1505 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1506 	 16,			/* bitsize */
1507 	 FALSE,			/* pc_relative */
1508 	 0,			/* bitpos */
1509 	 complain_overflow_signed, /* complain_on_overflow */
1510 	 ppc64_elf_unhandled_reloc, /* special_function */
1511 	 "R_PPC64_DTPREL16_DS",	/* name */
1512 	 FALSE,			/* partial_inplace */
1513 	 0,			/* src_mask */
1514 	 0xfffc,		/* dst_mask */
1515 	 FALSE),		/* pcrel_offset */
1516 
1517   /* Like DTPREL16_DS, but no overflow.  */
1518   HOWTO (R_PPC64_DTPREL16_LO_DS,
1519 	 0,			/* rightshift */
1520 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1521 	 16,			/* bitsize */
1522 	 FALSE,			/* pc_relative */
1523 	 0,			/* bitpos */
1524 	 complain_overflow_dont, /* complain_on_overflow */
1525 	 ppc64_elf_unhandled_reloc, /* special_function */
1526 	 "R_PPC64_DTPREL16_LO_DS", /* name */
1527 	 FALSE,			/* partial_inplace */
1528 	 0,			/* src_mask */
1529 	 0xfffc,		/* dst_mask */
1530 	 FALSE),		/* pcrel_offset */
1531 
1532   /* Computes a tp-relative displacement, the difference between the value of
1533      sym+add and the value of the thread pointer (r13).  */
1534   HOWTO (R_PPC64_TPREL64,
1535 	 0,			/* rightshift */
1536 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
1537 	 64,			/* bitsize */
1538 	 FALSE,			/* pc_relative */
1539 	 0,			/* bitpos */
1540 	 complain_overflow_dont, /* complain_on_overflow */
1541 	 ppc64_elf_unhandled_reloc, /* special_function */
1542 	 "R_PPC64_TPREL64",	/* name */
1543 	 FALSE,			/* partial_inplace */
1544 	 0,			/* src_mask */
1545 	 ONES (64),		/* dst_mask */
1546 	 FALSE),		/* pcrel_offset */
1547 
1548   /* A 16 bit tprel reloc.  */
1549   HOWTO (R_PPC64_TPREL16,
1550 	 0,			/* rightshift */
1551 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1552 	 16,			/* bitsize */
1553 	 FALSE,			/* pc_relative */
1554 	 0,			/* bitpos */
1555 	 complain_overflow_signed, /* complain_on_overflow */
1556 	 ppc64_elf_unhandled_reloc, /* special_function */
1557 	 "R_PPC64_TPREL16",	/* name */
1558 	 FALSE,			/* partial_inplace */
1559 	 0,			/* src_mask */
1560 	 0xffff,		/* dst_mask */
1561 	 FALSE),		/* pcrel_offset */
1562 
1563   /* Like TPREL16, but no overflow.  */
1564   HOWTO (R_PPC64_TPREL16_LO,
1565 	 0,			/* rightshift */
1566 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1567 	 16,			/* bitsize */
1568 	 FALSE,			/* pc_relative */
1569 	 0,			/* bitpos */
1570 	 complain_overflow_dont, /* complain_on_overflow */
1571 	 ppc64_elf_unhandled_reloc, /* special_function */
1572 	 "R_PPC64_TPREL16_LO",	/* name */
1573 	 FALSE,			/* partial_inplace */
1574 	 0,			/* src_mask */
1575 	 0xffff,		/* dst_mask */
1576 	 FALSE),		/* pcrel_offset */
1577 
1578   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1579   HOWTO (R_PPC64_TPREL16_HI,
1580 	 16,			/* rightshift */
1581 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1582 	 16,			/* bitsize */
1583 	 FALSE,			/* pc_relative */
1584 	 0,			/* bitpos */
1585 	 complain_overflow_signed, /* complain_on_overflow */
1586 	 ppc64_elf_unhandled_reloc, /* special_function */
1587 	 "R_PPC64_TPREL16_HI",	/* name */
1588 	 FALSE,			/* partial_inplace */
1589 	 0,			/* src_mask */
1590 	 0xffff,		/* dst_mask */
1591 	 FALSE),		/* pcrel_offset */
1592 
1593   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1594   HOWTO (R_PPC64_TPREL16_HA,
1595 	 16,			/* rightshift */
1596 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1597 	 16,			/* bitsize */
1598 	 FALSE,			/* pc_relative */
1599 	 0,			/* bitpos */
1600 	 complain_overflow_signed, /* complain_on_overflow */
1601 	 ppc64_elf_unhandled_reloc, /* special_function */
1602 	 "R_PPC64_TPREL16_HA",	/* name */
1603 	 FALSE,			/* partial_inplace */
1604 	 0,			/* src_mask */
1605 	 0xffff,		/* dst_mask */
1606 	 FALSE),		/* pcrel_offset */
1607 
1608   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1609   HOWTO (R_PPC64_TPREL16_HIGHER,
1610 	 32,			/* rightshift */
1611 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1612 	 16,			/* bitsize */
1613 	 FALSE,			/* pc_relative */
1614 	 0,			/* bitpos */
1615 	 complain_overflow_dont, /* complain_on_overflow */
1616 	 ppc64_elf_unhandled_reloc, /* special_function */
1617 	 "R_PPC64_TPREL16_HIGHER",	/* name */
1618 	 FALSE,			/* partial_inplace */
1619 	 0,			/* src_mask */
1620 	 0xffff,		/* dst_mask */
1621 	 FALSE),		/* pcrel_offset */
1622 
1623   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1624   HOWTO (R_PPC64_TPREL16_HIGHERA,
1625 	 32,			/* rightshift */
1626 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1627 	 16,			/* bitsize */
1628 	 FALSE,			/* pc_relative */
1629 	 0,			/* bitpos */
1630 	 complain_overflow_dont, /* complain_on_overflow */
1631 	 ppc64_elf_unhandled_reloc, /* special_function */
1632 	 "R_PPC64_TPREL16_HIGHERA", /* name */
1633 	 FALSE,			/* partial_inplace */
1634 	 0,			/* src_mask */
1635 	 0xffff,		/* dst_mask */
1636 	 FALSE),		/* pcrel_offset */
1637 
1638   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1639   HOWTO (R_PPC64_TPREL16_HIGHEST,
1640 	 48,			/* rightshift */
1641 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1642 	 16,			/* bitsize */
1643 	 FALSE,			/* pc_relative */
1644 	 0,			/* bitpos */
1645 	 complain_overflow_dont, /* complain_on_overflow */
1646 	 ppc64_elf_unhandled_reloc, /* special_function */
1647 	 "R_PPC64_TPREL16_HIGHEST", /* name */
1648 	 FALSE,			/* partial_inplace */
1649 	 0,			/* src_mask */
1650 	 0xffff,		/* dst_mask */
1651 	 FALSE),		/* pcrel_offset */
1652 
1653   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1654   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1655 	 48,			/* rightshift */
1656 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1657 	 16,			/* bitsize */
1658 	 FALSE,			/* pc_relative */
1659 	 0,			/* bitpos */
1660 	 complain_overflow_dont, /* complain_on_overflow */
1661 	 ppc64_elf_unhandled_reloc, /* special_function */
1662 	 "R_PPC64_TPREL16_HIGHESTA", /* name */
1663 	 FALSE,			/* partial_inplace */
1664 	 0,			/* src_mask */
1665 	 0xffff,		/* dst_mask */
1666 	 FALSE),		/* pcrel_offset */
1667 
1668   /* Like TPREL16, but for insns with a DS field.  */
1669   HOWTO (R_PPC64_TPREL16_DS,
1670 	 0,			/* rightshift */
1671 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1672 	 16,			/* bitsize */
1673 	 FALSE,			/* pc_relative */
1674 	 0,			/* bitpos */
1675 	 complain_overflow_signed, /* complain_on_overflow */
1676 	 ppc64_elf_unhandled_reloc, /* special_function */
1677 	 "R_PPC64_TPREL16_DS",	/* name */
1678 	 FALSE,			/* partial_inplace */
1679 	 0,			/* src_mask */
1680 	 0xfffc,		/* dst_mask */
1681 	 FALSE),		/* pcrel_offset */
1682 
1683   /* Like TPREL16_DS, but no overflow.  */
1684   HOWTO (R_PPC64_TPREL16_LO_DS,
1685 	 0,			/* rightshift */
1686 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1687 	 16,			/* bitsize */
1688 	 FALSE,			/* pc_relative */
1689 	 0,			/* bitpos */
1690 	 complain_overflow_dont, /* complain_on_overflow */
1691 	 ppc64_elf_unhandled_reloc, /* special_function */
1692 	 "R_PPC64_TPREL16_LO_DS", /* name */
1693 	 FALSE,			/* partial_inplace */
1694 	 0,			/* src_mask */
1695 	 0xfffc,		/* dst_mask */
1696 	 FALSE),		/* pcrel_offset */
1697 
1698   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1699      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1700      to the first entry relative to the TOC base (r2).  */
1701   HOWTO (R_PPC64_GOT_TLSGD16,
1702 	 0,			/* rightshift */
1703 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1704 	 16,			/* bitsize */
1705 	 FALSE,			/* pc_relative */
1706 	 0,			/* bitpos */
1707 	 complain_overflow_signed, /* complain_on_overflow */
1708 	 ppc64_elf_unhandled_reloc, /* special_function */
1709 	 "R_PPC64_GOT_TLSGD16",	/* name */
1710 	 FALSE,			/* partial_inplace */
1711 	 0,			/* src_mask */
1712 	 0xffff,		/* dst_mask */
1713 	 FALSE),		/* pcrel_offset */
1714 
1715   /* Like GOT_TLSGD16, but no overflow.  */
1716   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1717 	 0,			/* rightshift */
1718 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1719 	 16,			/* bitsize */
1720 	 FALSE,			/* pc_relative */
1721 	 0,			/* bitpos */
1722 	 complain_overflow_dont, /* complain_on_overflow */
1723 	 ppc64_elf_unhandled_reloc, /* special_function */
1724 	 "R_PPC64_GOT_TLSGD16_LO", /* name */
1725 	 FALSE,			/* partial_inplace */
1726 	 0,			/* src_mask */
1727 	 0xffff,		/* dst_mask */
1728 	 FALSE),		/* pcrel_offset */
1729 
1730   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1731   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1732 	 16,			/* rightshift */
1733 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1734 	 16,			/* bitsize */
1735 	 FALSE,			/* pc_relative */
1736 	 0,			/* bitpos */
1737 	 complain_overflow_signed, /* complain_on_overflow */
1738 	 ppc64_elf_unhandled_reloc, /* special_function */
1739 	 "R_PPC64_GOT_TLSGD16_HI", /* name */
1740 	 FALSE,			/* partial_inplace */
1741 	 0,			/* src_mask */
1742 	 0xffff,		/* dst_mask */
1743 	 FALSE),		/* pcrel_offset */
1744 
1745   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1746   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1747 	 16,			/* rightshift */
1748 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1749 	 16,			/* bitsize */
1750 	 FALSE,			/* pc_relative */
1751 	 0,			/* bitpos */
1752 	 complain_overflow_signed, /* complain_on_overflow */
1753 	 ppc64_elf_unhandled_reloc, /* special_function */
1754 	 "R_PPC64_GOT_TLSGD16_HA", /* name */
1755 	 FALSE,			/* partial_inplace */
1756 	 0,			/* src_mask */
1757 	 0xffff,		/* dst_mask */
1758 	 FALSE),		/* pcrel_offset */
1759 
1760   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1761      with values (sym+add)@dtpmod and zero, and computes the offset to the
1762      first entry relative to the TOC base (r2).  */
1763   HOWTO (R_PPC64_GOT_TLSLD16,
1764 	 0,			/* rightshift */
1765 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1766 	 16,			/* bitsize */
1767 	 FALSE,			/* pc_relative */
1768 	 0,			/* bitpos */
1769 	 complain_overflow_signed, /* complain_on_overflow */
1770 	 ppc64_elf_unhandled_reloc, /* special_function */
1771 	 "R_PPC64_GOT_TLSLD16",	/* name */
1772 	 FALSE,			/* partial_inplace */
1773 	 0,			/* src_mask */
1774 	 0xffff,		/* dst_mask */
1775 	 FALSE),		/* pcrel_offset */
1776 
1777   /* Like GOT_TLSLD16, but no overflow.  */
1778   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1779 	 0,			/* rightshift */
1780 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1781 	 16,			/* bitsize */
1782 	 FALSE,			/* pc_relative */
1783 	 0,			/* bitpos */
1784 	 complain_overflow_dont, /* complain_on_overflow */
1785 	 ppc64_elf_unhandled_reloc, /* special_function */
1786 	 "R_PPC64_GOT_TLSLD16_LO", /* name */
1787 	 FALSE,			/* partial_inplace */
1788 	 0,			/* src_mask */
1789 	 0xffff,		/* dst_mask */
1790 	 FALSE),		/* pcrel_offset */
1791 
1792   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1793   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1794 	 16,			/* rightshift */
1795 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1796 	 16,			/* bitsize */
1797 	 FALSE,			/* pc_relative */
1798 	 0,			/* bitpos */
1799 	 complain_overflow_signed, /* complain_on_overflow */
1800 	 ppc64_elf_unhandled_reloc, /* special_function */
1801 	 "R_PPC64_GOT_TLSLD16_HI", /* name */
1802 	 FALSE,			/* partial_inplace */
1803 	 0,			/* src_mask */
1804 	 0xffff,		/* dst_mask */
1805 	 FALSE),		/* pcrel_offset */
1806 
1807   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1808   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1809 	 16,			/* rightshift */
1810 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1811 	 16,			/* bitsize */
1812 	 FALSE,			/* pc_relative */
1813 	 0,			/* bitpos */
1814 	 complain_overflow_signed, /* complain_on_overflow */
1815 	 ppc64_elf_unhandled_reloc, /* special_function */
1816 	 "R_PPC64_GOT_TLSLD16_HA", /* name */
1817 	 FALSE,			/* partial_inplace */
1818 	 0,			/* src_mask */
1819 	 0xffff,		/* dst_mask */
1820 	 FALSE),		/* pcrel_offset */
1821 
1822   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1823      the offset to the entry relative to the TOC base (r2).  */
1824   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1825 	 0,			/* rightshift */
1826 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1827 	 16,			/* bitsize */
1828 	 FALSE,			/* pc_relative */
1829 	 0,			/* bitpos */
1830 	 complain_overflow_signed, /* complain_on_overflow */
1831 	 ppc64_elf_unhandled_reloc, /* special_function */
1832 	 "R_PPC64_GOT_DTPREL16_DS", /* name */
1833 	 FALSE,			/* partial_inplace */
1834 	 0,			/* src_mask */
1835 	 0xfffc,		/* dst_mask */
1836 	 FALSE),		/* pcrel_offset */
1837 
1838   /* Like GOT_DTPREL16_DS, but no overflow.  */
1839   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1840 	 0,			/* rightshift */
1841 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1842 	 16,			/* bitsize */
1843 	 FALSE,			/* pc_relative */
1844 	 0,			/* bitpos */
1845 	 complain_overflow_dont, /* complain_on_overflow */
1846 	 ppc64_elf_unhandled_reloc, /* special_function */
1847 	 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1848 	 FALSE,			/* partial_inplace */
1849 	 0,			/* src_mask */
1850 	 0xfffc,		/* dst_mask */
1851 	 FALSE),		/* pcrel_offset */
1852 
1853   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1854   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1855 	 16,			/* rightshift */
1856 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1857 	 16,			/* bitsize */
1858 	 FALSE,			/* pc_relative */
1859 	 0,			/* bitpos */
1860 	 complain_overflow_signed, /* complain_on_overflow */
1861 	 ppc64_elf_unhandled_reloc, /* special_function */
1862 	 "R_PPC64_GOT_DTPREL16_HI", /* name */
1863 	 FALSE,			/* partial_inplace */
1864 	 0,			/* src_mask */
1865 	 0xffff,		/* dst_mask */
1866 	 FALSE),		/* pcrel_offset */
1867 
1868   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1869   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1870 	 16,			/* rightshift */
1871 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1872 	 16,			/* bitsize */
1873 	 FALSE,			/* pc_relative */
1874 	 0,			/* bitpos */
1875 	 complain_overflow_signed, /* complain_on_overflow */
1876 	 ppc64_elf_unhandled_reloc, /* special_function */
1877 	 "R_PPC64_GOT_DTPREL16_HA", /* name */
1878 	 FALSE,			/* partial_inplace */
1879 	 0,			/* src_mask */
1880 	 0xffff,		/* dst_mask */
1881 	 FALSE),		/* pcrel_offset */
1882 
1883   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1884      offset to the entry relative to the TOC base (r2).  */
1885   HOWTO (R_PPC64_GOT_TPREL16_DS,
1886 	 0,			/* rightshift */
1887 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1888 	 16,			/* bitsize */
1889 	 FALSE,			/* pc_relative */
1890 	 0,			/* bitpos */
1891 	 complain_overflow_signed, /* complain_on_overflow */
1892 	 ppc64_elf_unhandled_reloc, /* special_function */
1893 	 "R_PPC64_GOT_TPREL16_DS", /* name */
1894 	 FALSE,			/* partial_inplace */
1895 	 0,			/* src_mask */
1896 	 0xfffc,		/* dst_mask */
1897 	 FALSE),		/* pcrel_offset */
1898 
1899   /* Like GOT_TPREL16_DS, but no overflow.  */
1900   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1901 	 0,			/* rightshift */
1902 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1903 	 16,			/* bitsize */
1904 	 FALSE,			/* pc_relative */
1905 	 0,			/* bitpos */
1906 	 complain_overflow_dont, /* complain_on_overflow */
1907 	 ppc64_elf_unhandled_reloc, /* special_function */
1908 	 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1909 	 FALSE,			/* partial_inplace */
1910 	 0,			/* src_mask */
1911 	 0xfffc,		/* dst_mask */
1912 	 FALSE),		/* pcrel_offset */
1913 
1914   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1915   HOWTO (R_PPC64_GOT_TPREL16_HI,
1916 	 16,			/* rightshift */
1917 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1918 	 16,			/* bitsize */
1919 	 FALSE,			/* pc_relative */
1920 	 0,			/* bitpos */
1921 	 complain_overflow_signed, /* complain_on_overflow */
1922 	 ppc64_elf_unhandled_reloc, /* special_function */
1923 	 "R_PPC64_GOT_TPREL16_HI", /* name */
1924 	 FALSE,			/* partial_inplace */
1925 	 0,			/* src_mask */
1926 	 0xffff,		/* dst_mask */
1927 	 FALSE),		/* pcrel_offset */
1928 
1929   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1930   HOWTO (R_PPC64_GOT_TPREL16_HA,
1931 	 16,			/* rightshift */
1932 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1933 	 16,			/* bitsize */
1934 	 FALSE,			/* pc_relative */
1935 	 0,			/* bitpos */
1936 	 complain_overflow_signed, /* complain_on_overflow */
1937 	 ppc64_elf_unhandled_reloc, /* special_function */
1938 	 "R_PPC64_GOT_TPREL16_HA", /* name */
1939 	 FALSE,			/* partial_inplace */
1940 	 0,			/* src_mask */
1941 	 0xffff,		/* dst_mask */
1942 	 FALSE),		/* pcrel_offset */
1943 
1944   HOWTO (R_PPC64_JMP_IREL,	/* type */
1945 	 0,			/* rightshift */
1946 	 0,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
1947 	 0,			/* bitsize */
1948 	 FALSE,			/* pc_relative */
1949 	 0,			/* bitpos */
1950 	 complain_overflow_dont, /* complain_on_overflow */
1951 	 ppc64_elf_unhandled_reloc, /* special_function */
1952 	 "R_PPC64_JMP_IREL",	/* name */
1953 	 FALSE,			/* partial_inplace */
1954 	 0,			/* src_mask */
1955 	 0,			/* dst_mask */
1956 	 FALSE),		/* pcrel_offset */
1957 
1958   HOWTO (R_PPC64_IRELATIVE,	/* type */
1959 	 0,			/* rightshift */
1960 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
1961 	 64,			/* bitsize */
1962 	 FALSE,			/* pc_relative */
1963 	 0,			/* bitpos */
1964 	 complain_overflow_dont, /* complain_on_overflow */
1965 	 bfd_elf_generic_reloc,	/* special_function */
1966 	 "R_PPC64_IRELATIVE",	/* name */
1967 	 FALSE,			/* partial_inplace */
1968 	 0,			/* src_mask */
1969 	 ONES (64),		/* dst_mask */
1970 	 FALSE),		/* pcrel_offset */
1971 
1972   /* A 16 bit relative relocation.  */
1973   HOWTO (R_PPC64_REL16,		/* type */
1974 	 0,			/* rightshift */
1975 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1976 	 16,			/* bitsize */
1977 	 TRUE,			/* pc_relative */
1978 	 0,			/* bitpos */
1979 	 complain_overflow_signed, /* complain_on_overflow */
1980 	 bfd_elf_generic_reloc,	/* special_function */
1981 	 "R_PPC64_REL16",	/* name */
1982 	 FALSE,			/* partial_inplace */
1983 	 0,			/* src_mask */
1984 	 0xffff,		/* dst_mask */
1985 	 TRUE),			/* pcrel_offset */
1986 
1987   /* A 16 bit relative relocation without overflow.  */
1988   HOWTO (R_PPC64_REL16_LO,	/* type */
1989 	 0,			/* rightshift */
1990 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1991 	 16,			/* bitsize */
1992 	 TRUE,			/* pc_relative */
1993 	 0,			/* bitpos */
1994 	 complain_overflow_dont,/* complain_on_overflow */
1995 	 bfd_elf_generic_reloc,	/* special_function */
1996 	 "R_PPC64_REL16_LO",	/* name */
1997 	 FALSE,			/* partial_inplace */
1998 	 0,			/* src_mask */
1999 	 0xffff,		/* dst_mask */
2000 	 TRUE),			/* pcrel_offset */
2001 
2002   /* The high order 16 bits of a relative address.  */
2003   HOWTO (R_PPC64_REL16_HI,	/* type */
2004 	 16,			/* rightshift */
2005 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2006 	 16,			/* bitsize */
2007 	 TRUE,			/* pc_relative */
2008 	 0,			/* bitpos */
2009 	 complain_overflow_signed, /* complain_on_overflow */
2010 	 bfd_elf_generic_reloc,	/* special_function */
2011 	 "R_PPC64_REL16_HI",	/* name */
2012 	 FALSE,			/* partial_inplace */
2013 	 0,			/* src_mask */
2014 	 0xffff,		/* dst_mask */
2015 	 TRUE),			/* pcrel_offset */
2016 
2017   /* The high order 16 bits of a relative address, plus 1 if the contents of
2018      the low 16 bits, treated as a signed number, is negative.  */
2019   HOWTO (R_PPC64_REL16_HA,	/* type */
2020 	 16,			/* rightshift */
2021 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2022 	 16,			/* bitsize */
2023 	 TRUE,			/* pc_relative */
2024 	 0,			/* bitpos */
2025 	 complain_overflow_signed, /* complain_on_overflow */
2026 	 ppc64_elf_ha_reloc,	/* special_function */
2027 	 "R_PPC64_REL16_HA",	/* name */
2028 	 FALSE,			/* partial_inplace */
2029 	 0,			/* src_mask */
2030 	 0xffff,		/* dst_mask */
2031 	 TRUE),			/* pcrel_offset */
2032 
2033   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2034   HOWTO (R_PPC64_REL16DX_HA,	/* type */
2035 	 16,			/* rightshift */
2036 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
2037 	 16,			/* bitsize */
2038 	 TRUE,			/* pc_relative */
2039 	 0,			/* bitpos */
2040 	 complain_overflow_signed, /* complain_on_overflow */
2041 	 ppc64_elf_ha_reloc,	/* special_function */
2042 	 "R_PPC64_REL16DX_HA",	/* name */
2043 	 FALSE,			/* partial_inplace */
2044 	 0,			/* src_mask */
2045 	 0x1fffc1,		/* dst_mask */
2046 	 TRUE),			/* pcrel_offset */
2047 
2048   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2049   HOWTO (R_PPC64_16DX_HA,	/* type */
2050 	 16,			/* rightshift */
2051 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
2052 	 16,			/* bitsize */
2053 	 FALSE,			/* pc_relative */
2054 	 0,			/* bitpos */
2055 	 complain_overflow_signed, /* complain_on_overflow */
2056 	 ppc64_elf_ha_reloc,	/* special_function */
2057 	 "R_PPC64_16DX_HA",	/* name */
2058 	 FALSE,			/* partial_inplace */
2059 	 0,			/* src_mask */
2060 	 0x1fffc1,		/* dst_mask */
2061 	 FALSE),		/* pcrel_offset */
2062 
2063   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2064   HOWTO (R_PPC64_ADDR16_HIGH,	/* type */
2065 	 16,			/* rightshift */
2066 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2067 	 16,			/* bitsize */
2068 	 FALSE,			/* pc_relative */
2069 	 0,			/* bitpos */
2070 	 complain_overflow_dont, /* complain_on_overflow */
2071 	 bfd_elf_generic_reloc,	/* special_function */
2072 	 "R_PPC64_ADDR16_HIGH",	/* name */
2073 	 FALSE,			/* partial_inplace */
2074 	 0,			/* src_mask */
2075 	 0xffff,		/* dst_mask */
2076 	 FALSE),		/* pcrel_offset */
2077 
2078   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2079   HOWTO (R_PPC64_ADDR16_HIGHA,	/* type */
2080 	 16,			/* rightshift */
2081 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2082 	 16,			/* bitsize */
2083 	 FALSE,			/* pc_relative */
2084 	 0,			/* bitpos */
2085 	 complain_overflow_dont, /* complain_on_overflow */
2086 	 ppc64_elf_ha_reloc,	/* special_function */
2087 	 "R_PPC64_ADDR16_HIGHA",	/* name */
2088 	 FALSE,			/* partial_inplace */
2089 	 0,			/* src_mask */
2090 	 0xffff,		/* dst_mask */
2091 	 FALSE),		/* pcrel_offset */
2092 
2093   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2094   HOWTO (R_PPC64_DTPREL16_HIGH,
2095 	 16,			/* rightshift */
2096 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2097 	 16,			/* bitsize */
2098 	 FALSE,			/* pc_relative */
2099 	 0,			/* bitpos */
2100 	 complain_overflow_dont, /* complain_on_overflow */
2101 	 ppc64_elf_unhandled_reloc, /* special_function */
2102 	 "R_PPC64_DTPREL16_HIGH", /* name */
2103 	 FALSE,			/* partial_inplace */
2104 	 0,			/* src_mask */
2105 	 0xffff,		/* dst_mask */
2106 	 FALSE),		/* pcrel_offset */
2107 
2108   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2109   HOWTO (R_PPC64_DTPREL16_HIGHA,
2110 	 16,			/* rightshift */
2111 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2112 	 16,			/* bitsize */
2113 	 FALSE,			/* pc_relative */
2114 	 0,			/* bitpos */
2115 	 complain_overflow_dont, /* complain_on_overflow */
2116 	 ppc64_elf_unhandled_reloc, /* special_function */
2117 	 "R_PPC64_DTPREL16_HIGHA", /* name */
2118 	 FALSE,			/* partial_inplace */
2119 	 0,			/* src_mask */
2120 	 0xffff,		/* dst_mask */
2121 	 FALSE),		/* pcrel_offset */
2122 
2123   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2124   HOWTO (R_PPC64_TPREL16_HIGH,
2125 	 16,			/* rightshift */
2126 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2127 	 16,			/* bitsize */
2128 	 FALSE,			/* pc_relative */
2129 	 0,			/* bitpos */
2130 	 complain_overflow_dont, /* complain_on_overflow */
2131 	 ppc64_elf_unhandled_reloc, /* special_function */
2132 	 "R_PPC64_TPREL16_HIGH",	/* name */
2133 	 FALSE,			/* partial_inplace */
2134 	 0,			/* src_mask */
2135 	 0xffff,		/* dst_mask */
2136 	 FALSE),		/* pcrel_offset */
2137 
2138   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2139   HOWTO (R_PPC64_TPREL16_HIGHA,
2140 	 16,			/* rightshift */
2141 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2142 	 16,			/* bitsize */
2143 	 FALSE,			/* pc_relative */
2144 	 0,			/* bitpos */
2145 	 complain_overflow_dont, /* complain_on_overflow */
2146 	 ppc64_elf_unhandled_reloc, /* special_function */
2147 	 "R_PPC64_TPREL16_HIGHA",	/* name */
2148 	 FALSE,			/* partial_inplace */
2149 	 0,			/* src_mask */
2150 	 0xffff,		/* dst_mask */
2151 	 FALSE),		/* pcrel_offset */
2152 
2153   /* Marker reloc on ELFv2 large-model function entry.  */
2154   HOWTO (R_PPC64_ENTRY,
2155 	 0,			/* rightshift */
2156 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
2157 	 32,			/* bitsize */
2158 	 FALSE,			/* pc_relative */
2159 	 0,			/* bitpos */
2160 	 complain_overflow_dont, /* complain_on_overflow */
2161 	 bfd_elf_generic_reloc,	/* special_function */
2162 	 "R_PPC64_ENTRY",	/* name */
2163 	 FALSE,			/* partial_inplace */
2164 	 0,			/* src_mask */
2165 	 0,			/* dst_mask */
2166 	 FALSE),		/* pcrel_offset */
2167 
2168   /* Like ADDR64, but use local entry point of function.  */
2169   HOWTO (R_PPC64_ADDR64_LOCAL,	/* type */
2170 	 0,			/* rightshift */
2171 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
2172 	 64,			/* bitsize */
2173 	 FALSE,			/* pc_relative */
2174 	 0,			/* bitpos */
2175 	 complain_overflow_dont, /* complain_on_overflow */
2176 	 bfd_elf_generic_reloc,	/* special_function */
2177 	 "R_PPC64_ADDR64_LOCAL", /* name */
2178 	 FALSE,			/* partial_inplace */
2179 	 0,			/* src_mask */
2180 	 ONES (64),		/* dst_mask */
2181 	 FALSE),		/* pcrel_offset */
2182 
2183   /* GNU extension to record C++ vtable hierarchy.  */
2184   HOWTO (R_PPC64_GNU_VTINHERIT,	/* type */
2185 	 0,			/* rightshift */
2186 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
2187 	 0,			/* bitsize */
2188 	 FALSE,			/* pc_relative */
2189 	 0,			/* bitpos */
2190 	 complain_overflow_dont, /* complain_on_overflow */
2191 	 NULL,			/* special_function */
2192 	 "R_PPC64_GNU_VTINHERIT", /* name */
2193 	 FALSE,			/* partial_inplace */
2194 	 0,			/* src_mask */
2195 	 0,			/* dst_mask */
2196 	 FALSE),		/* pcrel_offset */
2197 
2198   /* GNU extension to record C++ vtable member usage.  */
2199   HOWTO (R_PPC64_GNU_VTENTRY,	/* type */
2200 	 0,			/* rightshift */
2201 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
2202 	 0,			/* bitsize */
2203 	 FALSE,			/* pc_relative */
2204 	 0,			/* bitpos */
2205 	 complain_overflow_dont, /* complain_on_overflow */
2206 	 NULL,			/* special_function */
2207 	 "R_PPC64_GNU_VTENTRY",	/* name */
2208 	 FALSE,			/* partial_inplace */
2209 	 0,			/* src_mask */
2210 	 0,			/* dst_mask */
2211 	 FALSE),		/* pcrel_offset */
2212 };
2213 
2214 
2215 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2216    be done.  */
2217 
2218 static void
2219 ppc_howto_init (void)
2220 {
2221   unsigned int i, type;
2222 
2223   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2224     {
2225       type = ppc64_elf_howto_raw[i].type;
2226       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2227       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2228     }
2229 }
2230 
2231 static reloc_howto_type *
2232 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2233 			     bfd_reloc_code_real_type code)
2234 {
2235   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2236 
2237   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2238     /* Initialize howto table if needed.  */
2239     ppc_howto_init ();
2240 
2241   switch (code)
2242     {
2243     default:
2244       return NULL;
2245 
2246     case BFD_RELOC_NONE:			r = R_PPC64_NONE;
2247       break;
2248     case BFD_RELOC_32:				r = R_PPC64_ADDR32;
2249       break;
2250     case BFD_RELOC_PPC_BA26:			r = R_PPC64_ADDR24;
2251       break;
2252     case BFD_RELOC_16:				r = R_PPC64_ADDR16;
2253       break;
2254     case BFD_RELOC_LO16:			r = R_PPC64_ADDR16_LO;
2255       break;
2256     case BFD_RELOC_HI16:			r = R_PPC64_ADDR16_HI;
2257       break;
2258     case BFD_RELOC_PPC64_ADDR16_HIGH:		r = R_PPC64_ADDR16_HIGH;
2259       break;
2260     case BFD_RELOC_HI16_S:			r = R_PPC64_ADDR16_HA;
2261       break;
2262     case BFD_RELOC_PPC64_ADDR16_HIGHA:		r = R_PPC64_ADDR16_HIGHA;
2263       break;
2264     case BFD_RELOC_PPC_BA16:			r = R_PPC64_ADDR14;
2265       break;
2266     case BFD_RELOC_PPC_BA16_BRTAKEN:		r = R_PPC64_ADDR14_BRTAKEN;
2267       break;
2268     case BFD_RELOC_PPC_BA16_BRNTAKEN:		r = R_PPC64_ADDR14_BRNTAKEN;
2269       break;
2270     case BFD_RELOC_PPC_B26:			r = R_PPC64_REL24;
2271       break;
2272     case BFD_RELOC_PPC_B16:			r = R_PPC64_REL14;
2273       break;
2274     case BFD_RELOC_PPC_B16_BRTAKEN:		r = R_PPC64_REL14_BRTAKEN;
2275       break;
2276     case BFD_RELOC_PPC_B16_BRNTAKEN:		r = R_PPC64_REL14_BRNTAKEN;
2277       break;
2278     case BFD_RELOC_16_GOTOFF:			r = R_PPC64_GOT16;
2279       break;
2280     case BFD_RELOC_LO16_GOTOFF:			r = R_PPC64_GOT16_LO;
2281       break;
2282     case BFD_RELOC_HI16_GOTOFF:			r = R_PPC64_GOT16_HI;
2283       break;
2284     case BFD_RELOC_HI16_S_GOTOFF:		r = R_PPC64_GOT16_HA;
2285       break;
2286     case BFD_RELOC_PPC_COPY:			r = R_PPC64_COPY;
2287       break;
2288     case BFD_RELOC_PPC_GLOB_DAT:		r = R_PPC64_GLOB_DAT;
2289       break;
2290     case BFD_RELOC_32_PCREL:			r = R_PPC64_REL32;
2291       break;
2292     case BFD_RELOC_32_PLTOFF:			r = R_PPC64_PLT32;
2293       break;
2294     case BFD_RELOC_32_PLT_PCREL:		r = R_PPC64_PLTREL32;
2295       break;
2296     case BFD_RELOC_LO16_PLTOFF:			r = R_PPC64_PLT16_LO;
2297       break;
2298     case BFD_RELOC_HI16_PLTOFF:			r = R_PPC64_PLT16_HI;
2299       break;
2300     case BFD_RELOC_HI16_S_PLTOFF:		r = R_PPC64_PLT16_HA;
2301       break;
2302     case BFD_RELOC_16_BASEREL:			r = R_PPC64_SECTOFF;
2303       break;
2304     case BFD_RELOC_LO16_BASEREL:		r = R_PPC64_SECTOFF_LO;
2305       break;
2306     case BFD_RELOC_HI16_BASEREL:		r = R_PPC64_SECTOFF_HI;
2307       break;
2308     case BFD_RELOC_HI16_S_BASEREL:		r = R_PPC64_SECTOFF_HA;
2309       break;
2310     case BFD_RELOC_CTOR:			r = R_PPC64_ADDR64;
2311       break;
2312     case BFD_RELOC_64:				r = R_PPC64_ADDR64;
2313       break;
2314     case BFD_RELOC_PPC64_HIGHER:		r = R_PPC64_ADDR16_HIGHER;
2315       break;
2316     case BFD_RELOC_PPC64_HIGHER_S:		r = R_PPC64_ADDR16_HIGHERA;
2317       break;
2318     case BFD_RELOC_PPC64_HIGHEST:		r = R_PPC64_ADDR16_HIGHEST;
2319       break;
2320     case BFD_RELOC_PPC64_HIGHEST_S:		r = R_PPC64_ADDR16_HIGHESTA;
2321       break;
2322     case BFD_RELOC_64_PCREL:			r = R_PPC64_REL64;
2323       break;
2324     case BFD_RELOC_64_PLTOFF:			r = R_PPC64_PLT64;
2325       break;
2326     case BFD_RELOC_64_PLT_PCREL:		r = R_PPC64_PLTREL64;
2327       break;
2328     case BFD_RELOC_PPC_TOC16:			r = R_PPC64_TOC16;
2329       break;
2330     case BFD_RELOC_PPC64_TOC16_LO:		r = R_PPC64_TOC16_LO;
2331       break;
2332     case BFD_RELOC_PPC64_TOC16_HI:		r = R_PPC64_TOC16_HI;
2333       break;
2334     case BFD_RELOC_PPC64_TOC16_HA:		r = R_PPC64_TOC16_HA;
2335       break;
2336     case BFD_RELOC_PPC64_TOC:			r = R_PPC64_TOC;
2337       break;
2338     case BFD_RELOC_PPC64_PLTGOT16:		r = R_PPC64_PLTGOT16;
2339       break;
2340     case BFD_RELOC_PPC64_PLTGOT16_LO:		r = R_PPC64_PLTGOT16_LO;
2341       break;
2342     case BFD_RELOC_PPC64_PLTGOT16_HI:		r = R_PPC64_PLTGOT16_HI;
2343       break;
2344     case BFD_RELOC_PPC64_PLTGOT16_HA:		r = R_PPC64_PLTGOT16_HA;
2345       break;
2346     case BFD_RELOC_PPC64_ADDR16_DS:		r = R_PPC64_ADDR16_DS;
2347       break;
2348     case BFD_RELOC_PPC64_ADDR16_LO_DS:		r = R_PPC64_ADDR16_LO_DS;
2349       break;
2350     case BFD_RELOC_PPC64_GOT16_DS:		r = R_PPC64_GOT16_DS;
2351       break;
2352     case BFD_RELOC_PPC64_GOT16_LO_DS:		r = R_PPC64_GOT16_LO_DS;
2353       break;
2354     case BFD_RELOC_PPC64_PLT16_LO_DS:		r = R_PPC64_PLT16_LO_DS;
2355       break;
2356     case BFD_RELOC_PPC64_SECTOFF_DS:		r = R_PPC64_SECTOFF_DS;
2357       break;
2358     case BFD_RELOC_PPC64_SECTOFF_LO_DS:		r = R_PPC64_SECTOFF_LO_DS;
2359       break;
2360     case BFD_RELOC_PPC64_TOC16_DS:		r = R_PPC64_TOC16_DS;
2361       break;
2362     case BFD_RELOC_PPC64_TOC16_LO_DS:		r = R_PPC64_TOC16_LO_DS;
2363       break;
2364     case BFD_RELOC_PPC64_PLTGOT16_DS:		r = R_PPC64_PLTGOT16_DS;
2365       break;
2366     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:	r = R_PPC64_PLTGOT16_LO_DS;
2367       break;
2368     case BFD_RELOC_PPC_TLS:			r = R_PPC64_TLS;
2369       break;
2370     case BFD_RELOC_PPC_TLSGD:			r = R_PPC64_TLSGD;
2371       break;
2372     case BFD_RELOC_PPC_TLSLD:			r = R_PPC64_TLSLD;
2373       break;
2374     case BFD_RELOC_PPC_DTPMOD:			r = R_PPC64_DTPMOD64;
2375       break;
2376     case BFD_RELOC_PPC_TPREL16:			r = R_PPC64_TPREL16;
2377       break;
2378     case BFD_RELOC_PPC_TPREL16_LO:		r = R_PPC64_TPREL16_LO;
2379       break;
2380     case BFD_RELOC_PPC_TPREL16_HI:		r = R_PPC64_TPREL16_HI;
2381       break;
2382     case BFD_RELOC_PPC64_TPREL16_HIGH:		r = R_PPC64_TPREL16_HIGH;
2383       break;
2384     case BFD_RELOC_PPC_TPREL16_HA:		r = R_PPC64_TPREL16_HA;
2385       break;
2386     case BFD_RELOC_PPC64_TPREL16_HIGHA:		r = R_PPC64_TPREL16_HIGHA;
2387       break;
2388     case BFD_RELOC_PPC_TPREL:			r = R_PPC64_TPREL64;
2389       break;
2390     case BFD_RELOC_PPC_DTPREL16:		r = R_PPC64_DTPREL16;
2391       break;
2392     case BFD_RELOC_PPC_DTPREL16_LO:		r = R_PPC64_DTPREL16_LO;
2393       break;
2394     case BFD_RELOC_PPC_DTPREL16_HI:		r = R_PPC64_DTPREL16_HI;
2395       break;
2396     case BFD_RELOC_PPC64_DTPREL16_HIGH:		r = R_PPC64_DTPREL16_HIGH;
2397       break;
2398     case BFD_RELOC_PPC_DTPREL16_HA:		r = R_PPC64_DTPREL16_HA;
2399       break;
2400     case BFD_RELOC_PPC64_DTPREL16_HIGHA:	r = R_PPC64_DTPREL16_HIGHA;
2401       break;
2402     case BFD_RELOC_PPC_DTPREL:			r = R_PPC64_DTPREL64;
2403       break;
2404     case BFD_RELOC_PPC_GOT_TLSGD16:		r = R_PPC64_GOT_TLSGD16;
2405       break;
2406     case BFD_RELOC_PPC_GOT_TLSGD16_LO:		r = R_PPC64_GOT_TLSGD16_LO;
2407       break;
2408     case BFD_RELOC_PPC_GOT_TLSGD16_HI:		r = R_PPC64_GOT_TLSGD16_HI;
2409       break;
2410     case BFD_RELOC_PPC_GOT_TLSGD16_HA:		r = R_PPC64_GOT_TLSGD16_HA;
2411       break;
2412     case BFD_RELOC_PPC_GOT_TLSLD16:		r = R_PPC64_GOT_TLSLD16;
2413       break;
2414     case BFD_RELOC_PPC_GOT_TLSLD16_LO:		r = R_PPC64_GOT_TLSLD16_LO;
2415       break;
2416     case BFD_RELOC_PPC_GOT_TLSLD16_HI:		r = R_PPC64_GOT_TLSLD16_HI;
2417       break;
2418     case BFD_RELOC_PPC_GOT_TLSLD16_HA:		r = R_PPC64_GOT_TLSLD16_HA;
2419       break;
2420     case BFD_RELOC_PPC_GOT_TPREL16:		r = R_PPC64_GOT_TPREL16_DS;
2421       break;
2422     case BFD_RELOC_PPC_GOT_TPREL16_LO:		r = R_PPC64_GOT_TPREL16_LO_DS;
2423       break;
2424     case BFD_RELOC_PPC_GOT_TPREL16_HI:		r = R_PPC64_GOT_TPREL16_HI;
2425       break;
2426     case BFD_RELOC_PPC_GOT_TPREL16_HA:		r = R_PPC64_GOT_TPREL16_HA;
2427       break;
2428     case BFD_RELOC_PPC_GOT_DTPREL16:		r = R_PPC64_GOT_DTPREL16_DS;
2429       break;
2430     case BFD_RELOC_PPC_GOT_DTPREL16_LO:		r = R_PPC64_GOT_DTPREL16_LO_DS;
2431       break;
2432     case BFD_RELOC_PPC_GOT_DTPREL16_HI:		r = R_PPC64_GOT_DTPREL16_HI;
2433       break;
2434     case BFD_RELOC_PPC_GOT_DTPREL16_HA:		r = R_PPC64_GOT_DTPREL16_HA;
2435       break;
2436     case BFD_RELOC_PPC64_TPREL16_DS:		r = R_PPC64_TPREL16_DS;
2437       break;
2438     case BFD_RELOC_PPC64_TPREL16_LO_DS:		r = R_PPC64_TPREL16_LO_DS;
2439       break;
2440     case BFD_RELOC_PPC64_TPREL16_HIGHER:	r = R_PPC64_TPREL16_HIGHER;
2441       break;
2442     case BFD_RELOC_PPC64_TPREL16_HIGHERA:	r = R_PPC64_TPREL16_HIGHERA;
2443       break;
2444     case BFD_RELOC_PPC64_TPREL16_HIGHEST:	r = R_PPC64_TPREL16_HIGHEST;
2445       break;
2446     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:	r = R_PPC64_TPREL16_HIGHESTA;
2447       break;
2448     case BFD_RELOC_PPC64_DTPREL16_DS:		r = R_PPC64_DTPREL16_DS;
2449       break;
2450     case BFD_RELOC_PPC64_DTPREL16_LO_DS:	r = R_PPC64_DTPREL16_LO_DS;
2451       break;
2452     case BFD_RELOC_PPC64_DTPREL16_HIGHER:	r = R_PPC64_DTPREL16_HIGHER;
2453       break;
2454     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:	r = R_PPC64_DTPREL16_HIGHERA;
2455       break;
2456     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:	r = R_PPC64_DTPREL16_HIGHEST;
2457       break;
2458     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:	r = R_PPC64_DTPREL16_HIGHESTA;
2459       break;
2460     case BFD_RELOC_16_PCREL:			r = R_PPC64_REL16;
2461       break;
2462     case BFD_RELOC_LO16_PCREL:			r = R_PPC64_REL16_LO;
2463       break;
2464     case BFD_RELOC_HI16_PCREL:			r = R_PPC64_REL16_HI;
2465       break;
2466     case BFD_RELOC_HI16_S_PCREL:		r = R_PPC64_REL16_HA;
2467       break;
2468     case BFD_RELOC_PPC_16DX_HA:			r = R_PPC64_16DX_HA;
2469       break;
2470     case BFD_RELOC_PPC_REL16DX_HA:		r = R_PPC64_REL16DX_HA;
2471       break;
2472     case BFD_RELOC_PPC64_ENTRY:			r = R_PPC64_ENTRY;
2473       break;
2474     case BFD_RELOC_PPC64_ADDR64_LOCAL:		r = R_PPC64_ADDR64_LOCAL;
2475       break;
2476     case BFD_RELOC_VTABLE_INHERIT:		r = R_PPC64_GNU_VTINHERIT;
2477       break;
2478     case BFD_RELOC_VTABLE_ENTRY:		r = R_PPC64_GNU_VTENTRY;
2479       break;
2480     }
2481 
2482   return ppc64_elf_howto_table[r];
2483 };
2484 
2485 static reloc_howto_type *
2486 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2487 			     const char *r_name)
2488 {
2489   unsigned int i;
2490 
2491   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2492     if (ppc64_elf_howto_raw[i].name != NULL
2493 	&& strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2494       return &ppc64_elf_howto_raw[i];
2495 
2496   return NULL;
2497 }
2498 
2499 /* Set the howto pointer for a PowerPC ELF reloc.  */
2500 
2501 static void
2502 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2503 			 Elf_Internal_Rela *dst)
2504 {
2505   unsigned int type;
2506 
2507   /* Initialize howto table if needed.  */
2508   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2509     ppc_howto_init ();
2510 
2511   type = ELF64_R_TYPE (dst->r_info);
2512   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2513     {
2514       /* xgettext:c-format */
2515       _bfd_error_handler (_("%B: invalid relocation type %d"),
2516 			  abfd, (int) type);
2517       type = R_PPC64_NONE;
2518     }
2519   cache_ptr->howto = ppc64_elf_howto_table[type];
2520 }
2521 
2522 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2523 
2524 static bfd_reloc_status_type
2525 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2526 		    void *data, asection *input_section,
2527 		    bfd *output_bfd, char **error_message)
2528 {
2529   enum elf_ppc64_reloc_type r_type;
2530   long insn;
2531   bfd_size_type octets;
2532   bfd_vma value;
2533 
2534   /* If this is a relocatable link (output_bfd test tells us), just
2535      call the generic function.  Any adjustment will be done at final
2536      link time.  */
2537   if (output_bfd != NULL)
2538     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2539 				  input_section, output_bfd, error_message);
2540 
2541   /* Adjust the addend for sign extension of the low 16 bits.
2542      We won't actually be using the low 16 bits, so trashing them
2543      doesn't matter.  */
2544   reloc_entry->addend += 0x8000;
2545   r_type = reloc_entry->howto->type;
2546   if (r_type != R_PPC64_REL16DX_HA)
2547     return bfd_reloc_continue;
2548 
2549   value = 0;
2550   if (!bfd_is_com_section (symbol->section))
2551     value = symbol->value;
2552   value += (reloc_entry->addend
2553 	    + symbol->section->output_offset
2554 	    + symbol->section->output_section->vma);
2555   value -= (reloc_entry->address
2556 	    + input_section->output_offset
2557 	    + input_section->output_section->vma);
2558   value = (bfd_signed_vma) value >> 16;
2559 
2560   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2561   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2562   insn &= ~0x1fffc1;
2563   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2564   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2565   if (value + 0x8000 > 0xffff)
2566     return bfd_reloc_overflow;
2567   return bfd_reloc_ok;
2568 }
2569 
2570 static bfd_reloc_status_type
2571 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2572 			void *data, asection *input_section,
2573 			bfd *output_bfd, char **error_message)
2574 {
2575   if (output_bfd != NULL)
2576     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2577 				  input_section, output_bfd, error_message);
2578 
2579   if (strcmp (symbol->section->name, ".opd") == 0
2580       && (symbol->section->owner->flags & DYNAMIC) == 0)
2581     {
2582       bfd_vma dest = opd_entry_value (symbol->section,
2583 				      symbol->value + reloc_entry->addend,
2584 				      NULL, NULL, FALSE);
2585       if (dest != (bfd_vma) -1)
2586 	reloc_entry->addend = dest - (symbol->value
2587 				      + symbol->section->output_section->vma
2588 				      + symbol->section->output_offset);
2589     }
2590   else
2591     {
2592       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2593 
2594       if (symbol->section->owner != abfd
2595 	  && symbol->section->owner != NULL
2596 	  && abiversion (symbol->section->owner) >= 2)
2597 	{
2598 	  unsigned int i;
2599 
2600 	  for (i = 0; i < symbol->section->owner->symcount; ++i)
2601 	    {
2602 	      asymbol *symdef = symbol->section->owner->outsymbols[i];
2603 
2604 	      if (strcmp (symdef->name, symbol->name) == 0)
2605 		{
2606 		  elfsym = (elf_symbol_type *) symdef;
2607 		  break;
2608 		}
2609 	    }
2610 	}
2611       reloc_entry->addend
2612 	+= PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2613     }
2614   return bfd_reloc_continue;
2615 }
2616 
2617 static bfd_reloc_status_type
2618 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619 			 void *data, asection *input_section,
2620 			 bfd *output_bfd, char **error_message)
2621 {
2622   long insn;
2623   enum elf_ppc64_reloc_type r_type;
2624   bfd_size_type octets;
2625   /* Assume 'at' branch hints.  */
2626   bfd_boolean is_isa_v2 = TRUE;
2627 
2628   /* If this is a relocatable link (output_bfd test tells us), just
2629      call the generic function.  Any adjustment will be done at final
2630      link time.  */
2631   if (output_bfd != NULL)
2632     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2633 				  input_section, output_bfd, error_message);
2634 
2635   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2636   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2637   insn &= ~(0x01 << 21);
2638   r_type = reloc_entry->howto->type;
2639   if (r_type == R_PPC64_ADDR14_BRTAKEN
2640       || r_type == R_PPC64_REL14_BRTAKEN)
2641     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2642 
2643   if (is_isa_v2)
2644     {
2645       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2646 	 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2647 	 for branch on CTR insns (BO == 1a00t or 1a01t).  */
2648       if ((insn & (0x14 << 21)) == (0x04 << 21))
2649 	insn |= 0x02 << 21;
2650       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2651 	insn |= 0x08 << 21;
2652       else
2653 	goto out;
2654     }
2655   else
2656     {
2657       bfd_vma target = 0;
2658       bfd_vma from;
2659 
2660       if (!bfd_is_com_section (symbol->section))
2661 	target = symbol->value;
2662       target += symbol->section->output_section->vma;
2663       target += symbol->section->output_offset;
2664       target += reloc_entry->addend;
2665 
2666       from = (reloc_entry->address
2667 	      + input_section->output_offset
2668 	      + input_section->output_section->vma);
2669 
2670       /* Invert 'y' bit if not the default.  */
2671       if ((bfd_signed_vma) (target - from) < 0)
2672 	insn ^= 0x01 << 21;
2673     }
2674   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2675  out:
2676   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2677 				 input_section, output_bfd, error_message);
2678 }
2679 
2680 static bfd_reloc_status_type
2681 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2682 			 void *data, asection *input_section,
2683 			 bfd *output_bfd, char **error_message)
2684 {
2685   /* If this is a relocatable link (output_bfd test tells us), just
2686      call the generic function.  Any adjustment will be done at final
2687      link time.  */
2688   if (output_bfd != NULL)
2689     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2690 				  input_section, output_bfd, error_message);
2691 
2692   /* Subtract the symbol section base address.  */
2693   reloc_entry->addend -= symbol->section->output_section->vma;
2694   return bfd_reloc_continue;
2695 }
2696 
2697 static bfd_reloc_status_type
2698 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2699 			    void *data, asection *input_section,
2700 			    bfd *output_bfd, char **error_message)
2701 {
2702   /* If this is a relocatable link (output_bfd test tells us), just
2703      call the generic function.  Any adjustment will be done at final
2704      link time.  */
2705   if (output_bfd != NULL)
2706     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707 				  input_section, output_bfd, error_message);
2708 
2709   /* Subtract the symbol section base address.  */
2710   reloc_entry->addend -= symbol->section->output_section->vma;
2711 
2712   /* Adjust the addend for sign extension of the low 16 bits.  */
2713   reloc_entry->addend += 0x8000;
2714   return bfd_reloc_continue;
2715 }
2716 
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719 		     void *data, asection *input_section,
2720 		     bfd *output_bfd, char **error_message)
2721 {
2722   bfd_vma TOCstart;
2723 
2724   /* If this is a relocatable link (output_bfd test tells us), just
2725      call the generic function.  Any adjustment will be done at final
2726      link time.  */
2727   if (output_bfd != NULL)
2728     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729 				  input_section, output_bfd, error_message);
2730 
2731   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2732   if (TOCstart == 0)
2733     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2734 
2735   /* Subtract the TOC base address.  */
2736   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737   return bfd_reloc_continue;
2738 }
2739 
2740 static bfd_reloc_status_type
2741 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2742 			void *data, asection *input_section,
2743 			bfd *output_bfd, char **error_message)
2744 {
2745   bfd_vma TOCstart;
2746 
2747   /* If this is a relocatable link (output_bfd test tells us), just
2748      call the generic function.  Any adjustment will be done at final
2749      link time.  */
2750   if (output_bfd != NULL)
2751     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2752 				  input_section, output_bfd, error_message);
2753 
2754   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2755   if (TOCstart == 0)
2756     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2757 
2758   /* Subtract the TOC base address.  */
2759   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2760 
2761   /* Adjust the addend for sign extension of the low 16 bits.  */
2762   reloc_entry->addend += 0x8000;
2763   return bfd_reloc_continue;
2764 }
2765 
2766 static bfd_reloc_status_type
2767 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2768 		       void *data, asection *input_section,
2769 		       bfd *output_bfd, char **error_message)
2770 {
2771   bfd_vma TOCstart;
2772   bfd_size_type octets;
2773 
2774   /* If this is a relocatable link (output_bfd test tells us), just
2775      call the generic function.  Any adjustment will be done at final
2776      link time.  */
2777   if (output_bfd != NULL)
2778     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2779 				  input_section, output_bfd, error_message);
2780 
2781   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2782   if (TOCstart == 0)
2783     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2784 
2785   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2786   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2787   return bfd_reloc_ok;
2788 }
2789 
2790 static bfd_reloc_status_type
2791 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2792 			   void *data, asection *input_section,
2793 			   bfd *output_bfd, char **error_message)
2794 {
2795   /* If this is a relocatable link (output_bfd test tells us), just
2796      call the generic function.  Any adjustment will be done at final
2797      link time.  */
2798   if (output_bfd != NULL)
2799     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2800 				  input_section, output_bfd, error_message);
2801 
2802   if (error_message != NULL)
2803     {
2804       static char buf[60];
2805       sprintf (buf, "generic linker can't handle %s",
2806 	       reloc_entry->howto->name);
2807       *error_message = buf;
2808     }
2809   return bfd_reloc_dangerous;
2810 }
2811 
2812 /* Track GOT entries needed for a given symbol.  We might need more
2813    than one got entry per symbol.  */
2814 struct got_entry
2815 {
2816   struct got_entry *next;
2817 
2818   /* The symbol addend that we'll be placing in the GOT.  */
2819   bfd_vma addend;
2820 
2821   /* Unlike other ELF targets, we use separate GOT entries for the same
2822      symbol referenced from different input files.  This is to support
2823      automatic multiple TOC/GOT sections, where the TOC base can vary
2824      from one input file to another.  After partitioning into TOC groups
2825      we merge entries within the group.
2826 
2827      Point to the BFD owning this GOT entry.  */
2828   bfd *owner;
2829 
2830   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2831      TLS_TPREL or TLS_DTPREL for tls entries.  */
2832   unsigned char tls_type;
2833 
2834   /* Non-zero if got.ent points to real entry.  */
2835   unsigned char is_indirect;
2836 
2837   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2838   union
2839     {
2840       bfd_signed_vma refcount;
2841       bfd_vma offset;
2842       struct got_entry *ent;
2843     } got;
2844 };
2845 
2846 /* The same for PLT.  */
2847 struct plt_entry
2848 {
2849   struct plt_entry *next;
2850 
2851   bfd_vma addend;
2852 
2853   union
2854     {
2855       bfd_signed_vma refcount;
2856       bfd_vma offset;
2857     } plt;
2858 };
2859 
2860 struct ppc64_elf_obj_tdata
2861 {
2862   struct elf_obj_tdata elf;
2863 
2864   /* Shortcuts to dynamic linker sections.  */
2865   asection *got;
2866   asection *relgot;
2867 
2868   /* Used during garbage collection.  We attach global symbols defined
2869      on removed .opd entries to this section so that the sym is removed.  */
2870   asection *deleted_section;
2871 
2872   /* TLS local dynamic got entry handling.  Support for multiple GOT
2873      sections means we potentially need one of these for each input bfd.  */
2874   struct got_entry tlsld_got;
2875 
2876   union {
2877     /* A copy of relocs before they are modified for --emit-relocs.  */
2878     Elf_Internal_Rela *relocs;
2879 
2880     /* Section contents.  */
2881     bfd_byte *contents;
2882   } opd;
2883 
2884   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2885      the reloc to be in the range -32768 to 32767.  */
2886   unsigned int has_small_toc_reloc : 1;
2887 
2888   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2889      instruction not one we handle.  */
2890   unsigned int unexpected_toc_insn : 1;
2891 };
2892 
2893 #define ppc64_elf_tdata(bfd) \
2894   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2895 
2896 #define ppc64_tlsld_got(bfd) \
2897   (&ppc64_elf_tdata (bfd)->tlsld_got)
2898 
2899 #define is_ppc64_elf(bfd) \
2900   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2901    && elf_object_id (bfd) == PPC64_ELF_DATA)
2902 
2903 /* Override the generic function because we store some extras.  */
2904 
2905 static bfd_boolean
2906 ppc64_elf_mkobject (bfd *abfd)
2907 {
2908   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2909 				  PPC64_ELF_DATA);
2910 }
2911 
2912 /* Fix bad default arch selected for a 64 bit input bfd when the
2913    default is 32 bit.  Also select arch based on apuinfo.  */
2914 
2915 static bfd_boolean
2916 ppc64_elf_object_p (bfd *abfd)
2917 {
2918   if (!abfd->arch_info->the_default)
2919     return TRUE;
2920 
2921   if (abfd->arch_info->bits_per_word == 32)
2922     {
2923       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2924 
2925       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2926 	{
2927 	  /* Relies on arch after 32 bit default being 64 bit default.  */
2928 	  abfd->arch_info = abfd->arch_info->next;
2929 	  BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2930 	}
2931     }
2932   return _bfd_elf_ppc_set_arch (abfd);
2933 }
2934 
2935 /* Support for core dump NOTE sections.  */
2936 
2937 static bfd_boolean
2938 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2939 {
2940   size_t offset, size;
2941 
2942   if (note->descsz != 504)
2943     return FALSE;
2944 
2945   /* pr_cursig */
2946   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2947 
2948   /* pr_pid */
2949   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2950 
2951   /* pr_reg */
2952   offset = 112;
2953   size = 384;
2954 
2955   /* Make a ".reg/999" section.  */
2956   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2957 					  size, note->descpos + offset);
2958 }
2959 
2960 static bfd_boolean
2961 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2962 {
2963   if (note->descsz != 136)
2964     return FALSE;
2965 
2966   elf_tdata (abfd)->core->pid
2967     = bfd_get_32 (abfd, note->descdata + 24);
2968   elf_tdata (abfd)->core->program
2969     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2970   elf_tdata (abfd)->core->command
2971     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2972 
2973   return TRUE;
2974 }
2975 
2976 static char *
2977 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2978 			   ...)
2979 {
2980   switch (note_type)
2981     {
2982     default:
2983       return NULL;
2984 
2985     case NT_PRPSINFO:
2986       {
2987 	char data[136];
2988 	va_list ap;
2989 
2990 	va_start (ap, note_type);
2991 	memset (data, 0, sizeof (data));
2992 	strncpy (data + 40, va_arg (ap, const char *), 16);
2993 	strncpy (data + 56, va_arg (ap, const char *), 80);
2994 	va_end (ap);
2995 	return elfcore_write_note (abfd, buf, bufsiz,
2996 				   "CORE", note_type, data, sizeof (data));
2997       }
2998 
2999     case NT_PRSTATUS:
3000       {
3001 	char data[504];
3002 	va_list ap;
3003 	long pid;
3004 	int cursig;
3005 	const void *greg;
3006 
3007 	va_start (ap, note_type);
3008 	memset (data, 0, 112);
3009 	pid = va_arg (ap, long);
3010 	bfd_put_32 (abfd, pid, data + 32);
3011 	cursig = va_arg (ap, int);
3012 	bfd_put_16 (abfd, cursig, data + 12);
3013 	greg = va_arg (ap, const void *);
3014 	memcpy (data + 112, greg, 384);
3015 	memset (data + 496, 0, 8);
3016 	va_end (ap);
3017 	return elfcore_write_note (abfd, buf, bufsiz,
3018 				   "CORE", note_type, data, sizeof (data));
3019       }
3020     }
3021 }
3022 
3023 /* Add extra PPC sections.  */
3024 
3025 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3026 {
3027   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3028   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3029   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3030   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3033   { NULL,                     0,  0, 0,            0 }
3034 };
3035 
3036 enum _ppc64_sec_type {
3037   sec_normal = 0,
3038   sec_opd = 1,
3039   sec_toc = 2
3040 };
3041 
3042 struct _ppc64_elf_section_data
3043 {
3044   struct bfd_elf_section_data elf;
3045 
3046   union
3047   {
3048     /* An array with one entry for each opd function descriptor,
3049        and some spares since opd entries may be either 16 or 24 bytes.  */
3050 #define OPD_NDX(OFF) ((OFF) >> 4)
3051     struct _opd_sec_data
3052     {
3053       /* Points to the function code section for local opd entries.  */
3054       asection **func_sec;
3055 
3056       /* After editing .opd, adjust references to opd local syms.  */
3057       long *adjust;
3058     } opd;
3059 
3060     /* An array for toc sections, indexed by offset/8.  */
3061     struct _toc_sec_data
3062     {
3063       /* Specifies the relocation symbol index used at a given toc offset.  */
3064       unsigned *symndx;
3065 
3066       /* And the relocation addend.  */
3067       bfd_vma *add;
3068     } toc;
3069   } u;
3070 
3071   enum _ppc64_sec_type sec_type:2;
3072 
3073   /* Flag set when small branches are detected.  Used to
3074      select suitable defaults for the stub group size.  */
3075   unsigned int has_14bit_branch:1;
3076 };
3077 
3078 #define ppc64_elf_section_data(sec) \
3079   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3080 
3081 static bfd_boolean
3082 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3083 {
3084   if (!sec->used_by_bfd)
3085     {
3086       struct _ppc64_elf_section_data *sdata;
3087       bfd_size_type amt = sizeof (*sdata);
3088 
3089       sdata = bfd_zalloc (abfd, amt);
3090       if (sdata == NULL)
3091 	return FALSE;
3092       sec->used_by_bfd = sdata;
3093     }
3094 
3095   return _bfd_elf_new_section_hook (abfd, sec);
3096 }
3097 
3098 static struct _opd_sec_data *
3099 get_opd_info (asection * sec)
3100 {
3101   if (sec != NULL
3102       && ppc64_elf_section_data (sec) != NULL
3103       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3104     return &ppc64_elf_section_data (sec)->u.opd;
3105   return NULL;
3106 }
3107 
3108 /* Parameters for the qsort hook.  */
3109 static bfd_boolean synthetic_relocatable;
3110 static asection *synthetic_opd;
3111 
3112 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3113 
3114 static int
3115 compare_symbols (const void *ap, const void *bp)
3116 {
3117   const asymbol *a = * (const asymbol **) ap;
3118   const asymbol *b = * (const asymbol **) bp;
3119 
3120   /* Section symbols first.  */
3121   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3122     return -1;
3123   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3124     return 1;
3125 
3126   /* then .opd symbols.  */
3127   if (synthetic_opd != NULL)
3128     {
3129       if (strcmp (a->section->name, ".opd") == 0
3130 	  && strcmp (b->section->name, ".opd") != 0)
3131 	return -1;
3132       if (strcmp (a->section->name, ".opd") != 0
3133 	  && strcmp (b->section->name, ".opd") == 0)
3134 	return 1;
3135     }
3136 
3137   /* then other code symbols.  */
3138   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3139       == (SEC_CODE | SEC_ALLOC)
3140       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3141 	 != (SEC_CODE | SEC_ALLOC))
3142     return -1;
3143 
3144   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3145       != (SEC_CODE | SEC_ALLOC)
3146       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3147 	 == (SEC_CODE | SEC_ALLOC))
3148     return 1;
3149 
3150   if (synthetic_relocatable)
3151     {
3152       if (a->section->id < b->section->id)
3153 	return -1;
3154 
3155       if (a->section->id > b->section->id)
3156 	return 1;
3157     }
3158 
3159   if (a->value + a->section->vma < b->value + b->section->vma)
3160     return -1;
3161 
3162   if (a->value + a->section->vma > b->value + b->section->vma)
3163     return 1;
3164 
3165   /* For syms with the same value, prefer strong dynamic global function
3166      syms over other syms.  */
3167   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3168     return -1;
3169 
3170   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3171     return 1;
3172 
3173   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3174     return -1;
3175 
3176   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3177     return 1;
3178 
3179   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3180     return -1;
3181 
3182   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3183     return 1;
3184 
3185   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3186     return -1;
3187 
3188   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3189     return 1;
3190 
3191   return a > b;
3192 }
3193 
3194 /* Search SYMS for a symbol of the given VALUE.  */
3195 
3196 static asymbol *
3197 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3198 {
3199   long mid;
3200 
3201   if (id == (unsigned) -1)
3202     {
3203       while (lo < hi)
3204 	{
3205 	  mid = (lo + hi) >> 1;
3206 	  if (syms[mid]->value + syms[mid]->section->vma < value)
3207 	    lo = mid + 1;
3208 	  else if (syms[mid]->value + syms[mid]->section->vma > value)
3209 	    hi = mid;
3210 	  else
3211 	    return syms[mid];
3212 	}
3213     }
3214   else
3215     {
3216       while (lo < hi)
3217 	{
3218 	  mid = (lo + hi) >> 1;
3219 	  if (syms[mid]->section->id < id)
3220 	    lo = mid + 1;
3221 	  else if (syms[mid]->section->id > id)
3222 	    hi = mid;
3223 	  else if (syms[mid]->value < value)
3224 	    lo = mid + 1;
3225 	  else if (syms[mid]->value > value)
3226 	    hi = mid;
3227 	  else
3228 	    return syms[mid];
3229 	}
3230     }
3231   return NULL;
3232 }
3233 
3234 static bfd_boolean
3235 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3236 {
3237   bfd_vma vma = *(bfd_vma *) ptr;
3238   return ((section->flags & SEC_ALLOC) != 0
3239 	  && section->vma <= vma
3240 	  && vma < section->vma + section->size);
3241 }
3242 
3243 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3244    entry syms.  Also generate @plt symbols for the glink branch table.
3245    Returns count of synthetic symbols in RET or -1 on error.  */
3246 
3247 static long
3248 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3249 				long static_count, asymbol **static_syms,
3250 				long dyn_count, asymbol **dyn_syms,
3251 				asymbol **ret)
3252 {
3253   asymbol *s;
3254   long i;
3255   long count;
3256   char *names;
3257   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3258   asection *opd = NULL;
3259   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3260   asymbol **syms;
3261   int abi = abiversion (abfd);
3262 
3263   *ret = NULL;
3264 
3265   if (abi < 2)
3266     {
3267       opd = bfd_get_section_by_name (abfd, ".opd");
3268       if (opd == NULL && abi == 1)
3269 	return 0;
3270     }
3271 
3272   symcount = static_count;
3273   if (!relocatable)
3274     symcount += dyn_count;
3275   if (symcount == 0)
3276     return 0;
3277 
3278   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3279   if (syms == NULL)
3280     return -1;
3281 
3282   if (!relocatable && static_count != 0 && dyn_count != 0)
3283     {
3284       /* Use both symbol tables.  */
3285       memcpy (syms, static_syms, static_count * sizeof (*syms));
3286       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3287     }
3288   else if (!relocatable && static_count == 0)
3289     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3290   else
3291     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3292 
3293   synthetic_relocatable = relocatable;
3294   synthetic_opd = opd;
3295   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3296 
3297   if (!relocatable && symcount > 1)
3298     {
3299       long j;
3300       /* Trim duplicate syms, since we may have merged the normal and
3301 	 dynamic symbols.  Actually, we only care about syms that have
3302 	 different values, so trim any with the same value.  */
3303       for (i = 1, j = 1; i < symcount; ++i)
3304 	if (syms[i - 1]->value + syms[i - 1]->section->vma
3305 	    != syms[i]->value + syms[i]->section->vma)
3306 	  syms[j++] = syms[i];
3307       symcount = j;
3308     }
3309 
3310   i = 0;
3311   /* Note that here and in compare_symbols we can't compare opd and
3312      sym->section directly.  With separate debug info files, the
3313      symbols will be extracted from the debug file while abfd passed
3314      to this function is the real binary.  */
3315   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3316     ++i;
3317   codesecsym = i;
3318 
3319   for (; i < symcount; ++i)
3320     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3321 	 != (SEC_CODE | SEC_ALLOC))
3322 	|| (syms[i]->flags & BSF_SECTION_SYM) == 0)
3323       break;
3324   codesecsymend = i;
3325 
3326   for (; i < symcount; ++i)
3327     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3328       break;
3329   secsymend = i;
3330 
3331   if (opd != NULL)
3332     for (; i < symcount; ++i)
3333       if (strcmp (syms[i]->section->name, ".opd") != 0)
3334 	break;
3335   opdsymend = i;
3336 
3337   for (; i < symcount; ++i)
3338     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3339 	!= (SEC_CODE | SEC_ALLOC))
3340       break;
3341   symcount = i;
3342 
3343   count = 0;
3344 
3345   if (relocatable)
3346     {
3347       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3348       arelent *r;
3349       size_t size;
3350       long relcount;
3351 
3352       if (opdsymend == secsymend)
3353 	goto done;
3354 
3355       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3356       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3357       if (relcount == 0)
3358 	goto done;
3359 
3360       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3361 	{
3362 	  count = -1;
3363 	  goto done;
3364 	}
3365 
3366       size = 0;
3367       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3368 	{
3369 	  asymbol *sym;
3370 
3371 	  while (r < opd->relocation + relcount
3372 		 && r->address < syms[i]->value + opd->vma)
3373 	    ++r;
3374 
3375 	  if (r == opd->relocation + relcount)
3376 	    break;
3377 
3378 	  if (r->address != syms[i]->value + opd->vma)
3379 	    continue;
3380 
3381 	  if (r->howto->type != R_PPC64_ADDR64)
3382 	    continue;
3383 
3384 	  sym = *r->sym_ptr_ptr;
3385 	  if (!sym_exists_at (syms, opdsymend, symcount,
3386 			      sym->section->id, sym->value + r->addend))
3387 	    {
3388 	      ++count;
3389 	      size += sizeof (asymbol);
3390 	      size += strlen (syms[i]->name) + 2;
3391 	    }
3392 	}
3393 
3394       if (size == 0)
3395 	goto done;
3396       s = *ret = bfd_malloc (size);
3397       if (s == NULL)
3398 	{
3399 	  count = -1;
3400 	  goto done;
3401 	}
3402 
3403       names = (char *) (s + count);
3404 
3405       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3406 	{
3407 	  asymbol *sym;
3408 
3409 	  while (r < opd->relocation + relcount
3410 		 && r->address < syms[i]->value + opd->vma)
3411 	    ++r;
3412 
3413 	  if (r == opd->relocation + relcount)
3414 	    break;
3415 
3416 	  if (r->address != syms[i]->value + opd->vma)
3417 	    continue;
3418 
3419 	  if (r->howto->type != R_PPC64_ADDR64)
3420 	    continue;
3421 
3422 	  sym = *r->sym_ptr_ptr;
3423 	  if (!sym_exists_at (syms, opdsymend, symcount,
3424 			      sym->section->id, sym->value + r->addend))
3425 	    {
3426 	      size_t len;
3427 
3428 	      *s = *syms[i];
3429 	      s->flags |= BSF_SYNTHETIC;
3430 	      s->section = sym->section;
3431 	      s->value = sym->value + r->addend;
3432 	      s->name = names;
3433 	      *names++ = '.';
3434 	      len = strlen (syms[i]->name);
3435 	      memcpy (names, syms[i]->name, len + 1);
3436 	      names += len + 1;
3437 	      /* Have udata.p point back to the original symbol this
3438 		 synthetic symbol was derived from.  */
3439 	      s->udata.p = syms[i];
3440 	      s++;
3441 	    }
3442 	}
3443     }
3444   else
3445     {
3446       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3447       bfd_byte *contents = NULL;
3448       size_t size;
3449       long plt_count = 0;
3450       bfd_vma glink_vma = 0, resolv_vma = 0;
3451       asection *dynamic, *glink = NULL, *relplt = NULL;
3452       arelent *p;
3453 
3454       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3455 	{
3456 	free_contents_and_exit_err:
3457 	  count = -1;
3458 	free_contents_and_exit:
3459 	  if (contents)
3460 	    free (contents);
3461 	  goto done;
3462 	}
3463 
3464       size = 0;
3465       for (i = secsymend; i < opdsymend; ++i)
3466 	{
3467 	  bfd_vma ent;
3468 
3469 	  /* Ignore bogus symbols.  */
3470 	  if (syms[i]->value > opd->size - 8)
3471 	    continue;
3472 
3473 	  ent = bfd_get_64 (abfd, contents + syms[i]->value);
3474 	  if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3475 	    {
3476 	      ++count;
3477 	      size += sizeof (asymbol);
3478 	      size += strlen (syms[i]->name) + 2;
3479 	    }
3480 	}
3481 
3482       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3483       if (dyn_count != 0
3484 	  && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3485 	{
3486 	  bfd_byte *dynbuf, *extdyn, *extdynend;
3487 	  size_t extdynsize;
3488 	  void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3489 
3490 	  if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3491 	    goto free_contents_and_exit_err;
3492 
3493 	  extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3494 	  swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3495 
3496 	  extdyn = dynbuf;
3497 	  extdynend = extdyn + dynamic->size;
3498 	  for (; extdyn < extdynend; extdyn += extdynsize)
3499 	    {
3500 	      Elf_Internal_Dyn dyn;
3501 	      (*swap_dyn_in) (abfd, extdyn, &dyn);
3502 
3503 	      if (dyn.d_tag == DT_NULL)
3504 		break;
3505 
3506 	      if (dyn.d_tag == DT_PPC64_GLINK)
3507 		{
3508 		  /* The first glink stub starts at offset 32; see
3509 		     comment in ppc64_elf_finish_dynamic_sections. */
3510 		  glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3511 		  /* The .glink section usually does not survive the final
3512 		     link; search for the section (usually .text) where the
3513 		     glink stubs now reside.  */
3514 		  glink = bfd_sections_find_if (abfd, section_covers_vma,
3515 						&glink_vma);
3516 		  break;
3517 		}
3518 	    }
3519 
3520 	  free (dynbuf);
3521 	}
3522 
3523       if (glink != NULL)
3524 	{
3525 	  /* Determine __glink trampoline by reading the relative branch
3526 	     from the first glink stub.  */
3527 	  bfd_byte buf[4];
3528 	  unsigned int off = 0;
3529 
3530 	  while (bfd_get_section_contents (abfd, glink, buf,
3531 					   glink_vma + off - glink->vma, 4))
3532 	    {
3533 	      unsigned int insn = bfd_get_32 (abfd, buf);
3534 	      insn ^= B_DOT;
3535 	      if ((insn & ~0x3fffffc) == 0)
3536 		{
3537 		  resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3538 		  break;
3539 		}
3540 	      off += 4;
3541 	      if (off > 4)
3542 		break;
3543 	    }
3544 
3545 	  if (resolv_vma)
3546 	    size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3547 
3548 	  relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3549 	  if (relplt != NULL)
3550 	    {
3551 	      slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3552 	      if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3553 		goto free_contents_and_exit_err;
3554 
3555 	      plt_count = relplt->size / sizeof (Elf64_External_Rela);
3556 	      size += plt_count * sizeof (asymbol);
3557 
3558 	      p = relplt->relocation;
3559 	      for (i = 0; i < plt_count; i++, p++)
3560 		{
3561 		  size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3562 		  if (p->addend != 0)
3563 		    size += sizeof ("+0x") - 1 + 16;
3564 		}
3565 	    }
3566 	}
3567 
3568       if (size == 0)
3569 	goto free_contents_and_exit;
3570       s = *ret = bfd_malloc (size);
3571       if (s == NULL)
3572 	goto free_contents_and_exit_err;
3573 
3574       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3575 
3576       for (i = secsymend; i < opdsymend; ++i)
3577 	{
3578 	  bfd_vma ent;
3579 
3580 	  if (syms[i]->value > opd->size - 8)
3581 	    continue;
3582 
3583 	  ent = bfd_get_64 (abfd, contents + syms[i]->value);
3584 	  if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3585 	    {
3586 	      long lo, hi;
3587 	      size_t len;
3588 	      asection *sec = abfd->sections;
3589 
3590 	      *s = *syms[i];
3591 	      lo = codesecsym;
3592 	      hi = codesecsymend;
3593 	      while (lo < hi)
3594 		{
3595 		  long mid = (lo + hi) >> 1;
3596 		  if (syms[mid]->section->vma < ent)
3597 		    lo = mid + 1;
3598 		  else if (syms[mid]->section->vma > ent)
3599 		    hi = mid;
3600 		  else
3601 		    {
3602 		      sec = syms[mid]->section;
3603 		      break;
3604 		    }
3605 		}
3606 
3607 	      if (lo >= hi && lo > codesecsym)
3608 		sec = syms[lo - 1]->section;
3609 
3610 	      for (; sec != NULL; sec = sec->next)
3611 		{
3612 		  if (sec->vma > ent)
3613 		    break;
3614 		  /* SEC_LOAD may not be set if SEC is from a separate debug
3615 		     info file.  */
3616 		  if ((sec->flags & SEC_ALLOC) == 0)
3617 		    break;
3618 		  if ((sec->flags & SEC_CODE) != 0)
3619 		    s->section = sec;
3620 		}
3621 	      s->flags |= BSF_SYNTHETIC;
3622 	      s->value = ent - s->section->vma;
3623 	      s->name = names;
3624 	      *names++ = '.';
3625 	      len = strlen (syms[i]->name);
3626 	      memcpy (names, syms[i]->name, len + 1);
3627 	      names += len + 1;
3628 	      /* Have udata.p point back to the original symbol this
3629 		 synthetic symbol was derived from.  */
3630 	      s->udata.p = syms[i];
3631 	      s++;
3632 	    }
3633 	}
3634       free (contents);
3635 
3636       if (glink != NULL && relplt != NULL)
3637 	{
3638 	  if (resolv_vma)
3639 	    {
3640 	      /* Add a symbol for the main glink trampoline.  */
3641 	      memset (s, 0, sizeof *s);
3642 	      s->the_bfd = abfd;
3643 	      s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3644 	      s->section = glink;
3645 	      s->value = resolv_vma - glink->vma;
3646 	      s->name = names;
3647 	      memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3648 	      names += sizeof ("__glink_PLTresolve");
3649 	      s++;
3650 	      count++;
3651 	    }
3652 
3653 	  /* FIXME: It would be very much nicer to put sym@plt on the
3654 	     stub rather than on the glink branch table entry.  The
3655 	     objdump disassembler would then use a sensible symbol
3656 	     name on plt calls.  The difficulty in doing so is
3657 	     a) finding the stubs, and,
3658 	     b) matching stubs against plt entries, and,
3659 	     c) there can be multiple stubs for a given plt entry.
3660 
3661 	     Solving (a) could be done by code scanning, but older
3662 	     ppc64 binaries used different stubs to current code.
3663 	     (b) is the tricky one since you need to known the toc
3664 	     pointer for at least one function that uses a pic stub to
3665 	     be able to calculate the plt address referenced.
3666 	     (c) means gdb would need to set multiple breakpoints (or
3667 	     find the glink branch itself) when setting breakpoints
3668 	     for pending shared library loads.  */
3669 	  p = relplt->relocation;
3670 	  for (i = 0; i < plt_count; i++, p++)
3671 	    {
3672 	      size_t len;
3673 
3674 	      *s = **p->sym_ptr_ptr;
3675 	      /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3676 		 we are defining a symbol, ensure one of them is set.  */
3677 	      if ((s->flags & BSF_LOCAL) == 0)
3678 		s->flags |= BSF_GLOBAL;
3679 	      s->flags |= BSF_SYNTHETIC;
3680 	      s->section = glink;
3681 	      s->value = glink_vma - glink->vma;
3682 	      s->name = names;
3683 	      s->udata.p = NULL;
3684 	      len = strlen ((*p->sym_ptr_ptr)->name);
3685 	      memcpy (names, (*p->sym_ptr_ptr)->name, len);
3686 	      names += len;
3687 	      if (p->addend != 0)
3688 		{
3689 		  memcpy (names, "+0x", sizeof ("+0x") - 1);
3690 		  names += sizeof ("+0x") - 1;
3691 		  bfd_sprintf_vma (abfd, names, p->addend);
3692 		  names += strlen (names);
3693 		}
3694 	      memcpy (names, "@plt", sizeof ("@plt"));
3695 	      names += sizeof ("@plt");
3696 	      s++;
3697 	      if (abi < 2)
3698 		{
3699 		  glink_vma += 8;
3700 		  if (i >= 0x8000)
3701 		    glink_vma += 4;
3702 		}
3703 	      else
3704 		glink_vma += 4;
3705 	    }
3706 	  count += plt_count;
3707 	}
3708     }
3709 
3710  done:
3711   free (syms);
3712   return count;
3713 }
3714 
3715 /* The following functions are specific to the ELF linker, while
3716    functions above are used generally.  Those named ppc64_elf_* are
3717    called by the main ELF linker code.  They appear in this file more
3718    or less in the order in which they are called.  eg.
3719    ppc64_elf_check_relocs is called early in the link process,
3720    ppc64_elf_finish_dynamic_sections is one of the last functions
3721    called.
3722 
3723    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3724    functions have both a function code symbol and a function descriptor
3725    symbol.  A call to foo in a relocatable object file looks like:
3726 
3727    .		.text
3728    .	x:
3729    .		bl	.foo
3730    .		nop
3731 
3732    The function definition in another object file might be:
3733 
3734    .		.section .opd
3735    .	foo:	.quad	.foo
3736    .		.quad	.TOC.@tocbase
3737    .		.quad	0
3738    .
3739    .		.text
3740    .	.foo:	blr
3741 
3742    When the linker resolves the call during a static link, the branch
3743    unsurprisingly just goes to .foo and the .opd information is unused.
3744    If the function definition is in a shared library, things are a little
3745    different:  The call goes via a plt call stub, the opd information gets
3746    copied to the plt, and the linker patches the nop.
3747 
3748    .	x:
3749    .		bl	.foo_stub
3750    .		ld	2,40(1)
3751    .
3752    .
3753    .	.foo_stub:
3754    .		std	2,40(1)			# in practice, the call stub
3755    .		addis	11,2,Lfoo@toc@ha	# is slightly optimized, but
3756    .		addi	11,11,Lfoo@toc@l	# this is the general idea
3757    .		ld	12,0(11)
3758    .		ld	2,8(11)
3759    .		mtctr	12
3760    .		ld	11,16(11)
3761    .		bctr
3762    .
3763    .		.section .plt
3764    .	Lfoo:	reloc (R_PPC64_JMP_SLOT, foo)
3765 
3766    The "reloc ()" notation is supposed to indicate that the linker emits
3767    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3768    copying.
3769 
3770    What are the difficulties here?  Well, firstly, the relocations
3771    examined by the linker in check_relocs are against the function code
3772    sym .foo, while the dynamic relocation in the plt is emitted against
3773    the function descriptor symbol, foo.  Somewhere along the line, we need
3774    to carefully copy dynamic link information from one symbol to the other.
3775    Secondly, the generic part of the elf linker will make .foo a dynamic
3776    symbol as is normal for most other backends.  We need foo dynamic
3777    instead, at least for an application final link.  However, when
3778    creating a shared library containing foo, we need to have both symbols
3779    dynamic so that references to .foo are satisfied during the early
3780    stages of linking.  Otherwise the linker might decide to pull in a
3781    definition from some other object, eg. a static library.
3782 
3783    Update: As of August 2004, we support a new convention.  Function
3784    calls may use the function descriptor symbol, ie. "bl foo".  This
3785    behaves exactly as "bl .foo".  */
3786 
3787 /* Of those relocs that might be copied as dynamic relocs, this function
3788    selects those that must be copied when linking a shared library,
3789    even when the symbol is local.  */
3790 
3791 static int
3792 must_be_dyn_reloc (struct bfd_link_info *info,
3793 		   enum elf_ppc64_reloc_type r_type)
3794 {
3795   switch (r_type)
3796     {
3797     default:
3798       return 1;
3799 
3800     case R_PPC64_REL32:
3801     case R_PPC64_REL64:
3802     case R_PPC64_REL30:
3803       return 0;
3804 
3805     case R_PPC64_TPREL16:
3806     case R_PPC64_TPREL16_LO:
3807     case R_PPC64_TPREL16_HI:
3808     case R_PPC64_TPREL16_HA:
3809     case R_PPC64_TPREL16_DS:
3810     case R_PPC64_TPREL16_LO_DS:
3811     case R_PPC64_TPREL16_HIGH:
3812     case R_PPC64_TPREL16_HIGHA:
3813     case R_PPC64_TPREL16_HIGHER:
3814     case R_PPC64_TPREL16_HIGHERA:
3815     case R_PPC64_TPREL16_HIGHEST:
3816     case R_PPC64_TPREL16_HIGHESTA:
3817     case R_PPC64_TPREL64:
3818       return !bfd_link_executable (info);
3819     }
3820 }
3821 
3822 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3823    copying dynamic variables from a shared lib into an app's dynbss
3824    section, and instead use a dynamic relocation to point into the
3825    shared lib.  With code that gcc generates, it's vital that this be
3826    enabled;  In the PowerPC64 ABI, the address of a function is actually
3827    the address of a function descriptor, which resides in the .opd
3828    section.  gcc uses the descriptor directly rather than going via the
3829    GOT as some other ABI's do, which means that initialized function
3830    pointers must reference the descriptor.  Thus, a function pointer
3831    initialized to the address of a function in a shared library will
3832    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3833    redefines the function descriptor symbol to point to the copy.  This
3834    presents a problem as a plt entry for that function is also
3835    initialized from the function descriptor symbol and the copy reloc
3836    may not be initialized first.  */
3837 #define ELIMINATE_COPY_RELOCS 1
3838 
3839 /* Section name for stubs is the associated section name plus this
3840    string.  */
3841 #define STUB_SUFFIX ".stub"
3842 
3843 /* Linker stubs.
3844    ppc_stub_long_branch:
3845    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3846    destination, but a 24 bit branch in a stub section will reach.
3847    .	b	dest
3848 
3849    ppc_stub_plt_branch:
3850    Similar to the above, but a 24 bit branch in the stub section won't
3851    reach its destination.
3852    .	addis	%r11,%r2,xxx@toc@ha
3853    .	ld	%r12,xxx@toc@l(%r11)
3854    .	mtctr	%r12
3855    .	bctr
3856 
3857    ppc_stub_plt_call:
3858    Used to call a function in a shared library.  If it so happens that
3859    the plt entry referenced crosses a 64k boundary, then an extra
3860    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3861    .	std	%r2,40(%r1)
3862    .	addis	%r11,%r2,xxx@toc@ha
3863    .	ld	%r12,xxx+0@toc@l(%r11)
3864    .	mtctr	%r12
3865    .	ld	%r2,xxx+8@toc@l(%r11)
3866    .	ld	%r11,xxx+16@toc@l(%r11)
3867    .	bctr
3868 
3869    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3870    code to adjust the value and save r2 to support multiple toc sections.
3871    A ppc_stub_long_branch with an r2 offset looks like:
3872    .	std	%r2,40(%r1)
3873    .	addis	%r2,%r2,off@ha
3874    .	addi	%r2,%r2,off@l
3875    .	b	dest
3876 
3877    A ppc_stub_plt_branch with an r2 offset looks like:
3878    .	std	%r2,40(%r1)
3879    .	addis	%r11,%r2,xxx@toc@ha
3880    .	ld	%r12,xxx@toc@l(%r11)
3881    .	addis	%r2,%r2,off@ha
3882    .	addi	%r2,%r2,off@l
3883    .	mtctr	%r12
3884    .	bctr
3885 
3886    In cases where the "addis" instruction would add zero, the "addis" is
3887    omitted and following instructions modified slightly in some cases.
3888 */
3889 
3890 enum ppc_stub_type {
3891   ppc_stub_none,
3892   ppc_stub_long_branch,
3893   ppc_stub_long_branch_r2off,
3894   ppc_stub_plt_branch,
3895   ppc_stub_plt_branch_r2off,
3896   ppc_stub_plt_call,
3897   ppc_stub_plt_call_r2save,
3898   ppc_stub_global_entry,
3899   ppc_stub_save_res
3900 };
3901 
3902 /* Information on stub grouping.  */
3903 struct map_stub
3904 {
3905   /* The stub section.  */
3906   asection *stub_sec;
3907   /* This is the section to which stubs in the group will be attached.  */
3908   asection *link_sec;
3909   /* Next group.  */
3910   struct map_stub *next;
3911   /* Whether to emit a copy of register save/restore functions in this
3912      group.  */
3913   int needs_save_res;
3914 };
3915 
3916 struct ppc_stub_hash_entry {
3917 
3918   /* Base hash table entry structure.  */
3919   struct bfd_hash_entry root;
3920 
3921   enum ppc_stub_type stub_type;
3922 
3923   /* Group information.  */
3924   struct map_stub *group;
3925 
3926   /* Offset within stub_sec of the beginning of this stub.  */
3927   bfd_vma stub_offset;
3928 
3929   /* Given the symbol's value and its section we can determine its final
3930      value when building the stubs (so the stub knows where to jump.  */
3931   bfd_vma target_value;
3932   asection *target_section;
3933 
3934   /* The symbol table entry, if any, that this was derived from.  */
3935   struct ppc_link_hash_entry *h;
3936   struct plt_entry *plt_ent;
3937 
3938   /* Symbol st_other.  */
3939   unsigned char other;
3940 };
3941 
3942 struct ppc_branch_hash_entry {
3943 
3944   /* Base hash table entry structure.  */
3945   struct bfd_hash_entry root;
3946 
3947   /* Offset within branch lookup table.  */
3948   unsigned int offset;
3949 
3950   /* Generation marker.  */
3951   unsigned int iter;
3952 };
3953 
3954 /* Used to track dynamic relocations for local symbols.  */
3955 struct ppc_dyn_relocs
3956 {
3957   struct ppc_dyn_relocs *next;
3958 
3959   /* The input section of the reloc.  */
3960   asection *sec;
3961 
3962   /* Total number of relocs copied for the input section.  */
3963   unsigned int count : 31;
3964 
3965   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3966   unsigned int ifunc : 1;
3967 };
3968 
3969 struct ppc_link_hash_entry
3970 {
3971   struct elf_link_hash_entry elf;
3972 
3973   union {
3974     /* A pointer to the most recently used stub hash entry against this
3975        symbol.  */
3976     struct ppc_stub_hash_entry *stub_cache;
3977 
3978     /* A pointer to the next symbol starting with a '.'  */
3979     struct ppc_link_hash_entry *next_dot_sym;
3980   } u;
3981 
3982   /* Track dynamic relocs copied for this symbol.  */
3983   struct elf_dyn_relocs *dyn_relocs;
3984 
3985   /* Chain of aliases referring to a weakdef.  */
3986   struct ppc_link_hash_entry *weakref;
3987 
3988   /* Link between function code and descriptor symbols.  */
3989   struct ppc_link_hash_entry *oh;
3990 
3991   /* Flag function code and descriptor symbols.  */
3992   unsigned int is_func:1;
3993   unsigned int is_func_descriptor:1;
3994   unsigned int fake:1;
3995 
3996   /* Whether global opd/toc sym has been adjusted or not.
3997      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3998      should be set for all globals defined in any opd/toc section.  */
3999   unsigned int adjust_done:1;
4000 
4001   /* Set if this is an out-of-line register save/restore function,
4002      with non-standard calling convention.  */
4003   unsigned int save_res:1;
4004 
4005   /* Contexts in which symbol is used in the GOT (or TOC).
4006      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4007      corresponding relocs are encountered during check_relocs.
4008      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4009      indicate the corresponding GOT entry type is not needed.
4010      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4011      a TPREL one.  We use a separate flag rather than setting TPREL
4012      just for convenience in distinguishing the two cases.  */
4013 #define TLS_GD		 1	/* GD reloc. */
4014 #define TLS_LD		 2	/* LD reloc. */
4015 #define TLS_TPREL	 4	/* TPREL reloc, => IE. */
4016 #define TLS_DTPREL	 8	/* DTPREL reloc, => LD. */
4017 #define TLS_TLS		16	/* Any TLS reloc.  */
4018 #define TLS_EXPLICIT	32	/* Marks TOC section TLS relocs. */
4019 #define TLS_TPRELGD	64	/* TPREL reloc resulting from GD->IE. */
4020 #define PLT_IFUNC      128	/* STT_GNU_IFUNC.  */
4021   unsigned char tls_mask;
4022 };
4023 
4024 /* ppc64 ELF linker hash table.  */
4025 
4026 struct ppc_link_hash_table
4027 {
4028   struct elf_link_hash_table elf;
4029 
4030   /* The stub hash table.  */
4031   struct bfd_hash_table stub_hash_table;
4032 
4033   /* Another hash table for plt_branch stubs.  */
4034   struct bfd_hash_table branch_hash_table;
4035 
4036   /* Hash table for function prologue tocsave.  */
4037   htab_t tocsave_htab;
4038 
4039   /* Various options and other info passed from the linker.  */
4040   struct ppc64_elf_params *params;
4041 
4042   /* The size of sec_info below.  */
4043   unsigned int sec_info_arr_size;
4044 
4045   /* Per-section array of extra section info.  Done this way rather
4046      than as part of ppc64_elf_section_data so we have the info for
4047      non-ppc64 sections.  */
4048   struct
4049   {
4050     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4051     bfd_vma toc_off;
4052 
4053     union
4054     {
4055       /* The section group that this section belongs to.  */
4056       struct map_stub *group;
4057       /* A temp section list pointer.  */
4058       asection *list;
4059     } u;
4060   } *sec_info;
4061 
4062   /* Linked list of groups.  */
4063   struct map_stub *group;
4064 
4065   /* Temp used when calculating TOC pointers.  */
4066   bfd_vma toc_curr;
4067   bfd *toc_bfd;
4068   asection *toc_first_sec;
4069 
4070   /* Used when adding symbols.  */
4071   struct ppc_link_hash_entry *dot_syms;
4072 
4073   /* Shortcuts to get to dynamic linker sections.  */
4074   asection *glink;
4075   asection *sfpr;
4076   asection *brlt;
4077   asection *relbrlt;
4078   asection *glink_eh_frame;
4079 
4080   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4081   struct ppc_link_hash_entry *tls_get_addr;
4082   struct ppc_link_hash_entry *tls_get_addr_fd;
4083 
4084   /* The size of reliplt used by got entry relocs.  */
4085   bfd_size_type got_reli_size;
4086 
4087   /* Statistics.  */
4088   unsigned long stub_count[ppc_stub_global_entry];
4089 
4090   /* Number of stubs against global syms.  */
4091   unsigned long stub_globals;
4092 
4093   /* Set if we're linking code with function descriptors.  */
4094   unsigned int opd_abi:1;
4095 
4096   /* Support for multiple toc sections.  */
4097   unsigned int do_multi_toc:1;
4098   unsigned int multi_toc_needed:1;
4099   unsigned int second_toc_pass:1;
4100   unsigned int do_toc_opt:1;
4101 
4102   /* Set on error.  */
4103   unsigned int stub_error:1;
4104 
4105   /* Whether func_desc_adjust needs to be run over symbols.  */
4106   unsigned int need_func_desc_adj:1;
4107 
4108   /* Whether there exist local gnu indirect function resolvers,
4109      referenced by dynamic relocations.  */
4110   unsigned int local_ifunc_resolver:1;
4111   unsigned int maybe_local_ifunc_resolver:1;
4112 
4113   /* Incremented every time we size stubs.  */
4114   unsigned int stub_iteration;
4115 
4116   /* Small local sym cache.  */
4117   struct sym_cache sym_cache;
4118 };
4119 
4120 /* Rename some of the generic section flags to better document how they
4121    are used here.  */
4122 
4123 /* Nonzero if this section has TLS related relocations.  */
4124 #define has_tls_reloc sec_flg0
4125 
4126 /* Nonzero if this section has a call to __tls_get_addr.  */
4127 #define has_tls_get_addr_call sec_flg1
4128 
4129 /* Nonzero if this section has any toc or got relocs.  */
4130 #define has_toc_reloc sec_flg2
4131 
4132 /* Nonzero if this section has a call to another section that uses
4133    the toc or got.  */
4134 #define makes_toc_func_call sec_flg3
4135 
4136 /* Recursion protection when determining above flag.  */
4137 #define call_check_in_progress sec_flg4
4138 #define call_check_done sec_flg5
4139 
4140 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4141 
4142 #define ppc_hash_table(p) \
4143   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4144   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4145 
4146 #define ppc_stub_hash_lookup(table, string, create, copy) \
4147   ((struct ppc_stub_hash_entry *) \
4148    bfd_hash_lookup ((table), (string), (create), (copy)))
4149 
4150 #define ppc_branch_hash_lookup(table, string, create, copy) \
4151   ((struct ppc_branch_hash_entry *) \
4152    bfd_hash_lookup ((table), (string), (create), (copy)))
4153 
4154 /* Create an entry in the stub hash table.  */
4155 
4156 static struct bfd_hash_entry *
4157 stub_hash_newfunc (struct bfd_hash_entry *entry,
4158 		   struct bfd_hash_table *table,
4159 		   const char *string)
4160 {
4161   /* Allocate the structure if it has not already been allocated by a
4162      subclass.  */
4163   if (entry == NULL)
4164     {
4165       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4166       if (entry == NULL)
4167 	return entry;
4168     }
4169 
4170   /* Call the allocation method of the superclass.  */
4171   entry = bfd_hash_newfunc (entry, table, string);
4172   if (entry != NULL)
4173     {
4174       struct ppc_stub_hash_entry *eh;
4175 
4176       /* Initialize the local fields.  */
4177       eh = (struct ppc_stub_hash_entry *) entry;
4178       eh->stub_type = ppc_stub_none;
4179       eh->group = NULL;
4180       eh->stub_offset = 0;
4181       eh->target_value = 0;
4182       eh->target_section = NULL;
4183       eh->h = NULL;
4184       eh->plt_ent = NULL;
4185       eh->other = 0;
4186     }
4187 
4188   return entry;
4189 }
4190 
4191 /* Create an entry in the branch hash table.  */
4192 
4193 static struct bfd_hash_entry *
4194 branch_hash_newfunc (struct bfd_hash_entry *entry,
4195 		     struct bfd_hash_table *table,
4196 		     const char *string)
4197 {
4198   /* Allocate the structure if it has not already been allocated by a
4199      subclass.  */
4200   if (entry == NULL)
4201     {
4202       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4203       if (entry == NULL)
4204 	return entry;
4205     }
4206 
4207   /* Call the allocation method of the superclass.  */
4208   entry = bfd_hash_newfunc (entry, table, string);
4209   if (entry != NULL)
4210     {
4211       struct ppc_branch_hash_entry *eh;
4212 
4213       /* Initialize the local fields.  */
4214       eh = (struct ppc_branch_hash_entry *) entry;
4215       eh->offset = 0;
4216       eh->iter = 0;
4217     }
4218 
4219   return entry;
4220 }
4221 
4222 /* Create an entry in a ppc64 ELF linker hash table.  */
4223 
4224 static struct bfd_hash_entry *
4225 link_hash_newfunc (struct bfd_hash_entry *entry,
4226 		   struct bfd_hash_table *table,
4227 		   const char *string)
4228 {
4229   /* Allocate the structure if it has not already been allocated by a
4230      subclass.  */
4231   if (entry == NULL)
4232     {
4233       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4234       if (entry == NULL)
4235 	return entry;
4236     }
4237 
4238   /* Call the allocation method of the superclass.  */
4239   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4240   if (entry != NULL)
4241     {
4242       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4243 
4244       memset (&eh->u.stub_cache, 0,
4245 	      (sizeof (struct ppc_link_hash_entry)
4246 	       - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4247 
4248       /* When making function calls, old ABI code references function entry
4249 	 points (dot symbols), while new ABI code references the function
4250 	 descriptor symbol.  We need to make any combination of reference and
4251 	 definition work together, without breaking archive linking.
4252 
4253 	 For a defined function "foo" and an undefined call to "bar":
4254 	 An old object defines "foo" and ".foo", references ".bar" (possibly
4255 	 "bar" too).
4256 	 A new object defines "foo" and references "bar".
4257 
4258 	 A new object thus has no problem with its undefined symbols being
4259 	 satisfied by definitions in an old object.  On the other hand, the
4260 	 old object won't have ".bar" satisfied by a new object.
4261 
4262 	 Keep a list of newly added dot-symbols.  */
4263 
4264       if (string[0] == '.')
4265 	{
4266 	  struct ppc_link_hash_table *htab;
4267 
4268 	  htab = (struct ppc_link_hash_table *) table;
4269 	  eh->u.next_dot_sym = htab->dot_syms;
4270 	  htab->dot_syms = eh;
4271 	}
4272     }
4273 
4274   return entry;
4275 }
4276 
4277 struct tocsave_entry {
4278   asection *sec;
4279   bfd_vma offset;
4280 };
4281 
4282 static hashval_t
4283 tocsave_htab_hash (const void *p)
4284 {
4285   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4286   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4287 }
4288 
4289 static int
4290 tocsave_htab_eq (const void *p1, const void *p2)
4291 {
4292   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4293   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4294   return e1->sec == e2->sec && e1->offset == e2->offset;
4295 }
4296 
4297 /* Destroy a ppc64 ELF linker hash table.  */
4298 
4299 static void
4300 ppc64_elf_link_hash_table_free (bfd *obfd)
4301 {
4302   struct ppc_link_hash_table *htab;
4303 
4304   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4305   if (htab->tocsave_htab)
4306     htab_delete (htab->tocsave_htab);
4307   bfd_hash_table_free (&htab->branch_hash_table);
4308   bfd_hash_table_free (&htab->stub_hash_table);
4309   _bfd_elf_link_hash_table_free (obfd);
4310 }
4311 
4312 /* Create a ppc64 ELF linker hash table.  */
4313 
4314 static struct bfd_link_hash_table *
4315 ppc64_elf_link_hash_table_create (bfd *abfd)
4316 {
4317   struct ppc_link_hash_table *htab;
4318   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4319 
4320   htab = bfd_zmalloc (amt);
4321   if (htab == NULL)
4322     return NULL;
4323 
4324   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4325 				      sizeof (struct ppc_link_hash_entry),
4326 				      PPC64_ELF_DATA))
4327     {
4328       free (htab);
4329       return NULL;
4330     }
4331 
4332   /* Init the stub hash table too.  */
4333   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4334 			    sizeof (struct ppc_stub_hash_entry)))
4335     {
4336       _bfd_elf_link_hash_table_free (abfd);
4337       return NULL;
4338     }
4339 
4340   /* And the branch hash table.  */
4341   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4342 			    sizeof (struct ppc_branch_hash_entry)))
4343     {
4344       bfd_hash_table_free (&htab->stub_hash_table);
4345       _bfd_elf_link_hash_table_free (abfd);
4346       return NULL;
4347     }
4348 
4349   htab->tocsave_htab = htab_try_create (1024,
4350 					tocsave_htab_hash,
4351 					tocsave_htab_eq,
4352 					NULL);
4353   if (htab->tocsave_htab == NULL)
4354     {
4355       ppc64_elf_link_hash_table_free (abfd);
4356       return NULL;
4357     }
4358   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4359 
4360   /* Initializing two fields of the union is just cosmetic.  We really
4361      only care about glist, but when compiled on a 32-bit host the
4362      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4363      debugger inspection of these fields look nicer.  */
4364   htab->elf.init_got_refcount.refcount = 0;
4365   htab->elf.init_got_refcount.glist = NULL;
4366   htab->elf.init_plt_refcount.refcount = 0;
4367   htab->elf.init_plt_refcount.glist = NULL;
4368   htab->elf.init_got_offset.offset = 0;
4369   htab->elf.init_got_offset.glist = NULL;
4370   htab->elf.init_plt_offset.offset = 0;
4371   htab->elf.init_plt_offset.glist = NULL;
4372 
4373   return &htab->elf.root;
4374 }
4375 
4376 /* Create sections for linker generated code.  */
4377 
4378 static bfd_boolean
4379 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4380 {
4381   struct ppc_link_hash_table *htab;
4382   flagword flags;
4383 
4384   htab = ppc_hash_table (info);
4385 
4386   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4387 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4388   if (htab->params->save_restore_funcs)
4389     {
4390       /* Create .sfpr for code to save and restore fp regs.  */
4391       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4392 						       flags);
4393       if (htab->sfpr == NULL
4394 	  || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4395 	return FALSE;
4396     }
4397 
4398   if (bfd_link_relocatable (info))
4399     return TRUE;
4400 
4401   /* Create .glink for lazy dynamic linking support.  */
4402   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4403 						    flags);
4404   if (htab->glink == NULL
4405       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4406     return FALSE;
4407 
4408   if (!info->no_ld_generated_unwind_info)
4409     {
4410       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4411 	       | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4412       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4413 								 ".eh_frame",
4414 								 flags);
4415       if (htab->glink_eh_frame == NULL
4416 	  || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4417 	return FALSE;
4418     }
4419 
4420   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4421   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4422   if (htab->elf.iplt == NULL
4423       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4424     return FALSE;
4425 
4426   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4427 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4428   htab->elf.irelplt
4429     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4430   if (htab->elf.irelplt == NULL
4431       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4432     return FALSE;
4433 
4434   /* Create branch lookup table for plt_branch stubs.  */
4435   flags = (SEC_ALLOC | SEC_LOAD
4436 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4437   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4438 						   flags);
4439   if (htab->brlt == NULL
4440       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4441     return FALSE;
4442 
4443   if (!bfd_link_pic (info))
4444     return TRUE;
4445 
4446   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4447 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4448   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4449 						      ".rela.branch_lt",
4450 						      flags);
4451   if (htab->relbrlt == NULL
4452       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4453     return FALSE;
4454 
4455   return TRUE;
4456 }
4457 
4458 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4459 
4460 bfd_boolean
4461 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4462 			 struct ppc64_elf_params *params)
4463 {
4464   struct ppc_link_hash_table *htab;
4465 
4466   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4467 
4468 /* Always hook our dynamic sections into the first bfd, which is the
4469    linker created stub bfd.  This ensures that the GOT header is at
4470    the start of the output TOC section.  */
4471   htab = ppc_hash_table (info);
4472   htab->elf.dynobj = params->stub_bfd;
4473   htab->params = params;
4474 
4475   return create_linkage_sections (htab->elf.dynobj, info);
4476 }
4477 
4478 /* Build a name for an entry in the stub hash table.  */
4479 
4480 static char *
4481 ppc_stub_name (const asection *input_section,
4482 	       const asection *sym_sec,
4483 	       const struct ppc_link_hash_entry *h,
4484 	       const Elf_Internal_Rela *rel)
4485 {
4486   char *stub_name;
4487   ssize_t len;
4488 
4489   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4490      offsets from a sym as a branch target?  In fact, we could
4491      probably assume the addend is always zero.  */
4492   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4493 
4494   if (h)
4495     {
4496       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4497       stub_name = bfd_malloc (len);
4498       if (stub_name == NULL)
4499 	return stub_name;
4500 
4501       len = sprintf (stub_name, "%08x.%s+%x",
4502 		     input_section->id & 0xffffffff,
4503 		     h->elf.root.root.string,
4504 		     (int) rel->r_addend & 0xffffffff);
4505     }
4506   else
4507     {
4508       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4509       stub_name = bfd_malloc (len);
4510       if (stub_name == NULL)
4511 	return stub_name;
4512 
4513       len = sprintf (stub_name, "%08x.%x:%x+%x",
4514 		     input_section->id & 0xffffffff,
4515 		     sym_sec->id & 0xffffffff,
4516 		     (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4517 		     (int) rel->r_addend & 0xffffffff);
4518     }
4519   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4520     stub_name[len - 2] = 0;
4521   return stub_name;
4522 }
4523 
4524 /* Look up an entry in the stub hash.  Stub entries are cached because
4525    creating the stub name takes a bit of time.  */
4526 
4527 static struct ppc_stub_hash_entry *
4528 ppc_get_stub_entry (const asection *input_section,
4529 		    const asection *sym_sec,
4530 		    struct ppc_link_hash_entry *h,
4531 		    const Elf_Internal_Rela *rel,
4532 		    struct ppc_link_hash_table *htab)
4533 {
4534   struct ppc_stub_hash_entry *stub_entry;
4535   struct map_stub *group;
4536 
4537   /* If this input section is part of a group of sections sharing one
4538      stub section, then use the id of the first section in the group.
4539      Stub names need to include a section id, as there may well be
4540      more than one stub used to reach say, printf, and we need to
4541      distinguish between them.  */
4542   group = htab->sec_info[input_section->id].u.group;
4543   if (group == NULL)
4544     return NULL;
4545 
4546   if (h != NULL && h->u.stub_cache != NULL
4547       && h->u.stub_cache->h == h
4548       && h->u.stub_cache->group == group)
4549     {
4550       stub_entry = h->u.stub_cache;
4551     }
4552   else
4553     {
4554       char *stub_name;
4555 
4556       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4557       if (stub_name == NULL)
4558 	return NULL;
4559 
4560       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4561 					 stub_name, FALSE, FALSE);
4562       if (h != NULL)
4563 	h->u.stub_cache = stub_entry;
4564 
4565       free (stub_name);
4566     }
4567 
4568   return stub_entry;
4569 }
4570 
4571 /* Add a new stub entry to the stub hash.  Not all fields of the new
4572    stub entry are initialised.  */
4573 
4574 static struct ppc_stub_hash_entry *
4575 ppc_add_stub (const char *stub_name,
4576 	      asection *section,
4577 	      struct bfd_link_info *info)
4578 {
4579   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4580   struct map_stub *group;
4581   asection *link_sec;
4582   asection *stub_sec;
4583   struct ppc_stub_hash_entry *stub_entry;
4584 
4585   group = htab->sec_info[section->id].u.group;
4586   link_sec = group->link_sec;
4587   stub_sec = group->stub_sec;
4588   if (stub_sec == NULL)
4589     {
4590       size_t namelen;
4591       bfd_size_type len;
4592       char *s_name;
4593 
4594       namelen = strlen (link_sec->name);
4595       len = namelen + sizeof (STUB_SUFFIX);
4596       s_name = bfd_alloc (htab->params->stub_bfd, len);
4597       if (s_name == NULL)
4598 	return NULL;
4599 
4600       memcpy (s_name, link_sec->name, namelen);
4601       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4602       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4603       if (stub_sec == NULL)
4604 	return NULL;
4605       group->stub_sec = stub_sec;
4606     }
4607 
4608   /* Enter this entry into the linker stub hash table.  */
4609   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4610 				     TRUE, FALSE);
4611   if (stub_entry == NULL)
4612     {
4613       /* xgettext:c-format */
4614       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4615 			      section->owner, stub_name);
4616       return NULL;
4617     }
4618 
4619   stub_entry->group = group;
4620   stub_entry->stub_offset = 0;
4621   return stub_entry;
4622 }
4623 
4624 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4625    not already done.  */
4626 
4627 static bfd_boolean
4628 create_got_section (bfd *abfd, struct bfd_link_info *info)
4629 {
4630   asection *got, *relgot;
4631   flagword flags;
4632   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4633 
4634   if (!is_ppc64_elf (abfd))
4635     return FALSE;
4636   if (htab == NULL)
4637     return FALSE;
4638 
4639   if (!htab->elf.sgot
4640       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4641     return FALSE;
4642 
4643   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4644 	   | SEC_LINKER_CREATED);
4645 
4646   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4647   if (!got
4648       || !bfd_set_section_alignment (abfd, got, 3))
4649     return FALSE;
4650 
4651   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4652 					       flags | SEC_READONLY);
4653   if (!relgot
4654       || ! bfd_set_section_alignment (abfd, relgot, 3))
4655     return FALSE;
4656 
4657   ppc64_elf_tdata (abfd)->got = got;
4658   ppc64_elf_tdata (abfd)->relgot = relgot;
4659   return TRUE;
4660 }
4661 
4662 /* Follow indirect and warning symbol links.  */
4663 
4664 static inline struct bfd_link_hash_entry *
4665 follow_link (struct bfd_link_hash_entry *h)
4666 {
4667   while (h->type == bfd_link_hash_indirect
4668 	 || h->type == bfd_link_hash_warning)
4669     h = h->u.i.link;
4670   return h;
4671 }
4672 
4673 static inline struct elf_link_hash_entry *
4674 elf_follow_link (struct elf_link_hash_entry *h)
4675 {
4676   return (struct elf_link_hash_entry *) follow_link (&h->root);
4677 }
4678 
4679 static inline struct ppc_link_hash_entry *
4680 ppc_follow_link (struct ppc_link_hash_entry *h)
4681 {
4682   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4683 }
4684 
4685 /* Merge PLT info on FROM with that on TO.  */
4686 
4687 static void
4688 move_plt_plist (struct ppc_link_hash_entry *from,
4689 		struct ppc_link_hash_entry *to)
4690 {
4691   if (from->elf.plt.plist != NULL)
4692     {
4693       if (to->elf.plt.plist != NULL)
4694 	{
4695 	  struct plt_entry **entp;
4696 	  struct plt_entry *ent;
4697 
4698 	  for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4699 	    {
4700 	      struct plt_entry *dent;
4701 
4702 	      for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4703 		if (dent->addend == ent->addend)
4704 		  {
4705 		    dent->plt.refcount += ent->plt.refcount;
4706 		    *entp = ent->next;
4707 		    break;
4708 		  }
4709 	      if (dent == NULL)
4710 		entp = &ent->next;
4711 	    }
4712 	  *entp = to->elf.plt.plist;
4713 	}
4714 
4715       to->elf.plt.plist = from->elf.plt.plist;
4716       from->elf.plt.plist = NULL;
4717     }
4718 }
4719 
4720 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4721 
4722 static void
4723 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4724 				struct elf_link_hash_entry *dir,
4725 				struct elf_link_hash_entry *ind)
4726 {
4727   struct ppc_link_hash_entry *edir, *eind;
4728 
4729   edir = (struct ppc_link_hash_entry *) dir;
4730   eind = (struct ppc_link_hash_entry *) ind;
4731 
4732   edir->is_func |= eind->is_func;
4733   edir->is_func_descriptor |= eind->is_func_descriptor;
4734   edir->tls_mask |= eind->tls_mask;
4735   if (eind->oh != NULL)
4736     edir->oh = ppc_follow_link (eind->oh);
4737 
4738   /* If called to transfer flags for a weakdef during processing
4739      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4740      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4741   if (!(ELIMINATE_COPY_RELOCS
4742 	&& eind->elf.root.type != bfd_link_hash_indirect
4743 	&& edir->elf.dynamic_adjusted))
4744     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4745 
4746   if (edir->elf.versioned != versioned_hidden)
4747     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4748   edir->elf.ref_regular |= eind->elf.ref_regular;
4749   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4750   edir->elf.needs_plt |= eind->elf.needs_plt;
4751   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4752 
4753   /* If we were called to copy over info for a weak sym, don't copy
4754      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4755      in order to simplify readonly_dynrelocs and save a field in the
4756      symbol hash entry, but that means dyn_relocs can't be used in any
4757      tests about a specific symbol, or affect other symbol flags which
4758      are then tested.
4759      Chain weakdefs so we can get from the weakdef back to an alias.
4760      The list is circular so that we don't need to use u.weakdef as
4761      well as this list to look at all aliases.  */
4762   if (eind->elf.root.type != bfd_link_hash_indirect)
4763     {
4764       struct ppc_link_hash_entry *cur, *add, *next;
4765 
4766       add = eind;
4767       do
4768 	{
4769 	  cur = edir->weakref;
4770 	  if (cur != NULL)
4771 	    {
4772 	      do
4773 		{
4774 		  /* We can be called twice for the same symbols.
4775 		     Don't make multiple loops.  */
4776 		  if (cur == add)
4777 		    return;
4778 		  cur = cur->weakref;
4779 		} while (cur != edir);
4780 	    }
4781 	  next = add->weakref;
4782 	  if (cur != add)
4783 	    {
4784 	      add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4785 	      edir->weakref = add;
4786 	    }
4787 	  add = next;
4788 	} while (add != NULL && add != eind);
4789       return;
4790     }
4791 
4792   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4793   if (eind->dyn_relocs != NULL)
4794     {
4795       if (edir->dyn_relocs != NULL)
4796 	{
4797 	  struct elf_dyn_relocs **pp;
4798 	  struct elf_dyn_relocs *p;
4799 
4800 	  /* Add reloc counts against the indirect sym to the direct sym
4801 	     list.  Merge any entries against the same section.  */
4802 	  for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4803 	    {
4804 	      struct elf_dyn_relocs *q;
4805 
4806 	      for (q = edir->dyn_relocs; q != NULL; q = q->next)
4807 		if (q->sec == p->sec)
4808 		  {
4809 		    q->pc_count += p->pc_count;
4810 		    q->count += p->count;
4811 		    *pp = p->next;
4812 		    break;
4813 		  }
4814 	      if (q == NULL)
4815 		pp = &p->next;
4816 	    }
4817 	  *pp = edir->dyn_relocs;
4818 	}
4819 
4820       edir->dyn_relocs = eind->dyn_relocs;
4821       eind->dyn_relocs = NULL;
4822     }
4823 
4824   /* Copy over got entries that we may have already seen to the
4825      symbol which just became indirect.  */
4826   if (eind->elf.got.glist != NULL)
4827     {
4828       if (edir->elf.got.glist != NULL)
4829 	{
4830 	  struct got_entry **entp;
4831 	  struct got_entry *ent;
4832 
4833 	  for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4834 	    {
4835 	      struct got_entry *dent;
4836 
4837 	      for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4838 		if (dent->addend == ent->addend
4839 		    && dent->owner == ent->owner
4840 		    && dent->tls_type == ent->tls_type)
4841 		  {
4842 		    dent->got.refcount += ent->got.refcount;
4843 		    *entp = ent->next;
4844 		    break;
4845 		  }
4846 	      if (dent == NULL)
4847 		entp = &ent->next;
4848 	    }
4849 	  *entp = edir->elf.got.glist;
4850 	}
4851 
4852       edir->elf.got.glist = eind->elf.got.glist;
4853       eind->elf.got.glist = NULL;
4854     }
4855 
4856   /* And plt entries.  */
4857   move_plt_plist (eind, edir);
4858 
4859   if (eind->elf.dynindx != -1)
4860     {
4861       if (edir->elf.dynindx != -1)
4862 	_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4863 				edir->elf.dynstr_index);
4864       edir->elf.dynindx = eind->elf.dynindx;
4865       edir->elf.dynstr_index = eind->elf.dynstr_index;
4866       eind->elf.dynindx = -1;
4867       eind->elf.dynstr_index = 0;
4868     }
4869 }
4870 
4871 /* Find the function descriptor hash entry from the given function code
4872    hash entry FH.  Link the entries via their OH fields.  */
4873 
4874 static struct ppc_link_hash_entry *
4875 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4876 {
4877   struct ppc_link_hash_entry *fdh = fh->oh;
4878 
4879   if (fdh == NULL)
4880     {
4881       const char *fd_name = fh->elf.root.root.string + 1;
4882 
4883       fdh = (struct ppc_link_hash_entry *)
4884 	elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4885       if (fdh == NULL)
4886 	return fdh;
4887 
4888       fdh->is_func_descriptor = 1;
4889       fdh->oh = fh;
4890       fh->is_func = 1;
4891       fh->oh = fdh;
4892     }
4893 
4894   fdh = ppc_follow_link (fdh);
4895   fdh->is_func_descriptor = 1;
4896   fdh->oh = fh;
4897   return fdh;
4898 }
4899 
4900 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4901 
4902 static struct ppc_link_hash_entry *
4903 make_fdh (struct bfd_link_info *info,
4904 	  struct ppc_link_hash_entry *fh)
4905 {
4906   bfd *abfd = fh->elf.root.u.undef.abfd;
4907   struct bfd_link_hash_entry *bh = NULL;
4908   struct ppc_link_hash_entry *fdh;
4909   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4910 		    ? BSF_WEAK
4911 		    : BSF_GLOBAL);
4912 
4913   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4914 					 fh->elf.root.root.string + 1,
4915 					 flags, bfd_und_section_ptr, 0,
4916 					 NULL, FALSE, FALSE, &bh))
4917     return NULL;
4918 
4919   fdh = (struct ppc_link_hash_entry *) bh;
4920   fdh->elf.non_elf = 0;
4921   fdh->fake = 1;
4922   fdh->is_func_descriptor = 1;
4923   fdh->oh = fh;
4924   fh->is_func = 1;
4925   fh->oh = fdh;
4926   return fdh;
4927 }
4928 
4929 /* Fix function descriptor symbols defined in .opd sections to be
4930    function type.  */
4931 
4932 static bfd_boolean
4933 ppc64_elf_add_symbol_hook (bfd *ibfd,
4934 			   struct bfd_link_info *info,
4935 			   Elf_Internal_Sym *isym,
4936 			   const char **name,
4937 			   flagword *flags ATTRIBUTE_UNUSED,
4938 			   asection **sec,
4939 			   bfd_vma *value)
4940 {
4941   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4942       && (ibfd->flags & DYNAMIC) == 0
4943       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4944     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4945 
4946   if (*sec != NULL
4947       && strcmp ((*sec)->name, ".opd") == 0)
4948     {
4949       asection *code_sec;
4950 
4951       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4952 	    || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4953 	isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4954 
4955       /* If the symbol is a function defined in .opd, and the function
4956 	 code is in a discarded group, let it appear to be undefined.  */
4957       if (!bfd_link_relocatable (info)
4958 	  && (*sec)->reloc_count != 0
4959 	  && opd_entry_value (*sec, *value, &code_sec, NULL,
4960 			      FALSE) != (bfd_vma) -1
4961 	  && discarded_section (code_sec))
4962 	{
4963 	  *sec = bfd_und_section_ptr;
4964 	  isym->st_shndx = SHN_UNDEF;
4965 	}
4966     }
4967   else if (*sec != NULL
4968 	   && strcmp ((*sec)->name, ".toc") == 0
4969 	   && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4970     {
4971       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4972       if (htab != NULL)
4973 	htab->params->object_in_toc = 1;
4974     }
4975 
4976   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4977     {
4978       if (abiversion (ibfd) == 0)
4979 	set_abiversion (ibfd, 2);
4980       else if (abiversion (ibfd) == 1)
4981 	{
4982 	  info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4983 				    " for ABI version 1\n"), name);
4984 	  bfd_set_error (bfd_error_bad_value);
4985 	  return FALSE;
4986 	}
4987     }
4988 
4989   return TRUE;
4990 }
4991 
4992 /* Merge non-visibility st_other attributes: local entry point.  */
4993 
4994 static void
4995 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4996 				  const Elf_Internal_Sym *isym,
4997 				  bfd_boolean definition,
4998 				  bfd_boolean dynamic)
4999 {
5000   if (definition && !dynamic)
5001     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5002 		| ELF_ST_VISIBILITY (h->other));
5003 }
5004 
5005 /* Hook called on merging a symbol.  We use this to clear "fake" since
5006    we now have a real symbol.  */
5007 
5008 static bfd_boolean
5009 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5010 			const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
5011 			asection **psec ATTRIBUTE_UNUSED,
5012 			bfd_boolean newdef ATTRIBUTE_UNUSED,
5013 			bfd_boolean olddef ATTRIBUTE_UNUSED,
5014 			bfd *oldbfd ATTRIBUTE_UNUSED,
5015 			const asection *oldsec ATTRIBUTE_UNUSED)
5016 {
5017   ((struct ppc_link_hash_entry *) h)->fake = 0;
5018   return TRUE;
5019 }
5020 
5021 /* This function makes an old ABI object reference to ".bar" cause the
5022    inclusion of a new ABI object archive that defines "bar".
5023    NAME is a symbol defined in an archive.  Return a symbol in the hash
5024    table that might be satisfied by the archive symbols.  */
5025 
5026 static struct elf_link_hash_entry *
5027 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5028 				 struct bfd_link_info *info,
5029 				 const char *name)
5030 {
5031   struct elf_link_hash_entry *h;
5032   char *dot_name;
5033   size_t len;
5034 
5035   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5036   if (h != NULL
5037       /* Don't return this sym if it is a fake function descriptor
5038 	 created by add_symbol_adjust.  */
5039       && !((struct ppc_link_hash_entry *) h)->fake)
5040     return h;
5041 
5042   if (name[0] == '.')
5043     return h;
5044 
5045   len = strlen (name);
5046   dot_name = bfd_alloc (abfd, len + 2);
5047   if (dot_name == NULL)
5048     return (struct elf_link_hash_entry *) 0 - 1;
5049   dot_name[0] = '.';
5050   memcpy (dot_name + 1, name, len + 1);
5051   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5052   bfd_release (abfd, dot_name);
5053   return h;
5054 }
5055 
5056 /* This function satisfies all old ABI object references to ".bar" if a
5057    new ABI object defines "bar".  Well, at least, undefined dot symbols
5058    are made weak.  This stops later archive searches from including an
5059    object if we already have a function descriptor definition.  It also
5060    prevents the linker complaining about undefined symbols.
5061    We also check and correct mismatched symbol visibility here.  The
5062    most restrictive visibility of the function descriptor and the
5063    function entry symbol is used.  */
5064 
5065 static bfd_boolean
5066 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5067 {
5068   struct ppc_link_hash_table *htab;
5069   struct ppc_link_hash_entry *fdh;
5070 
5071   if (eh->elf.root.type == bfd_link_hash_warning)
5072     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5073 
5074   if (eh->elf.root.type == bfd_link_hash_indirect)
5075     return TRUE;
5076 
5077   if (eh->elf.root.root.string[0] != '.')
5078     abort ();
5079 
5080   htab = ppc_hash_table (info);
5081   if (htab == NULL)
5082     return FALSE;
5083 
5084   fdh = lookup_fdh (eh, htab);
5085   if (fdh == NULL
5086       && !bfd_link_relocatable (info)
5087       && (eh->elf.root.type == bfd_link_hash_undefined
5088 	  || eh->elf.root.type == bfd_link_hash_undefweak)
5089       && eh->elf.ref_regular)
5090     {
5091       /* Make an undefined function descriptor sym, in order to
5092 	 pull in an --as-needed shared lib.  Archives are handled
5093 	 elsewhere.  */
5094       fdh = make_fdh (info, eh);
5095       if (fdh == NULL)
5096 	return FALSE;
5097     }
5098 
5099   if (fdh != NULL)
5100     {
5101       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5102       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5103 
5104       /* Make both descriptor and entry symbol have the most
5105 	 constraining visibility of either symbol.  */
5106       if (entry_vis < descr_vis)
5107 	fdh->elf.other += entry_vis - descr_vis;
5108       else if (entry_vis > descr_vis)
5109 	eh->elf.other += descr_vis - entry_vis;
5110 
5111       /* Propagate reference flags from entry symbol to function
5112 	 descriptor symbol.  */
5113       fdh->elf.root.non_ir_ref |= eh->elf.root.non_ir_ref;
5114       fdh->elf.ref_regular |= eh->elf.ref_regular;
5115       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5116 
5117       if (!fdh->elf.forced_local
5118 	  && fdh->elf.dynindx == -1
5119 	  && fdh->elf.versioned != versioned_hidden
5120 	  && (bfd_link_dll (info)
5121 	      || fdh->elf.def_dynamic
5122 	      || fdh->elf.ref_dynamic)
5123 	  && (eh->elf.ref_regular
5124 	      || eh->elf.def_regular))
5125 	{
5126 	  if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5127 	    return FALSE;
5128 	}
5129     }
5130 
5131   return TRUE;
5132 }
5133 
5134 /* Set up opd section info and abiversion for IBFD, and process list
5135    of dot-symbols we made in link_hash_newfunc.  */
5136 
5137 static bfd_boolean
5138 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5139 {
5140   struct ppc_link_hash_table *htab;
5141   struct ppc_link_hash_entry **p, *eh;
5142   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5143 
5144   if (opd != NULL && opd->size != 0)
5145     {
5146       if (abiversion (ibfd) == 0)
5147 	set_abiversion (ibfd, 1);
5148       else if (abiversion (ibfd) >= 2)
5149 	{
5150 	  /* xgettext:c-format */
5151 	  info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5152 				    " version %d\n"),
5153 				  ibfd, abiversion (ibfd));
5154 	  bfd_set_error (bfd_error_bad_value);
5155 	  return FALSE;
5156 	}
5157 
5158       if ((ibfd->flags & DYNAMIC) == 0
5159 	  && (opd->flags & SEC_RELOC) != 0
5160 	  && opd->reloc_count != 0
5161 	  && !bfd_is_abs_section (opd->output_section))
5162 	{
5163 	  /* Garbage collection needs some extra help with .opd sections.
5164 	     We don't want to necessarily keep everything referenced by
5165 	     relocs in .opd, as that would keep all functions.  Instead,
5166 	     if we reference an .opd symbol (a function descriptor), we
5167 	     want to keep the function code symbol's section.  This is
5168 	     easy for global symbols, but for local syms we need to keep
5169 	     information about the associated function section.  */
5170 	  bfd_size_type amt;
5171 	  asection **opd_sym_map;
5172 
5173 	  amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5174 	  opd_sym_map = bfd_zalloc (ibfd, amt);
5175 	  if (opd_sym_map == NULL)
5176 	    return FALSE;
5177 	  ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5178 	  BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5179 	  ppc64_elf_section_data (opd)->sec_type = sec_opd;
5180 	}
5181     }
5182 
5183   if (!is_ppc64_elf (info->output_bfd))
5184     return TRUE;
5185   htab = ppc_hash_table (info);
5186   if (htab == NULL)
5187     return FALSE;
5188 
5189   /* For input files without an explicit abiversion in e_flags
5190      we should have flagged any with symbol st_other bits set
5191      as ELFv1 and above flagged those with .opd as ELFv2.
5192      Set the output abiversion if not yet set, and for any input
5193      still ambiguous, take its abiversion from the output.
5194      Differences in ABI are reported later.  */
5195   if (abiversion (info->output_bfd) == 0)
5196     set_abiversion (info->output_bfd, abiversion (ibfd));
5197   else if (abiversion (ibfd) == 0)
5198     set_abiversion (ibfd, abiversion (info->output_bfd));
5199 
5200   p = &htab->dot_syms;
5201   while ((eh = *p) != NULL)
5202     {
5203       *p = NULL;
5204       if (&eh->elf == htab->elf.hgot)
5205 	;
5206       else if (htab->elf.hgot == NULL
5207 	       && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5208 	htab->elf.hgot = &eh->elf;
5209       else if (abiversion (ibfd) <= 1)
5210 	{
5211 	  htab->need_func_desc_adj = 1;
5212 	  if (!add_symbol_adjust (eh, info))
5213 	    return FALSE;
5214 	}
5215       p = &eh->u.next_dot_sym;
5216     }
5217   return TRUE;
5218 }
5219 
5220 /* Undo hash table changes when an --as-needed input file is determined
5221    not to be needed.  */
5222 
5223 static bfd_boolean
5224 ppc64_elf_notice_as_needed (bfd *ibfd,
5225 			    struct bfd_link_info *info,
5226 			    enum notice_asneeded_action act)
5227 {
5228   if (act == notice_not_needed)
5229     {
5230       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5231 
5232       if (htab == NULL)
5233 	return FALSE;
5234 
5235       htab->dot_syms = NULL;
5236     }
5237   return _bfd_elf_notice_as_needed (ibfd, info, act);
5238 }
5239 
5240 /* If --just-symbols against a final linked binary, then assume we need
5241    toc adjusting stubs when calling functions defined there.  */
5242 
5243 static void
5244 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5245 {
5246   if ((sec->flags & SEC_CODE) != 0
5247       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5248       && is_ppc64_elf (sec->owner))
5249     {
5250       if (abiversion (sec->owner) >= 2
5251 	  || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5252 	sec->has_toc_reloc = 1;
5253     }
5254   _bfd_elf_link_just_syms (sec, info);
5255 }
5256 
5257 static struct plt_entry **
5258 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5259 		       unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5260 {
5261   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5262   struct plt_entry **local_plt;
5263   unsigned char *local_got_tls_masks;
5264 
5265   if (local_got_ents == NULL)
5266     {
5267       bfd_size_type size = symtab_hdr->sh_info;
5268 
5269       size *= (sizeof (*local_got_ents)
5270 	       + sizeof (*local_plt)
5271 	       + sizeof (*local_got_tls_masks));
5272       local_got_ents = bfd_zalloc (abfd, size);
5273       if (local_got_ents == NULL)
5274 	return NULL;
5275       elf_local_got_ents (abfd) = local_got_ents;
5276     }
5277 
5278   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5279     {
5280       struct got_entry *ent;
5281 
5282       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5283 	if (ent->addend == r_addend
5284 	    && ent->owner == abfd
5285 	    && ent->tls_type == tls_type)
5286 	  break;
5287       if (ent == NULL)
5288 	{
5289 	  bfd_size_type amt = sizeof (*ent);
5290 	  ent = bfd_alloc (abfd, amt);
5291 	  if (ent == NULL)
5292 	    return FALSE;
5293 	  ent->next = local_got_ents[r_symndx];
5294 	  ent->addend = r_addend;
5295 	  ent->owner = abfd;
5296 	  ent->tls_type = tls_type;
5297 	  ent->is_indirect = FALSE;
5298 	  ent->got.refcount = 0;
5299 	  local_got_ents[r_symndx] = ent;
5300 	}
5301       ent->got.refcount += 1;
5302     }
5303 
5304   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5305   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5306   local_got_tls_masks[r_symndx] |= tls_type;
5307 
5308   return local_plt + r_symndx;
5309 }
5310 
5311 static bfd_boolean
5312 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5313 {
5314   struct plt_entry *ent;
5315 
5316   for (ent = *plist; ent != NULL; ent = ent->next)
5317     if (ent->addend == addend)
5318       break;
5319   if (ent == NULL)
5320     {
5321       bfd_size_type amt = sizeof (*ent);
5322       ent = bfd_alloc (abfd, amt);
5323       if (ent == NULL)
5324 	return FALSE;
5325       ent->next = *plist;
5326       ent->addend = addend;
5327       ent->plt.refcount = 0;
5328       *plist = ent;
5329     }
5330   ent->plt.refcount += 1;
5331   return TRUE;
5332 }
5333 
5334 static bfd_boolean
5335 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5336 {
5337   return (r_type == R_PPC64_REL24
5338 	  || r_type == R_PPC64_REL14
5339 	  || r_type == R_PPC64_REL14_BRTAKEN
5340 	  || r_type == R_PPC64_REL14_BRNTAKEN
5341 	  || r_type == R_PPC64_ADDR24
5342 	  || r_type == R_PPC64_ADDR14
5343 	  || r_type == R_PPC64_ADDR14_BRTAKEN
5344 	  || r_type == R_PPC64_ADDR14_BRNTAKEN);
5345 }
5346 
5347 /* Look through the relocs for a section during the first phase, and
5348    calculate needed space in the global offset table, procedure
5349    linkage table, and dynamic reloc sections.  */
5350 
5351 static bfd_boolean
5352 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5353 			asection *sec, const Elf_Internal_Rela *relocs)
5354 {
5355   struct ppc_link_hash_table *htab;
5356   Elf_Internal_Shdr *symtab_hdr;
5357   struct elf_link_hash_entry **sym_hashes;
5358   const Elf_Internal_Rela *rel;
5359   const Elf_Internal_Rela *rel_end;
5360   asection *sreloc;
5361   asection **opd_sym_map;
5362   struct elf_link_hash_entry *tga, *dottga;
5363 
5364   if (bfd_link_relocatable (info))
5365     return TRUE;
5366 
5367   /* Don't do anything special with non-loaded, non-alloced sections.
5368      In particular, any relocs in such sections should not affect GOT
5369      and PLT reference counting (ie. we don't allow them to create GOT
5370      or PLT entries), there's no possibility or desire to optimize TLS
5371      relocs, and there's not much point in propagating relocs to shared
5372      libs that the dynamic linker won't relocate.  */
5373   if ((sec->flags & SEC_ALLOC) == 0)
5374     return TRUE;
5375 
5376   BFD_ASSERT (is_ppc64_elf (abfd));
5377 
5378   htab = ppc_hash_table (info);
5379   if (htab == NULL)
5380     return FALSE;
5381 
5382   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5383 			      FALSE, FALSE, TRUE);
5384   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5385 				 FALSE, FALSE, TRUE);
5386   symtab_hdr = &elf_symtab_hdr (abfd);
5387   sym_hashes = elf_sym_hashes (abfd);
5388   sreloc = NULL;
5389   opd_sym_map = NULL;
5390   if (ppc64_elf_section_data (sec) != NULL
5391       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5392     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5393 
5394   rel_end = relocs + sec->reloc_count;
5395   for (rel = relocs; rel < rel_end; rel++)
5396     {
5397       unsigned long r_symndx;
5398       struct elf_link_hash_entry *h;
5399       enum elf_ppc64_reloc_type r_type;
5400       int tls_type;
5401       struct _ppc64_elf_section_data *ppc64_sec;
5402       struct plt_entry **ifunc, **plt_list;
5403 
5404       r_symndx = ELF64_R_SYM (rel->r_info);
5405       if (r_symndx < symtab_hdr->sh_info)
5406 	h = NULL;
5407       else
5408 	{
5409 	  struct ppc_link_hash_entry *eh;
5410 
5411 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5412 	  h = elf_follow_link (h);
5413 	  eh = (struct ppc_link_hash_entry *) h;
5414 
5415 	  /* PR15323, ref flags aren't set for references in the same
5416 	     object.  */
5417 	  h->root.non_ir_ref = 1;
5418 	  if (eh->is_func && eh->oh != NULL)
5419 	    eh->oh->elf.root.non_ir_ref = 1;
5420 
5421 	  if (h == htab->elf.hgot)
5422 	    sec->has_toc_reloc = 1;
5423 	}
5424 
5425       tls_type = 0;
5426       ifunc = NULL;
5427       if (h != NULL)
5428 	{
5429 	  if (h->type == STT_GNU_IFUNC)
5430 	    {
5431 	      h->needs_plt = 1;
5432 	      ifunc = &h->plt.plist;
5433 	    }
5434 	}
5435       else
5436 	{
5437 	  Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5438 							  abfd, r_symndx);
5439 	  if (isym == NULL)
5440 	    return FALSE;
5441 
5442 	  if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5443 	    {
5444 	      ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5445 					     rel->r_addend, PLT_IFUNC);
5446 	      if (ifunc == NULL)
5447 		return FALSE;
5448 	    }
5449 	}
5450 
5451       r_type = ELF64_R_TYPE (rel->r_info);
5452       switch (r_type)
5453 	{
5454 	case R_PPC64_TLSGD:
5455 	case R_PPC64_TLSLD:
5456 	  /* These special tls relocs tie a call to __tls_get_addr with
5457 	     its parameter symbol.  */
5458 	  break;
5459 
5460 	case R_PPC64_GOT_TLSLD16:
5461 	case R_PPC64_GOT_TLSLD16_LO:
5462 	case R_PPC64_GOT_TLSLD16_HI:
5463 	case R_PPC64_GOT_TLSLD16_HA:
5464 	  tls_type = TLS_TLS | TLS_LD;
5465 	  goto dogottls;
5466 
5467 	case R_PPC64_GOT_TLSGD16:
5468 	case R_PPC64_GOT_TLSGD16_LO:
5469 	case R_PPC64_GOT_TLSGD16_HI:
5470 	case R_PPC64_GOT_TLSGD16_HA:
5471 	  tls_type = TLS_TLS | TLS_GD;
5472 	  goto dogottls;
5473 
5474 	case R_PPC64_GOT_TPREL16_DS:
5475 	case R_PPC64_GOT_TPREL16_LO_DS:
5476 	case R_PPC64_GOT_TPREL16_HI:
5477 	case R_PPC64_GOT_TPREL16_HA:
5478 	  if (bfd_link_pic (info))
5479 	    info->flags |= DF_STATIC_TLS;
5480 	  tls_type = TLS_TLS | TLS_TPREL;
5481 	  goto dogottls;
5482 
5483 	case R_PPC64_GOT_DTPREL16_DS:
5484 	case R_PPC64_GOT_DTPREL16_LO_DS:
5485 	case R_PPC64_GOT_DTPREL16_HI:
5486 	case R_PPC64_GOT_DTPREL16_HA:
5487 	  tls_type = TLS_TLS | TLS_DTPREL;
5488 	dogottls:
5489 	  sec->has_tls_reloc = 1;
5490 	  /* Fall through */
5491 
5492 	case R_PPC64_GOT16:
5493 	case R_PPC64_GOT16_DS:
5494 	case R_PPC64_GOT16_HA:
5495 	case R_PPC64_GOT16_HI:
5496 	case R_PPC64_GOT16_LO:
5497 	case R_PPC64_GOT16_LO_DS:
5498 	  /* This symbol requires a global offset table entry.  */
5499 	  sec->has_toc_reloc = 1;
5500 	  if (r_type == R_PPC64_GOT_TLSLD16
5501 	      || r_type == R_PPC64_GOT_TLSGD16
5502 	      || r_type == R_PPC64_GOT_TPREL16_DS
5503 	      || r_type == R_PPC64_GOT_DTPREL16_DS
5504 	      || r_type == R_PPC64_GOT16
5505 	      || r_type == R_PPC64_GOT16_DS)
5506 	    {
5507 	      htab->do_multi_toc = 1;
5508 	      ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5509 	    }
5510 
5511 	  if (ppc64_elf_tdata (abfd)->got == NULL
5512 	      && !create_got_section (abfd, info))
5513 	    return FALSE;
5514 
5515 	  if (h != NULL)
5516 	    {
5517 	      struct ppc_link_hash_entry *eh;
5518 	      struct got_entry *ent;
5519 
5520 	      eh = (struct ppc_link_hash_entry *) h;
5521 	      for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5522 		if (ent->addend == rel->r_addend
5523 		    && ent->owner == abfd
5524 		    && ent->tls_type == tls_type)
5525 		  break;
5526 	      if (ent == NULL)
5527 		{
5528 		  bfd_size_type amt = sizeof (*ent);
5529 		  ent = bfd_alloc (abfd, amt);
5530 		  if (ent == NULL)
5531 		    return FALSE;
5532 		  ent->next = eh->elf.got.glist;
5533 		  ent->addend = rel->r_addend;
5534 		  ent->owner = abfd;
5535 		  ent->tls_type = tls_type;
5536 		  ent->is_indirect = FALSE;
5537 		  ent->got.refcount = 0;
5538 		  eh->elf.got.glist = ent;
5539 		}
5540 	      ent->got.refcount += 1;
5541 	      eh->tls_mask |= tls_type;
5542 	    }
5543 	  else
5544 	    /* This is a global offset table entry for a local symbol.  */
5545 	    if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5546 					rel->r_addend, tls_type))
5547 	      return FALSE;
5548 
5549 	  /* We may also need a plt entry if the symbol turns out to be
5550 	     an ifunc.  */
5551 	  if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5552 	    {
5553 	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5554 		return FALSE;
5555 	    }
5556 	  break;
5557 
5558 	case R_PPC64_PLT16_HA:
5559 	case R_PPC64_PLT16_HI:
5560 	case R_PPC64_PLT16_LO:
5561 	case R_PPC64_PLT32:
5562 	case R_PPC64_PLT64:
5563 	  /* This symbol requires a procedure linkage table entry.  */
5564 	  plt_list = ifunc;
5565 	  if (h != NULL)
5566 	    {
5567 	      h->needs_plt = 1;
5568 	      if (h->root.root.string[0] == '.'
5569 		  && h->root.root.string[1] != '\0')
5570 		((struct ppc_link_hash_entry *) h)->is_func = 1;
5571 	      plt_list = &h->plt.plist;
5572 	    }
5573 	  if (plt_list == NULL)
5574 	    {
5575 	      /* It does not make sense to have a procedure linkage
5576 		 table entry for a non-ifunc local symbol.  */
5577 	      info->callbacks->einfo
5578 		/* xgettext:c-format */
5579 		(_("%H: %s reloc against local symbol\n"),
5580 		 abfd, sec, rel->r_offset,
5581 		 ppc64_elf_howto_table[r_type]->name);
5582 	      bfd_set_error (bfd_error_bad_value);
5583 	      return FALSE;
5584 	    }
5585 	  if (!update_plt_info (abfd, plt_list, rel->r_addend))
5586 	    return FALSE;
5587 	  break;
5588 
5589 	  /* The following relocations don't need to propagate the
5590 	     relocation if linking a shared object since they are
5591 	     section relative.  */
5592 	case R_PPC64_SECTOFF:
5593 	case R_PPC64_SECTOFF_LO:
5594 	case R_PPC64_SECTOFF_HI:
5595 	case R_PPC64_SECTOFF_HA:
5596 	case R_PPC64_SECTOFF_DS:
5597 	case R_PPC64_SECTOFF_LO_DS:
5598 	case R_PPC64_DTPREL16:
5599 	case R_PPC64_DTPREL16_LO:
5600 	case R_PPC64_DTPREL16_HI:
5601 	case R_PPC64_DTPREL16_HA:
5602 	case R_PPC64_DTPREL16_DS:
5603 	case R_PPC64_DTPREL16_LO_DS:
5604 	case R_PPC64_DTPREL16_HIGH:
5605 	case R_PPC64_DTPREL16_HIGHA:
5606 	case R_PPC64_DTPREL16_HIGHER:
5607 	case R_PPC64_DTPREL16_HIGHERA:
5608 	case R_PPC64_DTPREL16_HIGHEST:
5609 	case R_PPC64_DTPREL16_HIGHESTA:
5610 	  break;
5611 
5612 	  /* Nor do these.  */
5613 	case R_PPC64_REL16:
5614 	case R_PPC64_REL16_LO:
5615 	case R_PPC64_REL16_HI:
5616 	case R_PPC64_REL16_HA:
5617 	case R_PPC64_REL16DX_HA:
5618 	  break;
5619 
5620 	  /* Not supported as a dynamic relocation.  */
5621 	case R_PPC64_ADDR64_LOCAL:
5622 	  if (bfd_link_pic (info))
5623 	    {
5624 	      if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5625 		ppc_howto_init ();
5626 	      /* xgettext:c-format */
5627 	      info->callbacks->einfo (_("%H: %s reloc unsupported "
5628 					"in shared libraries and PIEs.\n"),
5629 				      abfd, sec, rel->r_offset,
5630 				      ppc64_elf_howto_table[r_type]->name);
5631 	      bfd_set_error (bfd_error_bad_value);
5632 	      return FALSE;
5633 	    }
5634 	  break;
5635 
5636 	case R_PPC64_TOC16:
5637 	case R_PPC64_TOC16_DS:
5638 	  htab->do_multi_toc = 1;
5639 	  ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5640 	  /* Fall through.  */
5641 	case R_PPC64_TOC16_LO:
5642 	case R_PPC64_TOC16_HI:
5643 	case R_PPC64_TOC16_HA:
5644 	case R_PPC64_TOC16_LO_DS:
5645 	  sec->has_toc_reloc = 1;
5646 	  break;
5647 
5648 	  /* Marker reloc.  */
5649 	case R_PPC64_ENTRY:
5650 	  break;
5651 
5652 	  /* This relocation describes the C++ object vtable hierarchy.
5653 	     Reconstruct it for later use during GC.  */
5654 	case R_PPC64_GNU_VTINHERIT:
5655 	  if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5656 	    return FALSE;
5657 	  break;
5658 
5659 	  /* This relocation describes which C++ vtable entries are actually
5660 	     used.  Record for later use during GC.  */
5661 	case R_PPC64_GNU_VTENTRY:
5662 	  BFD_ASSERT (h != NULL);
5663 	  if (h != NULL
5664 	      && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5665 	    return FALSE;
5666 	  break;
5667 
5668 	case R_PPC64_REL14:
5669 	case R_PPC64_REL14_BRTAKEN:
5670 	case R_PPC64_REL14_BRNTAKEN:
5671 	  {
5672 	    asection *dest = NULL;
5673 
5674 	    /* Heuristic: If jumping outside our section, chances are
5675 	       we are going to need a stub.  */
5676 	    if (h != NULL)
5677 	      {
5678 		/* If the sym is weak it may be overridden later, so
5679 		   don't assume we know where a weak sym lives.  */
5680 		if (h->root.type == bfd_link_hash_defined)
5681 		  dest = h->root.u.def.section;
5682 	      }
5683 	    else
5684 	      {
5685 		Elf_Internal_Sym *isym;
5686 
5687 		isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5688 					      abfd, r_symndx);
5689 		if (isym == NULL)
5690 		  return FALSE;
5691 
5692 		dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5693 	      }
5694 
5695 	    if (dest != sec)
5696 	      ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5697 	  }
5698 	  /* Fall through.  */
5699 
5700 	case R_PPC64_REL24:
5701 	  plt_list = ifunc;
5702 	  if (h != NULL)
5703 	    {
5704 	      h->needs_plt = 1;
5705 	      if (h->root.root.string[0] == '.'
5706 		  && h->root.root.string[1] != '\0')
5707 		((struct ppc_link_hash_entry *) h)->is_func = 1;
5708 
5709 	      if (h == tga || h == dottga)
5710 		{
5711 		  sec->has_tls_reloc = 1;
5712 		  if (rel != relocs
5713 		      && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5714 			  || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5715 		    /* We have a new-style __tls_get_addr call with
5716 		       a marker reloc.  */
5717 		    ;
5718 		  else
5719 		    /* Mark this section as having an old-style call.  */
5720 		    sec->has_tls_get_addr_call = 1;
5721 		}
5722 	      plt_list = &h->plt.plist;
5723 	    }
5724 
5725 	  /* We may need a .plt entry if the function this reloc
5726 	     refers to is in a shared lib.  */
5727 	  if (plt_list
5728 	      && !update_plt_info (abfd, plt_list, rel->r_addend))
5729 	    return FALSE;
5730 	  break;
5731 
5732 	case R_PPC64_ADDR14:
5733 	case R_PPC64_ADDR14_BRNTAKEN:
5734 	case R_PPC64_ADDR14_BRTAKEN:
5735 	case R_PPC64_ADDR24:
5736 	  goto dodyn;
5737 
5738 	case R_PPC64_TPREL64:
5739 	  tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5740 	  if (bfd_link_pic (info))
5741 	    info->flags |= DF_STATIC_TLS;
5742 	  goto dotlstoc;
5743 
5744 	case R_PPC64_DTPMOD64:
5745 	  if (rel + 1 < rel_end
5746 	      && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5747 	      && rel[1].r_offset == rel->r_offset + 8)
5748 	    tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5749 	  else
5750 	    tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5751 	  goto dotlstoc;
5752 
5753 	case R_PPC64_DTPREL64:
5754 	  tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5755 	  if (rel != relocs
5756 	      && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5757 	      && rel[-1].r_offset == rel->r_offset - 8)
5758 	    /* This is the second reloc of a dtpmod, dtprel pair.
5759 	       Don't mark with TLS_DTPREL.  */
5760 	    goto dodyn;
5761 
5762 	dotlstoc:
5763 	  sec->has_tls_reloc = 1;
5764 	  if (h != NULL)
5765 	    {
5766 	      struct ppc_link_hash_entry *eh;
5767 	      eh = (struct ppc_link_hash_entry *) h;
5768 	      eh->tls_mask |= tls_type;
5769 	    }
5770 	  else
5771 	    if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5772 					rel->r_addend, tls_type))
5773 	      return FALSE;
5774 
5775 	  ppc64_sec = ppc64_elf_section_data (sec);
5776 	  if (ppc64_sec->sec_type != sec_toc)
5777 	    {
5778 	      bfd_size_type amt;
5779 
5780 	      /* One extra to simplify get_tls_mask.  */
5781 	      amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5782 	      ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5783 	      if (ppc64_sec->u.toc.symndx == NULL)
5784 		return FALSE;
5785 	      amt = sec->size * sizeof (bfd_vma) / 8;
5786 	      ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5787 	      if (ppc64_sec->u.toc.add == NULL)
5788 		return FALSE;
5789 	      BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5790 	      ppc64_sec->sec_type = sec_toc;
5791 	    }
5792 	  BFD_ASSERT (rel->r_offset % 8 == 0);
5793 	  ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5794 	  ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5795 
5796 	  /* Mark the second slot of a GD or LD entry.
5797 	     -1 to indicate GD and -2 to indicate LD.  */
5798 	  if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5799 	    ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5800 	  else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5801 	    ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5802 	  goto dodyn;
5803 
5804 	case R_PPC64_TPREL16:
5805 	case R_PPC64_TPREL16_LO:
5806 	case R_PPC64_TPREL16_HI:
5807 	case R_PPC64_TPREL16_HA:
5808 	case R_PPC64_TPREL16_DS:
5809 	case R_PPC64_TPREL16_LO_DS:
5810 	case R_PPC64_TPREL16_HIGH:
5811 	case R_PPC64_TPREL16_HIGHA:
5812 	case R_PPC64_TPREL16_HIGHER:
5813 	case R_PPC64_TPREL16_HIGHERA:
5814 	case R_PPC64_TPREL16_HIGHEST:
5815 	case R_PPC64_TPREL16_HIGHESTA:
5816 	  if (bfd_link_pic (info))
5817 	    {
5818 	      info->flags |= DF_STATIC_TLS;
5819 	      goto dodyn;
5820 	    }
5821 	  break;
5822 
5823 	case R_PPC64_ADDR64:
5824 	  if (opd_sym_map != NULL
5825 	      && rel + 1 < rel_end
5826 	      && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5827 	    {
5828 	      if (h != NULL)
5829 		((struct ppc_link_hash_entry *) h)->is_func = 1;
5830 	      else
5831 		{
5832 		  asection *s;
5833 		  Elf_Internal_Sym *isym;
5834 
5835 		  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5836 						abfd, r_symndx);
5837 		  if (isym == NULL)
5838 		    return FALSE;
5839 
5840 		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5841 		  if (s != NULL && s != sec)
5842 		    opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5843 		}
5844 	    }
5845 	  /* Fall through.  */
5846 
5847 	case R_PPC64_ADDR16:
5848 	case R_PPC64_ADDR16_DS:
5849 	case R_PPC64_ADDR16_HA:
5850 	case R_PPC64_ADDR16_HI:
5851 	case R_PPC64_ADDR16_HIGH:
5852 	case R_PPC64_ADDR16_HIGHA:
5853 	case R_PPC64_ADDR16_HIGHER:
5854 	case R_PPC64_ADDR16_HIGHERA:
5855 	case R_PPC64_ADDR16_HIGHEST:
5856 	case R_PPC64_ADDR16_HIGHESTA:
5857 	case R_PPC64_ADDR16_LO:
5858 	case R_PPC64_ADDR16_LO_DS:
5859 	  if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5860 	      && rel->r_addend == 0)
5861 	    {
5862 	      /* We may need a .plt entry if this reloc refers to a
5863 		 function in a shared lib.  */
5864 	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5865 		return FALSE;
5866 	      h->pointer_equality_needed = 1;
5867 	    }
5868 	  /* Fall through.  */
5869 
5870 	case R_PPC64_REL30:
5871 	case R_PPC64_REL32:
5872 	case R_PPC64_REL64:
5873 	case R_PPC64_ADDR32:
5874 	case R_PPC64_UADDR16:
5875 	case R_PPC64_UADDR32:
5876 	case R_PPC64_UADDR64:
5877 	case R_PPC64_TOC:
5878 	  if (h != NULL && !bfd_link_pic (info))
5879 	    /* We may need a copy reloc.  */
5880 	    h->non_got_ref = 1;
5881 
5882 	  /* Don't propagate .opd relocs.  */
5883 	  if (NO_OPD_RELOCS && opd_sym_map != NULL)
5884 	    break;
5885 
5886 	  /* If we are creating a shared library, and this is a reloc
5887 	     against a global symbol, or a non PC relative reloc
5888 	     against a local symbol, then we need to copy the reloc
5889 	     into the shared library.  However, if we are linking with
5890 	     -Bsymbolic, we do not need to copy a reloc against a
5891 	     global symbol which is defined in an object we are
5892 	     including in the link (i.e., DEF_REGULAR is set).  At
5893 	     this point we have not seen all the input files, so it is
5894 	     possible that DEF_REGULAR is not set now but will be set
5895 	     later (it is never cleared).  In case of a weak definition,
5896 	     DEF_REGULAR may be cleared later by a strong definition in
5897 	     a shared library.  We account for that possibility below by
5898 	     storing information in the dyn_relocs field of the hash
5899 	     table entry.  A similar situation occurs when creating
5900 	     shared libraries and symbol visibility changes render the
5901 	     symbol local.
5902 
5903 	     If on the other hand, we are creating an executable, we
5904 	     may need to keep relocations for symbols satisfied by a
5905 	     dynamic library if we manage to avoid copy relocs for the
5906 	     symbol.  */
5907 	dodyn:
5908 	  if ((bfd_link_pic (info)
5909 	       && (must_be_dyn_reloc (info, r_type)
5910 		   || (h != NULL
5911 		       && (!SYMBOLIC_BIND (info, h)
5912 			   || h->root.type == bfd_link_hash_defweak
5913 			   || !h->def_regular))))
5914 	      || (ELIMINATE_COPY_RELOCS
5915 		  && !bfd_link_pic (info)
5916 		  && h != NULL
5917 		  && (h->root.type == bfd_link_hash_defweak
5918 		      || !h->def_regular))
5919 	      || (!bfd_link_pic (info)
5920 		  && ifunc != NULL))
5921 	    {
5922 	      /* We must copy these reloc types into the output file.
5923 		 Create a reloc section in dynobj and make room for
5924 		 this reloc.  */
5925 	      if (sreloc == NULL)
5926 		{
5927 		  sreloc = _bfd_elf_make_dynamic_reloc_section
5928 		    (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5929 
5930 		  if (sreloc == NULL)
5931 		    return FALSE;
5932 		}
5933 
5934 	      /* If this is a global symbol, we count the number of
5935 		 relocations we need for this symbol.  */
5936 	      if (h != NULL)
5937 		{
5938 		  struct elf_dyn_relocs *p;
5939 		  struct elf_dyn_relocs **head;
5940 
5941 		  head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5942 		  p = *head;
5943 		  if (p == NULL || p->sec != sec)
5944 		    {
5945 		      p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5946 		      if (p == NULL)
5947 			return FALSE;
5948 		      p->next = *head;
5949 		      *head = p;
5950 		      p->sec = sec;
5951 		      p->count = 0;
5952 		      p->pc_count = 0;
5953 		    }
5954 		  p->count += 1;
5955 		  if (!must_be_dyn_reloc (info, r_type))
5956 		    p->pc_count += 1;
5957 		}
5958 	      else
5959 		{
5960 		  /* Track dynamic relocs needed for local syms too.
5961 		     We really need local syms available to do this
5962 		     easily.  Oh well.  */
5963 		  struct ppc_dyn_relocs *p;
5964 		  struct ppc_dyn_relocs **head;
5965 		  bfd_boolean is_ifunc;
5966 		  asection *s;
5967 		  void *vpp;
5968 		  Elf_Internal_Sym *isym;
5969 
5970 		  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5971 						abfd, r_symndx);
5972 		  if (isym == NULL)
5973 		    return FALSE;
5974 
5975 		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5976 		  if (s == NULL)
5977 		    s = sec;
5978 
5979 		  vpp = &elf_section_data (s)->local_dynrel;
5980 		  head = (struct ppc_dyn_relocs **) vpp;
5981 		  is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5982 		  p = *head;
5983 		  if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5984 		    p = p->next;
5985 		  if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5986 		    {
5987 		      p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5988 		      if (p == NULL)
5989 			return FALSE;
5990 		      p->next = *head;
5991 		      *head = p;
5992 		      p->sec = sec;
5993 		      p->ifunc = is_ifunc;
5994 		      p->count = 0;
5995 		    }
5996 		  p->count += 1;
5997 		}
5998 	    }
5999 	  break;
6000 
6001 	default:
6002 	  break;
6003 	}
6004     }
6005 
6006   return TRUE;
6007 }
6008 
6009 /* Merge backend specific data from an object file to the output
6010    object file when linking.  */
6011 
6012 static bfd_boolean
6013 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6014 {
6015   bfd *obfd = info->output_bfd;
6016   unsigned long iflags, oflags;
6017 
6018   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6019     return TRUE;
6020 
6021   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6022     return TRUE;
6023 
6024   if (!_bfd_generic_verify_endian_match (ibfd, info))
6025     return FALSE;
6026 
6027   iflags = elf_elfheader (ibfd)->e_flags;
6028   oflags = elf_elfheader (obfd)->e_flags;
6029 
6030   if (iflags & ~EF_PPC64_ABI)
6031     {
6032       _bfd_error_handler
6033 	/* xgettext:c-format */
6034 	(_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6035       bfd_set_error (bfd_error_bad_value);
6036       return FALSE;
6037     }
6038   else if (iflags != oflags && iflags != 0)
6039     {
6040       _bfd_error_handler
6041 	/* xgettext:c-format */
6042 	(_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6043 	 ibfd, iflags, oflags);
6044       bfd_set_error (bfd_error_bad_value);
6045       return FALSE;
6046     }
6047 
6048   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6049 
6050   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6051   _bfd_elf_merge_object_attributes (ibfd, info);
6052 
6053   return TRUE;
6054 }
6055 
6056 static bfd_boolean
6057 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6058 {
6059   /* Print normal ELF private data.  */
6060   _bfd_elf_print_private_bfd_data (abfd, ptr);
6061 
6062   if (elf_elfheader (abfd)->e_flags != 0)
6063     {
6064       FILE *file = ptr;
6065 
6066       fprintf (file, _("private flags = 0x%lx:"),
6067 	       elf_elfheader (abfd)->e_flags);
6068 
6069       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6070 	fprintf (file, _(" [abiv%ld]"),
6071 		 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6072       fputc ('\n', file);
6073     }
6074 
6075   return TRUE;
6076 }
6077 
6078 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6079    of the code entry point, and its section, which must be in the same
6080    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6081 
6082 static bfd_vma
6083 opd_entry_value (asection *opd_sec,
6084 		 bfd_vma offset,
6085 		 asection **code_sec,
6086 		 bfd_vma *code_off,
6087 		 bfd_boolean in_code_sec)
6088 {
6089   bfd *opd_bfd = opd_sec->owner;
6090   Elf_Internal_Rela *relocs;
6091   Elf_Internal_Rela *lo, *hi, *look;
6092   bfd_vma val;
6093 
6094   /* No relocs implies we are linking a --just-symbols object, or looking
6095      at a final linked executable with addr2line or somesuch.  */
6096   if (opd_sec->reloc_count == 0)
6097     {
6098       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6099 
6100       if (contents == NULL)
6101 	{
6102 	  if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6103 	    return (bfd_vma) -1;
6104 	  ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6105 	}
6106 
6107       /* PR 17512: file: 64b9dfbb.  */
6108       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6109 	return (bfd_vma) -1;
6110 
6111       val = bfd_get_64 (opd_bfd, contents + offset);
6112       if (code_sec != NULL)
6113 	{
6114 	  asection *sec, *likely = NULL;
6115 
6116 	  if (in_code_sec)
6117 	    {
6118 	      sec = *code_sec;
6119 	      if (sec->vma <= val
6120 		  && val < sec->vma + sec->size)
6121 		likely = sec;
6122 	      else
6123 		val = -1;
6124 	    }
6125 	  else
6126 	    for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6127 	      if (sec->vma <= val
6128 		  && (sec->flags & SEC_LOAD) != 0
6129 		  && (sec->flags & SEC_ALLOC) != 0)
6130 		likely = sec;
6131 	  if (likely != NULL)
6132 	    {
6133 	      *code_sec = likely;
6134 	      if (code_off != NULL)
6135 		*code_off = val - likely->vma;
6136 	    }
6137 	}
6138       return val;
6139     }
6140 
6141   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6142 
6143   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6144   if (relocs == NULL)
6145     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6146   /* PR 17512: file: df8e1fd6.  */
6147   if (relocs == NULL)
6148     return (bfd_vma) -1;
6149 
6150   /* Go find the opd reloc at the sym address.  */
6151   lo = relocs;
6152   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6153   val = (bfd_vma) -1;
6154   while (lo < hi)
6155     {
6156       look = lo + (hi - lo) / 2;
6157       if (look->r_offset < offset)
6158 	lo = look + 1;
6159       else if (look->r_offset > offset)
6160 	hi = look;
6161       else
6162 	{
6163 	  Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6164 
6165 	  if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6166 	      && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6167 	    {
6168 	      unsigned long symndx = ELF64_R_SYM (look->r_info);
6169 	      asection *sec = NULL;
6170 
6171 	      if (symndx >= symtab_hdr->sh_info
6172 		  && elf_sym_hashes (opd_bfd) != NULL)
6173 		{
6174 		  struct elf_link_hash_entry **sym_hashes;
6175 		  struct elf_link_hash_entry *rh;
6176 
6177 		  sym_hashes = elf_sym_hashes (opd_bfd);
6178 		  rh = sym_hashes[symndx - symtab_hdr->sh_info];
6179 		  if (rh != NULL)
6180 		    {
6181 		      rh = elf_follow_link (rh);
6182 		      if (rh->root.type != bfd_link_hash_defined
6183 			  && rh->root.type != bfd_link_hash_defweak)
6184 			break;
6185 		      if (rh->root.u.def.section->owner == opd_bfd)
6186 			{
6187 			  val = rh->root.u.def.value;
6188 			  sec = rh->root.u.def.section;
6189 			}
6190 		    }
6191 		}
6192 
6193 	      if (sec == NULL)
6194 		{
6195 		  Elf_Internal_Sym *sym;
6196 
6197 		  if (symndx < symtab_hdr->sh_info)
6198 		    {
6199 		      sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6200 		      if (sym == NULL)
6201 			{
6202 			  size_t symcnt = symtab_hdr->sh_info;
6203 			  sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6204 						      symcnt, 0,
6205 						      NULL, NULL, NULL);
6206 			  if (sym == NULL)
6207 			    break;
6208 			  symtab_hdr->contents = (bfd_byte *) sym;
6209 			}
6210 		      sym += symndx;
6211 		    }
6212 		  else
6213 		    {
6214 		      sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6215 						  1, symndx,
6216 						  NULL, NULL, NULL);
6217 		      if (sym == NULL)
6218 			break;
6219 		    }
6220 		  sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6221 		  if (sec == NULL)
6222 		    break;
6223 		  BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6224 		  val = sym->st_value;
6225 		}
6226 
6227 	      val += look->r_addend;
6228 	      if (code_off != NULL)
6229 		*code_off = val;
6230 	      if (code_sec != NULL)
6231 		{
6232 		  if (in_code_sec && *code_sec != sec)
6233 		    return -1;
6234 		  else
6235 		    *code_sec = sec;
6236 		}
6237 	      if (sec->output_section != NULL)
6238 		val += sec->output_section->vma + sec->output_offset;
6239 	    }
6240 	  break;
6241 	}
6242     }
6243 
6244   return val;
6245 }
6246 
6247 /* If the ELF symbol SYM might be a function in SEC, return the
6248    function size and set *CODE_OFF to the function's entry point,
6249    otherwise return zero.  */
6250 
6251 static bfd_size_type
6252 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6253 			      bfd_vma *code_off)
6254 {
6255   bfd_size_type size;
6256 
6257   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6258 		     | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6259     return 0;
6260 
6261   size = 0;
6262   if (!(sym->flags & BSF_SYNTHETIC))
6263     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6264 
6265   if (strcmp (sym->section->name, ".opd") == 0)
6266     {
6267       struct _opd_sec_data *opd = get_opd_info (sym->section);
6268       bfd_vma symval = sym->value;
6269 
6270       if (opd != NULL
6271 	  && opd->adjust != NULL
6272 	  && elf_section_data (sym->section)->relocs != NULL)
6273 	{
6274 	  /* opd_entry_value will use cached relocs that have been
6275 	     adjusted, but with raw symbols.  That means both local
6276 	     and global symbols need adjusting.  */
6277 	  long adjust = opd->adjust[OPD_NDX (symval)];
6278 	  if (adjust == -1)
6279 	    return 0;
6280 	  symval += adjust;
6281 	}
6282 
6283       if (opd_entry_value (sym->section, symval,
6284 			   &sec, code_off, TRUE) == (bfd_vma) -1)
6285 	return 0;
6286       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6287 	 symbol.  This size has nothing to do with the code size of the
6288 	 function, which is what we're supposed to return, but the
6289 	 code size isn't available without looking up the dot-sym.
6290 	 However, doing that would be a waste of time particularly
6291 	 since elf_find_function will look at the dot-sym anyway.
6292 	 Now, elf_find_function will keep the largest size of any
6293 	 function sym found at the code address of interest, so return
6294 	 1 here to avoid it incorrectly caching a larger function size
6295 	 for a small function.  This does mean we return the wrong
6296 	 size for a new-ABI function of size 24, but all that does is
6297 	 disable caching for such functions.  */
6298       if (size == 24)
6299 	size = 1;
6300     }
6301   else
6302     {
6303       if (sym->section != sec)
6304 	return 0;
6305       *code_off = sym->value;
6306     }
6307   if (size == 0)
6308     size = 1;
6309   return size;
6310 }
6311 
6312 /* Return true if symbol is defined in a regular object file.  */
6313 
6314 static bfd_boolean
6315 is_static_defined (struct elf_link_hash_entry *h)
6316 {
6317   return ((h->root.type == bfd_link_hash_defined
6318 	   || h->root.type == bfd_link_hash_defweak)
6319 	  && h->root.u.def.section != NULL
6320 	  && h->root.u.def.section->output_section != NULL);
6321 }
6322 
6323 /* If FDH is a function descriptor symbol, return the associated code
6324    entry symbol if it is defined.  Return NULL otherwise.  */
6325 
6326 static struct ppc_link_hash_entry *
6327 defined_code_entry (struct ppc_link_hash_entry *fdh)
6328 {
6329   if (fdh->is_func_descriptor)
6330     {
6331       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6332       if (fh->elf.root.type == bfd_link_hash_defined
6333 	  || fh->elf.root.type == bfd_link_hash_defweak)
6334 	return fh;
6335     }
6336   return NULL;
6337 }
6338 
6339 /* If FH is a function code entry symbol, return the associated
6340    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6341 
6342 static struct ppc_link_hash_entry *
6343 defined_func_desc (struct ppc_link_hash_entry *fh)
6344 {
6345   if (fh->oh != NULL
6346       && fh->oh->is_func_descriptor)
6347     {
6348       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6349       if (fdh->elf.root.type == bfd_link_hash_defined
6350 	  || fdh->elf.root.type == bfd_link_hash_defweak)
6351 	return fdh;
6352     }
6353   return NULL;
6354 }
6355 
6356 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6357 
6358 /* Garbage collect sections, after first dealing with dot-symbols.  */
6359 
6360 static bfd_boolean
6361 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6362 {
6363   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6364 
6365   if (htab != NULL && htab->need_func_desc_adj)
6366     {
6367       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6368       htab->need_func_desc_adj = 0;
6369     }
6370   return bfd_elf_gc_sections (abfd, info);
6371 }
6372 
6373 /* Mark all our entry sym sections, both opd and code section.  */
6374 
6375 static void
6376 ppc64_elf_gc_keep (struct bfd_link_info *info)
6377 {
6378   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6379   struct bfd_sym_chain *sym;
6380 
6381   if (htab == NULL)
6382     return;
6383 
6384   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6385     {
6386       struct ppc_link_hash_entry *eh, *fh;
6387       asection *sec;
6388 
6389       eh = (struct ppc_link_hash_entry *)
6390 	elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6391       if (eh == NULL)
6392 	continue;
6393       if (eh->elf.root.type != bfd_link_hash_defined
6394 	  && eh->elf.root.type != bfd_link_hash_defweak)
6395 	continue;
6396 
6397       fh = defined_code_entry (eh);
6398       if (fh != NULL)
6399 	{
6400 	  sec = fh->elf.root.u.def.section;
6401 	  sec->flags |= SEC_KEEP;
6402 	}
6403       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6404 	       && opd_entry_value (eh->elf.root.u.def.section,
6405 				   eh->elf.root.u.def.value,
6406 				   &sec, NULL, FALSE) != (bfd_vma) -1)
6407 	sec->flags |= SEC_KEEP;
6408 
6409       sec = eh->elf.root.u.def.section;
6410       sec->flags |= SEC_KEEP;
6411     }
6412 }
6413 
6414 /* Mark sections containing dynamically referenced symbols.  When
6415    building shared libraries, we must assume that any visible symbol is
6416    referenced.  */
6417 
6418 static bfd_boolean
6419 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6420 {
6421   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6422   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6423   struct ppc_link_hash_entry *fdh;
6424   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6425 
6426   /* Dynamic linking info is on the func descriptor sym.  */
6427   fdh = defined_func_desc (eh);
6428   if (fdh != NULL)
6429     eh = fdh;
6430 
6431   if ((eh->elf.root.type == bfd_link_hash_defined
6432        || eh->elf.root.type == bfd_link_hash_defweak)
6433       && (eh->elf.ref_dynamic
6434 	  || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6435 	      && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6436 	      && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6437 	      && (!bfd_link_executable (info)
6438 		  || info->gc_keep_exported
6439 		  || info->export_dynamic
6440 		  || (eh->elf.dynamic
6441 		      && d != NULL
6442 		      && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6443 	      && (eh->elf.versioned >= versioned
6444 		  || !bfd_hide_sym_by_version (info->version_info,
6445 					       eh->elf.root.root.string)))))
6446     {
6447       asection *code_sec;
6448       struct ppc_link_hash_entry *fh;
6449 
6450       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6451 
6452       /* Function descriptor syms cause the associated
6453 	 function code sym section to be marked.  */
6454       fh = defined_code_entry (eh);
6455       if (fh != NULL)
6456 	{
6457 	  code_sec = fh->elf.root.u.def.section;
6458 	  code_sec->flags |= SEC_KEEP;
6459 	}
6460       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6461 	       && opd_entry_value (eh->elf.root.u.def.section,
6462 				   eh->elf.root.u.def.value,
6463 				   &code_sec, NULL, FALSE) != (bfd_vma) -1)
6464 	code_sec->flags |= SEC_KEEP;
6465     }
6466 
6467   return TRUE;
6468 }
6469 
6470 /* Return the section that should be marked against GC for a given
6471    relocation.  */
6472 
6473 static asection *
6474 ppc64_elf_gc_mark_hook (asection *sec,
6475 			struct bfd_link_info *info,
6476 			Elf_Internal_Rela *rel,
6477 			struct elf_link_hash_entry *h,
6478 			Elf_Internal_Sym *sym)
6479 {
6480   asection *rsec;
6481 
6482   /* Syms return NULL if we're marking .opd, so we avoid marking all
6483      function sections, as all functions are referenced in .opd.  */
6484   rsec = NULL;
6485   if (get_opd_info (sec) != NULL)
6486     return rsec;
6487 
6488   if (h != NULL)
6489     {
6490       enum elf_ppc64_reloc_type r_type;
6491       struct ppc_link_hash_entry *eh, *fh, *fdh;
6492 
6493       r_type = ELF64_R_TYPE (rel->r_info);
6494       switch (r_type)
6495 	{
6496 	case R_PPC64_GNU_VTINHERIT:
6497 	case R_PPC64_GNU_VTENTRY:
6498 	  break;
6499 
6500 	default:
6501 	  switch (h->root.type)
6502 	    {
6503 	    case bfd_link_hash_defined:
6504 	    case bfd_link_hash_defweak:
6505 	      eh = (struct ppc_link_hash_entry *) h;
6506 	      fdh = defined_func_desc (eh);
6507 	      if (fdh != NULL)
6508 		{
6509 		  /* -mcall-aixdesc code references the dot-symbol on
6510 		     a call reloc.  Mark the function descriptor too
6511 		     against garbage collection.  */
6512 		  fdh->elf.mark = 1;
6513 		  if (fdh->elf.u.weakdef != NULL)
6514 		    fdh->elf.u.weakdef->mark = 1;
6515 		  eh = fdh;
6516 		}
6517 
6518 	      /* Function descriptor syms cause the associated
6519 		 function code sym section to be marked.  */
6520 	      fh = defined_code_entry (eh);
6521 	      if (fh != NULL)
6522 		{
6523 		  /* They also mark their opd section.  */
6524 		  eh->elf.root.u.def.section->gc_mark = 1;
6525 
6526 		  rsec = fh->elf.root.u.def.section;
6527 		}
6528 	      else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6529 		       && opd_entry_value (eh->elf.root.u.def.section,
6530 					   eh->elf.root.u.def.value,
6531 					   &rsec, NULL, FALSE) != (bfd_vma) -1)
6532 		eh->elf.root.u.def.section->gc_mark = 1;
6533 	      else
6534 		rsec = h->root.u.def.section;
6535 	      break;
6536 
6537 	    case bfd_link_hash_common:
6538 	      rsec = h->root.u.c.p->section;
6539 	      break;
6540 
6541 	    default:
6542 	      return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6543 	    }
6544 	}
6545     }
6546   else
6547     {
6548       struct _opd_sec_data *opd;
6549 
6550       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6551       opd = get_opd_info (rsec);
6552       if (opd != NULL && opd->func_sec != NULL)
6553 	{
6554 	  rsec->gc_mark = 1;
6555 
6556 	  rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6557 	}
6558     }
6559 
6560   return rsec;
6561 }
6562 
6563 /* Update the .got, .plt. and dynamic reloc reference counts for the
6564    section being removed.  */
6565 
6566 static bfd_boolean
6567 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6568 			 asection *sec, const Elf_Internal_Rela *relocs)
6569 {
6570   struct ppc_link_hash_table *htab;
6571   Elf_Internal_Shdr *symtab_hdr;
6572   struct elf_link_hash_entry **sym_hashes;
6573   struct got_entry **local_got_ents;
6574   const Elf_Internal_Rela *rel, *relend;
6575 
6576   if (bfd_link_relocatable (info))
6577     return TRUE;
6578 
6579   if ((sec->flags & SEC_ALLOC) == 0)
6580     return TRUE;
6581 
6582   elf_section_data (sec)->local_dynrel = NULL;
6583 
6584   htab = ppc_hash_table (info);
6585   if (htab == NULL)
6586     return FALSE;
6587 
6588   symtab_hdr = &elf_symtab_hdr (abfd);
6589   sym_hashes = elf_sym_hashes (abfd);
6590   local_got_ents = elf_local_got_ents (abfd);
6591 
6592   relend = relocs + sec->reloc_count;
6593   for (rel = relocs; rel < relend; rel++)
6594     {
6595       unsigned long r_symndx;
6596       enum elf_ppc64_reloc_type r_type;
6597       struct elf_link_hash_entry *h = NULL;
6598       struct plt_entry **plt_list = NULL;
6599       unsigned char tls_type = 0;
6600 
6601       r_symndx = ELF64_R_SYM (rel->r_info);
6602       r_type = ELF64_R_TYPE (rel->r_info);
6603       if (r_symndx >= symtab_hdr->sh_info)
6604 	{
6605 	  struct ppc_link_hash_entry *eh;
6606 	  struct elf_dyn_relocs **pp;
6607 	  struct elf_dyn_relocs *p;
6608 
6609 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6610 	  h = elf_follow_link (h);
6611 	  eh = (struct ppc_link_hash_entry *) h;
6612 
6613 	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6614 	    if (p->sec == sec)
6615 	      {
6616 		/* Everything must go for SEC.  */
6617 		*pp = p->next;
6618 		break;
6619 	      }
6620 	}
6621 
6622       switch (r_type)
6623 	{
6624 	case R_PPC64_GOT_TLSLD16:
6625 	case R_PPC64_GOT_TLSLD16_LO:
6626 	case R_PPC64_GOT_TLSLD16_HI:
6627 	case R_PPC64_GOT_TLSLD16_HA:
6628 	  tls_type = TLS_TLS | TLS_LD;
6629 	  goto dogot;
6630 
6631 	case R_PPC64_GOT_TLSGD16:
6632 	case R_PPC64_GOT_TLSGD16_LO:
6633 	case R_PPC64_GOT_TLSGD16_HI:
6634 	case R_PPC64_GOT_TLSGD16_HA:
6635 	  tls_type = TLS_TLS | TLS_GD;
6636 	  goto dogot;
6637 
6638 	case R_PPC64_GOT_TPREL16_DS:
6639 	case R_PPC64_GOT_TPREL16_LO_DS:
6640 	case R_PPC64_GOT_TPREL16_HI:
6641 	case R_PPC64_GOT_TPREL16_HA:
6642 	  tls_type = TLS_TLS | TLS_TPREL;
6643 	  goto dogot;
6644 
6645 	case R_PPC64_GOT_DTPREL16_DS:
6646 	case R_PPC64_GOT_DTPREL16_LO_DS:
6647 	case R_PPC64_GOT_DTPREL16_HI:
6648 	case R_PPC64_GOT_DTPREL16_HA:
6649 	  tls_type = TLS_TLS | TLS_DTPREL;
6650 	  goto dogot;
6651 
6652 	case R_PPC64_GOT16:
6653 	case R_PPC64_GOT16_DS:
6654 	case R_PPC64_GOT16_HA:
6655 	case R_PPC64_GOT16_HI:
6656 	case R_PPC64_GOT16_LO:
6657 	case R_PPC64_GOT16_LO_DS:
6658 	dogot:
6659 	  {
6660 	    struct got_entry *ent;
6661 
6662 	    if (h != NULL)
6663 	      ent = h->got.glist;
6664 	    else
6665 	      ent = local_got_ents[r_symndx];
6666 
6667 	    for (; ent != NULL; ent = ent->next)
6668 	      if (ent->addend == rel->r_addend
6669 		  && ent->owner == abfd
6670 		  && ent->tls_type == tls_type)
6671 		break;
6672 	    if (ent == NULL)
6673 	      abort ();
6674 	    if (ent->got.refcount > 0)
6675 	      ent->got.refcount -= 1;
6676 	  }
6677 	  if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6678 	    plt_list = &h->plt.plist;
6679 	  break;
6680 
6681 	case R_PPC64_PLT16_HA:
6682 	case R_PPC64_PLT16_HI:
6683 	case R_PPC64_PLT16_LO:
6684 	case R_PPC64_PLT32:
6685 	case R_PPC64_PLT64:
6686 	case R_PPC64_REL14:
6687 	case R_PPC64_REL14_BRNTAKEN:
6688 	case R_PPC64_REL14_BRTAKEN:
6689 	case R_PPC64_REL24:
6690 	  if (h != NULL)
6691 	    plt_list = &h->plt.plist;
6692 	  else if (local_got_ents != NULL)
6693 	    {
6694 	      struct plt_entry **local_plt = (struct plt_entry **)
6695 		(local_got_ents + symtab_hdr->sh_info);
6696 	      unsigned char *local_got_tls_masks = (unsigned char *)
6697 		(local_plt + symtab_hdr->sh_info);
6698 	      if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6699 		plt_list = local_plt + r_symndx;
6700 	    }
6701 	  break;
6702 
6703 	case R_PPC64_ADDR64:
6704 	case R_PPC64_ADDR16:
6705 	case R_PPC64_ADDR16_DS:
6706 	case R_PPC64_ADDR16_HA:
6707 	case R_PPC64_ADDR16_HI:
6708 	case R_PPC64_ADDR16_HIGH:
6709 	case R_PPC64_ADDR16_HIGHA:
6710 	case R_PPC64_ADDR16_HIGHER:
6711 	case R_PPC64_ADDR16_HIGHERA:
6712 	case R_PPC64_ADDR16_HIGHEST:
6713 	case R_PPC64_ADDR16_HIGHESTA:
6714 	case R_PPC64_ADDR16_LO:
6715 	case R_PPC64_ADDR16_LO_DS:
6716 	  if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6717 	      && rel->r_addend == 0)
6718 	    plt_list = &h->plt.plist;
6719 	  break;
6720 
6721 	default:
6722 	  break;
6723 	}
6724       if (plt_list != NULL)
6725 	{
6726 	  struct plt_entry *ent;
6727 
6728 	  for (ent = *plt_list; ent != NULL; ent = ent->next)
6729 	    if (ent->addend == rel->r_addend)
6730 	      break;
6731 	  if (ent != NULL && ent->plt.refcount > 0)
6732 	    ent->plt.refcount -= 1;
6733 	}
6734     }
6735   return TRUE;
6736 }
6737 
6738 /* The maximum size of .sfpr.  */
6739 #define SFPR_MAX (218*4)
6740 
6741 struct sfpr_def_parms
6742 {
6743   const char name[12];
6744   unsigned char lo, hi;
6745   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6746   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6747 };
6748 
6749 /* Auto-generate _save*, _rest* functions in .sfpr.
6750    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6751    instead.  */
6752 
6753 static bfd_boolean
6754 sfpr_define (struct bfd_link_info *info,
6755 	     const struct sfpr_def_parms *parm,
6756 	     asection *stub_sec)
6757 {
6758   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6759   unsigned int i;
6760   size_t len = strlen (parm->name);
6761   bfd_boolean writing = FALSE;
6762   char sym[16];
6763 
6764   if (htab == NULL)
6765     return FALSE;
6766 
6767   memcpy (sym, parm->name, len);
6768   sym[len + 2] = 0;
6769 
6770   for (i = parm->lo; i <= parm->hi; i++)
6771     {
6772       struct ppc_link_hash_entry *h;
6773 
6774       sym[len + 0] = i / 10 + '0';
6775       sym[len + 1] = i % 10 + '0';
6776       h = (struct ppc_link_hash_entry *)
6777 	elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6778       if (stub_sec != NULL)
6779 	{
6780 	  if (h != NULL
6781 	      && h->elf.root.type == bfd_link_hash_defined
6782 	      && h->elf.root.u.def.section == htab->sfpr)
6783 	    {
6784 	      struct elf_link_hash_entry *s;
6785 	      char buf[32];
6786 	      sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6787 	      s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6788 	      if (s == NULL)
6789 		return FALSE;
6790 	      if (s->root.type == bfd_link_hash_new
6791 		  || (s->root.type = bfd_link_hash_defined
6792 		      && s->root.u.def.section == stub_sec))
6793 		{
6794 		  s->root.type = bfd_link_hash_defined;
6795 		  s->root.u.def.section = stub_sec;
6796 		  s->root.u.def.value = (stub_sec->size
6797 					 + h->elf.root.u.def.value);
6798 		  s->ref_regular = 1;
6799 		  s->def_regular = 1;
6800 		  s->ref_regular_nonweak = 1;
6801 		  s->forced_local = 1;
6802 		  s->non_elf = 0;
6803 		  s->root.linker_def = 1;
6804 		}
6805 	    }
6806 	  continue;
6807 	}
6808       if (h != NULL)
6809 	{
6810 	  h->save_res = 1;
6811 	  if (!h->elf.def_regular)
6812 	    {
6813 	      h->elf.root.type = bfd_link_hash_defined;
6814 	      h->elf.root.u.def.section = htab->sfpr;
6815 	      h->elf.root.u.def.value = htab->sfpr->size;
6816 	      h->elf.type = STT_FUNC;
6817 	      h->elf.def_regular = 1;
6818 	      h->elf.non_elf = 0;
6819 	      _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6820 	      writing = TRUE;
6821 	      if (htab->sfpr->contents == NULL)
6822 		{
6823 		  htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6824 		  if (htab->sfpr->contents == NULL)
6825 		    return FALSE;
6826 		}
6827 	    }
6828 	}
6829       if (writing)
6830 	{
6831 	  bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6832 	  if (i != parm->hi)
6833 	    p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6834 	  else
6835 	    p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6836 	  htab->sfpr->size = p - htab->sfpr->contents;
6837 	}
6838     }
6839 
6840   return TRUE;
6841 }
6842 
6843 static bfd_byte *
6844 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6845 {
6846   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6847   return p + 4;
6848 }
6849 
6850 static bfd_byte *
6851 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6852 {
6853   p = savegpr0 (abfd, p, r);
6854   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6855   p = p + 4;
6856   bfd_put_32 (abfd, BLR, p);
6857   return p + 4;
6858 }
6859 
6860 static bfd_byte *
6861 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6862 {
6863   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6864   return p + 4;
6865 }
6866 
6867 static bfd_byte *
6868 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6869 {
6870   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6871   p = p + 4;
6872   p = restgpr0 (abfd, p, r);
6873   bfd_put_32 (abfd, MTLR_R0, p);
6874   p = p + 4;
6875   if (r == 29)
6876     {
6877       p = restgpr0 (abfd, p, 30);
6878       p = restgpr0 (abfd, p, 31);
6879     }
6880   bfd_put_32 (abfd, BLR, p);
6881   return p + 4;
6882 }
6883 
6884 static bfd_byte *
6885 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6886 {
6887   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6888   return p + 4;
6889 }
6890 
6891 static bfd_byte *
6892 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6893 {
6894   p = savegpr1 (abfd, p, r);
6895   bfd_put_32 (abfd, BLR, p);
6896   return p + 4;
6897 }
6898 
6899 static bfd_byte *
6900 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6901 {
6902   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6903   return p + 4;
6904 }
6905 
6906 static bfd_byte *
6907 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6908 {
6909   p = restgpr1 (abfd, p, r);
6910   bfd_put_32 (abfd, BLR, p);
6911   return p + 4;
6912 }
6913 
6914 static bfd_byte *
6915 savefpr (bfd *abfd, bfd_byte *p, int r)
6916 {
6917   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6918   return p + 4;
6919 }
6920 
6921 static bfd_byte *
6922 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6923 {
6924   p = savefpr (abfd, p, r);
6925   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6926   p = p + 4;
6927   bfd_put_32 (abfd, BLR, p);
6928   return p + 4;
6929 }
6930 
6931 static bfd_byte *
6932 restfpr (bfd *abfd, bfd_byte *p, int r)
6933 {
6934   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6935   return p + 4;
6936 }
6937 
6938 static bfd_byte *
6939 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6940 {
6941   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6942   p = p + 4;
6943   p = restfpr (abfd, p, r);
6944   bfd_put_32 (abfd, MTLR_R0, p);
6945   p = p + 4;
6946   if (r == 29)
6947     {
6948       p = restfpr (abfd, p, 30);
6949       p = restfpr (abfd, p, 31);
6950     }
6951   bfd_put_32 (abfd, BLR, p);
6952   return p + 4;
6953 }
6954 
6955 static bfd_byte *
6956 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6957 {
6958   p = savefpr (abfd, p, r);
6959   bfd_put_32 (abfd, BLR, p);
6960   return p + 4;
6961 }
6962 
6963 static bfd_byte *
6964 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6965 {
6966   p = restfpr (abfd, p, r);
6967   bfd_put_32 (abfd, BLR, p);
6968   return p + 4;
6969 }
6970 
6971 static bfd_byte *
6972 savevr (bfd *abfd, bfd_byte *p, int r)
6973 {
6974   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6975   p = p + 4;
6976   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6977   return p + 4;
6978 }
6979 
6980 static bfd_byte *
6981 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6982 {
6983   p = savevr (abfd, p, r);
6984   bfd_put_32 (abfd, BLR, p);
6985   return p + 4;
6986 }
6987 
6988 static bfd_byte *
6989 restvr (bfd *abfd, bfd_byte *p, int r)
6990 {
6991   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6992   p = p + 4;
6993   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6994   return p + 4;
6995 }
6996 
6997 static bfd_byte *
6998 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6999 {
7000   p = restvr (abfd, p, r);
7001   bfd_put_32 (abfd, BLR, p);
7002   return p + 4;
7003 }
7004 
7005 /* Called via elf_link_hash_traverse to transfer dynamic linking
7006    information on function code symbol entries to their corresponding
7007    function descriptor symbol entries.  */
7008 
7009 static bfd_boolean
7010 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7011 {
7012   struct bfd_link_info *info;
7013   struct ppc_link_hash_table *htab;
7014   struct ppc_link_hash_entry *fh;
7015   struct ppc_link_hash_entry *fdh;
7016   bfd_boolean force_local;
7017 
7018   fh = (struct ppc_link_hash_entry *) h;
7019   if (fh->elf.root.type == bfd_link_hash_indirect)
7020     return TRUE;
7021 
7022   if (!fh->is_func)
7023     return TRUE;
7024 
7025   if (fh->elf.root.root.string[0] != '.'
7026       || fh->elf.root.root.string[1] == '\0')
7027     return TRUE;
7028 
7029   info = inf;
7030   htab = ppc_hash_table (info);
7031   if (htab == NULL)
7032     return FALSE;
7033 
7034   /* Find the corresponding function descriptor symbol.  */
7035   fdh = lookup_fdh (fh, htab);
7036 
7037   /* Resolve undefined references to dot-symbols as the value
7038      in the function descriptor, if we have one in a regular object.
7039      This is to satisfy cases like ".quad .foo".  Calls to functions
7040      in dynamic objects are handled elsewhere.  */
7041   if ((fh->elf.root.type == bfd_link_hash_undefined
7042        || fh->elf.root.type == bfd_link_hash_undefweak)
7043       && (fdh->elf.root.type == bfd_link_hash_defined
7044 	  || fdh->elf.root.type == bfd_link_hash_defweak)
7045       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7046       && opd_entry_value (fdh->elf.root.u.def.section,
7047 			  fdh->elf.root.u.def.value,
7048 			  &fh->elf.root.u.def.section,
7049 			  &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7050     {
7051       fh->elf.root.type = fdh->elf.root.type;
7052       fh->elf.forced_local = 1;
7053       fh->elf.def_regular = fdh->elf.def_regular;
7054       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7055     }
7056 
7057   if (!fh->elf.dynamic)
7058     {
7059       struct plt_entry *ent;
7060 
7061       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7062 	if (ent->plt.refcount > 0)
7063 	  break;
7064       if (ent == NULL)
7065 	return TRUE;
7066     }
7067 
7068   /* Create a descriptor as undefined if necessary.  */
7069   if (fdh == NULL
7070       && !bfd_link_executable (info)
7071       && (fh->elf.root.type == bfd_link_hash_undefined
7072 	  || fh->elf.root.type == bfd_link_hash_undefweak))
7073     {
7074       fdh = make_fdh (info, fh);
7075       if (fdh == NULL)
7076 	return FALSE;
7077     }
7078 
7079   /* We can't support overriding of symbols on a fake descriptor.  */
7080   if (fdh != NULL
7081       && fdh->fake
7082       && (fh->elf.root.type == bfd_link_hash_defined
7083 	  || fh->elf.root.type == bfd_link_hash_defweak))
7084     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7085 
7086   /* Transfer dynamic linking information to the function descriptor.  */
7087   if (fdh != NULL)
7088     {
7089       fdh->elf.ref_regular |= fh->elf.ref_regular;
7090       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7091       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7092       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7093       fdh->elf.dynamic |= fh->elf.dynamic;
7094       fdh->elf.needs_plt |= (fh->elf.needs_plt
7095 			     || fh->elf.type == STT_FUNC
7096 			     || fh->elf.type == STT_GNU_IFUNC);
7097       move_plt_plist (fh, fdh);
7098 
7099       if (!fdh->elf.forced_local
7100 	  && fh->elf.dynindx != -1)
7101 	if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7102 	  return FALSE;
7103     }
7104 
7105   /* Now that the info is on the function descriptor, clear the
7106      function code sym info.  Any function code syms for which we
7107      don't have a definition in a regular file, we force local.
7108      This prevents a shared library from exporting syms that have
7109      been imported from another library.  Function code syms that
7110      are really in the library we must leave global to prevent the
7111      linker dragging in a definition from a static library.  */
7112   force_local = (!fh->elf.def_regular
7113 		 || fdh == NULL
7114 		 || !fdh->elf.def_regular
7115 		 || fdh->elf.forced_local);
7116   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7117 
7118   return TRUE;
7119 }
7120 
7121 static const struct sfpr_def_parms save_res_funcs[] =
7122   {
7123     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7124     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7125     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7126     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7127     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7128     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7129     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7130     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7131     { "._savef", 14, 31, savefpr, savefpr1_tail },
7132     { "._restf", 14, 31, restfpr, restfpr1_tail },
7133     { "_savevr_", 20, 31, savevr, savevr_tail },
7134     { "_restvr_", 20, 31, restvr, restvr_tail }
7135   };
7136 
7137 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7138    this hook to a) provide some gcc support functions, and b) transfer
7139    dynamic linking information gathered so far on function code symbol
7140    entries, to their corresponding function descriptor symbol entries.  */
7141 
7142 static bfd_boolean
7143 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7144 			    struct bfd_link_info *info)
7145 {
7146   struct ppc_link_hash_table *htab;
7147 
7148   htab = ppc_hash_table (info);
7149   if (htab == NULL)
7150     return FALSE;
7151 
7152   /* Provide any missing _save* and _rest* functions.  */
7153   if (htab->sfpr != NULL)
7154     {
7155       unsigned int i;
7156 
7157       htab->sfpr->size = 0;
7158       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7159 	if (!sfpr_define (info, &save_res_funcs[i], NULL))
7160 	  return FALSE;
7161       if (htab->sfpr->size == 0)
7162 	htab->sfpr->flags |= SEC_EXCLUDE;
7163     }
7164 
7165   if (bfd_link_relocatable (info))
7166     return TRUE;
7167 
7168   if (htab->elf.hgot != NULL)
7169     {
7170       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7171       /* Make .TOC. defined so as to prevent it being made dynamic.
7172 	 The wrong value here is fixed later in ppc64_elf_set_toc.  */
7173       if (!htab->elf.hgot->def_regular
7174 	  || htab->elf.hgot->root.type != bfd_link_hash_defined)
7175 	{
7176 	  htab->elf.hgot->root.type = bfd_link_hash_defined;
7177 	  htab->elf.hgot->root.u.def.value = 0;
7178 	  htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7179 	  htab->elf.hgot->def_regular = 1;
7180 	  htab->elf.hgot->root.linker_def = 1;
7181 	}
7182       htab->elf.hgot->type = STT_OBJECT;
7183       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7184 			       | STV_HIDDEN);
7185     }
7186 
7187   if (htab->need_func_desc_adj)
7188     {
7189       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7190       htab->need_func_desc_adj = 0;
7191     }
7192 
7193   return TRUE;
7194 }
7195 
7196 /* Return true if we have dynamic relocs against H that apply to
7197    read-only sections.  */
7198 
7199 static bfd_boolean
7200 readonly_dynrelocs (struct elf_link_hash_entry *h)
7201 {
7202   struct ppc_link_hash_entry *eh;
7203   struct elf_dyn_relocs *p;
7204 
7205   eh = (struct ppc_link_hash_entry *) h;
7206   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7207     {
7208       asection *s = p->sec->output_section;
7209 
7210       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7211 	return TRUE;
7212     }
7213   return FALSE;
7214 }
7215 
7216 /* Return true if we have dynamic relocs against H or any of its weak
7217    aliases, that apply to read-only sections.  */
7218 
7219 static bfd_boolean
7220 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7221 {
7222   struct ppc_link_hash_entry *eh;
7223 
7224   eh = (struct ppc_link_hash_entry *) h;
7225   do
7226     {
7227       if (readonly_dynrelocs (&eh->elf))
7228 	return TRUE;
7229       eh = eh->weakref;
7230     } while (eh != NULL && &eh->elf != h);
7231 
7232   return FALSE;
7233 }
7234 
7235 /* Return whether EH has pc-relative dynamic relocs.  */
7236 
7237 static bfd_boolean
7238 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7239 {
7240   struct elf_dyn_relocs *p;
7241 
7242   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7243     if (p->pc_count != 0)
7244       return TRUE;
7245   return FALSE;
7246 }
7247 
7248 /* Return true if a global entry stub will be created for H.  Valid
7249    for ELFv2 before plt entries have been allocated.  */
7250 
7251 static bfd_boolean
7252 global_entry_stub (struct elf_link_hash_entry *h)
7253 {
7254   struct plt_entry *pent;
7255 
7256   if (!h->pointer_equality_needed
7257       || h->def_regular)
7258     return FALSE;
7259 
7260   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7261     if (pent->plt.refcount > 0
7262 	&& pent->addend == 0)
7263       return TRUE;
7264 
7265   return FALSE;
7266 }
7267 
7268 /* Adjust a symbol defined by a dynamic object and referenced by a
7269    regular object.  The current definition is in some section of the
7270    dynamic object, but we're not including those sections.  We have to
7271    change the definition to something the rest of the link can
7272    understand.  */
7273 
7274 static bfd_boolean
7275 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7276 				 struct elf_link_hash_entry *h)
7277 {
7278   struct ppc_link_hash_table *htab;
7279   asection *s, *srel;
7280 
7281   htab = ppc_hash_table (info);
7282   if (htab == NULL)
7283     return FALSE;
7284 
7285   /* Deal with function syms.  */
7286   if (h->type == STT_FUNC
7287       || h->type == STT_GNU_IFUNC
7288       || h->needs_plt)
7289     {
7290       /* Clear procedure linkage table information for any symbol that
7291 	 won't need a .plt entry.  */
7292       struct plt_entry *ent;
7293       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7294 	if (ent->plt.refcount > 0)
7295 	  break;
7296       if (ent == NULL
7297 	  || (h->type != STT_GNU_IFUNC
7298 	      && (SYMBOL_CALLS_LOCAL (info, h)
7299 		  || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7300 		      && h->root.type == bfd_link_hash_undefweak)))
7301 	  || ((struct ppc_link_hash_entry *) h)->save_res)
7302 	{
7303 	  h->plt.plist = NULL;
7304 	  h->needs_plt = 0;
7305 	  h->pointer_equality_needed = 0;
7306 	}
7307       else if (abiversion (info->output_bfd) >= 2)
7308 	{
7309 	  /* Taking a function's address in a read/write section
7310 	     doesn't require us to define the function symbol in the
7311 	     executable on a global entry stub.  A dynamic reloc can
7312 	     be used instead.  The reason we prefer a few more dynamic
7313 	     relocs is that calling via a global entry stub costs a
7314 	     few more instructions, and pointer_equality_needed causes
7315 	     extra work in ld.so when resolving these symbols.  */
7316 	  if (global_entry_stub (h)
7317 	      && !alias_readonly_dynrelocs (h))
7318 	    {
7319 	      h->pointer_equality_needed = 0;
7320 	      /* After adjust_dynamic_symbol, non_got_ref set in
7321 		 the non-pic case means that dyn_relocs for this
7322 		 symbol should be discarded.  */
7323 	      h->non_got_ref = 0;
7324 	    }
7325 
7326 	  /* If making a plt entry, then we don't need copy relocs.  */
7327 	  return TRUE;
7328 	}
7329     }
7330   else
7331     h->plt.plist = NULL;
7332 
7333   /* If this is a weak symbol, and there is a real definition, the
7334      processor independent code will have arranged for us to see the
7335      real definition first, and we can just use the same value.  */
7336   if (h->u.weakdef != NULL)
7337     {
7338       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7339 		  || h->u.weakdef->root.type == bfd_link_hash_defweak);
7340       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7341       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7342       if (ELIMINATE_COPY_RELOCS)
7343 	h->non_got_ref = h->u.weakdef->non_got_ref;
7344       return TRUE;
7345     }
7346 
7347   /* If we are creating a shared library, we must presume that the
7348      only references to the symbol are via the global offset table.
7349      For such cases we need not do anything here; the relocations will
7350      be handled correctly by relocate_section.  */
7351   if (bfd_link_pic (info))
7352     return TRUE;
7353 
7354   /* If there are no references to this symbol that do not use the
7355      GOT, we don't need to generate a copy reloc.  */
7356   if (!h->non_got_ref)
7357     return TRUE;
7358 
7359   /* Don't generate a copy reloc for symbols defined in the executable.  */
7360   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7361 
7362       /* If -z nocopyreloc was given, don't generate them either.  */
7363       || info->nocopyreloc
7364 
7365       /* If we didn't find any dynamic relocs in read-only sections, then
7366 	 we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7367       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7368 
7369       /* Protected variables do not work with .dynbss.  The copy in
7370 	 .dynbss won't be used by the shared library with the protected
7371 	 definition for the variable.  Text relocations are preferable
7372 	 to an incorrect program.  */
7373       || h->protected_def)
7374     {
7375       h->non_got_ref = 0;
7376       return TRUE;
7377     }
7378 
7379   if (h->plt.plist != NULL)
7380     {
7381       /* We should never get here, but unfortunately there are versions
7382 	 of gcc out there that improperly (for this ABI) put initialized
7383 	 function pointers, vtable refs and suchlike in read-only
7384 	 sections.  Allow them to proceed, but warn that this might
7385 	 break at runtime.  */
7386       info->callbacks->einfo
7387 	(_("%P: copy reloc against `%T' requires lazy plt linking; "
7388 	   "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7389 	 h->root.root.string);
7390     }
7391 
7392   /* This is a reference to a symbol defined by a dynamic object which
7393      is not a function.  */
7394 
7395   /* We must allocate the symbol in our .dynbss section, which will
7396      become part of the .bss section of the executable.  There will be
7397      an entry for this symbol in the .dynsym section.  The dynamic
7398      object will contain position independent code, so all references
7399      from the dynamic object to this symbol will go through the global
7400      offset table.  The dynamic linker will use the .dynsym entry to
7401      determine the address it must put in the global offset table, so
7402      both the dynamic object and the regular object will refer to the
7403      same memory location for the variable.  */
7404 
7405   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7406      to copy the initial value out of the dynamic object and into the
7407      runtime process image.  We need to remember the offset into the
7408      .rela.bss section we are going to use.  */
7409   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7410     {
7411       s = htab->elf.sdynrelro;
7412       srel = htab->elf.sreldynrelro;
7413     }
7414   else
7415     {
7416       s = htab->elf.sdynbss;
7417       srel = htab->elf.srelbss;
7418     }
7419   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7420     {
7421       srel->size += sizeof (Elf64_External_Rela);
7422       h->needs_copy = 1;
7423     }
7424 
7425   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7426 }
7427 
7428 /* If given a function descriptor symbol, hide both the function code
7429    sym and the descriptor.  */
7430 static void
7431 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7432 		       struct elf_link_hash_entry *h,
7433 		       bfd_boolean force_local)
7434 {
7435   struct ppc_link_hash_entry *eh;
7436   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7437 
7438   eh = (struct ppc_link_hash_entry *) h;
7439   if (eh->is_func_descriptor)
7440     {
7441       struct ppc_link_hash_entry *fh = eh->oh;
7442 
7443       if (fh == NULL)
7444 	{
7445 	  const char *p, *q;
7446 	  struct elf_link_hash_table *htab = elf_hash_table (info);
7447 	  char save;
7448 
7449 	  /* We aren't supposed to use alloca in BFD because on
7450 	     systems which do not have alloca the version in libiberty
7451 	     calls xmalloc, which might cause the program to crash
7452 	     when it runs out of memory.  This function doesn't have a
7453 	     return status, so there's no way to gracefully return an
7454 	     error.  So cheat.  We know that string[-1] can be safely
7455 	     accessed;  It's either a string in an ELF string table,
7456 	     or allocated in an objalloc structure.  */
7457 
7458 	  p = eh->elf.root.root.string - 1;
7459 	  save = *p;
7460 	  *(char *) p = '.';
7461 	  fh = (struct ppc_link_hash_entry *)
7462 	    elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7463 	  *(char *) p = save;
7464 
7465 	  /* Unfortunately, if it so happens that the string we were
7466 	     looking for was allocated immediately before this string,
7467 	     then we overwrote the string terminator.  That's the only
7468 	     reason the lookup should fail.  */
7469 	  if (fh == NULL)
7470 	    {
7471 	      q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7472 	      while (q >= eh->elf.root.root.string && *q == *p)
7473 		--q, --p;
7474 	      if (q < eh->elf.root.root.string && *p == '.')
7475 		fh = (struct ppc_link_hash_entry *)
7476 		  elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7477 	    }
7478 	  if (fh != NULL)
7479 	    {
7480 	      eh->oh = fh;
7481 	      fh->oh = eh;
7482 	    }
7483 	}
7484       if (fh != NULL)
7485 	_bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7486     }
7487 }
7488 
7489 static bfd_boolean
7490 get_sym_h (struct elf_link_hash_entry **hp,
7491 	   Elf_Internal_Sym **symp,
7492 	   asection **symsecp,
7493 	   unsigned char **tls_maskp,
7494 	   Elf_Internal_Sym **locsymsp,
7495 	   unsigned long r_symndx,
7496 	   bfd *ibfd)
7497 {
7498   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7499 
7500   if (r_symndx >= symtab_hdr->sh_info)
7501     {
7502       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7503       struct elf_link_hash_entry *h;
7504 
7505       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7506       h = elf_follow_link (h);
7507 
7508       if (hp != NULL)
7509 	*hp = h;
7510 
7511       if (symp != NULL)
7512 	*symp = NULL;
7513 
7514       if (symsecp != NULL)
7515 	{
7516 	  asection *symsec = NULL;
7517 	  if (h->root.type == bfd_link_hash_defined
7518 	      || h->root.type == bfd_link_hash_defweak)
7519 	    symsec = h->root.u.def.section;
7520 	  *symsecp = symsec;
7521 	}
7522 
7523       if (tls_maskp != NULL)
7524 	{
7525 	  struct ppc_link_hash_entry *eh;
7526 
7527 	  eh = (struct ppc_link_hash_entry *) h;
7528 	  *tls_maskp = &eh->tls_mask;
7529 	}
7530     }
7531   else
7532     {
7533       Elf_Internal_Sym *sym;
7534       Elf_Internal_Sym *locsyms = *locsymsp;
7535 
7536       if (locsyms == NULL)
7537 	{
7538 	  locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7539 	  if (locsyms == NULL)
7540 	    locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7541 					    symtab_hdr->sh_info,
7542 					    0, NULL, NULL, NULL);
7543 	  if (locsyms == NULL)
7544 	    return FALSE;
7545 	  *locsymsp = locsyms;
7546 	}
7547       sym = locsyms + r_symndx;
7548 
7549       if (hp != NULL)
7550 	*hp = NULL;
7551 
7552       if (symp != NULL)
7553 	*symp = sym;
7554 
7555       if (symsecp != NULL)
7556 	*symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7557 
7558       if (tls_maskp != NULL)
7559 	{
7560 	  struct got_entry **lgot_ents;
7561 	  unsigned char *tls_mask;
7562 
7563 	  tls_mask = NULL;
7564 	  lgot_ents = elf_local_got_ents (ibfd);
7565 	  if (lgot_ents != NULL)
7566 	    {
7567 	      struct plt_entry **local_plt = (struct plt_entry **)
7568 		(lgot_ents + symtab_hdr->sh_info);
7569 	      unsigned char *lgot_masks = (unsigned char *)
7570 		(local_plt + symtab_hdr->sh_info);
7571 	      tls_mask = &lgot_masks[r_symndx];
7572 	    }
7573 	  *tls_maskp = tls_mask;
7574 	}
7575     }
7576   return TRUE;
7577 }
7578 
7579 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7580    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7581    type suitable for optimization, and 1 otherwise.  */
7582 
7583 static int
7584 get_tls_mask (unsigned char **tls_maskp,
7585 	      unsigned long *toc_symndx,
7586 	      bfd_vma *toc_addend,
7587 	      Elf_Internal_Sym **locsymsp,
7588 	      const Elf_Internal_Rela *rel,
7589 	      bfd *ibfd)
7590 {
7591   unsigned long r_symndx;
7592   int next_r;
7593   struct elf_link_hash_entry *h;
7594   Elf_Internal_Sym *sym;
7595   asection *sec;
7596   bfd_vma off;
7597 
7598   r_symndx = ELF64_R_SYM (rel->r_info);
7599   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7600     return 0;
7601 
7602   if ((*tls_maskp != NULL && **tls_maskp != 0)
7603       || sec == NULL
7604       || ppc64_elf_section_data (sec) == NULL
7605       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7606     return 1;
7607 
7608   /* Look inside a TOC section too.  */
7609   if (h != NULL)
7610     {
7611       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7612       off = h->root.u.def.value;
7613     }
7614   else
7615     off = sym->st_value;
7616   off += rel->r_addend;
7617   BFD_ASSERT (off % 8 == 0);
7618   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7619   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7620   if (toc_symndx != NULL)
7621     *toc_symndx = r_symndx;
7622   if (toc_addend != NULL)
7623     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7624   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7625     return 0;
7626   if ((h == NULL || is_static_defined (h))
7627       && (next_r == -1 || next_r == -2))
7628     return 1 - next_r;
7629   return 1;
7630 }
7631 
7632 /* Find (or create) an entry in the tocsave hash table.  */
7633 
7634 static struct tocsave_entry *
7635 tocsave_find (struct ppc_link_hash_table *htab,
7636 	      enum insert_option insert,
7637 	      Elf_Internal_Sym **local_syms,
7638 	      const Elf_Internal_Rela *irela,
7639 	      bfd *ibfd)
7640 {
7641   unsigned long r_indx;
7642   struct elf_link_hash_entry *h;
7643   Elf_Internal_Sym *sym;
7644   struct tocsave_entry ent, *p;
7645   hashval_t hash;
7646   struct tocsave_entry **slot;
7647 
7648   r_indx = ELF64_R_SYM (irela->r_info);
7649   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7650     return NULL;
7651   if (ent.sec == NULL || ent.sec->output_section == NULL)
7652     {
7653       _bfd_error_handler
7654 	(_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7655       return NULL;
7656     }
7657 
7658   if (h != NULL)
7659     ent.offset = h->root.u.def.value;
7660   else
7661     ent.offset = sym->st_value;
7662   ent.offset += irela->r_addend;
7663 
7664   hash = tocsave_htab_hash (&ent);
7665   slot = ((struct tocsave_entry **)
7666 	  htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7667   if (slot == NULL)
7668     return NULL;
7669 
7670   if (*slot == NULL)
7671     {
7672       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7673       if (p == NULL)
7674 	return NULL;
7675       *p = ent;
7676       *slot = p;
7677     }
7678   return *slot;
7679 }
7680 
7681 /* Adjust all global syms defined in opd sections.  In gcc generated
7682    code for the old ABI, these will already have been done.  */
7683 
7684 static bfd_boolean
7685 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7686 {
7687   struct ppc_link_hash_entry *eh;
7688   asection *sym_sec;
7689   struct _opd_sec_data *opd;
7690 
7691   if (h->root.type == bfd_link_hash_indirect)
7692     return TRUE;
7693 
7694   if (h->root.type != bfd_link_hash_defined
7695       && h->root.type != bfd_link_hash_defweak)
7696     return TRUE;
7697 
7698   eh = (struct ppc_link_hash_entry *) h;
7699   if (eh->adjust_done)
7700     return TRUE;
7701 
7702   sym_sec = eh->elf.root.u.def.section;
7703   opd = get_opd_info (sym_sec);
7704   if (opd != NULL && opd->adjust != NULL)
7705     {
7706       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7707       if (adjust == -1)
7708 	{
7709 	  /* This entry has been deleted.  */
7710 	  asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7711 	  if (dsec == NULL)
7712 	    {
7713 	      for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7714 		if (discarded_section (dsec))
7715 		  {
7716 		    ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7717 		    break;
7718 		  }
7719 	    }
7720 	  eh->elf.root.u.def.value = 0;
7721 	  eh->elf.root.u.def.section = dsec;
7722 	}
7723       else
7724 	eh->elf.root.u.def.value += adjust;
7725       eh->adjust_done = 1;
7726     }
7727   return TRUE;
7728 }
7729 
7730 /* Handles decrementing dynamic reloc counts for the reloc specified by
7731    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7732    have already been determined.  */
7733 
7734 static bfd_boolean
7735 dec_dynrel_count (bfd_vma r_info,
7736 		  asection *sec,
7737 		  struct bfd_link_info *info,
7738 		  Elf_Internal_Sym **local_syms,
7739 		  struct elf_link_hash_entry *h,
7740 		  Elf_Internal_Sym *sym)
7741 {
7742   enum elf_ppc64_reloc_type r_type;
7743   asection *sym_sec = NULL;
7744 
7745   /* Can this reloc be dynamic?  This switch, and later tests here
7746      should be kept in sync with the code in check_relocs.  */
7747   r_type = ELF64_R_TYPE (r_info);
7748   switch (r_type)
7749     {
7750     default:
7751       return TRUE;
7752 
7753     case R_PPC64_TPREL16:
7754     case R_PPC64_TPREL16_LO:
7755     case R_PPC64_TPREL16_HI:
7756     case R_PPC64_TPREL16_HA:
7757     case R_PPC64_TPREL16_DS:
7758     case R_PPC64_TPREL16_LO_DS:
7759     case R_PPC64_TPREL16_HIGH:
7760     case R_PPC64_TPREL16_HIGHA:
7761     case R_PPC64_TPREL16_HIGHER:
7762     case R_PPC64_TPREL16_HIGHERA:
7763     case R_PPC64_TPREL16_HIGHEST:
7764     case R_PPC64_TPREL16_HIGHESTA:
7765       if (!bfd_link_pic (info))
7766 	return TRUE;
7767 
7768     case R_PPC64_TPREL64:
7769     case R_PPC64_DTPMOD64:
7770     case R_PPC64_DTPREL64:
7771     case R_PPC64_ADDR64:
7772     case R_PPC64_REL30:
7773     case R_PPC64_REL32:
7774     case R_PPC64_REL64:
7775     case R_PPC64_ADDR14:
7776     case R_PPC64_ADDR14_BRNTAKEN:
7777     case R_PPC64_ADDR14_BRTAKEN:
7778     case R_PPC64_ADDR16:
7779     case R_PPC64_ADDR16_DS:
7780     case R_PPC64_ADDR16_HA:
7781     case R_PPC64_ADDR16_HI:
7782     case R_PPC64_ADDR16_HIGH:
7783     case R_PPC64_ADDR16_HIGHA:
7784     case R_PPC64_ADDR16_HIGHER:
7785     case R_PPC64_ADDR16_HIGHERA:
7786     case R_PPC64_ADDR16_HIGHEST:
7787     case R_PPC64_ADDR16_HIGHESTA:
7788     case R_PPC64_ADDR16_LO:
7789     case R_PPC64_ADDR16_LO_DS:
7790     case R_PPC64_ADDR24:
7791     case R_PPC64_ADDR32:
7792     case R_PPC64_UADDR16:
7793     case R_PPC64_UADDR32:
7794     case R_PPC64_UADDR64:
7795     case R_PPC64_TOC:
7796       break;
7797     }
7798 
7799   if (local_syms != NULL)
7800     {
7801       unsigned long r_symndx;
7802       bfd *ibfd = sec->owner;
7803 
7804       r_symndx = ELF64_R_SYM (r_info);
7805       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7806 	return FALSE;
7807     }
7808 
7809   if ((bfd_link_pic (info)
7810        && (must_be_dyn_reloc (info, r_type)
7811 	   || (h != NULL
7812 	       && (!SYMBOLIC_BIND (info, h)
7813 		   || h->root.type == bfd_link_hash_defweak
7814 		   || !h->def_regular))))
7815       || (ELIMINATE_COPY_RELOCS
7816 	  && !bfd_link_pic (info)
7817 	  && h != NULL
7818 	  && (h->root.type == bfd_link_hash_defweak
7819 	      || !h->def_regular)))
7820     ;
7821   else
7822     return TRUE;
7823 
7824   if (h != NULL)
7825     {
7826       struct elf_dyn_relocs *p;
7827       struct elf_dyn_relocs **pp;
7828       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7829 
7830       /* elf_gc_sweep may have already removed all dyn relocs associated
7831 	 with local syms for a given section.  Also, symbol flags are
7832 	 changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7833 	 report a dynreloc miscount.  */
7834       if (*pp == NULL && info->gc_sections)
7835 	return TRUE;
7836 
7837       while ((p = *pp) != NULL)
7838 	{
7839 	  if (p->sec == sec)
7840 	    {
7841 	      if (!must_be_dyn_reloc (info, r_type))
7842 		p->pc_count -= 1;
7843 	      p->count -= 1;
7844 	      if (p->count == 0)
7845 		*pp = p->next;
7846 	      return TRUE;
7847 	    }
7848 	  pp = &p->next;
7849 	}
7850     }
7851   else
7852     {
7853       struct ppc_dyn_relocs *p;
7854       struct ppc_dyn_relocs **pp;
7855       void *vpp;
7856       bfd_boolean is_ifunc;
7857 
7858       if (local_syms == NULL)
7859 	sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7860       if (sym_sec == NULL)
7861 	sym_sec = sec;
7862 
7863       vpp = &elf_section_data (sym_sec)->local_dynrel;
7864       pp = (struct ppc_dyn_relocs **) vpp;
7865 
7866       if (*pp == NULL && info->gc_sections)
7867 	return TRUE;
7868 
7869       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7870       while ((p = *pp) != NULL)
7871 	{
7872 	  if (p->sec == sec && p->ifunc == is_ifunc)
7873 	    {
7874 	      p->count -= 1;
7875 	      if (p->count == 0)
7876 		*pp = p->next;
7877 	      return TRUE;
7878 	    }
7879 	  pp = &p->next;
7880 	}
7881     }
7882 
7883   /* xgettext:c-format */
7884   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7885 			  sec->owner, sec);
7886   bfd_set_error (bfd_error_bad_value);
7887   return FALSE;
7888 }
7889 
7890 /* Remove unused Official Procedure Descriptor entries.  Currently we
7891    only remove those associated with functions in discarded link-once
7892    sections, or weakly defined functions that have been overridden.  It
7893    would be possible to remove many more entries for statically linked
7894    applications.  */
7895 
7896 bfd_boolean
7897 ppc64_elf_edit_opd (struct bfd_link_info *info)
7898 {
7899   bfd *ibfd;
7900   bfd_boolean some_edited = FALSE;
7901   asection *need_pad = NULL;
7902   struct ppc_link_hash_table *htab;
7903 
7904   htab = ppc_hash_table (info);
7905   if (htab == NULL)
7906     return FALSE;
7907 
7908   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7909     {
7910       asection *sec;
7911       Elf_Internal_Rela *relstart, *rel, *relend;
7912       Elf_Internal_Shdr *symtab_hdr;
7913       Elf_Internal_Sym *local_syms;
7914       struct _opd_sec_data *opd;
7915       bfd_boolean need_edit, add_aux_fields, broken;
7916       bfd_size_type cnt_16b = 0;
7917 
7918       if (!is_ppc64_elf (ibfd))
7919 	continue;
7920 
7921       sec = bfd_get_section_by_name (ibfd, ".opd");
7922       if (sec == NULL || sec->size == 0)
7923 	continue;
7924 
7925       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7926 	continue;
7927 
7928       if (sec->output_section == bfd_abs_section_ptr)
7929 	continue;
7930 
7931       /* Look through the section relocs.  */
7932       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7933 	continue;
7934 
7935       local_syms = NULL;
7936       symtab_hdr = &elf_symtab_hdr (ibfd);
7937 
7938       /* Read the relocations.  */
7939       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7940 					    info->keep_memory);
7941       if (relstart == NULL)
7942 	return FALSE;
7943 
7944       /* First run through the relocs to check they are sane, and to
7945 	 determine whether we need to edit this opd section.  */
7946       need_edit = FALSE;
7947       broken = FALSE;
7948       need_pad = sec;
7949       relend = relstart + sec->reloc_count;
7950       for (rel = relstart; rel < relend; )
7951 	{
7952 	  enum elf_ppc64_reloc_type r_type;
7953 	  unsigned long r_symndx;
7954 	  asection *sym_sec;
7955 	  struct elf_link_hash_entry *h;
7956 	  Elf_Internal_Sym *sym;
7957 	  bfd_vma offset;
7958 
7959 	  /* .opd contains an array of 16 or 24 byte entries.  We're
7960 	     only interested in the reloc pointing to a function entry
7961 	     point.  */
7962 	  offset = rel->r_offset;
7963 	  if (rel + 1 == relend
7964 	      || rel[1].r_offset != offset + 8)
7965 	    {
7966 	      /* If someone messes with .opd alignment then after a
7967 		 "ld -r" we might have padding in the middle of .opd.
7968 		 Also, there's nothing to prevent someone putting
7969 		 something silly in .opd with the assembler.  No .opd
7970 		 optimization for them!  */
7971 	    broken_opd:
7972 	      _bfd_error_handler
7973 		(_("%B: .opd is not a regular array of opd entries"), ibfd);
7974 	      broken = TRUE;
7975 	      break;
7976 	    }
7977 
7978 	  if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7979 	      || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7980 	    {
7981 	      _bfd_error_handler
7982 		/* xgettext:c-format */
7983 		(_("%B: unexpected reloc type %u in .opd section"),
7984 		 ibfd, r_type);
7985 	      broken = TRUE;
7986 	      break;
7987 	    }
7988 
7989 	  r_symndx = ELF64_R_SYM (rel->r_info);
7990 	  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7991 			  r_symndx, ibfd))
7992 	    goto error_ret;
7993 
7994 	  if (sym_sec == NULL || sym_sec->owner == NULL)
7995 	    {
7996 	      const char *sym_name;
7997 	      if (h != NULL)
7998 		sym_name = h->root.root.string;
7999 	      else
8000 		sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8001 					     sym_sec);
8002 
8003 	      _bfd_error_handler
8004 		/* xgettext:c-format */
8005 		(_("%B: undefined sym `%s' in .opd section"),
8006 		 ibfd, sym_name);
8007 	      broken = TRUE;
8008 	      break;
8009 	    }
8010 
8011 	  /* opd entries are always for functions defined in the
8012 	     current input bfd.  If the symbol isn't defined in the
8013 	     input bfd, then we won't be using the function in this
8014 	     bfd;  It must be defined in a linkonce section in another
8015 	     bfd, or is weak.  It's also possible that we are
8016 	     discarding the function due to a linker script /DISCARD/,
8017 	     which we test for via the output_section.  */
8018 	  if (sym_sec->owner != ibfd
8019 	      || sym_sec->output_section == bfd_abs_section_ptr)
8020 	    need_edit = TRUE;
8021 
8022 	  rel += 2;
8023 	  if (rel + 1 == relend
8024 	      || (rel + 2 < relend
8025 		  && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8026 	    ++rel;
8027 
8028 	  if (rel == relend)
8029 	    {
8030 	      if (sec->size == offset + 24)
8031 		{
8032 		  need_pad = NULL;
8033 		  break;
8034 		}
8035 	      if (sec->size == offset + 16)
8036 		{
8037 		  cnt_16b++;
8038 		  break;
8039 		}
8040 	      goto broken_opd;
8041 	    }
8042 	  else if (rel + 1 < relend
8043 		   && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8044 		   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8045 	    {
8046 	      if (rel[0].r_offset == offset + 16)
8047 		cnt_16b++;
8048 	      else if (rel[0].r_offset != offset + 24)
8049 		goto broken_opd;
8050 	    }
8051 	  else
8052 	    goto broken_opd;
8053 	}
8054 
8055       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8056 
8057       if (!broken && (need_edit || add_aux_fields))
8058 	{
8059 	  Elf_Internal_Rela *write_rel;
8060 	  Elf_Internal_Shdr *rel_hdr;
8061 	  bfd_byte *rptr, *wptr;
8062 	  bfd_byte *new_contents;
8063 	  bfd_size_type amt;
8064 
8065 	  new_contents = NULL;
8066 	  amt = OPD_NDX (sec->size) * sizeof (long);
8067 	  opd = &ppc64_elf_section_data (sec)->u.opd;
8068 	  opd->adjust = bfd_zalloc (sec->owner, amt);
8069 	  if (opd->adjust == NULL)
8070 	    return FALSE;
8071 	  ppc64_elf_section_data (sec)->sec_type = sec_opd;
8072 
8073 	  /* This seems a waste of time as input .opd sections are all
8074 	     zeros as generated by gcc, but I suppose there's no reason
8075 	     this will always be so.  We might start putting something in
8076 	     the third word of .opd entries.  */
8077 	  if ((sec->flags & SEC_IN_MEMORY) == 0)
8078 	    {
8079 	      bfd_byte *loc;
8080 	      if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8081 		{
8082 		  if (loc != NULL)
8083 		    free (loc);
8084 		error_ret:
8085 		  if (local_syms != NULL
8086 		      && symtab_hdr->contents != (unsigned char *) local_syms)
8087 		    free (local_syms);
8088 		  if (elf_section_data (sec)->relocs != relstart)
8089 		    free (relstart);
8090 		  return FALSE;
8091 		}
8092 	      sec->contents = loc;
8093 	      sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8094 	    }
8095 
8096 	  elf_section_data (sec)->relocs = relstart;
8097 
8098 	  new_contents = sec->contents;
8099 	  if (add_aux_fields)
8100 	    {
8101 	      new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8102 	      if (new_contents == NULL)
8103 		return FALSE;
8104 	      need_pad = NULL;
8105 	    }
8106 	  wptr = new_contents;
8107 	  rptr = sec->contents;
8108 	  write_rel = relstart;
8109 	  for (rel = relstart; rel < relend; )
8110 	    {
8111 	      unsigned long r_symndx;
8112 	      asection *sym_sec;
8113 	      struct elf_link_hash_entry *h;
8114 	      struct ppc_link_hash_entry *fdh = NULL;
8115 	      Elf_Internal_Sym *sym;
8116 	      long opd_ent_size;
8117 	      Elf_Internal_Rela *next_rel;
8118 	      bfd_boolean skip;
8119 
8120 	      r_symndx = ELF64_R_SYM (rel->r_info);
8121 	      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8122 			      r_symndx, ibfd))
8123 		goto error_ret;
8124 
8125 	      next_rel = rel + 2;
8126 	      if (next_rel + 1 == relend
8127 		  || (next_rel + 2 < relend
8128 		      && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8129 		++next_rel;
8130 
8131 	      /* See if the .opd entry is full 24 byte or
8132 		 16 byte (with fd_aux entry overlapped with next
8133 		 fd_func).  */
8134 	      opd_ent_size = 24;
8135 	      if (next_rel == relend)
8136 		{
8137 		  if (sec->size == rel->r_offset + 16)
8138 		    opd_ent_size = 16;
8139 		}
8140 	      else if (next_rel->r_offset == rel->r_offset + 16)
8141 		opd_ent_size = 16;
8142 
8143 	      if (h != NULL
8144 		  && h->root.root.string[0] == '.')
8145 		{
8146 		  fdh = ((struct ppc_link_hash_entry *) h)->oh;
8147 		  if (fdh != NULL)
8148 		    {
8149 		      fdh = ppc_follow_link (fdh);
8150 		      if (fdh->elf.root.type != bfd_link_hash_defined
8151 			  && fdh->elf.root.type != bfd_link_hash_defweak)
8152 			fdh = NULL;
8153 		    }
8154 		}
8155 
8156 	      skip = (sym_sec->owner != ibfd
8157 		      || sym_sec->output_section == bfd_abs_section_ptr);
8158 	      if (skip)
8159 		{
8160 		  if (fdh != NULL && sym_sec->owner == ibfd)
8161 		    {
8162 		      /* Arrange for the function descriptor sym
8163 			 to be dropped.  */
8164 		      fdh->elf.root.u.def.value = 0;
8165 		      fdh->elf.root.u.def.section = sym_sec;
8166 		    }
8167 		  opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8168 
8169 		  if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8170 		    rel = next_rel;
8171 		  else
8172 		    while (1)
8173 		      {
8174 			if (!dec_dynrel_count (rel->r_info, sec, info,
8175 					       NULL, h, sym))
8176 			  goto error_ret;
8177 
8178 			if (++rel == next_rel)
8179 			  break;
8180 
8181 			r_symndx = ELF64_R_SYM (rel->r_info);
8182 			if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8183 					r_symndx, ibfd))
8184 			  goto error_ret;
8185 		      }
8186 		}
8187 	      else
8188 		{
8189 		  /* We'll be keeping this opd entry.  */
8190 		  long adjust;
8191 
8192 		  if (fdh != NULL)
8193 		    {
8194 		      /* Redefine the function descriptor symbol to
8195 			 this location in the opd section.  It is
8196 			 necessary to update the value here rather
8197 			 than using an array of adjustments as we do
8198 			 for local symbols, because various places
8199 			 in the generic ELF code use the value
8200 			 stored in u.def.value.  */
8201 		      fdh->elf.root.u.def.value = wptr - new_contents;
8202 		      fdh->adjust_done = 1;
8203 		    }
8204 
8205 		  /* Local syms are a bit tricky.  We could
8206 		     tweak them as they can be cached, but
8207 		     we'd need to look through the local syms
8208 		     for the function descriptor sym which we
8209 		     don't have at the moment.  So keep an
8210 		     array of adjustments.  */
8211 		  adjust = (wptr - new_contents) - (rptr - sec->contents);
8212 		  opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8213 
8214 		  if (wptr != rptr)
8215 		    memcpy (wptr, rptr, opd_ent_size);
8216 		  wptr += opd_ent_size;
8217 		  if (add_aux_fields && opd_ent_size == 16)
8218 		    {
8219 		      memset (wptr, '\0', 8);
8220 		      wptr += 8;
8221 		    }
8222 
8223 		  /* We need to adjust any reloc offsets to point to the
8224 		     new opd entries.  */
8225 		  for ( ; rel != next_rel; ++rel)
8226 		    {
8227 		      rel->r_offset += adjust;
8228 		      if (write_rel != rel)
8229 			memcpy (write_rel, rel, sizeof (*rel));
8230 		      ++write_rel;
8231 		    }
8232 		}
8233 
8234 	      rptr += opd_ent_size;
8235 	    }
8236 
8237 	  sec->size = wptr - new_contents;
8238 	  sec->reloc_count = write_rel - relstart;
8239 	  if (add_aux_fields)
8240 	    {
8241 	      free (sec->contents);
8242 	      sec->contents = new_contents;
8243 	    }
8244 
8245 	  /* Fudge the header size too, as this is used later in
8246 	     elf_bfd_final_link if we are emitting relocs.  */
8247 	  rel_hdr = _bfd_elf_single_rel_hdr (sec);
8248 	  rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8249 	  some_edited = TRUE;
8250 	}
8251       else if (elf_section_data (sec)->relocs != relstart)
8252 	free (relstart);
8253 
8254       if (local_syms != NULL
8255 	  && symtab_hdr->contents != (unsigned char *) local_syms)
8256 	{
8257 	  if (!info->keep_memory)
8258 	    free (local_syms);
8259 	  else
8260 	    symtab_hdr->contents = (unsigned char *) local_syms;
8261 	}
8262     }
8263 
8264   if (some_edited)
8265     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8266 
8267   /* If we are doing a final link and the last .opd entry is just 16 byte
8268      long, add a 8 byte padding after it.  */
8269   if (need_pad != NULL && !bfd_link_relocatable (info))
8270     {
8271       bfd_byte *p;
8272 
8273       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8274 	{
8275 	  BFD_ASSERT (need_pad->size > 0);
8276 
8277 	  p = bfd_malloc (need_pad->size + 8);
8278 	  if (p == NULL)
8279 	    return FALSE;
8280 
8281 	  if (! bfd_get_section_contents (need_pad->owner, need_pad,
8282 					  p, 0, need_pad->size))
8283 	    return FALSE;
8284 
8285 	  need_pad->contents = p;
8286 	  need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8287 	}
8288       else
8289 	{
8290 	  p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8291 	  if (p == NULL)
8292 	    return FALSE;
8293 
8294 	  need_pad->contents = p;
8295 	}
8296 
8297       memset (need_pad->contents + need_pad->size, 0, 8);
8298       need_pad->size += 8;
8299     }
8300 
8301   return TRUE;
8302 }
8303 
8304 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8305 
8306 asection *
8307 ppc64_elf_tls_setup (struct bfd_link_info *info)
8308 {
8309   struct ppc_link_hash_table *htab;
8310 
8311   htab = ppc_hash_table (info);
8312   if (htab == NULL)
8313     return NULL;
8314 
8315   if (abiversion (info->output_bfd) == 1)
8316     htab->opd_abi = 1;
8317 
8318   if (htab->params->no_multi_toc)
8319     htab->do_multi_toc = 0;
8320   else if (!htab->do_multi_toc)
8321     htab->params->no_multi_toc = 1;
8322 
8323   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8324 			elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8325 					      FALSE, FALSE, TRUE));
8326   /* Move dynamic linking info to the function descriptor sym.  */
8327   if (htab->tls_get_addr != NULL)
8328     func_desc_adjust (&htab->tls_get_addr->elf, info);
8329   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8330 			   elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8331 						 FALSE, FALSE, TRUE));
8332   if (htab->params->tls_get_addr_opt)
8333     {
8334       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8335 
8336       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8337 				  FALSE, FALSE, TRUE);
8338       if (opt != NULL)
8339 	func_desc_adjust (opt, info);
8340       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8341 				     FALSE, FALSE, TRUE);
8342       if (opt_fd != NULL
8343 	  && (opt_fd->root.type == bfd_link_hash_defined
8344 	      || opt_fd->root.type == bfd_link_hash_defweak))
8345 	{
8346 	  /* If glibc supports an optimized __tls_get_addr call stub,
8347 	     signalled by the presence of __tls_get_addr_opt, and we'll
8348 	     be calling __tls_get_addr via a plt call stub, then
8349 	     make __tls_get_addr point to __tls_get_addr_opt.  */
8350 	  tga_fd = &htab->tls_get_addr_fd->elf;
8351 	  if (htab->elf.dynamic_sections_created
8352 	      && tga_fd != NULL
8353 	      && (tga_fd->type == STT_FUNC
8354 		  || tga_fd->needs_plt)
8355 	      && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8356 		   || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8357 		       && tga_fd->root.type == bfd_link_hash_undefweak)))
8358 	    {
8359 	      struct plt_entry *ent;
8360 
8361 	      for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8362 		if (ent->plt.refcount > 0)
8363 		  break;
8364 	      if (ent != NULL)
8365 		{
8366 		  tga_fd->root.type = bfd_link_hash_indirect;
8367 		  tga_fd->root.u.i.link = &opt_fd->root;
8368 		  ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8369 		  opt_fd->mark = 1;
8370 		  if (opt_fd->dynindx != -1)
8371 		    {
8372 		      /* Use __tls_get_addr_opt in dynamic relocations.  */
8373 		      opt_fd->dynindx = -1;
8374 		      _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8375 					      opt_fd->dynstr_index);
8376 		      if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8377 			return NULL;
8378 		    }
8379 		  htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8380 		  tga = &htab->tls_get_addr->elf;
8381 		  if (opt != NULL && tga != NULL)
8382 		    {
8383 		      tga->root.type = bfd_link_hash_indirect;
8384 		      tga->root.u.i.link = &opt->root;
8385 		      ppc64_elf_copy_indirect_symbol (info, opt, tga);
8386 		      opt->mark = 1;
8387 		      _bfd_elf_link_hash_hide_symbol (info, opt,
8388 						      tga->forced_local);
8389 		      htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8390 		    }
8391 		  htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8392 		  htab->tls_get_addr_fd->is_func_descriptor = 1;
8393 		  if (htab->tls_get_addr != NULL)
8394 		    {
8395 		      htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8396 		      htab->tls_get_addr->is_func = 1;
8397 		    }
8398 		}
8399 	    }
8400 	}
8401       else if (htab->params->tls_get_addr_opt < 0)
8402 	htab->params->tls_get_addr_opt = 0;
8403     }
8404   return _bfd_elf_tls_setup (info->output_bfd, info);
8405 }
8406 
8407 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8408    HASH1 or HASH2.  */
8409 
8410 static bfd_boolean
8411 branch_reloc_hash_match (const bfd *ibfd,
8412 			 const Elf_Internal_Rela *rel,
8413 			 const struct ppc_link_hash_entry *hash1,
8414 			 const struct ppc_link_hash_entry *hash2)
8415 {
8416   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8417   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8418   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8419 
8420   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8421     {
8422       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8423       struct elf_link_hash_entry *h;
8424 
8425       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8426       h = elf_follow_link (h);
8427       if (h == &hash1->elf || h == &hash2->elf)
8428 	return TRUE;
8429     }
8430   return FALSE;
8431 }
8432 
8433 /* Run through all the TLS relocs looking for optimization
8434    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8435    a preliminary section layout so that we know the TLS segment
8436    offsets.  We can't optimize earlier because some optimizations need
8437    to know the tp offset, and we need to optimize before allocating
8438    dynamic relocations.  */
8439 
8440 bfd_boolean
8441 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8442 {
8443   bfd *ibfd;
8444   asection *sec;
8445   struct ppc_link_hash_table *htab;
8446   unsigned char *toc_ref;
8447   int pass;
8448 
8449   if (!bfd_link_executable (info))
8450     return TRUE;
8451 
8452   htab = ppc_hash_table (info);
8453   if (htab == NULL)
8454     return FALSE;
8455 
8456   /* Make two passes over the relocs.  On the first pass, mark toc
8457      entries involved with tls relocs, and check that tls relocs
8458      involved in setting up a tls_get_addr call are indeed followed by
8459      such a call.  If they are not, we can't do any tls optimization.
8460      On the second pass twiddle tls_mask flags to notify
8461      relocate_section that optimization can be done, and adjust got
8462      and plt refcounts.  */
8463   toc_ref = NULL;
8464   for (pass = 0; pass < 2; ++pass)
8465     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8466       {
8467 	Elf_Internal_Sym *locsyms = NULL;
8468 	asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8469 
8470 	for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8471 	  if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8472 	    {
8473 	      Elf_Internal_Rela *relstart, *rel, *relend;
8474 	      bfd_boolean found_tls_get_addr_arg = 0;
8475 
8476 	      /* Read the relocations.  */
8477 	      relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8478 						    info->keep_memory);
8479 	      if (relstart == NULL)
8480 		{
8481 		  free (toc_ref);
8482 		  return FALSE;
8483 		}
8484 
8485 	      relend = relstart + sec->reloc_count;
8486 	      for (rel = relstart; rel < relend; rel++)
8487 		{
8488 		  enum elf_ppc64_reloc_type r_type;
8489 		  unsigned long r_symndx;
8490 		  struct elf_link_hash_entry *h;
8491 		  Elf_Internal_Sym *sym;
8492 		  asection *sym_sec;
8493 		  unsigned char *tls_mask;
8494 		  unsigned char tls_set, tls_clear, tls_type = 0;
8495 		  bfd_vma value;
8496 		  bfd_boolean ok_tprel, is_local;
8497 		  long toc_ref_index = 0;
8498 		  int expecting_tls_get_addr = 0;
8499 		  bfd_boolean ret = FALSE;
8500 
8501 		  r_symndx = ELF64_R_SYM (rel->r_info);
8502 		  if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8503 				  r_symndx, ibfd))
8504 		    {
8505 		    err_free_rel:
8506 		      if (elf_section_data (sec)->relocs != relstart)
8507 			free (relstart);
8508 		      if (toc_ref != NULL)
8509 			free (toc_ref);
8510 		      if (locsyms != NULL
8511 			  && (elf_symtab_hdr (ibfd).contents
8512 			      != (unsigned char *) locsyms))
8513 			free (locsyms);
8514 		      return ret;
8515 		    }
8516 
8517 		  if (h != NULL)
8518 		    {
8519 		      if (h->root.type == bfd_link_hash_defined
8520 			  || h->root.type == bfd_link_hash_defweak)
8521 			value = h->root.u.def.value;
8522 		      else if (h->root.type == bfd_link_hash_undefweak)
8523 			value = 0;
8524 		      else
8525 			{
8526 			  found_tls_get_addr_arg = 0;
8527 			  continue;
8528 			}
8529 		    }
8530 		  else
8531 		    /* Symbols referenced by TLS relocs must be of type
8532 		       STT_TLS.  So no need for .opd local sym adjust.  */
8533 		    value = sym->st_value;
8534 
8535 		  ok_tprel = FALSE;
8536 		  is_local = FALSE;
8537 		  if (h == NULL
8538 		      || !h->def_dynamic)
8539 		    {
8540 		      is_local = TRUE;
8541 		      if (h != NULL
8542 			  && h->root.type == bfd_link_hash_undefweak)
8543 			ok_tprel = TRUE;
8544 		      else if (sym_sec != NULL
8545 			       && sym_sec->output_section != NULL)
8546 			{
8547 			  value += sym_sec->output_offset;
8548 			  value += sym_sec->output_section->vma;
8549 			  value -= htab->elf.tls_sec->vma;
8550 			  ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8551 				      < (bfd_vma) 1 << 32);
8552 			}
8553 		    }
8554 
8555 		  r_type = ELF64_R_TYPE (rel->r_info);
8556 		  /* If this section has old-style __tls_get_addr calls
8557 		     without marker relocs, then check that each
8558 		     __tls_get_addr call reloc is preceded by a reloc
8559 		     that conceivably belongs to the __tls_get_addr arg
8560 		     setup insn.  If we don't find matching arg setup
8561 		     relocs, don't do any tls optimization.  */
8562 		  if (pass == 0
8563 		      && sec->has_tls_get_addr_call
8564 		      && h != NULL
8565 		      && (h == &htab->tls_get_addr->elf
8566 			  || h == &htab->tls_get_addr_fd->elf)
8567 		      && !found_tls_get_addr_arg
8568 		      && is_branch_reloc (r_type))
8569 		    {
8570 		      info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8571 						"TLS optimization disabled\n"),
8572 					      ibfd, sec, rel->r_offset);
8573 		      ret = TRUE;
8574 		      goto err_free_rel;
8575 		    }
8576 
8577 		  found_tls_get_addr_arg = 0;
8578 		  switch (r_type)
8579 		    {
8580 		    case R_PPC64_GOT_TLSLD16:
8581 		    case R_PPC64_GOT_TLSLD16_LO:
8582 		      expecting_tls_get_addr = 1;
8583 		      found_tls_get_addr_arg = 1;
8584 		      /* Fall through.  */
8585 
8586 		    case R_PPC64_GOT_TLSLD16_HI:
8587 		    case R_PPC64_GOT_TLSLD16_HA:
8588 		      /* These relocs should never be against a symbol
8589 			 defined in a shared lib.  Leave them alone if
8590 			 that turns out to be the case.  */
8591 		      if (!is_local)
8592 			continue;
8593 
8594 		      /* LD -> LE */
8595 		      tls_set = 0;
8596 		      tls_clear = TLS_LD;
8597 		      tls_type = TLS_TLS | TLS_LD;
8598 		      break;
8599 
8600 		    case R_PPC64_GOT_TLSGD16:
8601 		    case R_PPC64_GOT_TLSGD16_LO:
8602 		      expecting_tls_get_addr = 1;
8603 		      found_tls_get_addr_arg = 1;
8604 		      /* Fall through. */
8605 
8606 		    case R_PPC64_GOT_TLSGD16_HI:
8607 		    case R_PPC64_GOT_TLSGD16_HA:
8608 		      if (ok_tprel)
8609 			/* GD -> LE */
8610 			tls_set = 0;
8611 		      else
8612 			/* GD -> IE */
8613 			tls_set = TLS_TLS | TLS_TPRELGD;
8614 		      tls_clear = TLS_GD;
8615 		      tls_type = TLS_TLS | TLS_GD;
8616 		      break;
8617 
8618 		    case R_PPC64_GOT_TPREL16_DS:
8619 		    case R_PPC64_GOT_TPREL16_LO_DS:
8620 		    case R_PPC64_GOT_TPREL16_HI:
8621 		    case R_PPC64_GOT_TPREL16_HA:
8622 		      if (ok_tprel)
8623 			{
8624 			  /* IE -> LE */
8625 			  tls_set = 0;
8626 			  tls_clear = TLS_TPREL;
8627 			  tls_type = TLS_TLS | TLS_TPREL;
8628 			  break;
8629 			}
8630 		      continue;
8631 
8632 		    case R_PPC64_TLSGD:
8633 		    case R_PPC64_TLSLD:
8634 		      found_tls_get_addr_arg = 1;
8635 		      /* Fall through.  */
8636 
8637 		    case R_PPC64_TLS:
8638 		    case R_PPC64_TOC16:
8639 		    case R_PPC64_TOC16_LO:
8640 		      if (sym_sec == NULL || sym_sec != toc)
8641 			continue;
8642 
8643 		      /* Mark this toc entry as referenced by a TLS
8644 			 code sequence.  We can do that now in the
8645 			 case of R_PPC64_TLS, and after checking for
8646 			 tls_get_addr for the TOC16 relocs.  */
8647 		      if (toc_ref == NULL)
8648 			toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8649 		      if (toc_ref == NULL)
8650 			goto err_free_rel;
8651 
8652 		      if (h != NULL)
8653 			value = h->root.u.def.value;
8654 		      else
8655 			value = sym->st_value;
8656 		      value += rel->r_addend;
8657 		      if (value % 8 != 0)
8658 			continue;
8659 		      BFD_ASSERT (value < toc->size
8660 				  && toc->output_offset % 8 == 0);
8661 		      toc_ref_index = (value + toc->output_offset) / 8;
8662 		      if (r_type == R_PPC64_TLS
8663 			  || r_type == R_PPC64_TLSGD
8664 			  || r_type == R_PPC64_TLSLD)
8665 			{
8666 			  toc_ref[toc_ref_index] = 1;
8667 			  continue;
8668 			}
8669 
8670 		      if (pass != 0 && toc_ref[toc_ref_index] == 0)
8671 			continue;
8672 
8673 		      tls_set = 0;
8674 		      tls_clear = 0;
8675 		      expecting_tls_get_addr = 2;
8676 		      break;
8677 
8678 		    case R_PPC64_TPREL64:
8679 		      if (pass == 0
8680 			  || sec != toc
8681 			  || toc_ref == NULL
8682 			  || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8683 			continue;
8684 		      if (ok_tprel)
8685 			{
8686 			  /* IE -> LE */
8687 			  tls_set = TLS_EXPLICIT;
8688 			  tls_clear = TLS_TPREL;
8689 			  break;
8690 			}
8691 		      continue;
8692 
8693 		    case R_PPC64_DTPMOD64:
8694 		      if (pass == 0
8695 			  || sec != toc
8696 			  || toc_ref == NULL
8697 			  || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8698 			continue;
8699 		      if (rel + 1 < relend
8700 			  && (rel[1].r_info
8701 			      == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8702 			  && rel[1].r_offset == rel->r_offset + 8)
8703 			{
8704 			  if (ok_tprel)
8705 			    /* GD -> LE */
8706 			    tls_set = TLS_EXPLICIT | TLS_GD;
8707 			  else
8708 			    /* GD -> IE */
8709 			    tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8710 			  tls_clear = TLS_GD;
8711 			}
8712 		      else
8713 			{
8714 			  if (!is_local)
8715 			    continue;
8716 
8717 			  /* LD -> LE */
8718 			  tls_set = TLS_EXPLICIT;
8719 			  tls_clear = TLS_LD;
8720 			}
8721 		      break;
8722 
8723 		    default:
8724 		      continue;
8725 		    }
8726 
8727 		  if (pass == 0)
8728 		    {
8729 		      if (!expecting_tls_get_addr
8730 			  || !sec->has_tls_get_addr_call)
8731 			continue;
8732 
8733 		      if (rel + 1 < relend
8734 			  && branch_reloc_hash_match (ibfd, rel + 1,
8735 						      htab->tls_get_addr,
8736 						      htab->tls_get_addr_fd))
8737 			{
8738 			  if (expecting_tls_get_addr == 2)
8739 			    {
8740 			      /* Check for toc tls entries.  */
8741 			      unsigned char *toc_tls;
8742 			      int retval;
8743 
8744 			      retval = get_tls_mask (&toc_tls, NULL, NULL,
8745 						     &locsyms,
8746 						     rel, ibfd);
8747 			      if (retval == 0)
8748 				goto err_free_rel;
8749 			      if (toc_tls != NULL)
8750 				{
8751 				  if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8752 				    found_tls_get_addr_arg = 1;
8753 				  if (retval > 1)
8754 				    toc_ref[toc_ref_index] = 1;
8755 				}
8756 			    }
8757 			  continue;
8758 			}
8759 
8760 		      if (expecting_tls_get_addr != 1)
8761 			continue;
8762 
8763 		      /* Uh oh, we didn't find the expected call.  We
8764 			 could just mark this symbol to exclude it
8765 			 from tls optimization but it's safer to skip
8766 			 the entire optimization.  */
8767 		      /* xgettext:c-format */
8768 		      info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8769 						"TLS optimization disabled\n"),
8770 					      ibfd, sec, rel->r_offset);
8771 		      ret = TRUE;
8772 		      goto err_free_rel;
8773 		    }
8774 
8775 		  if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8776 		    {
8777 		      struct plt_entry *ent;
8778 		      for (ent = htab->tls_get_addr->elf.plt.plist;
8779 			   ent != NULL;
8780 			   ent = ent->next)
8781 			if (ent->addend == 0)
8782 			  {
8783 			    if (ent->plt.refcount > 0)
8784 			      {
8785 				ent->plt.refcount -= 1;
8786 				expecting_tls_get_addr = 0;
8787 			      }
8788 			    break;
8789 			  }
8790 		    }
8791 
8792 		  if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8793 		    {
8794 		      struct plt_entry *ent;
8795 		      for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8796 			   ent != NULL;
8797 			   ent = ent->next)
8798 			if (ent->addend == 0)
8799 			  {
8800 			    if (ent->plt.refcount > 0)
8801 			      ent->plt.refcount -= 1;
8802 			    break;
8803 			  }
8804 		    }
8805 
8806 		  if (tls_clear == 0)
8807 		    continue;
8808 
8809 		  if ((tls_set & TLS_EXPLICIT) == 0)
8810 		    {
8811 		      struct got_entry *ent;
8812 
8813 		      /* Adjust got entry for this reloc.  */
8814 		      if (h != NULL)
8815 			ent = h->got.glist;
8816 		      else
8817 			ent = elf_local_got_ents (ibfd)[r_symndx];
8818 
8819 		      for (; ent != NULL; ent = ent->next)
8820 			if (ent->addend == rel->r_addend
8821 			    && ent->owner == ibfd
8822 			    && ent->tls_type == tls_type)
8823 			  break;
8824 		      if (ent == NULL)
8825 			abort ();
8826 
8827 		      if (tls_set == 0)
8828 			{
8829 			  /* We managed to get rid of a got entry.  */
8830 			  if (ent->got.refcount > 0)
8831 			    ent->got.refcount -= 1;
8832 			}
8833 		    }
8834 		  else
8835 		    {
8836 		      /* If we got rid of a DTPMOD/DTPREL reloc pair then
8837 			 we'll lose one or two dyn relocs.  */
8838 		      if (!dec_dynrel_count (rel->r_info, sec, info,
8839 					     NULL, h, sym))
8840 			return FALSE;
8841 
8842 		      if (tls_set == (TLS_EXPLICIT | TLS_GD))
8843 			{
8844 			  if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8845 						 NULL, h, sym))
8846 			    return FALSE;
8847 			}
8848 		    }
8849 
8850 		  *tls_mask |= tls_set;
8851 		  *tls_mask &= ~tls_clear;
8852 		}
8853 
8854 	      if (elf_section_data (sec)->relocs != relstart)
8855 		free (relstart);
8856 	    }
8857 
8858 	if (locsyms != NULL
8859 	    && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8860 	  {
8861 	    if (!info->keep_memory)
8862 	      free (locsyms);
8863 	    else
8864 	      elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8865 	  }
8866       }
8867 
8868   if (toc_ref != NULL)
8869     free (toc_ref);
8870   return TRUE;
8871 }
8872 
8873 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8874    the values of any global symbols in a toc section that has been
8875    edited.  Globals in toc sections should be a rarity, so this function
8876    sets a flag if any are found in toc sections other than the one just
8877    edited, so that futher hash table traversals can be avoided.  */
8878 
8879 struct adjust_toc_info
8880 {
8881   asection *toc;
8882   unsigned long *skip;
8883   bfd_boolean global_toc_syms;
8884 };
8885 
8886 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8887 
8888 static bfd_boolean
8889 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8890 {
8891   struct ppc_link_hash_entry *eh;
8892   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8893   unsigned long i;
8894 
8895   if (h->root.type != bfd_link_hash_defined
8896       && h->root.type != bfd_link_hash_defweak)
8897     return TRUE;
8898 
8899   eh = (struct ppc_link_hash_entry *) h;
8900   if (eh->adjust_done)
8901     return TRUE;
8902 
8903   if (eh->elf.root.u.def.section == toc_inf->toc)
8904     {
8905       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8906 	i = toc_inf->toc->rawsize >> 3;
8907       else
8908 	i = eh->elf.root.u.def.value >> 3;
8909 
8910       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8911 	{
8912 	  _bfd_error_handler
8913 	    (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8914 	  do
8915 	    ++i;
8916 	  while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8917 	  eh->elf.root.u.def.value = (bfd_vma) i << 3;
8918 	}
8919 
8920       eh->elf.root.u.def.value -= toc_inf->skip[i];
8921       eh->adjust_done = 1;
8922     }
8923   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8924     toc_inf->global_toc_syms = TRUE;
8925 
8926   return TRUE;
8927 }
8928 
8929 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8930    on a _LO variety toc/got reloc.  */
8931 
8932 static bfd_boolean
8933 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8934 {
8935   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8936 	  || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8937 	  || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8938 	  || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8939 	  || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8940 	  || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8941 	  || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8942 	  || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8943 	  || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8944 	  || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8945 	  || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8946 	  || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8947 	  || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8948 	  || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8949 	  || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8950 	  || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8951 	  || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8952 	      /* Exclude lfqu by testing reloc.  If relocs are ever
8953 		 defined for the reduced D field in psq_lu then those
8954 		 will need testing too.  */
8955 	      && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8956 	  || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8957 	      && (insn & 1) == 0)
8958 	  || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8959 	  || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8960 	      /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8961 	      && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8962 	  || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8963 	      && (insn & 1) == 0));
8964 }
8965 
8966 /* Examine all relocs referencing .toc sections in order to remove
8967    unused .toc entries.  */
8968 
8969 bfd_boolean
8970 ppc64_elf_edit_toc (struct bfd_link_info *info)
8971 {
8972   bfd *ibfd;
8973   struct adjust_toc_info toc_inf;
8974   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8975 
8976   htab->do_toc_opt = 1;
8977   toc_inf.global_toc_syms = TRUE;
8978   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8979     {
8980       asection *toc, *sec;
8981       Elf_Internal_Shdr *symtab_hdr;
8982       Elf_Internal_Sym *local_syms;
8983       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8984       unsigned long *skip, *drop;
8985       unsigned char *used;
8986       unsigned char *keep, last, some_unused;
8987 
8988       if (!is_ppc64_elf (ibfd))
8989 	continue;
8990 
8991       toc = bfd_get_section_by_name (ibfd, ".toc");
8992       if (toc == NULL
8993 	  || toc->size == 0
8994 	  || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8995 	  || discarded_section (toc))
8996 	continue;
8997 
8998       toc_relocs = NULL;
8999       local_syms = NULL;
9000       symtab_hdr = &elf_symtab_hdr (ibfd);
9001 
9002       /* Look at sections dropped from the final link.  */
9003       skip = NULL;
9004       relstart = NULL;
9005       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9006 	{
9007 	  if (sec->reloc_count == 0
9008 	      || !discarded_section (sec)
9009 	      || get_opd_info (sec)
9010 	      || (sec->flags & SEC_ALLOC) == 0
9011 	      || (sec->flags & SEC_DEBUGGING) != 0)
9012 	    continue;
9013 
9014 	  relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9015 	  if (relstart == NULL)
9016 	    goto error_ret;
9017 
9018 	  /* Run through the relocs to see which toc entries might be
9019 	     unused.  */
9020 	  for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9021 	    {
9022 	      enum elf_ppc64_reloc_type r_type;
9023 	      unsigned long r_symndx;
9024 	      asection *sym_sec;
9025 	      struct elf_link_hash_entry *h;
9026 	      Elf_Internal_Sym *sym;
9027 	      bfd_vma val;
9028 
9029 	      r_type = ELF64_R_TYPE (rel->r_info);
9030 	      switch (r_type)
9031 		{
9032 		default:
9033 		  continue;
9034 
9035 		case R_PPC64_TOC16:
9036 		case R_PPC64_TOC16_LO:
9037 		case R_PPC64_TOC16_HI:
9038 		case R_PPC64_TOC16_HA:
9039 		case R_PPC64_TOC16_DS:
9040 		case R_PPC64_TOC16_LO_DS:
9041 		  break;
9042 		}
9043 
9044 	      r_symndx = ELF64_R_SYM (rel->r_info);
9045 	      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9046 			      r_symndx, ibfd))
9047 		goto error_ret;
9048 
9049 	      if (sym_sec != toc)
9050 		continue;
9051 
9052 	      if (h != NULL)
9053 		val = h->root.u.def.value;
9054 	      else
9055 		val = sym->st_value;
9056 	      val += rel->r_addend;
9057 
9058 	      if (val >= toc->size)
9059 		continue;
9060 
9061 	      /* Anything in the toc ought to be aligned to 8 bytes.
9062 		 If not, don't mark as unused.  */
9063 	      if (val & 7)
9064 		continue;
9065 
9066 	      if (skip == NULL)
9067 		{
9068 		  skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9069 		  if (skip == NULL)
9070 		    goto error_ret;
9071 		}
9072 
9073 	      skip[val >> 3] = ref_from_discarded;
9074 	    }
9075 
9076 	  if (elf_section_data (sec)->relocs != relstart)
9077 	    free (relstart);
9078 	}
9079 
9080       /* For largetoc loads of address constants, we can convert
9081 	 .  addis rx,2,addr@got@ha
9082 	 .  ld ry,addr@got@l(rx)
9083 	 to
9084 	 .  addis rx,2,addr@toc@ha
9085 	 .  addi ry,rx,addr@toc@l
9086 	 when addr is within 2G of the toc pointer.  This then means
9087 	 that the word storing "addr" in the toc is no longer needed.  */
9088 
9089       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9090 	  && toc->output_section->rawsize < (bfd_vma) 1 << 31
9091 	  && toc->reloc_count != 0)
9092 	{
9093 	  /* Read toc relocs.  */
9094 	  toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9095 						  info->keep_memory);
9096 	  if (toc_relocs == NULL)
9097 	    goto error_ret;
9098 
9099 	  for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9100 	    {
9101 	      enum elf_ppc64_reloc_type r_type;
9102 	      unsigned long r_symndx;
9103 	      asection *sym_sec;
9104 	      struct elf_link_hash_entry *h;
9105 	      Elf_Internal_Sym *sym;
9106 	      bfd_vma val, addr;
9107 
9108 	      r_type = ELF64_R_TYPE (rel->r_info);
9109 	      if (r_type != R_PPC64_ADDR64)
9110 		continue;
9111 
9112 	      r_symndx = ELF64_R_SYM (rel->r_info);
9113 	      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9114 			      r_symndx, ibfd))
9115 		goto error_ret;
9116 
9117 	      if (sym_sec == NULL
9118 		  || sym_sec->output_section == NULL
9119 		  || discarded_section (sym_sec))
9120 		continue;
9121 
9122 	      if (!SYMBOL_REFERENCES_LOCAL (info, h))
9123 		continue;
9124 
9125 	      if (h != NULL)
9126 		{
9127 		  if (h->type == STT_GNU_IFUNC)
9128 		    continue;
9129 		  val = h->root.u.def.value;
9130 		}
9131 	      else
9132 		{
9133 		  if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9134 		    continue;
9135 		  val = sym->st_value;
9136 		}
9137 	      val += rel->r_addend;
9138 	      val += sym_sec->output_section->vma + sym_sec->output_offset;
9139 
9140 	      /* We don't yet know the exact toc pointer value, but we
9141 		 know it will be somewhere in the toc section.  Don't
9142 		 optimize if the difference from any possible toc
9143 		 pointer is outside [ff..f80008000, 7fff7fff].  */
9144 	      addr = toc->output_section->vma + TOC_BASE_OFF;
9145 	      if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9146 		continue;
9147 
9148 	      addr = toc->output_section->vma + toc->output_section->rawsize;
9149 	      if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9150 		continue;
9151 
9152 	      if (skip == NULL)
9153 		{
9154 		  skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9155 		  if (skip == NULL)
9156 		    goto error_ret;
9157 		}
9158 
9159 	      skip[rel->r_offset >> 3]
9160 		|= can_optimize | ((rel - toc_relocs) << 2);
9161 	    }
9162 	}
9163 
9164       if (skip == NULL)
9165 	continue;
9166 
9167       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9168       if (used == NULL)
9169 	{
9170 	error_ret:
9171 	  if (local_syms != NULL
9172 	      && symtab_hdr->contents != (unsigned char *) local_syms)
9173 	    free (local_syms);
9174 	  if (sec != NULL
9175 	      && relstart != NULL
9176 	      && elf_section_data (sec)->relocs != relstart)
9177 	    free (relstart);
9178 	  if (toc_relocs != NULL
9179 	      && elf_section_data (toc)->relocs != toc_relocs)
9180 	    free (toc_relocs);
9181 	  if (skip != NULL)
9182 	    free (skip);
9183 	  return FALSE;
9184 	}
9185 
9186       /* Now check all kept sections that might reference the toc.
9187 	 Check the toc itself last.  */
9188       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9189 		  : ibfd->sections);
9190 	   sec != NULL;
9191 	   sec = (sec == toc ? NULL
9192 		  : sec->next == NULL ? toc
9193 		  : sec->next == toc && toc->next ? toc->next
9194 		  : sec->next))
9195 	{
9196 	  int repeat;
9197 
9198 	  if (sec->reloc_count == 0
9199 	      || discarded_section (sec)
9200 	      || get_opd_info (sec)
9201 	      || (sec->flags & SEC_ALLOC) == 0
9202 	      || (sec->flags & SEC_DEBUGGING) != 0)
9203 	    continue;
9204 
9205 	  relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9206 						info->keep_memory);
9207 	  if (relstart == NULL)
9208 	    {
9209 	      free (used);
9210 	      goto error_ret;
9211 	    }
9212 
9213 	  /* Mark toc entries referenced as used.  */
9214 	  do
9215 	    {
9216 	      repeat = 0;
9217 	      for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9218 		{
9219 		  enum elf_ppc64_reloc_type r_type;
9220 		  unsigned long r_symndx;
9221 		  asection *sym_sec;
9222 		  struct elf_link_hash_entry *h;
9223 		  Elf_Internal_Sym *sym;
9224 		  bfd_vma val;
9225 		  enum {no_check, check_lo, check_ha} insn_check;
9226 
9227 		  r_type = ELF64_R_TYPE (rel->r_info);
9228 		  switch (r_type)
9229 		    {
9230 		    default:
9231 		      insn_check = no_check;
9232 		      break;
9233 
9234 		    case R_PPC64_GOT_TLSLD16_HA:
9235 		    case R_PPC64_GOT_TLSGD16_HA:
9236 		    case R_PPC64_GOT_TPREL16_HA:
9237 		    case R_PPC64_GOT_DTPREL16_HA:
9238 		    case R_PPC64_GOT16_HA:
9239 		    case R_PPC64_TOC16_HA:
9240 		      insn_check = check_ha;
9241 		      break;
9242 
9243 		    case R_PPC64_GOT_TLSLD16_LO:
9244 		    case R_PPC64_GOT_TLSGD16_LO:
9245 		    case R_PPC64_GOT_TPREL16_LO_DS:
9246 		    case R_PPC64_GOT_DTPREL16_LO_DS:
9247 		    case R_PPC64_GOT16_LO:
9248 		    case R_PPC64_GOT16_LO_DS:
9249 		    case R_PPC64_TOC16_LO:
9250 		    case R_PPC64_TOC16_LO_DS:
9251 		      insn_check = check_lo;
9252 		      break;
9253 		    }
9254 
9255 		  if (insn_check != no_check)
9256 		    {
9257 		      bfd_vma off = rel->r_offset & ~3;
9258 		      unsigned char buf[4];
9259 		      unsigned int insn;
9260 
9261 		      if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9262 			{
9263 			  free (used);
9264 			  goto error_ret;
9265 			}
9266 		      insn = bfd_get_32 (ibfd, buf);
9267 		      if (insn_check == check_lo
9268 			  ? !ok_lo_toc_insn (insn, r_type)
9269 			  : ((insn & ((0x3f << 26) | 0x1f << 16))
9270 			     != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9271 			{
9272 			  char str[12];
9273 
9274 			  ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9275 			  sprintf (str, "%#08x", insn);
9276 			  info->callbacks->einfo
9277 			    /* xgettext:c-format */
9278 			    (_("%H: toc optimization is not supported for"
9279 			       " %s instruction.\n"),
9280 			     ibfd, sec, rel->r_offset & ~3, str);
9281 			}
9282 		    }
9283 
9284 		  switch (r_type)
9285 		    {
9286 		    case R_PPC64_TOC16:
9287 		    case R_PPC64_TOC16_LO:
9288 		    case R_PPC64_TOC16_HI:
9289 		    case R_PPC64_TOC16_HA:
9290 		    case R_PPC64_TOC16_DS:
9291 		    case R_PPC64_TOC16_LO_DS:
9292 		      /* In case we're taking addresses of toc entries.  */
9293 		    case R_PPC64_ADDR64:
9294 		      break;
9295 
9296 		    default:
9297 		      continue;
9298 		    }
9299 
9300 		  r_symndx = ELF64_R_SYM (rel->r_info);
9301 		  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9302 				  r_symndx, ibfd))
9303 		    {
9304 		      free (used);
9305 		      goto error_ret;
9306 		    }
9307 
9308 		  if (sym_sec != toc)
9309 		    continue;
9310 
9311 		  if (h != NULL)
9312 		    val = h->root.u.def.value;
9313 		  else
9314 		    val = sym->st_value;
9315 		  val += rel->r_addend;
9316 
9317 		  if (val >= toc->size)
9318 		    continue;
9319 
9320 		  if ((skip[val >> 3] & can_optimize) != 0)
9321 		    {
9322 		      bfd_vma off;
9323 		      unsigned char opc;
9324 
9325 		      switch (r_type)
9326 			{
9327 			case R_PPC64_TOC16_HA:
9328 			  break;
9329 
9330 			case R_PPC64_TOC16_LO_DS:
9331 			  off = rel->r_offset;
9332 			  off += (bfd_big_endian (ibfd) ? -2 : 3);
9333 			  if (!bfd_get_section_contents (ibfd, sec, &opc,
9334 							 off, 1))
9335 			    {
9336 			      free (used);
9337 			      goto error_ret;
9338 			    }
9339 			  if ((opc & (0x3f << 2)) == (58u << 2))
9340 			    break;
9341 			  /* Fall through.  */
9342 
9343 			default:
9344 			  /* Wrong sort of reloc, or not a ld.  We may
9345 			     as well clear ref_from_discarded too.  */
9346 			  skip[val >> 3] = 0;
9347 			}
9348 		    }
9349 
9350 		  if (sec != toc)
9351 		    used[val >> 3] = 1;
9352 		  /* For the toc section, we only mark as used if this
9353 		     entry itself isn't unused.  */
9354 		  else if ((used[rel->r_offset >> 3]
9355 			    || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9356 			   && !used[val >> 3])
9357 		    {
9358 		      /* Do all the relocs again, to catch reference
9359 			 chains.  */
9360 		      repeat = 1;
9361 		      used[val >> 3] = 1;
9362 		    }
9363 		}
9364 	    }
9365 	  while (repeat);
9366 
9367 	  if (elf_section_data (sec)->relocs != relstart)
9368 	    free (relstart);
9369 	}
9370 
9371       /* Merge the used and skip arrays.  Assume that TOC
9372 	 doublewords not appearing as either used or unused belong
9373 	 to to an entry more than one doubleword in size.  */
9374       for (drop = skip, keep = used, last = 0, some_unused = 0;
9375 	   drop < skip + (toc->size + 7) / 8;
9376 	   ++drop, ++keep)
9377 	{
9378 	  if (*keep)
9379 	    {
9380 	      *drop &= ~ref_from_discarded;
9381 	      if ((*drop & can_optimize) != 0)
9382 		some_unused = 1;
9383 	      last = 0;
9384 	    }
9385 	  else if ((*drop & ref_from_discarded) != 0)
9386 	    {
9387 	      some_unused = 1;
9388 	      last = ref_from_discarded;
9389 	    }
9390 	  else
9391 	    *drop = last;
9392 	}
9393 
9394       free (used);
9395 
9396       if (some_unused)
9397 	{
9398 	  bfd_byte *contents, *src;
9399 	  unsigned long off;
9400 	  Elf_Internal_Sym *sym;
9401 	  bfd_boolean local_toc_syms = FALSE;
9402 
9403 	  /* Shuffle the toc contents, and at the same time convert the
9404 	     skip array from booleans into offsets.  */
9405 	  if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9406 	    goto error_ret;
9407 
9408 	  elf_section_data (toc)->this_hdr.contents = contents;
9409 
9410 	  for (src = contents, off = 0, drop = skip;
9411 	       src < contents + toc->size;
9412 	       src += 8, ++drop)
9413 	    {
9414 	      if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9415 		off += 8;
9416 	      else if (off != 0)
9417 		{
9418 		  *drop = off;
9419 		  memcpy (src - off, src, 8);
9420 		}
9421 	    }
9422 	  *drop = off;
9423 	  toc->rawsize = toc->size;
9424 	  toc->size = src - contents - off;
9425 
9426 	  /* Adjust addends for relocs against the toc section sym,
9427 	     and optimize any accesses we can.  */
9428 	  for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9429 	    {
9430 	      if (sec->reloc_count == 0
9431 		  || discarded_section (sec))
9432 		continue;
9433 
9434 	      relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9435 						    info->keep_memory);
9436 	      if (relstart == NULL)
9437 		goto error_ret;
9438 
9439 	      for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9440 		{
9441 		  enum elf_ppc64_reloc_type r_type;
9442 		  unsigned long r_symndx;
9443 		  asection *sym_sec;
9444 		  struct elf_link_hash_entry *h;
9445 		  bfd_vma val;
9446 
9447 		  r_type = ELF64_R_TYPE (rel->r_info);
9448 		  switch (r_type)
9449 		    {
9450 		    default:
9451 		      continue;
9452 
9453 		    case R_PPC64_TOC16:
9454 		    case R_PPC64_TOC16_LO:
9455 		    case R_PPC64_TOC16_HI:
9456 		    case R_PPC64_TOC16_HA:
9457 		    case R_PPC64_TOC16_DS:
9458 		    case R_PPC64_TOC16_LO_DS:
9459 		    case R_PPC64_ADDR64:
9460 		      break;
9461 		    }
9462 
9463 		  r_symndx = ELF64_R_SYM (rel->r_info);
9464 		  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9465 				  r_symndx, ibfd))
9466 		    goto error_ret;
9467 
9468 		  if (sym_sec != toc)
9469 		    continue;
9470 
9471 		  if (h != NULL)
9472 		    val = h->root.u.def.value;
9473 		  else
9474 		    {
9475 		      val = sym->st_value;
9476 		      if (val != 0)
9477 			local_toc_syms = TRUE;
9478 		    }
9479 
9480 		  val += rel->r_addend;
9481 
9482 		  if (val > toc->rawsize)
9483 		    val = toc->rawsize;
9484 		  else if ((skip[val >> 3] & ref_from_discarded) != 0)
9485 		    continue;
9486 		  else if ((skip[val >> 3] & can_optimize) != 0)
9487 		    {
9488 		      Elf_Internal_Rela *tocrel
9489 			= toc_relocs + (skip[val >> 3] >> 2);
9490 		      unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9491 
9492 		      switch (r_type)
9493 			{
9494 			case R_PPC64_TOC16_HA:
9495 			  rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9496 			  break;
9497 
9498 			case R_PPC64_TOC16_LO_DS:
9499 			  rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9500 			  break;
9501 
9502 			default:
9503 			  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9504 			    ppc_howto_init ();
9505 			  info->callbacks->einfo
9506 			    /* xgettext:c-format */
9507 			    (_("%H: %s references "
9508 			       "optimized away TOC entry\n"),
9509 			     ibfd, sec, rel->r_offset,
9510 			     ppc64_elf_howto_table[r_type]->name);
9511 			  bfd_set_error (bfd_error_bad_value);
9512 			  goto error_ret;
9513 			}
9514 		      rel->r_addend = tocrel->r_addend;
9515 		      elf_section_data (sec)->relocs = relstart;
9516 		      continue;
9517 		    }
9518 
9519 		  if (h != NULL || sym->st_value != 0)
9520 		    continue;
9521 
9522 		  rel->r_addend -= skip[val >> 3];
9523 		  elf_section_data (sec)->relocs = relstart;
9524 		}
9525 
9526 	      if (elf_section_data (sec)->relocs != relstart)
9527 		free (relstart);
9528 	    }
9529 
9530 	  /* We shouldn't have local or global symbols defined in the TOC,
9531 	     but handle them anyway.  */
9532 	  if (local_syms != NULL)
9533 	    for (sym = local_syms;
9534 		 sym < local_syms + symtab_hdr->sh_info;
9535 		 ++sym)
9536 	      if (sym->st_value != 0
9537 		  && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9538 		{
9539 		  unsigned long i;
9540 
9541 		  if (sym->st_value > toc->rawsize)
9542 		    i = toc->rawsize >> 3;
9543 		  else
9544 		    i = sym->st_value >> 3;
9545 
9546 		  if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9547 		    {
9548 		      if (local_toc_syms)
9549 			_bfd_error_handler
9550 			  (_("%s defined on removed toc entry"),
9551 			   bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9552 		      do
9553 			++i;
9554 		      while ((skip[i] & (ref_from_discarded | can_optimize)));
9555 		      sym->st_value = (bfd_vma) i << 3;
9556 		    }
9557 
9558 		  sym->st_value -= skip[i];
9559 		  symtab_hdr->contents = (unsigned char *) local_syms;
9560 		}
9561 
9562 	  /* Adjust any global syms defined in this toc input section.  */
9563 	  if (toc_inf.global_toc_syms)
9564 	    {
9565 	      toc_inf.toc = toc;
9566 	      toc_inf.skip = skip;
9567 	      toc_inf.global_toc_syms = FALSE;
9568 	      elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9569 				      &toc_inf);
9570 	    }
9571 
9572 	  if (toc->reloc_count != 0)
9573 	    {
9574 	      Elf_Internal_Shdr *rel_hdr;
9575 	      Elf_Internal_Rela *wrel;
9576 	      bfd_size_type sz;
9577 
9578 	      /* Remove unused toc relocs, and adjust those we keep.  */
9579 	      if (toc_relocs == NULL)
9580 		toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9581 							info->keep_memory);
9582 	      if (toc_relocs == NULL)
9583 		goto error_ret;
9584 
9585 	      wrel = toc_relocs;
9586 	      for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9587 		if ((skip[rel->r_offset >> 3]
9588 		     & (ref_from_discarded | can_optimize)) == 0)
9589 		  {
9590 		    wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9591 		    wrel->r_info = rel->r_info;
9592 		    wrel->r_addend = rel->r_addend;
9593 		    ++wrel;
9594 		  }
9595 		else if (!dec_dynrel_count (rel->r_info, toc, info,
9596 					    &local_syms, NULL, NULL))
9597 		  goto error_ret;
9598 
9599 	      elf_section_data (toc)->relocs = toc_relocs;
9600 	      toc->reloc_count = wrel - toc_relocs;
9601 	      rel_hdr = _bfd_elf_single_rel_hdr (toc);
9602 	      sz = rel_hdr->sh_entsize;
9603 	      rel_hdr->sh_size = toc->reloc_count * sz;
9604 	    }
9605 	}
9606       else if (toc_relocs != NULL
9607 	       && elf_section_data (toc)->relocs != toc_relocs)
9608 	free (toc_relocs);
9609 
9610       if (local_syms != NULL
9611 	  && symtab_hdr->contents != (unsigned char *) local_syms)
9612 	{
9613 	  if (!info->keep_memory)
9614 	    free (local_syms);
9615 	  else
9616 	    symtab_hdr->contents = (unsigned char *) local_syms;
9617 	}
9618       free (skip);
9619     }
9620 
9621   return TRUE;
9622 }
9623 
9624 /* Return true iff input section I references the TOC using
9625    instructions limited to +/-32k offsets.  */
9626 
9627 bfd_boolean
9628 ppc64_elf_has_small_toc_reloc (asection *i)
9629 {
9630   return (is_ppc64_elf (i->owner)
9631 	  && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9632 }
9633 
9634 /* Allocate space for one GOT entry.  */
9635 
9636 static void
9637 allocate_got (struct elf_link_hash_entry *h,
9638 	      struct bfd_link_info *info,
9639 	      struct got_entry *gent)
9640 {
9641   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9642   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9643   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9644 		 ? 16 : 8);
9645   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9646 		  ? 2 : 1) * sizeof (Elf64_External_Rela);
9647   asection *got = ppc64_elf_tdata (gent->owner)->got;
9648 
9649   gent->got.offset = got->size;
9650   got->size += entsize;
9651 
9652   if (h->type == STT_GNU_IFUNC)
9653     {
9654       htab->elf.irelplt->size += rentsize;
9655       htab->got_reli_size += rentsize;
9656     }
9657   else if ((bfd_link_pic (info)
9658 	    || (htab->elf.dynamic_sections_created
9659 		&& h->dynindx != -1
9660 		&& !SYMBOL_REFERENCES_LOCAL (info, h)))
9661 	   && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9662 	       || h->root.type != bfd_link_hash_undefweak))
9663     {
9664       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9665       relgot->size += rentsize;
9666     }
9667 }
9668 
9669 /* This function merges got entries in the same toc group.  */
9670 
9671 static void
9672 merge_got_entries (struct got_entry **pent)
9673 {
9674   struct got_entry *ent, *ent2;
9675 
9676   for (ent = *pent; ent != NULL; ent = ent->next)
9677     if (!ent->is_indirect)
9678       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9679 	if (!ent2->is_indirect
9680 	    && ent2->addend == ent->addend
9681 	    && ent2->tls_type == ent->tls_type
9682 	    && elf_gp (ent2->owner) == elf_gp (ent->owner))
9683 	  {
9684 	    ent2->is_indirect = TRUE;
9685 	    ent2->got.ent = ent;
9686 	  }
9687 }
9688 
9689 /* If H is undefined weak, make it dynamic if that makes sense.  */
9690 
9691 static bfd_boolean
9692 ensure_undefweak_dynamic (struct bfd_link_info *info,
9693 			  struct elf_link_hash_entry *h)
9694 {
9695   struct elf_link_hash_table *htab = elf_hash_table (info);
9696 
9697   if (htab->dynamic_sections_created
9698       && h->root.type == bfd_link_hash_undefweak
9699       && h->dynindx == -1
9700       && !h->forced_local
9701       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9702     return bfd_elf_link_record_dynamic_symbol (info, h);
9703   return TRUE;
9704 }
9705 
9706 /* Allocate space in .plt, .got and associated reloc sections for
9707    dynamic relocs.  */
9708 
9709 static bfd_boolean
9710 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9711 {
9712   struct bfd_link_info *info;
9713   struct ppc_link_hash_table *htab;
9714   asection *s;
9715   struct ppc_link_hash_entry *eh;
9716   struct got_entry **pgent, *gent;
9717 
9718   if (h->root.type == bfd_link_hash_indirect)
9719     return TRUE;
9720 
9721   info = (struct bfd_link_info *) inf;
9722   htab = ppc_hash_table (info);
9723   if (htab == NULL)
9724     return FALSE;
9725 
9726   eh = (struct ppc_link_hash_entry *) h;
9727   /* Run through the TLS GD got entries first if we're changing them
9728      to TPREL.  */
9729   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9730     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9731       if (gent->got.refcount > 0
9732 	  && (gent->tls_type & TLS_GD) != 0)
9733 	{
9734 	  /* This was a GD entry that has been converted to TPREL.  If
9735 	     there happens to be a TPREL entry we can use that one.  */
9736 	  struct got_entry *ent;
9737 	  for (ent = h->got.glist; ent != NULL; ent = ent->next)
9738 	    if (ent->got.refcount > 0
9739 		&& (ent->tls_type & TLS_TPREL) != 0
9740 		&& ent->addend == gent->addend
9741 		&& ent->owner == gent->owner)
9742 	      {
9743 		gent->got.refcount = 0;
9744 		break;
9745 	      }
9746 
9747 	  /* If not, then we'll be using our own TPREL entry.  */
9748 	  if (gent->got.refcount != 0)
9749 	    gent->tls_type = TLS_TLS | TLS_TPREL;
9750 	}
9751 
9752   /* Remove any list entry that won't generate a word in the GOT before
9753      we call merge_got_entries.  Otherwise we risk merging to empty
9754      entries.  */
9755   pgent = &h->got.glist;
9756   while ((gent = *pgent) != NULL)
9757     if (gent->got.refcount > 0)
9758       {
9759 	if ((gent->tls_type & TLS_LD) != 0
9760 	    && !h->def_dynamic)
9761 	  {
9762 	    ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9763 	    *pgent = gent->next;
9764 	  }
9765 	else
9766 	  pgent = &gent->next;
9767       }
9768     else
9769       *pgent = gent->next;
9770 
9771   if (!htab->do_multi_toc)
9772     merge_got_entries (&h->got.glist);
9773 
9774   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9775     if (!gent->is_indirect)
9776       {
9777 	/* Make sure this symbol is output as a dynamic symbol.
9778 	   Undefined weak syms won't yet be marked as dynamic.  */
9779 	if (!ensure_undefweak_dynamic (info, h))
9780 	  return FALSE;
9781 
9782 	if (!is_ppc64_elf (gent->owner))
9783 	  abort ();
9784 
9785 	allocate_got (h, info, gent);
9786       }
9787 
9788   if (!htab->elf.dynamic_sections_created
9789       && h->type != STT_GNU_IFUNC)
9790     eh->dyn_relocs = NULL;
9791 
9792   if (eh->dyn_relocs != NULL)
9793     {
9794       struct elf_dyn_relocs *p, **pp;
9795 
9796       /* In the shared -Bsymbolic case, discard space allocated for
9797 	 dynamic pc-relative relocs against symbols which turn out to
9798 	 be defined in regular objects.  For the normal shared case,
9799 	 discard space for relocs that have become local due to symbol
9800 	 visibility changes.  */
9801 
9802       if (bfd_link_pic (info))
9803 	{
9804 	  /* Relocs that use pc_count are those that appear on a call
9805 	     insn, or certain REL relocs (see must_be_dyn_reloc) that
9806 	     can be generated via assembly.  We want calls to
9807 	     protected symbols to resolve directly to the function
9808 	     rather than going via the plt.  If people want function
9809 	     pointer comparisons to work as expected then they should
9810 	     avoid writing weird assembly.  */
9811 	  if (SYMBOL_CALLS_LOCAL (info, h))
9812 	    {
9813 	      for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9814 		{
9815 		  p->count -= p->pc_count;
9816 		  p->pc_count = 0;
9817 		  if (p->count == 0)
9818 		    *pp = p->next;
9819 		  else
9820 		    pp = &p->next;
9821 		}
9822 	    }
9823 
9824 	  /* Also discard relocs on undefined weak syms with
9825 	     non-default visibility.  */
9826 	  if (eh->dyn_relocs != NULL
9827 	      && h->root.type == bfd_link_hash_undefweak)
9828 	    {
9829 	      if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9830 		eh->dyn_relocs = NULL;
9831 
9832 	      /* Make sure this symbol is output as a dynamic symbol.
9833 		 Undefined weak syms won't yet be marked as dynamic.  */
9834 	      else if (!ensure_undefweak_dynamic (info, h))
9835 		return FALSE;
9836 	    }
9837 	}
9838       else if (h->type == STT_GNU_IFUNC)
9839 	{
9840 	  /* A plt entry is always created when making direct calls to
9841 	     an ifunc, even when building a static executable, but
9842 	     that doesn't cover all cases.  We may have only an ifunc
9843 	     initialised function pointer for a given ifunc symbol.
9844 
9845 	     For ELFv2, dynamic relocations are not required when
9846 	     generating a global entry PLT stub.  */
9847 	  if (abiversion (info->output_bfd) >= 2)
9848 	    {
9849 	      if (global_entry_stub (h))
9850 		eh->dyn_relocs = NULL;
9851 	    }
9852 
9853 	  /* For ELFv1 we have function descriptors.  Descriptors need
9854 	     to be treated like PLT entries and thus have dynamic
9855 	     relocations.  One exception is when the function
9856 	     descriptor is copied into .dynbss (which should only
9857 	     happen with ancient versions of gcc).  */
9858 	  else if (h->needs_copy)
9859 	    eh->dyn_relocs = NULL;
9860 	}
9861       else if (ELIMINATE_COPY_RELOCS)
9862 	{
9863 	  /* For the non-pic case, discard space for relocs against
9864 	     symbols which turn out to need copy relocs or are not
9865 	     dynamic.  */
9866 	  if (!h->non_got_ref
9867 	      && !h->def_regular)
9868 	    {
9869 	      /* Make sure this symbol is output as a dynamic symbol.
9870 		 Undefined weak syms won't yet be marked as dynamic.  */
9871 	      if (!ensure_undefweak_dynamic (info, h))
9872 		return FALSE;
9873 
9874 	      if (h->dynindx == -1)
9875 		eh->dyn_relocs = NULL;
9876 	    }
9877 	  else
9878 	    eh->dyn_relocs = NULL;
9879 	}
9880 
9881       /* Finally, allocate space.  */
9882       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9883 	{
9884 	  asection *sreloc = elf_section_data (p->sec)->sreloc;
9885 	  if (eh->elf.type == STT_GNU_IFUNC)
9886 	    sreloc = htab->elf.irelplt;
9887 	  sreloc->size += p->count * sizeof (Elf64_External_Rela);
9888 	}
9889     }
9890 
9891   if ((htab->elf.dynamic_sections_created
9892        && h->dynindx != -1)
9893       || h->type == STT_GNU_IFUNC)
9894     {
9895       struct plt_entry *pent;
9896       bfd_boolean doneone = FALSE;
9897       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9898 	if (pent->plt.refcount > 0)
9899 	  {
9900 	    if (!htab->elf.dynamic_sections_created
9901 		|| h->dynindx == -1)
9902 	      {
9903 		s = htab->elf.iplt;
9904 		pent->plt.offset = s->size;
9905 		s->size += PLT_ENTRY_SIZE (htab);
9906 		s = htab->elf.irelplt;
9907 	      }
9908 	    else
9909 	      {
9910 		/* If this is the first .plt entry, make room for the special
9911 		   first entry.  */
9912 		s = htab->elf.splt;
9913 		if (s->size == 0)
9914 		  s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9915 
9916 		pent->plt.offset = s->size;
9917 
9918 		/* Make room for this entry.  */
9919 		s->size += PLT_ENTRY_SIZE (htab);
9920 
9921 		/* Make room for the .glink code.  */
9922 		s = htab->glink;
9923 		if (s->size == 0)
9924 		  s->size += GLINK_CALL_STUB_SIZE;
9925 		if (htab->opd_abi)
9926 		  {
9927 		    /* We need bigger stubs past index 32767.  */
9928 		    if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9929 		      s->size += 4;
9930 		    s->size += 2*4;
9931 		  }
9932 		else
9933 		  s->size += 4;
9934 
9935 		/* We also need to make an entry in the .rela.plt section.  */
9936 		s = htab->elf.srelplt;
9937 	      }
9938 	    s->size += sizeof (Elf64_External_Rela);
9939 	    doneone = TRUE;
9940 	  }
9941 	else
9942 	  pent->plt.offset = (bfd_vma) -1;
9943       if (!doneone)
9944 	{
9945 	  h->plt.plist = NULL;
9946 	  h->needs_plt = 0;
9947 	}
9948     }
9949   else
9950     {
9951       h->plt.plist = NULL;
9952       h->needs_plt = 0;
9953     }
9954 
9955   return TRUE;
9956 }
9957 
9958 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9959    to set up space for global entry stubs.  These are put in glink,
9960    after the branch table.  */
9961 
9962 static bfd_boolean
9963 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9964 {
9965   struct bfd_link_info *info;
9966   struct ppc_link_hash_table *htab;
9967   struct plt_entry *pent;
9968   asection *s;
9969 
9970   if (h->root.type == bfd_link_hash_indirect)
9971     return TRUE;
9972 
9973   if (!h->pointer_equality_needed)
9974     return TRUE;
9975 
9976   if (h->def_regular)
9977     return TRUE;
9978 
9979   info = inf;
9980   htab = ppc_hash_table (info);
9981   if (htab == NULL)
9982     return FALSE;
9983 
9984   s = htab->glink;
9985   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9986     if (pent->plt.offset != (bfd_vma) -1
9987 	&& pent->addend == 0)
9988       {
9989 	/* For ELFv2, if this symbol is not defined in a regular file
9990 	   and we are not generating a shared library or pie, then we
9991 	   need to define the symbol in the executable on a call stub.
9992 	   This is to avoid text relocations.  */
9993 	s->size = (s->size + 15) & -16;
9994 	h->root.type = bfd_link_hash_defined;
9995 	h->root.u.def.section = s;
9996 	h->root.u.def.value = s->size;
9997 	s->size += 16;
9998 	break;
9999       }
10000   return TRUE;
10001 }
10002 
10003 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10004    read-only sections.  */
10005 
10006 static bfd_boolean
10007 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10008 {
10009   if (h->root.type == bfd_link_hash_indirect)
10010     return TRUE;
10011 
10012   if (readonly_dynrelocs (h))
10013     {
10014       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10015 
10016       /* Not an error, just cut short the traversal.  */
10017       return FALSE;
10018     }
10019   return TRUE;
10020 }
10021 
10022 /* Set the sizes of the dynamic sections.  */
10023 
10024 static bfd_boolean
10025 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10026 				 struct bfd_link_info *info)
10027 {
10028   struct ppc_link_hash_table *htab;
10029   bfd *dynobj;
10030   asection *s;
10031   bfd_boolean relocs;
10032   bfd *ibfd;
10033   struct got_entry *first_tlsld;
10034 
10035   htab = ppc_hash_table (info);
10036   if (htab == NULL)
10037     return FALSE;
10038 
10039   dynobj = htab->elf.dynobj;
10040   if (dynobj == NULL)
10041     abort ();
10042 
10043   if (htab->elf.dynamic_sections_created)
10044     {
10045       /* Set the contents of the .interp section to the interpreter.  */
10046       if (bfd_link_executable (info) && !info->nointerp)
10047 	{
10048 	  s = bfd_get_linker_section (dynobj, ".interp");
10049 	  if (s == NULL)
10050 	    abort ();
10051 	  s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10052 	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10053 	}
10054     }
10055 
10056   /* Set up .got offsets for local syms, and space for local dynamic
10057      relocs.  */
10058   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10059     {
10060       struct got_entry **lgot_ents;
10061       struct got_entry **end_lgot_ents;
10062       struct plt_entry **local_plt;
10063       struct plt_entry **end_local_plt;
10064       unsigned char *lgot_masks;
10065       bfd_size_type locsymcount;
10066       Elf_Internal_Shdr *symtab_hdr;
10067 
10068       if (!is_ppc64_elf (ibfd))
10069 	continue;
10070 
10071       for (s = ibfd->sections; s != NULL; s = s->next)
10072 	{
10073 	  struct ppc_dyn_relocs *p;
10074 
10075 	  for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10076 	    {
10077 	      if (!bfd_is_abs_section (p->sec)
10078 		  && bfd_is_abs_section (p->sec->output_section))
10079 		{
10080 		  /* Input section has been discarded, either because
10081 		     it is a copy of a linkonce section or due to
10082 		     linker script /DISCARD/, so we'll be discarding
10083 		     the relocs too.  */
10084 		}
10085 	      else if (p->count != 0)
10086 		{
10087 		  asection *srel = elf_section_data (p->sec)->sreloc;
10088 		  if (p->ifunc)
10089 		    srel = htab->elf.irelplt;
10090 		  srel->size += p->count * sizeof (Elf64_External_Rela);
10091 		  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10092 		    info->flags |= DF_TEXTREL;
10093 		}
10094 	    }
10095 	}
10096 
10097       lgot_ents = elf_local_got_ents (ibfd);
10098       if (!lgot_ents)
10099 	continue;
10100 
10101       symtab_hdr = &elf_symtab_hdr (ibfd);
10102       locsymcount = symtab_hdr->sh_info;
10103       end_lgot_ents = lgot_ents + locsymcount;
10104       local_plt = (struct plt_entry **) end_lgot_ents;
10105       end_local_plt = local_plt + locsymcount;
10106       lgot_masks = (unsigned char *) end_local_plt;
10107       s = ppc64_elf_tdata (ibfd)->got;
10108       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10109 	{
10110 	  struct got_entry **pent, *ent;
10111 
10112 	  pent = lgot_ents;
10113 	  while ((ent = *pent) != NULL)
10114 	    if (ent->got.refcount > 0)
10115 	      {
10116 		if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10117 		  {
10118 		    ppc64_tlsld_got (ibfd)->got.refcount += 1;
10119 		    *pent = ent->next;
10120 		  }
10121 		else
10122 		  {
10123 		    unsigned int ent_size = 8;
10124 		    unsigned int rel_size = sizeof (Elf64_External_Rela);
10125 
10126 		    ent->got.offset = s->size;
10127 		    if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10128 		      {
10129 			ent_size *= 2;
10130 			rel_size *= 2;
10131 		      }
10132 		    s->size += ent_size;
10133 		    if ((*lgot_masks & PLT_IFUNC) != 0)
10134 		      {
10135 			htab->elf.irelplt->size += rel_size;
10136 			htab->got_reli_size += rel_size;
10137 		      }
10138 		    else if (bfd_link_pic (info))
10139 		      {
10140 			asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10141 			srel->size += rel_size;
10142 		      }
10143 		    pent = &ent->next;
10144 		  }
10145 	      }
10146 	    else
10147 	      *pent = ent->next;
10148 	}
10149 
10150       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10151       for (; local_plt < end_local_plt; ++local_plt)
10152 	{
10153 	  struct plt_entry *ent;
10154 
10155 	  for (ent = *local_plt; ent != NULL; ent = ent->next)
10156 	    if (ent->plt.refcount > 0)
10157 	      {
10158 		s = htab->elf.iplt;
10159 		ent->plt.offset = s->size;
10160 		s->size += PLT_ENTRY_SIZE (htab);
10161 
10162 		htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10163 	      }
10164 	    else
10165 	      ent->plt.offset = (bfd_vma) -1;
10166 	}
10167     }
10168 
10169   /* Allocate global sym .plt and .got entries, and space for global
10170      sym dynamic relocs.  */
10171   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10172   /* Stash the end of glink branch table.  */
10173   if (htab->glink != NULL)
10174     htab->glink->rawsize = htab->glink->size;
10175 
10176   if (!htab->opd_abi && !bfd_link_pic (info))
10177     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10178 
10179   first_tlsld = NULL;
10180   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10181     {
10182       struct got_entry *ent;
10183 
10184       if (!is_ppc64_elf (ibfd))
10185 	continue;
10186 
10187       ent = ppc64_tlsld_got (ibfd);
10188       if (ent->got.refcount > 0)
10189 	{
10190 	  if (!htab->do_multi_toc && first_tlsld != NULL)
10191 	    {
10192 	      ent->is_indirect = TRUE;
10193 	      ent->got.ent = first_tlsld;
10194 	    }
10195 	  else
10196 	    {
10197 	      if (first_tlsld == NULL)
10198 		first_tlsld = ent;
10199 	      s = ppc64_elf_tdata (ibfd)->got;
10200 	      ent->got.offset = s->size;
10201 	      ent->owner = ibfd;
10202 	      s->size += 16;
10203 	      if (bfd_link_pic (info))
10204 		{
10205 		  asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10206 		  srel->size += sizeof (Elf64_External_Rela);
10207 		}
10208 	    }
10209 	}
10210       else
10211 	ent->got.offset = (bfd_vma) -1;
10212     }
10213 
10214   /* We now have determined the sizes of the various dynamic sections.
10215      Allocate memory for them.  */
10216   relocs = FALSE;
10217   for (s = dynobj->sections; s != NULL; s = s->next)
10218     {
10219       if ((s->flags & SEC_LINKER_CREATED) == 0)
10220 	continue;
10221 
10222       if (s == htab->brlt || s == htab->relbrlt)
10223 	/* These haven't been allocated yet;  don't strip.  */
10224 	continue;
10225       else if (s == htab->elf.sgot
10226 	       || s == htab->elf.splt
10227 	       || s == htab->elf.iplt
10228 	       || s == htab->glink
10229 	       || s == htab->elf.sdynbss
10230 	       || s == htab->elf.sdynrelro)
10231 	{
10232 	  /* Strip this section if we don't need it; see the
10233 	     comment below.  */
10234 	}
10235       else if (s == htab->glink_eh_frame)
10236 	{
10237 	  if (!bfd_is_abs_section (s->output_section))
10238 	    /* Not sized yet.  */
10239 	    continue;
10240 	}
10241       else if (CONST_STRNEQ (s->name, ".rela"))
10242 	{
10243 	  if (s->size != 0)
10244 	    {
10245 	      if (s != htab->elf.srelplt)
10246 		relocs = TRUE;
10247 
10248 	      /* We use the reloc_count field as a counter if we need
10249 		 to copy relocs into the output file.  */
10250 	      s->reloc_count = 0;
10251 	    }
10252 	}
10253       else
10254 	{
10255 	  /* It's not one of our sections, so don't allocate space.  */
10256 	  continue;
10257 	}
10258 
10259       if (s->size == 0)
10260 	{
10261 	  /* If we don't need this section, strip it from the
10262 	     output file.  This is mostly to handle .rela.bss and
10263 	     .rela.plt.  We must create both sections in
10264 	     create_dynamic_sections, because they must be created
10265 	     before the linker maps input sections to output
10266 	     sections.  The linker does that before
10267 	     adjust_dynamic_symbol is called, and it is that
10268 	     function which decides whether anything needs to go
10269 	     into these sections.  */
10270 	  s->flags |= SEC_EXCLUDE;
10271 	  continue;
10272 	}
10273 
10274       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10275 	continue;
10276 
10277       /* Allocate memory for the section contents.  We use bfd_zalloc
10278 	 here in case unused entries are not reclaimed before the
10279 	 section's contents are written out.  This should not happen,
10280 	 but this way if it does we get a R_PPC64_NONE reloc in .rela
10281 	 sections instead of garbage.
10282 	 We also rely on the section contents being zero when writing
10283 	 the GOT and .dynrelro.  */
10284       s->contents = bfd_zalloc (dynobj, s->size);
10285       if (s->contents == NULL)
10286 	return FALSE;
10287     }
10288 
10289   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10290     {
10291       if (!is_ppc64_elf (ibfd))
10292 	continue;
10293 
10294       s = ppc64_elf_tdata (ibfd)->got;
10295       if (s != NULL && s != htab->elf.sgot)
10296 	{
10297 	  if (s->size == 0)
10298 	    s->flags |= SEC_EXCLUDE;
10299 	  else
10300 	    {
10301 	      s->contents = bfd_zalloc (ibfd, s->size);
10302 	      if (s->contents == NULL)
10303 		return FALSE;
10304 	    }
10305 	}
10306       s = ppc64_elf_tdata (ibfd)->relgot;
10307       if (s != NULL)
10308 	{
10309 	  if (s->size == 0)
10310 	    s->flags |= SEC_EXCLUDE;
10311 	  else
10312 	    {
10313 	      s->contents = bfd_zalloc (ibfd, s->size);
10314 	      if (s->contents == NULL)
10315 		return FALSE;
10316 	      relocs = TRUE;
10317 	      s->reloc_count = 0;
10318 	    }
10319 	}
10320     }
10321 
10322   if (htab->elf.dynamic_sections_created)
10323     {
10324       bfd_boolean tls_opt;
10325 
10326       /* Add some entries to the .dynamic section.  We fill in the
10327 	 values later, in ppc64_elf_finish_dynamic_sections, but we
10328 	 must add the entries now so that we get the correct size for
10329 	 the .dynamic section.  The DT_DEBUG entry is filled in by the
10330 	 dynamic linker and used by the debugger.  */
10331 #define add_dynamic_entry(TAG, VAL) \
10332   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10333 
10334       if (bfd_link_executable (info))
10335 	{
10336 	  if (!add_dynamic_entry (DT_DEBUG, 0))
10337 	    return FALSE;
10338 	}
10339 
10340       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10341 	{
10342 	  if (!add_dynamic_entry (DT_PLTGOT, 0)
10343 	      || !add_dynamic_entry (DT_PLTRELSZ, 0)
10344 	      || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10345 	      || !add_dynamic_entry (DT_JMPREL, 0)
10346 	      || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10347 	    return FALSE;
10348 	}
10349 
10350       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10351 	{
10352 	  if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10353 	      || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10354 	    return FALSE;
10355 	}
10356 
10357       tls_opt = (htab->params->tls_get_addr_opt
10358 		 && htab->tls_get_addr_fd != NULL
10359 		 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10360       if (tls_opt || !htab->opd_abi)
10361 	{
10362 	  if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10363 	    return FALSE;
10364 	}
10365 
10366       if (relocs)
10367 	{
10368 	  if (!add_dynamic_entry (DT_RELA, 0)
10369 	      || !add_dynamic_entry (DT_RELASZ, 0)
10370 	      || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10371 	    return FALSE;
10372 
10373 	  /* If any dynamic relocs apply to a read-only section,
10374 	     then we need a DT_TEXTREL entry.  */
10375 	  if ((info->flags & DF_TEXTREL) == 0)
10376 	    elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10377 
10378 	  if ((info->flags & DF_TEXTREL) != 0)
10379 	    {
10380 	      if (!add_dynamic_entry (DT_TEXTREL, 0))
10381 		return FALSE;
10382 	    }
10383 	}
10384     }
10385 #undef add_dynamic_entry
10386 
10387   return TRUE;
10388 }
10389 
10390 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10391 
10392 static bfd_boolean
10393 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10394 {
10395   if (h->plt.plist != NULL
10396       && !h->def_regular
10397       && !h->pointer_equality_needed)
10398     return FALSE;
10399 
10400   return _bfd_elf_hash_symbol (h);
10401 }
10402 
10403 /* Determine the type of stub needed, if any, for a call.  */
10404 
10405 static inline enum ppc_stub_type
10406 ppc_type_of_stub (asection *input_sec,
10407 		  const Elf_Internal_Rela *rel,
10408 		  struct ppc_link_hash_entry **hash,
10409 		  struct plt_entry **plt_ent,
10410 		  bfd_vma destination,
10411 		  unsigned long local_off)
10412 {
10413   struct ppc_link_hash_entry *h = *hash;
10414   bfd_vma location;
10415   bfd_vma branch_offset;
10416   bfd_vma max_branch_offset;
10417   enum elf_ppc64_reloc_type r_type;
10418 
10419   if (h != NULL)
10420     {
10421       struct plt_entry *ent;
10422       struct ppc_link_hash_entry *fdh = h;
10423       if (h->oh != NULL
10424 	  && h->oh->is_func_descriptor)
10425 	{
10426 	  fdh = ppc_follow_link (h->oh);
10427 	  *hash = fdh;
10428 	}
10429 
10430       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10431 	if (ent->addend == rel->r_addend
10432 	    && ent->plt.offset != (bfd_vma) -1)
10433 	  {
10434 	    *plt_ent = ent;
10435 	    return ppc_stub_plt_call;
10436 	  }
10437 
10438       /* Here, we know we don't have a plt entry.  If we don't have a
10439 	 either a defined function descriptor or a defined entry symbol
10440 	 in a regular object file, then it is pointless trying to make
10441 	 any other type of stub.  */
10442       if (!is_static_defined (&fdh->elf)
10443 	  && !is_static_defined (&h->elf))
10444 	return ppc_stub_none;
10445     }
10446   else if (elf_local_got_ents (input_sec->owner) != NULL)
10447     {
10448       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10449       struct plt_entry **local_plt = (struct plt_entry **)
10450 	elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10451       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10452 
10453       if (local_plt[r_symndx] != NULL)
10454 	{
10455 	  struct plt_entry *ent;
10456 
10457 	  for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10458 	    if (ent->addend == rel->r_addend
10459 		&& ent->plt.offset != (bfd_vma) -1)
10460 	      {
10461 		*plt_ent = ent;
10462 		return ppc_stub_plt_call;
10463 	      }
10464 	}
10465     }
10466 
10467   /* Determine where the call point is.  */
10468   location = (input_sec->output_offset
10469 	      + input_sec->output_section->vma
10470 	      + rel->r_offset);
10471 
10472   branch_offset = destination - location;
10473   r_type = ELF64_R_TYPE (rel->r_info);
10474 
10475   /* Determine if a long branch stub is needed.  */
10476   max_branch_offset = 1 << 25;
10477   if (r_type != R_PPC64_REL24)
10478     max_branch_offset = 1 << 15;
10479 
10480   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10481     /* We need a stub.  Figure out whether a long_branch or plt_branch
10482        is needed later.  */
10483     return ppc_stub_long_branch;
10484 
10485   return ppc_stub_none;
10486 }
10487 
10488 /* With power7 weakly ordered memory model, it is possible for ld.so
10489    to update a plt entry in one thread and have another thread see a
10490    stale zero toc entry.  To avoid this we need some sort of acquire
10491    barrier in the call stub.  One solution is to make the load of the
10492    toc word seem to appear to depend on the load of the function entry
10493    word.  Another solution is to test for r2 being zero, and branch to
10494    the appropriate glink entry if so.
10495 
10496    .	fake dep barrier	compare
10497    .	ld 12,xxx(2)		ld 12,xxx(2)
10498    .	mtctr 12		mtctr 12
10499    .	xor 11,12,12		ld 2,xxx+8(2)
10500    .	add 2,2,11		cmpldi 2,0
10501    .	ld 2,xxx+8(2)		bnectr+
10502    .	bctr			b <glink_entry>
10503 
10504    The solution involving the compare turns out to be faster, so
10505    that's what we use unless the branch won't reach.  */
10506 
10507 #define ALWAYS_USE_FAKE_DEP 0
10508 #define ALWAYS_EMIT_R2SAVE 0
10509 
10510 #define PPC_LO(v) ((v) & 0xffff)
10511 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10512 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10513 
10514 static inline unsigned int
10515 plt_stub_size (struct ppc_link_hash_table *htab,
10516 	       struct ppc_stub_hash_entry *stub_entry,
10517 	       bfd_vma off)
10518 {
10519   unsigned size = 12;
10520 
10521   if (ALWAYS_EMIT_R2SAVE
10522       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10523     size += 4;
10524   if (PPC_HA (off) != 0)
10525     size += 4;
10526   if (htab->opd_abi)
10527     {
10528       size += 4;
10529       if (htab->params->plt_static_chain)
10530 	size += 4;
10531       if (htab->params->plt_thread_safe
10532 	  && htab->elf.dynamic_sections_created
10533 	  && stub_entry->h != NULL
10534 	  && stub_entry->h->elf.dynindx != -1)
10535 	size += 8;
10536       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10537 	size += 4;
10538     }
10539   if (stub_entry->h != NULL
10540       && (stub_entry->h == htab->tls_get_addr_fd
10541 	  || stub_entry->h == htab->tls_get_addr)
10542       && htab->params->tls_get_addr_opt)
10543     size += 13 * 4;
10544   return size;
10545 }
10546 
10547 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10548    then return the padding needed to do so.  */
10549 static inline unsigned int
10550 plt_stub_pad (struct ppc_link_hash_table *htab,
10551 	      struct ppc_stub_hash_entry *stub_entry,
10552 	      bfd_vma plt_off)
10553 {
10554   int stub_align = 1 << htab->params->plt_stub_align;
10555   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10556   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10557 
10558   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10559       > ((stub_size - 1) & -stub_align))
10560     return stub_align - (stub_off & (stub_align - 1));
10561   return 0;
10562 }
10563 
10564 /* Build a .plt call stub.  */
10565 
10566 static inline bfd_byte *
10567 build_plt_stub (struct ppc_link_hash_table *htab,
10568 		struct ppc_stub_hash_entry *stub_entry,
10569 		bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10570 {
10571   bfd *obfd = htab->params->stub_bfd;
10572   bfd_boolean plt_load_toc = htab->opd_abi;
10573   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10574   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10575 				 && htab->elf.dynamic_sections_created
10576 				 && stub_entry->h != NULL
10577 				 && stub_entry->h->elf.dynindx != -1);
10578   bfd_boolean use_fake_dep = plt_thread_safe;
10579   bfd_vma cmp_branch_off = 0;
10580 
10581   if (!ALWAYS_USE_FAKE_DEP
10582       && plt_load_toc
10583       && plt_thread_safe
10584       && !((stub_entry->h == htab->tls_get_addr_fd
10585 	    || stub_entry->h == htab->tls_get_addr)
10586 	   && htab->params->tls_get_addr_opt))
10587     {
10588       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10589       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10590 			  / PLT_ENTRY_SIZE (htab));
10591       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10592       bfd_vma to, from;
10593 
10594       if (pltindex > 32768)
10595 	glinkoff += (pltindex - 32768) * 4;
10596       to = (glinkoff
10597 	    + htab->glink->output_offset
10598 	    + htab->glink->output_section->vma);
10599       from = (p - stub_entry->group->stub_sec->contents
10600 	      + 4 * (ALWAYS_EMIT_R2SAVE
10601 		     || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10602 	      + 4 * (PPC_HA (offset) != 0)
10603 	      + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10604 		     != PPC_HA (offset))
10605 	      + 4 * (plt_static_chain != 0)
10606 	      + 20
10607 	      + stub_entry->group->stub_sec->output_offset
10608 	      + stub_entry->group->stub_sec->output_section->vma);
10609       cmp_branch_off = to - from;
10610       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10611     }
10612 
10613   if (PPC_HA (offset) != 0)
10614     {
10615       if (r != NULL)
10616 	{
10617 	  if (ALWAYS_EMIT_R2SAVE
10618 	      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10619 	    r[0].r_offset += 4;
10620 	  r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10621 	  r[1].r_offset = r[0].r_offset + 4;
10622 	  r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10623 	  r[1].r_addend = r[0].r_addend;
10624 	  if (plt_load_toc)
10625 	    {
10626 	      if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10627 		{
10628 		  r[2].r_offset = r[1].r_offset + 4;
10629 		  r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10630 		  r[2].r_addend = r[0].r_addend;
10631 		}
10632 	      else
10633 		{
10634 		  r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10635 		  r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10636 		  r[2].r_addend = r[0].r_addend + 8;
10637 		  if (plt_static_chain)
10638 		    {
10639 		      r[3].r_offset = r[2].r_offset + 4;
10640 		      r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10641 		      r[3].r_addend = r[0].r_addend + 16;
10642 		    }
10643 		}
10644 	    }
10645 	}
10646       if (ALWAYS_EMIT_R2SAVE
10647 	  || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10648 	bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),	p += 4;
10649       if (plt_load_toc)
10650 	{
10651 	  bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),	p += 4;
10652 	  bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),	p += 4;
10653 	}
10654       else
10655 	{
10656 	  bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),	p += 4;
10657 	  bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),	p += 4;
10658 	}
10659       if (plt_load_toc
10660 	  && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10661 	{
10662 	  bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p),	p += 4;
10663 	  offset = 0;
10664 	}
10665       bfd_put_32 (obfd, MTCTR_R12, p),				p += 4;
10666       if (plt_load_toc)
10667 	{
10668 	  if (use_fake_dep)
10669 	    {
10670 	      bfd_put_32 (obfd, XOR_R2_R12_R12, p),		p += 4;
10671 	      bfd_put_32 (obfd, ADD_R11_R11_R2, p),		p += 4;
10672 	    }
10673 	  bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10674 	  if (plt_static_chain)
10675 	    bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10676 	}
10677     }
10678   else
10679     {
10680       if (r != NULL)
10681 	{
10682 	  if (ALWAYS_EMIT_R2SAVE
10683 	      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10684 	    r[0].r_offset += 4;
10685 	  r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10686 	  if (plt_load_toc)
10687 	    {
10688 	      if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10689 		{
10690 		  r[1].r_offset = r[0].r_offset + 4;
10691 		  r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10692 		  r[1].r_addend = r[0].r_addend;
10693 		}
10694 	      else
10695 		{
10696 		  r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10697 		  r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10698 		  r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10699 		  if (plt_static_chain)
10700 		    {
10701 		      r[2].r_offset = r[1].r_offset + 4;
10702 		      r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10703 		      r[2].r_addend = r[0].r_addend + 8;
10704 		    }
10705 		}
10706 	    }
10707 	}
10708       if (ALWAYS_EMIT_R2SAVE
10709 	  || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10710 	bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),	p += 4;
10711       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),	p += 4;
10712       if (plt_load_toc
10713 	  && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10714 	{
10715 	  bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),	p += 4;
10716 	  offset = 0;
10717 	}
10718       bfd_put_32 (obfd, MTCTR_R12, p),				p += 4;
10719       if (plt_load_toc)
10720 	{
10721 	  if (use_fake_dep)
10722 	    {
10723 	      bfd_put_32 (obfd, XOR_R11_R12_R12, p),		p += 4;
10724 	      bfd_put_32 (obfd, ADD_R2_R2_R11, p),		p += 4;
10725 	    }
10726 	  if (plt_static_chain)
10727 	    bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10728 	  bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10729 	}
10730     }
10731   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10732     {
10733       bfd_put_32 (obfd, CMPLDI_R2_0, p),			p += 4;
10734       bfd_put_32 (obfd, BNECTR_P4, p),				p += 4;
10735       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10736     }
10737   else
10738     bfd_put_32 (obfd, BCTR, p),					p += 4;
10739   return p;
10740 }
10741 
10742 /* Build a special .plt call stub for __tls_get_addr.  */
10743 
10744 #define LD_R11_0R3	0xe9630000
10745 #define LD_R12_0R3	0xe9830000
10746 #define MR_R0_R3	0x7c601b78
10747 #define CMPDI_R11_0	0x2c2b0000
10748 #define ADD_R3_R12_R13	0x7c6c6a14
10749 #define BEQLR		0x4d820020
10750 #define MR_R3_R0	0x7c030378
10751 #define STD_R11_0R1	0xf9610000
10752 #define BCTRL		0x4e800421
10753 #define LD_R11_0R1	0xe9610000
10754 #define MTLR_R11	0x7d6803a6
10755 
10756 static inline bfd_byte *
10757 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10758 			 struct ppc_stub_hash_entry *stub_entry,
10759 			 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10760 {
10761   bfd *obfd = htab->params->stub_bfd;
10762 
10763   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),		p += 4;
10764   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),		p += 4;
10765   bfd_put_32 (obfd, MR_R0_R3, p),		p += 4;
10766   bfd_put_32 (obfd, CMPDI_R11_0, p),		p += 4;
10767   bfd_put_32 (obfd, ADD_R3_R12_R13, p),		p += 4;
10768   bfd_put_32 (obfd, BEQLR, p),			p += 4;
10769   bfd_put_32 (obfd, MR_R3_R0, p),		p += 4;
10770   bfd_put_32 (obfd, MFLR_R11, p),		p += 4;
10771   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10772 
10773   if (r != NULL)
10774     r[0].r_offset += 9 * 4;
10775   p = build_plt_stub (htab, stub_entry, p, offset, r);
10776   bfd_put_32 (obfd, BCTRL, p - 4);
10777 
10778   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),	p += 4;
10779   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p),	p += 4;
10780   bfd_put_32 (obfd, MTLR_R11, p),		p += 4;
10781   bfd_put_32 (obfd, BLR, p),			p += 4;
10782 
10783   return p;
10784 }
10785 
10786 static Elf_Internal_Rela *
10787 get_relocs (asection *sec, int count)
10788 {
10789   Elf_Internal_Rela *relocs;
10790   struct bfd_elf_section_data *elfsec_data;
10791 
10792   elfsec_data = elf_section_data (sec);
10793   relocs = elfsec_data->relocs;
10794   if (relocs == NULL)
10795     {
10796       bfd_size_type relsize;
10797       relsize = sec->reloc_count * sizeof (*relocs);
10798       relocs = bfd_alloc (sec->owner, relsize);
10799       if (relocs == NULL)
10800 	return NULL;
10801       elfsec_data->relocs = relocs;
10802       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10803 					  sizeof (Elf_Internal_Shdr));
10804       if (elfsec_data->rela.hdr == NULL)
10805 	return NULL;
10806       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10807 					* sizeof (Elf64_External_Rela));
10808       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10809       sec->reloc_count = 0;
10810     }
10811   relocs += sec->reloc_count;
10812   sec->reloc_count += count;
10813   return relocs;
10814 }
10815 
10816 static bfd_vma
10817 get_r2off (struct bfd_link_info *info,
10818 	   struct ppc_stub_hash_entry *stub_entry)
10819 {
10820   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10821   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10822 
10823   if (r2off == 0)
10824     {
10825       /* Support linking -R objects.  Get the toc pointer from the
10826 	 opd entry.  */
10827       char buf[8];
10828       if (!htab->opd_abi)
10829 	return r2off;
10830       asection *opd = stub_entry->h->elf.root.u.def.section;
10831       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10832 
10833       if (strcmp (opd->name, ".opd") != 0
10834 	  || opd->reloc_count != 0)
10835 	{
10836 	  info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10837 				  stub_entry->h->elf.root.root.string);
10838 	  bfd_set_error (bfd_error_bad_value);
10839 	  return (bfd_vma) -1;
10840 	}
10841       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10842 	return (bfd_vma) -1;
10843       r2off = bfd_get_64 (opd->owner, buf);
10844       r2off -= elf_gp (info->output_bfd);
10845     }
10846   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10847   return r2off;
10848 }
10849 
10850 static bfd_boolean
10851 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10852 {
10853   struct ppc_stub_hash_entry *stub_entry;
10854   struct ppc_branch_hash_entry *br_entry;
10855   struct bfd_link_info *info;
10856   struct ppc_link_hash_table *htab;
10857   bfd_byte *loc;
10858   bfd_byte *p;
10859   bfd_vma dest, off;
10860   int size;
10861   Elf_Internal_Rela *r;
10862   asection *plt;
10863 
10864   /* Massage our args to the form they really have.  */
10865   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10866   info = in_arg;
10867 
10868   htab = ppc_hash_table (info);
10869   if (htab == NULL)
10870     return FALSE;
10871 
10872   /* Make a note of the offset within the stubs for this entry.  */
10873   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10874   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10875 
10876   htab->stub_count[stub_entry->stub_type - 1] += 1;
10877   switch (stub_entry->stub_type)
10878     {
10879     case ppc_stub_long_branch:
10880     case ppc_stub_long_branch_r2off:
10881       /* Branches are relative.  This is where we are going to.  */
10882       dest = (stub_entry->target_value
10883 	      + stub_entry->target_section->output_offset
10884 	      + stub_entry->target_section->output_section->vma);
10885       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10886       off = dest;
10887 
10888       /* And this is where we are coming from.  */
10889       off -= (stub_entry->stub_offset
10890 	      + stub_entry->group->stub_sec->output_offset
10891 	      + stub_entry->group->stub_sec->output_section->vma);
10892 
10893       size = 4;
10894       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10895 	{
10896 	  bfd_vma r2off = get_r2off (info, stub_entry);
10897 
10898 	  if (r2off == (bfd_vma) -1)
10899 	    {
10900 	      htab->stub_error = TRUE;
10901 	      return FALSE;
10902 	    }
10903 	  bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10904 	  loc += 4;
10905 	  size = 8;
10906 	  if (PPC_HA (r2off) != 0)
10907 	    {
10908 	      bfd_put_32 (htab->params->stub_bfd,
10909 			  ADDIS_R2_R2 | PPC_HA (r2off), loc);
10910 	      loc += 4;
10911 	      size += 4;
10912 	    }
10913 	  if (PPC_LO (r2off) != 0)
10914 	    {
10915 	      bfd_put_32 (htab->params->stub_bfd,
10916 			  ADDI_R2_R2 | PPC_LO (r2off), loc);
10917 	      loc += 4;
10918 	      size += 4;
10919 	    }
10920 	  off -= size - 4;
10921 	}
10922       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10923 
10924       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10925 	{
10926 	  info->callbacks->einfo
10927 	    (_("%P: long branch stub `%s' offset overflow\n"),
10928 	     stub_entry->root.string);
10929 	  htab->stub_error = TRUE;
10930 	  return FALSE;
10931 	}
10932 
10933       if (info->emitrelocations)
10934 	{
10935 	  r = get_relocs (stub_entry->group->stub_sec, 1);
10936 	  if (r == NULL)
10937 	    return FALSE;
10938 	  r->r_offset = loc - stub_entry->group->stub_sec->contents;
10939 	  r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10940 	  r->r_addend = dest;
10941 	  if (stub_entry->h != NULL)
10942 	    {
10943 	      struct elf_link_hash_entry **hashes;
10944 	      unsigned long symndx;
10945 	      struct ppc_link_hash_entry *h;
10946 
10947 	      hashes = elf_sym_hashes (htab->params->stub_bfd);
10948 	      if (hashes == NULL)
10949 		{
10950 		  bfd_size_type hsize;
10951 
10952 		  hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10953 		  hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10954 		  if (hashes == NULL)
10955 		    return FALSE;
10956 		  elf_sym_hashes (htab->params->stub_bfd) = hashes;
10957 		  htab->stub_globals = 1;
10958 		}
10959 	      symndx = htab->stub_globals++;
10960 	      h = stub_entry->h;
10961 	      hashes[symndx] = &h->elf;
10962 	      r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10963 	      if (h->oh != NULL && h->oh->is_func)
10964 		h = ppc_follow_link (h->oh);
10965 	      if (h->elf.root.u.def.section != stub_entry->target_section)
10966 		/* H is an opd symbol.  The addend must be zero.  */
10967 		r->r_addend = 0;
10968 	      else
10969 		{
10970 		  off = (h->elf.root.u.def.value
10971 			 + h->elf.root.u.def.section->output_offset
10972 			 + h->elf.root.u.def.section->output_section->vma);
10973 		  r->r_addend -= off;
10974 		}
10975 	    }
10976 	}
10977       break;
10978 
10979     case ppc_stub_plt_branch:
10980     case ppc_stub_plt_branch_r2off:
10981       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10982 					 stub_entry->root.string + 9,
10983 					 FALSE, FALSE);
10984       if (br_entry == NULL)
10985 	{
10986 	  info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10987 				  stub_entry->root.string);
10988 	  htab->stub_error = TRUE;
10989 	  return FALSE;
10990 	}
10991 
10992       dest = (stub_entry->target_value
10993 	      + stub_entry->target_section->output_offset
10994 	      + stub_entry->target_section->output_section->vma);
10995       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10996 	dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10997 
10998       bfd_put_64 (htab->brlt->owner, dest,
10999 		  htab->brlt->contents + br_entry->offset);
11000 
11001       if (br_entry->iter == htab->stub_iteration)
11002 	{
11003 	  br_entry->iter = 0;
11004 
11005 	  if (htab->relbrlt != NULL)
11006 	    {
11007 	      /* Create a reloc for the branch lookup table entry.  */
11008 	      Elf_Internal_Rela rela;
11009 	      bfd_byte *rl;
11010 
11011 	      rela.r_offset = (br_entry->offset
11012 			       + htab->brlt->output_offset
11013 			       + htab->brlt->output_section->vma);
11014 	      rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11015 	      rela.r_addend = dest;
11016 
11017 	      rl = htab->relbrlt->contents;
11018 	      rl += (htab->relbrlt->reloc_count++
11019 		     * sizeof (Elf64_External_Rela));
11020 	      bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11021 	    }
11022 	  else if (info->emitrelocations)
11023 	    {
11024 	      r = get_relocs (htab->brlt, 1);
11025 	      if (r == NULL)
11026 		return FALSE;
11027 	      /* brlt, being SEC_LINKER_CREATED does not go through the
11028 		 normal reloc processing.  Symbols and offsets are not
11029 		 translated from input file to output file form, so
11030 		 set up the offset per the output file.  */
11031 	      r->r_offset = (br_entry->offset
11032 			     + htab->brlt->output_offset
11033 			     + htab->brlt->output_section->vma);
11034 	      r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11035 	      r->r_addend = dest;
11036 	    }
11037 	}
11038 
11039       dest = (br_entry->offset
11040 	      + htab->brlt->output_offset
11041 	      + htab->brlt->output_section->vma);
11042 
11043       off = (dest
11044 	     - elf_gp (htab->brlt->output_section->owner)
11045 	     - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11046 
11047       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11048 	{
11049 	  info->callbacks->einfo
11050 	    (_("%P: linkage table error against `%T'\n"),
11051 	     stub_entry->root.string);
11052 	  bfd_set_error (bfd_error_bad_value);
11053 	  htab->stub_error = TRUE;
11054 	  return FALSE;
11055 	}
11056 
11057       if (info->emitrelocations)
11058 	{
11059 	  r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11060 	  if (r == NULL)
11061 	    return FALSE;
11062 	  r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11063 	  if (bfd_big_endian (info->output_bfd))
11064 	    r[0].r_offset += 2;
11065 	  if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11066 	    r[0].r_offset += 4;
11067 	  r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11068 	  r[0].r_addend = dest;
11069 	  if (PPC_HA (off) != 0)
11070 	    {
11071 	      r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11072 	      r[1].r_offset = r[0].r_offset + 4;
11073 	      r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11074 	      r[1].r_addend = r[0].r_addend;
11075 	    }
11076 	}
11077 
11078       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11079 	{
11080 	  if (PPC_HA (off) != 0)
11081 	    {
11082 	      size = 16;
11083 	      bfd_put_32 (htab->params->stub_bfd,
11084 			  ADDIS_R12_R2 | PPC_HA (off), loc);
11085 	      loc += 4;
11086 	      bfd_put_32 (htab->params->stub_bfd,
11087 			  LD_R12_0R12 | PPC_LO (off), loc);
11088 	    }
11089 	  else
11090 	    {
11091 	      size = 12;
11092 	      bfd_put_32 (htab->params->stub_bfd,
11093 			  LD_R12_0R2 | PPC_LO (off), loc);
11094 	    }
11095 	}
11096       else
11097 	{
11098 	  bfd_vma r2off = get_r2off (info, stub_entry);
11099 
11100 	  if (r2off == (bfd_vma) -1)
11101 	    {
11102 	      htab->stub_error = TRUE;
11103 	      return FALSE;
11104 	    }
11105 
11106 	  bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11107 	  loc += 4;
11108 	  size = 16;
11109 	  if (PPC_HA (off) != 0)
11110 	    {
11111 	      size += 4;
11112 	      bfd_put_32 (htab->params->stub_bfd,
11113 			  ADDIS_R12_R2 | PPC_HA (off), loc);
11114 	      loc += 4;
11115 	      bfd_put_32 (htab->params->stub_bfd,
11116 			  LD_R12_0R12 | PPC_LO (off), loc);
11117 	    }
11118 	  else
11119 	    bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11120 
11121 	  if (PPC_HA (r2off) != 0)
11122 	    {
11123 	      size += 4;
11124 	      loc += 4;
11125 	      bfd_put_32 (htab->params->stub_bfd,
11126 			  ADDIS_R2_R2 | PPC_HA (r2off), loc);
11127 	    }
11128 	  if (PPC_LO (r2off) != 0)
11129 	    {
11130 	      size += 4;
11131 	      loc += 4;
11132 	      bfd_put_32 (htab->params->stub_bfd,
11133 			  ADDI_R2_R2 | PPC_LO (r2off), loc);
11134 	    }
11135 	}
11136       loc += 4;
11137       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11138       loc += 4;
11139       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11140       break;
11141 
11142     case ppc_stub_plt_call:
11143     case ppc_stub_plt_call_r2save:
11144       if (stub_entry->h != NULL
11145 	  && stub_entry->h->is_func_descriptor
11146 	  && stub_entry->h->oh != NULL)
11147 	{
11148 	  struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11149 
11150 	  /* If the old-ABI "dot-symbol" is undefined make it weak so
11151 	     we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11152 	  if (fh->elf.root.type == bfd_link_hash_undefined
11153 	      && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11154 		  || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11155 	    fh->elf.root.type = bfd_link_hash_undefweak;
11156 	}
11157 
11158       /* Now build the stub.  */
11159       dest = stub_entry->plt_ent->plt.offset & ~1;
11160       if (dest >= (bfd_vma) -2)
11161 	abort ();
11162 
11163       plt = htab->elf.splt;
11164       if (!htab->elf.dynamic_sections_created
11165 	  || stub_entry->h == NULL
11166 	  || stub_entry->h->elf.dynindx == -1)
11167 	plt = htab->elf.iplt;
11168 
11169       dest += plt->output_offset + plt->output_section->vma;
11170 
11171       if (stub_entry->h == NULL
11172 	  && (stub_entry->plt_ent->plt.offset & 1) == 0)
11173 	{
11174 	  Elf_Internal_Rela rela;
11175 	  bfd_byte *rl;
11176 
11177 	  rela.r_offset = dest;
11178 	  if (htab->opd_abi)
11179 	    rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11180 	  else
11181 	    rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11182 	  rela.r_addend = (stub_entry->target_value
11183 			   + stub_entry->target_section->output_offset
11184 			   + stub_entry->target_section->output_section->vma);
11185 
11186 	  rl = (htab->elf.irelplt->contents
11187 		+ (htab->elf.irelplt->reloc_count++
11188 		   * sizeof (Elf64_External_Rela)));
11189 	  bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11190 	  stub_entry->plt_ent->plt.offset |= 1;
11191 	  htab->local_ifunc_resolver = 1;
11192 	}
11193 
11194       off = (dest
11195 	     - elf_gp (plt->output_section->owner)
11196 	     - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11197 
11198       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11199 	{
11200 	  info->callbacks->einfo
11201 	    /* xgettext:c-format */
11202 	    (_("%P: linkage table error against `%T'\n"),
11203 	     stub_entry->h != NULL
11204 	     ? stub_entry->h->elf.root.root.string
11205 	     : "<local sym>");
11206 	  bfd_set_error (bfd_error_bad_value);
11207 	  htab->stub_error = TRUE;
11208 	  return FALSE;
11209 	}
11210 
11211       if (htab->params->plt_stub_align != 0)
11212 	{
11213 	  unsigned pad = plt_stub_pad (htab, stub_entry, off);
11214 
11215 	  stub_entry->group->stub_sec->size += pad;
11216 	  stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11217 	  loc += pad;
11218 	}
11219 
11220       r = NULL;
11221       if (info->emitrelocations)
11222 	{
11223 	  r = get_relocs (stub_entry->group->stub_sec,
11224 			  ((PPC_HA (off) != 0)
11225 			   + (htab->opd_abi
11226 			      ? 2 + (htab->params->plt_static_chain
11227 				     && PPC_HA (off + 16) == PPC_HA (off))
11228 			      : 1)));
11229 	  if (r == NULL)
11230 	    return FALSE;
11231 	  r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11232 	  if (bfd_big_endian (info->output_bfd))
11233 	    r[0].r_offset += 2;
11234 	  r[0].r_addend = dest;
11235 	}
11236       if (stub_entry->h != NULL
11237 	  && (stub_entry->h == htab->tls_get_addr_fd
11238 	      || stub_entry->h == htab->tls_get_addr)
11239 	  && htab->params->tls_get_addr_opt)
11240 	p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11241       else
11242 	p = build_plt_stub (htab, stub_entry, loc, off, r);
11243       size = p - loc;
11244       break;
11245 
11246     case ppc_stub_save_res:
11247       return TRUE;
11248 
11249     default:
11250       BFD_FAIL ();
11251       return FALSE;
11252     }
11253 
11254   stub_entry->group->stub_sec->size += size;
11255 
11256   if (htab->params->emit_stub_syms)
11257     {
11258       struct elf_link_hash_entry *h;
11259       size_t len1, len2;
11260       char *name;
11261       const char *const stub_str[] = { "long_branch",
11262 				       "long_branch_r2off",
11263 				       "plt_branch",
11264 				       "plt_branch_r2off",
11265 				       "plt_call",
11266 				       "plt_call" };
11267 
11268       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11269       len2 = strlen (stub_entry->root.string);
11270       name = bfd_malloc (len1 + len2 + 2);
11271       if (name == NULL)
11272 	return FALSE;
11273       memcpy (name, stub_entry->root.string, 9);
11274       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11275       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11276       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11277       if (h == NULL)
11278 	return FALSE;
11279       if (h->root.type == bfd_link_hash_new)
11280 	{
11281 	  h->root.type = bfd_link_hash_defined;
11282 	  h->root.u.def.section = stub_entry->group->stub_sec;
11283 	  h->root.u.def.value = stub_entry->stub_offset;
11284 	  h->ref_regular = 1;
11285 	  h->def_regular = 1;
11286 	  h->ref_regular_nonweak = 1;
11287 	  h->forced_local = 1;
11288 	  h->non_elf = 0;
11289 	  h->root.linker_def = 1;
11290 	}
11291     }
11292 
11293   return TRUE;
11294 }
11295 
11296 /* As above, but don't actually build the stub.  Just bump offset so
11297    we know stub section sizes, and select plt_branch stubs where
11298    long_branch stubs won't do.  */
11299 
11300 static bfd_boolean
11301 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11302 {
11303   struct ppc_stub_hash_entry *stub_entry;
11304   struct bfd_link_info *info;
11305   struct ppc_link_hash_table *htab;
11306   bfd_vma off;
11307   int size;
11308 
11309   /* Massage our args to the form they really have.  */
11310   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11311   info = in_arg;
11312 
11313   htab = ppc_hash_table (info);
11314   if (htab == NULL)
11315     return FALSE;
11316 
11317   if (stub_entry->h != NULL
11318       && stub_entry->h->save_res
11319       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11320       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11321     {
11322       /* Don't make stubs to out-of-line register save/restore
11323 	 functions.  Instead, emit copies of the functions.  */
11324       stub_entry->group->needs_save_res = 1;
11325       stub_entry->stub_type = ppc_stub_save_res;
11326       return TRUE;
11327     }
11328 
11329   if (stub_entry->stub_type == ppc_stub_plt_call
11330       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11331     {
11332       asection *plt;
11333       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11334       if (off >= (bfd_vma) -2)
11335 	abort ();
11336       plt = htab->elf.splt;
11337       if (!htab->elf.dynamic_sections_created
11338 	  || stub_entry->h == NULL
11339 	  || stub_entry->h->elf.dynindx == -1)
11340 	plt = htab->elf.iplt;
11341       off += (plt->output_offset
11342 	      + plt->output_section->vma
11343 	      - elf_gp (plt->output_section->owner)
11344 	      - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11345 
11346       size = plt_stub_size (htab, stub_entry, off);
11347       if (htab->params->plt_stub_align)
11348 	size += plt_stub_pad (htab, stub_entry, off);
11349       if (info->emitrelocations)
11350 	{
11351 	  stub_entry->group->stub_sec->reloc_count
11352 	    += ((PPC_HA (off) != 0)
11353 		+ (htab->opd_abi
11354 		   ? 2 + (htab->params->plt_static_chain
11355 			  && PPC_HA (off + 16) == PPC_HA (off))
11356 		   : 1));
11357 	  stub_entry->group->stub_sec->flags |= SEC_RELOC;
11358 	}
11359     }
11360   else
11361     {
11362       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11363 	 variants.  */
11364       bfd_vma r2off = 0;
11365       bfd_vma local_off = 0;
11366 
11367       off = (stub_entry->target_value
11368 	     + stub_entry->target_section->output_offset
11369 	     + stub_entry->target_section->output_section->vma);
11370       off -= (stub_entry->group->stub_sec->size
11371 	      + stub_entry->group->stub_sec->output_offset
11372 	      + stub_entry->group->stub_sec->output_section->vma);
11373 
11374       /* Reset the stub type from the plt variant in case we now
11375 	 can reach with a shorter stub.  */
11376       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11377 	stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11378 
11379       size = 4;
11380       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11381 	{
11382 	  r2off = get_r2off (info, stub_entry);
11383 	  if (r2off == (bfd_vma) -1)
11384 	    {
11385 	      htab->stub_error = TRUE;
11386 	      return FALSE;
11387 	    }
11388 	  size = 8;
11389 	  if (PPC_HA (r2off) != 0)
11390 	    size += 4;
11391 	  if (PPC_LO (r2off) != 0)
11392 	    size += 4;
11393 	  off -= size - 4;
11394 	}
11395 
11396       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11397 
11398       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11399 	 Do the same for -R objects without function descriptors.  */
11400       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11401 	  || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11402 	      && r2off == 0
11403 	      && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11404 	{
11405 	  struct ppc_branch_hash_entry *br_entry;
11406 
11407 	  br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11408 					     stub_entry->root.string + 9,
11409 					     TRUE, FALSE);
11410 	  if (br_entry == NULL)
11411 	    {
11412 	      info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11413 				      stub_entry->root.string);
11414 	      htab->stub_error = TRUE;
11415 	      return FALSE;
11416 	    }
11417 
11418 	  if (br_entry->iter != htab->stub_iteration)
11419 	    {
11420 	      br_entry->iter = htab->stub_iteration;
11421 	      br_entry->offset = htab->brlt->size;
11422 	      htab->brlt->size += 8;
11423 
11424 	      if (htab->relbrlt != NULL)
11425 		htab->relbrlt->size += sizeof (Elf64_External_Rela);
11426 	      else if (info->emitrelocations)
11427 		{
11428 		  htab->brlt->reloc_count += 1;
11429 		  htab->brlt->flags |= SEC_RELOC;
11430 		}
11431 	    }
11432 
11433 	  stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11434 	  off = (br_entry->offset
11435 		 + htab->brlt->output_offset
11436 		 + htab->brlt->output_section->vma
11437 		 - elf_gp (htab->brlt->output_section->owner)
11438 		 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11439 
11440 	  if (info->emitrelocations)
11441 	    {
11442 	      stub_entry->group->stub_sec->reloc_count
11443 		+= 1 + (PPC_HA (off) != 0);
11444 	      stub_entry->group->stub_sec->flags |= SEC_RELOC;
11445 	    }
11446 
11447 	  if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11448 	    {
11449 	      size = 12;
11450 	      if (PPC_HA (off) != 0)
11451 		size = 16;
11452 	    }
11453 	  else
11454 	    {
11455 	      size = 16;
11456 	      if (PPC_HA (off) != 0)
11457 		size += 4;
11458 
11459 	      if (PPC_HA (r2off) != 0)
11460 		size += 4;
11461 	      if (PPC_LO (r2off) != 0)
11462 		size += 4;
11463 	    }
11464 	}
11465       else if (info->emitrelocations)
11466 	{
11467 	  stub_entry->group->stub_sec->reloc_count += 1;
11468 	  stub_entry->group->stub_sec->flags |= SEC_RELOC;
11469 	}
11470     }
11471 
11472   stub_entry->group->stub_sec->size += size;
11473   return TRUE;
11474 }
11475 
11476 /* Set up various things so that we can make a list of input sections
11477    for each output section included in the link.  Returns -1 on error,
11478    0 when no stubs will be needed, and 1 on success.  */
11479 
11480 int
11481 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11482 {
11483   unsigned int id;
11484   bfd_size_type amt;
11485   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11486 
11487   if (htab == NULL)
11488     return -1;
11489 
11490   htab->sec_info_arr_size = bfd_get_next_section_id ();
11491   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11492   htab->sec_info = bfd_zmalloc (amt);
11493   if (htab->sec_info == NULL)
11494     return -1;
11495 
11496   /* Set toc_off for com, und, abs and ind sections.  */
11497   for (id = 0; id < 3; id++)
11498     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11499 
11500   return 1;
11501 }
11502 
11503 /* Set up for first pass at multitoc partitioning.  */
11504 
11505 void
11506 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11507 {
11508   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11509 
11510   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11511   htab->toc_bfd = NULL;
11512   htab->toc_first_sec = NULL;
11513 }
11514 
11515 /* The linker repeatedly calls this function for each TOC input section
11516    and linker generated GOT section.  Group input bfds such that the toc
11517    within a group is less than 64k in size.  */
11518 
11519 bfd_boolean
11520 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11521 {
11522   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11523   bfd_vma addr, off, limit;
11524 
11525   if (htab == NULL)
11526     return FALSE;
11527 
11528   if (!htab->second_toc_pass)
11529     {
11530       /* Keep track of the first .toc or .got section for this input bfd.  */
11531       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11532 
11533       if (new_bfd)
11534 	{
11535 	  htab->toc_bfd = isec->owner;
11536 	  htab->toc_first_sec = isec;
11537 	}
11538 
11539       addr = isec->output_offset + isec->output_section->vma;
11540       off = addr - htab->toc_curr;
11541       limit = 0x80008000;
11542       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11543 	limit = 0x10000;
11544       if (off + isec->size > limit)
11545 	{
11546 	  addr = (htab->toc_first_sec->output_offset
11547 		  + htab->toc_first_sec->output_section->vma);
11548 	  htab->toc_curr = addr;
11549 	  htab->toc_curr &= -TOC_BASE_ALIGN;
11550 	}
11551 
11552       /* toc_curr is the base address of this toc group.  Set elf_gp
11553 	 for the input section to be the offset relative to the
11554 	 output toc base plus 0x8000.  Making the input elf_gp an
11555 	 offset allows us to move the toc as a whole without
11556 	 recalculating input elf_gp.  */
11557       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11558       off += TOC_BASE_OFF;
11559 
11560       /* Die if someone uses a linker script that doesn't keep input
11561 	 file .toc and .got together.  */
11562       if (new_bfd
11563 	  && elf_gp (isec->owner) != 0
11564 	  && elf_gp (isec->owner) != off)
11565 	return FALSE;
11566 
11567       elf_gp (isec->owner) = off;
11568       return TRUE;
11569     }
11570 
11571   /* During the second pass toc_first_sec points to the start of
11572      a toc group, and toc_curr is used to track the old elf_gp.
11573      We use toc_bfd to ensure we only look at each bfd once.  */
11574   if (htab->toc_bfd == isec->owner)
11575     return TRUE;
11576   htab->toc_bfd = isec->owner;
11577 
11578   if (htab->toc_first_sec == NULL
11579       || htab->toc_curr != elf_gp (isec->owner))
11580     {
11581       htab->toc_curr = elf_gp (isec->owner);
11582       htab->toc_first_sec = isec;
11583     }
11584   addr = (htab->toc_first_sec->output_offset
11585 	  + htab->toc_first_sec->output_section->vma);
11586   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11587   elf_gp (isec->owner) = off;
11588 
11589   return TRUE;
11590 }
11591 
11592 /* Called via elf_link_hash_traverse to merge GOT entries for global
11593    symbol H.  */
11594 
11595 static bfd_boolean
11596 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11597 {
11598   if (h->root.type == bfd_link_hash_indirect)
11599     return TRUE;
11600 
11601   merge_got_entries (&h->got.glist);
11602 
11603   return TRUE;
11604 }
11605 
11606 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11607    symbol H.  */
11608 
11609 static bfd_boolean
11610 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11611 {
11612   struct got_entry *gent;
11613 
11614   if (h->root.type == bfd_link_hash_indirect)
11615     return TRUE;
11616 
11617   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11618     if (!gent->is_indirect)
11619       allocate_got (h, (struct bfd_link_info *) inf, gent);
11620   return TRUE;
11621 }
11622 
11623 /* Called on the first multitoc pass after the last call to
11624    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11625    entries.  */
11626 
11627 bfd_boolean
11628 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11629 {
11630   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11631   struct bfd *ibfd, *ibfd2;
11632   bfd_boolean done_something;
11633 
11634   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11635 
11636   if (!htab->do_multi_toc)
11637     return FALSE;
11638 
11639   /* Merge global sym got entries within a toc group.  */
11640   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11641 
11642   /* And tlsld_got.  */
11643   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11644     {
11645       struct got_entry *ent, *ent2;
11646 
11647       if (!is_ppc64_elf (ibfd))
11648 	continue;
11649 
11650       ent = ppc64_tlsld_got (ibfd);
11651       if (!ent->is_indirect
11652 	  && ent->got.offset != (bfd_vma) -1)
11653 	{
11654 	  for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11655 	    {
11656 	      if (!is_ppc64_elf (ibfd2))
11657 		continue;
11658 
11659 	      ent2 = ppc64_tlsld_got (ibfd2);
11660 	      if (!ent2->is_indirect
11661 		  && ent2->got.offset != (bfd_vma) -1
11662 		  && elf_gp (ibfd2) == elf_gp (ibfd))
11663 		{
11664 		  ent2->is_indirect = TRUE;
11665 		  ent2->got.ent = ent;
11666 		}
11667 	    }
11668 	}
11669     }
11670 
11671   /* Zap sizes of got sections.  */
11672   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11673   htab->elf.irelplt->size -= htab->got_reli_size;
11674   htab->got_reli_size = 0;
11675 
11676   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11677     {
11678       asection *got, *relgot;
11679 
11680       if (!is_ppc64_elf (ibfd))
11681 	continue;
11682 
11683       got = ppc64_elf_tdata (ibfd)->got;
11684       if (got != NULL)
11685 	{
11686 	  got->rawsize = got->size;
11687 	  got->size = 0;
11688 	  relgot = ppc64_elf_tdata (ibfd)->relgot;
11689 	  relgot->rawsize = relgot->size;
11690 	  relgot->size = 0;
11691 	}
11692     }
11693 
11694   /* Now reallocate the got, local syms first.  We don't need to
11695      allocate section contents again since we never increase size.  */
11696   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11697     {
11698       struct got_entry **lgot_ents;
11699       struct got_entry **end_lgot_ents;
11700       struct plt_entry **local_plt;
11701       struct plt_entry **end_local_plt;
11702       unsigned char *lgot_masks;
11703       bfd_size_type locsymcount;
11704       Elf_Internal_Shdr *symtab_hdr;
11705       asection *s;
11706 
11707       if (!is_ppc64_elf (ibfd))
11708 	continue;
11709 
11710       lgot_ents = elf_local_got_ents (ibfd);
11711       if (!lgot_ents)
11712 	continue;
11713 
11714       symtab_hdr = &elf_symtab_hdr (ibfd);
11715       locsymcount = symtab_hdr->sh_info;
11716       end_lgot_ents = lgot_ents + locsymcount;
11717       local_plt = (struct plt_entry **) end_lgot_ents;
11718       end_local_plt = local_plt + locsymcount;
11719       lgot_masks = (unsigned char *) end_local_plt;
11720       s = ppc64_elf_tdata (ibfd)->got;
11721       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11722 	{
11723 	  struct got_entry *ent;
11724 
11725 	  for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11726 	    {
11727 	      unsigned int ent_size = 8;
11728 	      unsigned int rel_size = sizeof (Elf64_External_Rela);
11729 
11730 	      ent->got.offset = s->size;
11731 	      if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11732 		{
11733 		  ent_size *= 2;
11734 		  rel_size *= 2;
11735 		}
11736 	      s->size += ent_size;
11737 	      if ((*lgot_masks & PLT_IFUNC) != 0)
11738 		{
11739 		  htab->elf.irelplt->size += rel_size;
11740 		  htab->got_reli_size += rel_size;
11741 		}
11742 	      else if (bfd_link_pic (info))
11743 		{
11744 		  asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11745 		  srel->size += rel_size;
11746 		}
11747 	    }
11748 	}
11749     }
11750 
11751   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11752 
11753   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11754     {
11755       struct got_entry *ent;
11756 
11757       if (!is_ppc64_elf (ibfd))
11758 	continue;
11759 
11760       ent = ppc64_tlsld_got (ibfd);
11761       if (!ent->is_indirect
11762 	  && ent->got.offset != (bfd_vma) -1)
11763 	{
11764 	  asection *s = ppc64_elf_tdata (ibfd)->got;
11765 	  ent->got.offset = s->size;
11766 	  s->size += 16;
11767 	  if (bfd_link_pic (info))
11768 	    {
11769 	      asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11770 	      srel->size += sizeof (Elf64_External_Rela);
11771 	    }
11772 	}
11773     }
11774 
11775   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11776   if (!done_something)
11777     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11778       {
11779 	asection *got;
11780 
11781 	if (!is_ppc64_elf (ibfd))
11782 	  continue;
11783 
11784 	got = ppc64_elf_tdata (ibfd)->got;
11785 	if (got != NULL)
11786 	  {
11787 	    done_something = got->rawsize != got->size;
11788 	    if (done_something)
11789 	      break;
11790 	  }
11791       }
11792 
11793   if (done_something)
11794     (*htab->params->layout_sections_again) ();
11795 
11796   /* Set up for second pass over toc sections to recalculate elf_gp
11797      on input sections.  */
11798   htab->toc_bfd = NULL;
11799   htab->toc_first_sec = NULL;
11800   htab->second_toc_pass = TRUE;
11801   return done_something;
11802 }
11803 
11804 /* Called after second pass of multitoc partitioning.  */
11805 
11806 void
11807 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11808 {
11809   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11810 
11811   /* After the second pass, toc_curr tracks the TOC offset used
11812      for code sections below in ppc64_elf_next_input_section.  */
11813   htab->toc_curr = TOC_BASE_OFF;
11814 }
11815 
11816 /* No toc references were found in ISEC.  If the code in ISEC makes no
11817    calls, then there's no need to use toc adjusting stubs when branching
11818    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11819    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11820    needed, and 2 if a cyclical call-graph was found but no other reason
11821    for a stub was detected.  If called from the top level, a return of
11822    2 means the same as a return of 0.  */
11823 
11824 static int
11825 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11826 {
11827   int ret;
11828 
11829   /* Mark this section as checked.  */
11830   isec->call_check_done = 1;
11831 
11832   /* We know none of our code bearing sections will need toc stubs.  */
11833   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11834     return 0;
11835 
11836   if (isec->size == 0)
11837     return 0;
11838 
11839   if (isec->output_section == NULL)
11840     return 0;
11841 
11842   ret = 0;
11843   if (isec->reloc_count != 0)
11844     {
11845       Elf_Internal_Rela *relstart, *rel;
11846       Elf_Internal_Sym *local_syms;
11847       struct ppc_link_hash_table *htab;
11848 
11849       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11850 					    info->keep_memory);
11851       if (relstart == NULL)
11852 	return -1;
11853 
11854       /* Look for branches to outside of this section.  */
11855       local_syms = NULL;
11856       htab = ppc_hash_table (info);
11857       if (htab == NULL)
11858 	return -1;
11859 
11860       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11861 	{
11862 	  enum elf_ppc64_reloc_type r_type;
11863 	  unsigned long r_symndx;
11864 	  struct elf_link_hash_entry *h;
11865 	  struct ppc_link_hash_entry *eh;
11866 	  Elf_Internal_Sym *sym;
11867 	  asection *sym_sec;
11868 	  struct _opd_sec_data *opd;
11869 	  bfd_vma sym_value;
11870 	  bfd_vma dest;
11871 
11872 	  r_type = ELF64_R_TYPE (rel->r_info);
11873 	  if (r_type != R_PPC64_REL24
11874 	      && r_type != R_PPC64_REL14
11875 	      && r_type != R_PPC64_REL14_BRTAKEN
11876 	      && r_type != R_PPC64_REL14_BRNTAKEN)
11877 	    continue;
11878 
11879 	  r_symndx = ELF64_R_SYM (rel->r_info);
11880 	  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11881 			  isec->owner))
11882 	    {
11883 	      ret = -1;
11884 	      break;
11885 	    }
11886 
11887 	  /* Calls to dynamic lib functions go through a plt call stub
11888 	     that uses r2.  */
11889 	  eh = (struct ppc_link_hash_entry *) h;
11890 	  if (eh != NULL
11891 	      && (eh->elf.plt.plist != NULL
11892 		  || (eh->oh != NULL
11893 		      && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11894 	    {
11895 	      ret = 1;
11896 	      break;
11897 	    }
11898 
11899 	  if (sym_sec == NULL)
11900 	    /* Ignore other undefined symbols.  */
11901 	    continue;
11902 
11903 	  /* Assume branches to other sections not included in the
11904 	     link need stubs too, to cover -R and absolute syms.  */
11905 	  if (sym_sec->output_section == NULL)
11906 	    {
11907 	      ret = 1;
11908 	      break;
11909 	    }
11910 
11911 	  if (h == NULL)
11912 	    sym_value = sym->st_value;
11913 	  else
11914 	    {
11915 	      if (h->root.type != bfd_link_hash_defined
11916 		  && h->root.type != bfd_link_hash_defweak)
11917 		abort ();
11918 	      sym_value = h->root.u.def.value;
11919 	    }
11920 	  sym_value += rel->r_addend;
11921 
11922 	  /* If this branch reloc uses an opd sym, find the code section.  */
11923 	  opd = get_opd_info (sym_sec);
11924 	  if (opd != NULL)
11925 	    {
11926 	      if (h == NULL && opd->adjust != NULL)
11927 		{
11928 		  long adjust;
11929 
11930 		  adjust = opd->adjust[OPD_NDX (sym_value)];
11931 		  if (adjust == -1)
11932 		    /* Assume deleted functions won't ever be called.  */
11933 		    continue;
11934 		  sym_value += adjust;
11935 		}
11936 
11937 	      dest = opd_entry_value (sym_sec, sym_value,
11938 				      &sym_sec, NULL, FALSE);
11939 	      if (dest == (bfd_vma) -1)
11940 		continue;
11941 	    }
11942 	  else
11943 	    dest = (sym_value
11944 		    + sym_sec->output_offset
11945 		    + sym_sec->output_section->vma);
11946 
11947 	  /* Ignore branch to self.  */
11948 	  if (sym_sec == isec)
11949 	    continue;
11950 
11951 	  /* If the called function uses the toc, we need a stub.  */
11952 	  if (sym_sec->has_toc_reloc
11953 	      || sym_sec->makes_toc_func_call)
11954 	    {
11955 	      ret = 1;
11956 	      break;
11957 	    }
11958 
11959 	  /* Assume any branch that needs a long branch stub might in fact
11960 	     need a plt_branch stub.  A plt_branch stub uses r2.  */
11961 	  else if (dest - (isec->output_offset
11962 			   + isec->output_section->vma
11963 			   + rel->r_offset) + (1 << 25)
11964 		   >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11965 							     ? h->other
11966 							     : sym->st_other))
11967 	    {
11968 	      ret = 1;
11969 	      break;
11970 	    }
11971 
11972 	  /* If calling back to a section in the process of being
11973 	     tested, we can't say for sure that no toc adjusting stubs
11974 	     are needed, so don't return zero.  */
11975 	  else if (sym_sec->call_check_in_progress)
11976 	    ret = 2;
11977 
11978 	  /* Branches to another section that itself doesn't have any TOC
11979 	     references are OK.  Recursively call ourselves to check.  */
11980 	  else if (!sym_sec->call_check_done)
11981 	    {
11982 	      int recur;
11983 
11984 	      /* Mark current section as indeterminate, so that other
11985 		 sections that call back to current won't be marked as
11986 		 known.  */
11987 	      isec->call_check_in_progress = 1;
11988 	      recur = toc_adjusting_stub_needed (info, sym_sec);
11989 	      isec->call_check_in_progress = 0;
11990 
11991 	      if (recur != 0)
11992 		{
11993 		  ret = recur;
11994 		  if (recur != 2)
11995 		    break;
11996 		}
11997 	    }
11998 	}
11999 
12000       if (local_syms != NULL
12001 	  && (elf_symtab_hdr (isec->owner).contents
12002 	      != (unsigned char *) local_syms))
12003 	free (local_syms);
12004       if (elf_section_data (isec)->relocs != relstart)
12005 	free (relstart);
12006     }
12007 
12008   if ((ret & 1) == 0
12009       && isec->map_head.s != NULL
12010       && (strcmp (isec->output_section->name, ".init") == 0
12011 	  || strcmp (isec->output_section->name, ".fini") == 0))
12012     {
12013       if (isec->map_head.s->has_toc_reloc
12014 	  || isec->map_head.s->makes_toc_func_call)
12015 	ret = 1;
12016       else if (!isec->map_head.s->call_check_done)
12017 	{
12018 	  int recur;
12019 	  isec->call_check_in_progress = 1;
12020 	  recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12021 	  isec->call_check_in_progress = 0;
12022 	  if (recur != 0)
12023 	    ret = recur;
12024 	}
12025     }
12026 
12027   if (ret == 1)
12028     isec->makes_toc_func_call = 1;
12029 
12030   return ret;
12031 }
12032 
12033 /* The linker repeatedly calls this function for each input section,
12034    in the order that input sections are linked into output sections.
12035    Build lists of input sections to determine groupings between which
12036    we may insert linker stubs.  */
12037 
12038 bfd_boolean
12039 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12040 {
12041   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12042 
12043   if (htab == NULL)
12044     return FALSE;
12045 
12046   if ((isec->output_section->flags & SEC_CODE) != 0
12047       && isec->output_section->id < htab->sec_info_arr_size)
12048     {
12049       /* This happens to make the list in reverse order,
12050 	 which is what we want.  */
12051       htab->sec_info[isec->id].u.list
12052 	= htab->sec_info[isec->output_section->id].u.list;
12053       htab->sec_info[isec->output_section->id].u.list = isec;
12054     }
12055 
12056   if (htab->multi_toc_needed)
12057     {
12058       /* Analyse sections that aren't already flagged as needing a
12059 	 valid toc pointer.  Exclude .fixup for the linux kernel.
12060 	 .fixup contains branches, but only back to the function that
12061 	 hit an exception.  */
12062       if (!(isec->has_toc_reloc
12063 	    || (isec->flags & SEC_CODE) == 0
12064 	    || strcmp (isec->name, ".fixup") == 0
12065 	    || isec->call_check_done))
12066 	{
12067 	  if (toc_adjusting_stub_needed (info, isec) < 0)
12068 	    return FALSE;
12069 	}
12070       /* Make all sections use the TOC assigned for this object file.
12071 	 This will be wrong for pasted sections;  We fix that in
12072 	 check_pasted_section().  */
12073       if (elf_gp (isec->owner) != 0)
12074 	htab->toc_curr = elf_gp (isec->owner);
12075     }
12076 
12077   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12078   return TRUE;
12079 }
12080 
12081 /* Check that all .init and .fini sections use the same toc, if they
12082    have toc relocs.  */
12083 
12084 static bfd_boolean
12085 check_pasted_section (struct bfd_link_info *info, const char *name)
12086 {
12087   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12088 
12089   if (o != NULL)
12090     {
12091       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12092       bfd_vma toc_off = 0;
12093       asection *i;
12094 
12095       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12096 	if (i->has_toc_reloc)
12097 	  {
12098 	    if (toc_off == 0)
12099 	      toc_off = htab->sec_info[i->id].toc_off;
12100 	    else if (toc_off != htab->sec_info[i->id].toc_off)
12101 	      return FALSE;
12102 	  }
12103 
12104       if (toc_off == 0)
12105 	for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12106 	  if (i->makes_toc_func_call)
12107 	    {
12108 	      toc_off = htab->sec_info[i->id].toc_off;
12109 	      break;
12110 	    }
12111 
12112       /* Make sure the whole pasted function uses the same toc offset.  */
12113       if (toc_off != 0)
12114 	for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12115 	  htab->sec_info[i->id].toc_off = toc_off;
12116     }
12117   return TRUE;
12118 }
12119 
12120 bfd_boolean
12121 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12122 {
12123   return (check_pasted_section (info, ".init")
12124 	  & check_pasted_section (info, ".fini"));
12125 }
12126 
12127 /* See whether we can group stub sections together.  Grouping stub
12128    sections may result in fewer stubs.  More importantly, we need to
12129    put all .init* and .fini* stubs at the beginning of the .init or
12130    .fini output sections respectively, because glibc splits the
12131    _init and _fini functions into multiple parts.  Putting a stub in
12132    the middle of a function is not a good idea.  */
12133 
12134 static bfd_boolean
12135 group_sections (struct bfd_link_info *info,
12136 		bfd_size_type stub_group_size,
12137 		bfd_boolean stubs_always_before_branch)
12138 {
12139   struct ppc_link_hash_table *htab;
12140   asection *osec;
12141   bfd_boolean suppress_size_errors;
12142 
12143   htab = ppc_hash_table (info);
12144   if (htab == NULL)
12145     return FALSE;
12146 
12147   suppress_size_errors = FALSE;
12148   if (stub_group_size == 1)
12149     {
12150       /* Default values.  */
12151       if (stubs_always_before_branch)
12152 	stub_group_size = 0x1e00000;
12153       else
12154 	stub_group_size = 0x1c00000;
12155       suppress_size_errors = TRUE;
12156     }
12157 
12158   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12159     {
12160       asection *tail;
12161 
12162       if (osec->id >= htab->sec_info_arr_size)
12163 	continue;
12164 
12165       tail = htab->sec_info[osec->id].u.list;
12166       while (tail != NULL)
12167 	{
12168 	  asection *curr;
12169 	  asection *prev;
12170 	  bfd_size_type total;
12171 	  bfd_boolean big_sec;
12172 	  bfd_vma curr_toc;
12173 	  struct map_stub *group;
12174 	  bfd_size_type group_size;
12175 
12176 	  curr = tail;
12177 	  total = tail->size;
12178 	  group_size = (ppc64_elf_section_data (tail) != NULL
12179 			&& ppc64_elf_section_data (tail)->has_14bit_branch
12180 			? stub_group_size >> 10 : stub_group_size);
12181 
12182 	  big_sec = total > group_size;
12183 	  if (big_sec && !suppress_size_errors)
12184 	    /* xgettext:c-format */
12185 	    _bfd_error_handler (_("%B section %A exceeds stub group size"),
12186 				tail->owner, tail);
12187 	  curr_toc = htab->sec_info[tail->id].toc_off;
12188 
12189 	  while ((prev = htab->sec_info[curr->id].u.list) != NULL
12190 		 && ((total += curr->output_offset - prev->output_offset)
12191 		     < (ppc64_elf_section_data (prev) != NULL
12192 			&& ppc64_elf_section_data (prev)->has_14bit_branch
12193 			? (group_size = stub_group_size >> 10) : group_size))
12194 		 && htab->sec_info[prev->id].toc_off == curr_toc)
12195 	    curr = prev;
12196 
12197 	  /* OK, the size from the start of CURR to the end is less
12198 	     than group_size and thus can be handled by one stub
12199 	     section.  (or the tail section is itself larger than
12200 	     group_size, in which case we may be toast.)  We should
12201 	     really be keeping track of the total size of stubs added
12202 	     here, as stubs contribute to the final output section
12203 	     size.  That's a little tricky, and this way will only
12204 	     break if stubs added make the total size more than 2^25,
12205 	     ie. for the default stub_group_size, if stubs total more
12206 	     than 2097152 bytes, or nearly 75000 plt call stubs.  */
12207 	  group = bfd_alloc (curr->owner, sizeof (*group));
12208 	  if (group == NULL)
12209 	    return FALSE;
12210 	  group->link_sec = curr;
12211 	  group->stub_sec = NULL;
12212 	  group->needs_save_res = 0;
12213 	  group->next = htab->group;
12214 	  htab->group = group;
12215 	  do
12216 	    {
12217 	      prev = htab->sec_info[tail->id].u.list;
12218 	      /* Set up this stub group.  */
12219 	      htab->sec_info[tail->id].u.group = group;
12220 	    }
12221 	  while (tail != curr && (tail = prev) != NULL);
12222 
12223 	  /* But wait, there's more!  Input sections up to group_size
12224 	     bytes before the stub section can be handled by it too.
12225 	     Don't do this if we have a really large section after the
12226 	     stubs, as adding more stubs increases the chance that
12227 	     branches may not reach into the stub section.  */
12228 	  if (!stubs_always_before_branch && !big_sec)
12229 	    {
12230 	      total = 0;
12231 	      while (prev != NULL
12232 		     && ((total += tail->output_offset - prev->output_offset)
12233 			 < (ppc64_elf_section_data (prev) != NULL
12234 			    && ppc64_elf_section_data (prev)->has_14bit_branch
12235 			    ? (group_size = stub_group_size >> 10) : group_size))
12236 		     && htab->sec_info[prev->id].toc_off == curr_toc)
12237 		{
12238 		  tail = prev;
12239 		  prev = htab->sec_info[tail->id].u.list;
12240 		  htab->sec_info[tail->id].u.group = group;
12241 		}
12242 	    }
12243 	  tail = prev;
12244 	}
12245     }
12246   return TRUE;
12247 }
12248 
12249 static const unsigned char glink_eh_frame_cie[] =
12250 {
12251   0, 0, 0, 16,				/* length.  */
12252   0, 0, 0, 0,				/* id.  */
12253   1,					/* CIE version.  */
12254   'z', 'R', 0,				/* Augmentation string.  */
12255   4,					/* Code alignment.  */
12256   0x78,					/* Data alignment.  */
12257   65,					/* RA reg.  */
12258   1,					/* Augmentation size.  */
12259   DW_EH_PE_pcrel | DW_EH_PE_sdata4,	/* FDE encoding.  */
12260   DW_CFA_def_cfa, 1, 0			/* def_cfa: r1 offset 0.  */
12261 };
12262 
12263 /* Stripping output sections is normally done before dynamic section
12264    symbols have been allocated.  This function is called later, and
12265    handles cases like htab->brlt which is mapped to its own output
12266    section.  */
12267 
12268 static void
12269 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12270 {
12271   if (isec->size == 0
12272       && isec->output_section->size == 0
12273       && !(isec->output_section->flags & SEC_KEEP)
12274       && !bfd_section_removed_from_list (info->output_bfd,
12275 					 isec->output_section)
12276       && elf_section_data (isec->output_section)->dynindx == 0)
12277     {
12278       isec->output_section->flags |= SEC_EXCLUDE;
12279       bfd_section_list_remove (info->output_bfd, isec->output_section);
12280       info->output_bfd->section_count--;
12281     }
12282 }
12283 
12284 /* Determine and set the size of the stub section for a final link.
12285 
12286    The basic idea here is to examine all the relocations looking for
12287    PC-relative calls to a target that is unreachable with a "bl"
12288    instruction.  */
12289 
12290 bfd_boolean
12291 ppc64_elf_size_stubs (struct bfd_link_info *info)
12292 {
12293   bfd_size_type stub_group_size;
12294   bfd_boolean stubs_always_before_branch;
12295   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12296 
12297   if (htab == NULL)
12298     return FALSE;
12299 
12300   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12301     htab->params->plt_thread_safe = 1;
12302   if (!htab->opd_abi)
12303     htab->params->plt_thread_safe = 0;
12304   else if (htab->params->plt_thread_safe == -1)
12305     {
12306       static const char *const thread_starter[] =
12307 	{
12308 	  "pthread_create",
12309 	  /* libstdc++ */
12310 	  "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12311 	  /* librt */
12312 	  "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12313 	  "mq_notify", "create_timer",
12314 	  /* libanl */
12315 	  "getaddrinfo_a",
12316 	  /* libgomp */
12317 	  "GOMP_parallel",
12318 	  "GOMP_parallel_start",
12319 	  "GOMP_parallel_loop_static",
12320 	  "GOMP_parallel_loop_static_start",
12321 	  "GOMP_parallel_loop_dynamic",
12322 	  "GOMP_parallel_loop_dynamic_start",
12323 	  "GOMP_parallel_loop_guided",
12324 	  "GOMP_parallel_loop_guided_start",
12325 	  "GOMP_parallel_loop_runtime",
12326 	  "GOMP_parallel_loop_runtime_start",
12327 	  "GOMP_parallel_sections",
12328 	  "GOMP_parallel_sections_start",
12329 	  /* libgo */
12330 	  "__go_go",
12331 	};
12332       unsigned i;
12333 
12334       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12335 	{
12336 	  struct elf_link_hash_entry *h;
12337 	  h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12338 				    FALSE, FALSE, TRUE);
12339 	  htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12340 	  if (htab->params->plt_thread_safe)
12341 	    break;
12342 	}
12343     }
12344   stubs_always_before_branch = htab->params->group_size < 0;
12345   if (htab->params->group_size < 0)
12346     stub_group_size = -htab->params->group_size;
12347   else
12348     stub_group_size = htab->params->group_size;
12349 
12350   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12351     return FALSE;
12352 
12353 #define STUB_SHRINK_ITER 20
12354   /* Loop until no stubs added.  After iteration 20 of this loop we may
12355      exit on a stub section shrinking.  This is to break out of a
12356      pathological case where adding stubs on one iteration decreases
12357      section gaps (perhaps due to alignment), which then requires
12358      fewer or smaller stubs on the next iteration.  */
12359 
12360   while (1)
12361     {
12362       bfd *input_bfd;
12363       unsigned int bfd_indx;
12364       struct map_stub *group;
12365       asection *stub_sec;
12366 
12367       htab->stub_iteration += 1;
12368 
12369       for (input_bfd = info->input_bfds, bfd_indx = 0;
12370 	   input_bfd != NULL;
12371 	   input_bfd = input_bfd->link.next, bfd_indx++)
12372 	{
12373 	  Elf_Internal_Shdr *symtab_hdr;
12374 	  asection *section;
12375 	  Elf_Internal_Sym *local_syms = NULL;
12376 
12377 	  if (!is_ppc64_elf (input_bfd))
12378 	    continue;
12379 
12380 	  /* We'll need the symbol table in a second.  */
12381 	  symtab_hdr = &elf_symtab_hdr (input_bfd);
12382 	  if (symtab_hdr->sh_info == 0)
12383 	    continue;
12384 
12385 	  /* Walk over each section attached to the input bfd.  */
12386 	  for (section = input_bfd->sections;
12387 	       section != NULL;
12388 	       section = section->next)
12389 	    {
12390 	      Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12391 
12392 	      /* If there aren't any relocs, then there's nothing more
12393 		 to do.  */
12394 	      if ((section->flags & SEC_RELOC) == 0
12395 		  || (section->flags & SEC_ALLOC) == 0
12396 		  || (section->flags & SEC_LOAD) == 0
12397 		  || (section->flags & SEC_CODE) == 0
12398 		  || section->reloc_count == 0)
12399 		continue;
12400 
12401 	      /* If this section is a link-once section that will be
12402 		 discarded, then don't create any stubs.  */
12403 	      if (section->output_section == NULL
12404 		  || section->output_section->owner != info->output_bfd)
12405 		continue;
12406 
12407 	      /* Get the relocs.  */
12408 	      internal_relocs
12409 		= _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12410 					     info->keep_memory);
12411 	      if (internal_relocs == NULL)
12412 		goto error_ret_free_local;
12413 
12414 	      /* Now examine each relocation.  */
12415 	      irela = internal_relocs;
12416 	      irelaend = irela + section->reloc_count;
12417 	      for (; irela < irelaend; irela++)
12418 		{
12419 		  enum elf_ppc64_reloc_type r_type;
12420 		  unsigned int r_indx;
12421 		  enum ppc_stub_type stub_type;
12422 		  struct ppc_stub_hash_entry *stub_entry;
12423 		  asection *sym_sec, *code_sec;
12424 		  bfd_vma sym_value, code_value;
12425 		  bfd_vma destination;
12426 		  unsigned long local_off;
12427 		  bfd_boolean ok_dest;
12428 		  struct ppc_link_hash_entry *hash;
12429 		  struct ppc_link_hash_entry *fdh;
12430 		  struct elf_link_hash_entry *h;
12431 		  Elf_Internal_Sym *sym;
12432 		  char *stub_name;
12433 		  const asection *id_sec;
12434 		  struct _opd_sec_data *opd;
12435 		  struct plt_entry *plt_ent;
12436 
12437 		  r_type = ELF64_R_TYPE (irela->r_info);
12438 		  r_indx = ELF64_R_SYM (irela->r_info);
12439 
12440 		  if (r_type >= R_PPC64_max)
12441 		    {
12442 		      bfd_set_error (bfd_error_bad_value);
12443 		      goto error_ret_free_internal;
12444 		    }
12445 
12446 		  /* Only look for stubs on branch instructions.  */
12447 		  if (r_type != R_PPC64_REL24
12448 		      && r_type != R_PPC64_REL14
12449 		      && r_type != R_PPC64_REL14_BRTAKEN
12450 		      && r_type != R_PPC64_REL14_BRNTAKEN)
12451 		    continue;
12452 
12453 		  /* Now determine the call target, its name, value,
12454 		     section.  */
12455 		  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12456 				  r_indx, input_bfd))
12457 		    goto error_ret_free_internal;
12458 		  hash = (struct ppc_link_hash_entry *) h;
12459 
12460 		  ok_dest = FALSE;
12461 		  fdh = NULL;
12462 		  sym_value = 0;
12463 		  if (hash == NULL)
12464 		    {
12465 		      sym_value = sym->st_value;
12466 		      if (sym_sec != NULL
12467 			  && sym_sec->output_section != NULL)
12468 			ok_dest = TRUE;
12469 		    }
12470 		  else if (hash->elf.root.type == bfd_link_hash_defined
12471 			   || hash->elf.root.type == bfd_link_hash_defweak)
12472 		    {
12473 		      sym_value = hash->elf.root.u.def.value;
12474 		      if (sym_sec->output_section != NULL)
12475 			ok_dest = TRUE;
12476 		    }
12477 		  else if (hash->elf.root.type == bfd_link_hash_undefweak
12478 			   || hash->elf.root.type == bfd_link_hash_undefined)
12479 		    {
12480 		      /* Recognise an old ABI func code entry sym, and
12481 			 use the func descriptor sym instead if it is
12482 			 defined.  */
12483 		      if (hash->elf.root.root.string[0] == '.'
12484 			  && hash->oh != NULL)
12485 			{
12486 			  fdh = ppc_follow_link (hash->oh);
12487 			  if (fdh->elf.root.type == bfd_link_hash_defined
12488 			      || fdh->elf.root.type == bfd_link_hash_defweak)
12489 			    {
12490 			      sym_sec = fdh->elf.root.u.def.section;
12491 			      sym_value = fdh->elf.root.u.def.value;
12492 			      if (sym_sec->output_section != NULL)
12493 				ok_dest = TRUE;
12494 			    }
12495 			  else
12496 			    fdh = NULL;
12497 			}
12498 		    }
12499 		  else
12500 		    {
12501 		      bfd_set_error (bfd_error_bad_value);
12502 		      goto error_ret_free_internal;
12503 		    }
12504 
12505 		  destination = 0;
12506 		  local_off = 0;
12507 		  if (ok_dest)
12508 		    {
12509 		      sym_value += irela->r_addend;
12510 		      destination = (sym_value
12511 				     + sym_sec->output_offset
12512 				     + sym_sec->output_section->vma);
12513 		      local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12514 							    ? hash->elf.other
12515 							    : sym->st_other);
12516 		    }
12517 
12518 		  code_sec = sym_sec;
12519 		  code_value = sym_value;
12520 		  opd = get_opd_info (sym_sec);
12521 		  if (opd != NULL)
12522 		    {
12523 		      bfd_vma dest;
12524 
12525 		      if (hash == NULL && opd->adjust != NULL)
12526 			{
12527 			  long adjust = opd->adjust[OPD_NDX (sym_value)];
12528 			  if (adjust == -1)
12529 			    continue;
12530 			  code_value += adjust;
12531 			  sym_value += adjust;
12532 			}
12533 		      dest = opd_entry_value (sym_sec, sym_value,
12534 					      &code_sec, &code_value, FALSE);
12535 		      if (dest != (bfd_vma) -1)
12536 			{
12537 			  destination = dest;
12538 			  if (fdh != NULL)
12539 			    {
12540 			      /* Fixup old ABI sym to point at code
12541 				 entry.  */
12542 			      hash->elf.root.type = bfd_link_hash_defweak;
12543 			      hash->elf.root.u.def.section = code_sec;
12544 			      hash->elf.root.u.def.value = code_value;
12545 			    }
12546 			}
12547 		    }
12548 
12549 		  /* Determine what (if any) linker stub is needed.  */
12550 		  plt_ent = NULL;
12551 		  stub_type = ppc_type_of_stub (section, irela, &hash,
12552 						&plt_ent, destination,
12553 						local_off);
12554 
12555 		  if (stub_type != ppc_stub_plt_call)
12556 		    {
12557 		      /* Check whether we need a TOC adjusting stub.
12558 			 Since the linker pastes together pieces from
12559 			 different object files when creating the
12560 			 _init and _fini functions, it may be that a
12561 			 call to what looks like a local sym is in
12562 			 fact a call needing a TOC adjustment.  */
12563 		      if (code_sec != NULL
12564 			  && code_sec->output_section != NULL
12565 			  && (htab->sec_info[code_sec->id].toc_off
12566 			      != htab->sec_info[section->id].toc_off)
12567 			  && (code_sec->has_toc_reloc
12568 			      || code_sec->makes_toc_func_call))
12569 			stub_type = ppc_stub_long_branch_r2off;
12570 		    }
12571 
12572 		  if (stub_type == ppc_stub_none)
12573 		    continue;
12574 
12575 		  /* __tls_get_addr calls might be eliminated.  */
12576 		  if (stub_type != ppc_stub_plt_call
12577 		      && hash != NULL
12578 		      && (hash == htab->tls_get_addr
12579 			  || hash == htab->tls_get_addr_fd)
12580 		      && section->has_tls_reloc
12581 		      && irela != internal_relocs)
12582 		    {
12583 		      /* Get tls info.  */
12584 		      unsigned char *tls_mask;
12585 
12586 		      if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12587 					 irela - 1, input_bfd))
12588 			goto error_ret_free_internal;
12589 		      if (*tls_mask != 0)
12590 			continue;
12591 		    }
12592 
12593 		  if (stub_type == ppc_stub_plt_call
12594 		      && irela + 1 < irelaend
12595 		      && irela[1].r_offset == irela->r_offset + 4
12596 		      && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12597 		    {
12598 		      if (!tocsave_find (htab, INSERT,
12599 					 &local_syms, irela + 1, input_bfd))
12600 			goto error_ret_free_internal;
12601 		    }
12602 		  else if (stub_type == ppc_stub_plt_call)
12603 		    stub_type = ppc_stub_plt_call_r2save;
12604 
12605 		  /* Support for grouping stub sections.  */
12606 		  id_sec = htab->sec_info[section->id].u.group->link_sec;
12607 
12608 		  /* Get the name of this stub.  */
12609 		  stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12610 		  if (!stub_name)
12611 		    goto error_ret_free_internal;
12612 
12613 		  stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12614 						     stub_name, FALSE, FALSE);
12615 		  if (stub_entry != NULL)
12616 		    {
12617 		      /* The proper stub has already been created.  */
12618 		      free (stub_name);
12619 		      if (stub_type == ppc_stub_plt_call_r2save)
12620 			stub_entry->stub_type = stub_type;
12621 		      continue;
12622 		    }
12623 
12624 		  stub_entry = ppc_add_stub (stub_name, section, info);
12625 		  if (stub_entry == NULL)
12626 		    {
12627 		      free (stub_name);
12628 		    error_ret_free_internal:
12629 		      if (elf_section_data (section)->relocs == NULL)
12630 			free (internal_relocs);
12631 		    error_ret_free_local:
12632 		      if (local_syms != NULL
12633 			  && (symtab_hdr->contents
12634 			      != (unsigned char *) local_syms))
12635 			free (local_syms);
12636 		      return FALSE;
12637 		    }
12638 
12639 		  stub_entry->stub_type = stub_type;
12640 		  if (stub_type != ppc_stub_plt_call
12641 		      && stub_type != ppc_stub_plt_call_r2save)
12642 		    {
12643 		      stub_entry->target_value = code_value;
12644 		      stub_entry->target_section = code_sec;
12645 		    }
12646 		  else
12647 		    {
12648 		      stub_entry->target_value = sym_value;
12649 		      stub_entry->target_section = sym_sec;
12650 		    }
12651 		  stub_entry->h = hash;
12652 		  stub_entry->plt_ent = plt_ent;
12653 		  stub_entry->other = hash ? hash->elf.other : sym->st_other;
12654 
12655 		  if (stub_entry->h != NULL)
12656 		    htab->stub_globals += 1;
12657 		}
12658 
12659 	      /* We're done with the internal relocs, free them.  */
12660 	      if (elf_section_data (section)->relocs != internal_relocs)
12661 		free (internal_relocs);
12662 	    }
12663 
12664 	  if (local_syms != NULL
12665 	      && symtab_hdr->contents != (unsigned char *) local_syms)
12666 	    {
12667 	      if (!info->keep_memory)
12668 		free (local_syms);
12669 	      else
12670 		symtab_hdr->contents = (unsigned char *) local_syms;
12671 	    }
12672 	}
12673 
12674       /* We may have added some stubs.  Find out the new size of the
12675 	 stub sections.  */
12676       for (stub_sec = htab->params->stub_bfd->sections;
12677 	   stub_sec != NULL;
12678 	   stub_sec = stub_sec->next)
12679 	if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12680 	  {
12681 	    if (htab->stub_iteration <= STUB_SHRINK_ITER
12682 		|| stub_sec->rawsize < stub_sec->size)
12683 	      /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12684 	      stub_sec->rawsize = stub_sec->size;
12685 	    stub_sec->size = 0;
12686 	    stub_sec->reloc_count = 0;
12687 	    stub_sec->flags &= ~SEC_RELOC;
12688 	  }
12689 
12690       htab->brlt->size = 0;
12691       htab->brlt->reloc_count = 0;
12692       htab->brlt->flags &= ~SEC_RELOC;
12693       if (htab->relbrlt != NULL)
12694 	htab->relbrlt->size = 0;
12695 
12696       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12697 
12698       for (group = htab->group; group != NULL; group = group->next)
12699 	if (group->needs_save_res)
12700 	  group->stub_sec->size += htab->sfpr->size;
12701 
12702       if (info->emitrelocations
12703 	  && htab->glink != NULL && htab->glink->size != 0)
12704 	{
12705 	  htab->glink->reloc_count = 1;
12706 	  htab->glink->flags |= SEC_RELOC;
12707 	}
12708 
12709       if (htab->glink_eh_frame != NULL
12710 	  && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12711 	  && htab->glink_eh_frame->output_section->size != 0)
12712 	{
12713 	  size_t size = 0, align = 4;
12714 
12715 	  for (stub_sec = htab->params->stub_bfd->sections;
12716 	       stub_sec != NULL;
12717 	       stub_sec = stub_sec->next)
12718 	    if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12719 	      size += (17 + align - 1) & -align;
12720 	  if (htab->glink != NULL && htab->glink->size != 0)
12721 	    size += (24 + align - 1) & -align;
12722 	  if (size != 0)
12723 	    size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12724 	  align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12725 	  size = (size + align - 1) & -align;
12726 	  htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12727 	  htab->glink_eh_frame->size = size;
12728 	}
12729 
12730       if (htab->params->plt_stub_align != 0)
12731 	for (stub_sec = htab->params->stub_bfd->sections;
12732 	     stub_sec != NULL;
12733 	     stub_sec = stub_sec->next)
12734 	  if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12735 	    stub_sec->size = ((stub_sec->size
12736 			       + (1 << htab->params->plt_stub_align) - 1)
12737 			      & -(1 << htab->params->plt_stub_align));
12738 
12739       for (stub_sec = htab->params->stub_bfd->sections;
12740 	   stub_sec != NULL;
12741 	   stub_sec = stub_sec->next)
12742 	if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12743 	    && stub_sec->rawsize != stub_sec->size
12744 	    && (htab->stub_iteration <= STUB_SHRINK_ITER
12745 		|| stub_sec->rawsize < stub_sec->size))
12746 	  break;
12747 
12748       if (stub_sec == NULL
12749 	  && (htab->glink_eh_frame == NULL
12750 	      || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12751 	break;
12752 
12753       /* Ask the linker to do its stuff.  */
12754       (*htab->params->layout_sections_again) ();
12755     }
12756 
12757   if (htab->glink_eh_frame != NULL
12758       && htab->glink_eh_frame->size != 0)
12759     {
12760       bfd_vma val;
12761       bfd_byte *p, *last_fde;
12762       size_t last_fde_len, size, align, pad;
12763       asection *stub_sec;
12764 
12765       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12766       if (p == NULL)
12767 	return FALSE;
12768       htab->glink_eh_frame->contents = p;
12769       last_fde = p;
12770       align = 4;
12771 
12772       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12773       /* CIE length (rewrite in case little-endian).  */
12774       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12775       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12776       p += last_fde_len + 4;
12777 
12778       for (stub_sec = htab->params->stub_bfd->sections;
12779 	   stub_sec != NULL;
12780 	   stub_sec = stub_sec->next)
12781 	if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12782 	  {
12783 	    last_fde = p;
12784 	    last_fde_len = ((17 + align - 1) & -align) - 4;
12785 	    /* FDE length.  */
12786 	    bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12787 	    p += 4;
12788 	    /* CIE pointer.  */
12789 	    val = p - htab->glink_eh_frame->contents;
12790 	    bfd_put_32 (htab->elf.dynobj, val, p);
12791 	    p += 4;
12792 	    /* Offset to stub section, written later.  */
12793 	    p += 4;
12794 	    /* stub section size.  */
12795 	    bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12796 	    p += 4;
12797 	    /* Augmentation.  */
12798 	    p += 1;
12799 	    /* Pad.  */
12800 	    p += ((17 + align - 1) & -align) - 17;
12801 	  }
12802       if (htab->glink != NULL && htab->glink->size != 0)
12803 	{
12804 	  last_fde = p;
12805 	  last_fde_len = ((24 + align - 1) & -align) - 4;
12806 	  /* FDE length.  */
12807 	  bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12808 	  p += 4;
12809 	  /* CIE pointer.  */
12810 	  val = p - htab->glink_eh_frame->contents;
12811 	  bfd_put_32 (htab->elf.dynobj, val, p);
12812 	  p += 4;
12813 	  /* Offset to .glink, written later.  */
12814 	  p += 4;
12815 	  /* .glink size.  */
12816 	  bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12817 	  p += 4;
12818 	  /* Augmentation.  */
12819 	  p += 1;
12820 
12821 	  *p++ = DW_CFA_advance_loc + 1;
12822 	  *p++ = DW_CFA_register;
12823 	  *p++ = 65;
12824 	  *p++ = htab->opd_abi ? 12 : 0;
12825 	  *p++ = DW_CFA_advance_loc + 4;
12826 	  *p++ = DW_CFA_restore_extended;
12827 	  *p++ = 65;
12828 	  p += ((24 + align - 1) & -align) - 24;
12829 	}
12830       /* Subsume any padding into the last FDE if user .eh_frame
12831 	 sections are aligned more than glink_eh_frame.  Otherwise any
12832 	 zero padding will be seen as a terminator.  */
12833       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12834       size = p - htab->glink_eh_frame->contents;
12835       pad = ((size + align - 1) & -align) - size;
12836       htab->glink_eh_frame->size = size + pad;
12837       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12838     }
12839 
12840   maybe_strip_output (info, htab->brlt);
12841   if (htab->glink_eh_frame != NULL)
12842     maybe_strip_output (info, htab->glink_eh_frame);
12843 
12844   return TRUE;
12845 }
12846 
12847 /* Called after we have determined section placement.  If sections
12848    move, we'll be called again.  Provide a value for TOCstart.  */
12849 
12850 bfd_vma
12851 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12852 {
12853   asection *s;
12854   bfd_vma TOCstart, adjust;
12855 
12856   if (info != NULL)
12857     {
12858       struct elf_link_hash_entry *h;
12859       struct elf_link_hash_table *htab = elf_hash_table (info);
12860 
12861       if (is_elf_hash_table (htab)
12862 	  && htab->hgot != NULL)
12863 	h = htab->hgot;
12864       else
12865 	{
12866 	  h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12867 	  if (is_elf_hash_table (htab))
12868 	    htab->hgot = h;
12869 	}
12870       if (h != NULL
12871 	  && h->root.type == bfd_link_hash_defined
12872 	  && !h->root.linker_def
12873 	  && (!is_elf_hash_table (htab)
12874 	      || h->def_regular))
12875 	{
12876 	  TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12877 		      + h->root.u.def.section->output_offset
12878 		      + h->root.u.def.section->output_section->vma);
12879 	  _bfd_set_gp_value (obfd, TOCstart);
12880 	  return TOCstart;
12881 	}
12882     }
12883 
12884   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12885      order.  The TOC starts where the first of these sections starts.  */
12886   s = bfd_get_section_by_name (obfd, ".got");
12887   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12888     s = bfd_get_section_by_name (obfd, ".toc");
12889   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12890     s = bfd_get_section_by_name (obfd, ".tocbss");
12891   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12892     s = bfd_get_section_by_name (obfd, ".plt");
12893   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12894     {
12895       /* This may happen for
12896 	 o  references to TOC base (SYM@toc / TOC[tc0]) without a
12897 	 .toc directive
12898 	 o  bad linker script
12899 	 o --gc-sections and empty TOC sections
12900 
12901 	 FIXME: Warn user?  */
12902 
12903       /* Look for a likely section.  We probably won't even be
12904 	 using TOCstart.  */
12905       for (s = obfd->sections; s != NULL; s = s->next)
12906 	if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12907 			 | SEC_EXCLUDE))
12908 	    == (SEC_ALLOC | SEC_SMALL_DATA))
12909 	  break;
12910       if (s == NULL)
12911 	for (s = obfd->sections; s != NULL; s = s->next)
12912 	  if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12913 	      == (SEC_ALLOC | SEC_SMALL_DATA))
12914 	    break;
12915       if (s == NULL)
12916 	for (s = obfd->sections; s != NULL; s = s->next)
12917 	  if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12918 	      == SEC_ALLOC)
12919 	    break;
12920       if (s == NULL)
12921 	for (s = obfd->sections; s != NULL; s = s->next)
12922 	  if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12923 	    break;
12924     }
12925 
12926   TOCstart = 0;
12927   if (s != NULL)
12928     TOCstart = s->output_section->vma + s->output_offset;
12929 
12930   /* Force alignment.  */
12931   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12932   TOCstart -= adjust;
12933   _bfd_set_gp_value (obfd, TOCstart);
12934 
12935   if (info != NULL && s != NULL)
12936     {
12937       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12938 
12939       if (htab != NULL)
12940 	{
12941 	  if (htab->elf.hgot != NULL)
12942 	    {
12943 	      htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12944 	      htab->elf.hgot->root.u.def.section = s;
12945 	    }
12946 	}
12947       else
12948 	{
12949 	  struct bfd_link_hash_entry *bh = NULL;
12950 	  _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12951 					    s, TOC_BASE_OFF - adjust,
12952 					    NULL, FALSE, FALSE, &bh);
12953 	}
12954     }
12955   return TOCstart;
12956 }
12957 
12958 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12959    write out any global entry stubs.  */
12960 
12961 static bfd_boolean
12962 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12963 {
12964   struct bfd_link_info *info;
12965   struct ppc_link_hash_table *htab;
12966   struct plt_entry *pent;
12967   asection *s;
12968 
12969   if (h->root.type == bfd_link_hash_indirect)
12970     return TRUE;
12971 
12972   if (!h->pointer_equality_needed)
12973     return TRUE;
12974 
12975   if (h->def_regular)
12976     return TRUE;
12977 
12978   info = inf;
12979   htab = ppc_hash_table (info);
12980   if (htab == NULL)
12981     return FALSE;
12982 
12983   s = htab->glink;
12984   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12985     if (pent->plt.offset != (bfd_vma) -1
12986 	&& pent->addend == 0)
12987       {
12988 	bfd_byte *p;
12989 	asection *plt;
12990 	bfd_vma off;
12991 
12992 	p = s->contents + h->root.u.def.value;
12993 	plt = htab->elf.splt;
12994 	if (!htab->elf.dynamic_sections_created
12995 	    || h->dynindx == -1)
12996 	  plt = htab->elf.iplt;
12997 	off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12998 	off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12999 
13000 	if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13001 	  {
13002 	    info->callbacks->einfo
13003 	      (_("%P: linkage table error against `%T'\n"),
13004 	       h->root.root.string);
13005 	    bfd_set_error (bfd_error_bad_value);
13006 	    htab->stub_error = TRUE;
13007 	  }
13008 
13009 	htab->stub_count[ppc_stub_global_entry - 1] += 1;
13010 	if (htab->params->emit_stub_syms)
13011 	  {
13012 	    size_t len = strlen (h->root.root.string);
13013 	    char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13014 
13015 	    if (name == NULL)
13016 	      return FALSE;
13017 
13018 	    sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13019 	    h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13020 	    if (h == NULL)
13021 	      return FALSE;
13022 	    if (h->root.type == bfd_link_hash_new)
13023 	      {
13024 		h->root.type = bfd_link_hash_defined;
13025 		h->root.u.def.section = s;
13026 		h->root.u.def.value = p - s->contents;
13027 		h->ref_regular = 1;
13028 		h->def_regular = 1;
13029 		h->ref_regular_nonweak = 1;
13030 		h->forced_local = 1;
13031 		h->non_elf = 0;
13032 		h->root.linker_def = 1;
13033 	      }
13034 	  }
13035 
13036 	if (PPC_HA (off) != 0)
13037 	  {
13038 	    bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13039 	    p += 4;
13040 	  }
13041 	bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13042 	p += 4;
13043 	bfd_put_32 (s->owner, MTCTR_R12, p);
13044 	p += 4;
13045 	bfd_put_32 (s->owner, BCTR, p);
13046 	break;
13047       }
13048   return TRUE;
13049 }
13050 
13051 /* Build all the stubs associated with the current output file.
13052    The stubs are kept in a hash table attached to the main linker
13053    hash table.  This function is called via gldelf64ppc_finish.  */
13054 
13055 bfd_boolean
13056 ppc64_elf_build_stubs (struct bfd_link_info *info,
13057 		       char **stats)
13058 {
13059   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13060   struct map_stub *group;
13061   asection *stub_sec;
13062   bfd_byte *p;
13063   int stub_sec_count = 0;
13064 
13065   if (htab == NULL)
13066     return FALSE;
13067 
13068   /* Allocate memory to hold the linker stubs.  */
13069   for (stub_sec = htab->params->stub_bfd->sections;
13070        stub_sec != NULL;
13071        stub_sec = stub_sec->next)
13072     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13073 	&& stub_sec->size != 0)
13074       {
13075 	stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13076 	if (stub_sec->contents == NULL)
13077 	  return FALSE;
13078 	stub_sec->size = 0;
13079       }
13080 
13081   if (htab->glink != NULL && htab->glink->size != 0)
13082     {
13083       unsigned int indx;
13084       bfd_vma plt0;
13085 
13086       /* Build the .glink plt call stub.  */
13087       if (htab->params->emit_stub_syms)
13088 	{
13089 	  struct elf_link_hash_entry *h;
13090 	  h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13091 				    TRUE, FALSE, FALSE);
13092 	  if (h == NULL)
13093 	    return FALSE;
13094 	  if (h->root.type == bfd_link_hash_new)
13095 	    {
13096 	      h->root.type = bfd_link_hash_defined;
13097 	      h->root.u.def.section = htab->glink;
13098 	      h->root.u.def.value = 8;
13099 	      h->ref_regular = 1;
13100 	      h->def_regular = 1;
13101 	      h->ref_regular_nonweak = 1;
13102 	      h->forced_local = 1;
13103 	      h->non_elf = 0;
13104 	      h->root.linker_def = 1;
13105 	    }
13106 	}
13107       plt0 = (htab->elf.splt->output_section->vma
13108 	      + htab->elf.splt->output_offset
13109 	      - 16);
13110       if (info->emitrelocations)
13111 	{
13112 	  Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13113 	  if (r == NULL)
13114 	    return FALSE;
13115 	  r->r_offset = (htab->glink->output_offset
13116 			 + htab->glink->output_section->vma);
13117 	  r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13118 	  r->r_addend = plt0;
13119 	}
13120       p = htab->glink->contents;
13121       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13122       bfd_put_64 (htab->glink->owner, plt0, p);
13123       p += 8;
13124       if (htab->opd_abi)
13125 	{
13126 	  bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13127 	  p += 4;
13128 	  bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13129 	  p += 4;
13130 	  bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13131 	  p += 4;
13132 	  bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13133 	  p += 4;
13134 	  bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13135 	  p += 4;
13136 	  bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13137 	  p += 4;
13138 	  bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13139 	  p += 4;
13140 	  bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13141 	  p += 4;
13142 	  bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13143 	  p += 4;
13144 	  bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13145 	  p += 4;
13146 	}
13147       else
13148 	{
13149 	  bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13150 	  p += 4;
13151 	  bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13152 	  p += 4;
13153 	  bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13154 	  p += 4;
13155 	  bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13156 	  p += 4;
13157 	  bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13158 	  p += 4;
13159 	  bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13160 	  p += 4;
13161 	  bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13162 	  p += 4;
13163 	  bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13164 	  p += 4;
13165 	  bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13166 	  p += 4;
13167 	  bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13168 	  p += 4;
13169 	  bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13170 	  p += 4;
13171 	  bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13172 	  p += 4;
13173 	}
13174       bfd_put_32 (htab->glink->owner, BCTR, p);
13175       p += 4;
13176       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13177 	{
13178 	  bfd_put_32 (htab->glink->owner, NOP, p);
13179 	  p += 4;
13180 	}
13181 
13182       /* Build the .glink lazy link call stubs.  */
13183       indx = 0;
13184       while (p < htab->glink->contents + htab->glink->rawsize)
13185 	{
13186 	  if (htab->opd_abi)
13187 	    {
13188 	      if (indx < 0x8000)
13189 		{
13190 		  bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13191 		  p += 4;
13192 		}
13193 	      else
13194 		{
13195 		  bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13196 		  p += 4;
13197 		  bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13198 			      p);
13199 		  p += 4;
13200 		}
13201 	    }
13202 	  bfd_put_32 (htab->glink->owner,
13203 		      B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13204 	  indx++;
13205 	  p += 4;
13206 	}
13207 
13208       /* Build .glink global entry stubs.  */
13209       if (htab->glink->size > htab->glink->rawsize)
13210 	elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13211     }
13212 
13213   if (htab->brlt != NULL && htab->brlt->size != 0)
13214     {
13215       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13216 					 htab->brlt->size);
13217       if (htab->brlt->contents == NULL)
13218 	return FALSE;
13219     }
13220   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13221     {
13222       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13223 					    htab->relbrlt->size);
13224       if (htab->relbrlt->contents == NULL)
13225 	return FALSE;
13226     }
13227 
13228   /* Build the stubs as directed by the stub hash table.  */
13229   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13230 
13231   for (group = htab->group; group != NULL; group = group->next)
13232     if (group->needs_save_res)
13233       {
13234 	stub_sec = group->stub_sec;
13235 	memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13236 		htab->sfpr->size);
13237 	if (htab->params->emit_stub_syms)
13238 	  {
13239 	    unsigned int i;
13240 
13241 	    for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13242 	      if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13243 		return FALSE;
13244 	  }
13245 	stub_sec->size += htab->sfpr->size;
13246       }
13247 
13248   if (htab->relbrlt != NULL)
13249     htab->relbrlt->reloc_count = 0;
13250 
13251   if (htab->params->plt_stub_align != 0)
13252     for (stub_sec = htab->params->stub_bfd->sections;
13253 	 stub_sec != NULL;
13254 	 stub_sec = stub_sec->next)
13255       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13256 	stub_sec->size = ((stub_sec->size
13257 			   + (1 << htab->params->plt_stub_align) - 1)
13258 			  & -(1 << htab->params->plt_stub_align));
13259 
13260   for (stub_sec = htab->params->stub_bfd->sections;
13261        stub_sec != NULL;
13262        stub_sec = stub_sec->next)
13263     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13264       {
13265 	stub_sec_count += 1;
13266 	if (stub_sec->rawsize != stub_sec->size
13267 	    && (htab->stub_iteration <= STUB_SHRINK_ITER
13268 		|| stub_sec->rawsize < stub_sec->size))
13269 	  break;
13270       }
13271 
13272   /* Note that the glink_eh_frame check here is not only testing that
13273      the generated size matched the calculated size but also that
13274      bfd_elf_discard_info didn't make any changes to the section.  */
13275   if (stub_sec != NULL
13276       || (htab->glink_eh_frame != NULL
13277 	  && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13278     {
13279       htab->stub_error = TRUE;
13280       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13281     }
13282 
13283   if (htab->stub_error)
13284     return FALSE;
13285 
13286   if (stats != NULL)
13287     {
13288       *stats = bfd_malloc (500);
13289       if (*stats == NULL)
13290 	return FALSE;
13291 
13292       sprintf (*stats, _("linker stubs in %u group%s\n"
13293 			 "  branch       %lu\n"
13294 			 "  toc adjust   %lu\n"
13295 			 "  long branch  %lu\n"
13296 			 "  long toc adj %lu\n"
13297 			 "  plt call     %lu\n"
13298 			 "  plt call toc %lu\n"
13299 			 "  global entry %lu"),
13300 	       stub_sec_count,
13301 	       stub_sec_count == 1 ? "" : "s",
13302 	       htab->stub_count[ppc_stub_long_branch - 1],
13303 	       htab->stub_count[ppc_stub_long_branch_r2off - 1],
13304 	       htab->stub_count[ppc_stub_plt_branch - 1],
13305 	       htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13306 	       htab->stub_count[ppc_stub_plt_call - 1],
13307 	       htab->stub_count[ppc_stub_plt_call_r2save - 1],
13308 	       htab->stub_count[ppc_stub_global_entry - 1]);
13309     }
13310   return TRUE;
13311 }
13312 
13313 /* What to do when ld finds relocations against symbols defined in
13314    discarded sections.  */
13315 
13316 static unsigned int
13317 ppc64_elf_action_discarded (asection *sec)
13318 {
13319   if (strcmp (".opd", sec->name) == 0)
13320     return 0;
13321 
13322   if (strcmp (".toc", sec->name) == 0)
13323     return 0;
13324 
13325   if (strcmp (".toc1", sec->name) == 0)
13326     return 0;
13327 
13328   return _bfd_elf_default_action_discarded (sec);
13329 }
13330 
13331 /* The RELOCATE_SECTION function is called by the ELF backend linker
13332    to handle the relocations for a section.
13333 
13334    The relocs are always passed as Rela structures; if the section
13335    actually uses Rel structures, the r_addend field will always be
13336    zero.
13337 
13338    This function is responsible for adjust the section contents as
13339    necessary, and (if using Rela relocs and generating a
13340    relocatable output file) adjusting the reloc addend as
13341    necessary.
13342 
13343    This function does not have to worry about setting the reloc
13344    address or the reloc symbol index.
13345 
13346    LOCAL_SYMS is a pointer to the swapped in local symbols.
13347 
13348    LOCAL_SECTIONS is an array giving the section in the input file
13349    corresponding to the st_shndx field of each local symbol.
13350 
13351    The global hash table entry for the global symbols can be found
13352    via elf_sym_hashes (input_bfd).
13353 
13354    When generating relocatable output, this function must handle
13355    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13356    going to be the section symbol corresponding to the output
13357    section, which means that the addend must be adjusted
13358    accordingly.  */
13359 
13360 static bfd_boolean
13361 ppc64_elf_relocate_section (bfd *output_bfd,
13362 			    struct bfd_link_info *info,
13363 			    bfd *input_bfd,
13364 			    asection *input_section,
13365 			    bfd_byte *contents,
13366 			    Elf_Internal_Rela *relocs,
13367 			    Elf_Internal_Sym *local_syms,
13368 			    asection **local_sections)
13369 {
13370   struct ppc_link_hash_table *htab;
13371   Elf_Internal_Shdr *symtab_hdr;
13372   struct elf_link_hash_entry **sym_hashes;
13373   Elf_Internal_Rela *rel;
13374   Elf_Internal_Rela *wrel;
13375   Elf_Internal_Rela *relend;
13376   Elf_Internal_Rela outrel;
13377   bfd_byte *loc;
13378   struct got_entry **local_got_ents;
13379   bfd_vma TOCstart;
13380   bfd_boolean ret = TRUE;
13381   bfd_boolean is_opd;
13382   /* Assume 'at' branch hints.  */
13383   bfd_boolean is_isa_v2 = TRUE;
13384   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13385 
13386   /* Initialize howto table if needed.  */
13387   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13388     ppc_howto_init ();
13389 
13390   htab = ppc_hash_table (info);
13391   if (htab == NULL)
13392     return FALSE;
13393 
13394   /* Don't relocate stub sections.  */
13395   if (input_section->owner == htab->params->stub_bfd)
13396     return TRUE;
13397 
13398   BFD_ASSERT (is_ppc64_elf (input_bfd));
13399 
13400   local_got_ents = elf_local_got_ents (input_bfd);
13401   TOCstart = elf_gp (output_bfd);
13402   symtab_hdr = &elf_symtab_hdr (input_bfd);
13403   sym_hashes = elf_sym_hashes (input_bfd);
13404   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13405 
13406   rel = wrel = relocs;
13407   relend = relocs + input_section->reloc_count;
13408   for (; rel < relend; wrel++, rel++)
13409     {
13410       enum elf_ppc64_reloc_type r_type;
13411       bfd_vma addend;
13412       bfd_reloc_status_type r;
13413       Elf_Internal_Sym *sym;
13414       asection *sec;
13415       struct elf_link_hash_entry *h_elf;
13416       struct ppc_link_hash_entry *h;
13417       struct ppc_link_hash_entry *fdh;
13418       const char *sym_name;
13419       unsigned long r_symndx, toc_symndx;
13420       bfd_vma toc_addend;
13421       unsigned char tls_mask, tls_gd, tls_type;
13422       unsigned char sym_type;
13423       bfd_vma relocation;
13424       bfd_boolean unresolved_reloc;
13425       bfd_boolean warned;
13426       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13427       unsigned int insn;
13428       unsigned int mask;
13429       struct ppc_stub_hash_entry *stub_entry;
13430       bfd_vma max_br_offset;
13431       bfd_vma from;
13432       Elf_Internal_Rela orig_rel;
13433       reloc_howto_type *howto;
13434       struct reloc_howto_struct alt_howto;
13435 
13436     again:
13437       orig_rel = *rel;
13438 
13439       r_type = ELF64_R_TYPE (rel->r_info);
13440       r_symndx = ELF64_R_SYM (rel->r_info);
13441 
13442       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13443 	 symbol of the previous ADDR64 reloc.  The symbol gives us the
13444 	 proper TOC base to use.  */
13445       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13446 	  && wrel != relocs
13447 	  && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13448 	  && is_opd)
13449 	r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13450 
13451       sym = NULL;
13452       sec = NULL;
13453       h_elf = NULL;
13454       sym_name = NULL;
13455       unresolved_reloc = FALSE;
13456       warned = FALSE;
13457 
13458       if (r_symndx < symtab_hdr->sh_info)
13459 	{
13460 	  /* It's a local symbol.  */
13461 	  struct _opd_sec_data *opd;
13462 
13463 	  sym = local_syms + r_symndx;
13464 	  sec = local_sections[r_symndx];
13465 	  sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13466 	  sym_type = ELF64_ST_TYPE (sym->st_info);
13467 	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13468 	  opd = get_opd_info (sec);
13469 	  if (opd != NULL && opd->adjust != NULL)
13470 	    {
13471 	      long adjust = opd->adjust[OPD_NDX (sym->st_value
13472 						 + rel->r_addend)];
13473 	      if (adjust == -1)
13474 		relocation = 0;
13475 	      else
13476 		{
13477 		  /* If this is a relocation against the opd section sym
13478 		     and we have edited .opd, adjust the reloc addend so
13479 		     that ld -r and ld --emit-relocs output is correct.
13480 		     If it is a reloc against some other .opd symbol,
13481 		     then the symbol value will be adjusted later.  */
13482 		  if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13483 		    rel->r_addend += adjust;
13484 		  else
13485 		    relocation += adjust;
13486 		}
13487 	    }
13488 	}
13489       else
13490 	{
13491 	  bfd_boolean ignored;
13492 
13493 	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13494 				   r_symndx, symtab_hdr, sym_hashes,
13495 				   h_elf, sec, relocation,
13496 				   unresolved_reloc, warned, ignored);
13497 	  sym_name = h_elf->root.root.string;
13498 	  sym_type = h_elf->type;
13499 	  if (sec != NULL
13500 	      && sec->owner == output_bfd
13501 	      && strcmp (sec->name, ".opd") == 0)
13502 	    {
13503 	      /* This is a symbol defined in a linker script.  All
13504 		 such are defined in output sections, even those
13505 		 defined by simple assignment from a symbol defined in
13506 		 an input section.  Transfer the symbol to an
13507 		 appropriate input .opd section, so that a branch to
13508 		 this symbol will be mapped to the location specified
13509 		 by the opd entry.  */
13510 	      struct bfd_link_order *lo;
13511 	      for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13512 		if (lo->type == bfd_indirect_link_order)
13513 		  {
13514 		    asection *isec = lo->u.indirect.section;
13515 		    if (h_elf->root.u.def.value >= isec->output_offset
13516 			&& h_elf->root.u.def.value < (isec->output_offset
13517 						      + isec->size))
13518 		      {
13519 			h_elf->root.u.def.value -= isec->output_offset;
13520 			h_elf->root.u.def.section = isec;
13521 			sec = isec;
13522 			break;
13523 		      }
13524 		  }
13525 	    }
13526 	}
13527       h = (struct ppc_link_hash_entry *) h_elf;
13528 
13529       if (sec != NULL && discarded_section (sec))
13530 	{
13531 	  _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13532 			       input_bfd, input_section,
13533 			       contents + rel->r_offset);
13534 	  wrel->r_offset = rel->r_offset;
13535 	  wrel->r_info = 0;
13536 	  wrel->r_addend = 0;
13537 
13538 	  /* For ld -r, remove relocations in debug sections against
13539 	     sections defined in discarded sections.  Not done for
13540 	     non-debug to preserve relocs in .eh_frame which the
13541 	     eh_frame editing code expects to be present.  */
13542 	  if (bfd_link_relocatable (info)
13543 	      && (input_section->flags & SEC_DEBUGGING))
13544 	    wrel--;
13545 
13546 	  continue;
13547 	}
13548 
13549       if (bfd_link_relocatable (info))
13550 	goto copy_reloc;
13551 
13552       if (h != NULL && &h->elf == htab->elf.hgot)
13553 	{
13554 	  relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13555 	  sec = bfd_abs_section_ptr;
13556 	  unresolved_reloc = FALSE;
13557 	}
13558 
13559       /* TLS optimizations.  Replace instruction sequences and relocs
13560 	 based on information we collected in tls_optimize.  We edit
13561 	 RELOCS so that --emit-relocs will output something sensible
13562 	 for the final instruction stream.  */
13563       tls_mask = 0;
13564       tls_gd = 0;
13565       toc_symndx = 0;
13566       if (h != NULL)
13567 	tls_mask = h->tls_mask;
13568       else if (local_got_ents != NULL)
13569 	{
13570 	  struct plt_entry **local_plt = (struct plt_entry **)
13571 	    (local_got_ents + symtab_hdr->sh_info);
13572 	  unsigned char *lgot_masks = (unsigned char *)
13573 	    (local_plt + symtab_hdr->sh_info);
13574 	  tls_mask = lgot_masks[r_symndx];
13575 	}
13576       if (tls_mask == 0
13577 	  && (r_type == R_PPC64_TLS
13578 	      || r_type == R_PPC64_TLSGD
13579 	      || r_type == R_PPC64_TLSLD))
13580 	{
13581 	  /* Check for toc tls entries.  */
13582 	  unsigned char *toc_tls;
13583 
13584 	  if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13585 			     &local_syms, rel, input_bfd))
13586 	    return FALSE;
13587 
13588 	  if (toc_tls)
13589 	    tls_mask = *toc_tls;
13590 	}
13591 
13592       /* Check that tls relocs are used with tls syms, and non-tls
13593 	 relocs are used with non-tls syms.  */
13594       if (r_symndx != STN_UNDEF
13595 	  && r_type != R_PPC64_NONE
13596 	  && (h == NULL
13597 	      || h->elf.root.type == bfd_link_hash_defined
13598 	      || h->elf.root.type == bfd_link_hash_defweak)
13599 	  && (IS_PPC64_TLS_RELOC (r_type)
13600 	      != (sym_type == STT_TLS
13601 		  || (sym_type == STT_SECTION
13602 		      && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13603 	{
13604 	  if (tls_mask != 0
13605 	      && (r_type == R_PPC64_TLS
13606 		  || r_type == R_PPC64_TLSGD
13607 		  || r_type == R_PPC64_TLSLD))
13608 	    /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13609 	    ;
13610 	  else
13611 	    info->callbacks->einfo
13612 	      (!IS_PPC64_TLS_RELOC (r_type)
13613 	       /* xgettext:c-format */
13614 	       ? _("%H: %s used with TLS symbol `%T'\n")
13615 	       /* xgettext:c-format */
13616 	       : _("%H: %s used with non-TLS symbol `%T'\n"),
13617 	       input_bfd, input_section, rel->r_offset,
13618 	       ppc64_elf_howto_table[r_type]->name,
13619 	       sym_name);
13620 	}
13621 
13622       /* Ensure reloc mapping code below stays sane.  */
13623       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13624 	  || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13625 	  || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13626 	  || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13627 	  || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13628 	  || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13629 	  || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13630 	  || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13631 	  || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13632 	  || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13633 	abort ();
13634 
13635       switch (r_type)
13636 	{
13637 	default:
13638 	  break;
13639 
13640 	case R_PPC64_LO_DS_OPT:
13641 	  insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13642 	  if ((insn & (0x3f << 26)) != 58u << 26)
13643 	    abort ();
13644 	  insn += (14u << 26) - (58u << 26);
13645 	  bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13646 	  r_type = R_PPC64_TOC16_LO;
13647 	  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13648 	  break;
13649 
13650 	case R_PPC64_TOC16:
13651 	case R_PPC64_TOC16_LO:
13652 	case R_PPC64_TOC16_DS:
13653 	case R_PPC64_TOC16_LO_DS:
13654 	  {
13655 	    /* Check for toc tls entries.  */
13656 	    unsigned char *toc_tls;
13657 	    int retval;
13658 
13659 	    retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13660 				   &local_syms, rel, input_bfd);
13661 	    if (retval == 0)
13662 	      return FALSE;
13663 
13664 	    if (toc_tls)
13665 	      {
13666 		tls_mask = *toc_tls;
13667 		if (r_type == R_PPC64_TOC16_DS
13668 		    || r_type == R_PPC64_TOC16_LO_DS)
13669 		  {
13670 		    if (tls_mask != 0
13671 			&& (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13672 		      goto toctprel;
13673 		  }
13674 		else
13675 		  {
13676 		    /* If we found a GD reloc pair, then we might be
13677 		       doing a GD->IE transition.  */
13678 		    if (retval == 2)
13679 		      {
13680 			tls_gd = TLS_TPRELGD;
13681 			if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13682 			  goto tls_ldgd_opt;
13683 		      }
13684 		    else if (retval == 3)
13685 		      {
13686 			if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13687 			  goto tls_ldgd_opt;
13688 		      }
13689 		  }
13690 	      }
13691 	  }
13692 	  break;
13693 
13694 	case R_PPC64_GOT_TPREL16_HI:
13695 	case R_PPC64_GOT_TPREL16_HA:
13696 	  if (tls_mask != 0
13697 	      && (tls_mask & TLS_TPREL) == 0)
13698 	    {
13699 	      rel->r_offset -= d_offset;
13700 	      bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13701 	      r_type = R_PPC64_NONE;
13702 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13703 	    }
13704 	  break;
13705 
13706 	case R_PPC64_GOT_TPREL16_DS:
13707 	case R_PPC64_GOT_TPREL16_LO_DS:
13708 	  if (tls_mask != 0
13709 	      && (tls_mask & TLS_TPREL) == 0)
13710 	    {
13711 	    toctprel:
13712 	      insn = bfd_get_32 (input_bfd,
13713 				 contents + rel->r_offset - d_offset);
13714 	      insn &= 31 << 21;
13715 	      insn |= 0x3c0d0000;	/* addis 0,13,0 */
13716 	      bfd_put_32 (input_bfd, insn,
13717 			  contents + rel->r_offset - d_offset);
13718 	      r_type = R_PPC64_TPREL16_HA;
13719 	      if (toc_symndx != 0)
13720 		{
13721 		  rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13722 		  rel->r_addend = toc_addend;
13723 		  /* We changed the symbol.  Start over in order to
13724 		     get h, sym, sec etc. right.  */
13725 		  goto again;
13726 		}
13727 	      else
13728 		rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13729 	    }
13730 	  break;
13731 
13732 	case R_PPC64_TLS:
13733 	  if (tls_mask != 0
13734 	      && (tls_mask & TLS_TPREL) == 0)
13735 	    {
13736 	      insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13737 	      insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13738 	      if (insn == 0)
13739 		abort ();
13740 	      bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13741 	      /* Was PPC64_TLS which sits on insn boundary, now
13742 		 PPC64_TPREL16_LO which is at low-order half-word.  */
13743 	      rel->r_offset += d_offset;
13744 	      r_type = R_PPC64_TPREL16_LO;
13745 	      if (toc_symndx != 0)
13746 		{
13747 		  rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13748 		  rel->r_addend = toc_addend;
13749 		  /* We changed the symbol.  Start over in order to
13750 		     get h, sym, sec etc. right.  */
13751 		  goto again;
13752 		}
13753 	      else
13754 		rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13755 	    }
13756 	  break;
13757 
13758 	case R_PPC64_GOT_TLSGD16_HI:
13759 	case R_PPC64_GOT_TLSGD16_HA:
13760 	  tls_gd = TLS_TPRELGD;
13761 	  if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13762 	    goto tls_gdld_hi;
13763 	  break;
13764 
13765 	case R_PPC64_GOT_TLSLD16_HI:
13766 	case R_PPC64_GOT_TLSLD16_HA:
13767 	  if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13768 	    {
13769 	    tls_gdld_hi:
13770 	      if ((tls_mask & tls_gd) != 0)
13771 		r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13772 			  + R_PPC64_GOT_TPREL16_DS);
13773 	      else
13774 		{
13775 		  rel->r_offset -= d_offset;
13776 		  bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13777 		  r_type = R_PPC64_NONE;
13778 		}
13779 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13780 	    }
13781 	  break;
13782 
13783 	case R_PPC64_GOT_TLSGD16:
13784 	case R_PPC64_GOT_TLSGD16_LO:
13785 	  tls_gd = TLS_TPRELGD;
13786 	  if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13787 	    goto tls_ldgd_opt;
13788 	  break;
13789 
13790 	case R_PPC64_GOT_TLSLD16:
13791 	case R_PPC64_GOT_TLSLD16_LO:
13792 	  if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13793 	    {
13794 	      unsigned int insn1, insn2, insn3;
13795 	      bfd_vma offset;
13796 
13797 	    tls_ldgd_opt:
13798 	      offset = (bfd_vma) -1;
13799 	      /* If not using the newer R_PPC64_TLSGD/LD to mark
13800 		 __tls_get_addr calls, we must trust that the call
13801 		 stays with its arg setup insns, ie. that the next
13802 		 reloc is the __tls_get_addr call associated with
13803 		 the current reloc.  Edit both insns.  */
13804 	      if (input_section->has_tls_get_addr_call
13805 		  && rel + 1 < relend
13806 		  && branch_reloc_hash_match (input_bfd, rel + 1,
13807 					      htab->tls_get_addr,
13808 					      htab->tls_get_addr_fd))
13809 		offset = rel[1].r_offset;
13810 	      /* We read the low GOT_TLS (or TOC16) insn because we
13811 		 need to keep the destination reg.  It may be
13812 		 something other than the usual r3, and moved to r3
13813 		 before the call by intervening code.  */
13814 	      insn1 = bfd_get_32 (input_bfd,
13815 				  contents + rel->r_offset - d_offset);
13816 	      if ((tls_mask & tls_gd) != 0)
13817 		{
13818 		  /* IE */
13819 		  insn1 &= (0x1f << 21) | (0x1f << 16);
13820 		  insn1 |= 58 << 26;	/* ld */
13821 		  insn2 = 0x7c636a14;	/* add 3,3,13 */
13822 		  if (offset != (bfd_vma) -1)
13823 		    rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13824 		  if ((tls_mask & TLS_EXPLICIT) == 0)
13825 		    r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13826 			      + R_PPC64_GOT_TPREL16_DS);
13827 		  else
13828 		    r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13829 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13830 		}
13831 	      else
13832 		{
13833 		  /* LE */
13834 		  insn1 &= 0x1f << 21;
13835 		  insn1 |= 0x3c0d0000;	/* addis r,13,0 */
13836 		  insn2 = 0x38630000;	/* addi 3,3,0 */
13837 		  if (tls_gd == 0)
13838 		    {
13839 		      /* Was an LD reloc.  */
13840 		      if (toc_symndx)
13841 			sec = local_sections[toc_symndx];
13842 		      for (r_symndx = 0;
13843 			   r_symndx < symtab_hdr->sh_info;
13844 			   r_symndx++)
13845 			if (local_sections[r_symndx] == sec)
13846 			  break;
13847 		      if (r_symndx >= symtab_hdr->sh_info)
13848 			r_symndx = STN_UNDEF;
13849 		      rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13850 		      if (r_symndx != STN_UNDEF)
13851 			rel->r_addend -= (local_syms[r_symndx].st_value
13852 					  + sec->output_offset
13853 					  + sec->output_section->vma);
13854 		    }
13855 		  else if (toc_symndx != 0)
13856 		    {
13857 		      r_symndx = toc_symndx;
13858 		      rel->r_addend = toc_addend;
13859 		    }
13860 		  r_type = R_PPC64_TPREL16_HA;
13861 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13862 		  if (offset != (bfd_vma) -1)
13863 		    {
13864 		      rel[1].r_info = ELF64_R_INFO (r_symndx,
13865 						    R_PPC64_TPREL16_LO);
13866 		      rel[1].r_offset = offset + d_offset;
13867 		      rel[1].r_addend = rel->r_addend;
13868 		    }
13869 		}
13870 	      bfd_put_32 (input_bfd, insn1,
13871 			  contents + rel->r_offset - d_offset);
13872 	      if (offset != (bfd_vma) -1)
13873 		{
13874 		  insn3 = bfd_get_32 (input_bfd,
13875 				      contents + offset + 4);
13876 		  if (insn3 == NOP
13877 		      || insn3 == CROR_151515 || insn3 == CROR_313131)
13878 		    {
13879 		      rel[1].r_offset += 4;
13880 		      bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13881 		      insn2 = NOP;
13882 		    }
13883 		  bfd_put_32 (input_bfd, insn2, contents + offset);
13884 		}
13885 	      if ((tls_mask & tls_gd) == 0
13886 		  && (tls_gd == 0 || toc_symndx != 0))
13887 		{
13888 		  /* We changed the symbol.  Start over in order
13889 		     to get h, sym, sec etc. right.  */
13890 		  goto again;
13891 		}
13892 	    }
13893 	  break;
13894 
13895 	case R_PPC64_TLSGD:
13896 	  if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13897 	    {
13898 	      unsigned int insn2, insn3;
13899 	      bfd_vma offset = rel->r_offset;
13900 
13901 	      if ((tls_mask & TLS_TPRELGD) != 0)
13902 		{
13903 		  /* IE */
13904 		  r_type = R_PPC64_NONE;
13905 		  insn2 = 0x7c636a14;	/* add 3,3,13 */
13906 		}
13907 	      else
13908 		{
13909 		  /* LE */
13910 		  if (toc_symndx != 0)
13911 		    {
13912 		      r_symndx = toc_symndx;
13913 		      rel->r_addend = toc_addend;
13914 		    }
13915 		  r_type = R_PPC64_TPREL16_LO;
13916 		  rel->r_offset = offset + d_offset;
13917 		  insn2 = 0x38630000;	/* addi 3,3,0 */
13918 		}
13919 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13920 	      /* Zap the reloc on the _tls_get_addr call too.  */
13921 	      BFD_ASSERT (offset == rel[1].r_offset);
13922 	      rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13923 	      insn3 = bfd_get_32 (input_bfd,
13924 				  contents + offset + 4);
13925 	      if (insn3 == NOP
13926 		  || insn3 == CROR_151515 || insn3 == CROR_313131)
13927 		{
13928 		  rel->r_offset += 4;
13929 		  bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13930 		  insn2 = NOP;
13931 		}
13932 	      bfd_put_32 (input_bfd, insn2, contents + offset);
13933 	      if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13934 		goto again;
13935 	    }
13936 	  break;
13937 
13938 	case R_PPC64_TLSLD:
13939 	  if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13940 	    {
13941 	      unsigned int insn2, insn3;
13942 	      bfd_vma offset = rel->r_offset;
13943 
13944 	      if (toc_symndx)
13945 		sec = local_sections[toc_symndx];
13946 	      for (r_symndx = 0;
13947 		   r_symndx < symtab_hdr->sh_info;
13948 		   r_symndx++)
13949 		if (local_sections[r_symndx] == sec)
13950 		  break;
13951 	      if (r_symndx >= symtab_hdr->sh_info)
13952 		r_symndx = STN_UNDEF;
13953 	      rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13954 	      if (r_symndx != STN_UNDEF)
13955 		rel->r_addend -= (local_syms[r_symndx].st_value
13956 				  + sec->output_offset
13957 				  + sec->output_section->vma);
13958 
13959 	      r_type = R_PPC64_TPREL16_LO;
13960 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13961 	      rel->r_offset = offset + d_offset;
13962 	      /* Zap the reloc on the _tls_get_addr call too.  */
13963 	      BFD_ASSERT (offset == rel[1].r_offset);
13964 	      rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13965 	      insn2 = 0x38630000;	/* addi 3,3,0 */
13966 	      insn3 = bfd_get_32 (input_bfd,
13967 				  contents + offset + 4);
13968 	      if (insn3 == NOP
13969 		  || insn3 == CROR_151515 || insn3 == CROR_313131)
13970 		{
13971 		  rel->r_offset += 4;
13972 		  bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13973 		  insn2 = NOP;
13974 		}
13975 	      bfd_put_32 (input_bfd, insn2, contents + offset);
13976 	      goto again;
13977 	    }
13978 	  break;
13979 
13980 	case R_PPC64_DTPMOD64:
13981 	  if (rel + 1 < relend
13982 	      && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13983 	      && rel[1].r_offset == rel->r_offset + 8)
13984 	    {
13985 	      if ((tls_mask & TLS_GD) == 0)
13986 		{
13987 		  rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13988 		  if ((tls_mask & TLS_TPRELGD) != 0)
13989 		    r_type = R_PPC64_TPREL64;
13990 		  else
13991 		    {
13992 		      bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13993 		      r_type = R_PPC64_NONE;
13994 		    }
13995 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13996 		}
13997 	    }
13998 	  else
13999 	    {
14000 	      if ((tls_mask & TLS_LD) == 0)
14001 		{
14002 		  bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14003 		  r_type = R_PPC64_NONE;
14004 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14005 		}
14006 	    }
14007 	  break;
14008 
14009 	case R_PPC64_TPREL64:
14010 	  if ((tls_mask & TLS_TPREL) == 0)
14011 	    {
14012 	      r_type = R_PPC64_NONE;
14013 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14014 	    }
14015 	  break;
14016 
14017 	case R_PPC64_ENTRY:
14018 	  relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14019 	  if (!bfd_link_pic (info)
14020 	      && !info->traditional_format
14021 	      && relocation + 0x80008000 <= 0xffffffff)
14022 	    {
14023 	      unsigned int insn1, insn2;
14024 
14025 	      insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14026 	      insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14027 	      if ((insn1 & ~0xfffc) == LD_R2_0R12
14028 		  && insn2 == ADD_R2_R2_R12)
14029 		{
14030 		  bfd_put_32 (input_bfd,
14031 			      LIS_R2 + PPC_HA (relocation),
14032 			      contents + rel->r_offset);
14033 		  bfd_put_32 (input_bfd,
14034 			      ADDI_R2_R2 + PPC_LO (relocation),
14035 			      contents + rel->r_offset + 4);
14036 		}
14037 	    }
14038 	  else
14039 	    {
14040 	      relocation -= (rel->r_offset
14041 			     + input_section->output_offset
14042 			     + input_section->output_section->vma);
14043 	      if (relocation + 0x80008000 <= 0xffffffff)
14044 		{
14045 		  unsigned int insn1, insn2;
14046 
14047 		  insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14048 		  insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14049 		  if ((insn1 & ~0xfffc) == LD_R2_0R12
14050 		      && insn2 == ADD_R2_R2_R12)
14051 		    {
14052 		      bfd_put_32 (input_bfd,
14053 				  ADDIS_R2_R12 + PPC_HA (relocation),
14054 				  contents + rel->r_offset);
14055 		      bfd_put_32 (input_bfd,
14056 				  ADDI_R2_R2 + PPC_LO (relocation),
14057 				  contents + rel->r_offset + 4);
14058 		    }
14059 		}
14060 	    }
14061 	  break;
14062 
14063 	case R_PPC64_REL16_HA:
14064 	  /* If we are generating a non-PIC executable, edit
14065 	     .	0:	addis 2,12,.TOC.-0b@ha
14066 	     .		addi 2,2,.TOC.-0b@l
14067 	     used by ELFv2 global entry points to set up r2, to
14068 	     .		lis 2,.TOC.@ha
14069 	     .		addi 2,2,.TOC.@l
14070 	     if .TOC. is in range.  */
14071 	  if (!bfd_link_pic (info)
14072 	      && !info->traditional_format
14073 	      && !htab->opd_abi
14074 	      && rel->r_addend == d_offset
14075 	      && h != NULL && &h->elf == htab->elf.hgot
14076 	      && rel + 1 < relend
14077 	      && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14078 	      && rel[1].r_offset == rel->r_offset + 4
14079 	      && rel[1].r_addend == rel->r_addend + 4
14080 	      && relocation + 0x80008000 <= 0xffffffff)
14081 	    {
14082 	      unsigned int insn1, insn2;
14083 	      bfd_vma offset = rel->r_offset - d_offset;
14084 	      insn1 = bfd_get_32 (input_bfd, contents + offset);
14085 	      insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14086 	      if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14087 		  && (insn2 & 0xffff0000) == ADDI_R2_R2)
14088 		{
14089 		  r_type = R_PPC64_ADDR16_HA;
14090 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14091 		  rel->r_addend -= d_offset;
14092 		  rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14093 		  rel[1].r_addend -= d_offset + 4;
14094 		  bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14095 		}
14096 	    }
14097 	  break;
14098 	}
14099 
14100       /* Handle other relocations that tweak non-addend part of insn.  */
14101       insn = 0;
14102       max_br_offset = 1 << 25;
14103       addend = rel->r_addend;
14104       reloc_dest = DEST_NORMAL;
14105       switch (r_type)
14106 	{
14107 	default:
14108 	  break;
14109 
14110 	case R_PPC64_TOCSAVE:
14111 	  if (relocation + addend == (rel->r_offset
14112 				      + input_section->output_offset
14113 				      + input_section->output_section->vma)
14114 	      && tocsave_find (htab, NO_INSERT,
14115 			       &local_syms, rel, input_bfd))
14116 	    {
14117 	      insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14118 	      if (insn == NOP
14119 		  || insn == CROR_151515 || insn == CROR_313131)
14120 		bfd_put_32 (input_bfd,
14121 			    STD_R2_0R1 + STK_TOC (htab),
14122 			    contents + rel->r_offset);
14123 	    }
14124 	  break;
14125 
14126 	  /* Branch taken prediction relocations.  */
14127 	case R_PPC64_ADDR14_BRTAKEN:
14128 	case R_PPC64_REL14_BRTAKEN:
14129 	  insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14130 	  /* Fall through.  */
14131 
14132 	  /* Branch not taken prediction relocations.  */
14133 	case R_PPC64_ADDR14_BRNTAKEN:
14134 	case R_PPC64_REL14_BRNTAKEN:
14135 	  insn |= bfd_get_32 (input_bfd,
14136 			      contents + rel->r_offset) & ~(0x01 << 21);
14137 	  /* Fall through.  */
14138 
14139 	case R_PPC64_REL14:
14140 	  max_br_offset = 1 << 15;
14141 	  /* Fall through.  */
14142 
14143 	case R_PPC64_REL24:
14144 	  /* Calls to functions with a different TOC, such as calls to
14145 	     shared objects, need to alter the TOC pointer.  This is
14146 	     done using a linkage stub.  A REL24 branching to these
14147 	     linkage stubs needs to be followed by a nop, as the nop
14148 	     will be replaced with an instruction to restore the TOC
14149 	     base pointer.  */
14150 	  fdh = h;
14151 	  if (h != NULL
14152 	      && h->oh != NULL
14153 	      && h->oh->is_func_descriptor)
14154 	    fdh = ppc_follow_link (h->oh);
14155 	  stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14156 					   htab);
14157 	  if (stub_entry != NULL
14158 	      && (stub_entry->stub_type == ppc_stub_plt_call
14159 		  || stub_entry->stub_type == ppc_stub_plt_call_r2save
14160 		  || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14161 		  || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14162 	    {
14163 	      bfd_boolean can_plt_call = FALSE;
14164 
14165 	      /* All of these stubs will modify r2, so there must be a
14166 		 branch and link followed by a nop.  The nop is
14167 		 replaced by an insn to restore r2.  */
14168 	      if (rel->r_offset + 8 <= input_section->size)
14169 		{
14170 		  unsigned long br;
14171 
14172 		  br = bfd_get_32 (input_bfd,
14173 				   contents + rel->r_offset);
14174 		  if ((br & 1) != 0)
14175 		    {
14176 		      unsigned long nop;
14177 
14178 		      nop = bfd_get_32 (input_bfd,
14179 					contents + rel->r_offset + 4);
14180 		      if (nop == NOP
14181 			  || nop == CROR_151515 || nop == CROR_313131)
14182 			{
14183 			  if (h != NULL
14184 			      && (h == htab->tls_get_addr_fd
14185 				  || h == htab->tls_get_addr)
14186 			      && htab->params->tls_get_addr_opt)
14187 			    {
14188 			      /* Special stub used, leave nop alone.  */
14189 			    }
14190 			  else
14191 			    bfd_put_32 (input_bfd,
14192 					LD_R2_0R1 + STK_TOC (htab),
14193 					contents + rel->r_offset + 4);
14194 			  can_plt_call = TRUE;
14195 			}
14196 		    }
14197 		}
14198 
14199 	      if (!can_plt_call && h != NULL)
14200 		{
14201 		  const char *name = h->elf.root.root.string;
14202 
14203 		  if (*name == '.')
14204 		    ++name;
14205 
14206 		  if (strncmp (name, "__libc_start_main", 17) == 0
14207 		      && (name[17] == 0 || name[17] == '@'))
14208 		    {
14209 		      /* Allow crt1 branch to go via a toc adjusting
14210 			 stub.  Other calls that never return could do
14211 			 the same, if we could detect such.  */
14212 		      can_plt_call = TRUE;
14213 		    }
14214 		}
14215 
14216 	      if (!can_plt_call)
14217 		{
14218 		  /* g++ as of 20130507 emits self-calls without a
14219 		     following nop.  This is arguably wrong since we
14220 		     have conflicting information.  On the one hand a
14221 		     global symbol and on the other a local call
14222 		     sequence, but don't error for this special case.
14223 		     It isn't possible to cheaply verify we have
14224 		     exactly such a call.  Allow all calls to the same
14225 		     section.  */
14226 		  asection *code_sec = sec;
14227 
14228 		  if (get_opd_info (sec) != NULL)
14229 		    {
14230 		      bfd_vma off = (relocation + addend
14231 				     - sec->output_section->vma
14232 				     - sec->output_offset);
14233 
14234 		      opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14235 		    }
14236 		  if (code_sec == input_section)
14237 		    can_plt_call = TRUE;
14238 		}
14239 
14240 	      if (!can_plt_call)
14241 		{
14242 		  if (stub_entry->stub_type == ppc_stub_plt_call
14243 		      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14244 		    info->callbacks->einfo
14245 		      /* xgettext:c-format */
14246 		      (_("%H: call to `%T' lacks nop, can't restore toc; "
14247 			 "recompile with -fPIC\n"),
14248 		       input_bfd, input_section, rel->r_offset, sym_name);
14249 		  else
14250 		    info->callbacks->einfo
14251 		      /* xgettext:c-format */
14252 		      (_("%H: call to `%T' lacks nop, can't restore toc; "
14253 			 "(-mcmodel=small toc adjust stub)\n"),
14254 		       input_bfd, input_section, rel->r_offset, sym_name);
14255 
14256 		  bfd_set_error (bfd_error_bad_value);
14257 		  ret = FALSE;
14258 		}
14259 
14260 	      if (can_plt_call
14261 		  && (stub_entry->stub_type == ppc_stub_plt_call
14262 		      || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14263 		unresolved_reloc = FALSE;
14264 	    }
14265 
14266 	  if ((stub_entry == NULL
14267 	       || stub_entry->stub_type == ppc_stub_long_branch
14268 	       || stub_entry->stub_type == ppc_stub_plt_branch)
14269 	      && get_opd_info (sec) != NULL)
14270 	    {
14271 	      /* The branch destination is the value of the opd entry. */
14272 	      bfd_vma off = (relocation + addend
14273 			     - sec->output_section->vma
14274 			     - sec->output_offset);
14275 	      bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14276 	      if (dest != (bfd_vma) -1)
14277 		{
14278 		  relocation = dest;
14279 		  addend = 0;
14280 		  reloc_dest = DEST_OPD;
14281 		}
14282 	    }
14283 
14284 	  /* If the branch is out of reach we ought to have a long
14285 	     branch stub.  */
14286 	  from = (rel->r_offset
14287 		  + input_section->output_offset
14288 		  + input_section->output_section->vma);
14289 
14290 	  relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14291 						  ? fdh->elf.other
14292 						  : sym->st_other);
14293 
14294 	  if (stub_entry != NULL
14295 	      && (stub_entry->stub_type == ppc_stub_long_branch
14296 		  || stub_entry->stub_type == ppc_stub_plt_branch)
14297 	      && (r_type == R_PPC64_ADDR14_BRTAKEN
14298 		  || r_type == R_PPC64_ADDR14_BRNTAKEN
14299 		  || (relocation + addend - from + max_br_offset
14300 		      < 2 * max_br_offset)))
14301 	    /* Don't use the stub if this branch is in range.  */
14302 	    stub_entry = NULL;
14303 
14304 	  if (stub_entry != NULL)
14305 	    {
14306 	      /* Munge up the value and addend so that we call the stub
14307 		 rather than the procedure directly.  */
14308 	      asection *stub_sec = stub_entry->group->stub_sec;
14309 
14310 	      if (stub_entry->stub_type == ppc_stub_save_res)
14311 		relocation += (stub_sec->output_offset
14312 			       + stub_sec->output_section->vma
14313 			       + stub_sec->size - htab->sfpr->size
14314 			       - htab->sfpr->output_offset
14315 			       - htab->sfpr->output_section->vma);
14316 	      else
14317 		relocation = (stub_entry->stub_offset
14318 			      + stub_sec->output_offset
14319 			      + stub_sec->output_section->vma);
14320 	      addend = 0;
14321 	      reloc_dest = DEST_STUB;
14322 
14323  	      if ((stub_entry->stub_type == ppc_stub_plt_call
14324 		   || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14325 		  && (ALWAYS_EMIT_R2SAVE
14326 		      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14327 		  && rel + 1 < relend
14328 		  && rel[1].r_offset == rel->r_offset + 4
14329 		  && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14330 		relocation += 4;
14331 	    }
14332 
14333 	  if (insn != 0)
14334 	    {
14335 	      if (is_isa_v2)
14336 		{
14337 		  /* Set 'a' bit.  This is 0b00010 in BO field for branch
14338 		     on CR(BI) insns (BO == 001at or 011at), and 0b01000
14339 		     for branch on CTR insns (BO == 1a00t or 1a01t).  */
14340 		  if ((insn & (0x14 << 21)) == (0x04 << 21))
14341 		    insn |= 0x02 << 21;
14342 		  else if ((insn & (0x14 << 21)) == (0x10 << 21))
14343 		    insn |= 0x08 << 21;
14344 		  else
14345 		    break;
14346 		}
14347 	      else
14348 		{
14349 		  /* Invert 'y' bit if not the default.  */
14350 		  if ((bfd_signed_vma) (relocation + addend - from) < 0)
14351 		    insn ^= 0x01 << 21;
14352 		}
14353 
14354 	      bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14355 	    }
14356 
14357 	  /* NOP out calls to undefined weak functions.
14358 	     We can thus call a weak function without first
14359 	     checking whether the function is defined.  */
14360 	  else if (h != NULL
14361 		   && h->elf.root.type == bfd_link_hash_undefweak
14362 		   && h->elf.dynindx == -1
14363 		   && r_type == R_PPC64_REL24
14364 		   && relocation == 0
14365 		   && addend == 0)
14366 	    {
14367 	      bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14368 	      goto copy_reloc;
14369 	    }
14370 	  break;
14371 	}
14372 
14373       /* Set `addend'.  */
14374       tls_type = 0;
14375       switch (r_type)
14376 	{
14377 	default:
14378 	  info->callbacks->einfo
14379 	    /* xgettext:c-format */
14380 	    (_("%P: %B: unknown relocation type %d for `%T'\n"),
14381 	     input_bfd, (int) r_type, sym_name);
14382 
14383 	  bfd_set_error (bfd_error_bad_value);
14384 	  ret = FALSE;
14385 	  goto copy_reloc;
14386 
14387 	case R_PPC64_NONE:
14388 	case R_PPC64_TLS:
14389 	case R_PPC64_TLSGD:
14390 	case R_PPC64_TLSLD:
14391 	case R_PPC64_TOCSAVE:
14392 	case R_PPC64_GNU_VTINHERIT:
14393 	case R_PPC64_GNU_VTENTRY:
14394 	case R_PPC64_ENTRY:
14395 	  goto copy_reloc;
14396 
14397 	  /* GOT16 relocations.  Like an ADDR16 using the symbol's
14398 	     address in the GOT as relocation value instead of the
14399 	     symbol's value itself.  Also, create a GOT entry for the
14400 	     symbol and put the symbol value there.  */
14401 	case R_PPC64_GOT_TLSGD16:
14402 	case R_PPC64_GOT_TLSGD16_LO:
14403 	case R_PPC64_GOT_TLSGD16_HI:
14404 	case R_PPC64_GOT_TLSGD16_HA:
14405 	  tls_type = TLS_TLS | TLS_GD;
14406 	  goto dogot;
14407 
14408 	case R_PPC64_GOT_TLSLD16:
14409 	case R_PPC64_GOT_TLSLD16_LO:
14410 	case R_PPC64_GOT_TLSLD16_HI:
14411 	case R_PPC64_GOT_TLSLD16_HA:
14412 	  tls_type = TLS_TLS | TLS_LD;
14413 	  goto dogot;
14414 
14415 	case R_PPC64_GOT_TPREL16_DS:
14416 	case R_PPC64_GOT_TPREL16_LO_DS:
14417 	case R_PPC64_GOT_TPREL16_HI:
14418 	case R_PPC64_GOT_TPREL16_HA:
14419 	  tls_type = TLS_TLS | TLS_TPREL;
14420 	  goto dogot;
14421 
14422 	case R_PPC64_GOT_DTPREL16_DS:
14423 	case R_PPC64_GOT_DTPREL16_LO_DS:
14424 	case R_PPC64_GOT_DTPREL16_HI:
14425 	case R_PPC64_GOT_DTPREL16_HA:
14426 	  tls_type = TLS_TLS | TLS_DTPREL;
14427 	  goto dogot;
14428 
14429 	case R_PPC64_GOT16:
14430 	case R_PPC64_GOT16_LO:
14431 	case R_PPC64_GOT16_HI:
14432 	case R_PPC64_GOT16_HA:
14433 	case R_PPC64_GOT16_DS:
14434 	case R_PPC64_GOT16_LO_DS:
14435 	dogot:
14436 	  {
14437 	    /* Relocation is to the entry for this symbol in the global
14438 	       offset table.  */
14439 	    asection *got;
14440 	    bfd_vma *offp;
14441 	    bfd_vma off;
14442 	    unsigned long indx = 0;
14443 	    struct got_entry *ent;
14444 
14445 	    if (tls_type == (TLS_TLS | TLS_LD)
14446 		&& (h == NULL
14447 		    || !h->elf.def_dynamic))
14448 	      ent = ppc64_tlsld_got (input_bfd);
14449 	    else
14450 	      {
14451 		if (h != NULL)
14452 		  {
14453 		    if (!htab->elf.dynamic_sections_created
14454 			|| h->elf.dynindx == -1
14455 			|| SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14456 			|| (ELF_ST_VISIBILITY (h->elf.other) != STV_DEFAULT
14457 			    && h->elf.root.type == bfd_link_hash_undefweak))
14458 		      /* This is actually a static link, or it is a
14459 			 -Bsymbolic link and the symbol is defined
14460 			 locally, or the symbol was forced to be local
14461 			 because of a version file.  */
14462 		      ;
14463 		    else
14464 		      {
14465 			indx = h->elf.dynindx;
14466 			unresolved_reloc = FALSE;
14467 		      }
14468 		    ent = h->elf.got.glist;
14469 		  }
14470 		else
14471 		  {
14472 		    if (local_got_ents == NULL)
14473 		      abort ();
14474 		    ent = local_got_ents[r_symndx];
14475 		  }
14476 
14477 		for (; ent != NULL; ent = ent->next)
14478 		  if (ent->addend == orig_rel.r_addend
14479 		      && ent->owner == input_bfd
14480 		      && ent->tls_type == tls_type)
14481 		    break;
14482 	      }
14483 
14484 	    if (ent == NULL)
14485 	      abort ();
14486 	    if (ent->is_indirect)
14487 	      ent = ent->got.ent;
14488 	    offp = &ent->got.offset;
14489 	    got = ppc64_elf_tdata (ent->owner)->got;
14490 	    if (got == NULL)
14491 	      abort ();
14492 
14493 	    /* The offset must always be a multiple of 8.  We use the
14494 	       least significant bit to record whether we have already
14495 	       processed this entry.  */
14496 	    off = *offp;
14497 	    if ((off & 1) != 0)
14498 	      off &= ~1;
14499 	    else
14500 	      {
14501 		/* Generate relocs for the dynamic linker, except in
14502 		   the case of TLSLD where we'll use one entry per
14503 		   module.  */
14504 		asection *relgot;
14505 		bfd_boolean ifunc;
14506 
14507 		*offp = off | 1;
14508 		relgot = NULL;
14509 		ifunc = (h != NULL
14510 			 ? h->elf.type == STT_GNU_IFUNC
14511 			 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14512 		if (ifunc)
14513 		  {
14514 		    relgot = htab->elf.irelplt;
14515 		    if (indx == 0)
14516 		      htab->local_ifunc_resolver = 1;
14517 		    else if (is_static_defined (&h->elf))
14518 		      htab->maybe_local_ifunc_resolver = 1;
14519 		  }
14520 		else if (indx != 0
14521 			 || (bfd_link_pic (info)
14522 			     && (h == NULL
14523 				 || (ELF_ST_VISIBILITY (h->elf.other)
14524 				     == STV_DEFAULT)
14525 				 || h->elf.root.type != bfd_link_hash_undefweak
14526 				 || (tls_type == (TLS_TLS | TLS_LD)
14527 				     && !h->elf.def_dynamic))))
14528 		  relgot = ppc64_elf_tdata (ent->owner)->relgot;
14529 		if (relgot != NULL)
14530 		  {
14531 		    outrel.r_offset = (got->output_section->vma
14532 				       + got->output_offset
14533 				       + off);
14534 		    outrel.r_addend = addend;
14535 		    if (tls_type & (TLS_LD | TLS_GD))
14536 		      {
14537 			outrel.r_addend = 0;
14538 			outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14539 			if (tls_type == (TLS_TLS | TLS_GD))
14540 			  {
14541 			    loc = relgot->contents;
14542 			    loc += (relgot->reloc_count++
14543 				    * sizeof (Elf64_External_Rela));
14544 			    bfd_elf64_swap_reloca_out (output_bfd,
14545 						       &outrel, loc);
14546 			    outrel.r_offset += 8;
14547 			    outrel.r_addend = addend;
14548 			    outrel.r_info
14549 			      = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14550 			  }
14551 		      }
14552 		    else if (tls_type == (TLS_TLS | TLS_DTPREL))
14553 		      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14554 		    else if (tls_type == (TLS_TLS | TLS_TPREL))
14555 		      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14556 		    else if (indx != 0)
14557 		      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14558 		    else
14559 		      {
14560 			if (ifunc)
14561 			  outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14562 			else
14563 			  outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14564 
14565 			/* Write the .got section contents for the sake
14566 			   of prelink.  */
14567 			loc = got->contents + off;
14568 			bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14569 				    loc);
14570 		      }
14571 
14572 		    if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14573 		      {
14574 			outrel.r_addend += relocation;
14575 			if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14576 			  {
14577 			    if (htab->elf.tls_sec == NULL)
14578 			      outrel.r_addend = 0;
14579 			    else
14580 			      outrel.r_addend -= htab->elf.tls_sec->vma;
14581 			  }
14582 		      }
14583 		    loc = relgot->contents;
14584 		    loc += (relgot->reloc_count++
14585 			    * sizeof (Elf64_External_Rela));
14586 		    bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14587 		  }
14588 
14589 		/* Init the .got section contents here if we're not
14590 		   emitting a reloc.  */
14591 		else
14592 		  {
14593 		    int tlsopt
14594 		      = (htab->params->tls_get_addr_opt
14595 			 && htab->tls_get_addr_fd != NULL
14596 			 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
14597 
14598 		    relocation += addend;
14599 		    if (tls_type != 0)
14600 		      {
14601 			if (htab->elf.tls_sec == NULL)
14602 			  relocation = 0;
14603 			else
14604 			  {
14605 			    if (tls_type & TLS_LD)
14606 			      relocation = 0;
14607 			    else
14608 			      relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14609 			    if ((tls_type & TLS_TPREL)
14610 				|| (tlsopt && !(tls_type & TLS_DTPREL)))
14611 			      relocation += DTP_OFFSET - TP_OFFSET;
14612 			  }
14613 
14614 			if (tls_type & (TLS_GD | TLS_LD))
14615 			  {
14616 			    bfd_put_64 (output_bfd, relocation,
14617 					got->contents + off + 8);
14618 			    relocation = !tlsopt;
14619 			  }
14620 		      }
14621 		    bfd_put_64 (output_bfd, relocation,
14622 				got->contents + off);
14623 		  }
14624 	      }
14625 
14626 	    if (off >= (bfd_vma) -2)
14627 	      abort ();
14628 
14629 	    relocation = got->output_section->vma + got->output_offset + off;
14630 	    addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14631 	  }
14632 	  break;
14633 
14634 	case R_PPC64_PLT16_HA:
14635 	case R_PPC64_PLT16_HI:
14636 	case R_PPC64_PLT16_LO:
14637 	case R_PPC64_PLT32:
14638 	case R_PPC64_PLT64:
14639 	  /* Relocation is to the entry for this symbol in the
14640 	     procedure linkage table.  */
14641 	  {
14642 	    struct plt_entry **plt_list = NULL;
14643 	    if (h != NULL)
14644 	      plt_list = &h->elf.plt.plist;
14645 	    else if (local_got_ents != NULL)
14646 	      {
14647 		struct plt_entry **local_plt = (struct plt_entry **)
14648 		  (local_got_ents + symtab_hdr->sh_info);
14649 		unsigned char *local_got_tls_masks = (unsigned char *)
14650 		  (local_plt + symtab_hdr->sh_info);
14651 		if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14652 		  plt_list = local_plt + r_symndx;
14653 	      }
14654 	    if (plt_list)
14655 	      {
14656 		struct plt_entry *ent;
14657 
14658 		for (ent = *plt_list; ent != NULL; ent = ent->next)
14659 		  if (ent->plt.offset != (bfd_vma) -1
14660 		      && ent->addend == orig_rel.r_addend)
14661 		    {
14662 		      asection *plt;
14663 
14664 		      plt = htab->elf.splt;
14665 		      if (!htab->elf.dynamic_sections_created
14666 			  || h == NULL
14667 			  || h->elf.dynindx == -1)
14668 			plt = htab->elf.iplt;
14669 		      relocation = (plt->output_section->vma
14670 				    + plt->output_offset
14671 				    + ent->plt.offset);
14672 		      addend = 0;
14673 		      unresolved_reloc = FALSE;
14674 		      break;
14675 		    }
14676 	      }
14677 	  }
14678 	  break;
14679 
14680 	case R_PPC64_TOC:
14681 	  /* Relocation value is TOC base.  */
14682 	  relocation = TOCstart;
14683 	  if (r_symndx == STN_UNDEF)
14684 	    relocation += htab->sec_info[input_section->id].toc_off;
14685 	  else if (unresolved_reloc)
14686 	    ;
14687 	  else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14688 	    relocation += htab->sec_info[sec->id].toc_off;
14689 	  else
14690 	    unresolved_reloc = TRUE;
14691 	  goto dodyn;
14692 
14693 	  /* TOC16 relocs.  We want the offset relative to the TOC base,
14694 	     which is the address of the start of the TOC plus 0x8000.
14695 	     The TOC consists of sections .got, .toc, .tocbss, and .plt,
14696 	     in this order.  */
14697 	case R_PPC64_TOC16:
14698 	case R_PPC64_TOC16_LO:
14699 	case R_PPC64_TOC16_HI:
14700 	case R_PPC64_TOC16_DS:
14701 	case R_PPC64_TOC16_LO_DS:
14702 	case R_PPC64_TOC16_HA:
14703 	  addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14704 	  break;
14705 
14706 	  /* Relocate against the beginning of the section.  */
14707 	case R_PPC64_SECTOFF:
14708 	case R_PPC64_SECTOFF_LO:
14709 	case R_PPC64_SECTOFF_HI:
14710 	case R_PPC64_SECTOFF_DS:
14711 	case R_PPC64_SECTOFF_LO_DS:
14712 	case R_PPC64_SECTOFF_HA:
14713 	  if (sec != NULL)
14714 	    addend -= sec->output_section->vma;
14715 	  break;
14716 
14717 	case R_PPC64_REL16:
14718 	case R_PPC64_REL16_LO:
14719 	case R_PPC64_REL16_HI:
14720 	case R_PPC64_REL16_HA:
14721 	case R_PPC64_REL16DX_HA:
14722 	  break;
14723 
14724 	case R_PPC64_REL14:
14725 	case R_PPC64_REL14_BRNTAKEN:
14726 	case R_PPC64_REL14_BRTAKEN:
14727 	case R_PPC64_REL24:
14728 	  break;
14729 
14730 	case R_PPC64_TPREL16:
14731 	case R_PPC64_TPREL16_LO:
14732 	case R_PPC64_TPREL16_HI:
14733 	case R_PPC64_TPREL16_HA:
14734 	case R_PPC64_TPREL16_DS:
14735 	case R_PPC64_TPREL16_LO_DS:
14736 	case R_PPC64_TPREL16_HIGH:
14737 	case R_PPC64_TPREL16_HIGHA:
14738 	case R_PPC64_TPREL16_HIGHER:
14739 	case R_PPC64_TPREL16_HIGHERA:
14740 	case R_PPC64_TPREL16_HIGHEST:
14741 	case R_PPC64_TPREL16_HIGHESTA:
14742 	  if (h != NULL
14743 	      && h->elf.root.type == bfd_link_hash_undefweak
14744 	      && h->elf.dynindx == -1)
14745 	    {
14746 	      /* Make this relocation against an undefined weak symbol
14747 		 resolve to zero.  This is really just a tweak, since
14748 		 code using weak externs ought to check that they are
14749 		 defined before using them.  */
14750 	      bfd_byte *p = contents + rel->r_offset - d_offset;
14751 
14752 	      insn = bfd_get_32 (input_bfd, p);
14753 	      insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14754 	      if (insn != 0)
14755 		bfd_put_32 (input_bfd, insn, p);
14756 	      break;
14757 	    }
14758 	  if (htab->elf.tls_sec != NULL)
14759 	    addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14760 	  if (bfd_link_pic (info))
14761 	    /* The TPREL16 relocs shouldn't really be used in shared
14762 	       libs as they will result in DT_TEXTREL being set, but
14763 	       support them anyway.  */
14764 	    goto dodyn;
14765 	  break;
14766 
14767 	case R_PPC64_DTPREL16:
14768 	case R_PPC64_DTPREL16_LO:
14769 	case R_PPC64_DTPREL16_HI:
14770 	case R_PPC64_DTPREL16_HA:
14771 	case R_PPC64_DTPREL16_DS:
14772 	case R_PPC64_DTPREL16_LO_DS:
14773 	case R_PPC64_DTPREL16_HIGH:
14774 	case R_PPC64_DTPREL16_HIGHA:
14775 	case R_PPC64_DTPREL16_HIGHER:
14776 	case R_PPC64_DTPREL16_HIGHERA:
14777 	case R_PPC64_DTPREL16_HIGHEST:
14778 	case R_PPC64_DTPREL16_HIGHESTA:
14779 	  if (htab->elf.tls_sec != NULL)
14780 	    addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14781 	  break;
14782 
14783 	case R_PPC64_ADDR64_LOCAL:
14784 	  addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14785 					      ? h->elf.other
14786 					      : sym->st_other);
14787 	  break;
14788 
14789 	case R_PPC64_DTPMOD64:
14790 	  relocation = 1;
14791 	  addend = 0;
14792 	  goto dodyn;
14793 
14794 	case R_PPC64_TPREL64:
14795 	  if (htab->elf.tls_sec != NULL)
14796 	    addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14797 	  goto dodyn;
14798 
14799 	case R_PPC64_DTPREL64:
14800 	  if (htab->elf.tls_sec != NULL)
14801 	    addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14802 	  /* Fall through.  */
14803 
14804 	  /* Relocations that may need to be propagated if this is a
14805 	     dynamic object.  */
14806 	case R_PPC64_REL30:
14807 	case R_PPC64_REL32:
14808 	case R_PPC64_REL64:
14809 	case R_PPC64_ADDR14:
14810 	case R_PPC64_ADDR14_BRNTAKEN:
14811 	case R_PPC64_ADDR14_BRTAKEN:
14812 	case R_PPC64_ADDR16:
14813 	case R_PPC64_ADDR16_DS:
14814 	case R_PPC64_ADDR16_HA:
14815 	case R_PPC64_ADDR16_HI:
14816 	case R_PPC64_ADDR16_HIGH:
14817 	case R_PPC64_ADDR16_HIGHA:
14818 	case R_PPC64_ADDR16_HIGHER:
14819 	case R_PPC64_ADDR16_HIGHERA:
14820 	case R_PPC64_ADDR16_HIGHEST:
14821 	case R_PPC64_ADDR16_HIGHESTA:
14822 	case R_PPC64_ADDR16_LO:
14823 	case R_PPC64_ADDR16_LO_DS:
14824 	case R_PPC64_ADDR24:
14825 	case R_PPC64_ADDR32:
14826 	case R_PPC64_ADDR64:
14827 	case R_PPC64_UADDR16:
14828 	case R_PPC64_UADDR32:
14829 	case R_PPC64_UADDR64:
14830 	dodyn:
14831 	  if ((input_section->flags & SEC_ALLOC) == 0)
14832 	    break;
14833 
14834 	  if (NO_OPD_RELOCS && is_opd)
14835 	    break;
14836 
14837 	  if (bfd_link_pic (info)
14838 	      ? ((h == NULL
14839 		  || h->dyn_relocs != NULL)
14840 		 && ((h != NULL && pc_dynrelocs (h))
14841 		     || must_be_dyn_reloc (info, r_type)))
14842 	      : (h != NULL
14843 		 ? h->dyn_relocs != NULL
14844 		 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14845 	    {
14846 	      bfd_boolean skip, relocate;
14847 	      asection *sreloc;
14848 	      bfd_vma out_off;
14849 	      long indx = 0;
14850 
14851 	      /* When generating a dynamic object, these relocations
14852 		 are copied into the output file to be resolved at run
14853 		 time.  */
14854 
14855 	      skip = FALSE;
14856 	      relocate = FALSE;
14857 
14858 	      out_off = _bfd_elf_section_offset (output_bfd, info,
14859 						 input_section, rel->r_offset);
14860 	      if (out_off == (bfd_vma) -1)
14861 		skip = TRUE;
14862 	      else if (out_off == (bfd_vma) -2)
14863 		skip = TRUE, relocate = TRUE;
14864 	      out_off += (input_section->output_section->vma
14865 			  + input_section->output_offset);
14866 	      outrel.r_offset = out_off;
14867 	      outrel.r_addend = rel->r_addend;
14868 
14869 	      /* Optimize unaligned reloc use.  */
14870 	      if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14871 		  || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14872 		r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14873 	      else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14874 		       || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14875 		r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14876 	      else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14877 		       || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14878 		r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14879 
14880 	      if (skip)
14881 		memset (&outrel, 0, sizeof outrel);
14882 	      else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14883 		       && !is_opd
14884 		       && r_type != R_PPC64_TOC)
14885 		{
14886 		  indx = h->elf.dynindx;
14887 		  BFD_ASSERT (indx != -1);
14888 		  outrel.r_info = ELF64_R_INFO (indx, r_type);
14889 		}
14890 	      else
14891 		{
14892 		  /* This symbol is local, or marked to become local,
14893 		     or this is an opd section reloc which must point
14894 		     at a local function.  */
14895 		  outrel.r_addend += relocation;
14896 		  if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14897 		    {
14898 		      if (is_opd && h != NULL)
14899 			{
14900 			  /* Lie about opd entries.  This case occurs
14901 			     when building shared libraries and we
14902 			     reference a function in another shared
14903 			     lib.  The same thing happens for a weak
14904 			     definition in an application that's
14905 			     overridden by a strong definition in a
14906 			     shared lib.  (I believe this is a generic
14907 			     bug in binutils handling of weak syms.)
14908 			     In these cases we won't use the opd
14909 			     entry in this lib.  */
14910 			  unresolved_reloc = FALSE;
14911 			}
14912 		      if (!is_opd
14913 			  && r_type == R_PPC64_ADDR64
14914 			  && (h != NULL
14915 			      ? h->elf.type == STT_GNU_IFUNC
14916 			      : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14917 			outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14918 		      else
14919 			{
14920 			  outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14921 
14922 			  /* We need to relocate .opd contents for ld.so.
14923 			     Prelink also wants simple and consistent rules
14924 			     for relocs.  This make all RELATIVE relocs have
14925 			     *r_offset equal to r_addend.  */
14926 			  relocate = TRUE;
14927 			}
14928 		    }
14929 		  else
14930 		    {
14931 		      if (h != NULL
14932 			  ? h->elf.type == STT_GNU_IFUNC
14933 			  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14934 			{
14935 			  info->callbacks->einfo
14936 			    /* xgettext:c-format */
14937 			    (_("%H: %s for indirect "
14938 			       "function `%T' unsupported\n"),
14939 			     input_bfd, input_section, rel->r_offset,
14940 			     ppc64_elf_howto_table[r_type]->name,
14941 			     sym_name);
14942 			  ret = FALSE;
14943 			}
14944 		      else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14945 			;
14946 		      else if (sec == NULL || sec->owner == NULL)
14947 			{
14948 			  bfd_set_error (bfd_error_bad_value);
14949 			  return FALSE;
14950 			}
14951 		      else
14952 			{
14953 			  asection *osec;
14954 
14955 			  osec = sec->output_section;
14956 			  indx = elf_section_data (osec)->dynindx;
14957 
14958 			  if (indx == 0)
14959 			    {
14960 			      if ((osec->flags & SEC_READONLY) == 0
14961 				  && htab->elf.data_index_section != NULL)
14962 				osec = htab->elf.data_index_section;
14963 			      else
14964 				osec = htab->elf.text_index_section;
14965 			      indx = elf_section_data (osec)->dynindx;
14966 			    }
14967 			  BFD_ASSERT (indx != 0);
14968 
14969 			  /* We are turning this relocation into one
14970 			     against a section symbol, so subtract out
14971 			     the output section's address but not the
14972 			     offset of the input section in the output
14973 			     section.  */
14974 			  outrel.r_addend -= osec->vma;
14975 			}
14976 
14977 		      outrel.r_info = ELF64_R_INFO (indx, r_type);
14978 		    }
14979 		}
14980 
14981 	      sreloc = elf_section_data (input_section)->sreloc;
14982 	      if (h != NULL
14983 		  ? h->elf.type == STT_GNU_IFUNC
14984 		  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14985 		{
14986 		  sreloc = htab->elf.irelplt;
14987 		  if (indx == 0)
14988 		    htab->local_ifunc_resolver = 1;
14989 		  else if (is_static_defined (&h->elf))
14990 		    htab->maybe_local_ifunc_resolver = 1;
14991 		}
14992 	      if (sreloc == NULL)
14993 		abort ();
14994 
14995 	      if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14996 		  >= sreloc->size)
14997 		abort ();
14998 	      loc = sreloc->contents;
14999 	      loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15000 	      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15001 
15002 	      /* If this reloc is against an external symbol, it will
15003 		 be computed at runtime, so there's no need to do
15004 		 anything now.  However, for the sake of prelink ensure
15005 		 that the section contents are a known value.  */
15006 	      if (! relocate)
15007 		{
15008 		  unresolved_reloc = FALSE;
15009 		  /* The value chosen here is quite arbitrary as ld.so
15010 		     ignores section contents except for the special
15011 		     case of .opd where the contents might be accessed
15012 		     before relocation.  Choose zero, as that won't
15013 		     cause reloc overflow.  */
15014 		  relocation = 0;
15015 		  addend = 0;
15016 		  /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15017 		     to improve backward compatibility with older
15018 		     versions of ld.  */
15019 		  if (r_type == R_PPC64_ADDR64)
15020 		    addend = outrel.r_addend;
15021 		  /* Adjust pc_relative relocs to have zero in *r_offset.  */
15022 		  else if (ppc64_elf_howto_table[r_type]->pc_relative)
15023 		    addend = outrel.r_offset;
15024 		}
15025 	    }
15026 	  else if (r_type == R_PPC64_DTPMOD64
15027 		   && htab->params->tls_get_addr_opt
15028 		   && htab->tls_get_addr_fd != NULL
15029 		   && htab->tls_get_addr_fd->elf.plt.plist != NULL)
15030 	    {
15031 	      /* Set up for __tls_get_addr_opt stub, when this entry
15032 		 does not have dynamic relocs.  */
15033 	      relocation = 0;
15034 	      /* Set up the next word for local dynamic.  If it turns
15035 		 out to be global dynamic, the reloc will overwrite
15036 		 this value.  */
15037 	      if (rel->r_offset + 16 <= input_section->size)
15038 		bfd_put_64 (input_bfd, DTP_OFFSET - TP_OFFSET,
15039 			    contents + rel->r_offset + 8);
15040 	    }
15041 	  else if (r_type == R_PPC64_DTPREL64
15042 		   && htab->params->tls_get_addr_opt
15043 		   && htab->tls_get_addr_fd != NULL
15044 		   && htab->tls_get_addr_fd->elf.plt.plist != NULL
15045 		   && rel > relocs
15046 		   && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
15047 		   && rel[-1].r_offset + 8 == rel->r_offset)
15048 	    {
15049 	      /* __tls_get_addr_opt stub value.  */
15050 	      addend += DTP_OFFSET - TP_OFFSET;
15051 	    }
15052 	  break;
15053 
15054 	case R_PPC64_COPY:
15055 	case R_PPC64_GLOB_DAT:
15056 	case R_PPC64_JMP_SLOT:
15057 	case R_PPC64_JMP_IREL:
15058 	case R_PPC64_RELATIVE:
15059 	  /* We shouldn't ever see these dynamic relocs in relocatable
15060 	     files.  */
15061 	  /* Fall through.  */
15062 
15063 	case R_PPC64_PLTGOT16:
15064 	case R_PPC64_PLTGOT16_DS:
15065 	case R_PPC64_PLTGOT16_HA:
15066 	case R_PPC64_PLTGOT16_HI:
15067 	case R_PPC64_PLTGOT16_LO:
15068 	case R_PPC64_PLTGOT16_LO_DS:
15069 	case R_PPC64_PLTREL32:
15070 	case R_PPC64_PLTREL64:
15071 	  /* These ones haven't been implemented yet.  */
15072 
15073 	  info->callbacks->einfo
15074 	    /* xgettext:c-format */
15075 	    (_("%P: %B: %s is not supported for `%T'\n"),
15076 	     input_bfd,
15077 	     ppc64_elf_howto_table[r_type]->name, sym_name);
15078 
15079 	  bfd_set_error (bfd_error_invalid_operation);
15080 	  ret = FALSE;
15081 	  goto copy_reloc;
15082 	}
15083 
15084       /* Multi-instruction sequences that access the TOC can be
15085 	 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15086 	 to             nop;           addi rb,r2,x;  */
15087       switch (r_type)
15088 	{
15089 	default:
15090 	  break;
15091 
15092 	case R_PPC64_GOT_TLSLD16_HI:
15093 	case R_PPC64_GOT_TLSGD16_HI:
15094 	case R_PPC64_GOT_TPREL16_HI:
15095 	case R_PPC64_GOT_DTPREL16_HI:
15096 	case R_PPC64_GOT16_HI:
15097 	case R_PPC64_TOC16_HI:
15098 	  /* These relocs would only be useful if building up an
15099 	     offset to later add to r2, perhaps in an indexed
15100 	     addressing mode instruction.  Don't try to optimize.
15101 	     Unfortunately, the possibility of someone building up an
15102 	     offset like this or even with the HA relocs, means that
15103 	     we need to check the high insn when optimizing the low
15104 	     insn.  */
15105 	  break;
15106 
15107 	case R_PPC64_GOT_TLSLD16_HA:
15108 	case R_PPC64_GOT_TLSGD16_HA:
15109 	case R_PPC64_GOT_TPREL16_HA:
15110 	case R_PPC64_GOT_DTPREL16_HA:
15111 	case R_PPC64_GOT16_HA:
15112 	case R_PPC64_TOC16_HA:
15113 	  if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15114 	      && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15115 	    {
15116 	      bfd_byte *p = contents + (rel->r_offset & ~3);
15117 	      bfd_put_32 (input_bfd, NOP, p);
15118 	    }
15119 	  break;
15120 
15121 	case R_PPC64_GOT_TLSLD16_LO:
15122 	case R_PPC64_GOT_TLSGD16_LO:
15123 	case R_PPC64_GOT_TPREL16_LO_DS:
15124 	case R_PPC64_GOT_DTPREL16_LO_DS:
15125 	case R_PPC64_GOT16_LO:
15126 	case R_PPC64_GOT16_LO_DS:
15127 	case R_PPC64_TOC16_LO:
15128 	case R_PPC64_TOC16_LO_DS:
15129 	  if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15130 	      && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15131 	    {
15132 	      bfd_byte *p = contents + (rel->r_offset & ~3);
15133 	      insn = bfd_get_32 (input_bfd, p);
15134 	      if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15135 		{
15136 		  /* Transform addic to addi when we change reg.  */
15137 		  insn &= ~((0x3f << 26) | (0x1f << 16));
15138 		  insn |= (14u << 26) | (2 << 16);
15139 		}
15140 	      else
15141 		{
15142 		  insn &= ~(0x1f << 16);
15143 		  insn |= 2 << 16;
15144 		}
15145 	      bfd_put_32 (input_bfd, insn, p);
15146 	    }
15147 	  break;
15148 	}
15149 
15150       /* Do any further special processing.  */
15151       howto = ppc64_elf_howto_table[(int) r_type];
15152       switch (r_type)
15153 	{
15154 	default:
15155 	  break;
15156 
15157 	case R_PPC64_REL16_HA:
15158 	case R_PPC64_REL16DX_HA:
15159 	case R_PPC64_ADDR16_HA:
15160 	case R_PPC64_ADDR16_HIGHA:
15161 	case R_PPC64_ADDR16_HIGHERA:
15162 	case R_PPC64_ADDR16_HIGHESTA:
15163 	case R_PPC64_TOC16_HA:
15164 	case R_PPC64_SECTOFF_HA:
15165 	case R_PPC64_TPREL16_HA:
15166 	case R_PPC64_TPREL16_HIGHA:
15167 	case R_PPC64_TPREL16_HIGHERA:
15168 	case R_PPC64_TPREL16_HIGHESTA:
15169 	case R_PPC64_DTPREL16_HA:
15170 	case R_PPC64_DTPREL16_HIGHA:
15171 	case R_PPC64_DTPREL16_HIGHERA:
15172 	case R_PPC64_DTPREL16_HIGHESTA:
15173 	  /* It's just possible that this symbol is a weak symbol
15174 	     that's not actually defined anywhere. In that case,
15175 	     'sec' would be NULL, and we should leave the symbol
15176 	     alone (it will be set to zero elsewhere in the link).  */
15177 	  if (sec == NULL)
15178 	    break;
15179 	  /* Fall through.  */
15180 
15181 	case R_PPC64_GOT16_HA:
15182 	case R_PPC64_PLTGOT16_HA:
15183 	case R_PPC64_PLT16_HA:
15184 	case R_PPC64_GOT_TLSGD16_HA:
15185 	case R_PPC64_GOT_TLSLD16_HA:
15186 	case R_PPC64_GOT_TPREL16_HA:
15187 	case R_PPC64_GOT_DTPREL16_HA:
15188 	  /* Add 0x10000 if sign bit in 0:15 is set.
15189 	     Bits 0:15 are not used.  */
15190 	  addend += 0x8000;
15191 	  break;
15192 
15193 	case R_PPC64_ADDR16_DS:
15194 	case R_PPC64_ADDR16_LO_DS:
15195 	case R_PPC64_GOT16_DS:
15196 	case R_PPC64_GOT16_LO_DS:
15197 	case R_PPC64_PLT16_LO_DS:
15198 	case R_PPC64_SECTOFF_DS:
15199 	case R_PPC64_SECTOFF_LO_DS:
15200 	case R_PPC64_TOC16_DS:
15201 	case R_PPC64_TOC16_LO_DS:
15202 	case R_PPC64_PLTGOT16_DS:
15203 	case R_PPC64_PLTGOT16_LO_DS:
15204 	case R_PPC64_GOT_TPREL16_DS:
15205 	case R_PPC64_GOT_TPREL16_LO_DS:
15206 	case R_PPC64_GOT_DTPREL16_DS:
15207 	case R_PPC64_GOT_DTPREL16_LO_DS:
15208 	case R_PPC64_TPREL16_DS:
15209 	case R_PPC64_TPREL16_LO_DS:
15210 	case R_PPC64_DTPREL16_DS:
15211 	case R_PPC64_DTPREL16_LO_DS:
15212 	  insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15213 	  mask = 3;
15214 	  /* If this reloc is against an lq, lxv, or stxv insn, then
15215 	     the value must be a multiple of 16.  This is somewhat of
15216 	     a hack, but the "correct" way to do this by defining _DQ
15217 	     forms of all the _DS relocs bloats all reloc switches in
15218 	     this file.  It doesn't make much sense to use these
15219 	     relocs in data, so testing the insn should be safe.  */
15220 	  if ((insn & (0x3f << 26)) == (56u << 26)
15221 	      || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15222 	    mask = 15;
15223 	  relocation += addend;
15224 	  addend = insn & (mask ^ 3);
15225 	  if ((relocation & mask) != 0)
15226 	    {
15227 	      relocation ^= relocation & mask;
15228 	      info->callbacks->einfo
15229 		/* xgettext:c-format */
15230 		(_("%H: error: %s not a multiple of %u\n"),
15231 		 input_bfd, input_section, rel->r_offset,
15232 		 howto->name,
15233 		 mask + 1);
15234 	      bfd_set_error (bfd_error_bad_value);
15235 	      ret = FALSE;
15236 	      goto copy_reloc;
15237 	    }
15238 	  break;
15239 	}
15240 
15241       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15242 	 because such sections are not SEC_ALLOC and thus ld.so will
15243 	 not process them.  */
15244       if (unresolved_reloc
15245 	  && !((input_section->flags & SEC_DEBUGGING) != 0
15246 	       && h->elf.def_dynamic)
15247 	  && _bfd_elf_section_offset (output_bfd, info, input_section,
15248 				      rel->r_offset) != (bfd_vma) -1)
15249 	{
15250 	  info->callbacks->einfo
15251 	    /* xgettext:c-format */
15252 	    (_("%H: unresolvable %s against `%T'\n"),
15253 	     input_bfd, input_section, rel->r_offset,
15254 	     howto->name,
15255 	     h->elf.root.root.string);
15256 	  ret = FALSE;
15257 	}
15258 
15259       /* 16-bit fields in insns mostly have signed values, but a
15260 	 few insns have 16-bit unsigned values.  Really, we should
15261 	 have different reloc types.  */
15262       if (howto->complain_on_overflow != complain_overflow_dont
15263 	  && howto->dst_mask == 0xffff
15264 	  && (input_section->flags & SEC_CODE) != 0)
15265 	{
15266 	  enum complain_overflow complain = complain_overflow_signed;
15267 
15268 	  insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15269 	  if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15270 	    complain = complain_overflow_bitfield;
15271 	  else if (howto->rightshift == 0
15272 		   ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15273 		      || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15274 		      || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15275 		   : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15276 		      || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15277 		      || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15278 	    complain = complain_overflow_unsigned;
15279 	  if (howto->complain_on_overflow != complain)
15280 	    {
15281 	      alt_howto = *howto;
15282 	      alt_howto.complain_on_overflow = complain;
15283 	      howto = &alt_howto;
15284 	    }
15285 	}
15286 
15287       if (r_type == R_PPC64_REL16DX_HA)
15288 	{
15289 	  /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15290 	  if (rel->r_offset + 4 > input_section->size)
15291 	    r = bfd_reloc_outofrange;
15292 	  else
15293 	    {
15294 	      relocation += addend;
15295 	      relocation -= (rel->r_offset
15296 			     + input_section->output_offset
15297 			     + input_section->output_section->vma);
15298 	      relocation = (bfd_signed_vma) relocation >> 16;
15299 	      insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15300 	      insn &= ~0x1fffc1;
15301 	      insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15302 	      bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15303 	      r = bfd_reloc_ok;
15304 	      if (relocation + 0x8000 > 0xffff)
15305 		r = bfd_reloc_overflow;
15306 	    }
15307 	}
15308       else
15309 	r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15310 				      rel->r_offset, relocation, addend);
15311 
15312       if (r != bfd_reloc_ok)
15313 	{
15314 	  char *more_info = NULL;
15315 	  const char *reloc_name = howto->name;
15316 
15317 	  if (reloc_dest != DEST_NORMAL)
15318 	    {
15319 	      more_info = bfd_malloc (strlen (reloc_name) + 8);
15320 	      if (more_info != NULL)
15321 		{
15322 		  strcpy (more_info, reloc_name);
15323 		  strcat (more_info, (reloc_dest == DEST_OPD
15324 				      ? " (OPD)" : " (stub)"));
15325 		  reloc_name = more_info;
15326 		}
15327 	    }
15328 
15329 	  if (r == bfd_reloc_overflow)
15330 	    {
15331 	      /* On code like "if (foo) foo();" don't report overflow
15332 		 on a branch to zero when foo is undefined.  */
15333 	      if (!warned
15334 		  && (reloc_dest == DEST_STUB
15335 		      || !(h != NULL
15336 			   && (h->elf.root.type == bfd_link_hash_undefweak
15337 			       || h->elf.root.type == bfd_link_hash_undefined)
15338 			   && is_branch_reloc (r_type))))
15339 		info->callbacks->reloc_overflow (info, &h->elf.root,
15340 						 sym_name, reloc_name,
15341 						 orig_rel.r_addend,
15342 						 input_bfd, input_section,
15343 						 rel->r_offset);
15344 	    }
15345 	  else
15346 	    {
15347 	      info->callbacks->einfo
15348 		/* xgettext:c-format */
15349 		(_("%H: %s against `%T': error %d\n"),
15350 		 input_bfd, input_section, rel->r_offset,
15351 		 reloc_name, sym_name, (int) r);
15352 	      ret = FALSE;
15353 	    }
15354 	  if (more_info != NULL)
15355 	    free (more_info);
15356 	}
15357     copy_reloc:
15358       if (wrel != rel)
15359 	*wrel = *rel;
15360     }
15361 
15362   if (wrel != rel)
15363     {
15364       Elf_Internal_Shdr *rel_hdr;
15365       size_t deleted = rel - wrel;
15366 
15367       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15368       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15369       if (rel_hdr->sh_size == 0)
15370 	{
15371 	  /* It is too late to remove an empty reloc section.  Leave
15372 	     one NONE reloc.
15373 	     ??? What is wrong with an empty section???  */
15374 	  rel_hdr->sh_size = rel_hdr->sh_entsize;
15375 	  deleted -= 1;
15376 	}
15377       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15378       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15379       input_section->reloc_count -= deleted;
15380     }
15381 
15382   /* If we're emitting relocations, then shortly after this function
15383      returns, reloc offsets and addends for this section will be
15384      adjusted.  Worse, reloc symbol indices will be for the output
15385      file rather than the input.  Save a copy of the relocs for
15386      opd_entry_value.  */
15387   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15388     {
15389       bfd_size_type amt;
15390       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15391       rel = bfd_alloc (input_bfd, amt);
15392       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15393       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15394       if (rel == NULL)
15395 	return FALSE;
15396       memcpy (rel, relocs, amt);
15397     }
15398   return ret;
15399 }
15400 
15401 /* Adjust the value of any local symbols in opd sections.  */
15402 
15403 static int
15404 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15405 			      const char *name ATTRIBUTE_UNUSED,
15406 			      Elf_Internal_Sym *elfsym,
15407 			      asection *input_sec,
15408 			      struct elf_link_hash_entry *h)
15409 {
15410   struct _opd_sec_data *opd;
15411   long adjust;
15412   bfd_vma value;
15413 
15414   if (h != NULL)
15415     return 1;
15416 
15417   opd = get_opd_info (input_sec);
15418   if (opd == NULL || opd->adjust == NULL)
15419     return 1;
15420 
15421   value = elfsym->st_value - input_sec->output_offset;
15422   if (!bfd_link_relocatable (info))
15423     value -= input_sec->output_section->vma;
15424 
15425   adjust = opd->adjust[OPD_NDX (value)];
15426   if (adjust == -1)
15427     return 2;
15428 
15429   elfsym->st_value += adjust;
15430   return 1;
15431 }
15432 
15433 /* Finish up dynamic symbol handling.  We set the contents of various
15434    dynamic sections here.  */
15435 
15436 static bfd_boolean
15437 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15438 				 struct bfd_link_info *info,
15439 				 struct elf_link_hash_entry *h,
15440 				 Elf_Internal_Sym *sym)
15441 {
15442   struct ppc_link_hash_table *htab;
15443   struct plt_entry *ent;
15444   Elf_Internal_Rela rela;
15445   bfd_byte *loc;
15446 
15447   htab = ppc_hash_table (info);
15448   if (htab == NULL)
15449     return FALSE;
15450 
15451   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15452     if (ent->plt.offset != (bfd_vma) -1)
15453       {
15454 	/* This symbol has an entry in the procedure linkage
15455 	   table.  Set it up.  */
15456 	if (!htab->elf.dynamic_sections_created
15457 	    || h->dynindx == -1)
15458 	  {
15459 	    BFD_ASSERT (h->type == STT_GNU_IFUNC
15460 			&& h->def_regular
15461 			&& (h->root.type == bfd_link_hash_defined
15462 			    || h->root.type == bfd_link_hash_defweak));
15463 	    rela.r_offset = (htab->elf.iplt->output_section->vma
15464 			     + htab->elf.iplt->output_offset
15465 			     + ent->plt.offset);
15466 	    if (htab->opd_abi)
15467 	      rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15468 	    else
15469 	      rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15470 	    rela.r_addend = (h->root.u.def.value
15471 			     + h->root.u.def.section->output_offset
15472 			     + h->root.u.def.section->output_section->vma
15473 			     + ent->addend);
15474 	    loc = (htab->elf.irelplt->contents
15475 		   + (htab->elf.irelplt->reloc_count++
15476 		      * sizeof (Elf64_External_Rela)));
15477 	    htab->local_ifunc_resolver = 1;
15478 	  }
15479 	else
15480 	  {
15481 	    rela.r_offset = (htab->elf.splt->output_section->vma
15482 			     + htab->elf.splt->output_offset
15483 			     + ent->plt.offset);
15484 	    rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15485 	    rela.r_addend = ent->addend;
15486 	    loc = (htab->elf.srelplt->contents
15487 		   + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15488 		      / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15489 	    if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15490 	      htab->maybe_local_ifunc_resolver = 1;
15491 	  }
15492 	bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15493 
15494 	if (!htab->opd_abi)
15495 	  {
15496 	    if (!h->def_regular)
15497 	      {
15498 		/* Mark the symbol as undefined, rather than as
15499 		   defined in glink.  Leave the value if there were
15500 		   any relocations where pointer equality matters
15501 		   (this is a clue for the dynamic linker, to make
15502 		   function pointer comparisons work between an
15503 		   application and shared library), otherwise set it
15504 		   to zero.  */
15505 		sym->st_shndx = SHN_UNDEF;
15506 		if (!h->pointer_equality_needed)
15507 		  sym->st_value = 0;
15508 		else if (!h->ref_regular_nonweak)
15509 		  {
15510 		    /* This breaks function pointer comparisons, but
15511 		       that is better than breaking tests for a NULL
15512 		       function pointer.  */
15513 		    sym->st_value = 0;
15514 		  }
15515 	      }
15516 	  }
15517       }
15518 
15519   if (h->needs_copy)
15520     {
15521       /* This symbol needs a copy reloc.  Set it up.  */
15522       asection *srel;
15523 
15524       if (h->dynindx == -1
15525 	  || (h->root.type != bfd_link_hash_defined
15526 	      && h->root.type != bfd_link_hash_defweak)
15527 	  || htab->elf.srelbss == NULL
15528 	  || htab->elf.sreldynrelro == NULL)
15529 	abort ();
15530 
15531       rela.r_offset = (h->root.u.def.value
15532 		       + h->root.u.def.section->output_section->vma
15533 		       + h->root.u.def.section->output_offset);
15534       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15535       rela.r_addend = 0;
15536       if (h->root.u.def.section == htab->elf.sdynrelro)
15537 	srel = htab->elf.sreldynrelro;
15538       else
15539 	srel = htab->elf.srelbss;
15540       loc = srel->contents;
15541       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15542       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15543     }
15544 
15545   return TRUE;
15546 }
15547 
15548 /* Used to decide how to sort relocs in an optimal manner for the
15549    dynamic linker, before writing them out.  */
15550 
15551 static enum elf_reloc_type_class
15552 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15553 			    const asection *rel_sec,
15554 			    const Elf_Internal_Rela *rela)
15555 {
15556   enum elf_ppc64_reloc_type r_type;
15557   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15558 
15559   if (rel_sec == htab->elf.irelplt)
15560     return reloc_class_ifunc;
15561 
15562   r_type = ELF64_R_TYPE (rela->r_info);
15563   switch (r_type)
15564     {
15565     case R_PPC64_RELATIVE:
15566       return reloc_class_relative;
15567     case R_PPC64_JMP_SLOT:
15568       return reloc_class_plt;
15569     case R_PPC64_COPY:
15570       return reloc_class_copy;
15571     default:
15572       return reloc_class_normal;
15573     }
15574 }
15575 
15576 /* Finish up the dynamic sections.  */
15577 
15578 static bfd_boolean
15579 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15580 				   struct bfd_link_info *info)
15581 {
15582   struct ppc_link_hash_table *htab;
15583   bfd *dynobj;
15584   asection *sdyn;
15585 
15586   htab = ppc_hash_table (info);
15587   if (htab == NULL)
15588     return FALSE;
15589 
15590   dynobj = htab->elf.dynobj;
15591   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15592 
15593   if (htab->elf.dynamic_sections_created)
15594     {
15595       Elf64_External_Dyn *dyncon, *dynconend;
15596 
15597       if (sdyn == NULL || htab->elf.sgot == NULL)
15598 	abort ();
15599 
15600       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15601       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15602       for (; dyncon < dynconend; dyncon++)
15603 	{
15604 	  Elf_Internal_Dyn dyn;
15605 	  asection *s;
15606 
15607 	  bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15608 
15609 	  switch (dyn.d_tag)
15610 	    {
15611 	    default:
15612 	      continue;
15613 
15614 	    case DT_PPC64_GLINK:
15615 	      s = htab->glink;
15616 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15617 	      /* We stupidly defined DT_PPC64_GLINK to be the start
15618 		 of glink rather than the first entry point, which is
15619 		 what ld.so needs, and now have a bigger stub to
15620 		 support automatic multiple TOCs.  */
15621 	      dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15622 	      break;
15623 
15624 	    case DT_PPC64_OPD:
15625 	      s = bfd_get_section_by_name (output_bfd, ".opd");
15626 	      if (s == NULL)
15627 		continue;
15628 	      dyn.d_un.d_ptr = s->vma;
15629 	      break;
15630 
15631 	    case DT_PPC64_OPT:
15632 	      if (htab->do_multi_toc && htab->multi_toc_needed)
15633 		dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15634 	      break;
15635 
15636 	    case DT_PPC64_OPDSZ:
15637 	      s = bfd_get_section_by_name (output_bfd, ".opd");
15638 	      if (s == NULL)
15639 		continue;
15640 	      dyn.d_un.d_val = s->size;
15641 	      break;
15642 
15643 	    case DT_PLTGOT:
15644 	      s = htab->elf.splt;
15645 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15646 	      break;
15647 
15648 	    case DT_JMPREL:
15649 	      s = htab->elf.srelplt;
15650 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15651 	      break;
15652 
15653 	    case DT_PLTRELSZ:
15654 	      dyn.d_un.d_val = htab->elf.srelplt->size;
15655 	      break;
15656 
15657 	    case DT_TEXTREL:
15658 	      if (htab->local_ifunc_resolver)
15659 		info->callbacks->einfo
15660 		  (_("%X%P: text relocations and GNU indirect "
15661 		     "functions will result in a segfault at runtime\n"));
15662 	      else if (htab->maybe_local_ifunc_resolver)
15663 		info->callbacks->einfo
15664 		  (_("%P: warning: text relocations and GNU indirect "
15665 		     "functions may result in a segfault at runtime\n"));
15666 	      continue;
15667 	    }
15668 
15669 	  bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15670 	}
15671     }
15672 
15673   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15674       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15675     {
15676       /* Fill in the first entry in the global offset table.
15677 	 We use it to hold the link-time TOCbase.  */
15678       bfd_put_64 (output_bfd,
15679 		  elf_gp (output_bfd) + TOC_BASE_OFF,
15680 		  htab->elf.sgot->contents);
15681 
15682       /* Set .got entry size.  */
15683       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15684     }
15685 
15686   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15687       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15688     {
15689       /* Set .plt entry size.  */
15690       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15691 	= PLT_ENTRY_SIZE (htab);
15692     }
15693 
15694   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15695      brlt ourselves if emitrelocations.  */
15696   if (htab->brlt != NULL
15697       && htab->brlt->reloc_count != 0
15698       && !_bfd_elf_link_output_relocs (output_bfd,
15699 				       htab->brlt,
15700 				       elf_section_data (htab->brlt)->rela.hdr,
15701 				       elf_section_data (htab->brlt)->relocs,
15702 				       NULL))
15703     return FALSE;
15704 
15705   if (htab->glink != NULL
15706       && htab->glink->reloc_count != 0
15707       && !_bfd_elf_link_output_relocs (output_bfd,
15708 				       htab->glink,
15709 				       elf_section_data (htab->glink)->rela.hdr,
15710 				       elf_section_data (htab->glink)->relocs,
15711 				       NULL))
15712     return FALSE;
15713 
15714   if (htab->glink_eh_frame != NULL
15715       && htab->glink_eh_frame->size != 0)
15716     {
15717       bfd_vma val;
15718       bfd_byte *p;
15719       asection *stub_sec;
15720       size_t align = 4;
15721 
15722       p = htab->glink_eh_frame->contents;
15723       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15724       for (stub_sec = htab->params->stub_bfd->sections;
15725 	   stub_sec != NULL;
15726 	   stub_sec = stub_sec->next)
15727 	if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15728 	  {
15729 	    /* FDE length.  */
15730 	    p += 4;
15731 	    /* CIE pointer.  */
15732 	    p += 4;
15733 	    /* Offset to stub section.  */
15734 	    val = (stub_sec->output_section->vma
15735 		   + stub_sec->output_offset);
15736 	    val -= (htab->glink_eh_frame->output_section->vma
15737 		    + htab->glink_eh_frame->output_offset
15738 		    + (p - htab->glink_eh_frame->contents));
15739 	    if (val + 0x80000000 > 0xffffffff)
15740 	      {
15741 		info->callbacks->einfo
15742 		  (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15743 		   stub_sec->name);
15744 		return FALSE;
15745 	      }
15746 	    bfd_put_32 (dynobj, val, p);
15747 	    p += 4;
15748 	    /* stub section size.  */
15749 	    p += 4;
15750 	    /* Augmentation.  */
15751 	    p += 1;
15752 	    /* Pad.  */
15753 	    p += ((17 + align - 1) & -align) - 17;
15754 	  }
15755       if (htab->glink != NULL && htab->glink->size != 0)
15756 	{
15757 	  /* FDE length.  */
15758 	  p += 4;
15759 	  /* CIE pointer.  */
15760 	  p += 4;
15761 	  /* Offset to .glink.  */
15762 	  val = (htab->glink->output_section->vma
15763 		 + htab->glink->output_offset
15764 		 + 8);
15765 	  val -= (htab->glink_eh_frame->output_section->vma
15766 		  + htab->glink_eh_frame->output_offset
15767 		  + (p - htab->glink_eh_frame->contents));
15768 	  if (val + 0x80000000 > 0xffffffff)
15769 	    {
15770 	      info->callbacks->einfo
15771 		(_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15772 		 htab->glink->name);
15773 	      return FALSE;
15774 	    }
15775 	  bfd_put_32 (dynobj, val, p);
15776 	  p += 4;
15777 	  /* .glink size.  */
15778 	  p += 4;
15779 	  /* Augmentation.  */
15780 	  p += 1;
15781 	  /* Ops.  */
15782 	  p += 7;
15783 	  p += ((24 + align - 1) & -align) - 24;
15784 	}
15785 
15786       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15787 	  && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15788 					       htab->glink_eh_frame,
15789 					       htab->glink_eh_frame->contents))
15790 	return FALSE;
15791     }
15792 
15793   /* We need to handle writing out multiple GOT sections ourselves,
15794      since we didn't add them to DYNOBJ.  We know dynobj is the first
15795      bfd.  */
15796   while ((dynobj = dynobj->link.next) != NULL)
15797     {
15798       asection *s;
15799 
15800       if (!is_ppc64_elf (dynobj))
15801 	continue;
15802 
15803       s = ppc64_elf_tdata (dynobj)->got;
15804       if (s != NULL
15805 	  && s->size != 0
15806 	  && s->output_section != bfd_abs_section_ptr
15807 	  && !bfd_set_section_contents (output_bfd, s->output_section,
15808 					s->contents, s->output_offset,
15809 					s->size))
15810 	return FALSE;
15811       s = ppc64_elf_tdata (dynobj)->relgot;
15812       if (s != NULL
15813 	  && s->size != 0
15814 	  && s->output_section != bfd_abs_section_ptr
15815 	  && !bfd_set_section_contents (output_bfd, s->output_section,
15816 					s->contents, s->output_offset,
15817 					s->size))
15818 	return FALSE;
15819     }
15820 
15821   return TRUE;
15822 }
15823 
15824 #include "elf64-target.h"
15825 
15826 /* FreeBSD support */
15827 
15828 #undef  TARGET_LITTLE_SYM
15829 #undef  TARGET_LITTLE_NAME
15830 
15831 #undef  TARGET_BIG_SYM
15832 #define TARGET_BIG_SYM	powerpc_elf64_fbsd_vec
15833 #undef  TARGET_BIG_NAME
15834 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15835 
15836 #undef  ELF_OSABI
15837 #define	ELF_OSABI       ELFOSABI_FREEBSD
15838 
15839 #undef  elf64_bed
15840 #define elf64_bed	elf64_powerpc_fbsd_bed
15841 
15842 #include "elf64-target.h"
15843 
15844