xref: /netbsd-src/external/gpl3/gdb/dist/bfd/elf64-ppc.c (revision b7b7574d3bf8eeb51a1fa3977b59142ec6434a55) 
1 /* PowerPC64-specific support for 64-bit ELF.
2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3    2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4    Written by Linus Nordberg, Swox AB <info@swox.com>,
5    based on elf32-ppc.c by Ian Lance Taylor.
6    Largely rewritten by Alan Modra.
7 
8    This file is part of BFD, the Binary File Descriptor library.
9 
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14 
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19 
20    You should have received a copy of the GNU General Public License along
21    with this program; if not, write to the Free Software Foundation, Inc.,
22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
23 
24 
25 /* The 64-bit PowerPC ELF ABI may be found at
26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
28 
29 #include "sysdep.h"
30 #include <stdarg.h>
31 #include "bfd.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
37 #include "dwarf2.h"
38 
39 static bfd_reloc_status_type ppc64_elf_ha_reloc
40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
41 static bfd_reloc_status_type ppc64_elf_branch_reloc
42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
46   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
48   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49 static bfd_reloc_status_type ppc64_elf_toc_reloc
50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
52   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
56   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
57 static bfd_vma opd_entry_value
58   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
59 
60 #define TARGET_LITTLE_SYM	bfd_elf64_powerpcle_vec
61 #define TARGET_LITTLE_NAME	"elf64-powerpcle"
62 #define TARGET_BIG_SYM		bfd_elf64_powerpc_vec
63 #define TARGET_BIG_NAME		"elf64-powerpc"
64 #define ELF_ARCH		bfd_arch_powerpc
65 #define ELF_TARGET_ID		PPC64_ELF_DATA
66 #define ELF_MACHINE_CODE	EM_PPC64
67 #define ELF_MAXPAGESIZE		0x10000
68 #define ELF_COMMONPAGESIZE	0x1000
69 #define elf_info_to_howto	ppc64_elf_info_to_howto
70 
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
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_default_execstack 0
80 
81 #define bfd_elf64_mkobject		      ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup	      ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup	      ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook	      ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
88 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
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 
92 #define elf_backend_object_p		      ppc64_elf_object_p
93 #define elf_backend_grok_prstatus	      ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo		      ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note	      ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook	      ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives	      ppc64_elf_process_dot_syms
100 #define elf_backend_notice_as_needed	      ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs	      ppc64_elf_check_relocs
103 #define elf_backend_gc_keep		      ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook	      ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook	      ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol		      ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym	      ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
112 #define elf_backend_hash_symbol		      ppc64_elf_hash_symbol
113 #define elf_backend_init_index_section	      _bfd_elf_init_2_index_sections
114 #define elf_backend_action_discarded	      ppc64_elf_action_discarded
115 #define elf_backend_relocate_section	      ppc64_elf_relocate_section
116 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
117 #define elf_backend_reloc_type_class	      ppc64_elf_reloc_type_class
118 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
119 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
120 #define elf_backend_special_sections	      ppc64_elf_special_sections
121 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
122 
123 /* The name of the dynamic interpreter.  This is put in the .interp
124    section.  */
125 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
126 
127 /* The size in bytes of an entry in the procedure linkage table.  */
128 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
129 
130 /* The initial size of the plt reserved for the dynamic linker.  */
131 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
132 
133 /* Offsets to some stack save slots.  */
134 #define STK_LR 16
135 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
136 /* This one is dodgy.  ABIv2 does not have a linker word, so use the
137    CR save slot.  Used only by optimised __tls_get_addr call stub,
138    relying on __tls_get_addr_opt not saving CR..  */
139 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
140 
141 /* TOC base pointers offset from start of TOC.  */
142 #define TOC_BASE_OFF	0x8000
143 
144 /* Offset of tp and dtp pointers from start of TLS block.  */
145 #define TP_OFFSET	0x7000
146 #define DTP_OFFSET	0x8000
147 
148 /* .plt call stub instructions.  The normal stub is like this, but
149    sometimes the .plt entry crosses a 64k boundary and we need to
150    insert an addi to adjust r11.  */
151 #define STD_R2_0R1	0xf8410000	/* std	 %r2,0+40(%r1)	     */
152 #define ADDIS_R11_R2	0x3d620000	/* addis %r11,%r2,xxx@ha     */
153 #define LD_R12_0R11	0xe98b0000	/* ld	 %r12,xxx+0@l(%r11)  */
154 #define MTCTR_R12	0x7d8903a6	/* mtctr %r12		     */
155 #define LD_R2_0R11	0xe84b0000	/* ld	 %r2,xxx+8@l(%r11)   */
156 #define LD_R11_0R11	0xe96b0000	/* ld	 %r11,xxx+16@l(%r11) */
157 #define BCTR		0x4e800420	/* bctr			     */
158 
159 #define ADDI_R11_R11	0x396b0000	/* addi %r11,%r11,off@l  */
160 #define ADDIS_R2_R2	0x3c420000	/* addis %r2,%r2,off@ha  */
161 #define ADDI_R2_R2	0x38420000	/* addi  %r2,%r2,off@l   */
162 
163 #define XOR_R2_R12_R12	0x7d826278	/* xor   %r2,%r12,%r12   */
164 #define ADD_R11_R11_R2	0x7d6b1214	/* add   %r11,%r11,%r2   */
165 #define XOR_R11_R12_R12	0x7d8b6278	/* xor   %r11,%r12,%r12  */
166 #define ADD_R2_R2_R11	0x7c425a14	/* add   %r2,%r2,%r11    */
167 #define CMPLDI_R2_0	0x28220000	/* cmpldi %r2,0          */
168 #define BNECTR		0x4ca20420	/* bnectr+               */
169 #define BNECTR_P4	0x4ce20420	/* bnectr+               */
170 
171 #define LD_R12_0R2	0xe9820000	/* ld	 %r12,xxx+0(%r2) */
172 #define LD_R11_0R2	0xe9620000	/* ld	 %r11,xxx+0(%r2) */
173 #define LD_R2_0R2	0xe8420000	/* ld	 %r2,xxx+0(%r2)  */
174 
175 #define LD_R2_0R1	0xe8410000	/* ld    %r2,0(%r1)      */
176 
177 #define ADDIS_R12_R12	0x3d8c0000	/* addis %r12,%r12,xxx@ha */
178 #define LD_R12_0R12	0xe98c0000	/* ld    %r12,xxx@l(%r12) */
179 
180 /* glink call stub instructions.  We enter with the index in R0.  */
181 #define GLINK_CALL_STUB_SIZE (16*4)
182 					/* 0:				*/
183 					/*  .quad plt0-1f		*/
184 					/* __glink:			*/
185 #define MFLR_R12	0x7d8802a6	/*  mflr %12			*/
186 #define BCL_20_31	0x429f0005	/*  bcl 20,31,1f		*/
187 					/* 1:				*/
188 #define MFLR_R11	0x7d6802a6	/*  mflr %11			*/
189 					/*  ld %2,(0b-1b)(%11)		*/
190 #define MTLR_R12	0x7d8803a6	/*  mtlr %12			*/
191 #define ADD_R11_R2_R11	0x7d625a14	/*  add %11,%2,%11		*/
192 					/*  ld %12,0(%11)		*/
193 					/*  ld %2,8(%11)		*/
194 					/*  mtctr %12			*/
195 					/*  ld %11,16(%11)		*/
196 					/*  bctr			*/
197 #define MFLR_R0		0x7c0802a6	/*  mflr %r0			*/
198 #define MTLR_R0		0x7c0803a6	/*  mtlr %r0			*/
199 #define SUB_R12_R12_R11	0x7d8b6050	/*  subf %r12,%r11,%r12		*/
200 #define ADDI_R0_R12	0x380c0000	/*  addi %r0,%r12,0		*/
201 #define SRDI_R0_R0_2	0x7800f082	/*  rldicl %r0,%r0,62,2		*/
202 
203 /* Pad with this.  */
204 #define NOP		0x60000000
205 
206 /* Some other nops.  */
207 #define CROR_151515	0x4def7b82
208 #define CROR_313131	0x4ffffb82
209 
210 /* .glink entries for the first 32k functions are two instructions.  */
211 #define LI_R0_0		0x38000000	/* li    %r0,0		*/
212 #define B_DOT		0x48000000	/* b     .		*/
213 
214 /* After that, we need two instructions to load the index, followed by
215    a branch.  */
216 #define LIS_R0_0	0x3c000000	/* lis   %r0,0		*/
217 #define ORI_R0_R0_0	0x60000000	/* ori	 %r0,%r0,0	*/
218 
219 /* Instructions used by the save and restore reg functions.  */
220 #define STD_R0_0R1	0xf8010000	/* std   %r0,0(%r1)	*/
221 #define STD_R0_0R12	0xf80c0000	/* std   %r0,0(%r12)	*/
222 #define LD_R0_0R1	0xe8010000	/* ld    %r0,0(%r1)	*/
223 #define LD_R0_0R12	0xe80c0000	/* ld    %r0,0(%r12)	*/
224 #define STFD_FR0_0R1	0xd8010000	/* stfd  %fr0,0(%r1)	*/
225 #define LFD_FR0_0R1	0xc8010000	/* lfd   %fr0,0(%r1)	*/
226 #define LI_R12_0	0x39800000	/* li    %r12,0		*/
227 #define STVX_VR0_R12_R0	0x7c0c01ce	/* stvx  %v0,%r12,%r0	*/
228 #define LVX_VR0_R12_R0	0x7c0c00ce	/* lvx   %v0,%r12,%r0	*/
229 #define MTLR_R0		0x7c0803a6	/* mtlr  %r0		*/
230 #define BLR		0x4e800020	/* blr			*/
231 
232 /* Since .opd is an array of descriptors and each entry will end up
233    with identical R_PPC64_RELATIVE relocs, there is really no need to
234    propagate .opd relocs;  The dynamic linker should be taught to
235    relocate .opd without reloc entries.  */
236 #ifndef NO_OPD_RELOCS
237 #define NO_OPD_RELOCS 0
238 #endif
239 
240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
241 
242 /* Relocation HOWTO's.  */
243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
244 
245 static reloc_howto_type ppc64_elf_howto_raw[] = {
246   /* This reloc does nothing.  */
247   HOWTO (R_PPC64_NONE,		/* type */
248 	 0,			/* rightshift */
249 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
250 	 32,			/* bitsize */
251 	 FALSE,			/* pc_relative */
252 	 0,			/* bitpos */
253 	 complain_overflow_dont, /* complain_on_overflow */
254 	 bfd_elf_generic_reloc,	/* special_function */
255 	 "R_PPC64_NONE",	/* name */
256 	 FALSE,			/* partial_inplace */
257 	 0,			/* src_mask */
258 	 0,			/* dst_mask */
259 	 FALSE),		/* pcrel_offset */
260 
261   /* A standard 32 bit relocation.  */
262   HOWTO (R_PPC64_ADDR32,	/* type */
263 	 0,			/* rightshift */
264 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
265 	 32,			/* bitsize */
266 	 FALSE,			/* pc_relative */
267 	 0,			/* bitpos */
268 	 complain_overflow_bitfield, /* complain_on_overflow */
269 	 bfd_elf_generic_reloc,	/* special_function */
270 	 "R_PPC64_ADDR32",	/* name */
271 	 FALSE,			/* partial_inplace */
272 	 0,			/* src_mask */
273 	 0xffffffff,		/* dst_mask */
274 	 FALSE),		/* pcrel_offset */
275 
276   /* An absolute 26 bit branch; the lower two bits must be zero.
277      FIXME: we don't check that, we just clear them.  */
278   HOWTO (R_PPC64_ADDR24,	/* type */
279 	 0,			/* rightshift */
280 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
281 	 26,			/* bitsize */
282 	 FALSE,			/* pc_relative */
283 	 0,			/* bitpos */
284 	 complain_overflow_bitfield, /* complain_on_overflow */
285 	 bfd_elf_generic_reloc,	/* special_function */
286 	 "R_PPC64_ADDR24",	/* name */
287 	 FALSE,			/* partial_inplace */
288 	 0,			/* src_mask */
289 	 0x03fffffc,		/* dst_mask */
290 	 FALSE),		/* pcrel_offset */
291 
292   /* A standard 16 bit relocation.  */
293   HOWTO (R_PPC64_ADDR16,	/* type */
294 	 0,			/* rightshift */
295 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
296 	 16,			/* bitsize */
297 	 FALSE,			/* pc_relative */
298 	 0,			/* bitpos */
299 	 complain_overflow_bitfield, /* complain_on_overflow */
300 	 bfd_elf_generic_reloc,	/* special_function */
301 	 "R_PPC64_ADDR16",	/* name */
302 	 FALSE,			/* partial_inplace */
303 	 0,			/* src_mask */
304 	 0xffff,		/* dst_mask */
305 	 FALSE),		/* pcrel_offset */
306 
307   /* A 16 bit relocation without overflow.  */
308   HOWTO (R_PPC64_ADDR16_LO,	/* type */
309 	 0,			/* rightshift */
310 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
311 	 16,			/* bitsize */
312 	 FALSE,			/* pc_relative */
313 	 0,			/* bitpos */
314 	 complain_overflow_dont,/* complain_on_overflow */
315 	 bfd_elf_generic_reloc,	/* special_function */
316 	 "R_PPC64_ADDR16_LO",	/* name */
317 	 FALSE,			/* partial_inplace */
318 	 0,			/* src_mask */
319 	 0xffff,		/* dst_mask */
320 	 FALSE),		/* pcrel_offset */
321 
322   /* Bits 16-31 of an address.  */
323   HOWTO (R_PPC64_ADDR16_HI,	/* type */
324 	 16,			/* rightshift */
325 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
326 	 16,			/* bitsize */
327 	 FALSE,			/* pc_relative */
328 	 0,			/* bitpos */
329 	 complain_overflow_signed, /* complain_on_overflow */
330 	 bfd_elf_generic_reloc,	/* special_function */
331 	 "R_PPC64_ADDR16_HI",	/* name */
332 	 FALSE,			/* partial_inplace */
333 	 0,			/* src_mask */
334 	 0xffff,		/* dst_mask */
335 	 FALSE),		/* pcrel_offset */
336 
337   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
338      bits, treated as a signed number, is negative.  */
339   HOWTO (R_PPC64_ADDR16_HA,	/* type */
340 	 16,			/* rightshift */
341 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
342 	 16,			/* bitsize */
343 	 FALSE,			/* pc_relative */
344 	 0,			/* bitpos */
345 	 complain_overflow_signed, /* complain_on_overflow */
346 	 ppc64_elf_ha_reloc,	/* special_function */
347 	 "R_PPC64_ADDR16_HA",	/* name */
348 	 FALSE,			/* partial_inplace */
349 	 0,			/* src_mask */
350 	 0xffff,		/* dst_mask */
351 	 FALSE),		/* pcrel_offset */
352 
353   /* An absolute 16 bit branch; the lower two bits must be zero.
354      FIXME: we don't check that, we just clear them.  */
355   HOWTO (R_PPC64_ADDR14,	/* type */
356 	 0,			/* rightshift */
357 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
358 	 16,			/* bitsize */
359 	 FALSE,			/* pc_relative */
360 	 0,			/* bitpos */
361 	 complain_overflow_bitfield, /* complain_on_overflow */
362 	 ppc64_elf_branch_reloc, /* special_function */
363 	 "R_PPC64_ADDR14",	/* name */
364 	 FALSE,			/* partial_inplace */
365 	 0,			/* src_mask */
366 	 0x0000fffc,		/* dst_mask */
367 	 FALSE),		/* pcrel_offset */
368 
369   /* An absolute 16 bit branch, for which bit 10 should be set to
370      indicate that the branch is expected to be taken.  The lower two
371      bits must be zero.  */
372   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
373 	 0,			/* rightshift */
374 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
375 	 16,			/* bitsize */
376 	 FALSE,			/* pc_relative */
377 	 0,			/* bitpos */
378 	 complain_overflow_bitfield, /* complain_on_overflow */
379 	 ppc64_elf_brtaken_reloc, /* special_function */
380 	 "R_PPC64_ADDR14_BRTAKEN",/* name */
381 	 FALSE,			/* partial_inplace */
382 	 0,			/* src_mask */
383 	 0x0000fffc,		/* dst_mask */
384 	 FALSE),		/* pcrel_offset */
385 
386   /* An absolute 16 bit branch, for which bit 10 should be set to
387      indicate that the branch is not expected to be taken.  The lower
388      two bits must be zero.  */
389   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
390 	 0,			/* rightshift */
391 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
392 	 16,			/* bitsize */
393 	 FALSE,			/* pc_relative */
394 	 0,			/* bitpos */
395 	 complain_overflow_bitfield, /* complain_on_overflow */
396 	 ppc64_elf_brtaken_reloc, /* special_function */
397 	 "R_PPC64_ADDR14_BRNTAKEN",/* name */
398 	 FALSE,			/* partial_inplace */
399 	 0,			/* src_mask */
400 	 0x0000fffc,		/* dst_mask */
401 	 FALSE),		/* pcrel_offset */
402 
403   /* A relative 26 bit branch; the lower two bits must be zero.  */
404   HOWTO (R_PPC64_REL24,		/* type */
405 	 0,			/* rightshift */
406 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
407 	 26,			/* bitsize */
408 	 TRUE,			/* pc_relative */
409 	 0,			/* bitpos */
410 	 complain_overflow_signed, /* complain_on_overflow */
411 	 ppc64_elf_branch_reloc, /* special_function */
412 	 "R_PPC64_REL24",	/* name */
413 	 FALSE,			/* partial_inplace */
414 	 0,			/* src_mask */
415 	 0x03fffffc,		/* dst_mask */
416 	 TRUE),			/* pcrel_offset */
417 
418   /* A relative 16 bit branch; the lower two bits must be zero.  */
419   HOWTO (R_PPC64_REL14,		/* type */
420 	 0,			/* rightshift */
421 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
422 	 16,			/* bitsize */
423 	 TRUE,			/* pc_relative */
424 	 0,			/* bitpos */
425 	 complain_overflow_signed, /* complain_on_overflow */
426 	 ppc64_elf_branch_reloc, /* special_function */
427 	 "R_PPC64_REL14",	/* name */
428 	 FALSE,			/* partial_inplace */
429 	 0,			/* src_mask */
430 	 0x0000fffc,		/* dst_mask */
431 	 TRUE),			/* pcrel_offset */
432 
433   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
434      the branch is expected to be taken.  The lower two bits must be
435      zero.  */
436   HOWTO (R_PPC64_REL14_BRTAKEN,	/* type */
437 	 0,			/* rightshift */
438 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
439 	 16,			/* bitsize */
440 	 TRUE,			/* pc_relative */
441 	 0,			/* bitpos */
442 	 complain_overflow_signed, /* complain_on_overflow */
443 	 ppc64_elf_brtaken_reloc, /* special_function */
444 	 "R_PPC64_REL14_BRTAKEN", /* name */
445 	 FALSE,			/* partial_inplace */
446 	 0,			/* src_mask */
447 	 0x0000fffc,		/* dst_mask */
448 	 TRUE),			/* pcrel_offset */
449 
450   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
451      the branch is not expected to be taken.  The lower two bits must
452      be zero.  */
453   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
454 	 0,			/* rightshift */
455 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
456 	 16,			/* bitsize */
457 	 TRUE,			/* pc_relative */
458 	 0,			/* bitpos */
459 	 complain_overflow_signed, /* complain_on_overflow */
460 	 ppc64_elf_brtaken_reloc, /* special_function */
461 	 "R_PPC64_REL14_BRNTAKEN",/* name */
462 	 FALSE,			/* partial_inplace */
463 	 0,			/* src_mask */
464 	 0x0000fffc,		/* dst_mask */
465 	 TRUE),			/* pcrel_offset */
466 
467   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
468      symbol.  */
469   HOWTO (R_PPC64_GOT16,		/* type */
470 	 0,			/* rightshift */
471 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
472 	 16,			/* bitsize */
473 	 FALSE,			/* pc_relative */
474 	 0,			/* bitpos */
475 	 complain_overflow_signed, /* complain_on_overflow */
476 	 ppc64_elf_unhandled_reloc, /* special_function */
477 	 "R_PPC64_GOT16",	/* name */
478 	 FALSE,			/* partial_inplace */
479 	 0,			/* src_mask */
480 	 0xffff,		/* dst_mask */
481 	 FALSE),		/* pcrel_offset */
482 
483   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
484      the symbol.  */
485   HOWTO (R_PPC64_GOT16_LO,	/* type */
486 	 0,			/* rightshift */
487 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
488 	 16,			/* bitsize */
489 	 FALSE,			/* pc_relative */
490 	 0,			/* bitpos */
491 	 complain_overflow_dont, /* complain_on_overflow */
492 	 ppc64_elf_unhandled_reloc, /* special_function */
493 	 "R_PPC64_GOT16_LO",	/* name */
494 	 FALSE,			/* partial_inplace */
495 	 0,			/* src_mask */
496 	 0xffff,		/* dst_mask */
497 	 FALSE),		/* pcrel_offset */
498 
499   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
500      the symbol.  */
501   HOWTO (R_PPC64_GOT16_HI,	/* type */
502 	 16,			/* rightshift */
503 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
504 	 16,			/* bitsize */
505 	 FALSE,			/* pc_relative */
506 	 0,			/* bitpos */
507 	 complain_overflow_signed,/* complain_on_overflow */
508 	 ppc64_elf_unhandled_reloc, /* special_function */
509 	 "R_PPC64_GOT16_HI",	/* name */
510 	 FALSE,			/* partial_inplace */
511 	 0,			/* src_mask */
512 	 0xffff,		/* dst_mask */
513 	 FALSE),		/* pcrel_offset */
514 
515   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
516      the symbol.  */
517   HOWTO (R_PPC64_GOT16_HA,	/* type */
518 	 16,			/* rightshift */
519 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
520 	 16,			/* bitsize */
521 	 FALSE,			/* pc_relative */
522 	 0,			/* bitpos */
523 	 complain_overflow_signed,/* complain_on_overflow */
524 	 ppc64_elf_unhandled_reloc, /* special_function */
525 	 "R_PPC64_GOT16_HA",	/* name */
526 	 FALSE,			/* partial_inplace */
527 	 0,			/* src_mask */
528 	 0xffff,		/* dst_mask */
529 	 FALSE),		/* pcrel_offset */
530 
531   /* This is used only by the dynamic linker.  The symbol should exist
532      both in the object being run and in some shared library.  The
533      dynamic linker copies the data addressed by the symbol from the
534      shared library into the object, because the object being
535      run has to have the data at some particular address.  */
536   HOWTO (R_PPC64_COPY,		/* type */
537 	 0,			/* rightshift */
538 	 0,			/* this one is variable size */
539 	 0,			/* bitsize */
540 	 FALSE,			/* pc_relative */
541 	 0,			/* bitpos */
542 	 complain_overflow_dont, /* complain_on_overflow */
543 	 ppc64_elf_unhandled_reloc, /* special_function */
544 	 "R_PPC64_COPY",	/* name */
545 	 FALSE,			/* partial_inplace */
546 	 0,			/* src_mask */
547 	 0,			/* dst_mask */
548 	 FALSE),		/* pcrel_offset */
549 
550   /* Like R_PPC64_ADDR64, but used when setting global offset table
551      entries.  */
552   HOWTO (R_PPC64_GLOB_DAT,	/* type */
553 	 0,			/* rightshift */
554 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
555 	 64,			/* bitsize */
556 	 FALSE,			/* pc_relative */
557 	 0,			/* bitpos */
558 	 complain_overflow_dont, /* complain_on_overflow */
559 	 ppc64_elf_unhandled_reloc,  /* special_function */
560 	 "R_PPC64_GLOB_DAT",	/* name */
561 	 FALSE,			/* partial_inplace */
562 	 0,			/* src_mask */
563 	 ONES (64),		/* dst_mask */
564 	 FALSE),		/* pcrel_offset */
565 
566   /* Created by the link editor.  Marks a procedure linkage table
567      entry for a symbol.  */
568   HOWTO (R_PPC64_JMP_SLOT,	/* type */
569 	 0,			/* rightshift */
570 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
571 	 0,			/* bitsize */
572 	 FALSE,			/* pc_relative */
573 	 0,			/* bitpos */
574 	 complain_overflow_dont, /* complain_on_overflow */
575 	 ppc64_elf_unhandled_reloc, /* special_function */
576 	 "R_PPC64_JMP_SLOT",	/* name */
577 	 FALSE,			/* partial_inplace */
578 	 0,			/* src_mask */
579 	 0,			/* dst_mask */
580 	 FALSE),		/* pcrel_offset */
581 
582   /* Used only by the dynamic linker.  When the object is run, this
583      doubleword64 is set to the load address of the object, plus the
584      addend.  */
585   HOWTO (R_PPC64_RELATIVE,	/* type */
586 	 0,			/* rightshift */
587 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
588 	 64,			/* bitsize */
589 	 FALSE,			/* pc_relative */
590 	 0,			/* bitpos */
591 	 complain_overflow_dont, /* complain_on_overflow */
592 	 bfd_elf_generic_reloc,	/* special_function */
593 	 "R_PPC64_RELATIVE",	/* name */
594 	 FALSE,			/* partial_inplace */
595 	 0,			/* src_mask */
596 	 ONES (64),		/* dst_mask */
597 	 FALSE),		/* pcrel_offset */
598 
599   /* Like R_PPC64_ADDR32, but may be unaligned.  */
600   HOWTO (R_PPC64_UADDR32,	/* type */
601 	 0,			/* rightshift */
602 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
603 	 32,			/* bitsize */
604 	 FALSE,			/* pc_relative */
605 	 0,			/* bitpos */
606 	 complain_overflow_bitfield, /* complain_on_overflow */
607 	 bfd_elf_generic_reloc,	/* special_function */
608 	 "R_PPC64_UADDR32",	/* name */
609 	 FALSE,			/* partial_inplace */
610 	 0,			/* src_mask */
611 	 0xffffffff,		/* dst_mask */
612 	 FALSE),		/* pcrel_offset */
613 
614   /* Like R_PPC64_ADDR16, but may be unaligned.  */
615   HOWTO (R_PPC64_UADDR16,	/* type */
616 	 0,			/* rightshift */
617 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
618 	 16,			/* bitsize */
619 	 FALSE,			/* pc_relative */
620 	 0,			/* bitpos */
621 	 complain_overflow_bitfield, /* complain_on_overflow */
622 	 bfd_elf_generic_reloc,	/* special_function */
623 	 "R_PPC64_UADDR16",	/* name */
624 	 FALSE,			/* partial_inplace */
625 	 0,			/* src_mask */
626 	 0xffff,		/* dst_mask */
627 	 FALSE),		/* pcrel_offset */
628 
629   /* 32-bit PC relative.  */
630   HOWTO (R_PPC64_REL32,		/* type */
631 	 0,			/* rightshift */
632 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
633 	 32,			/* bitsize */
634 	 TRUE,			/* pc_relative */
635 	 0,			/* bitpos */
636 	 /* FIXME: Verify.  Was complain_overflow_bitfield.  */
637 	 complain_overflow_signed, /* complain_on_overflow */
638 	 bfd_elf_generic_reloc,	/* special_function */
639 	 "R_PPC64_REL32",	/* name */
640 	 FALSE,			/* partial_inplace */
641 	 0,			/* src_mask */
642 	 0xffffffff,		/* dst_mask */
643 	 TRUE),			/* pcrel_offset */
644 
645   /* 32-bit relocation to the symbol's procedure linkage table.  */
646   HOWTO (R_PPC64_PLT32,		/* type */
647 	 0,			/* rightshift */
648 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
649 	 32,			/* bitsize */
650 	 FALSE,			/* pc_relative */
651 	 0,			/* bitpos */
652 	 complain_overflow_bitfield, /* complain_on_overflow */
653 	 ppc64_elf_unhandled_reloc, /* special_function */
654 	 "R_PPC64_PLT32",	/* name */
655 	 FALSE,			/* partial_inplace */
656 	 0,			/* src_mask */
657 	 0xffffffff,		/* dst_mask */
658 	 FALSE),		/* pcrel_offset */
659 
660   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
661      FIXME: R_PPC64_PLTREL32 not supported.  */
662   HOWTO (R_PPC64_PLTREL32,	/* type */
663 	 0,			/* rightshift */
664 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
665 	 32,			/* bitsize */
666 	 TRUE,			/* pc_relative */
667 	 0,			/* bitpos */
668 	 complain_overflow_signed, /* complain_on_overflow */
669 	 bfd_elf_generic_reloc,	/* special_function */
670 	 "R_PPC64_PLTREL32",	/* name */
671 	 FALSE,			/* partial_inplace */
672 	 0,			/* src_mask */
673 	 0xffffffff,		/* dst_mask */
674 	 TRUE),			/* pcrel_offset */
675 
676   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
677      the symbol.  */
678   HOWTO (R_PPC64_PLT16_LO,	/* type */
679 	 0,			/* rightshift */
680 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
681 	 16,			/* bitsize */
682 	 FALSE,			/* pc_relative */
683 	 0,			/* bitpos */
684 	 complain_overflow_dont, /* complain_on_overflow */
685 	 ppc64_elf_unhandled_reloc, /* special_function */
686 	 "R_PPC64_PLT16_LO",	/* name */
687 	 FALSE,			/* partial_inplace */
688 	 0,			/* src_mask */
689 	 0xffff,		/* dst_mask */
690 	 FALSE),		/* pcrel_offset */
691 
692   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
693      the symbol.  */
694   HOWTO (R_PPC64_PLT16_HI,	/* type */
695 	 16,			/* rightshift */
696 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
697 	 16,			/* bitsize */
698 	 FALSE,			/* pc_relative */
699 	 0,			/* bitpos */
700 	 complain_overflow_signed, /* complain_on_overflow */
701 	 ppc64_elf_unhandled_reloc, /* special_function */
702 	 "R_PPC64_PLT16_HI",	/* name */
703 	 FALSE,			/* partial_inplace */
704 	 0,			/* src_mask */
705 	 0xffff,		/* dst_mask */
706 	 FALSE),		/* pcrel_offset */
707 
708   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
709      the symbol.  */
710   HOWTO (R_PPC64_PLT16_HA,	/* type */
711 	 16,			/* rightshift */
712 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
713 	 16,			/* bitsize */
714 	 FALSE,			/* pc_relative */
715 	 0,			/* bitpos */
716 	 complain_overflow_signed, /* complain_on_overflow */
717 	 ppc64_elf_unhandled_reloc, /* special_function */
718 	 "R_PPC64_PLT16_HA",	/* name */
719 	 FALSE,			/* partial_inplace */
720 	 0,			/* src_mask */
721 	 0xffff,		/* dst_mask */
722 	 FALSE),		/* pcrel_offset */
723 
724   /* 16-bit section relative relocation.  */
725   HOWTO (R_PPC64_SECTOFF,	/* type */
726 	 0,			/* rightshift */
727 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
728 	 16,			/* bitsize */
729 	 FALSE,			/* pc_relative */
730 	 0,			/* bitpos */
731 	 complain_overflow_bitfield, /* complain_on_overflow */
732 	 ppc64_elf_sectoff_reloc, /* special_function */
733 	 "R_PPC64_SECTOFF",	/* name */
734 	 FALSE,			/* partial_inplace */
735 	 0,			/* src_mask */
736 	 0xffff,		/* dst_mask */
737 	 FALSE),		/* pcrel_offset */
738 
739   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
740   HOWTO (R_PPC64_SECTOFF_LO,	/* type */
741 	 0,			/* rightshift */
742 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
743 	 16,			/* bitsize */
744 	 FALSE,			/* pc_relative */
745 	 0,			/* bitpos */
746 	 complain_overflow_dont, /* complain_on_overflow */
747 	 ppc64_elf_sectoff_reloc, /* special_function */
748 	 "R_PPC64_SECTOFF_LO",	/* name */
749 	 FALSE,			/* partial_inplace */
750 	 0,			/* src_mask */
751 	 0xffff,		/* dst_mask */
752 	 FALSE),		/* pcrel_offset */
753 
754   /* 16-bit upper half section relative relocation.  */
755   HOWTO (R_PPC64_SECTOFF_HI,	/* type */
756 	 16,			/* rightshift */
757 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
758 	 16,			/* bitsize */
759 	 FALSE,			/* pc_relative */
760 	 0,			/* bitpos */
761 	 complain_overflow_signed, /* complain_on_overflow */
762 	 ppc64_elf_sectoff_reloc, /* special_function */
763 	 "R_PPC64_SECTOFF_HI",	/* name */
764 	 FALSE,			/* partial_inplace */
765 	 0,			/* src_mask */
766 	 0xffff,		/* dst_mask */
767 	 FALSE),		/* pcrel_offset */
768 
769   /* 16-bit upper half adjusted section relative relocation.  */
770   HOWTO (R_PPC64_SECTOFF_HA,	/* type */
771 	 16,			/* rightshift */
772 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
773 	 16,			/* bitsize */
774 	 FALSE,			/* pc_relative */
775 	 0,			/* bitpos */
776 	 complain_overflow_signed, /* complain_on_overflow */
777 	 ppc64_elf_sectoff_ha_reloc, /* special_function */
778 	 "R_PPC64_SECTOFF_HA",	/* name */
779 	 FALSE,			/* partial_inplace */
780 	 0,			/* src_mask */
781 	 0xffff,		/* dst_mask */
782 	 FALSE),		/* pcrel_offset */
783 
784   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
785   HOWTO (R_PPC64_REL30,		/* type */
786 	 2,			/* rightshift */
787 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
788 	 30,			/* bitsize */
789 	 TRUE,			/* pc_relative */
790 	 0,			/* bitpos */
791 	 complain_overflow_dont, /* complain_on_overflow */
792 	 bfd_elf_generic_reloc, /* special_function */
793 	 "R_PPC64_REL30",	/* name */
794 	 FALSE,			/* partial_inplace */
795 	 0,			/* src_mask */
796 	 0xfffffffc,		/* dst_mask */
797 	 TRUE),			/* pcrel_offset */
798 
799   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
800 
801   /* A standard 64-bit relocation.  */
802   HOWTO (R_PPC64_ADDR64,	/* type */
803 	 0,			/* rightshift */
804 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
805 	 64,			/* bitsize */
806 	 FALSE,			/* pc_relative */
807 	 0,			/* bitpos */
808 	 complain_overflow_dont, /* complain_on_overflow */
809 	 bfd_elf_generic_reloc,	/* special_function */
810 	 "R_PPC64_ADDR64",	/* name */
811 	 FALSE,			/* partial_inplace */
812 	 0,			/* src_mask */
813 	 ONES (64),		/* dst_mask */
814 	 FALSE),		/* pcrel_offset */
815 
816   /* The bits 32-47 of an address.  */
817   HOWTO (R_PPC64_ADDR16_HIGHER,	/* type */
818 	 32,			/* rightshift */
819 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
820 	 16,			/* bitsize */
821 	 FALSE,			/* pc_relative */
822 	 0,			/* bitpos */
823 	 complain_overflow_dont, /* complain_on_overflow */
824 	 bfd_elf_generic_reloc,	/* special_function */
825 	 "R_PPC64_ADDR16_HIGHER", /* name */
826 	 FALSE,			/* partial_inplace */
827 	 0,			/* src_mask */
828 	 0xffff,		/* dst_mask */
829 	 FALSE),		/* pcrel_offset */
830 
831   /* The bits 32-47 of an address, plus 1 if the contents of the low
832      16 bits, treated as a signed number, is negative.  */
833   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
834 	 32,			/* rightshift */
835 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
836 	 16,			/* bitsize */
837 	 FALSE,			/* pc_relative */
838 	 0,			/* bitpos */
839 	 complain_overflow_dont, /* complain_on_overflow */
840 	 ppc64_elf_ha_reloc,	/* special_function */
841 	 "R_PPC64_ADDR16_HIGHERA", /* name */
842 	 FALSE,			/* partial_inplace */
843 	 0,			/* src_mask */
844 	 0xffff,		/* dst_mask */
845 	 FALSE),		/* pcrel_offset */
846 
847   /* The bits 48-63 of an address.  */
848   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
849 	 48,			/* rightshift */
850 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
851 	 16,			/* bitsize */
852 	 FALSE,			/* pc_relative */
853 	 0,			/* bitpos */
854 	 complain_overflow_dont, /* complain_on_overflow */
855 	 bfd_elf_generic_reloc,	/* special_function */
856 	 "R_PPC64_ADDR16_HIGHEST", /* name */
857 	 FALSE,			/* partial_inplace */
858 	 0,			/* src_mask */
859 	 0xffff,		/* dst_mask */
860 	 FALSE),		/* pcrel_offset */
861 
862   /* The bits 48-63 of an address, plus 1 if the contents of the low
863      16 bits, treated as a signed number, is negative.  */
864   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
865 	 48,			/* rightshift */
866 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
867 	 16,			/* bitsize */
868 	 FALSE,			/* pc_relative */
869 	 0,			/* bitpos */
870 	 complain_overflow_dont, /* complain_on_overflow */
871 	 ppc64_elf_ha_reloc,	/* special_function */
872 	 "R_PPC64_ADDR16_HIGHESTA", /* name */
873 	 FALSE,			/* partial_inplace */
874 	 0,			/* src_mask */
875 	 0xffff,		/* dst_mask */
876 	 FALSE),		/* pcrel_offset */
877 
878   /* Like ADDR64, but may be unaligned.  */
879   HOWTO (R_PPC64_UADDR64,	/* type */
880 	 0,			/* rightshift */
881 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
882 	 64,			/* bitsize */
883 	 FALSE,			/* pc_relative */
884 	 0,			/* bitpos */
885 	 complain_overflow_dont, /* complain_on_overflow */
886 	 bfd_elf_generic_reloc,	/* special_function */
887 	 "R_PPC64_UADDR64",	/* name */
888 	 FALSE,			/* partial_inplace */
889 	 0,			/* src_mask */
890 	 ONES (64),		/* dst_mask */
891 	 FALSE),		/* pcrel_offset */
892 
893   /* 64-bit relative relocation.  */
894   HOWTO (R_PPC64_REL64,		/* type */
895 	 0,			/* rightshift */
896 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
897 	 64,			/* bitsize */
898 	 TRUE,			/* pc_relative */
899 	 0,			/* bitpos */
900 	 complain_overflow_dont, /* complain_on_overflow */
901 	 bfd_elf_generic_reloc,	/* special_function */
902 	 "R_PPC64_REL64",	/* name */
903 	 FALSE,			/* partial_inplace */
904 	 0,			/* src_mask */
905 	 ONES (64),		/* dst_mask */
906 	 TRUE),			/* pcrel_offset */
907 
908   /* 64-bit relocation to the symbol's procedure linkage table.  */
909   HOWTO (R_PPC64_PLT64,		/* type */
910 	 0,			/* rightshift */
911 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
912 	 64,			/* bitsize */
913 	 FALSE,			/* pc_relative */
914 	 0,			/* bitpos */
915 	 complain_overflow_dont, /* complain_on_overflow */
916 	 ppc64_elf_unhandled_reloc, /* special_function */
917 	 "R_PPC64_PLT64",	/* name */
918 	 FALSE,			/* partial_inplace */
919 	 0,			/* src_mask */
920 	 ONES (64),		/* dst_mask */
921 	 FALSE),		/* pcrel_offset */
922 
923   /* 64-bit PC relative relocation to the symbol's procedure linkage
924      table.  */
925   /* FIXME: R_PPC64_PLTREL64 not supported.  */
926   HOWTO (R_PPC64_PLTREL64,	/* type */
927 	 0,			/* rightshift */
928 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
929 	 64,			/* bitsize */
930 	 TRUE,			/* pc_relative */
931 	 0,			/* bitpos */
932 	 complain_overflow_dont, /* complain_on_overflow */
933 	 ppc64_elf_unhandled_reloc, /* special_function */
934 	 "R_PPC64_PLTREL64",	/* name */
935 	 FALSE,			/* partial_inplace */
936 	 0,			/* src_mask */
937 	 ONES (64),		/* dst_mask */
938 	 TRUE),			/* pcrel_offset */
939 
940   /* 16 bit TOC-relative relocation.  */
941 
942   /* R_PPC64_TOC16	  47	   half16*	S + A - .TOC.  */
943   HOWTO (R_PPC64_TOC16,		/* type */
944 	 0,			/* rightshift */
945 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
946 	 16,			/* bitsize */
947 	 FALSE,			/* pc_relative */
948 	 0,			/* bitpos */
949 	 complain_overflow_signed, /* complain_on_overflow */
950 	 ppc64_elf_toc_reloc,	/* special_function */
951 	 "R_PPC64_TOC16",	/* name */
952 	 FALSE,			/* partial_inplace */
953 	 0,			/* src_mask */
954 	 0xffff,		/* dst_mask */
955 	 FALSE),		/* pcrel_offset */
956 
957   /* 16 bit TOC-relative relocation without overflow.  */
958 
959   /* R_PPC64_TOC16_LO	  48	   half16	 #lo (S + A - .TOC.)  */
960   HOWTO (R_PPC64_TOC16_LO,	/* type */
961 	 0,			/* rightshift */
962 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
963 	 16,			/* bitsize */
964 	 FALSE,			/* pc_relative */
965 	 0,			/* bitpos */
966 	 complain_overflow_dont, /* complain_on_overflow */
967 	 ppc64_elf_toc_reloc,	/* special_function */
968 	 "R_PPC64_TOC16_LO",	/* name */
969 	 FALSE,			/* partial_inplace */
970 	 0,			/* src_mask */
971 	 0xffff,		/* dst_mask */
972 	 FALSE),		/* pcrel_offset */
973 
974   /* 16 bit TOC-relative relocation, high 16 bits.  */
975 
976   /* R_PPC64_TOC16_HI	  49	   half16	 #hi (S + A - .TOC.)  */
977   HOWTO (R_PPC64_TOC16_HI,	/* type */
978 	 16,			/* rightshift */
979 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
980 	 16,			/* bitsize */
981 	 FALSE,			/* pc_relative */
982 	 0,			/* bitpos */
983 	 complain_overflow_signed, /* complain_on_overflow */
984 	 ppc64_elf_toc_reloc,	/* special_function */
985 	 "R_PPC64_TOC16_HI",	/* name */
986 	 FALSE,			/* partial_inplace */
987 	 0,			/* src_mask */
988 	 0xffff,		/* dst_mask */
989 	 FALSE),		/* pcrel_offset */
990 
991   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
992      contents of the low 16 bits, treated as a signed number, is
993      negative.  */
994 
995   /* R_PPC64_TOC16_HA	  50	   half16	 #ha (S + A - .TOC.)  */
996   HOWTO (R_PPC64_TOC16_HA,	/* type */
997 	 16,			/* rightshift */
998 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
999 	 16,			/* bitsize */
1000 	 FALSE,			/* pc_relative */
1001 	 0,			/* bitpos */
1002 	 complain_overflow_signed, /* complain_on_overflow */
1003 	 ppc64_elf_toc_ha_reloc, /* special_function */
1004 	 "R_PPC64_TOC16_HA",	/* name */
1005 	 FALSE,			/* partial_inplace */
1006 	 0,			/* src_mask */
1007 	 0xffff,		/* dst_mask */
1008 	 FALSE),		/* pcrel_offset */
1009 
1010   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1011 
1012   /* R_PPC64_TOC		  51	   doubleword64	 .TOC.  */
1013   HOWTO (R_PPC64_TOC,		/* type */
1014 	 0,			/* rightshift */
1015 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
1016 	 64,			/* bitsize */
1017 	 FALSE,			/* pc_relative */
1018 	 0,			/* bitpos */
1019 	 complain_overflow_bitfield, /* complain_on_overflow */
1020 	 ppc64_elf_toc64_reloc,	/* special_function */
1021 	 "R_PPC64_TOC",		/* name */
1022 	 FALSE,			/* partial_inplace */
1023 	 0,			/* src_mask */
1024 	 ONES (64),		/* dst_mask */
1025 	 FALSE),		/* pcrel_offset */
1026 
1027   /* Like R_PPC64_GOT16, but also informs the link editor that the
1028      value to relocate may (!) refer to a PLT entry which the link
1029      editor (a) may replace with the symbol value.  If the link editor
1030      is unable to fully resolve the symbol, it may (b) create a PLT
1031      entry and store the address to the new PLT entry in the GOT.
1032      This permits lazy resolution of function symbols at run time.
1033      The link editor may also skip all of this and just (c) emit a
1034      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1035   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1036     HOWTO (R_PPC64_PLTGOT16,	/* type */
1037 	 0,			/* rightshift */
1038 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1039 	 16,			/* bitsize */
1040 	 FALSE,			/* pc_relative */
1041 	 0,			/* bitpos */
1042 	 complain_overflow_signed, /* complain_on_overflow */
1043 	 ppc64_elf_unhandled_reloc, /* special_function */
1044 	 "R_PPC64_PLTGOT16",	/* name */
1045 	 FALSE,			/* partial_inplace */
1046 	 0,			/* src_mask */
1047 	 0xffff,		/* dst_mask */
1048 	 FALSE),		/* pcrel_offset */
1049 
1050   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1051   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1052   HOWTO (R_PPC64_PLTGOT16_LO,	/* type */
1053 	 0,			/* rightshift */
1054 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1055 	 16,			/* bitsize */
1056 	 FALSE,			/* pc_relative */
1057 	 0,			/* bitpos */
1058 	 complain_overflow_dont, /* complain_on_overflow */
1059 	 ppc64_elf_unhandled_reloc, /* special_function */
1060 	 "R_PPC64_PLTGOT16_LO",	/* name */
1061 	 FALSE,			/* partial_inplace */
1062 	 0,			/* src_mask */
1063 	 0xffff,		/* dst_mask */
1064 	 FALSE),		/* pcrel_offset */
1065 
1066   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1067   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1068   HOWTO (R_PPC64_PLTGOT16_HI,	/* type */
1069 	 16,			/* rightshift */
1070 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1071 	 16,			/* bitsize */
1072 	 FALSE,			/* pc_relative */
1073 	 0,			/* bitpos */
1074 	 complain_overflow_signed, /* complain_on_overflow */
1075 	 ppc64_elf_unhandled_reloc, /* special_function */
1076 	 "R_PPC64_PLTGOT16_HI",	/* name */
1077 	 FALSE,			/* partial_inplace */
1078 	 0,			/* src_mask */
1079 	 0xffff,		/* dst_mask */
1080 	 FALSE),		/* pcrel_offset */
1081 
1082   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1083      1 if the contents of the low 16 bits, treated as a signed number,
1084      is negative.  */
1085   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1086   HOWTO (R_PPC64_PLTGOT16_HA,	/* type */
1087 	 16,			/* rightshift */
1088 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1089 	 16,			/* bitsize */
1090 	 FALSE,			/* pc_relative */
1091 	 0,			/* bitpos */
1092 	 complain_overflow_signed, /* complain_on_overflow */
1093 	 ppc64_elf_unhandled_reloc, /* special_function */
1094 	 "R_PPC64_PLTGOT16_HA",	/* name */
1095 	 FALSE,			/* partial_inplace */
1096 	 0,			/* src_mask */
1097 	 0xffff,		/* dst_mask */
1098 	 FALSE),		/* pcrel_offset */
1099 
1100   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1101   HOWTO (R_PPC64_ADDR16_DS,	/* type */
1102 	 0,			/* rightshift */
1103 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1104 	 16,			/* bitsize */
1105 	 FALSE,			/* pc_relative */
1106 	 0,			/* bitpos */
1107 	 complain_overflow_bitfield, /* complain_on_overflow */
1108 	 bfd_elf_generic_reloc,	/* special_function */
1109 	 "R_PPC64_ADDR16_DS",	/* name */
1110 	 FALSE,			/* partial_inplace */
1111 	 0,			/* src_mask */
1112 	 0xfffc,		/* dst_mask */
1113 	 FALSE),		/* pcrel_offset */
1114 
1115   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1116   HOWTO (R_PPC64_ADDR16_LO_DS,	/* type */
1117 	 0,			/* rightshift */
1118 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1119 	 16,			/* bitsize */
1120 	 FALSE,			/* pc_relative */
1121 	 0,			/* bitpos */
1122 	 complain_overflow_dont,/* complain_on_overflow */
1123 	 bfd_elf_generic_reloc,	/* special_function */
1124 	 "R_PPC64_ADDR16_LO_DS",/* name */
1125 	 FALSE,			/* partial_inplace */
1126 	 0,			/* src_mask */
1127 	 0xfffc,		/* dst_mask */
1128 	 FALSE),		/* pcrel_offset */
1129 
1130   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_GOT16_DS,	/* type */
1132 	 0,			/* rightshift */
1133 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1134 	 16,			/* bitsize */
1135 	 FALSE,			/* pc_relative */
1136 	 0,			/* bitpos */
1137 	 complain_overflow_signed, /* complain_on_overflow */
1138 	 ppc64_elf_unhandled_reloc, /* special_function */
1139 	 "R_PPC64_GOT16_DS",	/* name */
1140 	 FALSE,			/* partial_inplace */
1141 	 0,			/* src_mask */
1142 	 0xfffc,		/* dst_mask */
1143 	 FALSE),		/* pcrel_offset */
1144 
1145   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_GOT16_LO_DS,	/* type */
1147 	 0,			/* rightshift */
1148 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1149 	 16,			/* bitsize */
1150 	 FALSE,			/* pc_relative */
1151 	 0,			/* bitpos */
1152 	 complain_overflow_dont, /* complain_on_overflow */
1153 	 ppc64_elf_unhandled_reloc, /* special_function */
1154 	 "R_PPC64_GOT16_LO_DS",	/* name */
1155 	 FALSE,			/* partial_inplace */
1156 	 0,			/* src_mask */
1157 	 0xfffc,		/* dst_mask */
1158 	 FALSE),		/* pcrel_offset */
1159 
1160   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_PLT16_LO_DS,	/* type */
1162 	 0,			/* rightshift */
1163 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1164 	 16,			/* bitsize */
1165 	 FALSE,			/* pc_relative */
1166 	 0,			/* bitpos */
1167 	 complain_overflow_dont, /* complain_on_overflow */
1168 	 ppc64_elf_unhandled_reloc, /* special_function */
1169 	 "R_PPC64_PLT16_LO_DS",	/* name */
1170 	 FALSE,			/* partial_inplace */
1171 	 0,			/* src_mask */
1172 	 0xfffc,		/* dst_mask */
1173 	 FALSE),		/* pcrel_offset */
1174 
1175   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1176   HOWTO (R_PPC64_SECTOFF_DS,	/* type */
1177 	 0,			/* rightshift */
1178 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1179 	 16,			/* bitsize */
1180 	 FALSE,			/* pc_relative */
1181 	 0,			/* bitpos */
1182 	 complain_overflow_bitfield, /* complain_on_overflow */
1183 	 ppc64_elf_sectoff_reloc, /* special_function */
1184 	 "R_PPC64_SECTOFF_DS",	/* name */
1185 	 FALSE,			/* partial_inplace */
1186 	 0,			/* src_mask */
1187 	 0xfffc,		/* dst_mask */
1188 	 FALSE),		/* pcrel_offset */
1189 
1190   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1191   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1192 	 0,			/* rightshift */
1193 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1194 	 16,			/* bitsize */
1195 	 FALSE,			/* pc_relative */
1196 	 0,			/* bitpos */
1197 	 complain_overflow_dont, /* complain_on_overflow */
1198 	 ppc64_elf_sectoff_reloc, /* special_function */
1199 	 "R_PPC64_SECTOFF_LO_DS",/* name */
1200 	 FALSE,			/* partial_inplace */
1201 	 0,			/* src_mask */
1202 	 0xfffc,		/* dst_mask */
1203 	 FALSE),		/* pcrel_offset */
1204 
1205   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1206   HOWTO (R_PPC64_TOC16_DS,	/* type */
1207 	 0,			/* rightshift */
1208 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1209 	 16,			/* bitsize */
1210 	 FALSE,			/* pc_relative */
1211 	 0,			/* bitpos */
1212 	 complain_overflow_signed, /* complain_on_overflow */
1213 	 ppc64_elf_toc_reloc,	/* special_function */
1214 	 "R_PPC64_TOC16_DS",	/* name */
1215 	 FALSE,			/* partial_inplace */
1216 	 0,			/* src_mask */
1217 	 0xfffc,		/* dst_mask */
1218 	 FALSE),		/* pcrel_offset */
1219 
1220   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1221   HOWTO (R_PPC64_TOC16_LO_DS,	/* type */
1222 	 0,			/* rightshift */
1223 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1224 	 16,			/* bitsize */
1225 	 FALSE,			/* pc_relative */
1226 	 0,			/* bitpos */
1227 	 complain_overflow_dont, /* complain_on_overflow */
1228 	 ppc64_elf_toc_reloc,	/* special_function */
1229 	 "R_PPC64_TOC16_LO_DS",	/* name */
1230 	 FALSE,			/* partial_inplace */
1231 	 0,			/* src_mask */
1232 	 0xfffc,		/* dst_mask */
1233 	 FALSE),		/* pcrel_offset */
1234 
1235   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1236   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1237   HOWTO (R_PPC64_PLTGOT16_DS,	/* type */
1238 	 0,			/* rightshift */
1239 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1240 	 16,			/* bitsize */
1241 	 FALSE,			/* pc_relative */
1242 	 0,			/* bitpos */
1243 	 complain_overflow_signed, /* complain_on_overflow */
1244 	 ppc64_elf_unhandled_reloc, /* special_function */
1245 	 "R_PPC64_PLTGOT16_DS",	/* name */
1246 	 FALSE,			/* partial_inplace */
1247 	 0,			/* src_mask */
1248 	 0xfffc,		/* dst_mask */
1249 	 FALSE),		/* pcrel_offset */
1250 
1251   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1252   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1253   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1254 	 0,			/* rightshift */
1255 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1256 	 16,			/* bitsize */
1257 	 FALSE,			/* pc_relative */
1258 	 0,			/* bitpos */
1259 	 complain_overflow_dont, /* complain_on_overflow */
1260 	 ppc64_elf_unhandled_reloc, /* special_function */
1261 	 "R_PPC64_PLTGOT16_LO_DS",/* name */
1262 	 FALSE,			/* partial_inplace */
1263 	 0,			/* src_mask */
1264 	 0xfffc,		/* dst_mask */
1265 	 FALSE),		/* pcrel_offset */
1266 
1267   /* Marker relocs for TLS.  */
1268   HOWTO (R_PPC64_TLS,
1269 	 0,			/* rightshift */
1270 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1271 	 32,			/* bitsize */
1272 	 FALSE,			/* pc_relative */
1273 	 0,			/* bitpos */
1274 	 complain_overflow_dont, /* complain_on_overflow */
1275 	 bfd_elf_generic_reloc,	/* special_function */
1276 	 "R_PPC64_TLS",		/* name */
1277 	 FALSE,			/* partial_inplace */
1278 	 0,			/* src_mask */
1279 	 0,			/* dst_mask */
1280 	 FALSE),		/* pcrel_offset */
1281 
1282   HOWTO (R_PPC64_TLSGD,
1283 	 0,			/* rightshift */
1284 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1285 	 32,			/* bitsize */
1286 	 FALSE,			/* pc_relative */
1287 	 0,			/* bitpos */
1288 	 complain_overflow_dont, /* complain_on_overflow */
1289 	 bfd_elf_generic_reloc,	/* special_function */
1290 	 "R_PPC64_TLSGD",	/* name */
1291 	 FALSE,			/* partial_inplace */
1292 	 0,			/* src_mask */
1293 	 0,			/* dst_mask */
1294 	 FALSE),		/* pcrel_offset */
1295 
1296   HOWTO (R_PPC64_TLSLD,
1297 	 0,			/* rightshift */
1298 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1299 	 32,			/* bitsize */
1300 	 FALSE,			/* pc_relative */
1301 	 0,			/* bitpos */
1302 	 complain_overflow_dont, /* complain_on_overflow */
1303 	 bfd_elf_generic_reloc,	/* special_function */
1304 	 "R_PPC64_TLSLD",	/* name */
1305 	 FALSE,			/* partial_inplace */
1306 	 0,			/* src_mask */
1307 	 0,			/* dst_mask */
1308 	 FALSE),		/* pcrel_offset */
1309 
1310   HOWTO (R_PPC64_TOCSAVE,
1311 	 0,			/* rightshift */
1312 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1313 	 32,			/* bitsize */
1314 	 FALSE,			/* pc_relative */
1315 	 0,			/* bitpos */
1316 	 complain_overflow_dont, /* complain_on_overflow */
1317 	 bfd_elf_generic_reloc,	/* special_function */
1318 	 "R_PPC64_TOCSAVE",	/* name */
1319 	 FALSE,			/* partial_inplace */
1320 	 0,			/* src_mask */
1321 	 0,			/* dst_mask */
1322 	 FALSE),		/* pcrel_offset */
1323 
1324   /* Computes the load module index of the load module that contains the
1325      definition of its TLS sym.  */
1326   HOWTO (R_PPC64_DTPMOD64,
1327 	 0,			/* rightshift */
1328 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
1329 	 64,			/* bitsize */
1330 	 FALSE,			/* pc_relative */
1331 	 0,			/* bitpos */
1332 	 complain_overflow_dont, /* complain_on_overflow */
1333 	 ppc64_elf_unhandled_reloc, /* special_function */
1334 	 "R_PPC64_DTPMOD64",	/* name */
1335 	 FALSE,			/* partial_inplace */
1336 	 0,			/* src_mask */
1337 	 ONES (64),		/* dst_mask */
1338 	 FALSE),		/* pcrel_offset */
1339 
1340   /* Computes a dtv-relative displacement, the difference between the value
1341      of sym+add and the base address of the thread-local storage block that
1342      contains the definition of sym, minus 0x8000.  */
1343   HOWTO (R_PPC64_DTPREL64,
1344 	 0,			/* rightshift */
1345 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
1346 	 64,			/* bitsize */
1347 	 FALSE,			/* pc_relative */
1348 	 0,			/* bitpos */
1349 	 complain_overflow_dont, /* complain_on_overflow */
1350 	 ppc64_elf_unhandled_reloc, /* special_function */
1351 	 "R_PPC64_DTPREL64",	/* name */
1352 	 FALSE,			/* partial_inplace */
1353 	 0,			/* src_mask */
1354 	 ONES (64),		/* dst_mask */
1355 	 FALSE),		/* pcrel_offset */
1356 
1357   /* A 16 bit dtprel reloc.  */
1358   HOWTO (R_PPC64_DTPREL16,
1359 	 0,			/* rightshift */
1360 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1361 	 16,			/* bitsize */
1362 	 FALSE,			/* pc_relative */
1363 	 0,			/* bitpos */
1364 	 complain_overflow_signed, /* complain_on_overflow */
1365 	 ppc64_elf_unhandled_reloc, /* special_function */
1366 	 "R_PPC64_DTPREL16",	/* name */
1367 	 FALSE,			/* partial_inplace */
1368 	 0,			/* src_mask */
1369 	 0xffff,		/* dst_mask */
1370 	 FALSE),		/* pcrel_offset */
1371 
1372   /* Like DTPREL16, but no overflow.  */
1373   HOWTO (R_PPC64_DTPREL16_LO,
1374 	 0,			/* rightshift */
1375 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1376 	 16,			/* bitsize */
1377 	 FALSE,			/* pc_relative */
1378 	 0,			/* bitpos */
1379 	 complain_overflow_dont, /* complain_on_overflow */
1380 	 ppc64_elf_unhandled_reloc, /* special_function */
1381 	 "R_PPC64_DTPREL16_LO",	/* name */
1382 	 FALSE,			/* partial_inplace */
1383 	 0,			/* src_mask */
1384 	 0xffff,		/* dst_mask */
1385 	 FALSE),		/* pcrel_offset */
1386 
1387   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1388   HOWTO (R_PPC64_DTPREL16_HI,
1389 	 16,			/* rightshift */
1390 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1391 	 16,			/* bitsize */
1392 	 FALSE,			/* pc_relative */
1393 	 0,			/* bitpos */
1394 	 complain_overflow_signed, /* complain_on_overflow */
1395 	 ppc64_elf_unhandled_reloc, /* special_function */
1396 	 "R_PPC64_DTPREL16_HI",	/* name */
1397 	 FALSE,			/* partial_inplace */
1398 	 0,			/* src_mask */
1399 	 0xffff,		/* dst_mask */
1400 	 FALSE),		/* pcrel_offset */
1401 
1402   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1403   HOWTO (R_PPC64_DTPREL16_HA,
1404 	 16,			/* rightshift */
1405 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1406 	 16,			/* bitsize */
1407 	 FALSE,			/* pc_relative */
1408 	 0,			/* bitpos */
1409 	 complain_overflow_signed, /* complain_on_overflow */
1410 	 ppc64_elf_unhandled_reloc, /* special_function */
1411 	 "R_PPC64_DTPREL16_HA",	/* name */
1412 	 FALSE,			/* partial_inplace */
1413 	 0,			/* src_mask */
1414 	 0xffff,		/* dst_mask */
1415 	 FALSE),		/* pcrel_offset */
1416 
1417   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1418   HOWTO (R_PPC64_DTPREL16_HIGHER,
1419 	 32,			/* rightshift */
1420 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1421 	 16,			/* bitsize */
1422 	 FALSE,			/* pc_relative */
1423 	 0,			/* bitpos */
1424 	 complain_overflow_dont, /* complain_on_overflow */
1425 	 ppc64_elf_unhandled_reloc, /* special_function */
1426 	 "R_PPC64_DTPREL16_HIGHER", /* name */
1427 	 FALSE,			/* partial_inplace */
1428 	 0,			/* src_mask */
1429 	 0xffff,		/* dst_mask */
1430 	 FALSE),		/* pcrel_offset */
1431 
1432   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1433   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1434 	 32,			/* rightshift */
1435 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1436 	 16,			/* bitsize */
1437 	 FALSE,			/* pc_relative */
1438 	 0,			/* bitpos */
1439 	 complain_overflow_dont, /* complain_on_overflow */
1440 	 ppc64_elf_unhandled_reloc, /* special_function */
1441 	 "R_PPC64_DTPREL16_HIGHERA", /* name */
1442 	 FALSE,			/* partial_inplace */
1443 	 0,			/* src_mask */
1444 	 0xffff,		/* dst_mask */
1445 	 FALSE),		/* pcrel_offset */
1446 
1447   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1448   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1449 	 48,			/* rightshift */
1450 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1451 	 16,			/* bitsize */
1452 	 FALSE,			/* pc_relative */
1453 	 0,			/* bitpos */
1454 	 complain_overflow_dont, /* complain_on_overflow */
1455 	 ppc64_elf_unhandled_reloc, /* special_function */
1456 	 "R_PPC64_DTPREL16_HIGHEST", /* name */
1457 	 FALSE,			/* partial_inplace */
1458 	 0,			/* src_mask */
1459 	 0xffff,		/* dst_mask */
1460 	 FALSE),		/* pcrel_offset */
1461 
1462   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1463   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1464 	 48,			/* rightshift */
1465 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1466 	 16,			/* bitsize */
1467 	 FALSE,			/* pc_relative */
1468 	 0,			/* bitpos */
1469 	 complain_overflow_dont, /* complain_on_overflow */
1470 	 ppc64_elf_unhandled_reloc, /* special_function */
1471 	 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1472 	 FALSE,			/* partial_inplace */
1473 	 0,			/* src_mask */
1474 	 0xffff,		/* dst_mask */
1475 	 FALSE),		/* pcrel_offset */
1476 
1477   /* Like DTPREL16, but for insns with a DS field.  */
1478   HOWTO (R_PPC64_DTPREL16_DS,
1479 	 0,			/* rightshift */
1480 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1481 	 16,			/* bitsize */
1482 	 FALSE,			/* pc_relative */
1483 	 0,			/* bitpos */
1484 	 complain_overflow_signed, /* complain_on_overflow */
1485 	 ppc64_elf_unhandled_reloc, /* special_function */
1486 	 "R_PPC64_DTPREL16_DS",	/* name */
1487 	 FALSE,			/* partial_inplace */
1488 	 0,			/* src_mask */
1489 	 0xfffc,		/* dst_mask */
1490 	 FALSE),		/* pcrel_offset */
1491 
1492   /* Like DTPREL16_DS, but no overflow.  */
1493   HOWTO (R_PPC64_DTPREL16_LO_DS,
1494 	 0,			/* rightshift */
1495 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1496 	 16,			/* bitsize */
1497 	 FALSE,			/* pc_relative */
1498 	 0,			/* bitpos */
1499 	 complain_overflow_dont, /* complain_on_overflow */
1500 	 ppc64_elf_unhandled_reloc, /* special_function */
1501 	 "R_PPC64_DTPREL16_LO_DS", /* name */
1502 	 FALSE,			/* partial_inplace */
1503 	 0,			/* src_mask */
1504 	 0xfffc,		/* dst_mask */
1505 	 FALSE),		/* pcrel_offset */
1506 
1507   /* Computes a tp-relative displacement, the difference between the value of
1508      sym+add and the value of the thread pointer (r13).  */
1509   HOWTO (R_PPC64_TPREL64,
1510 	 0,			/* rightshift */
1511 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
1512 	 64,			/* bitsize */
1513 	 FALSE,			/* pc_relative */
1514 	 0,			/* bitpos */
1515 	 complain_overflow_dont, /* complain_on_overflow */
1516 	 ppc64_elf_unhandled_reloc, /* special_function */
1517 	 "R_PPC64_TPREL64",	/* name */
1518 	 FALSE,			/* partial_inplace */
1519 	 0,			/* src_mask */
1520 	 ONES (64),		/* dst_mask */
1521 	 FALSE),		/* pcrel_offset */
1522 
1523   /* A 16 bit tprel reloc.  */
1524   HOWTO (R_PPC64_TPREL16,
1525 	 0,			/* rightshift */
1526 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1527 	 16,			/* bitsize */
1528 	 FALSE,			/* pc_relative */
1529 	 0,			/* bitpos */
1530 	 complain_overflow_signed, /* complain_on_overflow */
1531 	 ppc64_elf_unhandled_reloc, /* special_function */
1532 	 "R_PPC64_TPREL16",	/* name */
1533 	 FALSE,			/* partial_inplace */
1534 	 0,			/* src_mask */
1535 	 0xffff,		/* dst_mask */
1536 	 FALSE),		/* pcrel_offset */
1537 
1538   /* Like TPREL16, but no overflow.  */
1539   HOWTO (R_PPC64_TPREL16_LO,
1540 	 0,			/* rightshift */
1541 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1542 	 16,			/* bitsize */
1543 	 FALSE,			/* pc_relative */
1544 	 0,			/* bitpos */
1545 	 complain_overflow_dont, /* complain_on_overflow */
1546 	 ppc64_elf_unhandled_reloc, /* special_function */
1547 	 "R_PPC64_TPREL16_LO",	/* name */
1548 	 FALSE,			/* partial_inplace */
1549 	 0,			/* src_mask */
1550 	 0xffff,		/* dst_mask */
1551 	 FALSE),		/* pcrel_offset */
1552 
1553   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1554   HOWTO (R_PPC64_TPREL16_HI,
1555 	 16,			/* rightshift */
1556 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1557 	 16,			/* bitsize */
1558 	 FALSE,			/* pc_relative */
1559 	 0,			/* bitpos */
1560 	 complain_overflow_signed, /* complain_on_overflow */
1561 	 ppc64_elf_unhandled_reloc, /* special_function */
1562 	 "R_PPC64_TPREL16_HI",	/* name */
1563 	 FALSE,			/* partial_inplace */
1564 	 0,			/* src_mask */
1565 	 0xffff,		/* dst_mask */
1566 	 FALSE),		/* pcrel_offset */
1567 
1568   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1569   HOWTO (R_PPC64_TPREL16_HA,
1570 	 16,			/* rightshift */
1571 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1572 	 16,			/* bitsize */
1573 	 FALSE,			/* pc_relative */
1574 	 0,			/* bitpos */
1575 	 complain_overflow_signed, /* complain_on_overflow */
1576 	 ppc64_elf_unhandled_reloc, /* special_function */
1577 	 "R_PPC64_TPREL16_HA",	/* name */
1578 	 FALSE,			/* partial_inplace */
1579 	 0,			/* src_mask */
1580 	 0xffff,		/* dst_mask */
1581 	 FALSE),		/* pcrel_offset */
1582 
1583   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1584   HOWTO (R_PPC64_TPREL16_HIGHER,
1585 	 32,			/* rightshift */
1586 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1587 	 16,			/* bitsize */
1588 	 FALSE,			/* pc_relative */
1589 	 0,			/* bitpos */
1590 	 complain_overflow_dont, /* complain_on_overflow */
1591 	 ppc64_elf_unhandled_reloc, /* special_function */
1592 	 "R_PPC64_TPREL16_HIGHER",	/* name */
1593 	 FALSE,			/* partial_inplace */
1594 	 0,			/* src_mask */
1595 	 0xffff,		/* dst_mask */
1596 	 FALSE),		/* pcrel_offset */
1597 
1598   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1599   HOWTO (R_PPC64_TPREL16_HIGHERA,
1600 	 32,			/* rightshift */
1601 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1602 	 16,			/* bitsize */
1603 	 FALSE,			/* pc_relative */
1604 	 0,			/* bitpos */
1605 	 complain_overflow_dont, /* complain_on_overflow */
1606 	 ppc64_elf_unhandled_reloc, /* special_function */
1607 	 "R_PPC64_TPREL16_HIGHERA", /* name */
1608 	 FALSE,			/* partial_inplace */
1609 	 0,			/* src_mask */
1610 	 0xffff,		/* dst_mask */
1611 	 FALSE),		/* pcrel_offset */
1612 
1613   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1614   HOWTO (R_PPC64_TPREL16_HIGHEST,
1615 	 48,			/* rightshift */
1616 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1617 	 16,			/* bitsize */
1618 	 FALSE,			/* pc_relative */
1619 	 0,			/* bitpos */
1620 	 complain_overflow_dont, /* complain_on_overflow */
1621 	 ppc64_elf_unhandled_reloc, /* special_function */
1622 	 "R_PPC64_TPREL16_HIGHEST", /* name */
1623 	 FALSE,			/* partial_inplace */
1624 	 0,			/* src_mask */
1625 	 0xffff,		/* dst_mask */
1626 	 FALSE),		/* pcrel_offset */
1627 
1628   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1629   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1630 	 48,			/* rightshift */
1631 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1632 	 16,			/* bitsize */
1633 	 FALSE,			/* pc_relative */
1634 	 0,			/* bitpos */
1635 	 complain_overflow_dont, /* complain_on_overflow */
1636 	 ppc64_elf_unhandled_reloc, /* special_function */
1637 	 "R_PPC64_TPREL16_HIGHESTA", /* name */
1638 	 FALSE,			/* partial_inplace */
1639 	 0,			/* src_mask */
1640 	 0xffff,		/* dst_mask */
1641 	 FALSE),		/* pcrel_offset */
1642 
1643   /* Like TPREL16, but for insns with a DS field.  */
1644   HOWTO (R_PPC64_TPREL16_DS,
1645 	 0,			/* rightshift */
1646 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1647 	 16,			/* bitsize */
1648 	 FALSE,			/* pc_relative */
1649 	 0,			/* bitpos */
1650 	 complain_overflow_signed, /* complain_on_overflow */
1651 	 ppc64_elf_unhandled_reloc, /* special_function */
1652 	 "R_PPC64_TPREL16_DS",	/* name */
1653 	 FALSE,			/* partial_inplace */
1654 	 0,			/* src_mask */
1655 	 0xfffc,		/* dst_mask */
1656 	 FALSE),		/* pcrel_offset */
1657 
1658   /* Like TPREL16_DS, but no overflow.  */
1659   HOWTO (R_PPC64_TPREL16_LO_DS,
1660 	 0,			/* rightshift */
1661 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1662 	 16,			/* bitsize */
1663 	 FALSE,			/* pc_relative */
1664 	 0,			/* bitpos */
1665 	 complain_overflow_dont, /* complain_on_overflow */
1666 	 ppc64_elf_unhandled_reloc, /* special_function */
1667 	 "R_PPC64_TPREL16_LO_DS", /* name */
1668 	 FALSE,			/* partial_inplace */
1669 	 0,			/* src_mask */
1670 	 0xfffc,		/* dst_mask */
1671 	 FALSE),		/* pcrel_offset */
1672 
1673   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1674      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1675      to the first entry relative to the TOC base (r2).  */
1676   HOWTO (R_PPC64_GOT_TLSGD16,
1677 	 0,			/* rightshift */
1678 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1679 	 16,			/* bitsize */
1680 	 FALSE,			/* pc_relative */
1681 	 0,			/* bitpos */
1682 	 complain_overflow_signed, /* complain_on_overflow */
1683 	 ppc64_elf_unhandled_reloc, /* special_function */
1684 	 "R_PPC64_GOT_TLSGD16",	/* name */
1685 	 FALSE,			/* partial_inplace */
1686 	 0,			/* src_mask */
1687 	 0xffff,		/* dst_mask */
1688 	 FALSE),		/* pcrel_offset */
1689 
1690   /* Like GOT_TLSGD16, but no overflow.  */
1691   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1692 	 0,			/* rightshift */
1693 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1694 	 16,			/* bitsize */
1695 	 FALSE,			/* pc_relative */
1696 	 0,			/* bitpos */
1697 	 complain_overflow_dont, /* complain_on_overflow */
1698 	 ppc64_elf_unhandled_reloc, /* special_function */
1699 	 "R_PPC64_GOT_TLSGD16_LO", /* name */
1700 	 FALSE,			/* partial_inplace */
1701 	 0,			/* src_mask */
1702 	 0xffff,		/* dst_mask */
1703 	 FALSE),		/* pcrel_offset */
1704 
1705   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1706   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1707 	 16,			/* rightshift */
1708 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1709 	 16,			/* bitsize */
1710 	 FALSE,			/* pc_relative */
1711 	 0,			/* bitpos */
1712 	 complain_overflow_signed, /* complain_on_overflow */
1713 	 ppc64_elf_unhandled_reloc, /* special_function */
1714 	 "R_PPC64_GOT_TLSGD16_HI", /* name */
1715 	 FALSE,			/* partial_inplace */
1716 	 0,			/* src_mask */
1717 	 0xffff,		/* dst_mask */
1718 	 FALSE),		/* pcrel_offset */
1719 
1720   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1721   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1722 	 16,			/* rightshift */
1723 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1724 	 16,			/* bitsize */
1725 	 FALSE,			/* pc_relative */
1726 	 0,			/* bitpos */
1727 	 complain_overflow_signed, /* complain_on_overflow */
1728 	 ppc64_elf_unhandled_reloc, /* special_function */
1729 	 "R_PPC64_GOT_TLSGD16_HA", /* name */
1730 	 FALSE,			/* partial_inplace */
1731 	 0,			/* src_mask */
1732 	 0xffff,		/* dst_mask */
1733 	 FALSE),		/* pcrel_offset */
1734 
1735   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1736      with values (sym+add)@dtpmod and zero, and computes the offset to the
1737      first entry relative to the TOC base (r2).  */
1738   HOWTO (R_PPC64_GOT_TLSLD16,
1739 	 0,			/* rightshift */
1740 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1741 	 16,			/* bitsize */
1742 	 FALSE,			/* pc_relative */
1743 	 0,			/* bitpos */
1744 	 complain_overflow_signed, /* complain_on_overflow */
1745 	 ppc64_elf_unhandled_reloc, /* special_function */
1746 	 "R_PPC64_GOT_TLSLD16",	/* name */
1747 	 FALSE,			/* partial_inplace */
1748 	 0,			/* src_mask */
1749 	 0xffff,		/* dst_mask */
1750 	 FALSE),		/* pcrel_offset */
1751 
1752   /* Like GOT_TLSLD16, but no overflow.  */
1753   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1754 	 0,			/* rightshift */
1755 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1756 	 16,			/* bitsize */
1757 	 FALSE,			/* pc_relative */
1758 	 0,			/* bitpos */
1759 	 complain_overflow_dont, /* complain_on_overflow */
1760 	 ppc64_elf_unhandled_reloc, /* special_function */
1761 	 "R_PPC64_GOT_TLSLD16_LO", /* name */
1762 	 FALSE,			/* partial_inplace */
1763 	 0,			/* src_mask */
1764 	 0xffff,		/* dst_mask */
1765 	 FALSE),		/* pcrel_offset */
1766 
1767   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1768   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1769 	 16,			/* rightshift */
1770 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1771 	 16,			/* bitsize */
1772 	 FALSE,			/* pc_relative */
1773 	 0,			/* bitpos */
1774 	 complain_overflow_signed, /* complain_on_overflow */
1775 	 ppc64_elf_unhandled_reloc, /* special_function */
1776 	 "R_PPC64_GOT_TLSLD16_HI", /* name */
1777 	 FALSE,			/* partial_inplace */
1778 	 0,			/* src_mask */
1779 	 0xffff,		/* dst_mask */
1780 	 FALSE),		/* pcrel_offset */
1781 
1782   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1783   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1784 	 16,			/* rightshift */
1785 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1786 	 16,			/* bitsize */
1787 	 FALSE,			/* pc_relative */
1788 	 0,			/* bitpos */
1789 	 complain_overflow_signed, /* complain_on_overflow */
1790 	 ppc64_elf_unhandled_reloc, /* special_function */
1791 	 "R_PPC64_GOT_TLSLD16_HA", /* name */
1792 	 FALSE,			/* partial_inplace */
1793 	 0,			/* src_mask */
1794 	 0xffff,		/* dst_mask */
1795 	 FALSE),		/* pcrel_offset */
1796 
1797   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1798      the offset to the entry relative to the TOC base (r2).  */
1799   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1800 	 0,			/* rightshift */
1801 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1802 	 16,			/* bitsize */
1803 	 FALSE,			/* pc_relative */
1804 	 0,			/* bitpos */
1805 	 complain_overflow_signed, /* complain_on_overflow */
1806 	 ppc64_elf_unhandled_reloc, /* special_function */
1807 	 "R_PPC64_GOT_DTPREL16_DS", /* name */
1808 	 FALSE,			/* partial_inplace */
1809 	 0,			/* src_mask */
1810 	 0xfffc,		/* dst_mask */
1811 	 FALSE),		/* pcrel_offset */
1812 
1813   /* Like GOT_DTPREL16_DS, but no overflow.  */
1814   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1815 	 0,			/* rightshift */
1816 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1817 	 16,			/* bitsize */
1818 	 FALSE,			/* pc_relative */
1819 	 0,			/* bitpos */
1820 	 complain_overflow_dont, /* complain_on_overflow */
1821 	 ppc64_elf_unhandled_reloc, /* special_function */
1822 	 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1823 	 FALSE,			/* partial_inplace */
1824 	 0,			/* src_mask */
1825 	 0xfffc,		/* dst_mask */
1826 	 FALSE),		/* pcrel_offset */
1827 
1828   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1829   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1830 	 16,			/* rightshift */
1831 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1832 	 16,			/* bitsize */
1833 	 FALSE,			/* pc_relative */
1834 	 0,			/* bitpos */
1835 	 complain_overflow_signed, /* complain_on_overflow */
1836 	 ppc64_elf_unhandled_reloc, /* special_function */
1837 	 "R_PPC64_GOT_DTPREL16_HI", /* name */
1838 	 FALSE,			/* partial_inplace */
1839 	 0,			/* src_mask */
1840 	 0xffff,		/* dst_mask */
1841 	 FALSE),		/* pcrel_offset */
1842 
1843   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1844   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1845 	 16,			/* rightshift */
1846 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1847 	 16,			/* bitsize */
1848 	 FALSE,			/* pc_relative */
1849 	 0,			/* bitpos */
1850 	 complain_overflow_signed, /* complain_on_overflow */
1851 	 ppc64_elf_unhandled_reloc, /* special_function */
1852 	 "R_PPC64_GOT_DTPREL16_HA", /* name */
1853 	 FALSE,			/* partial_inplace */
1854 	 0,			/* src_mask */
1855 	 0xffff,		/* dst_mask */
1856 	 FALSE),		/* pcrel_offset */
1857 
1858   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1859      offset to the entry relative to the TOC base (r2).  */
1860   HOWTO (R_PPC64_GOT_TPREL16_DS,
1861 	 0,			/* rightshift */
1862 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1863 	 16,			/* bitsize */
1864 	 FALSE,			/* pc_relative */
1865 	 0,			/* bitpos */
1866 	 complain_overflow_signed, /* complain_on_overflow */
1867 	 ppc64_elf_unhandled_reloc, /* special_function */
1868 	 "R_PPC64_GOT_TPREL16_DS", /* name */
1869 	 FALSE,			/* partial_inplace */
1870 	 0,			/* src_mask */
1871 	 0xfffc,		/* dst_mask */
1872 	 FALSE),		/* pcrel_offset */
1873 
1874   /* Like GOT_TPREL16_DS, but no overflow.  */
1875   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1876 	 0,			/* rightshift */
1877 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1878 	 16,			/* bitsize */
1879 	 FALSE,			/* pc_relative */
1880 	 0,			/* bitpos */
1881 	 complain_overflow_dont, /* complain_on_overflow */
1882 	 ppc64_elf_unhandled_reloc, /* special_function */
1883 	 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1884 	 FALSE,			/* partial_inplace */
1885 	 0,			/* src_mask */
1886 	 0xfffc,		/* dst_mask */
1887 	 FALSE),		/* pcrel_offset */
1888 
1889   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1890   HOWTO (R_PPC64_GOT_TPREL16_HI,
1891 	 16,			/* rightshift */
1892 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1893 	 16,			/* bitsize */
1894 	 FALSE,			/* pc_relative */
1895 	 0,			/* bitpos */
1896 	 complain_overflow_signed, /* complain_on_overflow */
1897 	 ppc64_elf_unhandled_reloc, /* special_function */
1898 	 "R_PPC64_GOT_TPREL16_HI", /* name */
1899 	 FALSE,			/* partial_inplace */
1900 	 0,			/* src_mask */
1901 	 0xffff,		/* dst_mask */
1902 	 FALSE),		/* pcrel_offset */
1903 
1904   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1905   HOWTO (R_PPC64_GOT_TPREL16_HA,
1906 	 16,			/* rightshift */
1907 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1908 	 16,			/* bitsize */
1909 	 FALSE,			/* pc_relative */
1910 	 0,			/* bitpos */
1911 	 complain_overflow_signed, /* complain_on_overflow */
1912 	 ppc64_elf_unhandled_reloc, /* special_function */
1913 	 "R_PPC64_GOT_TPREL16_HA", /* name */
1914 	 FALSE,			/* partial_inplace */
1915 	 0,			/* src_mask */
1916 	 0xffff,		/* dst_mask */
1917 	 FALSE),		/* pcrel_offset */
1918 
1919   HOWTO (R_PPC64_JMP_IREL,	/* type */
1920 	 0,			/* rightshift */
1921 	 0,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
1922 	 0,			/* bitsize */
1923 	 FALSE,			/* pc_relative */
1924 	 0,			/* bitpos */
1925 	 complain_overflow_dont, /* complain_on_overflow */
1926 	 ppc64_elf_unhandled_reloc, /* special_function */
1927 	 "R_PPC64_JMP_IREL",	/* name */
1928 	 FALSE,			/* partial_inplace */
1929 	 0,			/* src_mask */
1930 	 0,			/* dst_mask */
1931 	 FALSE),		/* pcrel_offset */
1932 
1933   HOWTO (R_PPC64_IRELATIVE,	/* type */
1934 	 0,			/* rightshift */
1935 	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
1936 	 64,			/* bitsize */
1937 	 FALSE,			/* pc_relative */
1938 	 0,			/* bitpos */
1939 	 complain_overflow_dont, /* complain_on_overflow */
1940 	 bfd_elf_generic_reloc,	/* special_function */
1941 	 "R_PPC64_IRELATIVE",	/* name */
1942 	 FALSE,			/* partial_inplace */
1943 	 0,			/* src_mask */
1944 	 ONES (64),		/* dst_mask */
1945 	 FALSE),		/* pcrel_offset */
1946 
1947   /* A 16 bit relative relocation.  */
1948   HOWTO (R_PPC64_REL16,		/* type */
1949 	 0,			/* rightshift */
1950 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1951 	 16,			/* bitsize */
1952 	 TRUE,			/* pc_relative */
1953 	 0,			/* bitpos */
1954 	 complain_overflow_bitfield, /* complain_on_overflow */
1955 	 bfd_elf_generic_reloc,	/* special_function */
1956 	 "R_PPC64_REL16",	/* name */
1957 	 FALSE,			/* partial_inplace */
1958 	 0,			/* src_mask */
1959 	 0xffff,		/* dst_mask */
1960 	 TRUE),			/* pcrel_offset */
1961 
1962   /* A 16 bit relative relocation without overflow.  */
1963   HOWTO (R_PPC64_REL16_LO,	/* type */
1964 	 0,			/* rightshift */
1965 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1966 	 16,			/* bitsize */
1967 	 TRUE,			/* pc_relative */
1968 	 0,			/* bitpos */
1969 	 complain_overflow_dont,/* complain_on_overflow */
1970 	 bfd_elf_generic_reloc,	/* special_function */
1971 	 "R_PPC64_REL16_LO",	/* name */
1972 	 FALSE,			/* partial_inplace */
1973 	 0,			/* src_mask */
1974 	 0xffff,		/* dst_mask */
1975 	 TRUE),			/* pcrel_offset */
1976 
1977   /* The high order 16 bits of a relative address.  */
1978   HOWTO (R_PPC64_REL16_HI,	/* type */
1979 	 16,			/* rightshift */
1980 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1981 	 16,			/* bitsize */
1982 	 TRUE,			/* pc_relative */
1983 	 0,			/* bitpos */
1984 	 complain_overflow_signed, /* complain_on_overflow */
1985 	 bfd_elf_generic_reloc,	/* special_function */
1986 	 "R_PPC64_REL16_HI",	/* name */
1987 	 FALSE,			/* partial_inplace */
1988 	 0,			/* src_mask */
1989 	 0xffff,		/* dst_mask */
1990 	 TRUE),			/* pcrel_offset */
1991 
1992   /* The high order 16 bits of a relative address, plus 1 if the contents of
1993      the low 16 bits, treated as a signed number, is negative.  */
1994   HOWTO (R_PPC64_REL16_HA,	/* type */
1995 	 16,			/* rightshift */
1996 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1997 	 16,			/* bitsize */
1998 	 TRUE,			/* pc_relative */
1999 	 0,			/* bitpos */
2000 	 complain_overflow_signed, /* complain_on_overflow */
2001 	 ppc64_elf_ha_reloc,	/* special_function */
2002 	 "R_PPC64_REL16_HA",	/* name */
2003 	 FALSE,			/* partial_inplace */
2004 	 0,			/* src_mask */
2005 	 0xffff,		/* dst_mask */
2006 	 TRUE),			/* pcrel_offset */
2007 
2008   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2009   HOWTO (R_PPC64_ADDR16_HIGH,	/* type */
2010 	 16,			/* rightshift */
2011 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2012 	 16,			/* bitsize */
2013 	 FALSE,			/* pc_relative */
2014 	 0,			/* bitpos */
2015 	 complain_overflow_dont, /* complain_on_overflow */
2016 	 bfd_elf_generic_reloc,	/* special_function */
2017 	 "R_PPC64_ADDR16_HIGH",	/* name */
2018 	 FALSE,			/* partial_inplace */
2019 	 0,			/* src_mask */
2020 	 0xffff,		/* dst_mask */
2021 	 FALSE),		/* pcrel_offset */
2022 
2023   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2024   HOWTO (R_PPC64_ADDR16_HIGHA,	/* type */
2025 	 16,			/* rightshift */
2026 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2027 	 16,			/* bitsize */
2028 	 FALSE,			/* pc_relative */
2029 	 0,			/* bitpos */
2030 	 complain_overflow_dont, /* complain_on_overflow */
2031 	 ppc64_elf_ha_reloc,	/* special_function */
2032 	 "R_PPC64_ADDR16_HIGHA",	/* name */
2033 	 FALSE,			/* partial_inplace */
2034 	 0,			/* src_mask */
2035 	 0xffff,		/* dst_mask */
2036 	 FALSE),		/* pcrel_offset */
2037 
2038   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2039   HOWTO (R_PPC64_DTPREL16_HIGH,
2040 	 16,			/* rightshift */
2041 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2042 	 16,			/* bitsize */
2043 	 FALSE,			/* pc_relative */
2044 	 0,			/* bitpos */
2045 	 complain_overflow_dont, /* complain_on_overflow */
2046 	 ppc64_elf_unhandled_reloc, /* special_function */
2047 	 "R_PPC64_DTPREL16_HIGH", /* name */
2048 	 FALSE,			/* partial_inplace */
2049 	 0,			/* src_mask */
2050 	 0xffff,		/* dst_mask */
2051 	 FALSE),		/* pcrel_offset */
2052 
2053   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2054   HOWTO (R_PPC64_DTPREL16_HIGHA,
2055 	 16,			/* rightshift */
2056 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2057 	 16,			/* bitsize */
2058 	 FALSE,			/* pc_relative */
2059 	 0,			/* bitpos */
2060 	 complain_overflow_dont, /* complain_on_overflow */
2061 	 ppc64_elf_unhandled_reloc, /* special_function */
2062 	 "R_PPC64_DTPREL16_HIGHA", /* name */
2063 	 FALSE,			/* partial_inplace */
2064 	 0,			/* src_mask */
2065 	 0xffff,		/* dst_mask */
2066 	 FALSE),		/* pcrel_offset */
2067 
2068   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2069   HOWTO (R_PPC64_TPREL16_HIGH,
2070 	 16,			/* rightshift */
2071 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2072 	 16,			/* bitsize */
2073 	 FALSE,			/* pc_relative */
2074 	 0,			/* bitpos */
2075 	 complain_overflow_dont, /* complain_on_overflow */
2076 	 ppc64_elf_unhandled_reloc, /* special_function */
2077 	 "R_PPC64_TPREL16_HIGH",	/* name */
2078 	 FALSE,			/* partial_inplace */
2079 	 0,			/* src_mask */
2080 	 0xffff,		/* dst_mask */
2081 	 FALSE),		/* pcrel_offset */
2082 
2083   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2084   HOWTO (R_PPC64_TPREL16_HIGHA,
2085 	 16,			/* rightshift */
2086 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
2087 	 16,			/* bitsize */
2088 	 FALSE,			/* pc_relative */
2089 	 0,			/* bitpos */
2090 	 complain_overflow_dont, /* complain_on_overflow */
2091 	 ppc64_elf_unhandled_reloc, /* special_function */
2092 	 "R_PPC64_TPREL16_HIGHA",	/* name */
2093 	 FALSE,			/* partial_inplace */
2094 	 0,			/* src_mask */
2095 	 0xffff,		/* dst_mask */
2096 	 FALSE),		/* pcrel_offset */
2097 
2098   /* GNU extension to record C++ vtable hierarchy.  */
2099   HOWTO (R_PPC64_GNU_VTINHERIT,	/* type */
2100 	 0,			/* rightshift */
2101 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
2102 	 0,			/* bitsize */
2103 	 FALSE,			/* pc_relative */
2104 	 0,			/* bitpos */
2105 	 complain_overflow_dont, /* complain_on_overflow */
2106 	 NULL,			/* special_function */
2107 	 "R_PPC64_GNU_VTINHERIT", /* name */
2108 	 FALSE,			/* partial_inplace */
2109 	 0,			/* src_mask */
2110 	 0,			/* dst_mask */
2111 	 FALSE),		/* pcrel_offset */
2112 
2113   /* GNU extension to record C++ vtable member usage.  */
2114   HOWTO (R_PPC64_GNU_VTENTRY,	/* type */
2115 	 0,			/* rightshift */
2116 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
2117 	 0,			/* bitsize */
2118 	 FALSE,			/* pc_relative */
2119 	 0,			/* bitpos */
2120 	 complain_overflow_dont, /* complain_on_overflow */
2121 	 NULL,			/* special_function */
2122 	 "R_PPC64_GNU_VTENTRY",	/* name */
2123 	 FALSE,			/* partial_inplace */
2124 	 0,			/* src_mask */
2125 	 0,			/* dst_mask */
2126 	 FALSE),		/* pcrel_offset */
2127 };
2128 
2129 
2130 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2131    be done.  */
2132 
2133 static void
2134 ppc_howto_init (void)
2135 {
2136   unsigned int i, type;
2137 
2138   for (i = 0;
2139        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2140        i++)
2141     {
2142       type = ppc64_elf_howto_raw[i].type;
2143       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2144 			  / sizeof (ppc64_elf_howto_table[0])));
2145       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2146     }
2147 }
2148 
2149 static reloc_howto_type *
2150 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2151 			     bfd_reloc_code_real_type code)
2152 {
2153   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2154 
2155   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2156     /* Initialize howto table if needed.  */
2157     ppc_howto_init ();
2158 
2159   switch (code)
2160     {
2161     default:
2162       return NULL;
2163 
2164     case BFD_RELOC_NONE:			r = R_PPC64_NONE;
2165       break;
2166     case BFD_RELOC_32:				r = R_PPC64_ADDR32;
2167       break;
2168     case BFD_RELOC_PPC_BA26:			r = R_PPC64_ADDR24;
2169       break;
2170     case BFD_RELOC_16:				r = R_PPC64_ADDR16;
2171       break;
2172     case BFD_RELOC_LO16:			r = R_PPC64_ADDR16_LO;
2173       break;
2174     case BFD_RELOC_HI16:			r = R_PPC64_ADDR16_HI;
2175       break;
2176     case BFD_RELOC_PPC64_ADDR16_HIGH:		r = R_PPC64_ADDR16_HIGH;
2177       break;
2178     case BFD_RELOC_HI16_S:			r = R_PPC64_ADDR16_HA;
2179       break;
2180     case BFD_RELOC_PPC64_ADDR16_HIGHA:		r = R_PPC64_ADDR16_HIGHA;
2181       break;
2182     case BFD_RELOC_PPC_BA16:			r = R_PPC64_ADDR14;
2183       break;
2184     case BFD_RELOC_PPC_BA16_BRTAKEN:		r = R_PPC64_ADDR14_BRTAKEN;
2185       break;
2186     case BFD_RELOC_PPC_BA16_BRNTAKEN:		r = R_PPC64_ADDR14_BRNTAKEN;
2187       break;
2188     case BFD_RELOC_PPC_B26:			r = R_PPC64_REL24;
2189       break;
2190     case BFD_RELOC_PPC_B16:			r = R_PPC64_REL14;
2191       break;
2192     case BFD_RELOC_PPC_B16_BRTAKEN:		r = R_PPC64_REL14_BRTAKEN;
2193       break;
2194     case BFD_RELOC_PPC_B16_BRNTAKEN:		r = R_PPC64_REL14_BRNTAKEN;
2195       break;
2196     case BFD_RELOC_16_GOTOFF:			r = R_PPC64_GOT16;
2197       break;
2198     case BFD_RELOC_LO16_GOTOFF:			r = R_PPC64_GOT16_LO;
2199       break;
2200     case BFD_RELOC_HI16_GOTOFF:			r = R_PPC64_GOT16_HI;
2201       break;
2202     case BFD_RELOC_HI16_S_GOTOFF:		r = R_PPC64_GOT16_HA;
2203       break;
2204     case BFD_RELOC_PPC_COPY:			r = R_PPC64_COPY;
2205       break;
2206     case BFD_RELOC_PPC_GLOB_DAT:		r = R_PPC64_GLOB_DAT;
2207       break;
2208     case BFD_RELOC_32_PCREL:			r = R_PPC64_REL32;
2209       break;
2210     case BFD_RELOC_32_PLTOFF:			r = R_PPC64_PLT32;
2211       break;
2212     case BFD_RELOC_32_PLT_PCREL:		r = R_PPC64_PLTREL32;
2213       break;
2214     case BFD_RELOC_LO16_PLTOFF:			r = R_PPC64_PLT16_LO;
2215       break;
2216     case BFD_RELOC_HI16_PLTOFF:			r = R_PPC64_PLT16_HI;
2217       break;
2218     case BFD_RELOC_HI16_S_PLTOFF:		r = R_PPC64_PLT16_HA;
2219       break;
2220     case BFD_RELOC_16_BASEREL:			r = R_PPC64_SECTOFF;
2221       break;
2222     case BFD_RELOC_LO16_BASEREL:		r = R_PPC64_SECTOFF_LO;
2223       break;
2224     case BFD_RELOC_HI16_BASEREL:		r = R_PPC64_SECTOFF_HI;
2225       break;
2226     case BFD_RELOC_HI16_S_BASEREL:		r = R_PPC64_SECTOFF_HA;
2227       break;
2228     case BFD_RELOC_CTOR:			r = R_PPC64_ADDR64;
2229       break;
2230     case BFD_RELOC_64:				r = R_PPC64_ADDR64;
2231       break;
2232     case BFD_RELOC_PPC64_HIGHER:		r = R_PPC64_ADDR16_HIGHER;
2233       break;
2234     case BFD_RELOC_PPC64_HIGHER_S:		r = R_PPC64_ADDR16_HIGHERA;
2235       break;
2236     case BFD_RELOC_PPC64_HIGHEST:		r = R_PPC64_ADDR16_HIGHEST;
2237       break;
2238     case BFD_RELOC_PPC64_HIGHEST_S:		r = R_PPC64_ADDR16_HIGHESTA;
2239       break;
2240     case BFD_RELOC_64_PCREL:			r = R_PPC64_REL64;
2241       break;
2242     case BFD_RELOC_64_PLTOFF:			r = R_PPC64_PLT64;
2243       break;
2244     case BFD_RELOC_64_PLT_PCREL:		r = R_PPC64_PLTREL64;
2245       break;
2246     case BFD_RELOC_PPC_TOC16:			r = R_PPC64_TOC16;
2247       break;
2248     case BFD_RELOC_PPC64_TOC16_LO:		r = R_PPC64_TOC16_LO;
2249       break;
2250     case BFD_RELOC_PPC64_TOC16_HI:		r = R_PPC64_TOC16_HI;
2251       break;
2252     case BFD_RELOC_PPC64_TOC16_HA:		r = R_PPC64_TOC16_HA;
2253       break;
2254     case BFD_RELOC_PPC64_TOC:			r = R_PPC64_TOC;
2255       break;
2256     case BFD_RELOC_PPC64_PLTGOT16:		r = R_PPC64_PLTGOT16;
2257       break;
2258     case BFD_RELOC_PPC64_PLTGOT16_LO:		r = R_PPC64_PLTGOT16_LO;
2259       break;
2260     case BFD_RELOC_PPC64_PLTGOT16_HI:		r = R_PPC64_PLTGOT16_HI;
2261       break;
2262     case BFD_RELOC_PPC64_PLTGOT16_HA:		r = R_PPC64_PLTGOT16_HA;
2263       break;
2264     case BFD_RELOC_PPC64_ADDR16_DS:		r = R_PPC64_ADDR16_DS;
2265       break;
2266     case BFD_RELOC_PPC64_ADDR16_LO_DS:		r = R_PPC64_ADDR16_LO_DS;
2267       break;
2268     case BFD_RELOC_PPC64_GOT16_DS:		r = R_PPC64_GOT16_DS;
2269       break;
2270     case BFD_RELOC_PPC64_GOT16_LO_DS:		r = R_PPC64_GOT16_LO_DS;
2271       break;
2272     case BFD_RELOC_PPC64_PLT16_LO_DS:		r = R_PPC64_PLT16_LO_DS;
2273       break;
2274     case BFD_RELOC_PPC64_SECTOFF_DS:		r = R_PPC64_SECTOFF_DS;
2275       break;
2276     case BFD_RELOC_PPC64_SECTOFF_LO_DS:		r = R_PPC64_SECTOFF_LO_DS;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_DS:		r = R_PPC64_TOC16_DS;
2279       break;
2280     case BFD_RELOC_PPC64_TOC16_LO_DS:		r = R_PPC64_TOC16_LO_DS;
2281       break;
2282     case BFD_RELOC_PPC64_PLTGOT16_DS:		r = R_PPC64_PLTGOT16_DS;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:	r = R_PPC64_PLTGOT16_LO_DS;
2285       break;
2286     case BFD_RELOC_PPC_TLS:			r = R_PPC64_TLS;
2287       break;
2288     case BFD_RELOC_PPC_TLSGD:			r = R_PPC64_TLSGD;
2289       break;
2290     case BFD_RELOC_PPC_TLSLD:			r = R_PPC64_TLSLD;
2291       break;
2292     case BFD_RELOC_PPC_DTPMOD:			r = R_PPC64_DTPMOD64;
2293       break;
2294     case BFD_RELOC_PPC_TPREL16:			r = R_PPC64_TPREL16;
2295       break;
2296     case BFD_RELOC_PPC_TPREL16_LO:		r = R_PPC64_TPREL16_LO;
2297       break;
2298     case BFD_RELOC_PPC_TPREL16_HI:		r = R_PPC64_TPREL16_HI;
2299       break;
2300     case BFD_RELOC_PPC64_TPREL16_HIGH:		r = R_PPC64_TPREL16_HIGH;
2301       break;
2302     case BFD_RELOC_PPC_TPREL16_HA:		r = R_PPC64_TPREL16_HA;
2303       break;
2304     case BFD_RELOC_PPC64_TPREL16_HIGHA:		r = R_PPC64_TPREL16_HIGHA;
2305       break;
2306     case BFD_RELOC_PPC_TPREL:			r = R_PPC64_TPREL64;
2307       break;
2308     case BFD_RELOC_PPC_DTPREL16:		r = R_PPC64_DTPREL16;
2309       break;
2310     case BFD_RELOC_PPC_DTPREL16_LO:		r = R_PPC64_DTPREL16_LO;
2311       break;
2312     case BFD_RELOC_PPC_DTPREL16_HI:		r = R_PPC64_DTPREL16_HI;
2313       break;
2314     case BFD_RELOC_PPC64_DTPREL16_HIGH:		r = R_PPC64_DTPREL16_HIGH;
2315       break;
2316     case BFD_RELOC_PPC_DTPREL16_HA:		r = R_PPC64_DTPREL16_HA;
2317       break;
2318     case BFD_RELOC_PPC64_DTPREL16_HIGHA:	r = R_PPC64_DTPREL16_HIGHA;
2319       break;
2320     case BFD_RELOC_PPC_DTPREL:			r = R_PPC64_DTPREL64;
2321       break;
2322     case BFD_RELOC_PPC_GOT_TLSGD16:		r = R_PPC64_GOT_TLSGD16;
2323       break;
2324     case BFD_RELOC_PPC_GOT_TLSGD16_LO:		r = R_PPC64_GOT_TLSGD16_LO;
2325       break;
2326     case BFD_RELOC_PPC_GOT_TLSGD16_HI:		r = R_PPC64_GOT_TLSGD16_HI;
2327       break;
2328     case BFD_RELOC_PPC_GOT_TLSGD16_HA:		r = R_PPC64_GOT_TLSGD16_HA;
2329       break;
2330     case BFD_RELOC_PPC_GOT_TLSLD16:		r = R_PPC64_GOT_TLSLD16;
2331       break;
2332     case BFD_RELOC_PPC_GOT_TLSLD16_LO:		r = R_PPC64_GOT_TLSLD16_LO;
2333       break;
2334     case BFD_RELOC_PPC_GOT_TLSLD16_HI:		r = R_PPC64_GOT_TLSLD16_HI;
2335       break;
2336     case BFD_RELOC_PPC_GOT_TLSLD16_HA:		r = R_PPC64_GOT_TLSLD16_HA;
2337       break;
2338     case BFD_RELOC_PPC_GOT_TPREL16:		r = R_PPC64_GOT_TPREL16_DS;
2339       break;
2340     case BFD_RELOC_PPC_GOT_TPREL16_LO:		r = R_PPC64_GOT_TPREL16_LO_DS;
2341       break;
2342     case BFD_RELOC_PPC_GOT_TPREL16_HI:		r = R_PPC64_GOT_TPREL16_HI;
2343       break;
2344     case BFD_RELOC_PPC_GOT_TPREL16_HA:		r = R_PPC64_GOT_TPREL16_HA;
2345       break;
2346     case BFD_RELOC_PPC_GOT_DTPREL16:		r = R_PPC64_GOT_DTPREL16_DS;
2347       break;
2348     case BFD_RELOC_PPC_GOT_DTPREL16_LO:		r = R_PPC64_GOT_DTPREL16_LO_DS;
2349       break;
2350     case BFD_RELOC_PPC_GOT_DTPREL16_HI:		r = R_PPC64_GOT_DTPREL16_HI;
2351       break;
2352     case BFD_RELOC_PPC_GOT_DTPREL16_HA:		r = R_PPC64_GOT_DTPREL16_HA;
2353       break;
2354     case BFD_RELOC_PPC64_TPREL16_DS:		r = R_PPC64_TPREL16_DS;
2355       break;
2356     case BFD_RELOC_PPC64_TPREL16_LO_DS:		r = R_PPC64_TPREL16_LO_DS;
2357       break;
2358     case BFD_RELOC_PPC64_TPREL16_HIGHER:	r = R_PPC64_TPREL16_HIGHER;
2359       break;
2360     case BFD_RELOC_PPC64_TPREL16_HIGHERA:	r = R_PPC64_TPREL16_HIGHERA;
2361       break;
2362     case BFD_RELOC_PPC64_TPREL16_HIGHEST:	r = R_PPC64_TPREL16_HIGHEST;
2363       break;
2364     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:	r = R_PPC64_TPREL16_HIGHESTA;
2365       break;
2366     case BFD_RELOC_PPC64_DTPREL16_DS:		r = R_PPC64_DTPREL16_DS;
2367       break;
2368     case BFD_RELOC_PPC64_DTPREL16_LO_DS:	r = R_PPC64_DTPREL16_LO_DS;
2369       break;
2370     case BFD_RELOC_PPC64_DTPREL16_HIGHER:	r = R_PPC64_DTPREL16_HIGHER;
2371       break;
2372     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:	r = R_PPC64_DTPREL16_HIGHERA;
2373       break;
2374     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:	r = R_PPC64_DTPREL16_HIGHEST;
2375       break;
2376     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:	r = R_PPC64_DTPREL16_HIGHESTA;
2377       break;
2378     case BFD_RELOC_16_PCREL:			r = R_PPC64_REL16;
2379       break;
2380     case BFD_RELOC_LO16_PCREL:			r = R_PPC64_REL16_LO;
2381       break;
2382     case BFD_RELOC_HI16_PCREL:			r = R_PPC64_REL16_HI;
2383       break;
2384     case BFD_RELOC_HI16_S_PCREL:		r = R_PPC64_REL16_HA;
2385       break;
2386     case BFD_RELOC_VTABLE_INHERIT:		r = R_PPC64_GNU_VTINHERIT;
2387       break;
2388     case BFD_RELOC_VTABLE_ENTRY:		r = R_PPC64_GNU_VTENTRY;
2389       break;
2390     }
2391 
2392   return ppc64_elf_howto_table[r];
2393 };
2394 
2395 static reloc_howto_type *
2396 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2397 			     const char *r_name)
2398 {
2399   unsigned int i;
2400 
2401   for (i = 0;
2402        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2403        i++)
2404     if (ppc64_elf_howto_raw[i].name != NULL
2405 	&& strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2406       return &ppc64_elf_howto_raw[i];
2407 
2408   return NULL;
2409 }
2410 
2411 /* Set the howto pointer for a PowerPC ELF reloc.  */
2412 
2413 static void
2414 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2415 			 Elf_Internal_Rela *dst)
2416 {
2417   unsigned int type;
2418 
2419   /* Initialize howto table if needed.  */
2420   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2421     ppc_howto_init ();
2422 
2423   type = ELF64_R_TYPE (dst->r_info);
2424   if (type >= (sizeof (ppc64_elf_howto_table)
2425 	       / sizeof (ppc64_elf_howto_table[0])))
2426     {
2427       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2428 			     abfd, (int) type);
2429       type = R_PPC64_NONE;
2430     }
2431   cache_ptr->howto = ppc64_elf_howto_table[type];
2432 }
2433 
2434 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2435 
2436 static bfd_reloc_status_type
2437 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2438 		    void *data, asection *input_section,
2439 		    bfd *output_bfd, char **error_message)
2440 {
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446 				  input_section, output_bfd, error_message);
2447 
2448   /* Adjust the addend for sign extension of the low 16 bits.
2449      We won't actually be using the low 16 bits, so trashing them
2450      doesn't matter.  */
2451   reloc_entry->addend += 0x8000;
2452   return bfd_reloc_continue;
2453 }
2454 
2455 static bfd_reloc_status_type
2456 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2457 			void *data, asection *input_section,
2458 			bfd *output_bfd, char **error_message)
2459 {
2460   if (output_bfd != NULL)
2461     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462 				  input_section, output_bfd, error_message);
2463 
2464   if (strcmp (symbol->section->name, ".opd") == 0
2465       && (symbol->section->owner->flags & DYNAMIC) == 0)
2466     {
2467       bfd_vma dest = opd_entry_value (symbol->section,
2468 				      symbol->value + reloc_entry->addend,
2469 				      NULL, NULL, FALSE);
2470       if (dest != (bfd_vma) -1)
2471 	reloc_entry->addend = dest - (symbol->value
2472 				      + symbol->section->output_section->vma
2473 				      + symbol->section->output_offset);
2474     }
2475   return bfd_reloc_continue;
2476 }
2477 
2478 static bfd_reloc_status_type
2479 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2480 			 void *data, asection *input_section,
2481 			 bfd *output_bfd, char **error_message)
2482 {
2483   long insn;
2484   enum elf_ppc64_reloc_type r_type;
2485   bfd_size_type octets;
2486   /* Assume 'at' branch hints.  */
2487   bfd_boolean is_isa_v2 = TRUE;
2488 
2489   /* If this is a relocatable link (output_bfd test tells us), just
2490      call the generic function.  Any adjustment will be done at final
2491      link time.  */
2492   if (output_bfd != NULL)
2493     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494 				  input_section, output_bfd, error_message);
2495 
2496   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2497   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2498   insn &= ~(0x01 << 21);
2499   r_type = reloc_entry->howto->type;
2500   if (r_type == R_PPC64_ADDR14_BRTAKEN
2501       || r_type == R_PPC64_REL14_BRTAKEN)
2502     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2503 
2504   if (is_isa_v2)
2505     {
2506       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2507 	 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2508 	 for branch on CTR insns (BO == 1a00t or 1a01t).  */
2509       if ((insn & (0x14 << 21)) == (0x04 << 21))
2510 	insn |= 0x02 << 21;
2511       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2512 	insn |= 0x08 << 21;
2513       else
2514 	goto out;
2515     }
2516   else
2517     {
2518       bfd_vma target = 0;
2519       bfd_vma from;
2520 
2521       if (!bfd_is_com_section (symbol->section))
2522 	target = symbol->value;
2523       target += symbol->section->output_section->vma;
2524       target += symbol->section->output_offset;
2525       target += reloc_entry->addend;
2526 
2527       from = (reloc_entry->address
2528 	      + input_section->output_offset
2529 	      + input_section->output_section->vma);
2530 
2531       /* Invert 'y' bit if not the default.  */
2532       if ((bfd_signed_vma) (target - from) < 0)
2533 	insn ^= 0x01 << 21;
2534     }
2535   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2536  out:
2537   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2538 				 input_section, output_bfd, error_message);
2539 }
2540 
2541 static bfd_reloc_status_type
2542 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2543 			 void *data, asection *input_section,
2544 			 bfd *output_bfd, char **error_message)
2545 {
2546   /* If this is a relocatable link (output_bfd test tells us), just
2547      call the generic function.  Any adjustment will be done at final
2548      link time.  */
2549   if (output_bfd != NULL)
2550     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2551 				  input_section, output_bfd, error_message);
2552 
2553   /* Subtract the symbol section base address.  */
2554   reloc_entry->addend -= symbol->section->output_section->vma;
2555   return bfd_reloc_continue;
2556 }
2557 
2558 static bfd_reloc_status_type
2559 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2560 			    void *data, asection *input_section,
2561 			    bfd *output_bfd, char **error_message)
2562 {
2563   /* If this is a relocatable link (output_bfd test tells us), just
2564      call the generic function.  Any adjustment will be done at final
2565      link time.  */
2566   if (output_bfd != NULL)
2567     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2568 				  input_section, output_bfd, error_message);
2569 
2570   /* Subtract the symbol section base address.  */
2571   reloc_entry->addend -= symbol->section->output_section->vma;
2572 
2573   /* Adjust the addend for sign extension of the low 16 bits.  */
2574   reloc_entry->addend += 0x8000;
2575   return bfd_reloc_continue;
2576 }
2577 
2578 static bfd_reloc_status_type
2579 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2580 		     void *data, asection *input_section,
2581 		     bfd *output_bfd, char **error_message)
2582 {
2583   bfd_vma TOCstart;
2584 
2585   /* If this is a relocatable link (output_bfd test tells us), just
2586      call the generic function.  Any adjustment will be done at final
2587      link time.  */
2588   if (output_bfd != NULL)
2589     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590 				  input_section, output_bfd, error_message);
2591 
2592   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2593   if (TOCstart == 0)
2594     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2595 
2596   /* Subtract the TOC base address.  */
2597   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2598   return bfd_reloc_continue;
2599 }
2600 
2601 static bfd_reloc_status_type
2602 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603 			void *data, asection *input_section,
2604 			bfd *output_bfd, char **error_message)
2605 {
2606   bfd_vma TOCstart;
2607 
2608   /* If this is a relocatable link (output_bfd test tells us), just
2609      call the generic function.  Any adjustment will be done at final
2610      link time.  */
2611   if (output_bfd != NULL)
2612     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613 				  input_section, output_bfd, error_message);
2614 
2615   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2616   if (TOCstart == 0)
2617     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2618 
2619   /* Subtract the TOC base address.  */
2620   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2621 
2622   /* Adjust the addend for sign extension of the low 16 bits.  */
2623   reloc_entry->addend += 0x8000;
2624   return bfd_reloc_continue;
2625 }
2626 
2627 static bfd_reloc_status_type
2628 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2629 		       void *data, asection *input_section,
2630 		       bfd *output_bfd, char **error_message)
2631 {
2632   bfd_vma TOCstart;
2633   bfd_size_type octets;
2634 
2635   /* If this is a relocatable link (output_bfd test tells us), just
2636      call the generic function.  Any adjustment will be done at final
2637      link time.  */
2638   if (output_bfd != NULL)
2639     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2640 				  input_section, output_bfd, error_message);
2641 
2642   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2643   if (TOCstart == 0)
2644     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2645 
2646   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2647   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2648   return bfd_reloc_ok;
2649 }
2650 
2651 static bfd_reloc_status_type
2652 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2653 			   void *data, asection *input_section,
2654 			   bfd *output_bfd, char **error_message)
2655 {
2656   /* If this is a relocatable link (output_bfd test tells us), just
2657      call the generic function.  Any adjustment will be done at final
2658      link time.  */
2659   if (output_bfd != NULL)
2660     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2661 				  input_section, output_bfd, error_message);
2662 
2663   if (error_message != NULL)
2664     {
2665       static char buf[60];
2666       sprintf (buf, "generic linker can't handle %s",
2667 	       reloc_entry->howto->name);
2668       *error_message = buf;
2669     }
2670   return bfd_reloc_dangerous;
2671 }
2672 
2673 /* Track GOT entries needed for a given symbol.  We might need more
2674    than one got entry per symbol.  */
2675 struct got_entry
2676 {
2677   struct got_entry *next;
2678 
2679   /* The symbol addend that we'll be placing in the GOT.  */
2680   bfd_vma addend;
2681 
2682   /* Unlike other ELF targets, we use separate GOT entries for the same
2683      symbol referenced from different input files.  This is to support
2684      automatic multiple TOC/GOT sections, where the TOC base can vary
2685      from one input file to another.  After partitioning into TOC groups
2686      we merge entries within the group.
2687 
2688      Point to the BFD owning this GOT entry.  */
2689   bfd *owner;
2690 
2691   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2692      TLS_TPREL or TLS_DTPREL for tls entries.  */
2693   unsigned char tls_type;
2694 
2695   /* Non-zero if got.ent points to real entry.  */
2696   unsigned char is_indirect;
2697 
2698   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2699   union
2700     {
2701       bfd_signed_vma refcount;
2702       bfd_vma offset;
2703       struct got_entry *ent;
2704     } got;
2705 };
2706 
2707 /* The same for PLT.  */
2708 struct plt_entry
2709 {
2710   struct plt_entry *next;
2711 
2712   bfd_vma addend;
2713 
2714   union
2715     {
2716       bfd_signed_vma refcount;
2717       bfd_vma offset;
2718     } plt;
2719 };
2720 
2721 struct ppc64_elf_obj_tdata
2722 {
2723   struct elf_obj_tdata elf;
2724 
2725   /* Shortcuts to dynamic linker sections.  */
2726   asection *got;
2727   asection *relgot;
2728 
2729   /* Used during garbage collection.  We attach global symbols defined
2730      on removed .opd entries to this section so that the sym is removed.  */
2731   asection *deleted_section;
2732 
2733   /* TLS local dynamic got entry handling.  Support for multiple GOT
2734      sections means we potentially need one of these for each input bfd.  */
2735   struct got_entry tlsld_got;
2736 
2737   union {
2738     /* A copy of relocs before they are modified for --emit-relocs.  */
2739     Elf_Internal_Rela *relocs;
2740 
2741     /* Section contents.  */
2742     bfd_byte *contents;
2743   } opd;
2744 
2745   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2746      the reloc to be in the range -32768 to 32767.  */
2747   unsigned int has_small_toc_reloc : 1;
2748 
2749   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2750      instruction not one we handle.  */
2751   unsigned int unexpected_toc_insn : 1;
2752 };
2753 
2754 #define ppc64_elf_tdata(bfd) \
2755   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2756 
2757 #define ppc64_tlsld_got(bfd) \
2758   (&ppc64_elf_tdata (bfd)->tlsld_got)
2759 
2760 #define is_ppc64_elf(bfd) \
2761   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2762    && elf_object_id (bfd) == PPC64_ELF_DATA)
2763 
2764 /* Override the generic function because we store some extras.  */
2765 
2766 static bfd_boolean
2767 ppc64_elf_mkobject (bfd *abfd)
2768 {
2769   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2770 				  PPC64_ELF_DATA);
2771 }
2772 
2773 /* Fix bad default arch selected for a 64 bit input bfd when the
2774    default is 32 bit.  */
2775 
2776 static bfd_boolean
2777 ppc64_elf_object_p (bfd *abfd)
2778 {
2779   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2780     {
2781       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2782 
2783       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2784 	{
2785 	  /* Relies on arch after 32 bit default being 64 bit default.  */
2786 	  abfd->arch_info = abfd->arch_info->next;
2787 	  BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2788 	}
2789     }
2790   return TRUE;
2791 }
2792 
2793 /* Support for core dump NOTE sections.  */
2794 
2795 static bfd_boolean
2796 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2797 {
2798   size_t offset, size;
2799 
2800   if (note->descsz != 504)
2801     return FALSE;
2802 
2803   /* pr_cursig */
2804   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2805 
2806   /* pr_pid */
2807   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2808 
2809   /* pr_reg */
2810   offset = 112;
2811   size = 384;
2812 
2813   /* Make a ".reg/999" section.  */
2814   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2815 					  size, note->descpos + offset);
2816 }
2817 
2818 static bfd_boolean
2819 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2820 {
2821   if (note->descsz != 136)
2822     return FALSE;
2823 
2824   elf_tdata (abfd)->core->pid
2825     = bfd_get_32 (abfd, note->descdata + 24);
2826   elf_tdata (abfd)->core->program
2827     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2828   elf_tdata (abfd)->core->command
2829     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2830 
2831   return TRUE;
2832 }
2833 
2834 static char *
2835 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2836 			   ...)
2837 {
2838   switch (note_type)
2839     {
2840     default:
2841       return NULL;
2842 
2843     case NT_PRPSINFO:
2844       {
2845 	char data[136];
2846 	va_list ap;
2847 
2848 	va_start (ap, note_type);
2849 	memset (data, 0, sizeof (data));
2850 	strncpy (data + 40, va_arg (ap, const char *), 16);
2851 	strncpy (data + 56, va_arg (ap, const char *), 80);
2852 	va_end (ap);
2853 	return elfcore_write_note (abfd, buf, bufsiz,
2854 				   "CORE", note_type, data, sizeof (data));
2855       }
2856 
2857     case NT_PRSTATUS:
2858       {
2859 	char data[504];
2860 	va_list ap;
2861 	long pid;
2862 	int cursig;
2863 	const void *greg;
2864 
2865 	va_start (ap, note_type);
2866 	memset (data, 0, 112);
2867 	pid = va_arg (ap, long);
2868 	bfd_put_32 (abfd, pid, data + 32);
2869 	cursig = va_arg (ap, int);
2870 	bfd_put_16 (abfd, cursig, data + 12);
2871 	greg = va_arg (ap, const void *);
2872 	memcpy (data + 112, greg, 384);
2873 	memset (data + 496, 0, 8);
2874 	va_end (ap);
2875 	return elfcore_write_note (abfd, buf, bufsiz,
2876 				   "CORE", note_type, data, sizeof (data));
2877       }
2878     }
2879 }
2880 
2881 /* Add extra PPC sections.  */
2882 
2883 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2884 {
2885   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2886   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2887   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2888   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2891   { NULL,                     0,  0, 0,            0 }
2892 };
2893 
2894 enum _ppc64_sec_type {
2895   sec_normal = 0,
2896   sec_opd = 1,
2897   sec_toc = 2
2898 };
2899 
2900 struct _ppc64_elf_section_data
2901 {
2902   struct bfd_elf_section_data elf;
2903 
2904   union
2905   {
2906     /* An array with one entry for each opd function descriptor.  */
2907     struct _opd_sec_data
2908     {
2909       /* Points to the function code section for local opd entries.  */
2910       asection **func_sec;
2911 
2912       /* After editing .opd, adjust references to opd local syms.  */
2913       long *adjust;
2914     } opd;
2915 
2916     /* An array for toc sections, indexed by offset/8.  */
2917     struct _toc_sec_data
2918     {
2919       /* Specifies the relocation symbol index used at a given toc offset.  */
2920       unsigned *symndx;
2921 
2922       /* And the relocation addend.  */
2923       bfd_vma *add;
2924     } toc;
2925   } u;
2926 
2927   enum _ppc64_sec_type sec_type:2;
2928 
2929   /* Flag set when small branches are detected.  Used to
2930      select suitable defaults for the stub group size.  */
2931   unsigned int has_14bit_branch:1;
2932 };
2933 
2934 #define ppc64_elf_section_data(sec) \
2935   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2936 
2937 static bfd_boolean
2938 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2939 {
2940   if (!sec->used_by_bfd)
2941     {
2942       struct _ppc64_elf_section_data *sdata;
2943       bfd_size_type amt = sizeof (*sdata);
2944 
2945       sdata = bfd_zalloc (abfd, amt);
2946       if (sdata == NULL)
2947 	return FALSE;
2948       sec->used_by_bfd = sdata;
2949     }
2950 
2951   return _bfd_elf_new_section_hook (abfd, sec);
2952 }
2953 
2954 static struct _opd_sec_data *
2955 get_opd_info (asection * sec)
2956 {
2957   if (sec != NULL
2958       && ppc64_elf_section_data (sec) != NULL
2959       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2960     return &ppc64_elf_section_data (sec)->u.opd;
2961   return NULL;
2962 }
2963 
2964 static inline int
2965 abiversion (bfd *abfd)
2966 {
2967   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2968 }
2969 
2970 static inline void
2971 set_abiversion (bfd *abfd, int ver)
2972 {
2973   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2974   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2975 }
2976 
2977 /* Parameters for the qsort hook.  */
2978 static bfd_boolean synthetic_relocatable;
2979 
2980 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2981 
2982 static int
2983 compare_symbols (const void *ap, const void *bp)
2984 {
2985   const asymbol *a = * (const asymbol **) ap;
2986   const asymbol *b = * (const asymbol **) bp;
2987 
2988   /* Section symbols first.  */
2989   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2990     return -1;
2991   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2992     return 1;
2993 
2994   /* then .opd symbols.  */
2995   if (strcmp (a->section->name, ".opd") == 0
2996       && strcmp (b->section->name, ".opd") != 0)
2997     return -1;
2998   if (strcmp (a->section->name, ".opd") != 0
2999       && strcmp (b->section->name, ".opd") == 0)
3000     return 1;
3001 
3002   /* then other code symbols.  */
3003   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3004       == (SEC_CODE | SEC_ALLOC)
3005       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3006 	 != (SEC_CODE | SEC_ALLOC))
3007     return -1;
3008 
3009   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3010       != (SEC_CODE | SEC_ALLOC)
3011       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3012 	 == (SEC_CODE | SEC_ALLOC))
3013     return 1;
3014 
3015   if (synthetic_relocatable)
3016     {
3017       if (a->section->id < b->section->id)
3018 	return -1;
3019 
3020       if (a->section->id > b->section->id)
3021 	return 1;
3022     }
3023 
3024   if (a->value + a->section->vma < b->value + b->section->vma)
3025     return -1;
3026 
3027   if (a->value + a->section->vma > b->value + b->section->vma)
3028     return 1;
3029 
3030   /* For syms with the same value, prefer strong dynamic global function
3031      syms over other syms.  */
3032   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3033     return -1;
3034 
3035   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3036     return 1;
3037 
3038   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3039     return -1;
3040 
3041   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3042     return 1;
3043 
3044   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3045     return -1;
3046 
3047   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3048     return 1;
3049 
3050   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3051     return -1;
3052 
3053   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3054     return 1;
3055 
3056   return 0;
3057 }
3058 
3059 /* Search SYMS for a symbol of the given VALUE.  */
3060 
3061 static asymbol *
3062 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3063 {
3064   long mid;
3065 
3066   if (id == -1)
3067     {
3068       while (lo < hi)
3069 	{
3070 	  mid = (lo + hi) >> 1;
3071 	  if (syms[mid]->value + syms[mid]->section->vma < value)
3072 	    lo = mid + 1;
3073 	  else if (syms[mid]->value + syms[mid]->section->vma > value)
3074 	    hi = mid;
3075 	  else
3076 	    return syms[mid];
3077 	}
3078     }
3079   else
3080     {
3081       while (lo < hi)
3082 	{
3083 	  mid = (lo + hi) >> 1;
3084 	  if (syms[mid]->section->id < id)
3085 	    lo = mid + 1;
3086 	  else if (syms[mid]->section->id > id)
3087 	    hi = mid;
3088 	  else if (syms[mid]->value < value)
3089 	    lo = mid + 1;
3090 	  else if (syms[mid]->value > value)
3091 	    hi = mid;
3092 	  else
3093 	    return syms[mid];
3094 	}
3095     }
3096   return NULL;
3097 }
3098 
3099 static bfd_boolean
3100 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3101 {
3102   bfd_vma vma = *(bfd_vma *) ptr;
3103   return ((section->flags & SEC_ALLOC) != 0
3104 	  && section->vma <= vma
3105 	  && vma < section->vma + section->size);
3106 }
3107 
3108 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3109    entry syms.  Also generate @plt symbols for the glink branch table.  */
3110 
3111 static long
3112 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3113 				long static_count, asymbol **static_syms,
3114 				long dyn_count, asymbol **dyn_syms,
3115 				asymbol **ret)
3116 {
3117   asymbol *s;
3118   long i;
3119   long count;
3120   char *names;
3121   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3122   asection *opd = NULL;
3123   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3124   asymbol **syms;
3125   int abi = abiversion (abfd);
3126 
3127   *ret = NULL;
3128 
3129   if (abi < 2)
3130     {
3131       opd = bfd_get_section_by_name (abfd, ".opd");
3132       if (opd == NULL && abi == 1)
3133 	return 0;
3134     }
3135 
3136   symcount = static_count;
3137   if (!relocatable)
3138     symcount += dyn_count;
3139   if (symcount == 0)
3140     return 0;
3141 
3142   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3143   if (syms == NULL)
3144     return -1;
3145 
3146   if (!relocatable && static_count != 0 && dyn_count != 0)
3147     {
3148       /* Use both symbol tables.  */
3149       memcpy (syms, static_syms, static_count * sizeof (*syms));
3150       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3151     }
3152   else if (!relocatable && static_count == 0)
3153     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3154   else
3155     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3156 
3157   synthetic_relocatable = relocatable;
3158   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3159 
3160   if (!relocatable && symcount > 1)
3161     {
3162       long j;
3163       /* Trim duplicate syms, since we may have merged the normal and
3164 	 dynamic symbols.  Actually, we only care about syms that have
3165 	 different values, so trim any with the same value.  */
3166       for (i = 1, j = 1; i < symcount; ++i)
3167 	if (syms[i - 1]->value + syms[i - 1]->section->vma
3168 	    != syms[i]->value + syms[i]->section->vma)
3169 	  syms[j++] = syms[i];
3170       symcount = j;
3171     }
3172 
3173   i = 0;
3174   if (strcmp (syms[i]->section->name, ".opd") == 0)
3175     ++i;
3176   codesecsym = i;
3177 
3178   for (; i < symcount; ++i)
3179     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3180 	 != (SEC_CODE | SEC_ALLOC))
3181 	|| (syms[i]->flags & BSF_SECTION_SYM) == 0)
3182       break;
3183   codesecsymend = i;
3184 
3185   for (; i < symcount; ++i)
3186     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3187       break;
3188   secsymend = i;
3189 
3190   for (; i < symcount; ++i)
3191     if (strcmp (syms[i]->section->name, ".opd") != 0)
3192       break;
3193   opdsymend = i;
3194 
3195   for (; i < symcount; ++i)
3196     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3197 	!= (SEC_CODE | SEC_ALLOC))
3198       break;
3199   symcount = i;
3200 
3201   count = 0;
3202 
3203   if (relocatable)
3204     {
3205       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3206       arelent *r;
3207       size_t size;
3208       long relcount;
3209 
3210       if (opdsymend == secsymend)
3211 	goto done;
3212 
3213       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3214       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3215       if (relcount == 0)
3216 	goto done;
3217 
3218       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3219 	{
3220 	  count = -1;
3221 	  goto done;
3222 	}
3223 
3224       size = 0;
3225       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3226 	{
3227 	  asymbol *sym;
3228 
3229 	  while (r < opd->relocation + relcount
3230 		 && r->address < syms[i]->value + opd->vma)
3231 	    ++r;
3232 
3233 	  if (r == opd->relocation + relcount)
3234 	    break;
3235 
3236 	  if (r->address != syms[i]->value + opd->vma)
3237 	    continue;
3238 
3239 	  if (r->howto->type != R_PPC64_ADDR64)
3240 	    continue;
3241 
3242 	  sym = *r->sym_ptr_ptr;
3243 	  if (!sym_exists_at (syms, opdsymend, symcount,
3244 			      sym->section->id, sym->value + r->addend))
3245 	    {
3246 	      ++count;
3247 	      size += sizeof (asymbol);
3248 	      size += strlen (syms[i]->name) + 2;
3249 	    }
3250 	}
3251 
3252       s = *ret = bfd_malloc (size);
3253       if (s == NULL)
3254 	{
3255 	  count = -1;
3256 	  goto done;
3257 	}
3258 
3259       names = (char *) (s + count);
3260 
3261       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3262 	{
3263 	  asymbol *sym;
3264 
3265 	  while (r < opd->relocation + relcount
3266 		 && r->address < syms[i]->value + opd->vma)
3267 	    ++r;
3268 
3269 	  if (r == opd->relocation + relcount)
3270 	    break;
3271 
3272 	  if (r->address != syms[i]->value + opd->vma)
3273 	    continue;
3274 
3275 	  if (r->howto->type != R_PPC64_ADDR64)
3276 	    continue;
3277 
3278 	  sym = *r->sym_ptr_ptr;
3279 	  if (!sym_exists_at (syms, opdsymend, symcount,
3280 			      sym->section->id, sym->value + r->addend))
3281 	    {
3282 	      size_t len;
3283 
3284 	      *s = *syms[i];
3285 	      s->flags |= BSF_SYNTHETIC;
3286 	      s->section = sym->section;
3287 	      s->value = sym->value + r->addend;
3288 	      s->name = names;
3289 	      *names++ = '.';
3290 	      len = strlen (syms[i]->name);
3291 	      memcpy (names, syms[i]->name, len + 1);
3292 	      names += len + 1;
3293 	      /* Have udata.p point back to the original symbol this
3294 		 synthetic symbol was derived from.  */
3295 	      s->udata.p = syms[i];
3296 	      s++;
3297 	    }
3298 	}
3299     }
3300   else
3301     {
3302       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3303       bfd_byte *contents = NULL;
3304       size_t size;
3305       long plt_count = 0;
3306       bfd_vma glink_vma = 0, resolv_vma = 0;
3307       asection *dynamic, *glink = NULL, *relplt = NULL;
3308       arelent *p;
3309 
3310       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3311 	{
3312 	free_contents_and_exit:
3313 	  if (contents)
3314 	    free (contents);
3315 	  count = -1;
3316 	  goto done;
3317 	}
3318 
3319       size = 0;
3320       for (i = secsymend; i < opdsymend; ++i)
3321 	{
3322 	  bfd_vma ent;
3323 
3324 	  /* Ignore bogus symbols.  */
3325 	  if (syms[i]->value > opd->size - 8)
3326 	    continue;
3327 
3328 	  ent = bfd_get_64 (abfd, contents + syms[i]->value);
3329 	  if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3330 	    {
3331 	      ++count;
3332 	      size += sizeof (asymbol);
3333 	      size += strlen (syms[i]->name) + 2;
3334 	    }
3335 	}
3336 
3337       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3338       if (dyn_count != 0
3339 	  && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3340 	{
3341 	  bfd_byte *dynbuf, *extdyn, *extdynend;
3342 	  size_t extdynsize;
3343 	  void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3344 
3345 	  if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3346 	    goto free_contents_and_exit;
3347 
3348 	  extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3349 	  swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3350 
3351 	  extdyn = dynbuf;
3352 	  extdynend = extdyn + dynamic->size;
3353 	  for (; extdyn < extdynend; extdyn += extdynsize)
3354 	    {
3355 	      Elf_Internal_Dyn dyn;
3356 	      (*swap_dyn_in) (abfd, extdyn, &dyn);
3357 
3358 	      if (dyn.d_tag == DT_NULL)
3359 		break;
3360 
3361 	      if (dyn.d_tag == DT_PPC64_GLINK)
3362 		{
3363 		  /* The first glink stub starts at offset 32; see
3364 		     comment in ppc64_elf_finish_dynamic_sections. */
3365 		  glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3366 		  /* The .glink section usually does not survive the final
3367 		     link; search for the section (usually .text) where the
3368 		     glink stubs now reside.  */
3369 		  glink = bfd_sections_find_if (abfd, section_covers_vma,
3370 						&glink_vma);
3371 		  break;
3372 		}
3373 	    }
3374 
3375 	  free (dynbuf);
3376 	}
3377 
3378       if (glink != NULL)
3379 	{
3380 	  /* Determine __glink trampoline by reading the relative branch
3381 	     from the first glink stub.  */
3382 	  bfd_byte buf[4];
3383 	  unsigned int off = 0;
3384 
3385 	  while (bfd_get_section_contents (abfd, glink, buf,
3386 					   glink_vma + off - glink->vma, 4))
3387 	    {
3388 	      unsigned int insn = bfd_get_32 (abfd, buf);
3389 	      insn ^= B_DOT;
3390 	      if ((insn & ~0x3fffffc) == 0)
3391 		{
3392 		  resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3393 		  break;
3394 		}
3395 	      off += 4;
3396 	      if (off > 4)
3397 		break;
3398 	    }
3399 
3400 	  if (resolv_vma)
3401 	    size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3402 
3403 	  relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3404 	  if (relplt != NULL)
3405 	    {
3406 	      slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3407 	      if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3408 		goto free_contents_and_exit;
3409 
3410 	      plt_count = relplt->size / sizeof (Elf64_External_Rela);
3411 	      size += plt_count * sizeof (asymbol);
3412 
3413 	      p = relplt->relocation;
3414 	      for (i = 0; i < plt_count; i++, p++)
3415 		{
3416 		  size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3417 		  if (p->addend != 0)
3418 		    size += sizeof ("+0x") - 1 + 16;
3419 		}
3420 	    }
3421 	}
3422 
3423       s = *ret = bfd_malloc (size);
3424       if (s == NULL)
3425 	goto free_contents_and_exit;
3426 
3427       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3428 
3429       for (i = secsymend; i < opdsymend; ++i)
3430 	{
3431 	  bfd_vma ent;
3432 
3433 	  if (syms[i]->value > opd->size - 8)
3434 	    continue;
3435 
3436 	  ent = bfd_get_64 (abfd, contents + syms[i]->value);
3437 	  if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3438 	    {
3439 	      long lo, hi;
3440 	      size_t len;
3441 	      asection *sec = abfd->sections;
3442 
3443 	      *s = *syms[i];
3444 	      lo = codesecsym;
3445 	      hi = codesecsymend;
3446 	      while (lo < hi)
3447 		{
3448 		  long mid = (lo + hi) >> 1;
3449 		  if (syms[mid]->section->vma < ent)
3450 		    lo = mid + 1;
3451 		  else if (syms[mid]->section->vma > ent)
3452 		    hi = mid;
3453 		  else
3454 		    {
3455 		      sec = syms[mid]->section;
3456 		      break;
3457 		    }
3458 		}
3459 
3460 	      if (lo >= hi && lo > codesecsym)
3461 		sec = syms[lo - 1]->section;
3462 
3463 	      for (; sec != NULL; sec = sec->next)
3464 		{
3465 		  if (sec->vma > ent)
3466 		    break;
3467 		  /* SEC_LOAD may not be set if SEC is from a separate debug
3468 		     info file.  */
3469 		  if ((sec->flags & SEC_ALLOC) == 0)
3470 		    break;
3471 		  if ((sec->flags & SEC_CODE) != 0)
3472 		    s->section = sec;
3473 		}
3474 	      s->flags |= BSF_SYNTHETIC;
3475 	      s->value = ent - s->section->vma;
3476 	      s->name = names;
3477 	      *names++ = '.';
3478 	      len = strlen (syms[i]->name);
3479 	      memcpy (names, syms[i]->name, len + 1);
3480 	      names += len + 1;
3481 	      /* Have udata.p point back to the original symbol this
3482 		 synthetic symbol was derived from.  */
3483 	      s->udata.p = syms[i];
3484 	      s++;
3485 	    }
3486 	}
3487       free (contents);
3488 
3489       if (glink != NULL && relplt != NULL)
3490 	{
3491 	  if (resolv_vma)
3492 	    {
3493 	      /* Add a symbol for the main glink trampoline.  */
3494 	      memset (s, 0, sizeof *s);
3495 	      s->the_bfd = abfd;
3496 	      s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3497 	      s->section = glink;
3498 	      s->value = resolv_vma - glink->vma;
3499 	      s->name = names;
3500 	      memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3501 	      names += sizeof ("__glink_PLTresolve");
3502 	      s++;
3503 	      count++;
3504 	    }
3505 
3506 	  /* FIXME: It would be very much nicer to put sym@plt on the
3507 	     stub rather than on the glink branch table entry.  The
3508 	     objdump disassembler would then use a sensible symbol
3509 	     name on plt calls.  The difficulty in doing so is
3510 	     a) finding the stubs, and,
3511 	     b) matching stubs against plt entries, and,
3512 	     c) there can be multiple stubs for a given plt entry.
3513 
3514 	     Solving (a) could be done by code scanning, but older
3515 	     ppc64 binaries used different stubs to current code.
3516 	     (b) is the tricky one since you need to known the toc
3517 	     pointer for at least one function that uses a pic stub to
3518 	     be able to calculate the plt address referenced.
3519 	     (c) means gdb would need to set multiple breakpoints (or
3520 	     find the glink branch itself) when setting breakpoints
3521 	     for pending shared library loads.  */
3522 	  p = relplt->relocation;
3523 	  for (i = 0; i < plt_count; i++, p++)
3524 	    {
3525 	      size_t len;
3526 
3527 	      *s = **p->sym_ptr_ptr;
3528 	      /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3529 		 we are defining a symbol, ensure one of them is set.  */
3530 	      if ((s->flags & BSF_LOCAL) == 0)
3531 		s->flags |= BSF_GLOBAL;
3532 	      s->flags |= BSF_SYNTHETIC;
3533 	      s->section = glink;
3534 	      s->value = glink_vma - glink->vma;
3535 	      s->name = names;
3536 	      s->udata.p = NULL;
3537 	      len = strlen ((*p->sym_ptr_ptr)->name);
3538 	      memcpy (names, (*p->sym_ptr_ptr)->name, len);
3539 	      names += len;
3540 	      if (p->addend != 0)
3541 		{
3542 		  memcpy (names, "+0x", sizeof ("+0x") - 1);
3543 		  names += sizeof ("+0x") - 1;
3544 		  bfd_sprintf_vma (abfd, names, p->addend);
3545 		  names += strlen (names);
3546 		}
3547 	      memcpy (names, "@plt", sizeof ("@plt"));
3548 	      names += sizeof ("@plt");
3549 	      s++;
3550 	      if (abi < 2)
3551 		{
3552 		  glink_vma += 8;
3553 		  if (i >= 0x8000)
3554 		    glink_vma += 4;
3555 		}
3556 	      else
3557 		glink_vma += 4;
3558 	    }
3559 	  count += plt_count;
3560 	}
3561     }
3562 
3563  done:
3564   free (syms);
3565   return count;
3566 }
3567 
3568 /* The following functions are specific to the ELF linker, while
3569    functions above are used generally.  Those named ppc64_elf_* are
3570    called by the main ELF linker code.  They appear in this file more
3571    or less in the order in which they are called.  eg.
3572    ppc64_elf_check_relocs is called early in the link process,
3573    ppc64_elf_finish_dynamic_sections is one of the last functions
3574    called.
3575 
3576    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3577    functions have both a function code symbol and a function descriptor
3578    symbol.  A call to foo in a relocatable object file looks like:
3579 
3580    .		.text
3581    .	x:
3582    .		bl	.foo
3583    .		nop
3584 
3585    The function definition in another object file might be:
3586 
3587    .		.section .opd
3588    .	foo:	.quad	.foo
3589    .		.quad	.TOC.@tocbase
3590    .		.quad	0
3591    .
3592    .		.text
3593    .	.foo:	blr
3594 
3595    When the linker resolves the call during a static link, the branch
3596    unsurprisingly just goes to .foo and the .opd information is unused.
3597    If the function definition is in a shared library, things are a little
3598    different:  The call goes via a plt call stub, the opd information gets
3599    copied to the plt, and the linker patches the nop.
3600 
3601    .	x:
3602    .		bl	.foo_stub
3603    .		ld	2,40(1)
3604    .
3605    .
3606    .	.foo_stub:
3607    .		std	2,40(1)			# in practice, the call stub
3608    .		addis	11,2,Lfoo@toc@ha	# is slightly optimized, but
3609    .		addi	11,11,Lfoo@toc@l	# this is the general idea
3610    .		ld	12,0(11)
3611    .		ld	2,8(11)
3612    .		mtctr	12
3613    .		ld	11,16(11)
3614    .		bctr
3615    .
3616    .		.section .plt
3617    .	Lfoo:	reloc (R_PPC64_JMP_SLOT, foo)
3618 
3619    The "reloc ()" notation is supposed to indicate that the linker emits
3620    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3621    copying.
3622 
3623    What are the difficulties here?  Well, firstly, the relocations
3624    examined by the linker in check_relocs are against the function code
3625    sym .foo, while the dynamic relocation in the plt is emitted against
3626    the function descriptor symbol, foo.  Somewhere along the line, we need
3627    to carefully copy dynamic link information from one symbol to the other.
3628    Secondly, the generic part of the elf linker will make .foo a dynamic
3629    symbol as is normal for most other backends.  We need foo dynamic
3630    instead, at least for an application final link.  However, when
3631    creating a shared library containing foo, we need to have both symbols
3632    dynamic so that references to .foo are satisfied during the early
3633    stages of linking.  Otherwise the linker might decide to pull in a
3634    definition from some other object, eg. a static library.
3635 
3636    Update: As of August 2004, we support a new convention.  Function
3637    calls may use the function descriptor symbol, ie. "bl foo".  This
3638    behaves exactly as "bl .foo".  */
3639 
3640 /* Of those relocs that might be copied as dynamic relocs, this function
3641    selects those that must be copied when linking a shared library,
3642    even when the symbol is local.  */
3643 
3644 static int
3645 must_be_dyn_reloc (struct bfd_link_info *info,
3646 		   enum elf_ppc64_reloc_type r_type)
3647 {
3648   switch (r_type)
3649     {
3650     default:
3651       return 1;
3652 
3653     case R_PPC64_REL32:
3654     case R_PPC64_REL64:
3655     case R_PPC64_REL30:
3656       return 0;
3657 
3658     case R_PPC64_TPREL16:
3659     case R_PPC64_TPREL16_LO:
3660     case R_PPC64_TPREL16_HI:
3661     case R_PPC64_TPREL16_HA:
3662     case R_PPC64_TPREL16_DS:
3663     case R_PPC64_TPREL16_LO_DS:
3664     case R_PPC64_TPREL16_HIGH:
3665     case R_PPC64_TPREL16_HIGHA:
3666     case R_PPC64_TPREL16_HIGHER:
3667     case R_PPC64_TPREL16_HIGHERA:
3668     case R_PPC64_TPREL16_HIGHEST:
3669     case R_PPC64_TPREL16_HIGHESTA:
3670     case R_PPC64_TPREL64:
3671       return !info->executable;
3672     }
3673 }
3674 
3675 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3676    copying dynamic variables from a shared lib into an app's dynbss
3677    section, and instead use a dynamic relocation to point into the
3678    shared lib.  With code that gcc generates, it's vital that this be
3679    enabled;  In the PowerPC64 ABI, the address of a function is actually
3680    the address of a function descriptor, which resides in the .opd
3681    section.  gcc uses the descriptor directly rather than going via the
3682    GOT as some other ABI's do, which means that initialized function
3683    pointers must reference the descriptor.  Thus, a function pointer
3684    initialized to the address of a function in a shared library will
3685    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3686    redefines the function descriptor symbol to point to the copy.  This
3687    presents a problem as a plt entry for that function is also
3688    initialized from the function descriptor symbol and the copy reloc
3689    may not be initialized first.  */
3690 #define ELIMINATE_COPY_RELOCS 1
3691 
3692 /* Section name for stubs is the associated section name plus this
3693    string.  */
3694 #define STUB_SUFFIX ".stub"
3695 
3696 /* Linker stubs.
3697    ppc_stub_long_branch:
3698    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3699    destination, but a 24 bit branch in a stub section will reach.
3700    .	b	dest
3701 
3702    ppc_stub_plt_branch:
3703    Similar to the above, but a 24 bit branch in the stub section won't
3704    reach its destination.
3705    .	addis	%r11,%r2,xxx@toc@ha
3706    .	ld	%r12,xxx@toc@l(%r11)
3707    .	mtctr	%r12
3708    .	bctr
3709 
3710    ppc_stub_plt_call:
3711    Used to call a function in a shared library.  If it so happens that
3712    the plt entry referenced crosses a 64k boundary, then an extra
3713    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3714    .	std	%r2,40(%r1)
3715    .	addis	%r11,%r2,xxx@toc@ha
3716    .	ld	%r12,xxx+0@toc@l(%r11)
3717    .	mtctr	%r12
3718    .	ld	%r2,xxx+8@toc@l(%r11)
3719    .	ld	%r11,xxx+16@toc@l(%r11)
3720    .	bctr
3721 
3722    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3723    code to adjust the value and save r2 to support multiple toc sections.
3724    A ppc_stub_long_branch with an r2 offset looks like:
3725    .	std	%r2,40(%r1)
3726    .	addis	%r2,%r2,off@ha
3727    .	addi	%r2,%r2,off@l
3728    .	b	dest
3729 
3730    A ppc_stub_plt_branch with an r2 offset looks like:
3731    .	std	%r2,40(%r1)
3732    .	addis	%r11,%r2,xxx@toc@ha
3733    .	ld	%r12,xxx@toc@l(%r11)
3734    .	addis	%r2,%r2,off@ha
3735    .	addi	%r2,%r2,off@l
3736    .	mtctr	%r12
3737    .	bctr
3738 
3739    In cases where the "addis" instruction would add zero, the "addis" is
3740    omitted and following instructions modified slightly in some cases.
3741 */
3742 
3743 enum ppc_stub_type {
3744   ppc_stub_none,
3745   ppc_stub_long_branch,
3746   ppc_stub_long_branch_r2off,
3747   ppc_stub_plt_branch,
3748   ppc_stub_plt_branch_r2off,
3749   ppc_stub_plt_call,
3750   ppc_stub_plt_call_r2save
3751 };
3752 
3753 struct ppc_stub_hash_entry {
3754 
3755   /* Base hash table entry structure.  */
3756   struct bfd_hash_entry root;
3757 
3758   enum ppc_stub_type stub_type;
3759 
3760   /* The stub section.  */
3761   asection *stub_sec;
3762 
3763   /* Offset within stub_sec of the beginning of this stub.  */
3764   bfd_vma stub_offset;
3765 
3766   /* Given the symbol's value and its section we can determine its final
3767      value when building the stubs (so the stub knows where to jump.  */
3768   bfd_vma target_value;
3769   asection *target_section;
3770 
3771   /* The symbol table entry, if any, that this was derived from.  */
3772   struct ppc_link_hash_entry *h;
3773   struct plt_entry *plt_ent;
3774 
3775   /* Where this stub is being called from, or, in the case of combined
3776      stub sections, the first input section in the group.  */
3777   asection *id_sec;
3778 
3779   /* Symbol st_other.  */
3780   unsigned char other;
3781 };
3782 
3783 struct ppc_branch_hash_entry {
3784 
3785   /* Base hash table entry structure.  */
3786   struct bfd_hash_entry root;
3787 
3788   /* Offset within branch lookup table.  */
3789   unsigned int offset;
3790 
3791   /* Generation marker.  */
3792   unsigned int iter;
3793 };
3794 
3795 /* Used to track dynamic relocations for local symbols.  */
3796 struct ppc_dyn_relocs
3797 {
3798   struct ppc_dyn_relocs *next;
3799 
3800   /* The input section of the reloc.  */
3801   asection *sec;
3802 
3803   /* Total number of relocs copied for the input section.  */
3804   unsigned int count : 31;
3805 
3806   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3807   unsigned int ifunc : 1;
3808 };
3809 
3810 struct ppc_link_hash_entry
3811 {
3812   struct elf_link_hash_entry elf;
3813 
3814   union {
3815     /* A pointer to the most recently used stub hash entry against this
3816        symbol.  */
3817     struct ppc_stub_hash_entry *stub_cache;
3818 
3819     /* A pointer to the next symbol starting with a '.'  */
3820     struct ppc_link_hash_entry *next_dot_sym;
3821   } u;
3822 
3823   /* Track dynamic relocs copied for this symbol.  */
3824   struct elf_dyn_relocs *dyn_relocs;
3825 
3826   /* Link between function code and descriptor symbols.  */
3827   struct ppc_link_hash_entry *oh;
3828 
3829   /* Flag function code and descriptor symbols.  */
3830   unsigned int is_func:1;
3831   unsigned int is_func_descriptor:1;
3832   unsigned int fake:1;
3833 
3834   /* Whether global opd/toc sym has been adjusted or not.
3835      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3836      should be set for all globals defined in any opd/toc section.  */
3837   unsigned int adjust_done:1;
3838 
3839   /* Set if we twiddled this symbol to weak at some stage.  */
3840   unsigned int was_undefined:1;
3841 
3842   /* Contexts in which symbol is used in the GOT (or TOC).
3843      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3844      corresponding relocs are encountered during check_relocs.
3845      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3846      indicate the corresponding GOT entry type is not needed.
3847      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3848      a TPREL one.  We use a separate flag rather than setting TPREL
3849      just for convenience in distinguishing the two cases.  */
3850 #define TLS_GD		 1	/* GD reloc. */
3851 #define TLS_LD		 2	/* LD reloc. */
3852 #define TLS_TPREL	 4	/* TPREL reloc, => IE. */
3853 #define TLS_DTPREL	 8	/* DTPREL reloc, => LD. */
3854 #define TLS_TLS		16	/* Any TLS reloc.  */
3855 #define TLS_EXPLICIT	32	/* Marks TOC section TLS relocs. */
3856 #define TLS_TPRELGD	64	/* TPREL reloc resulting from GD->IE. */
3857 #define PLT_IFUNC      128	/* STT_GNU_IFUNC.  */
3858   unsigned char tls_mask;
3859 };
3860 
3861 /* ppc64 ELF linker hash table.  */
3862 
3863 struct ppc_link_hash_table
3864 {
3865   struct elf_link_hash_table elf;
3866 
3867   /* The stub hash table.  */
3868   struct bfd_hash_table stub_hash_table;
3869 
3870   /* Another hash table for plt_branch stubs.  */
3871   struct bfd_hash_table branch_hash_table;
3872 
3873   /* Hash table for function prologue tocsave.  */
3874   htab_t tocsave_htab;
3875 
3876   /* Linker stub bfd.  */
3877   bfd *stub_bfd;
3878 
3879   /* Linker call-backs.  */
3880   asection * (*add_stub_section) (const char *, asection *);
3881   void (*layout_sections_again) (void);
3882 
3883   /* Array to keep track of which stub sections have been created, and
3884      information on stub grouping.  */
3885   struct map_stub {
3886     /* This is the section to which stubs in the group will be attached.  */
3887     asection *link_sec;
3888     /* The stub section.  */
3889     asection *stub_sec;
3890     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3891     bfd_vma toc_off;
3892   } *stub_group;
3893 
3894   /* Temp used when calculating TOC pointers.  */
3895   bfd_vma toc_curr;
3896   bfd *toc_bfd;
3897   asection *toc_first_sec;
3898 
3899   /* Highest input section id.  */
3900   int top_id;
3901 
3902   /* Highest output section index.  */
3903   int top_index;
3904 
3905   /* Used when adding symbols.  */
3906   struct ppc_link_hash_entry *dot_syms;
3907 
3908   /* List of input sections for each output section.  */
3909   asection **input_list;
3910 
3911   /* Shortcuts to get to dynamic linker sections.  */
3912   asection *dynbss;
3913   asection *relbss;
3914   asection *glink;
3915   asection *sfpr;
3916   asection *brlt;
3917   asection *relbrlt;
3918   asection *glink_eh_frame;
3919 
3920   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3921   struct ppc_link_hash_entry *tls_get_addr;
3922   struct ppc_link_hash_entry *tls_get_addr_fd;
3923 
3924   /* The size of reliplt used by got entry relocs.  */
3925   bfd_size_type got_reli_size;
3926 
3927   /* Statistics.  */
3928   unsigned long stub_count[ppc_stub_plt_call_r2save];
3929 
3930   /* Number of stubs against global syms.  */
3931   unsigned long stub_globals;
3932 
3933   /* Alignment of PLT call stubs.  */
3934   unsigned int plt_stub_align:4;
3935 
3936   /* Set if we're linking code with function descriptors.  */
3937   unsigned int opd_abi:1;
3938 
3939   /* Set if PLT call stubs should load r11.  */
3940   unsigned int plt_static_chain:1;
3941 
3942   /* Set if PLT call stubs need a read-read barrier.  */
3943   unsigned int plt_thread_safe:1;
3944 
3945   /* Set if we should emit symbols for stubs.  */
3946   unsigned int emit_stub_syms:1;
3947 
3948   /* Set if __tls_get_addr optimization should not be done.  */
3949   unsigned int no_tls_get_addr_opt:1;
3950 
3951   /* Support for multiple toc sections.  */
3952   unsigned int do_multi_toc:1;
3953   unsigned int multi_toc_needed:1;
3954   unsigned int second_toc_pass:1;
3955   unsigned int do_toc_opt:1;
3956 
3957   /* Set on error.  */
3958   unsigned int stub_error:1;
3959 
3960   /* Temp used by ppc64_elf_process_dot_syms.  */
3961   unsigned int twiddled_syms:1;
3962 
3963   /* Incremented every time we size stubs.  */
3964   unsigned int stub_iteration;
3965 
3966   /* Small local sym cache.  */
3967   struct sym_cache sym_cache;
3968 };
3969 
3970 /* Rename some of the generic section flags to better document how they
3971    are used here.  */
3972 
3973 /* Nonzero if this section has TLS related relocations.  */
3974 #define has_tls_reloc sec_flg0
3975 
3976 /* Nonzero if this section has a call to __tls_get_addr.  */
3977 #define has_tls_get_addr_call sec_flg1
3978 
3979 /* Nonzero if this section has any toc or got relocs.  */
3980 #define has_toc_reloc sec_flg2
3981 
3982 /* Nonzero if this section has a call to another section that uses
3983    the toc or got.  */
3984 #define makes_toc_func_call sec_flg3
3985 
3986 /* Recursion protection when determining above flag.  */
3987 #define call_check_in_progress sec_flg4
3988 #define call_check_done sec_flg5
3989 
3990 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3991 
3992 #define ppc_hash_table(p) \
3993   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3994   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3995 
3996 #define ppc_stub_hash_lookup(table, string, create, copy) \
3997   ((struct ppc_stub_hash_entry *) \
3998    bfd_hash_lookup ((table), (string), (create), (copy)))
3999 
4000 #define ppc_branch_hash_lookup(table, string, create, copy) \
4001   ((struct ppc_branch_hash_entry *) \
4002    bfd_hash_lookup ((table), (string), (create), (copy)))
4003 
4004 /* Create an entry in the stub hash table.  */
4005 
4006 static struct bfd_hash_entry *
4007 stub_hash_newfunc (struct bfd_hash_entry *entry,
4008 		   struct bfd_hash_table *table,
4009 		   const char *string)
4010 {
4011   /* Allocate the structure if it has not already been allocated by a
4012      subclass.  */
4013   if (entry == NULL)
4014     {
4015       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4016       if (entry == NULL)
4017 	return entry;
4018     }
4019 
4020   /* Call the allocation method of the superclass.  */
4021   entry = bfd_hash_newfunc (entry, table, string);
4022   if (entry != NULL)
4023     {
4024       struct ppc_stub_hash_entry *eh;
4025 
4026       /* Initialize the local fields.  */
4027       eh = (struct ppc_stub_hash_entry *) entry;
4028       eh->stub_type = ppc_stub_none;
4029       eh->stub_sec = NULL;
4030       eh->stub_offset = 0;
4031       eh->target_value = 0;
4032       eh->target_section = NULL;
4033       eh->h = NULL;
4034       eh->plt_ent = NULL;
4035       eh->id_sec = NULL;
4036       eh->other = 0;
4037     }
4038 
4039   return entry;
4040 }
4041 
4042 /* Create an entry in the branch hash table.  */
4043 
4044 static struct bfd_hash_entry *
4045 branch_hash_newfunc (struct bfd_hash_entry *entry,
4046 		     struct bfd_hash_table *table,
4047 		     const char *string)
4048 {
4049   /* Allocate the structure if it has not already been allocated by a
4050      subclass.  */
4051   if (entry == NULL)
4052     {
4053       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4054       if (entry == NULL)
4055 	return entry;
4056     }
4057 
4058   /* Call the allocation method of the superclass.  */
4059   entry = bfd_hash_newfunc (entry, table, string);
4060   if (entry != NULL)
4061     {
4062       struct ppc_branch_hash_entry *eh;
4063 
4064       /* Initialize the local fields.  */
4065       eh = (struct ppc_branch_hash_entry *) entry;
4066       eh->offset = 0;
4067       eh->iter = 0;
4068     }
4069 
4070   return entry;
4071 }
4072 
4073 /* Create an entry in a ppc64 ELF linker hash table.  */
4074 
4075 static struct bfd_hash_entry *
4076 link_hash_newfunc (struct bfd_hash_entry *entry,
4077 		   struct bfd_hash_table *table,
4078 		   const char *string)
4079 {
4080   /* Allocate the structure if it has not already been allocated by a
4081      subclass.  */
4082   if (entry == NULL)
4083     {
4084       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4085       if (entry == NULL)
4086 	return entry;
4087     }
4088 
4089   /* Call the allocation method of the superclass.  */
4090   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4091   if (entry != NULL)
4092     {
4093       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4094 
4095       memset (&eh->u.stub_cache, 0,
4096 	      (sizeof (struct ppc_link_hash_entry)
4097 	       - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4098 
4099       /* When making function calls, old ABI code references function entry
4100 	 points (dot symbols), while new ABI code references the function
4101 	 descriptor symbol.  We need to make any combination of reference and
4102 	 definition work together, without breaking archive linking.
4103 
4104 	 For a defined function "foo" and an undefined call to "bar":
4105 	 An old object defines "foo" and ".foo", references ".bar" (possibly
4106 	 "bar" too).
4107 	 A new object defines "foo" and references "bar".
4108 
4109 	 A new object thus has no problem with its undefined symbols being
4110 	 satisfied by definitions in an old object.  On the other hand, the
4111 	 old object won't have ".bar" satisfied by a new object.
4112 
4113 	 Keep a list of newly added dot-symbols.  */
4114 
4115       if (string[0] == '.')
4116 	{
4117 	  struct ppc_link_hash_table *htab;
4118 
4119 	  htab = (struct ppc_link_hash_table *) table;
4120 	  eh->u.next_dot_sym = htab->dot_syms;
4121 	  htab->dot_syms = eh;
4122 	}
4123     }
4124 
4125   return entry;
4126 }
4127 
4128 struct tocsave_entry {
4129   asection *sec;
4130   bfd_vma offset;
4131 };
4132 
4133 static hashval_t
4134 tocsave_htab_hash (const void *p)
4135 {
4136   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4137   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4138 }
4139 
4140 static int
4141 tocsave_htab_eq (const void *p1, const void *p2)
4142 {
4143   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4144   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4145   return e1->sec == e2->sec && e1->offset == e2->offset;
4146 }
4147 
4148 /* Create a ppc64 ELF linker hash table.  */
4149 
4150 static struct bfd_link_hash_table *
4151 ppc64_elf_link_hash_table_create (bfd *abfd)
4152 {
4153   struct ppc_link_hash_table *htab;
4154   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4155 
4156   htab = bfd_zmalloc (amt);
4157   if (htab == NULL)
4158     return NULL;
4159 
4160   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4161 				      sizeof (struct ppc_link_hash_entry),
4162 				      PPC64_ELF_DATA))
4163     {
4164       free (htab);
4165       return NULL;
4166     }
4167 
4168   /* Init the stub hash table too.  */
4169   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4170 			    sizeof (struct ppc_stub_hash_entry)))
4171     return NULL;
4172 
4173   /* And the branch hash table.  */
4174   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175 			    sizeof (struct ppc_branch_hash_entry)))
4176     return NULL;
4177 
4178   htab->tocsave_htab = htab_try_create (1024,
4179 					tocsave_htab_hash,
4180 					tocsave_htab_eq,
4181 					NULL);
4182   if (htab->tocsave_htab == NULL)
4183     return NULL;
4184 
4185   /* Initializing two fields of the union is just cosmetic.  We really
4186      only care about glist, but when compiled on a 32-bit host the
4187      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4188      debugger inspection of these fields look nicer.  */
4189   htab->elf.init_got_refcount.refcount = 0;
4190   htab->elf.init_got_refcount.glist = NULL;
4191   htab->elf.init_plt_refcount.refcount = 0;
4192   htab->elf.init_plt_refcount.glist = NULL;
4193   htab->elf.init_got_offset.offset = 0;
4194   htab->elf.init_got_offset.glist = NULL;
4195   htab->elf.init_plt_offset.offset = 0;
4196   htab->elf.init_plt_offset.glist = NULL;
4197 
4198   return &htab->elf.root;
4199 }
4200 
4201 /* Free the derived linker hash table.  */
4202 
4203 static void
4204 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4205 {
4206   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4207 
4208   bfd_hash_table_free (&htab->stub_hash_table);
4209   bfd_hash_table_free (&htab->branch_hash_table);
4210   if (htab->tocsave_htab)
4211     htab_delete (htab->tocsave_htab);
4212   _bfd_elf_link_hash_table_free (hash);
4213 }
4214 
4215 /* Create sections for linker generated code.  */
4216 
4217 static bfd_boolean
4218 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4219 {
4220   struct ppc_link_hash_table *htab;
4221   flagword flags;
4222 
4223   htab = ppc_hash_table (info);
4224 
4225   /* Create .sfpr for code to save and restore fp regs.  */
4226   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4227 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4228   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4229 						   flags);
4230   if (htab->sfpr == NULL
4231       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4232     return FALSE;
4233 
4234   /* Create .glink for lazy dynamic linking support.  */
4235   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4236 						    flags);
4237   if (htab->glink == NULL
4238       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4239     return FALSE;
4240 
4241   if (!info->no_ld_generated_unwind_info)
4242     {
4243       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4244 	       | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4245       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4246 								 ".eh_frame",
4247 								 flags);
4248       if (htab->glink_eh_frame == NULL
4249 	  || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4250 	return FALSE;
4251     }
4252 
4253   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4254   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4255   if (htab->elf.iplt == NULL
4256       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4257     return FALSE;
4258 
4259   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4260 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4261   htab->elf.irelplt
4262     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4263   if (htab->elf.irelplt == NULL
4264       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4265     return FALSE;
4266 
4267   /* Create branch lookup table for plt_branch stubs.  */
4268   flags = (SEC_ALLOC | SEC_LOAD
4269 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4271 						   flags);
4272   if (htab->brlt == NULL
4273       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4274     return FALSE;
4275 
4276   if (!info->shared)
4277     return TRUE;
4278 
4279   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4280 	   | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4281   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4282 						      ".rela.branch_lt",
4283 						      flags);
4284   if (htab->relbrlt == NULL
4285       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4286     return FALSE;
4287 
4288   return TRUE;
4289 }
4290 
4291 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4292 
4293 bfd_boolean
4294 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4295 {
4296   struct ppc_link_hash_table *htab;
4297 
4298   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4299 
4300 /* Always hook our dynamic sections into the first bfd, which is the
4301    linker created stub bfd.  This ensures that the GOT header is at
4302    the start of the output TOC section.  */
4303   htab = ppc_hash_table (info);
4304   if (htab == NULL)
4305     return FALSE;
4306   htab->stub_bfd = abfd;
4307   htab->elf.dynobj = abfd;
4308 
4309   if (info->relocatable)
4310     return TRUE;
4311 
4312   return create_linkage_sections (htab->elf.dynobj, info);
4313 }
4314 
4315 /* Build a name for an entry in the stub hash table.  */
4316 
4317 static char *
4318 ppc_stub_name (const asection *input_section,
4319 	       const asection *sym_sec,
4320 	       const struct ppc_link_hash_entry *h,
4321 	       const Elf_Internal_Rela *rel)
4322 {
4323   char *stub_name;
4324   ssize_t len;
4325 
4326   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4327      offsets from a sym as a branch target?  In fact, we could
4328      probably assume the addend is always zero.  */
4329   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4330 
4331   if (h)
4332     {
4333       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4334       stub_name = bfd_malloc (len);
4335       if (stub_name == NULL)
4336 	return stub_name;
4337 
4338       len = sprintf (stub_name, "%08x.%s+%x",
4339 		     input_section->id & 0xffffffff,
4340 		     h->elf.root.root.string,
4341 		     (int) rel->r_addend & 0xffffffff);
4342     }
4343   else
4344     {
4345       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4346       stub_name = bfd_malloc (len);
4347       if (stub_name == NULL)
4348 	return stub_name;
4349 
4350       len = sprintf (stub_name, "%08x.%x:%x+%x",
4351 		     input_section->id & 0xffffffff,
4352 		     sym_sec->id & 0xffffffff,
4353 		     (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4354 		     (int) rel->r_addend & 0xffffffff);
4355     }
4356   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4357     stub_name[len - 2] = 0;
4358   return stub_name;
4359 }
4360 
4361 /* Look up an entry in the stub hash.  Stub entries are cached because
4362    creating the stub name takes a bit of time.  */
4363 
4364 static struct ppc_stub_hash_entry *
4365 ppc_get_stub_entry (const asection *input_section,
4366 		    const asection *sym_sec,
4367 		    struct ppc_link_hash_entry *h,
4368 		    const Elf_Internal_Rela *rel,
4369 		    struct ppc_link_hash_table *htab)
4370 {
4371   struct ppc_stub_hash_entry *stub_entry;
4372   const asection *id_sec;
4373 
4374   /* If this input section is part of a group of sections sharing one
4375      stub section, then use the id of the first section in the group.
4376      Stub names need to include a section id, as there may well be
4377      more than one stub used to reach say, printf, and we need to
4378      distinguish between them.  */
4379   id_sec = htab->stub_group[input_section->id].link_sec;
4380 
4381   if (h != NULL && h->u.stub_cache != NULL
4382       && h->u.stub_cache->h == h
4383       && h->u.stub_cache->id_sec == id_sec)
4384     {
4385       stub_entry = h->u.stub_cache;
4386     }
4387   else
4388     {
4389       char *stub_name;
4390 
4391       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4392       if (stub_name == NULL)
4393 	return NULL;
4394 
4395       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4396 					 stub_name, FALSE, FALSE);
4397       if (h != NULL)
4398 	h->u.stub_cache = stub_entry;
4399 
4400       free (stub_name);
4401     }
4402 
4403   return stub_entry;
4404 }
4405 
4406 /* Add a new stub entry to the stub hash.  Not all fields of the new
4407    stub entry are initialised.  */
4408 
4409 static struct ppc_stub_hash_entry *
4410 ppc_add_stub (const char *stub_name,
4411 	      asection *section,
4412 	      struct bfd_link_info *info)
4413 {
4414   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4415   asection *link_sec;
4416   asection *stub_sec;
4417   struct ppc_stub_hash_entry *stub_entry;
4418 
4419   link_sec = htab->stub_group[section->id].link_sec;
4420   stub_sec = htab->stub_group[section->id].stub_sec;
4421   if (stub_sec == NULL)
4422     {
4423       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4424       if (stub_sec == NULL)
4425 	{
4426 	  size_t namelen;
4427 	  bfd_size_type len;
4428 	  char *s_name;
4429 
4430 	  namelen = strlen (link_sec->name);
4431 	  len = namelen + sizeof (STUB_SUFFIX);
4432 	  s_name = bfd_alloc (htab->stub_bfd, len);
4433 	  if (s_name == NULL)
4434 	    return NULL;
4435 
4436 	  memcpy (s_name, link_sec->name, namelen);
4437 	  memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4438 	  stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4439 	  if (stub_sec == NULL)
4440 	    return NULL;
4441 	  htab->stub_group[link_sec->id].stub_sec = stub_sec;
4442 	}
4443       htab->stub_group[section->id].stub_sec = stub_sec;
4444     }
4445 
4446   /* Enter this entry into the linker stub hash table.  */
4447   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4448 				     TRUE, FALSE);
4449   if (stub_entry == NULL)
4450     {
4451       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4452 			      section->owner, stub_name);
4453       return NULL;
4454     }
4455 
4456   stub_entry->stub_sec = stub_sec;
4457   stub_entry->stub_offset = 0;
4458   stub_entry->id_sec = link_sec;
4459   return stub_entry;
4460 }
4461 
4462 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4463    not already done.  */
4464 
4465 static bfd_boolean
4466 create_got_section (bfd *abfd, struct bfd_link_info *info)
4467 {
4468   asection *got, *relgot;
4469   flagword flags;
4470   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4471 
4472   if (!is_ppc64_elf (abfd))
4473     return FALSE;
4474   if (htab == NULL)
4475     return FALSE;
4476 
4477   if (!htab->elf.sgot
4478       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4479     return FALSE;
4480 
4481   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4482 	   | SEC_LINKER_CREATED);
4483 
4484   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4485   if (!got
4486       || !bfd_set_section_alignment (abfd, got, 3))
4487     return FALSE;
4488 
4489   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4490 					       flags | SEC_READONLY);
4491   if (!relgot
4492       || ! bfd_set_section_alignment (abfd, relgot, 3))
4493     return FALSE;
4494 
4495   ppc64_elf_tdata (abfd)->got = got;
4496   ppc64_elf_tdata (abfd)->relgot = relgot;
4497   return TRUE;
4498 }
4499 
4500 /* Create the dynamic sections, and set up shortcuts.  */
4501 
4502 static bfd_boolean
4503 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4504 {
4505   struct ppc_link_hash_table *htab;
4506 
4507   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4508     return FALSE;
4509 
4510   htab = ppc_hash_table (info);
4511   if (htab == NULL)
4512     return FALSE;
4513 
4514   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4515   if (!info->shared)
4516     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4517 
4518   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4519       || (!info->shared && !htab->relbss))
4520     abort ();
4521 
4522   return TRUE;
4523 }
4524 
4525 /* Follow indirect and warning symbol links.  */
4526 
4527 static inline struct bfd_link_hash_entry *
4528 follow_link (struct bfd_link_hash_entry *h)
4529 {
4530   while (h->type == bfd_link_hash_indirect
4531 	 || h->type == bfd_link_hash_warning)
4532     h = h->u.i.link;
4533   return h;
4534 }
4535 
4536 static inline struct elf_link_hash_entry *
4537 elf_follow_link (struct elf_link_hash_entry *h)
4538 {
4539   return (struct elf_link_hash_entry *) follow_link (&h->root);
4540 }
4541 
4542 static inline struct ppc_link_hash_entry *
4543 ppc_follow_link (struct ppc_link_hash_entry *h)
4544 {
4545   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4546 }
4547 
4548 /* Merge PLT info on FROM with that on TO.  */
4549 
4550 static void
4551 move_plt_plist (struct ppc_link_hash_entry *from,
4552 		struct ppc_link_hash_entry *to)
4553 {
4554   if (from->elf.plt.plist != NULL)
4555     {
4556       if (to->elf.plt.plist != NULL)
4557 	{
4558 	  struct plt_entry **entp;
4559 	  struct plt_entry *ent;
4560 
4561 	  for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4562 	    {
4563 	      struct plt_entry *dent;
4564 
4565 	      for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4566 		if (dent->addend == ent->addend)
4567 		  {
4568 		    dent->plt.refcount += ent->plt.refcount;
4569 		    *entp = ent->next;
4570 		    break;
4571 		  }
4572 	      if (dent == NULL)
4573 		entp = &ent->next;
4574 	    }
4575 	  *entp = to->elf.plt.plist;
4576 	}
4577 
4578       to->elf.plt.plist = from->elf.plt.plist;
4579       from->elf.plt.plist = NULL;
4580     }
4581 }
4582 
4583 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4584 
4585 static void
4586 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4587 				struct elf_link_hash_entry *dir,
4588 				struct elf_link_hash_entry *ind)
4589 {
4590   struct ppc_link_hash_entry *edir, *eind;
4591 
4592   edir = (struct ppc_link_hash_entry *) dir;
4593   eind = (struct ppc_link_hash_entry *) ind;
4594 
4595   edir->is_func |= eind->is_func;
4596   edir->is_func_descriptor |= eind->is_func_descriptor;
4597   edir->tls_mask |= eind->tls_mask;
4598   if (eind->oh != NULL)
4599     edir->oh = ppc_follow_link (eind->oh);
4600 
4601   /* If called to transfer flags for a weakdef during processing
4602      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4603      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4604   if (!(ELIMINATE_COPY_RELOCS
4605 	&& eind->elf.root.type != bfd_link_hash_indirect
4606 	&& edir->elf.dynamic_adjusted))
4607     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4608 
4609   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4610   edir->elf.ref_regular |= eind->elf.ref_regular;
4611   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4612   edir->elf.needs_plt |= eind->elf.needs_plt;
4613   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4614 
4615   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4616   if (eind->dyn_relocs != NULL)
4617     {
4618       if (edir->dyn_relocs != NULL)
4619 	{
4620 	  struct elf_dyn_relocs **pp;
4621 	  struct elf_dyn_relocs *p;
4622 
4623 	  /* Add reloc counts against the indirect sym to the direct sym
4624 	     list.  Merge any entries against the same section.  */
4625 	  for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4626 	    {
4627 	      struct elf_dyn_relocs *q;
4628 
4629 	      for (q = edir->dyn_relocs; q != NULL; q = q->next)
4630 		if (q->sec == p->sec)
4631 		  {
4632 		    q->pc_count += p->pc_count;
4633 		    q->count += p->count;
4634 		    *pp = p->next;
4635 		    break;
4636 		  }
4637 	      if (q == NULL)
4638 		pp = &p->next;
4639 	    }
4640 	  *pp = edir->dyn_relocs;
4641 	}
4642 
4643       edir->dyn_relocs = eind->dyn_relocs;
4644       eind->dyn_relocs = NULL;
4645     }
4646 
4647   /* If we were called to copy over info for a weak sym, that's all.
4648      You might think dyn_relocs need not be copied over;  After all,
4649      both syms will be dynamic or both non-dynamic so we're just
4650      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4651      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4652      dyn_relocs in read-only sections, and it does so on what is the
4653      DIR sym here.  */
4654   if (eind->elf.root.type != bfd_link_hash_indirect)
4655     return;
4656 
4657   /* Copy over got entries that we may have already seen to the
4658      symbol which just became indirect.  */
4659   if (eind->elf.got.glist != NULL)
4660     {
4661       if (edir->elf.got.glist != NULL)
4662 	{
4663 	  struct got_entry **entp;
4664 	  struct got_entry *ent;
4665 
4666 	  for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4667 	    {
4668 	      struct got_entry *dent;
4669 
4670 	      for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4671 		if (dent->addend == ent->addend
4672 		    && dent->owner == ent->owner
4673 		    && dent->tls_type == ent->tls_type)
4674 		  {
4675 		    dent->got.refcount += ent->got.refcount;
4676 		    *entp = ent->next;
4677 		    break;
4678 		  }
4679 	      if (dent == NULL)
4680 		entp = &ent->next;
4681 	    }
4682 	  *entp = edir->elf.got.glist;
4683 	}
4684 
4685       edir->elf.got.glist = eind->elf.got.glist;
4686       eind->elf.got.glist = NULL;
4687     }
4688 
4689   /* And plt entries.  */
4690   move_plt_plist (eind, edir);
4691 
4692   if (eind->elf.dynindx != -1)
4693     {
4694       if (edir->elf.dynindx != -1)
4695 	_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4696 				edir->elf.dynstr_index);
4697       edir->elf.dynindx = eind->elf.dynindx;
4698       edir->elf.dynstr_index = eind->elf.dynstr_index;
4699       eind->elf.dynindx = -1;
4700       eind->elf.dynstr_index = 0;
4701     }
4702 }
4703 
4704 /* Find the function descriptor hash entry from the given function code
4705    hash entry FH.  Link the entries via their OH fields.  */
4706 
4707 static struct ppc_link_hash_entry *
4708 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4709 {
4710   struct ppc_link_hash_entry *fdh = fh->oh;
4711 
4712   if (fdh == NULL)
4713     {
4714       const char *fd_name = fh->elf.root.root.string + 1;
4715 
4716       fdh = (struct ppc_link_hash_entry *)
4717 	elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4718       if (fdh == NULL)
4719 	return fdh;
4720 
4721       fdh->is_func_descriptor = 1;
4722       fdh->oh = fh;
4723       fh->is_func = 1;
4724       fh->oh = fdh;
4725     }
4726 
4727   return ppc_follow_link (fdh);
4728 }
4729 
4730 /* Make a fake function descriptor sym for the code sym FH.  */
4731 
4732 static struct ppc_link_hash_entry *
4733 make_fdh (struct bfd_link_info *info,
4734 	  struct ppc_link_hash_entry *fh)
4735 {
4736   bfd *abfd;
4737   asymbol *newsym;
4738   struct bfd_link_hash_entry *bh;
4739   struct ppc_link_hash_entry *fdh;
4740 
4741   abfd = fh->elf.root.u.undef.abfd;
4742   newsym = bfd_make_empty_symbol (abfd);
4743   newsym->name = fh->elf.root.root.string + 1;
4744   newsym->section = bfd_und_section_ptr;
4745   newsym->value = 0;
4746   newsym->flags = BSF_WEAK;
4747 
4748   bh = NULL;
4749   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4750 					 newsym->flags, newsym->section,
4751 					 newsym->value, NULL, FALSE, FALSE,
4752 					 &bh))
4753     return NULL;
4754 
4755   fdh = (struct ppc_link_hash_entry *) bh;
4756   fdh->elf.non_elf = 0;
4757   fdh->fake = 1;
4758   fdh->is_func_descriptor = 1;
4759   fdh->oh = fh;
4760   fh->is_func = 1;
4761   fh->oh = fdh;
4762   return fdh;
4763 }
4764 
4765 /* Fix function descriptor symbols defined in .opd sections to be
4766    function type.  */
4767 
4768 static bfd_boolean
4769 ppc64_elf_add_symbol_hook (bfd *ibfd,
4770 			   struct bfd_link_info *info,
4771 			   Elf_Internal_Sym *isym,
4772 			   const char **name,
4773 			   flagword *flags ATTRIBUTE_UNUSED,
4774 			   asection **sec,
4775 			   bfd_vma *value ATTRIBUTE_UNUSED)
4776 {
4777   if ((ibfd->flags & DYNAMIC) == 0
4778       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4779     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4780 
4781   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4782     {
4783       if ((ibfd->flags & DYNAMIC) == 0)
4784 	elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4785     }
4786   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4787     ;
4788   else if (*sec != NULL
4789 	   && strcmp ((*sec)->name, ".opd") == 0)
4790     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4791 
4792   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4793     {
4794       if (abiversion (ibfd) == 0)
4795 	set_abiversion (ibfd, 2);
4796       else if (abiversion (ibfd) == 1)
4797 	{
4798 	  info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4799 				    " for ABI version 1\n"), name);
4800 	  bfd_set_error (bfd_error_bad_value);
4801 	  return FALSE;
4802 	}
4803     }
4804 
4805   return TRUE;
4806 }
4807 
4808 /* Merge non-visibility st_other attributes: local entry point.  */
4809 
4810 static void
4811 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4812 				  const Elf_Internal_Sym *isym,
4813 				  bfd_boolean definition,
4814 				  bfd_boolean dynamic)
4815 {
4816   if (definition && !dynamic)
4817     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4818 		| ELF_ST_VISIBILITY (h->other));
4819 }
4820 
4821 /* This function makes an old ABI object reference to ".bar" cause the
4822    inclusion of a new ABI object archive that defines "bar".
4823    NAME is a symbol defined in an archive.  Return a symbol in the hash
4824    table that might be satisfied by the archive symbols.  */
4825 
4826 static struct elf_link_hash_entry *
4827 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4828 				 struct bfd_link_info *info,
4829 				 const char *name)
4830 {
4831   struct elf_link_hash_entry *h;
4832   char *dot_name;
4833   size_t len;
4834 
4835   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4836   if (h != NULL
4837       /* Don't return this sym if it is a fake function descriptor
4838 	 created by add_symbol_adjust.  */
4839       && !(h->root.type == bfd_link_hash_undefweak
4840 	   && ((struct ppc_link_hash_entry *) h)->fake))
4841     return h;
4842 
4843   if (name[0] == '.')
4844     return h;
4845 
4846   len = strlen (name);
4847   dot_name = bfd_alloc (abfd, len + 2);
4848   if (dot_name == NULL)
4849     return (struct elf_link_hash_entry *) 0 - 1;
4850   dot_name[0] = '.';
4851   memcpy (dot_name + 1, name, len + 1);
4852   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4853   bfd_release (abfd, dot_name);
4854   return h;
4855 }
4856 
4857 /* This function satisfies all old ABI object references to ".bar" if a
4858    new ABI object defines "bar".  Well, at least, undefined dot symbols
4859    are made weak.  This stops later archive searches from including an
4860    object if we already have a function descriptor definition.  It also
4861    prevents the linker complaining about undefined symbols.
4862    We also check and correct mismatched symbol visibility here.  The
4863    most restrictive visibility of the function descriptor and the
4864    function entry symbol is used.  */
4865 
4866 static bfd_boolean
4867 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4868 {
4869   struct ppc_link_hash_table *htab;
4870   struct ppc_link_hash_entry *fdh;
4871 
4872   if (eh->elf.root.type == bfd_link_hash_indirect)
4873     return TRUE;
4874 
4875   if (eh->elf.root.type == bfd_link_hash_warning)
4876     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4877 
4878   if (eh->elf.root.root.string[0] != '.')
4879     abort ();
4880 
4881   htab = ppc_hash_table (info);
4882   if (htab == NULL)
4883     return FALSE;
4884 
4885   fdh = lookup_fdh (eh, htab);
4886   if (fdh == NULL)
4887     {
4888       if (!info->relocatable
4889 	  && (eh->elf.root.type == bfd_link_hash_undefined
4890 	      || eh->elf.root.type == bfd_link_hash_undefweak)
4891 	  && eh->elf.ref_regular)
4892 	{
4893 	  /* Make an undefweak function descriptor sym, which is enough to
4894 	     pull in an --as-needed shared lib, but won't cause link
4895 	     errors.  Archives are handled elsewhere.  */
4896 	  fdh = make_fdh (info, eh);
4897 	  if (fdh == NULL)
4898 	    return FALSE;
4899 	  fdh->elf.ref_regular = 1;
4900 	}
4901     }
4902   else
4903     {
4904       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4905       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4906       if (entry_vis < descr_vis)
4907 	fdh->elf.other += entry_vis - descr_vis;
4908       else if (entry_vis > descr_vis)
4909 	eh->elf.other += descr_vis - entry_vis;
4910 
4911       if ((fdh->elf.root.type == bfd_link_hash_defined
4912 	   || fdh->elf.root.type == bfd_link_hash_defweak)
4913 	  && eh->elf.root.type == bfd_link_hash_undefined)
4914 	{
4915 	  eh->elf.root.type = bfd_link_hash_undefweak;
4916 	  eh->was_undefined = 1;
4917 	  htab->twiddled_syms = 1;
4918 	}
4919     }
4920 
4921   return TRUE;
4922 }
4923 
4924 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4925 
4926 static bfd_boolean
4927 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4928 {
4929   struct ppc_link_hash_table *htab;
4930   struct ppc_link_hash_entry **p, *eh;
4931 
4932   if (!is_ppc64_elf (info->output_bfd))
4933     return TRUE;
4934   htab = ppc_hash_table (info);
4935   if (htab == NULL)
4936     return FALSE;
4937 
4938   if (is_ppc64_elf (ibfd))
4939     {
4940       p = &htab->dot_syms;
4941       while ((eh = *p) != NULL)
4942 	{
4943 	  *p = NULL;
4944 	  if (&eh->elf == htab->elf.hgot)
4945 	    ;
4946 	  else if (htab->elf.hgot == NULL
4947 		   && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4948 	    htab->elf.hgot = &eh->elf;
4949 	  else if (!add_symbol_adjust (eh, info))
4950 	    return FALSE;
4951 	  p = &eh->u.next_dot_sym;
4952 	}
4953     }
4954 
4955   /* Clear the list for non-ppc64 input files.  */
4956   p = &htab->dot_syms;
4957   while ((eh = *p) != NULL)
4958     {
4959       *p = NULL;
4960       p = &eh->u.next_dot_sym;
4961     }
4962 
4963   /* We need to fix the undefs list for any syms we have twiddled to
4964      undef_weak.  */
4965   if (htab->twiddled_syms)
4966     {
4967       bfd_link_repair_undef_list (&htab->elf.root);
4968       htab->twiddled_syms = 0;
4969     }
4970   return TRUE;
4971 }
4972 
4973 /* Undo hash table changes when an --as-needed input file is determined
4974    not to be needed.  */
4975 
4976 static bfd_boolean
4977 ppc64_elf_notice_as_needed (bfd *ibfd,
4978 			    struct bfd_link_info *info,
4979 			    enum notice_asneeded_action act)
4980 {
4981   if (act == notice_not_needed)
4982     {
4983       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4984 
4985       if (htab == NULL)
4986 	return FALSE;
4987 
4988       htab->dot_syms = NULL;
4989     }
4990   return _bfd_elf_notice_as_needed (ibfd, info, act);
4991 }
4992 
4993 /* If --just-symbols against a final linked binary, then assume we need
4994    toc adjusting stubs when calling functions defined there.  */
4995 
4996 static void
4997 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4998 {
4999   if ((sec->flags & SEC_CODE) != 0
5000       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5001       && is_ppc64_elf (sec->owner))
5002     {
5003       if (abiversion (sec->owner) >= 2
5004 	  || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5005 	sec->has_toc_reloc = 1;
5006     }
5007   _bfd_elf_link_just_syms (sec, info);
5008 }
5009 
5010 static struct plt_entry **
5011 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5012 		       unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5013 {
5014   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5015   struct plt_entry **local_plt;
5016   unsigned char *local_got_tls_masks;
5017 
5018   if (local_got_ents == NULL)
5019     {
5020       bfd_size_type size = symtab_hdr->sh_info;
5021 
5022       size *= (sizeof (*local_got_ents)
5023 	       + sizeof (*local_plt)
5024 	       + sizeof (*local_got_tls_masks));
5025       local_got_ents = bfd_zalloc (abfd, size);
5026       if (local_got_ents == NULL)
5027 	return NULL;
5028       elf_local_got_ents (abfd) = local_got_ents;
5029     }
5030 
5031   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5032     {
5033       struct got_entry *ent;
5034 
5035       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5036 	if (ent->addend == r_addend
5037 	    && ent->owner == abfd
5038 	    && ent->tls_type == tls_type)
5039 	  break;
5040       if (ent == NULL)
5041 	{
5042 	  bfd_size_type amt = sizeof (*ent);
5043 	  ent = bfd_alloc (abfd, amt);
5044 	  if (ent == NULL)
5045 	    return FALSE;
5046 	  ent->next = local_got_ents[r_symndx];
5047 	  ent->addend = r_addend;
5048 	  ent->owner = abfd;
5049 	  ent->tls_type = tls_type;
5050 	  ent->is_indirect = FALSE;
5051 	  ent->got.refcount = 0;
5052 	  local_got_ents[r_symndx] = ent;
5053 	}
5054       ent->got.refcount += 1;
5055     }
5056 
5057   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5058   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5059   local_got_tls_masks[r_symndx] |= tls_type;
5060 
5061   return local_plt + r_symndx;
5062 }
5063 
5064 static bfd_boolean
5065 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5066 {
5067   struct plt_entry *ent;
5068 
5069   for (ent = *plist; ent != NULL; ent = ent->next)
5070     if (ent->addend == addend)
5071       break;
5072   if (ent == NULL)
5073     {
5074       bfd_size_type amt = sizeof (*ent);
5075       ent = bfd_alloc (abfd, amt);
5076       if (ent == NULL)
5077 	return FALSE;
5078       ent->next = *plist;
5079       ent->addend = addend;
5080       ent->plt.refcount = 0;
5081       *plist = ent;
5082     }
5083   ent->plt.refcount += 1;
5084   return TRUE;
5085 }
5086 
5087 static bfd_boolean
5088 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5089 {
5090   return (r_type == R_PPC64_REL24
5091 	  || r_type == R_PPC64_REL14
5092 	  || r_type == R_PPC64_REL14_BRTAKEN
5093 	  || r_type == R_PPC64_REL14_BRNTAKEN
5094 	  || r_type == R_PPC64_ADDR24
5095 	  || r_type == R_PPC64_ADDR14
5096 	  || r_type == R_PPC64_ADDR14_BRTAKEN
5097 	  || r_type == R_PPC64_ADDR14_BRNTAKEN);
5098 }
5099 
5100 /* Look through the relocs for a section during the first phase, and
5101    calculate needed space in the global offset table, procedure
5102    linkage table, and dynamic reloc sections.  */
5103 
5104 static bfd_boolean
5105 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5106 			asection *sec, const Elf_Internal_Rela *relocs)
5107 {
5108   struct ppc_link_hash_table *htab;
5109   Elf_Internal_Shdr *symtab_hdr;
5110   struct elf_link_hash_entry **sym_hashes;
5111   const Elf_Internal_Rela *rel;
5112   const Elf_Internal_Rela *rel_end;
5113   asection *sreloc;
5114   asection **opd_sym_map;
5115   struct elf_link_hash_entry *tga, *dottga;
5116 
5117   if (info->relocatable)
5118     return TRUE;
5119 
5120   /* Don't do anything special with non-loaded, non-alloced sections.
5121      In particular, any relocs in such sections should not affect GOT
5122      and PLT reference counting (ie. we don't allow them to create GOT
5123      or PLT entries), there's no possibility or desire to optimize TLS
5124      relocs, and there's not much point in propagating relocs to shared
5125      libs that the dynamic linker won't relocate.  */
5126   if ((sec->flags & SEC_ALLOC) == 0)
5127     return TRUE;
5128 
5129   BFD_ASSERT (is_ppc64_elf (abfd));
5130 
5131   htab = ppc_hash_table (info);
5132   if (htab == NULL)
5133     return FALSE;
5134 
5135   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5136 			      FALSE, FALSE, TRUE);
5137   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5138 				 FALSE, FALSE, TRUE);
5139   symtab_hdr = &elf_symtab_hdr (abfd);
5140   sym_hashes = elf_sym_hashes (abfd);
5141   sreloc = NULL;
5142   opd_sym_map = NULL;
5143   if (strcmp (sec->name, ".opd") == 0)
5144     {
5145       /* Garbage collection needs some extra help with .opd sections.
5146 	 We don't want to necessarily keep everything referenced by
5147 	 relocs in .opd, as that would keep all functions.  Instead,
5148 	 if we reference an .opd symbol (a function descriptor), we
5149 	 want to keep the function code symbol's section.  This is
5150 	 easy for global symbols, but for local syms we need to keep
5151 	 information about the associated function section.  */
5152       bfd_size_type amt;
5153 
5154       if (abiversion (abfd) == 0)
5155 	set_abiversion (abfd, 1);
5156       else if (abiversion (abfd) == 2)
5157 	{
5158 	  info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5159 				  abiversion (abfd));
5160 	  bfd_set_error (bfd_error_bad_value);
5161 	  return FALSE;
5162 	}
5163       amt = sec->size * sizeof (*opd_sym_map) / 8;
5164       opd_sym_map = bfd_zalloc (abfd, amt);
5165       if (opd_sym_map == NULL)
5166 	return FALSE;
5167       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5168       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5169       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5170     }
5171 
5172   rel_end = relocs + sec->reloc_count;
5173   for (rel = relocs; rel < rel_end; rel++)
5174     {
5175       unsigned long r_symndx;
5176       struct elf_link_hash_entry *h;
5177       enum elf_ppc64_reloc_type r_type;
5178       int tls_type;
5179       struct _ppc64_elf_section_data *ppc64_sec;
5180       struct plt_entry **ifunc;
5181 
5182       r_symndx = ELF64_R_SYM (rel->r_info);
5183       if (r_symndx < symtab_hdr->sh_info)
5184 	h = NULL;
5185       else
5186 	{
5187 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5188 	  h = elf_follow_link (h);
5189 
5190 	  /* PR15323, ref flags aren't set for references in the same
5191 	     object.  */
5192 	  h->root.non_ir_ref = 1;
5193 
5194 	  if (h == htab->elf.hgot)
5195 	    sec->has_toc_reloc = 1;
5196 	}
5197 
5198       tls_type = 0;
5199       ifunc = NULL;
5200       if (h != NULL)
5201 	{
5202 	  if (h->type == STT_GNU_IFUNC)
5203 	    {
5204 	      h->needs_plt = 1;
5205 	      ifunc = &h->plt.plist;
5206 	    }
5207 	}
5208       else
5209 	{
5210 	  Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5211 							  abfd, r_symndx);
5212 	  if (isym == NULL)
5213 	    return FALSE;
5214 
5215 	  if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5216 	    {
5217 	      ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5218 					     rel->r_addend, PLT_IFUNC);
5219 	      if (ifunc == NULL)
5220 		return FALSE;
5221 	    }
5222 	}
5223       r_type = ELF64_R_TYPE (rel->r_info);
5224       if (is_branch_reloc (r_type))
5225 	{
5226 	  if (h != NULL && (h == tga || h == dottga))
5227 	    {
5228 	      if (rel != relocs
5229 		  && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5230 		      || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5231 		/* We have a new-style __tls_get_addr call with a marker
5232 		   reloc.  */
5233 		;
5234 	      else
5235 		/* Mark this section as having an old-style call.  */
5236 		sec->has_tls_get_addr_call = 1;
5237 	    }
5238 
5239 	  /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5240 	  if (ifunc != NULL
5241 	      && !update_plt_info (abfd, ifunc, rel->r_addend))
5242 	    return FALSE;
5243 	}
5244 
5245       switch (r_type)
5246 	{
5247 	case R_PPC64_TLSGD:
5248 	case R_PPC64_TLSLD:
5249 	  /* These special tls relocs tie a call to __tls_get_addr with
5250 	     its parameter symbol.  */
5251 	  break;
5252 
5253 	case R_PPC64_GOT_TLSLD16:
5254 	case R_PPC64_GOT_TLSLD16_LO:
5255 	case R_PPC64_GOT_TLSLD16_HI:
5256 	case R_PPC64_GOT_TLSLD16_HA:
5257 	  tls_type = TLS_TLS | TLS_LD;
5258 	  goto dogottls;
5259 
5260 	case R_PPC64_GOT_TLSGD16:
5261 	case R_PPC64_GOT_TLSGD16_LO:
5262 	case R_PPC64_GOT_TLSGD16_HI:
5263 	case R_PPC64_GOT_TLSGD16_HA:
5264 	  tls_type = TLS_TLS | TLS_GD;
5265 	  goto dogottls;
5266 
5267 	case R_PPC64_GOT_TPREL16_DS:
5268 	case R_PPC64_GOT_TPREL16_LO_DS:
5269 	case R_PPC64_GOT_TPREL16_HI:
5270 	case R_PPC64_GOT_TPREL16_HA:
5271 	  if (!info->executable)
5272 	    info->flags |= DF_STATIC_TLS;
5273 	  tls_type = TLS_TLS | TLS_TPREL;
5274 	  goto dogottls;
5275 
5276 	case R_PPC64_GOT_DTPREL16_DS:
5277 	case R_PPC64_GOT_DTPREL16_LO_DS:
5278 	case R_PPC64_GOT_DTPREL16_HI:
5279 	case R_PPC64_GOT_DTPREL16_HA:
5280 	  tls_type = TLS_TLS | TLS_DTPREL;
5281 	dogottls:
5282 	  sec->has_tls_reloc = 1;
5283 	  /* Fall thru */
5284 
5285 	case R_PPC64_GOT16:
5286 	case R_PPC64_GOT16_DS:
5287 	case R_PPC64_GOT16_HA:
5288 	case R_PPC64_GOT16_HI:
5289 	case R_PPC64_GOT16_LO:
5290 	case R_PPC64_GOT16_LO_DS:
5291 	  /* This symbol requires a global offset table entry.  */
5292 	  sec->has_toc_reloc = 1;
5293 	  if (r_type == R_PPC64_GOT_TLSLD16
5294 	      || r_type == R_PPC64_GOT_TLSGD16
5295 	      || r_type == R_PPC64_GOT_TPREL16_DS
5296 	      || r_type == R_PPC64_GOT_DTPREL16_DS
5297 	      || r_type == R_PPC64_GOT16
5298 	      || r_type == R_PPC64_GOT16_DS)
5299 	    {
5300 	      htab->do_multi_toc = 1;
5301 	      ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5302 	    }
5303 
5304 	  if (ppc64_elf_tdata (abfd)->got == NULL
5305 	      && !create_got_section (abfd, info))
5306 	    return FALSE;
5307 
5308 	  if (h != NULL)
5309 	    {
5310 	      struct ppc_link_hash_entry *eh;
5311 	      struct got_entry *ent;
5312 
5313 	      eh = (struct ppc_link_hash_entry *) h;
5314 	      for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5315 		if (ent->addend == rel->r_addend
5316 		    && ent->owner == abfd
5317 		    && ent->tls_type == tls_type)
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 = eh->elf.got.glist;
5326 		  ent->addend = rel->r_addend;
5327 		  ent->owner = abfd;
5328 		  ent->tls_type = tls_type;
5329 		  ent->is_indirect = FALSE;
5330 		  ent->got.refcount = 0;
5331 		  eh->elf.got.glist = ent;
5332 		}
5333 	      ent->got.refcount += 1;
5334 	      eh->tls_mask |= tls_type;
5335 	    }
5336 	  else
5337 	    /* This is a global offset table entry for a local symbol.  */
5338 	    if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5339 					rel->r_addend, tls_type))
5340 	      return FALSE;
5341 
5342 	  /* We may also need a plt entry if the symbol turns out to be
5343 	     an ifunc.  */
5344 	  if (h != NULL && !info->shared && abiversion (abfd) == 2)
5345 	    {
5346 	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5347 		return FALSE;
5348 	    }
5349 	  break;
5350 
5351 	case R_PPC64_PLT16_HA:
5352 	case R_PPC64_PLT16_HI:
5353 	case R_PPC64_PLT16_LO:
5354 	case R_PPC64_PLT32:
5355 	case R_PPC64_PLT64:
5356 	  /* This symbol requires a procedure linkage table entry.  We
5357 	     actually build the entry in adjust_dynamic_symbol,
5358 	     because this might be a case of linking PIC code without
5359 	     linking in any dynamic objects, in which case we don't
5360 	     need to generate a procedure linkage table after all.  */
5361 	  if (h == NULL)
5362 	    {
5363 	      /* It does not make sense to have a procedure linkage
5364 		 table entry for a local symbol.  */
5365 	      bfd_set_error (bfd_error_bad_value);
5366 	      return FALSE;
5367 	    }
5368 	  else
5369 	    {
5370 	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5371 		return FALSE;
5372 	      h->needs_plt = 1;
5373 	      if (h->root.root.string[0] == '.'
5374 		  && h->root.root.string[1] != '\0')
5375 		((struct ppc_link_hash_entry *) h)->is_func = 1;
5376 	    }
5377 	  break;
5378 
5379 	  /* The following relocations don't need to propagate the
5380 	     relocation if linking a shared object since they are
5381 	     section relative.  */
5382 	case R_PPC64_SECTOFF:
5383 	case R_PPC64_SECTOFF_LO:
5384 	case R_PPC64_SECTOFF_HI:
5385 	case R_PPC64_SECTOFF_HA:
5386 	case R_PPC64_SECTOFF_DS:
5387 	case R_PPC64_SECTOFF_LO_DS:
5388 	case R_PPC64_DTPREL16:
5389 	case R_PPC64_DTPREL16_LO:
5390 	case R_PPC64_DTPREL16_HI:
5391 	case R_PPC64_DTPREL16_HA:
5392 	case R_PPC64_DTPREL16_DS:
5393 	case R_PPC64_DTPREL16_LO_DS:
5394 	case R_PPC64_DTPREL16_HIGH:
5395 	case R_PPC64_DTPREL16_HIGHA:
5396 	case R_PPC64_DTPREL16_HIGHER:
5397 	case R_PPC64_DTPREL16_HIGHERA:
5398 	case R_PPC64_DTPREL16_HIGHEST:
5399 	case R_PPC64_DTPREL16_HIGHESTA:
5400 	  break;
5401 
5402 	  /* Nor do these.  */
5403 	case R_PPC64_REL16:
5404 	case R_PPC64_REL16_LO:
5405 	case R_PPC64_REL16_HI:
5406 	case R_PPC64_REL16_HA:
5407 	  break;
5408 
5409 	case R_PPC64_TOC16:
5410 	case R_PPC64_TOC16_DS:
5411 	  htab->do_multi_toc = 1;
5412 	  ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5413 	case R_PPC64_TOC16_LO:
5414 	case R_PPC64_TOC16_HI:
5415 	case R_PPC64_TOC16_HA:
5416 	case R_PPC64_TOC16_LO_DS:
5417 	  sec->has_toc_reloc = 1;
5418 	  break;
5419 
5420 	  /* This relocation describes the C++ object vtable hierarchy.
5421 	     Reconstruct it for later use during GC.  */
5422 	case R_PPC64_GNU_VTINHERIT:
5423 	  if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5424 	    return FALSE;
5425 	  break;
5426 
5427 	  /* This relocation describes which C++ vtable entries are actually
5428 	     used.  Record for later use during GC.  */
5429 	case R_PPC64_GNU_VTENTRY:
5430 	  BFD_ASSERT (h != NULL);
5431 	  if (h != NULL
5432 	      && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5433 	    return FALSE;
5434 	  break;
5435 
5436 	case R_PPC64_REL14:
5437 	case R_PPC64_REL14_BRTAKEN:
5438 	case R_PPC64_REL14_BRNTAKEN:
5439 	  {
5440 	    asection *dest = NULL;
5441 
5442 	    /* Heuristic: If jumping outside our section, chances are
5443 	       we are going to need a stub.  */
5444 	    if (h != NULL)
5445 	      {
5446 		/* If the sym is weak it may be overridden later, so
5447 		   don't assume we know where a weak sym lives.  */
5448 		if (h->root.type == bfd_link_hash_defined)
5449 		  dest = h->root.u.def.section;
5450 	      }
5451 	    else
5452 	      {
5453 		Elf_Internal_Sym *isym;
5454 
5455 		isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5456 					      abfd, r_symndx);
5457 		if (isym == NULL)
5458 		  return FALSE;
5459 
5460 		dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5461 	      }
5462 
5463 	    if (dest != sec)
5464 	      ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5465 	  }
5466 	  /* Fall through.  */
5467 
5468 	case R_PPC64_REL24:
5469 	  if (h != NULL && ifunc == NULL)
5470 	    {
5471 	      /* We may need a .plt entry if the function this reloc
5472 		 refers to is in a shared lib.  */
5473 	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5474 		return FALSE;
5475 	      h->needs_plt = 1;
5476 	      if (h->root.root.string[0] == '.'
5477 		  && h->root.root.string[1] != '\0')
5478 		((struct ppc_link_hash_entry *) h)->is_func = 1;
5479 	      if (h == tga || h == dottga)
5480 		sec->has_tls_reloc = 1;
5481 	    }
5482 	  break;
5483 
5484 	case R_PPC64_TPREL64:
5485 	  tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5486 	  if (!info->executable)
5487 	    info->flags |= DF_STATIC_TLS;
5488 	  goto dotlstoc;
5489 
5490 	case R_PPC64_DTPMOD64:
5491 	  if (rel + 1 < rel_end
5492 	      && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5493 	      && rel[1].r_offset == rel->r_offset + 8)
5494 	    tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5495 	  else
5496 	    tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5497 	  goto dotlstoc;
5498 
5499 	case R_PPC64_DTPREL64:
5500 	  tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5501 	  if (rel != relocs
5502 	      && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5503 	      && rel[-1].r_offset == rel->r_offset - 8)
5504 	    /* This is the second reloc of a dtpmod, dtprel pair.
5505 	       Don't mark with TLS_DTPREL.  */
5506 	    goto dodyn;
5507 
5508 	dotlstoc:
5509 	  sec->has_tls_reloc = 1;
5510 	  if (h != NULL)
5511 	    {
5512 	      struct ppc_link_hash_entry *eh;
5513 	      eh = (struct ppc_link_hash_entry *) h;
5514 	      eh->tls_mask |= tls_type;
5515 	    }
5516 	  else
5517 	    if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5518 					rel->r_addend, tls_type))
5519 	      return FALSE;
5520 
5521 	  ppc64_sec = ppc64_elf_section_data (sec);
5522 	  if (ppc64_sec->sec_type != sec_toc)
5523 	    {
5524 	      bfd_size_type amt;
5525 
5526 	      /* One extra to simplify get_tls_mask.  */
5527 	      amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5528 	      ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5529 	      if (ppc64_sec->u.toc.symndx == NULL)
5530 		return FALSE;
5531 	      amt = sec->size * sizeof (bfd_vma) / 8;
5532 	      ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5533 	      if (ppc64_sec->u.toc.add == NULL)
5534 		return FALSE;
5535 	      BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5536 	      ppc64_sec->sec_type = sec_toc;
5537 	    }
5538 	  BFD_ASSERT (rel->r_offset % 8 == 0);
5539 	  ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5540 	  ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5541 
5542 	  /* Mark the second slot of a GD or LD entry.
5543 	     -1 to indicate GD and -2 to indicate LD.  */
5544 	  if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5545 	    ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5546 	  else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5547 	    ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5548 	  goto dodyn;
5549 
5550 	case R_PPC64_TPREL16:
5551 	case R_PPC64_TPREL16_LO:
5552 	case R_PPC64_TPREL16_HI:
5553 	case R_PPC64_TPREL16_HA:
5554 	case R_PPC64_TPREL16_DS:
5555 	case R_PPC64_TPREL16_LO_DS:
5556 	case R_PPC64_TPREL16_HIGH:
5557 	case R_PPC64_TPREL16_HIGHA:
5558 	case R_PPC64_TPREL16_HIGHER:
5559 	case R_PPC64_TPREL16_HIGHERA:
5560 	case R_PPC64_TPREL16_HIGHEST:
5561 	case R_PPC64_TPREL16_HIGHESTA:
5562 	  if (info->shared)
5563 	    {
5564 	      if (!info->executable)
5565 		info->flags |= DF_STATIC_TLS;
5566 	      goto dodyn;
5567 	    }
5568 	  break;
5569 
5570 	case R_PPC64_ADDR64:
5571 	  if (opd_sym_map != NULL
5572 	      && rel + 1 < rel_end
5573 	      && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5574 	    {
5575 	      if (h != NULL)
5576 		{
5577 		  if (h->root.root.string[0] == '.'
5578 		      && h->root.root.string[1] != 0
5579 		      && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5580 		    ;
5581 		  else
5582 		    ((struct ppc_link_hash_entry *) h)->is_func = 1;
5583 		}
5584 	      else
5585 		{
5586 		  asection *s;
5587 		  Elf_Internal_Sym *isym;
5588 
5589 		  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5590 						abfd, r_symndx);
5591 		  if (isym == NULL)
5592 		    return FALSE;
5593 
5594 		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5595 		  if (s != NULL && s != sec)
5596 		    opd_sym_map[rel->r_offset / 8] = s;
5597 		}
5598 	    }
5599 	  /* Fall through.  */
5600 
5601 	case R_PPC64_ADDR16:
5602 	case R_PPC64_ADDR16_DS:
5603 	case R_PPC64_ADDR16_HA:
5604 	case R_PPC64_ADDR16_HI:
5605 	case R_PPC64_ADDR16_HIGH:
5606 	case R_PPC64_ADDR16_HIGHA:
5607 	case R_PPC64_ADDR16_HIGHER:
5608 	case R_PPC64_ADDR16_HIGHERA:
5609 	case R_PPC64_ADDR16_HIGHEST:
5610 	case R_PPC64_ADDR16_HIGHESTA:
5611 	case R_PPC64_ADDR16_LO:
5612 	case R_PPC64_ADDR16_LO_DS:
5613 	  if (h != NULL && !info->shared && abiversion (abfd) == 2
5614 	      && rel->r_addend == 0)
5615 	    {
5616 	      /* We may need a .plt entry if this reloc refers to a
5617 		 function in a shared lib.  */
5618 	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5619 		return FALSE;
5620 	      h->pointer_equality_needed = 1;
5621 	    }
5622 	  /* Fall through.  */
5623 
5624 	case R_PPC64_REL30:
5625 	case R_PPC64_REL32:
5626 	case R_PPC64_REL64:
5627 	case R_PPC64_ADDR14:
5628 	case R_PPC64_ADDR14_BRNTAKEN:
5629 	case R_PPC64_ADDR14_BRTAKEN:
5630 	case R_PPC64_ADDR24:
5631 	case R_PPC64_ADDR32:
5632 	case R_PPC64_UADDR16:
5633 	case R_PPC64_UADDR32:
5634 	case R_PPC64_UADDR64:
5635 	case R_PPC64_TOC:
5636 	  if (h != NULL && !info->shared)
5637 	    /* We may need a copy reloc.  */
5638 	    h->non_got_ref = 1;
5639 
5640 	  /* Don't propagate .opd relocs.  */
5641 	  if (NO_OPD_RELOCS && opd_sym_map != NULL)
5642 	    break;
5643 
5644 	  /* If we are creating a shared library, and this is a reloc
5645 	     against a global symbol, or a non PC relative reloc
5646 	     against a local symbol, then we need to copy the reloc
5647 	     into the shared library.  However, if we are linking with
5648 	     -Bsymbolic, we do not need to copy a reloc against a
5649 	     global symbol which is defined in an object we are
5650 	     including in the link (i.e., DEF_REGULAR is set).  At
5651 	     this point we have not seen all the input files, so it is
5652 	     possible that DEF_REGULAR is not set now but will be set
5653 	     later (it is never cleared).  In case of a weak definition,
5654 	     DEF_REGULAR may be cleared later by a strong definition in
5655 	     a shared library.  We account for that possibility below by
5656 	     storing information in the dyn_relocs field of the hash
5657 	     table entry.  A similar situation occurs when creating
5658 	     shared libraries and symbol visibility changes render the
5659 	     symbol local.
5660 
5661 	     If on the other hand, we are creating an executable, we
5662 	     may need to keep relocations for symbols satisfied by a
5663 	     dynamic library if we manage to avoid copy relocs for the
5664 	     symbol.  */
5665 	dodyn:
5666 	  if ((info->shared
5667 	       && (must_be_dyn_reloc (info, r_type)
5668 		   || (h != NULL
5669 		       && (!SYMBOLIC_BIND (info, h)
5670 			   || h->root.type == bfd_link_hash_defweak
5671 			   || !h->def_regular))))
5672 	      || (ELIMINATE_COPY_RELOCS
5673 		  && !info->shared
5674 		  && h != NULL
5675 		  && (h->root.type == bfd_link_hash_defweak
5676 		      || !h->def_regular))
5677 	      || (!info->shared
5678 		  && ifunc != NULL))
5679 	    {
5680 	      /* We must copy these reloc types into the output file.
5681 		 Create a reloc section in dynobj and make room for
5682 		 this reloc.  */
5683 	      if (sreloc == NULL)
5684 		{
5685 		  sreloc = _bfd_elf_make_dynamic_reloc_section
5686 		    (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5687 
5688 		  if (sreloc == NULL)
5689 		    return FALSE;
5690 		}
5691 
5692 	      /* If this is a global symbol, we count the number of
5693 		 relocations we need for this symbol.  */
5694 	      if (h != NULL)
5695 		{
5696 		  struct elf_dyn_relocs *p;
5697 		  struct elf_dyn_relocs **head;
5698 
5699 		  head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5700 		  p = *head;
5701 		  if (p == NULL || p->sec != sec)
5702 		    {
5703 		      p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5704 		      if (p == NULL)
5705 			return FALSE;
5706 		      p->next = *head;
5707 		      *head = p;
5708 		      p->sec = sec;
5709 		      p->count = 0;
5710 		      p->pc_count = 0;
5711 		    }
5712 		  p->count += 1;
5713 		  if (!must_be_dyn_reloc (info, r_type))
5714 		    p->pc_count += 1;
5715 		}
5716 	      else
5717 		{
5718 		  /* Track dynamic relocs needed for local syms too.
5719 		     We really need local syms available to do this
5720 		     easily.  Oh well.  */
5721 		  struct ppc_dyn_relocs *p;
5722 		  struct ppc_dyn_relocs **head;
5723 		  bfd_boolean is_ifunc;
5724 		  asection *s;
5725 		  void *vpp;
5726 		  Elf_Internal_Sym *isym;
5727 
5728 		  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5729 						abfd, r_symndx);
5730 		  if (isym == NULL)
5731 		    return FALSE;
5732 
5733 		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5734 		  if (s == NULL)
5735 		    s = sec;
5736 
5737 		  vpp = &elf_section_data (s)->local_dynrel;
5738 		  head = (struct ppc_dyn_relocs **) vpp;
5739 		  is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5740 		  p = *head;
5741 		  if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5742 		    p = p->next;
5743 		  if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5744 		    {
5745 		      p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5746 		      if (p == NULL)
5747 			return FALSE;
5748 		      p->next = *head;
5749 		      *head = p;
5750 		      p->sec = sec;
5751 		      p->ifunc = is_ifunc;
5752 		      p->count = 0;
5753 		    }
5754 		  p->count += 1;
5755 		}
5756 	    }
5757 	  break;
5758 
5759 	default:
5760 	  break;
5761 	}
5762     }
5763 
5764   return TRUE;
5765 }
5766 
5767 /* Merge backend specific data from an object file to the output
5768    object file when linking.  */
5769 
5770 static bfd_boolean
5771 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5772 {
5773   unsigned long iflags, oflags;
5774 
5775   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5776     return TRUE;
5777 
5778   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5779     return TRUE;
5780 
5781   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5782     return FALSE;
5783 
5784   iflags = elf_elfheader (ibfd)->e_flags;
5785   oflags = elf_elfheader (obfd)->e_flags;
5786 
5787   if (!elf_flags_init (obfd) || oflags == 0)
5788     {
5789       elf_flags_init (obfd) = TRUE;
5790       elf_elfheader (obfd)->e_flags = iflags;
5791     }
5792   else if (iflags == oflags || iflags == 0)
5793     ;
5794   else if (iflags & ~EF_PPC64_ABI)
5795     {
5796       (*_bfd_error_handler)
5797 	(_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5798       bfd_set_error (bfd_error_bad_value);
5799       return FALSE;
5800     }
5801   else
5802     {
5803       (*_bfd_error_handler)
5804 	(_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5805 	 ibfd, iflags, oflags);
5806       bfd_set_error (bfd_error_bad_value);
5807       return FALSE;
5808     }
5809 
5810   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5811   _bfd_elf_merge_object_attributes (ibfd, obfd);
5812 
5813   return TRUE;
5814 }
5815 
5816 static bfd_boolean
5817 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5818 {
5819   /* Print normal ELF private data.  */
5820   _bfd_elf_print_private_bfd_data (abfd, ptr);
5821 
5822   if (elf_elfheader (abfd)->e_flags != 0)
5823     {
5824       FILE *file = ptr;
5825 
5826       /* xgettext:c-format */
5827       fprintf (file, _("private flags = 0x%lx:"),
5828 	       elf_elfheader (abfd)->e_flags);
5829 
5830       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5831 	fprintf (file, _(" [abiv%ld]"),
5832 		 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5833       fputc ('\n', file);
5834     }
5835 
5836   return TRUE;
5837 }
5838 
5839 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5840    of the code entry point, and its section.  */
5841 
5842 static bfd_vma
5843 opd_entry_value (asection *opd_sec,
5844 		 bfd_vma offset,
5845 		 asection **code_sec,
5846 		 bfd_vma *code_off,
5847 		 bfd_boolean in_code_sec)
5848 {
5849   bfd *opd_bfd = opd_sec->owner;
5850   Elf_Internal_Rela *relocs;
5851   Elf_Internal_Rela *lo, *hi, *look;
5852   bfd_vma val;
5853 
5854   /* No relocs implies we are linking a --just-symbols object, or looking
5855      at a final linked executable with addr2line or somesuch.  */
5856   if (opd_sec->reloc_count == 0)
5857     {
5858       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5859 
5860       if (contents == NULL)
5861 	{
5862 	  if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5863 	    return (bfd_vma) -1;
5864 	  ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5865 	}
5866 
5867       val = bfd_get_64 (opd_bfd, contents + offset);
5868       if (code_sec != NULL)
5869 	{
5870 	  asection *sec, *likely = NULL;
5871 
5872 	  if (in_code_sec)
5873 	    {
5874 	      sec = *code_sec;
5875 	      if (sec->vma <= val
5876 		  && val < sec->vma + sec->size)
5877 		likely = sec;
5878 	      else
5879 		val = -1;
5880 	    }
5881 	  else
5882 	    for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5883 	      if (sec->vma <= val
5884 		  && (sec->flags & SEC_LOAD) != 0
5885 		  && (sec->flags & SEC_ALLOC) != 0)
5886 		likely = sec;
5887 	  if (likely != NULL)
5888 	    {
5889 	      *code_sec = likely;
5890 	      if (code_off != NULL)
5891 		*code_off = val - likely->vma;
5892 	    }
5893 	}
5894       return val;
5895     }
5896 
5897   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5898 
5899   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5900   if (relocs == NULL)
5901     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5902 
5903   /* Go find the opd reloc at the sym address.  */
5904   lo = relocs;
5905   BFD_ASSERT (lo != NULL);
5906   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5907   val = (bfd_vma) -1;
5908   while (lo < hi)
5909     {
5910       look = lo + (hi - lo) / 2;
5911       if (look->r_offset < offset)
5912 	lo = look + 1;
5913       else if (look->r_offset > offset)
5914 	hi = look;
5915       else
5916 	{
5917 	  Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5918 
5919 	  if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5920 	      && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5921 	    {
5922 	      unsigned long symndx = ELF64_R_SYM (look->r_info);
5923 	      asection *sec;
5924 
5925 	      if (symndx < symtab_hdr->sh_info
5926 		  || elf_sym_hashes (opd_bfd) == NULL)
5927 		{
5928 		  Elf_Internal_Sym *sym;
5929 
5930 		  sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5931 		  if (sym == NULL)
5932 		    {
5933 		      size_t symcnt = symtab_hdr->sh_info;
5934 		      if (elf_sym_hashes (opd_bfd) == NULL)
5935 			symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5936 		      sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5937 						  0, NULL, NULL, NULL);
5938 		      if (sym == NULL)
5939 			break;
5940 		      symtab_hdr->contents = (bfd_byte *) sym;
5941 		    }
5942 
5943 		  sym += symndx;
5944 		  val = sym->st_value;
5945 		  sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5946 		  BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5947 		}
5948 	      else
5949 		{
5950 		  struct elf_link_hash_entry **sym_hashes;
5951 		  struct elf_link_hash_entry *rh;
5952 
5953 		  sym_hashes = elf_sym_hashes (opd_bfd);
5954 		  rh = sym_hashes[symndx - symtab_hdr->sh_info];
5955 		  if (rh != NULL)
5956 		    {
5957 		      rh = elf_follow_link (rh);
5958 		      BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5959 				  || rh->root.type == bfd_link_hash_defweak);
5960 		      val = rh->root.u.def.value;
5961 		      sec = rh->root.u.def.section;
5962 		    }
5963 		  else
5964 		    {
5965 		      /* Handle the odd case where we can be called
5966 			 during bfd_elf_link_add_symbols before the
5967 			 symbol hashes have been fully populated.  */
5968 		      Elf_Internal_Sym *sym;
5969 
5970 		      sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5971 						  symndx, NULL, NULL, NULL);
5972 		      if (sym == NULL)
5973 			break;
5974 
5975 		      val = sym->st_value;
5976 		      sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5977 		      free (sym);
5978 		    }
5979 		}
5980 	      val += look->r_addend;
5981 	      if (code_off != NULL)
5982 		*code_off = val;
5983 	      if (code_sec != NULL)
5984 		{
5985 		  if (in_code_sec && *code_sec != sec)
5986 		    return -1;
5987 		  else
5988 		    *code_sec = sec;
5989 		}
5990 	      if (sec != NULL && sec->output_section != NULL)
5991 		val += sec->output_section->vma + sec->output_offset;
5992 	    }
5993 	  break;
5994 	}
5995     }
5996 
5997   return val;
5998 }
5999 
6000 /* If the ELF symbol SYM might be a function in SEC, return the
6001    function size and set *CODE_OFF to the function's entry point,
6002    otherwise return zero.  */
6003 
6004 static bfd_size_type
6005 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6006 			      bfd_vma *code_off)
6007 {
6008   bfd_size_type size;
6009 
6010   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6011 		     | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6012     return 0;
6013 
6014   size = 0;
6015   if (!(sym->flags & BSF_SYNTHETIC))
6016     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6017 
6018   if (strcmp (sym->section->name, ".opd") == 0)
6019     {
6020       if (opd_entry_value (sym->section, sym->value,
6021 			   &sec, code_off, TRUE) == (bfd_vma) -1)
6022 	return 0;
6023       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6024 	 symbol.  This size has nothing to do with the code size of the
6025 	 function, which is what we're supposed to return, but the
6026 	 code size isn't available without looking up the dot-sym.
6027 	 However, doing that would be a waste of time particularly
6028 	 since elf_find_function will look at the dot-sym anyway.
6029 	 Now, elf_find_function will keep the largest size of any
6030 	 function sym found at the code address of interest, so return
6031 	 1 here to avoid it incorrectly caching a larger function size
6032 	 for a small function.  This does mean we return the wrong
6033 	 size for a new-ABI function of size 24, but all that does is
6034 	 disable caching for such functions.  */
6035       if (size == 24)
6036 	size = 1;
6037     }
6038   else
6039     {
6040       if (sym->section != sec)
6041 	return 0;
6042       *code_off = sym->value;
6043     }
6044   if (size == 0)
6045     size = 1;
6046   return size;
6047 }
6048 
6049 /* Return true if symbol is defined in a regular object file.  */
6050 
6051 static bfd_boolean
6052 is_static_defined (struct elf_link_hash_entry *h)
6053 {
6054   return ((h->root.type == bfd_link_hash_defined
6055 	   || h->root.type == bfd_link_hash_defweak)
6056 	  && h->root.u.def.section != NULL
6057 	  && h->root.u.def.section->output_section != NULL);
6058 }
6059 
6060 /* If FDH is a function descriptor symbol, return the associated code
6061    entry symbol if it is defined.  Return NULL otherwise.  */
6062 
6063 static struct ppc_link_hash_entry *
6064 defined_code_entry (struct ppc_link_hash_entry *fdh)
6065 {
6066   if (fdh->is_func_descriptor)
6067     {
6068       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6069       if (fh->elf.root.type == bfd_link_hash_defined
6070 	  || fh->elf.root.type == bfd_link_hash_defweak)
6071 	return fh;
6072     }
6073   return NULL;
6074 }
6075 
6076 /* If FH is a function code entry symbol, return the associated
6077    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6078 
6079 static struct ppc_link_hash_entry *
6080 defined_func_desc (struct ppc_link_hash_entry *fh)
6081 {
6082   if (fh->oh != NULL
6083       && fh->oh->is_func_descriptor)
6084     {
6085       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6086       if (fdh->elf.root.type == bfd_link_hash_defined
6087 	  || fdh->elf.root.type == bfd_link_hash_defweak)
6088 	return fdh;
6089     }
6090   return NULL;
6091 }
6092 
6093 /* Mark all our entry sym sections, both opd and code section.  */
6094 
6095 static void
6096 ppc64_elf_gc_keep (struct bfd_link_info *info)
6097 {
6098   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6099   struct bfd_sym_chain *sym;
6100 
6101   if (htab == NULL)
6102     return;
6103 
6104   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6105     {
6106       struct ppc_link_hash_entry *eh, *fh;
6107       asection *sec;
6108 
6109       eh = (struct ppc_link_hash_entry *)
6110 	elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6111       if (eh == NULL)
6112 	continue;
6113       if (eh->elf.root.type != bfd_link_hash_defined
6114 	  && eh->elf.root.type != bfd_link_hash_defweak)
6115 	continue;
6116 
6117       fh = defined_code_entry (eh);
6118       if (fh != NULL)
6119 	{
6120 	  sec = fh->elf.root.u.def.section;
6121 	  sec->flags |= SEC_KEEP;
6122 	}
6123       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6124 	       && opd_entry_value (eh->elf.root.u.def.section,
6125 				   eh->elf.root.u.def.value,
6126 				   &sec, NULL, FALSE) != (bfd_vma) -1)
6127 	sec->flags |= SEC_KEEP;
6128 
6129       sec = eh->elf.root.u.def.section;
6130       sec->flags |= SEC_KEEP;
6131     }
6132 }
6133 
6134 /* Mark sections containing dynamically referenced symbols.  When
6135    building shared libraries, we must assume that any visible symbol is
6136    referenced.  */
6137 
6138 static bfd_boolean
6139 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6140 {
6141   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6142   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6143   struct ppc_link_hash_entry *fdh;
6144 
6145   /* Dynamic linking info is on the func descriptor sym.  */
6146   fdh = defined_func_desc (eh);
6147   if (fdh != NULL)
6148     eh = fdh;
6149 
6150   if ((eh->elf.root.type == bfd_link_hash_defined
6151        || eh->elf.root.type == bfd_link_hash_defweak)
6152       && (eh->elf.ref_dynamic
6153 	  || (!info->executable
6154 	      && eh->elf.def_regular
6155 	      && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6156 	      && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6157 	      && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6158 		  || !bfd_hide_sym_by_version (info->version_info,
6159 					       eh->elf.root.root.string)))))
6160     {
6161       asection *code_sec;
6162       struct ppc_link_hash_entry *fh;
6163 
6164       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6165 
6166       /* Function descriptor syms cause the associated
6167 	 function code sym section to be marked.  */
6168       fh = defined_code_entry (eh);
6169       if (fh != NULL)
6170 	{
6171 	  code_sec = fh->elf.root.u.def.section;
6172 	  code_sec->flags |= SEC_KEEP;
6173 	}
6174       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6175 	       && opd_entry_value (eh->elf.root.u.def.section,
6176 				   eh->elf.root.u.def.value,
6177 				   &code_sec, NULL, FALSE) != (bfd_vma) -1)
6178 	code_sec->flags |= SEC_KEEP;
6179     }
6180 
6181   return TRUE;
6182 }
6183 
6184 /* Return the section that should be marked against GC for a given
6185    relocation.  */
6186 
6187 static asection *
6188 ppc64_elf_gc_mark_hook (asection *sec,
6189 			struct bfd_link_info *info,
6190 			Elf_Internal_Rela *rel,
6191 			struct elf_link_hash_entry *h,
6192 			Elf_Internal_Sym *sym)
6193 {
6194   asection *rsec;
6195 
6196   /* Syms return NULL if we're marking .opd, so we avoid marking all
6197      function sections, as all functions are referenced in .opd.  */
6198   rsec = NULL;
6199   if (get_opd_info (sec) != NULL)
6200     return rsec;
6201 
6202   if (h != NULL)
6203     {
6204       enum elf_ppc64_reloc_type r_type;
6205       struct ppc_link_hash_entry *eh, *fh, *fdh;
6206 
6207       r_type = ELF64_R_TYPE (rel->r_info);
6208       switch (r_type)
6209 	{
6210 	case R_PPC64_GNU_VTINHERIT:
6211 	case R_PPC64_GNU_VTENTRY:
6212 	  break;
6213 
6214 	default:
6215 	  switch (h->root.type)
6216 	    {
6217 	    case bfd_link_hash_defined:
6218 	    case bfd_link_hash_defweak:
6219 	      eh = (struct ppc_link_hash_entry *) h;
6220 	      fdh = defined_func_desc (eh);
6221 	      if (fdh != NULL)
6222 		eh = fdh;
6223 
6224 	      /* Function descriptor syms cause the associated
6225 		 function code sym section to be marked.  */
6226 	      fh = defined_code_entry (eh);
6227 	      if (fh != NULL)
6228 		{
6229 		  /* They also mark their opd section.  */
6230 		  eh->elf.root.u.def.section->gc_mark = 1;
6231 
6232 		  rsec = fh->elf.root.u.def.section;
6233 		}
6234 	      else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6235 		       && opd_entry_value (eh->elf.root.u.def.section,
6236 					   eh->elf.root.u.def.value,
6237 					   &rsec, NULL, FALSE) != (bfd_vma) -1)
6238 		eh->elf.root.u.def.section->gc_mark = 1;
6239 	      else
6240 		rsec = h->root.u.def.section;
6241 	      break;
6242 
6243 	    case bfd_link_hash_common:
6244 	      rsec = h->root.u.c.p->section;
6245 	      break;
6246 
6247 	    default:
6248 	      return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6249 	    }
6250 	}
6251     }
6252   else
6253     {
6254       struct _opd_sec_data *opd;
6255 
6256       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6257       opd = get_opd_info (rsec);
6258       if (opd != NULL && opd->func_sec != NULL)
6259 	{
6260 	  rsec->gc_mark = 1;
6261 
6262 	  rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6263 	}
6264     }
6265 
6266   return rsec;
6267 }
6268 
6269 /* Update the .got, .plt. and dynamic reloc reference counts for the
6270    section being removed.  */
6271 
6272 static bfd_boolean
6273 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6274 			 asection *sec, const Elf_Internal_Rela *relocs)
6275 {
6276   struct ppc_link_hash_table *htab;
6277   Elf_Internal_Shdr *symtab_hdr;
6278   struct elf_link_hash_entry **sym_hashes;
6279   struct got_entry **local_got_ents;
6280   const Elf_Internal_Rela *rel, *relend;
6281 
6282   if (info->relocatable)
6283     return TRUE;
6284 
6285   if ((sec->flags & SEC_ALLOC) == 0)
6286     return TRUE;
6287 
6288   elf_section_data (sec)->local_dynrel = NULL;
6289 
6290   htab = ppc_hash_table (info);
6291   if (htab == NULL)
6292     return FALSE;
6293 
6294   symtab_hdr = &elf_symtab_hdr (abfd);
6295   sym_hashes = elf_sym_hashes (abfd);
6296   local_got_ents = elf_local_got_ents (abfd);
6297 
6298   relend = relocs + sec->reloc_count;
6299   for (rel = relocs; rel < relend; rel++)
6300     {
6301       unsigned long r_symndx;
6302       enum elf_ppc64_reloc_type r_type;
6303       struct elf_link_hash_entry *h = NULL;
6304       unsigned char tls_type = 0;
6305 
6306       r_symndx = ELF64_R_SYM (rel->r_info);
6307       r_type = ELF64_R_TYPE (rel->r_info);
6308       if (r_symndx >= symtab_hdr->sh_info)
6309 	{
6310 	  struct ppc_link_hash_entry *eh;
6311 	  struct elf_dyn_relocs **pp;
6312 	  struct elf_dyn_relocs *p;
6313 
6314 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6315 	  h = elf_follow_link (h);
6316 	  eh = (struct ppc_link_hash_entry *) h;
6317 
6318 	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6319 	    if (p->sec == sec)
6320 	      {
6321 		/* Everything must go for SEC.  */
6322 		*pp = p->next;
6323 		break;
6324 	      }
6325 	}
6326 
6327       if (is_branch_reloc (r_type))
6328 	{
6329 	  struct plt_entry **ifunc = NULL;
6330 	  if (h != NULL)
6331 	    {
6332 	      if (h->type == STT_GNU_IFUNC)
6333 		ifunc = &h->plt.plist;
6334 	    }
6335 	  else if (local_got_ents != NULL)
6336 	    {
6337 	      struct plt_entry **local_plt = (struct plt_entry **)
6338 		(local_got_ents + symtab_hdr->sh_info);
6339 	      unsigned char *local_got_tls_masks = (unsigned char *)
6340 		(local_plt + symtab_hdr->sh_info);
6341 	      if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6342 		ifunc = local_plt + r_symndx;
6343 	    }
6344 	  if (ifunc != NULL)
6345 	    {
6346 	      struct plt_entry *ent;
6347 
6348 	      for (ent = *ifunc; ent != NULL; ent = ent->next)
6349 		if (ent->addend == rel->r_addend)
6350 		  break;
6351 	      if (ent == NULL)
6352 		abort ();
6353 	      if (ent->plt.refcount > 0)
6354 		ent->plt.refcount -= 1;
6355 	      continue;
6356 	    }
6357 	}
6358 
6359       switch (r_type)
6360 	{
6361 	case R_PPC64_GOT_TLSLD16:
6362 	case R_PPC64_GOT_TLSLD16_LO:
6363 	case R_PPC64_GOT_TLSLD16_HI:
6364 	case R_PPC64_GOT_TLSLD16_HA:
6365 	  tls_type = TLS_TLS | TLS_LD;
6366 	  goto dogot;
6367 
6368 	case R_PPC64_GOT_TLSGD16:
6369 	case R_PPC64_GOT_TLSGD16_LO:
6370 	case R_PPC64_GOT_TLSGD16_HI:
6371 	case R_PPC64_GOT_TLSGD16_HA:
6372 	  tls_type = TLS_TLS | TLS_GD;
6373 	  goto dogot;
6374 
6375 	case R_PPC64_GOT_TPREL16_DS:
6376 	case R_PPC64_GOT_TPREL16_LO_DS:
6377 	case R_PPC64_GOT_TPREL16_HI:
6378 	case R_PPC64_GOT_TPREL16_HA:
6379 	  tls_type = TLS_TLS | TLS_TPREL;
6380 	  goto dogot;
6381 
6382 	case R_PPC64_GOT_DTPREL16_DS:
6383 	case R_PPC64_GOT_DTPREL16_LO_DS:
6384 	case R_PPC64_GOT_DTPREL16_HI:
6385 	case R_PPC64_GOT_DTPREL16_HA:
6386 	  tls_type = TLS_TLS | TLS_DTPREL;
6387 	  goto dogot;
6388 
6389 	case R_PPC64_GOT16:
6390 	case R_PPC64_GOT16_DS:
6391 	case R_PPC64_GOT16_HA:
6392 	case R_PPC64_GOT16_HI:
6393 	case R_PPC64_GOT16_LO:
6394 	case R_PPC64_GOT16_LO_DS:
6395 	dogot:
6396 	  {
6397 	    struct got_entry *ent;
6398 
6399 	    if (h != NULL)
6400 	      ent = h->got.glist;
6401 	    else
6402 	      ent = local_got_ents[r_symndx];
6403 
6404 	    for (; ent != NULL; ent = ent->next)
6405 	      if (ent->addend == rel->r_addend
6406 		  && ent->owner == abfd
6407 		  && ent->tls_type == tls_type)
6408 		break;
6409 	    if (ent == NULL)
6410 	      abort ();
6411 	    if (ent->got.refcount > 0)
6412 	      ent->got.refcount -= 1;
6413 	  }
6414 	  break;
6415 
6416 	case R_PPC64_PLT16_HA:
6417 	case R_PPC64_PLT16_HI:
6418 	case R_PPC64_PLT16_LO:
6419 	case R_PPC64_PLT32:
6420 	case R_PPC64_PLT64:
6421 	case R_PPC64_REL14:
6422 	case R_PPC64_REL14_BRNTAKEN:
6423 	case R_PPC64_REL14_BRTAKEN:
6424 	case R_PPC64_REL24:
6425 	  if (h != NULL)
6426 	    {
6427 	      struct plt_entry *ent;
6428 
6429 	      for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6430 		if (ent->addend == rel->r_addend)
6431 		  break;
6432 	      if (ent != NULL && ent->plt.refcount > 0)
6433 		ent->plt.refcount -= 1;
6434 	    }
6435 	  break;
6436 
6437 	default:
6438 	  break;
6439 	}
6440     }
6441   return TRUE;
6442 }
6443 
6444 /* The maximum size of .sfpr.  */
6445 #define SFPR_MAX (218*4)
6446 
6447 struct sfpr_def_parms
6448 {
6449   const char name[12];
6450   unsigned char lo, hi;
6451   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6452   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6453 };
6454 
6455 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6456 
6457 static bfd_boolean
6458 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6459 {
6460   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6461   unsigned int i;
6462   size_t len = strlen (parm->name);
6463   bfd_boolean writing = FALSE;
6464   char sym[16];
6465 
6466   if (htab == NULL)
6467     return FALSE;
6468 
6469   memcpy (sym, parm->name, len);
6470   sym[len + 2] = 0;
6471 
6472   for (i = parm->lo; i <= parm->hi; i++)
6473     {
6474       struct elf_link_hash_entry *h;
6475 
6476       sym[len + 0] = i / 10 + '0';
6477       sym[len + 1] = i % 10 + '0';
6478       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6479       if (h != NULL
6480 	  && !h->def_regular)
6481 	{
6482 	  h->root.type = bfd_link_hash_defined;
6483 	  h->root.u.def.section = htab->sfpr;
6484 	  h->root.u.def.value = htab->sfpr->size;
6485 	  h->type = STT_FUNC;
6486 	  h->def_regular = 1;
6487 	  _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6488 	  writing = TRUE;
6489 	  if (htab->sfpr->contents == NULL)
6490 	    {
6491 	      htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6492 	      if (htab->sfpr->contents == NULL)
6493 		return FALSE;
6494 	    }
6495 	}
6496       if (writing)
6497 	{
6498 	  bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6499 	  if (i != parm->hi)
6500 	    p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6501 	  else
6502 	    p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6503 	  htab->sfpr->size = p - htab->sfpr->contents;
6504 	}
6505     }
6506 
6507   return TRUE;
6508 }
6509 
6510 static bfd_byte *
6511 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6512 {
6513   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6514   return p + 4;
6515 }
6516 
6517 static bfd_byte *
6518 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6519 {
6520   p = savegpr0 (abfd, p, r);
6521   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6522   p = p + 4;
6523   bfd_put_32 (abfd, BLR, p);
6524   return p + 4;
6525 }
6526 
6527 static bfd_byte *
6528 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6529 {
6530   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6531   return p + 4;
6532 }
6533 
6534 static bfd_byte *
6535 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6536 {
6537   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6538   p = p + 4;
6539   p = restgpr0 (abfd, p, r);
6540   bfd_put_32 (abfd, MTLR_R0, p);
6541   p = p + 4;
6542   if (r == 29)
6543     {
6544       p = restgpr0 (abfd, p, 30);
6545       p = restgpr0 (abfd, p, 31);
6546     }
6547   bfd_put_32 (abfd, BLR, p);
6548   return p + 4;
6549 }
6550 
6551 static bfd_byte *
6552 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6553 {
6554   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6555   return p + 4;
6556 }
6557 
6558 static bfd_byte *
6559 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6560 {
6561   p = savegpr1 (abfd, p, r);
6562   bfd_put_32 (abfd, BLR, p);
6563   return p + 4;
6564 }
6565 
6566 static bfd_byte *
6567 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6568 {
6569   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6570   return p + 4;
6571 }
6572 
6573 static bfd_byte *
6574 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6575 {
6576   p = restgpr1 (abfd, p, r);
6577   bfd_put_32 (abfd, BLR, p);
6578   return p + 4;
6579 }
6580 
6581 static bfd_byte *
6582 savefpr (bfd *abfd, bfd_byte *p, int r)
6583 {
6584   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6585   return p + 4;
6586 }
6587 
6588 static bfd_byte *
6589 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6590 {
6591   p = savefpr (abfd, p, r);
6592   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6593   p = p + 4;
6594   bfd_put_32 (abfd, BLR, p);
6595   return p + 4;
6596 }
6597 
6598 static bfd_byte *
6599 restfpr (bfd *abfd, bfd_byte *p, int r)
6600 {
6601   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6602   return p + 4;
6603 }
6604 
6605 static bfd_byte *
6606 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6607 {
6608   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6609   p = p + 4;
6610   p = restfpr (abfd, p, r);
6611   bfd_put_32 (abfd, MTLR_R0, p);
6612   p = p + 4;
6613   if (r == 29)
6614     {
6615       p = restfpr (abfd, p, 30);
6616       p = restfpr (abfd, p, 31);
6617     }
6618   bfd_put_32 (abfd, BLR, p);
6619   return p + 4;
6620 }
6621 
6622 static bfd_byte *
6623 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6624 {
6625   p = savefpr (abfd, p, r);
6626   bfd_put_32 (abfd, BLR, p);
6627   return p + 4;
6628 }
6629 
6630 static bfd_byte *
6631 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   p = restfpr (abfd, p, r);
6634   bfd_put_32 (abfd, BLR, p);
6635   return p + 4;
6636 }
6637 
6638 static bfd_byte *
6639 savevr (bfd *abfd, bfd_byte *p, int r)
6640 {
6641   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6642   p = p + 4;
6643   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6644   return p + 4;
6645 }
6646 
6647 static bfd_byte *
6648 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6649 {
6650   p = savevr (abfd, p, r);
6651   bfd_put_32 (abfd, BLR, p);
6652   return p + 4;
6653 }
6654 
6655 static bfd_byte *
6656 restvr (bfd *abfd, bfd_byte *p, int r)
6657 {
6658   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6659   p = p + 4;
6660   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6661   return p + 4;
6662 }
6663 
6664 static bfd_byte *
6665 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6666 {
6667   p = restvr (abfd, p, r);
6668   bfd_put_32 (abfd, BLR, p);
6669   return p + 4;
6670 }
6671 
6672 /* Called via elf_link_hash_traverse to transfer dynamic linking
6673    information on function code symbol entries to their corresponding
6674    function descriptor symbol entries.  */
6675 
6676 static bfd_boolean
6677 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6678 {
6679   struct bfd_link_info *info;
6680   struct ppc_link_hash_table *htab;
6681   struct plt_entry *ent;
6682   struct ppc_link_hash_entry *fh;
6683   struct ppc_link_hash_entry *fdh;
6684   bfd_boolean force_local;
6685 
6686   fh = (struct ppc_link_hash_entry *) h;
6687   if (fh->elf.root.type == bfd_link_hash_indirect)
6688     return TRUE;
6689 
6690   info = inf;
6691   htab = ppc_hash_table (info);
6692   if (htab == NULL)
6693     return FALSE;
6694 
6695   /* Resolve undefined references to dot-symbols as the value
6696      in the function descriptor, if we have one in a regular object.
6697      This is to satisfy cases like ".quad .foo".  Calls to functions
6698      in dynamic objects are handled elsewhere.  */
6699   if (fh->elf.root.type == bfd_link_hash_undefweak
6700       && fh->was_undefined
6701       && (fdh = defined_func_desc (fh)) != NULL
6702       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6703       && opd_entry_value (fdh->elf.root.u.def.section,
6704 			  fdh->elf.root.u.def.value,
6705 			  &fh->elf.root.u.def.section,
6706 			  &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6707     {
6708       fh->elf.root.type = fdh->elf.root.type;
6709       fh->elf.forced_local = 1;
6710       fh->elf.def_regular = fdh->elf.def_regular;
6711       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6712     }
6713 
6714   /* If this is a function code symbol, transfer dynamic linking
6715      information to the function descriptor symbol.  */
6716   if (!fh->is_func)
6717     return TRUE;
6718 
6719   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6720     if (ent->plt.refcount > 0)
6721       break;
6722   if (ent == NULL
6723       || fh->elf.root.root.string[0] != '.'
6724       || fh->elf.root.root.string[1] == '\0')
6725     return TRUE;
6726 
6727   /* Find the corresponding function descriptor symbol.  Create it
6728      as undefined if necessary.  */
6729 
6730   fdh = lookup_fdh (fh, htab);
6731   if (fdh == NULL
6732       && !info->executable
6733       && (fh->elf.root.type == bfd_link_hash_undefined
6734 	  || fh->elf.root.type == bfd_link_hash_undefweak))
6735     {
6736       fdh = make_fdh (info, fh);
6737       if (fdh == NULL)
6738 	return FALSE;
6739     }
6740 
6741   /* Fake function descriptors are made undefweak.  If the function
6742      code symbol is strong undefined, make the fake sym the same.
6743      If the function code symbol is defined, then force the fake
6744      descriptor local;  We can't support overriding of symbols in a
6745      shared library on a fake descriptor.  */
6746 
6747   if (fdh != NULL
6748       && fdh->fake
6749       && fdh->elf.root.type == bfd_link_hash_undefweak)
6750     {
6751       if (fh->elf.root.type == bfd_link_hash_undefined)
6752 	{
6753 	  fdh->elf.root.type = bfd_link_hash_undefined;
6754 	  bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6755 	}
6756       else if (fh->elf.root.type == bfd_link_hash_defined
6757 	       || fh->elf.root.type == bfd_link_hash_defweak)
6758 	{
6759 	  _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6760 	}
6761     }
6762 
6763   if (fdh != NULL
6764       && !fdh->elf.forced_local
6765       && (!info->executable
6766 	  || fdh->elf.def_dynamic
6767 	  || fdh->elf.ref_dynamic
6768 	  || (fdh->elf.root.type == bfd_link_hash_undefweak
6769 	      && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6770     {
6771       if (fdh->elf.dynindx == -1)
6772 	if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6773 	  return FALSE;
6774       fdh->elf.ref_regular |= fh->elf.ref_regular;
6775       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6776       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6777       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6778       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6779 	{
6780 	  move_plt_plist (fh, fdh);
6781 	  fdh->elf.needs_plt = 1;
6782 	}
6783       fdh->is_func_descriptor = 1;
6784       fdh->oh = fh;
6785       fh->oh = fdh;
6786     }
6787 
6788   /* Now that the info is on the function descriptor, clear the
6789      function code sym info.  Any function code syms for which we
6790      don't have a definition in a regular file, we force local.
6791      This prevents a shared library from exporting syms that have
6792      been imported from another library.  Function code syms that
6793      are really in the library we must leave global to prevent the
6794      linker dragging in a definition from a static library.  */
6795   force_local = (!fh->elf.def_regular
6796 		 || fdh == NULL
6797 		 || !fdh->elf.def_regular
6798 		 || fdh->elf.forced_local);
6799   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6800 
6801   return TRUE;
6802 }
6803 
6804 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6805    this hook to a) provide some gcc support functions, and b) transfer
6806    dynamic linking information gathered so far on function code symbol
6807    entries, to their corresponding function descriptor symbol entries.  */
6808 
6809 static bfd_boolean
6810 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6811 			    struct bfd_link_info *info)
6812 {
6813   struct ppc_link_hash_table *htab;
6814   unsigned int i;
6815   static const struct sfpr_def_parms funcs[] =
6816     {
6817       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6818       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6819       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6820       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6821       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6822       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6823       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6824       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6825       { "._savef", 14, 31, savefpr, savefpr1_tail },
6826       { "._restf", 14, 31, restfpr, restfpr1_tail },
6827       { "_savevr_", 20, 31, savevr, savevr_tail },
6828       { "_restvr_", 20, 31, restvr, restvr_tail }
6829     };
6830 
6831   htab = ppc_hash_table (info);
6832   if (htab == NULL)
6833     return FALSE;
6834 
6835   if (!info->relocatable
6836       && htab->elf.hgot != NULL)
6837     {
6838       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6839       /* Make .TOC. defined so as to prevent it being made dynamic.
6840 	 The wrong value here is fixed later in ppc64_elf_set_toc.  */
6841       htab->elf.hgot->type = STT_OBJECT;
6842       htab->elf.hgot->root.type = bfd_link_hash_defined;
6843       htab->elf.hgot->root.u.def.value = 0;
6844       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6845       htab->elf.hgot->def_regular = 1;
6846       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6847 			       | STV_HIDDEN);
6848     }
6849 
6850   if (htab->sfpr == NULL)
6851     /* We don't have any relocs.  */
6852     return TRUE;
6853 
6854   /* Provide any missing _save* and _rest* functions.  */
6855   htab->sfpr->size = 0;
6856   if (!info->relocatable)
6857     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6858       if (!sfpr_define (info, &funcs[i]))
6859 	return FALSE;
6860 
6861   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6862 
6863   if (htab->sfpr->size == 0)
6864     htab->sfpr->flags |= SEC_EXCLUDE;
6865 
6866   return TRUE;
6867 }
6868 
6869 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6870 
6871 static bfd_boolean
6872 readonly_dynrelocs (struct elf_link_hash_entry *h)
6873 {
6874   struct ppc_link_hash_entry *eh;
6875   struct elf_dyn_relocs *p;
6876 
6877   eh = (struct ppc_link_hash_entry *) h;
6878   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6879     {
6880       asection *s = p->sec->output_section;
6881 
6882       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6883 	return TRUE;
6884     }
6885   return FALSE;
6886 }
6887 
6888 /* Adjust a symbol defined by a dynamic object and referenced by a
6889    regular object.  The current definition is in some section of the
6890    dynamic object, but we're not including those sections.  We have to
6891    change the definition to something the rest of the link can
6892    understand.  */
6893 
6894 static bfd_boolean
6895 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6896 				 struct elf_link_hash_entry *h)
6897 {
6898   struct ppc_link_hash_table *htab;
6899   asection *s;
6900 
6901   htab = ppc_hash_table (info);
6902   if (htab == NULL)
6903     return FALSE;
6904 
6905   /* Deal with function syms.  */
6906   if (h->type == STT_FUNC
6907       || h->type == STT_GNU_IFUNC
6908       || h->needs_plt)
6909     {
6910       /* Clear procedure linkage table information for any symbol that
6911 	 won't need a .plt entry.  */
6912       struct plt_entry *ent;
6913       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6914 	if (ent->plt.refcount > 0)
6915 	  break;
6916       if (ent == NULL
6917 	  || (h->type != STT_GNU_IFUNC
6918 	      && (SYMBOL_CALLS_LOCAL (info, h)
6919 		  || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6920 		      && h->root.type == bfd_link_hash_undefweak))))
6921 	{
6922 	  h->plt.plist = NULL;
6923 	  h->needs_plt = 0;
6924 	}
6925       else if (abiversion (info->output_bfd) == 2)
6926 	{
6927 	  /* After adjust_dynamic_symbol, non_got_ref set in the
6928 	     non-shared case means that we have allocated space in
6929 	     .dynbss for the symbol and thus dyn_relocs for this
6930 	     symbol should be discarded.
6931 	     If we get here we know we are making a PLT entry for this
6932 	     symbol, and in an executable we'd normally resolve
6933 	     relocations against this symbol to the PLT entry.  Allow
6934 	     dynamic relocs if the reference is weak, and the dynamic
6935 	     relocs will not cause text relocation.  */
6936 	  if (!h->ref_regular_nonweak
6937 	      && h->non_got_ref
6938 	      && h->type != STT_GNU_IFUNC
6939 	      && !readonly_dynrelocs (h))
6940 	    h->non_got_ref = 0;
6941 
6942 	  /* If making a plt entry, then we don't need copy relocs.  */
6943 	  return TRUE;
6944 	}
6945     }
6946   else
6947     h->plt.plist = NULL;
6948 
6949   /* If this is a weak symbol, and there is a real definition, the
6950      processor independent code will have arranged for us to see the
6951      real definition first, and we can just use the same value.  */
6952   if (h->u.weakdef != NULL)
6953     {
6954       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6955 		  || h->u.weakdef->root.type == bfd_link_hash_defweak);
6956       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6957       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6958       if (ELIMINATE_COPY_RELOCS)
6959 	h->non_got_ref = h->u.weakdef->non_got_ref;
6960       return TRUE;
6961     }
6962 
6963   /* If we are creating a shared library, we must presume that the
6964      only references to the symbol are via the global offset table.
6965      For such cases we need not do anything here; the relocations will
6966      be handled correctly by relocate_section.  */
6967   if (info->shared)
6968     return TRUE;
6969 
6970   /* If there are no references to this symbol that do not use the
6971      GOT, we don't need to generate a copy reloc.  */
6972   if (!h->non_got_ref)
6973     return TRUE;
6974 
6975   /* Don't generate a copy reloc for symbols defined in the executable.  */
6976   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6977     return TRUE;
6978 
6979   /* If we didn't find any dynamic relocs in read-only sections, then
6980      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6981   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6982     {
6983       h->non_got_ref = 0;
6984       return TRUE;
6985     }
6986 
6987   if (h->plt.plist != NULL)
6988     {
6989       /* We should never get here, but unfortunately there are versions
6990 	 of gcc out there that improperly (for this ABI) put initialized
6991 	 function pointers, vtable refs and suchlike in read-only
6992 	 sections.  Allow them to proceed, but warn that this might
6993 	 break at runtime.  */
6994       info->callbacks->einfo
6995 	(_("%P: copy reloc against `%T' requires lazy plt linking; "
6996 	   "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6997 	 h->root.root.string);
6998     }
6999 
7000   /* This is a reference to a symbol defined by a dynamic object which
7001      is not a function.  */
7002 
7003   /* We must allocate the symbol in our .dynbss section, which will
7004      become part of the .bss section of the executable.  There will be
7005      an entry for this symbol in the .dynsym section.  The dynamic
7006      object will contain position independent code, so all references
7007      from the dynamic object to this symbol will go through the global
7008      offset table.  The dynamic linker will use the .dynsym entry to
7009      determine the address it must put in the global offset table, so
7010      both the dynamic object and the regular object will refer to the
7011      same memory location for the variable.  */
7012 
7013   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7014      to copy the initial value out of the dynamic object and into the
7015      runtime process image.  We need to remember the offset into the
7016      .rela.bss section we are going to use.  */
7017   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7018     {
7019       htab->relbss->size += sizeof (Elf64_External_Rela);
7020       h->needs_copy = 1;
7021     }
7022 
7023   s = htab->dynbss;
7024 
7025   return _bfd_elf_adjust_dynamic_copy (h, s);
7026 }
7027 
7028 /* If given a function descriptor symbol, hide both the function code
7029    sym and the descriptor.  */
7030 static void
7031 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7032 		       struct elf_link_hash_entry *h,
7033 		       bfd_boolean force_local)
7034 {
7035   struct ppc_link_hash_entry *eh;
7036   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7037 
7038   eh = (struct ppc_link_hash_entry *) h;
7039   if (eh->is_func_descriptor)
7040     {
7041       struct ppc_link_hash_entry *fh = eh->oh;
7042 
7043       if (fh == NULL)
7044 	{
7045 	  const char *p, *q;
7046 	  struct ppc_link_hash_table *htab;
7047 	  char save;
7048 
7049 	  /* We aren't supposed to use alloca in BFD because on
7050 	     systems which do not have alloca the version in libiberty
7051 	     calls xmalloc, which might cause the program to crash
7052 	     when it runs out of memory.  This function doesn't have a
7053 	     return status, so there's no way to gracefully return an
7054 	     error.  So cheat.  We know that string[-1] can be safely
7055 	     accessed;  It's either a string in an ELF string table,
7056 	     or allocated in an objalloc structure.  */
7057 
7058 	  p = eh->elf.root.root.string - 1;
7059 	  save = *p;
7060 	  *(char *) p = '.';
7061 	  htab = ppc_hash_table (info);
7062 	  if (htab == NULL)
7063 	    return;
7064 
7065 	  fh = (struct ppc_link_hash_entry *)
7066 	    elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7067 	  *(char *) p = save;
7068 
7069 	  /* Unfortunately, if it so happens that the string we were
7070 	     looking for was allocated immediately before this string,
7071 	     then we overwrote the string terminator.  That's the only
7072 	     reason the lookup should fail.  */
7073 	  if (fh == NULL)
7074 	    {
7075 	      q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7076 	      while (q >= eh->elf.root.root.string && *q == *p)
7077 		--q, --p;
7078 	      if (q < eh->elf.root.root.string && *p == '.')
7079 		fh = (struct ppc_link_hash_entry *)
7080 		  elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7081 	    }
7082 	  if (fh != NULL)
7083 	    {
7084 	      eh->oh = fh;
7085 	      fh->oh = eh;
7086 	    }
7087 	}
7088       if (fh != NULL)
7089 	_bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7090     }
7091 }
7092 
7093 static bfd_boolean
7094 get_sym_h (struct elf_link_hash_entry **hp,
7095 	   Elf_Internal_Sym **symp,
7096 	   asection **symsecp,
7097 	   unsigned char **tls_maskp,
7098 	   Elf_Internal_Sym **locsymsp,
7099 	   unsigned long r_symndx,
7100 	   bfd *ibfd)
7101 {
7102   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7103 
7104   if (r_symndx >= symtab_hdr->sh_info)
7105     {
7106       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7107       struct elf_link_hash_entry *h;
7108 
7109       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7110       h = elf_follow_link (h);
7111 
7112       if (hp != NULL)
7113 	*hp = h;
7114 
7115       if (symp != NULL)
7116 	*symp = NULL;
7117 
7118       if (symsecp != NULL)
7119 	{
7120 	  asection *symsec = NULL;
7121 	  if (h->root.type == bfd_link_hash_defined
7122 	      || h->root.type == bfd_link_hash_defweak)
7123 	    symsec = h->root.u.def.section;
7124 	  *symsecp = symsec;
7125 	}
7126 
7127       if (tls_maskp != NULL)
7128 	{
7129 	  struct ppc_link_hash_entry *eh;
7130 
7131 	  eh = (struct ppc_link_hash_entry *) h;
7132 	  *tls_maskp = &eh->tls_mask;
7133 	}
7134     }
7135   else
7136     {
7137       Elf_Internal_Sym *sym;
7138       Elf_Internal_Sym *locsyms = *locsymsp;
7139 
7140       if (locsyms == NULL)
7141 	{
7142 	  locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7143 	  if (locsyms == NULL)
7144 	    locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7145 					    symtab_hdr->sh_info,
7146 					    0, NULL, NULL, NULL);
7147 	  if (locsyms == NULL)
7148 	    return FALSE;
7149 	  *locsymsp = locsyms;
7150 	}
7151       sym = locsyms + r_symndx;
7152 
7153       if (hp != NULL)
7154 	*hp = NULL;
7155 
7156       if (symp != NULL)
7157 	*symp = sym;
7158 
7159       if (symsecp != NULL)
7160 	*symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7161 
7162       if (tls_maskp != NULL)
7163 	{
7164 	  struct got_entry **lgot_ents;
7165 	  unsigned char *tls_mask;
7166 
7167 	  tls_mask = NULL;
7168 	  lgot_ents = elf_local_got_ents (ibfd);
7169 	  if (lgot_ents != NULL)
7170 	    {
7171 	      struct plt_entry **local_plt = (struct plt_entry **)
7172 		(lgot_ents + symtab_hdr->sh_info);
7173 	      unsigned char *lgot_masks = (unsigned char *)
7174 		(local_plt + symtab_hdr->sh_info);
7175 	      tls_mask = &lgot_masks[r_symndx];
7176 	    }
7177 	  *tls_maskp = tls_mask;
7178 	}
7179     }
7180   return TRUE;
7181 }
7182 
7183 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7184    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7185    type suitable for optimization, and 1 otherwise.  */
7186 
7187 static int
7188 get_tls_mask (unsigned char **tls_maskp,
7189 	      unsigned long *toc_symndx,
7190 	      bfd_vma *toc_addend,
7191 	      Elf_Internal_Sym **locsymsp,
7192 	      const Elf_Internal_Rela *rel,
7193 	      bfd *ibfd)
7194 {
7195   unsigned long r_symndx;
7196   int next_r;
7197   struct elf_link_hash_entry *h;
7198   Elf_Internal_Sym *sym;
7199   asection *sec;
7200   bfd_vma off;
7201 
7202   r_symndx = ELF64_R_SYM (rel->r_info);
7203   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7204     return 0;
7205 
7206   if ((*tls_maskp != NULL && **tls_maskp != 0)
7207       || sec == NULL
7208       || ppc64_elf_section_data (sec) == NULL
7209       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7210     return 1;
7211 
7212   /* Look inside a TOC section too.  */
7213   if (h != NULL)
7214     {
7215       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7216       off = h->root.u.def.value;
7217     }
7218   else
7219     off = sym->st_value;
7220   off += rel->r_addend;
7221   BFD_ASSERT (off % 8 == 0);
7222   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7223   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7224   if (toc_symndx != NULL)
7225     *toc_symndx = r_symndx;
7226   if (toc_addend != NULL)
7227     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7228   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7229     return 0;
7230   if ((h == NULL || is_static_defined (h))
7231       && (next_r == -1 || next_r == -2))
7232     return 1 - next_r;
7233   return 1;
7234 }
7235 
7236 /* Find (or create) an entry in the tocsave hash table.  */
7237 
7238 static struct tocsave_entry *
7239 tocsave_find (struct ppc_link_hash_table *htab,
7240 	      enum insert_option insert,
7241 	      Elf_Internal_Sym **local_syms,
7242 	      const Elf_Internal_Rela *irela,
7243 	      bfd *ibfd)
7244 {
7245   unsigned long r_indx;
7246   struct elf_link_hash_entry *h;
7247   Elf_Internal_Sym *sym;
7248   struct tocsave_entry ent, *p;
7249   hashval_t hash;
7250   struct tocsave_entry **slot;
7251 
7252   r_indx = ELF64_R_SYM (irela->r_info);
7253   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7254     return NULL;
7255   if (ent.sec == NULL || ent.sec->output_section == NULL)
7256     {
7257       (*_bfd_error_handler)
7258 	(_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7259       return NULL;
7260     }
7261 
7262   if (h != NULL)
7263     ent.offset = h->root.u.def.value;
7264   else
7265     ent.offset = sym->st_value;
7266   ent.offset += irela->r_addend;
7267 
7268   hash = tocsave_htab_hash (&ent);
7269   slot = ((struct tocsave_entry **)
7270 	  htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7271   if (slot == NULL)
7272     return NULL;
7273 
7274   if (*slot == NULL)
7275     {
7276       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7277       if (p == NULL)
7278 	return NULL;
7279       *p = ent;
7280       *slot = p;
7281     }
7282   return *slot;
7283 }
7284 
7285 /* Adjust all global syms defined in opd sections.  In gcc generated
7286    code for the old ABI, these will already have been done.  */
7287 
7288 static bfd_boolean
7289 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7290 {
7291   struct ppc_link_hash_entry *eh;
7292   asection *sym_sec;
7293   struct _opd_sec_data *opd;
7294 
7295   if (h->root.type == bfd_link_hash_indirect)
7296     return TRUE;
7297 
7298   if (h->root.type != bfd_link_hash_defined
7299       && h->root.type != bfd_link_hash_defweak)
7300     return TRUE;
7301 
7302   eh = (struct ppc_link_hash_entry *) h;
7303   if (eh->adjust_done)
7304     return TRUE;
7305 
7306   sym_sec = eh->elf.root.u.def.section;
7307   opd = get_opd_info (sym_sec);
7308   if (opd != NULL && opd->adjust != NULL)
7309     {
7310       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7311       if (adjust == -1)
7312 	{
7313 	  /* This entry has been deleted.  */
7314 	  asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7315 	  if (dsec == NULL)
7316 	    {
7317 	      for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7318 		if (discarded_section (dsec))
7319 		  {
7320 		    ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7321 		    break;
7322 		  }
7323 	    }
7324 	  eh->elf.root.u.def.value = 0;
7325 	  eh->elf.root.u.def.section = dsec;
7326 	}
7327       else
7328 	eh->elf.root.u.def.value += adjust;
7329       eh->adjust_done = 1;
7330     }
7331   return TRUE;
7332 }
7333 
7334 /* Handles decrementing dynamic reloc counts for the reloc specified by
7335    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7336    have already been determined.  */
7337 
7338 static bfd_boolean
7339 dec_dynrel_count (bfd_vma r_info,
7340 		  asection *sec,
7341 		  struct bfd_link_info *info,
7342 		  Elf_Internal_Sym **local_syms,
7343 		  struct elf_link_hash_entry *h,
7344 		  Elf_Internal_Sym *sym)
7345 {
7346   enum elf_ppc64_reloc_type r_type;
7347   asection *sym_sec = NULL;
7348 
7349   /* Can this reloc be dynamic?  This switch, and later tests here
7350      should be kept in sync with the code in check_relocs.  */
7351   r_type = ELF64_R_TYPE (r_info);
7352   switch (r_type)
7353     {
7354     default:
7355       return TRUE;
7356 
7357     case R_PPC64_TPREL16:
7358     case R_PPC64_TPREL16_LO:
7359     case R_PPC64_TPREL16_HI:
7360     case R_PPC64_TPREL16_HA:
7361     case R_PPC64_TPREL16_DS:
7362     case R_PPC64_TPREL16_LO_DS:
7363     case R_PPC64_TPREL16_HIGH:
7364     case R_PPC64_TPREL16_HIGHA:
7365     case R_PPC64_TPREL16_HIGHER:
7366     case R_PPC64_TPREL16_HIGHERA:
7367     case R_PPC64_TPREL16_HIGHEST:
7368     case R_PPC64_TPREL16_HIGHESTA:
7369       if (!info->shared)
7370 	return TRUE;
7371 
7372     case R_PPC64_TPREL64:
7373     case R_PPC64_DTPMOD64:
7374     case R_PPC64_DTPREL64:
7375     case R_PPC64_ADDR64:
7376     case R_PPC64_REL30:
7377     case R_PPC64_REL32:
7378     case R_PPC64_REL64:
7379     case R_PPC64_ADDR14:
7380     case R_PPC64_ADDR14_BRNTAKEN:
7381     case R_PPC64_ADDR14_BRTAKEN:
7382     case R_PPC64_ADDR16:
7383     case R_PPC64_ADDR16_DS:
7384     case R_PPC64_ADDR16_HA:
7385     case R_PPC64_ADDR16_HI:
7386     case R_PPC64_ADDR16_HIGH:
7387     case R_PPC64_ADDR16_HIGHA:
7388     case R_PPC64_ADDR16_HIGHER:
7389     case R_PPC64_ADDR16_HIGHERA:
7390     case R_PPC64_ADDR16_HIGHEST:
7391     case R_PPC64_ADDR16_HIGHESTA:
7392     case R_PPC64_ADDR16_LO:
7393     case R_PPC64_ADDR16_LO_DS:
7394     case R_PPC64_ADDR24:
7395     case R_PPC64_ADDR32:
7396     case R_PPC64_UADDR16:
7397     case R_PPC64_UADDR32:
7398     case R_PPC64_UADDR64:
7399     case R_PPC64_TOC:
7400       break;
7401     }
7402 
7403   if (local_syms != NULL)
7404     {
7405       unsigned long r_symndx;
7406       bfd *ibfd = sec->owner;
7407 
7408       r_symndx = ELF64_R_SYM (r_info);
7409       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7410 	return FALSE;
7411     }
7412 
7413   if ((info->shared
7414        && (must_be_dyn_reloc (info, r_type)
7415 	   || (h != NULL
7416 	       && (!SYMBOLIC_BIND (info, h)
7417 		   || h->root.type == bfd_link_hash_defweak
7418 		   || !h->def_regular))))
7419       || (ELIMINATE_COPY_RELOCS
7420 	  && !info->shared
7421 	  && h != NULL
7422 	  && (h->root.type == bfd_link_hash_defweak
7423 	      || !h->def_regular)))
7424     ;
7425   else
7426     return TRUE;
7427 
7428   if (h != NULL)
7429     {
7430       struct elf_dyn_relocs *p;
7431       struct elf_dyn_relocs **pp;
7432       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7433 
7434       /* elf_gc_sweep may have already removed all dyn relocs associated
7435 	 with local syms for a given section.  Also, symbol flags are
7436 	 changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7437 	 report a dynreloc miscount.  */
7438       if (*pp == NULL && info->gc_sections)
7439 	return TRUE;
7440 
7441       while ((p = *pp) != NULL)
7442 	{
7443 	  if (p->sec == sec)
7444 	    {
7445 	      if (!must_be_dyn_reloc (info, r_type))
7446 		p->pc_count -= 1;
7447 	      p->count -= 1;
7448 	      if (p->count == 0)
7449 		*pp = p->next;
7450 	      return TRUE;
7451 	    }
7452 	  pp = &p->next;
7453 	}
7454     }
7455   else
7456     {
7457       struct ppc_dyn_relocs *p;
7458       struct ppc_dyn_relocs **pp;
7459       void *vpp;
7460       bfd_boolean is_ifunc;
7461 
7462       if (local_syms == NULL)
7463 	sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7464       if (sym_sec == NULL)
7465 	sym_sec = sec;
7466 
7467       vpp = &elf_section_data (sym_sec)->local_dynrel;
7468       pp = (struct ppc_dyn_relocs **) vpp;
7469 
7470       if (*pp == NULL && info->gc_sections)
7471 	return TRUE;
7472 
7473       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7474       while ((p = *pp) != NULL)
7475 	{
7476 	  if (p->sec == sec && p->ifunc == is_ifunc)
7477 	    {
7478 	      p->count -= 1;
7479 	      if (p->count == 0)
7480 		*pp = p->next;
7481 	      return TRUE;
7482 	    }
7483 	  pp = &p->next;
7484 	}
7485     }
7486 
7487   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7488 			  sec->owner, sec);
7489   bfd_set_error (bfd_error_bad_value);
7490   return FALSE;
7491 }
7492 
7493 /* Remove unused Official Procedure Descriptor entries.  Currently we
7494    only remove those associated with functions in discarded link-once
7495    sections, or weakly defined functions that have been overridden.  It
7496    would be possible to remove many more entries for statically linked
7497    applications.  */
7498 
7499 bfd_boolean
7500 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7501 {
7502   bfd *ibfd;
7503   bfd_boolean some_edited = FALSE;
7504   asection *need_pad = NULL;
7505 
7506   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7507     {
7508       asection *sec;
7509       Elf_Internal_Rela *relstart, *rel, *relend;
7510       Elf_Internal_Shdr *symtab_hdr;
7511       Elf_Internal_Sym *local_syms;
7512       bfd_vma offset;
7513       struct _opd_sec_data *opd;
7514       bfd_boolean need_edit, add_aux_fields;
7515       bfd_size_type cnt_16b = 0;
7516 
7517       if (!is_ppc64_elf (ibfd))
7518 	continue;
7519 
7520       sec = bfd_get_section_by_name (ibfd, ".opd");
7521       if (sec == NULL || sec->size == 0)
7522 	continue;
7523 
7524       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7525 	continue;
7526 
7527       if (sec->output_section == bfd_abs_section_ptr)
7528 	continue;
7529 
7530       /* Look through the section relocs.  */
7531       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7532 	continue;
7533 
7534       local_syms = NULL;
7535       symtab_hdr = &elf_symtab_hdr (ibfd);
7536 
7537       /* Read the relocations.  */
7538       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7539 					    info->keep_memory);
7540       if (relstart == NULL)
7541 	return FALSE;
7542 
7543       /* First run through the relocs to check they are sane, and to
7544 	 determine whether we need to edit this opd section.  */
7545       need_edit = FALSE;
7546       need_pad = sec;
7547       offset = 0;
7548       relend = relstart + sec->reloc_count;
7549       for (rel = relstart; rel < relend; )
7550 	{
7551 	  enum elf_ppc64_reloc_type r_type;
7552 	  unsigned long r_symndx;
7553 	  asection *sym_sec;
7554 	  struct elf_link_hash_entry *h;
7555 	  Elf_Internal_Sym *sym;
7556 
7557 	  /* .opd contains a regular array of 16 or 24 byte entries.  We're
7558 	     only interested in the reloc pointing to a function entry
7559 	     point.  */
7560 	  if (rel->r_offset != offset
7561 	      || rel + 1 >= relend
7562 	      || (rel + 1)->r_offset != offset + 8)
7563 	    {
7564 	      /* If someone messes with .opd alignment then after a
7565 		 "ld -r" we might have padding in the middle of .opd.
7566 		 Also, there's nothing to prevent someone putting
7567 		 something silly in .opd with the assembler.  No .opd
7568 		 optimization for them!  */
7569 	    broken_opd:
7570 	      (*_bfd_error_handler)
7571 		(_("%B: .opd is not a regular array of opd entries"), ibfd);
7572 	      need_edit = FALSE;
7573 	      break;
7574 	    }
7575 
7576 	  if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7577 	      || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7578 	    {
7579 	      (*_bfd_error_handler)
7580 		(_("%B: unexpected reloc type %u in .opd section"),
7581 		 ibfd, r_type);
7582 	      need_edit = FALSE;
7583 	      break;
7584 	    }
7585 
7586 	  r_symndx = ELF64_R_SYM (rel->r_info);
7587 	  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7588 			  r_symndx, ibfd))
7589 	    goto error_ret;
7590 
7591 	  if (sym_sec == NULL || sym_sec->owner == NULL)
7592 	    {
7593 	      const char *sym_name;
7594 	      if (h != NULL)
7595 		sym_name = h->root.root.string;
7596 	      else
7597 		sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7598 					     sym_sec);
7599 
7600 	      (*_bfd_error_handler)
7601 		(_("%B: undefined sym `%s' in .opd section"),
7602 		 ibfd, sym_name);
7603 	      need_edit = FALSE;
7604 	      break;
7605 	    }
7606 
7607 	  /* opd entries are always for functions defined in the
7608 	     current input bfd.  If the symbol isn't defined in the
7609 	     input bfd, then we won't be using the function in this
7610 	     bfd;  It must be defined in a linkonce section in another
7611 	     bfd, or is weak.  It's also possible that we are
7612 	     discarding the function due to a linker script /DISCARD/,
7613 	     which we test for via the output_section.  */
7614 	  if (sym_sec->owner != ibfd
7615 	      || sym_sec->output_section == bfd_abs_section_ptr)
7616 	    need_edit = TRUE;
7617 
7618 	  rel += 2;
7619 	  if (rel == relend
7620 	      || (rel + 1 == relend && rel->r_offset == offset + 16))
7621 	    {
7622 	      if (sec->size == offset + 24)
7623 		{
7624 		  need_pad = NULL;
7625 		  break;
7626 		}
7627 	      if (rel == relend && sec->size == offset + 16)
7628 		{
7629 		  cnt_16b++;
7630 		  break;
7631 		}
7632 	      goto broken_opd;
7633 	    }
7634 
7635 	  if (rel->r_offset == offset + 24)
7636 	    offset += 24;
7637 	  else if (rel->r_offset != offset + 16)
7638 	    goto broken_opd;
7639 	  else if (rel + 1 < relend
7640 		   && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7641 		   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7642 	    {
7643 	      offset += 16;
7644 	      cnt_16b++;
7645 	    }
7646 	  else if (rel + 2 < relend
7647 		   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7648 		   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7649 	    {
7650 	      offset += 24;
7651 	      rel += 1;
7652 	    }
7653 	  else
7654 	    goto broken_opd;
7655 	}
7656 
7657       add_aux_fields = non_overlapping && cnt_16b > 0;
7658 
7659       if (need_edit || add_aux_fields)
7660 	{
7661 	  Elf_Internal_Rela *write_rel;
7662 	  Elf_Internal_Shdr *rel_hdr;
7663 	  bfd_byte *rptr, *wptr;
7664 	  bfd_byte *new_contents;
7665 	  bfd_boolean skip;
7666 	  long opd_ent_size;
7667 	  bfd_size_type amt;
7668 
7669 	  new_contents = NULL;
7670 	  amt = sec->size * sizeof (long) / 8;
7671 	  opd = &ppc64_elf_section_data (sec)->u.opd;
7672 	  opd->adjust = bfd_zalloc (sec->owner, amt);
7673 	  if (opd->adjust == NULL)
7674 	    return FALSE;
7675 	  ppc64_elf_section_data (sec)->sec_type = sec_opd;
7676 
7677 	  /* This seems a waste of time as input .opd sections are all
7678 	     zeros as generated by gcc, but I suppose there's no reason
7679 	     this will always be so.  We might start putting something in
7680 	     the third word of .opd entries.  */
7681 	  if ((sec->flags & SEC_IN_MEMORY) == 0)
7682 	    {
7683 	      bfd_byte *loc;
7684 	      if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7685 		{
7686 		  if (loc != NULL)
7687 		    free (loc);
7688 		error_ret:
7689 		  if (local_syms != NULL
7690 		      && symtab_hdr->contents != (unsigned char *) local_syms)
7691 		    free (local_syms);
7692 		  if (elf_section_data (sec)->relocs != relstart)
7693 		    free (relstart);
7694 		  return FALSE;
7695 		}
7696 	      sec->contents = loc;
7697 	      sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7698 	    }
7699 
7700 	  elf_section_data (sec)->relocs = relstart;
7701 
7702 	  new_contents = sec->contents;
7703 	  if (add_aux_fields)
7704 	    {
7705 	      new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7706 	      if (new_contents == NULL)
7707 		return FALSE;
7708 	      need_pad = FALSE;
7709 	    }
7710 	  wptr = new_contents;
7711 	  rptr = sec->contents;
7712 
7713 	  write_rel = relstart;
7714 	  skip = FALSE;
7715 	  offset = 0;
7716 	  opd_ent_size = 0;
7717 	  for (rel = relstart; rel < relend; rel++)
7718 	    {
7719 	      unsigned long r_symndx;
7720 	      asection *sym_sec;
7721 	      struct elf_link_hash_entry *h;
7722 	      Elf_Internal_Sym *sym;
7723 
7724 	      r_symndx = ELF64_R_SYM (rel->r_info);
7725 	      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7726 			      r_symndx, ibfd))
7727 		goto error_ret;
7728 
7729 	      if (rel->r_offset == offset)
7730 		{
7731 		  struct ppc_link_hash_entry *fdh = NULL;
7732 
7733 		  /* See if the .opd entry is full 24 byte or
7734 		     16 byte (with fd_aux entry overlapped with next
7735 		     fd_func).  */
7736 		  opd_ent_size = 24;
7737 		  if ((rel + 2 == relend && sec->size == offset + 16)
7738 		      || (rel + 3 < relend
7739 			  && rel[2].r_offset == offset + 16
7740 			  && rel[3].r_offset == offset + 24
7741 			  && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7742 			  && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7743 		    opd_ent_size = 16;
7744 
7745 		  if (h != NULL
7746 		      && h->root.root.string[0] == '.')
7747 		    {
7748 		      struct ppc_link_hash_table *htab;
7749 
7750 		      htab = ppc_hash_table (info);
7751 		      if (htab != NULL)
7752 			fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7753 					  htab);
7754 		      if (fdh != NULL
7755 			  && fdh->elf.root.type != bfd_link_hash_defined
7756 			  && fdh->elf.root.type != bfd_link_hash_defweak)
7757 			fdh = NULL;
7758 		    }
7759 
7760 		  skip = (sym_sec->owner != ibfd
7761 			  || sym_sec->output_section == bfd_abs_section_ptr);
7762 		  if (skip)
7763 		    {
7764 		      if (fdh != NULL && sym_sec->owner == ibfd)
7765 			{
7766 			  /* Arrange for the function descriptor sym
7767 			     to be dropped.  */
7768 			  fdh->elf.root.u.def.value = 0;
7769 			  fdh->elf.root.u.def.section = sym_sec;
7770 			}
7771 		      opd->adjust[rel->r_offset / 8] = -1;
7772 		    }
7773 		  else
7774 		    {
7775 		      /* We'll be keeping this opd entry.  */
7776 
7777 		      if (fdh != NULL)
7778 			{
7779 			  /* Redefine the function descriptor symbol to
7780 			     this location in the opd section.  It is
7781 			     necessary to update the value here rather
7782 			     than using an array of adjustments as we do
7783 			     for local symbols, because various places
7784 			     in the generic ELF code use the value
7785 			     stored in u.def.value.  */
7786 			  fdh->elf.root.u.def.value = wptr - new_contents;
7787 			  fdh->adjust_done = 1;
7788 			}
7789 
7790 		      /* Local syms are a bit tricky.  We could
7791 			 tweak them as they can be cached, but
7792 			 we'd need to look through the local syms
7793 			 for the function descriptor sym which we
7794 			 don't have at the moment.  So keep an
7795 			 array of adjustments.  */
7796 		      opd->adjust[rel->r_offset / 8]
7797 			= (wptr - new_contents) - (rptr - sec->contents);
7798 
7799 		      if (wptr != rptr)
7800 			memcpy (wptr, rptr, opd_ent_size);
7801 		      wptr += opd_ent_size;
7802 		      if (add_aux_fields && opd_ent_size == 16)
7803 			{
7804 			  memset (wptr, '\0', 8);
7805 			  wptr += 8;
7806 			}
7807 		    }
7808 		  rptr += opd_ent_size;
7809 		  offset += opd_ent_size;
7810 		}
7811 
7812 	      if (skip)
7813 		{
7814 		  if (!NO_OPD_RELOCS
7815 		      && !info->relocatable
7816 		      && !dec_dynrel_count (rel->r_info, sec, info,
7817 					    NULL, h, sym))
7818 		    goto error_ret;
7819 		}
7820 	      else
7821 		{
7822 		  /* We need to adjust any reloc offsets to point to the
7823 		     new opd entries.  While we're at it, we may as well
7824 		     remove redundant relocs.  */
7825 		  rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7826 		  if (write_rel != rel)
7827 		    memcpy (write_rel, rel, sizeof (*rel));
7828 		  ++write_rel;
7829 		}
7830 	    }
7831 
7832 	  sec->size = wptr - new_contents;
7833 	  sec->reloc_count = write_rel - relstart;
7834 	  if (add_aux_fields)
7835 	    {
7836 	      free (sec->contents);
7837 	      sec->contents = new_contents;
7838 	    }
7839 
7840 	  /* Fudge the header size too, as this is used later in
7841 	     elf_bfd_final_link if we are emitting relocs.  */
7842 	  rel_hdr = _bfd_elf_single_rel_hdr (sec);
7843 	  rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7844 	  some_edited = TRUE;
7845 	}
7846       else if (elf_section_data (sec)->relocs != relstart)
7847 	free (relstart);
7848 
7849       if (local_syms != NULL
7850 	  && symtab_hdr->contents != (unsigned char *) local_syms)
7851 	{
7852 	  if (!info->keep_memory)
7853 	    free (local_syms);
7854 	  else
7855 	    symtab_hdr->contents = (unsigned char *) local_syms;
7856 	}
7857     }
7858 
7859   if (some_edited)
7860     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7861 
7862   /* If we are doing a final link and the last .opd entry is just 16 byte
7863      long, add a 8 byte padding after it.  */
7864   if (need_pad != NULL && !info->relocatable)
7865     {
7866       bfd_byte *p;
7867 
7868       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7869 	{
7870 	  BFD_ASSERT (need_pad->size > 0);
7871 
7872 	  p = bfd_malloc (need_pad->size + 8);
7873 	  if (p == NULL)
7874 	    return FALSE;
7875 
7876 	  if (! bfd_get_section_contents (need_pad->owner, need_pad,
7877 					  p, 0, need_pad->size))
7878 	    return FALSE;
7879 
7880 	  need_pad->contents = p;
7881 	  need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7882 	}
7883       else
7884 	{
7885 	  p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7886 	  if (p == NULL)
7887 	    return FALSE;
7888 
7889 	  need_pad->contents = p;
7890 	}
7891 
7892       memset (need_pad->contents + need_pad->size, 0, 8);
7893       need_pad->size += 8;
7894     }
7895 
7896   return TRUE;
7897 }
7898 
7899 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7900 
7901 asection *
7902 ppc64_elf_tls_setup (struct bfd_link_info *info,
7903 		     int no_tls_get_addr_opt,
7904 		     int *no_multi_toc)
7905 {
7906   struct ppc_link_hash_table *htab;
7907 
7908   htab = ppc_hash_table (info);
7909   if (htab == NULL)
7910     return NULL;
7911 
7912   if (abiversion (info->output_bfd) == 1)
7913     htab->opd_abi = 1;
7914 
7915   if (*no_multi_toc)
7916     htab->do_multi_toc = 0;
7917   else if (!htab->do_multi_toc)
7918     *no_multi_toc = 1;
7919 
7920   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7921 			elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7922 					      FALSE, FALSE, TRUE));
7923   /* Move dynamic linking info to the function descriptor sym.  */
7924   if (htab->tls_get_addr != NULL)
7925     func_desc_adjust (&htab->tls_get_addr->elf, info);
7926   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7927 			   elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7928 						 FALSE, FALSE, TRUE));
7929   if (!no_tls_get_addr_opt)
7930     {
7931       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7932 
7933       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7934 				  FALSE, FALSE, TRUE);
7935       if (opt != NULL)
7936 	func_desc_adjust (opt, info);
7937       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7938 				     FALSE, FALSE, TRUE);
7939       if (opt_fd != NULL
7940 	  && (opt_fd->root.type == bfd_link_hash_defined
7941 	      || opt_fd->root.type == bfd_link_hash_defweak))
7942 	{
7943 	  /* If glibc supports an optimized __tls_get_addr call stub,
7944 	     signalled by the presence of __tls_get_addr_opt, and we'll
7945 	     be calling __tls_get_addr via a plt call stub, then
7946 	     make __tls_get_addr point to __tls_get_addr_opt.  */
7947 	  tga_fd = &htab->tls_get_addr_fd->elf;
7948 	  if (htab->elf.dynamic_sections_created
7949 	      && tga_fd != NULL
7950 	      && (tga_fd->type == STT_FUNC
7951 		  || tga_fd->needs_plt)
7952 	      && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7953 		   || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7954 		       && tga_fd->root.type == bfd_link_hash_undefweak)))
7955 	    {
7956 	      struct plt_entry *ent;
7957 
7958 	      for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7959 		if (ent->plt.refcount > 0)
7960 		  break;
7961 	      if (ent != NULL)
7962 		{
7963 		  tga_fd->root.type = bfd_link_hash_indirect;
7964 		  tga_fd->root.u.i.link = &opt_fd->root;
7965 		  ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7966 		  if (opt_fd->dynindx != -1)
7967 		    {
7968 		      /* Use __tls_get_addr_opt in dynamic relocations.  */
7969 		      opt_fd->dynindx = -1;
7970 		      _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7971 					      opt_fd->dynstr_index);
7972 		      if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7973 			return NULL;
7974 		    }
7975 		  htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7976 		  tga = &htab->tls_get_addr->elf;
7977 		  if (opt != NULL && tga != NULL)
7978 		    {
7979 		      tga->root.type = bfd_link_hash_indirect;
7980 		      tga->root.u.i.link = &opt->root;
7981 		      ppc64_elf_copy_indirect_symbol (info, opt, tga);
7982 		      _bfd_elf_link_hash_hide_symbol (info, opt,
7983 						      tga->forced_local);
7984 		      htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7985 		    }
7986 		  htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7987 		  htab->tls_get_addr_fd->is_func_descriptor = 1;
7988 		  if (htab->tls_get_addr != NULL)
7989 		    {
7990 		      htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7991 		      htab->tls_get_addr->is_func = 1;
7992 		    }
7993 		}
7994 	    }
7995 	}
7996       else
7997 	no_tls_get_addr_opt = TRUE;
7998     }
7999   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8000   return _bfd_elf_tls_setup (info->output_bfd, info);
8001 }
8002 
8003 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8004    HASH1 or HASH2.  */
8005 
8006 static bfd_boolean
8007 branch_reloc_hash_match (const bfd *ibfd,
8008 			 const Elf_Internal_Rela *rel,
8009 			 const struct ppc_link_hash_entry *hash1,
8010 			 const struct ppc_link_hash_entry *hash2)
8011 {
8012   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8013   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8014   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8015 
8016   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8017     {
8018       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8019       struct elf_link_hash_entry *h;
8020 
8021       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8022       h = elf_follow_link (h);
8023       if (h == &hash1->elf || h == &hash2->elf)
8024 	return TRUE;
8025     }
8026   return FALSE;
8027 }
8028 
8029 /* Run through all the TLS relocs looking for optimization
8030    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8031    a preliminary section layout so that we know the TLS segment
8032    offsets.  We can't optimize earlier because some optimizations need
8033    to know the tp offset, and we need to optimize before allocating
8034    dynamic relocations.  */
8035 
8036 bfd_boolean
8037 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8038 {
8039   bfd *ibfd;
8040   asection *sec;
8041   struct ppc_link_hash_table *htab;
8042   unsigned char *toc_ref;
8043   int pass;
8044 
8045   if (info->relocatable || !info->executable)
8046     return TRUE;
8047 
8048   htab = ppc_hash_table (info);
8049   if (htab == NULL)
8050     return FALSE;
8051 
8052   /* Make two passes over the relocs.  On the first pass, mark toc
8053      entries involved with tls relocs, and check that tls relocs
8054      involved in setting up a tls_get_addr call are indeed followed by
8055      such a call.  If they are not, we can't do any tls optimization.
8056      On the second pass twiddle tls_mask flags to notify
8057      relocate_section that optimization can be done, and adjust got
8058      and plt refcounts.  */
8059   toc_ref = NULL;
8060   for (pass = 0; pass < 2; ++pass)
8061     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8062       {
8063 	Elf_Internal_Sym *locsyms = NULL;
8064 	asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8065 
8066 	for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8067 	  if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8068 	    {
8069 	      Elf_Internal_Rela *relstart, *rel, *relend;
8070 	      bfd_boolean found_tls_get_addr_arg = 0;
8071 
8072 	      /* Read the relocations.  */
8073 	      relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8074 						    info->keep_memory);
8075 	      if (relstart == NULL)
8076 		return FALSE;
8077 
8078 	      relend = relstart + sec->reloc_count;
8079 	      for (rel = relstart; rel < relend; rel++)
8080 		{
8081 		  enum elf_ppc64_reloc_type r_type;
8082 		  unsigned long r_symndx;
8083 		  struct elf_link_hash_entry *h;
8084 		  Elf_Internal_Sym *sym;
8085 		  asection *sym_sec;
8086 		  unsigned char *tls_mask;
8087 		  unsigned char tls_set, tls_clear, tls_type = 0;
8088 		  bfd_vma value;
8089 		  bfd_boolean ok_tprel, is_local;
8090 		  long toc_ref_index = 0;
8091 		  int expecting_tls_get_addr = 0;
8092 		  bfd_boolean ret = FALSE;
8093 
8094 		  r_symndx = ELF64_R_SYM (rel->r_info);
8095 		  if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8096 				  r_symndx, ibfd))
8097 		    {
8098 		    err_free_rel:
8099 		      if (elf_section_data (sec)->relocs != relstart)
8100 			free (relstart);
8101 		      if (toc_ref != NULL)
8102 			free (toc_ref);
8103 		      if (locsyms != NULL
8104 			  && (elf_symtab_hdr (ibfd).contents
8105 			      != (unsigned char *) locsyms))
8106 			free (locsyms);
8107 		      return ret;
8108 		    }
8109 
8110 		  if (h != NULL)
8111 		    {
8112 		      if (h->root.type == bfd_link_hash_defined
8113 			  || h->root.type == bfd_link_hash_defweak)
8114 			value = h->root.u.def.value;
8115 		      else if (h->root.type == bfd_link_hash_undefweak)
8116 			value = 0;
8117 		      else
8118 			{
8119 			  found_tls_get_addr_arg = 0;
8120 			  continue;
8121 			}
8122 		    }
8123 		  else
8124 		    /* Symbols referenced by TLS relocs must be of type
8125 		       STT_TLS.  So no need for .opd local sym adjust.  */
8126 		    value = sym->st_value;
8127 
8128 		  ok_tprel = FALSE;
8129 		  is_local = FALSE;
8130 		  if (h == NULL
8131 		      || !h->def_dynamic)
8132 		    {
8133 		      is_local = TRUE;
8134 		      if (h != NULL
8135 			  && h->root.type == bfd_link_hash_undefweak)
8136 			ok_tprel = TRUE;
8137 		      else
8138 			{
8139 			  value += sym_sec->output_offset;
8140 			  value += sym_sec->output_section->vma;
8141 			  value -= htab->elf.tls_sec->vma;
8142 			  ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8143 				      < (bfd_vma) 1 << 32);
8144 			}
8145 		    }
8146 
8147 		  r_type = ELF64_R_TYPE (rel->r_info);
8148 		  /* If this section has old-style __tls_get_addr calls
8149 		     without marker relocs, then check that each
8150 		     __tls_get_addr call reloc is preceded by a reloc
8151 		     that conceivably belongs to the __tls_get_addr arg
8152 		     setup insn.  If we don't find matching arg setup
8153 		     relocs, don't do any tls optimization.  */
8154 		  if (pass == 0
8155 		      && sec->has_tls_get_addr_call
8156 		      && h != NULL
8157 		      && (h == &htab->tls_get_addr->elf
8158 			  || h == &htab->tls_get_addr_fd->elf)
8159 		      && !found_tls_get_addr_arg
8160 		      && is_branch_reloc (r_type))
8161 		    {
8162 		      info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8163 						"TLS optimization disabled\n"),
8164 					      ibfd, sec, rel->r_offset);
8165 		      ret = TRUE;
8166 		      goto err_free_rel;
8167 		    }
8168 
8169 		  found_tls_get_addr_arg = 0;
8170 		  switch (r_type)
8171 		    {
8172 		    case R_PPC64_GOT_TLSLD16:
8173 		    case R_PPC64_GOT_TLSLD16_LO:
8174 		      expecting_tls_get_addr = 1;
8175 		      found_tls_get_addr_arg = 1;
8176 		      /* Fall thru */
8177 
8178 		    case R_PPC64_GOT_TLSLD16_HI:
8179 		    case R_PPC64_GOT_TLSLD16_HA:
8180 		      /* These relocs should never be against a symbol
8181 			 defined in a shared lib.  Leave them alone if
8182 			 that turns out to be the case.  */
8183 		      if (!is_local)
8184 			continue;
8185 
8186 		      /* LD -> LE */
8187 		      tls_set = 0;
8188 		      tls_clear = TLS_LD;
8189 		      tls_type = TLS_TLS | TLS_LD;
8190 		      break;
8191 
8192 		    case R_PPC64_GOT_TLSGD16:
8193 		    case R_PPC64_GOT_TLSGD16_LO:
8194 		      expecting_tls_get_addr = 1;
8195 		      found_tls_get_addr_arg = 1;
8196 		      /* Fall thru */
8197 
8198 		    case R_PPC64_GOT_TLSGD16_HI:
8199 		    case R_PPC64_GOT_TLSGD16_HA:
8200 		      if (ok_tprel)
8201 			/* GD -> LE */
8202 			tls_set = 0;
8203 		      else
8204 			/* GD -> IE */
8205 			tls_set = TLS_TLS | TLS_TPRELGD;
8206 		      tls_clear = TLS_GD;
8207 		      tls_type = TLS_TLS | TLS_GD;
8208 		      break;
8209 
8210 		    case R_PPC64_GOT_TPREL16_DS:
8211 		    case R_PPC64_GOT_TPREL16_LO_DS:
8212 		    case R_PPC64_GOT_TPREL16_HI:
8213 		    case R_PPC64_GOT_TPREL16_HA:
8214 		      if (ok_tprel)
8215 			{
8216 			  /* IE -> LE */
8217 			  tls_set = 0;
8218 			  tls_clear = TLS_TPREL;
8219 			  tls_type = TLS_TLS | TLS_TPREL;
8220 			  break;
8221 			}
8222 		      continue;
8223 
8224 		    case R_PPC64_TLSGD:
8225 		    case R_PPC64_TLSLD:
8226 		      found_tls_get_addr_arg = 1;
8227 		      /* Fall thru */
8228 
8229 		    case R_PPC64_TLS:
8230 		    case R_PPC64_TOC16:
8231 		    case R_PPC64_TOC16_LO:
8232 		      if (sym_sec == NULL || sym_sec != toc)
8233 			continue;
8234 
8235 		      /* Mark this toc entry as referenced by a TLS
8236 			 code sequence.  We can do that now in the
8237 			 case of R_PPC64_TLS, and after checking for
8238 			 tls_get_addr for the TOC16 relocs.  */
8239 		      if (toc_ref == NULL)
8240 			toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8241 		      if (toc_ref == NULL)
8242 			goto err_free_rel;
8243 
8244 		      if (h != NULL)
8245 			value = h->root.u.def.value;
8246 		      else
8247 			value = sym->st_value;
8248 		      value += rel->r_addend;
8249 		      BFD_ASSERT (value < toc->size && value % 8 == 0);
8250 		      toc_ref_index = (value + toc->output_offset) / 8;
8251 		      if (r_type == R_PPC64_TLS
8252 			  || r_type == R_PPC64_TLSGD
8253 			  || r_type == R_PPC64_TLSLD)
8254 			{
8255 			  toc_ref[toc_ref_index] = 1;
8256 			  continue;
8257 			}
8258 
8259 		      if (pass != 0 && toc_ref[toc_ref_index] == 0)
8260 			continue;
8261 
8262 		      tls_set = 0;
8263 		      tls_clear = 0;
8264 		      expecting_tls_get_addr = 2;
8265 		      break;
8266 
8267 		    case R_PPC64_TPREL64:
8268 		      if (pass == 0
8269 			  || sec != toc
8270 			  || toc_ref == NULL
8271 			  || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8272 			continue;
8273 		      if (ok_tprel)
8274 			{
8275 			  /* IE -> LE */
8276 			  tls_set = TLS_EXPLICIT;
8277 			  tls_clear = TLS_TPREL;
8278 			  break;
8279 			}
8280 		      continue;
8281 
8282 		    case R_PPC64_DTPMOD64:
8283 		      if (pass == 0
8284 			  || sec != toc
8285 			  || toc_ref == NULL
8286 			  || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8287 			continue;
8288 		      if (rel + 1 < relend
8289 			  && (rel[1].r_info
8290 			      == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8291 			  && rel[1].r_offset == rel->r_offset + 8)
8292 			{
8293 			  if (ok_tprel)
8294 			    /* GD -> LE */
8295 			    tls_set = TLS_EXPLICIT | TLS_GD;
8296 			  else
8297 			    /* GD -> IE */
8298 			    tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8299 			  tls_clear = TLS_GD;
8300 			}
8301 		      else
8302 			{
8303 			  if (!is_local)
8304 			    continue;
8305 
8306 			  /* LD -> LE */
8307 			  tls_set = TLS_EXPLICIT;
8308 			  tls_clear = TLS_LD;
8309 			}
8310 		      break;
8311 
8312 		    default:
8313 		      continue;
8314 		    }
8315 
8316 		  if (pass == 0)
8317 		    {
8318 		      if (!expecting_tls_get_addr
8319 			  || !sec->has_tls_get_addr_call)
8320 			continue;
8321 
8322 		      if (rel + 1 < relend
8323 			  && branch_reloc_hash_match (ibfd, rel + 1,
8324 						      htab->tls_get_addr,
8325 						      htab->tls_get_addr_fd))
8326 			{
8327 			  if (expecting_tls_get_addr == 2)
8328 			    {
8329 			      /* Check for toc tls entries.  */
8330 			      unsigned char *toc_tls;
8331 			      int retval;
8332 
8333 			      retval = get_tls_mask (&toc_tls, NULL, NULL,
8334 						     &locsyms,
8335 						     rel, ibfd);
8336 			      if (retval == 0)
8337 				goto err_free_rel;
8338 			      if (toc_tls != NULL)
8339 				{
8340 				  if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8341 				    found_tls_get_addr_arg = 1;
8342 				  if (retval > 1)
8343 				    toc_ref[toc_ref_index] = 1;
8344 				}
8345 			    }
8346 			  continue;
8347 			}
8348 
8349 		      if (expecting_tls_get_addr != 1)
8350 			continue;
8351 
8352 		      /* Uh oh, we didn't find the expected call.  We
8353 			 could just mark this symbol to exclude it
8354 			 from tls optimization but it's safer to skip
8355 			 the entire optimization.  */
8356 		      info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8357 						"TLS optimization disabled\n"),
8358 					      ibfd, sec, rel->r_offset);
8359 		      ret = TRUE;
8360 		      goto err_free_rel;
8361 		    }
8362 
8363 		  if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8364 		    {
8365 		      struct plt_entry *ent;
8366 		      for (ent = htab->tls_get_addr->elf.plt.plist;
8367 			   ent != NULL;
8368 			   ent = ent->next)
8369 			if (ent->addend == 0)
8370 			  {
8371 			    if (ent->plt.refcount > 0)
8372 			      {
8373 				ent->plt.refcount -= 1;
8374 				expecting_tls_get_addr = 0;
8375 			      }
8376 			    break;
8377 			  }
8378 		    }
8379 
8380 		  if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8381 		    {
8382 		      struct plt_entry *ent;
8383 		      for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8384 			   ent != NULL;
8385 			   ent = ent->next)
8386 			if (ent->addend == 0)
8387 			  {
8388 			    if (ent->plt.refcount > 0)
8389 			      ent->plt.refcount -= 1;
8390 			    break;
8391 			  }
8392 		    }
8393 
8394 		  if (tls_clear == 0)
8395 		    continue;
8396 
8397 		  if ((tls_set & TLS_EXPLICIT) == 0)
8398 		    {
8399 		      struct got_entry *ent;
8400 
8401 		      /* Adjust got entry for this reloc.  */
8402 		      if (h != NULL)
8403 			ent = h->got.glist;
8404 		      else
8405 			ent = elf_local_got_ents (ibfd)[r_symndx];
8406 
8407 		      for (; ent != NULL; ent = ent->next)
8408 			if (ent->addend == rel->r_addend
8409 			    && ent->owner == ibfd
8410 			    && ent->tls_type == tls_type)
8411 			  break;
8412 		      if (ent == NULL)
8413 			abort ();
8414 
8415 		      if (tls_set == 0)
8416 			{
8417 			  /* We managed to get rid of a got entry.  */
8418 			  if (ent->got.refcount > 0)
8419 			    ent->got.refcount -= 1;
8420 			}
8421 		    }
8422 		  else
8423 		    {
8424 		      /* If we got rid of a DTPMOD/DTPREL reloc pair then
8425 			 we'll lose one or two dyn relocs.  */
8426 		      if (!dec_dynrel_count (rel->r_info, sec, info,
8427 					     NULL, h, sym))
8428 			return FALSE;
8429 
8430 		      if (tls_set == (TLS_EXPLICIT | TLS_GD))
8431 			{
8432 			  if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8433 						 NULL, h, sym))
8434 			    return FALSE;
8435 			}
8436 		    }
8437 
8438 		  *tls_mask |= tls_set;
8439 		  *tls_mask &= ~tls_clear;
8440 		}
8441 
8442 	      if (elf_section_data (sec)->relocs != relstart)
8443 		free (relstart);
8444 	    }
8445 
8446 	if (locsyms != NULL
8447 	    && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8448 	  {
8449 	    if (!info->keep_memory)
8450 	      free (locsyms);
8451 	    else
8452 	      elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8453 	  }
8454       }
8455 
8456   if (toc_ref != NULL)
8457     free (toc_ref);
8458   return TRUE;
8459 }
8460 
8461 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8462    the values of any global symbols in a toc section that has been
8463    edited.  Globals in toc sections should be a rarity, so this function
8464    sets a flag if any are found in toc sections other than the one just
8465    edited, so that futher hash table traversals can be avoided.  */
8466 
8467 struct adjust_toc_info
8468 {
8469   asection *toc;
8470   unsigned long *skip;
8471   bfd_boolean global_toc_syms;
8472 };
8473 
8474 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8475 
8476 static bfd_boolean
8477 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8478 {
8479   struct ppc_link_hash_entry *eh;
8480   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8481   unsigned long i;
8482 
8483   if (h->root.type != bfd_link_hash_defined
8484       && h->root.type != bfd_link_hash_defweak)
8485     return TRUE;
8486 
8487   eh = (struct ppc_link_hash_entry *) h;
8488   if (eh->adjust_done)
8489     return TRUE;
8490 
8491   if (eh->elf.root.u.def.section == toc_inf->toc)
8492     {
8493       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8494 	i = toc_inf->toc->rawsize >> 3;
8495       else
8496 	i = eh->elf.root.u.def.value >> 3;
8497 
8498       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8499 	{
8500 	  (*_bfd_error_handler)
8501 	    (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8502 	  do
8503 	    ++i;
8504 	  while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8505 	  eh->elf.root.u.def.value = (bfd_vma) i << 3;
8506 	}
8507 
8508       eh->elf.root.u.def.value -= toc_inf->skip[i];
8509       eh->adjust_done = 1;
8510     }
8511   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8512     toc_inf->global_toc_syms = TRUE;
8513 
8514   return TRUE;
8515 }
8516 
8517 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8518 
8519 static bfd_boolean
8520 ok_lo_toc_insn (unsigned int insn)
8521 {
8522   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8523 	  || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8524 	  || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8525 	  || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8526 	  || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8527 	  || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8528 	  || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8529 	  || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8530 	  || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8531 	  || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8532 	  || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8533 	  || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8534 	  || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8535 	  || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8536 	  || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8537 	      && (insn & 3) != 1)
8538 	  || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8539 	      && ((insn & 3) == 0 || (insn & 3) == 3))
8540 	  || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8541 }
8542 
8543 /* Examine all relocs referencing .toc sections in order to remove
8544    unused .toc entries.  */
8545 
8546 bfd_boolean
8547 ppc64_elf_edit_toc (struct bfd_link_info *info)
8548 {
8549   bfd *ibfd;
8550   struct adjust_toc_info toc_inf;
8551   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8552 
8553   htab->do_toc_opt = 1;
8554   toc_inf.global_toc_syms = TRUE;
8555   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8556     {
8557       asection *toc, *sec;
8558       Elf_Internal_Shdr *symtab_hdr;
8559       Elf_Internal_Sym *local_syms;
8560       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8561       unsigned long *skip, *drop;
8562       unsigned char *used;
8563       unsigned char *keep, last, some_unused;
8564 
8565       if (!is_ppc64_elf (ibfd))
8566 	continue;
8567 
8568       toc = bfd_get_section_by_name (ibfd, ".toc");
8569       if (toc == NULL
8570 	  || toc->size == 0
8571 	  || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8572 	  || discarded_section (toc))
8573 	continue;
8574 
8575       toc_relocs = NULL;
8576       local_syms = NULL;
8577       symtab_hdr = &elf_symtab_hdr (ibfd);
8578 
8579       /* Look at sections dropped from the final link.  */
8580       skip = NULL;
8581       relstart = NULL;
8582       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8583 	{
8584 	  if (sec->reloc_count == 0
8585 	      || !discarded_section (sec)
8586 	      || get_opd_info (sec)
8587 	      || (sec->flags & SEC_ALLOC) == 0
8588 	      || (sec->flags & SEC_DEBUGGING) != 0)
8589 	    continue;
8590 
8591 	  relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8592 	  if (relstart == NULL)
8593 	    goto error_ret;
8594 
8595 	  /* Run through the relocs to see which toc entries might be
8596 	     unused.  */
8597 	  for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8598 	    {
8599 	      enum elf_ppc64_reloc_type r_type;
8600 	      unsigned long r_symndx;
8601 	      asection *sym_sec;
8602 	      struct elf_link_hash_entry *h;
8603 	      Elf_Internal_Sym *sym;
8604 	      bfd_vma val;
8605 
8606 	      r_type = ELF64_R_TYPE (rel->r_info);
8607 	      switch (r_type)
8608 		{
8609 		default:
8610 		  continue;
8611 
8612 		case R_PPC64_TOC16:
8613 		case R_PPC64_TOC16_LO:
8614 		case R_PPC64_TOC16_HI:
8615 		case R_PPC64_TOC16_HA:
8616 		case R_PPC64_TOC16_DS:
8617 		case R_PPC64_TOC16_LO_DS:
8618 		  break;
8619 		}
8620 
8621 	      r_symndx = ELF64_R_SYM (rel->r_info);
8622 	      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8623 			      r_symndx, ibfd))
8624 		goto error_ret;
8625 
8626 	      if (sym_sec != toc)
8627 		continue;
8628 
8629 	      if (h != NULL)
8630 		val = h->root.u.def.value;
8631 	      else
8632 		val = sym->st_value;
8633 	      val += rel->r_addend;
8634 
8635 	      if (val >= toc->size)
8636 		continue;
8637 
8638 	      /* Anything in the toc ought to be aligned to 8 bytes.
8639 		 If not, don't mark as unused.  */
8640 	      if (val & 7)
8641 		continue;
8642 
8643 	      if (skip == NULL)
8644 		{
8645 		  skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8646 		  if (skip == NULL)
8647 		    goto error_ret;
8648 		}
8649 
8650 	      skip[val >> 3] = ref_from_discarded;
8651 	    }
8652 
8653 	  if (elf_section_data (sec)->relocs != relstart)
8654 	    free (relstart);
8655 	}
8656 
8657       /* For largetoc loads of address constants, we can convert
8658 	 .  addis rx,2,addr@got@ha
8659 	 .  ld ry,addr@got@l(rx)
8660 	 to
8661 	 .  addis rx,2,addr@toc@ha
8662 	 .  addi ry,rx,addr@toc@l
8663 	 when addr is within 2G of the toc pointer.  This then means
8664 	 that the word storing "addr" in the toc is no longer needed.  */
8665 
8666       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8667 	  && toc->output_section->rawsize < (bfd_vma) 1 << 31
8668 	  && toc->reloc_count != 0)
8669 	{
8670 	  /* Read toc relocs.  */
8671 	  toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8672 						  info->keep_memory);
8673 	  if (toc_relocs == NULL)
8674 	    goto error_ret;
8675 
8676 	  for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8677 	    {
8678 	      enum elf_ppc64_reloc_type r_type;
8679 	      unsigned long r_symndx;
8680 	      asection *sym_sec;
8681 	      struct elf_link_hash_entry *h;
8682 	      Elf_Internal_Sym *sym;
8683 	      bfd_vma val, addr;
8684 
8685 	      r_type = ELF64_R_TYPE (rel->r_info);
8686 	      if (r_type != R_PPC64_ADDR64)
8687 		continue;
8688 
8689 	      r_symndx = ELF64_R_SYM (rel->r_info);
8690 	      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8691 			      r_symndx, ibfd))
8692 		goto error_ret;
8693 
8694 	      if (sym_sec == NULL
8695 		  || discarded_section (sym_sec))
8696 		continue;
8697 
8698 	      if (!SYMBOL_REFERENCES_LOCAL (info, h))
8699 		continue;
8700 
8701 	      if (h != NULL)
8702 		{
8703 		  if (h->type == STT_GNU_IFUNC)
8704 		    continue;
8705 		  val = h->root.u.def.value;
8706 		}
8707 	      else
8708 		{
8709 		  if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8710 		    continue;
8711 		  val = sym->st_value;
8712 		}
8713 	      val += rel->r_addend;
8714 	      val += sym_sec->output_section->vma + sym_sec->output_offset;
8715 
8716 	      /* We don't yet know the exact toc pointer value, but we
8717 		 know it will be somewhere in the toc section.  Don't
8718 		 optimize if the difference from any possible toc
8719 		 pointer is outside [ff..f80008000, 7fff7fff].  */
8720 	      addr = toc->output_section->vma + TOC_BASE_OFF;
8721 	      if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8722 		continue;
8723 
8724 	      addr = toc->output_section->vma + toc->output_section->rawsize;
8725 	      if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8726 		continue;
8727 
8728 	      if (skip == NULL)
8729 		{
8730 		  skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8731 		  if (skip == NULL)
8732 		    goto error_ret;
8733 		}
8734 
8735 	      skip[rel->r_offset >> 3]
8736 		|= can_optimize | ((rel - toc_relocs) << 2);
8737 	    }
8738 	}
8739 
8740       if (skip == NULL)
8741 	continue;
8742 
8743       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8744       if (used == NULL)
8745 	{
8746 	error_ret:
8747 	  if (local_syms != NULL
8748 	      && symtab_hdr->contents != (unsigned char *) local_syms)
8749 	    free (local_syms);
8750 	  if (sec != NULL
8751 	      && relstart != NULL
8752 	      && elf_section_data (sec)->relocs != relstart)
8753 	    free (relstart);
8754 	  if (toc_relocs != NULL
8755 	      && elf_section_data (toc)->relocs != toc_relocs)
8756 	    free (toc_relocs);
8757 	  if (skip != NULL)
8758 	    free (skip);
8759 	  return FALSE;
8760 	}
8761 
8762       /* Now check all kept sections that might reference the toc.
8763 	 Check the toc itself last.  */
8764       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8765 		  : ibfd->sections);
8766 	   sec != NULL;
8767 	   sec = (sec == toc ? NULL
8768 		  : sec->next == NULL ? toc
8769 		  : sec->next == toc && toc->next ? toc->next
8770 		  : sec->next))
8771 	{
8772 	  int repeat;
8773 
8774 	  if (sec->reloc_count == 0
8775 	      || discarded_section (sec)
8776 	      || get_opd_info (sec)
8777 	      || (sec->flags & SEC_ALLOC) == 0
8778 	      || (sec->flags & SEC_DEBUGGING) != 0)
8779 	    continue;
8780 
8781 	  relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8782 						info->keep_memory);
8783 	  if (relstart == NULL)
8784 	    goto error_ret;
8785 
8786 	  /* Mark toc entries referenced as used.  */
8787 	  do
8788 	    {
8789 	      repeat = 0;
8790 	      for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8791 		{
8792 		  enum elf_ppc64_reloc_type r_type;
8793 		  unsigned long r_symndx;
8794 		  asection *sym_sec;
8795 		  struct elf_link_hash_entry *h;
8796 		  Elf_Internal_Sym *sym;
8797 		  bfd_vma val;
8798 		  enum {no_check, check_lo, check_ha} insn_check;
8799 
8800 		  r_type = ELF64_R_TYPE (rel->r_info);
8801 		  switch (r_type)
8802 		    {
8803 		    default:
8804 		      insn_check = no_check;
8805 		      break;
8806 
8807 		    case R_PPC64_GOT_TLSLD16_HA:
8808 		    case R_PPC64_GOT_TLSGD16_HA:
8809 		    case R_PPC64_GOT_TPREL16_HA:
8810 		    case R_PPC64_GOT_DTPREL16_HA:
8811 		    case R_PPC64_GOT16_HA:
8812 		    case R_PPC64_TOC16_HA:
8813 		      insn_check = check_ha;
8814 		      break;
8815 
8816 		    case R_PPC64_GOT_TLSLD16_LO:
8817 		    case R_PPC64_GOT_TLSGD16_LO:
8818 		    case R_PPC64_GOT_TPREL16_LO_DS:
8819 		    case R_PPC64_GOT_DTPREL16_LO_DS:
8820 		    case R_PPC64_GOT16_LO:
8821 		    case R_PPC64_GOT16_LO_DS:
8822 		    case R_PPC64_TOC16_LO:
8823 		    case R_PPC64_TOC16_LO_DS:
8824 		      insn_check = check_lo;
8825 		      break;
8826 		    }
8827 
8828 		  if (insn_check != no_check)
8829 		    {
8830 		      bfd_vma off = rel->r_offset & ~3;
8831 		      unsigned char buf[4];
8832 		      unsigned int insn;
8833 
8834 		      if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8835 			{
8836 			  free (used);
8837 			  goto error_ret;
8838 			}
8839 		      insn = bfd_get_32 (ibfd, buf);
8840 		      if (insn_check == check_lo
8841 			  ? !ok_lo_toc_insn (insn)
8842 			  : ((insn & ((0x3f << 26) | 0x1f << 16))
8843 			     != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8844 			{
8845 			  char str[12];
8846 
8847 			  ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8848 			  sprintf (str, "%#08x", insn);
8849 			  info->callbacks->einfo
8850 			    (_("%P: %H: toc optimization is not supported for"
8851 			       " %s instruction.\n"),
8852 			     ibfd, sec, rel->r_offset & ~3, str);
8853 			}
8854 		    }
8855 
8856 		  switch (r_type)
8857 		    {
8858 		    case R_PPC64_TOC16:
8859 		    case R_PPC64_TOC16_LO:
8860 		    case R_PPC64_TOC16_HI:
8861 		    case R_PPC64_TOC16_HA:
8862 		    case R_PPC64_TOC16_DS:
8863 		    case R_PPC64_TOC16_LO_DS:
8864 		      /* In case we're taking addresses of toc entries.  */
8865 		    case R_PPC64_ADDR64:
8866 		      break;
8867 
8868 		    default:
8869 		      continue;
8870 		    }
8871 
8872 		  r_symndx = ELF64_R_SYM (rel->r_info);
8873 		  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8874 				  r_symndx, ibfd))
8875 		    {
8876 		      free (used);
8877 		      goto error_ret;
8878 		    }
8879 
8880 		  if (sym_sec != toc)
8881 		    continue;
8882 
8883 		  if (h != NULL)
8884 		    val = h->root.u.def.value;
8885 		  else
8886 		    val = sym->st_value;
8887 		  val += rel->r_addend;
8888 
8889 		  if (val >= toc->size)
8890 		    continue;
8891 
8892 		  if ((skip[val >> 3] & can_optimize) != 0)
8893 		    {
8894 		      bfd_vma off;
8895 		      unsigned char opc;
8896 
8897 		      switch (r_type)
8898 			{
8899 			case R_PPC64_TOC16_HA:
8900 			  break;
8901 
8902 			case R_PPC64_TOC16_LO_DS:
8903 			  off = rel->r_offset;
8904 			  off += (bfd_big_endian (ibfd) ? -2 : 3);
8905 			  if (!bfd_get_section_contents (ibfd, sec, &opc,
8906 							 off, 1))
8907 			    {
8908 			      free (used);
8909 			      goto error_ret;
8910 			    }
8911 			  if ((opc & (0x3f << 2)) == (58u << 2))
8912 			    break;
8913 			  /* Fall thru */
8914 
8915 			default:
8916 			  /* Wrong sort of reloc, or not a ld.  We may
8917 			     as well clear ref_from_discarded too.  */
8918 			  skip[val >> 3] = 0;
8919 			}
8920 		    }
8921 
8922 		  if (sec != toc)
8923 		    used[val >> 3] = 1;
8924 		  /* For the toc section, we only mark as used if this
8925 		     entry itself isn't unused.  */
8926 		  else if ((used[rel->r_offset >> 3]
8927 			    || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8928 			   && !used[val >> 3])
8929 		    {
8930 		      /* Do all the relocs again, to catch reference
8931 			 chains.  */
8932 		      repeat = 1;
8933 		      used[val >> 3] = 1;
8934 		    }
8935 		}
8936 	    }
8937 	  while (repeat);
8938 
8939 	  if (elf_section_data (sec)->relocs != relstart)
8940 	    free (relstart);
8941 	}
8942 
8943       /* Merge the used and skip arrays.  Assume that TOC
8944 	 doublewords not appearing as either used or unused belong
8945 	 to to an entry more than one doubleword in size.  */
8946       for (drop = skip, keep = used, last = 0, some_unused = 0;
8947 	   drop < skip + (toc->size + 7) / 8;
8948 	   ++drop, ++keep)
8949 	{
8950 	  if (*keep)
8951 	    {
8952 	      *drop &= ~ref_from_discarded;
8953 	      if ((*drop & can_optimize) != 0)
8954 		some_unused = 1;
8955 	      last = 0;
8956 	    }
8957 	  else if ((*drop & ref_from_discarded) != 0)
8958 	    {
8959 	      some_unused = 1;
8960 	      last = ref_from_discarded;
8961 	    }
8962 	  else
8963 	    *drop = last;
8964 	}
8965 
8966       free (used);
8967 
8968       if (some_unused)
8969 	{
8970 	  bfd_byte *contents, *src;
8971 	  unsigned long off;
8972 	  Elf_Internal_Sym *sym;
8973 	  bfd_boolean local_toc_syms = FALSE;
8974 
8975 	  /* Shuffle the toc contents, and at the same time convert the
8976 	     skip array from booleans into offsets.  */
8977 	  if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8978 	    goto error_ret;
8979 
8980 	  elf_section_data (toc)->this_hdr.contents = contents;
8981 
8982 	  for (src = contents, off = 0, drop = skip;
8983 	       src < contents + toc->size;
8984 	       src += 8, ++drop)
8985 	    {
8986 	      if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8987 		off += 8;
8988 	      else if (off != 0)
8989 		{
8990 		  *drop = off;
8991 		  memcpy (src - off, src, 8);
8992 		}
8993 	    }
8994 	  *drop = off;
8995 	  toc->rawsize = toc->size;
8996 	  toc->size = src - contents - off;
8997 
8998 	  /* Adjust addends for relocs against the toc section sym,
8999 	     and optimize any accesses we can.  */
9000 	  for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9001 	    {
9002 	      if (sec->reloc_count == 0
9003 		  || discarded_section (sec))
9004 		continue;
9005 
9006 	      relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9007 						    info->keep_memory);
9008 	      if (relstart == NULL)
9009 		goto error_ret;
9010 
9011 	      for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9012 		{
9013 		  enum elf_ppc64_reloc_type r_type;
9014 		  unsigned long r_symndx;
9015 		  asection *sym_sec;
9016 		  struct elf_link_hash_entry *h;
9017 		  bfd_vma val;
9018 
9019 		  r_type = ELF64_R_TYPE (rel->r_info);
9020 		  switch (r_type)
9021 		    {
9022 		    default:
9023 		      continue;
9024 
9025 		    case R_PPC64_TOC16:
9026 		    case R_PPC64_TOC16_LO:
9027 		    case R_PPC64_TOC16_HI:
9028 		    case R_PPC64_TOC16_HA:
9029 		    case R_PPC64_TOC16_DS:
9030 		    case R_PPC64_TOC16_LO_DS:
9031 		    case R_PPC64_ADDR64:
9032 		      break;
9033 		    }
9034 
9035 		  r_symndx = ELF64_R_SYM (rel->r_info);
9036 		  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9037 				  r_symndx, ibfd))
9038 		    goto error_ret;
9039 
9040 		  if (sym_sec != toc)
9041 		    continue;
9042 
9043 		  if (h != NULL)
9044 		    val = h->root.u.def.value;
9045 		  else
9046 		    {
9047 		      val = sym->st_value;
9048 		      if (val != 0)
9049 			local_toc_syms = TRUE;
9050 		    }
9051 
9052 		  val += rel->r_addend;
9053 
9054 		  if (val > toc->rawsize)
9055 		    val = toc->rawsize;
9056 		  else if ((skip[val >> 3] & ref_from_discarded) != 0)
9057 		    continue;
9058 		  else if ((skip[val >> 3] & can_optimize) != 0)
9059 		    {
9060 		      Elf_Internal_Rela *tocrel
9061 			= toc_relocs + (skip[val >> 3] >> 2);
9062 		      unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9063 
9064 		      switch (r_type)
9065 			{
9066 			case R_PPC64_TOC16_HA:
9067 			  rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9068 			  break;
9069 
9070 			case R_PPC64_TOC16_LO_DS:
9071 			  rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9072 			  break;
9073 
9074 			default:
9075 			  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9076 			    ppc_howto_init ();
9077 			  info->callbacks->einfo
9078 			    (_("%P: %H: %s references "
9079 			       "optimized away TOC entry\n"),
9080 			     ibfd, sec, rel->r_offset,
9081 			     ppc64_elf_howto_table[r_type]->name);
9082 			  bfd_set_error (bfd_error_bad_value);
9083 			  goto error_ret;
9084 			}
9085 		      rel->r_addend = tocrel->r_addend;
9086 		      elf_section_data (sec)->relocs = relstart;
9087 		      continue;
9088 		    }
9089 
9090 		  if (h != NULL || sym->st_value != 0)
9091 		    continue;
9092 
9093 		  rel->r_addend -= skip[val >> 3];
9094 		  elf_section_data (sec)->relocs = relstart;
9095 		}
9096 
9097 	      if (elf_section_data (sec)->relocs != relstart)
9098 		free (relstart);
9099 	    }
9100 
9101 	  /* We shouldn't have local or global symbols defined in the TOC,
9102 	     but handle them anyway.  */
9103 	  if (local_syms != NULL)
9104 	    for (sym = local_syms;
9105 		 sym < local_syms + symtab_hdr->sh_info;
9106 		 ++sym)
9107 	      if (sym->st_value != 0
9108 		  && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9109 		{
9110 		  unsigned long i;
9111 
9112 		  if (sym->st_value > toc->rawsize)
9113 		    i = toc->rawsize >> 3;
9114 		  else
9115 		    i = sym->st_value >> 3;
9116 
9117 		  if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9118 		    {
9119 		      if (local_toc_syms)
9120 			(*_bfd_error_handler)
9121 			  (_("%s defined on removed toc entry"),
9122 			   bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9123 		      do
9124 			++i;
9125 		      while ((skip[i] & (ref_from_discarded | can_optimize)));
9126 		      sym->st_value = (bfd_vma) i << 3;
9127 		    }
9128 
9129 		  sym->st_value -= skip[i];
9130 		  symtab_hdr->contents = (unsigned char *) local_syms;
9131 		}
9132 
9133 	  /* Adjust any global syms defined in this toc input section.  */
9134 	  if (toc_inf.global_toc_syms)
9135 	    {
9136 	      toc_inf.toc = toc;
9137 	      toc_inf.skip = skip;
9138 	      toc_inf.global_toc_syms = FALSE;
9139 	      elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9140 				      &toc_inf);
9141 	    }
9142 
9143 	  if (toc->reloc_count != 0)
9144 	    {
9145 	      Elf_Internal_Shdr *rel_hdr;
9146 	      Elf_Internal_Rela *wrel;
9147 	      bfd_size_type sz;
9148 
9149 	      /* Remove unused toc relocs, and adjust those we keep.  */
9150 	      if (toc_relocs == NULL)
9151 		toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9152 							info->keep_memory);
9153 	      if (toc_relocs == NULL)
9154 		goto error_ret;
9155 
9156 	      wrel = toc_relocs;
9157 	      for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9158 		if ((skip[rel->r_offset >> 3]
9159 		     & (ref_from_discarded | can_optimize)) == 0)
9160 		  {
9161 		    wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9162 		    wrel->r_info = rel->r_info;
9163 		    wrel->r_addend = rel->r_addend;
9164 		    ++wrel;
9165 		  }
9166 		else if (!dec_dynrel_count (rel->r_info, toc, info,
9167 					    &local_syms, NULL, NULL))
9168 		  goto error_ret;
9169 
9170 	      elf_section_data (toc)->relocs = toc_relocs;
9171 	      toc->reloc_count = wrel - toc_relocs;
9172 	      rel_hdr = _bfd_elf_single_rel_hdr (toc);
9173 	      sz = rel_hdr->sh_entsize;
9174 	      rel_hdr->sh_size = toc->reloc_count * sz;
9175 	    }
9176 	}
9177       else if (toc_relocs != NULL
9178 	       && elf_section_data (toc)->relocs != toc_relocs)
9179 	free (toc_relocs);
9180 
9181       if (local_syms != NULL
9182 	  && symtab_hdr->contents != (unsigned char *) local_syms)
9183 	{
9184 	  if (!info->keep_memory)
9185 	    free (local_syms);
9186 	  else
9187 	    symtab_hdr->contents = (unsigned char *) local_syms;
9188 	}
9189       free (skip);
9190     }
9191 
9192   return TRUE;
9193 }
9194 
9195 /* Return true iff input section I references the TOC using
9196    instructions limited to +/-32k offsets.  */
9197 
9198 bfd_boolean
9199 ppc64_elf_has_small_toc_reloc (asection *i)
9200 {
9201   return (is_ppc64_elf (i->owner)
9202 	  && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9203 }
9204 
9205 /* Allocate space for one GOT entry.  */
9206 
9207 static void
9208 allocate_got (struct elf_link_hash_entry *h,
9209 	      struct bfd_link_info *info,
9210 	      struct got_entry *gent)
9211 {
9212   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9213   bfd_boolean dyn;
9214   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9215   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9216 		 ? 16 : 8);
9217   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9218 		  ? 2 : 1) * sizeof (Elf64_External_Rela);
9219   asection *got = ppc64_elf_tdata (gent->owner)->got;
9220 
9221   gent->got.offset = got->size;
9222   got->size += entsize;
9223 
9224   dyn = htab->elf.dynamic_sections_created;
9225   if (h->type == STT_GNU_IFUNC)
9226     {
9227       htab->elf.irelplt->size += rentsize;
9228       htab->got_reli_size += rentsize;
9229     }
9230   else if ((info->shared
9231 	    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9232 	   && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9233 	       || h->root.type != bfd_link_hash_undefweak))
9234     {
9235       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9236       relgot->size += rentsize;
9237     }
9238 }
9239 
9240 /* This function merges got entries in the same toc group.  */
9241 
9242 static void
9243 merge_got_entries (struct got_entry **pent)
9244 {
9245   struct got_entry *ent, *ent2;
9246 
9247   for (ent = *pent; ent != NULL; ent = ent->next)
9248     if (!ent->is_indirect)
9249       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9250 	if (!ent2->is_indirect
9251 	    && ent2->addend == ent->addend
9252 	    && ent2->tls_type == ent->tls_type
9253 	    && elf_gp (ent2->owner) == elf_gp (ent->owner))
9254 	  {
9255 	    ent2->is_indirect = TRUE;
9256 	    ent2->got.ent = ent;
9257 	  }
9258 }
9259 
9260 /* Allocate space in .plt, .got and associated reloc sections for
9261    dynamic relocs.  */
9262 
9263 static bfd_boolean
9264 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9265 {
9266   struct bfd_link_info *info;
9267   struct ppc_link_hash_table *htab;
9268   asection *s;
9269   struct ppc_link_hash_entry *eh;
9270   struct elf_dyn_relocs *p;
9271   struct got_entry **pgent, *gent;
9272 
9273   if (h->root.type == bfd_link_hash_indirect)
9274     return TRUE;
9275 
9276   info = (struct bfd_link_info *) inf;
9277   htab = ppc_hash_table (info);
9278   if (htab == NULL)
9279     return FALSE;
9280 
9281   if ((htab->elf.dynamic_sections_created
9282        && h->dynindx != -1
9283        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9284       || h->type == STT_GNU_IFUNC)
9285     {
9286       struct plt_entry *pent;
9287       bfd_boolean doneone = FALSE;
9288       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9289 	if (pent->plt.refcount > 0)
9290 	  {
9291 	    if (!htab->elf.dynamic_sections_created
9292 		|| h->dynindx == -1)
9293 	      {
9294 		s = htab->elf.iplt;
9295 		pent->plt.offset = s->size;
9296 		s->size += PLT_ENTRY_SIZE (htab);
9297 		s = htab->elf.irelplt;
9298 	      }
9299 	    else
9300 	      {
9301 		/* If this is the first .plt entry, make room for the special
9302 		   first entry.  */
9303 		s = htab->elf.splt;
9304 		if (s->size == 0)
9305 		  s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9306 
9307 		pent->plt.offset = s->size;
9308 
9309 		/* Make room for this entry.  */
9310 		s->size += PLT_ENTRY_SIZE (htab);
9311 
9312 		/* Make room for the .glink code.  */
9313 		s = htab->glink;
9314 		if (s->size == 0)
9315 		  s->size += GLINK_CALL_STUB_SIZE;
9316 		if (htab->opd_abi)
9317 		  {
9318 		    /* We need bigger stubs past index 32767.  */
9319 		    if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9320 		      s->size += 4;
9321 		    s->size += 2*4;
9322 		  }
9323 		else
9324 		  s->size += 4;
9325 
9326 		/* We also need to make an entry in the .rela.plt section.  */
9327 		s = htab->elf.srelplt;
9328 	      }
9329 	    s->size += sizeof (Elf64_External_Rela);
9330 	    doneone = TRUE;
9331 	  }
9332 	else
9333 	  pent->plt.offset = (bfd_vma) -1;
9334       if (!doneone)
9335 	{
9336 	  h->plt.plist = NULL;
9337 	  h->needs_plt = 0;
9338 	}
9339     }
9340   else
9341     {
9342       h->plt.plist = NULL;
9343       h->needs_plt = 0;
9344     }
9345 
9346   eh = (struct ppc_link_hash_entry *) h;
9347   /* Run through the TLS GD got entries first if we're changing them
9348      to TPREL.  */
9349   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9350     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9351       if (gent->got.refcount > 0
9352 	  && (gent->tls_type & TLS_GD) != 0)
9353 	{
9354 	  /* This was a GD entry that has been converted to TPREL.  If
9355 	     there happens to be a TPREL entry we can use that one.  */
9356 	  struct got_entry *ent;
9357 	  for (ent = h->got.glist; ent != NULL; ent = ent->next)
9358 	    if (ent->got.refcount > 0
9359 		&& (ent->tls_type & TLS_TPREL) != 0
9360 		&& ent->addend == gent->addend
9361 		&& ent->owner == gent->owner)
9362 	      {
9363 		gent->got.refcount = 0;
9364 		break;
9365 	      }
9366 
9367 	  /* If not, then we'll be using our own TPREL entry.  */
9368 	  if (gent->got.refcount != 0)
9369 	    gent->tls_type = TLS_TLS | TLS_TPREL;
9370 	}
9371 
9372   /* Remove any list entry that won't generate a word in the GOT before
9373      we call merge_got_entries.  Otherwise we risk merging to empty
9374      entries.  */
9375   pgent = &h->got.glist;
9376   while ((gent = *pgent) != NULL)
9377     if (gent->got.refcount > 0)
9378       {
9379 	if ((gent->tls_type & TLS_LD) != 0
9380 	    && !h->def_dynamic)
9381 	  {
9382 	    ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9383 	    *pgent = gent->next;
9384 	  }
9385 	else
9386 	  pgent = &gent->next;
9387       }
9388     else
9389       *pgent = gent->next;
9390 
9391   if (!htab->do_multi_toc)
9392     merge_got_entries (&h->got.glist);
9393 
9394   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9395     if (!gent->is_indirect)
9396       {
9397 	/* Make sure this symbol is output as a dynamic symbol.
9398 	   Undefined weak syms won't yet be marked as dynamic,
9399 	   nor will all TLS symbols.  */
9400 	if (h->dynindx == -1
9401 	    && !h->forced_local
9402 	    && h->type != STT_GNU_IFUNC
9403 	    && htab->elf.dynamic_sections_created)
9404 	  {
9405 	    if (! bfd_elf_link_record_dynamic_symbol (info, h))
9406 	      return FALSE;
9407 	  }
9408 
9409 	if (!is_ppc64_elf (gent->owner))
9410 	  abort ();
9411 
9412 	allocate_got (h, info, gent);
9413       }
9414 
9415   if (eh->dyn_relocs == NULL
9416       || (!htab->elf.dynamic_sections_created
9417 	  && h->type != STT_GNU_IFUNC))
9418     return TRUE;
9419 
9420   /* In the shared -Bsymbolic case, discard space allocated for
9421      dynamic pc-relative relocs against symbols which turn out to be
9422      defined in regular objects.  For the normal shared case, discard
9423      space for relocs that have become local due to symbol visibility
9424      changes.  */
9425 
9426   if (info->shared)
9427     {
9428       /* Relocs that use pc_count are those that appear on a call insn,
9429 	 or certain REL relocs (see must_be_dyn_reloc) that can be
9430 	 generated via assembly.  We want calls to protected symbols to
9431 	 resolve directly to the function rather than going via the plt.
9432 	 If people want function pointer comparisons to work as expected
9433 	 then they should avoid writing weird assembly.  */
9434       if (SYMBOL_CALLS_LOCAL (info, h))
9435 	{
9436 	  struct elf_dyn_relocs **pp;
9437 
9438 	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9439 	    {
9440 	      p->count -= p->pc_count;
9441 	      p->pc_count = 0;
9442 	      if (p->count == 0)
9443 		*pp = p->next;
9444 	      else
9445 		pp = &p->next;
9446 	    }
9447 	}
9448 
9449       /* Also discard relocs on undefined weak syms with non-default
9450 	 visibility.  */
9451       if (eh->dyn_relocs != NULL
9452 	  && h->root.type == bfd_link_hash_undefweak)
9453 	{
9454 	  if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9455 	    eh->dyn_relocs = NULL;
9456 
9457 	  /* Make sure this symbol is output as a dynamic symbol.
9458 	     Undefined weak syms won't yet be marked as dynamic.  */
9459 	  else if (h->dynindx == -1
9460 		   && !h->forced_local)
9461 	    {
9462 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
9463 		return FALSE;
9464 	    }
9465 	}
9466     }
9467   else if (h->type == STT_GNU_IFUNC)
9468     {
9469       if (!h->non_got_ref)
9470 	eh->dyn_relocs = NULL;
9471     }
9472   else if (ELIMINATE_COPY_RELOCS)
9473     {
9474       /* For the non-shared case, discard space for relocs against
9475 	 symbols which turn out to need copy relocs or are not
9476 	 dynamic.  */
9477 
9478       if (!h->non_got_ref
9479 	  && !h->def_regular)
9480 	{
9481 	  /* Make sure this symbol is output as a dynamic symbol.
9482 	     Undefined weak syms won't yet be marked as dynamic.  */
9483 	  if (h->dynindx == -1
9484 	      && !h->forced_local)
9485 	    {
9486 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
9487 		return FALSE;
9488 	    }
9489 
9490 	  /* If that succeeded, we know we'll be keeping all the
9491 	     relocs.  */
9492 	  if (h->dynindx != -1)
9493 	    goto keep;
9494 	}
9495 
9496       eh->dyn_relocs = NULL;
9497 
9498     keep: ;
9499     }
9500 
9501   /* Finally, allocate space.  */
9502   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9503     {
9504       asection *sreloc = elf_section_data (p->sec)->sreloc;
9505       if (eh->elf.type == STT_GNU_IFUNC)
9506 	sreloc = htab->elf.irelplt;
9507       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9508     }
9509 
9510   return TRUE;
9511 }
9512 
9513 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9514    to set up space for global entry stubs.  These are put in glink,
9515    after the branch table.  */
9516 
9517 static bfd_boolean
9518 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9519 {
9520   struct bfd_link_info *info;
9521   struct ppc_link_hash_table *htab;
9522   struct plt_entry *pent;
9523   asection *s;
9524 
9525   if (h->root.type == bfd_link_hash_indirect)
9526     return TRUE;
9527 
9528   if (!h->pointer_equality_needed)
9529     return TRUE;
9530 
9531   if (h->def_regular)
9532     return TRUE;
9533 
9534   info = inf;
9535   htab = ppc_hash_table (info);
9536   if (htab == NULL)
9537     return FALSE;
9538 
9539   s = htab->glink;
9540   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9541     if (pent->plt.offset != (bfd_vma) -1
9542 	&& pent->addend == 0)
9543       {
9544 	/* For ELFv2, if this symbol is not defined in a regular file
9545 	   and we are not generating a shared library or pie, then we
9546 	   need to define the symbol in the executable on a call stub.
9547 	   This is to avoid text relocations.  */
9548 	s->size = (s->size + 15) & -16;
9549 	h->root.u.def.section = s;
9550 	h->root.u.def.value = s->size;
9551 	s->size += 16;
9552 	break;
9553       }
9554   return TRUE;
9555 }
9556 
9557 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9558    read-only sections.  */
9559 
9560 static bfd_boolean
9561 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9562 {
9563   if (h->root.type == bfd_link_hash_indirect)
9564     return TRUE;
9565 
9566   if (readonly_dynrelocs (h))
9567     {
9568       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9569 
9570       /* Not an error, just cut short the traversal.  */
9571       return FALSE;
9572     }
9573   return TRUE;
9574 }
9575 
9576 /* Set the sizes of the dynamic sections.  */
9577 
9578 static bfd_boolean
9579 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9580 				 struct bfd_link_info *info)
9581 {
9582   struct ppc_link_hash_table *htab;
9583   bfd *dynobj;
9584   asection *s;
9585   bfd_boolean relocs;
9586   bfd *ibfd;
9587   struct got_entry *first_tlsld;
9588 
9589   htab = ppc_hash_table (info);
9590   if (htab == NULL)
9591     return FALSE;
9592 
9593   dynobj = htab->elf.dynobj;
9594   if (dynobj == NULL)
9595     abort ();
9596 
9597   if (htab->elf.dynamic_sections_created)
9598     {
9599       /* Set the contents of the .interp section to the interpreter.  */
9600       if (info->executable)
9601 	{
9602 	  s = bfd_get_linker_section (dynobj, ".interp");
9603 	  if (s == NULL)
9604 	    abort ();
9605 	  s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9606 	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9607 	}
9608     }
9609 
9610   /* Set up .got offsets for local syms, and space for local dynamic
9611      relocs.  */
9612   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9613     {
9614       struct got_entry **lgot_ents;
9615       struct got_entry **end_lgot_ents;
9616       struct plt_entry **local_plt;
9617       struct plt_entry **end_local_plt;
9618       unsigned char *lgot_masks;
9619       bfd_size_type locsymcount;
9620       Elf_Internal_Shdr *symtab_hdr;
9621 
9622       if (!is_ppc64_elf (ibfd))
9623 	continue;
9624 
9625       for (s = ibfd->sections; s != NULL; s = s->next)
9626 	{
9627 	  struct ppc_dyn_relocs *p;
9628 
9629 	  for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9630 	    {
9631 	      if (!bfd_is_abs_section (p->sec)
9632 		  && bfd_is_abs_section (p->sec->output_section))
9633 		{
9634 		  /* Input section has been discarded, either because
9635 		     it is a copy of a linkonce section or due to
9636 		     linker script /DISCARD/, so we'll be discarding
9637 		     the relocs too.  */
9638 		}
9639 	      else if (p->count != 0)
9640 		{
9641 		  asection *srel = elf_section_data (p->sec)->sreloc;
9642 		  if (p->ifunc)
9643 		    srel = htab->elf.irelplt;
9644 		  srel->size += p->count * sizeof (Elf64_External_Rela);
9645 		  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9646 		    info->flags |= DF_TEXTREL;
9647 		}
9648 	    }
9649 	}
9650 
9651       lgot_ents = elf_local_got_ents (ibfd);
9652       if (!lgot_ents)
9653 	continue;
9654 
9655       symtab_hdr = &elf_symtab_hdr (ibfd);
9656       locsymcount = symtab_hdr->sh_info;
9657       end_lgot_ents = lgot_ents + locsymcount;
9658       local_plt = (struct plt_entry **) end_lgot_ents;
9659       end_local_plt = local_plt + locsymcount;
9660       lgot_masks = (unsigned char *) end_local_plt;
9661       s = ppc64_elf_tdata (ibfd)->got;
9662       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9663 	{
9664 	  struct got_entry **pent, *ent;
9665 
9666 	  pent = lgot_ents;
9667 	  while ((ent = *pent) != NULL)
9668 	    if (ent->got.refcount > 0)
9669 	      {
9670 		if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9671 		  {
9672 		    ppc64_tlsld_got (ibfd)->got.refcount += 1;
9673 		    *pent = ent->next;
9674 		  }
9675 		else
9676 		  {
9677 		    unsigned int ent_size = 8;
9678 		    unsigned int rel_size = sizeof (Elf64_External_Rela);
9679 
9680 		    ent->got.offset = s->size;
9681 		    if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9682 		      {
9683 			ent_size *= 2;
9684 			rel_size *= 2;
9685 		      }
9686 		    s->size += ent_size;
9687 		    if ((*lgot_masks & PLT_IFUNC) != 0)
9688 		      {
9689 			htab->elf.irelplt->size += rel_size;
9690 			htab->got_reli_size += rel_size;
9691 		      }
9692 		    else if (info->shared)
9693 		      {
9694 			asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9695 			srel->size += rel_size;
9696 		      }
9697 		    pent = &ent->next;
9698 		  }
9699 	      }
9700 	    else
9701 	      *pent = ent->next;
9702 	}
9703 
9704       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9705       for (; local_plt < end_local_plt; ++local_plt)
9706 	{
9707 	  struct plt_entry *ent;
9708 
9709 	  for (ent = *local_plt; ent != NULL; ent = ent->next)
9710 	    if (ent->plt.refcount > 0)
9711 	      {
9712 		s = htab->elf.iplt;
9713 		ent->plt.offset = s->size;
9714 		s->size += PLT_ENTRY_SIZE (htab);
9715 
9716 		htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9717 	      }
9718 	    else
9719 	      ent->plt.offset = (bfd_vma) -1;
9720 	}
9721     }
9722 
9723   /* Allocate global sym .plt and .got entries, and space for global
9724      sym dynamic relocs.  */
9725   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9726   /* Stash the end of glink branch table.  */
9727   if (htab->glink != NULL)
9728     htab->glink->rawsize = htab->glink->size;
9729 
9730   if (!htab->opd_abi && !info->shared)
9731     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9732 
9733   first_tlsld = NULL;
9734   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9735     {
9736       struct got_entry *ent;
9737 
9738       if (!is_ppc64_elf (ibfd))
9739 	continue;
9740 
9741       ent = ppc64_tlsld_got (ibfd);
9742       if (ent->got.refcount > 0)
9743 	{
9744 	  if (!htab->do_multi_toc && first_tlsld != NULL)
9745 	    {
9746 	      ent->is_indirect = TRUE;
9747 	      ent->got.ent = first_tlsld;
9748 	    }
9749 	  else
9750 	    {
9751 	      if (first_tlsld == NULL)
9752 		first_tlsld = ent;
9753 	      s = ppc64_elf_tdata (ibfd)->got;
9754 	      ent->got.offset = s->size;
9755 	      ent->owner = ibfd;
9756 	      s->size += 16;
9757 	      if (info->shared)
9758 		{
9759 		  asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9760 		  srel->size += sizeof (Elf64_External_Rela);
9761 		}
9762 	    }
9763 	}
9764       else
9765 	ent->got.offset = (bfd_vma) -1;
9766     }
9767 
9768   /* We now have determined the sizes of the various dynamic sections.
9769      Allocate memory for them.  */
9770   relocs = FALSE;
9771   for (s = dynobj->sections; s != NULL; s = s->next)
9772     {
9773       if ((s->flags & SEC_LINKER_CREATED) == 0)
9774 	continue;
9775 
9776       if (s == htab->brlt || s == htab->relbrlt)
9777 	/* These haven't been allocated yet;  don't strip.  */
9778 	continue;
9779       else if (s == htab->elf.sgot
9780 	       || s == htab->elf.splt
9781 	       || s == htab->elf.iplt
9782 	       || s == htab->glink
9783 	       || s == htab->dynbss)
9784 	{
9785 	  /* Strip this section if we don't need it; see the
9786 	     comment below.  */
9787 	}
9788       else if (s == htab->glink_eh_frame)
9789 	{
9790 	  if (!bfd_is_abs_section (s->output_section))
9791 	    /* Not sized yet.  */
9792 	    continue;
9793 	}
9794       else if (CONST_STRNEQ (s->name, ".rela"))
9795 	{
9796 	  if (s->size != 0)
9797 	    {
9798 	      if (s != htab->elf.srelplt)
9799 		relocs = TRUE;
9800 
9801 	      /* We use the reloc_count field as a counter if we need
9802 		 to copy relocs into the output file.  */
9803 	      s->reloc_count = 0;
9804 	    }
9805 	}
9806       else
9807 	{
9808 	  /* It's not one of our sections, so don't allocate space.  */
9809 	  continue;
9810 	}
9811 
9812       if (s->size == 0)
9813 	{
9814 	  /* If we don't need this section, strip it from the
9815 	     output file.  This is mostly to handle .rela.bss and
9816 	     .rela.plt.  We must create both sections in
9817 	     create_dynamic_sections, because they must be created
9818 	     before the linker maps input sections to output
9819 	     sections.  The linker does that before
9820 	     adjust_dynamic_symbol is called, and it is that
9821 	     function which decides whether anything needs to go
9822 	     into these sections.  */
9823 	  s->flags |= SEC_EXCLUDE;
9824 	  continue;
9825 	}
9826 
9827       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9828 	continue;
9829 
9830       /* Allocate memory for the section contents.  We use bfd_zalloc
9831 	 here in case unused entries are not reclaimed before the
9832 	 section's contents are written out.  This should not happen,
9833 	 but this way if it does we get a R_PPC64_NONE reloc in .rela
9834 	 sections instead of garbage.
9835 	 We also rely on the section contents being zero when writing
9836 	 the GOT.  */
9837       s->contents = bfd_zalloc (dynobj, s->size);
9838       if (s->contents == NULL)
9839 	return FALSE;
9840     }
9841 
9842   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9843     {
9844       if (!is_ppc64_elf (ibfd))
9845 	continue;
9846 
9847       s = ppc64_elf_tdata (ibfd)->got;
9848       if (s != NULL && s != htab->elf.sgot)
9849 	{
9850 	  if (s->size == 0)
9851 	    s->flags |= SEC_EXCLUDE;
9852 	  else
9853 	    {
9854 	      s->contents = bfd_zalloc (ibfd, s->size);
9855 	      if (s->contents == NULL)
9856 		return FALSE;
9857 	    }
9858 	}
9859       s = ppc64_elf_tdata (ibfd)->relgot;
9860       if (s != NULL)
9861 	{
9862 	  if (s->size == 0)
9863 	    s->flags |= SEC_EXCLUDE;
9864 	  else
9865 	    {
9866 	      s->contents = bfd_zalloc (ibfd, s->size);
9867 	      if (s->contents == NULL)
9868 		return FALSE;
9869 	      relocs = TRUE;
9870 	      s->reloc_count = 0;
9871 	    }
9872 	}
9873     }
9874 
9875   if (htab->elf.dynamic_sections_created)
9876     {
9877       bfd_boolean tls_opt;
9878 
9879       /* Add some entries to the .dynamic section.  We fill in the
9880 	 values later, in ppc64_elf_finish_dynamic_sections, but we
9881 	 must add the entries now so that we get the correct size for
9882 	 the .dynamic section.  The DT_DEBUG entry is filled in by the
9883 	 dynamic linker and used by the debugger.  */
9884 #define add_dynamic_entry(TAG, VAL) \
9885   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9886 
9887       if (info->executable)
9888 	{
9889 	  if (!add_dynamic_entry (DT_DEBUG, 0))
9890 	    return FALSE;
9891 	}
9892 
9893       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9894 	{
9895 	  if (!add_dynamic_entry (DT_PLTGOT, 0)
9896 	      || !add_dynamic_entry (DT_PLTRELSZ, 0)
9897 	      || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9898 	      || !add_dynamic_entry (DT_JMPREL, 0)
9899 	      || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9900 	    return FALSE;
9901 	}
9902 
9903       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9904 	{
9905 	  if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9906 	      || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9907 	    return FALSE;
9908 	}
9909 
9910       tls_opt = (!htab->no_tls_get_addr_opt
9911 		 && htab->tls_get_addr_fd != NULL
9912 		 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9913       if (tls_opt || !htab->opd_abi)
9914 	{
9915 	  if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9916 	    return FALSE;
9917 	}
9918 
9919       if (relocs)
9920 	{
9921 	  if (!add_dynamic_entry (DT_RELA, 0)
9922 	      || !add_dynamic_entry (DT_RELASZ, 0)
9923 	      || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9924 	    return FALSE;
9925 
9926 	  /* If any dynamic relocs apply to a read-only section,
9927 	     then we need a DT_TEXTREL entry.  */
9928 	  if ((info->flags & DF_TEXTREL) == 0)
9929 	    elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9930 
9931 	  if ((info->flags & DF_TEXTREL) != 0)
9932 	    {
9933 	      if (!add_dynamic_entry (DT_TEXTREL, 0))
9934 		return FALSE;
9935 	    }
9936 	}
9937     }
9938 #undef add_dynamic_entry
9939 
9940   return TRUE;
9941 }
9942 
9943 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9944 
9945 static bfd_boolean
9946 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9947 {
9948   if (h->plt.plist != NULL
9949       && !h->def_regular
9950       && !h->pointer_equality_needed)
9951     return FALSE;
9952 
9953   return _bfd_elf_hash_symbol (h);
9954 }
9955 
9956 /* Determine the type of stub needed, if any, for a call.  */
9957 
9958 static inline enum ppc_stub_type
9959 ppc_type_of_stub (asection *input_sec,
9960 		  const Elf_Internal_Rela *rel,
9961 		  struct ppc_link_hash_entry **hash,
9962 		  struct plt_entry **plt_ent,
9963 		  bfd_vma destination,
9964 		  unsigned long local_off)
9965 {
9966   struct ppc_link_hash_entry *h = *hash;
9967   bfd_vma location;
9968   bfd_vma branch_offset;
9969   bfd_vma max_branch_offset;
9970   enum elf_ppc64_reloc_type r_type;
9971 
9972   if (h != NULL)
9973     {
9974       struct plt_entry *ent;
9975       struct ppc_link_hash_entry *fdh = h;
9976       if (h->oh != NULL
9977 	  && h->oh->is_func_descriptor)
9978 	{
9979 	  fdh = ppc_follow_link (h->oh);
9980 	  *hash = fdh;
9981 	}
9982 
9983       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9984 	if (ent->addend == rel->r_addend
9985 	    && ent->plt.offset != (bfd_vma) -1)
9986 	  {
9987 	    *plt_ent = ent;
9988 	    return ppc_stub_plt_call;
9989 	  }
9990 
9991       /* Here, we know we don't have a plt entry.  If we don't have a
9992 	 either a defined function descriptor or a defined entry symbol
9993 	 in a regular object file, then it is pointless trying to make
9994 	 any other type of stub.  */
9995       if (!is_static_defined (&fdh->elf)
9996 	  && !is_static_defined (&h->elf))
9997 	return ppc_stub_none;
9998     }
9999   else if (elf_local_got_ents (input_sec->owner) != NULL)
10000     {
10001       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10002       struct plt_entry **local_plt = (struct plt_entry **)
10003 	elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10004       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10005 
10006       if (local_plt[r_symndx] != NULL)
10007 	{
10008 	  struct plt_entry *ent;
10009 
10010 	  for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10011 	    if (ent->addend == rel->r_addend
10012 		&& ent->plt.offset != (bfd_vma) -1)
10013 	      {
10014 		*plt_ent = ent;
10015 		return ppc_stub_plt_call;
10016 	      }
10017 	}
10018     }
10019 
10020   /* Determine where the call point is.  */
10021   location = (input_sec->output_offset
10022 	      + input_sec->output_section->vma
10023 	      + rel->r_offset);
10024 
10025   branch_offset = destination - location;
10026   r_type = ELF64_R_TYPE (rel->r_info);
10027 
10028   /* Determine if a long branch stub is needed.  */
10029   max_branch_offset = 1 << 25;
10030   if (r_type != R_PPC64_REL24)
10031     max_branch_offset = 1 << 15;
10032 
10033   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10034     /* We need a stub.  Figure out whether a long_branch or plt_branch
10035        is needed later.  */
10036     return ppc_stub_long_branch;
10037 
10038   return ppc_stub_none;
10039 }
10040 
10041 /* With power7 weakly ordered memory model, it is possible for ld.so
10042    to update a plt entry in one thread and have another thread see a
10043    stale zero toc entry.  To avoid this we need some sort of acquire
10044    barrier in the call stub.  One solution is to make the load of the
10045    toc word seem to appear to depend on the load of the function entry
10046    word.  Another solution is to test for r2 being zero, and branch to
10047    the appropriate glink entry if so.
10048 
10049    .	fake dep barrier	compare
10050    .	ld 12,xxx(2)		ld 12,xxx(2)
10051    .	mtctr 12		mtctr 12
10052    .	xor 11,12,12		ld 2,xxx+8(2)
10053    .	add 2,2,11		cmpldi 2,0
10054    .	ld 2,xxx+8(2)		bnectr+
10055    .	bctr			b <glink_entry>
10056 
10057    The solution involving the compare turns out to be faster, so
10058    that's what we use unless the branch won't reach.  */
10059 
10060 #define ALWAYS_USE_FAKE_DEP 0
10061 #define ALWAYS_EMIT_R2SAVE 0
10062 
10063 #define PPC_LO(v) ((v) & 0xffff)
10064 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10065 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10066 
10067 static inline unsigned int
10068 plt_stub_size (struct ppc_link_hash_table *htab,
10069 	       struct ppc_stub_hash_entry *stub_entry,
10070 	       bfd_vma off)
10071 {
10072   unsigned size = 12;
10073 
10074   if (ALWAYS_EMIT_R2SAVE
10075       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10076     size += 4;
10077   if (PPC_HA (off) != 0)
10078     size += 4;
10079   if (htab->opd_abi)
10080     {
10081       size += 4;
10082       if (htab->plt_static_chain)
10083 	size += 4;
10084       if (htab->plt_thread_safe)
10085 	size += 8;
10086       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10087 	size += 4;
10088     }
10089   if (stub_entry->h != NULL
10090       && (stub_entry->h == htab->tls_get_addr_fd
10091 	  || stub_entry->h == htab->tls_get_addr)
10092       && !htab->no_tls_get_addr_opt)
10093     size += 13 * 4;
10094   return size;
10095 }
10096 
10097 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10098    then return the padding needed to do so.  */
10099 static inline unsigned int
10100 plt_stub_pad (struct ppc_link_hash_table *htab,
10101 	      struct ppc_stub_hash_entry *stub_entry,
10102 	      bfd_vma plt_off)
10103 {
10104   int stub_align = 1 << htab->plt_stub_align;
10105   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10106   bfd_vma stub_off = stub_entry->stub_sec->size;
10107 
10108   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10109       > (stub_size & -stub_align))
10110     return stub_align - (stub_off & (stub_align - 1));
10111   return 0;
10112 }
10113 
10114 /* Build a .plt call stub.  */
10115 
10116 static inline bfd_byte *
10117 build_plt_stub (struct ppc_link_hash_table *htab,
10118 		struct ppc_stub_hash_entry *stub_entry,
10119 		bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10120 {
10121   bfd *obfd = htab->stub_bfd;
10122   bfd_boolean plt_load_toc = htab->opd_abi;
10123   bfd_boolean plt_static_chain = htab->plt_static_chain;
10124   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10125   bfd_boolean use_fake_dep = plt_thread_safe;
10126   bfd_vma cmp_branch_off = 0;
10127 
10128   if (!ALWAYS_USE_FAKE_DEP
10129       && plt_load_toc
10130       && plt_thread_safe
10131       && !(stub_entry->h != NULL
10132 	   && (stub_entry->h == htab->tls_get_addr_fd
10133 	       || stub_entry->h == htab->tls_get_addr)
10134 	   && !htab->no_tls_get_addr_opt))
10135     {
10136       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10137       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10138 			  / PLT_ENTRY_SIZE (htab));
10139       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10140       bfd_vma to, from;
10141 
10142       if (pltindex > 32768)
10143 	glinkoff += (pltindex - 32768) * 4;
10144       to = (glinkoff
10145 	    + htab->glink->output_offset
10146 	    + htab->glink->output_section->vma);
10147       from = (p - stub_entry->stub_sec->contents
10148 	      + 4 * (ALWAYS_EMIT_R2SAVE
10149 		     || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10150 	      + 4 * (PPC_HA (offset) != 0)
10151 	      + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10152 		     != PPC_HA (offset))
10153 	      + 4 * (plt_static_chain != 0)
10154 	      + 20
10155 	      + stub_entry->stub_sec->output_offset
10156 	      + stub_entry->stub_sec->output_section->vma);
10157       cmp_branch_off = to - from;
10158       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10159     }
10160 
10161   if (PPC_HA (offset) != 0)
10162     {
10163       if (r != NULL)
10164 	{
10165 	  if (ALWAYS_EMIT_R2SAVE
10166 	      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10167 	    r[0].r_offset += 4;
10168 	  r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10169 	  r[1].r_offset = r[0].r_offset + 4;
10170 	  r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10171 	  r[1].r_addend = r[0].r_addend;
10172 	  if (plt_load_toc)
10173 	    {
10174 	      if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10175 		{
10176 		  r[2].r_offset = r[1].r_offset + 4;
10177 		  r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10178 		  r[2].r_addend = r[0].r_addend;
10179 		}
10180 	      else
10181 		{
10182 		  r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10183 		  r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10184 		  r[2].r_addend = r[0].r_addend + 8;
10185 		  if (plt_static_chain)
10186 		    {
10187 		      r[3].r_offset = r[2].r_offset + 4;
10188 		      r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10189 		      r[3].r_addend = r[0].r_addend + 16;
10190 		    }
10191 		}
10192 	    }
10193 	}
10194       if (ALWAYS_EMIT_R2SAVE
10195 	  || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10196 	bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),	p += 4;
10197       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),	p += 4;
10198       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),	p += 4;
10199       if (plt_load_toc
10200 	  && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10201 	{
10202 	  bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p),	p += 4;
10203 	  offset = 0;
10204 	}
10205       bfd_put_32 (obfd, MTCTR_R12, p),				p += 4;
10206       if (plt_load_toc)
10207 	{
10208 	  if (use_fake_dep)
10209 	    {
10210 	      bfd_put_32 (obfd, XOR_R2_R12_R12, p),		p += 4;
10211 	      bfd_put_32 (obfd, ADD_R11_R11_R2, p),		p += 4;
10212 	    }
10213 	  bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10214 	  if (plt_static_chain)
10215 	    bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10216 	}
10217     }
10218   else
10219     {
10220       if (r != NULL)
10221 	{
10222 	  if (ALWAYS_EMIT_R2SAVE
10223 	      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10224 	    r[0].r_offset += 4;
10225 	  r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10226 	  if (plt_load_toc)
10227 	    {
10228 	      if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10229 		{
10230 		  r[1].r_offset = r[0].r_offset + 4;
10231 		  r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10232 		  r[1].r_addend = r[0].r_addend;
10233 		}
10234 	      else
10235 		{
10236 		  r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10237 		  r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10238 		  r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10239 		  if (plt_static_chain)
10240 		    {
10241 		      r[2].r_offset = r[1].r_offset + 4;
10242 		      r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10243 		      r[2].r_addend = r[0].r_addend + 8;
10244 		    }
10245 		}
10246 	    }
10247 	}
10248       if (ALWAYS_EMIT_R2SAVE
10249 	  || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10250 	bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),	p += 4;
10251       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),	p += 4;
10252       if (plt_load_toc
10253 	  && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10254 	{
10255 	  bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),	p += 4;
10256 	  offset = 0;
10257 	}
10258       bfd_put_32 (obfd, MTCTR_R12, p),				p += 4;
10259       if (plt_load_toc)
10260 	{
10261 	  if (use_fake_dep)
10262 	    {
10263 	      bfd_put_32 (obfd, XOR_R11_R12_R12, p),		p += 4;
10264 	      bfd_put_32 (obfd, ADD_R2_R2_R11, p),		p += 4;
10265 	    }
10266 	  if (plt_static_chain)
10267 	    bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10268 	  bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10269 	}
10270     }
10271   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10272     {
10273       bfd_put_32 (obfd, CMPLDI_R2_0, p),			p += 4;
10274       bfd_put_32 (obfd, BNECTR_P4, p),				p += 4;
10275       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10276     }
10277   else
10278     bfd_put_32 (obfd, BCTR, p),					p += 4;
10279   return p;
10280 }
10281 
10282 /* Build a special .plt call stub for __tls_get_addr.  */
10283 
10284 #define LD_R11_0R3	0xe9630000
10285 #define LD_R12_0R3	0xe9830000
10286 #define MR_R0_R3	0x7c601b78
10287 #define CMPDI_R11_0	0x2c2b0000
10288 #define ADD_R3_R12_R13	0x7c6c6a14
10289 #define BEQLR		0x4d820020
10290 #define MR_R3_R0	0x7c030378
10291 #define STD_R11_0R1	0xf9610000
10292 #define BCTRL		0x4e800421
10293 #define LD_R11_0R1	0xe9610000
10294 #define MTLR_R11	0x7d6803a6
10295 
10296 static inline bfd_byte *
10297 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10298 			 struct ppc_stub_hash_entry *stub_entry,
10299 			 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10300 {
10301   bfd *obfd = htab->stub_bfd;
10302 
10303   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),		p += 4;
10304   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),		p += 4;
10305   bfd_put_32 (obfd, MR_R0_R3, p),		p += 4;
10306   bfd_put_32 (obfd, CMPDI_R11_0, p),		p += 4;
10307   bfd_put_32 (obfd, ADD_R3_R12_R13, p),		p += 4;
10308   bfd_put_32 (obfd, BEQLR, p),			p += 4;
10309   bfd_put_32 (obfd, MR_R3_R0, p),		p += 4;
10310   bfd_put_32 (obfd, MFLR_R11, p),		p += 4;
10311   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10312 
10313   if (r != NULL)
10314     r[0].r_offset += 9 * 4;
10315   p = build_plt_stub (htab, stub_entry, p, offset, r);
10316   bfd_put_32 (obfd, BCTRL, p - 4);
10317 
10318   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p),	p += 4;
10319   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),	p += 4;
10320   bfd_put_32 (obfd, MTLR_R11, p),		p += 4;
10321   bfd_put_32 (obfd, BLR, p),			p += 4;
10322 
10323   return p;
10324 }
10325 
10326 static Elf_Internal_Rela *
10327 get_relocs (asection *sec, int count)
10328 {
10329   Elf_Internal_Rela *relocs;
10330   struct bfd_elf_section_data *elfsec_data;
10331 
10332   elfsec_data = elf_section_data (sec);
10333   relocs = elfsec_data->relocs;
10334   if (relocs == NULL)
10335     {
10336       bfd_size_type relsize;
10337       relsize = sec->reloc_count * sizeof (*relocs);
10338       relocs = bfd_alloc (sec->owner, relsize);
10339       if (relocs == NULL)
10340 	return NULL;
10341       elfsec_data->relocs = relocs;
10342       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10343 					  sizeof (Elf_Internal_Shdr));
10344       if (elfsec_data->rela.hdr == NULL)
10345 	return NULL;
10346       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10347 					* sizeof (Elf64_External_Rela));
10348       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10349       sec->reloc_count = 0;
10350     }
10351   relocs += sec->reloc_count;
10352   sec->reloc_count += count;
10353   return relocs;
10354 }
10355 
10356 static bfd_vma
10357 get_r2off (struct bfd_link_info *info,
10358 	   struct ppc_stub_hash_entry *stub_entry)
10359 {
10360   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10361   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10362 
10363   if (r2off == 0)
10364     {
10365       /* Support linking -R objects.  Get the toc pointer from the
10366 	 opd entry.  */
10367       char buf[8];
10368       if (!htab->opd_abi)
10369 	return r2off;
10370       asection *opd = stub_entry->h->elf.root.u.def.section;
10371       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10372 
10373       if (strcmp (opd->name, ".opd") != 0
10374 	  || opd->reloc_count != 0)
10375 	{
10376 	  info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10377 				  stub_entry->h->elf.root.root.string);
10378 	  bfd_set_error (bfd_error_bad_value);
10379 	  return 0;
10380 	}
10381       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10382 	return 0;
10383       r2off = bfd_get_64 (opd->owner, buf);
10384       r2off -= elf_gp (info->output_bfd);
10385     }
10386   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10387   return r2off;
10388 }
10389 
10390 static bfd_boolean
10391 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10392 {
10393   struct ppc_stub_hash_entry *stub_entry;
10394   struct ppc_branch_hash_entry *br_entry;
10395   struct bfd_link_info *info;
10396   struct ppc_link_hash_table *htab;
10397   bfd_byte *loc;
10398   bfd_byte *p;
10399   bfd_vma dest, off;
10400   int size;
10401   Elf_Internal_Rela *r;
10402   asection *plt;
10403 
10404   /* Massage our args to the form they really have.  */
10405   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10406   info = in_arg;
10407 
10408   htab = ppc_hash_table (info);
10409   if (htab == NULL)
10410     return FALSE;
10411 
10412   /* Make a note of the offset within the stubs for this entry.  */
10413   stub_entry->stub_offset = stub_entry->stub_sec->size;
10414   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10415 
10416   htab->stub_count[stub_entry->stub_type - 1] += 1;
10417   switch (stub_entry->stub_type)
10418     {
10419     case ppc_stub_long_branch:
10420     case ppc_stub_long_branch_r2off:
10421       /* Branches are relative.  This is where we are going to.  */
10422       dest = (stub_entry->target_value
10423 	      + stub_entry->target_section->output_offset
10424 	      + stub_entry->target_section->output_section->vma);
10425       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10426       off = dest;
10427 
10428       /* And this is where we are coming from.  */
10429       off -= (stub_entry->stub_offset
10430 	      + stub_entry->stub_sec->output_offset
10431 	      + stub_entry->stub_sec->output_section->vma);
10432 
10433       size = 4;
10434       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10435 	{
10436 	  bfd_vma r2off = get_r2off (info, stub_entry);
10437 
10438 	  if (r2off == 0)
10439 	    {
10440 	      htab->stub_error = TRUE;
10441 	      return FALSE;
10442 	    }
10443 	  bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10444 	  loc += 4;
10445 	  size = 12;
10446 	  if (PPC_HA (r2off) != 0)
10447 	    {
10448 	      size = 16;
10449 	      bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10450 	      loc += 4;
10451 	    }
10452 	  bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10453 	  loc += 4;
10454 	  off -= size - 4;
10455 	}
10456       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10457 
10458       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10459 	{
10460 	  info->callbacks->einfo
10461 	    (_("%P: long branch stub `%s' offset overflow\n"),
10462 	     stub_entry->root.string);
10463 	  htab->stub_error = TRUE;
10464 	  return FALSE;
10465 	}
10466 
10467       if (info->emitrelocations)
10468 	{
10469 	  r = get_relocs (stub_entry->stub_sec, 1);
10470 	  if (r == NULL)
10471 	    return FALSE;
10472 	  r->r_offset = loc - stub_entry->stub_sec->contents;
10473 	  r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10474 	  r->r_addend = dest;
10475 	  if (stub_entry->h != NULL)
10476 	    {
10477 	      struct elf_link_hash_entry **hashes;
10478 	      unsigned long symndx;
10479 	      struct ppc_link_hash_entry *h;
10480 
10481 	      hashes = elf_sym_hashes (htab->stub_bfd);
10482 	      if (hashes == NULL)
10483 		{
10484 		  bfd_size_type hsize;
10485 
10486 		  hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10487 		  hashes = bfd_zalloc (htab->stub_bfd, hsize);
10488 		  if (hashes == NULL)
10489 		    return FALSE;
10490 		  elf_sym_hashes (htab->stub_bfd) = hashes;
10491 		  htab->stub_globals = 1;
10492 		}
10493 	      symndx = htab->stub_globals++;
10494 	      h = stub_entry->h;
10495 	      hashes[symndx] = &h->elf;
10496 	      r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10497 	      if (h->oh != NULL && h->oh->is_func)
10498 		h = ppc_follow_link (h->oh);
10499 	      if (h->elf.root.u.def.section != stub_entry->target_section)
10500 		/* H is an opd symbol.  The addend must be zero.  */
10501 		r->r_addend = 0;
10502 	      else
10503 		{
10504 		  off = (h->elf.root.u.def.value
10505 			 + h->elf.root.u.def.section->output_offset
10506 			 + h->elf.root.u.def.section->output_section->vma);
10507 		  r->r_addend -= off;
10508 		}
10509 	    }
10510 	}
10511       break;
10512 
10513     case ppc_stub_plt_branch:
10514     case ppc_stub_plt_branch_r2off:
10515       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10516 					 stub_entry->root.string + 9,
10517 					 FALSE, FALSE);
10518       if (br_entry == NULL)
10519 	{
10520 	  info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10521 				  stub_entry->root.string);
10522 	  htab->stub_error = TRUE;
10523 	  return FALSE;
10524 	}
10525 
10526       dest = (stub_entry->target_value
10527 	      + stub_entry->target_section->output_offset
10528 	      + stub_entry->target_section->output_section->vma);
10529       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10530 	dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10531 
10532       bfd_put_64 (htab->brlt->owner, dest,
10533 		  htab->brlt->contents + br_entry->offset);
10534 
10535       if (br_entry->iter == htab->stub_iteration)
10536 	{
10537 	  br_entry->iter = 0;
10538 
10539 	  if (htab->relbrlt != NULL)
10540 	    {
10541 	      /* Create a reloc for the branch lookup table entry.  */
10542 	      Elf_Internal_Rela rela;
10543 	      bfd_byte *rl;
10544 
10545 	      rela.r_offset = (br_entry->offset
10546 			       + htab->brlt->output_offset
10547 			       + htab->brlt->output_section->vma);
10548 	      rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10549 	      rela.r_addend = dest;
10550 
10551 	      rl = htab->relbrlt->contents;
10552 	      rl += (htab->relbrlt->reloc_count++
10553 		     * sizeof (Elf64_External_Rela));
10554 	      bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10555 	    }
10556 	  else if (info->emitrelocations)
10557 	    {
10558 	      r = get_relocs (htab->brlt, 1);
10559 	      if (r == NULL)
10560 		return FALSE;
10561 	      /* brlt, being SEC_LINKER_CREATED does not go through the
10562 		 normal reloc processing.  Symbols and offsets are not
10563 		 translated from input file to output file form, so
10564 		 set up the offset per the output file.  */
10565 	      r->r_offset = (br_entry->offset
10566 			     + htab->brlt->output_offset
10567 			     + htab->brlt->output_section->vma);
10568 	      r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10569 	      r->r_addend = dest;
10570 	    }
10571 	}
10572 
10573       dest = (br_entry->offset
10574 	      + htab->brlt->output_offset
10575 	      + htab->brlt->output_section->vma);
10576 
10577       off = (dest
10578 	     - elf_gp (htab->brlt->output_section->owner)
10579 	     - htab->stub_group[stub_entry->id_sec->id].toc_off);
10580 
10581       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10582 	{
10583 	  info->callbacks->einfo
10584 	    (_("%P: linkage table error against `%T'\n"),
10585 	     stub_entry->root.string);
10586 	  bfd_set_error (bfd_error_bad_value);
10587 	  htab->stub_error = TRUE;
10588 	  return FALSE;
10589 	}
10590 
10591       if (info->emitrelocations)
10592 	{
10593 	  r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10594 	  if (r == NULL)
10595 	    return FALSE;
10596 	  r[0].r_offset = loc - stub_entry->stub_sec->contents;
10597 	  if (bfd_big_endian (info->output_bfd))
10598 	    r[0].r_offset += 2;
10599 	  if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10600 	    r[0].r_offset += 4;
10601 	  r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10602 	  r[0].r_addend = dest;
10603 	  if (PPC_HA (off) != 0)
10604 	    {
10605 	      r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10606 	      r[1].r_offset = r[0].r_offset + 4;
10607 	      r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10608 	      r[1].r_addend = r[0].r_addend;
10609 	    }
10610 	}
10611 
10612       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10613 	{
10614 	  if (PPC_HA (off) != 0)
10615 	    {
10616 	      size = 16;
10617 	      bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10618 	      loc += 4;
10619 	      bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10620 	    }
10621 	  else
10622 	    {
10623 	      size = 12;
10624 	      bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10625 	    }
10626 	}
10627       else
10628 	{
10629 	  bfd_vma r2off = get_r2off (info, stub_entry);
10630 
10631 	  if (r2off == 0 && htab->opd_abi)
10632 	    {
10633 	      htab->stub_error = TRUE;
10634 	      return FALSE;
10635 	    }
10636 
10637 	  bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10638 	  loc += 4;
10639 	  size = 16;
10640 	  if (PPC_HA (off) != 0)
10641 	    {
10642 	      size += 4;
10643 	      bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10644 	      loc += 4;
10645 	      bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10646 	    }
10647 	  else
10648 	    bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10649 
10650 	  if (PPC_HA (r2off) != 0)
10651 	    {
10652 	      size += 4;
10653 	      loc += 4;
10654 	      bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10655 	    }
10656 	  if (PPC_LO (r2off) != 0)
10657 	    {
10658 	      size += 4;
10659 	      loc += 4;
10660 	      bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10661 	    }
10662 	}
10663       loc += 4;
10664       bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10665       loc += 4;
10666       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10667       break;
10668 
10669     case ppc_stub_plt_call:
10670     case ppc_stub_plt_call_r2save:
10671       if (stub_entry->h != NULL
10672 	  && stub_entry->h->is_func_descriptor
10673 	  && stub_entry->h->oh != NULL)
10674 	{
10675 	  struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10676 
10677 	  /* If the old-ABI "dot-symbol" is undefined make it weak so
10678 	     we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10679 	     FIXME: We used to define the symbol on one of the call
10680 	     stubs instead, which is why we test symbol section id
10681 	     against htab->top_id in various places.  Likely all
10682 	     these checks could now disappear.  */
10683 	  if (fh->elf.root.type == bfd_link_hash_undefined)
10684 	    fh->elf.root.type = bfd_link_hash_undefweak;
10685 	  /* Stop undo_symbol_twiddle changing it back to undefined.  */
10686 	  fh->was_undefined = 0;
10687 	}
10688 
10689       /* Now build the stub.  */
10690       dest = stub_entry->plt_ent->plt.offset & ~1;
10691       if (dest >= (bfd_vma) -2)
10692 	abort ();
10693 
10694       plt = htab->elf.splt;
10695       if (!htab->elf.dynamic_sections_created
10696 	  || stub_entry->h == NULL
10697 	  || stub_entry->h->elf.dynindx == -1)
10698 	plt = htab->elf.iplt;
10699 
10700       dest += plt->output_offset + plt->output_section->vma;
10701 
10702       if (stub_entry->h == NULL
10703 	  && (stub_entry->plt_ent->plt.offset & 1) == 0)
10704 	{
10705 	  Elf_Internal_Rela rela;
10706 	  bfd_byte *rl;
10707 
10708 	  rela.r_offset = dest;
10709 	  if (htab->opd_abi)
10710 	    rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10711 	  else
10712 	    rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10713 	  rela.r_addend = (stub_entry->target_value
10714 			   + stub_entry->target_section->output_offset
10715 			   + stub_entry->target_section->output_section->vma);
10716 
10717 	  rl = (htab->elf.irelplt->contents
10718 		+ (htab->elf.irelplt->reloc_count++
10719 		   * sizeof (Elf64_External_Rela)));
10720 	  bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10721 	  stub_entry->plt_ent->plt.offset |= 1;
10722 	}
10723 
10724       off = (dest
10725 	     - elf_gp (plt->output_section->owner)
10726 	     - htab->stub_group[stub_entry->id_sec->id].toc_off);
10727 
10728       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10729 	{
10730 	  info->callbacks->einfo
10731 	    (_("%P: linkage table error against `%T'\n"),
10732 	     stub_entry->h != NULL
10733 	     ? stub_entry->h->elf.root.root.string
10734 	     : "<local sym>");
10735 	  bfd_set_error (bfd_error_bad_value);
10736 	  htab->stub_error = TRUE;
10737 	  return FALSE;
10738 	}
10739 
10740       if (htab->plt_stub_align != 0)
10741 	{
10742 	  unsigned pad = plt_stub_pad (htab, stub_entry, off);
10743 
10744 	  stub_entry->stub_sec->size += pad;
10745 	  stub_entry->stub_offset = stub_entry->stub_sec->size;
10746 	  loc += pad;
10747 	}
10748 
10749       r = NULL;
10750       if (info->emitrelocations)
10751 	{
10752 	  r = get_relocs (stub_entry->stub_sec,
10753 			  (2
10754 			   + (PPC_HA (off) != 0)
10755 			   + (htab->plt_static_chain
10756 			      && PPC_HA (off + 16) == PPC_HA (off))));
10757 	  if (r == NULL)
10758 	    return FALSE;
10759 	  r[0].r_offset = loc - stub_entry->stub_sec->contents;
10760 	  if (bfd_big_endian (info->output_bfd))
10761 	    r[0].r_offset += 2;
10762 	  r[0].r_addend = dest;
10763 	}
10764       if (stub_entry->h != NULL
10765 	  && (stub_entry->h == htab->tls_get_addr_fd
10766 	      || stub_entry->h == htab->tls_get_addr)
10767 	  && !htab->no_tls_get_addr_opt)
10768 	p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10769       else
10770 	p = build_plt_stub (htab, stub_entry, loc, off, r);
10771       size = p - loc;
10772       break;
10773 
10774     default:
10775       BFD_FAIL ();
10776       return FALSE;
10777     }
10778 
10779   stub_entry->stub_sec->size += size;
10780 
10781   if (htab->emit_stub_syms)
10782     {
10783       struct elf_link_hash_entry *h;
10784       size_t len1, len2;
10785       char *name;
10786       const char *const stub_str[] = { "long_branch",
10787 				       "long_branch_r2off",
10788 				       "plt_branch",
10789 				       "plt_branch_r2off",
10790 				       "plt_call",
10791 				       "plt_call" };
10792 
10793       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10794       len2 = strlen (stub_entry->root.string);
10795       name = bfd_malloc (len1 + len2 + 2);
10796       if (name == NULL)
10797 	return FALSE;
10798       memcpy (name, stub_entry->root.string, 9);
10799       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10800       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10801       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10802       if (h == NULL)
10803 	return FALSE;
10804       if (h->root.type == bfd_link_hash_new)
10805 	{
10806 	  h->root.type = bfd_link_hash_defined;
10807 	  h->root.u.def.section = stub_entry->stub_sec;
10808 	  h->root.u.def.value = stub_entry->stub_offset;
10809 	  h->ref_regular = 1;
10810 	  h->def_regular = 1;
10811 	  h->ref_regular_nonweak = 1;
10812 	  h->forced_local = 1;
10813 	  h->non_elf = 0;
10814 	}
10815     }
10816 
10817   return TRUE;
10818 }
10819 
10820 /* As above, but don't actually build the stub.  Just bump offset so
10821    we know stub section sizes, and select plt_branch stubs where
10822    long_branch stubs won't do.  */
10823 
10824 static bfd_boolean
10825 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10826 {
10827   struct ppc_stub_hash_entry *stub_entry;
10828   struct bfd_link_info *info;
10829   struct ppc_link_hash_table *htab;
10830   bfd_vma off;
10831   int size;
10832 
10833   /* Massage our args to the form they really have.  */
10834   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10835   info = in_arg;
10836 
10837   htab = ppc_hash_table (info);
10838   if (htab == NULL)
10839     return FALSE;
10840 
10841   if (stub_entry->stub_type == ppc_stub_plt_call
10842       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10843     {
10844       asection *plt;
10845       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10846       if (off >= (bfd_vma) -2)
10847 	abort ();
10848       plt = htab->elf.splt;
10849       if (!htab->elf.dynamic_sections_created
10850 	  || stub_entry->h == NULL
10851 	  || stub_entry->h->elf.dynindx == -1)
10852 	plt = htab->elf.iplt;
10853       off += (plt->output_offset
10854 	      + plt->output_section->vma
10855 	      - elf_gp (plt->output_section->owner)
10856 	      - htab->stub_group[stub_entry->id_sec->id].toc_off);
10857 
10858       size = plt_stub_size (htab, stub_entry, off);
10859       if (htab->plt_stub_align)
10860 	size += plt_stub_pad (htab, stub_entry, off);
10861       if (info->emitrelocations)
10862 	{
10863 	  stub_entry->stub_sec->reloc_count
10864 	    += ((PPC_HA (off) != 0)
10865 		+ (htab->opd_abi
10866 		   ? 2 + (htab->plt_static_chain
10867 			  && PPC_HA (off + 16) == PPC_HA (off))
10868 		   : 1));
10869 	  stub_entry->stub_sec->flags |= SEC_RELOC;
10870 	}
10871     }
10872   else
10873     {
10874       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10875 	 variants.  */
10876       bfd_vma r2off = 0;
10877       bfd_vma local_off = 0;
10878 
10879       off = (stub_entry->target_value
10880 	     + stub_entry->target_section->output_offset
10881 	     + stub_entry->target_section->output_section->vma);
10882       off -= (stub_entry->stub_sec->size
10883 	      + stub_entry->stub_sec->output_offset
10884 	      + stub_entry->stub_sec->output_section->vma);
10885 
10886       /* Reset the stub type from the plt variant in case we now
10887 	 can reach with a shorter stub.  */
10888       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10889 	stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10890 
10891       size = 4;
10892       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10893 	{
10894 	  r2off = get_r2off (info, stub_entry);
10895 	  if (r2off == 0 && htab->opd_abi)
10896 	    {
10897 	      htab->stub_error = TRUE;
10898 	      return FALSE;
10899 	    }
10900 	  size = 12;
10901 	  if (PPC_HA (r2off) != 0)
10902 	    size = 16;
10903 	  off -= size - 4;
10904 	}
10905 
10906       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10907 
10908       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10909 	 Do the same for -R objects without function descriptors.  */
10910       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10911 	  || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10912 	      && r2off == 0))
10913 	{
10914 	  struct ppc_branch_hash_entry *br_entry;
10915 
10916 	  br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10917 					     stub_entry->root.string + 9,
10918 					     TRUE, FALSE);
10919 	  if (br_entry == NULL)
10920 	    {
10921 	      info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10922 				      stub_entry->root.string);
10923 	      htab->stub_error = TRUE;
10924 	      return FALSE;
10925 	    }
10926 
10927 	  if (br_entry->iter != htab->stub_iteration)
10928 	    {
10929 	      br_entry->iter = htab->stub_iteration;
10930 	      br_entry->offset = htab->brlt->size;
10931 	      htab->brlt->size += 8;
10932 
10933 	      if (htab->relbrlt != NULL)
10934 		htab->relbrlt->size += sizeof (Elf64_External_Rela);
10935 	      else if (info->emitrelocations)
10936 		{
10937 		  htab->brlt->reloc_count += 1;
10938 		  htab->brlt->flags |= SEC_RELOC;
10939 		}
10940 	    }
10941 
10942 	  stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10943 	  off = (br_entry->offset
10944 		 + htab->brlt->output_offset
10945 		 + htab->brlt->output_section->vma
10946 		 - elf_gp (htab->brlt->output_section->owner)
10947 		 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10948 
10949 	  if (info->emitrelocations)
10950 	    {
10951 	      stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10952 	      stub_entry->stub_sec->flags |= SEC_RELOC;
10953 	    }
10954 
10955 	  if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10956 	    {
10957 	      size = 12;
10958 	      if (PPC_HA (off) != 0)
10959 		size = 16;
10960 	    }
10961 	  else
10962 	    {
10963 	      size = 16;
10964 	      if (PPC_HA (off) != 0)
10965 		size += 4;
10966 
10967 	      if (PPC_HA (r2off) != 0)
10968 		size += 4;
10969 	      if (PPC_LO (r2off) != 0)
10970 		size += 4;
10971 	    }
10972 	}
10973       else if (info->emitrelocations)
10974 	{
10975 	  stub_entry->stub_sec->reloc_count += 1;
10976 	  stub_entry->stub_sec->flags |= SEC_RELOC;
10977 	}
10978     }
10979 
10980   stub_entry->stub_sec->size += size;
10981   return TRUE;
10982 }
10983 
10984 /* Set up various things so that we can make a list of input sections
10985    for each output section included in the link.  Returns -1 on error,
10986    0 when no stubs will be needed, and 1 on success.  */
10987 
10988 int
10989 ppc64_elf_setup_section_lists
10990   (struct bfd_link_info *info,
10991    asection *(*add_stub_section) (const char *, asection *),
10992    void (*layout_sections_again) (void))
10993 {
10994   bfd *input_bfd;
10995   int top_id, top_index, id;
10996   asection *section;
10997   asection **input_list;
10998   bfd_size_type amt;
10999   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11000 
11001   if (htab == NULL)
11002     return -1;
11003   /* Stash our params away.  */
11004   htab->add_stub_section = add_stub_section;
11005   htab->layout_sections_again = layout_sections_again;
11006 
11007   /* Find the top input section id.  */
11008   for (input_bfd = info->input_bfds, top_id = 3;
11009        input_bfd != NULL;
11010        input_bfd = input_bfd->link_next)
11011     {
11012       for (section = input_bfd->sections;
11013 	   section != NULL;
11014 	   section = section->next)
11015 	{
11016 	  if (top_id < section->id)
11017 	    top_id = section->id;
11018 	}
11019     }
11020 
11021   htab->top_id = top_id;
11022   amt = sizeof (struct map_stub) * (top_id + 1);
11023   htab->stub_group = bfd_zmalloc (amt);
11024   if (htab->stub_group == NULL)
11025     return -1;
11026 
11027   /* Set toc_off for com, und, abs and ind sections.  */
11028   for (id = 0; id < 3; id++)
11029     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11030 
11031   /* We can't use output_bfd->section_count here to find the top output
11032      section index as some sections may have been removed, and
11033      strip_excluded_output_sections doesn't renumber the indices.  */
11034   for (section = info->output_bfd->sections, top_index = 0;
11035        section != NULL;
11036        section = section->next)
11037     {
11038       if (top_index < section->index)
11039 	top_index = section->index;
11040     }
11041 
11042   htab->top_index = top_index;
11043   amt = sizeof (asection *) * (top_index + 1);
11044   input_list = bfd_zmalloc (amt);
11045   htab->input_list = input_list;
11046   if (input_list == NULL)
11047     return -1;
11048 
11049   return 1;
11050 }
11051 
11052 /* Set up for first pass at multitoc partitioning.  */
11053 
11054 void
11055 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11056 {
11057   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11058 
11059   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11060   htab->toc_bfd = NULL;
11061   htab->toc_first_sec = NULL;
11062 }
11063 
11064 /* The linker repeatedly calls this function for each TOC input section
11065    and linker generated GOT section.  Group input bfds such that the toc
11066    within a group is less than 64k in size.  */
11067 
11068 bfd_boolean
11069 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11070 {
11071   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11072   bfd_vma addr, off, limit;
11073 
11074   if (htab == NULL)
11075     return FALSE;
11076 
11077   if (!htab->second_toc_pass)
11078     {
11079       /* Keep track of the first .toc or .got section for this input bfd.  */
11080       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11081 
11082       if (new_bfd)
11083 	{
11084 	  htab->toc_bfd = isec->owner;
11085 	  htab->toc_first_sec = isec;
11086 	}
11087 
11088       addr = isec->output_offset + isec->output_section->vma;
11089       off = addr - htab->toc_curr;
11090       limit = 0x80008000;
11091       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11092 	limit = 0x10000;
11093       if (off + isec->size > limit)
11094 	{
11095 	  addr = (htab->toc_first_sec->output_offset
11096 		  + htab->toc_first_sec->output_section->vma);
11097 	  htab->toc_curr = addr;
11098 	}
11099 
11100       /* toc_curr is the base address of this toc group.  Set elf_gp
11101 	 for the input section to be the offset relative to the
11102 	 output toc base plus 0x8000.  Making the input elf_gp an
11103 	 offset allows us to move the toc as a whole without
11104 	 recalculating input elf_gp.  */
11105       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11106       off += TOC_BASE_OFF;
11107 
11108       /* Die if someone uses a linker script that doesn't keep input
11109 	 file .toc and .got together.  */
11110       if (new_bfd
11111 	  && elf_gp (isec->owner) != 0
11112 	  && elf_gp (isec->owner) != off)
11113 	return FALSE;
11114 
11115       elf_gp (isec->owner) = off;
11116       return TRUE;
11117     }
11118 
11119   /* During the second pass toc_first_sec points to the start of
11120      a toc group, and toc_curr is used to track the old elf_gp.
11121      We use toc_bfd to ensure we only look at each bfd once.  */
11122   if (htab->toc_bfd == isec->owner)
11123     return TRUE;
11124   htab->toc_bfd = isec->owner;
11125 
11126   if (htab->toc_first_sec == NULL
11127       || htab->toc_curr != elf_gp (isec->owner))
11128     {
11129       htab->toc_curr = elf_gp (isec->owner);
11130       htab->toc_first_sec = isec;
11131     }
11132   addr = (htab->toc_first_sec->output_offset
11133 	  + htab->toc_first_sec->output_section->vma);
11134   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11135   elf_gp (isec->owner) = off;
11136 
11137   return TRUE;
11138 }
11139 
11140 /* Called via elf_link_hash_traverse to merge GOT entries for global
11141    symbol H.  */
11142 
11143 static bfd_boolean
11144 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11145 {
11146   if (h->root.type == bfd_link_hash_indirect)
11147     return TRUE;
11148 
11149   merge_got_entries (&h->got.glist);
11150 
11151   return TRUE;
11152 }
11153 
11154 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11155    symbol H.  */
11156 
11157 static bfd_boolean
11158 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11159 {
11160   struct got_entry *gent;
11161 
11162   if (h->root.type == bfd_link_hash_indirect)
11163     return TRUE;
11164 
11165   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11166     if (!gent->is_indirect)
11167       allocate_got (h, (struct bfd_link_info *) inf, gent);
11168   return TRUE;
11169 }
11170 
11171 /* Called on the first multitoc pass after the last call to
11172    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11173    entries.  */
11174 
11175 bfd_boolean
11176 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11177 {
11178   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11179   struct bfd *ibfd, *ibfd2;
11180   bfd_boolean done_something;
11181 
11182   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11183 
11184   if (!htab->do_multi_toc)
11185     return FALSE;
11186 
11187   /* Merge global sym got entries within a toc group.  */
11188   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11189 
11190   /* And tlsld_got.  */
11191   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11192     {
11193       struct got_entry *ent, *ent2;
11194 
11195       if (!is_ppc64_elf (ibfd))
11196 	continue;
11197 
11198       ent = ppc64_tlsld_got (ibfd);
11199       if (!ent->is_indirect
11200 	  && ent->got.offset != (bfd_vma) -1)
11201 	{
11202 	  for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11203 	    {
11204 	      if (!is_ppc64_elf (ibfd2))
11205 		continue;
11206 
11207 	      ent2 = ppc64_tlsld_got (ibfd2);
11208 	      if (!ent2->is_indirect
11209 		  && ent2->got.offset != (bfd_vma) -1
11210 		  && elf_gp (ibfd2) == elf_gp (ibfd))
11211 		{
11212 		  ent2->is_indirect = TRUE;
11213 		  ent2->got.ent = ent;
11214 		}
11215 	    }
11216 	}
11217     }
11218 
11219   /* Zap sizes of got sections.  */
11220   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11221   htab->elf.irelplt->size -= htab->got_reli_size;
11222   htab->got_reli_size = 0;
11223 
11224   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11225     {
11226       asection *got, *relgot;
11227 
11228       if (!is_ppc64_elf (ibfd))
11229 	continue;
11230 
11231       got = ppc64_elf_tdata (ibfd)->got;
11232       if (got != NULL)
11233 	{
11234 	  got->rawsize = got->size;
11235 	  got->size = 0;
11236 	  relgot = ppc64_elf_tdata (ibfd)->relgot;
11237 	  relgot->rawsize = relgot->size;
11238 	  relgot->size = 0;
11239 	}
11240     }
11241 
11242   /* Now reallocate the got, local syms first.  We don't need to
11243      allocate section contents again since we never increase size.  */
11244   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11245     {
11246       struct got_entry **lgot_ents;
11247       struct got_entry **end_lgot_ents;
11248       struct plt_entry **local_plt;
11249       struct plt_entry **end_local_plt;
11250       unsigned char *lgot_masks;
11251       bfd_size_type locsymcount;
11252       Elf_Internal_Shdr *symtab_hdr;
11253       asection *s;
11254 
11255       if (!is_ppc64_elf (ibfd))
11256 	continue;
11257 
11258       lgot_ents = elf_local_got_ents (ibfd);
11259       if (!lgot_ents)
11260 	continue;
11261 
11262       symtab_hdr = &elf_symtab_hdr (ibfd);
11263       locsymcount = symtab_hdr->sh_info;
11264       end_lgot_ents = lgot_ents + locsymcount;
11265       local_plt = (struct plt_entry **) end_lgot_ents;
11266       end_local_plt = local_plt + locsymcount;
11267       lgot_masks = (unsigned char *) end_local_plt;
11268       s = ppc64_elf_tdata (ibfd)->got;
11269       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11270 	{
11271 	  struct got_entry *ent;
11272 
11273 	  for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11274 	    {
11275 	      unsigned int ent_size = 8;
11276 	      unsigned int rel_size = sizeof (Elf64_External_Rela);
11277 
11278 	      ent->got.offset = s->size;
11279 	      if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11280 		{
11281 		  ent_size *= 2;
11282 		  rel_size *= 2;
11283 		}
11284 	      s->size += ent_size;
11285 	      if ((*lgot_masks & PLT_IFUNC) != 0)
11286 		{
11287 		  htab->elf.irelplt->size += rel_size;
11288 		  htab->got_reli_size += rel_size;
11289 		}
11290 	      else if (info->shared)
11291 		{
11292 		  asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11293 		  srel->size += rel_size;
11294 		}
11295 	    }
11296 	}
11297     }
11298 
11299   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11300 
11301   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11302     {
11303       struct got_entry *ent;
11304 
11305       if (!is_ppc64_elf (ibfd))
11306 	continue;
11307 
11308       ent = ppc64_tlsld_got (ibfd);
11309       if (!ent->is_indirect
11310 	  && ent->got.offset != (bfd_vma) -1)
11311 	{
11312 	  asection *s = ppc64_elf_tdata (ibfd)->got;
11313 	  ent->got.offset = s->size;
11314 	  s->size += 16;
11315 	  if (info->shared)
11316 	    {
11317 	      asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11318 	      srel->size += sizeof (Elf64_External_Rela);
11319 	    }
11320 	}
11321     }
11322 
11323   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11324   if (!done_something)
11325     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11326       {
11327 	asection *got;
11328 
11329 	if (!is_ppc64_elf (ibfd))
11330 	  continue;
11331 
11332 	got = ppc64_elf_tdata (ibfd)->got;
11333 	if (got != NULL)
11334 	  {
11335 	    done_something = got->rawsize != got->size;
11336 	    if (done_something)
11337 	      break;
11338 	  }
11339       }
11340 
11341   if (done_something)
11342     (*htab->layout_sections_again) ();
11343 
11344   /* Set up for second pass over toc sections to recalculate elf_gp
11345      on input sections.  */
11346   htab->toc_bfd = NULL;
11347   htab->toc_first_sec = NULL;
11348   htab->second_toc_pass = TRUE;
11349   return done_something;
11350 }
11351 
11352 /* Called after second pass of multitoc partitioning.  */
11353 
11354 void
11355 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11356 {
11357   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11358 
11359   /* After the second pass, toc_curr tracks the TOC offset used
11360      for code sections below in ppc64_elf_next_input_section.  */
11361   htab->toc_curr = TOC_BASE_OFF;
11362 }
11363 
11364 /* No toc references were found in ISEC.  If the code in ISEC makes no
11365    calls, then there's no need to use toc adjusting stubs when branching
11366    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11367    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11368    needed, and 2 if a cyclical call-graph was found but no other reason
11369    for a stub was detected.  If called from the top level, a return of
11370    2 means the same as a return of 0.  */
11371 
11372 static int
11373 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11374 {
11375   int ret;
11376 
11377   /* Mark this section as checked.  */
11378   isec->call_check_done = 1;
11379 
11380   /* We know none of our code bearing sections will need toc stubs.  */
11381   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11382     return 0;
11383 
11384   if (isec->size == 0)
11385     return 0;
11386 
11387   if (isec->output_section == NULL)
11388     return 0;
11389 
11390   ret = 0;
11391   if (isec->reloc_count != 0)
11392     {
11393       Elf_Internal_Rela *relstart, *rel;
11394       Elf_Internal_Sym *local_syms;
11395       struct ppc_link_hash_table *htab;
11396 
11397       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11398 					    info->keep_memory);
11399       if (relstart == NULL)
11400 	return -1;
11401 
11402       /* Look for branches to outside of this section.  */
11403       local_syms = NULL;
11404       htab = ppc_hash_table (info);
11405       if (htab == NULL)
11406 	return -1;
11407 
11408       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11409 	{
11410 	  enum elf_ppc64_reloc_type r_type;
11411 	  unsigned long r_symndx;
11412 	  struct elf_link_hash_entry *h;
11413 	  struct ppc_link_hash_entry *eh;
11414 	  Elf_Internal_Sym *sym;
11415 	  asection *sym_sec;
11416 	  struct _opd_sec_data *opd;
11417 	  bfd_vma sym_value;
11418 	  bfd_vma dest;
11419 
11420 	  r_type = ELF64_R_TYPE (rel->r_info);
11421 	  if (r_type != R_PPC64_REL24
11422 	      && r_type != R_PPC64_REL14
11423 	      && r_type != R_PPC64_REL14_BRTAKEN
11424 	      && r_type != R_PPC64_REL14_BRNTAKEN)
11425 	    continue;
11426 
11427 	  r_symndx = ELF64_R_SYM (rel->r_info);
11428 	  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11429 			  isec->owner))
11430 	    {
11431 	      ret = -1;
11432 	      break;
11433 	    }
11434 
11435 	  /* Calls to dynamic lib functions go through a plt call stub
11436 	     that uses r2.  */
11437 	  eh = (struct ppc_link_hash_entry *) h;
11438 	  if (eh != NULL
11439 	      && (eh->elf.plt.plist != NULL
11440 		  || (eh->oh != NULL
11441 		      && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11442 	    {
11443 	      ret = 1;
11444 	      break;
11445 	    }
11446 
11447 	  if (sym_sec == NULL)
11448 	    /* Ignore other undefined symbols.  */
11449 	    continue;
11450 
11451 	  /* Assume branches to other sections not included in the
11452 	     link need stubs too, to cover -R and absolute syms.  */
11453 	  if (sym_sec->output_section == NULL)
11454 	    {
11455 	      ret = 1;
11456 	      break;
11457 	    }
11458 
11459 	  if (h == NULL)
11460 	    sym_value = sym->st_value;
11461 	  else
11462 	    {
11463 	      if (h->root.type != bfd_link_hash_defined
11464 		  && h->root.type != bfd_link_hash_defweak)
11465 		abort ();
11466 	      sym_value = h->root.u.def.value;
11467 	    }
11468 	  sym_value += rel->r_addend;
11469 
11470 	  /* If this branch reloc uses an opd sym, find the code section.  */
11471 	  opd = get_opd_info (sym_sec);
11472 	  if (opd != NULL)
11473 	    {
11474 	      if (h == NULL && opd->adjust != NULL)
11475 		{
11476 		  long adjust;
11477 
11478 		  adjust = opd->adjust[sym->st_value / 8];
11479 		  if (adjust == -1)
11480 		    /* Assume deleted functions won't ever be called.  */
11481 		    continue;
11482 		  sym_value += adjust;
11483 		}
11484 
11485 	      dest = opd_entry_value (sym_sec, sym_value,
11486 				      &sym_sec, NULL, FALSE);
11487 	      if (dest == (bfd_vma) -1)
11488 		continue;
11489 	    }
11490 	  else
11491 	    dest = (sym_value
11492 		    + sym_sec->output_offset
11493 		    + sym_sec->output_section->vma);
11494 
11495 	  /* Ignore branch to self.  */
11496 	  if (sym_sec == isec)
11497 	    continue;
11498 
11499 	  /* If the called function uses the toc, we need a stub.  */
11500 	  if (sym_sec->has_toc_reloc
11501 	      || sym_sec->makes_toc_func_call)
11502 	    {
11503 	      ret = 1;
11504 	      break;
11505 	    }
11506 
11507 	  /* Assume any branch that needs a long branch stub might in fact
11508 	     need a plt_branch stub.  A plt_branch stub uses r2.  */
11509 	  else if (dest - (isec->output_offset
11510 			   + isec->output_section->vma
11511 			   + rel->r_offset) + (1 << 25)
11512 		   >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11513 							     ? h->other
11514 							     : sym->st_other))
11515 	    {
11516 	      ret = 1;
11517 	      break;
11518 	    }
11519 
11520 	  /* If calling back to a section in the process of being
11521 	     tested, we can't say for sure that no toc adjusting stubs
11522 	     are needed, so don't return zero.  */
11523 	  else if (sym_sec->call_check_in_progress)
11524 	    ret = 2;
11525 
11526 	  /* Branches to another section that itself doesn't have any TOC
11527 	     references are OK.  Recursively call ourselves to check.  */
11528 	  else if (!sym_sec->call_check_done)
11529 	    {
11530 	      int recur;
11531 
11532 	      /* Mark current section as indeterminate, so that other
11533 		 sections that call back to current won't be marked as
11534 		 known.  */
11535 	      isec->call_check_in_progress = 1;
11536 	      recur = toc_adjusting_stub_needed (info, sym_sec);
11537 	      isec->call_check_in_progress = 0;
11538 
11539 	      if (recur != 0)
11540 		{
11541 		  ret = recur;
11542 		  if (recur != 2)
11543 		    break;
11544 		}
11545 	    }
11546 	}
11547 
11548       if (local_syms != NULL
11549 	  && (elf_symtab_hdr (isec->owner).contents
11550 	      != (unsigned char *) local_syms))
11551 	free (local_syms);
11552       if (elf_section_data (isec)->relocs != relstart)
11553 	free (relstart);
11554     }
11555 
11556   if ((ret & 1) == 0
11557       && isec->map_head.s != NULL
11558       && (strcmp (isec->output_section->name, ".init") == 0
11559 	  || strcmp (isec->output_section->name, ".fini") == 0))
11560     {
11561       if (isec->map_head.s->has_toc_reloc
11562 	  || isec->map_head.s->makes_toc_func_call)
11563 	ret = 1;
11564       else if (!isec->map_head.s->call_check_done)
11565 	{
11566 	  int recur;
11567 	  isec->call_check_in_progress = 1;
11568 	  recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11569 	  isec->call_check_in_progress = 0;
11570 	  if (recur != 0)
11571 	    ret = recur;
11572 	}
11573     }
11574 
11575   if (ret == 1)
11576     isec->makes_toc_func_call = 1;
11577 
11578   return ret;
11579 }
11580 
11581 /* The linker repeatedly calls this function for each input section,
11582    in the order that input sections are linked into output sections.
11583    Build lists of input sections to determine groupings between which
11584    we may insert linker stubs.  */
11585 
11586 bfd_boolean
11587 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11588 {
11589   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11590 
11591   if (htab == NULL)
11592     return FALSE;
11593 
11594   if ((isec->output_section->flags & SEC_CODE) != 0
11595       && isec->output_section->index <= htab->top_index)
11596     {
11597       asection **list = htab->input_list + isec->output_section->index;
11598       /* Steal the link_sec pointer for our list.  */
11599 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11600       /* This happens to make the list in reverse order,
11601 	 which is what we want.  */
11602       PREV_SEC (isec) = *list;
11603       *list = isec;
11604     }
11605 
11606   if (htab->multi_toc_needed)
11607     {
11608       /* Analyse sections that aren't already flagged as needing a
11609 	 valid toc pointer.  Exclude .fixup for the linux kernel.
11610 	 .fixup contains branches, but only back to the function that
11611 	 hit an exception.  */
11612       if (!(isec->has_toc_reloc
11613 	    || (isec->flags & SEC_CODE) == 0
11614 	    || strcmp (isec->name, ".fixup") == 0
11615 	    || isec->call_check_done))
11616 	{
11617 	  if (toc_adjusting_stub_needed (info, isec) < 0)
11618 	    return FALSE;
11619 	}
11620       /* Make all sections use the TOC assigned for this object file.
11621 	 This will be wrong for pasted sections;  We fix that in
11622 	 check_pasted_section().  */
11623       if (elf_gp (isec->owner) != 0)
11624 	htab->toc_curr = elf_gp (isec->owner);
11625     }
11626 
11627   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11628   return TRUE;
11629 }
11630 
11631 /* Check that all .init and .fini sections use the same toc, if they
11632    have toc relocs.  */
11633 
11634 static bfd_boolean
11635 check_pasted_section (struct bfd_link_info *info, const char *name)
11636 {
11637   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11638 
11639   if (o != NULL)
11640     {
11641       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11642       bfd_vma toc_off = 0;
11643       asection *i;
11644 
11645       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11646 	if (i->has_toc_reloc)
11647 	  {
11648 	    if (toc_off == 0)
11649 	      toc_off = htab->stub_group[i->id].toc_off;
11650 	    else if (toc_off != htab->stub_group[i->id].toc_off)
11651 	      return FALSE;
11652 	  }
11653 
11654       if (toc_off == 0)
11655 	for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11656 	  if (i->makes_toc_func_call)
11657 	    {
11658 	      toc_off = htab->stub_group[i->id].toc_off;
11659 	      break;
11660 	    }
11661 
11662       /* Make sure the whole pasted function uses the same toc offset.  */
11663       if (toc_off != 0)
11664 	for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11665 	  htab->stub_group[i->id].toc_off = toc_off;
11666     }
11667   return TRUE;
11668 }
11669 
11670 bfd_boolean
11671 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11672 {
11673   return (check_pasted_section (info, ".init")
11674 	  & check_pasted_section (info, ".fini"));
11675 }
11676 
11677 /* See whether we can group stub sections together.  Grouping stub
11678    sections may result in fewer stubs.  More importantly, we need to
11679    put all .init* and .fini* stubs at the beginning of the .init or
11680    .fini output sections respectively, because glibc splits the
11681    _init and _fini functions into multiple parts.  Putting a stub in
11682    the middle of a function is not a good idea.  */
11683 
11684 static void
11685 group_sections (struct ppc_link_hash_table *htab,
11686 		bfd_size_type stub_group_size,
11687 		bfd_boolean stubs_always_before_branch)
11688 {
11689   asection **list;
11690   bfd_size_type stub14_group_size;
11691   bfd_boolean suppress_size_errors;
11692 
11693   suppress_size_errors = FALSE;
11694   stub14_group_size = stub_group_size;
11695   if (stub_group_size == 1)
11696     {
11697       /* Default values.  */
11698       if (stubs_always_before_branch)
11699 	{
11700 	  stub_group_size = 0x1e00000;
11701 	  stub14_group_size = 0x7800;
11702 	}
11703       else
11704 	{
11705 	  stub_group_size = 0x1c00000;
11706 	  stub14_group_size = 0x7000;
11707 	}
11708       suppress_size_errors = TRUE;
11709     }
11710 
11711   list = htab->input_list + htab->top_index;
11712   do
11713     {
11714       asection *tail = *list;
11715       while (tail != NULL)
11716 	{
11717 	  asection *curr;
11718 	  asection *prev;
11719 	  bfd_size_type total;
11720 	  bfd_boolean big_sec;
11721 	  bfd_vma curr_toc;
11722 
11723 	  curr = tail;
11724 	  total = tail->size;
11725 	  big_sec = total > (ppc64_elf_section_data (tail) != NULL
11726 			     && ppc64_elf_section_data (tail)->has_14bit_branch
11727 			     ? stub14_group_size : stub_group_size);
11728 	  if (big_sec && !suppress_size_errors)
11729 	    (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11730 				     tail->owner, tail);
11731 	  curr_toc = htab->stub_group[tail->id].toc_off;
11732 
11733 	  while ((prev = PREV_SEC (curr)) != NULL
11734 		 && ((total += curr->output_offset - prev->output_offset)
11735 		     < (ppc64_elf_section_data (prev) != NULL
11736 			&& ppc64_elf_section_data (prev)->has_14bit_branch
11737 			? stub14_group_size : stub_group_size))
11738 		 && htab->stub_group[prev->id].toc_off == curr_toc)
11739 	    curr = prev;
11740 
11741 	  /* OK, the size from the start of CURR to the end is less
11742 	     than stub_group_size and thus can be handled by one stub
11743 	     section.  (or the tail section is itself larger than
11744 	     stub_group_size, in which case we may be toast.)  We
11745 	     should really be keeping track of the total size of stubs
11746 	     added here, as stubs contribute to the final output
11747 	     section size.  That's a little tricky, and this way will
11748 	     only break if stubs added make the total size more than
11749 	     2^25, ie. for the default stub_group_size, if stubs total
11750 	     more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11751 	  do
11752 	    {
11753 	      prev = PREV_SEC (tail);
11754 	      /* Set up this stub group.  */
11755 	      htab->stub_group[tail->id].link_sec = curr;
11756 	    }
11757 	  while (tail != curr && (tail = prev) != NULL);
11758 
11759 	  /* But wait, there's more!  Input sections up to stub_group_size
11760 	     bytes before the stub section can be handled by it too.
11761 	     Don't do this if we have a really large section after the
11762 	     stubs, as adding more stubs increases the chance that
11763 	     branches may not reach into the stub section.  */
11764 	  if (!stubs_always_before_branch && !big_sec)
11765 	    {
11766 	      total = 0;
11767 	      while (prev != NULL
11768 		     && ((total += tail->output_offset - prev->output_offset)
11769 			 < (ppc64_elf_section_data (prev) != NULL
11770 			    && ppc64_elf_section_data (prev)->has_14bit_branch
11771 			    ? stub14_group_size : stub_group_size))
11772 		     && htab->stub_group[prev->id].toc_off == curr_toc)
11773 		{
11774 		  tail = prev;
11775 		  prev = PREV_SEC (tail);
11776 		  htab->stub_group[tail->id].link_sec = curr;
11777 		}
11778 	    }
11779 	  tail = prev;
11780 	}
11781     }
11782   while (list-- != htab->input_list);
11783   free (htab->input_list);
11784 #undef PREV_SEC
11785 }
11786 
11787 static const unsigned char glink_eh_frame_cie[] =
11788 {
11789   0, 0, 0, 16,				/* length.  */
11790   0, 0, 0, 0,				/* id.  */
11791   1,					/* CIE version.  */
11792   'z', 'R', 0,				/* Augmentation string.  */
11793   4,					/* Code alignment.  */
11794   0x78,					/* Data alignment.  */
11795   65,					/* RA reg.  */
11796   1,					/* Augmentation size.  */
11797   DW_EH_PE_pcrel | DW_EH_PE_sdata4,	/* FDE encoding.  */
11798   DW_CFA_def_cfa, 1, 0			/* def_cfa: r1 offset 0.  */
11799 };
11800 
11801 /* Stripping output sections is normally done before dynamic section
11802    symbols have been allocated.  This function is called later, and
11803    handles cases like htab->brlt which is mapped to its own output
11804    section.  */
11805 
11806 static void
11807 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11808 {
11809   if (isec->size == 0
11810       && isec->output_section->size == 0
11811       && !(isec->output_section->flags & SEC_KEEP)
11812       && !bfd_section_removed_from_list (info->output_bfd,
11813 					 isec->output_section)
11814       && elf_section_data (isec->output_section)->dynindx == 0)
11815     {
11816       isec->output_section->flags |= SEC_EXCLUDE;
11817       bfd_section_list_remove (info->output_bfd, isec->output_section);
11818       info->output_bfd->section_count--;
11819     }
11820 }
11821 
11822 /* Determine and set the size of the stub section for a final link.
11823 
11824    The basic idea here is to examine all the relocations looking for
11825    PC-relative calls to a target that is unreachable with a "bl"
11826    instruction.  */
11827 
11828 bfd_boolean
11829 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11830 		      bfd_boolean plt_static_chain, int plt_thread_safe,
11831 		      int plt_stub_align)
11832 {
11833   bfd_size_type stub_group_size;
11834   bfd_boolean stubs_always_before_branch;
11835   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11836 
11837   if (htab == NULL)
11838     return FALSE;
11839 
11840   htab->plt_static_chain = plt_static_chain;
11841   htab->plt_stub_align = plt_stub_align;
11842   if (plt_thread_safe == -1 && !info->executable)
11843     plt_thread_safe = 1;
11844   if (!htab->opd_abi)
11845     plt_thread_safe = 0;
11846   else if (plt_thread_safe == -1)
11847     {
11848       static const char *const thread_starter[] =
11849 	{
11850 	  "pthread_create",
11851 	  /* libstdc++ */
11852 	  "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11853 	  /* librt */
11854 	  "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11855 	  "mq_notify", "create_timer",
11856 	  /* libanl */
11857 	  "getaddrinfo_a",
11858 	  /* libgomp */
11859 	  "GOMP_parallel_start",
11860 	  "GOMP_parallel_loop_static_start",
11861 	  "GOMP_parallel_loop_dynamic_start",
11862 	  "GOMP_parallel_loop_guided_start",
11863 	  "GOMP_parallel_loop_runtime_start",
11864 	  "GOMP_parallel_sections_start",
11865 	};
11866       unsigned i;
11867 
11868       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11869 	{
11870 	  struct elf_link_hash_entry *h;
11871 	  h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11872 				    FALSE, FALSE, TRUE);
11873 	  plt_thread_safe = h != NULL && h->ref_regular;
11874 	  if (plt_thread_safe)
11875 	    break;
11876 	}
11877     }
11878   htab->plt_thread_safe = plt_thread_safe;
11879   stubs_always_before_branch = group_size < 0;
11880   if (group_size < 0)
11881     stub_group_size = -group_size;
11882   else
11883     stub_group_size = group_size;
11884 
11885   group_sections (htab, stub_group_size, stubs_always_before_branch);
11886 
11887   while (1)
11888     {
11889       bfd *input_bfd;
11890       unsigned int bfd_indx;
11891       asection *stub_sec;
11892 
11893       htab->stub_iteration += 1;
11894 
11895       for (input_bfd = info->input_bfds, bfd_indx = 0;
11896 	   input_bfd != NULL;
11897 	   input_bfd = input_bfd->link_next, bfd_indx++)
11898 	{
11899 	  Elf_Internal_Shdr *symtab_hdr;
11900 	  asection *section;
11901 	  Elf_Internal_Sym *local_syms = NULL;
11902 
11903 	  if (!is_ppc64_elf (input_bfd))
11904 	    continue;
11905 
11906 	  /* We'll need the symbol table in a second.  */
11907 	  symtab_hdr = &elf_symtab_hdr (input_bfd);
11908 	  if (symtab_hdr->sh_info == 0)
11909 	    continue;
11910 
11911 	  /* Walk over each section attached to the input bfd.  */
11912 	  for (section = input_bfd->sections;
11913 	       section != NULL;
11914 	       section = section->next)
11915 	    {
11916 	      Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11917 
11918 	      /* If there aren't any relocs, then there's nothing more
11919 		 to do.  */
11920 	      if ((section->flags & SEC_RELOC) == 0
11921 		  || (section->flags & SEC_ALLOC) == 0
11922 		  || (section->flags & SEC_LOAD) == 0
11923 		  || (section->flags & SEC_CODE) == 0
11924 		  || section->reloc_count == 0)
11925 		continue;
11926 
11927 	      /* If this section is a link-once section that will be
11928 		 discarded, then don't create any stubs.  */
11929 	      if (section->output_section == NULL
11930 		  || section->output_section->owner != info->output_bfd)
11931 		continue;
11932 
11933 	      /* Get the relocs.  */
11934 	      internal_relocs
11935 		= _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11936 					     info->keep_memory);
11937 	      if (internal_relocs == NULL)
11938 		goto error_ret_free_local;
11939 
11940 	      /* Now examine each relocation.  */
11941 	      irela = internal_relocs;
11942 	      irelaend = irela + section->reloc_count;
11943 	      for (; irela < irelaend; irela++)
11944 		{
11945 		  enum elf_ppc64_reloc_type r_type;
11946 		  unsigned int r_indx;
11947 		  enum ppc_stub_type stub_type;
11948 		  struct ppc_stub_hash_entry *stub_entry;
11949 		  asection *sym_sec, *code_sec;
11950 		  bfd_vma sym_value, code_value;
11951 		  bfd_vma destination;
11952 		  unsigned long local_off;
11953 		  bfd_boolean ok_dest;
11954 		  struct ppc_link_hash_entry *hash;
11955 		  struct ppc_link_hash_entry *fdh;
11956 		  struct elf_link_hash_entry *h;
11957 		  Elf_Internal_Sym *sym;
11958 		  char *stub_name;
11959 		  const asection *id_sec;
11960 		  struct _opd_sec_data *opd;
11961 		  struct plt_entry *plt_ent;
11962 
11963 		  r_type = ELF64_R_TYPE (irela->r_info);
11964 		  r_indx = ELF64_R_SYM (irela->r_info);
11965 
11966 		  if (r_type >= R_PPC64_max)
11967 		    {
11968 		      bfd_set_error (bfd_error_bad_value);
11969 		      goto error_ret_free_internal;
11970 		    }
11971 
11972 		  /* Only look for stubs on branch instructions.  */
11973 		  if (r_type != R_PPC64_REL24
11974 		      && r_type != R_PPC64_REL14
11975 		      && r_type != R_PPC64_REL14_BRTAKEN
11976 		      && r_type != R_PPC64_REL14_BRNTAKEN)
11977 		    continue;
11978 
11979 		  /* Now determine the call target, its name, value,
11980 		     section.  */
11981 		  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11982 				  r_indx, input_bfd))
11983 		    goto error_ret_free_internal;
11984 		  hash = (struct ppc_link_hash_entry *) h;
11985 
11986 		  ok_dest = FALSE;
11987 		  fdh = NULL;
11988 		  sym_value = 0;
11989 		  if (hash == NULL)
11990 		    {
11991 		      sym_value = sym->st_value;
11992 		      ok_dest = TRUE;
11993 		    }
11994 		  else if (hash->elf.root.type == bfd_link_hash_defined
11995 			   || hash->elf.root.type == bfd_link_hash_defweak)
11996 		    {
11997 		      sym_value = hash->elf.root.u.def.value;
11998 		      if (sym_sec->output_section != NULL)
11999 			ok_dest = TRUE;
12000 		    }
12001 		  else if (hash->elf.root.type == bfd_link_hash_undefweak
12002 			   || hash->elf.root.type == bfd_link_hash_undefined)
12003 		    {
12004 		      /* Recognise an old ABI func code entry sym, and
12005 			 use the func descriptor sym instead if it is
12006 			 defined.  */
12007 		      if (hash->elf.root.root.string[0] == '.'
12008 			  && (fdh = lookup_fdh (hash, htab)) != NULL)
12009 			{
12010 			  if (fdh->elf.root.type == bfd_link_hash_defined
12011 			      || fdh->elf.root.type == bfd_link_hash_defweak)
12012 			    {
12013 			      sym_sec = fdh->elf.root.u.def.section;
12014 			      sym_value = fdh->elf.root.u.def.value;
12015 			      if (sym_sec->output_section != NULL)
12016 				ok_dest = TRUE;
12017 			    }
12018 			  else
12019 			    fdh = NULL;
12020 			}
12021 		    }
12022 		  else
12023 		    {
12024 		      bfd_set_error (bfd_error_bad_value);
12025 		      goto error_ret_free_internal;
12026 		    }
12027 
12028 		  destination = 0;
12029 		  local_off = 0;
12030 		  if (ok_dest)
12031 		    {
12032 		      sym_value += irela->r_addend;
12033 		      destination = (sym_value
12034 				     + sym_sec->output_offset
12035 				     + sym_sec->output_section->vma);
12036 		      local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12037 							    ? hash->elf.other
12038 							    : sym->st_other);
12039 		    }
12040 
12041 		  code_sec = sym_sec;
12042 		  code_value = sym_value;
12043 		  opd = get_opd_info (sym_sec);
12044 		  if (opd != NULL)
12045 		    {
12046 		      bfd_vma dest;
12047 
12048 		      if (hash == NULL && opd->adjust != NULL)
12049 			{
12050 			  long adjust = opd->adjust[sym_value / 8];
12051 			  if (adjust == -1)
12052 			    continue;
12053 			  code_value += adjust;
12054 			  sym_value += adjust;
12055 			}
12056 		      dest = opd_entry_value (sym_sec, sym_value,
12057 					      &code_sec, &code_value, FALSE);
12058 		      if (dest != (bfd_vma) -1)
12059 			{
12060 			  destination = dest;
12061 			  if (fdh != NULL)
12062 			    {
12063 			      /* Fixup old ABI sym to point at code
12064 				 entry.  */
12065 			      hash->elf.root.type = bfd_link_hash_defweak;
12066 			      hash->elf.root.u.def.section = code_sec;
12067 			      hash->elf.root.u.def.value = code_value;
12068 			    }
12069 			}
12070 		    }
12071 
12072 		  /* Determine what (if any) linker stub is needed.  */
12073 		  plt_ent = NULL;
12074 		  stub_type = ppc_type_of_stub (section, irela, &hash,
12075 						&plt_ent, destination,
12076 						local_off);
12077 
12078 		  if (stub_type != ppc_stub_plt_call)
12079 		    {
12080 		      /* Check whether we need a TOC adjusting stub.
12081 			 Since the linker pastes together pieces from
12082 			 different object files when creating the
12083 			 _init and _fini functions, it may be that a
12084 			 call to what looks like a local sym is in
12085 			 fact a call needing a TOC adjustment.  */
12086 		      if (code_sec != NULL
12087 			  && code_sec->output_section != NULL
12088 			  && (htab->stub_group[code_sec->id].toc_off
12089 			      != htab->stub_group[section->id].toc_off)
12090 			  && (code_sec->has_toc_reloc
12091 			      || code_sec->makes_toc_func_call))
12092 			stub_type = ppc_stub_long_branch_r2off;
12093 		    }
12094 
12095 		  if (stub_type == ppc_stub_none)
12096 		    continue;
12097 
12098 		  /* __tls_get_addr calls might be eliminated.  */
12099 		  if (stub_type != ppc_stub_plt_call
12100 		      && hash != NULL
12101 		      && (hash == htab->tls_get_addr
12102 			  || hash == htab->tls_get_addr_fd)
12103 		      && section->has_tls_reloc
12104 		      && irela != internal_relocs)
12105 		    {
12106 		      /* Get tls info.  */
12107 		      unsigned char *tls_mask;
12108 
12109 		      if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12110 					 irela - 1, input_bfd))
12111 			goto error_ret_free_internal;
12112 		      if (*tls_mask != 0)
12113 			continue;
12114 		    }
12115 
12116 		  if (stub_type == ppc_stub_plt_call
12117 		      && irela + 1 < irelaend
12118 		      && irela[1].r_offset == irela->r_offset + 4
12119 		      && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12120 		    {
12121 		      if (!tocsave_find (htab, INSERT,
12122 					 &local_syms, irela + 1, input_bfd))
12123 			goto error_ret_free_internal;
12124 		    }
12125 		  else if (stub_type == ppc_stub_plt_call)
12126 		    stub_type = ppc_stub_plt_call_r2save;
12127 
12128 		  /* Support for grouping stub sections.  */
12129 		  id_sec = htab->stub_group[section->id].link_sec;
12130 
12131 		  /* Get the name of this stub.  */
12132 		  stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12133 		  if (!stub_name)
12134 		    goto error_ret_free_internal;
12135 
12136 		  stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12137 						     stub_name, FALSE, FALSE);
12138 		  if (stub_entry != NULL)
12139 		    {
12140 		      /* The proper stub has already been created.  */
12141 		      free (stub_name);
12142 		      if (stub_type == ppc_stub_plt_call_r2save)
12143 			stub_entry->stub_type = stub_type;
12144 		      continue;
12145 		    }
12146 
12147 		  stub_entry = ppc_add_stub (stub_name, section, info);
12148 		  if (stub_entry == NULL)
12149 		    {
12150 		      free (stub_name);
12151 		    error_ret_free_internal:
12152 		      if (elf_section_data (section)->relocs == NULL)
12153 			free (internal_relocs);
12154 		    error_ret_free_local:
12155 		      if (local_syms != NULL
12156 			  && (symtab_hdr->contents
12157 			      != (unsigned char *) local_syms))
12158 			free (local_syms);
12159 		      return FALSE;
12160 		    }
12161 
12162 		  stub_entry->stub_type = stub_type;
12163 		  if (stub_type != ppc_stub_plt_call
12164 		      && stub_type != ppc_stub_plt_call_r2save)
12165 		    {
12166 		      stub_entry->target_value = code_value;
12167 		      stub_entry->target_section = code_sec;
12168 		    }
12169 		  else
12170 		    {
12171 		      stub_entry->target_value = sym_value;
12172 		      stub_entry->target_section = sym_sec;
12173 		    }
12174 		  stub_entry->h = hash;
12175 		  stub_entry->plt_ent = plt_ent;
12176 		  stub_entry->other = hash ? hash->elf.other : sym->st_other;
12177 
12178 		  if (stub_entry->h != NULL)
12179 		    htab->stub_globals += 1;
12180 		}
12181 
12182 	      /* We're done with the internal relocs, free them.  */
12183 	      if (elf_section_data (section)->relocs != internal_relocs)
12184 		free (internal_relocs);
12185 	    }
12186 
12187 	  if (local_syms != NULL
12188 	      && symtab_hdr->contents != (unsigned char *) local_syms)
12189 	    {
12190 	      if (!info->keep_memory)
12191 		free (local_syms);
12192 	      else
12193 		symtab_hdr->contents = (unsigned char *) local_syms;
12194 	    }
12195 	}
12196 
12197       /* We may have added some stubs.  Find out the new size of the
12198 	 stub sections.  */
12199       for (stub_sec = htab->stub_bfd->sections;
12200 	   stub_sec != NULL;
12201 	   stub_sec = stub_sec->next)
12202 	if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12203 	  {
12204 	    stub_sec->rawsize = stub_sec->size;
12205 	    stub_sec->size = 0;
12206 	    stub_sec->reloc_count = 0;
12207 	    stub_sec->flags &= ~SEC_RELOC;
12208 	  }
12209 
12210       htab->brlt->size = 0;
12211       htab->brlt->reloc_count = 0;
12212       htab->brlt->flags &= ~SEC_RELOC;
12213       if (htab->relbrlt != NULL)
12214 	htab->relbrlt->size = 0;
12215 
12216       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12217 
12218       if (info->emitrelocations
12219 	  && htab->glink != NULL && htab->glink->size != 0)
12220 	{
12221 	  htab->glink->reloc_count = 1;
12222 	  htab->glink->flags |= SEC_RELOC;
12223 	}
12224 
12225       if (htab->glink_eh_frame != NULL
12226 	  && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12227 	  && htab->glink_eh_frame->output_section->size != 0)
12228 	{
12229 	  size_t size = 0, align;
12230 
12231 	  for (stub_sec = htab->stub_bfd->sections;
12232 	       stub_sec != NULL;
12233 	       stub_sec = stub_sec->next)
12234 	    if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12235 	      size += 20;
12236 	  if (htab->glink != NULL && htab->glink->size != 0)
12237 	    size += 24;
12238 	  if (size != 0)
12239 	    size += sizeof (glink_eh_frame_cie);
12240 	  align = 1;
12241 	  align <<= htab->glink_eh_frame->output_section->alignment_power;
12242 	  align -= 1;
12243 	  size = (size + align) & ~align;
12244 	  htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12245 	  htab->glink_eh_frame->size = size;
12246 	}
12247 
12248       if (htab->plt_stub_align != 0)
12249 	for (stub_sec = htab->stub_bfd->sections;
12250 	     stub_sec != NULL;
12251 	     stub_sec = stub_sec->next)
12252 	  if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12253 	    stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12254 			      & (-1 << htab->plt_stub_align));
12255 
12256       for (stub_sec = htab->stub_bfd->sections;
12257 	   stub_sec != NULL;
12258 	   stub_sec = stub_sec->next)
12259 	if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12260 	    && stub_sec->rawsize != stub_sec->size)
12261 	  break;
12262 
12263       /* Exit from this loop when no stubs have been added, and no stubs
12264 	 have changed size.  */
12265       if (stub_sec == NULL
12266 	  && (htab->glink_eh_frame == NULL
12267 	      || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12268 	break;
12269 
12270       /* Ask the linker to do its stuff.  */
12271       (*htab->layout_sections_again) ();
12272     }
12273 
12274   maybe_strip_output (info, htab->brlt);
12275   if (htab->glink_eh_frame != NULL)
12276     maybe_strip_output (info, htab->glink_eh_frame);
12277 
12278   return TRUE;
12279 }
12280 
12281 /* Called after we have determined section placement.  If sections
12282    move, we'll be called again.  Provide a value for TOCstart.  */
12283 
12284 bfd_vma
12285 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12286 {
12287   asection *s;
12288   bfd_vma TOCstart;
12289 
12290   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12291      order.  The TOC starts where the first of these sections starts.  */
12292   s = bfd_get_section_by_name (obfd, ".got");
12293   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12294     s = bfd_get_section_by_name (obfd, ".toc");
12295   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12296     s = bfd_get_section_by_name (obfd, ".tocbss");
12297   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12298     s = bfd_get_section_by_name (obfd, ".plt");
12299   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12300     {
12301       /* This may happen for
12302 	 o  references to TOC base (SYM@toc / TOC[tc0]) without a
12303 	 .toc directive
12304 	 o  bad linker script
12305 	 o --gc-sections and empty TOC sections
12306 
12307 	 FIXME: Warn user?  */
12308 
12309       /* Look for a likely section.  We probably won't even be
12310 	 using TOCstart.  */
12311       for (s = obfd->sections; s != NULL; s = s->next)
12312 	if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12313 			 | SEC_EXCLUDE))
12314 	    == (SEC_ALLOC | SEC_SMALL_DATA))
12315 	  break;
12316       if (s == NULL)
12317 	for (s = obfd->sections; s != NULL; s = s->next)
12318 	  if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12319 	      == (SEC_ALLOC | SEC_SMALL_DATA))
12320 	    break;
12321       if (s == NULL)
12322 	for (s = obfd->sections; s != NULL; s = s->next)
12323 	  if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12324 	      == SEC_ALLOC)
12325 	    break;
12326       if (s == NULL)
12327 	for (s = obfd->sections; s != NULL; s = s->next)
12328 	  if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12329 	    break;
12330     }
12331 
12332   TOCstart = 0;
12333   if (s != NULL)
12334     TOCstart = s->output_section->vma + s->output_offset;
12335 
12336   _bfd_set_gp_value (obfd, TOCstart);
12337 
12338   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12339     {
12340       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12341 
12342       if (htab != NULL
12343 	  && htab->elf.hgot != NULL)
12344 	{
12345 	  htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12346 	  htab->elf.hgot->root.u.def.section = s;
12347 	}
12348     }
12349   return TOCstart;
12350 }
12351 
12352 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12353    write out any global entry stubs.  */
12354 
12355 static bfd_boolean
12356 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12357 {
12358   struct bfd_link_info *info;
12359   struct ppc_link_hash_table *htab;
12360   struct plt_entry *pent;
12361   asection *s;
12362 
12363   if (h->root.type == bfd_link_hash_indirect)
12364     return TRUE;
12365 
12366   if (!h->pointer_equality_needed)
12367     return TRUE;
12368 
12369   if (h->def_regular)
12370     return TRUE;
12371 
12372   info = inf;
12373   htab = ppc_hash_table (info);
12374   if (htab == NULL)
12375     return FALSE;
12376 
12377   s = htab->glink;
12378   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12379     if (pent->plt.offset != (bfd_vma) -1
12380 	&& pent->addend == 0)
12381       {
12382 	bfd_byte *p;
12383 	asection *plt;
12384 	bfd_vma off;
12385 
12386 	p = s->contents + h->root.u.def.value;
12387 	plt = htab->elf.splt;
12388 	if (!htab->elf.dynamic_sections_created
12389 	    || h->dynindx == -1)
12390 	  plt = htab->elf.iplt;
12391 	off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12392 	off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12393 
12394 	if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12395 	  {
12396 	    info->callbacks->einfo
12397 	      (_("%P: linkage table error against `%T'\n"),
12398 	       h->root.root.string);
12399 	    bfd_set_error (bfd_error_bad_value);
12400 	    htab->stub_error = TRUE;
12401 	  }
12402 
12403 	if (PPC_HA (off) != 0)
12404 	  {
12405 	    bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12406 	    p += 4;
12407 	  }
12408 	bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12409 	p += 4;
12410 	bfd_put_32 (s->owner, MTCTR_R12, p);
12411 	p += 4;
12412 	bfd_put_32 (s->owner, BCTR, p);
12413 	break;
12414       }
12415   return TRUE;
12416 }
12417 
12418 /* Build all the stubs associated with the current output file.
12419    The stubs are kept in a hash table attached to the main linker
12420    hash table.  This function is called via gldelf64ppc_finish.  */
12421 
12422 bfd_boolean
12423 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12424 		       struct bfd_link_info *info,
12425 		       char **stats)
12426 {
12427   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12428   asection *stub_sec;
12429   bfd_byte *p;
12430   int stub_sec_count = 0;
12431 
12432   if (htab == NULL)
12433     return FALSE;
12434 
12435   htab->emit_stub_syms = emit_stub_syms;
12436 
12437   /* Allocate memory to hold the linker stubs.  */
12438   for (stub_sec = htab->stub_bfd->sections;
12439        stub_sec != NULL;
12440        stub_sec = stub_sec->next)
12441     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12442 	&& stub_sec->size != 0)
12443       {
12444 	stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12445 	if (stub_sec->contents == NULL)
12446 	  return FALSE;
12447 	/* We want to check that built size is the same as calculated
12448 	   size.  rawsize is a convenient location to use.  */
12449 	stub_sec->rawsize = stub_sec->size;
12450 	stub_sec->size = 0;
12451       }
12452 
12453   if (htab->glink != NULL && htab->glink->size != 0)
12454     {
12455       unsigned int indx;
12456       bfd_vma plt0;
12457 
12458       /* Build the .glink plt call stub.  */
12459       if (htab->emit_stub_syms)
12460 	{
12461 	  struct elf_link_hash_entry *h;
12462 	  h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12463 				    TRUE, FALSE, FALSE);
12464 	  if (h == NULL)
12465 	    return FALSE;
12466 	  if (h->root.type == bfd_link_hash_new)
12467 	    {
12468 	      h->root.type = bfd_link_hash_defined;
12469 	      h->root.u.def.section = htab->glink;
12470 	      h->root.u.def.value = 8;
12471 	      h->ref_regular = 1;
12472 	      h->def_regular = 1;
12473 	      h->ref_regular_nonweak = 1;
12474 	      h->forced_local = 1;
12475 	      h->non_elf = 0;
12476 	    }
12477 	}
12478       plt0 = (htab->elf.splt->output_section->vma
12479 	      + htab->elf.splt->output_offset
12480 	      - 16);
12481       if (info->emitrelocations)
12482 	{
12483 	  Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12484 	  if (r == NULL)
12485 	    return FALSE;
12486 	  r->r_offset = (htab->glink->output_offset
12487 			 + htab->glink->output_section->vma);
12488 	  r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12489 	  r->r_addend = plt0;
12490 	}
12491       p = htab->glink->contents;
12492       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12493       bfd_put_64 (htab->glink->owner, plt0, p);
12494       p += 8;
12495       if (htab->opd_abi)
12496 	{
12497 	  bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12498 	  p += 4;
12499 	  bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12500 	  p += 4;
12501 	  bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12502 	  p += 4;
12503 	  bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12504 	  p += 4;
12505 	  bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12506 	  p += 4;
12507 	  bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12508 	  p += 4;
12509 	  bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12510 	  p += 4;
12511 	  bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12512 	  p += 4;
12513 	  bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12514 	  p += 4;
12515 	  bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12516 	  p += 4;
12517 	}
12518       else
12519 	{
12520 	  bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12521 	  p += 4;
12522 	  bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12523 	  p += 4;
12524 	  bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12525 	  p += 4;
12526 	  bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12527 	  p += 4;
12528 	  bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12529 	  p += 4;
12530 	  bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12531 	  p += 4;
12532 	  bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12533 	  p += 4;
12534 	  bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12535 	  p += 4;
12536 	  bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12537 	  p += 4;
12538 	  bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12539 	  p += 4;
12540 	  bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12541 	  p += 4;
12542 	  bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12543 	  p += 4;
12544 	}
12545       bfd_put_32 (htab->glink->owner, BCTR, p);
12546       p += 4;
12547       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12548 	{
12549 	  bfd_put_32 (htab->glink->owner, NOP, p);
12550 	  p += 4;
12551 	}
12552 
12553       /* Build the .glink lazy link call stubs.  */
12554       indx = 0;
12555       while (p < htab->glink->contents + htab->glink->rawsize)
12556 	{
12557 	  if (htab->opd_abi)
12558 	    {
12559 	      if (indx < 0x8000)
12560 		{
12561 		  bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12562 		  p += 4;
12563 		}
12564 	      else
12565 		{
12566 		  bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12567 		  p += 4;
12568 		  bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12569 			      p);
12570 		  p += 4;
12571 		}
12572 	    }
12573 	  bfd_put_32 (htab->glink->owner,
12574 		      B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12575 	  indx++;
12576 	  p += 4;
12577 	}
12578 
12579       /* Build .glink global entry stubs.  */
12580       if (htab->glink->size > htab->glink->rawsize)
12581 	elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12582     }
12583 
12584   if (htab->brlt->size != 0)
12585     {
12586       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12587 					 htab->brlt->size);
12588       if (htab->brlt->contents == NULL)
12589 	return FALSE;
12590     }
12591   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12592     {
12593       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12594 					    htab->relbrlt->size);
12595       if (htab->relbrlt->contents == NULL)
12596 	return FALSE;
12597     }
12598 
12599   if (htab->glink_eh_frame != NULL
12600       && htab->glink_eh_frame->size != 0)
12601     {
12602       bfd_vma val;
12603       bfd_byte *last_fde;
12604       size_t last_fde_len, size, align, pad;
12605 
12606       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12607       if (p == NULL)
12608 	return FALSE;
12609       htab->glink_eh_frame->contents = p;
12610       last_fde = p;
12611 
12612       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12613 
12614       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12615       /* CIE length (rewrite in case little-endian).  */
12616       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12617       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12618       p += sizeof (glink_eh_frame_cie);
12619 
12620       for (stub_sec = htab->stub_bfd->sections;
12621 	   stub_sec != NULL;
12622 	   stub_sec = stub_sec->next)
12623 	if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12624 	  {
12625 	    last_fde = p;
12626 	    last_fde_len = 16;
12627 	    /* FDE length.  */
12628 	    bfd_put_32 (htab->elf.dynobj, 16, p);
12629 	    p += 4;
12630 	    /* CIE pointer.  */
12631 	    val = p - htab->glink_eh_frame->contents;
12632 	    bfd_put_32 (htab->elf.dynobj, val, p);
12633 	    p += 4;
12634 	    /* Offset to stub section.  */
12635 	    val = (stub_sec->output_section->vma
12636 		   + stub_sec->output_offset);
12637 	    val -= (htab->glink_eh_frame->output_section->vma
12638 		    + htab->glink_eh_frame->output_offset);
12639 	    val -= p - htab->glink_eh_frame->contents;
12640 	    if (val + 0x80000000 > 0xffffffff)
12641 	      {
12642 		info->callbacks->einfo
12643 		  (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12644 		   stub_sec->name);
12645 		return FALSE;
12646 	      }
12647 	    bfd_put_32 (htab->elf.dynobj, val, p);
12648 	    p += 4;
12649 	    /* stub section size.  */
12650 	    bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12651 	    p += 4;
12652 	    /* Augmentation.  */
12653 	    p += 1;
12654 	    /* Pad.  */
12655 	    p += 3;
12656 	  }
12657       if (htab->glink != NULL && htab->glink->size != 0)
12658 	{
12659 	  last_fde = p;
12660 	  last_fde_len = 20;
12661 	  /* FDE length.  */
12662 	  bfd_put_32 (htab->elf.dynobj, 20, p);
12663 	  p += 4;
12664 	  /* CIE pointer.  */
12665 	  val = p - htab->glink_eh_frame->contents;
12666 	  bfd_put_32 (htab->elf.dynobj, val, p);
12667 	  p += 4;
12668 	  /* Offset to .glink.  */
12669 	  val = (htab->glink->output_section->vma
12670 		 + htab->glink->output_offset
12671 		 + 8);
12672 	  val -= (htab->glink_eh_frame->output_section->vma
12673 		  + htab->glink_eh_frame->output_offset);
12674 	  val -= p - htab->glink_eh_frame->contents;
12675 	  if (val + 0x80000000 > 0xffffffff)
12676 	    {
12677 	      info->callbacks->einfo
12678 		(_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12679 		 htab->glink->name);
12680 	      return FALSE;
12681 	    }
12682 	  bfd_put_32 (htab->elf.dynobj, val, p);
12683 	  p += 4;
12684 	  /* .glink size.  */
12685 	  bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12686 	  p += 4;
12687 	  /* Augmentation.  */
12688 	  p += 1;
12689 
12690 	  *p++ = DW_CFA_advance_loc + 1;
12691 	  *p++ = DW_CFA_register;
12692 	  *p++ = 65;
12693 	  *p++ = 12;
12694 	  *p++ = DW_CFA_advance_loc + 4;
12695 	  *p++ = DW_CFA_restore_extended;
12696 	  *p++ = 65;
12697 	}
12698       /* Subsume any padding into the last FDE if user .eh_frame
12699 	 sections are aligned more than glink_eh_frame.  Otherwise any
12700 	 zero padding will be seen as a terminator.  */
12701       size = p - htab->glink_eh_frame->contents;
12702       align = 1;
12703       align <<= htab->glink_eh_frame->output_section->alignment_power;
12704       align -= 1;
12705       pad = ((size + align) & ~align) - size;
12706       htab->glink_eh_frame->size = size + pad;
12707       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12708     }
12709 
12710   /* Build the stubs as directed by the stub hash table.  */
12711   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12712 
12713   if (htab->relbrlt != NULL)
12714     htab->relbrlt->reloc_count = 0;
12715 
12716   if (htab->plt_stub_align != 0)
12717     for (stub_sec = htab->stub_bfd->sections;
12718 	 stub_sec != NULL;
12719 	 stub_sec = stub_sec->next)
12720       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12721 	stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12722 			  & (-1 << htab->plt_stub_align));
12723 
12724   for (stub_sec = htab->stub_bfd->sections;
12725        stub_sec != NULL;
12726        stub_sec = stub_sec->next)
12727     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12728       {
12729 	stub_sec_count += 1;
12730 	if (stub_sec->rawsize != stub_sec->size)
12731 	  break;
12732       }
12733 
12734   if (stub_sec != NULL
12735       || (htab->glink_eh_frame != NULL
12736 	  && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12737     {
12738       htab->stub_error = TRUE;
12739       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12740     }
12741 
12742   if (htab->stub_error)
12743     return FALSE;
12744 
12745   if (stats != NULL)
12746     {
12747       *stats = bfd_malloc (500);
12748       if (*stats == NULL)
12749 	return FALSE;
12750 
12751       sprintf (*stats, _("linker stubs in %u group%s\n"
12752 			 "  branch       %lu\n"
12753 			 "  toc adjust   %lu\n"
12754 			 "  long branch  %lu\n"
12755 			 "  long toc adj %lu\n"
12756 			 "  plt call     %lu\n"
12757 			 "  plt call toc %lu"),
12758 	       stub_sec_count,
12759 	       stub_sec_count == 1 ? "" : "s",
12760 	       htab->stub_count[ppc_stub_long_branch - 1],
12761 	       htab->stub_count[ppc_stub_long_branch_r2off - 1],
12762 	       htab->stub_count[ppc_stub_plt_branch - 1],
12763 	       htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12764 	       htab->stub_count[ppc_stub_plt_call - 1],
12765 	       htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12766     }
12767   return TRUE;
12768 }
12769 
12770 /* This function undoes the changes made by add_symbol_adjust.  */
12771 
12772 static bfd_boolean
12773 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12774 {
12775   struct ppc_link_hash_entry *eh;
12776 
12777   if (h->root.type == bfd_link_hash_indirect)
12778     return TRUE;
12779 
12780   eh = (struct ppc_link_hash_entry *) h;
12781   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12782     return TRUE;
12783 
12784   eh->elf.root.type = bfd_link_hash_undefined;
12785   return TRUE;
12786 }
12787 
12788 void
12789 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12790 {
12791   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12792 
12793   if (htab != NULL)
12794     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12795 }
12796 
12797 /* What to do when ld finds relocations against symbols defined in
12798    discarded sections.  */
12799 
12800 static unsigned int
12801 ppc64_elf_action_discarded (asection *sec)
12802 {
12803   if (strcmp (".opd", sec->name) == 0)
12804     return 0;
12805 
12806   if (strcmp (".toc", sec->name) == 0)
12807     return 0;
12808 
12809   if (strcmp (".toc1", sec->name) == 0)
12810     return 0;
12811 
12812   return _bfd_elf_default_action_discarded (sec);
12813 }
12814 
12815 /* The RELOCATE_SECTION function is called by the ELF backend linker
12816    to handle the relocations for a section.
12817 
12818    The relocs are always passed as Rela structures; if the section
12819    actually uses Rel structures, the r_addend field will always be
12820    zero.
12821 
12822    This function is responsible for adjust the section contents as
12823    necessary, and (if using Rela relocs and generating a
12824    relocatable output file) adjusting the reloc addend as
12825    necessary.
12826 
12827    This function does not have to worry about setting the reloc
12828    address or the reloc symbol index.
12829 
12830    LOCAL_SYMS is a pointer to the swapped in local symbols.
12831 
12832    LOCAL_SECTIONS is an array giving the section in the input file
12833    corresponding to the st_shndx field of each local symbol.
12834 
12835    The global hash table entry for the global symbols can be found
12836    via elf_sym_hashes (input_bfd).
12837 
12838    When generating relocatable output, this function must handle
12839    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12840    going to be the section symbol corresponding to the output
12841    section, which means that the addend must be adjusted
12842    accordingly.  */
12843 
12844 static bfd_boolean
12845 ppc64_elf_relocate_section (bfd *output_bfd,
12846 			    struct bfd_link_info *info,
12847 			    bfd *input_bfd,
12848 			    asection *input_section,
12849 			    bfd_byte *contents,
12850 			    Elf_Internal_Rela *relocs,
12851 			    Elf_Internal_Sym *local_syms,
12852 			    asection **local_sections)
12853 {
12854   struct ppc_link_hash_table *htab;
12855   Elf_Internal_Shdr *symtab_hdr;
12856   struct elf_link_hash_entry **sym_hashes;
12857   Elf_Internal_Rela *rel;
12858   Elf_Internal_Rela *relend;
12859   Elf_Internal_Rela outrel;
12860   bfd_byte *loc;
12861   struct got_entry **local_got_ents;
12862   bfd_vma TOCstart;
12863   bfd_boolean ret = TRUE;
12864   bfd_boolean is_opd;
12865   /* Assume 'at' branch hints.  */
12866   bfd_boolean is_isa_v2 = TRUE;
12867   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12868 
12869   /* Initialize howto table if needed.  */
12870   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12871     ppc_howto_init ();
12872 
12873   htab = ppc_hash_table (info);
12874   if (htab == NULL)
12875     return FALSE;
12876 
12877   /* Don't relocate stub sections.  */
12878   if (input_section->owner == htab->stub_bfd)
12879     return TRUE;
12880 
12881   BFD_ASSERT (is_ppc64_elf (input_bfd));
12882 
12883   local_got_ents = elf_local_got_ents (input_bfd);
12884   TOCstart = elf_gp (output_bfd);
12885   symtab_hdr = &elf_symtab_hdr (input_bfd);
12886   sym_hashes = elf_sym_hashes (input_bfd);
12887   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12888 
12889   rel = relocs;
12890   relend = relocs + input_section->reloc_count;
12891   for (; rel < relend; rel++)
12892     {
12893       enum elf_ppc64_reloc_type r_type;
12894       bfd_vma addend;
12895       bfd_reloc_status_type r;
12896       Elf_Internal_Sym *sym;
12897       asection *sec;
12898       struct elf_link_hash_entry *h_elf;
12899       struct ppc_link_hash_entry *h;
12900       struct ppc_link_hash_entry *fdh;
12901       const char *sym_name;
12902       unsigned long r_symndx, toc_symndx;
12903       bfd_vma toc_addend;
12904       unsigned char tls_mask, tls_gd, tls_type;
12905       unsigned char sym_type;
12906       bfd_vma relocation;
12907       bfd_boolean unresolved_reloc;
12908       bfd_boolean warned;
12909       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12910       unsigned int insn;
12911       unsigned int mask;
12912       struct ppc_stub_hash_entry *stub_entry;
12913       bfd_vma max_br_offset;
12914       bfd_vma from;
12915       const Elf_Internal_Rela orig_rel = *rel;
12916 
12917       r_type = ELF64_R_TYPE (rel->r_info);
12918       r_symndx = ELF64_R_SYM (rel->r_info);
12919 
12920       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12921 	 symbol of the previous ADDR64 reloc.  The symbol gives us the
12922 	 proper TOC base to use.  */
12923       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12924 	  && rel != relocs
12925 	  && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12926 	  && is_opd)
12927 	r_symndx = ELF64_R_SYM (rel[-1].r_info);
12928 
12929       sym = NULL;
12930       sec = NULL;
12931       h_elf = NULL;
12932       sym_name = NULL;
12933       unresolved_reloc = FALSE;
12934       warned = FALSE;
12935 
12936       if (r_symndx < symtab_hdr->sh_info)
12937 	{
12938 	  /* It's a local symbol.  */
12939 	  struct _opd_sec_data *opd;
12940 
12941 	  sym = local_syms + r_symndx;
12942 	  sec = local_sections[r_symndx];
12943 	  sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12944 	  sym_type = ELF64_ST_TYPE (sym->st_info);
12945 	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12946 	  opd = get_opd_info (sec);
12947 	  if (opd != NULL && opd->adjust != NULL)
12948 	    {
12949 	      long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12950 	      if (adjust == -1)
12951 		relocation = 0;
12952 	      else
12953 		{
12954 		  /* If this is a relocation against the opd section sym
12955 		     and we have edited .opd, adjust the reloc addend so
12956 		     that ld -r and ld --emit-relocs output is correct.
12957 		     If it is a reloc against some other .opd symbol,
12958 		     then the symbol value will be adjusted later.  */
12959 		  if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12960 		    rel->r_addend += adjust;
12961 		  else
12962 		    relocation += adjust;
12963 		}
12964 	    }
12965 	}
12966       else
12967 	{
12968 	  bfd_boolean ignored;
12969 
12970 	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12971 				   r_symndx, symtab_hdr, sym_hashes,
12972 				   h_elf, sec, relocation,
12973 				   unresolved_reloc, warned, ignored);
12974 	  sym_name = h_elf->root.root.string;
12975 	  sym_type = h_elf->type;
12976 	  if (sec != NULL
12977 	      && sec->owner == output_bfd
12978 	      && strcmp (sec->name, ".opd") == 0)
12979 	    {
12980 	      /* This is a symbol defined in a linker script.  All
12981 		 such are defined in output sections, even those
12982 		 defined by simple assignment from a symbol defined in
12983 		 an input section.  Transfer the symbol to an
12984 		 appropriate input .opd section, so that a branch to
12985 		 this symbol will be mapped to the location specified
12986 		 by the opd entry.  */
12987 	      struct bfd_link_order *lo;
12988 	      for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12989 		if (lo->type == bfd_indirect_link_order)
12990 		  {
12991 		    asection *isec = lo->u.indirect.section;
12992 		    if (h_elf->root.u.def.value >= isec->output_offset
12993 			&& h_elf->root.u.def.value < (isec->output_offset
12994 						      + isec->size))
12995 		      {
12996 			h_elf->root.u.def.value -= isec->output_offset;
12997 			h_elf->root.u.def.section = isec;
12998 			sec = isec;
12999 			break;
13000 		      }
13001 		  }
13002 	    }
13003 	}
13004       h = (struct ppc_link_hash_entry *) h_elf;
13005 
13006       if (sec != NULL && discarded_section (sec))
13007 	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13008 					 rel, 1, relend,
13009 					 ppc64_elf_howto_table[r_type], 0,
13010 					 contents);
13011 
13012       if (info->relocatable)
13013 	continue;
13014 
13015       if (h != NULL && &h->elf == htab->elf.hgot)
13016 	{
13017 	  relocation = (TOCstart
13018 			+ htab->stub_group[input_section->id].toc_off);
13019 	  sec = bfd_abs_section_ptr;
13020 	  unresolved_reloc = FALSE;
13021 	}
13022 
13023       /* TLS optimizations.  Replace instruction sequences and relocs
13024 	 based on information we collected in tls_optimize.  We edit
13025 	 RELOCS so that --emit-relocs will output something sensible
13026 	 for the final instruction stream.  */
13027       tls_mask = 0;
13028       tls_gd = 0;
13029       toc_symndx = 0;
13030       if (h != NULL)
13031 	tls_mask = h->tls_mask;
13032       else if (local_got_ents != NULL)
13033 	{
13034 	  struct plt_entry **local_plt = (struct plt_entry **)
13035 	    (local_got_ents + symtab_hdr->sh_info);
13036 	  unsigned char *lgot_masks = (unsigned char *)
13037 	    (local_plt + symtab_hdr->sh_info);
13038 	  tls_mask = lgot_masks[r_symndx];
13039 	}
13040       if (tls_mask == 0
13041 	  && (r_type == R_PPC64_TLS
13042 	      || r_type == R_PPC64_TLSGD
13043 	      || r_type == R_PPC64_TLSLD))
13044 	{
13045 	  /* Check for toc tls entries.  */
13046 	  unsigned char *toc_tls;
13047 
13048 	  if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13049 			     &local_syms, rel, input_bfd))
13050 	    return FALSE;
13051 
13052 	  if (toc_tls)
13053 	    tls_mask = *toc_tls;
13054 	}
13055 
13056       /* Check that tls relocs are used with tls syms, and non-tls
13057 	 relocs are used with non-tls syms.  */
13058       if (r_symndx != STN_UNDEF
13059 	  && r_type != R_PPC64_NONE
13060 	  && (h == NULL
13061 	      || h->elf.root.type == bfd_link_hash_defined
13062 	      || h->elf.root.type == bfd_link_hash_defweak)
13063 	  && (IS_PPC64_TLS_RELOC (r_type)
13064 	      != (sym_type == STT_TLS
13065 		  || (sym_type == STT_SECTION
13066 		      && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13067 	{
13068 	  if (tls_mask != 0
13069 	      && (r_type == R_PPC64_TLS
13070 		  || r_type == R_PPC64_TLSGD
13071 		  || r_type == R_PPC64_TLSLD))
13072 	    /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13073 	    ;
13074 	  else
13075 	    info->callbacks->einfo
13076 	      (!IS_PPC64_TLS_RELOC (r_type)
13077 	       ? _("%P: %H: %s used with TLS symbol `%T'\n")
13078 	       : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13079 	       input_bfd, input_section, rel->r_offset,
13080 	       ppc64_elf_howto_table[r_type]->name,
13081 	       sym_name);
13082 	}
13083 
13084       /* Ensure reloc mapping code below stays sane.  */
13085       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13086 	  || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13087 	  || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13088 	  || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13089 	  || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13090 	  || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13091 	  || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13092 	  || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13093 	  || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13094 	  || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13095 	abort ();
13096 
13097       switch (r_type)
13098 	{
13099 	default:
13100 	  break;
13101 
13102 	case R_PPC64_LO_DS_OPT:
13103 	  insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13104 	  if ((insn & (0x3f << 26)) != 58u << 26)
13105 	    abort ();
13106 	  insn += (14u << 26) - (58u << 26);
13107 	  bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13108 	  r_type = R_PPC64_TOC16_LO;
13109 	  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13110 	  break;
13111 
13112 	case R_PPC64_TOC16:
13113 	case R_PPC64_TOC16_LO:
13114 	case R_PPC64_TOC16_DS:
13115 	case R_PPC64_TOC16_LO_DS:
13116 	  {
13117 	    /* Check for toc tls entries.  */
13118 	    unsigned char *toc_tls;
13119 	    int retval;
13120 
13121 	    retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13122 				   &local_syms, rel, input_bfd);
13123 	    if (retval == 0)
13124 	      return FALSE;
13125 
13126 	    if (toc_tls)
13127 	      {
13128 		tls_mask = *toc_tls;
13129 		if (r_type == R_PPC64_TOC16_DS
13130 		    || r_type == R_PPC64_TOC16_LO_DS)
13131 		  {
13132 		    if (tls_mask != 0
13133 			&& (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13134 		      goto toctprel;
13135 		  }
13136 		else
13137 		  {
13138 		    /* If we found a GD reloc pair, then we might be
13139 		       doing a GD->IE transition.  */
13140 		    if (retval == 2)
13141 		      {
13142 			tls_gd = TLS_TPRELGD;
13143 			if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13144 			  goto tls_ldgd_opt;
13145 		      }
13146 		    else if (retval == 3)
13147 		      {
13148 			if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13149 			  goto tls_ldgd_opt;
13150 		      }
13151 		  }
13152 	      }
13153 	  }
13154 	  break;
13155 
13156 	case R_PPC64_GOT_TPREL16_HI:
13157 	case R_PPC64_GOT_TPREL16_HA:
13158 	  if (tls_mask != 0
13159 	      && (tls_mask & TLS_TPREL) == 0)
13160 	    {
13161 	      rel->r_offset -= d_offset;
13162 	      bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13163 	      r_type = R_PPC64_NONE;
13164 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13165 	    }
13166 	  break;
13167 
13168 	case R_PPC64_GOT_TPREL16_DS:
13169 	case R_PPC64_GOT_TPREL16_LO_DS:
13170 	  if (tls_mask != 0
13171 	      && (tls_mask & TLS_TPREL) == 0)
13172 	    {
13173 	    toctprel:
13174 	      insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13175 	      insn &= 31 << 21;
13176 	      insn |= 0x3c0d0000;	/* addis 0,13,0 */
13177 	      bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13178 	      r_type = R_PPC64_TPREL16_HA;
13179 	      if (toc_symndx != 0)
13180 		{
13181 		  rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13182 		  rel->r_addend = toc_addend;
13183 		  /* We changed the symbol.  Start over in order to
13184 		     get h, sym, sec etc. right.  */
13185 		  rel--;
13186 		  continue;
13187 		}
13188 	      else
13189 		rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13190 	    }
13191 	  break;
13192 
13193 	case R_PPC64_TLS:
13194 	  if (tls_mask != 0
13195 	      && (tls_mask & TLS_TPREL) == 0)
13196 	    {
13197 	      insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13198 	      insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13199 	      if (insn == 0)
13200 		abort ();
13201 	      bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13202 	      /* Was PPC64_TLS which sits on insn boundary, now
13203 		 PPC64_TPREL16_LO which is at low-order half-word.  */
13204 	      rel->r_offset += d_offset;
13205 	      r_type = R_PPC64_TPREL16_LO;
13206 	      if (toc_symndx != 0)
13207 		{
13208 		  rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13209 		  rel->r_addend = toc_addend;
13210 		  /* We changed the symbol.  Start over in order to
13211 		     get h, sym, sec etc. right.  */
13212 		  rel--;
13213 		  continue;
13214 		}
13215 	      else
13216 		rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13217 	    }
13218 	  break;
13219 
13220 	case R_PPC64_GOT_TLSGD16_HI:
13221 	case R_PPC64_GOT_TLSGD16_HA:
13222 	  tls_gd = TLS_TPRELGD;
13223 	  if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13224 	    goto tls_gdld_hi;
13225 	  break;
13226 
13227 	case R_PPC64_GOT_TLSLD16_HI:
13228 	case R_PPC64_GOT_TLSLD16_HA:
13229 	  if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13230 	    {
13231 	    tls_gdld_hi:
13232 	      if ((tls_mask & tls_gd) != 0)
13233 		r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13234 			  + R_PPC64_GOT_TPREL16_DS);
13235 	      else
13236 		{
13237 		  rel->r_offset -= d_offset;
13238 		  bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13239 		  r_type = R_PPC64_NONE;
13240 		}
13241 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13242 	    }
13243 	  break;
13244 
13245 	case R_PPC64_GOT_TLSGD16:
13246 	case R_PPC64_GOT_TLSGD16_LO:
13247 	  tls_gd = TLS_TPRELGD;
13248 	  if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13249 	    goto tls_ldgd_opt;
13250 	  break;
13251 
13252 	case R_PPC64_GOT_TLSLD16:
13253 	case R_PPC64_GOT_TLSLD16_LO:
13254 	  if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13255 	    {
13256 	      unsigned int insn1, insn2, insn3;
13257 	      bfd_vma offset;
13258 
13259 	    tls_ldgd_opt:
13260 	      offset = (bfd_vma) -1;
13261 	      /* If not using the newer R_PPC64_TLSGD/LD to mark
13262 		 __tls_get_addr calls, we must trust that the call
13263 		 stays with its arg setup insns, ie. that the next
13264 		 reloc is the __tls_get_addr call associated with
13265 		 the current reloc.  Edit both insns.  */
13266 	      if (input_section->has_tls_get_addr_call
13267 		  && rel + 1 < relend
13268 		  && branch_reloc_hash_match (input_bfd, rel + 1,
13269 					      htab->tls_get_addr,
13270 					      htab->tls_get_addr_fd))
13271 		offset = rel[1].r_offset;
13272 	      if ((tls_mask & tls_gd) != 0)
13273 		{
13274 		  /* IE */
13275 		  insn1 = bfd_get_32 (output_bfd,
13276 				      contents + rel->r_offset - d_offset);
13277 		  insn1 &= (1 << 26) - (1 << 2);
13278 		  insn1 |= 58 << 26;	/* ld */
13279 		  insn2 = 0x7c636a14;	/* add 3,3,13 */
13280 		  if (offset != (bfd_vma) -1)
13281 		    rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13282 		  if ((tls_mask & TLS_EXPLICIT) == 0)
13283 		    r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13284 			      + R_PPC64_GOT_TPREL16_DS);
13285 		  else
13286 		    r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13287 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13288 		}
13289 	      else
13290 		{
13291 		  /* LE */
13292 		  insn1 = 0x3c6d0000;	/* addis 3,13,0 */
13293 		  insn2 = 0x38630000;	/* addi 3,3,0 */
13294 		  if (tls_gd == 0)
13295 		    {
13296 		      /* Was an LD reloc.  */
13297 		      if (toc_symndx)
13298 			sec = local_sections[toc_symndx];
13299 		      for (r_symndx = 0;
13300 			   r_symndx < symtab_hdr->sh_info;
13301 			   r_symndx++)
13302 			if (local_sections[r_symndx] == sec)
13303 			  break;
13304 		      if (r_symndx >= symtab_hdr->sh_info)
13305 			r_symndx = STN_UNDEF;
13306 		      rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13307 		      if (r_symndx != STN_UNDEF)
13308 			rel->r_addend -= (local_syms[r_symndx].st_value
13309 					  + sec->output_offset
13310 					  + sec->output_section->vma);
13311 		    }
13312 		  else if (toc_symndx != 0)
13313 		    {
13314 		      r_symndx = toc_symndx;
13315 		      rel->r_addend = toc_addend;
13316 		    }
13317 		  r_type = R_PPC64_TPREL16_HA;
13318 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13319 		  if (offset != (bfd_vma) -1)
13320 		    {
13321 		      rel[1].r_info = ELF64_R_INFO (r_symndx,
13322 						    R_PPC64_TPREL16_LO);
13323 		      rel[1].r_offset = offset + d_offset;
13324 		      rel[1].r_addend = rel->r_addend;
13325 		    }
13326 		}
13327 	      bfd_put_32 (output_bfd, insn1,
13328 			  contents + rel->r_offset - d_offset);
13329 	      if (offset != (bfd_vma) -1)
13330 		{
13331 		  insn3 = bfd_get_32 (output_bfd,
13332 				      contents + offset + 4);
13333 		  if (insn3 == NOP
13334 		      || insn3 == CROR_151515 || insn3 == CROR_313131)
13335 		    {
13336 		      rel[1].r_offset += 4;
13337 		      bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13338 		      insn2 = NOP;
13339 		    }
13340 		  bfd_put_32 (output_bfd, insn2, contents + offset);
13341 		}
13342 	      if ((tls_mask & tls_gd) == 0
13343 		  && (tls_gd == 0 || toc_symndx != 0))
13344 		{
13345 		  /* We changed the symbol.  Start over in order
13346 		     to get h, sym, sec etc. right.  */
13347 		  rel--;
13348 		  continue;
13349 		}
13350 	    }
13351 	  break;
13352 
13353 	case R_PPC64_TLSGD:
13354 	  if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13355 	    {
13356 	      unsigned int insn2, insn3;
13357 	      bfd_vma offset = rel->r_offset;
13358 
13359 	      if ((tls_mask & TLS_TPRELGD) != 0)
13360 		{
13361 		  /* IE */
13362 		  r_type = R_PPC64_NONE;
13363 		  insn2 = 0x7c636a14;	/* add 3,3,13 */
13364 		}
13365 	      else
13366 		{
13367 		  /* LE */
13368 		  if (toc_symndx != 0)
13369 		    {
13370 		      r_symndx = toc_symndx;
13371 		      rel->r_addend = toc_addend;
13372 		    }
13373 		  r_type = R_PPC64_TPREL16_LO;
13374 		  rel->r_offset = offset + d_offset;
13375 		  insn2 = 0x38630000;	/* addi 3,3,0 */
13376 		}
13377 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13378 	      /* Zap the reloc on the _tls_get_addr call too.  */
13379 	      BFD_ASSERT (offset == rel[1].r_offset);
13380 	      rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13381 	      insn3 = bfd_get_32 (output_bfd,
13382 				  contents + offset + 4);
13383 	      if (insn3 == NOP
13384 		  || insn3 == CROR_151515 || insn3 == CROR_313131)
13385 		{
13386 		  rel->r_offset += 4;
13387 		  bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13388 		  insn2 = NOP;
13389 		}
13390 	      bfd_put_32 (output_bfd, insn2, contents + offset);
13391 	      if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13392 		{
13393 		  rel--;
13394 		  continue;
13395 		}
13396 	    }
13397 	  break;
13398 
13399 	case R_PPC64_TLSLD:
13400 	  if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13401 	    {
13402 	      unsigned int insn2, insn3;
13403 	      bfd_vma offset = rel->r_offset;
13404 
13405 	      if (toc_symndx)
13406 		sec = local_sections[toc_symndx];
13407 	      for (r_symndx = 0;
13408 		   r_symndx < symtab_hdr->sh_info;
13409 		   r_symndx++)
13410 		if (local_sections[r_symndx] == sec)
13411 		  break;
13412 	      if (r_symndx >= symtab_hdr->sh_info)
13413 		r_symndx = STN_UNDEF;
13414 	      rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13415 	      if (r_symndx != STN_UNDEF)
13416 		rel->r_addend -= (local_syms[r_symndx].st_value
13417 				  + sec->output_offset
13418 				  + sec->output_section->vma);
13419 
13420 	      r_type = R_PPC64_TPREL16_LO;
13421 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13422 	      rel->r_offset = offset + d_offset;
13423 	      /* Zap the reloc on the _tls_get_addr call too.  */
13424 	      BFD_ASSERT (offset == rel[1].r_offset);
13425 	      rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13426 	      insn2 = 0x38630000;	/* addi 3,3,0 */
13427 	      insn3 = bfd_get_32 (output_bfd,
13428 				  contents + offset + 4);
13429 	      if (insn3 == NOP
13430 		  || insn3 == CROR_151515 || insn3 == CROR_313131)
13431 		{
13432 		  rel->r_offset += 4;
13433 		  bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13434 		  insn2 = NOP;
13435 		}
13436 	      bfd_put_32 (output_bfd, insn2, contents + offset);
13437 	      rel--;
13438 	      continue;
13439 	    }
13440 	  break;
13441 
13442 	case R_PPC64_DTPMOD64:
13443 	  if (rel + 1 < relend
13444 	      && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13445 	      && rel[1].r_offset == rel->r_offset + 8)
13446 	    {
13447 	      if ((tls_mask & TLS_GD) == 0)
13448 		{
13449 		  rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13450 		  if ((tls_mask & TLS_TPRELGD) != 0)
13451 		    r_type = R_PPC64_TPREL64;
13452 		  else
13453 		    {
13454 		      bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13455 		      r_type = R_PPC64_NONE;
13456 		    }
13457 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13458 		}
13459 	    }
13460 	  else
13461 	    {
13462 	      if ((tls_mask & TLS_LD) == 0)
13463 		{
13464 		  bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13465 		  r_type = R_PPC64_NONE;
13466 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13467 		}
13468 	    }
13469 	  break;
13470 
13471 	case R_PPC64_TPREL64:
13472 	  if ((tls_mask & TLS_TPREL) == 0)
13473 	    {
13474 	      r_type = R_PPC64_NONE;
13475 	      rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13476 	    }
13477 	  break;
13478 
13479 	case R_PPC64_REL16_HA:
13480 	  /* If we are generating a non-PIC executable, edit
13481 	     .	0:	addis 2,12,.TOC.-0b@ha
13482 	     .		addi 2,2,.TOC.-0b@l
13483 	     used by ELFv2 global entry points to set up r2, to
13484 	     .		lis 2,.TOC.@ha
13485 	     .		addi 2,2,.TOC.@l
13486 	     if .TOC. is in range.  */
13487 	  if (!info->shared
13488 	      && h != NULL && &h->elf == htab->elf.hgot
13489 	      && rel + 1 < relend
13490 	      && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13491 	      && rel[1].r_offset == rel->r_offset + 4
13492 	      && rel[1].r_addend == rel->r_addend + 4
13493 	      && relocation + 0x80008000 <= 0xffffffff)
13494 	    {
13495 	      unsigned int insn1, insn2;
13496 	      bfd_vma offset = rel->r_offset - d_offset;
13497 	      insn1 = bfd_get_32 (output_bfd, contents + offset);
13498 	      insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13499 	      if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13500 		  && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13501 		{
13502 		  r_type = R_PPC64_ADDR16_HA;
13503 		  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13504 		  rel->r_addend -= d_offset;
13505 		  rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13506 		  rel[1].r_addend -= d_offset + 4;
13507 		  bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13508 		}
13509 	    }
13510 	  break;
13511 	}
13512 
13513       /* Handle other relocations that tweak non-addend part of insn.  */
13514       insn = 0;
13515       max_br_offset = 1 << 25;
13516       addend = rel->r_addend;
13517       reloc_dest = DEST_NORMAL;
13518       switch (r_type)
13519 	{
13520 	default:
13521 	  break;
13522 
13523 	case R_PPC64_TOCSAVE:
13524 	  if (relocation + addend == (rel->r_offset
13525 				      + input_section->output_offset
13526 				      + input_section->output_section->vma)
13527 	      && tocsave_find (htab, NO_INSERT,
13528 			       &local_syms, rel, input_bfd))
13529 	    {
13530 	      insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13531 	      if (insn == NOP
13532 		  || insn == CROR_151515 || insn == CROR_313131)
13533 		bfd_put_32 (input_bfd,
13534 			    STD_R2_0R1 + STK_TOC (htab),
13535 			    contents + rel->r_offset);
13536 	    }
13537 	  break;
13538 
13539 	  /* Branch taken prediction relocations.  */
13540 	case R_PPC64_ADDR14_BRTAKEN:
13541 	case R_PPC64_REL14_BRTAKEN:
13542 	  insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13543 	  /* Fall thru.  */
13544 
13545 	  /* Branch not taken prediction relocations.  */
13546 	case R_PPC64_ADDR14_BRNTAKEN:
13547 	case R_PPC64_REL14_BRNTAKEN:
13548 	  insn |= bfd_get_32 (output_bfd,
13549 			      contents + rel->r_offset) & ~(0x01 << 21);
13550 	  /* Fall thru.  */
13551 
13552 	case R_PPC64_REL14:
13553 	  max_br_offset = 1 << 15;
13554 	  /* Fall thru.  */
13555 
13556 	case R_PPC64_REL24:
13557 	  /* Calls to functions with a different TOC, such as calls to
13558 	     shared objects, need to alter the TOC pointer.  This is
13559 	     done using a linkage stub.  A REL24 branching to these
13560 	     linkage stubs needs to be followed by a nop, as the nop
13561 	     will be replaced with an instruction to restore the TOC
13562 	     base pointer.  */
13563 	  fdh = h;
13564 	  if (h != NULL
13565 	      && h->oh != NULL
13566 	      && h->oh->is_func_descriptor)
13567 	    fdh = ppc_follow_link (h->oh);
13568 	  stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13569 					   htab);
13570 	  if (stub_entry != NULL
13571 	      && (stub_entry->stub_type == ppc_stub_plt_call
13572 		  || stub_entry->stub_type == ppc_stub_plt_call_r2save
13573 		  || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13574 		  || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13575 	    {
13576 	      bfd_boolean can_plt_call = FALSE;
13577 
13578 	      /* All of these stubs will modify r2, so there must be a
13579 		 branch and link followed by a nop.  The nop is
13580 		 replaced by an insn to restore r2.  */
13581 	      if (rel->r_offset + 8 <= input_section->size)
13582 		{
13583 		  unsigned long br;
13584 
13585 		  br = bfd_get_32 (input_bfd,
13586 				   contents + rel->r_offset);
13587 		  if ((br & 1) != 0)
13588 		    {
13589 		      unsigned long nop;
13590 
13591 		      nop = bfd_get_32 (input_bfd,
13592 					contents + rel->r_offset + 4);
13593 		      if (nop == NOP
13594 			  || nop == CROR_151515 || nop == CROR_313131)
13595 			{
13596 			  if (h != NULL
13597 			      && (h == htab->tls_get_addr_fd
13598 				  || h == htab->tls_get_addr)
13599 			      && !htab->no_tls_get_addr_opt)
13600 			    {
13601 			      /* Special stub used, leave nop alone.  */
13602 			    }
13603 			  else
13604 			    bfd_put_32 (input_bfd,
13605 					LD_R2_0R1 + STK_TOC (htab),
13606 					contents + rel->r_offset + 4);
13607 			  can_plt_call = TRUE;
13608 			}
13609 		    }
13610 		}
13611 
13612 	      if (!can_plt_call && h != NULL)
13613 		{
13614 		  const char *name = h->elf.root.root.string;
13615 
13616 		  if (*name == '.')
13617 		    ++name;
13618 
13619 		  if (strncmp (name, "__libc_start_main", 17) == 0
13620 		      && (name[17] == 0 || name[17] == '@'))
13621 		    {
13622 		      /* Allow crt1 branch to go via a toc adjusting
13623 			 stub.  Other calls that never return could do
13624 			 the same, if we could detect such.  */
13625 		      can_plt_call = TRUE;
13626 		    }
13627 		}
13628 
13629 	      if (!can_plt_call)
13630 		{
13631 		  /* g++ as of 20130507 emits self-calls without a
13632 		     following nop.  This is arguably wrong since we
13633 		     have conflicting information.  On the one hand a
13634 		     global symbol and on the other a local call
13635 		     sequence, but don't error for this special case.
13636 		     It isn't possible to cheaply verify we have
13637 		     exactly such a call.  Allow all calls to the same
13638 		     section.  */
13639 		  asection *code_sec = sec;
13640 
13641 		  if (get_opd_info (sec) != NULL)
13642 		    {
13643 		      bfd_vma off = (relocation + addend
13644 				     - sec->output_section->vma
13645 				     - sec->output_offset);
13646 
13647 		      opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13648 		    }
13649 		  if (code_sec == input_section)
13650 		    can_plt_call = TRUE;
13651 		}
13652 
13653 	      if (!can_plt_call)
13654 		{
13655 		  info->callbacks->einfo
13656 		    (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13657 		       "recompile with -fPIC\n"),
13658 		     input_bfd, input_section, rel->r_offset, sym_name);
13659 
13660 		  bfd_set_error (bfd_error_bad_value);
13661 		  ret = FALSE;
13662 		}
13663 
13664 	      if (can_plt_call
13665 		  && (stub_entry->stub_type == ppc_stub_plt_call
13666 		      || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13667 		unresolved_reloc = FALSE;
13668 	    }
13669 
13670 	  if ((stub_entry == NULL
13671 	       || stub_entry->stub_type == ppc_stub_long_branch
13672 	       || stub_entry->stub_type == ppc_stub_plt_branch)
13673 	      && get_opd_info (sec) != NULL)
13674 	    {
13675 	      /* The branch destination is the value of the opd entry. */
13676 	      bfd_vma off = (relocation + addend
13677 			     - sec->output_section->vma
13678 			     - sec->output_offset);
13679 	      bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13680 	      if (dest != (bfd_vma) -1)
13681 		{
13682 		  relocation = dest;
13683 		  addend = 0;
13684 		  reloc_dest = DEST_OPD;
13685 		}
13686 	    }
13687 
13688 	  /* If the branch is out of reach we ought to have a long
13689 	     branch stub.  */
13690 	  from = (rel->r_offset
13691 		  + input_section->output_offset
13692 		  + input_section->output_section->vma);
13693 
13694 	  relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13695 						  ? fdh->elf.other
13696 						  : sym->st_other);
13697 
13698 	  if (stub_entry != NULL
13699 	      && (stub_entry->stub_type == ppc_stub_long_branch
13700 		  || stub_entry->stub_type == ppc_stub_plt_branch)
13701 	      && (r_type == R_PPC64_ADDR14_BRTAKEN
13702 		  || r_type == R_PPC64_ADDR14_BRNTAKEN
13703 		  || (relocation + addend - from + max_br_offset
13704 		      < 2 * max_br_offset)))
13705 	    /* Don't use the stub if this branch is in range.  */
13706 	    stub_entry = NULL;
13707 
13708 	  if (stub_entry != NULL)
13709 	    {
13710 	      /* Munge up the value and addend so that we call the stub
13711 		 rather than the procedure directly.  */
13712 	      relocation = (stub_entry->stub_offset
13713 			    + stub_entry->stub_sec->output_offset
13714 			    + stub_entry->stub_sec->output_section->vma);
13715 	      addend = 0;
13716 	      reloc_dest = DEST_STUB;
13717 
13718  	      if ((stub_entry->stub_type == ppc_stub_plt_call
13719 		   || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13720 		  && (ALWAYS_EMIT_R2SAVE
13721 		      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13722 		  && rel + 1 < relend
13723 		  && rel[1].r_offset == rel->r_offset + 4
13724 		  && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13725 		relocation += 4;
13726 	    }
13727 
13728 	  if (insn != 0)
13729 	    {
13730 	      if (is_isa_v2)
13731 		{
13732 		  /* Set 'a' bit.  This is 0b00010 in BO field for branch
13733 		     on CR(BI) insns (BO == 001at or 011at), and 0b01000
13734 		     for branch on CTR insns (BO == 1a00t or 1a01t).  */
13735 		  if ((insn & (0x14 << 21)) == (0x04 << 21))
13736 		    insn |= 0x02 << 21;
13737 		  else if ((insn & (0x14 << 21)) == (0x10 << 21))
13738 		    insn |= 0x08 << 21;
13739 		  else
13740 		    break;
13741 		}
13742 	      else
13743 		{
13744 		  /* Invert 'y' bit if not the default.  */
13745 		  if ((bfd_signed_vma) (relocation + addend - from) < 0)
13746 		    insn ^= 0x01 << 21;
13747 		}
13748 
13749 	      bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13750 	    }
13751 
13752 	  /* NOP out calls to undefined weak functions.
13753 	     We can thus call a weak function without first
13754 	     checking whether the function is defined.  */
13755 	  else if (h != NULL
13756 		   && h->elf.root.type == bfd_link_hash_undefweak
13757 		   && h->elf.dynindx == -1
13758 		   && r_type == R_PPC64_REL24
13759 		   && relocation == 0
13760 		   && addend == 0)
13761 	    {
13762 	      bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13763 	      continue;
13764 	    }
13765 	  break;
13766 	}
13767 
13768       /* Set `addend'.  */
13769       tls_type = 0;
13770       switch (r_type)
13771 	{
13772 	default:
13773 	  info->callbacks->einfo
13774 	    (_("%P: %B: unknown relocation type %d for `%T'\n"),
13775 	     input_bfd, (int) r_type, sym_name);
13776 
13777 	  bfd_set_error (bfd_error_bad_value);
13778 	  ret = FALSE;
13779 	  continue;
13780 
13781 	case R_PPC64_NONE:
13782 	case R_PPC64_TLS:
13783 	case R_PPC64_TLSGD:
13784 	case R_PPC64_TLSLD:
13785 	case R_PPC64_TOCSAVE:
13786 	case R_PPC64_GNU_VTINHERIT:
13787 	case R_PPC64_GNU_VTENTRY:
13788 	  continue;
13789 
13790 	  /* GOT16 relocations.  Like an ADDR16 using the symbol's
13791 	     address in the GOT as relocation value instead of the
13792 	     symbol's value itself.  Also, create a GOT entry for the
13793 	     symbol and put the symbol value there.  */
13794 	case R_PPC64_GOT_TLSGD16:
13795 	case R_PPC64_GOT_TLSGD16_LO:
13796 	case R_PPC64_GOT_TLSGD16_HI:
13797 	case R_PPC64_GOT_TLSGD16_HA:
13798 	  tls_type = TLS_TLS | TLS_GD;
13799 	  goto dogot;
13800 
13801 	case R_PPC64_GOT_TLSLD16:
13802 	case R_PPC64_GOT_TLSLD16_LO:
13803 	case R_PPC64_GOT_TLSLD16_HI:
13804 	case R_PPC64_GOT_TLSLD16_HA:
13805 	  tls_type = TLS_TLS | TLS_LD;
13806 	  goto dogot;
13807 
13808 	case R_PPC64_GOT_TPREL16_DS:
13809 	case R_PPC64_GOT_TPREL16_LO_DS:
13810 	case R_PPC64_GOT_TPREL16_HI:
13811 	case R_PPC64_GOT_TPREL16_HA:
13812 	  tls_type = TLS_TLS | TLS_TPREL;
13813 	  goto dogot;
13814 
13815 	case R_PPC64_GOT_DTPREL16_DS:
13816 	case R_PPC64_GOT_DTPREL16_LO_DS:
13817 	case R_PPC64_GOT_DTPREL16_HI:
13818 	case R_PPC64_GOT_DTPREL16_HA:
13819 	  tls_type = TLS_TLS | TLS_DTPREL;
13820 	  goto dogot;
13821 
13822 	case R_PPC64_GOT16:
13823 	case R_PPC64_GOT16_LO:
13824 	case R_PPC64_GOT16_HI:
13825 	case R_PPC64_GOT16_HA:
13826 	case R_PPC64_GOT16_DS:
13827 	case R_PPC64_GOT16_LO_DS:
13828 	dogot:
13829 	  {
13830 	    /* Relocation is to the entry for this symbol in the global
13831 	       offset table.  */
13832 	    asection *got;
13833 	    bfd_vma *offp;
13834 	    bfd_vma off;
13835 	    unsigned long indx = 0;
13836 	    struct got_entry *ent;
13837 
13838 	    if (tls_type == (TLS_TLS | TLS_LD)
13839 		&& (h == NULL
13840 		    || !h->elf.def_dynamic))
13841 	      ent = ppc64_tlsld_got (input_bfd);
13842 	    else
13843 	      {
13844 
13845 		if (h != NULL)
13846 		  {
13847 		    bfd_boolean dyn = htab->elf.dynamic_sections_created;
13848 		    if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13849 							  &h->elf)
13850 			|| (info->shared
13851 			    && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13852 		      /* This is actually a static link, or it is a
13853 			 -Bsymbolic link and the symbol is defined
13854 			 locally, or the symbol was forced to be local
13855 			 because of a version file.  */
13856 		      ;
13857 		    else
13858 		      {
13859 			BFD_ASSERT (h->elf.dynindx != -1);
13860 			indx = h->elf.dynindx;
13861 			unresolved_reloc = FALSE;
13862 		      }
13863 		    ent = h->elf.got.glist;
13864 		  }
13865 		else
13866 		  {
13867 		    if (local_got_ents == NULL)
13868 		      abort ();
13869 		    ent = local_got_ents[r_symndx];
13870 		  }
13871 
13872 		for (; ent != NULL; ent = ent->next)
13873 		  if (ent->addend == orig_rel.r_addend
13874 		      && ent->owner == input_bfd
13875 		      && ent->tls_type == tls_type)
13876 		    break;
13877 	      }
13878 
13879 	    if (ent == NULL)
13880 	      abort ();
13881 	    if (ent->is_indirect)
13882 	      ent = ent->got.ent;
13883 	    offp = &ent->got.offset;
13884 	    got = ppc64_elf_tdata (ent->owner)->got;
13885 	    if (got == NULL)
13886 	      abort ();
13887 
13888 	    /* The offset must always be a multiple of 8.  We use the
13889 	       least significant bit to record whether we have already
13890 	       processed this entry.  */
13891 	    off = *offp;
13892 	    if ((off & 1) != 0)
13893 	      off &= ~1;
13894 	    else
13895 	      {
13896 		/* Generate relocs for the dynamic linker, except in
13897 		   the case of TLSLD where we'll use one entry per
13898 		   module.  */
13899 		asection *relgot;
13900 		bfd_boolean ifunc;
13901 
13902 		*offp = off | 1;
13903 		relgot = NULL;
13904 		ifunc = (h != NULL
13905 			 ? h->elf.type == STT_GNU_IFUNC
13906 			 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13907 		if (ifunc)
13908 		  relgot = htab->elf.irelplt;
13909 		else if ((info->shared || indx != 0)
13910 			 && (h == NULL
13911 			     || (tls_type == (TLS_TLS | TLS_LD)
13912 				 && !h->elf.def_dynamic)
13913 			     || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13914 			     || h->elf.root.type != bfd_link_hash_undefweak))
13915 		  relgot = ppc64_elf_tdata (ent->owner)->relgot;
13916 		if (relgot != NULL)
13917 		  {
13918 		    outrel.r_offset = (got->output_section->vma
13919 				       + got->output_offset
13920 				       + off);
13921 		    outrel.r_addend = addend;
13922 		    if (tls_type & (TLS_LD | TLS_GD))
13923 		      {
13924 			outrel.r_addend = 0;
13925 			outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13926 			if (tls_type == (TLS_TLS | TLS_GD))
13927 			  {
13928 			    loc = relgot->contents;
13929 			    loc += (relgot->reloc_count++
13930 				    * sizeof (Elf64_External_Rela));
13931 			    bfd_elf64_swap_reloca_out (output_bfd,
13932 						       &outrel, loc);
13933 			    outrel.r_offset += 8;
13934 			    outrel.r_addend = addend;
13935 			    outrel.r_info
13936 			      = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13937 			  }
13938 		      }
13939 		    else if (tls_type == (TLS_TLS | TLS_DTPREL))
13940 		      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13941 		    else if (tls_type == (TLS_TLS | TLS_TPREL))
13942 		      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13943 		    else if (indx != 0)
13944 		      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13945 		    else
13946 		      {
13947 			if (ifunc)
13948 			  outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13949 			else
13950 			  outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13951 
13952 			/* Write the .got section contents for the sake
13953 			   of prelink.  */
13954 			loc = got->contents + off;
13955 			bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13956 				    loc);
13957 		      }
13958 
13959 		    if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13960 		      {
13961 			outrel.r_addend += relocation;
13962 			if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13963 			  outrel.r_addend -= htab->elf.tls_sec->vma;
13964 		      }
13965 		    loc = relgot->contents;
13966 		    loc += (relgot->reloc_count++
13967 			    * sizeof (Elf64_External_Rela));
13968 		    bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13969 		  }
13970 
13971 		/* Init the .got section contents here if we're not
13972 		   emitting a reloc.  */
13973 		else
13974 		  {
13975 		    relocation += addend;
13976 		    if (tls_type == (TLS_TLS | TLS_LD))
13977 		      relocation = 1;
13978 		    else if (tls_type != 0)
13979 		      {
13980 			relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13981 			if (tls_type == (TLS_TLS | TLS_TPREL))
13982 			  relocation += DTP_OFFSET - TP_OFFSET;
13983 
13984 			if (tls_type == (TLS_TLS | TLS_GD))
13985 			  {
13986 			    bfd_put_64 (output_bfd, relocation,
13987 					got->contents + off + 8);
13988 			    relocation = 1;
13989 			  }
13990 		      }
13991 
13992 		    bfd_put_64 (output_bfd, relocation,
13993 				got->contents + off);
13994 		  }
13995 	      }
13996 
13997 	    if (off >= (bfd_vma) -2)
13998 	      abort ();
13999 
14000 	    relocation = got->output_section->vma + got->output_offset + off;
14001 	    addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14002 	  }
14003 	  break;
14004 
14005 	case R_PPC64_PLT16_HA:
14006 	case R_PPC64_PLT16_HI:
14007 	case R_PPC64_PLT16_LO:
14008 	case R_PPC64_PLT32:
14009 	case R_PPC64_PLT64:
14010 	  /* Relocation is to the entry for this symbol in the
14011 	     procedure linkage table.  */
14012 
14013 	  /* Resolve a PLT reloc against a local symbol directly,
14014 	     without using the procedure linkage table.  */
14015 	  if (h == NULL)
14016 	    break;
14017 
14018 	  /* It's possible that we didn't make a PLT entry for this
14019 	     symbol.  This happens when statically linking PIC code,
14020 	     or when using -Bsymbolic.  Go find a match if there is a
14021 	     PLT entry.  */
14022 	  if (htab->elf.splt != NULL)
14023 	    {
14024 	      struct plt_entry *ent;
14025 	      for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14026 		if (ent->plt.offset != (bfd_vma) -1
14027 		    && ent->addend == orig_rel.r_addend)
14028 		  {
14029 		    relocation = (htab->elf.splt->output_section->vma
14030 				  + htab->elf.splt->output_offset
14031 				  + ent->plt.offset);
14032 		    unresolved_reloc = FALSE;
14033 		    break;
14034 		  }
14035 	    }
14036 	  break;
14037 
14038 	case R_PPC64_TOC:
14039 	  /* Relocation value is TOC base.  */
14040 	  relocation = TOCstart;
14041 	  if (r_symndx == STN_UNDEF)
14042 	    relocation += htab->stub_group[input_section->id].toc_off;
14043 	  else if (unresolved_reloc)
14044 	    ;
14045 	  else if (sec != NULL && sec->id <= htab->top_id)
14046 	    relocation += htab->stub_group[sec->id].toc_off;
14047 	  else
14048 	    unresolved_reloc = TRUE;
14049 	  goto dodyn;
14050 
14051 	  /* TOC16 relocs.  We want the offset relative to the TOC base,
14052 	     which is the address of the start of the TOC plus 0x8000.
14053 	     The TOC consists of sections .got, .toc, .tocbss, and .plt,
14054 	     in this order.  */
14055 	case R_PPC64_TOC16:
14056 	case R_PPC64_TOC16_LO:
14057 	case R_PPC64_TOC16_HI:
14058 	case R_PPC64_TOC16_DS:
14059 	case R_PPC64_TOC16_LO_DS:
14060 	case R_PPC64_TOC16_HA:
14061 	  addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14062 	  break;
14063 
14064 	  /* Relocate against the beginning of the section.  */
14065 	case R_PPC64_SECTOFF:
14066 	case R_PPC64_SECTOFF_LO:
14067 	case R_PPC64_SECTOFF_HI:
14068 	case R_PPC64_SECTOFF_DS:
14069 	case R_PPC64_SECTOFF_LO_DS:
14070 	case R_PPC64_SECTOFF_HA:
14071 	  if (sec != NULL)
14072 	    addend -= sec->output_section->vma;
14073 	  break;
14074 
14075 	case R_PPC64_REL16:
14076 	case R_PPC64_REL16_LO:
14077 	case R_PPC64_REL16_HI:
14078 	case R_PPC64_REL16_HA:
14079 	  break;
14080 
14081 	case R_PPC64_REL14:
14082 	case R_PPC64_REL14_BRNTAKEN:
14083 	case R_PPC64_REL14_BRTAKEN:
14084 	case R_PPC64_REL24:
14085 	  break;
14086 
14087 	case R_PPC64_TPREL16:
14088 	case R_PPC64_TPREL16_LO:
14089 	case R_PPC64_TPREL16_HI:
14090 	case R_PPC64_TPREL16_HA:
14091 	case R_PPC64_TPREL16_DS:
14092 	case R_PPC64_TPREL16_LO_DS:
14093 	case R_PPC64_TPREL16_HIGH:
14094 	case R_PPC64_TPREL16_HIGHA:
14095 	case R_PPC64_TPREL16_HIGHER:
14096 	case R_PPC64_TPREL16_HIGHERA:
14097 	case R_PPC64_TPREL16_HIGHEST:
14098 	case R_PPC64_TPREL16_HIGHESTA:
14099 	  if (h != NULL
14100 	      && h->elf.root.type == bfd_link_hash_undefweak
14101 	      && h->elf.dynindx == -1)
14102 	    {
14103 	      /* Make this relocation against an undefined weak symbol
14104 		 resolve to zero.  This is really just a tweak, since
14105 		 code using weak externs ought to check that they are
14106 		 defined before using them.  */
14107 	      bfd_byte *p = contents + rel->r_offset - d_offset;
14108 
14109 	      insn = bfd_get_32 (output_bfd, p);
14110 	      insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14111 	      if (insn != 0)
14112 		bfd_put_32 (output_bfd, insn, p);
14113 	      break;
14114 	    }
14115 	  addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14116 	  if (info->shared)
14117 	    /* The TPREL16 relocs shouldn't really be used in shared
14118 	       libs as they will result in DT_TEXTREL being set, but
14119 	       support them anyway.  */
14120 	    goto dodyn;
14121 	  break;
14122 
14123 	case R_PPC64_DTPREL16:
14124 	case R_PPC64_DTPREL16_LO:
14125 	case R_PPC64_DTPREL16_HI:
14126 	case R_PPC64_DTPREL16_HA:
14127 	case R_PPC64_DTPREL16_DS:
14128 	case R_PPC64_DTPREL16_LO_DS:
14129 	case R_PPC64_DTPREL16_HIGH:
14130 	case R_PPC64_DTPREL16_HIGHA:
14131 	case R_PPC64_DTPREL16_HIGHER:
14132 	case R_PPC64_DTPREL16_HIGHERA:
14133 	case R_PPC64_DTPREL16_HIGHEST:
14134 	case R_PPC64_DTPREL16_HIGHESTA:
14135 	  addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14136 	  break;
14137 
14138 	case R_PPC64_DTPMOD64:
14139 	  relocation = 1;
14140 	  addend = 0;
14141 	  goto dodyn;
14142 
14143 	case R_PPC64_TPREL64:
14144 	  addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14145 	  goto dodyn;
14146 
14147 	case R_PPC64_DTPREL64:
14148 	  addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14149 	  /* Fall thru */
14150 
14151 	  /* Relocations that may need to be propagated if this is a
14152 	     dynamic object.  */
14153 	case R_PPC64_REL30:
14154 	case R_PPC64_REL32:
14155 	case R_PPC64_REL64:
14156 	case R_PPC64_ADDR14:
14157 	case R_PPC64_ADDR14_BRNTAKEN:
14158 	case R_PPC64_ADDR14_BRTAKEN:
14159 	case R_PPC64_ADDR16:
14160 	case R_PPC64_ADDR16_DS:
14161 	case R_PPC64_ADDR16_HA:
14162 	case R_PPC64_ADDR16_HI:
14163 	case R_PPC64_ADDR16_HIGH:
14164 	case R_PPC64_ADDR16_HIGHA:
14165 	case R_PPC64_ADDR16_HIGHER:
14166 	case R_PPC64_ADDR16_HIGHERA:
14167 	case R_PPC64_ADDR16_HIGHEST:
14168 	case R_PPC64_ADDR16_HIGHESTA:
14169 	case R_PPC64_ADDR16_LO:
14170 	case R_PPC64_ADDR16_LO_DS:
14171 	case R_PPC64_ADDR24:
14172 	case R_PPC64_ADDR32:
14173 	case R_PPC64_ADDR64:
14174 	case R_PPC64_UADDR16:
14175 	case R_PPC64_UADDR32:
14176 	case R_PPC64_UADDR64:
14177 	dodyn:
14178 	  if ((input_section->flags & SEC_ALLOC) == 0)
14179 	    break;
14180 
14181 	  if (NO_OPD_RELOCS && is_opd)
14182 	    break;
14183 
14184 	  if ((info->shared
14185 	       && (h == NULL
14186 		   || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14187 		   || h->elf.root.type != bfd_link_hash_undefweak)
14188 	       && (must_be_dyn_reloc (info, r_type)
14189 		   || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14190 	      || (ELIMINATE_COPY_RELOCS
14191 		  && !info->shared
14192 		  && h != NULL
14193 		  && h->elf.dynindx != -1
14194 		  && !h->elf.non_got_ref
14195 		  && !h->elf.def_regular)
14196 	      || (!info->shared
14197 		  && (h != NULL
14198 		      ? h->elf.type == STT_GNU_IFUNC
14199 		      : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14200 	    {
14201 	      bfd_boolean skip, relocate;
14202 	      asection *sreloc;
14203 	      bfd_vma out_off;
14204 
14205 	      /* When generating a dynamic object, these relocations
14206 		 are copied into the output file to be resolved at run
14207 		 time.  */
14208 
14209 	      skip = FALSE;
14210 	      relocate = FALSE;
14211 
14212 	      out_off = _bfd_elf_section_offset (output_bfd, info,
14213 						 input_section, rel->r_offset);
14214 	      if (out_off == (bfd_vma) -1)
14215 		skip = TRUE;
14216 	      else if (out_off == (bfd_vma) -2)
14217 		skip = TRUE, relocate = TRUE;
14218 	      out_off += (input_section->output_section->vma
14219 			  + input_section->output_offset);
14220 	      outrel.r_offset = out_off;
14221 	      outrel.r_addend = rel->r_addend;
14222 
14223 	      /* Optimize unaligned reloc use.  */
14224 	      if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14225 		  || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14226 		r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14227 	      else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14228 		       || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14229 		r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14230 	      else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14231 		       || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14232 		r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14233 
14234 	      if (skip)
14235 		memset (&outrel, 0, sizeof outrel);
14236 	      else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14237 		       && !is_opd
14238 		       && r_type != R_PPC64_TOC)
14239 		{
14240 		  BFD_ASSERT (h->elf.dynindx != -1);
14241 		  outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14242 		}
14243 	      else
14244 		{
14245 		  /* This symbol is local, or marked to become local,
14246 		     or this is an opd section reloc which must point
14247 		     at a local function.  */
14248 		  outrel.r_addend += relocation;
14249 		  if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14250 		    {
14251 		      if (is_opd && h != NULL)
14252 			{
14253 			  /* Lie about opd entries.  This case occurs
14254 			     when building shared libraries and we
14255 			     reference a function in another shared
14256 			     lib.  The same thing happens for a weak
14257 			     definition in an application that's
14258 			     overridden by a strong definition in a
14259 			     shared lib.  (I believe this is a generic
14260 			     bug in binutils handling of weak syms.)
14261 			     In these cases we won't use the opd
14262 			     entry in this lib.  */
14263 			  unresolved_reloc = FALSE;
14264 			}
14265 		      if (!is_opd
14266 			  && r_type == R_PPC64_ADDR64
14267 			  && (h != NULL
14268 			      ? h->elf.type == STT_GNU_IFUNC
14269 			      : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14270 			outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14271 		      else
14272 			{
14273 			  outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14274 
14275 			  /* We need to relocate .opd contents for ld.so.
14276 			     Prelink also wants simple and consistent rules
14277 			     for relocs.  This make all RELATIVE relocs have
14278 			     *r_offset equal to r_addend.  */
14279 			  relocate = TRUE;
14280 			}
14281 		    }
14282 		  else
14283 		    {
14284 		      long indx = 0;
14285 
14286 		      if (h != NULL
14287 			  ? h->elf.type == STT_GNU_IFUNC
14288 			  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14289 			{
14290 			  info->callbacks->einfo
14291 			    (_("%P: %H: %s for indirect "
14292 			       "function `%T' unsupported\n"),
14293 			     input_bfd, input_section, rel->r_offset,
14294 			     ppc64_elf_howto_table[r_type]->name,
14295 			     sym_name);
14296 			  ret = FALSE;
14297 			}
14298 		      else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14299 			;
14300 		      else if (sec == NULL || sec->owner == NULL)
14301 			{
14302 			  bfd_set_error (bfd_error_bad_value);
14303 			  return FALSE;
14304 			}
14305 		      else
14306 			{
14307 			  asection *osec;
14308 
14309 			  osec = sec->output_section;
14310 			  indx = elf_section_data (osec)->dynindx;
14311 
14312 			  if (indx == 0)
14313 			    {
14314 			      if ((osec->flags & SEC_READONLY) == 0
14315 				  && htab->elf.data_index_section != NULL)
14316 				osec = htab->elf.data_index_section;
14317 			      else
14318 				osec = htab->elf.text_index_section;
14319 			      indx = elf_section_data (osec)->dynindx;
14320 			    }
14321 			  BFD_ASSERT (indx != 0);
14322 
14323 			  /* We are turning this relocation into one
14324 			     against a section symbol, so subtract out
14325 			     the output section's address but not the
14326 			     offset of the input section in the output
14327 			     section.  */
14328 			  outrel.r_addend -= osec->vma;
14329 			}
14330 
14331 		      outrel.r_info = ELF64_R_INFO (indx, r_type);
14332 		    }
14333 		}
14334 
14335 	      sreloc = elf_section_data (input_section)->sreloc;
14336 	      if (h != NULL
14337 		  ? h->elf.type == STT_GNU_IFUNC
14338 		  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14339 		sreloc = htab->elf.irelplt;
14340 	      if (sreloc == NULL)
14341 		abort ();
14342 
14343 	      if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14344 		  >= sreloc->size)
14345 		abort ();
14346 	      loc = sreloc->contents;
14347 	      loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14348 	      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14349 
14350 	      /* If this reloc is against an external symbol, it will
14351 		 be computed at runtime, so there's no need to do
14352 		 anything now.  However, for the sake of prelink ensure
14353 		 that the section contents are a known value.  */
14354 	      if (! relocate)
14355 		{
14356 		  unresolved_reloc = FALSE;
14357 		  /* The value chosen here is quite arbitrary as ld.so
14358 		     ignores section contents except for the special
14359 		     case of .opd where the contents might be accessed
14360 		     before relocation.  Choose zero, as that won't
14361 		     cause reloc overflow.  */
14362 		  relocation = 0;
14363 		  addend = 0;
14364 		  /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14365 		     to improve backward compatibility with older
14366 		     versions of ld.  */
14367 		  if (r_type == R_PPC64_ADDR64)
14368 		    addend = outrel.r_addend;
14369 		  /* Adjust pc_relative relocs to have zero in *r_offset.  */
14370 		  else if (ppc64_elf_howto_table[r_type]->pc_relative)
14371 		    addend = (input_section->output_section->vma
14372 			      + input_section->output_offset
14373 			      + rel->r_offset);
14374 		}
14375 	    }
14376 	  break;
14377 
14378 	case R_PPC64_COPY:
14379 	case R_PPC64_GLOB_DAT:
14380 	case R_PPC64_JMP_SLOT:
14381 	case R_PPC64_JMP_IREL:
14382 	case R_PPC64_RELATIVE:
14383 	  /* We shouldn't ever see these dynamic relocs in relocatable
14384 	     files.  */
14385 	  /* Fall through.  */
14386 
14387 	case R_PPC64_PLTGOT16:
14388 	case R_PPC64_PLTGOT16_DS:
14389 	case R_PPC64_PLTGOT16_HA:
14390 	case R_PPC64_PLTGOT16_HI:
14391 	case R_PPC64_PLTGOT16_LO:
14392 	case R_PPC64_PLTGOT16_LO_DS:
14393 	case R_PPC64_PLTREL32:
14394 	case R_PPC64_PLTREL64:
14395 	  /* These ones haven't been implemented yet.  */
14396 
14397 	  info->callbacks->einfo
14398 	    (_("%P: %B: %s is not supported for `%T'\n"),
14399 	     input_bfd,
14400 	     ppc64_elf_howto_table[r_type]->name, sym_name);
14401 
14402 	  bfd_set_error (bfd_error_invalid_operation);
14403 	  ret = FALSE;
14404 	  continue;
14405 	}
14406 
14407       /* Multi-instruction sequences that access the TOC can be
14408 	 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14409 	 to             nop;           addi rb,r2,x;  */
14410       switch (r_type)
14411 	{
14412 	default:
14413 	  break;
14414 
14415 	case R_PPC64_GOT_TLSLD16_HI:
14416 	case R_PPC64_GOT_TLSGD16_HI:
14417 	case R_PPC64_GOT_TPREL16_HI:
14418 	case R_PPC64_GOT_DTPREL16_HI:
14419 	case R_PPC64_GOT16_HI:
14420 	case R_PPC64_TOC16_HI:
14421 	  /* These relocs would only be useful if building up an
14422 	     offset to later add to r2, perhaps in an indexed
14423 	     addressing mode instruction.  Don't try to optimize.
14424 	     Unfortunately, the possibility of someone building up an
14425 	     offset like this or even with the HA relocs, means that
14426 	     we need to check the high insn when optimizing the low
14427 	     insn.  */
14428 	  break;
14429 
14430 	case R_PPC64_GOT_TLSLD16_HA:
14431 	case R_PPC64_GOT_TLSGD16_HA:
14432 	case R_PPC64_GOT_TPREL16_HA:
14433 	case R_PPC64_GOT_DTPREL16_HA:
14434 	case R_PPC64_GOT16_HA:
14435 	case R_PPC64_TOC16_HA:
14436 	  if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14437 	      && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14438 	    {
14439 	      bfd_byte *p = contents + (rel->r_offset & ~3);
14440 	      bfd_put_32 (input_bfd, NOP, p);
14441 	    }
14442 	  break;
14443 
14444 	case R_PPC64_GOT_TLSLD16_LO:
14445 	case R_PPC64_GOT_TLSGD16_LO:
14446 	case R_PPC64_GOT_TPREL16_LO_DS:
14447 	case R_PPC64_GOT_DTPREL16_LO_DS:
14448 	case R_PPC64_GOT16_LO:
14449 	case R_PPC64_GOT16_LO_DS:
14450 	case R_PPC64_TOC16_LO:
14451 	case R_PPC64_TOC16_LO_DS:
14452 	  if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14453 	      && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14454 	    {
14455 	      bfd_byte *p = contents + (rel->r_offset & ~3);
14456 	      insn = bfd_get_32 (input_bfd, p);
14457 	      if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14458 		{
14459 		  /* Transform addic to addi when we change reg.  */
14460 		  insn &= ~((0x3f << 26) | (0x1f << 16));
14461 		  insn |= (14u << 26) | (2 << 16);
14462 		}
14463 	      else
14464 		{
14465 		  insn &= ~(0x1f << 16);
14466 		  insn |= 2 << 16;
14467 		}
14468 	      bfd_put_32 (input_bfd, insn, p);
14469 	    }
14470 	  break;
14471 	}
14472 
14473       /* Do any further special processing.  */
14474       switch (r_type)
14475 	{
14476 	default:
14477 	  break;
14478 
14479 	case R_PPC64_REL16_HA:
14480 	case R_PPC64_ADDR16_HA:
14481 	case R_PPC64_ADDR16_HIGHA:
14482 	case R_PPC64_ADDR16_HIGHERA:
14483 	case R_PPC64_ADDR16_HIGHESTA:
14484 	case R_PPC64_TOC16_HA:
14485 	case R_PPC64_SECTOFF_HA:
14486 	case R_PPC64_TPREL16_HA:
14487 	case R_PPC64_TPREL16_HIGHA:
14488 	case R_PPC64_TPREL16_HIGHERA:
14489 	case R_PPC64_TPREL16_HIGHESTA:
14490 	case R_PPC64_DTPREL16_HA:
14491 	case R_PPC64_DTPREL16_HIGHA:
14492 	case R_PPC64_DTPREL16_HIGHERA:
14493 	case R_PPC64_DTPREL16_HIGHESTA:
14494 	  /* It's just possible that this symbol is a weak symbol
14495 	     that's not actually defined anywhere. In that case,
14496 	     'sec' would be NULL, and we should leave the symbol
14497 	     alone (it will be set to zero elsewhere in the link).  */
14498 	  if (sec == NULL)
14499 	    break;
14500 	  /* Fall thru */
14501 
14502 	case R_PPC64_GOT16_HA:
14503 	case R_PPC64_PLTGOT16_HA:
14504 	case R_PPC64_PLT16_HA:
14505 	case R_PPC64_GOT_TLSGD16_HA:
14506 	case R_PPC64_GOT_TLSLD16_HA:
14507 	case R_PPC64_GOT_TPREL16_HA:
14508 	case R_PPC64_GOT_DTPREL16_HA:
14509 	  /* Add 0x10000 if sign bit in 0:15 is set.
14510 	     Bits 0:15 are not used.  */
14511 	  addend += 0x8000;
14512 	  break;
14513 
14514 	case R_PPC64_ADDR16_DS:
14515 	case R_PPC64_ADDR16_LO_DS:
14516 	case R_PPC64_GOT16_DS:
14517 	case R_PPC64_GOT16_LO_DS:
14518 	case R_PPC64_PLT16_LO_DS:
14519 	case R_PPC64_SECTOFF_DS:
14520 	case R_PPC64_SECTOFF_LO_DS:
14521 	case R_PPC64_TOC16_DS:
14522 	case R_PPC64_TOC16_LO_DS:
14523 	case R_PPC64_PLTGOT16_DS:
14524 	case R_PPC64_PLTGOT16_LO_DS:
14525 	case R_PPC64_GOT_TPREL16_DS:
14526 	case R_PPC64_GOT_TPREL16_LO_DS:
14527 	case R_PPC64_GOT_DTPREL16_DS:
14528 	case R_PPC64_GOT_DTPREL16_LO_DS:
14529 	case R_PPC64_TPREL16_DS:
14530 	case R_PPC64_TPREL16_LO_DS:
14531 	case R_PPC64_DTPREL16_DS:
14532 	case R_PPC64_DTPREL16_LO_DS:
14533 	  insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14534 	  mask = 3;
14535 	  /* If this reloc is against an lq insn, then the value must be
14536 	     a multiple of 16.  This is somewhat of a hack, but the
14537 	     "correct" way to do this by defining _DQ forms of all the
14538 	     _DS relocs bloats all reloc switches in this file.  It
14539 	     doesn't seem to make much sense to use any of these relocs
14540 	     in data, so testing the insn should be safe.  */
14541 	  if ((insn & (0x3f << 26)) == (56u << 26))
14542 	    mask = 15;
14543 	  if (((relocation + addend) & mask) != 0)
14544 	    {
14545 	      info->callbacks->einfo
14546 		(_("%P: %H: error: %s not a multiple of %u\n"),
14547 		 input_bfd, input_section, rel->r_offset,
14548 		 ppc64_elf_howto_table[r_type]->name,
14549 		 mask + 1);
14550 	      bfd_set_error (bfd_error_bad_value);
14551 	      ret = FALSE;
14552 	      continue;
14553 	    }
14554 	  break;
14555 	}
14556 
14557       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14558 	 because such sections are not SEC_ALLOC and thus ld.so will
14559 	 not process them.  */
14560       if (unresolved_reloc
14561 	  && !((input_section->flags & SEC_DEBUGGING) != 0
14562 	       && h->elf.def_dynamic)
14563 	  && _bfd_elf_section_offset (output_bfd, info, input_section,
14564 				      rel->r_offset) != (bfd_vma) -1)
14565 	{
14566 	  info->callbacks->einfo
14567 	    (_("%P: %H: unresolvable %s against `%T'\n"),
14568 	     input_bfd, input_section, rel->r_offset,
14569 	     ppc64_elf_howto_table[(int) r_type]->name,
14570 	     h->elf.root.root.string);
14571 	  ret = FALSE;
14572 	}
14573 
14574       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14575 				    input_bfd,
14576 				    input_section,
14577 				    contents,
14578 				    rel->r_offset,
14579 				    relocation,
14580 				    addend);
14581 
14582       if (r != bfd_reloc_ok)
14583 	{
14584 	  char *more_info = NULL;
14585 	  const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14586 
14587 	  if (reloc_dest != DEST_NORMAL)
14588 	    {
14589 	      more_info = bfd_malloc (strlen (reloc_name) + 8);
14590 	      if (more_info != NULL)
14591 		{
14592 		  strcpy (more_info, reloc_name);
14593 		  strcat (more_info, (reloc_dest == DEST_OPD
14594 				      ? " (OPD)" : " (stub)"));
14595 		  reloc_name = more_info;
14596 		}
14597 	    }
14598 
14599 	  if (r == bfd_reloc_overflow)
14600 	    {
14601 	      if (warned)
14602 		continue;
14603 	      if (h != NULL
14604 		  && h->elf.root.type == bfd_link_hash_undefweak
14605 		  && ppc64_elf_howto_table[r_type]->pc_relative)
14606 		{
14607 		  /* Assume this is a call protected by other code that
14608 		     detects the symbol is undefined.  If this is the case,
14609 		     we can safely ignore the overflow.  If not, the
14610 		     program is hosed anyway, and a little warning isn't
14611 		     going to help.  */
14612 
14613 		  continue;
14614 		}
14615 
14616 	      if (!((*info->callbacks->reloc_overflow)
14617 		    (info, &h->elf.root, sym_name,
14618 		     reloc_name, orig_rel.r_addend,
14619 		     input_bfd, input_section, rel->r_offset)))
14620 		return FALSE;
14621 	    }
14622 	  else
14623 	    {
14624 	      info->callbacks->einfo
14625 		(_("%P: %H: %s against `%T': error %d\n"),
14626 		 input_bfd, input_section, rel->r_offset,
14627 		 reloc_name, sym_name, (int) r);
14628 	      ret = FALSE;
14629 	    }
14630 	  if (more_info != NULL)
14631 	    free (more_info);
14632 	}
14633     }
14634 
14635   /* If we're emitting relocations, then shortly after this function
14636      returns, reloc offsets and addends for this section will be
14637      adjusted.  Worse, reloc symbol indices will be for the output
14638      file rather than the input.  Save a copy of the relocs for
14639      opd_entry_value.  */
14640   if (is_opd && (info->emitrelocations || info->relocatable))
14641     {
14642       bfd_size_type amt;
14643       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14644       rel = bfd_alloc (input_bfd, amt);
14645       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14646       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14647       if (rel == NULL)
14648 	return FALSE;
14649       memcpy (rel, relocs, amt);
14650     }
14651   return ret;
14652 }
14653 
14654 /* Adjust the value of any local symbols in opd sections.  */
14655 
14656 static int
14657 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14658 			      const char *name ATTRIBUTE_UNUSED,
14659 			      Elf_Internal_Sym *elfsym,
14660 			      asection *input_sec,
14661 			      struct elf_link_hash_entry *h)
14662 {
14663   struct _opd_sec_data *opd;
14664   long adjust;
14665   bfd_vma value;
14666 
14667   if (h != NULL)
14668     return 1;
14669 
14670   opd = get_opd_info (input_sec);
14671   if (opd == NULL || opd->adjust == NULL)
14672     return 1;
14673 
14674   value = elfsym->st_value - input_sec->output_offset;
14675   if (!info->relocatable)
14676     value -= input_sec->output_section->vma;
14677 
14678   adjust = opd->adjust[value / 8];
14679   if (adjust == -1)
14680     return 2;
14681 
14682   elfsym->st_value += adjust;
14683   return 1;
14684 }
14685 
14686 /* Finish up dynamic symbol handling.  We set the contents of various
14687    dynamic sections here.  */
14688 
14689 static bfd_boolean
14690 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14691 				 struct bfd_link_info *info,
14692 				 struct elf_link_hash_entry *h,
14693 				 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14694 {
14695   struct ppc_link_hash_table *htab;
14696   struct plt_entry *ent;
14697   Elf_Internal_Rela rela;
14698   bfd_byte *loc;
14699 
14700   htab = ppc_hash_table (info);
14701   if (htab == NULL)
14702     return FALSE;
14703 
14704   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14705     if (ent->plt.offset != (bfd_vma) -1)
14706       {
14707 	/* This symbol has an entry in the procedure linkage
14708 	   table.  Set it up.  */
14709 	if (!htab->elf.dynamic_sections_created
14710 	    || h->dynindx == -1)
14711 	  {
14712 	    BFD_ASSERT (h->type == STT_GNU_IFUNC
14713 			&& h->def_regular
14714 			&& (h->root.type == bfd_link_hash_defined
14715 			    || h->root.type == bfd_link_hash_defweak));
14716 	    rela.r_offset = (htab->elf.iplt->output_section->vma
14717 			     + htab->elf.iplt->output_offset
14718 			     + ent->plt.offset);
14719 	    if (htab->opd_abi)
14720 	      rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14721 	    else
14722 	      rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14723 	    rela.r_addend = (h->root.u.def.value
14724 			     + h->root.u.def.section->output_offset
14725 			     + h->root.u.def.section->output_section->vma
14726 			     + ent->addend);
14727 	    loc = (htab->elf.irelplt->contents
14728 		   + (htab->elf.irelplt->reloc_count++
14729 		      * sizeof (Elf64_External_Rela)));
14730 	  }
14731 	else
14732 	  {
14733 	    rela.r_offset = (htab->elf.splt->output_section->vma
14734 			     + htab->elf.splt->output_offset
14735 			     + ent->plt.offset);
14736 	    rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14737 	    rela.r_addend = ent->addend;
14738 	    loc = (htab->elf.srelplt->contents
14739 		   + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14740 		      / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14741 	  }
14742 	bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14743 
14744 	if (!htab->opd_abi)
14745 	  {
14746 	    if (!h->def_regular)
14747 	      {
14748 		/* Mark the symbol as undefined, rather than as
14749 		   defined in glink.  Leave the value if there were
14750 		   any relocations where pointer equality matters
14751 		   (this is a clue for the dynamic linker, to make
14752 		   function pointer comparisons work between an
14753 		   application and shared library), otherwise set it
14754 		   to zero.  */
14755 		sym->st_shndx = SHN_UNDEF;
14756 		if (!h->pointer_equality_needed)
14757 		  sym->st_value = 0;
14758 		else if (!h->ref_regular_nonweak)
14759 		  {
14760 		    /* This breaks function pointer comparisons, but
14761 		       that is better than breaking tests for a NULL
14762 		       function pointer.  */
14763 		    sym->st_value = 0;
14764 		  }
14765 	      }
14766 	  }
14767       }
14768 
14769   if (h->needs_copy)
14770     {
14771       /* This symbol needs a copy reloc.  Set it up.  */
14772 
14773       if (h->dynindx == -1
14774 	  || (h->root.type != bfd_link_hash_defined
14775 	      && h->root.type != bfd_link_hash_defweak)
14776 	  || htab->relbss == NULL)
14777 	abort ();
14778 
14779       rela.r_offset = (h->root.u.def.value
14780 		       + h->root.u.def.section->output_section->vma
14781 		       + h->root.u.def.section->output_offset);
14782       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14783       rela.r_addend = 0;
14784       loc = htab->relbss->contents;
14785       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14786       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14787     }
14788 
14789   return TRUE;
14790 }
14791 
14792 /* Used to decide how to sort relocs in an optimal manner for the
14793    dynamic linker, before writing them out.  */
14794 
14795 static enum elf_reloc_type_class
14796 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14797 			    const asection *rel_sec,
14798 			    const Elf_Internal_Rela *rela)
14799 {
14800   enum elf_ppc64_reloc_type r_type;
14801   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14802 
14803   if (rel_sec == htab->elf.irelplt)
14804     return reloc_class_ifunc;
14805 
14806   r_type = ELF64_R_TYPE (rela->r_info);
14807   switch (r_type)
14808     {
14809     case R_PPC64_RELATIVE:
14810       return reloc_class_relative;
14811     case R_PPC64_JMP_SLOT:
14812       return reloc_class_plt;
14813     case R_PPC64_COPY:
14814       return reloc_class_copy;
14815     default:
14816       return reloc_class_normal;
14817     }
14818 }
14819 
14820 /* Finish up the dynamic sections.  */
14821 
14822 static bfd_boolean
14823 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14824 				   struct bfd_link_info *info)
14825 {
14826   struct ppc_link_hash_table *htab;
14827   bfd *dynobj;
14828   asection *sdyn;
14829 
14830   htab = ppc_hash_table (info);
14831   if (htab == NULL)
14832     return FALSE;
14833 
14834   dynobj = htab->elf.dynobj;
14835   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14836 
14837   if (htab->elf.dynamic_sections_created)
14838     {
14839       Elf64_External_Dyn *dyncon, *dynconend;
14840 
14841       if (sdyn == NULL || htab->elf.sgot == NULL)
14842 	abort ();
14843 
14844       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14845       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14846       for (; dyncon < dynconend; dyncon++)
14847 	{
14848 	  Elf_Internal_Dyn dyn;
14849 	  asection *s;
14850 
14851 	  bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14852 
14853 	  switch (dyn.d_tag)
14854 	    {
14855 	    default:
14856 	      continue;
14857 
14858 	    case DT_PPC64_GLINK:
14859 	      s = htab->glink;
14860 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14861 	      /* We stupidly defined DT_PPC64_GLINK to be the start
14862 		 of glink rather than the first entry point, which is
14863 		 what ld.so needs, and now have a bigger stub to
14864 		 support automatic multiple TOCs.  */
14865 	      dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14866 	      break;
14867 
14868 	    case DT_PPC64_OPD:
14869 	      s = bfd_get_section_by_name (output_bfd, ".opd");
14870 	      if (s == NULL)
14871 		continue;
14872 	      dyn.d_un.d_ptr = s->vma;
14873 	      break;
14874 
14875 	    case DT_PPC64_OPT:
14876 	      if (htab->do_multi_toc && htab->multi_toc_needed)
14877 		dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14878 	      break;
14879 
14880 	    case DT_PPC64_OPDSZ:
14881 	      s = bfd_get_section_by_name (output_bfd, ".opd");
14882 	      if (s == NULL)
14883 		continue;
14884 	      dyn.d_un.d_val = s->size;
14885 	      break;
14886 
14887 	    case DT_PLTGOT:
14888 	      s = htab->elf.splt;
14889 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14890 	      break;
14891 
14892 	    case DT_JMPREL:
14893 	      s = htab->elf.srelplt;
14894 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14895 	      break;
14896 
14897 	    case DT_PLTRELSZ:
14898 	      dyn.d_un.d_val = htab->elf.srelplt->size;
14899 	      break;
14900 
14901 	    case DT_RELASZ:
14902 	      /* Don't count procedure linkage table relocs in the
14903 		 overall reloc count.  */
14904 	      s = htab->elf.srelplt;
14905 	      if (s == NULL)
14906 		continue;
14907 	      dyn.d_un.d_val -= s->size;
14908 	      break;
14909 
14910 	    case DT_RELA:
14911 	      /* We may not be using the standard ELF linker script.
14912 		 If .rela.plt is the first .rela section, we adjust
14913 		 DT_RELA to not include it.  */
14914 	      s = htab->elf.srelplt;
14915 	      if (s == NULL)
14916 		continue;
14917 	      if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14918 		continue;
14919 	      dyn.d_un.d_ptr += s->size;
14920 	      break;
14921 	    }
14922 
14923 	  bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14924 	}
14925     }
14926 
14927   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14928     {
14929       /* Fill in the first entry in the global offset table.
14930 	 We use it to hold the link-time TOCbase.  */
14931       bfd_put_64 (output_bfd,
14932 		  elf_gp (output_bfd) + TOC_BASE_OFF,
14933 		  htab->elf.sgot->contents);
14934 
14935       /* Set .got entry size.  */
14936       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14937     }
14938 
14939   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14940     {
14941       /* Set .plt entry size.  */
14942       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14943 	= PLT_ENTRY_SIZE (htab);
14944     }
14945 
14946   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14947      brlt ourselves if emitrelocations.  */
14948   if (htab->brlt != NULL
14949       && htab->brlt->reloc_count != 0
14950       && !_bfd_elf_link_output_relocs (output_bfd,
14951 				       htab->brlt,
14952 				       elf_section_data (htab->brlt)->rela.hdr,
14953 				       elf_section_data (htab->brlt)->relocs,
14954 				       NULL))
14955     return FALSE;
14956 
14957   if (htab->glink != NULL
14958       && htab->glink->reloc_count != 0
14959       && !_bfd_elf_link_output_relocs (output_bfd,
14960 				       htab->glink,
14961 				       elf_section_data (htab->glink)->rela.hdr,
14962 				       elf_section_data (htab->glink)->relocs,
14963 				       NULL))
14964     return FALSE;
14965 
14966 
14967   if (htab->glink_eh_frame != NULL
14968       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14969       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14970 					   htab->glink_eh_frame,
14971 					   htab->glink_eh_frame->contents))
14972     return FALSE;
14973 
14974   /* We need to handle writing out multiple GOT sections ourselves,
14975      since we didn't add them to DYNOBJ.  We know dynobj is the first
14976      bfd.  */
14977   while ((dynobj = dynobj->link_next) != NULL)
14978     {
14979       asection *s;
14980 
14981       if (!is_ppc64_elf (dynobj))
14982 	continue;
14983 
14984       s = ppc64_elf_tdata (dynobj)->got;
14985       if (s != NULL
14986 	  && s->size != 0
14987 	  && s->output_section != bfd_abs_section_ptr
14988 	  && !bfd_set_section_contents (output_bfd, s->output_section,
14989 					s->contents, s->output_offset,
14990 					s->size))
14991 	return FALSE;
14992       s = ppc64_elf_tdata (dynobj)->relgot;
14993       if (s != NULL
14994 	  && s->size != 0
14995 	  && s->output_section != bfd_abs_section_ptr
14996 	  && !bfd_set_section_contents (output_bfd, s->output_section,
14997 					s->contents, s->output_offset,
14998 					s->size))
14999 	return FALSE;
15000     }
15001 
15002   return TRUE;
15003 }
15004 
15005 #include "elf64-target.h"
15006 
15007 /* FreeBSD support */
15008 
15009 #undef  TARGET_LITTLE_SYM
15010 #undef  TARGET_LITTLE_NAME
15011 
15012 #undef  TARGET_BIG_SYM
15013 #define TARGET_BIG_SYM	bfd_elf64_powerpc_freebsd_vec
15014 #undef  TARGET_BIG_NAME
15015 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15016 
15017 #undef  ELF_OSABI
15018 #define	ELF_OSABI       ELFOSABI_FREEBSD
15019 
15020 #undef  elf64_bed
15021 #define elf64_bed	elf64_powerpc_fbsd_bed
15022 
15023 #include "elf64-target.h"
15024 
15025