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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elf64-ppc.c] - Blame information for rev 298

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

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

powered by: WebSVN 2.1.0

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