OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elf64-ppc.c] - Blame information for rev 179

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* PowerPC64-specific support for 64-bit ELF.
2
   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
3
   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 <amodra@bigpond.net.au>
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
 
38
static bfd_reloc_status_type ppc64_elf_ha_reloc
39
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40
static bfd_reloc_status_type ppc64_elf_branch_reloc
41
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42
static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44
static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46
static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48
static bfd_reloc_status_type ppc64_elf_toc_reloc
49
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50
static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52
static bfd_reloc_status_type ppc64_elf_toc64_reloc
53
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54
static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56
static bfd_vma opd_entry_value
57
  (asection *, bfd_vma, asection **, bfd_vma *);
58
 
59
#define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
60
#define TARGET_LITTLE_NAME      "elf64-powerpcle"
61
#define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
62
#define TARGET_BIG_NAME         "elf64-powerpc"
63
#define ELF_ARCH                bfd_arch_powerpc
64
#define ELF_MACHINE_CODE        EM_PPC64
65
#define ELF_MAXPAGESIZE         0x10000
66
#define ELF_COMMONPAGESIZE      0x1000
67
#define elf_info_to_howto       ppc64_elf_info_to_howto
68
 
69
#define elf_backend_want_got_sym 0
70
#define elf_backend_want_plt_sym 0
71
#define elf_backend_plt_alignment 3
72
#define elf_backend_plt_not_loaded 1
73
#define elf_backend_got_header_size 8
74
#define elf_backend_can_gc_sections 1
75
#define elf_backend_can_refcount 1
76
#define elf_backend_rela_normal 1
77
#define elf_backend_default_execstack 0
78
 
79
#define bfd_elf64_mkobject                    ppc64_elf_mkobject
80
#define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
81
#define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
82
#define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
83
#define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
84
#define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
85
#define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
86
#define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
87
 
88
#define elf_backend_object_p                  ppc64_elf_object_p
89
#define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
90
#define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
91
#define elf_backend_write_core_note           ppc64_elf_write_core_note
92
#define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
93
#define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
94
#define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
95
#define elf_backend_check_directives          ppc64_elf_check_directives
96
#define elf_backend_as_needed_cleanup         ppc64_elf_as_needed_cleanup
97
#define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
98
#define elf_backend_check_relocs              ppc64_elf_check_relocs
99
#define elf_backend_gc_keep                   ppc64_elf_gc_keep
100
#define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
101
#define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
102
#define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
103
#define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
104
#define elf_backend_hide_symbol               ppc64_elf_hide_symbol
105
#define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
106
#define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
107
#define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
108
#define elf_backend_action_discarded          ppc64_elf_action_discarded
109
#define elf_backend_relocate_section          ppc64_elf_relocate_section
110
#define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
111
#define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
112
#define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
113
#define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
114
#define elf_backend_special_sections          ppc64_elf_special_sections
115
 
116
/* The name of the dynamic interpreter.  This is put in the .interp
117
   section.  */
118
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
119
 
120
/* The size in bytes of an entry in the procedure linkage table.  */
121
#define PLT_ENTRY_SIZE 24
122
 
123
/* The initial size of the plt reserved for the dynamic linker.  */
124
#define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
125
 
126
/* TOC base pointers offset from start of TOC.  */
127
#define TOC_BASE_OFF    0x8000
128
 
129
/* Offset of tp and dtp pointers from start of TLS block.  */
130
#define TP_OFFSET       0x7000
131
#define DTP_OFFSET      0x8000
132
 
133
/* .plt call stub instructions.  The normal stub is like this, but
134
   sometimes the .plt entry crosses a 64k boundary and we need to
135
   insert an addi to adjust r12.  */
136
#define PLT_CALL_STUB_SIZE (7*4)
137
#define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
138
#define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
139
#define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
140
#define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
141
#define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
142
                                        /* ld    %r11,xxx+16@l(%r12) */
143
#define BCTR            0x4e800420      /* bctr                      */
144
 
145
 
146
#define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
147
#define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
148
#define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
149
#define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
150
 
151
#define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
152
#define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
153
 
154
#define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
155
 
156
/* glink call stub instructions.  We enter with the index in R0.  */
157
#define GLINK_CALL_STUB_SIZE (16*4)
158
                                        /* 0:                           */
159
                                        /*  .quad plt0-1f               */
160
                                        /* __glink:                     */
161
#define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
162
#define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
163
                                        /* 1:                           */
164
#define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
165
#define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
166
#define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
167
#define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
168
                                        /*  ld %11,0(%12)               */
169
                                        /*  ld %2,8(%12)                */
170
                                        /*  mtctr %11                   */
171
                                        /*  ld %11,16(%12)              */
172
                                        /*  bctr                        */
173
 
174
/* Pad with this.  */
175
#define NOP             0x60000000
176
 
177
/* Some other nops.  */
178
#define CROR_151515     0x4def7b82
179
#define CROR_313131     0x4ffffb82
180
 
181
/* .glink entries for the first 32k functions are two instructions.  */
182
#define LI_R0_0         0x38000000      /* li    %r0,0          */
183
#define B_DOT           0x48000000      /* b     .              */
184
 
185
/* After that, we need two instructions to load the index, followed by
186
   a branch.  */
187
#define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
188
#define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
189
 
190
/* Instructions used by the save and restore reg functions.  */
191
#define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
192
#define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
193
#define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
194
#define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
195
#define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
196
#define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
197
#define LI_R12_0        0x39800000      /* li    %r12,0         */
198
#define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
199
#define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
200
#define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
201
#define BLR             0x4e800020      /* blr                  */
202
 
203
/* Since .opd is an array of descriptors and each entry will end up
204
   with identical R_PPC64_RELATIVE relocs, there is really no need to
205
   propagate .opd relocs;  The dynamic linker should be taught to
206
   relocate .opd without reloc entries.  */
207
#ifndef NO_OPD_RELOCS
208
#define NO_OPD_RELOCS 0
209
#endif
210
 
211
#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
212
 
213
/* Relocation HOWTO's.  */
214
static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
215
 
216
static reloc_howto_type ppc64_elf_howto_raw[] = {
217
  /* This reloc does nothing.  */
218
  HOWTO (R_PPC64_NONE,          /* type */
219
         0,                      /* rightshift */
220
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
221
         32,                    /* bitsize */
222
         FALSE,                 /* pc_relative */
223
         0,                      /* bitpos */
224
         complain_overflow_dont, /* complain_on_overflow */
225
         bfd_elf_generic_reloc, /* special_function */
226
         "R_PPC64_NONE",        /* name */
227
         FALSE,                 /* partial_inplace */
228
         0,                      /* src_mask */
229
         0,                      /* dst_mask */
230
         FALSE),                /* pcrel_offset */
231
 
232
  /* A standard 32 bit relocation.  */
233
  HOWTO (R_PPC64_ADDR32,        /* type */
234
         0,                      /* rightshift */
235
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
236
         32,                    /* bitsize */
237
         FALSE,                 /* pc_relative */
238
         0,                      /* bitpos */
239
         complain_overflow_bitfield, /* complain_on_overflow */
240
         bfd_elf_generic_reloc, /* special_function */
241
         "R_PPC64_ADDR32",      /* name */
242
         FALSE,                 /* partial_inplace */
243
         0,                      /* src_mask */
244
         0xffffffff,            /* dst_mask */
245
         FALSE),                /* pcrel_offset */
246
 
247
  /* An absolute 26 bit branch; the lower two bits must be zero.
248
     FIXME: we don't check that, we just clear them.  */
249
  HOWTO (R_PPC64_ADDR24,        /* type */
250
         0,                      /* rightshift */
251
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
252
         26,                    /* bitsize */
253
         FALSE,                 /* pc_relative */
254
         0,                      /* bitpos */
255
         complain_overflow_bitfield, /* complain_on_overflow */
256
         bfd_elf_generic_reloc, /* special_function */
257
         "R_PPC64_ADDR24",      /* name */
258
         FALSE,                 /* partial_inplace */
259
         0,                      /* src_mask */
260
         0x03fffffc,            /* dst_mask */
261
         FALSE),                /* pcrel_offset */
262
 
263
  /* A standard 16 bit relocation.  */
264
  HOWTO (R_PPC64_ADDR16,        /* type */
265
         0,                      /* rightshift */
266
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
267
         16,                    /* bitsize */
268
         FALSE,                 /* pc_relative */
269
         0,                      /* bitpos */
270
         complain_overflow_bitfield, /* complain_on_overflow */
271
         bfd_elf_generic_reloc, /* special_function */
272
         "R_PPC64_ADDR16",      /* name */
273
         FALSE,                 /* partial_inplace */
274
         0,                      /* src_mask */
275
         0xffff,                /* dst_mask */
276
         FALSE),                /* pcrel_offset */
277
 
278
  /* A 16 bit relocation without overflow.  */
279
  HOWTO (R_PPC64_ADDR16_LO,     /* type */
280
         0,                      /* rightshift */
281
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
282
         16,                    /* bitsize */
283
         FALSE,                 /* pc_relative */
284
         0,                      /* bitpos */
285
         complain_overflow_dont,/* complain_on_overflow */
286
         bfd_elf_generic_reloc, /* special_function */
287
         "R_PPC64_ADDR16_LO",   /* name */
288
         FALSE,                 /* partial_inplace */
289
         0,                      /* src_mask */
290
         0xffff,                /* dst_mask */
291
         FALSE),                /* pcrel_offset */
292
 
293
  /* Bits 16-31 of an address.  */
294
  HOWTO (R_PPC64_ADDR16_HI,     /* type */
295
         16,                    /* rightshift */
296
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
297
         16,                    /* bitsize */
298
         FALSE,                 /* pc_relative */
299
         0,                      /* bitpos */
300
         complain_overflow_dont, /* complain_on_overflow */
301
         bfd_elf_generic_reloc, /* special_function */
302
         "R_PPC64_ADDR16_HI",   /* name */
303
         FALSE,                 /* partial_inplace */
304
         0,                      /* src_mask */
305
         0xffff,                /* dst_mask */
306
         FALSE),                /* pcrel_offset */
307
 
308
  /* Bits 16-31 of an address, plus 1 if the contents of the low 16
309
     bits, treated as a signed number, is negative.  */
310
  HOWTO (R_PPC64_ADDR16_HA,     /* type */
311
         16,                    /* rightshift */
312
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
313
         16,                    /* bitsize */
314
         FALSE,                 /* pc_relative */
315
         0,                      /* bitpos */
316
         complain_overflow_dont, /* complain_on_overflow */
317
         ppc64_elf_ha_reloc,    /* special_function */
318
         "R_PPC64_ADDR16_HA",   /* name */
319
         FALSE,                 /* partial_inplace */
320
         0,                      /* src_mask */
321
         0xffff,                /* dst_mask */
322
         FALSE),                /* pcrel_offset */
323
 
324
  /* An absolute 16 bit branch; the lower two bits must be zero.
325
     FIXME: we don't check that, we just clear them.  */
326
  HOWTO (R_PPC64_ADDR14,        /* type */
327
         0,                      /* rightshift */
328
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
329
         16,                    /* bitsize */
330
         FALSE,                 /* pc_relative */
331
         0,                      /* bitpos */
332
         complain_overflow_bitfield, /* complain_on_overflow */
333
         ppc64_elf_branch_reloc, /* special_function */
334
         "R_PPC64_ADDR14",      /* name */
335
         FALSE,                 /* partial_inplace */
336
         0,                      /* src_mask */
337
         0x0000fffc,            /* dst_mask */
338
         FALSE),                /* pcrel_offset */
339
 
340
  /* An absolute 16 bit branch, for which bit 10 should be set to
341
     indicate that the branch is expected to be taken.  The lower two
342
     bits must be zero.  */
343
  HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
344
         0,                      /* rightshift */
345
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
346
         16,                    /* bitsize */
347
         FALSE,                 /* pc_relative */
348
         0,                      /* bitpos */
349
         complain_overflow_bitfield, /* complain_on_overflow */
350
         ppc64_elf_brtaken_reloc, /* special_function */
351
         "R_PPC64_ADDR14_BRTAKEN",/* name */
352
         FALSE,                 /* partial_inplace */
353
         0,                      /* src_mask */
354
         0x0000fffc,            /* dst_mask */
355
         FALSE),                /* pcrel_offset */
356
 
357
  /* An absolute 16 bit branch, for which bit 10 should be set to
358
     indicate that the branch is not expected to be taken.  The lower
359
     two bits must be zero.  */
360
  HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
361
         0,                      /* rightshift */
362
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
363
         16,                    /* bitsize */
364
         FALSE,                 /* pc_relative */
365
         0,                      /* bitpos */
366
         complain_overflow_bitfield, /* complain_on_overflow */
367
         ppc64_elf_brtaken_reloc, /* special_function */
368
         "R_PPC64_ADDR14_BRNTAKEN",/* name */
369
         FALSE,                 /* partial_inplace */
370
         0,                      /* src_mask */
371
         0x0000fffc,            /* dst_mask */
372
         FALSE),                /* pcrel_offset */
373
 
374
  /* A relative 26 bit branch; the lower two bits must be zero.  */
375
  HOWTO (R_PPC64_REL24,         /* type */
376
         0,                      /* rightshift */
377
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
378
         26,                    /* bitsize */
379
         TRUE,                  /* pc_relative */
380
         0,                      /* bitpos */
381
         complain_overflow_signed, /* complain_on_overflow */
382
         ppc64_elf_branch_reloc, /* special_function */
383
         "R_PPC64_REL24",       /* name */
384
         FALSE,                 /* partial_inplace */
385
         0,                      /* src_mask */
386
         0x03fffffc,            /* dst_mask */
387
         TRUE),                 /* pcrel_offset */
388
 
389
  /* A relative 16 bit branch; the lower two bits must be zero.  */
390
  HOWTO (R_PPC64_REL14,         /* type */
391
         0,                      /* rightshift */
392
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
393
         16,                    /* bitsize */
394
         TRUE,                  /* pc_relative */
395
         0,                      /* bitpos */
396
         complain_overflow_signed, /* complain_on_overflow */
397
         ppc64_elf_branch_reloc, /* special_function */
398
         "R_PPC64_REL14",       /* name */
399
         FALSE,                 /* partial_inplace */
400
         0,                      /* src_mask */
401
         0x0000fffc,            /* dst_mask */
402
         TRUE),                 /* pcrel_offset */
403
 
404
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
405
     the branch is expected to be taken.  The lower two bits must be
406
     zero.  */
407
  HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
408
         0,                      /* rightshift */
409
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
410
         16,                    /* bitsize */
411
         TRUE,                  /* pc_relative */
412
         0,                      /* bitpos */
413
         complain_overflow_signed, /* complain_on_overflow */
414
         ppc64_elf_brtaken_reloc, /* special_function */
415
         "R_PPC64_REL14_BRTAKEN", /* name */
416
         FALSE,                 /* partial_inplace */
417
         0,                      /* src_mask */
418
         0x0000fffc,            /* dst_mask */
419
         TRUE),                 /* pcrel_offset */
420
 
421
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
422
     the branch is not expected to be taken.  The lower two bits must
423
     be zero.  */
424
  HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
425
         0,                      /* rightshift */
426
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
427
         16,                    /* bitsize */
428
         TRUE,                  /* pc_relative */
429
         0,                      /* bitpos */
430
         complain_overflow_signed, /* complain_on_overflow */
431
         ppc64_elf_brtaken_reloc, /* special_function */
432
         "R_PPC64_REL14_BRNTAKEN",/* name */
433
         FALSE,                 /* partial_inplace */
434
         0,                      /* src_mask */
435
         0x0000fffc,            /* dst_mask */
436
         TRUE),                 /* pcrel_offset */
437
 
438
  /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
439
     symbol.  */
440
  HOWTO (R_PPC64_GOT16,         /* type */
441
         0,                      /* rightshift */
442
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
443
         16,                    /* bitsize */
444
         FALSE,                 /* pc_relative */
445
         0,                      /* bitpos */
446
         complain_overflow_signed, /* complain_on_overflow */
447
         ppc64_elf_unhandled_reloc, /* special_function */
448
         "R_PPC64_GOT16",       /* name */
449
         FALSE,                 /* partial_inplace */
450
         0,                      /* src_mask */
451
         0xffff,                /* dst_mask */
452
         FALSE),                /* pcrel_offset */
453
 
454
  /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
455
     the symbol.  */
456
  HOWTO (R_PPC64_GOT16_LO,      /* type */
457
         0,                      /* rightshift */
458
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
459
         16,                    /* bitsize */
460
         FALSE,                 /* pc_relative */
461
         0,                      /* bitpos */
462
         complain_overflow_dont, /* complain_on_overflow */
463
         ppc64_elf_unhandled_reloc, /* special_function */
464
         "R_PPC64_GOT16_LO",    /* name */
465
         FALSE,                 /* partial_inplace */
466
         0,                      /* src_mask */
467
         0xffff,                /* dst_mask */
468
         FALSE),                /* pcrel_offset */
469
 
470
  /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
471
     the symbol.  */
472
  HOWTO (R_PPC64_GOT16_HI,      /* type */
473
         16,                    /* rightshift */
474
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
475
         16,                    /* bitsize */
476
         FALSE,                 /* pc_relative */
477
         0,                      /* bitpos */
478
         complain_overflow_dont,/* complain_on_overflow */
479
         ppc64_elf_unhandled_reloc, /* special_function */
480
         "R_PPC64_GOT16_HI",    /* name */
481
         FALSE,                 /* partial_inplace */
482
         0,                      /* src_mask */
483
         0xffff,                /* dst_mask */
484
         FALSE),                /* pcrel_offset */
485
 
486
  /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
487
     the symbol.  */
488
  HOWTO (R_PPC64_GOT16_HA,      /* type */
489
         16,                    /* rightshift */
490
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
491
         16,                    /* bitsize */
492
         FALSE,                 /* pc_relative */
493
         0,                      /* bitpos */
494
         complain_overflow_dont,/* complain_on_overflow */
495
         ppc64_elf_unhandled_reloc, /* special_function */
496
         "R_PPC64_GOT16_HA",    /* name */
497
         FALSE,                 /* partial_inplace */
498
         0,                      /* src_mask */
499
         0xffff,                /* dst_mask */
500
         FALSE),                /* pcrel_offset */
501
 
502
  /* This is used only by the dynamic linker.  The symbol should exist
503
     both in the object being run and in some shared library.  The
504
     dynamic linker copies the data addressed by the symbol from the
505
     shared library into the object, because the object being
506
     run has to have the data at some particular address.  */
507
  HOWTO (R_PPC64_COPY,          /* type */
508
         0,                      /* rightshift */
509
         0,                      /* this one is variable size */
510
         0,                      /* bitsize */
511
         FALSE,                 /* pc_relative */
512
         0,                      /* bitpos */
513
         complain_overflow_dont, /* complain_on_overflow */
514
         ppc64_elf_unhandled_reloc, /* special_function */
515
         "R_PPC64_COPY",        /* name */
516
         FALSE,                 /* partial_inplace */
517
         0,                      /* src_mask */
518
         0,                      /* dst_mask */
519
         FALSE),                /* pcrel_offset */
520
 
521
  /* Like R_PPC64_ADDR64, but used when setting global offset table
522
     entries.  */
523
  HOWTO (R_PPC64_GLOB_DAT,      /* type */
524
         0,                      /* rightshift */
525
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
526
         64,                    /* bitsize */
527
         FALSE,                 /* pc_relative */
528
         0,                      /* bitpos */
529
         complain_overflow_dont, /* complain_on_overflow */
530
         ppc64_elf_unhandled_reloc,  /* special_function */
531
         "R_PPC64_GLOB_DAT",    /* name */
532
         FALSE,                 /* partial_inplace */
533
         0,                      /* src_mask */
534
         ONES (64),             /* dst_mask */
535
         FALSE),                /* pcrel_offset */
536
 
537
  /* Created by the link editor.  Marks a procedure linkage table
538
     entry for a symbol.  */
539
  HOWTO (R_PPC64_JMP_SLOT,      /* type */
540
         0,                      /* rightshift */
541
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
542
         0,                      /* bitsize */
543
         FALSE,                 /* pc_relative */
544
         0,                      /* bitpos */
545
         complain_overflow_dont, /* complain_on_overflow */
546
         ppc64_elf_unhandled_reloc, /* special_function */
547
         "R_PPC64_JMP_SLOT",    /* name */
548
         FALSE,                 /* partial_inplace */
549
         0,                      /* src_mask */
550
         0,                      /* dst_mask */
551
         FALSE),                /* pcrel_offset */
552
 
553
  /* Used only by the dynamic linker.  When the object is run, this
554
     doubleword64 is set to the load address of the object, plus the
555
     addend.  */
556
  HOWTO (R_PPC64_RELATIVE,      /* type */
557
         0,                      /* rightshift */
558
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
559
         64,                    /* bitsize */
560
         FALSE,                 /* pc_relative */
561
         0,                      /* bitpos */
562
         complain_overflow_dont, /* complain_on_overflow */
563
         bfd_elf_generic_reloc, /* special_function */
564
         "R_PPC64_RELATIVE",    /* name */
565
         FALSE,                 /* partial_inplace */
566
         0,                      /* src_mask */
567
         ONES (64),             /* dst_mask */
568
         FALSE),                /* pcrel_offset */
569
 
570
  /* Like R_PPC64_ADDR32, but may be unaligned.  */
571
  HOWTO (R_PPC64_UADDR32,       /* type */
572
         0,                      /* rightshift */
573
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
574
         32,                    /* bitsize */
575
         FALSE,                 /* pc_relative */
576
         0,                      /* bitpos */
577
         complain_overflow_bitfield, /* complain_on_overflow */
578
         bfd_elf_generic_reloc, /* special_function */
579
         "R_PPC64_UADDR32",     /* name */
580
         FALSE,                 /* partial_inplace */
581
         0,                      /* src_mask */
582
         0xffffffff,            /* dst_mask */
583
         FALSE),                /* pcrel_offset */
584
 
585
  /* Like R_PPC64_ADDR16, but may be unaligned.  */
586
  HOWTO (R_PPC64_UADDR16,       /* type */
587
         0,                      /* rightshift */
588
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
589
         16,                    /* bitsize */
590
         FALSE,                 /* pc_relative */
591
         0,                      /* bitpos */
592
         complain_overflow_bitfield, /* complain_on_overflow */
593
         bfd_elf_generic_reloc, /* special_function */
594
         "R_PPC64_UADDR16",     /* name */
595
         FALSE,                 /* partial_inplace */
596
         0,                      /* src_mask */
597
         0xffff,                /* dst_mask */
598
         FALSE),                /* pcrel_offset */
599
 
600
  /* 32-bit PC relative.  */
601
  HOWTO (R_PPC64_REL32,         /* type */
602
         0,                      /* rightshift */
603
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
604
         32,                    /* bitsize */
605
         TRUE,                  /* pc_relative */
606
         0,                      /* bitpos */
607
         /* FIXME: Verify.  Was complain_overflow_bitfield.  */
608
         complain_overflow_signed, /* complain_on_overflow */
609
         bfd_elf_generic_reloc, /* special_function */
610
         "R_PPC64_REL32",       /* name */
611
         FALSE,                 /* partial_inplace */
612
         0,                      /* src_mask */
613
         0xffffffff,            /* dst_mask */
614
         TRUE),                 /* pcrel_offset */
615
 
616
  /* 32-bit relocation to the symbol's procedure linkage table.  */
617
  HOWTO (R_PPC64_PLT32,         /* type */
618
         0,                      /* rightshift */
619
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
620
         32,                    /* bitsize */
621
         FALSE,                 /* pc_relative */
622
         0,                      /* bitpos */
623
         complain_overflow_bitfield, /* complain_on_overflow */
624
         ppc64_elf_unhandled_reloc, /* special_function */
625
         "R_PPC64_PLT32",       /* name */
626
         FALSE,                 /* partial_inplace */
627
         0,                      /* src_mask */
628
         0xffffffff,            /* dst_mask */
629
         FALSE),                /* pcrel_offset */
630
 
631
  /* 32-bit PC relative relocation to the symbol's procedure linkage table.
632
     FIXME: R_PPC64_PLTREL32 not supported.  */
633
  HOWTO (R_PPC64_PLTREL32,      /* type */
634
         0,                      /* rightshift */
635
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
636
         32,                    /* bitsize */
637
         TRUE,                  /* pc_relative */
638
         0,                      /* bitpos */
639
         complain_overflow_signed, /* complain_on_overflow */
640
         bfd_elf_generic_reloc, /* special_function */
641
         "R_PPC64_PLTREL32",    /* name */
642
         FALSE,                 /* partial_inplace */
643
         0,                      /* src_mask */
644
         0xffffffff,            /* dst_mask */
645
         TRUE),                 /* pcrel_offset */
646
 
647
  /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
648
     the symbol.  */
649
  HOWTO (R_PPC64_PLT16_LO,      /* type */
650
         0,                      /* rightshift */
651
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
652
         16,                    /* bitsize */
653
         FALSE,                 /* pc_relative */
654
         0,                      /* bitpos */
655
         complain_overflow_dont, /* complain_on_overflow */
656
         ppc64_elf_unhandled_reloc, /* special_function */
657
         "R_PPC64_PLT16_LO",    /* name */
658
         FALSE,                 /* partial_inplace */
659
         0,                      /* src_mask */
660
         0xffff,                /* dst_mask */
661
         FALSE),                /* pcrel_offset */
662
 
663
  /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
664
     the symbol.  */
665
  HOWTO (R_PPC64_PLT16_HI,      /* type */
666
         16,                    /* rightshift */
667
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
668
         16,                    /* bitsize */
669
         FALSE,                 /* pc_relative */
670
         0,                      /* bitpos */
671
         complain_overflow_dont, /* complain_on_overflow */
672
         ppc64_elf_unhandled_reloc, /* special_function */
673
         "R_PPC64_PLT16_HI",    /* name */
674
         FALSE,                 /* partial_inplace */
675
         0,                      /* src_mask */
676
         0xffff,                /* dst_mask */
677
         FALSE),                /* pcrel_offset */
678
 
679
  /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
680
     the symbol.  */
681
  HOWTO (R_PPC64_PLT16_HA,      /* type */
682
         16,                    /* rightshift */
683
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
684
         16,                    /* bitsize */
685
         FALSE,                 /* pc_relative */
686
         0,                      /* bitpos */
687
         complain_overflow_dont, /* complain_on_overflow */
688
         ppc64_elf_unhandled_reloc, /* special_function */
689
         "R_PPC64_PLT16_HA",    /* name */
690
         FALSE,                 /* partial_inplace */
691
         0,                      /* src_mask */
692
         0xffff,                /* dst_mask */
693
         FALSE),                /* pcrel_offset */
694
 
695
  /* 16-bit section relative relocation.  */
696
  HOWTO (R_PPC64_SECTOFF,       /* type */
697
         0,                      /* rightshift */
698
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
699
         16,                    /* bitsize */
700
         FALSE,                 /* pc_relative */
701
         0,                      /* bitpos */
702
         complain_overflow_bitfield, /* complain_on_overflow */
703
         ppc64_elf_sectoff_reloc, /* special_function */
704
         "R_PPC64_SECTOFF",     /* name */
705
         FALSE,                 /* partial_inplace */
706
         0,                      /* src_mask */
707
         0xffff,                /* dst_mask */
708
         FALSE),                /* pcrel_offset */
709
 
710
  /* Like R_PPC64_SECTOFF, but no overflow warning.  */
711
  HOWTO (R_PPC64_SECTOFF_LO,    /* type */
712
         0,                      /* rightshift */
713
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
714
         16,                    /* bitsize */
715
         FALSE,                 /* pc_relative */
716
         0,                      /* bitpos */
717
         complain_overflow_dont, /* complain_on_overflow */
718
         ppc64_elf_sectoff_reloc, /* special_function */
719
         "R_PPC64_SECTOFF_LO",  /* name */
720
         FALSE,                 /* partial_inplace */
721
         0,                      /* src_mask */
722
         0xffff,                /* dst_mask */
723
         FALSE),                /* pcrel_offset */
724
 
725
  /* 16-bit upper half section relative relocation.  */
726
  HOWTO (R_PPC64_SECTOFF_HI,    /* type */
727
         16,                    /* rightshift */
728
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
729
         16,                    /* bitsize */
730
         FALSE,                 /* pc_relative */
731
         0,                      /* bitpos */
732
         complain_overflow_dont, /* complain_on_overflow */
733
         ppc64_elf_sectoff_reloc, /* special_function */
734
         "R_PPC64_SECTOFF_HI",  /* name */
735
         FALSE,                 /* partial_inplace */
736
         0,                      /* src_mask */
737
         0xffff,                /* dst_mask */
738
         FALSE),                /* pcrel_offset */
739
 
740
  /* 16-bit upper half adjusted section relative relocation.  */
741
  HOWTO (R_PPC64_SECTOFF_HA,    /* type */
742
         16,                    /* rightshift */
743
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
744
         16,                    /* bitsize */
745
         FALSE,                 /* pc_relative */
746
         0,                      /* bitpos */
747
         complain_overflow_dont, /* complain_on_overflow */
748
         ppc64_elf_sectoff_ha_reloc, /* special_function */
749
         "R_PPC64_SECTOFF_HA",  /* name */
750
         FALSE,                 /* partial_inplace */
751
         0,                      /* src_mask */
752
         0xffff,                /* dst_mask */
753
         FALSE),                /* pcrel_offset */
754
 
755
  /* Like R_PPC64_REL24 without touching the two least significant bits.  */
756
  HOWTO (R_PPC64_REL30,         /* type */
757
         2,                     /* rightshift */
758
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
759
         30,                    /* bitsize */
760
         TRUE,                  /* pc_relative */
761
         0,                      /* bitpos */
762
         complain_overflow_dont, /* complain_on_overflow */
763
         bfd_elf_generic_reloc, /* special_function */
764
         "R_PPC64_REL30",       /* name */
765
         FALSE,                 /* partial_inplace */
766
         0,                      /* src_mask */
767
         0xfffffffc,            /* dst_mask */
768
         TRUE),                 /* pcrel_offset */
769
 
770
  /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
771
 
772
  /* A standard 64-bit relocation.  */
773
  HOWTO (R_PPC64_ADDR64,        /* type */
774
         0,                      /* rightshift */
775
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
776
         64,                    /* bitsize */
777
         FALSE,                 /* pc_relative */
778
         0,                      /* bitpos */
779
         complain_overflow_dont, /* complain_on_overflow */
780
         bfd_elf_generic_reloc, /* special_function */
781
         "R_PPC64_ADDR64",      /* name */
782
         FALSE,                 /* partial_inplace */
783
         0,                      /* src_mask */
784
         ONES (64),             /* dst_mask */
785
         FALSE),                /* pcrel_offset */
786
 
787
  /* The bits 32-47 of an address.  */
788
  HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
789
         32,                    /* rightshift */
790
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
791
         16,                    /* bitsize */
792
         FALSE,                 /* pc_relative */
793
         0,                      /* bitpos */
794
         complain_overflow_dont, /* complain_on_overflow */
795
         bfd_elf_generic_reloc, /* special_function */
796
         "R_PPC64_ADDR16_HIGHER", /* name */
797
         FALSE,                 /* partial_inplace */
798
         0,                      /* src_mask */
799
         0xffff,                /* dst_mask */
800
         FALSE),                /* pcrel_offset */
801
 
802
  /* The bits 32-47 of an address, plus 1 if the contents of the low
803
     16 bits, treated as a signed number, is negative.  */
804
  HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
805
         32,                    /* rightshift */
806
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
807
         16,                    /* bitsize */
808
         FALSE,                 /* pc_relative */
809
         0,                      /* bitpos */
810
         complain_overflow_dont, /* complain_on_overflow */
811
         ppc64_elf_ha_reloc,    /* special_function */
812
         "R_PPC64_ADDR16_HIGHERA", /* name */
813
         FALSE,                 /* partial_inplace */
814
         0,                      /* src_mask */
815
         0xffff,                /* dst_mask */
816
         FALSE),                /* pcrel_offset */
817
 
818
  /* The bits 48-63 of an address.  */
819
  HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
820
         48,                    /* rightshift */
821
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
822
         16,                    /* bitsize */
823
         FALSE,                 /* pc_relative */
824
         0,                      /* bitpos */
825
         complain_overflow_dont, /* complain_on_overflow */
826
         bfd_elf_generic_reloc, /* special_function */
827
         "R_PPC64_ADDR16_HIGHEST", /* name */
828
         FALSE,                 /* partial_inplace */
829
         0,                      /* src_mask */
830
         0xffff,                /* dst_mask */
831
         FALSE),                /* pcrel_offset */
832
 
833
  /* The bits 48-63 of an address, plus 1 if the contents of the low
834
     16 bits, treated as a signed number, is negative.  */
835
  HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
836
         48,                    /* rightshift */
837
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
838
         16,                    /* bitsize */
839
         FALSE,                 /* pc_relative */
840
         0,                      /* bitpos */
841
         complain_overflow_dont, /* complain_on_overflow */
842
         ppc64_elf_ha_reloc,    /* special_function */
843
         "R_PPC64_ADDR16_HIGHESTA", /* name */
844
         FALSE,                 /* partial_inplace */
845
         0,                      /* src_mask */
846
         0xffff,                /* dst_mask */
847
         FALSE),                /* pcrel_offset */
848
 
849
  /* Like ADDR64, but may be unaligned.  */
850
  HOWTO (R_PPC64_UADDR64,       /* type */
851
         0,                      /* rightshift */
852
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
853
         64,                    /* bitsize */
854
         FALSE,                 /* pc_relative */
855
         0,                      /* bitpos */
856
         complain_overflow_dont, /* complain_on_overflow */
857
         bfd_elf_generic_reloc, /* special_function */
858
         "R_PPC64_UADDR64",     /* name */
859
         FALSE,                 /* partial_inplace */
860
         0,                      /* src_mask */
861
         ONES (64),             /* dst_mask */
862
         FALSE),                /* pcrel_offset */
863
 
864
  /* 64-bit relative relocation.  */
865
  HOWTO (R_PPC64_REL64,         /* type */
866
         0,                      /* rightshift */
867
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
868
         64,                    /* bitsize */
869
         TRUE,                  /* pc_relative */
870
         0,                      /* bitpos */
871
         complain_overflow_dont, /* complain_on_overflow */
872
         bfd_elf_generic_reloc, /* special_function */
873
         "R_PPC64_REL64",       /* name */
874
         FALSE,                 /* partial_inplace */
875
         0,                      /* src_mask */
876
         ONES (64),             /* dst_mask */
877
         TRUE),                 /* pcrel_offset */
878
 
879
  /* 64-bit relocation to the symbol's procedure linkage table.  */
880
  HOWTO (R_PPC64_PLT64,         /* type */
881
         0,                      /* rightshift */
882
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
883
         64,                    /* bitsize */
884
         FALSE,                 /* pc_relative */
885
         0,                      /* bitpos */
886
         complain_overflow_dont, /* complain_on_overflow */
887
         ppc64_elf_unhandled_reloc, /* special_function */
888
         "R_PPC64_PLT64",       /* name */
889
         FALSE,                 /* partial_inplace */
890
         0,                      /* src_mask */
891
         ONES (64),             /* dst_mask */
892
         FALSE),                /* pcrel_offset */
893
 
894
  /* 64-bit PC relative relocation to the symbol's procedure linkage
895
     table.  */
896
  /* FIXME: R_PPC64_PLTREL64 not supported.  */
897
  HOWTO (R_PPC64_PLTREL64,      /* type */
898
         0,                      /* rightshift */
899
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
900
         64,                    /* bitsize */
901
         TRUE,                  /* pc_relative */
902
         0,                      /* bitpos */
903
         complain_overflow_dont, /* complain_on_overflow */
904
         ppc64_elf_unhandled_reloc, /* special_function */
905
         "R_PPC64_PLTREL64",    /* name */
906
         FALSE,                 /* partial_inplace */
907
         0,                      /* src_mask */
908
         ONES (64),             /* dst_mask */
909
         TRUE),                 /* pcrel_offset */
910
 
911
  /* 16 bit TOC-relative relocation.  */
912
 
913
  /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
914
  HOWTO (R_PPC64_TOC16,         /* type */
915
         0,                      /* rightshift */
916
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
917
         16,                    /* bitsize */
918
         FALSE,                 /* pc_relative */
919
         0,                      /* bitpos */
920
         complain_overflow_signed, /* complain_on_overflow */
921
         ppc64_elf_toc_reloc,   /* special_function */
922
         "R_PPC64_TOC16",       /* name */
923
         FALSE,                 /* partial_inplace */
924
         0,                      /* src_mask */
925
         0xffff,                /* dst_mask */
926
         FALSE),                /* pcrel_offset */
927
 
928
  /* 16 bit TOC-relative relocation without overflow.  */
929
 
930
  /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
931
  HOWTO (R_PPC64_TOC16_LO,      /* type */
932
         0,                      /* rightshift */
933
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
934
         16,                    /* bitsize */
935
         FALSE,                 /* pc_relative */
936
         0,                      /* bitpos */
937
         complain_overflow_dont, /* complain_on_overflow */
938
         ppc64_elf_toc_reloc,   /* special_function */
939
         "R_PPC64_TOC16_LO",    /* name */
940
         FALSE,                 /* partial_inplace */
941
         0,                      /* src_mask */
942
         0xffff,                /* dst_mask */
943
         FALSE),                /* pcrel_offset */
944
 
945
  /* 16 bit TOC-relative relocation, high 16 bits.  */
946
 
947
  /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
948
  HOWTO (R_PPC64_TOC16_HI,      /* type */
949
         16,                    /* rightshift */
950
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
951
         16,                    /* bitsize */
952
         FALSE,                 /* pc_relative */
953
         0,                      /* bitpos */
954
         complain_overflow_dont, /* complain_on_overflow */
955
         ppc64_elf_toc_reloc,   /* special_function */
956
         "R_PPC64_TOC16_HI",    /* name */
957
         FALSE,                 /* partial_inplace */
958
         0,                      /* src_mask */
959
         0xffff,                /* dst_mask */
960
         FALSE),                /* pcrel_offset */
961
 
962
  /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
963
     contents of the low 16 bits, treated as a signed number, is
964
     negative.  */
965
 
966
  /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
967
  HOWTO (R_PPC64_TOC16_HA,      /* type */
968
         16,                    /* rightshift */
969
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
970
         16,                    /* bitsize */
971
         FALSE,                 /* pc_relative */
972
         0,                      /* bitpos */
973
         complain_overflow_dont, /* complain_on_overflow */
974
         ppc64_elf_toc_ha_reloc, /* special_function */
975
         "R_PPC64_TOC16_HA",    /* name */
976
         FALSE,                 /* partial_inplace */
977
         0,                      /* src_mask */
978
         0xffff,                /* dst_mask */
979
         FALSE),                /* pcrel_offset */
980
 
981
  /* 64-bit relocation; insert value of TOC base (.TOC.).  */
982
 
983
  /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
984
  HOWTO (R_PPC64_TOC,           /* type */
985
         0,                      /* rightshift */
986
         4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
987
         64,                    /* bitsize */
988
         FALSE,                 /* pc_relative */
989
         0,                      /* bitpos */
990
         complain_overflow_bitfield, /* complain_on_overflow */
991
         ppc64_elf_toc64_reloc, /* special_function */
992
         "R_PPC64_TOC",         /* name */
993
         FALSE,                 /* partial_inplace */
994
         0,                      /* src_mask */
995
         ONES (64),             /* dst_mask */
996
         FALSE),                /* pcrel_offset */
997
 
998
  /* Like R_PPC64_GOT16, but also informs the link editor that the
999
     value to relocate may (!) refer to a PLT entry which the link
1000
     editor (a) may replace with the symbol value.  If the link editor
1001
     is unable to fully resolve the symbol, it may (b) create a PLT
1002
     entry and store the address to the new PLT entry in the GOT.
1003
     This permits lazy resolution of function symbols at run time.
1004
     The link editor may also skip all of this and just (c) emit a
1005
     R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1006
  /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1007
    HOWTO (R_PPC64_PLTGOT16,    /* type */
1008
         0,                      /* rightshift */
1009
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1010
         16,                    /* bitsize */
1011
         FALSE,                 /* pc_relative */
1012
         0,                      /* bitpos */
1013
         complain_overflow_signed, /* complain_on_overflow */
1014
         ppc64_elf_unhandled_reloc, /* special_function */
1015
         "R_PPC64_PLTGOT16",    /* name */
1016
         FALSE,                 /* partial_inplace */
1017
         0,                      /* src_mask */
1018
         0xffff,                /* dst_mask */
1019
         FALSE),                /* pcrel_offset */
1020
 
1021
  /* Like R_PPC64_PLTGOT16, but without overflow.  */
1022
  /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1023
  HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1024
         0,                      /* rightshift */
1025
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1026
         16,                    /* bitsize */
1027
         FALSE,                 /* pc_relative */
1028
         0,                      /* bitpos */
1029
         complain_overflow_dont, /* complain_on_overflow */
1030
         ppc64_elf_unhandled_reloc, /* special_function */
1031
         "R_PPC64_PLTGOT16_LO", /* name */
1032
         FALSE,                 /* partial_inplace */
1033
         0,                      /* src_mask */
1034
         0xffff,                /* dst_mask */
1035
         FALSE),                /* pcrel_offset */
1036
 
1037
  /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1038
  /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1039
  HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1040
         16,                    /* rightshift */
1041
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1042
         16,                    /* bitsize */
1043
         FALSE,                 /* pc_relative */
1044
         0,                      /* bitpos */
1045
         complain_overflow_dont, /* complain_on_overflow */
1046
         ppc64_elf_unhandled_reloc, /* special_function */
1047
         "R_PPC64_PLTGOT16_HI", /* name */
1048
         FALSE,                 /* partial_inplace */
1049
         0,                      /* src_mask */
1050
         0xffff,                /* dst_mask */
1051
         FALSE),                /* pcrel_offset */
1052
 
1053
  /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1054
     1 if the contents of the low 16 bits, treated as a signed number,
1055
     is negative.  */
1056
  /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1057
  HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1058
         16,                    /* rightshift */
1059
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060
         16,                    /* bitsize */
1061
         FALSE,                 /* pc_relative */
1062
         0,                      /* bitpos */
1063
         complain_overflow_dont,/* complain_on_overflow */
1064
         ppc64_elf_unhandled_reloc, /* special_function */
1065
         "R_PPC64_PLTGOT16_HA", /* name */
1066
         FALSE,                 /* partial_inplace */
1067
         0,                      /* src_mask */
1068
         0xffff,                /* dst_mask */
1069
         FALSE),                /* pcrel_offset */
1070
 
1071
  /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1072
  HOWTO (R_PPC64_ADDR16_DS,     /* type */
1073
         0,                      /* rightshift */
1074
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1075
         16,                    /* bitsize */
1076
         FALSE,                 /* pc_relative */
1077
         0,                      /* bitpos */
1078
         complain_overflow_bitfield, /* complain_on_overflow */
1079
         bfd_elf_generic_reloc, /* special_function */
1080
         "R_PPC64_ADDR16_DS",   /* name */
1081
         FALSE,                 /* partial_inplace */
1082
         0,                      /* src_mask */
1083
         0xfffc,                /* dst_mask */
1084
         FALSE),                /* pcrel_offset */
1085
 
1086
  /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1087
  HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1088
         0,                      /* rightshift */
1089
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1090
         16,                    /* bitsize */
1091
         FALSE,                 /* pc_relative */
1092
         0,                      /* bitpos */
1093
         complain_overflow_dont,/* complain_on_overflow */
1094
         bfd_elf_generic_reloc, /* special_function */
1095
         "R_PPC64_ADDR16_LO_DS",/* name */
1096
         FALSE,                 /* partial_inplace */
1097
         0,                      /* src_mask */
1098
         0xfffc,                /* dst_mask */
1099
         FALSE),                /* pcrel_offset */
1100
 
1101
  /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1102
  HOWTO (R_PPC64_GOT16_DS,      /* type */
1103
         0,                      /* rightshift */
1104
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1105
         16,                    /* bitsize */
1106
         FALSE,                 /* pc_relative */
1107
         0,                      /* bitpos */
1108
         complain_overflow_signed, /* complain_on_overflow */
1109
         ppc64_elf_unhandled_reloc, /* special_function */
1110
         "R_PPC64_GOT16_DS",    /* name */
1111
         FALSE,                 /* partial_inplace */
1112
         0,                      /* src_mask */
1113
         0xfffc,                /* dst_mask */
1114
         FALSE),                /* pcrel_offset */
1115
 
1116
  /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1117
  HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1118
         0,                      /* rightshift */
1119
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1120
         16,                    /* bitsize */
1121
         FALSE,                 /* pc_relative */
1122
         0,                      /* bitpos */
1123
         complain_overflow_dont, /* complain_on_overflow */
1124
         ppc64_elf_unhandled_reloc, /* special_function */
1125
         "R_PPC64_GOT16_LO_DS", /* name */
1126
         FALSE,                 /* partial_inplace */
1127
         0,                      /* src_mask */
1128
         0xfffc,                /* dst_mask */
1129
         FALSE),                /* pcrel_offset */
1130
 
1131
  /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1132
  HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1133
         0,                      /* rightshift */
1134
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1135
         16,                    /* bitsize */
1136
         FALSE,                 /* pc_relative */
1137
         0,                      /* bitpos */
1138
         complain_overflow_dont, /* complain_on_overflow */
1139
         ppc64_elf_unhandled_reloc, /* special_function */
1140
         "R_PPC64_PLT16_LO_DS", /* name */
1141
         FALSE,                 /* partial_inplace */
1142
         0,                      /* src_mask */
1143
         0xfffc,                /* dst_mask */
1144
         FALSE),                /* pcrel_offset */
1145
 
1146
  /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1147
  HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1148
         0,                      /* rightshift */
1149
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1150
         16,                    /* bitsize */
1151
         FALSE,                 /* pc_relative */
1152
         0,                      /* bitpos */
1153
         complain_overflow_bitfield, /* complain_on_overflow */
1154
         ppc64_elf_sectoff_reloc, /* special_function */
1155
         "R_PPC64_SECTOFF_DS",  /* name */
1156
         FALSE,                 /* partial_inplace */
1157
         0,                      /* src_mask */
1158
         0xfffc,                /* dst_mask */
1159
         FALSE),                /* pcrel_offset */
1160
 
1161
  /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1162
  HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1163
         0,                      /* rightshift */
1164
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1165
         16,                    /* bitsize */
1166
         FALSE,                 /* pc_relative */
1167
         0,                      /* bitpos */
1168
         complain_overflow_dont, /* complain_on_overflow */
1169
         ppc64_elf_sectoff_reloc, /* special_function */
1170
         "R_PPC64_SECTOFF_LO_DS",/* name */
1171
         FALSE,                 /* partial_inplace */
1172
         0,                      /* src_mask */
1173
         0xfffc,                /* dst_mask */
1174
         FALSE),                /* pcrel_offset */
1175
 
1176
  /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1177
  HOWTO (R_PPC64_TOC16_DS,      /* type */
1178
         0,                      /* rightshift */
1179
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1180
         16,                    /* bitsize */
1181
         FALSE,                 /* pc_relative */
1182
         0,                      /* bitpos */
1183
         complain_overflow_signed, /* complain_on_overflow */
1184
         ppc64_elf_toc_reloc,   /* special_function */
1185
         "R_PPC64_TOC16_DS",    /* name */
1186
         FALSE,                 /* partial_inplace */
1187
         0,                      /* src_mask */
1188
         0xfffc,                /* dst_mask */
1189
         FALSE),                /* pcrel_offset */
1190
 
1191
  /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1192
  HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1193
         0,                      /* rightshift */
1194
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1195
         16,                    /* bitsize */
1196
         FALSE,                 /* pc_relative */
1197
         0,                      /* bitpos */
1198
         complain_overflow_dont, /* complain_on_overflow */
1199
         ppc64_elf_toc_reloc,   /* special_function */
1200
         "R_PPC64_TOC16_LO_DS", /* name */
1201
         FALSE,                 /* partial_inplace */
1202
         0,                      /* src_mask */
1203
         0xfffc,                /* dst_mask */
1204
         FALSE),                /* pcrel_offset */
1205
 
1206
  /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1207
  /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1208
  HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1209
         0,                      /* rightshift */
1210
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1211
         16,                    /* bitsize */
1212
         FALSE,                 /* pc_relative */
1213
         0,                      /* bitpos */
1214
         complain_overflow_signed, /* complain_on_overflow */
1215
         ppc64_elf_unhandled_reloc, /* special_function */
1216
         "R_PPC64_PLTGOT16_DS", /* name */
1217
         FALSE,                 /* partial_inplace */
1218
         0,                      /* src_mask */
1219
         0xfffc,                /* dst_mask */
1220
         FALSE),                /* pcrel_offset */
1221
 
1222
  /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1223
  /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1224
  HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1225
         0,                      /* rightshift */
1226
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1227
         16,                    /* bitsize */
1228
         FALSE,                 /* pc_relative */
1229
         0,                      /* bitpos */
1230
         complain_overflow_dont, /* complain_on_overflow */
1231
         ppc64_elf_unhandled_reloc, /* special_function */
1232
         "R_PPC64_PLTGOT16_LO_DS",/* name */
1233
         FALSE,                 /* partial_inplace */
1234
         0,                      /* src_mask */
1235
         0xfffc,                /* dst_mask */
1236
         FALSE),                /* pcrel_offset */
1237
 
1238
  /* Marker reloc for TLS.  */
1239
  HOWTO (R_PPC64_TLS,
1240
         0,                      /* rightshift */
1241
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1242
         32,                    /* bitsize */
1243
         FALSE,                 /* pc_relative */
1244
         0,                      /* bitpos */
1245
         complain_overflow_dont, /* complain_on_overflow */
1246
         bfd_elf_generic_reloc, /* special_function */
1247
         "R_PPC64_TLS",         /* name */
1248
         FALSE,                 /* partial_inplace */
1249
         0,                      /* src_mask */
1250
         0,                      /* dst_mask */
1251
         FALSE),                /* pcrel_offset */
1252
 
1253
  /* Computes the load module index of the load module that contains the
1254
     definition of its TLS sym.  */
1255
  HOWTO (R_PPC64_DTPMOD64,
1256
         0,                      /* rightshift */
1257
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
1258
         64,                    /* bitsize */
1259
         FALSE,                 /* pc_relative */
1260
         0,                      /* bitpos */
1261
         complain_overflow_dont, /* complain_on_overflow */
1262
         ppc64_elf_unhandled_reloc, /* special_function */
1263
         "R_PPC64_DTPMOD64",    /* name */
1264
         FALSE,                 /* partial_inplace */
1265
         0,                      /* src_mask */
1266
         ONES (64),             /* dst_mask */
1267
         FALSE),                /* pcrel_offset */
1268
 
1269
  /* Computes a dtv-relative displacement, the difference between the value
1270
     of sym+add and the base address of the thread-local storage block that
1271
     contains the definition of sym, minus 0x8000.  */
1272
  HOWTO (R_PPC64_DTPREL64,
1273
         0,                      /* rightshift */
1274
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
1275
         64,                    /* bitsize */
1276
         FALSE,                 /* pc_relative */
1277
         0,                      /* bitpos */
1278
         complain_overflow_dont, /* complain_on_overflow */
1279
         ppc64_elf_unhandled_reloc, /* special_function */
1280
         "R_PPC64_DTPREL64",    /* name */
1281
         FALSE,                 /* partial_inplace */
1282
         0,                      /* src_mask */
1283
         ONES (64),             /* dst_mask */
1284
         FALSE),                /* pcrel_offset */
1285
 
1286
  /* A 16 bit dtprel reloc.  */
1287
  HOWTO (R_PPC64_DTPREL16,
1288
         0,                      /* rightshift */
1289
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1290
         16,                    /* bitsize */
1291
         FALSE,                 /* pc_relative */
1292
         0,                      /* bitpos */
1293
         complain_overflow_signed, /* complain_on_overflow */
1294
         ppc64_elf_unhandled_reloc, /* special_function */
1295
         "R_PPC64_DTPREL16",    /* name */
1296
         FALSE,                 /* partial_inplace */
1297
         0,                      /* src_mask */
1298
         0xffff,                /* dst_mask */
1299
         FALSE),                /* pcrel_offset */
1300
 
1301
  /* Like DTPREL16, but no overflow.  */
1302
  HOWTO (R_PPC64_DTPREL16_LO,
1303
         0,                      /* rightshift */
1304
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1305
         16,                    /* bitsize */
1306
         FALSE,                 /* pc_relative */
1307
         0,                      /* bitpos */
1308
         complain_overflow_dont, /* complain_on_overflow */
1309
         ppc64_elf_unhandled_reloc, /* special_function */
1310
         "R_PPC64_DTPREL16_LO", /* name */
1311
         FALSE,                 /* partial_inplace */
1312
         0,                      /* src_mask */
1313
         0xffff,                /* dst_mask */
1314
         FALSE),                /* pcrel_offset */
1315
 
1316
  /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1317
  HOWTO (R_PPC64_DTPREL16_HI,
1318
         16,                    /* rightshift */
1319
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1320
         16,                    /* bitsize */
1321
         FALSE,                 /* pc_relative */
1322
         0,                      /* bitpos */
1323
         complain_overflow_dont, /* complain_on_overflow */
1324
         ppc64_elf_unhandled_reloc, /* special_function */
1325
         "R_PPC64_DTPREL16_HI", /* name */
1326
         FALSE,                 /* partial_inplace */
1327
         0,                      /* src_mask */
1328
         0xffff,                /* dst_mask */
1329
         FALSE),                /* pcrel_offset */
1330
 
1331
  /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1332
  HOWTO (R_PPC64_DTPREL16_HA,
1333
         16,                    /* rightshift */
1334
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1335
         16,                    /* bitsize */
1336
         FALSE,                 /* pc_relative */
1337
         0,                      /* bitpos */
1338
         complain_overflow_dont, /* complain_on_overflow */
1339
         ppc64_elf_unhandled_reloc, /* special_function */
1340
         "R_PPC64_DTPREL16_HA", /* name */
1341
         FALSE,                 /* partial_inplace */
1342
         0,                      /* src_mask */
1343
         0xffff,                /* dst_mask */
1344
         FALSE),                /* pcrel_offset */
1345
 
1346
  /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1347
  HOWTO (R_PPC64_DTPREL16_HIGHER,
1348
         32,                    /* rightshift */
1349
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1350
         16,                    /* bitsize */
1351
         FALSE,                 /* pc_relative */
1352
         0,                      /* bitpos */
1353
         complain_overflow_dont, /* complain_on_overflow */
1354
         ppc64_elf_unhandled_reloc, /* special_function */
1355
         "R_PPC64_DTPREL16_HIGHER", /* name */
1356
         FALSE,                 /* partial_inplace */
1357
         0,                      /* src_mask */
1358
         0xffff,                /* dst_mask */
1359
         FALSE),                /* pcrel_offset */
1360
 
1361
  /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1362
  HOWTO (R_PPC64_DTPREL16_HIGHERA,
1363
         32,                    /* rightshift */
1364
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1365
         16,                    /* bitsize */
1366
         FALSE,                 /* pc_relative */
1367
         0,                      /* bitpos */
1368
         complain_overflow_dont, /* complain_on_overflow */
1369
         ppc64_elf_unhandled_reloc, /* special_function */
1370
         "R_PPC64_DTPREL16_HIGHERA", /* name */
1371
         FALSE,                 /* partial_inplace */
1372
         0,                      /* src_mask */
1373
         0xffff,                /* dst_mask */
1374
         FALSE),                /* pcrel_offset */
1375
 
1376
  /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1377
  HOWTO (R_PPC64_DTPREL16_HIGHEST,
1378
         48,                    /* rightshift */
1379
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1380
         16,                    /* bitsize */
1381
         FALSE,                 /* pc_relative */
1382
         0,                      /* bitpos */
1383
         complain_overflow_dont, /* complain_on_overflow */
1384
         ppc64_elf_unhandled_reloc, /* special_function */
1385
         "R_PPC64_DTPREL16_HIGHEST", /* name */
1386
         FALSE,                 /* partial_inplace */
1387
         0,                      /* src_mask */
1388
         0xffff,                /* dst_mask */
1389
         FALSE),                /* pcrel_offset */
1390
 
1391
  /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1392
  HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1393
         48,                    /* rightshift */
1394
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1395
         16,                    /* bitsize */
1396
         FALSE,                 /* pc_relative */
1397
         0,                      /* bitpos */
1398
         complain_overflow_dont, /* complain_on_overflow */
1399
         ppc64_elf_unhandled_reloc, /* special_function */
1400
         "R_PPC64_DTPREL16_HIGHESTA", /* name */
1401
         FALSE,                 /* partial_inplace */
1402
         0,                      /* src_mask */
1403
         0xffff,                /* dst_mask */
1404
         FALSE),                /* pcrel_offset */
1405
 
1406
  /* Like DTPREL16, but for insns with a DS field.  */
1407
  HOWTO (R_PPC64_DTPREL16_DS,
1408
         0,                      /* rightshift */
1409
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1410
         16,                    /* bitsize */
1411
         FALSE,                 /* pc_relative */
1412
         0,                      /* bitpos */
1413
         complain_overflow_signed, /* complain_on_overflow */
1414
         ppc64_elf_unhandled_reloc, /* special_function */
1415
         "R_PPC64_DTPREL16_DS", /* name */
1416
         FALSE,                 /* partial_inplace */
1417
         0,                      /* src_mask */
1418
         0xfffc,                /* dst_mask */
1419
         FALSE),                /* pcrel_offset */
1420
 
1421
  /* Like DTPREL16_DS, but no overflow.  */
1422
  HOWTO (R_PPC64_DTPREL16_LO_DS,
1423
         0,                      /* rightshift */
1424
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1425
         16,                    /* bitsize */
1426
         FALSE,                 /* pc_relative */
1427
         0,                      /* bitpos */
1428
         complain_overflow_dont, /* complain_on_overflow */
1429
         ppc64_elf_unhandled_reloc, /* special_function */
1430
         "R_PPC64_DTPREL16_LO_DS", /* name */
1431
         FALSE,                 /* partial_inplace */
1432
         0,                      /* src_mask */
1433
         0xfffc,                /* dst_mask */
1434
         FALSE),                /* pcrel_offset */
1435
 
1436
  /* Computes a tp-relative displacement, the difference between the value of
1437
     sym+add and the value of the thread pointer (r13).  */
1438
  HOWTO (R_PPC64_TPREL64,
1439
         0,                      /* rightshift */
1440
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
1441
         64,                    /* bitsize */
1442
         FALSE,                 /* pc_relative */
1443
         0,                      /* bitpos */
1444
         complain_overflow_dont, /* complain_on_overflow */
1445
         ppc64_elf_unhandled_reloc, /* special_function */
1446
         "R_PPC64_TPREL64",     /* name */
1447
         FALSE,                 /* partial_inplace */
1448
         0,                      /* src_mask */
1449
         ONES (64),             /* dst_mask */
1450
         FALSE),                /* pcrel_offset */
1451
 
1452
  /* A 16 bit tprel reloc.  */
1453
  HOWTO (R_PPC64_TPREL16,
1454
         0,                      /* rightshift */
1455
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1456
         16,                    /* bitsize */
1457
         FALSE,                 /* pc_relative */
1458
         0,                      /* bitpos */
1459
         complain_overflow_signed, /* complain_on_overflow */
1460
         ppc64_elf_unhandled_reloc, /* special_function */
1461
         "R_PPC64_TPREL16",     /* name */
1462
         FALSE,                 /* partial_inplace */
1463
         0,                      /* src_mask */
1464
         0xffff,                /* dst_mask */
1465
         FALSE),                /* pcrel_offset */
1466
 
1467
  /* Like TPREL16, but no overflow.  */
1468
  HOWTO (R_PPC64_TPREL16_LO,
1469
         0,                      /* rightshift */
1470
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1471
         16,                    /* bitsize */
1472
         FALSE,                 /* pc_relative */
1473
         0,                      /* bitpos */
1474
         complain_overflow_dont, /* complain_on_overflow */
1475
         ppc64_elf_unhandled_reloc, /* special_function */
1476
         "R_PPC64_TPREL16_LO",  /* name */
1477
         FALSE,                 /* partial_inplace */
1478
         0,                      /* src_mask */
1479
         0xffff,                /* dst_mask */
1480
         FALSE),                /* pcrel_offset */
1481
 
1482
  /* Like TPREL16_LO, but next higher group of 16 bits.  */
1483
  HOWTO (R_PPC64_TPREL16_HI,
1484
         16,                    /* rightshift */
1485
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1486
         16,                    /* bitsize */
1487
         FALSE,                 /* pc_relative */
1488
         0,                      /* bitpos */
1489
         complain_overflow_dont, /* complain_on_overflow */
1490
         ppc64_elf_unhandled_reloc, /* special_function */
1491
         "R_PPC64_TPREL16_HI",  /* name */
1492
         FALSE,                 /* partial_inplace */
1493
         0,                      /* src_mask */
1494
         0xffff,                /* dst_mask */
1495
         FALSE),                /* pcrel_offset */
1496
 
1497
  /* Like TPREL16_HI, but adjust for low 16 bits.  */
1498
  HOWTO (R_PPC64_TPREL16_HA,
1499
         16,                    /* rightshift */
1500
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1501
         16,                    /* bitsize */
1502
         FALSE,                 /* pc_relative */
1503
         0,                      /* bitpos */
1504
         complain_overflow_dont, /* complain_on_overflow */
1505
         ppc64_elf_unhandled_reloc, /* special_function */
1506
         "R_PPC64_TPREL16_HA",  /* name */
1507
         FALSE,                 /* partial_inplace */
1508
         0,                      /* src_mask */
1509
         0xffff,                /* dst_mask */
1510
         FALSE),                /* pcrel_offset */
1511
 
1512
  /* Like TPREL16_HI, but next higher group of 16 bits.  */
1513
  HOWTO (R_PPC64_TPREL16_HIGHER,
1514
         32,                    /* rightshift */
1515
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1516
         16,                    /* bitsize */
1517
         FALSE,                 /* pc_relative */
1518
         0,                      /* bitpos */
1519
         complain_overflow_dont, /* complain_on_overflow */
1520
         ppc64_elf_unhandled_reloc, /* special_function */
1521
         "R_PPC64_TPREL16_HIGHER",      /* name */
1522
         FALSE,                 /* partial_inplace */
1523
         0,                      /* src_mask */
1524
         0xffff,                /* dst_mask */
1525
         FALSE),                /* pcrel_offset */
1526
 
1527
  /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1528
  HOWTO (R_PPC64_TPREL16_HIGHERA,
1529
         32,                    /* rightshift */
1530
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1531
         16,                    /* bitsize */
1532
         FALSE,                 /* pc_relative */
1533
         0,                      /* bitpos */
1534
         complain_overflow_dont, /* complain_on_overflow */
1535
         ppc64_elf_unhandled_reloc, /* special_function */
1536
         "R_PPC64_TPREL16_HIGHERA", /* name */
1537
         FALSE,                 /* partial_inplace */
1538
         0,                      /* src_mask */
1539
         0xffff,                /* dst_mask */
1540
         FALSE),                /* pcrel_offset */
1541
 
1542
  /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1543
  HOWTO (R_PPC64_TPREL16_HIGHEST,
1544
         48,                    /* rightshift */
1545
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1546
         16,                    /* bitsize */
1547
         FALSE,                 /* pc_relative */
1548
         0,                      /* bitpos */
1549
         complain_overflow_dont, /* complain_on_overflow */
1550
         ppc64_elf_unhandled_reloc, /* special_function */
1551
         "R_PPC64_TPREL16_HIGHEST", /* name */
1552
         FALSE,                 /* partial_inplace */
1553
         0,                      /* src_mask */
1554
         0xffff,                /* dst_mask */
1555
         FALSE),                /* pcrel_offset */
1556
 
1557
  /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1558
  HOWTO (R_PPC64_TPREL16_HIGHESTA,
1559
         48,                    /* rightshift */
1560
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1561
         16,                    /* bitsize */
1562
         FALSE,                 /* pc_relative */
1563
         0,                      /* bitpos */
1564
         complain_overflow_dont, /* complain_on_overflow */
1565
         ppc64_elf_unhandled_reloc, /* special_function */
1566
         "R_PPC64_TPREL16_HIGHESTA", /* name */
1567
         FALSE,                 /* partial_inplace */
1568
         0,                      /* src_mask */
1569
         0xffff,                /* dst_mask */
1570
         FALSE),                /* pcrel_offset */
1571
 
1572
  /* Like TPREL16, but for insns with a DS field.  */
1573
  HOWTO (R_PPC64_TPREL16_DS,
1574
         0,                      /* rightshift */
1575
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1576
         16,                    /* bitsize */
1577
         FALSE,                 /* pc_relative */
1578
         0,                      /* bitpos */
1579
         complain_overflow_signed, /* complain_on_overflow */
1580
         ppc64_elf_unhandled_reloc, /* special_function */
1581
         "R_PPC64_TPREL16_DS",  /* name */
1582
         FALSE,                 /* partial_inplace */
1583
         0,                      /* src_mask */
1584
         0xfffc,                /* dst_mask */
1585
         FALSE),                /* pcrel_offset */
1586
 
1587
  /* Like TPREL16_DS, but no overflow.  */
1588
  HOWTO (R_PPC64_TPREL16_LO_DS,
1589
         0,                      /* rightshift */
1590
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1591
         16,                    /* bitsize */
1592
         FALSE,                 /* pc_relative */
1593
         0,                      /* bitpos */
1594
         complain_overflow_dont, /* complain_on_overflow */
1595
         ppc64_elf_unhandled_reloc, /* special_function */
1596
         "R_PPC64_TPREL16_LO_DS", /* name */
1597
         FALSE,                 /* partial_inplace */
1598
         0,                      /* src_mask */
1599
         0xfffc,                /* dst_mask */
1600
         FALSE),                /* pcrel_offset */
1601
 
1602
  /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1603
     with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1604
     to the first entry relative to the TOC base (r2).  */
1605
  HOWTO (R_PPC64_GOT_TLSGD16,
1606
         0,                      /* rightshift */
1607
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608
         16,                    /* bitsize */
1609
         FALSE,                 /* pc_relative */
1610
         0,                      /* bitpos */
1611
         complain_overflow_signed, /* complain_on_overflow */
1612
         ppc64_elf_unhandled_reloc, /* special_function */
1613
         "R_PPC64_GOT_TLSGD16", /* name */
1614
         FALSE,                 /* partial_inplace */
1615
         0,                      /* src_mask */
1616
         0xffff,                /* dst_mask */
1617
         FALSE),                /* pcrel_offset */
1618
 
1619
  /* Like GOT_TLSGD16, but no overflow.  */
1620
  HOWTO (R_PPC64_GOT_TLSGD16_LO,
1621
         0,                      /* rightshift */
1622
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623
         16,                    /* bitsize */
1624
         FALSE,                 /* pc_relative */
1625
         0,                      /* bitpos */
1626
         complain_overflow_dont, /* complain_on_overflow */
1627
         ppc64_elf_unhandled_reloc, /* special_function */
1628
         "R_PPC64_GOT_TLSGD16_LO", /* name */
1629
         FALSE,                 /* partial_inplace */
1630
         0,                      /* src_mask */
1631
         0xffff,                /* dst_mask */
1632
         FALSE),                /* pcrel_offset */
1633
 
1634
  /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1635
  HOWTO (R_PPC64_GOT_TLSGD16_HI,
1636
         16,                    /* rightshift */
1637
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638
         16,                    /* bitsize */
1639
         FALSE,                 /* pc_relative */
1640
         0,                      /* bitpos */
1641
         complain_overflow_dont, /* complain_on_overflow */
1642
         ppc64_elf_unhandled_reloc, /* special_function */
1643
         "R_PPC64_GOT_TLSGD16_HI", /* name */
1644
         FALSE,                 /* partial_inplace */
1645
         0,                      /* src_mask */
1646
         0xffff,                /* dst_mask */
1647
         FALSE),                /* pcrel_offset */
1648
 
1649
  /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1650
  HOWTO (R_PPC64_GOT_TLSGD16_HA,
1651
         16,                    /* rightshift */
1652
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653
         16,                    /* bitsize */
1654
         FALSE,                 /* pc_relative */
1655
         0,                      /* bitpos */
1656
         complain_overflow_dont, /* complain_on_overflow */
1657
         ppc64_elf_unhandled_reloc, /* special_function */
1658
         "R_PPC64_GOT_TLSGD16_HA", /* name */
1659
         FALSE,                 /* partial_inplace */
1660
         0,                      /* src_mask */
1661
         0xffff,                /* dst_mask */
1662
         FALSE),                /* pcrel_offset */
1663
 
1664
  /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1665
     with values (sym+add)@dtpmod and zero, and computes the offset to the
1666
     first entry relative to the TOC base (r2).  */
1667
  HOWTO (R_PPC64_GOT_TLSLD16,
1668
         0,                      /* rightshift */
1669
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1670
         16,                    /* bitsize */
1671
         FALSE,                 /* pc_relative */
1672
         0,                      /* bitpos */
1673
         complain_overflow_signed, /* complain_on_overflow */
1674
         ppc64_elf_unhandled_reloc, /* special_function */
1675
         "R_PPC64_GOT_TLSLD16", /* name */
1676
         FALSE,                 /* partial_inplace */
1677
         0,                      /* src_mask */
1678
         0xffff,                /* dst_mask */
1679
         FALSE),                /* pcrel_offset */
1680
 
1681
  /* Like GOT_TLSLD16, but no overflow.  */
1682
  HOWTO (R_PPC64_GOT_TLSLD16_LO,
1683
         0,                      /* rightshift */
1684
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1685
         16,                    /* bitsize */
1686
         FALSE,                 /* pc_relative */
1687
         0,                      /* bitpos */
1688
         complain_overflow_dont, /* complain_on_overflow */
1689
         ppc64_elf_unhandled_reloc, /* special_function */
1690
         "R_PPC64_GOT_TLSLD16_LO", /* name */
1691
         FALSE,                 /* partial_inplace */
1692
         0,                      /* src_mask */
1693
         0xffff,                /* dst_mask */
1694
         FALSE),                /* pcrel_offset */
1695
 
1696
  /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1697
  HOWTO (R_PPC64_GOT_TLSLD16_HI,
1698
         16,                    /* rightshift */
1699
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700
         16,                    /* bitsize */
1701
         FALSE,                 /* pc_relative */
1702
         0,                      /* bitpos */
1703
         complain_overflow_dont, /* complain_on_overflow */
1704
         ppc64_elf_unhandled_reloc, /* special_function */
1705
         "R_PPC64_GOT_TLSLD16_HI", /* name */
1706
         FALSE,                 /* partial_inplace */
1707
         0,                      /* src_mask */
1708
         0xffff,                /* dst_mask */
1709
         FALSE),                /* pcrel_offset */
1710
 
1711
  /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1712
  HOWTO (R_PPC64_GOT_TLSLD16_HA,
1713
         16,                    /* rightshift */
1714
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715
         16,                    /* bitsize */
1716
         FALSE,                 /* pc_relative */
1717
         0,                      /* bitpos */
1718
         complain_overflow_dont, /* complain_on_overflow */
1719
         ppc64_elf_unhandled_reloc, /* special_function */
1720
         "R_PPC64_GOT_TLSLD16_HA", /* name */
1721
         FALSE,                 /* partial_inplace */
1722
         0,                      /* src_mask */
1723
         0xffff,                /* dst_mask */
1724
         FALSE),                /* pcrel_offset */
1725
 
1726
  /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1727
     the offset to the entry relative to the TOC base (r2).  */
1728
  HOWTO (R_PPC64_GOT_DTPREL16_DS,
1729
         0,                      /* rightshift */
1730
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1731
         16,                    /* bitsize */
1732
         FALSE,                 /* pc_relative */
1733
         0,                      /* bitpos */
1734
         complain_overflow_signed, /* complain_on_overflow */
1735
         ppc64_elf_unhandled_reloc, /* special_function */
1736
         "R_PPC64_GOT_DTPREL16_DS", /* name */
1737
         FALSE,                 /* partial_inplace */
1738
         0,                      /* src_mask */
1739
         0xfffc,                /* dst_mask */
1740
         FALSE),                /* pcrel_offset */
1741
 
1742
  /* Like GOT_DTPREL16_DS, but no overflow.  */
1743
  HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1744
         0,                      /* rightshift */
1745
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1746
         16,                    /* bitsize */
1747
         FALSE,                 /* pc_relative */
1748
         0,                      /* bitpos */
1749
         complain_overflow_dont, /* complain_on_overflow */
1750
         ppc64_elf_unhandled_reloc, /* special_function */
1751
         "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1752
         FALSE,                 /* partial_inplace */
1753
         0,                      /* src_mask */
1754
         0xfffc,                /* dst_mask */
1755
         FALSE),                /* pcrel_offset */
1756
 
1757
  /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1758
  HOWTO (R_PPC64_GOT_DTPREL16_HI,
1759
         16,                    /* rightshift */
1760
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1761
         16,                    /* bitsize */
1762
         FALSE,                 /* pc_relative */
1763
         0,                      /* bitpos */
1764
         complain_overflow_dont, /* complain_on_overflow */
1765
         ppc64_elf_unhandled_reloc, /* special_function */
1766
         "R_PPC64_GOT_DTPREL16_HI", /* name */
1767
         FALSE,                 /* partial_inplace */
1768
         0,                      /* src_mask */
1769
         0xffff,                /* dst_mask */
1770
         FALSE),                /* pcrel_offset */
1771
 
1772
  /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1773
  HOWTO (R_PPC64_GOT_DTPREL16_HA,
1774
         16,                    /* rightshift */
1775
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1776
         16,                    /* bitsize */
1777
         FALSE,                 /* pc_relative */
1778
         0,                      /* bitpos */
1779
         complain_overflow_dont, /* complain_on_overflow */
1780
         ppc64_elf_unhandled_reloc, /* special_function */
1781
         "R_PPC64_GOT_DTPREL16_HA", /* name */
1782
         FALSE,                 /* partial_inplace */
1783
         0,                      /* src_mask */
1784
         0xffff,                /* dst_mask */
1785
         FALSE),                /* pcrel_offset */
1786
 
1787
  /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1788
     offset to the entry relative to the TOC base (r2).  */
1789
  HOWTO (R_PPC64_GOT_TPREL16_DS,
1790
         0,                      /* rightshift */
1791
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792
         16,                    /* bitsize */
1793
         FALSE,                 /* pc_relative */
1794
         0,                      /* bitpos */
1795
         complain_overflow_signed, /* complain_on_overflow */
1796
         ppc64_elf_unhandled_reloc, /* special_function */
1797
         "R_PPC64_GOT_TPREL16_DS", /* name */
1798
         FALSE,                 /* partial_inplace */
1799
         0,                      /* src_mask */
1800
         0xfffc,                /* dst_mask */
1801
         FALSE),                /* pcrel_offset */
1802
 
1803
  /* Like GOT_TPREL16_DS, but no overflow.  */
1804
  HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1805
         0,                      /* rightshift */
1806
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807
         16,                    /* bitsize */
1808
         FALSE,                 /* pc_relative */
1809
         0,                      /* bitpos */
1810
         complain_overflow_dont, /* complain_on_overflow */
1811
         ppc64_elf_unhandled_reloc, /* special_function */
1812
         "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1813
         FALSE,                 /* partial_inplace */
1814
         0,                      /* src_mask */
1815
         0xfffc,                /* dst_mask */
1816
         FALSE),                /* pcrel_offset */
1817
 
1818
  /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1819
  HOWTO (R_PPC64_GOT_TPREL16_HI,
1820
         16,                    /* rightshift */
1821
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1822
         16,                    /* bitsize */
1823
         FALSE,                 /* pc_relative */
1824
         0,                      /* bitpos */
1825
         complain_overflow_dont, /* complain_on_overflow */
1826
         ppc64_elf_unhandled_reloc, /* special_function */
1827
         "R_PPC64_GOT_TPREL16_HI", /* name */
1828
         FALSE,                 /* partial_inplace */
1829
         0,                      /* src_mask */
1830
         0xffff,                /* dst_mask */
1831
         FALSE),                /* pcrel_offset */
1832
 
1833
  /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1834
  HOWTO (R_PPC64_GOT_TPREL16_HA,
1835
         16,                    /* rightshift */
1836
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1837
         16,                    /* bitsize */
1838
         FALSE,                 /* pc_relative */
1839
         0,                      /* bitpos */
1840
         complain_overflow_dont, /* complain_on_overflow */
1841
         ppc64_elf_unhandled_reloc, /* special_function */
1842
         "R_PPC64_GOT_TPREL16_HA", /* name */
1843
         FALSE,                 /* partial_inplace */
1844
         0,                      /* src_mask */
1845
         0xffff,                /* dst_mask */
1846
         FALSE),                /* pcrel_offset */
1847
 
1848
  /* GNU extension to record C++ vtable hierarchy.  */
1849
  HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1850
         0,                      /* rightshift */
1851
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
1852
         0,                      /* bitsize */
1853
         FALSE,                 /* pc_relative */
1854
         0,                      /* bitpos */
1855
         complain_overflow_dont, /* complain_on_overflow */
1856
         NULL,                  /* special_function */
1857
         "R_PPC64_GNU_VTINHERIT", /* name */
1858
         FALSE,                 /* partial_inplace */
1859
         0,                      /* src_mask */
1860
         0,                      /* dst_mask */
1861
         FALSE),                /* pcrel_offset */
1862
 
1863
  /* GNU extension to record C++ vtable member usage.  */
1864
  HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1865
         0,                      /* rightshift */
1866
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
1867
         0,                      /* bitsize */
1868
         FALSE,                 /* pc_relative */
1869
         0,                      /* bitpos */
1870
         complain_overflow_dont, /* complain_on_overflow */
1871
         NULL,                  /* special_function */
1872
         "R_PPC64_GNU_VTENTRY", /* name */
1873
         FALSE,                 /* partial_inplace */
1874
         0,                      /* src_mask */
1875
         0,                      /* dst_mask */
1876
         FALSE),                /* pcrel_offset */
1877
};
1878
 
1879
 
1880
/* Initialize the ppc64_elf_howto_table, so that linear accesses can
1881
   be done.  */
1882
 
1883
static void
1884
ppc_howto_init (void)
1885
{
1886
  unsigned int i, type;
1887
 
1888
  for (i = 0;
1889
       i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1890
       i++)
1891
    {
1892
      type = ppc64_elf_howto_raw[i].type;
1893
      BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1894
                          / sizeof (ppc64_elf_howto_table[0])));
1895
      ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1896
    }
1897
}
1898
 
1899
static reloc_howto_type *
1900
ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1901
                             bfd_reloc_code_real_type code)
1902
{
1903
  enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1904
 
1905
  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1906
    /* Initialize howto table if needed.  */
1907
    ppc_howto_init ();
1908
 
1909
  switch (code)
1910
    {
1911
    default:
1912
      return NULL;
1913
 
1914
    case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
1915
      break;
1916
    case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
1917
      break;
1918
    case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
1919
      break;
1920
    case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
1921
      break;
1922
    case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
1923
      break;
1924
    case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
1925
      break;
1926
    case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
1927
      break;
1928
    case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
1929
      break;
1930
    case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
1931
      break;
1932
    case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
1933
      break;
1934
    case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
1935
      break;
1936
    case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
1937
      break;
1938
    case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
1939
      break;
1940
    case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
1941
      break;
1942
    case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
1943
      break;
1944
    case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
1945
      break;
1946
    case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
1947
      break;
1948
    case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
1949
      break;
1950
    case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
1951
      break;
1952
    case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
1953
      break;
1954
    case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
1955
      break;
1956
    case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
1957
      break;
1958
    case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
1959
      break;
1960
    case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
1961
      break;
1962
    case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
1963
      break;
1964
    case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
1965
      break;
1966
    case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
1967
      break;
1968
    case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
1969
      break;
1970
    case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
1971
      break;
1972
    case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
1973
      break;
1974
    case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
1975
      break;
1976
    case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
1977
      break;
1978
    case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
1979
      break;
1980
    case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
1981
      break;
1982
    case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
1983
      break;
1984
    case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
1985
      break;
1986
    case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
1987
      break;
1988
    case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
1989
      break;
1990
    case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
1991
      break;
1992
    case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
1993
      break;
1994
    case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
1995
      break;
1996
    case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
1997
      break;
1998
    case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
1999
      break;
2000
    case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2001
      break;
2002
    case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2003
      break;
2004
    case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2005
      break;
2006
    case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2007
      break;
2008
    case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2009
      break;
2010
    case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2011
      break;
2012
    case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2013
      break;
2014
    case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2015
      break;
2016
    case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2017
      break;
2018
    case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2019
      break;
2020
    case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2021
      break;
2022
    case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2023
      break;
2024
    case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2025
      break;
2026
    case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2027
      break;
2028
    case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2029
      break;
2030
    case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2031
      break;
2032
    case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2033
      break;
2034
    case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2035
      break;
2036
    case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2037
      break;
2038
    case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2039
      break;
2040
    case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2041
      break;
2042
    case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2043
      break;
2044
    case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2045
      break;
2046
    case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2047
      break;
2048
    case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2049
      break;
2050
    case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2051
      break;
2052
    case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2053
      break;
2054
    case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2055
      break;
2056
    case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2057
      break;
2058
    case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2059
      break;
2060
    case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2061
      break;
2062
    case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2063
      break;
2064
    case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2065
      break;
2066
    case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2067
      break;
2068
    case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2069
      break;
2070
    case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2071
      break;
2072
    case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2073
      break;
2074
    case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2075
      break;
2076
    case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2077
      break;
2078
    case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2079
      break;
2080
    case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2081
      break;
2082
    case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2083
      break;
2084
    case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2085
      break;
2086
    case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2087
      break;
2088
    case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2089
      break;
2090
    case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2091
      break;
2092
    case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2093
      break;
2094
    case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2095
      break;
2096
    case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2097
      break;
2098
    case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2099
      break;
2100
    case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2101
      break;
2102
    case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2103
      break;
2104
    case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2105
      break;
2106
    case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2107
      break;
2108
    case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2109
      break;
2110
    case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2111
      break;
2112
    case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2113
      break;
2114
    case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2115
      break;
2116
    }
2117
 
2118
  return ppc64_elf_howto_table[r];
2119
};
2120
 
2121
static reloc_howto_type *
2122
ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2123
                             const char *r_name)
2124
{
2125
  unsigned int i;
2126
 
2127
  for (i = 0;
2128
       i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2129
       i++)
2130
    if (ppc64_elf_howto_raw[i].name != NULL
2131
        && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2132
      return &ppc64_elf_howto_raw[i];
2133
 
2134
  return NULL;
2135
}
2136
 
2137
/* Set the howto pointer for a PowerPC ELF reloc.  */
2138
 
2139
static void
2140
ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2141
                         Elf_Internal_Rela *dst)
2142
{
2143
  unsigned int type;
2144
 
2145
  /* Initialize howto table if needed.  */
2146
  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2147
    ppc_howto_init ();
2148
 
2149
  type = ELF64_R_TYPE (dst->r_info);
2150
  if (type >= (sizeof (ppc64_elf_howto_table)
2151
               / sizeof (ppc64_elf_howto_table[0])))
2152
    {
2153
      (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2154
                             abfd, (int) type);
2155
      type = R_PPC64_NONE;
2156
    }
2157
  cache_ptr->howto = ppc64_elf_howto_table[type];
2158
}
2159
 
2160
/* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2161
 
2162
static bfd_reloc_status_type
2163
ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2164
                    void *data, asection *input_section,
2165
                    bfd *output_bfd, char **error_message)
2166
{
2167
  /* If this is a relocatable link (output_bfd test tells us), just
2168
     call the generic function.  Any adjustment will be done at final
2169
     link time.  */
2170
  if (output_bfd != NULL)
2171
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2172
                                  input_section, output_bfd, error_message);
2173
 
2174
  /* Adjust the addend for sign extension of the low 16 bits.
2175
     We won't actually be using the low 16 bits, so trashing them
2176
     doesn't matter.  */
2177
  reloc_entry->addend += 0x8000;
2178
  return bfd_reloc_continue;
2179
}
2180
 
2181
static bfd_reloc_status_type
2182
ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2183
                        void *data, asection *input_section,
2184
                        bfd *output_bfd, char **error_message)
2185
{
2186
  if (output_bfd != NULL)
2187
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2188
                                  input_section, output_bfd, error_message);
2189
 
2190
  if (strcmp (symbol->section->name, ".opd") == 0
2191
      && (symbol->section->owner->flags & DYNAMIC) == 0)
2192
    {
2193
      bfd_vma dest = opd_entry_value (symbol->section,
2194
                                      symbol->value + reloc_entry->addend,
2195
                                      NULL, NULL);
2196
      if (dest != (bfd_vma) -1)
2197
        reloc_entry->addend = dest - (symbol->value
2198
                                      + symbol->section->output_section->vma
2199
                                      + symbol->section->output_offset);
2200
    }
2201
  return bfd_reloc_continue;
2202
}
2203
 
2204
static bfd_reloc_status_type
2205
ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2206
                         void *data, asection *input_section,
2207
                         bfd *output_bfd, char **error_message)
2208
{
2209
  long insn;
2210
  enum elf_ppc64_reloc_type r_type;
2211
  bfd_size_type octets;
2212
  /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2213
  bfd_boolean is_power4 = FALSE;
2214
 
2215
  /* If this is a relocatable link (output_bfd test tells us), just
2216
     call the generic function.  Any adjustment will be done at final
2217
     link time.  */
2218
  if (output_bfd != NULL)
2219
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2220
                                  input_section, output_bfd, error_message);
2221
 
2222
  octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2223
  insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2224
  insn &= ~(0x01 << 21);
2225
  r_type = reloc_entry->howto->type;
2226
  if (r_type == R_PPC64_ADDR14_BRTAKEN
2227
      || r_type == R_PPC64_REL14_BRTAKEN)
2228
    insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2229
 
2230
  if (is_power4)
2231
    {
2232
      /* Set 'a' bit.  This is 0b00010 in BO field for branch
2233
         on CR(BI) insns (BO == 001at or 011at), and 0b01000
2234
         for branch on CTR insns (BO == 1a00t or 1a01t).  */
2235
      if ((insn & (0x14 << 21)) == (0x04 << 21))
2236
        insn |= 0x02 << 21;
2237
      else if ((insn & (0x14 << 21)) == (0x10 << 21))
2238
        insn |= 0x08 << 21;
2239
      else
2240
        goto out;
2241
    }
2242
  else
2243
    {
2244
      bfd_vma target = 0;
2245
      bfd_vma from;
2246
 
2247
      if (!bfd_is_com_section (symbol->section))
2248
        target = symbol->value;
2249
      target += symbol->section->output_section->vma;
2250
      target += symbol->section->output_offset;
2251
      target += reloc_entry->addend;
2252
 
2253
      from = (reloc_entry->address
2254
              + input_section->output_offset
2255
              + input_section->output_section->vma);
2256
 
2257
      /* Invert 'y' bit if not the default.  */
2258
      if ((bfd_signed_vma) (target - from) < 0)
2259
        insn ^= 0x01 << 21;
2260
    }
2261
  bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2262
 out:
2263
  return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2264
                                 input_section, output_bfd, error_message);
2265
}
2266
 
2267
static bfd_reloc_status_type
2268
ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2269
                         void *data, asection *input_section,
2270
                         bfd *output_bfd, char **error_message)
2271
{
2272
  /* If this is a relocatable link (output_bfd test tells us), just
2273
     call the generic function.  Any adjustment will be done at final
2274
     link time.  */
2275
  if (output_bfd != NULL)
2276
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2277
                                  input_section, output_bfd, error_message);
2278
 
2279
  /* Subtract the symbol section base address.  */
2280
  reloc_entry->addend -= symbol->section->output_section->vma;
2281
  return bfd_reloc_continue;
2282
}
2283
 
2284
static bfd_reloc_status_type
2285
ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2286
                            void *data, asection *input_section,
2287
                            bfd *output_bfd, char **error_message)
2288
{
2289
  /* If this is a relocatable link (output_bfd test tells us), just
2290
     call the generic function.  Any adjustment will be done at final
2291
     link time.  */
2292
  if (output_bfd != NULL)
2293
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2294
                                  input_section, output_bfd, error_message);
2295
 
2296
  /* Subtract the symbol section base address.  */
2297
  reloc_entry->addend -= symbol->section->output_section->vma;
2298
 
2299
  /* Adjust the addend for sign extension of the low 16 bits.  */
2300
  reloc_entry->addend += 0x8000;
2301
  return bfd_reloc_continue;
2302
}
2303
 
2304
static bfd_reloc_status_type
2305
ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2306
                     void *data, asection *input_section,
2307
                     bfd *output_bfd, char **error_message)
2308
{
2309
  bfd_vma TOCstart;
2310
 
2311
  /* If this is a relocatable link (output_bfd test tells us), just
2312
     call the generic function.  Any adjustment will be done at final
2313
     link time.  */
2314
  if (output_bfd != NULL)
2315
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2316
                                  input_section, output_bfd, error_message);
2317
 
2318
  TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2319
  if (TOCstart == 0)
2320
    TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2321
 
2322
  /* Subtract the TOC base address.  */
2323
  reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2324
  return bfd_reloc_continue;
2325
}
2326
 
2327
static bfd_reloc_status_type
2328
ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2329
                        void *data, asection *input_section,
2330
                        bfd *output_bfd, char **error_message)
2331
{
2332
  bfd_vma TOCstart;
2333
 
2334
  /* If this is a relocatable link (output_bfd test tells us), just
2335
     call the generic function.  Any adjustment will be done at final
2336
     link time.  */
2337
  if (output_bfd != NULL)
2338
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2339
                                  input_section, output_bfd, error_message);
2340
 
2341
  TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2342
  if (TOCstart == 0)
2343
    TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2344
 
2345
  /* Subtract the TOC base address.  */
2346
  reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2347
 
2348
  /* Adjust the addend for sign extension of the low 16 bits.  */
2349
  reloc_entry->addend += 0x8000;
2350
  return bfd_reloc_continue;
2351
}
2352
 
2353
static bfd_reloc_status_type
2354
ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2355
                       void *data, asection *input_section,
2356
                       bfd *output_bfd, char **error_message)
2357
{
2358
  bfd_vma TOCstart;
2359
  bfd_size_type octets;
2360
 
2361
  /* If this is a relocatable link (output_bfd test tells us), just
2362
     call the generic function.  Any adjustment will be done at final
2363
     link time.  */
2364
  if (output_bfd != NULL)
2365
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2366
                                  input_section, output_bfd, error_message);
2367
 
2368
  TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2369
  if (TOCstart == 0)
2370
    TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2371
 
2372
  octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2373
  bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2374
  return bfd_reloc_ok;
2375
}
2376
 
2377
static bfd_reloc_status_type
2378
ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2379
                           void *data, asection *input_section,
2380
                           bfd *output_bfd, char **error_message)
2381
{
2382
  /* If this is a relocatable link (output_bfd test tells us), just
2383
     call the generic function.  Any adjustment will be done at final
2384
     link time.  */
2385
  if (output_bfd != NULL)
2386
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2387
                                  input_section, output_bfd, error_message);
2388
 
2389
  if (error_message != NULL)
2390
    {
2391
      static char buf[60];
2392
      sprintf (buf, "generic linker can't handle %s",
2393
               reloc_entry->howto->name);
2394
      *error_message = buf;
2395
    }
2396
  return bfd_reloc_dangerous;
2397
}
2398
 
2399
struct ppc64_elf_obj_tdata
2400
{
2401
  struct elf_obj_tdata elf;
2402
 
2403
  /* Shortcuts to dynamic linker sections.  */
2404
  asection *got;
2405
  asection *relgot;
2406
 
2407
  /* Used during garbage collection.  We attach global symbols defined
2408
     on removed .opd entries to this section so that the sym is removed.  */
2409
  asection *deleted_section;
2410
 
2411
  /* TLS local dynamic got entry handling.  Suppose for multiple GOT
2412
     sections means we potentially need one of these for each input bfd.  */
2413
  union {
2414
    bfd_signed_vma refcount;
2415
    bfd_vma offset;
2416
  } tlsld_got;
2417
 
2418
  /* A copy of relocs before they are modified for --emit-relocs.  */
2419
  Elf_Internal_Rela *opd_relocs;
2420
};
2421
 
2422
#define ppc64_elf_tdata(bfd) \
2423
  ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2424
 
2425
#define ppc64_tlsld_got(bfd) \
2426
  (&ppc64_elf_tdata (bfd)->tlsld_got)
2427
 
2428
#define is_ppc64_elf(bfd) \
2429
  (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2430
   && elf_object_id (bfd) == PPC64_ELF_TDATA)
2431
 
2432
/* Override the generic function because we store some extras.  */
2433
 
2434
static bfd_boolean
2435
ppc64_elf_mkobject (bfd *abfd)
2436
{
2437
  return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2438
                                  PPC64_ELF_TDATA);
2439
}
2440
 
2441
/* Fix bad default arch selected for a 64 bit input bfd when the
2442
   default is 32 bit.  */
2443
 
2444
static bfd_boolean
2445
ppc64_elf_object_p (bfd *abfd)
2446
{
2447
  if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2448
    {
2449
      Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2450
 
2451
      if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2452
        {
2453
          /* Relies on arch after 32 bit default being 64 bit default.  */
2454
          abfd->arch_info = abfd->arch_info->next;
2455
          BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2456
        }
2457
    }
2458
  return TRUE;
2459
}
2460
 
2461
/* Support for core dump NOTE sections.  */
2462
 
2463
static bfd_boolean
2464
ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2465
{
2466
  size_t offset, size;
2467
 
2468
  if (note->descsz != 504)
2469
    return FALSE;
2470
 
2471
  /* pr_cursig */
2472
  elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2473
 
2474
  /* pr_pid */
2475
  elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2476
 
2477
  /* pr_reg */
2478
  offset = 112;
2479
  size = 384;
2480
 
2481
  /* Make a ".reg/999" section.  */
2482
  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2483
                                          size, note->descpos + offset);
2484
}
2485
 
2486
static bfd_boolean
2487
ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2488
{
2489
  if (note->descsz != 136)
2490
    return FALSE;
2491
 
2492
  elf_tdata (abfd)->core_program
2493
    = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2494
  elf_tdata (abfd)->core_command
2495
    = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2496
 
2497
  return TRUE;
2498
}
2499
 
2500
static char *
2501
ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2502
                           ...)
2503
{
2504
  switch (note_type)
2505
    {
2506
    default:
2507
      return NULL;
2508
 
2509
    case NT_PRPSINFO:
2510
      {
2511
        char data[136];
2512
        va_list ap;
2513
 
2514
        va_start (ap, note_type);
2515
        memset (data, 0, 40);
2516
        strncpy (data + 40, va_arg (ap, const char *), 16);
2517
        strncpy (data + 56, va_arg (ap, const char *), 80);
2518
        va_end (ap);
2519
        return elfcore_write_note (abfd, buf, bufsiz,
2520
                                   "CORE", note_type, data, sizeof (data));
2521
      }
2522
 
2523
    case NT_PRSTATUS:
2524
      {
2525
        char data[504];
2526
        va_list ap;
2527
        long pid;
2528
        int cursig;
2529
        const void *greg;
2530
 
2531
        va_start (ap, note_type);
2532
        memset (data, 0, 112);
2533
        pid = va_arg (ap, long);
2534
        bfd_put_32 (abfd, pid, data + 32);
2535
        cursig = va_arg (ap, int);
2536
        bfd_put_16 (abfd, cursig, data + 12);
2537
        greg = va_arg (ap, const void *);
2538
        memcpy (data + 112, greg, 384);
2539
        memset (data + 496, 0, 8);
2540
        va_end (ap);
2541
        return elfcore_write_note (abfd, buf, bufsiz,
2542
                                   "CORE", note_type, data, sizeof (data));
2543
      }
2544
    }
2545
}
2546
 
2547
/* Merge backend specific data from an object file to the output
2548
   object file when linking.  */
2549
 
2550
static bfd_boolean
2551
ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2552
{
2553
  /* Check if we have the same endianess.  */
2554
  if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2555
      && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2556
      && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2557
    {
2558
      const char *msg;
2559
 
2560
      if (bfd_big_endian (ibfd))
2561
        msg = _("%B: compiled for a big endian system "
2562
                "and target is little endian");
2563
      else
2564
        msg = _("%B: compiled for a little endian system "
2565
                "and target is big endian");
2566
 
2567
      (*_bfd_error_handler) (msg, ibfd);
2568
 
2569
      bfd_set_error (bfd_error_wrong_format);
2570
      return FALSE;
2571
    }
2572
 
2573
  return TRUE;
2574
}
2575
 
2576
/* Add extra PPC sections.  */
2577
 
2578
static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2579
{
2580
  { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2581
  { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2582
  { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2583
  { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2584
  { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2585
  { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2586
  { NULL,                     0,  0, 0,            0 }
2587
};
2588
 
2589
enum _ppc64_sec_type {
2590
  sec_normal = 0,
2591
  sec_opd = 1,
2592
  sec_toc = 2
2593
};
2594
 
2595
struct _ppc64_elf_section_data
2596
{
2597
  struct bfd_elf_section_data elf;
2598
 
2599
  union
2600
  {
2601
    /* An array with one entry for each opd function descriptor.  */
2602
    struct _opd_sec_data
2603
    {
2604
      /* Points to the function code section for local opd entries.  */
2605
      asection **func_sec;
2606
 
2607
      /* After editing .opd, adjust references to opd local syms.  */
2608
      long *adjust;
2609
    } opd;
2610
 
2611
    /* An array for toc sections, indexed by offset/8.
2612
       Specifies the relocation symbol index used at a given toc offset.  */
2613
    unsigned *t_symndx;
2614
  } u;
2615
 
2616
  enum _ppc64_sec_type sec_type:2;
2617
 
2618
  /* Flag set when small branches are detected.  Used to
2619
     select suitable defaults for the stub group size.  */
2620
  unsigned int has_14bit_branch:1;
2621
};
2622
 
2623
#define ppc64_elf_section_data(sec) \
2624
  ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2625
 
2626
static bfd_boolean
2627
ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2628
{
2629
  if (!sec->used_by_bfd)
2630
    {
2631
      struct _ppc64_elf_section_data *sdata;
2632
      bfd_size_type amt = sizeof (*sdata);
2633
 
2634
      sdata = bfd_zalloc (abfd, amt);
2635
      if (sdata == NULL)
2636
        return FALSE;
2637
      sec->used_by_bfd = sdata;
2638
    }
2639
 
2640
  return _bfd_elf_new_section_hook (abfd, sec);
2641
}
2642
 
2643
static struct _opd_sec_data *
2644
get_opd_info (asection * sec)
2645
{
2646
  if (sec != NULL
2647
      && ppc64_elf_section_data (sec) != NULL
2648
      && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2649
    return &ppc64_elf_section_data (sec)->u.opd;
2650
  return NULL;
2651
}
2652
 
2653
/* Parameters for the qsort hook.  */
2654
static asection *synthetic_opd;
2655
static bfd_boolean synthetic_relocatable;
2656
 
2657
/* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2658
 
2659
static int
2660
compare_symbols (const void *ap, const void *bp)
2661
{
2662
  const asymbol *a = * (const asymbol **) ap;
2663
  const asymbol *b = * (const asymbol **) bp;
2664
 
2665
  /* Section symbols first.  */
2666
  if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2667
    return -1;
2668
  if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2669
    return 1;
2670
 
2671
  /* then .opd symbols.  */
2672
  if (a->section == synthetic_opd && b->section != synthetic_opd)
2673
    return -1;
2674
  if (a->section != synthetic_opd && b->section == synthetic_opd)
2675
    return 1;
2676
 
2677
  /* then other code symbols.  */
2678
  if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2679
      == (SEC_CODE | SEC_ALLOC)
2680
      && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2681
         != (SEC_CODE | SEC_ALLOC))
2682
    return -1;
2683
 
2684
  if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2685
      != (SEC_CODE | SEC_ALLOC)
2686
      && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2687
         == (SEC_CODE | SEC_ALLOC))
2688
    return 1;
2689
 
2690
  if (synthetic_relocatable)
2691
    {
2692
      if (a->section->id < b->section->id)
2693
        return -1;
2694
 
2695
      if (a->section->id > b->section->id)
2696
        return 1;
2697
    }
2698
 
2699
  if (a->value + a->section->vma < b->value + b->section->vma)
2700
    return -1;
2701
 
2702
  if (a->value + a->section->vma > b->value + b->section->vma)
2703
    return 1;
2704
 
2705
  /* For syms with the same value, prefer strong dynamic global function
2706
     syms over other syms.  */
2707
  if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2708
    return -1;
2709
 
2710
  if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2711
    return 1;
2712
 
2713
  if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2714
    return -1;
2715
 
2716
  if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2717
    return 1;
2718
 
2719
  if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2720
    return -1;
2721
 
2722
  if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2723
    return 1;
2724
 
2725
  if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2726
    return -1;
2727
 
2728
  if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2729
    return 1;
2730
 
2731
  return 0;
2732
}
2733
 
2734
/* Search SYMS for a symbol of the given VALUE.  */
2735
 
2736
static asymbol *
2737
sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2738
{
2739
  long mid;
2740
 
2741
  if (id == -1)
2742
    {
2743
      while (lo < hi)
2744
        {
2745
          mid = (lo + hi) >> 1;
2746
          if (syms[mid]->value + syms[mid]->section->vma < value)
2747
            lo = mid + 1;
2748
          else if (syms[mid]->value + syms[mid]->section->vma > value)
2749
            hi = mid;
2750
          else
2751
            return syms[mid];
2752
        }
2753
    }
2754
  else
2755
    {
2756
      while (lo < hi)
2757
        {
2758
          mid = (lo + hi) >> 1;
2759
          if (syms[mid]->section->id < id)
2760
            lo = mid + 1;
2761
          else if (syms[mid]->section->id > id)
2762
            hi = mid;
2763
          else if (syms[mid]->value < value)
2764
            lo = mid + 1;
2765
          else if (syms[mid]->value > value)
2766
            hi = mid;
2767
          else
2768
            return syms[mid];
2769
        }
2770
    }
2771
  return NULL;
2772
}
2773
 
2774
/* Create synthetic symbols, effectively restoring "dot-symbol" function
2775
   entry syms.  */
2776
 
2777
static long
2778
ppc64_elf_get_synthetic_symtab (bfd *abfd,
2779
                                long static_count, asymbol **static_syms,
2780
                                long dyn_count, asymbol **dyn_syms,
2781
                                asymbol **ret)
2782
{
2783
  asymbol *s;
2784
  long i;
2785
  long count;
2786
  char *names;
2787
  long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2788
  asection *opd;
2789
  bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2790
  asymbol **syms;
2791
 
2792
  *ret = NULL;
2793
 
2794
  opd = bfd_get_section_by_name (abfd, ".opd");
2795
  if (opd == NULL)
2796
    return 0;
2797
 
2798
  symcount = static_count;
2799
  if (!relocatable)
2800
    symcount += dyn_count;
2801
  if (symcount == 0)
2802
    return 0;
2803
 
2804
  syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2805
  if (syms == NULL)
2806
    return -1;
2807
 
2808
  if (!relocatable && static_count != 0 && dyn_count != 0)
2809
    {
2810
      /* Use both symbol tables.  */
2811
      memcpy (syms, static_syms, static_count * sizeof (*syms));
2812
      memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2813
    }
2814
  else if (!relocatable && static_count == 0)
2815
    memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2816
  else
2817
    memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2818
 
2819
  synthetic_opd = opd;
2820
  synthetic_relocatable = relocatable;
2821
  qsort (syms, symcount, sizeof (*syms), compare_symbols);
2822
 
2823
  if (!relocatable && symcount > 1)
2824
    {
2825
      long j;
2826
      /* Trim duplicate syms, since we may have merged the normal and
2827
         dynamic symbols.  Actually, we only care about syms that have
2828
         different values, so trim any with the same value.  */
2829
      for (i = 1, j = 1; i < symcount; ++i)
2830
        if (syms[i - 1]->value + syms[i - 1]->section->vma
2831
            != syms[i]->value + syms[i]->section->vma)
2832
          syms[j++] = syms[i];
2833
      symcount = j;
2834
    }
2835
 
2836
  i = 0;
2837
  if (syms[i]->section == opd)
2838
    ++i;
2839
  codesecsym = i;
2840
 
2841
  for (; i < symcount; ++i)
2842
    if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2843
         != (SEC_CODE | SEC_ALLOC))
2844
        || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2845
      break;
2846
  codesecsymend = i;
2847
 
2848
  for (; i < symcount; ++i)
2849
    if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2850
      break;
2851
  secsymend = i;
2852
 
2853
  for (; i < symcount; ++i)
2854
    if (syms[i]->section != opd)
2855
      break;
2856
  opdsymend = i;
2857
 
2858
  for (; i < symcount; ++i)
2859
    if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2860
        != (SEC_CODE | SEC_ALLOC))
2861
      break;
2862
  symcount = i;
2863
 
2864
  count = 0;
2865
  if (opdsymend == secsymend)
2866
    goto done;
2867
 
2868
  if (relocatable)
2869
    {
2870
      bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2871
      arelent *r;
2872
      size_t size;
2873
      long relcount;
2874
 
2875
      slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2876
      relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2877
      if (relcount == 0)
2878
        goto done;
2879
 
2880
      if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2881
        {
2882
          count = -1;
2883
          goto done;
2884
        }
2885
 
2886
      size = 0;
2887
      for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2888
        {
2889
          asymbol *sym;
2890
 
2891
          while (r < opd->relocation + relcount
2892
                 && r->address < syms[i]->value + opd->vma)
2893
            ++r;
2894
 
2895
          if (r == opd->relocation + relcount)
2896
            break;
2897
 
2898
          if (r->address != syms[i]->value + opd->vma)
2899
            continue;
2900
 
2901
          if (r->howto->type != R_PPC64_ADDR64)
2902
            continue;
2903
 
2904
          sym = *r->sym_ptr_ptr;
2905
          if (!sym_exists_at (syms, opdsymend, symcount,
2906
                              sym->section->id, sym->value + r->addend))
2907
            {
2908
              ++count;
2909
              size += sizeof (asymbol);
2910
              size += strlen (syms[i]->name) + 2;
2911
            }
2912
        }
2913
 
2914
      s = *ret = bfd_malloc (size);
2915
      if (s == NULL)
2916
        {
2917
          count = -1;
2918
          goto done;
2919
        }
2920
 
2921
      names = (char *) (s + count);
2922
 
2923
      for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2924
        {
2925
          asymbol *sym;
2926
 
2927
          while (r < opd->relocation + relcount
2928
                 && r->address < syms[i]->value + opd->vma)
2929
            ++r;
2930
 
2931
          if (r == opd->relocation + relcount)
2932
            break;
2933
 
2934
          if (r->address != syms[i]->value + opd->vma)
2935
            continue;
2936
 
2937
          if (r->howto->type != R_PPC64_ADDR64)
2938
            continue;
2939
 
2940
          sym = *r->sym_ptr_ptr;
2941
          if (!sym_exists_at (syms, opdsymend, symcount,
2942
                              sym->section->id, sym->value + r->addend))
2943
            {
2944
              size_t len;
2945
 
2946
              *s = *syms[i];
2947
              s->section = sym->section;
2948
              s->value = sym->value + r->addend;
2949
              s->name = names;
2950
              *names++ = '.';
2951
              len = strlen (syms[i]->name);
2952
              memcpy (names, syms[i]->name, len + 1);
2953
              names += len + 1;
2954
              /* Have udata.p point back to the original symbol this
2955
                 synthetic symbol was derived from.  */
2956
              s->udata.p = syms[i];
2957
              s++;
2958
            }
2959
        }
2960
    }
2961
  else
2962
    {
2963
      bfd_byte *contents;
2964
      size_t size;
2965
 
2966
      if (!bfd_malloc_and_get_section (abfd, opd, &contents))
2967
        {
2968
          if (contents)
2969
            {
2970
            free_contents_and_exit:
2971
              free (contents);
2972
            }
2973
          count = -1;
2974
          goto done;
2975
        }
2976
 
2977
      size = 0;
2978
      for (i = secsymend; i < opdsymend; ++i)
2979
        {
2980
          bfd_vma ent;
2981
 
2982
          ent = bfd_get_64 (abfd, contents + syms[i]->value);
2983
          if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2984
            {
2985
              ++count;
2986
              size += sizeof (asymbol);
2987
              size += strlen (syms[i]->name) + 2;
2988
            }
2989
        }
2990
 
2991
      s = *ret = bfd_malloc (size);
2992
      if (s == NULL)
2993
        goto free_contents_and_exit;
2994
 
2995
      names = (char *) (s + count);
2996
 
2997
      for (i = secsymend; i < opdsymend; ++i)
2998
        {
2999
          bfd_vma ent;
3000
 
3001
          ent = bfd_get_64 (abfd, contents + syms[i]->value);
3002
          if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3003
            {
3004
              long lo, hi;
3005
              size_t len;
3006
              asection *sec = abfd->sections;
3007
 
3008
              *s = *syms[i];
3009
              lo = codesecsym;
3010
              hi = codesecsymend;
3011
              while (lo < hi)
3012
                {
3013
                  long mid = (lo + hi) >> 1;
3014
                  if (syms[mid]->section->vma < ent)
3015
                    lo = mid + 1;
3016
                  else if (syms[mid]->section->vma > ent)
3017
                    hi = mid;
3018
                  else
3019
                    {
3020
                      sec = syms[mid]->section;
3021
                      break;
3022
                    }
3023
                }
3024
 
3025
              if (lo >= hi && lo > codesecsym)
3026
                sec = syms[lo - 1]->section;
3027
 
3028
              for (; sec != NULL; sec = sec->next)
3029
                {
3030
                  if (sec->vma > ent)
3031
                    break;
3032
                  if ((sec->flags & SEC_ALLOC) == 0
3033
                      || (sec->flags & SEC_LOAD) == 0)
3034
                    break;
3035
                  if ((sec->flags & SEC_CODE) != 0)
3036
                    s->section = sec;
3037
                }
3038
              s->value = ent - s->section->vma;
3039
              s->name = names;
3040
              *names++ = '.';
3041
              len = strlen (syms[i]->name);
3042
              memcpy (names, syms[i]->name, len + 1);
3043
              names += len + 1;
3044
              /* Have udata.p point back to the original symbol this
3045
                 synthetic symbol was derived from.  */
3046
              s->udata.p = syms[i];
3047
              s++;
3048
            }
3049
        }
3050
      free (contents);
3051
    }
3052
 
3053
 done:
3054
  free (syms);
3055
  return count;
3056
}
3057
 
3058
/* The following functions are specific to the ELF linker, while
3059
   functions above are used generally.  Those named ppc64_elf_* are
3060
   called by the main ELF linker code.  They appear in this file more
3061
   or less in the order in which they are called.  eg.
3062
   ppc64_elf_check_relocs is called early in the link process,
3063
   ppc64_elf_finish_dynamic_sections is one of the last functions
3064
   called.
3065
 
3066
   PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3067
   functions have both a function code symbol and a function descriptor
3068
   symbol.  A call to foo in a relocatable object file looks like:
3069
 
3070
   .            .text
3071
   .    x:
3072
   .            bl      .foo
3073
   .            nop
3074
 
3075
   The function definition in another object file might be:
3076
 
3077
   .            .section .opd
3078
   .    foo:    .quad   .foo
3079
   .            .quad   .TOC.@tocbase
3080
   .            .quad   0
3081
   .
3082
   .            .text
3083
   .    .foo:   blr
3084
 
3085
   When the linker resolves the call during a static link, the branch
3086
   unsurprisingly just goes to .foo and the .opd information is unused.
3087
   If the function definition is in a shared library, things are a little
3088
   different:  The call goes via a plt call stub, the opd information gets
3089
   copied to the plt, and the linker patches the nop.
3090
 
3091
   .    x:
3092
   .            bl      .foo_stub
3093
   .            ld      2,40(1)
3094
   .
3095
   .
3096
   .    .foo_stub:
3097
   .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3098
   .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3099
   .            std     2,40(1)                 # this is the general idea
3100
   .            ld      11,0(12)
3101
   .            ld      2,8(12)
3102
   .            mtctr   11
3103
   .            ld      11,16(12)
3104
   .            bctr
3105
   .
3106
   .            .section .plt
3107
   .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3108
 
3109
   The "reloc ()" notation is supposed to indicate that the linker emits
3110
   an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3111
   copying.
3112
 
3113
   What are the difficulties here?  Well, firstly, the relocations
3114
   examined by the linker in check_relocs are against the function code
3115
   sym .foo, while the dynamic relocation in the plt is emitted against
3116
   the function descriptor symbol, foo.  Somewhere along the line, we need
3117
   to carefully copy dynamic link information from one symbol to the other.
3118
   Secondly, the generic part of the elf linker will make .foo a dynamic
3119
   symbol as is normal for most other backends.  We need foo dynamic
3120
   instead, at least for an application final link.  However, when
3121
   creating a shared library containing foo, we need to have both symbols
3122
   dynamic so that references to .foo are satisfied during the early
3123
   stages of linking.  Otherwise the linker might decide to pull in a
3124
   definition from some other object, eg. a static library.
3125
 
3126
   Update: As of August 2004, we support a new convention.  Function
3127
   calls may use the function descriptor symbol, ie. "bl foo".  This
3128
   behaves exactly as "bl .foo".  */
3129
 
3130
/* The linker needs to keep track of the number of relocs that it
3131
   decides to copy as dynamic relocs in check_relocs for each symbol.
3132
   This is so that it can later discard them if they are found to be
3133
   unnecessary.  We store the information in a field extending the
3134
   regular ELF linker hash table.  */
3135
 
3136
struct ppc_dyn_relocs
3137
{
3138
  struct ppc_dyn_relocs *next;
3139
 
3140
  /* The input section of the reloc.  */
3141
  asection *sec;
3142
 
3143
  /* Total number of relocs copied for the input section.  */
3144
  bfd_size_type count;
3145
 
3146
  /* Number of pc-relative relocs copied for the input section.  */
3147
  bfd_size_type pc_count;
3148
};
3149
 
3150
/* Track GOT entries needed for a given symbol.  We might need more
3151
   than one got entry per symbol.  */
3152
struct got_entry
3153
{
3154
  struct got_entry *next;
3155
 
3156
  /* The symbol addend that we'll be placing in the GOT.  */
3157
  bfd_vma addend;
3158
 
3159
  /* Unlike other ELF targets, we use separate GOT entries for the same
3160
     symbol referenced from different input files.  This is to support
3161
     automatic multiple TOC/GOT sections, where the TOC base can vary
3162
     from one input file to another.  FIXME: After group_sections we
3163
     ought to merge entries within the group.
3164
 
3165
     Point to the BFD owning this GOT entry.  */
3166
  bfd *owner;
3167
 
3168
  /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3169
     TLS_TPREL or TLS_DTPREL for tls entries.  */
3170
  char tls_type;
3171
 
3172
  /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
3173
  union
3174
    {
3175
      bfd_signed_vma refcount;
3176
      bfd_vma offset;
3177
    } got;
3178
};
3179
 
3180
/* The same for PLT.  */
3181
struct plt_entry
3182
{
3183
  struct plt_entry *next;
3184
 
3185
  bfd_vma addend;
3186
 
3187
  union
3188
    {
3189
      bfd_signed_vma refcount;
3190
      bfd_vma offset;
3191
    } plt;
3192
};
3193
 
3194
/* Of those relocs that might be copied as dynamic relocs, this macro
3195
   selects those that must be copied when linking a shared library,
3196
   even when the symbol is local.  */
3197
 
3198
#define MUST_BE_DYN_RELOC(RTYPE)                \
3199
  ((RTYPE) != R_PPC64_REL32                     \
3200
   && (RTYPE) != R_PPC64_REL64                  \
3201
   && (RTYPE) != R_PPC64_REL30)
3202
 
3203
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3204
   copying dynamic variables from a shared lib into an app's dynbss
3205
   section, and instead use a dynamic relocation to point into the
3206
   shared lib.  With code that gcc generates, it's vital that this be
3207
   enabled;  In the PowerPC64 ABI, the address of a function is actually
3208
   the address of a function descriptor, which resides in the .opd
3209
   section.  gcc uses the descriptor directly rather than going via the
3210
   GOT as some other ABI's do, which means that initialized function
3211
   pointers must reference the descriptor.  Thus, a function pointer
3212
   initialized to the address of a function in a shared library will
3213
   either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3214
   redefines the function descriptor symbol to point to the copy.  This
3215
   presents a problem as a plt entry for that function is also
3216
   initialized from the function descriptor symbol and the copy reloc
3217
   may not be initialized first.  */
3218
#define ELIMINATE_COPY_RELOCS 1
3219
 
3220
/* Section name for stubs is the associated section name plus this
3221
   string.  */
3222
#define STUB_SUFFIX ".stub"
3223
 
3224
/* Linker stubs.
3225
   ppc_stub_long_branch:
3226
   Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3227
   destination, but a 24 bit branch in a stub section will reach.
3228
   .    b       dest
3229
 
3230
   ppc_stub_plt_branch:
3231
   Similar to the above, but a 24 bit branch in the stub section won't
3232
   reach its destination.
3233
   .    addis   %r12,%r2,xxx@toc@ha
3234
   .    ld      %r11,xxx@toc@l(%r12)
3235
   .    mtctr   %r11
3236
   .    bctr
3237
 
3238
   ppc_stub_plt_call:
3239
   Used to call a function in a shared library.  If it so happens that
3240
   the plt entry referenced crosses a 64k boundary, then an extra
3241
   "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3242
   .    addis   %r12,%r2,xxx@toc@ha
3243
   .    std     %r2,40(%r1)
3244
   .    ld      %r11,xxx+0@toc@l(%r12)
3245
   .    mtctr   %r11
3246
   .    ld      %r2,xxx+8@toc@l(%r12)
3247
   .    ld      %r11,xxx+16@toc@l(%r12)
3248
   .    bctr
3249
 
3250
   ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3251
   code to adjust the value and save r2 to support multiple toc sections.
3252
   A ppc_stub_long_branch with an r2 offset looks like:
3253
   .    std     %r2,40(%r1)
3254
   .    addis   %r2,%r2,off@ha
3255
   .    addi    %r2,%r2,off@l
3256
   .    b       dest
3257
 
3258
   A ppc_stub_plt_branch with an r2 offset looks like:
3259
   .    std     %r2,40(%r1)
3260
   .    addis   %r12,%r2,xxx@toc@ha
3261
   .    ld      %r11,xxx@toc@l(%r12)
3262
   .    addis   %r2,%r2,off@ha
3263
   .    addi    %r2,%r2,off@l
3264
   .    mtctr   %r11
3265
   .    bctr
3266
 
3267
   In cases where the "addis" instruction would add zero, the "addis" is
3268
   omitted and following instructions modified slightly in some cases.
3269
*/
3270
 
3271
enum ppc_stub_type {
3272
  ppc_stub_none,
3273
  ppc_stub_long_branch,
3274
  ppc_stub_long_branch_r2off,
3275
  ppc_stub_plt_branch,
3276
  ppc_stub_plt_branch_r2off,
3277
  ppc_stub_plt_call
3278
};
3279
 
3280
struct ppc_stub_hash_entry {
3281
 
3282
  /* Base hash table entry structure.  */
3283
  struct bfd_hash_entry root;
3284
 
3285
  enum ppc_stub_type stub_type;
3286
 
3287
  /* The stub section.  */
3288
  asection *stub_sec;
3289
 
3290
  /* Offset within stub_sec of the beginning of this stub.  */
3291
  bfd_vma stub_offset;
3292
 
3293
  /* Given the symbol's value and its section we can determine its final
3294
     value when building the stubs (so the stub knows where to jump.  */
3295
  bfd_vma target_value;
3296
  asection *target_section;
3297
 
3298
  /* The symbol table entry, if any, that this was derived from.  */
3299
  struct ppc_link_hash_entry *h;
3300
 
3301
  /* And the reloc addend that this was derived from.  */
3302
  bfd_vma addend;
3303
 
3304
  /* Where this stub is being called from, or, in the case of combined
3305
     stub sections, the first input section in the group.  */
3306
  asection *id_sec;
3307
};
3308
 
3309
struct ppc_branch_hash_entry {
3310
 
3311
  /* Base hash table entry structure.  */
3312
  struct bfd_hash_entry root;
3313
 
3314
  /* Offset within branch lookup table.  */
3315
  unsigned int offset;
3316
 
3317
  /* Generation marker.  */
3318
  unsigned int iter;
3319
};
3320
 
3321
struct ppc_link_hash_entry
3322
{
3323
  struct elf_link_hash_entry elf;
3324
 
3325
  union {
3326
    /* A pointer to the most recently used stub hash entry against this
3327
       symbol.  */
3328
    struct ppc_stub_hash_entry *stub_cache;
3329
 
3330
    /* A pointer to the next symbol starting with a '.'  */
3331
    struct ppc_link_hash_entry *next_dot_sym;
3332
  } u;
3333
 
3334
  /* Track dynamic relocs copied for this symbol.  */
3335
  struct ppc_dyn_relocs *dyn_relocs;
3336
 
3337
  /* Link between function code and descriptor symbols.  */
3338
  struct ppc_link_hash_entry *oh;
3339
 
3340
  /* Flag function code and descriptor symbols.  */
3341
  unsigned int is_func:1;
3342
  unsigned int is_func_descriptor:1;
3343
  unsigned int fake:1;
3344
 
3345
  /* Whether global opd/toc sym has been adjusted or not.
3346
     After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3347
     should be set for all globals defined in any opd/toc section.  */
3348
  unsigned int adjust_done:1;
3349
 
3350
  /* Set if we twiddled this symbol to weak at some stage.  */
3351
  unsigned int was_undefined:1;
3352
 
3353
  /* Contexts in which symbol is used in the GOT (or TOC).
3354
     TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3355
     corresponding relocs are encountered during check_relocs.
3356
     tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3357
     indicate the corresponding GOT entry type is not needed.
3358
     tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3359
     a TPREL one.  We use a separate flag rather than setting TPREL
3360
     just for convenience in distinguishing the two cases.  */
3361
#define TLS_GD           1      /* GD reloc. */
3362
#define TLS_LD           2      /* LD reloc. */
3363
#define TLS_TPREL        4      /* TPREL reloc, => IE. */
3364
#define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3365
#define TLS_TLS         16      /* Any TLS reloc.  */
3366
#define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3367
#define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3368
  char tls_mask;
3369
};
3370
 
3371
/* ppc64 ELF linker hash table.  */
3372
 
3373
struct ppc_link_hash_table
3374
{
3375
  struct elf_link_hash_table elf;
3376
 
3377
  /* The stub hash table.  */
3378
  struct bfd_hash_table stub_hash_table;
3379
 
3380
  /* Another hash table for plt_branch stubs.  */
3381
  struct bfd_hash_table branch_hash_table;
3382
 
3383
  /* Linker stub bfd.  */
3384
  bfd *stub_bfd;
3385
 
3386
  /* Linker call-backs.  */
3387
  asection * (*add_stub_section) (const char *, asection *);
3388
  void (*layout_sections_again) (void);
3389
 
3390
  /* Array to keep track of which stub sections have been created, and
3391
     information on stub grouping.  */
3392
  struct map_stub {
3393
    /* This is the section to which stubs in the group will be attached.  */
3394
    asection *link_sec;
3395
    /* The stub section.  */
3396
    asection *stub_sec;
3397
    /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3398
    bfd_vma toc_off;
3399
  } *stub_group;
3400
 
3401
  /* Temp used when calculating TOC pointers.  */
3402
  bfd_vma toc_curr;
3403
 
3404
  /* Highest input section id.  */
3405
  int top_id;
3406
 
3407
  /* Highest output section index.  */
3408
  int top_index;
3409
 
3410
  /* Used when adding symbols.  */
3411
  struct ppc_link_hash_entry *dot_syms;
3412
 
3413
  /* List of input sections for each output section.  */
3414
  asection **input_list;
3415
 
3416
  /* Short-cuts to get to dynamic linker sections.  */
3417
  asection *got;
3418
  asection *plt;
3419
  asection *relplt;
3420
  asection *dynbss;
3421
  asection *relbss;
3422
  asection *glink;
3423
  asection *sfpr;
3424
  asection *brlt;
3425
  asection *relbrlt;
3426
 
3427
  /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3428
  struct ppc_link_hash_entry *tls_get_addr;
3429
  struct ppc_link_hash_entry *tls_get_addr_fd;
3430
 
3431
  /* Statistics.  */
3432
  unsigned long stub_count[ppc_stub_plt_call];
3433
 
3434
  /* Number of stubs against global syms.  */
3435
  unsigned long stub_globals;
3436
 
3437
  /* Set if we should emit symbols for stubs.  */
3438
  unsigned int emit_stub_syms:1;
3439
 
3440
  /* Support for multiple toc sections.  */
3441
  unsigned int no_multi_toc:1;
3442
  unsigned int multi_toc_needed:1;
3443
 
3444
  /* Set on error.  */
3445
  unsigned int stub_error:1;
3446
 
3447
  /* Temp used by ppc64_elf_check_directives.  */
3448
  unsigned int twiddled_syms:1;
3449
 
3450
  /* Incremented every time we size stubs.  */
3451
  unsigned int stub_iteration;
3452
 
3453
  /* Small local sym to section mapping cache.  */
3454
  struct sym_sec_cache sym_sec;
3455
};
3456
 
3457
/* Rename some of the generic section flags to better document how they
3458
   are used here.  */
3459
#define has_toc_reloc has_gp_reloc
3460
#define makes_toc_func_call need_finalize_relax
3461
#define call_check_in_progress reloc_done
3462
 
3463
/* Get the ppc64 ELF linker hash table from a link_info structure.  */
3464
 
3465
#define ppc_hash_table(p) \
3466
  ((struct ppc_link_hash_table *) ((p)->hash))
3467
 
3468
#define ppc_stub_hash_lookup(table, string, create, copy) \
3469
  ((struct ppc_stub_hash_entry *) \
3470
   bfd_hash_lookup ((table), (string), (create), (copy)))
3471
 
3472
#define ppc_branch_hash_lookup(table, string, create, copy) \
3473
  ((struct ppc_branch_hash_entry *) \
3474
   bfd_hash_lookup ((table), (string), (create), (copy)))
3475
 
3476
/* Create an entry in the stub hash table.  */
3477
 
3478
static struct bfd_hash_entry *
3479
stub_hash_newfunc (struct bfd_hash_entry *entry,
3480
                   struct bfd_hash_table *table,
3481
                   const char *string)
3482
{
3483
  /* Allocate the structure if it has not already been allocated by a
3484
     subclass.  */
3485
  if (entry == NULL)
3486
    {
3487
      entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3488
      if (entry == NULL)
3489
        return entry;
3490
    }
3491
 
3492
  /* Call the allocation method of the superclass.  */
3493
  entry = bfd_hash_newfunc (entry, table, string);
3494
  if (entry != NULL)
3495
    {
3496
      struct ppc_stub_hash_entry *eh;
3497
 
3498
      /* Initialize the local fields.  */
3499
      eh = (struct ppc_stub_hash_entry *) entry;
3500
      eh->stub_type = ppc_stub_none;
3501
      eh->stub_sec = NULL;
3502
      eh->stub_offset = 0;
3503
      eh->target_value = 0;
3504
      eh->target_section = NULL;
3505
      eh->h = NULL;
3506
      eh->id_sec = NULL;
3507
    }
3508
 
3509
  return entry;
3510
}
3511
 
3512
/* Create an entry in the branch hash table.  */
3513
 
3514
static struct bfd_hash_entry *
3515
branch_hash_newfunc (struct bfd_hash_entry *entry,
3516
                     struct bfd_hash_table *table,
3517
                     const char *string)
3518
{
3519
  /* Allocate the structure if it has not already been allocated by a
3520
     subclass.  */
3521
  if (entry == NULL)
3522
    {
3523
      entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3524
      if (entry == NULL)
3525
        return entry;
3526
    }
3527
 
3528
  /* Call the allocation method of the superclass.  */
3529
  entry = bfd_hash_newfunc (entry, table, string);
3530
  if (entry != NULL)
3531
    {
3532
      struct ppc_branch_hash_entry *eh;
3533
 
3534
      /* Initialize the local fields.  */
3535
      eh = (struct ppc_branch_hash_entry *) entry;
3536
      eh->offset = 0;
3537
      eh->iter = 0;
3538
    }
3539
 
3540
  return entry;
3541
}
3542
 
3543
/* Create an entry in a ppc64 ELF linker hash table.  */
3544
 
3545
static struct bfd_hash_entry *
3546
link_hash_newfunc (struct bfd_hash_entry *entry,
3547
                   struct bfd_hash_table *table,
3548
                   const char *string)
3549
{
3550
  /* Allocate the structure if it has not already been allocated by a
3551
     subclass.  */
3552
  if (entry == NULL)
3553
    {
3554
      entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3555
      if (entry == NULL)
3556
        return entry;
3557
    }
3558
 
3559
  /* Call the allocation method of the superclass.  */
3560
  entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3561
  if (entry != NULL)
3562
    {
3563
      struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3564
 
3565
      memset (&eh->u.stub_cache, 0,
3566
              (sizeof (struct ppc_link_hash_entry)
3567
               - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3568
 
3569
      /* When making function calls, old ABI code references function entry
3570
         points (dot symbols), while new ABI code references the function
3571
         descriptor symbol.  We need to make any combination of reference and
3572
         definition work together, without breaking archive linking.
3573
 
3574
         For a defined function "foo" and an undefined call to "bar":
3575
         An old object defines "foo" and ".foo", references ".bar" (possibly
3576
         "bar" too).
3577
         A new object defines "foo" and references "bar".
3578
 
3579
         A new object thus has no problem with its undefined symbols being
3580
         satisfied by definitions in an old object.  On the other hand, the
3581
         old object won't have ".bar" satisfied by a new object.
3582
 
3583
         Keep a list of newly added dot-symbols.  */
3584
 
3585
      if (string[0] == '.')
3586
        {
3587
          struct ppc_link_hash_table *htab;
3588
 
3589
          htab = (struct ppc_link_hash_table *) table;
3590
          eh->u.next_dot_sym = htab->dot_syms;
3591
          htab->dot_syms = eh;
3592
        }
3593
    }
3594
 
3595
  return entry;
3596
}
3597
 
3598
/* Create a ppc64 ELF linker hash table.  */
3599
 
3600
static struct bfd_link_hash_table *
3601
ppc64_elf_link_hash_table_create (bfd *abfd)
3602
{
3603
  struct ppc_link_hash_table *htab;
3604
  bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3605
 
3606
  htab = bfd_zmalloc (amt);
3607
  if (htab == NULL)
3608
    return NULL;
3609
 
3610
  if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3611
                                      sizeof (struct ppc_link_hash_entry)))
3612
    {
3613
      free (htab);
3614
      return NULL;
3615
    }
3616
 
3617
  /* Init the stub hash table too.  */
3618
  if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3619
                            sizeof (struct ppc_stub_hash_entry)))
3620
    return NULL;
3621
 
3622
  /* And the branch hash table.  */
3623
  if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3624
                            sizeof (struct ppc_branch_hash_entry)))
3625
    return NULL;
3626
 
3627
  /* Initializing two fields of the union is just cosmetic.  We really
3628
     only care about glist, but when compiled on a 32-bit host the
3629
     bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3630
     debugger inspection of these fields look nicer.  */
3631
  htab->elf.init_got_refcount.refcount = 0;
3632
  htab->elf.init_got_refcount.glist = NULL;
3633
  htab->elf.init_plt_refcount.refcount = 0;
3634
  htab->elf.init_plt_refcount.glist = NULL;
3635
  htab->elf.init_got_offset.offset = 0;
3636
  htab->elf.init_got_offset.glist = NULL;
3637
  htab->elf.init_plt_offset.offset = 0;
3638
  htab->elf.init_plt_offset.glist = NULL;
3639
 
3640
  return &htab->elf.root;
3641
}
3642
 
3643
/* Free the derived linker hash table.  */
3644
 
3645
static void
3646
ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3647
{
3648
  struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3649
 
3650
  bfd_hash_table_free (&ret->stub_hash_table);
3651
  bfd_hash_table_free (&ret->branch_hash_table);
3652
  _bfd_generic_link_hash_table_free (hash);
3653
}
3654
 
3655
/* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3656
 
3657
void
3658
ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3659
{
3660
  struct ppc_link_hash_table *htab;
3661
 
3662
  elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3663
 
3664
/* Always hook our dynamic sections into the first bfd, which is the
3665
   linker created stub bfd.  This ensures that the GOT header is at
3666
   the start of the output TOC section.  */
3667
  htab = ppc_hash_table (info);
3668
  htab->stub_bfd = abfd;
3669
  htab->elf.dynobj = abfd;
3670
}
3671
 
3672
/* Build a name for an entry in the stub hash table.  */
3673
 
3674
static char *
3675
ppc_stub_name (const asection *input_section,
3676
               const asection *sym_sec,
3677
               const struct ppc_link_hash_entry *h,
3678
               const Elf_Internal_Rela *rel)
3679
{
3680
  char *stub_name;
3681
  bfd_size_type len;
3682
 
3683
  /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3684
     offsets from a sym as a branch target?  In fact, we could
3685
     probably assume the addend is always zero.  */
3686
  BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3687
 
3688
  if (h)
3689
    {
3690
      len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3691
      stub_name = bfd_malloc (len);
3692
      if (stub_name == NULL)
3693
        return stub_name;
3694
 
3695
      sprintf (stub_name, "%08x.%s+%x",
3696
               input_section->id & 0xffffffff,
3697
               h->elf.root.root.string,
3698
               (int) rel->r_addend & 0xffffffff);
3699
    }
3700
  else
3701
    {
3702
      len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3703
      stub_name = bfd_malloc (len);
3704
      if (stub_name == NULL)
3705
        return stub_name;
3706
 
3707
      sprintf (stub_name, "%08x.%x:%x+%x",
3708
               input_section->id & 0xffffffff,
3709
               sym_sec->id & 0xffffffff,
3710
               (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3711
               (int) rel->r_addend & 0xffffffff);
3712
    }
3713
  if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3714
    stub_name[len - 2] = 0;
3715
  return stub_name;
3716
}
3717
 
3718
/* Look up an entry in the stub hash.  Stub entries are cached because
3719
   creating the stub name takes a bit of time.  */
3720
 
3721
static struct ppc_stub_hash_entry *
3722
ppc_get_stub_entry (const asection *input_section,
3723
                    const asection *sym_sec,
3724
                    struct ppc_link_hash_entry *h,
3725
                    const Elf_Internal_Rela *rel,
3726
                    struct ppc_link_hash_table *htab)
3727
{
3728
  struct ppc_stub_hash_entry *stub_entry;
3729
  const asection *id_sec;
3730
 
3731
  /* If this input section is part of a group of sections sharing one
3732
     stub section, then use the id of the first section in the group.
3733
     Stub names need to include a section id, as there may well be
3734
     more than one stub used to reach say, printf, and we need to
3735
     distinguish between them.  */
3736
  id_sec = htab->stub_group[input_section->id].link_sec;
3737
 
3738
  if (h != NULL && h->u.stub_cache != NULL
3739
      && h->u.stub_cache->h == h
3740
      && h->u.stub_cache->id_sec == id_sec)
3741
    {
3742
      stub_entry = h->u.stub_cache;
3743
    }
3744
  else
3745
    {
3746
      char *stub_name;
3747
 
3748
      stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3749
      if (stub_name == NULL)
3750
        return NULL;
3751
 
3752
      stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3753
                                         stub_name, FALSE, FALSE);
3754
      if (h != NULL)
3755
        h->u.stub_cache = stub_entry;
3756
 
3757
      free (stub_name);
3758
    }
3759
 
3760
  return stub_entry;
3761
}
3762
 
3763
/* Add a new stub entry to the stub hash.  Not all fields of the new
3764
   stub entry are initialised.  */
3765
 
3766
static struct ppc_stub_hash_entry *
3767
ppc_add_stub (const char *stub_name,
3768
              asection *section,
3769
              struct ppc_link_hash_table *htab)
3770
{
3771
  asection *link_sec;
3772
  asection *stub_sec;
3773
  struct ppc_stub_hash_entry *stub_entry;
3774
 
3775
  link_sec = htab->stub_group[section->id].link_sec;
3776
  stub_sec = htab->stub_group[section->id].stub_sec;
3777
  if (stub_sec == NULL)
3778
    {
3779
      stub_sec = htab->stub_group[link_sec->id].stub_sec;
3780
      if (stub_sec == NULL)
3781
        {
3782
          size_t namelen;
3783
          bfd_size_type len;
3784
          char *s_name;
3785
 
3786
          namelen = strlen (link_sec->name);
3787
          len = namelen + sizeof (STUB_SUFFIX);
3788
          s_name = bfd_alloc (htab->stub_bfd, len);
3789
          if (s_name == NULL)
3790
            return NULL;
3791
 
3792
          memcpy (s_name, link_sec->name, namelen);
3793
          memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3794
          stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3795
          if (stub_sec == NULL)
3796
            return NULL;
3797
          htab->stub_group[link_sec->id].stub_sec = stub_sec;
3798
        }
3799
      htab->stub_group[section->id].stub_sec = stub_sec;
3800
    }
3801
 
3802
  /* Enter this entry into the linker stub hash table.  */
3803
  stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3804
                                     TRUE, FALSE);
3805
  if (stub_entry == NULL)
3806
    {
3807
      (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3808
                             section->owner, stub_name);
3809
      return NULL;
3810
    }
3811
 
3812
  stub_entry->stub_sec = stub_sec;
3813
  stub_entry->stub_offset = 0;
3814
  stub_entry->id_sec = link_sec;
3815
  return stub_entry;
3816
}
3817
 
3818
/* Create sections for linker generated code.  */
3819
 
3820
static bfd_boolean
3821
create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3822
{
3823
  struct ppc_link_hash_table *htab;
3824
  flagword flags;
3825
 
3826
  htab = ppc_hash_table (info);
3827
 
3828
  /* Create .sfpr for code to save and restore fp regs.  */
3829
  flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3830
           | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3831
  htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
3832
                                                   flags);
3833
  if (htab->sfpr == NULL
3834
      || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3835
    return FALSE;
3836
 
3837
  /* Create .glink for lazy dynamic linking support.  */
3838
  htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3839
                                                    flags);
3840
  if (htab->glink == NULL
3841
      || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
3842
    return FALSE;
3843
 
3844
  /* Create branch lookup table for plt_branch stubs.  */
3845
  flags = (SEC_ALLOC | SEC_LOAD
3846
           | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3847
  htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
3848
                                                   flags);
3849
  if (htab->brlt == NULL
3850
      || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
3851
    return FALSE;
3852
 
3853
  if (!info->shared)
3854
    return TRUE;
3855
 
3856
  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3857
           | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3858
  htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
3859
                                                      ".rela.branch_lt",
3860
                                                      flags);
3861
  if (!htab->relbrlt
3862
      || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3863
    return FALSE;
3864
 
3865
  return TRUE;
3866
}
3867
 
3868
/* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3869
   not already done.  */
3870
 
3871
static bfd_boolean
3872
create_got_section (bfd *abfd, struct bfd_link_info *info)
3873
{
3874
  asection *got, *relgot;
3875
  flagword flags;
3876
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
3877
 
3878
  if (!is_ppc64_elf (abfd))
3879
    return FALSE;
3880
 
3881
  if (!htab->got)
3882
    {
3883
      if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
3884
        return FALSE;
3885
 
3886
      htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
3887
      if (!htab->got)
3888
        abort ();
3889
    }
3890
 
3891
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3892
           | SEC_LINKER_CREATED);
3893
 
3894
  got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3895
  if (!got
3896
      || !bfd_set_section_alignment (abfd, got, 3))
3897
    return FALSE;
3898
 
3899
  relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
3900
                                               flags | SEC_READONLY);
3901
  if (!relgot
3902
      || ! bfd_set_section_alignment (abfd, relgot, 3))
3903
    return FALSE;
3904
 
3905
  ppc64_elf_tdata (abfd)->got = got;
3906
  ppc64_elf_tdata (abfd)->relgot = relgot;
3907
  return TRUE;
3908
}
3909
 
3910
/* Create the dynamic sections, and set up shortcuts.  */
3911
 
3912
static bfd_boolean
3913
ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3914
{
3915
  struct ppc_link_hash_table *htab;
3916
 
3917
  if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3918
    return FALSE;
3919
 
3920
  htab = ppc_hash_table (info);
3921
  if (!htab->got)
3922
    htab->got = bfd_get_section_by_name (dynobj, ".got");
3923
  htab->plt = bfd_get_section_by_name (dynobj, ".plt");
3924
  htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
3925
  htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
3926
  if (!info->shared)
3927
    htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
3928
 
3929
  if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
3930
      || (!info->shared && !htab->relbss))
3931
    abort ();
3932
 
3933
  return TRUE;
3934
}
3935
 
3936
/* Merge PLT info on FROM with that on TO.  */
3937
 
3938
static void
3939
move_plt_plist (struct ppc_link_hash_entry *from,
3940
                struct ppc_link_hash_entry *to)
3941
{
3942
  if (from->elf.plt.plist != NULL)
3943
    {
3944
      if (to->elf.plt.plist != NULL)
3945
        {
3946
          struct plt_entry **entp;
3947
          struct plt_entry *ent;
3948
 
3949
          for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
3950
            {
3951
              struct plt_entry *dent;
3952
 
3953
              for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
3954
                if (dent->addend == ent->addend)
3955
                  {
3956
                    dent->plt.refcount += ent->plt.refcount;
3957
                    *entp = ent->next;
3958
                    break;
3959
                  }
3960
              if (dent == NULL)
3961
                entp = &ent->next;
3962
            }
3963
          *entp = to->elf.plt.plist;
3964
        }
3965
 
3966
      to->elf.plt.plist = from->elf.plt.plist;
3967
      from->elf.plt.plist = NULL;
3968
    }
3969
}
3970
 
3971
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
3972
 
3973
static void
3974
ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
3975
                                struct elf_link_hash_entry *dir,
3976
                                struct elf_link_hash_entry *ind)
3977
{
3978
  struct ppc_link_hash_entry *edir, *eind;
3979
 
3980
  edir = (struct ppc_link_hash_entry *) dir;
3981
  eind = (struct ppc_link_hash_entry *) ind;
3982
 
3983
  /* Copy over any dynamic relocs we may have on the indirect sym.  */
3984
  if (eind->dyn_relocs != NULL)
3985
    {
3986
      if (edir->dyn_relocs != NULL)
3987
        {
3988
          struct ppc_dyn_relocs **pp;
3989
          struct ppc_dyn_relocs *p;
3990
 
3991
          /* Add reloc counts against the indirect sym to the direct sym
3992
             list.  Merge any entries against the same section.  */
3993
          for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3994
            {
3995
              struct ppc_dyn_relocs *q;
3996
 
3997
              for (q = edir->dyn_relocs; q != NULL; q = q->next)
3998
                if (q->sec == p->sec)
3999
                  {
4000
                    q->pc_count += p->pc_count;
4001
                    q->count += p->count;
4002
                    *pp = p->next;
4003
                    break;
4004
                  }
4005
              if (q == NULL)
4006
                pp = &p->next;
4007
            }
4008
          *pp = edir->dyn_relocs;
4009
        }
4010
 
4011
      edir->dyn_relocs = eind->dyn_relocs;
4012
      eind->dyn_relocs = NULL;
4013
    }
4014
 
4015
  edir->is_func |= eind->is_func;
4016
  edir->is_func_descriptor |= eind->is_func_descriptor;
4017
  edir->tls_mask |= eind->tls_mask;
4018
 
4019
  /* If called to transfer flags for a weakdef during processing
4020
     of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4021
     We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4022
  if (!(ELIMINATE_COPY_RELOCS
4023
        && eind->elf.root.type != bfd_link_hash_indirect
4024
        && edir->elf.dynamic_adjusted))
4025
    edir->elf.non_got_ref |= eind->elf.non_got_ref;
4026
 
4027
  edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4028
  edir->elf.ref_regular |= eind->elf.ref_regular;
4029
  edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4030
  edir->elf.needs_plt |= eind->elf.needs_plt;
4031
 
4032
  /* If we were called to copy over info for a weak sym, that's all.  */
4033
  if (eind->elf.root.type != bfd_link_hash_indirect)
4034
    return;
4035
 
4036
  /* Copy over got entries that we may have already seen to the
4037
     symbol which just became indirect.  */
4038
  if (eind->elf.got.glist != NULL)
4039
    {
4040
      if (edir->elf.got.glist != NULL)
4041
        {
4042
          struct got_entry **entp;
4043
          struct got_entry *ent;
4044
 
4045
          for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4046
            {
4047
              struct got_entry *dent;
4048
 
4049
              for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4050
                if (dent->addend == ent->addend
4051
                    && dent->owner == ent->owner
4052
                    && dent->tls_type == ent->tls_type)
4053
                  {
4054
                    dent->got.refcount += ent->got.refcount;
4055
                    *entp = ent->next;
4056
                    break;
4057
                  }
4058
              if (dent == NULL)
4059
                entp = &ent->next;
4060
            }
4061
          *entp = edir->elf.got.glist;
4062
        }
4063
 
4064
      edir->elf.got.glist = eind->elf.got.glist;
4065
      eind->elf.got.glist = NULL;
4066
    }
4067
 
4068
  /* And plt entries.  */
4069
  move_plt_plist (eind, edir);
4070
 
4071
  if (eind->elf.dynindx != -1)
4072
    {
4073
      if (edir->elf.dynindx != -1)
4074
        _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4075
                                edir->elf.dynstr_index);
4076
      edir->elf.dynindx = eind->elf.dynindx;
4077
      edir->elf.dynstr_index = eind->elf.dynstr_index;
4078
      eind->elf.dynindx = -1;
4079
      eind->elf.dynstr_index = 0;
4080
    }
4081
}
4082
 
4083
/* Find the function descriptor hash entry from the given function code
4084
   hash entry FH.  Link the entries via their OH fields.  */
4085
 
4086
static struct ppc_link_hash_entry *
4087
get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4088
{
4089
  struct ppc_link_hash_entry *fdh = fh->oh;
4090
 
4091
  if (fdh == NULL)
4092
    {
4093
      const char *fd_name = fh->elf.root.root.string + 1;
4094
 
4095
      fdh = (struct ppc_link_hash_entry *)
4096
        elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4097
      if (fdh != NULL)
4098
        {
4099
          fdh->is_func_descriptor = 1;
4100
          fdh->oh = fh;
4101
          fh->is_func = 1;
4102
          fh->oh = fdh;
4103
        }
4104
    }
4105
 
4106
  return fdh;
4107
}
4108
 
4109
/* Make a fake function descriptor sym for the code sym FH.  */
4110
 
4111
static struct ppc_link_hash_entry *
4112
make_fdh (struct bfd_link_info *info,
4113
          struct ppc_link_hash_entry *fh)
4114
{
4115
  bfd *abfd;
4116
  asymbol *newsym;
4117
  struct bfd_link_hash_entry *bh;
4118
  struct ppc_link_hash_entry *fdh;
4119
 
4120
  abfd = fh->elf.root.u.undef.abfd;
4121
  newsym = bfd_make_empty_symbol (abfd);
4122
  newsym->name = fh->elf.root.root.string + 1;
4123
  newsym->section = bfd_und_section_ptr;
4124
  newsym->value = 0;
4125
  newsym->flags = BSF_WEAK;
4126
 
4127
  bh = NULL;
4128
  if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4129
                                         newsym->flags, newsym->section,
4130
                                         newsym->value, NULL, FALSE, FALSE,
4131
                                         &bh))
4132
    return NULL;
4133
 
4134
  fdh = (struct ppc_link_hash_entry *) bh;
4135
  fdh->elf.non_elf = 0;
4136
  fdh->fake = 1;
4137
  fdh->is_func_descriptor = 1;
4138
  fdh->oh = fh;
4139
  fh->is_func = 1;
4140
  fh->oh = fdh;
4141
  return fdh;
4142
}
4143
 
4144
/* Fix function descriptor symbols defined in .opd sections to be
4145
   function type.  */
4146
 
4147
static bfd_boolean
4148
ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4149
                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
4150
                           Elf_Internal_Sym *isym,
4151
                           const char **name ATTRIBUTE_UNUSED,
4152
                           flagword *flags ATTRIBUTE_UNUSED,
4153
                           asection **sec,
4154
                           bfd_vma *value ATTRIBUTE_UNUSED)
4155
{
4156
  if (*sec != NULL
4157
      && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4158
    isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4159
 
4160
  return TRUE;
4161
}
4162
 
4163
/* This function makes an old ABI object reference to ".bar" cause the
4164
   inclusion of a new ABI object archive that defines "bar".
4165
   NAME is a symbol defined in an archive.  Return a symbol in the hash
4166
   table that might be satisfied by the archive symbols.  */
4167
 
4168
static struct elf_link_hash_entry *
4169
ppc64_elf_archive_symbol_lookup (bfd *abfd,
4170
                                 struct bfd_link_info *info,
4171
                                 const char *name)
4172
{
4173
  struct elf_link_hash_entry *h;
4174
  char *dot_name;
4175
  size_t len;
4176
 
4177
  h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4178
  if (h != NULL
4179
      /* Don't return this sym if it is a fake function descriptor
4180
         created by add_symbol_adjust.  */
4181
      && !(h->root.type == bfd_link_hash_undefweak
4182
           && ((struct ppc_link_hash_entry *) h)->fake))
4183
    return h;
4184
 
4185
  if (name[0] == '.')
4186
    return h;
4187
 
4188
  len = strlen (name);
4189
  dot_name = bfd_alloc (abfd, len + 2);
4190
  if (dot_name == NULL)
4191
    return (struct elf_link_hash_entry *) 0 - 1;
4192
  dot_name[0] = '.';
4193
  memcpy (dot_name + 1, name, len + 1);
4194
  h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4195
  bfd_release (abfd, dot_name);
4196
  return h;
4197
}
4198
 
4199
/* This function satisfies all old ABI object references to ".bar" if a
4200
   new ABI object defines "bar".  Well, at least, undefined dot symbols
4201
   are made weak.  This stops later archive searches from including an
4202
   object if we already have a function descriptor definition.  It also
4203
   prevents the linker complaining about undefined symbols.
4204
   We also check and correct mismatched symbol visibility here.  The
4205
   most restrictive visibility of the function descriptor and the
4206
   function entry symbol is used.  */
4207
 
4208
static bfd_boolean
4209
add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4210
{
4211
  struct ppc_link_hash_table *htab;
4212
  struct ppc_link_hash_entry *fdh;
4213
 
4214
  if (eh->elf.root.type == bfd_link_hash_indirect)
4215
    return TRUE;
4216
 
4217
  if (eh->elf.root.type == bfd_link_hash_warning)
4218
    eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4219
 
4220
  if (eh->elf.root.root.string[0] != '.')
4221
    abort ();
4222
 
4223
  htab = ppc_hash_table (info);
4224
  fdh = get_fdh (eh, htab);
4225
  if (fdh == NULL
4226
      && !info->relocatable
4227
      && (eh->elf.root.type == bfd_link_hash_undefined
4228
          || eh->elf.root.type == bfd_link_hash_undefweak)
4229
      && eh->elf.ref_regular)
4230
    {
4231
      /* Make an undefweak function descriptor sym, which is enough to
4232
         pull in an --as-needed shared lib, but won't cause link
4233
         errors.  Archives are handled elsewhere.  */
4234
      fdh = make_fdh (info, eh);
4235
      if (fdh == NULL)
4236
        return FALSE;
4237
      else
4238
        fdh->elf.ref_regular = 1;
4239
    }
4240
  else if (fdh != NULL)
4241
    {
4242
      unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4243
      unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4244
      if (entry_vis < descr_vis)
4245
        fdh->elf.other += entry_vis - descr_vis;
4246
      else if (entry_vis > descr_vis)
4247
        eh->elf.other += descr_vis - entry_vis;
4248
 
4249
      if ((fdh->elf.root.type == bfd_link_hash_defined
4250
           || fdh->elf.root.type == bfd_link_hash_defweak)
4251
          && eh->elf.root.type == bfd_link_hash_undefined)
4252
        {
4253
          eh->elf.root.type = bfd_link_hash_undefweak;
4254
          eh->was_undefined = 1;
4255
          htab->twiddled_syms = 1;
4256
        }
4257
    }
4258
 
4259
  return TRUE;
4260
}
4261
 
4262
/* Process list of dot-symbols we made in link_hash_newfunc.  */
4263
 
4264
static bfd_boolean
4265
ppc64_elf_check_directives (bfd *ibfd, struct bfd_link_info *info)
4266
{
4267
  struct ppc_link_hash_table *htab;
4268
  struct ppc_link_hash_entry **p, *eh;
4269
 
4270
  htab = ppc_hash_table (info);
4271
  if (!is_ppc64_elf (info->output_bfd))
4272
    return TRUE;
4273
 
4274
  if (is_ppc64_elf (ibfd))
4275
    {
4276
      p = &htab->dot_syms;
4277
      while ((eh = *p) != NULL)
4278
        {
4279
          *p = NULL;
4280
          if (!add_symbol_adjust (eh, info))
4281
            return FALSE;
4282
          p = &eh->u.next_dot_sym;
4283
        }
4284
    }
4285
 
4286
  /* Clear the list for non-ppc64 input files.  */
4287
  p = &htab->dot_syms;
4288
  while ((eh = *p) != NULL)
4289
    {
4290
      *p = NULL;
4291
      p = &eh->u.next_dot_sym;
4292
    }
4293
 
4294
  /* We need to fix the undefs list for any syms we have twiddled to
4295
     undef_weak.  */
4296
  if (htab->twiddled_syms)
4297
    {
4298
      bfd_link_repair_undef_list (&htab->elf.root);
4299
      htab->twiddled_syms = 0;
4300
    }
4301
  return TRUE;
4302
}
4303
 
4304
/* Undo hash table changes when an --as-needed input file is determined
4305
   not to be needed.  */
4306
 
4307
static bfd_boolean
4308
ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4309
                             struct bfd_link_info *info)
4310
{
4311
  ppc_hash_table (info)->dot_syms = NULL;
4312
  return TRUE;
4313
}
4314
 
4315
static bfd_boolean
4316
update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4317
                       unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4318
{
4319
  struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4320
  char *local_got_tls_masks;
4321
 
4322
  if (local_got_ents == NULL)
4323
    {
4324
      bfd_size_type size = symtab_hdr->sh_info;
4325
 
4326
      size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4327
      local_got_ents = bfd_zalloc (abfd, size);
4328
      if (local_got_ents == NULL)
4329
        return FALSE;
4330
      elf_local_got_ents (abfd) = local_got_ents;
4331
    }
4332
 
4333
  if ((tls_type & TLS_EXPLICIT) == 0)
4334
    {
4335
      struct got_entry *ent;
4336
 
4337
      for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4338
        if (ent->addend == r_addend
4339
            && ent->owner == abfd
4340
            && ent->tls_type == tls_type)
4341
          break;
4342
      if (ent == NULL)
4343
        {
4344
          bfd_size_type amt = sizeof (*ent);
4345
          ent = bfd_alloc (abfd, amt);
4346
          if (ent == NULL)
4347
            return FALSE;
4348
          ent->next = local_got_ents[r_symndx];
4349
          ent->addend = r_addend;
4350
          ent->owner = abfd;
4351
          ent->tls_type = tls_type;
4352
          ent->got.refcount = 0;
4353
          local_got_ents[r_symndx] = ent;
4354
        }
4355
      ent->got.refcount += 1;
4356
    }
4357
 
4358
  local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4359
  local_got_tls_masks[r_symndx] |= tls_type;
4360
  return TRUE;
4361
}
4362
 
4363
static bfd_boolean
4364
update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
4365
{
4366
  struct plt_entry *ent;
4367
 
4368
  for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4369
    if (ent->addend == addend)
4370
      break;
4371
  if (ent == NULL)
4372
    {
4373
      bfd_size_type amt = sizeof (*ent);
4374
      ent = bfd_alloc (abfd, amt);
4375
      if (ent == NULL)
4376
        return FALSE;
4377
      ent->next = eh->elf.plt.plist;
4378
      ent->addend = addend;
4379
      ent->plt.refcount = 0;
4380
      eh->elf.plt.plist = ent;
4381
    }
4382
  ent->plt.refcount += 1;
4383
  eh->elf.needs_plt = 1;
4384
  if (eh->elf.root.root.string[0] == '.'
4385
      && eh->elf.root.root.string[1] != '\0')
4386
    eh->is_func = 1;
4387
  return TRUE;
4388
}
4389
 
4390
/* Look through the relocs for a section during the first phase, and
4391
   calculate needed space in the global offset table, procedure
4392
   linkage table, and dynamic reloc sections.  */
4393
 
4394
static bfd_boolean
4395
ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4396
                        asection *sec, const Elf_Internal_Rela *relocs)
4397
{
4398
  struct ppc_link_hash_table *htab;
4399
  Elf_Internal_Shdr *symtab_hdr;
4400
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4401
  const Elf_Internal_Rela *rel;
4402
  const Elf_Internal_Rela *rel_end;
4403
  asection *sreloc;
4404
  asection **opd_sym_map;
4405
 
4406
  if (info->relocatable)
4407
    return TRUE;
4408
 
4409
  /* Don't do anything special with non-loaded, non-alloced sections.
4410
     In particular, any relocs in such sections should not affect GOT
4411
     and PLT reference counting (ie. we don't allow them to create GOT
4412
     or PLT entries), there's no possibility or desire to optimize TLS
4413
     relocs, and there's not much point in propagating relocs to shared
4414
     libs that the dynamic linker won't relocate.  */
4415
  if ((sec->flags & SEC_ALLOC) == 0)
4416
    return TRUE;
4417
 
4418
  BFD_ASSERT (is_ppc64_elf (abfd));
4419
 
4420
  htab = ppc_hash_table (info);
4421
  symtab_hdr = &elf_symtab_hdr (abfd);
4422
 
4423
  sym_hashes = elf_sym_hashes (abfd);
4424
  sym_hashes_end = (sym_hashes
4425
                    + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4426
                    - symtab_hdr->sh_info);
4427
 
4428
  sreloc = NULL;
4429
  opd_sym_map = NULL;
4430
  if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4431
    {
4432
      /* Garbage collection needs some extra help with .opd sections.
4433
         We don't want to necessarily keep everything referenced by
4434
         relocs in .opd, as that would keep all functions.  Instead,
4435
         if we reference an .opd symbol (a function descriptor), we
4436
         want to keep the function code symbol's section.  This is
4437
         easy for global symbols, but for local syms we need to keep
4438
         information about the associated function section.  */
4439
      bfd_size_type amt;
4440
 
4441
      amt = sec->size * sizeof (*opd_sym_map) / 8;
4442
      opd_sym_map = bfd_zalloc (abfd, amt);
4443
      if (opd_sym_map == NULL)
4444
        return FALSE;
4445
      ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4446
      BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4447
      ppc64_elf_section_data (sec)->sec_type = sec_opd;
4448
    }
4449
 
4450
  if (htab->sfpr == NULL
4451
      && !create_linkage_sections (htab->elf.dynobj, info))
4452
    return FALSE;
4453
 
4454
  rel_end = relocs + sec->reloc_count;
4455
  for (rel = relocs; rel < rel_end; rel++)
4456
    {
4457
      unsigned long r_symndx;
4458
      struct elf_link_hash_entry *h;
4459
      enum elf_ppc64_reloc_type r_type;
4460
      int tls_type = 0;
4461
      struct _ppc64_elf_section_data *ppc64_sec;
4462
 
4463
      r_symndx = ELF64_R_SYM (rel->r_info);
4464
      if (r_symndx < symtab_hdr->sh_info)
4465
        h = NULL;
4466
      else
4467
        {
4468
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4469
          while (h->root.type == bfd_link_hash_indirect
4470
                 || h->root.type == bfd_link_hash_warning)
4471
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
4472
        }
4473
 
4474
      r_type = ELF64_R_TYPE (rel->r_info);
4475
      switch (r_type)
4476
        {
4477
        case R_PPC64_GOT_TLSLD16:
4478
        case R_PPC64_GOT_TLSLD16_LO:
4479
        case R_PPC64_GOT_TLSLD16_HI:
4480
        case R_PPC64_GOT_TLSLD16_HA:
4481
          tls_type = TLS_TLS | TLS_LD;
4482
          goto dogottls;
4483
 
4484
        case R_PPC64_GOT_TLSGD16:
4485
        case R_PPC64_GOT_TLSGD16_LO:
4486
        case R_PPC64_GOT_TLSGD16_HI:
4487
        case R_PPC64_GOT_TLSGD16_HA:
4488
          tls_type = TLS_TLS | TLS_GD;
4489
          goto dogottls;
4490
 
4491
        case R_PPC64_GOT_TPREL16_DS:
4492
        case R_PPC64_GOT_TPREL16_LO_DS:
4493
        case R_PPC64_GOT_TPREL16_HI:
4494
        case R_PPC64_GOT_TPREL16_HA:
4495
          if (info->shared)
4496
            info->flags |= DF_STATIC_TLS;
4497
          tls_type = TLS_TLS | TLS_TPREL;
4498
          goto dogottls;
4499
 
4500
        case R_PPC64_GOT_DTPREL16_DS:
4501
        case R_PPC64_GOT_DTPREL16_LO_DS:
4502
        case R_PPC64_GOT_DTPREL16_HI:
4503
        case R_PPC64_GOT_DTPREL16_HA:
4504
          tls_type = TLS_TLS | TLS_DTPREL;
4505
        dogottls:
4506
          sec->has_tls_reloc = 1;
4507
          /* Fall thru */
4508
 
4509
        case R_PPC64_GOT16:
4510
        case R_PPC64_GOT16_DS:
4511
        case R_PPC64_GOT16_HA:
4512
        case R_PPC64_GOT16_HI:
4513
        case R_PPC64_GOT16_LO:
4514
        case R_PPC64_GOT16_LO_DS:
4515
          /* This symbol requires a global offset table entry.  */
4516
          sec->has_toc_reloc = 1;
4517
          if (ppc64_elf_tdata (abfd)->got == NULL
4518
              && !create_got_section (abfd, info))
4519
            return FALSE;
4520
 
4521
          if (h != NULL)
4522
            {
4523
              struct ppc_link_hash_entry *eh;
4524
              struct got_entry *ent;
4525
 
4526
              eh = (struct ppc_link_hash_entry *) h;
4527
              for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4528
                if (ent->addend == rel->r_addend
4529
                    && ent->owner == abfd
4530
                    && ent->tls_type == tls_type)
4531
                  break;
4532
              if (ent == NULL)
4533
                {
4534
                  bfd_size_type amt = sizeof (*ent);
4535
                  ent = bfd_alloc (abfd, amt);
4536
                  if (ent == NULL)
4537
                    return FALSE;
4538
                  ent->next = eh->elf.got.glist;
4539
                  ent->addend = rel->r_addend;
4540
                  ent->owner = abfd;
4541
                  ent->tls_type = tls_type;
4542
                  ent->got.refcount = 0;
4543
                  eh->elf.got.glist = ent;
4544
                }
4545
              ent->got.refcount += 1;
4546
              eh->tls_mask |= tls_type;
4547
            }
4548
          else
4549
            /* This is a global offset table entry for a local symbol.  */
4550
            if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4551
                                        rel->r_addend, tls_type))
4552
              return FALSE;
4553
          break;
4554
 
4555
        case R_PPC64_PLT16_HA:
4556
        case R_PPC64_PLT16_HI:
4557
        case R_PPC64_PLT16_LO:
4558
        case R_PPC64_PLT32:
4559
        case R_PPC64_PLT64:
4560
          /* This symbol requires a procedure linkage table entry.  We
4561
             actually build the entry in adjust_dynamic_symbol,
4562
             because this might be a case of linking PIC code without
4563
             linking in any dynamic objects, in which case we don't
4564
             need to generate a procedure linkage table after all.  */
4565
          if (h == NULL)
4566
            {
4567
              /* It does not make sense to have a procedure linkage
4568
                 table entry for a local symbol.  */
4569
              bfd_set_error (bfd_error_bad_value);
4570
              return FALSE;
4571
            }
4572
          else
4573
            if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4574
                                  rel->r_addend))
4575
              return FALSE;
4576
          break;
4577
 
4578
          /* The following relocations don't need to propagate the
4579
             relocation if linking a shared object since they are
4580
             section relative.  */
4581
        case R_PPC64_SECTOFF:
4582
        case R_PPC64_SECTOFF_LO:
4583
        case R_PPC64_SECTOFF_HI:
4584
        case R_PPC64_SECTOFF_HA:
4585
        case R_PPC64_SECTOFF_DS:
4586
        case R_PPC64_SECTOFF_LO_DS:
4587
        case R_PPC64_DTPREL16:
4588
        case R_PPC64_DTPREL16_LO:
4589
        case R_PPC64_DTPREL16_HI:
4590
        case R_PPC64_DTPREL16_HA:
4591
        case R_PPC64_DTPREL16_DS:
4592
        case R_PPC64_DTPREL16_LO_DS:
4593
        case R_PPC64_DTPREL16_HIGHER:
4594
        case R_PPC64_DTPREL16_HIGHERA:
4595
        case R_PPC64_DTPREL16_HIGHEST:
4596
        case R_PPC64_DTPREL16_HIGHESTA:
4597
          break;
4598
 
4599
          /* Nor do these.  */
4600
        case R_PPC64_TOC16:
4601
        case R_PPC64_TOC16_LO:
4602
        case R_PPC64_TOC16_HI:
4603
        case R_PPC64_TOC16_HA:
4604
        case R_PPC64_TOC16_DS:
4605
        case R_PPC64_TOC16_LO_DS:
4606
          sec->has_toc_reloc = 1;
4607
          break;
4608
 
4609
          /* This relocation describes the C++ object vtable hierarchy.
4610
             Reconstruct it for later use during GC.  */
4611
        case R_PPC64_GNU_VTINHERIT:
4612
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4613
            return FALSE;
4614
          break;
4615
 
4616
          /* This relocation describes which C++ vtable entries are actually
4617
             used.  Record for later use during GC.  */
4618
        case R_PPC64_GNU_VTENTRY:
4619
          BFD_ASSERT (h != NULL);
4620
          if (h != NULL
4621
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4622
            return FALSE;
4623
          break;
4624
 
4625
        case R_PPC64_REL14:
4626
        case R_PPC64_REL14_BRTAKEN:
4627
        case R_PPC64_REL14_BRNTAKEN:
4628
          {
4629
            asection *dest = NULL;
4630
 
4631
            /* Heuristic: If jumping outside our section, chances are
4632
               we are going to need a stub.  */
4633
            if (h != NULL)
4634
              {
4635
                /* If the sym is weak it may be overridden later, so
4636
                   don't assume we know where a weak sym lives.  */
4637
                if (h->root.type == bfd_link_hash_defined)
4638
                  dest = h->root.u.def.section;
4639
              }
4640
            else
4641
              dest = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4642
                                                sec, r_symndx);
4643
            if (dest != sec)
4644
              ppc64_elf_section_data (sec)->has_14bit_branch = 1;
4645
          }
4646
          /* Fall through.  */
4647
 
4648
        case R_PPC64_REL24:
4649
          if (h != NULL)
4650
            {
4651
              /* We may need a .plt entry if the function this reloc
4652
                 refers to is in a shared lib.  */
4653
              if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4654
                                    rel->r_addend))
4655
                return FALSE;
4656
              if (h == &htab->tls_get_addr->elf
4657
                  || h == &htab->tls_get_addr_fd->elf)
4658
                sec->has_tls_reloc = 1;
4659
              else if (htab->tls_get_addr == NULL
4660
                       && CONST_STRNEQ (h->root.root.string, ".__tls_get_addr")
4661
                       && (h->root.root.string[15] == 0
4662
                           || h->root.root.string[15] == '@'))
4663
                {
4664
                  htab->tls_get_addr = (struct ppc_link_hash_entry *) h;
4665
                  sec->has_tls_reloc = 1;
4666
                }
4667
              else if (htab->tls_get_addr_fd == NULL
4668
                       && CONST_STRNEQ (h->root.root.string, "__tls_get_addr")
4669
                       && (h->root.root.string[14] == 0
4670
                           || h->root.root.string[14] == '@'))
4671
                {
4672
                  htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) h;
4673
                  sec->has_tls_reloc = 1;
4674
                }
4675
            }
4676
          break;
4677
 
4678
        case R_PPC64_TPREL64:
4679
          tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4680
          if (info->shared)
4681
            info->flags |= DF_STATIC_TLS;
4682
          goto dotlstoc;
4683
 
4684
        case R_PPC64_DTPMOD64:
4685
          if (rel + 1 < rel_end
4686
              && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4687
              && rel[1].r_offset == rel->r_offset + 8)
4688
            tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4689
          else
4690
            tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4691
          goto dotlstoc;
4692
 
4693
        case R_PPC64_DTPREL64:
4694
          tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4695
          if (rel != relocs
4696
              && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4697
              && rel[-1].r_offset == rel->r_offset - 8)
4698
            /* This is the second reloc of a dtpmod, dtprel pair.
4699
               Don't mark with TLS_DTPREL.  */
4700
            goto dodyn;
4701
 
4702
        dotlstoc:
4703
          sec->has_tls_reloc = 1;
4704
          if (h != NULL)
4705
            {
4706
              struct ppc_link_hash_entry *eh;
4707
              eh = (struct ppc_link_hash_entry *) h;
4708
              eh->tls_mask |= tls_type;
4709
            }
4710
          else
4711
            if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4712
                                        rel->r_addend, tls_type))
4713
              return FALSE;
4714
 
4715
          ppc64_sec = ppc64_elf_section_data (sec);
4716
          if (ppc64_sec->sec_type != sec_toc)
4717
            {
4718
              /* One extra to simplify get_tls_mask.  */
4719
              bfd_size_type amt = sec->size * sizeof (unsigned) / 8 + 1;
4720
              ppc64_sec->u.t_symndx = bfd_zalloc (abfd, amt);
4721
              if (ppc64_sec->u.t_symndx == NULL)
4722
                return FALSE;
4723
              BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
4724
              ppc64_sec->sec_type = sec_toc;
4725
            }
4726
          BFD_ASSERT (rel->r_offset % 8 == 0);
4727
          ppc64_sec->u.t_symndx[rel->r_offset / 8] = r_symndx;
4728
 
4729
          /* Mark the second slot of a GD or LD entry.
4730
             -1 to indicate GD and -2 to indicate LD.  */
4731
          if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4732
            ppc64_sec->u.t_symndx[rel->r_offset / 8 + 1] = -1;
4733
          else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4734
            ppc64_sec->u.t_symndx[rel->r_offset / 8 + 1] = -2;
4735
          goto dodyn;
4736
 
4737
        case R_PPC64_TPREL16:
4738
        case R_PPC64_TPREL16_LO:
4739
        case R_PPC64_TPREL16_HI:
4740
        case R_PPC64_TPREL16_HA:
4741
        case R_PPC64_TPREL16_DS:
4742
        case R_PPC64_TPREL16_LO_DS:
4743
        case R_PPC64_TPREL16_HIGHER:
4744
        case R_PPC64_TPREL16_HIGHERA:
4745
        case R_PPC64_TPREL16_HIGHEST:
4746
        case R_PPC64_TPREL16_HIGHESTA:
4747
          if (info->shared)
4748
            {
4749
              info->flags |= DF_STATIC_TLS;
4750
              goto dodyn;
4751
            }
4752
          break;
4753
 
4754
        case R_PPC64_ADDR64:
4755
          if (opd_sym_map != NULL
4756
              && rel + 1 < rel_end
4757
              && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
4758
            {
4759
              if (h != NULL)
4760
                {
4761
                  if (h->root.root.string[0] == '.'
4762
                      && h->root.root.string[1] != 0
4763
                      && get_fdh ((struct ppc_link_hash_entry *) h, htab))
4764
                    ;
4765
                  else
4766
                    ((struct ppc_link_hash_entry *) h)->is_func = 1;
4767
                }
4768
              else
4769
                {
4770
                  asection *s;
4771
 
4772
                  s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
4773
                                                 r_symndx);
4774
                  if (s == NULL)
4775
                    return FALSE;
4776
                  else if (s != sec)
4777
                    opd_sym_map[rel->r_offset / 8] = s;
4778
                }
4779
            }
4780
          /* Fall through.  */
4781
 
4782
        case R_PPC64_REL30:
4783
        case R_PPC64_REL32:
4784
        case R_PPC64_REL64:
4785
        case R_PPC64_ADDR14:
4786
        case R_PPC64_ADDR14_BRNTAKEN:
4787
        case R_PPC64_ADDR14_BRTAKEN:
4788
        case R_PPC64_ADDR16:
4789
        case R_PPC64_ADDR16_DS:
4790
        case R_PPC64_ADDR16_HA:
4791
        case R_PPC64_ADDR16_HI:
4792
        case R_PPC64_ADDR16_HIGHER:
4793
        case R_PPC64_ADDR16_HIGHERA:
4794
        case R_PPC64_ADDR16_HIGHEST:
4795
        case R_PPC64_ADDR16_HIGHESTA:
4796
        case R_PPC64_ADDR16_LO:
4797
        case R_PPC64_ADDR16_LO_DS:
4798
        case R_PPC64_ADDR24:
4799
        case R_PPC64_ADDR32:
4800
        case R_PPC64_UADDR16:
4801
        case R_PPC64_UADDR32:
4802
        case R_PPC64_UADDR64:
4803
        case R_PPC64_TOC:
4804
          if (h != NULL && !info->shared)
4805
            /* We may need a copy reloc.  */
4806
            h->non_got_ref = 1;
4807
 
4808
          /* Don't propagate .opd relocs.  */
4809
          if (NO_OPD_RELOCS && opd_sym_map != NULL)
4810
            break;
4811
 
4812
          /* If we are creating a shared library, and this is a reloc
4813
             against a global symbol, or a non PC relative reloc
4814
             against a local symbol, then we need to copy the reloc
4815
             into the shared library.  However, if we are linking with
4816
             -Bsymbolic, we do not need to copy a reloc against a
4817
             global symbol which is defined in an object we are
4818
             including in the link (i.e., DEF_REGULAR is set).  At
4819
             this point we have not seen all the input files, so it is
4820
             possible that DEF_REGULAR is not set now but will be set
4821
             later (it is never cleared).  In case of a weak definition,
4822
             DEF_REGULAR may be cleared later by a strong definition in
4823
             a shared library.  We account for that possibility below by
4824
             storing information in the dyn_relocs field of the hash
4825
             table entry.  A similar situation occurs when creating
4826
             shared libraries and symbol visibility changes render the
4827
             symbol local.
4828
 
4829
             If on the other hand, we are creating an executable, we
4830
             may need to keep relocations for symbols satisfied by a
4831
             dynamic library if we manage to avoid copy relocs for the
4832
             symbol.  */
4833
        dodyn:
4834
          if ((info->shared
4835
               && (MUST_BE_DYN_RELOC (r_type)
4836
                   || (h != NULL
4837
                       && (! info->symbolic
4838
                           || h->root.type == bfd_link_hash_defweak
4839
                           || !h->def_regular))))
4840
              || (ELIMINATE_COPY_RELOCS
4841
                  && !info->shared
4842
                  && h != NULL
4843
                  && (h->root.type == bfd_link_hash_defweak
4844
                      || !h->def_regular)))
4845
            {
4846
              struct ppc_dyn_relocs *p;
4847
              struct ppc_dyn_relocs **head;
4848
 
4849
              /* We must copy these reloc types into the output file.
4850
                 Create a reloc section in dynobj and make room for
4851
                 this reloc.  */
4852
              if (sreloc == NULL)
4853
                {
4854
                  const char *name;
4855
                  bfd *dynobj;
4856
 
4857
                  name = (bfd_elf_string_from_elf_section
4858
                          (abfd,
4859
                           elf_elfheader (abfd)->e_shstrndx,
4860
                           elf_section_data (sec)->rel_hdr.sh_name));
4861
                  if (name == NULL)
4862
                    return FALSE;
4863
 
4864
                  if (! CONST_STRNEQ (name, ".rela")
4865
                      || strcmp (bfd_get_section_name (abfd, sec),
4866
                                 name + 5) != 0)
4867
                    {
4868
                      (*_bfd_error_handler)
4869
                        (_("%B: bad relocation section name `%s\'"),
4870
                         abfd, name);
4871
                      bfd_set_error (bfd_error_bad_value);
4872
                    }
4873
 
4874
                  dynobj = htab->elf.dynobj;
4875
                  sreloc = bfd_get_section_by_name (dynobj, name);
4876
                  if (sreloc == NULL)
4877
                    {
4878
                      flagword flags;
4879
 
4880
                      flags = (SEC_HAS_CONTENTS | SEC_READONLY
4881
                               | SEC_IN_MEMORY | SEC_LINKER_CREATED
4882
                               | SEC_ALLOC | SEC_LOAD);
4883
                      sreloc = bfd_make_section_with_flags (dynobj,
4884
                                                            name,
4885
                                                            flags);
4886
                      if (sreloc == NULL
4887
                          || ! bfd_set_section_alignment (dynobj, sreloc, 3))
4888
                        return FALSE;
4889
                    }
4890
                  elf_section_data (sec)->sreloc = sreloc;
4891
                }
4892
 
4893
              /* If this is a global symbol, we count the number of
4894
                 relocations we need for this symbol.  */
4895
              if (h != NULL)
4896
                {
4897
                  head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
4898
                }
4899
              else
4900
                {
4901
                  /* Track dynamic relocs needed for local syms too.
4902
                     We really need local syms available to do this
4903
                     easily.  Oh well.  */
4904
 
4905
                  asection *s;
4906
                  void *vpp;
4907
 
4908
                  s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4909
                                                 sec, r_symndx);
4910
                  if (s == NULL)
4911
                    return FALSE;
4912
 
4913
                  vpp = &elf_section_data (s)->local_dynrel;
4914
                  head = (struct ppc_dyn_relocs **) vpp;
4915
                }
4916
 
4917
              p = *head;
4918
              if (p == NULL || p->sec != sec)
4919
                {
4920
                  p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4921
                  if (p == NULL)
4922
                    return FALSE;
4923
                  p->next = *head;
4924
                  *head = p;
4925
                  p->sec = sec;
4926
                  p->count = 0;
4927
                  p->pc_count = 0;
4928
                }
4929
 
4930
              p->count += 1;
4931
              if (!MUST_BE_DYN_RELOC (r_type))
4932
                p->pc_count += 1;
4933
            }
4934
          break;
4935
 
4936
        default:
4937
          break;
4938
        }
4939
    }
4940
 
4941
  return TRUE;
4942
}
4943
 
4944
/* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
4945
   of the code entry point, and its section.  */
4946
 
4947
static bfd_vma
4948
opd_entry_value (asection *opd_sec,
4949
                 bfd_vma offset,
4950
                 asection **code_sec,
4951
                 bfd_vma *code_off)
4952
{
4953
  bfd *opd_bfd = opd_sec->owner;
4954
  Elf_Internal_Rela *relocs;
4955
  Elf_Internal_Rela *lo, *hi, *look;
4956
  bfd_vma val;
4957
 
4958
  /* No relocs implies we are linking a --just-symbols object.  */
4959
  if (opd_sec->reloc_count == 0)
4960
    {
4961
      bfd_vma val;
4962
 
4963
      if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
4964
        return (bfd_vma) -1;
4965
 
4966
      if (code_sec != NULL)
4967
        {
4968
          asection *sec, *likely = NULL;
4969
          for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
4970
            if (sec->vma <= val
4971
                && (sec->flags & SEC_LOAD) != 0
4972
                && (sec->flags & SEC_ALLOC) != 0)
4973
              likely = sec;
4974
          if (likely != NULL)
4975
            {
4976
              *code_sec = likely;
4977
              if (code_off != NULL)
4978
                *code_off = val - likely->vma;
4979
            }
4980
        }
4981
      return val;
4982
    }
4983
 
4984
  BFD_ASSERT (is_ppc64_elf (opd_bfd));
4985
 
4986
  relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
4987
  if (relocs == NULL)
4988
    relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
4989
 
4990
  /* Go find the opd reloc at the sym address.  */
4991
  lo = relocs;
4992
  BFD_ASSERT (lo != NULL);
4993
  hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
4994
  val = (bfd_vma) -1;
4995
  while (lo < hi)
4996
    {
4997
      look = lo + (hi - lo) / 2;
4998
      if (look->r_offset < offset)
4999
        lo = look + 1;
5000
      else if (look->r_offset > offset)
5001
        hi = look;
5002
      else
5003
        {
5004
          Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5005
 
5006
          if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5007
              && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5008
            {
5009
              unsigned long symndx = ELF64_R_SYM (look->r_info);
5010
              asection *sec;
5011
 
5012
              if (symndx < symtab_hdr->sh_info)
5013
                {
5014
                  Elf_Internal_Sym *sym;
5015
 
5016
                  sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5017
                  if (sym == NULL)
5018
                    {
5019
                      sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5020
                                                  symtab_hdr->sh_info,
5021
                                                  0, NULL, NULL, NULL);
5022
                      if (sym == NULL)
5023
                        break;
5024
                      symtab_hdr->contents = (bfd_byte *) sym;
5025
                    }
5026
 
5027
                  sym += symndx;
5028
                  val = sym->st_value;
5029
                  sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5030
                  BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5031
                }
5032
              else
5033
                {
5034
                  struct elf_link_hash_entry **sym_hashes;
5035
                  struct elf_link_hash_entry *rh;
5036
 
5037
                  sym_hashes = elf_sym_hashes (opd_bfd);
5038
                  rh = sym_hashes[symndx - symtab_hdr->sh_info];
5039
                  while (rh->root.type == bfd_link_hash_indirect
5040
                         || rh->root.type == bfd_link_hash_warning)
5041
                    rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
5042
                  BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5043
                              || rh->root.type == bfd_link_hash_defweak);
5044
                  val = rh->root.u.def.value;
5045
                  sec = rh->root.u.def.section;
5046
                }
5047
              val += look->r_addend;
5048
              if (code_off != NULL)
5049
                *code_off = val;
5050
              if (code_sec != NULL)
5051
                *code_sec = sec;
5052
              if (sec != NULL && sec->output_section != NULL)
5053
                val += sec->output_section->vma + sec->output_offset;
5054
            }
5055
          break;
5056
        }
5057
    }
5058
 
5059
  return val;
5060
}
5061
 
5062
/* Mark all our entry sym sections, both opd and code section.  */
5063
 
5064
static void
5065
ppc64_elf_gc_keep (struct bfd_link_info *info)
5066
{
5067
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
5068
  struct bfd_sym_chain *sym;
5069
 
5070
  for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5071
    {
5072
      struct ppc_link_hash_entry *eh;
5073
      asection *sec;
5074
 
5075
      eh = (struct ppc_link_hash_entry *)
5076
        elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5077
      if (eh == NULL)
5078
        continue;
5079
      if (eh->elf.root.type != bfd_link_hash_defined
5080
          && eh->elf.root.type != bfd_link_hash_defweak)
5081
        continue;
5082
 
5083
      if (eh->is_func_descriptor
5084
          && (eh->oh->elf.root.type == bfd_link_hash_defined
5085
              || eh->oh->elf.root.type == bfd_link_hash_defweak))
5086
        {
5087
          sec = eh->oh->elf.root.u.def.section;
5088
          sec->flags |= SEC_KEEP;
5089
        }
5090
      else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5091
               && opd_entry_value (eh->elf.root.u.def.section,
5092
                                   eh->elf.root.u.def.value,
5093
                                   &sec, NULL) != (bfd_vma) -1)
5094
        sec->flags |= SEC_KEEP;
5095
 
5096
      sec = eh->elf.root.u.def.section;
5097
      sec->flags |= SEC_KEEP;
5098
    }
5099
}
5100
 
5101
/* Mark sections containing dynamically referenced symbols.  When
5102
   building shared libraries, we must assume that any visible symbol is
5103
   referenced.  */
5104
 
5105
static bfd_boolean
5106
ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5107
{
5108
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
5109
  struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5110
 
5111
  if (eh->elf.root.type == bfd_link_hash_warning)
5112
    eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5113
 
5114
  /* Dynamic linking info is on the func descriptor sym.  */
5115
  if (eh->oh != NULL
5116
      && eh->oh->is_func_descriptor
5117
      && (eh->oh->elf.root.type == bfd_link_hash_defined
5118
          || eh->oh->elf.root.type == bfd_link_hash_defweak))
5119
    eh = eh->oh;
5120
 
5121
  if ((eh->elf.root.type == bfd_link_hash_defined
5122
       || eh->elf.root.type == bfd_link_hash_defweak)
5123
      && (eh->elf.ref_dynamic
5124
          || (!info->executable
5125
              && eh->elf.def_regular
5126
              && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5127
              && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5128
    {
5129
      asection *code_sec;
5130
 
5131
      eh->elf.root.u.def.section->flags |= SEC_KEEP;
5132
 
5133
      /* Function descriptor syms cause the associated
5134
         function code sym section to be marked.  */
5135
      if (eh->is_func_descriptor
5136
          && (eh->oh->elf.root.type == bfd_link_hash_defined
5137
              || eh->oh->elf.root.type == bfd_link_hash_defweak))
5138
        eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
5139
      else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5140
               && opd_entry_value (eh->elf.root.u.def.section,
5141
                                   eh->elf.root.u.def.value,
5142
                                   &code_sec, NULL) != (bfd_vma) -1)
5143
        code_sec->flags |= SEC_KEEP;
5144
    }
5145
 
5146
  return TRUE;
5147
}
5148
 
5149
/* Return the section that should be marked against GC for a given
5150
   relocation.  */
5151
 
5152
static asection *
5153
ppc64_elf_gc_mark_hook (asection *sec,
5154
                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
5155
                        Elf_Internal_Rela *rel,
5156
                        struct elf_link_hash_entry *h,
5157
                        Elf_Internal_Sym *sym)
5158
{
5159
  asection *rsec;
5160
 
5161
  /* Syms return NULL if we're marking .opd, so we avoid marking all
5162
     function sections, as all functions are referenced in .opd.  */
5163
  rsec = NULL;
5164
  if (get_opd_info (sec) != NULL)
5165
    return rsec;
5166
 
5167
  if (h != NULL)
5168
    {
5169
      enum elf_ppc64_reloc_type r_type;
5170
      struct ppc_link_hash_entry *eh;
5171
 
5172
      r_type = ELF64_R_TYPE (rel->r_info);
5173
      switch (r_type)
5174
        {
5175
        case R_PPC64_GNU_VTINHERIT:
5176
        case R_PPC64_GNU_VTENTRY:
5177
          break;
5178
 
5179
        default:
5180
          switch (h->root.type)
5181
            {
5182
            case bfd_link_hash_defined:
5183
            case bfd_link_hash_defweak:
5184
              eh = (struct ppc_link_hash_entry *) h;
5185
              if (eh->oh != NULL
5186
                  && eh->oh->is_func_descriptor
5187
                  && (eh->oh->elf.root.type == bfd_link_hash_defined
5188
                      || eh->oh->elf.root.type == bfd_link_hash_defweak))
5189
                eh = eh->oh;
5190
 
5191
              /* Function descriptor syms cause the associated
5192
                 function code sym section to be marked.  */
5193
              if (eh->is_func_descriptor
5194
                  && (eh->oh->elf.root.type == bfd_link_hash_defined
5195
                      || eh->oh->elf.root.type == bfd_link_hash_defweak))
5196
                {
5197
                  /* They also mark their opd section.  */
5198
                  eh->elf.root.u.def.section->gc_mark = 1;
5199
 
5200
                  rsec = eh->oh->elf.root.u.def.section;
5201
                }
5202
              else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5203
                       && opd_entry_value (eh->elf.root.u.def.section,
5204
                                           eh->elf.root.u.def.value,
5205
                                           &rsec, NULL) != (bfd_vma) -1)
5206
                eh->elf.root.u.def.section->gc_mark = 1;
5207
              else
5208
                rsec = h->root.u.def.section;
5209
              break;
5210
 
5211
            case bfd_link_hash_common:
5212
              rsec = h->root.u.c.p->section;
5213
              break;
5214
 
5215
            default:
5216
              break;
5217
            }
5218
        }
5219
    }
5220
  else
5221
    {
5222
      struct _opd_sec_data *opd;
5223
 
5224
      rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5225
      opd = get_opd_info (rsec);
5226
      if (opd != NULL && opd->func_sec != NULL)
5227
        {
5228
          rsec->gc_mark = 1;
5229
 
5230
          rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5231
        }
5232
    }
5233
 
5234
  return rsec;
5235
}
5236
 
5237
/* Update the .got, .plt. and dynamic reloc reference counts for the
5238
   section being removed.  */
5239
 
5240
static bfd_boolean
5241
ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5242
                         asection *sec, const Elf_Internal_Rela *relocs)
5243
{
5244
  struct ppc_link_hash_table *htab;
5245
  Elf_Internal_Shdr *symtab_hdr;
5246
  struct elf_link_hash_entry **sym_hashes;
5247
  struct got_entry **local_got_ents;
5248
  const Elf_Internal_Rela *rel, *relend;
5249
 
5250
  if (info->relocatable)
5251
    return TRUE;
5252
 
5253
  if ((sec->flags & SEC_ALLOC) == 0)
5254
    return TRUE;
5255
 
5256
  elf_section_data (sec)->local_dynrel = NULL;
5257
 
5258
  htab = ppc_hash_table (info);
5259
  symtab_hdr = &elf_symtab_hdr (abfd);
5260
  sym_hashes = elf_sym_hashes (abfd);
5261
  local_got_ents = elf_local_got_ents (abfd);
5262
 
5263
  relend = relocs + sec->reloc_count;
5264
  for (rel = relocs; rel < relend; rel++)
5265
    {
5266
      unsigned long r_symndx;
5267
      enum elf_ppc64_reloc_type r_type;
5268
      struct elf_link_hash_entry *h = NULL;
5269
      char tls_type = 0;
5270
 
5271
      r_symndx = ELF64_R_SYM (rel->r_info);
5272
      r_type = ELF64_R_TYPE (rel->r_info);
5273
      if (r_symndx >= symtab_hdr->sh_info)
5274
        {
5275
          struct ppc_link_hash_entry *eh;
5276
          struct ppc_dyn_relocs **pp;
5277
          struct ppc_dyn_relocs *p;
5278
 
5279
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5280
          while (h->root.type == bfd_link_hash_indirect
5281
                 || h->root.type == bfd_link_hash_warning)
5282
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
5283
          eh = (struct ppc_link_hash_entry *) h;
5284
 
5285
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5286
            if (p->sec == sec)
5287
              {
5288
                /* Everything must go for SEC.  */
5289
                *pp = p->next;
5290
                break;
5291
              }
5292
        }
5293
 
5294
      switch (r_type)
5295
        {
5296
        case R_PPC64_GOT_TLSLD16:
5297
        case R_PPC64_GOT_TLSLD16_LO:
5298
        case R_PPC64_GOT_TLSLD16_HI:
5299
        case R_PPC64_GOT_TLSLD16_HA:
5300
          tls_type = TLS_TLS | TLS_LD;
5301
          goto dogot;
5302
 
5303
        case R_PPC64_GOT_TLSGD16:
5304
        case R_PPC64_GOT_TLSGD16_LO:
5305
        case R_PPC64_GOT_TLSGD16_HI:
5306
        case R_PPC64_GOT_TLSGD16_HA:
5307
          tls_type = TLS_TLS | TLS_GD;
5308
          goto dogot;
5309
 
5310
        case R_PPC64_GOT_TPREL16_DS:
5311
        case R_PPC64_GOT_TPREL16_LO_DS:
5312
        case R_PPC64_GOT_TPREL16_HI:
5313
        case R_PPC64_GOT_TPREL16_HA:
5314
          tls_type = TLS_TLS | TLS_TPREL;
5315
          goto dogot;
5316
 
5317
        case R_PPC64_GOT_DTPREL16_DS:
5318
        case R_PPC64_GOT_DTPREL16_LO_DS:
5319
        case R_PPC64_GOT_DTPREL16_HI:
5320
        case R_PPC64_GOT_DTPREL16_HA:
5321
          tls_type = TLS_TLS | TLS_DTPREL;
5322
          goto dogot;
5323
 
5324
        case R_PPC64_GOT16:
5325
        case R_PPC64_GOT16_DS:
5326
        case R_PPC64_GOT16_HA:
5327
        case R_PPC64_GOT16_HI:
5328
        case R_PPC64_GOT16_LO:
5329
        case R_PPC64_GOT16_LO_DS:
5330
        dogot:
5331
          {
5332
            struct got_entry *ent;
5333
 
5334
            if (h != NULL)
5335
              ent = h->got.glist;
5336
            else
5337
              ent = local_got_ents[r_symndx];
5338
 
5339
            for (; ent != NULL; ent = ent->next)
5340
              if (ent->addend == rel->r_addend
5341
                  && ent->owner == abfd
5342
                  && ent->tls_type == tls_type)
5343
                break;
5344
            if (ent == NULL)
5345
              abort ();
5346
            if (ent->got.refcount > 0)
5347
              ent->got.refcount -= 1;
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
        case R_PPC64_REL14:
5357
        case R_PPC64_REL14_BRNTAKEN:
5358
        case R_PPC64_REL14_BRTAKEN:
5359
        case R_PPC64_REL24:
5360
          if (h != NULL)
5361
            {
5362
              struct plt_entry *ent;
5363
 
5364
              for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5365
                if (ent->addend == rel->r_addend)
5366
                  break;
5367
              if (ent == NULL)
5368
                abort ();
5369
              if (ent->plt.refcount > 0)
5370
                ent->plt.refcount -= 1;
5371
            }
5372
          break;
5373
 
5374
        default:
5375
          break;
5376
        }
5377
    }
5378
  return TRUE;
5379
}
5380
 
5381
/* The maximum size of .sfpr.  */
5382
#define SFPR_MAX (218*4)
5383
 
5384
struct sfpr_def_parms
5385
{
5386
  const char name[12];
5387
  unsigned char lo, hi;
5388
  bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5389
  bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5390
};
5391
 
5392
/* Auto-generate _save*, _rest* functions in .sfpr.  */
5393
 
5394
static unsigned int
5395
sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5396
{
5397
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
5398
  unsigned int i;
5399
  size_t len = strlen (parm->name);
5400
  bfd_boolean writing = FALSE;
5401
  char sym[16];
5402
 
5403
  memcpy (sym, parm->name, len);
5404
  sym[len + 2] = 0;
5405
 
5406
  for (i = parm->lo; i <= parm->hi; i++)
5407
    {
5408
      struct elf_link_hash_entry *h;
5409
 
5410
      sym[len + 0] = i / 10 + '0';
5411
      sym[len + 1] = i % 10 + '0';
5412
      h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5413
      if (h != NULL
5414
          && !h->def_regular)
5415
        {
5416
          h->root.type = bfd_link_hash_defined;
5417
          h->root.u.def.section = htab->sfpr;
5418
          h->root.u.def.value = htab->sfpr->size;
5419
          h->type = STT_FUNC;
5420
          h->def_regular = 1;
5421
          _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5422
          writing = TRUE;
5423
          if (htab->sfpr->contents == NULL)
5424
            {
5425
              htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5426
              if (htab->sfpr->contents == NULL)
5427
                return FALSE;
5428
            }
5429
        }
5430
      if (writing)
5431
        {
5432
          bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5433
          if (i != parm->hi)
5434
            p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5435
          else
5436
            p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5437
          htab->sfpr->size = p - htab->sfpr->contents;
5438
        }
5439
    }
5440
 
5441
  return TRUE;
5442
}
5443
 
5444
static bfd_byte *
5445
savegpr0 (bfd *abfd, bfd_byte *p, int r)
5446
{
5447
  bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5448
  return p + 4;
5449
}
5450
 
5451
static bfd_byte *
5452
savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5453
{
5454
  p = savegpr0 (abfd, p, r);
5455
  bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5456
  p = p + 4;
5457
  bfd_put_32 (abfd, BLR, p);
5458
  return p + 4;
5459
}
5460
 
5461
static bfd_byte *
5462
restgpr0 (bfd *abfd, bfd_byte *p, int r)
5463
{
5464
  bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5465
  return p + 4;
5466
}
5467
 
5468
static bfd_byte *
5469
restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5470
{
5471
  bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5472
  p = p + 4;
5473
  p = restgpr0 (abfd, p, r);
5474
  bfd_put_32 (abfd, MTLR_R0, p);
5475
  p = p + 4;
5476
  if (r == 29)
5477
    {
5478
      p = restgpr0 (abfd, p, 30);
5479
      p = restgpr0 (abfd, p, 31);
5480
    }
5481
  bfd_put_32 (abfd, BLR, p);
5482
  return p + 4;
5483
}
5484
 
5485
static bfd_byte *
5486
savegpr1 (bfd *abfd, bfd_byte *p, int r)
5487
{
5488
  bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5489
  return p + 4;
5490
}
5491
 
5492
static bfd_byte *
5493
savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5494
{
5495
  p = savegpr1 (abfd, p, r);
5496
  bfd_put_32 (abfd, BLR, p);
5497
  return p + 4;
5498
}
5499
 
5500
static bfd_byte *
5501
restgpr1 (bfd *abfd, bfd_byte *p, int r)
5502
{
5503
  bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5504
  return p + 4;
5505
}
5506
 
5507
static bfd_byte *
5508
restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5509
{
5510
  p = restgpr1 (abfd, p, r);
5511
  bfd_put_32 (abfd, BLR, p);
5512
  return p + 4;
5513
}
5514
 
5515
static bfd_byte *
5516
savefpr (bfd *abfd, bfd_byte *p, int r)
5517
{
5518
  bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5519
  return p + 4;
5520
}
5521
 
5522
static bfd_byte *
5523
savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5524
{
5525
  p = savefpr (abfd, p, r);
5526
  bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5527
  p = p + 4;
5528
  bfd_put_32 (abfd, BLR, p);
5529
  return p + 4;
5530
}
5531
 
5532
static bfd_byte *
5533
restfpr (bfd *abfd, bfd_byte *p, int r)
5534
{
5535
  bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5536
  return p + 4;
5537
}
5538
 
5539
static bfd_byte *
5540
restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5541
{
5542
  bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5543
  p = p + 4;
5544
  p = restfpr (abfd, p, r);
5545
  bfd_put_32 (abfd, MTLR_R0, p);
5546
  p = p + 4;
5547
  if (r == 29)
5548
    {
5549
      p = restfpr (abfd, p, 30);
5550
      p = restfpr (abfd, p, 31);
5551
    }
5552
  bfd_put_32 (abfd, BLR, p);
5553
  return p + 4;
5554
}
5555
 
5556
static bfd_byte *
5557
savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5558
{
5559
  p = savefpr (abfd, p, r);
5560
  bfd_put_32 (abfd, BLR, p);
5561
  return p + 4;
5562
}
5563
 
5564
static bfd_byte *
5565
restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5566
{
5567
  p = restfpr (abfd, p, r);
5568
  bfd_put_32 (abfd, BLR, p);
5569
  return p + 4;
5570
}
5571
 
5572
static bfd_byte *
5573
savevr (bfd *abfd, bfd_byte *p, int r)
5574
{
5575
  bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5576
  p = p + 4;
5577
  bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5578
  return p + 4;
5579
}
5580
 
5581
static bfd_byte *
5582
savevr_tail (bfd *abfd, bfd_byte *p, int r)
5583
{
5584
  p = savevr (abfd, p, r);
5585
  bfd_put_32 (abfd, BLR, p);
5586
  return p + 4;
5587
}
5588
 
5589
static bfd_byte *
5590
restvr (bfd *abfd, bfd_byte *p, int r)
5591
{
5592
  bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5593
  p = p + 4;
5594
  bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5595
  return p + 4;
5596
}
5597
 
5598
static bfd_byte *
5599
restvr_tail (bfd *abfd, bfd_byte *p, int r)
5600
{
5601
  p = restvr (abfd, p, r);
5602
  bfd_put_32 (abfd, BLR, p);
5603
  return p + 4;
5604
}
5605
 
5606
/* Called via elf_link_hash_traverse to transfer dynamic linking
5607
   information on function code symbol entries to their corresponding
5608
   function descriptor symbol entries.  */
5609
 
5610
static bfd_boolean
5611
func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5612
{
5613
  struct bfd_link_info *info;
5614
  struct ppc_link_hash_table *htab;
5615
  struct plt_entry *ent;
5616
  struct ppc_link_hash_entry *fh;
5617
  struct ppc_link_hash_entry *fdh;
5618
  bfd_boolean force_local;
5619
 
5620
  fh = (struct ppc_link_hash_entry *) h;
5621
  if (fh->elf.root.type == bfd_link_hash_indirect)
5622
    return TRUE;
5623
 
5624
  if (fh->elf.root.type == bfd_link_hash_warning)
5625
    fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5626
 
5627
  info = inf;
5628
  htab = ppc_hash_table (info);
5629
 
5630
  /* Resolve undefined references to dot-symbols as the value
5631
     in the function descriptor, if we have one in a regular object.
5632
     This is to satisfy cases like ".quad .foo".  Calls to functions
5633
     in dynamic objects are handled elsewhere.  */
5634
  if (fh->elf.root.type == bfd_link_hash_undefweak
5635
      && fh->was_undefined
5636
      && (fh->oh->elf.root.type == bfd_link_hash_defined
5637
          || fh->oh->elf.root.type == bfd_link_hash_defweak)
5638
      && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5639
      && opd_entry_value (fh->oh->elf.root.u.def.section,
5640
                          fh->oh->elf.root.u.def.value,
5641
                          &fh->elf.root.u.def.section,
5642
                          &fh->elf.root.u.def.value) != (bfd_vma) -1)
5643
    {
5644
      fh->elf.root.type = fh->oh->elf.root.type;
5645
      fh->elf.forced_local = 1;
5646
      fh->elf.def_regular = fh->oh->elf.def_regular;
5647
      fh->elf.def_dynamic = fh->oh->elf.def_dynamic;
5648
    }
5649
 
5650
  /* If this is a function code symbol, transfer dynamic linking
5651
     information to the function descriptor symbol.  */
5652
  if (!fh->is_func)
5653
    return TRUE;
5654
 
5655
  for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
5656
    if (ent->plt.refcount > 0)
5657
      break;
5658
  if (ent == NULL
5659
      || fh->elf.root.root.string[0] != '.'
5660
      || fh->elf.root.root.string[1] == '\0')
5661
    return TRUE;
5662
 
5663
  /* Find the corresponding function descriptor symbol.  Create it
5664
     as undefined if necessary.  */
5665
 
5666
  fdh = get_fdh (fh, htab);
5667
  if (fdh != NULL)
5668
    while (fdh->elf.root.type == bfd_link_hash_indirect
5669
           || fdh->elf.root.type == bfd_link_hash_warning)
5670
      fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5671
 
5672
  if (fdh == NULL
5673
      && info->shared
5674
      && (fh->elf.root.type == bfd_link_hash_undefined
5675
          || fh->elf.root.type == bfd_link_hash_undefweak))
5676
    {
5677
      fdh = make_fdh (info, fh);
5678
      if (fdh == NULL)
5679
        return FALSE;
5680
    }
5681
 
5682
  /* Fake function descriptors are made undefweak.  If the function
5683
     code symbol is strong undefined, make the fake sym the same.
5684
     If the function code symbol is defined, then force the fake
5685
     descriptor local;  We can't support overriding of symbols in a
5686
     shared library on a fake descriptor.  */
5687
 
5688
  if (fdh != NULL
5689
      && fdh->fake
5690
      && fdh->elf.root.type == bfd_link_hash_undefweak)
5691
    {
5692
      if (fh->elf.root.type == bfd_link_hash_undefined)
5693
        {
5694
          fdh->elf.root.type = bfd_link_hash_undefined;
5695
          bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
5696
        }
5697
      else if (fh->elf.root.type == bfd_link_hash_defined
5698
               || fh->elf.root.type == bfd_link_hash_defweak)
5699
        {
5700
          _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
5701
        }
5702
    }
5703
 
5704
  if (fdh != NULL
5705
      && !fdh->elf.forced_local
5706
      && (info->shared
5707
          || fdh->elf.def_dynamic
5708
          || fdh->elf.ref_dynamic
5709
          || (fdh->elf.root.type == bfd_link_hash_undefweak
5710
              && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5711
    {
5712
      if (fdh->elf.dynindx == -1)
5713
        if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5714
          return FALSE;
5715
      fdh->elf.ref_regular |= fh->elf.ref_regular;
5716
      fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5717
      fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5718
      fdh->elf.non_got_ref |= fh->elf.non_got_ref;
5719
      if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
5720
        {
5721
          move_plt_plist (fh, fdh);
5722
          fdh->elf.needs_plt = 1;
5723
        }
5724
      fdh->is_func_descriptor = 1;
5725
      fdh->oh = fh;
5726
      fh->oh = fdh;
5727
    }
5728
 
5729
  /* Now that the info is on the function descriptor, clear the
5730
     function code sym info.  Any function code syms for which we
5731
     don't have a definition in a regular file, we force local.
5732
     This prevents a shared library from exporting syms that have
5733
     been imported from another library.  Function code syms that
5734
     are really in the library we must leave global to prevent the
5735
     linker dragging in a definition from a static library.  */
5736
  force_local = (!fh->elf.def_regular
5737
                 || fdh == NULL
5738
                 || !fdh->elf.def_regular
5739
                 || fdh->elf.forced_local);
5740
  _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5741
 
5742
  return TRUE;
5743
}
5744
 
5745
/* Called near the start of bfd_elf_size_dynamic_sections.  We use
5746
   this hook to a) provide some gcc support functions, and b) transfer
5747
   dynamic linking information gathered so far on function code symbol
5748
   entries, to their corresponding function descriptor symbol entries.  */
5749
 
5750
static bfd_boolean
5751
ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5752
                            struct bfd_link_info *info)
5753
{
5754
  struct ppc_link_hash_table *htab;
5755
  unsigned int i;
5756
  const struct sfpr_def_parms funcs[] =
5757
    {
5758
      { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5759
      { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5760
      { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5761
      { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5762
      { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5763
      { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5764
      { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5765
      { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5766
      { "._savef", 14, 31, savefpr, savefpr1_tail },
5767
      { "._restf", 14, 31, restfpr, restfpr1_tail },
5768
      { "_savevr_", 20, 31, savevr, savevr_tail },
5769
      { "_restvr_", 20, 31, restvr, restvr_tail }
5770
    };
5771
 
5772
  htab = ppc_hash_table (info);
5773
  if (htab->sfpr == NULL)
5774
    /* We don't have any relocs.  */
5775
    return TRUE;
5776
 
5777
  /* Provide any missing _save* and _rest* functions.  */
5778
  htab->sfpr->size = 0;
5779
  for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5780
    if (!sfpr_define (info, &funcs[i]))
5781
      return FALSE;
5782
 
5783
  elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5784
 
5785
  if (htab->sfpr->size == 0)
5786
    htab->sfpr->flags |= SEC_EXCLUDE;
5787
 
5788
  return TRUE;
5789
}
5790
 
5791
/* Adjust a symbol defined by a dynamic object and referenced by a
5792
   regular object.  The current definition is in some section of the
5793
   dynamic object, but we're not including those sections.  We have to
5794
   change the definition to something the rest of the link can
5795
   understand.  */
5796
 
5797
static bfd_boolean
5798
ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5799
                                 struct elf_link_hash_entry *h)
5800
{
5801
  struct ppc_link_hash_table *htab;
5802
  asection *s;
5803
 
5804
  htab = ppc_hash_table (info);
5805
 
5806
  /* Deal with function syms.  */
5807
  if (h->type == STT_FUNC
5808
      || h->needs_plt)
5809
    {
5810
      /* Clear procedure linkage table information for any symbol that
5811
         won't need a .plt entry.  */
5812
      struct plt_entry *ent;
5813
      for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5814
        if (ent->plt.refcount > 0)
5815
          break;
5816
      if (ent == NULL
5817
          || SYMBOL_CALLS_LOCAL (info, h)
5818
          || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5819
              && h->root.type == bfd_link_hash_undefweak))
5820
        {
5821
          h->plt.plist = NULL;
5822
          h->needs_plt = 0;
5823
        }
5824
    }
5825
  else
5826
    h->plt.plist = NULL;
5827
 
5828
  /* If this is a weak symbol, and there is a real definition, the
5829
     processor independent code will have arranged for us to see the
5830
     real definition first, and we can just use the same value.  */
5831
  if (h->u.weakdef != NULL)
5832
    {
5833
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5834
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
5835
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
5836
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
5837
      if (ELIMINATE_COPY_RELOCS)
5838
        h->non_got_ref = h->u.weakdef->non_got_ref;
5839
      return TRUE;
5840
    }
5841
 
5842
  /* If we are creating a shared library, we must presume that the
5843
     only references to the symbol are via the global offset table.
5844
     For such cases we need not do anything here; the relocations will
5845
     be handled correctly by relocate_section.  */
5846
  if (info->shared)
5847
    return TRUE;
5848
 
5849
  /* If there are no references to this symbol that do not use the
5850
     GOT, we don't need to generate a copy reloc.  */
5851
  if (!h->non_got_ref)
5852
    return TRUE;
5853
 
5854
  /* Don't generate a copy reloc for symbols defined in the executable.  */
5855
  if (!h->def_dynamic || !h->ref_regular || h->def_regular)
5856
    return TRUE;
5857
 
5858
  if (ELIMINATE_COPY_RELOCS)
5859
    {
5860
      struct ppc_link_hash_entry * eh;
5861
      struct ppc_dyn_relocs *p;
5862
 
5863
      eh = (struct ppc_link_hash_entry *) h;
5864
      for (p = eh->dyn_relocs; p != NULL; p = p->next)
5865
        {
5866
          s = p->sec->output_section;
5867
          if (s != NULL && (s->flags & SEC_READONLY) != 0)
5868
            break;
5869
        }
5870
 
5871
      /* If we didn't find any dynamic relocs in read-only sections, then
5872
         we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
5873
      if (p == NULL)
5874
        {
5875
          h->non_got_ref = 0;
5876
          return TRUE;
5877
        }
5878
    }
5879
 
5880
  if (h->plt.plist != NULL)
5881
    {
5882
      /* We should never get here, but unfortunately there are versions
5883
         of gcc out there that improperly (for this ABI) put initialized
5884
         function pointers, vtable refs and suchlike in read-only
5885
         sections.  Allow them to proceed, but warn that this might
5886
         break at runtime.  */
5887
      (*_bfd_error_handler)
5888
        (_("copy reloc against `%s' requires lazy plt linking; "
5889
           "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
5890
         h->root.root.string);
5891
    }
5892
 
5893
  /* This is a reference to a symbol defined by a dynamic object which
5894
     is not a function.  */
5895
 
5896
  if (h->size == 0)
5897
    {
5898
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
5899
                             h->root.root.string);
5900
      return TRUE;
5901
    }
5902
 
5903
  /* We must allocate the symbol in our .dynbss section, which will
5904
     become part of the .bss section of the executable.  There will be
5905
     an entry for this symbol in the .dynsym section.  The dynamic
5906
     object will contain position independent code, so all references
5907
     from the dynamic object to this symbol will go through the global
5908
     offset table.  The dynamic linker will use the .dynsym entry to
5909
     determine the address it must put in the global offset table, so
5910
     both the dynamic object and the regular object will refer to the
5911
     same memory location for the variable.  */
5912
 
5913
  /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
5914
     to copy the initial value out of the dynamic object and into the
5915
     runtime process image.  We need to remember the offset into the
5916
     .rela.bss section we are going to use.  */
5917
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5918
    {
5919
      htab->relbss->size += sizeof (Elf64_External_Rela);
5920
      h->needs_copy = 1;
5921
    }
5922
 
5923
  s = htab->dynbss;
5924
 
5925
  return _bfd_elf_adjust_dynamic_copy (h, s);
5926
}
5927
 
5928
/* If given a function descriptor symbol, hide both the function code
5929
   sym and the descriptor.  */
5930
static void
5931
ppc64_elf_hide_symbol (struct bfd_link_info *info,
5932
                       struct elf_link_hash_entry *h,
5933
                       bfd_boolean force_local)
5934
{
5935
  struct ppc_link_hash_entry *eh;
5936
  _bfd_elf_link_hash_hide_symbol (info, h, force_local);
5937
 
5938
  eh = (struct ppc_link_hash_entry *) h;
5939
  if (eh->is_func_descriptor)
5940
    {
5941
      struct ppc_link_hash_entry *fh = eh->oh;
5942
 
5943
      if (fh == NULL)
5944
        {
5945
          const char *p, *q;
5946
          struct ppc_link_hash_table *htab;
5947
          char save;
5948
 
5949
          /* We aren't supposed to use alloca in BFD because on
5950
             systems which do not have alloca the version in libiberty
5951
             calls xmalloc, which might cause the program to crash
5952
             when it runs out of memory.  This function doesn't have a
5953
             return status, so there's no way to gracefully return an
5954
             error.  So cheat.  We know that string[-1] can be safely
5955
             accessed;  It's either a string in an ELF string table,
5956
             or allocated in an objalloc structure.  */
5957
 
5958
          p = eh->elf.root.root.string - 1;
5959
          save = *p;
5960
          *(char *) p = '.';
5961
          htab = ppc_hash_table (info);
5962
          fh = (struct ppc_link_hash_entry *)
5963
            elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5964
          *(char *) p = save;
5965
 
5966
          /* Unfortunately, if it so happens that the string we were
5967
             looking for was allocated immediately before this string,
5968
             then we overwrote the string terminator.  That's the only
5969
             reason the lookup should fail.  */
5970
          if (fh == NULL)
5971
            {
5972
              q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
5973
              while (q >= eh->elf.root.root.string && *q == *p)
5974
                --q, --p;
5975
              if (q < eh->elf.root.root.string && *p == '.')
5976
                fh = (struct ppc_link_hash_entry *)
5977
                  elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5978
            }
5979
          if (fh != NULL)
5980
            {
5981
              eh->oh = fh;
5982
              fh->oh = eh;
5983
            }
5984
        }
5985
      if (fh != NULL)
5986
        _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5987
    }
5988
}
5989
 
5990
static bfd_boolean
5991
get_sym_h (struct elf_link_hash_entry **hp,
5992
           Elf_Internal_Sym **symp,
5993
           asection **symsecp,
5994
           char **tls_maskp,
5995
           Elf_Internal_Sym **locsymsp,
5996
           unsigned long r_symndx,
5997
           bfd *ibfd)
5998
{
5999
  Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6000
 
6001
  if (r_symndx >= symtab_hdr->sh_info)
6002
    {
6003
      struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6004
      struct elf_link_hash_entry *h;
6005
 
6006
      h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6007
      while (h->root.type == bfd_link_hash_indirect
6008
             || h->root.type == bfd_link_hash_warning)
6009
        h = (struct elf_link_hash_entry *) h->root.u.i.link;
6010
 
6011
      if (hp != NULL)
6012
        *hp = h;
6013
 
6014
      if (symp != NULL)
6015
        *symp = NULL;
6016
 
6017
      if (symsecp != NULL)
6018
        {
6019
          asection *symsec = NULL;
6020
          if (h->root.type == bfd_link_hash_defined
6021
              || h->root.type == bfd_link_hash_defweak)
6022
            symsec = h->root.u.def.section;
6023
          *symsecp = symsec;
6024
        }
6025
 
6026
      if (tls_maskp != NULL)
6027
        {
6028
          struct ppc_link_hash_entry *eh;
6029
 
6030
          eh = (struct ppc_link_hash_entry *) h;
6031
          *tls_maskp = &eh->tls_mask;
6032
        }
6033
    }
6034
  else
6035
    {
6036
      Elf_Internal_Sym *sym;
6037
      Elf_Internal_Sym *locsyms = *locsymsp;
6038
 
6039
      if (locsyms == NULL)
6040
        {
6041
          locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6042
          if (locsyms == NULL)
6043
            locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6044
                                            symtab_hdr->sh_info,
6045
                                            0, NULL, NULL, NULL);
6046
          if (locsyms == NULL)
6047
            return FALSE;
6048
          *locsymsp = locsyms;
6049
        }
6050
      sym = locsyms + r_symndx;
6051
 
6052
      if (hp != NULL)
6053
        *hp = NULL;
6054
 
6055
      if (symp != NULL)
6056
        *symp = sym;
6057
 
6058
      if (symsecp != NULL)
6059
        *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6060
 
6061
      if (tls_maskp != NULL)
6062
        {
6063
          struct got_entry **lgot_ents;
6064
          char *tls_mask;
6065
 
6066
          tls_mask = NULL;
6067
          lgot_ents = elf_local_got_ents (ibfd);
6068
          if (lgot_ents != NULL)
6069
            {
6070
              char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
6071
              tls_mask = &lgot_masks[r_symndx];
6072
            }
6073
          *tls_maskp = tls_mask;
6074
        }
6075
    }
6076
  return TRUE;
6077
}
6078
 
6079
/* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6080
   error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6081
   type suitable for optimization, and 1 otherwise.  */
6082
 
6083
static int
6084
get_tls_mask (char **tls_maskp, unsigned long *toc_symndx,
6085
              Elf_Internal_Sym **locsymsp,
6086
              const Elf_Internal_Rela *rel, bfd *ibfd)
6087
{
6088
  unsigned long r_symndx;
6089
  int next_r;
6090
  struct elf_link_hash_entry *h;
6091
  Elf_Internal_Sym *sym;
6092
  asection *sec;
6093
  bfd_vma off;
6094
 
6095
  r_symndx = ELF64_R_SYM (rel->r_info);
6096
  if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6097
    return 0;
6098
 
6099
  if ((*tls_maskp != NULL && **tls_maskp != 0)
6100
      || sec == NULL
6101
      || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6102
    return 1;
6103
 
6104
  /* Look inside a TOC section too.  */
6105
  if (h != NULL)
6106
    {
6107
      BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6108
      off = h->root.u.def.value;
6109
    }
6110
  else
6111
    off = sym->st_value;
6112
  off += rel->r_addend;
6113
  BFD_ASSERT (off % 8 == 0);
6114
  r_symndx = ppc64_elf_section_data (sec)->u.t_symndx[off / 8];
6115
  next_r = ppc64_elf_section_data (sec)->u.t_symndx[off / 8 + 1];
6116
  if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6117
    return 0;
6118
  if (toc_symndx != NULL)
6119
    *toc_symndx = r_symndx;
6120
  if ((h == NULL
6121
       || ((h->root.type == bfd_link_hash_defined
6122
            || h->root.type == bfd_link_hash_defweak)
6123
           && !h->def_dynamic))
6124
      && (next_r == -1 || next_r == -2))
6125
    return 1 - next_r;
6126
  return 1;
6127
}
6128
 
6129
/* Adjust all global syms defined in opd sections.  In gcc generated
6130
   code for the old ABI, these will already have been done.  */
6131
 
6132
static bfd_boolean
6133
adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6134
{
6135
  struct ppc_link_hash_entry *eh;
6136
  asection *sym_sec;
6137
  struct _opd_sec_data *opd;
6138
 
6139
  if (h->root.type == bfd_link_hash_indirect)
6140
    return TRUE;
6141
 
6142
  if (h->root.type == bfd_link_hash_warning)
6143
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
6144
 
6145
  if (h->root.type != bfd_link_hash_defined
6146
      && h->root.type != bfd_link_hash_defweak)
6147
    return TRUE;
6148
 
6149
  eh = (struct ppc_link_hash_entry *) h;
6150
  if (eh->adjust_done)
6151
    return TRUE;
6152
 
6153
  sym_sec = eh->elf.root.u.def.section;
6154
  opd = get_opd_info (sym_sec);
6155
  if (opd != NULL && opd->adjust != NULL)
6156
    {
6157
      long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6158
      if (adjust == -1)
6159
        {
6160
          /* This entry has been deleted.  */
6161
          asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6162
          if (dsec == NULL)
6163
            {
6164
              for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6165
                if (elf_discarded_section (dsec))
6166
                  {
6167
                    ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6168
                    break;
6169
                  }
6170
            }
6171
          eh->elf.root.u.def.value = 0;
6172
          eh->elf.root.u.def.section = dsec;
6173
        }
6174
      else
6175
        eh->elf.root.u.def.value += adjust;
6176
      eh->adjust_done = 1;
6177
    }
6178
  return TRUE;
6179
}
6180
 
6181
/* Handles decrementing dynamic reloc counts for the reloc specified by
6182
   R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6183
   have already been determined.  */
6184
 
6185
static bfd_boolean
6186
dec_dynrel_count (bfd_vma r_info,
6187
                  asection *sec,
6188
                  struct bfd_link_info *info,
6189
                  Elf_Internal_Sym **local_syms,
6190
                  struct elf_link_hash_entry *h,
6191
                  asection *sym_sec)
6192
{
6193
  enum elf_ppc64_reloc_type r_type;
6194
  struct ppc_dyn_relocs *p;
6195
  struct ppc_dyn_relocs **pp;
6196
 
6197
  /* Can this reloc be dynamic?  This switch, and later tests here
6198
     should be kept in sync with the code in check_relocs.  */
6199
  r_type = ELF64_R_TYPE (r_info);
6200
  switch (r_type)
6201
    {
6202
    default:
6203
      return TRUE;
6204
 
6205
    case R_PPC64_TPREL16:
6206
    case R_PPC64_TPREL16_LO:
6207
    case R_PPC64_TPREL16_HI:
6208
    case R_PPC64_TPREL16_HA:
6209
    case R_PPC64_TPREL16_DS:
6210
    case R_PPC64_TPREL16_LO_DS:
6211
    case R_PPC64_TPREL16_HIGHER:
6212
    case R_PPC64_TPREL16_HIGHERA:
6213
    case R_PPC64_TPREL16_HIGHEST:
6214
    case R_PPC64_TPREL16_HIGHESTA:
6215
      if (!info->shared)
6216
        return TRUE;
6217
 
6218
    case R_PPC64_TPREL64:
6219
    case R_PPC64_DTPMOD64:
6220
    case R_PPC64_DTPREL64:
6221
    case R_PPC64_ADDR64:
6222
    case R_PPC64_REL30:
6223
    case R_PPC64_REL32:
6224
    case R_PPC64_REL64:
6225
    case R_PPC64_ADDR14:
6226
    case R_PPC64_ADDR14_BRNTAKEN:
6227
    case R_PPC64_ADDR14_BRTAKEN:
6228
    case R_PPC64_ADDR16:
6229
    case R_PPC64_ADDR16_DS:
6230
    case R_PPC64_ADDR16_HA:
6231
    case R_PPC64_ADDR16_HI:
6232
    case R_PPC64_ADDR16_HIGHER:
6233
    case R_PPC64_ADDR16_HIGHERA:
6234
    case R_PPC64_ADDR16_HIGHEST:
6235
    case R_PPC64_ADDR16_HIGHESTA:
6236
    case R_PPC64_ADDR16_LO:
6237
    case R_PPC64_ADDR16_LO_DS:
6238
    case R_PPC64_ADDR24:
6239
    case R_PPC64_ADDR32:
6240
    case R_PPC64_UADDR16:
6241
    case R_PPC64_UADDR32:
6242
    case R_PPC64_UADDR64:
6243
    case R_PPC64_TOC:
6244
      break;
6245
    }
6246
 
6247
  if (local_syms != NULL)
6248
    {
6249
      unsigned long r_symndx;
6250
      Elf_Internal_Sym *sym;
6251
      bfd *ibfd = sec->owner;
6252
 
6253
      r_symndx = ELF64_R_SYM (r_info);
6254
      if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6255
        return FALSE;
6256
    }
6257
 
6258
  if ((info->shared
6259
       && (MUST_BE_DYN_RELOC (r_type)
6260
           || (h != NULL
6261
               && (!info->symbolic
6262
                   || h->root.type == bfd_link_hash_defweak
6263
                   || !h->def_regular))))
6264
      || (ELIMINATE_COPY_RELOCS
6265
          && !info->shared
6266
          && h != NULL
6267
          && (h->root.type == bfd_link_hash_defweak
6268
              || !h->def_regular)))
6269
    ;
6270
  else
6271
    return TRUE;
6272
 
6273
  if (h != NULL)
6274
    pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6275
  else
6276
    {
6277
      if (sym_sec != NULL)
6278
        {
6279
          void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6280
          pp = (struct ppc_dyn_relocs **) vpp;
6281
        }
6282
      else
6283
        {
6284
          void *vpp = &elf_section_data (sec)->local_dynrel;
6285
          pp = (struct ppc_dyn_relocs **) vpp;
6286
        }
6287
 
6288
      /* elf_gc_sweep may have already removed all dyn relocs associated
6289
         with local syms for a given section.  Don't report a dynreloc
6290
         miscount.  */
6291
      if (*pp == NULL)
6292
        return TRUE;
6293
    }
6294
 
6295
  while ((p = *pp) != NULL)
6296
    {
6297
      if (p->sec == sec)
6298
        {
6299
          if (!MUST_BE_DYN_RELOC (r_type))
6300
            p->pc_count -= 1;
6301
          p->count -= 1;
6302
          if (p->count == 0)
6303
            *pp = p->next;
6304
          return TRUE;
6305
        }
6306
      pp = &p->next;
6307
    }
6308
 
6309
  (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6310
                           sec->owner, sec);
6311
  bfd_set_error (bfd_error_bad_value);
6312
  return FALSE;
6313
}
6314
 
6315
/* Remove unused Official Procedure Descriptor entries.  Currently we
6316
   only remove those associated with functions in discarded link-once
6317
   sections, or weakly defined functions that have been overridden.  It
6318
   would be possible to remove many more entries for statically linked
6319
   applications.  */
6320
 
6321
bfd_boolean
6322
ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6323
                    bfd_boolean non_overlapping)
6324
{
6325
  bfd *ibfd;
6326
  bfd_boolean some_edited = FALSE;
6327
  asection *need_pad = NULL;
6328
 
6329
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6330
    {
6331
      asection *sec;
6332
      Elf_Internal_Rela *relstart, *rel, *relend;
6333
      Elf_Internal_Shdr *symtab_hdr;
6334
      Elf_Internal_Sym *local_syms;
6335
      struct elf_link_hash_entry **sym_hashes;
6336
      bfd_vma offset;
6337
      struct _opd_sec_data *opd;
6338
      bfd_boolean need_edit, add_aux_fields;
6339
      bfd_size_type cnt_16b = 0;
6340
 
6341
      sec = bfd_get_section_by_name (ibfd, ".opd");
6342
      if (sec == NULL || sec->size == 0)
6343
        continue;
6344
 
6345
      if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6346
        continue;
6347
 
6348
      if (sec->output_section == bfd_abs_section_ptr)
6349
        continue;
6350
 
6351
      /* Look through the section relocs.  */
6352
      if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6353
        continue;
6354
 
6355
      local_syms = NULL;
6356
      symtab_hdr = &elf_symtab_hdr (ibfd);
6357
      sym_hashes = elf_sym_hashes (ibfd);
6358
 
6359
      /* Read the relocations.  */
6360
      relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6361
                                            info->keep_memory);
6362
      if (relstart == NULL)
6363
        return FALSE;
6364
 
6365
      /* First run through the relocs to check they are sane, and to
6366
         determine whether we need to edit this opd section.  */
6367
      need_edit = FALSE;
6368
      need_pad = sec;
6369
      offset = 0;
6370
      relend = relstart + sec->reloc_count;
6371
      for (rel = relstart; rel < relend; )
6372
        {
6373
          enum elf_ppc64_reloc_type r_type;
6374
          unsigned long r_symndx;
6375
          asection *sym_sec;
6376
          struct elf_link_hash_entry *h;
6377
          Elf_Internal_Sym *sym;
6378
 
6379
          /* .opd contains a regular array of 16 or 24 byte entries.  We're
6380
             only interested in the reloc pointing to a function entry
6381
             point.  */
6382
          if (rel->r_offset != offset
6383
              || rel + 1 >= relend
6384
              || (rel + 1)->r_offset != offset + 8)
6385
            {
6386
              /* If someone messes with .opd alignment then after a
6387
                 "ld -r" we might have padding in the middle of .opd.
6388
                 Also, there's nothing to prevent someone putting
6389
                 something silly in .opd with the assembler.  No .opd
6390
                 optimization for them!  */
6391
            broken_opd:
6392
              (*_bfd_error_handler)
6393
                (_("%B: .opd is not a regular array of opd entries"), ibfd);
6394
              need_edit = FALSE;
6395
              break;
6396
            }
6397
 
6398
          if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6399
              || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6400
            {
6401
              (*_bfd_error_handler)
6402
                (_("%B: unexpected reloc type %u in .opd section"),
6403
                 ibfd, r_type);
6404
              need_edit = FALSE;
6405
              break;
6406
            }
6407
 
6408
          r_symndx = ELF64_R_SYM (rel->r_info);
6409
          if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6410
                          r_symndx, ibfd))
6411
            goto error_ret;
6412
 
6413
          if (sym_sec == NULL || sym_sec->owner == NULL)
6414
            {
6415
              const char *sym_name;
6416
              if (h != NULL)
6417
                sym_name = h->root.root.string;
6418
              else
6419
                sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6420
                                             sym_sec);
6421
 
6422
              (*_bfd_error_handler)
6423
                (_("%B: undefined sym `%s' in .opd section"),
6424
                 ibfd, sym_name);
6425
              need_edit = FALSE;
6426
              break;
6427
            }
6428
 
6429
          /* opd entries are always for functions defined in the
6430
             current input bfd.  If the symbol isn't defined in the
6431
             input bfd, then we won't be using the function in this
6432
             bfd;  It must be defined in a linkonce section in another
6433
             bfd, or is weak.  It's also possible that we are
6434
             discarding the function due to a linker script /DISCARD/,
6435
             which we test for via the output_section.  */
6436
          if (sym_sec->owner != ibfd
6437
              || sym_sec->output_section == bfd_abs_section_ptr)
6438
            need_edit = TRUE;
6439
 
6440
          rel += 2;
6441
          if (rel == relend
6442
              || (rel + 1 == relend && rel->r_offset == offset + 16))
6443
            {
6444
              if (sec->size == offset + 24)
6445
                {
6446
                  need_pad = NULL;
6447
                  break;
6448
                }
6449
              if (rel == relend && sec->size == offset + 16)
6450
                {
6451
                  cnt_16b++;
6452
                  break;
6453
                }
6454
              goto broken_opd;
6455
            }
6456
 
6457
          if (rel->r_offset == offset + 24)
6458
            offset += 24;
6459
          else if (rel->r_offset != offset + 16)
6460
            goto broken_opd;
6461
          else if (rel + 1 < relend
6462
                   && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6463
                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6464
            {
6465
              offset += 16;
6466
              cnt_16b++;
6467
            }
6468
          else if (rel + 2 < relend
6469
                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6470
                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6471
            {
6472
              offset += 24;
6473
              rel += 1;
6474
            }
6475
          else
6476
            goto broken_opd;
6477
        }
6478
 
6479
      add_aux_fields = non_overlapping && cnt_16b > 0;
6480
 
6481
      if (need_edit || add_aux_fields)
6482
        {
6483
          Elf_Internal_Rela *write_rel;
6484
          bfd_byte *rptr, *wptr;
6485
          bfd_byte *new_contents = NULL;
6486
          bfd_boolean skip;
6487
          long opd_ent_size;
6488
          bfd_size_type amt;
6489
 
6490
          amt = sec->size * sizeof (long) / 8;
6491
          opd = &ppc64_elf_section_data (sec)->u.opd;
6492
          opd->adjust = bfd_zalloc (obfd, amt);
6493
          if (opd->adjust == NULL)
6494
            return FALSE;
6495
          ppc64_elf_section_data (sec)->sec_type = sec_opd;
6496
 
6497
          /* This seems a waste of time as input .opd sections are all
6498
             zeros as generated by gcc, but I suppose there's no reason
6499
             this will always be so.  We might start putting something in
6500
             the third word of .opd entries.  */
6501
          if ((sec->flags & SEC_IN_MEMORY) == 0)
6502
            {
6503
              bfd_byte *loc;
6504
              if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6505
                {
6506
                  if (loc != NULL)
6507
                    free (loc);
6508
                error_ret:
6509
                  if (local_syms != NULL
6510
                      && symtab_hdr->contents != (unsigned char *) local_syms)
6511
                    free (local_syms);
6512
                  if (elf_section_data (sec)->relocs != relstart)
6513
                    free (relstart);
6514
                  return FALSE;
6515
                }
6516
              sec->contents = loc;
6517
              sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6518
            }
6519
 
6520
          elf_section_data (sec)->relocs = relstart;
6521
 
6522
          new_contents = sec->contents;
6523
          if (add_aux_fields)
6524
            {
6525
              new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6526
              if (new_contents == NULL)
6527
                return FALSE;
6528
              need_pad = FALSE;
6529
            }
6530
          wptr = new_contents;
6531
          rptr = sec->contents;
6532
 
6533
          write_rel = relstart;
6534
          skip = FALSE;
6535
          offset = 0;
6536
          opd_ent_size = 0;
6537
          for (rel = relstart; rel < relend; rel++)
6538
            {
6539
              unsigned long r_symndx;
6540
              asection *sym_sec;
6541
              struct elf_link_hash_entry *h;
6542
              Elf_Internal_Sym *sym;
6543
 
6544
              r_symndx = ELF64_R_SYM (rel->r_info);
6545
              if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6546
                              r_symndx, ibfd))
6547
                goto error_ret;
6548
 
6549
              if (rel->r_offset == offset)
6550
                {
6551
                  struct ppc_link_hash_entry *fdh = NULL;
6552
 
6553
                  /* See if the .opd entry is full 24 byte or
6554
                     16 byte (with fd_aux entry overlapped with next
6555
                     fd_func).  */
6556
                  opd_ent_size = 24;
6557
                  if ((rel + 2 == relend && sec->size == offset + 16)
6558
                      || (rel + 3 < relend
6559
                          && rel[2].r_offset == offset + 16
6560
                          && rel[3].r_offset == offset + 24
6561
                          && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6562
                          && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6563
                    opd_ent_size = 16;
6564
 
6565
                  if (h != NULL
6566
                      && h->root.root.string[0] == '.')
6567
                    {
6568
                      fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6569
                                     ppc_hash_table (info));
6570
                      if (fdh != NULL
6571
                          && fdh->elf.root.type != bfd_link_hash_defined
6572
                          && fdh->elf.root.type != bfd_link_hash_defweak)
6573
                        fdh = NULL;
6574
                    }
6575
 
6576
                  skip = (sym_sec->owner != ibfd
6577
                          || sym_sec->output_section == bfd_abs_section_ptr);
6578
                  if (skip)
6579
                    {
6580
                      if (fdh != NULL && sym_sec->owner == ibfd)
6581
                        {
6582
                          /* Arrange for the function descriptor sym
6583
                             to be dropped.  */
6584
                          fdh->elf.root.u.def.value = 0;
6585
                          fdh->elf.root.u.def.section = sym_sec;
6586
                        }
6587
                      opd->adjust[rel->r_offset / 8] = -1;
6588
                    }
6589
                  else
6590
                    {
6591
                      /* We'll be keeping this opd entry.  */
6592
 
6593
                      if (fdh != NULL)
6594
                        {
6595
                          /* Redefine the function descriptor symbol to
6596
                             this location in the opd section.  It is
6597
                             necessary to update the value here rather
6598
                             than using an array of adjustments as we do
6599
                             for local symbols, because various places
6600
                             in the generic ELF code use the value
6601
                             stored in u.def.value.  */
6602
                          fdh->elf.root.u.def.value = wptr - new_contents;
6603
                          fdh->adjust_done = 1;
6604
                        }
6605
 
6606
                      /* Local syms are a bit tricky.  We could
6607
                         tweak them as they can be cached, but
6608
                         we'd need to look through the local syms
6609
                         for the function descriptor sym which we
6610
                         don't have at the moment.  So keep an
6611
                         array of adjustments.  */
6612
                      opd->adjust[rel->r_offset / 8]
6613
                        = (wptr - new_contents) - (rptr - sec->contents);
6614
 
6615
                      if (wptr != rptr)
6616
                        memcpy (wptr, rptr, opd_ent_size);
6617
                      wptr += opd_ent_size;
6618
                      if (add_aux_fields && opd_ent_size == 16)
6619
                        {
6620
                          memset (wptr, '\0', 8);
6621
                          wptr += 8;
6622
                        }
6623
                    }
6624
                  rptr += opd_ent_size;
6625
                  offset += opd_ent_size;
6626
                }
6627
 
6628
              if (skip)
6629
                {
6630
                  if (!NO_OPD_RELOCS
6631
                      && !info->relocatable
6632
                      && !dec_dynrel_count (rel->r_info, sec, info,
6633
                                            NULL, h, sym_sec))
6634
                    goto error_ret;
6635
                }
6636
              else
6637
                {
6638
                  /* We need to adjust any reloc offsets to point to the
6639
                     new opd entries.  While we're at it, we may as well
6640
                     remove redundant relocs.  */
6641
                  rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
6642
                  if (write_rel != rel)
6643
                    memcpy (write_rel, rel, sizeof (*rel));
6644
                  ++write_rel;
6645
                }
6646
            }
6647
 
6648
          sec->size = wptr - new_contents;
6649
          sec->reloc_count = write_rel - relstart;
6650
          if (add_aux_fields)
6651
            {
6652
              free (sec->contents);
6653
              sec->contents = new_contents;
6654
            }
6655
 
6656
          /* Fudge the header size too, as this is used later in
6657
             elf_bfd_final_link if we are emitting relocs.  */
6658
          elf_section_data (sec)->rel_hdr.sh_size
6659
            = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6660
          BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
6661
          some_edited = TRUE;
6662
        }
6663
      else if (elf_section_data (sec)->relocs != relstart)
6664
        free (relstart);
6665
 
6666
      if (local_syms != NULL
6667
          && symtab_hdr->contents != (unsigned char *) local_syms)
6668
        {
6669
          if (!info->keep_memory)
6670
            free (local_syms);
6671
          else
6672
            symtab_hdr->contents = (unsigned char *) local_syms;
6673
        }
6674
    }
6675
 
6676
  if (some_edited)
6677
    elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6678
 
6679
  /* If we are doing a final link and the last .opd entry is just 16 byte
6680
     long, add a 8 byte padding after it.  */
6681
  if (need_pad != NULL && !info->relocatable)
6682
    {
6683
      bfd_byte *p;
6684
 
6685
      if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6686
        {
6687
          BFD_ASSERT (need_pad->size > 0);
6688
 
6689
          p = bfd_malloc (need_pad->size + 8);
6690
          if (p == NULL)
6691
            return FALSE;
6692
 
6693
          if (! bfd_get_section_contents (need_pad->owner, need_pad,
6694
                                          p, 0, need_pad->size))
6695
            return FALSE;
6696
 
6697
          need_pad->contents = p;
6698
          need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6699
        }
6700
      else
6701
        {
6702
          p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6703
          if (p == NULL)
6704
            return FALSE;
6705
 
6706
          need_pad->contents = p;
6707
        }
6708
 
6709
      memset (need_pad->contents + need_pad->size, 0, 8);
6710
      need_pad->size += 8;
6711
    }
6712
 
6713
  return TRUE;
6714
}
6715
 
6716
/* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
6717
 
6718
asection *
6719
ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
6720
{
6721
  struct ppc_link_hash_table *htab;
6722
 
6723
  htab = ppc_hash_table (info);
6724
  if (htab->tls_get_addr != NULL)
6725
    {
6726
      struct ppc_link_hash_entry *h = htab->tls_get_addr;
6727
 
6728
      while (h->elf.root.type == bfd_link_hash_indirect
6729
             || h->elf.root.type == bfd_link_hash_warning)
6730
        h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6731
 
6732
      htab->tls_get_addr = h;
6733
 
6734
      if (htab->tls_get_addr_fd == NULL
6735
          && h->oh != NULL
6736
          && h->oh->is_func_descriptor
6737
          && (h->oh->elf.root.type == bfd_link_hash_defined
6738
              || h->oh->elf.root.type == bfd_link_hash_defweak))
6739
        htab->tls_get_addr_fd = h->oh;
6740
    }
6741
 
6742
  if (htab->tls_get_addr_fd != NULL)
6743
    {
6744
      struct ppc_link_hash_entry *h = htab->tls_get_addr_fd;
6745
 
6746
      while (h->elf.root.type == bfd_link_hash_indirect
6747
             || h->elf.root.type == bfd_link_hash_warning)
6748
        h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6749
 
6750
      htab->tls_get_addr_fd = h;
6751
    }
6752
 
6753
  return _bfd_elf_tls_setup (obfd, info);
6754
}
6755
 
6756
/* Run through all the TLS relocs looking for optimization
6757
   opportunities.  The linker has been hacked (see ppc64elf.em) to do
6758
   a preliminary section layout so that we know the TLS segment
6759
   offsets.  We can't optimize earlier because some optimizations need
6760
   to know the tp offset, and we need to optimize before allocating
6761
   dynamic relocations.  */
6762
 
6763
bfd_boolean
6764
ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6765
{
6766
  bfd *ibfd;
6767
  asection *sec;
6768
  struct ppc_link_hash_table *htab;
6769
  int pass;
6770
 
6771
  if (info->relocatable || info->shared)
6772
    return TRUE;
6773
 
6774
  htab = ppc_hash_table (info);
6775
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6776
    {
6777
      Elf_Internal_Sym *locsyms = NULL;
6778
      asection *toc = bfd_get_section_by_name (ibfd, ".toc");
6779
      unsigned char *toc_ref = NULL;
6780
 
6781
      /* Look at all the sections for this file.  Make two passes over
6782
         the relocs.  On the first pass, mark toc entries involved
6783
         with tls relocs, and check that tls relocs involved in
6784
         setting up a tls_get_addr call are indeed followed by such a
6785
         call.  If they are not, exclude them from the optimizations
6786
         done on the second pass.  */
6787
      for (pass = 0; pass < 2; ++pass)
6788
        for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6789
          if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
6790
            {
6791
              Elf_Internal_Rela *relstart, *rel, *relend;
6792
 
6793
              /* Read the relocations.  */
6794
              relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6795
                                                    info->keep_memory);
6796
              if (relstart == NULL)
6797
                return FALSE;
6798
 
6799
              relend = relstart + sec->reloc_count;
6800
              for (rel = relstart; rel < relend; rel++)
6801
                {
6802
                  enum elf_ppc64_reloc_type r_type;
6803
                  unsigned long r_symndx;
6804
                  struct elf_link_hash_entry *h;
6805
                  Elf_Internal_Sym *sym;
6806
                  asection *sym_sec;
6807
                  char *tls_mask;
6808
                  char tls_set, tls_clear, tls_type = 0;
6809
                  bfd_vma value;
6810
                  bfd_boolean ok_tprel, is_local;
6811
                  long toc_ref_index = 0;
6812
                  int expecting_tls_get_addr = 0;
6813
 
6814
                  r_symndx = ELF64_R_SYM (rel->r_info);
6815
                  if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
6816
                                  r_symndx, ibfd))
6817
                    {
6818
                    err_free_rel:
6819
                      if (elf_section_data (sec)->relocs != relstart)
6820
                        free (relstart);
6821
                      if (toc_ref != NULL)
6822
                        free (toc_ref);
6823
                      if (locsyms != NULL
6824
                          && (elf_symtab_hdr (ibfd).contents
6825
                              != (unsigned char *) locsyms))
6826
                        free (locsyms);
6827
                      return FALSE;
6828
                    }
6829
 
6830
                  if (h != NULL)
6831
                    {
6832
                      if (h->root.type != bfd_link_hash_defined
6833
                          && h->root.type != bfd_link_hash_defweak)
6834
                        continue;
6835
                      value = h->root.u.def.value;
6836
                    }
6837
                  else
6838
                    /* Symbols referenced by TLS relocs must be of type
6839
                       STT_TLS.  So no need for .opd local sym adjust.  */
6840
                    value = sym->st_value;
6841
 
6842
                  ok_tprel = FALSE;
6843
                  is_local = FALSE;
6844
                  if (h == NULL
6845
                      || !h->def_dynamic)
6846
                    {
6847
                      is_local = TRUE;
6848
                      value += sym_sec->output_offset;
6849
                      value += sym_sec->output_section->vma;
6850
                      value -= htab->elf.tls_sec->vma;
6851
                      ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
6852
                                  < (bfd_vma) 1 << 32);
6853
                    }
6854
 
6855
                  r_type = ELF64_R_TYPE (rel->r_info);
6856
                  switch (r_type)
6857
                    {
6858
                    case R_PPC64_GOT_TLSLD16:
6859
                    case R_PPC64_GOT_TLSLD16_LO:
6860
                      expecting_tls_get_addr = 1;
6861
                      /* Fall thru */
6862
 
6863
                    case R_PPC64_GOT_TLSLD16_HI:
6864
                    case R_PPC64_GOT_TLSLD16_HA:
6865
                      /* These relocs should never be against a symbol
6866
                         defined in a shared lib.  Leave them alone if
6867
                         that turns out to be the case.  */
6868
                      if (!is_local)
6869
                        continue;
6870
 
6871
                      /* LD -> LE */
6872
                      tls_set = 0;
6873
                      tls_clear = TLS_LD;
6874
                      tls_type = TLS_TLS | TLS_LD;
6875
                      break;
6876
 
6877
                    case R_PPC64_GOT_TLSGD16:
6878
                    case R_PPC64_GOT_TLSGD16_LO:
6879
                      expecting_tls_get_addr = 1;
6880
                      /* Fall thru */
6881
 
6882
                    case R_PPC64_GOT_TLSGD16_HI:
6883
                    case R_PPC64_GOT_TLSGD16_HA:
6884
                      if (ok_tprel)
6885
                        /* GD -> LE */
6886
                        tls_set = 0;
6887
                      else
6888
                        /* GD -> IE */
6889
                        tls_set = TLS_TLS | TLS_TPRELGD;
6890
                      tls_clear = TLS_GD;
6891
                      tls_type = TLS_TLS | TLS_GD;
6892
                      break;
6893
 
6894
                    case R_PPC64_GOT_TPREL16_DS:
6895
                    case R_PPC64_GOT_TPREL16_LO_DS:
6896
                    case R_PPC64_GOT_TPREL16_HI:
6897
                    case R_PPC64_GOT_TPREL16_HA:
6898
                      if (ok_tprel)
6899
                        {
6900
                          /* IE -> LE */
6901
                          tls_set = 0;
6902
                          tls_clear = TLS_TPREL;
6903
                          tls_type = TLS_TLS | TLS_TPREL;
6904
                          break;
6905
                        }
6906
                      continue;
6907
 
6908
                    case R_PPC64_TOC16:
6909
                    case R_PPC64_TOC16_LO:
6910
                    case R_PPC64_TLS:
6911
                      if (sym_sec == NULL || sym_sec != toc)
6912
                        continue;
6913
 
6914
                      /* Mark this toc entry as referenced by a TLS
6915
                         code sequence.  We can do that now in the
6916
                         case of R_PPC64_TLS, and after checking for
6917
                         tls_get_addr for the TOC16 relocs.  */
6918
                      if (toc_ref == NULL)
6919
                        {
6920
                          toc_ref = bfd_zmalloc (toc->size / 8);
6921
                          if (toc_ref == NULL)
6922
                            goto err_free_rel;
6923
                        }
6924
                      if (h != NULL)
6925
                        value = h->root.u.def.value;
6926
                      else
6927
                        value = sym->st_value;
6928
                      value += rel->r_addend;
6929
                      BFD_ASSERT (value < toc->size && value % 8 == 0);
6930
                      toc_ref_index = value / 8;
6931
                      if (r_type == R_PPC64_TLS)
6932
                        {
6933
                          toc_ref[toc_ref_index] = 1;
6934
                          continue;
6935
                        }
6936
 
6937
                      if (pass != 0 && toc_ref[toc_ref_index] == 0)
6938
                        continue;
6939
 
6940
                      tls_set = 0;
6941
                      tls_clear = 0;
6942
                      expecting_tls_get_addr = 2;
6943
                      break;
6944
 
6945
                    case R_PPC64_TPREL64:
6946
                      if (pass == 0
6947
                          || sec != toc
6948
                          || toc_ref == NULL
6949
                          || !toc_ref[rel->r_offset / 8])
6950
                        continue;
6951
                      if (ok_tprel)
6952
                        {
6953
                          /* IE -> LE */
6954
                          tls_set = TLS_EXPLICIT;
6955
                          tls_clear = TLS_TPREL;
6956
                          break;
6957
                        }
6958
                      continue;
6959
 
6960
                    case R_PPC64_DTPMOD64:
6961
                      if (pass == 0
6962
                          || sec != toc
6963
                          || toc_ref == NULL
6964
                          || !toc_ref[rel->r_offset / 8])
6965
                        continue;
6966
                      if (rel + 1 < relend
6967
                          && (rel[1].r_info
6968
                              == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
6969
                          && rel[1].r_offset == rel->r_offset + 8)
6970
                        {
6971
                          if (ok_tprel)
6972
                            /* GD -> LE */
6973
                            tls_set = TLS_EXPLICIT | TLS_GD;
6974
                          else
6975
                            /* GD -> IE */
6976
                            tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
6977
                          tls_clear = TLS_GD;
6978
                        }
6979
                      else
6980
                        {
6981
                          if (!is_local)
6982
                            continue;
6983
 
6984
                          /* LD -> LE */
6985
                          tls_set = TLS_EXPLICIT;
6986
                          tls_clear = TLS_LD;
6987
                        }
6988
                      break;
6989
 
6990
                    default:
6991
                      continue;
6992
                    }
6993
 
6994
                  if (pass == 0)
6995
                    {
6996
                      if (!expecting_tls_get_addr)
6997
                        continue;
6998
 
6999
                      if (rel + 1 < relend)
7000
                        {
7001
                          Elf_Internal_Shdr *symtab_hdr;
7002
                          enum elf_ppc64_reloc_type r_type2;
7003
                          unsigned long r_symndx2;
7004
                          struct elf_link_hash_entry *h2;
7005
 
7006
                          symtab_hdr = &elf_symtab_hdr (ibfd);
7007
 
7008
                          /* The next instruction should be a call to
7009
                             __tls_get_addr.  Peek at the reloc to be sure.  */
7010
                          r_type2 = ELF64_R_TYPE (rel[1].r_info);
7011
                          r_symndx2 = ELF64_R_SYM (rel[1].r_info);
7012
                          if (r_symndx2 >= symtab_hdr->sh_info
7013
                              && (r_type2 == R_PPC64_REL14
7014
                                  || r_type2 == R_PPC64_REL14_BRTAKEN
7015
                                  || r_type2 == R_PPC64_REL14_BRNTAKEN
7016
                                  || r_type2 == R_PPC64_REL24))
7017
                            {
7018
                              struct elf_link_hash_entry **sym_hashes;
7019
 
7020
                              sym_hashes = elf_sym_hashes (ibfd);
7021
 
7022
                              h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
7023
                              while (h2->root.type == bfd_link_hash_indirect
7024
                                     || h2->root.type == bfd_link_hash_warning)
7025
                                h2 = ((struct elf_link_hash_entry *)
7026
                                      h2->root.u.i.link);
7027
                              if (h2 != NULL
7028
                                  && (h2 == &htab->tls_get_addr->elf
7029
                                      || h2 == &htab->tls_get_addr_fd->elf))
7030
                                {
7031
                                  if (expecting_tls_get_addr == 2)
7032
                                    {
7033
                                      /* Check for toc tls entries.  */
7034
                                      char *toc_tls;
7035
                                      int retval;
7036
 
7037
                                      retval = get_tls_mask (&toc_tls, NULL,
7038
                                                             &locsyms,
7039
                                                             rel, ibfd);
7040
                                      if (retval == 0)
7041
                                        goto err_free_rel;
7042
                                      if (retval > 1 && toc_tls != NULL)
7043
                                        toc_ref[toc_ref_index] = 1;
7044
                                    }
7045
                                  continue;
7046
                                }
7047
                            }
7048
                        }
7049
 
7050
                      if (expecting_tls_get_addr != 1)
7051
                        continue;
7052
 
7053
                      /* Uh oh, we didn't find the expected call.  We
7054
                         could just mark this symbol to exclude it
7055
                         from tls optimization but it's safer to skip
7056
                         the entire section.  */
7057
                      sec->has_tls_reloc = 0;
7058
                      break;
7059
                    }
7060
 
7061
                  if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7062
                    {
7063
                      struct plt_entry *ent;
7064
                      for (ent = htab->tls_get_addr->elf.plt.plist;
7065
                           ent != NULL;
7066
                           ent = ent->next)
7067
                        if (ent->addend == 0)
7068
                          {
7069
                            if (ent->plt.refcount > 0)
7070
                              {
7071
                                ent->plt.refcount -= 1;
7072
                                expecting_tls_get_addr = 0;
7073
                              }
7074
                            break;
7075
                          }
7076
                    }
7077
 
7078
                  if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7079
                    {
7080
                      struct plt_entry *ent;
7081
                      for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7082
                           ent != NULL;
7083
                           ent = ent->next)
7084
                        if (ent->addend == 0)
7085
                          {
7086
                            if (ent->plt.refcount > 0)
7087
                              ent->plt.refcount -= 1;
7088
                            break;
7089
                          }
7090
                    }
7091
 
7092
                  if (tls_clear == 0)
7093
                    continue;
7094
 
7095
                  if ((tls_set & TLS_EXPLICIT) == 0)
7096
                    {
7097
                      struct got_entry *ent;
7098
 
7099
                      /* Adjust got entry for this reloc.  */
7100
                      if (h != NULL)
7101
                        ent = h->got.glist;
7102
                      else
7103
                        ent = elf_local_got_ents (ibfd)[r_symndx];
7104
 
7105
                      for (; ent != NULL; ent = ent->next)
7106
                        if (ent->addend == rel->r_addend
7107
                            && ent->owner == ibfd
7108
                            && ent->tls_type == tls_type)
7109
                          break;
7110
                      if (ent == NULL)
7111
                        abort ();
7112
 
7113
                      if (tls_set == 0)
7114
                        {
7115
                          /* We managed to get rid of a got entry.  */
7116
                          if (ent->got.refcount > 0)
7117
                            ent->got.refcount -= 1;
7118
                        }
7119
                    }
7120
                  else
7121
                    {
7122
                      /* If we got rid of a DTPMOD/DTPREL reloc pair then
7123
                         we'll lose one or two dyn relocs.  */
7124
                      if (!dec_dynrel_count (rel->r_info, sec, info,
7125
                                             NULL, h, sym_sec))
7126
                        return FALSE;
7127
 
7128
                      if (tls_set == (TLS_EXPLICIT | TLS_GD))
7129
                        {
7130
                          if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7131
                                                 NULL, h, sym_sec))
7132
                            return FALSE;
7133
                        }
7134
                    }
7135
 
7136
                  *tls_mask |= tls_set;
7137
                  *tls_mask &= ~tls_clear;
7138
                }
7139
 
7140
              if (elf_section_data (sec)->relocs != relstart)
7141
                free (relstart);
7142
            }
7143
 
7144
        if (toc_ref != NULL)
7145
          free (toc_ref);
7146
 
7147
        if (locsyms != NULL
7148
            && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7149
          {
7150
            if (!info->keep_memory)
7151
              free (locsyms);
7152
            else
7153
              elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7154
          }
7155
      }
7156
  return TRUE;
7157
}
7158
 
7159
/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7160
   the values of any global symbols in a toc section that has been
7161
   edited.  Globals in toc sections should be a rarity, so this function
7162
   sets a flag if any are found in toc sections other than the one just
7163
   edited, so that futher hash table traversals can be avoided.  */
7164
 
7165
struct adjust_toc_info
7166
{
7167
  asection *toc;
7168
  unsigned long *skip;
7169
  bfd_boolean global_toc_syms;
7170
};
7171
 
7172
static bfd_boolean
7173
adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7174
{
7175
  struct ppc_link_hash_entry *eh;
7176
  struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7177
 
7178
  if (h->root.type == bfd_link_hash_indirect)
7179
    return TRUE;
7180
 
7181
  if (h->root.type == bfd_link_hash_warning)
7182
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
7183
 
7184
  if (h->root.type != bfd_link_hash_defined
7185
      && h->root.type != bfd_link_hash_defweak)
7186
    return TRUE;
7187
 
7188
  eh = (struct ppc_link_hash_entry *) h;
7189
  if (eh->adjust_done)
7190
    return TRUE;
7191
 
7192
  if (eh->elf.root.u.def.section == toc_inf->toc)
7193
    {
7194
      unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7195
      if (skip != (unsigned long) -1)
7196
        eh->elf.root.u.def.value -= skip;
7197
      else
7198
        {
7199
          (*_bfd_error_handler)
7200
            (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7201
          eh->elf.root.u.def.section = &bfd_abs_section;
7202
          eh->elf.root.u.def.value = 0;
7203
        }
7204
      eh->adjust_done = 1;
7205
    }
7206
  else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7207
    toc_inf->global_toc_syms = TRUE;
7208
 
7209
  return TRUE;
7210
}
7211
 
7212
/* Examine all relocs referencing .toc sections in order to remove
7213
   unused .toc entries.  */
7214
 
7215
bfd_boolean
7216
ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7217
{
7218
  bfd *ibfd;
7219
  struct adjust_toc_info toc_inf;
7220
 
7221
  toc_inf.global_toc_syms = TRUE;
7222
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7223
    {
7224
      asection *toc, *sec;
7225
      Elf_Internal_Shdr *symtab_hdr;
7226
      Elf_Internal_Sym *local_syms;
7227
      struct elf_link_hash_entry **sym_hashes;
7228
      Elf_Internal_Rela *relstart, *rel;
7229
      unsigned long *skip, *drop;
7230
      unsigned char *used;
7231
      unsigned char *keep, last, some_unused;
7232
 
7233
      toc = bfd_get_section_by_name (ibfd, ".toc");
7234
      if (toc == NULL
7235
          || toc->size == 0
7236
          || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7237
          || elf_discarded_section (toc))
7238
        continue;
7239
 
7240
      local_syms = NULL;
7241
      symtab_hdr = &elf_symtab_hdr (ibfd);
7242
      sym_hashes = elf_sym_hashes (ibfd);
7243
 
7244
      /* Look at sections dropped from the final link.  */
7245
      skip = NULL;
7246
      relstart = NULL;
7247
      for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7248
        {
7249
          if (sec->reloc_count == 0
7250
              || !elf_discarded_section (sec)
7251
              || get_opd_info (sec)
7252
              || (sec->flags & SEC_ALLOC) == 0
7253
              || (sec->flags & SEC_DEBUGGING) != 0)
7254
            continue;
7255
 
7256
          relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7257
          if (relstart == NULL)
7258
            goto error_ret;
7259
 
7260
          /* Run through the relocs to see which toc entries might be
7261
             unused.  */
7262
          for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7263
            {
7264
              enum elf_ppc64_reloc_type r_type;
7265
              unsigned long r_symndx;
7266
              asection *sym_sec;
7267
              struct elf_link_hash_entry *h;
7268
              Elf_Internal_Sym *sym;
7269
              bfd_vma val;
7270
 
7271
              r_type = ELF64_R_TYPE (rel->r_info);
7272
              switch (r_type)
7273
                {
7274
                default:
7275
                  continue;
7276
 
7277
                case R_PPC64_TOC16:
7278
                case R_PPC64_TOC16_LO:
7279
                case R_PPC64_TOC16_HI:
7280
                case R_PPC64_TOC16_HA:
7281
                case R_PPC64_TOC16_DS:
7282
                case R_PPC64_TOC16_LO_DS:
7283
                  break;
7284
                }
7285
 
7286
              r_symndx = ELF64_R_SYM (rel->r_info);
7287
              if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7288
                              r_symndx, ibfd))
7289
                goto error_ret;
7290
 
7291
              if (sym_sec != toc)
7292
                continue;
7293
 
7294
              if (h != NULL)
7295
                val = h->root.u.def.value;
7296
              else
7297
                val = sym->st_value;
7298
              val += rel->r_addend;
7299
 
7300
              if (val >= toc->size)
7301
                continue;
7302
 
7303
              /* Anything in the toc ought to be aligned to 8 bytes.
7304
                 If not, don't mark as unused.  */
7305
              if (val & 7)
7306
                continue;
7307
 
7308
              if (skip == NULL)
7309
                {
7310
                  skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7311
                  if (skip == NULL)
7312
                    goto error_ret;
7313
                }
7314
 
7315
              skip[val >> 3] = 1;
7316
            }
7317
 
7318
          if (elf_section_data (sec)->relocs != relstart)
7319
            free (relstart);
7320
        }
7321
 
7322
      if (skip == NULL)
7323
        continue;
7324
 
7325
      used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7326
      if (used == NULL)
7327
        {
7328
        error_ret:
7329
          if (local_syms != NULL
7330
              && symtab_hdr->contents != (unsigned char *) local_syms)
7331
            free (local_syms);
7332
          if (sec != NULL
7333
              && relstart != NULL
7334
              && elf_section_data (sec)->relocs != relstart)
7335
            free (relstart);
7336
          if (skip != NULL)
7337
            free (skip);
7338
          return FALSE;
7339
        }
7340
 
7341
      /* Now check all kept sections that might reference the toc.
7342
         Check the toc itself last.  */
7343
      for (sec = (ibfd->sections == toc && toc->next ? toc->next
7344
                  : ibfd->sections);
7345
           sec != NULL;
7346
           sec = (sec == toc ? NULL
7347
                  : sec->next == NULL ? toc
7348
                  : sec->next == toc && toc->next ? toc->next
7349
                  : sec->next))
7350
        {
7351
          int repeat;
7352
 
7353
          if (sec->reloc_count == 0
7354
              || elf_discarded_section (sec)
7355
              || get_opd_info (sec)
7356
              || (sec->flags & SEC_ALLOC) == 0
7357
              || (sec->flags & SEC_DEBUGGING) != 0)
7358
            continue;
7359
 
7360
          relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7361
          if (relstart == NULL)
7362
            goto error_ret;
7363
 
7364
          /* Mark toc entries referenced as used.  */
7365
          repeat = 0;
7366
          do
7367
            for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7368
              {
7369
                enum elf_ppc64_reloc_type r_type;
7370
                unsigned long r_symndx;
7371
                asection *sym_sec;
7372
                struct elf_link_hash_entry *h;
7373
                Elf_Internal_Sym *sym;
7374
                bfd_vma val;
7375
 
7376
                r_type = ELF64_R_TYPE (rel->r_info);
7377
                switch (r_type)
7378
                  {
7379
                  case R_PPC64_TOC16:
7380
                  case R_PPC64_TOC16_LO:
7381
                  case R_PPC64_TOC16_HI:
7382
                  case R_PPC64_TOC16_HA:
7383
                  case R_PPC64_TOC16_DS:
7384
                  case R_PPC64_TOC16_LO_DS:
7385
                    /* In case we're taking addresses of toc entries.  */
7386
                  case R_PPC64_ADDR64:
7387
                    break;
7388
 
7389
                  default:
7390
                    continue;
7391
                  }
7392
 
7393
                r_symndx = ELF64_R_SYM (rel->r_info);
7394
                if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7395
                                r_symndx, ibfd))
7396
                  {
7397
                    free (used);
7398
                    goto error_ret;
7399
                  }
7400
 
7401
                if (sym_sec != toc)
7402
                  continue;
7403
 
7404
                if (h != NULL)
7405
                  val = h->root.u.def.value;
7406
                else
7407
                  val = sym->st_value;
7408
                val += rel->r_addend;
7409
 
7410
                if (val >= toc->size)
7411
                  continue;
7412
 
7413
                /* For the toc section, we only mark as used if
7414
                   this entry itself isn't unused.  */
7415
                if (sec == toc
7416
                    && !used[val >> 3]
7417
                    && (used[rel->r_offset >> 3]
7418
                        || !skip[rel->r_offset >> 3]))
7419
                  /* Do all the relocs again, to catch reference
7420
                     chains.  */
7421
                  repeat = 1;
7422
 
7423
                used[val >> 3] = 1;
7424
              }
7425
          while (repeat);
7426
        }
7427
 
7428
      /* Merge the used and skip arrays.  Assume that TOC
7429
         doublewords not appearing as either used or unused belong
7430
         to to an entry more than one doubleword in size.  */
7431
      for (drop = skip, keep = used, last = 0, some_unused = 0;
7432
           drop < skip + (toc->size + 7) / 8;
7433
           ++drop, ++keep)
7434
        {
7435
          if (*keep)
7436
            {
7437
              *drop = 0;
7438
              last = 0;
7439
            }
7440
          else if (*drop)
7441
            {
7442
              some_unused = 1;
7443
              last = 1;
7444
            }
7445
          else
7446
            *drop = last;
7447
        }
7448
 
7449
      free (used);
7450
 
7451
      if (some_unused)
7452
        {
7453
          bfd_byte *contents, *src;
7454
          unsigned long off;
7455
 
7456
          /* Shuffle the toc contents, and at the same time convert the
7457
             skip array from booleans into offsets.  */
7458
          if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7459
            goto error_ret;
7460
 
7461
          elf_section_data (toc)->this_hdr.contents = contents;
7462
 
7463
          for (src = contents, off = 0, drop = skip;
7464
               src < contents + toc->size;
7465
               src += 8, ++drop)
7466
            {
7467
              if (*drop)
7468
                {
7469
                  *drop = (unsigned long) -1;
7470
                  off += 8;
7471
                }
7472
              else if (off != 0)
7473
                {
7474
                  *drop = off;
7475
                  memcpy (src - off, src, 8);
7476
                }
7477
            }
7478
          toc->rawsize = toc->size;
7479
          toc->size = src - contents - off;
7480
 
7481
          if (toc->reloc_count != 0)
7482
            {
7483
              Elf_Internal_Rela *wrel;
7484
              bfd_size_type sz;
7485
 
7486
              /* Read toc relocs.  */
7487
              relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7488
                                                    TRUE);
7489
              if (relstart == NULL)
7490
                goto error_ret;
7491
 
7492
              /* Remove unused toc relocs, and adjust those we keep.  */
7493
              wrel = relstart;
7494
              for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7495
                if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7496
                  {
7497
                    wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7498
                    wrel->r_info = rel->r_info;
7499
                    wrel->r_addend = rel->r_addend;
7500
                    ++wrel;
7501
                  }
7502
                else if (!dec_dynrel_count (rel->r_info, toc, info,
7503
                                            &local_syms, NULL, NULL))
7504
                  goto error_ret;
7505
 
7506
              toc->reloc_count = wrel - relstart;
7507
              sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7508
              elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7509
              BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7510
            }
7511
 
7512
          /* Adjust addends for relocs against the toc section sym.  */
7513
          for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7514
            {
7515
              if (sec->reloc_count == 0
7516
                  || elf_discarded_section (sec))
7517
                continue;
7518
 
7519
              relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7520
                                                    TRUE);
7521
              if (relstart == NULL)
7522
                goto error_ret;
7523
 
7524
              for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7525
                {
7526
                  enum elf_ppc64_reloc_type r_type;
7527
                  unsigned long r_symndx;
7528
                  asection *sym_sec;
7529
                  struct elf_link_hash_entry *h;
7530
                  Elf_Internal_Sym *sym;
7531
 
7532
                  r_type = ELF64_R_TYPE (rel->r_info);
7533
                  switch (r_type)
7534
                    {
7535
                    default:
7536
                      continue;
7537
 
7538
                    case R_PPC64_TOC16:
7539
                    case R_PPC64_TOC16_LO:
7540
                    case R_PPC64_TOC16_HI:
7541
                    case R_PPC64_TOC16_HA:
7542
                    case R_PPC64_TOC16_DS:
7543
                    case R_PPC64_TOC16_LO_DS:
7544
                    case R_PPC64_ADDR64:
7545
                      break;
7546
                    }
7547
 
7548
                  r_symndx = ELF64_R_SYM (rel->r_info);
7549
                  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7550
                                  r_symndx, ibfd))
7551
                    goto error_ret;
7552
 
7553
                  if (sym_sec != toc || h != NULL || sym->st_value != 0)
7554
                    continue;
7555
 
7556
                  rel->r_addend -= skip[rel->r_addend >> 3];
7557
                }
7558
            }
7559
 
7560
          /* We shouldn't have local or global symbols defined in the TOC,
7561
             but handle them anyway.  */
7562
          if (local_syms != NULL)
7563
            {
7564
              Elf_Internal_Sym *sym;
7565
 
7566
              for (sym = local_syms;
7567
                   sym < local_syms + symtab_hdr->sh_info;
7568
                   ++sym)
7569
                if (sym->st_value != 0
7570
                    && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7571
                  {
7572
                    if (skip[sym->st_value >> 3] != (unsigned long) -1)
7573
                      sym->st_value -= skip[sym->st_value >> 3];
7574
                    else
7575
                      {
7576
                        (*_bfd_error_handler)
7577
                          (_("%s defined in removed toc entry"),
7578
                           bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7579
                                             NULL));
7580
                        sym->st_value = 0;
7581
                        sym->st_shndx = SHN_ABS;
7582
                      }
7583
                    symtab_hdr->contents = (unsigned char *) local_syms;
7584
                  }
7585
            }
7586
 
7587
          /* Finally, adjust any global syms defined in the toc.  */
7588
          if (toc_inf.global_toc_syms)
7589
            {
7590
              toc_inf.toc = toc;
7591
              toc_inf.skip = skip;
7592
              toc_inf.global_toc_syms = FALSE;
7593
              elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7594
                                      &toc_inf);
7595
            }
7596
        }
7597
 
7598
      if (local_syms != NULL
7599
          && symtab_hdr->contents != (unsigned char *) local_syms)
7600
        {
7601
          if (!info->keep_memory)
7602
            free (local_syms);
7603
          else
7604
            symtab_hdr->contents = (unsigned char *) local_syms;
7605
        }
7606
      free (skip);
7607
    }
7608
 
7609
  return TRUE;
7610
}
7611
 
7612
/* Allocate space in .plt, .got and associated reloc sections for
7613
   dynamic relocs.  */
7614
 
7615
static bfd_boolean
7616
allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7617
{
7618
  struct bfd_link_info *info;
7619
  struct ppc_link_hash_table *htab;
7620
  asection *s;
7621
  struct ppc_link_hash_entry *eh;
7622
  struct ppc_dyn_relocs *p;
7623
  struct got_entry *gent;
7624
 
7625
  if (h->root.type == bfd_link_hash_indirect)
7626
    return TRUE;
7627
 
7628
  if (h->root.type == bfd_link_hash_warning)
7629
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
7630
 
7631
  info = (struct bfd_link_info *) inf;
7632
  htab = ppc_hash_table (info);
7633
 
7634
  if (htab->elf.dynamic_sections_created
7635
      && h->dynindx != -1
7636
      && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7637
    {
7638
      struct plt_entry *pent;
7639
      bfd_boolean doneone = FALSE;
7640
      for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7641
        if (pent->plt.refcount > 0)
7642
          {
7643
            /* If this is the first .plt entry, make room for the special
7644
               first entry.  */
7645
            s = htab->plt;
7646
            if (s->size == 0)
7647
              s->size += PLT_INITIAL_ENTRY_SIZE;
7648
 
7649
            pent->plt.offset = s->size;
7650
 
7651
            /* Make room for this entry.  */
7652
            s->size += PLT_ENTRY_SIZE;
7653
 
7654
            /* Make room for the .glink code.  */
7655
            s = htab->glink;
7656
            if (s->size == 0)
7657
              s->size += GLINK_CALL_STUB_SIZE;
7658
            /* We need bigger stubs past index 32767.  */
7659
            if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
7660
              s->size += 4;
7661
            s->size += 2*4;
7662
 
7663
            /* We also need to make an entry in the .rela.plt section.  */
7664
            s = htab->relplt;
7665
            s->size += sizeof (Elf64_External_Rela);
7666
            doneone = TRUE;
7667
          }
7668
        else
7669
          pent->plt.offset = (bfd_vma) -1;
7670
      if (!doneone)
7671
        {
7672
          h->plt.plist = NULL;
7673
          h->needs_plt = 0;
7674
        }
7675
    }
7676
  else
7677
    {
7678
      h->plt.plist = NULL;
7679
      h->needs_plt = 0;
7680
    }
7681
 
7682
  eh = (struct ppc_link_hash_entry *) h;
7683
  /* Run through the TLS GD got entries first if we're changing them
7684
     to TPREL.  */
7685
  if ((eh->tls_mask & TLS_TPRELGD) != 0)
7686
    for (gent = h->got.glist; gent != NULL; gent = gent->next)
7687
      if (gent->got.refcount > 0
7688
          && (gent->tls_type & TLS_GD) != 0)
7689
        {
7690
          /* This was a GD entry that has been converted to TPREL.  If
7691
             there happens to be a TPREL entry we can use that one.  */
7692
          struct got_entry *ent;
7693
          for (ent = h->got.glist; ent != NULL; ent = ent->next)
7694
            if (ent->got.refcount > 0
7695
                && (ent->tls_type & TLS_TPREL) != 0
7696
                && ent->addend == gent->addend
7697
                && ent->owner == gent->owner)
7698
              {
7699
                gent->got.refcount = 0;
7700
                break;
7701
              }
7702
 
7703
          /* If not, then we'll be using our own TPREL entry.  */
7704
          if (gent->got.refcount != 0)
7705
            gent->tls_type = TLS_TLS | TLS_TPREL;
7706
        }
7707
 
7708
  for (gent = h->got.glist; gent != NULL; gent = gent->next)
7709
    if (gent->got.refcount > 0)
7710
      {
7711
        bfd_boolean dyn;
7712
 
7713
        /* Make sure this symbol is output as a dynamic symbol.
7714
           Undefined weak syms won't yet be marked as dynamic,
7715
           nor will all TLS symbols.  */
7716
        if (h->dynindx == -1
7717
            && !h->forced_local)
7718
          {
7719
            if (! bfd_elf_link_record_dynamic_symbol (info, h))
7720
              return FALSE;
7721
          }
7722
 
7723
        if ((gent->tls_type & TLS_LD) != 0
7724
            && !h->def_dynamic)
7725
          {
7726
            ppc64_tlsld_got (gent->owner)->refcount += 1;
7727
            gent->got.offset = (bfd_vma) -1;
7728
            continue;
7729
          }
7730
 
7731
        if (!is_ppc64_elf (gent->owner))
7732
          continue;
7733
 
7734
        s = ppc64_elf_tdata (gent->owner)->got;
7735
        gent->got.offset = s->size;
7736
        s->size
7737
          += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
7738
        dyn = htab->elf.dynamic_sections_created;
7739
        if ((info->shared
7740
             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
7741
            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7742
                || h->root.type != bfd_link_hash_undefweak))
7743
          ppc64_elf_tdata (gent->owner)->relgot->size
7744
            += (gent->tls_type & eh->tls_mask & TLS_GD
7745
                ? 2 * sizeof (Elf64_External_Rela)
7746
                : sizeof (Elf64_External_Rela));
7747
      }
7748
    else
7749
      gent->got.offset = (bfd_vma) -1;
7750
 
7751
  if (eh->dyn_relocs == NULL)
7752
    return TRUE;
7753
 
7754
  /* In the shared -Bsymbolic case, discard space allocated for
7755
     dynamic pc-relative relocs against symbols which turn out to be
7756
     defined in regular objects.  For the normal shared case, discard
7757
     space for relocs that have become local due to symbol visibility
7758
     changes.  */
7759
 
7760
  if (info->shared)
7761
    {
7762
      /* Relocs that use pc_count are those that appear on a call insn,
7763
         or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
7764
         generated via assembly.  We want calls to protected symbols to
7765
         resolve directly to the function rather than going via the plt.
7766
         If people want function pointer comparisons to work as expected
7767
         then they should avoid writing weird assembly.  */
7768
      if (SYMBOL_CALLS_LOCAL (info, h))
7769
        {
7770
          struct ppc_dyn_relocs **pp;
7771
 
7772
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
7773
            {
7774
              p->count -= p->pc_count;
7775
              p->pc_count = 0;
7776
              if (p->count == 0)
7777
                *pp = p->next;
7778
              else
7779
                pp = &p->next;
7780
            }
7781
        }
7782
 
7783
      /* Also discard relocs on undefined weak syms with non-default
7784
         visibility.  */
7785
      if (eh->dyn_relocs != NULL
7786
          && h->root.type == bfd_link_hash_undefweak)
7787
        {
7788
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
7789
            eh->dyn_relocs = NULL;
7790
 
7791
          /* Make sure this symbol is output as a dynamic symbol.
7792
             Undefined weak syms won't yet be marked as dynamic.  */
7793
          else if (h->dynindx == -1
7794
                   && !h->forced_local)
7795
            {
7796
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
7797
                return FALSE;
7798
            }
7799
        }
7800
    }
7801
  else if (ELIMINATE_COPY_RELOCS)
7802
    {
7803
      /* For the non-shared case, discard space for relocs against
7804
         symbols which turn out to need copy relocs or are not
7805
         dynamic.  */
7806
 
7807
      if (!h->non_got_ref
7808
          && h->def_dynamic
7809
          && !h->def_regular)
7810
        {
7811
          /* Make sure this symbol is output as a dynamic symbol.
7812
             Undefined weak syms won't yet be marked as dynamic.  */
7813
          if (h->dynindx == -1
7814
              && !h->forced_local)
7815
            {
7816
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
7817
                return FALSE;
7818
            }
7819
 
7820
          /* If that succeeded, we know we'll be keeping all the
7821
             relocs.  */
7822
          if (h->dynindx != -1)
7823
            goto keep;
7824
        }
7825
 
7826
      eh->dyn_relocs = NULL;
7827
 
7828
    keep: ;
7829
    }
7830
 
7831
  /* Finally, allocate space.  */
7832
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
7833
    {
7834
      asection *sreloc = elf_section_data (p->sec)->sreloc;
7835
      sreloc->size += p->count * sizeof (Elf64_External_Rela);
7836
    }
7837
 
7838
  return TRUE;
7839
}
7840
 
7841
/* Find any dynamic relocs that apply to read-only sections.  */
7842
 
7843
static bfd_boolean
7844
readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7845
{
7846
  struct ppc_link_hash_entry *eh;
7847
  struct ppc_dyn_relocs *p;
7848
 
7849
  if (h->root.type == bfd_link_hash_warning)
7850
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
7851
 
7852
  eh = (struct ppc_link_hash_entry *) h;
7853
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
7854
    {
7855
      asection *s = p->sec->output_section;
7856
 
7857
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
7858
        {
7859
          struct bfd_link_info *info = inf;
7860
 
7861
          info->flags |= DF_TEXTREL;
7862
 
7863
          /* Not an error, just cut short the traversal.  */
7864
          return FALSE;
7865
        }
7866
    }
7867
  return TRUE;
7868
}
7869
 
7870
/* Set the sizes of the dynamic sections.  */
7871
 
7872
static bfd_boolean
7873
ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
7874
                                 struct bfd_link_info *info)
7875
{
7876
  struct ppc_link_hash_table *htab;
7877
  bfd *dynobj;
7878
  asection *s;
7879
  bfd_boolean relocs;
7880
  bfd *ibfd;
7881
 
7882
  htab = ppc_hash_table (info);
7883
  dynobj = htab->elf.dynobj;
7884
  if (dynobj == NULL)
7885
    abort ();
7886
 
7887
  if (htab->elf.dynamic_sections_created)
7888
    {
7889
      /* Set the contents of the .interp section to the interpreter.  */
7890
      if (info->executable)
7891
        {
7892
          s = bfd_get_section_by_name (dynobj, ".interp");
7893
          if (s == NULL)
7894
            abort ();
7895
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
7896
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
7897
        }
7898
    }
7899
 
7900
  /* Set up .got offsets for local syms, and space for local dynamic
7901
     relocs.  */
7902
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7903
    {
7904
      struct got_entry **lgot_ents;
7905
      struct got_entry **end_lgot_ents;
7906
      char *lgot_masks;
7907
      bfd_size_type locsymcount;
7908
      Elf_Internal_Shdr *symtab_hdr;
7909
      asection *srel;
7910
 
7911
      if (!is_ppc64_elf (ibfd))
7912
        continue;
7913
 
7914
      for (s = ibfd->sections; s != NULL; s = s->next)
7915
        {
7916
          struct ppc_dyn_relocs *p;
7917
 
7918
          for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
7919
            {
7920
              if (!bfd_is_abs_section (p->sec)
7921
                  && bfd_is_abs_section (p->sec->output_section))
7922
                {
7923
                  /* Input section has been discarded, either because
7924
                     it is a copy of a linkonce section or due to
7925
                     linker script /DISCARD/, so we'll be discarding
7926
                     the relocs too.  */
7927
                }
7928
              else if (p->count != 0)
7929
                {
7930
                  srel = elf_section_data (p->sec)->sreloc;
7931
                  srel->size += p->count * sizeof (Elf64_External_Rela);
7932
                  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
7933
                    info->flags |= DF_TEXTREL;
7934
                }
7935
            }
7936
        }
7937
 
7938
      lgot_ents = elf_local_got_ents (ibfd);
7939
      if (!lgot_ents)
7940
        continue;
7941
 
7942
      symtab_hdr = &elf_symtab_hdr (ibfd);
7943
      locsymcount = symtab_hdr->sh_info;
7944
      end_lgot_ents = lgot_ents + locsymcount;
7945
      lgot_masks = (char *) end_lgot_ents;
7946
      s = ppc64_elf_tdata (ibfd)->got;
7947
      srel = ppc64_elf_tdata (ibfd)->relgot;
7948
      for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
7949
        {
7950
          struct got_entry *ent;
7951
 
7952
          for (ent = *lgot_ents; ent != NULL; ent = ent->next)
7953
            if (ent->got.refcount > 0)
7954
              {
7955
                if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
7956
                  {
7957
                    ppc64_tlsld_got (ibfd)->refcount += 1;
7958
                    ent->got.offset = (bfd_vma) -1;
7959
                  }
7960
                else
7961
                  {
7962
                    ent->got.offset = s->size;
7963
                    if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
7964
                      {
7965
                        s->size += 16;
7966
                        if (info->shared)
7967
                          srel->size += 2 * sizeof (Elf64_External_Rela);
7968
                      }
7969
                    else
7970
                      {
7971
                        s->size += 8;
7972
                        if (info->shared)
7973
                          srel->size += sizeof (Elf64_External_Rela);
7974
                      }
7975
                  }
7976
              }
7977
            else
7978
              ent->got.offset = (bfd_vma) -1;
7979
        }
7980
    }
7981
 
7982
  /* Allocate global sym .plt and .got entries, and space for global
7983
     sym dynamic relocs.  */
7984
  elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
7985
 
7986
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7987
    {
7988
      if (!is_ppc64_elf (ibfd))
7989
        continue;
7990
 
7991
      if (ppc64_tlsld_got (ibfd)->refcount > 0)
7992
        {
7993
          s = ppc64_elf_tdata (ibfd)->got;
7994
          ppc64_tlsld_got (ibfd)->offset = s->size;
7995
          s->size += 16;
7996
          if (info->shared)
7997
            {
7998
              asection *srel = ppc64_elf_tdata (ibfd)->relgot;
7999
              srel->size += sizeof (Elf64_External_Rela);
8000
            }
8001
        }
8002
      else
8003
        ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
8004
    }
8005
 
8006
  /* We now have determined the sizes of the various dynamic sections.
8007
     Allocate memory for them.  */
8008
  relocs = FALSE;
8009
  for (s = dynobj->sections; s != NULL; s = s->next)
8010
    {
8011
      if ((s->flags & SEC_LINKER_CREATED) == 0)
8012
        continue;
8013
 
8014
      if (s == htab->brlt || s == htab->relbrlt)
8015
        /* These haven't been allocated yet;  don't strip.  */
8016
        continue;
8017
      else if (s == htab->got
8018
               || s == htab->plt
8019
               || s == htab->glink
8020
               || s == htab->dynbss)
8021
        {
8022
          /* Strip this section if we don't need it; see the
8023
             comment below.  */
8024
        }
8025
      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8026
        {
8027
          if (s->size != 0)
8028
            {
8029
              if (s != htab->relplt)
8030
                relocs = TRUE;
8031
 
8032
              /* We use the reloc_count field as a counter if we need
8033
                 to copy relocs into the output file.  */
8034
              s->reloc_count = 0;
8035
            }
8036
        }
8037
      else
8038
        {
8039
          /* It's not one of our sections, so don't allocate space.  */
8040
          continue;
8041
        }
8042
 
8043
      if (s->size == 0)
8044
        {
8045
          /* If we don't need this section, strip it from the
8046
             output file.  This is mostly to handle .rela.bss and
8047
             .rela.plt.  We must create both sections in
8048
             create_dynamic_sections, because they must be created
8049
             before the linker maps input sections to output
8050
             sections.  The linker does that before
8051
             adjust_dynamic_symbol is called, and it is that
8052
             function which decides whether anything needs to go
8053
             into these sections.  */
8054
          s->flags |= SEC_EXCLUDE;
8055
          continue;
8056
        }
8057
 
8058
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
8059
        continue;
8060
 
8061
      /* Allocate memory for the section contents.  We use bfd_zalloc
8062
         here in case unused entries are not reclaimed before the
8063
         section's contents are written out.  This should not happen,
8064
         but this way if it does we get a R_PPC64_NONE reloc in .rela
8065
         sections instead of garbage.
8066
         We also rely on the section contents being zero when writing
8067
         the GOT.  */
8068
      s->contents = bfd_zalloc (dynobj, s->size);
8069
      if (s->contents == NULL)
8070
        return FALSE;
8071
    }
8072
 
8073
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8074
    {
8075
      if (!is_ppc64_elf (ibfd))
8076
        continue;
8077
 
8078
      s = ppc64_elf_tdata (ibfd)->got;
8079
      if (s != NULL && s != htab->got)
8080
        {
8081
          if (s->size == 0)
8082
            s->flags |= SEC_EXCLUDE;
8083
          else
8084
            {
8085
              s->contents = bfd_zalloc (ibfd, s->size);
8086
              if (s->contents == NULL)
8087
                return FALSE;
8088
            }
8089
        }
8090
      s = ppc64_elf_tdata (ibfd)->relgot;
8091
      if (s != NULL)
8092
        {
8093
          if (s->size == 0)
8094
            s->flags |= SEC_EXCLUDE;
8095
          else
8096
            {
8097
              s->contents = bfd_zalloc (ibfd, s->size);
8098
              if (s->contents == NULL)
8099
                return FALSE;
8100
              relocs = TRUE;
8101
              s->reloc_count = 0;
8102
            }
8103
        }
8104
    }
8105
 
8106
  if (htab->elf.dynamic_sections_created)
8107
    {
8108
      /* Add some entries to the .dynamic section.  We fill in the
8109
         values later, in ppc64_elf_finish_dynamic_sections, but we
8110
         must add the entries now so that we get the correct size for
8111
         the .dynamic section.  The DT_DEBUG entry is filled in by the
8112
         dynamic linker and used by the debugger.  */
8113
#define add_dynamic_entry(TAG, VAL) \
8114
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8115
 
8116
      if (info->executable)
8117
        {
8118
          if (!add_dynamic_entry (DT_DEBUG, 0))
8119
            return FALSE;
8120
        }
8121
 
8122
      if (htab->plt != NULL && htab->plt->size != 0)
8123
        {
8124
          if (!add_dynamic_entry (DT_PLTGOT, 0)
8125
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
8126
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8127
              || !add_dynamic_entry (DT_JMPREL, 0)
8128
              || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8129
            return FALSE;
8130
        }
8131
 
8132
      if (NO_OPD_RELOCS)
8133
        {
8134
          if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8135
              || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8136
            return FALSE;
8137
        }
8138
 
8139
      if (relocs)
8140
        {
8141
          if (!add_dynamic_entry (DT_RELA, 0)
8142
              || !add_dynamic_entry (DT_RELASZ, 0)
8143
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8144
            return FALSE;
8145
 
8146
          /* If any dynamic relocs apply to a read-only section,
8147
             then we need a DT_TEXTREL entry.  */
8148
          if ((info->flags & DF_TEXTREL) == 0)
8149
            elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8150
 
8151
          if ((info->flags & DF_TEXTREL) != 0)
8152
            {
8153
              if (!add_dynamic_entry (DT_TEXTREL, 0))
8154
                return FALSE;
8155
            }
8156
        }
8157
    }
8158
#undef add_dynamic_entry
8159
 
8160
  return TRUE;
8161
}
8162
 
8163
/* Determine the type of stub needed, if any, for a call.  */
8164
 
8165
static inline enum ppc_stub_type
8166
ppc_type_of_stub (asection *input_sec,
8167
                  const Elf_Internal_Rela *rel,
8168
                  struct ppc_link_hash_entry **hash,
8169
                  bfd_vma destination)
8170
{
8171
  struct ppc_link_hash_entry *h = *hash;
8172
  bfd_vma location;
8173
  bfd_vma branch_offset;
8174
  bfd_vma max_branch_offset;
8175
  enum elf_ppc64_reloc_type r_type;
8176
 
8177
  if (h != NULL)
8178
    {
8179
      struct ppc_link_hash_entry *fdh = h;
8180
      if (fdh->oh != NULL
8181
          && fdh->oh->is_func_descriptor)
8182
        fdh = fdh->oh;
8183
 
8184
      if (fdh->elf.dynindx != -1)
8185
        {
8186
          struct plt_entry *ent;
8187
 
8188
          for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8189
            if (ent->addend == rel->r_addend
8190
                && ent->plt.offset != (bfd_vma) -1)
8191
              {
8192
                *hash = fdh;
8193
                return ppc_stub_plt_call;
8194
              }
8195
        }
8196
 
8197
      /* Here, we know we don't have a plt entry.  If we don't have a
8198
         either a defined function descriptor or a defined entry symbol
8199
         in a regular object file, then it is pointless trying to make
8200
         any other type of stub.  */
8201
      if (!((fdh->elf.root.type == bfd_link_hash_defined
8202
            || fdh->elf.root.type == bfd_link_hash_defweak)
8203
            && fdh->elf.root.u.def.section->output_section != NULL)
8204
          && !((h->elf.root.type == bfd_link_hash_defined
8205
                || h->elf.root.type == bfd_link_hash_defweak)
8206
               && h->elf.root.u.def.section->output_section != NULL))
8207
        return ppc_stub_none;
8208
    }
8209
 
8210
  /* Determine where the call point is.  */
8211
  location = (input_sec->output_offset
8212
              + input_sec->output_section->vma
8213
              + rel->r_offset);
8214
 
8215
  branch_offset = destination - location;
8216
  r_type = ELF64_R_TYPE (rel->r_info);
8217
 
8218
  /* Determine if a long branch stub is needed.  */
8219
  max_branch_offset = 1 << 25;
8220
  if (r_type != R_PPC64_REL24)
8221
    max_branch_offset = 1 << 15;
8222
 
8223
  if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8224
    /* We need a stub.  Figure out whether a long_branch or plt_branch
8225
       is needed later.  */
8226
    return ppc_stub_long_branch;
8227
 
8228
  return ppc_stub_none;
8229
}
8230
 
8231
/* Build a .plt call stub.  */
8232
 
8233
static inline bfd_byte *
8234
build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
8235
{
8236
#define PPC_LO(v) ((v) & 0xffff)
8237
#define PPC_HI(v) (((v) >> 16) & 0xffff)
8238
#define PPC_HA(v) PPC_HI ((v) + 0x8000)
8239
 
8240
  if (PPC_HA (offset) != 0)
8241
    {
8242
      if (r != NULL)
8243
        {
8244
          r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8245
          r[1].r_offset = r[0].r_offset + 8;
8246
          r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8247
          r[1].r_addend = r[0].r_addend;
8248
          if (PPC_HA (offset + 16) != PPC_HA (offset))
8249
            {
8250
              r[2].r_offset = r[1].r_offset + 4;
8251
              r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8252
              r[2].r_addend = r[0].r_addend;
8253
            }
8254
          else
8255
            {
8256
              r[2].r_offset = r[1].r_offset + 8;
8257
              r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8258
              r[2].r_addend = r[0].r_addend + 8;
8259
              r[3].r_offset = r[2].r_offset + 4;
8260
              r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8261
              r[3].r_addend = r[0].r_addend + 16;
8262
            }
8263
        }
8264
      bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
8265
      bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
8266
      bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
8267
      if (PPC_HA (offset + 16) != PPC_HA (offset))
8268
        {
8269
          bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
8270
          offset = 0;
8271
        }
8272
      bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
8273
      bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
8274
      bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
8275
      bfd_put_32 (obfd, BCTR, p),                               p += 4;
8276
    }
8277
  else
8278
    {
8279
      if (r != NULL)
8280
        {
8281
          r[0].r_offset += 4;
8282
          r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8283
          if (PPC_HA (offset + 16) != PPC_HA (offset))
8284
            {
8285
              r[1].r_offset = r[0].r_offset + 4;
8286
              r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
8287
              r[1].r_addend = r[0].r_addend;
8288
            }
8289
          else
8290
            {
8291
              r[1].r_offset = r[0].r_offset + 8;
8292
              r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8293
              r[1].r_addend = r[0].r_addend + 16;
8294
              r[2].r_offset = r[1].r_offset + 4;
8295
              r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8296
              r[2].r_addend = r[0].r_addend + 8;
8297
            }
8298
        }
8299
      bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
8300
      bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
8301
      if (PPC_HA (offset + 16) != PPC_HA (offset))
8302
        {
8303
          bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
8304
          offset = 0;
8305
        }
8306
      bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
8307
      bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p),  p += 4;
8308
      bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
8309
      bfd_put_32 (obfd, BCTR, p),                               p += 4;
8310
    }
8311
  return p;
8312
}
8313
 
8314
static Elf_Internal_Rela *
8315
get_relocs (asection *sec, int count)
8316
{
8317
  Elf_Internal_Rela *relocs;
8318
  struct bfd_elf_section_data *elfsec_data;
8319
 
8320
  elfsec_data = elf_section_data (sec);
8321
  relocs = elfsec_data->relocs;
8322
  if (relocs == NULL)
8323
    {
8324
      bfd_size_type relsize;
8325
      relsize = sec->reloc_count * sizeof (*relocs);
8326
      relocs = bfd_alloc (sec->owner, relsize);
8327
      if (relocs == NULL)
8328
        return NULL;
8329
      elfsec_data->relocs = relocs;
8330
      elfsec_data->rel_hdr.sh_size = (sec->reloc_count
8331
                                      * sizeof (Elf64_External_Rela));
8332
      elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
8333
      sec->reloc_count = 0;
8334
    }
8335
  relocs += sec->reloc_count;
8336
  sec->reloc_count += count;
8337
  return relocs;
8338
}
8339
 
8340
static bfd_boolean
8341
ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8342
{
8343
  struct ppc_stub_hash_entry *stub_entry;
8344
  struct ppc_branch_hash_entry *br_entry;
8345
  struct bfd_link_info *info;
8346
  struct ppc_link_hash_table *htab;
8347
  bfd_byte *loc;
8348
  bfd_byte *p;
8349
  struct plt_entry *ent;
8350
  bfd_vma dest, off;
8351
  int size;
8352
  Elf_Internal_Rela *r;
8353
 
8354
  /* Massage our args to the form they really have.  */
8355
  stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8356
  info = in_arg;
8357
 
8358
  htab = ppc_hash_table (info);
8359
 
8360
  /* Make a note of the offset within the stubs for this entry.  */
8361
  stub_entry->stub_offset = stub_entry->stub_sec->size;
8362
  loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
8363
 
8364
  htab->stub_count[stub_entry->stub_type - 1] += 1;
8365
  switch (stub_entry->stub_type)
8366
    {
8367
    case ppc_stub_long_branch:
8368
    case ppc_stub_long_branch_r2off:
8369
      /* Branches are relative.  This is where we are going to.  */
8370
      off = dest = (stub_entry->target_value
8371
                    + stub_entry->target_section->output_offset
8372
                    + stub_entry->target_section->output_section->vma);
8373
 
8374
      /* And this is where we are coming from.  */
8375
      off -= (stub_entry->stub_offset
8376
              + stub_entry->stub_sec->output_offset
8377
              + stub_entry->stub_sec->output_section->vma);
8378
 
8379
      size = 4;
8380
      if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8381
        {
8382
          bfd_vma r2off;
8383
 
8384
          r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8385
                   - htab->stub_group[stub_entry->id_sec->id].toc_off);
8386
          bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8387
          loc += 4;
8388
          size = 12;
8389
          if (PPC_HA (r2off) != 0)
8390
            {
8391
              size = 16;
8392
              bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8393
              loc += 4;
8394
            }
8395
          bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8396
          loc += 4;
8397
          off -= size - 4;
8398
        }
8399
      bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
8400
 
8401
      if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8402
        {
8403
          (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8404
                                 stub_entry->root.string);
8405
          htab->stub_error = TRUE;
8406
          return FALSE;
8407
        }
8408
 
8409
      if (info->emitrelocations)
8410
        {
8411
          r = get_relocs (stub_entry->stub_sec, 1);
8412
          if (r == NULL)
8413
            return FALSE;
8414
          r->r_offset = loc - stub_entry->stub_sec->contents;
8415
          r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8416
          r->r_addend = dest;
8417
          if (stub_entry->h != NULL)
8418
            {
8419
              struct elf_link_hash_entry **hashes;
8420
              unsigned long symndx;
8421
              struct ppc_link_hash_entry *h;
8422
 
8423
              hashes = elf_sym_hashes (htab->stub_bfd);
8424
              if (hashes == NULL)
8425
                {
8426
                  bfd_size_type hsize;
8427
 
8428
                  hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8429
                  hashes = bfd_zalloc (htab->stub_bfd, hsize);
8430
                  if (hashes == NULL)
8431
                    return FALSE;
8432
                  elf_sym_hashes (htab->stub_bfd) = hashes;
8433
                  htab->stub_globals = 1;
8434
                }
8435
              symndx = htab->stub_globals++;
8436
              h = stub_entry->h;
8437
              hashes[symndx] = &h->elf;
8438
              r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8439
              if (h->oh != NULL && h->oh->is_func)
8440
                h = h->oh;
8441
              if (h->elf.root.u.def.section != stub_entry->target_section)
8442
                /* H is an opd symbol.  The addend must be zero.  */
8443
                r->r_addend = 0;
8444
              else
8445
                {
8446
                  off = (h->elf.root.u.def.value
8447
                         + h->elf.root.u.def.section->output_offset
8448
                         + h->elf.root.u.def.section->output_section->vma);
8449
                  r->r_addend -= off;
8450
                }
8451
            }
8452
        }
8453
      break;
8454
 
8455
    case ppc_stub_plt_branch:
8456
    case ppc_stub_plt_branch_r2off:
8457
      br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8458
                                         stub_entry->root.string + 9,
8459
                                         FALSE, FALSE);
8460
      if (br_entry == NULL)
8461
        {
8462
          (*_bfd_error_handler) (_("can't find branch stub `%s'"),
8463
                                 stub_entry->root.string);
8464
          htab->stub_error = TRUE;
8465
          return FALSE;
8466
        }
8467
 
8468
      dest = (stub_entry->target_value
8469
              + stub_entry->target_section->output_offset
8470
              + stub_entry->target_section->output_section->vma);
8471
 
8472
      bfd_put_64 (htab->brlt->owner, dest,
8473
                  htab->brlt->contents + br_entry->offset);
8474
 
8475
      if (br_entry->iter == htab->stub_iteration)
8476
        {
8477
          br_entry->iter = 0;
8478
 
8479
          if (htab->relbrlt != NULL)
8480
            {
8481
              /* Create a reloc for the branch lookup table entry.  */
8482
              Elf_Internal_Rela rela;
8483
              bfd_byte *rl;
8484
 
8485
              rela.r_offset = (br_entry->offset
8486
                               + htab->brlt->output_offset
8487
                               + htab->brlt->output_section->vma);
8488
              rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8489
              rela.r_addend = dest;
8490
 
8491
              rl = htab->relbrlt->contents;
8492
              rl += (htab->relbrlt->reloc_count++
8493
                     * sizeof (Elf64_External_Rela));
8494
              bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
8495
            }
8496
          else if (info->emitrelocations)
8497
            {
8498
              r = get_relocs (htab->brlt, 1);
8499
              if (r == NULL)
8500
                return FALSE;
8501
              /* brlt, being SEC_LINKER_CREATED does not go through the
8502
                 normal reloc processing.  Symbols and offsets are not
8503
                 translated from input file to output file form, so
8504
                 set up the offset per the output file.  */
8505
              r->r_offset = (br_entry->offset
8506
                             + htab->brlt->output_offset
8507
                             + htab->brlt->output_section->vma);
8508
              r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8509
              r->r_addend = dest;
8510
            }
8511
        }
8512
 
8513
      dest = (br_entry->offset
8514
              + htab->brlt->output_offset
8515
              + htab->brlt->output_section->vma);
8516
 
8517
      off = (dest
8518
             - elf_gp (htab->brlt->output_section->owner)
8519
             - htab->stub_group[stub_entry->id_sec->id].toc_off);
8520
 
8521
      if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8522
        {
8523
          (*_bfd_error_handler)
8524
            (_("linkage table error against `%s'"),
8525
             stub_entry->root.string);
8526
          bfd_set_error (bfd_error_bad_value);
8527
          htab->stub_error = TRUE;
8528
          return FALSE;
8529
        }
8530
 
8531
      if (info->emitrelocations)
8532
        {
8533
          r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
8534
          if (r == NULL)
8535
            return FALSE;
8536
          r[0].r_offset = loc - stub_entry->stub_sec->contents;
8537
          if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
8538
            r[0].r_offset += 4;
8539
          r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8540
          r[0].r_addend = dest;
8541
          if (PPC_HA (off) != 0)
8542
            {
8543
              r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8544
              r[1].r_offset = r[0].r_offset + 4;
8545
              r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8546
              r[1].r_addend = r[0].r_addend;
8547
            }
8548
        }
8549
 
8550
      if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8551
        {
8552
          if (PPC_HA (off) != 0)
8553
            {
8554
              size = 16;
8555
              bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8556
              loc += 4;
8557
              bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8558
            }
8559
          else
8560
            {
8561
              size = 12;
8562
              bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8563
            }
8564
        }
8565
      else
8566
        {
8567
          bfd_vma r2off;
8568
 
8569
          r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8570
                   - htab->stub_group[stub_entry->id_sec->id].toc_off);
8571
          bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8572
          loc += 4;
8573
          size = 20;
8574
          if (PPC_HA (off) != 0)
8575
            {
8576
              size += 4;
8577
              bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8578
              loc += 4;
8579
              bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8580
              loc += 4;
8581
            }
8582
          else
8583
            {
8584
              bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8585
              loc += 4;
8586
            }
8587
 
8588
          if (PPC_HA (r2off) != 0)
8589
            {
8590
              size += 4;
8591
              bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8592
              loc += 4;
8593
            }
8594
          bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8595
        }
8596
      loc += 4;
8597
      bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
8598
      loc += 4;
8599
      bfd_put_32 (htab->stub_bfd, BCTR, loc);
8600
      break;
8601
 
8602
    case ppc_stub_plt_call:
8603
      /* Do the best we can for shared libraries built without
8604
         exporting ".foo" for each "foo".  This can happen when symbol
8605
         versioning scripts strip all bar a subset of symbols.  */
8606
      if (stub_entry->h->oh != NULL
8607
          && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
8608
          && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
8609
        {
8610
          /* Point the symbol at the stub.  There may be multiple stubs,
8611
             we don't really care;  The main thing is to make this sym
8612
             defined somewhere.  Maybe defining the symbol in the stub
8613
             section is a silly idea.  If we didn't do this, htab->top_id
8614
             could disappear.  */
8615
          stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
8616
          stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
8617
          stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
8618
        }
8619
 
8620
      /* Now build the stub.  */
8621
      dest = (bfd_vma) -1;
8622
      for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8623
        if (ent->addend == stub_entry->addend)
8624
          {
8625
            dest = ent->plt.offset;
8626
            break;
8627
          }
8628
      if (dest >= (bfd_vma) -2)
8629
        abort ();
8630
 
8631
      dest &= ~ (bfd_vma) 1;
8632
      dest += (htab->plt->output_offset
8633
               + htab->plt->output_section->vma);
8634
 
8635
      off = (dest
8636
             - elf_gp (htab->plt->output_section->owner)
8637
             - htab->stub_group[stub_entry->id_sec->id].toc_off);
8638
 
8639
      if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8640
        {
8641
          (*_bfd_error_handler)
8642
            (_("linkage table error against `%s'"),
8643
             stub_entry->h->elf.root.root.string);
8644
          bfd_set_error (bfd_error_bad_value);
8645
          htab->stub_error = TRUE;
8646
          return FALSE;
8647
        }
8648
 
8649
      r = NULL;
8650
      if (info->emitrelocations)
8651
        {
8652
          r = get_relocs (stub_entry->stub_sec,
8653
                          (2 + (PPC_HA (off) != 0)
8654
                           + (PPC_HA (off + 16) == PPC_HA (off))));
8655
          if (r == NULL)
8656
            return FALSE;
8657
          r[0].r_offset = loc - stub_entry->stub_sec->contents;
8658
          r[0].r_addend = dest;
8659
        }
8660
      p = build_plt_stub (htab->stub_bfd, loc, off, r);
8661
      size = p - loc;
8662
      break;
8663
 
8664
    default:
8665
      BFD_FAIL ();
8666
      return FALSE;
8667
    }
8668
 
8669
  stub_entry->stub_sec->size += size;
8670
 
8671
  if (htab->emit_stub_syms)
8672
    {
8673
      struct elf_link_hash_entry *h;
8674
      size_t len1, len2;
8675
      char *name;
8676
      const char *const stub_str[] = { "long_branch",
8677
                                       "long_branch_r2off",
8678
                                       "plt_branch",
8679
                                       "plt_branch_r2off",
8680
                                       "plt_call" };
8681
 
8682
      len1 = strlen (stub_str[stub_entry->stub_type - 1]);
8683
      len2 = strlen (stub_entry->root.string);
8684
      name = bfd_malloc (len1 + len2 + 2);
8685
      if (name == NULL)
8686
        return FALSE;
8687
      memcpy (name, stub_entry->root.string, 9);
8688
      memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
8689
      memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
8690
      h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
8691
      if (h == NULL)
8692
        return FALSE;
8693
      if (h->root.type == bfd_link_hash_new)
8694
        {
8695
          h->root.type = bfd_link_hash_defined;
8696
          h->root.u.def.section = stub_entry->stub_sec;
8697
          h->root.u.def.value = stub_entry->stub_offset;
8698
          h->ref_regular = 1;
8699
          h->def_regular = 1;
8700
          h->ref_regular_nonweak = 1;
8701
          h->forced_local = 1;
8702
          h->non_elf = 0;
8703
        }
8704
    }
8705
 
8706
  return TRUE;
8707
}
8708
 
8709
/* As above, but don't actually build the stub.  Just bump offset so
8710
   we know stub section sizes, and select plt_branch stubs where
8711
   long_branch stubs won't do.  */
8712
 
8713
static bfd_boolean
8714
ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8715
{
8716
  struct ppc_stub_hash_entry *stub_entry;
8717
  struct bfd_link_info *info;
8718
  struct ppc_link_hash_table *htab;
8719
  bfd_vma off;
8720
  int size;
8721
 
8722
  /* Massage our args to the form they really have.  */
8723
  stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8724
  info = in_arg;
8725
 
8726
  htab = ppc_hash_table (info);
8727
 
8728
  if (stub_entry->stub_type == ppc_stub_plt_call)
8729
    {
8730
      struct plt_entry *ent;
8731
      off = (bfd_vma) -1;
8732
      for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8733
        if (ent->addend == stub_entry->addend)
8734
          {
8735
            off = ent->plt.offset & ~(bfd_vma) 1;
8736
            break;
8737
          }
8738
      if (off >= (bfd_vma) -2)
8739
        abort ();
8740
      off += (htab->plt->output_offset
8741
              + htab->plt->output_section->vma
8742
              - elf_gp (htab->plt->output_section->owner)
8743
              - htab->stub_group[stub_entry->id_sec->id].toc_off);
8744
 
8745
      size = PLT_CALL_STUB_SIZE;
8746
      if (PPC_HA (off) == 0)
8747
        size -= 4;
8748
      if (PPC_HA (off + 16) != PPC_HA (off))
8749
        size += 4;
8750
      if (info->emitrelocations)
8751
        {
8752
          stub_entry->stub_sec->reloc_count
8753
            += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
8754
          stub_entry->stub_sec->flags |= SEC_RELOC;
8755
        }
8756
    }
8757
  else
8758
    {
8759
      /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
8760
         variants.  */
8761
      bfd_vma r2off = 0;
8762
 
8763
      off = (stub_entry->target_value
8764
             + stub_entry->target_section->output_offset
8765
             + stub_entry->target_section->output_section->vma);
8766
      off -= (stub_entry->stub_sec->size
8767
              + stub_entry->stub_sec->output_offset
8768
              + stub_entry->stub_sec->output_section->vma);
8769
 
8770
      /* Reset the stub type from the plt variant in case we now
8771
         can reach with a shorter stub.  */
8772
      if (stub_entry->stub_type >= ppc_stub_plt_branch)
8773
        stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
8774
 
8775
      size = 4;
8776
      if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8777
        {
8778
          r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8779
                   - htab->stub_group[stub_entry->id_sec->id].toc_off);
8780
          size = 12;
8781
          if (PPC_HA (r2off) != 0)
8782
            size = 16;
8783
          off -= size - 4;
8784
        }
8785
 
8786
      /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
8787
      if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8788
        {
8789
          struct ppc_branch_hash_entry *br_entry;
8790
 
8791
          br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8792
                                             stub_entry->root.string + 9,
8793
                                             TRUE, FALSE);
8794
          if (br_entry == NULL)
8795
            {
8796
              (*_bfd_error_handler) (_("can't build branch stub `%s'"),
8797
                                     stub_entry->root.string);
8798
              htab->stub_error = TRUE;
8799
              return FALSE;
8800
            }
8801
 
8802
          if (br_entry->iter != htab->stub_iteration)
8803
            {
8804
              br_entry->iter = htab->stub_iteration;
8805
              br_entry->offset = htab->brlt->size;
8806
              htab->brlt->size += 8;
8807
 
8808
              if (htab->relbrlt != NULL)
8809
                htab->relbrlt->size += sizeof (Elf64_External_Rela);
8810
              else if (info->emitrelocations)
8811
                {
8812
                  htab->brlt->reloc_count += 1;
8813
                  htab->brlt->flags |= SEC_RELOC;
8814
                }
8815
            }
8816
 
8817
          stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
8818
          off = (br_entry->offset
8819
                 + htab->brlt->output_offset
8820
                 + htab->brlt->output_section->vma
8821
                 - elf_gp (htab->brlt->output_section->owner)
8822
                 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8823
 
8824
          if (info->emitrelocations)
8825
            {
8826
              stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
8827
              stub_entry->stub_sec->flags |= SEC_RELOC;
8828
            }
8829
 
8830
          if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8831
            {
8832
              size = 12;
8833
              if (PPC_HA (off) != 0)
8834
                size = 16;
8835
            }
8836
          else
8837
            {
8838
              size = 20;
8839
              if (PPC_HA (off) != 0)
8840
                size += 4;
8841
 
8842
              if (PPC_HA (r2off) != 0)
8843
                size += 4;
8844
            }
8845
        }
8846
      else if (info->emitrelocations)
8847
        {
8848
          stub_entry->stub_sec->reloc_count += 1;
8849
          stub_entry->stub_sec->flags |= SEC_RELOC;
8850
        }
8851
    }
8852
 
8853
  stub_entry->stub_sec->size += size;
8854
  return TRUE;
8855
}
8856
 
8857
/* Set up various things so that we can make a list of input sections
8858
   for each output section included in the link.  Returns -1 on error,
8859
 
8860
 
8861
int
8862
ppc64_elf_setup_section_lists (bfd *output_bfd,
8863
                               struct bfd_link_info *info,
8864
                               int no_multi_toc)
8865
{
8866
  bfd *input_bfd;
8867
  int top_id, top_index, id;
8868
  asection *section;
8869
  asection **input_list;
8870
  bfd_size_type amt;
8871
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
8872
 
8873
  htab->no_multi_toc = no_multi_toc;
8874
 
8875
  if (htab->brlt == NULL)
8876
    return 0;
8877
 
8878
  /* Find the top input section id.  */
8879
  for (input_bfd = info->input_bfds, top_id = 3;
8880
       input_bfd != NULL;
8881
       input_bfd = input_bfd->link_next)
8882
    {
8883
      for (section = input_bfd->sections;
8884
           section != NULL;
8885
           section = section->next)
8886
        {
8887
          if (top_id < section->id)
8888
            top_id = section->id;
8889
        }
8890
    }
8891
 
8892
  htab->top_id = top_id;
8893
  amt = sizeof (struct map_stub) * (top_id + 1);
8894
  htab->stub_group = bfd_zmalloc (amt);
8895
  if (htab->stub_group == NULL)
8896
    return -1;
8897
 
8898
  /* Set toc_off for com, und, abs and ind sections.  */
8899
  for (id = 0; id < 3; id++)
8900
    htab->stub_group[id].toc_off = TOC_BASE_OFF;
8901
 
8902
  elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
8903
 
8904
  /* We can't use output_bfd->section_count here to find the top output
8905
     section index as some sections may have been removed, and
8906
     strip_excluded_output_sections doesn't renumber the indices.  */
8907
  for (section = output_bfd->sections, top_index = 0;
8908
       section != NULL;
8909
       section = section->next)
8910
    {
8911
      if (top_index < section->index)
8912
        top_index = section->index;
8913
    }
8914
 
8915
  htab->top_index = top_index;
8916
  amt = sizeof (asection *) * (top_index + 1);
8917
  input_list = bfd_zmalloc (amt);
8918
  htab->input_list = input_list;
8919
  if (input_list == NULL)
8920
    return -1;
8921
 
8922
  return 1;
8923
}
8924
 
8925
/* The linker repeatedly calls this function for each TOC input section
8926
   and linker generated GOT section.  Group input bfds such that the toc
8927
   within a group is less than 64k in size.  Will break with cute linker
8928
   scripts that play games with dot in the output toc section.  */
8929
 
8930
void
8931
ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
8932
{
8933
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
8934
 
8935
  if (!htab->no_multi_toc)
8936
    {
8937
      bfd_vma addr = isec->output_offset + isec->output_section->vma;
8938
      bfd_vma off = addr - htab->toc_curr;
8939
 
8940
      if (off + isec->size > 0x10000)
8941
        htab->toc_curr = addr;
8942
 
8943
      elf_gp (isec->owner) = (htab->toc_curr
8944
                              - elf_gp (isec->output_section->owner)
8945
                              + TOC_BASE_OFF);
8946
    }
8947
}
8948
 
8949
/* Called after the last call to the above function.  */
8950
 
8951
void
8952
ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
8953
{
8954
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
8955
 
8956
  htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
8957
 
8958
  /* toc_curr tracks the TOC offset used for code sections below in
8959
     ppc64_elf_next_input_section.  Start off at 0x8000.  */
8960
  htab->toc_curr = TOC_BASE_OFF;
8961
}
8962
 
8963
/* No toc references were found in ISEC.  If the code in ISEC makes no
8964
   calls, then there's no need to use toc adjusting stubs when branching
8965
   into ISEC.  Actually, indirect calls from ISEC are OK as they will
8966
   load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
8967
   needed, and 2 if a cyclical call-graph was found but no other reason
8968
   for a stub was detected.  If called from the top level, a return of
8969
   2 means the same as a return of 0.  */
8970
 
8971
static int
8972
toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
8973
{
8974
  Elf_Internal_Rela *relstart, *rel;
8975
  Elf_Internal_Sym *local_syms;
8976
  int ret;
8977
  struct ppc_link_hash_table *htab;
8978
 
8979
  /* We know none of our code bearing sections will need toc stubs.  */
8980
  if ((isec->flags & SEC_LINKER_CREATED) != 0)
8981
    return 0;
8982
 
8983
  if (isec->size == 0)
8984
    return 0;
8985
 
8986
  if (isec->output_section == NULL)
8987
    return 0;
8988
 
8989
  if (isec->reloc_count == 0)
8990
    return 0;
8991
 
8992
  relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
8993
                                        info->keep_memory);
8994
  if (relstart == NULL)
8995
    return -1;
8996
 
8997
  /* Look for branches to outside of this section.  */
8998
  local_syms = NULL;
8999
  ret = 0;
9000
  htab = ppc_hash_table (info);
9001
  for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
9002
    {
9003
      enum elf_ppc64_reloc_type r_type;
9004
      unsigned long r_symndx;
9005
      struct elf_link_hash_entry *h;
9006
      Elf_Internal_Sym *sym;
9007
      asection *sym_sec;
9008
      struct _opd_sec_data *opd;
9009
      bfd_vma sym_value;
9010
      bfd_vma dest;
9011
 
9012
      r_type = ELF64_R_TYPE (rel->r_info);
9013
      if (r_type != R_PPC64_REL24
9014
          && r_type != R_PPC64_REL14
9015
          && r_type != R_PPC64_REL14_BRTAKEN
9016
          && r_type != R_PPC64_REL14_BRNTAKEN)
9017
        continue;
9018
 
9019
      r_symndx = ELF64_R_SYM (rel->r_info);
9020
      if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
9021
                      isec->owner))
9022
        {
9023
          ret = -1;
9024
          break;
9025
        }
9026
 
9027
      /* Calls to dynamic lib functions go through a plt call stub
9028
         that uses r2.  Branches to undefined symbols might be a call
9029
         using old-style dot symbols that can be satisfied by a plt
9030
         call into a new-style dynamic library.  */
9031
      if (sym_sec == NULL)
9032
        {
9033
          struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9034
          if (eh != NULL
9035
              && eh->oh != NULL
9036
              && eh->oh->elf.plt.plist != NULL)
9037
            {
9038
              ret = 1;
9039
              break;
9040
            }
9041
 
9042
          /* Ignore other undefined symbols.  */
9043
          continue;
9044
        }
9045
 
9046
      /* Assume branches to other sections not included in the link need
9047
         stubs too, to cover -R and absolute syms.  */
9048
      if (sym_sec->output_section == NULL)
9049
        {
9050
          ret = 1;
9051
          break;
9052
        }
9053
 
9054
      if (h == NULL)
9055
        sym_value = sym->st_value;
9056
      else
9057
        {
9058
          if (h->root.type != bfd_link_hash_defined
9059
              && h->root.type != bfd_link_hash_defweak)
9060
            abort ();
9061
          sym_value = h->root.u.def.value;
9062
        }
9063
      sym_value += rel->r_addend;
9064
 
9065
      /* If this branch reloc uses an opd sym, find the code section.  */
9066
      opd = get_opd_info (sym_sec);
9067
      if (opd != NULL)
9068
        {
9069
          if (h == NULL && opd->adjust != NULL)
9070
            {
9071
              long adjust;
9072
 
9073
              adjust = opd->adjust[sym->st_value / 8];
9074
              if (adjust == -1)
9075
                /* Assume deleted functions won't ever be called.  */
9076
                continue;
9077
              sym_value += adjust;
9078
            }
9079
 
9080
          dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
9081
          if (dest == (bfd_vma) -1)
9082
            continue;
9083
        }
9084
      else
9085
        dest = (sym_value
9086
                + sym_sec->output_offset
9087
                + sym_sec->output_section->vma);
9088
 
9089
      /* Ignore branch to self.  */
9090
      if (sym_sec == isec)
9091
        continue;
9092
 
9093
      /* If the called function uses the toc, we need a stub.  */
9094
      if (sym_sec->has_toc_reloc
9095
          || sym_sec->makes_toc_func_call)
9096
        {
9097
          ret = 1;
9098
          break;
9099
        }
9100
 
9101
      /* Assume any branch that needs a long branch stub might in fact
9102
         need a plt_branch stub.  A plt_branch stub uses r2.  */
9103
      else if (dest - (isec->output_offset
9104
                       + isec->output_section->vma
9105
                       + rel->r_offset) + (1 << 25) >= (2 << 25))
9106
        {
9107
          ret = 1;
9108
          break;
9109
        }
9110
 
9111
      /* If calling back to a section in the process of being tested, we
9112
         can't say for sure that no toc adjusting stubs are needed, so
9113
         don't return zero.  */
9114
      else if (sym_sec->call_check_in_progress)
9115
        ret = 2;
9116
 
9117
      /* Branches to another section that itself doesn't have any TOC
9118
         references are OK.  Recursively call ourselves to check.  */
9119
      else if (sym_sec->id <= htab->top_id
9120
               && htab->stub_group[sym_sec->id].toc_off == 0)
9121
        {
9122
          int recur;
9123
 
9124
          /* Mark current section as indeterminate, so that other
9125
             sections that call back to current won't be marked as
9126
             known.  */
9127
          isec->call_check_in_progress = 1;
9128
          recur = toc_adjusting_stub_needed (info, sym_sec);
9129
          isec->call_check_in_progress = 0;
9130
 
9131
          if (recur < 0)
9132
            {
9133
              /* An error.  Exit.  */
9134
              ret = -1;
9135
              break;
9136
            }
9137
          else if (recur <= 1)
9138
            {
9139
              /* Known result.  Mark as checked and set section flag.  */
9140
              htab->stub_group[sym_sec->id].toc_off = 1;
9141
              if (recur != 0)
9142
                {
9143
                  sym_sec->makes_toc_func_call = 1;
9144
                  ret = 1;
9145
                  break;
9146
                }
9147
            }
9148
          else
9149
            {
9150
              /* Unknown result.  Continue checking.  */
9151
              ret = 2;
9152
            }
9153
        }
9154
    }
9155
 
9156
  if (local_syms != NULL
9157
      && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
9158
    free (local_syms);
9159
  if (elf_section_data (isec)->relocs != relstart)
9160
    free (relstart);
9161
 
9162
  return ret;
9163
}
9164
 
9165
/* The linker repeatedly calls this function for each input section,
9166
   in the order that input sections are linked into output sections.
9167
   Build lists of input sections to determine groupings between which
9168
   we may insert linker stubs.  */
9169
 
9170
bfd_boolean
9171
ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
9172
{
9173
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
9174
 
9175
  if ((isec->output_section->flags & SEC_CODE) != 0
9176
      && isec->output_section->index <= htab->top_index)
9177
    {
9178
      asection **list = htab->input_list + isec->output_section->index;
9179
      /* Steal the link_sec pointer for our list.  */
9180
#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
9181
      /* This happens to make the list in reverse order,
9182
         which is what we want.  */
9183
      PREV_SEC (isec) = *list;
9184
      *list = isec;
9185
    }
9186
 
9187
  if (htab->multi_toc_needed)
9188
    {
9189
      /* If a code section has a function that uses the TOC then we need
9190
         to use the right TOC (obviously).  Also, make sure that .opd gets
9191
         the correct TOC value for R_PPC64_TOC relocs that don't have or
9192
         can't find their function symbol (shouldn't ever happen now).
9193
         Also specially treat .fixup for the linux kernel.  .fixup
9194
         contains branches, but only back to the function that hit an
9195
         exception.  */
9196
      if (isec->has_toc_reloc
9197
          || (isec->flags & SEC_CODE) == 0
9198
          || strcmp (isec->name, ".fixup") == 0)
9199
        {
9200
          if (elf_gp (isec->owner) != 0)
9201
            htab->toc_curr = elf_gp (isec->owner);
9202
        }
9203
      else if (htab->stub_group[isec->id].toc_off == 0)
9204
        {
9205
          int ret = toc_adjusting_stub_needed (info, isec);
9206
          if (ret < 0)
9207
            return FALSE;
9208
          else
9209
            isec->makes_toc_func_call = ret & 1;
9210
        }
9211
    }
9212
 
9213
  /* Functions that don't use the TOC can belong in any TOC group.
9214
     Use the last TOC base.  This happens to make _init and _fini
9215
     pasting work.  */
9216
  htab->stub_group[isec->id].toc_off = htab->toc_curr;
9217
  return TRUE;
9218
}
9219
 
9220
/* See whether we can group stub sections together.  Grouping stub
9221
   sections may result in fewer stubs.  More importantly, we need to
9222
   put all .init* and .fini* stubs at the beginning of the .init or
9223
   .fini output sections respectively, because glibc splits the
9224
   _init and _fini functions into multiple parts.  Putting a stub in
9225
   the middle of a function is not a good idea.  */
9226
 
9227
static void
9228
group_sections (struct ppc_link_hash_table *htab,
9229
                bfd_size_type stub_group_size,
9230
                bfd_boolean stubs_always_before_branch)
9231
{
9232
  asection **list;
9233
  bfd_size_type stub14_group_size;
9234
  bfd_boolean suppress_size_errors;
9235
 
9236
  suppress_size_errors = FALSE;
9237
  stub14_group_size = stub_group_size;
9238
  if (stub_group_size == 1)
9239
    {
9240
      /* Default values.  */
9241
      if (stubs_always_before_branch)
9242
        {
9243
          stub_group_size = 0x1e00000;
9244
          stub14_group_size = 0x7800;
9245
        }
9246
      else
9247
        {
9248
          stub_group_size = 0x1c00000;
9249
          stub14_group_size = 0x7000;
9250
        }
9251
      suppress_size_errors = TRUE;
9252
    }
9253
 
9254
  list = htab->input_list + htab->top_index;
9255
  do
9256
    {
9257
      asection *tail = *list;
9258
      while (tail != NULL)
9259
        {
9260
          asection *curr;
9261
          asection *prev;
9262
          bfd_size_type total;
9263
          bfd_boolean big_sec;
9264
          bfd_vma curr_toc;
9265
 
9266
          curr = tail;
9267
          total = tail->size;
9268
          big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
9269
                             ? stub14_group_size : stub_group_size);
9270
          if (big_sec && !suppress_size_errors)
9271
            (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
9272
                                     tail->owner, tail);
9273
          curr_toc = htab->stub_group[tail->id].toc_off;
9274
 
9275
          while ((prev = PREV_SEC (curr)) != NULL
9276
                 && ((total += curr->output_offset - prev->output_offset)
9277
                     < (ppc64_elf_section_data (prev)->has_14bit_branch
9278
                        ? stub14_group_size : stub_group_size))
9279
                 && htab->stub_group[prev->id].toc_off == curr_toc)
9280
            curr = prev;
9281
 
9282
          /* OK, the size from the start of CURR to the end is less
9283
             than stub_group_size and thus can be handled by one stub
9284
             section.  (or the tail section is itself larger than
9285
             stub_group_size, in which case we may be toast.)  We
9286
             should really be keeping track of the total size of stubs
9287
             added here, as stubs contribute to the final output
9288
             section size.  That's a little tricky, and this way will
9289
             only break if stubs added make the total size more than
9290
             2^25, ie. for the default stub_group_size, if stubs total
9291
             more than 2097152 bytes, or nearly 75000 plt call stubs.  */
9292
          do
9293
            {
9294
              prev = PREV_SEC (tail);
9295
              /* Set up this stub group.  */
9296
              htab->stub_group[tail->id].link_sec = curr;
9297
            }
9298
          while (tail != curr && (tail = prev) != NULL);
9299
 
9300
          /* But wait, there's more!  Input sections up to stub_group_size
9301
             bytes before the stub section can be handled by it too.
9302
             Don't do this if we have a really large section after the
9303
             stubs, as adding more stubs increases the chance that
9304
             branches may not reach into the stub section.  */
9305
          if (!stubs_always_before_branch && !big_sec)
9306
            {
9307
              total = 0;
9308
              while (prev != NULL
9309
                     && ((total += tail->output_offset - prev->output_offset)
9310
                         < (ppc64_elf_section_data (prev)->has_14bit_branch
9311
                            ? stub14_group_size : stub_group_size))
9312
                     && htab->stub_group[prev->id].toc_off == curr_toc)
9313
                {
9314
                  tail = prev;
9315
                  prev = PREV_SEC (tail);
9316
                  htab->stub_group[tail->id].link_sec = curr;
9317
                }
9318
            }
9319
          tail = prev;
9320
        }
9321
    }
9322
  while (list-- != htab->input_list);
9323
  free (htab->input_list);
9324
#undef PREV_SEC
9325
}
9326
 
9327
/* Determine and set the size of the stub section for a final link.
9328
 
9329
   The basic idea here is to examine all the relocations looking for
9330
   PC-relative calls to a target that is unreachable with a "bl"
9331
   instruction.  */
9332
 
9333
bfd_boolean
9334
ppc64_elf_size_stubs (bfd *output_bfd,
9335
                      struct bfd_link_info *info,
9336
                      bfd_signed_vma group_size,
9337
                      asection *(*add_stub_section) (const char *, asection *),
9338
                      void (*layout_sections_again) (void))
9339
{
9340
  bfd_size_type stub_group_size;
9341
  bfd_boolean stubs_always_before_branch;
9342
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
9343
 
9344
  /* Stash our params away.  */
9345
  htab->add_stub_section = add_stub_section;
9346
  htab->layout_sections_again = layout_sections_again;
9347
  stubs_always_before_branch = group_size < 0;
9348
  if (group_size < 0)
9349
    stub_group_size = -group_size;
9350
  else
9351
    stub_group_size = group_size;
9352
 
9353
  group_sections (htab, stub_group_size, stubs_always_before_branch);
9354
 
9355
  while (1)
9356
    {
9357
      bfd *input_bfd;
9358
      unsigned int bfd_indx;
9359
      asection *stub_sec;
9360
 
9361
      htab->stub_iteration += 1;
9362
 
9363
      for (input_bfd = info->input_bfds, bfd_indx = 0;
9364
           input_bfd != NULL;
9365
           input_bfd = input_bfd->link_next, bfd_indx++)
9366
        {
9367
          Elf_Internal_Shdr *symtab_hdr;
9368
          asection *section;
9369
          Elf_Internal_Sym *local_syms = NULL;
9370
 
9371
          if (!is_ppc64_elf (input_bfd))
9372
            continue;
9373
 
9374
          /* We'll need the symbol table in a second.  */
9375
          symtab_hdr = &elf_symtab_hdr (input_bfd);
9376
          if (symtab_hdr->sh_info == 0)
9377
            continue;
9378
 
9379
          /* Walk over each section attached to the input bfd.  */
9380
          for (section = input_bfd->sections;
9381
               section != NULL;
9382
               section = section->next)
9383
            {
9384
              Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
9385
 
9386
              /* If there aren't any relocs, then there's nothing more
9387
                 to do.  */
9388
              if ((section->flags & SEC_RELOC) == 0
9389
                  || (section->flags & SEC_ALLOC) == 0
9390
                  || (section->flags & SEC_LOAD) == 0
9391
                  || (section->flags & SEC_CODE) == 0
9392
                  || section->reloc_count == 0)
9393
                continue;
9394
 
9395
              /* If this section is a link-once section that will be
9396
                 discarded, then don't create any stubs.  */
9397
              if (section->output_section == NULL
9398
                  || section->output_section->owner != output_bfd)
9399
                continue;
9400
 
9401
              /* Get the relocs.  */
9402
              internal_relocs
9403
                = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
9404
                                             info->keep_memory);
9405
              if (internal_relocs == NULL)
9406
                goto error_ret_free_local;
9407
 
9408
              /* Now examine each relocation.  */
9409
              irela = internal_relocs;
9410
              irelaend = irela + section->reloc_count;
9411
              for (; irela < irelaend; irela++)
9412
                {
9413
                  enum elf_ppc64_reloc_type r_type;
9414
                  unsigned int r_indx;
9415
                  enum ppc_stub_type stub_type;
9416
                  struct ppc_stub_hash_entry *stub_entry;
9417
                  asection *sym_sec, *code_sec;
9418
                  bfd_vma sym_value;
9419
                  bfd_vma destination;
9420
                  bfd_boolean ok_dest;
9421
                  struct ppc_link_hash_entry *hash;
9422
                  struct ppc_link_hash_entry *fdh;
9423
                  struct elf_link_hash_entry *h;
9424
                  Elf_Internal_Sym *sym;
9425
                  char *stub_name;
9426
                  const asection *id_sec;
9427
                  struct _opd_sec_data *opd;
9428
 
9429
                  r_type = ELF64_R_TYPE (irela->r_info);
9430
                  r_indx = ELF64_R_SYM (irela->r_info);
9431
 
9432
                  if (r_type >= R_PPC64_max)
9433
                    {
9434
                      bfd_set_error (bfd_error_bad_value);
9435
                      goto error_ret_free_internal;
9436
                    }
9437
 
9438
                  /* Only look for stubs on branch instructions.  */
9439
                  if (r_type != R_PPC64_REL24
9440
                      && r_type != R_PPC64_REL14
9441
                      && r_type != R_PPC64_REL14_BRTAKEN
9442
                      && r_type != R_PPC64_REL14_BRNTAKEN)
9443
                    continue;
9444
 
9445
                  /* Now determine the call target, its name, value,
9446
                     section.  */
9447
                  if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9448
                                  r_indx, input_bfd))
9449
                    goto error_ret_free_internal;
9450
                  hash = (struct ppc_link_hash_entry *) h;
9451
 
9452
                  ok_dest = FALSE;
9453
                  fdh = NULL;
9454
                  sym_value = 0;
9455
                  if (hash == NULL)
9456
                    {
9457
                      sym_value = sym->st_value;
9458
                      ok_dest = TRUE;
9459
                    }
9460
                  else if (hash->elf.root.type == bfd_link_hash_defined
9461
                           || hash->elf.root.type == bfd_link_hash_defweak)
9462
                    {
9463
                      sym_value = hash->elf.root.u.def.value;
9464
                      if (sym_sec->output_section != NULL)
9465
                        ok_dest = TRUE;
9466
                    }
9467
                  else if (hash->elf.root.type == bfd_link_hash_undefweak
9468
                           || hash->elf.root.type == bfd_link_hash_undefined)
9469
                    {
9470
                      /* Recognise an old ABI func code entry sym, and
9471
                         use the func descriptor sym instead if it is
9472
                         defined.  */
9473
                      if (hash->elf.root.root.string[0] == '.'
9474
                          && (fdh = get_fdh (hash, htab)) != NULL)
9475
                        {
9476
                          if (fdh->elf.root.type == bfd_link_hash_defined
9477
                              || fdh->elf.root.type == bfd_link_hash_defweak)
9478
                            {
9479
                              sym_sec = fdh->elf.root.u.def.section;
9480
                              sym_value = fdh->elf.root.u.def.value;
9481
                              if (sym_sec->output_section != NULL)
9482
                                ok_dest = TRUE;
9483
                            }
9484
                          else
9485
                            fdh = NULL;
9486
                        }
9487
                    }
9488
                  else
9489
                    {
9490
                      bfd_set_error (bfd_error_bad_value);
9491
                      goto error_ret_free_internal;
9492
                    }
9493
 
9494
                  destination = 0;
9495
                  if (ok_dest)
9496
                    {
9497
                      sym_value += irela->r_addend;
9498
                      destination = (sym_value
9499
                                     + sym_sec->output_offset
9500
                                     + sym_sec->output_section->vma);
9501
                    }
9502
 
9503
                  code_sec = sym_sec;
9504
                  opd = get_opd_info (sym_sec);
9505
                  if (opd != NULL)
9506
                    {
9507
                      bfd_vma dest;
9508
 
9509
                      if (hash == NULL && opd->adjust != NULL)
9510
                        {
9511
                          long adjust = opd->adjust[sym_value / 8];
9512
                          if (adjust == -1)
9513
                            continue;
9514
                          sym_value += adjust;
9515
                        }
9516
                      dest = opd_entry_value (sym_sec, sym_value,
9517
                                              &code_sec, &sym_value);
9518
                      if (dest != (bfd_vma) -1)
9519
                        {
9520
                          destination = dest;
9521
                          if (fdh != NULL)
9522
                            {
9523
                              /* Fixup old ABI sym to point at code
9524
                                 entry.  */
9525
                              hash->elf.root.type = bfd_link_hash_defweak;
9526
                              hash->elf.root.u.def.section = code_sec;
9527
                              hash->elf.root.u.def.value = sym_value;
9528
                            }
9529
                        }
9530
                    }
9531
 
9532
                  /* Determine what (if any) linker stub is needed.  */
9533
                  stub_type = ppc_type_of_stub (section, irela, &hash,
9534
                                                destination);
9535
 
9536
                  if (stub_type != ppc_stub_plt_call)
9537
                    {
9538
                      /* Check whether we need a TOC adjusting stub.
9539
                         Since the linker pastes together pieces from
9540
                         different object files when creating the
9541
                         _init and _fini functions, it may be that a
9542
                         call to what looks like a local sym is in
9543
                         fact a call needing a TOC adjustment.  */
9544
                      if (code_sec != NULL
9545
                          && code_sec->output_section != NULL
9546
                          && (htab->stub_group[code_sec->id].toc_off
9547
                              != htab->stub_group[section->id].toc_off)
9548
                          && (code_sec->has_toc_reloc
9549
                              || code_sec->makes_toc_func_call))
9550
                        stub_type = ppc_stub_long_branch_r2off;
9551
                    }
9552
 
9553
                  if (stub_type == ppc_stub_none)
9554
                    continue;
9555
 
9556
                  /* __tls_get_addr calls might be eliminated.  */
9557
                  if (stub_type != ppc_stub_plt_call
9558
                      && hash != NULL
9559
                      && (hash == htab->tls_get_addr
9560
                          || hash == htab->tls_get_addr_fd)
9561
                      && section->has_tls_reloc
9562
                      && irela != internal_relocs)
9563
                    {
9564
                      /* Get tls info.  */
9565
                      char *tls_mask;
9566
 
9567
                      if (!get_tls_mask (&tls_mask, NULL, &local_syms,
9568
                                         irela - 1, input_bfd))
9569
                        goto error_ret_free_internal;
9570
                      if (*tls_mask != 0)
9571
                        continue;
9572
                    }
9573
 
9574
                  /* Support for grouping stub sections.  */
9575
                  id_sec = htab->stub_group[section->id].link_sec;
9576
 
9577
                  /* Get the name of this stub.  */
9578
                  stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
9579
                  if (!stub_name)
9580
                    goto error_ret_free_internal;
9581
 
9582
                  stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
9583
                                                     stub_name, FALSE, FALSE);
9584
                  if (stub_entry != NULL)
9585
                    {
9586
                      /* The proper stub has already been created.  */
9587
                      free (stub_name);
9588
                      continue;
9589
                    }
9590
 
9591
                  stub_entry = ppc_add_stub (stub_name, section, htab);
9592
                  if (stub_entry == NULL)
9593
                    {
9594
                      free (stub_name);
9595
                    error_ret_free_internal:
9596
                      if (elf_section_data (section)->relocs == NULL)
9597
                        free (internal_relocs);
9598
                    error_ret_free_local:
9599
                      if (local_syms != NULL
9600
                          && (symtab_hdr->contents
9601
                              != (unsigned char *) local_syms))
9602
                        free (local_syms);
9603
                      return FALSE;
9604
                    }
9605
 
9606
                  stub_entry->stub_type = stub_type;
9607
                  stub_entry->target_value = sym_value;
9608
                  stub_entry->target_section = code_sec;
9609
                  stub_entry->h = hash;
9610
                  stub_entry->addend = irela->r_addend;
9611
 
9612
                  if (stub_entry->h != NULL)
9613
                    htab->stub_globals += 1;
9614
                }
9615
 
9616
              /* We're done with the internal relocs, free them.  */
9617
              if (elf_section_data (section)->relocs != internal_relocs)
9618
                free (internal_relocs);
9619
            }
9620
 
9621
          if (local_syms != NULL
9622
              && symtab_hdr->contents != (unsigned char *) local_syms)
9623
            {
9624
              if (!info->keep_memory)
9625
                free (local_syms);
9626
              else
9627
                symtab_hdr->contents = (unsigned char *) local_syms;
9628
            }
9629
        }
9630
 
9631
      /* We may have added some stubs.  Find out the new size of the
9632
         stub sections.  */
9633
      for (stub_sec = htab->stub_bfd->sections;
9634
           stub_sec != NULL;
9635
           stub_sec = stub_sec->next)
9636
        if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9637
          {
9638
            stub_sec->rawsize = stub_sec->size;
9639
            stub_sec->size = 0;
9640
            stub_sec->reloc_count = 0;
9641
            stub_sec->flags &= ~SEC_RELOC;
9642
          }
9643
 
9644
      htab->brlt->size = 0;
9645
      htab->brlt->reloc_count = 0;
9646
      htab->brlt->flags &= ~SEC_RELOC;
9647
      if (htab->relbrlt != NULL)
9648
        htab->relbrlt->size = 0;
9649
 
9650
      bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
9651
 
9652
      if (info->emitrelocations
9653
          && htab->glink != NULL && htab->glink->size != 0)
9654
        {
9655
          htab->glink->reloc_count = 1;
9656
          htab->glink->flags |= SEC_RELOC;
9657
        }
9658
 
9659
      for (stub_sec = htab->stub_bfd->sections;
9660
           stub_sec != NULL;
9661
           stub_sec = stub_sec->next)
9662
        if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9663
            && stub_sec->rawsize != stub_sec->size)
9664
          break;
9665
 
9666
      /* Exit from this loop when no stubs have been added, and no stubs
9667
         have changed size.  */
9668
      if (stub_sec == NULL)
9669
        break;
9670
 
9671
      /* Ask the linker to do its stuff.  */
9672
      (*htab->layout_sections_again) ();
9673
    }
9674
 
9675
  /* It would be nice to strip htab->brlt from the output if the
9676
     section is empty, but it's too late.  If we strip sections here,
9677
     the dynamic symbol table is corrupted since the section symbol
9678
     for the stripped section isn't written.  */
9679
 
9680
  return TRUE;
9681
}
9682
 
9683
/* Called after we have determined section placement.  If sections
9684
   move, we'll be called again.  Provide a value for TOCstart.  */
9685
 
9686
bfd_vma
9687
ppc64_elf_toc (bfd *obfd)
9688
{
9689
  asection *s;
9690
  bfd_vma TOCstart;
9691
 
9692
  /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
9693
     order.  The TOC starts where the first of these sections starts.  */
9694
  s = bfd_get_section_by_name (obfd, ".got");
9695
  if (s == NULL)
9696
    s = bfd_get_section_by_name (obfd, ".toc");
9697
  if (s == NULL)
9698
    s = bfd_get_section_by_name (obfd, ".tocbss");
9699
  if (s == NULL)
9700
    s = bfd_get_section_by_name (obfd, ".plt");
9701
  if (s == NULL)
9702
    {
9703
      /* This may happen for
9704
         o  references to TOC base (SYM@toc / TOC[tc0]) without a
9705
         .toc directive
9706
         o  bad linker script
9707
         o --gc-sections and empty TOC sections
9708
 
9709
         FIXME: Warn user?  */
9710
 
9711
      /* Look for a likely section.  We probably won't even be
9712
         using TOCstart.  */
9713
      for (s = obfd->sections; s != NULL; s = s->next)
9714
        if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
9715
            == (SEC_ALLOC | SEC_SMALL_DATA))
9716
          break;
9717
      if (s == NULL)
9718
        for (s = obfd->sections; s != NULL; s = s->next)
9719
          if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
9720
              == (SEC_ALLOC | SEC_SMALL_DATA))
9721
            break;
9722
      if (s == NULL)
9723
        for (s = obfd->sections; s != NULL; s = s->next)
9724
          if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
9725
            break;
9726
      if (s == NULL)
9727
        for (s = obfd->sections; s != NULL; s = s->next)
9728
          if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
9729
            break;
9730
    }
9731
 
9732
  TOCstart = 0;
9733
  if (s != NULL)
9734
    TOCstart = s->output_section->vma + s->output_offset;
9735
 
9736
  return TOCstart;
9737
}
9738
 
9739
/* Build all the stubs associated with the current output file.
9740
   The stubs are kept in a hash table attached to the main linker
9741
   hash table.  This function is called via gldelf64ppc_finish.  */
9742
 
9743
bfd_boolean
9744
ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
9745
                       struct bfd_link_info *info,
9746
                       char **stats)
9747
{
9748
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
9749
  asection *stub_sec;
9750
  bfd_byte *p;
9751
  int stub_sec_count = 0;
9752
 
9753
  htab->emit_stub_syms = emit_stub_syms;
9754
 
9755
  /* Allocate memory to hold the linker stubs.  */
9756
  for (stub_sec = htab->stub_bfd->sections;
9757
       stub_sec != NULL;
9758
       stub_sec = stub_sec->next)
9759
    if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9760
        && stub_sec->size != 0)
9761
      {
9762
        stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
9763
        if (stub_sec->contents == NULL)
9764
          return FALSE;
9765
        /* We want to check that built size is the same as calculated
9766
           size.  rawsize is a convenient location to use.  */
9767
        stub_sec->rawsize = stub_sec->size;
9768
        stub_sec->size = 0;
9769
      }
9770
 
9771
  if (htab->glink != NULL && htab->glink->size != 0)
9772
    {
9773
      unsigned int indx;
9774
      bfd_vma plt0;
9775
 
9776
      /* Build the .glink plt call stub.  */
9777
      if (htab->emit_stub_syms)
9778
        {
9779
          struct elf_link_hash_entry *h;
9780
          h = elf_link_hash_lookup (&htab->elf, "__glink", TRUE, FALSE, FALSE);
9781
          if (h == NULL)
9782
            return FALSE;
9783
          if (h->root.type == bfd_link_hash_new)
9784
            {
9785
              h->root.type = bfd_link_hash_defined;
9786
              h->root.u.def.section = htab->glink;
9787
              h->root.u.def.value = 8;
9788
              h->ref_regular = 1;
9789
              h->def_regular = 1;
9790
              h->ref_regular_nonweak = 1;
9791
              h->forced_local = 1;
9792
              h->non_elf = 0;
9793
            }
9794
        }
9795
      plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
9796
      if (info->emitrelocations)
9797
        {
9798
          Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
9799
          if (r == NULL)
9800
            return FALSE;
9801
          r->r_offset = (htab->glink->output_offset
9802
                         + htab->glink->output_section->vma);
9803
          r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
9804
          r->r_addend = plt0;
9805
        }
9806
      p = htab->glink->contents;
9807
      plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
9808
      bfd_put_64 (htab->glink->owner, plt0, p);
9809
      p += 8;
9810
      bfd_put_32 (htab->glink->owner, MFLR_R12, p);
9811
      p += 4;
9812
      bfd_put_32 (htab->glink->owner, BCL_20_31, p);
9813
      p += 4;
9814
      bfd_put_32 (htab->glink->owner, MFLR_R11, p);
9815
      p += 4;
9816
      bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
9817
      p += 4;
9818
      bfd_put_32 (htab->glink->owner, MTLR_R12, p);
9819
      p += 4;
9820
      bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
9821
      p += 4;
9822
      bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
9823
      p += 4;
9824
      bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
9825
      p += 4;
9826
      bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
9827
      p += 4;
9828
      bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
9829
      p += 4;
9830
      bfd_put_32 (htab->glink->owner, BCTR, p);
9831
      p += 4;
9832
      while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
9833
        {
9834
          bfd_put_32 (htab->glink->owner, NOP, p);
9835
          p += 4;
9836
        }
9837
 
9838
      /* Build the .glink lazy link call stubs.  */
9839
      indx = 0;
9840
      while (p < htab->glink->contents + htab->glink->size)
9841
        {
9842
          if (indx < 0x8000)
9843
            {
9844
              bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
9845
              p += 4;
9846
            }
9847
          else
9848
            {
9849
              bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
9850
              p += 4;
9851
              bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
9852
              p += 4;
9853
            }
9854
          bfd_put_32 (htab->glink->owner,
9855
                      B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
9856
          indx++;
9857
          p += 4;
9858
        }
9859
      htab->glink->rawsize = p - htab->glink->contents;
9860
    }
9861
 
9862
  if (htab->brlt->size != 0)
9863
    {
9864
      htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
9865
                                         htab->brlt->size);
9866
      if (htab->brlt->contents == NULL)
9867
        return FALSE;
9868
    }
9869
  if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
9870
    {
9871
      htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
9872
                                            htab->relbrlt->size);
9873
      if (htab->relbrlt->contents == NULL)
9874
        return FALSE;
9875
    }
9876
 
9877
  /* Build the stubs as directed by the stub hash table.  */
9878
  bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
9879
 
9880
  if (htab->relbrlt != NULL)
9881
    htab->relbrlt->reloc_count = 0;
9882
 
9883
  for (stub_sec = htab->stub_bfd->sections;
9884
       stub_sec != NULL;
9885
       stub_sec = stub_sec->next)
9886
    if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9887
      {
9888
        stub_sec_count += 1;
9889
        if (stub_sec->rawsize != stub_sec->size)
9890
          break;
9891
      }
9892
 
9893
  if (stub_sec != NULL
9894
      || htab->glink->rawsize != htab->glink->size)
9895
    {
9896
      htab->stub_error = TRUE;
9897
      (*_bfd_error_handler) (_("stubs don't match calculated size"));
9898
    }
9899
 
9900
  if (htab->stub_error)
9901
    return FALSE;
9902
 
9903
  if (stats != NULL)
9904
    {
9905
      *stats = bfd_malloc (500);
9906
      if (*stats == NULL)
9907
        return FALSE;
9908
 
9909
      sprintf (*stats, _("linker stubs in %u group%s\n"
9910
                         "  branch       %lu\n"
9911
                         "  toc adjust   %lu\n"
9912
                         "  long branch  %lu\n"
9913
                         "  long toc adj %lu\n"
9914
                         "  plt call     %lu"),
9915
               stub_sec_count,
9916
               stub_sec_count == 1 ? "" : "s",
9917
               htab->stub_count[ppc_stub_long_branch - 1],
9918
               htab->stub_count[ppc_stub_long_branch_r2off - 1],
9919
               htab->stub_count[ppc_stub_plt_branch - 1],
9920
               htab->stub_count[ppc_stub_plt_branch_r2off - 1],
9921
               htab->stub_count[ppc_stub_plt_call - 1]);
9922
    }
9923
  return TRUE;
9924
}
9925
 
9926
/* This function undoes the changes made by add_symbol_adjust.  */
9927
 
9928
static bfd_boolean
9929
undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9930
{
9931
  struct ppc_link_hash_entry *eh;
9932
 
9933
  if (h->root.type == bfd_link_hash_indirect)
9934
    return TRUE;
9935
 
9936
  if (h->root.type == bfd_link_hash_warning)
9937
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
9938
 
9939
  eh = (struct ppc_link_hash_entry *) h;
9940
  if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
9941
    return TRUE;
9942
 
9943
  eh->elf.root.type = bfd_link_hash_undefined;
9944
  return TRUE;
9945
}
9946
 
9947
void
9948
ppc64_elf_restore_symbols (struct bfd_link_info *info)
9949
{
9950
  struct ppc_link_hash_table *htab = ppc_hash_table (info);
9951
  elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
9952
}
9953
 
9954
/* What to do when ld finds relocations against symbols defined in
9955
   discarded sections.  */
9956
 
9957
static unsigned int
9958
ppc64_elf_action_discarded (asection *sec)
9959
{
9960
  if (strcmp (".opd", sec->name) == 0)
9961
    return 0;
9962
 
9963
  if (strcmp (".toc", sec->name) == 0)
9964
    return 0;
9965
 
9966
  if (strcmp (".toc1", sec->name) == 0)
9967
    return 0;
9968
 
9969
  return _bfd_elf_default_action_discarded (sec);
9970
}
9971
 
9972
/* The RELOCATE_SECTION function is called by the ELF backend linker
9973
   to handle the relocations for a section.
9974
 
9975
   The relocs are always passed as Rela structures; if the section
9976
   actually uses Rel structures, the r_addend field will always be
9977
   zero.
9978
 
9979
   This function is responsible for adjust the section contents as
9980
   necessary, and (if using Rela relocs and generating a
9981
   relocatable output file) adjusting the reloc addend as
9982
   necessary.
9983
 
9984
   This function does not have to worry about setting the reloc
9985
   address or the reloc symbol index.
9986
 
9987
   LOCAL_SYMS is a pointer to the swapped in local symbols.
9988
 
9989
   LOCAL_SECTIONS is an array giving the section in the input file
9990
   corresponding to the st_shndx field of each local symbol.
9991
 
9992
   The global hash table entry for the global symbols can be found
9993
   via elf_sym_hashes (input_bfd).
9994
 
9995
   When generating relocatable output, this function must handle
9996
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
9997
   going to be the section symbol corresponding to the output
9998
   section, which means that the addend must be adjusted
9999
   accordingly.  */
10000
 
10001
static bfd_boolean
10002
ppc64_elf_relocate_section (bfd *output_bfd,
10003
                            struct bfd_link_info *info,
10004
                            bfd *input_bfd,
10005
                            asection *input_section,
10006
                            bfd_byte *contents,
10007
                            Elf_Internal_Rela *relocs,
10008
                            Elf_Internal_Sym *local_syms,
10009
                            asection **local_sections)
10010
{
10011
  struct ppc_link_hash_table *htab;
10012
  Elf_Internal_Shdr *symtab_hdr;
10013
  struct elf_link_hash_entry **sym_hashes;
10014
  Elf_Internal_Rela *rel;
10015
  Elf_Internal_Rela *relend;
10016
  Elf_Internal_Rela outrel;
10017
  bfd_byte *loc;
10018
  struct got_entry **local_got_ents;
10019
  bfd_vma TOCstart;
10020
  bfd_boolean ret = TRUE;
10021
  bfd_boolean is_opd;
10022
  /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
10023
  bfd_boolean is_power4 = FALSE;
10024
  bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
10025
 
10026
  /* Initialize howto table if needed.  */
10027
  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
10028
    ppc_howto_init ();
10029
 
10030
  htab = ppc_hash_table (info);
10031
 
10032
  /* Don't relocate stub sections.  */
10033
  if (input_section->owner == htab->stub_bfd)
10034
    return TRUE;
10035
 
10036
  BFD_ASSERT (is_ppc64_elf (input_bfd));
10037
 
10038
  local_got_ents = elf_local_got_ents (input_bfd);
10039
  TOCstart = elf_gp (output_bfd);
10040
  symtab_hdr = &elf_symtab_hdr (input_bfd);
10041
  sym_hashes = elf_sym_hashes (input_bfd);
10042
  is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
10043
 
10044
  rel = relocs;
10045
  relend = relocs + input_section->reloc_count;
10046
  for (; rel < relend; rel++)
10047
    {
10048
      enum elf_ppc64_reloc_type r_type;
10049
      bfd_vma addend, orig_addend;
10050
      bfd_reloc_status_type r;
10051
      Elf_Internal_Sym *sym;
10052
      asection *sec;
10053
      struct elf_link_hash_entry *h_elf;
10054
      struct ppc_link_hash_entry *h;
10055
      struct ppc_link_hash_entry *fdh;
10056
      const char *sym_name;
10057
      unsigned long r_symndx, toc_symndx;
10058
      char tls_mask, tls_gd, tls_type;
10059
      char sym_type;
10060
      bfd_vma relocation;
10061
      bfd_boolean unresolved_reloc;
10062
      bfd_boolean warned;
10063
      unsigned long insn, mask;
10064
      struct ppc_stub_hash_entry *stub_entry;
10065
      bfd_vma max_br_offset;
10066
      bfd_vma from;
10067
 
10068
      r_type = ELF64_R_TYPE (rel->r_info);
10069
      r_symndx = ELF64_R_SYM (rel->r_info);
10070
 
10071
      /* For old style R_PPC64_TOC relocs with a zero symbol, use the
10072
         symbol of the previous ADDR64 reloc.  The symbol gives us the
10073
         proper TOC base to use.  */
10074
      if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
10075
          && rel != relocs
10076
          && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
10077
          && is_opd)
10078
        r_symndx = ELF64_R_SYM (rel[-1].r_info);
10079
 
10080
      sym = NULL;
10081
      sec = NULL;
10082
      h_elf = NULL;
10083
      sym_name = NULL;
10084
      unresolved_reloc = FALSE;
10085
      warned = FALSE;
10086
      orig_addend = rel->r_addend;
10087
 
10088
      if (r_symndx < symtab_hdr->sh_info)
10089
        {
10090
          /* It's a local symbol.  */
10091
          struct _opd_sec_data *opd;
10092
 
10093
          sym = local_syms + r_symndx;
10094
          sec = local_sections[r_symndx];
10095
          sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
10096
          sym_type = ELF64_ST_TYPE (sym->st_info);
10097
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10098
          opd = get_opd_info (sec);
10099
          if (opd != NULL && opd->adjust != NULL)
10100
            {
10101
              long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
10102
              if (adjust == -1)
10103
                relocation = 0;
10104
              else
10105
                {
10106
                  /* If this is a relocation against the opd section sym
10107
                     and we have edited .opd, adjust the reloc addend so
10108
                     that ld -r and ld --emit-relocs output is correct.
10109
                     If it is a reloc against some other .opd symbol,
10110
                     then the symbol value will be adjusted later.  */
10111
                  if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10112
                    rel->r_addend += adjust;
10113
                  else
10114
                    relocation += adjust;
10115
                }
10116
            }
10117
        }
10118
      else
10119
        {
10120
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
10121
                                   r_symndx, symtab_hdr, sym_hashes,
10122
                                   h_elf, sec, relocation,
10123
                                   unresolved_reloc, warned);
10124
          sym_name = h_elf->root.root.string;
10125
          sym_type = h_elf->type;
10126
        }
10127
      h = (struct ppc_link_hash_entry *) h_elf;
10128
 
10129
      if (sec != NULL && elf_discarded_section (sec))
10130
        {
10131
          /* For relocs against symbols from removed linkonce sections,
10132
             or sections discarded by a linker script, we just want the
10133
             section contents zeroed.  Avoid any special processing.  */
10134
          _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10135
                               contents + rel->r_offset);
10136
          rel->r_info = 0;
10137
          rel->r_addend = 0;
10138
          continue;
10139
        }
10140
 
10141
      if (info->relocatable)
10142
        continue;
10143
 
10144
      /* TLS optimizations.  Replace instruction sequences and relocs
10145
         based on information we collected in tls_optimize.  We edit
10146
         RELOCS so that --emit-relocs will output something sensible
10147
         for the final instruction stream.  */
10148
      tls_mask = 0;
10149
      tls_gd = 0;
10150
      toc_symndx = 0;
10151
      if (IS_PPC64_TLS_RELOC (r_type))
10152
        {
10153
          if (h != NULL)
10154
            tls_mask = h->tls_mask;
10155
          else if (local_got_ents != NULL)
10156
            {
10157
              char *lgot_masks;
10158
              lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
10159
              tls_mask = lgot_masks[r_symndx];
10160
            }
10161
          if (tls_mask == 0 && r_type == R_PPC64_TLS)
10162
            {
10163
              /* Check for toc tls entries.  */
10164
              char *toc_tls;
10165
 
10166
              if (!get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
10167
                                 rel, input_bfd))
10168
                return FALSE;
10169
 
10170
              if (toc_tls)
10171
                tls_mask = *toc_tls;
10172
            }
10173
        }
10174
 
10175
      /* Check that tls relocs are used with tls syms, and non-tls
10176
         relocs are used with non-tls syms.  */
10177
      if (r_symndx != 0
10178
          && r_type != R_PPC64_NONE
10179
          && (h == NULL
10180
              || h->elf.root.type == bfd_link_hash_defined
10181
              || h->elf.root.type == bfd_link_hash_defweak)
10182
          && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
10183
        {
10184
          if (r_type == R_PPC64_TLS && tls_mask != 0)
10185
            /* R_PPC64_TLS is OK against a symbol in the TOC.  */
10186
            ;
10187
          else
10188
            (*_bfd_error_handler)
10189
              (sym_type == STT_TLS
10190
               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
10191
               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
10192
               input_bfd,
10193
               input_section,
10194
               (long) rel->r_offset,
10195
               ppc64_elf_howto_table[r_type]->name,
10196
               sym_name);
10197
        }
10198
 
10199
      /* Ensure reloc mapping code below stays sane.  */
10200
      if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
10201
          || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
10202
          || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
10203
          || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
10204
          || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
10205
          || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
10206
          || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
10207
          || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
10208
          || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
10209
          || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
10210
        abort ();
10211
 
10212
      switch (r_type)
10213
        {
10214
        default:
10215
          break;
10216
 
10217
        case R_PPC64_TOC16:
10218
        case R_PPC64_TOC16_LO:
10219
        case R_PPC64_TOC16_DS:
10220
        case R_PPC64_TOC16_LO_DS:
10221
          {
10222
            /* Check for toc tls entries.  */
10223
            char *toc_tls;
10224
            int retval;
10225
 
10226
            retval = get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
10227
                                   rel, input_bfd);
10228
            if (retval == 0)
10229
              return FALSE;
10230
 
10231
            if (toc_tls)
10232
              {
10233
                tls_mask = *toc_tls;
10234
                if (r_type == R_PPC64_TOC16_DS
10235
                    || r_type == R_PPC64_TOC16_LO_DS)
10236
                  {
10237
                    if (tls_mask != 0
10238
                        && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
10239
                      goto toctprel;
10240
                  }
10241
                else
10242
                  {
10243
                    /* If we found a GD reloc pair, then we might be
10244
                       doing a GD->IE transition.  */
10245
                    if (retval == 2)
10246
                      {
10247
                        tls_gd = TLS_TPRELGD;
10248
                        if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10249
                          goto tls_ldgd_opt;
10250
                      }
10251
                    else if (retval == 3)
10252
                      {
10253
                        if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10254
                          goto tls_ldgd_opt;
10255
                      }
10256
                  }
10257
              }
10258
          }
10259
          break;
10260
 
10261
        case R_PPC64_GOT_TPREL16_DS:
10262
        case R_PPC64_GOT_TPREL16_LO_DS:
10263
          if (tls_mask != 0
10264
              && (tls_mask & TLS_TPREL) == 0)
10265
            {
10266
            toctprel:
10267
              insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
10268
              insn &= 31 << 21;
10269
              insn |= 0x3c0d0000;       /* addis 0,13,0 */
10270
              bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
10271
              r_type = R_PPC64_TPREL16_HA;
10272
              if (toc_symndx != 0)
10273
                {
10274
                  rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10275
                  /* We changed the symbol.  Start over in order to
10276
                     get h, sym, sec etc. right.  */
10277
                  rel--;
10278
                  continue;
10279
                }
10280
              else
10281
                rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10282
            }
10283
          break;
10284
 
10285
        case R_PPC64_TLS:
10286
          if (tls_mask != 0
10287
              && (tls_mask & TLS_TPREL) == 0)
10288
            {
10289
              bfd_vma rtra;
10290
              insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
10291
              if ((insn & ((0x3f << 26) | (31 << 11)))
10292
                  == ((31 << 26) | (13 << 11)))
10293
                rtra = insn & ((1 << 26) - (1 << 16));
10294
              else if ((insn & ((0x3f << 26) | (31 << 16)))
10295
                       == ((31 << 26) | (13 << 16)))
10296
                rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
10297
              else
10298
                abort ();
10299
              if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
10300
                /* add -> addi.  */
10301
                insn = 14 << 26;
10302
              else if ((insn & (31 << 1)) == 23 << 1
10303
                       && ((insn & (31 << 6)) < 14 << 6
10304
                           || ((insn & (31 << 6)) >= 16 << 6
10305
                               && (insn & (31 << 6)) < 24 << 6)))
10306
                /* load and store indexed -> dform.  */
10307
                insn = (32 | ((insn >> 6) & 31)) << 26;
10308
              else if ((insn & (31 << 1)) == 21 << 1
10309
                       && (insn & (0x1a << 6)) == 0)
10310
                /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
10311
                insn = (((58 | ((insn >> 6) & 4)) << 26)
10312
                        | ((insn >> 6) & 1));
10313
              else if ((insn & (31 << 1)) == 21 << 1
10314
                       && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
10315
                /* lwax -> lwa.  */
10316
                insn = (58 << 26) | 2;
10317
              else
10318
                abort ();
10319
              insn |= rtra;
10320
              bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10321
              /* Was PPC64_TLS which sits on insn boundary, now
10322
                 PPC64_TPREL16_LO which is at low-order half-word.  */
10323
              rel->r_offset += d_offset;
10324
              r_type = R_PPC64_TPREL16_LO;
10325
              if (toc_symndx != 0)
10326
                {
10327
                  rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10328
                  /* We changed the symbol.  Start over in order to
10329
                     get h, sym, sec etc. right.  */
10330
                  rel--;
10331
                  continue;
10332
                }
10333
              else
10334
                rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10335
            }
10336
          break;
10337
 
10338
        case R_PPC64_GOT_TLSGD16_HI:
10339
        case R_PPC64_GOT_TLSGD16_HA:
10340
          tls_gd = TLS_TPRELGD;
10341
          if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10342
            goto tls_gdld_hi;
10343
          break;
10344
 
10345
        case R_PPC64_GOT_TLSLD16_HI:
10346
        case R_PPC64_GOT_TLSLD16_HA:
10347
          if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10348
            {
10349
            tls_gdld_hi:
10350
              if ((tls_mask & tls_gd) != 0)
10351
                r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10352
                          + R_PPC64_GOT_TPREL16_DS);
10353
              else
10354
                {
10355
                  bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10356
                  rel->r_offset -= d_offset;
10357
                  r_type = R_PPC64_NONE;
10358
                }
10359
              rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10360
            }
10361
          break;
10362
 
10363
        case R_PPC64_GOT_TLSGD16:
10364
        case R_PPC64_GOT_TLSGD16_LO:
10365
          tls_gd = TLS_TPRELGD;
10366
          if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10367
            goto tls_ldgd_opt;
10368
          break;
10369
 
10370
        case R_PPC64_GOT_TLSLD16:
10371
        case R_PPC64_GOT_TLSLD16_LO:
10372
          if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10373
            {
10374
              bfd_vma insn1, insn2, insn3;
10375
              bfd_vma offset;
10376
 
10377
            tls_ldgd_opt:
10378
              /* We know that the next reloc is on a tls_get_addr
10379
                 call, since ppc64_elf_tls_optimize checks this.  */
10380
              offset = rel[1].r_offset;
10381
              insn1 = bfd_get_32 (output_bfd,
10382
                                  contents + rel->r_offset - d_offset);
10383
              insn3 = bfd_get_32 (output_bfd,
10384
                                  contents + offset + 4);
10385
              if ((tls_mask & tls_gd) != 0)
10386
                {
10387
                  /* IE */
10388
                  insn1 &= (1 << 26) - (1 << 2);
10389
                  insn1 |= 58 << 26;    /* ld */
10390
                  insn2 = 0x7c636a14;   /* add 3,3,13 */
10391
                  rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10392
                                                R_PPC64_NONE);
10393
                  if ((tls_mask & TLS_EXPLICIT) == 0)
10394
                    r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10395
                              + R_PPC64_GOT_TPREL16_DS);
10396
                  else
10397
                    r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10398
                  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10399
                }
10400
              else
10401
                {
10402
                  /* LE */
10403
                  insn1 = 0x3c6d0000;   /* addis 3,13,0 */
10404
                  insn2 = 0x38630000;   /* addi 3,3,0 */
10405
                  if (tls_gd == 0)
10406
                    {
10407
                      /* Was an LD reloc.  */
10408
                      r_symndx = 0;
10409
                      rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10410
                      rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10411
                    }
10412
                  else if (toc_symndx != 0)
10413
                    r_symndx = toc_symndx;
10414
                  r_type = R_PPC64_TPREL16_HA;
10415
                  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10416
                  rel[1].r_info = ELF64_R_INFO (r_symndx,
10417
                                                R_PPC64_TPREL16_LO);
10418
                  rel[1].r_offset += d_offset;
10419
                }
10420
              if (insn3 == NOP
10421
                  || insn3 == CROR_151515 || insn3 == CROR_313131)
10422
                {
10423
                  insn3 = insn2;
10424
                  insn2 = NOP;
10425
                  rel[1].r_offset += 4;
10426
                }
10427
              bfd_put_32 (output_bfd, insn1,
10428
                          contents + rel->r_offset - d_offset);
10429
              bfd_put_32 (output_bfd, insn2, contents + offset);
10430
              bfd_put_32 (output_bfd, insn3, contents + offset + 4);
10431
              if (tls_gd == 0 || toc_symndx != 0)
10432
                {
10433
                  /* We changed the symbol.  Start over in order
10434
                     to get h, sym, sec etc. right.  */
10435
                  rel--;
10436
                  continue;
10437
                }
10438
            }
10439
          break;
10440
 
10441
        case R_PPC64_DTPMOD64:
10442
          if (rel + 1 < relend
10443
              && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
10444
              && rel[1].r_offset == rel->r_offset + 8)
10445
            {
10446
              if ((tls_mask & TLS_GD) == 0)
10447
                {
10448
                  rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
10449
                  if ((tls_mask & TLS_TPRELGD) != 0)
10450
                    r_type = R_PPC64_TPREL64;
10451
                  else
10452
                    {
10453
                      bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10454
                      r_type = R_PPC64_NONE;
10455
                    }
10456
                  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10457
                }
10458
            }
10459
          else
10460
            {
10461
              if ((tls_mask & TLS_LD) == 0)
10462
                {
10463
                  bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10464
                  r_type = R_PPC64_NONE;
10465
                  rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10466
                }
10467
            }
10468
          break;
10469
 
10470
        case R_PPC64_TPREL64:
10471
          if ((tls_mask & TLS_TPREL) == 0)
10472
            {
10473
              r_type = R_PPC64_NONE;
10474
              rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10475
            }
10476
          break;
10477
        }
10478
 
10479
      /* Handle other relocations that tweak non-addend part of insn.  */
10480
      insn = 0;
10481
      max_br_offset = 1 << 25;
10482
      addend = rel->r_addend;
10483
      switch (r_type)
10484
        {
10485
        default:
10486
          break;
10487
 
10488
          /* Branch taken prediction relocations.  */
10489
        case R_PPC64_ADDR14_BRTAKEN:
10490
        case R_PPC64_REL14_BRTAKEN:
10491
          insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
10492
          /* Fall thru.  */
10493
 
10494
          /* Branch not taken prediction relocations.  */
10495
        case R_PPC64_ADDR14_BRNTAKEN:
10496
        case R_PPC64_REL14_BRNTAKEN:
10497
          insn |= bfd_get_32 (output_bfd,
10498
                              contents + rel->r_offset) & ~(0x01 << 21);
10499
          /* Fall thru.  */
10500
 
10501
        case R_PPC64_REL14:
10502
          max_br_offset = 1 << 15;
10503
          /* Fall thru.  */
10504
 
10505
        case R_PPC64_REL24:
10506
          /* Calls to functions with a different TOC, such as calls to
10507
             shared objects, need to alter the TOC pointer.  This is
10508
             done using a linkage stub.  A REL24 branching to these
10509
             linkage stubs needs to be followed by a nop, as the nop
10510
             will be replaced with an instruction to restore the TOC
10511
             base pointer.  */
10512
          stub_entry = NULL;
10513
          fdh = h;
10514
          if (((h != NULL
10515
                && (((fdh = h->oh) != NULL
10516
                     && fdh->elf.plt.plist != NULL)
10517
                    || (fdh = h)->elf.plt.plist != NULL))
10518
               || (sec != NULL
10519
                   && sec->output_section != NULL
10520
                   && sec->id <= htab->top_id
10521
                   && (htab->stub_group[sec->id].toc_off
10522
                       != htab->stub_group[input_section->id].toc_off)))
10523
              && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
10524
                                                   rel, htab)) != NULL
10525
              && (stub_entry->stub_type == ppc_stub_plt_call
10526
                  || stub_entry->stub_type == ppc_stub_plt_branch_r2off
10527
                  || stub_entry->stub_type == ppc_stub_long_branch_r2off))
10528
            {
10529
              bfd_boolean can_plt_call = FALSE;
10530
 
10531
              if (rel->r_offset + 8 <= input_section->size)
10532
                {
10533
                  unsigned long nop;
10534
                  nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
10535
                  if (nop == NOP
10536
                      || nop == CROR_151515 || nop == CROR_313131)
10537
                    {
10538
                      bfd_put_32 (input_bfd, LD_R2_40R1,
10539
                                  contents + rel->r_offset + 4);
10540
                      can_plt_call = TRUE;
10541
                    }
10542
                }
10543
 
10544
              if (!can_plt_call)
10545
                {
10546
                  if (stub_entry->stub_type == ppc_stub_plt_call)
10547
                    {
10548
                      /* If this is a plain branch rather than a branch
10549
                         and link, don't require a nop.  However, don't
10550
                         allow tail calls in a shared library as they
10551
                         will result in r2 being corrupted.  */
10552
                      unsigned long br;
10553
                      br = bfd_get_32 (input_bfd, contents + rel->r_offset);
10554
                      if (info->executable && (br & 1) == 0)
10555
                        can_plt_call = TRUE;
10556
                      else
10557
                        stub_entry = NULL;
10558
                    }
10559
                  else if (h != NULL
10560
                           && strcmp (h->elf.root.root.string,
10561
                                      ".__libc_start_main") == 0)
10562
                    {
10563
                      /* Allow crt1 branch to go via a toc adjusting stub.  */
10564
                      can_plt_call = TRUE;
10565
                    }
10566
                  else
10567
                    {
10568
                      if (strcmp (input_section->output_section->name,
10569
                                  ".init") == 0
10570
                          || strcmp (input_section->output_section->name,
10571
                                     ".fini") == 0)
10572
                        (*_bfd_error_handler)
10573
                          (_("%B(%A+0x%lx): automatic multiple TOCs "
10574
                             "not supported using your crt files; "
10575
                             "recompile with -mminimal-toc or upgrade gcc"),
10576
                           input_bfd,
10577
                           input_section,
10578
                           (long) rel->r_offset);
10579
                      else
10580
                        (*_bfd_error_handler)
10581
                          (_("%B(%A+0x%lx): sibling call optimization to `%s' "
10582
                             "does not allow automatic multiple TOCs; "
10583
                             "recompile with -mminimal-toc or "
10584
                             "-fno-optimize-sibling-calls, "
10585
                             "or make `%s' extern"),
10586
                           input_bfd,
10587
                           input_section,
10588
                           (long) rel->r_offset,
10589
                           sym_name,
10590
                           sym_name);
10591
                      bfd_set_error (bfd_error_bad_value);
10592
                      ret = FALSE;
10593
                    }
10594
                }
10595
 
10596
              if (can_plt_call
10597
                  && stub_entry->stub_type == ppc_stub_plt_call)
10598
                unresolved_reloc = FALSE;
10599
            }
10600
 
10601
          if (stub_entry == NULL
10602
              && get_opd_info (sec) != NULL)
10603
            {
10604
              /* The branch destination is the value of the opd entry. */
10605
              bfd_vma off = (relocation + addend
10606
                             - sec->output_section->vma
10607
                             - sec->output_offset);
10608
              bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
10609
              if (dest != (bfd_vma) -1)
10610
                {
10611
                  relocation = dest;
10612
                  addend = 0;
10613
                }
10614
            }
10615
 
10616
          /* If the branch is out of reach we ought to have a long
10617
             branch stub.  */
10618
          from = (rel->r_offset
10619
                  + input_section->output_offset
10620
                  + input_section->output_section->vma);
10621
 
10622
          if (stub_entry == NULL
10623
              && (relocation + addend - from + max_br_offset
10624
                  >= 2 * max_br_offset)
10625
              && r_type != R_PPC64_ADDR14_BRTAKEN
10626
              && r_type != R_PPC64_ADDR14_BRNTAKEN)
10627
            stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
10628
                                             htab);
10629
 
10630
          if (stub_entry != NULL)
10631
            {
10632
              /* Munge up the value and addend so that we call the stub
10633
                 rather than the procedure directly.  */
10634
              relocation = (stub_entry->stub_offset
10635
                            + stub_entry->stub_sec->output_offset
10636
                            + stub_entry->stub_sec->output_section->vma);
10637
              addend = 0;
10638
            }
10639
 
10640
          if (insn != 0)
10641
            {
10642
              if (is_power4)
10643
                {
10644
                  /* Set 'a' bit.  This is 0b00010 in BO field for branch
10645
                     on CR(BI) insns (BO == 001at or 011at), and 0b01000
10646
                     for branch on CTR insns (BO == 1a00t or 1a01t).  */
10647
                  if ((insn & (0x14 << 21)) == (0x04 << 21))
10648
                    insn |= 0x02 << 21;
10649
                  else if ((insn & (0x14 << 21)) == (0x10 << 21))
10650
                    insn |= 0x08 << 21;
10651
                  else
10652
                    break;
10653
                }
10654
              else
10655
                {
10656
                  /* Invert 'y' bit if not the default.  */
10657
                  if ((bfd_signed_vma) (relocation + addend - from) < 0)
10658
                    insn ^= 0x01 << 21;
10659
                }
10660
 
10661
              bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10662
            }
10663
 
10664
          /* NOP out calls to undefined weak functions.
10665
             We can thus call a weak function without first
10666
             checking whether the function is defined.  */
10667
          else if (h != NULL
10668
                   && h->elf.root.type == bfd_link_hash_undefweak
10669
                   && r_type == R_PPC64_REL24
10670
                   && relocation == 0
10671
                   && addend == 0)
10672
            {
10673
              bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10674
              continue;
10675
            }
10676
          break;
10677
        }
10678
 
10679
      /* Set `addend'.  */
10680
      tls_type = 0;
10681
      switch (r_type)
10682
        {
10683
        default:
10684
          (*_bfd_error_handler)
10685
            (_("%B: unknown relocation type %d for symbol %s"),
10686
             input_bfd, (int) r_type, sym_name);
10687
 
10688
          bfd_set_error (bfd_error_bad_value);
10689
          ret = FALSE;
10690
          continue;
10691
 
10692
        case R_PPC64_NONE:
10693
        case R_PPC64_TLS:
10694
        case R_PPC64_GNU_VTINHERIT:
10695
        case R_PPC64_GNU_VTENTRY:
10696
          continue;
10697
 
10698
          /* GOT16 relocations.  Like an ADDR16 using the symbol's
10699
             address in the GOT as relocation value instead of the
10700
             symbol's value itself.  Also, create a GOT entry for the
10701
             symbol and put the symbol value there.  */
10702
        case R_PPC64_GOT_TLSGD16:
10703
        case R_PPC64_GOT_TLSGD16_LO:
10704
        case R_PPC64_GOT_TLSGD16_HI:
10705
        case R_PPC64_GOT_TLSGD16_HA:
10706
          tls_type = TLS_TLS | TLS_GD;
10707
          goto dogot;
10708
 
10709
        case R_PPC64_GOT_TLSLD16:
10710
        case R_PPC64_GOT_TLSLD16_LO:
10711
        case R_PPC64_GOT_TLSLD16_HI:
10712
        case R_PPC64_GOT_TLSLD16_HA:
10713
          tls_type = TLS_TLS | TLS_LD;
10714
          goto dogot;
10715
 
10716
        case R_PPC64_GOT_TPREL16_DS:
10717
        case R_PPC64_GOT_TPREL16_LO_DS:
10718
        case R_PPC64_GOT_TPREL16_HI:
10719
        case R_PPC64_GOT_TPREL16_HA:
10720
          tls_type = TLS_TLS | TLS_TPREL;
10721
          goto dogot;
10722
 
10723
        case R_PPC64_GOT_DTPREL16_DS:
10724
        case R_PPC64_GOT_DTPREL16_LO_DS:
10725
        case R_PPC64_GOT_DTPREL16_HI:
10726
        case R_PPC64_GOT_DTPREL16_HA:
10727
          tls_type = TLS_TLS | TLS_DTPREL;
10728
          goto dogot;
10729
 
10730
        case R_PPC64_GOT16:
10731
        case R_PPC64_GOT16_LO:
10732
        case R_PPC64_GOT16_HI:
10733
        case R_PPC64_GOT16_HA:
10734
        case R_PPC64_GOT16_DS:
10735
        case R_PPC64_GOT16_LO_DS:
10736
        dogot:
10737
          {
10738
            /* Relocation is to the entry for this symbol in the global
10739
               offset table.  */
10740
            asection *got;
10741
            bfd_vma *offp;
10742
            bfd_vma off;
10743
            unsigned long indx = 0;
10744
 
10745
            if (tls_type == (TLS_TLS | TLS_LD)
10746
                && (h == NULL
10747
                    || !h->elf.def_dynamic))
10748
              offp = &ppc64_tlsld_got (input_bfd)->offset;
10749
            else
10750
              {
10751
                struct got_entry *ent;
10752
 
10753
                if (h != NULL)
10754
                  {
10755
                    bfd_boolean dyn = htab->elf.dynamic_sections_created;
10756
                    if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
10757
                                                          &h->elf)
10758
                        || (info->shared
10759
                            && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
10760
                      /* This is actually a static link, or it is a
10761
                         -Bsymbolic link and the symbol is defined
10762
                         locally, or the symbol was forced to be local
10763
                         because of a version file.  */
10764
                      ;
10765
                    else
10766
                      {
10767
                        indx = h->elf.dynindx;
10768
                        unresolved_reloc = FALSE;
10769
                      }
10770
                    ent = h->elf.got.glist;
10771
                  }
10772
                else
10773
                  {
10774
                    if (local_got_ents == NULL)
10775
                      abort ();
10776
                    ent = local_got_ents[r_symndx];
10777
                  }
10778
 
10779
                for (; ent != NULL; ent = ent->next)
10780
                  if (ent->addend == orig_addend
10781
                      && ent->owner == input_bfd
10782
                      && ent->tls_type == tls_type)
10783
                    break;
10784
                if (ent == NULL)
10785
                  abort ();
10786
                offp = &ent->got.offset;
10787
              }
10788
 
10789
            got = ppc64_elf_tdata (input_bfd)->got;
10790
            if (got == NULL)
10791
              abort ();
10792
 
10793
            /* The offset must always be a multiple of 8.  We use the
10794
               least significant bit to record whether we have already
10795
               processed this entry.  */
10796
            off = *offp;
10797
            if ((off & 1) != 0)
10798
              off &= ~1;
10799
            else
10800
              {
10801
                /* Generate relocs for the dynamic linker, except in
10802
                   the case of TLSLD where we'll use one entry per
10803
                   module.  */
10804
                asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
10805
 
10806
                *offp = off | 1;
10807
                if ((info->shared || indx != 0)
10808
                    && (h == NULL
10809
                        || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10810
                        || h->elf.root.type != bfd_link_hash_undefweak))
10811
                  {
10812
                    outrel.r_offset = (got->output_section->vma
10813
                                       + got->output_offset
10814
                                       + off);
10815
                    outrel.r_addend = addend;
10816
                    if (tls_type & (TLS_LD | TLS_GD))
10817
                      {
10818
                        outrel.r_addend = 0;
10819
                        outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
10820
                        if (tls_type == (TLS_TLS | TLS_GD))
10821
                          {
10822
                            loc = relgot->contents;
10823
                            loc += (relgot->reloc_count++
10824
                                    * sizeof (Elf64_External_Rela));
10825
                            bfd_elf64_swap_reloca_out (output_bfd,
10826
                                                       &outrel, loc);
10827
                            outrel.r_offset += 8;
10828
                            outrel.r_addend = addend;
10829
                            outrel.r_info
10830
                              = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10831
                          }
10832
                      }
10833
                    else if (tls_type == (TLS_TLS | TLS_DTPREL))
10834
                      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10835
                    else if (tls_type == (TLS_TLS | TLS_TPREL))
10836
                      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
10837
                    else if (indx == 0)
10838
                      {
10839
                        outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
10840
 
10841
                        /* Write the .got section contents for the sake
10842
                           of prelink.  */
10843
                        loc = got->contents + off;
10844
                        bfd_put_64 (output_bfd, outrel.r_addend + relocation,
10845
                                    loc);
10846
                      }
10847
                    else
10848
                      outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
10849
 
10850
                    if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
10851
                      {
10852
                        outrel.r_addend += relocation;
10853
                        if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
10854
                          outrel.r_addend -= htab->elf.tls_sec->vma;
10855
                      }
10856
                    loc = relgot->contents;
10857
                    loc += (relgot->reloc_count++
10858
                            * sizeof (Elf64_External_Rela));
10859
                    bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10860
                  }
10861
 
10862
                /* Init the .got section contents here if we're not
10863
                   emitting a reloc.  */
10864
                else
10865
                  {
10866
                    relocation += addend;
10867
                    if (tls_type == (TLS_TLS | TLS_LD))
10868
                      relocation = 1;
10869
                    else if (tls_type != 0)
10870
                      {
10871
                        relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
10872
                        if (tls_type == (TLS_TLS | TLS_TPREL))
10873
                          relocation += DTP_OFFSET - TP_OFFSET;
10874
 
10875
                        if (tls_type == (TLS_TLS | TLS_GD))
10876
                          {
10877
                            bfd_put_64 (output_bfd, relocation,
10878
                                        got->contents + off + 8);
10879
                            relocation = 1;
10880
                          }
10881
                      }
10882
 
10883
                    bfd_put_64 (output_bfd, relocation,
10884
                                got->contents + off);
10885
                  }
10886
              }
10887
 
10888
            if (off >= (bfd_vma) -2)
10889
              abort ();
10890
 
10891
            relocation = got->output_offset + off;
10892
 
10893
            /* TOC base (r2) is TOC start plus 0x8000.  */
10894
            addend = -TOC_BASE_OFF;
10895
          }
10896
          break;
10897
 
10898
        case R_PPC64_PLT16_HA:
10899
        case R_PPC64_PLT16_HI:
10900
        case R_PPC64_PLT16_LO:
10901
        case R_PPC64_PLT32:
10902
        case R_PPC64_PLT64:
10903
          /* Relocation is to the entry for this symbol in the
10904
             procedure linkage table.  */
10905
 
10906
          /* Resolve a PLT reloc against a local symbol directly,
10907
             without using the procedure linkage table.  */
10908
          if (h == NULL)
10909
            break;
10910
 
10911
          /* It's possible that we didn't make a PLT entry for this
10912
             symbol.  This happens when statically linking PIC code,
10913
             or when using -Bsymbolic.  Go find a match if there is a
10914
             PLT entry.  */
10915
          if (htab->plt != NULL)
10916
            {
10917
              struct plt_entry *ent;
10918
              for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
10919
                if (ent->addend == orig_addend
10920
                    && ent->plt.offset != (bfd_vma) -1)
10921
                  {
10922
                    relocation = (htab->plt->output_section->vma
10923
                                  + htab->plt->output_offset
10924
                                  + ent->plt.offset);
10925
                    unresolved_reloc = FALSE;
10926
                  }
10927
            }
10928
          break;
10929
 
10930
        case R_PPC64_TOC:
10931
          /* Relocation value is TOC base.  */
10932
          relocation = TOCstart;
10933
          if (r_symndx == 0)
10934
            relocation += htab->stub_group[input_section->id].toc_off;
10935
          else if (unresolved_reloc)
10936
            ;
10937
          else if (sec != NULL && sec->id <= htab->top_id)
10938
            relocation += htab->stub_group[sec->id].toc_off;
10939
          else
10940
            unresolved_reloc = TRUE;
10941
          goto dodyn;
10942
 
10943
          /* TOC16 relocs.  We want the offset relative to the TOC base,
10944
             which is the address of the start of the TOC plus 0x8000.
10945
             The TOC consists of sections .got, .toc, .tocbss, and .plt,
10946
             in this order.  */
10947
        case R_PPC64_TOC16:
10948
        case R_PPC64_TOC16_LO:
10949
        case R_PPC64_TOC16_HI:
10950
        case R_PPC64_TOC16_DS:
10951
        case R_PPC64_TOC16_LO_DS:
10952
        case R_PPC64_TOC16_HA:
10953
          addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
10954
          break;
10955
 
10956
          /* Relocate against the beginning of the section.  */
10957
        case R_PPC64_SECTOFF:
10958
        case R_PPC64_SECTOFF_LO:
10959
        case R_PPC64_SECTOFF_HI:
10960
        case R_PPC64_SECTOFF_DS:
10961
        case R_PPC64_SECTOFF_LO_DS:
10962
        case R_PPC64_SECTOFF_HA:
10963
          if (sec != NULL)
10964
            addend -= sec->output_section->vma;
10965
          break;
10966
 
10967
        case R_PPC64_REL14:
10968
        case R_PPC64_REL14_BRNTAKEN:
10969
        case R_PPC64_REL14_BRTAKEN:
10970
        case R_PPC64_REL24:
10971
          break;
10972
 
10973
        case R_PPC64_TPREL16:
10974
        case R_PPC64_TPREL16_LO:
10975
        case R_PPC64_TPREL16_HI:
10976
        case R_PPC64_TPREL16_HA:
10977
        case R_PPC64_TPREL16_DS:
10978
        case R_PPC64_TPREL16_LO_DS:
10979
        case R_PPC64_TPREL16_HIGHER:
10980
        case R_PPC64_TPREL16_HIGHERA:
10981
        case R_PPC64_TPREL16_HIGHEST:
10982
        case R_PPC64_TPREL16_HIGHESTA:
10983
          addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10984
          if (info->shared)
10985
            /* The TPREL16 relocs shouldn't really be used in shared
10986
               libs as they will result in DT_TEXTREL being set, but
10987
               support them anyway.  */
10988
            goto dodyn;
10989
          break;
10990
 
10991
        case R_PPC64_DTPREL16:
10992
        case R_PPC64_DTPREL16_LO:
10993
        case R_PPC64_DTPREL16_HI:
10994
        case R_PPC64_DTPREL16_HA:
10995
        case R_PPC64_DTPREL16_DS:
10996
        case R_PPC64_DTPREL16_LO_DS:
10997
        case R_PPC64_DTPREL16_HIGHER:
10998
        case R_PPC64_DTPREL16_HIGHERA:
10999
        case R_PPC64_DTPREL16_HIGHEST:
11000
        case R_PPC64_DTPREL16_HIGHESTA:
11001
          addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11002
          break;
11003
 
11004
        case R_PPC64_DTPMOD64:
11005
          relocation = 1;
11006
          addend = 0;
11007
          goto dodyn;
11008
 
11009
        case R_PPC64_TPREL64:
11010
          addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11011
          goto dodyn;
11012
 
11013
        case R_PPC64_DTPREL64:
11014
          addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11015
          /* Fall thru */
11016
 
11017
          /* Relocations that may need to be propagated if this is a
11018
             dynamic object.  */
11019
        case R_PPC64_REL30:
11020
        case R_PPC64_REL32:
11021
        case R_PPC64_REL64:
11022
        case R_PPC64_ADDR14:
11023
        case R_PPC64_ADDR14_BRNTAKEN:
11024
        case R_PPC64_ADDR14_BRTAKEN:
11025
        case R_PPC64_ADDR16:
11026
        case R_PPC64_ADDR16_DS:
11027
        case R_PPC64_ADDR16_HA:
11028
        case R_PPC64_ADDR16_HI:
11029
        case R_PPC64_ADDR16_HIGHER:
11030
        case R_PPC64_ADDR16_HIGHERA:
11031
        case R_PPC64_ADDR16_HIGHEST:
11032
        case R_PPC64_ADDR16_HIGHESTA:
11033
        case R_PPC64_ADDR16_LO:
11034
        case R_PPC64_ADDR16_LO_DS:
11035
        case R_PPC64_ADDR24:
11036
        case R_PPC64_ADDR32:
11037
        case R_PPC64_ADDR64:
11038
        case R_PPC64_UADDR16:
11039
        case R_PPC64_UADDR32:
11040
        case R_PPC64_UADDR64:
11041
        dodyn:
11042
          if ((input_section->flags & SEC_ALLOC) == 0)
11043
            break;
11044
 
11045
          if (NO_OPD_RELOCS && is_opd)
11046
            break;
11047
 
11048
          if ((info->shared
11049
               && (h == NULL
11050
                   || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11051
                   || h->elf.root.type != bfd_link_hash_undefweak)
11052
               && (MUST_BE_DYN_RELOC (r_type)
11053
                   || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
11054
              || (ELIMINATE_COPY_RELOCS
11055
                  && !info->shared
11056
                  && h != NULL
11057
                  && h->elf.dynindx != -1
11058
                  && !h->elf.non_got_ref
11059
                  && h->elf.def_dynamic
11060
                  && !h->elf.def_regular))
11061
            {
11062
              Elf_Internal_Rela outrel;
11063
              bfd_boolean skip, relocate;
11064
              asection *sreloc;
11065
              bfd_byte *loc;
11066
              bfd_vma out_off;
11067
 
11068
              /* When generating a dynamic object, these relocations
11069
                 are copied into the output file to be resolved at run
11070
                 time.  */
11071
 
11072
              skip = FALSE;
11073
              relocate = FALSE;
11074
 
11075
              out_off = _bfd_elf_section_offset (output_bfd, info,
11076
                                                 input_section, rel->r_offset);
11077
              if (out_off == (bfd_vma) -1)
11078
                skip = TRUE;
11079
              else if (out_off == (bfd_vma) -2)
11080
                skip = TRUE, relocate = TRUE;
11081
              out_off += (input_section->output_section->vma
11082
                          + input_section->output_offset);
11083
              outrel.r_offset = out_off;
11084
              outrel.r_addend = rel->r_addend;
11085
 
11086
              /* Optimize unaligned reloc use.  */
11087
              if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
11088
                  || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
11089
                r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
11090
              else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
11091
                       || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
11092
                r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
11093
              else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
11094
                       || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
11095
                r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
11096
 
11097
              if (skip)
11098
                memset (&outrel, 0, sizeof outrel);
11099
              else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
11100
                       && !is_opd
11101
                       && r_type != R_PPC64_TOC)
11102
                outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
11103
              else
11104
                {
11105
                  /* This symbol is local, or marked to become local,
11106
                     or this is an opd section reloc which must point
11107
                     at a local function.  */
11108
                  outrel.r_addend += relocation;
11109
                  if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
11110
                    {
11111
                      if (is_opd && h != NULL)
11112
                        {
11113
                          /* Lie about opd entries.  This case occurs
11114
                             when building shared libraries and we
11115
                             reference a function in another shared
11116
                             lib.  The same thing happens for a weak
11117
                             definition in an application that's
11118
                             overridden by a strong definition in a
11119
                             shared lib.  (I believe this is a generic
11120
                             bug in binutils handling of weak syms.)
11121
                             In these cases we won't use the opd
11122
                             entry in this lib.  */
11123
                          unresolved_reloc = FALSE;
11124
                        }
11125
                      outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11126
 
11127
                      /* We need to relocate .opd contents for ld.so.
11128
                         Prelink also wants simple and consistent rules
11129
                         for relocs.  This make all RELATIVE relocs have
11130
                         *r_offset equal to r_addend.  */
11131
                      relocate = TRUE;
11132
                    }
11133
                  else
11134
                    {
11135
                      long indx = 0;
11136
 
11137
                      if (bfd_is_abs_section (sec))
11138
                        ;
11139
                      else if (sec == NULL || sec->owner == NULL)
11140
                        {
11141
                          bfd_set_error (bfd_error_bad_value);
11142
                          return FALSE;
11143
                        }
11144
                      else
11145
                        {
11146
                          asection *osec;
11147
 
11148
                          osec = sec->output_section;
11149
                          indx = elf_section_data (osec)->dynindx;
11150
 
11151
                          if (indx == 0)
11152
                            {
11153
                              if ((osec->flags & SEC_READONLY) == 0
11154
                                  && htab->elf.data_index_section != NULL)
11155
                                osec = htab->elf.data_index_section;
11156
                              else
11157
                                osec = htab->elf.text_index_section;
11158
                              indx = elf_section_data (osec)->dynindx;
11159
                            }
11160
                          BFD_ASSERT (indx != 0);
11161
 
11162
                          /* We are turning this relocation into one
11163
                             against a section symbol, so subtract out
11164
                             the output section's address but not the
11165
                             offset of the input section in the output
11166
                             section.  */
11167
                          outrel.r_addend -= osec->vma;
11168
                        }
11169
 
11170
                      outrel.r_info = ELF64_R_INFO (indx, r_type);
11171
                    }
11172
                }
11173
 
11174
              sreloc = elf_section_data (input_section)->sreloc;
11175
              if (sreloc == NULL)
11176
                abort ();
11177
 
11178
              if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
11179
                  >= sreloc->size)
11180
                abort ();
11181
              loc = sreloc->contents;
11182
              loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
11183
              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11184
 
11185
              /* If this reloc is against an external symbol, it will
11186
                 be computed at runtime, so there's no need to do
11187
                 anything now.  However, for the sake of prelink ensure
11188
                 that the section contents are a known value.  */
11189
              if (! relocate)
11190
                {
11191
                  unresolved_reloc = FALSE;
11192
                  /* The value chosen here is quite arbitrary as ld.so
11193
                     ignores section contents except for the special
11194
                     case of .opd where the contents might be accessed
11195
                     before relocation.  Choose zero, as that won't
11196
                     cause reloc overflow.  */
11197
                  relocation = 0;
11198
                  addend = 0;
11199
                  /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
11200
                     to improve backward compatibility with older
11201
                     versions of ld.  */
11202
                  if (r_type == R_PPC64_ADDR64)
11203
                    addend = outrel.r_addend;
11204
                  /* Adjust pc_relative relocs to have zero in *r_offset.  */
11205
                  else if (ppc64_elf_howto_table[r_type]->pc_relative)
11206
                    addend = (input_section->output_section->vma
11207
                              + input_section->output_offset
11208
                              + rel->r_offset);
11209
                }
11210
            }
11211
          break;
11212
 
11213
        case R_PPC64_COPY:
11214
        case R_PPC64_GLOB_DAT:
11215
        case R_PPC64_JMP_SLOT:
11216
        case R_PPC64_RELATIVE:
11217
          /* We shouldn't ever see these dynamic relocs in relocatable
11218
             files.  */
11219
          /* Fall through.  */
11220
 
11221
        case R_PPC64_PLTGOT16:
11222
        case R_PPC64_PLTGOT16_DS:
11223
        case R_PPC64_PLTGOT16_HA:
11224
        case R_PPC64_PLTGOT16_HI:
11225
        case R_PPC64_PLTGOT16_LO:
11226
        case R_PPC64_PLTGOT16_LO_DS:
11227
        case R_PPC64_PLTREL32:
11228
        case R_PPC64_PLTREL64:
11229
          /* These ones haven't been implemented yet.  */
11230
 
11231
          (*_bfd_error_handler)
11232
            (_("%B: relocation %s is not supported for symbol %s."),
11233
             input_bfd,
11234
             ppc64_elf_howto_table[r_type]->name, sym_name);
11235
 
11236
          bfd_set_error (bfd_error_invalid_operation);
11237
          ret = FALSE;
11238
          continue;
11239
        }
11240
 
11241
      /* Do any further special processing.  */
11242
      switch (r_type)
11243
        {
11244
        default:
11245
          break;
11246
 
11247
        case R_PPC64_ADDR16_HA:
11248
        case R_PPC64_ADDR16_HIGHERA:
11249
        case R_PPC64_ADDR16_HIGHESTA:
11250
        case R_PPC64_TOC16_HA:
11251
        case R_PPC64_SECTOFF_HA:
11252
        case R_PPC64_TPREL16_HA:
11253
        case R_PPC64_DTPREL16_HA:
11254
        case R_PPC64_TPREL16_HIGHER:
11255
        case R_PPC64_TPREL16_HIGHERA:
11256
        case R_PPC64_TPREL16_HIGHEST:
11257
        case R_PPC64_TPREL16_HIGHESTA:
11258
        case R_PPC64_DTPREL16_HIGHER:
11259
        case R_PPC64_DTPREL16_HIGHERA:
11260
        case R_PPC64_DTPREL16_HIGHEST:
11261
        case R_PPC64_DTPREL16_HIGHESTA:
11262
          /* It's just possible that this symbol is a weak symbol
11263
             that's not actually defined anywhere. In that case,
11264
             'sec' would be NULL, and we should leave the symbol
11265
             alone (it will be set to zero elsewhere in the link).  */
11266
          if (sec == NULL)
11267
            break;
11268
          /* Fall thru */
11269
 
11270
        case R_PPC64_GOT16_HA:
11271
        case R_PPC64_PLTGOT16_HA:
11272
        case R_PPC64_PLT16_HA:
11273
        case R_PPC64_GOT_TLSGD16_HA:
11274
        case R_PPC64_GOT_TLSLD16_HA:
11275
        case R_PPC64_GOT_TPREL16_HA:
11276
        case R_PPC64_GOT_DTPREL16_HA:
11277
          /* Add 0x10000 if sign bit in 0:15 is set.
11278
             Bits 0:15 are not used.  */
11279
          addend += 0x8000;
11280
          break;
11281
 
11282
        case R_PPC64_ADDR16_DS:
11283
        case R_PPC64_ADDR16_LO_DS:
11284
        case R_PPC64_GOT16_DS:
11285
        case R_PPC64_GOT16_LO_DS:
11286
        case R_PPC64_PLT16_LO_DS:
11287
        case R_PPC64_SECTOFF_DS:
11288
        case R_PPC64_SECTOFF_LO_DS:
11289
        case R_PPC64_TOC16_DS:
11290
        case R_PPC64_TOC16_LO_DS:
11291
        case R_PPC64_PLTGOT16_DS:
11292
        case R_PPC64_PLTGOT16_LO_DS:
11293
        case R_PPC64_GOT_TPREL16_DS:
11294
        case R_PPC64_GOT_TPREL16_LO_DS:
11295
        case R_PPC64_GOT_DTPREL16_DS:
11296
        case R_PPC64_GOT_DTPREL16_LO_DS:
11297
        case R_PPC64_TPREL16_DS:
11298
        case R_PPC64_TPREL16_LO_DS:
11299
        case R_PPC64_DTPREL16_DS:
11300
        case R_PPC64_DTPREL16_LO_DS:
11301
          insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
11302
          mask = 3;
11303
          /* If this reloc is against an lq insn, then the value must be
11304
             a multiple of 16.  This is somewhat of a hack, but the
11305
             "correct" way to do this by defining _DQ forms of all the
11306
             _DS relocs bloats all reloc switches in this file.  It
11307
             doesn't seem to make much sense to use any of these relocs
11308
             in data, so testing the insn should be safe.  */
11309
          if ((insn & (0x3f << 26)) == (56u << 26))
11310
            mask = 15;
11311
          if (((relocation + addend) & mask) != 0)
11312
            {
11313
              (*_bfd_error_handler)
11314
                (_("%B: error: relocation %s not a multiple of %d"),
11315
                 input_bfd,
11316
                 ppc64_elf_howto_table[r_type]->name,
11317
                 mask + 1);
11318
              bfd_set_error (bfd_error_bad_value);
11319
              ret = FALSE;
11320
              continue;
11321
            }
11322
          break;
11323
        }
11324
 
11325
      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11326
         because such sections are not SEC_ALLOC and thus ld.so will
11327
         not process them.  */
11328
      if (unresolved_reloc
11329
          && !((input_section->flags & SEC_DEBUGGING) != 0
11330
               && h->elf.def_dynamic))
11331
        {
11332
          (*_bfd_error_handler)
11333
            (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11334
             input_bfd,
11335
             input_section,
11336
             (long) rel->r_offset,
11337
             ppc64_elf_howto_table[(int) r_type]->name,
11338
             h->elf.root.root.string);
11339
          ret = FALSE;
11340
        }
11341
 
11342
      r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
11343
                                    input_bfd,
11344
                                    input_section,
11345
                                    contents,
11346
                                    rel->r_offset,
11347
                                    relocation,
11348
                                    addend);
11349
 
11350
      if (r != bfd_reloc_ok)
11351
        {
11352
          if (sym_name == NULL)
11353
            sym_name = "(null)";
11354
          if (r == bfd_reloc_overflow)
11355
            {
11356
              if (warned)
11357
                continue;
11358
              if (h != NULL
11359
                  && h->elf.root.type == bfd_link_hash_undefweak
11360
                  && ppc64_elf_howto_table[r_type]->pc_relative)
11361
                {
11362
                  /* Assume this is a call protected by other code that
11363
                     detects the symbol is undefined.  If this is the case,
11364
                     we can safely ignore the overflow.  If not, the
11365
                     program is hosed anyway, and a little warning isn't
11366
                     going to help.  */
11367
 
11368
                  continue;
11369
                }
11370
 
11371
              if (!((*info->callbacks->reloc_overflow)
11372
                    (info, (h ? &h->elf.root : NULL), sym_name,
11373
                     ppc64_elf_howto_table[r_type]->name,
11374
                     orig_addend, input_bfd, input_section, rel->r_offset)))
11375
                return FALSE;
11376
            }
11377
          else
11378
            {
11379
              (*_bfd_error_handler)
11380
                (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11381
                 input_bfd,
11382
                 input_section,
11383
                 (long) rel->r_offset,
11384
                 ppc64_elf_howto_table[r_type]->name,
11385
                 sym_name,
11386
                 (int) r);
11387
              ret = FALSE;
11388
            }
11389
        }
11390
    }
11391
 
11392
  /* If we're emitting relocations, then shortly after this function
11393
     returns, reloc offsets and addends for this section will be
11394
     adjusted.  Worse, reloc symbol indices will be for the output
11395
     file rather than the input.  Save a copy of the relocs for
11396
     opd_entry_value.  */
11397
  if (is_opd && (info->emitrelocations || info->relocatable))
11398
    {
11399
      bfd_size_type amt;
11400
      amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11401
      rel = bfd_alloc (input_bfd, amt);
11402
      BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11403
      ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11404
      if (rel == NULL)
11405
        return FALSE;
11406
      memcpy (rel, relocs, amt);
11407
    }
11408
  return ret;
11409
}
11410
 
11411
/* Adjust the value of any local symbols in opd sections.  */
11412
 
11413
static bfd_boolean
11414
ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11415
                              const char *name ATTRIBUTE_UNUSED,
11416
                              Elf_Internal_Sym *elfsym,
11417
                              asection *input_sec,
11418
                              struct elf_link_hash_entry *h)
11419
{
11420
  struct _opd_sec_data *opd;
11421
  long adjust;
11422
  bfd_vma value;
11423
 
11424
  if (h != NULL)
11425
    return TRUE;
11426
 
11427
  opd = get_opd_info (input_sec);
11428
  if (opd == NULL || opd->adjust == NULL)
11429
    return TRUE;
11430
 
11431
  value = elfsym->st_value - input_sec->output_offset;
11432
  if (!info->relocatable)
11433
    value -= input_sec->output_section->vma;
11434
 
11435
  adjust = opd->adjust[value / 8];
11436
  if (adjust == -1)
11437
    elfsym->st_value = 0;
11438
  else
11439
    elfsym->st_value += adjust;
11440
  return TRUE;
11441
}
11442
 
11443
/* Finish up dynamic symbol handling.  We set the contents of various
11444
   dynamic sections here.  */
11445
 
11446
static bfd_boolean
11447
ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
11448
                                 struct bfd_link_info *info,
11449
                                 struct elf_link_hash_entry *h,
11450
                                 Elf_Internal_Sym *sym)
11451
{
11452
  struct ppc_link_hash_table *htab;
11453
  struct plt_entry *ent;
11454
  Elf_Internal_Rela rela;
11455
  bfd_byte *loc;
11456
 
11457
  htab = ppc_hash_table (info);
11458
 
11459
  for (ent = h->plt.plist; ent != NULL; ent = ent->next)
11460
    if (ent->plt.offset != (bfd_vma) -1)
11461
      {
11462
        /* This symbol has an entry in the procedure linkage
11463
           table.  Set it up.  */
11464
 
11465
        if (htab->plt == NULL
11466
            || htab->relplt == NULL
11467
            || htab->glink == NULL)
11468
          abort ();
11469
 
11470
        /* Create a JMP_SLOT reloc to inform the dynamic linker to
11471
           fill in the PLT entry.  */
11472
        rela.r_offset = (htab->plt->output_section->vma
11473
                         + htab->plt->output_offset
11474
                         + ent->plt.offset);
11475
        rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
11476
        rela.r_addend = ent->addend;
11477
 
11478
        loc = htab->relplt->contents;
11479
        loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
11480
                * sizeof (Elf64_External_Rela));
11481
        bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11482
      }
11483
 
11484
  if (h->needs_copy)
11485
    {
11486
      Elf_Internal_Rela rela;
11487
      bfd_byte *loc;
11488
 
11489
      /* This symbol needs a copy reloc.  Set it up.  */
11490
 
11491
      if (h->dynindx == -1
11492
          || (h->root.type != bfd_link_hash_defined
11493
              && h->root.type != bfd_link_hash_defweak)
11494
          || htab->relbss == NULL)
11495
        abort ();
11496
 
11497
      rela.r_offset = (h->root.u.def.value
11498
                       + h->root.u.def.section->output_section->vma
11499
                       + h->root.u.def.section->output_offset);
11500
      rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
11501
      rela.r_addend = 0;
11502
      loc = htab->relbss->contents;
11503
      loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
11504
      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11505
    }
11506
 
11507
  /* Mark some specially defined symbols as absolute.  */
11508
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
11509
    sym->st_shndx = SHN_ABS;
11510
 
11511
  return TRUE;
11512
}
11513
 
11514
/* Used to decide how to sort relocs in an optimal manner for the
11515
   dynamic linker, before writing them out.  */
11516
 
11517
static enum elf_reloc_type_class
11518
ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
11519
{
11520
  enum elf_ppc64_reloc_type r_type;
11521
 
11522
  r_type = ELF64_R_TYPE (rela->r_info);
11523
  switch (r_type)
11524
    {
11525
    case R_PPC64_RELATIVE:
11526
      return reloc_class_relative;
11527
    case R_PPC64_JMP_SLOT:
11528
      return reloc_class_plt;
11529
    case R_PPC64_COPY:
11530
      return reloc_class_copy;
11531
    default:
11532
      return reloc_class_normal;
11533
    }
11534
}
11535
 
11536
/* Finish up the dynamic sections.  */
11537
 
11538
static bfd_boolean
11539
ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
11540
                                   struct bfd_link_info *info)
11541
{
11542
  struct ppc_link_hash_table *htab;
11543
  bfd *dynobj;
11544
  asection *sdyn;
11545
 
11546
  htab = ppc_hash_table (info);
11547
  dynobj = htab->elf.dynobj;
11548
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11549
 
11550
  if (htab->elf.dynamic_sections_created)
11551
    {
11552
      Elf64_External_Dyn *dyncon, *dynconend;
11553
 
11554
      if (sdyn == NULL || htab->got == NULL)
11555
        abort ();
11556
 
11557
      dyncon = (Elf64_External_Dyn *) sdyn->contents;
11558
      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
11559
      for (; dyncon < dynconend; dyncon++)
11560
        {
11561
          Elf_Internal_Dyn dyn;
11562
          asection *s;
11563
 
11564
          bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
11565
 
11566
          switch (dyn.d_tag)
11567
            {
11568
            default:
11569
              continue;
11570
 
11571
            case DT_PPC64_GLINK:
11572
              s = htab->glink;
11573
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11574
              /* We stupidly defined DT_PPC64_GLINK to be the start
11575
                 of glink rather than the first entry point, which is
11576
                 what ld.so needs, and now have a bigger stub to
11577
                 support automatic multiple TOCs.  */
11578
              dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
11579
              break;
11580
 
11581
            case DT_PPC64_OPD:
11582
              s = bfd_get_section_by_name (output_bfd, ".opd");
11583
              if (s == NULL)
11584
                continue;
11585
              dyn.d_un.d_ptr = s->vma;
11586
              break;
11587
 
11588
            case DT_PPC64_OPDSZ:
11589
              s = bfd_get_section_by_name (output_bfd, ".opd");
11590
              if (s == NULL)
11591
                continue;
11592
              dyn.d_un.d_val = s->size;
11593
              break;
11594
 
11595
            case DT_PLTGOT:
11596
              s = htab->plt;
11597
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11598
              break;
11599
 
11600
            case DT_JMPREL:
11601
              s = htab->relplt;
11602
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11603
              break;
11604
 
11605
            case DT_PLTRELSZ:
11606
              dyn.d_un.d_val = htab->relplt->size;
11607
              break;
11608
 
11609
            case DT_RELASZ:
11610
              /* Don't count procedure linkage table relocs in the
11611
                 overall reloc count.  */
11612
              s = htab->relplt;
11613
              if (s == NULL)
11614
                continue;
11615
              dyn.d_un.d_val -= s->size;
11616
              break;
11617
 
11618
            case DT_RELA:
11619
              /* We may not be using the standard ELF linker script.
11620
                 If .rela.plt is the first .rela section, we adjust
11621
                 DT_RELA to not include it.  */
11622
              s = htab->relplt;
11623
              if (s == NULL)
11624
                continue;
11625
              if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
11626
                continue;
11627
              dyn.d_un.d_ptr += s->size;
11628
              break;
11629
            }
11630
 
11631
          bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
11632
        }
11633
    }
11634
 
11635
  if (htab->got != NULL && htab->got->size != 0)
11636
    {
11637
      /* Fill in the first entry in the global offset table.
11638
         We use it to hold the link-time TOCbase.  */
11639
      bfd_put_64 (output_bfd,
11640
                  elf_gp (output_bfd) + TOC_BASE_OFF,
11641
                  htab->got->contents);
11642
 
11643
      /* Set .got entry size.  */
11644
      elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
11645
    }
11646
 
11647
  if (htab->plt != NULL && htab->plt->size != 0)
11648
    {
11649
      /* Set .plt entry size.  */
11650
      elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
11651
        = PLT_ENTRY_SIZE;
11652
    }
11653
 
11654
  /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
11655
     brlt ourselves if emitrelocations.  */
11656
  if (htab->brlt != NULL
11657
      && htab->brlt->reloc_count != 0
11658
      && !_bfd_elf_link_output_relocs (output_bfd,
11659
                                       htab->brlt,
11660
                                       &elf_section_data (htab->brlt)->rel_hdr,
11661
                                       elf_section_data (htab->brlt)->relocs,
11662
                                       NULL))
11663
    return FALSE;
11664
 
11665
  if (htab->glink != NULL
11666
      && htab->glink->reloc_count != 0
11667
      && !_bfd_elf_link_output_relocs (output_bfd,
11668
                                       htab->glink,
11669
                                       &elf_section_data (htab->glink)->rel_hdr,
11670
                                       elf_section_data (htab->glink)->relocs,
11671
                                       NULL))
11672
    return FALSE;
11673
 
11674
  /* We need to handle writing out multiple GOT sections ourselves,
11675
     since we didn't add them to DYNOBJ.  We know dynobj is the first
11676
     bfd.  */
11677
  while ((dynobj = dynobj->link_next) != NULL)
11678
    {
11679
      asection *s;
11680
 
11681
      if (!is_ppc64_elf (dynobj))
11682
        continue;
11683
 
11684
      s = ppc64_elf_tdata (dynobj)->got;
11685
      if (s != NULL
11686
          && s->size != 0
11687
          && s->output_section != bfd_abs_section_ptr
11688
          && !bfd_set_section_contents (output_bfd, s->output_section,
11689
                                        s->contents, s->output_offset,
11690
                                        s->size))
11691
        return FALSE;
11692
      s = ppc64_elf_tdata (dynobj)->relgot;
11693
      if (s != NULL
11694
          && s->size != 0
11695
          && s->output_section != bfd_abs_section_ptr
11696
          && !bfd_set_section_contents (output_bfd, s->output_section,
11697
                                        s->contents, s->output_offset,
11698
                                        s->size))
11699
        return FALSE;
11700
    }
11701
 
11702
  return TRUE;
11703
}
11704
 
11705
#include "elf64-target.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.