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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [elf32-ppc.c] - Blame information for rev 841

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* PowerPC-specific support for 32-bit ELF
2
   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3
   2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor, Cygnus Support.
5
 
6
   This file is part of BFD, the Binary File Descriptor library.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the
20
   Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
21
   Boston, MA 02110-1301, USA.  */
22
 
23
 
24
/* This file is based on a preliminary PowerPC ELF ABI.  The
25
   information may not match the final PowerPC ELF ABI.  It includes
26
   suggestions from the in-progress Embedded PowerPC ABI, and that
27
   information may also not match.  */
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/ppc.h"
36
#include "elf32-ppc.h"
37
#include "elf-vxworks.h"
38
 
39
/* RELA relocations are used here.  */
40
 
41
static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
42
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43
static bfd_reloc_status_type ppc_elf_unhandled_reloc
44
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
45
 
46
/* Branch prediction bit for branch taken relocs.  */
47
#define BRANCH_PREDICT_BIT 0x200000
48
/* Mask to set RA in memory instructions.  */
49
#define RA_REGISTER_MASK 0x001f0000
50
/* Value to shift register by to insert RA.  */
51
#define RA_REGISTER_SHIFT 16
52
 
53
/* The name of the dynamic interpreter.  This is put in the .interp
54
   section.  */
55
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
56
 
57
/* For old-style PLT.  */
58
/* The number of single-slot PLT entries (the rest use two slots).  */
59
#define PLT_NUM_SINGLE_ENTRIES 8192
60
 
61
/* For new-style .glink and .plt.  */
62
#define GLINK_PLTRESOLVE 16*4
63
#define GLINK_ENTRY_SIZE 4*4
64
#define TLS_GET_ADDR_GLINK_SIZE 12*4
65
 
66
/* VxWorks uses its own plt layout, filled in by the static linker.  */
67
 
68
/* The standard VxWorks PLT entry.  */
69
#define VXWORKS_PLT_ENTRY_SIZE 32
70
static const bfd_vma ppc_elf_vxworks_plt_entry
71
    [VXWORKS_PLT_ENTRY_SIZE / 4] =
72
  {
73
    0x3d800000, /* lis     r12,0                 */
74
    0x818c0000, /* lwz     r12,0(r12)            */
75
    0x7d8903a6, /* mtctr   r12                   */
76
    0x4e800420, /* bctr                          */
77
    0x39600000, /* li      r11,0                 */
78
    0x48000000, /* b       14 <.PLT0resolve+0x4> */
79
    0x60000000, /* nop                           */
80
    0x60000000, /* nop                           */
81
  };
82
static const bfd_vma ppc_elf_vxworks_pic_plt_entry
83
    [VXWORKS_PLT_ENTRY_SIZE / 4] =
84
  {
85
    0x3d9e0000, /* addis r12,r30,0 */
86
    0x818c0000, /* lwz   r12,0(r12) */
87
    0x7d8903a6, /* mtctr r12 */
88
    0x4e800420, /* bctr */
89
    0x39600000, /* li    r11,0 */
90
    0x48000000, /* b     14 <.PLT0resolve+0x4> 14: R_PPC_REL24 .PLTresolve */
91
    0x60000000, /* nop */
92
    0x60000000, /* nop */
93
  };
94
 
95
/* The initial VxWorks PLT entry.  */
96
#define VXWORKS_PLT_INITIAL_ENTRY_SIZE 32
97
static const bfd_vma ppc_elf_vxworks_plt0_entry
98
    [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] =
99
  {
100
    0x3d800000, /* lis     r12,0        */
101
    0x398c0000, /* addi    r12,r12,0    */
102
    0x800c0008, /* lwz     r0,8(r12)    */
103
    0x7c0903a6, /* mtctr   r0           */
104
    0x818c0004, /* lwz     r12,4(r12)   */
105
    0x4e800420, /* bctr                 */
106
    0x60000000, /* nop                  */
107
    0x60000000, /* nop                  */
108
  };
109
static const bfd_vma ppc_elf_vxworks_pic_plt0_entry
110
    [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] =
111
  {
112
    0x819e0008, /* lwz   r12,8(r30) */
113
    0x7d8903a6, /* mtctr r12        */
114
    0x819e0004, /* lwz   r12,4(r30) */
115
    0x4e800420, /* bctr             */
116
    0x60000000, /* nop              */
117
    0x60000000, /* nop              */
118
    0x60000000, /* nop              */
119
    0x60000000, /* nop              */
120
  };
121
 
122
/* For executables, we have some additional relocations in
123
   .rela.plt.unloaded, for the kernel loader.  */
124
 
125
/* The number of non-JMP_SLOT relocations per PLT0 slot. */
126
#define VXWORKS_PLT_NON_JMP_SLOT_RELOCS 3
127
/* The number of relocations in the PLTResolve slot. */
128
#define VXWORKS_PLTRESOLVE_RELOCS 2
129
/* The number of relocations in the PLTResolve slot when when creating
130
   a shared library. */
131
#define VXWORKS_PLTRESOLVE_RELOCS_SHLIB 0
132
 
133
/* Some instructions.  */
134
#define ADDIS_11_11     0x3d6b0000
135
#define ADDIS_11_30     0x3d7e0000
136
#define ADDIS_12_12     0x3d8c0000
137
#define ADDI_11_11      0x396b0000
138
#define ADD_0_11_11     0x7c0b5a14
139
#define ADD_3_12_2      0x7c6c1214
140
#define ADD_11_0_11     0x7d605a14
141
#define B               0x48000000
142
#define BCL_20_31       0x429f0005
143
#define BCTR            0x4e800420
144
#define BEQLR           0x4d820020
145
#define CMPWI_11_0      0x2c0b0000
146
#define LIS_11          0x3d600000
147
#define LIS_12          0x3d800000
148
#define LWZU_0_12       0x840c0000
149
#define LWZ_0_12        0x800c0000
150
#define LWZ_11_3        0x81630000
151
#define LWZ_11_11       0x816b0000
152
#define LWZ_11_30       0x817e0000
153
#define LWZ_12_3        0x81830000
154
#define LWZ_12_12       0x818c0000
155
#define MR_0_3          0x7c601b78
156
#define MR_3_0          0x7c030378
157
#define MFLR_0          0x7c0802a6
158
#define MFLR_12         0x7d8802a6
159
#define MTCTR_0         0x7c0903a6
160
#define MTCTR_11        0x7d6903a6
161
#define MTLR_0          0x7c0803a6
162
#define NOP             0x60000000
163
#define SUB_11_11_12    0x7d6c5850
164
 
165
/* Offset of tp and dtp pointers from start of TLS block.  */
166
#define TP_OFFSET       0x7000
167
#define DTP_OFFSET      0x8000
168
 
169
/* The value of a defined global symbol.  */
170
#define SYM_VAL(SYM) \
171
  ((SYM)->root.u.def.section->output_section->vma       \
172
   + (SYM)->root.u.def.section->output_offset           \
173
   + (SYM)->root.u.def.value)
174
 
175
static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
176
 
177
static reloc_howto_type ppc_elf_howto_raw[] = {
178
  /* This reloc does nothing.  */
179
  HOWTO (R_PPC_NONE,            /* type */
180
         0,                      /* rightshift */
181
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
182
         32,                    /* bitsize */
183
         FALSE,                 /* pc_relative */
184
         0,                      /* bitpos */
185
         complain_overflow_bitfield, /* complain_on_overflow */
186
         bfd_elf_generic_reloc, /* special_function */
187
         "R_PPC_NONE",          /* name */
188
         FALSE,                 /* partial_inplace */
189
         0,                      /* src_mask */
190
         0,                      /* dst_mask */
191
         FALSE),                /* pcrel_offset */
192
 
193
  /* A standard 32 bit relocation.  */
194
  HOWTO (R_PPC_ADDR32,          /* type */
195
         0,                      /* rightshift */
196
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
197
         32,                    /* bitsize */
198
         FALSE,                 /* pc_relative */
199
         0,                      /* bitpos */
200
         complain_overflow_bitfield, /* complain_on_overflow */
201
         bfd_elf_generic_reloc, /* special_function */
202
         "R_PPC_ADDR32",        /* name */
203
         FALSE,                 /* partial_inplace */
204
         0,                      /* src_mask */
205
         0xffffffff,            /* dst_mask */
206
         FALSE),                /* pcrel_offset */
207
 
208
  /* An absolute 26 bit branch; the lower two bits must be zero.
209
     FIXME: we don't check that, we just clear them.  */
210
  HOWTO (R_PPC_ADDR24,          /* type */
211
         0,                      /* rightshift */
212
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
213
         26,                    /* bitsize */
214
         FALSE,                 /* pc_relative */
215
         0,                      /* bitpos */
216
         complain_overflow_bitfield, /* complain_on_overflow */
217
         bfd_elf_generic_reloc, /* special_function */
218
         "R_PPC_ADDR24",        /* name */
219
         FALSE,                 /* partial_inplace */
220
         0,                      /* src_mask */
221
         0x3fffffc,             /* dst_mask */
222
         FALSE),                /* pcrel_offset */
223
 
224
  /* A standard 16 bit relocation.  */
225
  HOWTO (R_PPC_ADDR16,          /* type */
226
         0,                      /* rightshift */
227
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
228
         16,                    /* bitsize */
229
         FALSE,                 /* pc_relative */
230
         0,                      /* bitpos */
231
         complain_overflow_bitfield, /* complain_on_overflow */
232
         bfd_elf_generic_reloc, /* special_function */
233
         "R_PPC_ADDR16",        /* name */
234
         FALSE,                 /* partial_inplace */
235
         0,                      /* src_mask */
236
         0xffff,                /* dst_mask */
237
         FALSE),                /* pcrel_offset */
238
 
239
  /* A 16 bit relocation without overflow.  */
240
  HOWTO (R_PPC_ADDR16_LO,       /* type */
241
         0,                      /* rightshift */
242
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
243
         16,                    /* bitsize */
244
         FALSE,                 /* pc_relative */
245
         0,                      /* bitpos */
246
         complain_overflow_dont,/* complain_on_overflow */
247
         bfd_elf_generic_reloc, /* special_function */
248
         "R_PPC_ADDR16_LO",     /* name */
249
         FALSE,                 /* partial_inplace */
250
         0,                      /* src_mask */
251
         0xffff,                /* dst_mask */
252
         FALSE),                /* pcrel_offset */
253
 
254
  /* The high order 16 bits of an address.  */
255
  HOWTO (R_PPC_ADDR16_HI,       /* type */
256
         16,                    /* rightshift */
257
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
258
         16,                    /* bitsize */
259
         FALSE,                 /* pc_relative */
260
         0,                      /* bitpos */
261
         complain_overflow_dont, /* complain_on_overflow */
262
         bfd_elf_generic_reloc, /* special_function */
263
         "R_PPC_ADDR16_HI",     /* name */
264
         FALSE,                 /* partial_inplace */
265
         0,                      /* src_mask */
266
         0xffff,                /* dst_mask */
267
         FALSE),                /* pcrel_offset */
268
 
269
  /* The high order 16 bits of an address, plus 1 if the contents of
270
     the low 16 bits, treated as a signed number, is negative.  */
271
  HOWTO (R_PPC_ADDR16_HA,       /* type */
272
         16,                    /* rightshift */
273
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
274
         16,                    /* bitsize */
275
         FALSE,                 /* pc_relative */
276
         0,                      /* bitpos */
277
         complain_overflow_dont, /* complain_on_overflow */
278
         ppc_elf_addr16_ha_reloc, /* special_function */
279
         "R_PPC_ADDR16_HA",     /* name */
280
         FALSE,                 /* partial_inplace */
281
         0,                      /* src_mask */
282
         0xffff,                /* dst_mask */
283
         FALSE),                /* pcrel_offset */
284
 
285
  /* An absolute 16 bit branch; the lower two bits must be zero.
286
     FIXME: we don't check that, we just clear them.  */
287
  HOWTO (R_PPC_ADDR14,          /* type */
288
         0,                      /* rightshift */
289
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
290
         16,                    /* bitsize */
291
         FALSE,                 /* pc_relative */
292
         0,                      /* bitpos */
293
         complain_overflow_bitfield, /* complain_on_overflow */
294
         bfd_elf_generic_reloc, /* special_function */
295
         "R_PPC_ADDR14",        /* name */
296
         FALSE,                 /* partial_inplace */
297
         0,                      /* src_mask */
298
         0xfffc,                /* dst_mask */
299
         FALSE),                /* pcrel_offset */
300
 
301
  /* An absolute 16 bit branch, for which bit 10 should be set to
302
     indicate that the branch is expected to be taken.  The lower two
303
     bits must be zero.  */
304
  HOWTO (R_PPC_ADDR14_BRTAKEN,  /* type */
305
         0,                      /* rightshift */
306
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
307
         16,                    /* bitsize */
308
         FALSE,                 /* pc_relative */
309
         0,                      /* bitpos */
310
         complain_overflow_bitfield, /* complain_on_overflow */
311
         bfd_elf_generic_reloc, /* special_function */
312
         "R_PPC_ADDR14_BRTAKEN",/* name */
313
         FALSE,                 /* partial_inplace */
314
         0,                      /* src_mask */
315
         0xfffc,                /* dst_mask */
316
         FALSE),                /* pcrel_offset */
317
 
318
  /* An absolute 16 bit branch, for which bit 10 should be set to
319
     indicate that the branch is not expected to be taken.  The lower
320
     two bits must be zero.  */
321
  HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
322
         0,                      /* rightshift */
323
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
324
         16,                    /* bitsize */
325
         FALSE,                 /* pc_relative */
326
         0,                      /* bitpos */
327
         complain_overflow_bitfield, /* complain_on_overflow */
328
         bfd_elf_generic_reloc, /* special_function */
329
         "R_PPC_ADDR14_BRNTAKEN",/* name */
330
         FALSE,                 /* partial_inplace */
331
         0,                      /* src_mask */
332
         0xfffc,                /* dst_mask */
333
         FALSE),                /* pcrel_offset */
334
 
335
  /* A relative 26 bit branch; the lower two bits must be zero.  */
336
  HOWTO (R_PPC_REL24,           /* type */
337
         0,                      /* rightshift */
338
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
339
         26,                    /* bitsize */
340
         TRUE,                  /* pc_relative */
341
         0,                      /* bitpos */
342
         complain_overflow_signed, /* complain_on_overflow */
343
         bfd_elf_generic_reloc, /* special_function */
344
         "R_PPC_REL24",         /* name */
345
         FALSE,                 /* partial_inplace */
346
         0,                      /* src_mask */
347
         0x3fffffc,             /* dst_mask */
348
         TRUE),                 /* pcrel_offset */
349
 
350
  /* A relative 16 bit branch; the lower two bits must be zero.  */
351
  HOWTO (R_PPC_REL14,           /* type */
352
         0,                      /* rightshift */
353
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
354
         16,                    /* bitsize */
355
         TRUE,                  /* pc_relative */
356
         0,                      /* bitpos */
357
         complain_overflow_signed, /* complain_on_overflow */
358
         bfd_elf_generic_reloc, /* special_function */
359
         "R_PPC_REL14",         /* name */
360
         FALSE,                 /* partial_inplace */
361
         0,                      /* src_mask */
362
         0xfffc,                /* dst_mask */
363
         TRUE),                 /* pcrel_offset */
364
 
365
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
366
     the branch is expected to be taken.  The lower two bits must be
367
     zero.  */
368
  HOWTO (R_PPC_REL14_BRTAKEN,   /* type */
369
         0,                      /* rightshift */
370
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
371
         16,                    /* bitsize */
372
         TRUE,                  /* pc_relative */
373
         0,                      /* bitpos */
374
         complain_overflow_signed, /* complain_on_overflow */
375
         bfd_elf_generic_reloc, /* special_function */
376
         "R_PPC_REL14_BRTAKEN", /* name */
377
         FALSE,                 /* partial_inplace */
378
         0,                      /* src_mask */
379
         0xfffc,                /* dst_mask */
380
         TRUE),                 /* pcrel_offset */
381
 
382
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
383
     the branch is not expected to be taken.  The lower two bits must
384
     be zero.  */
385
  HOWTO (R_PPC_REL14_BRNTAKEN,  /* type */
386
         0,                      /* rightshift */
387
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
388
         16,                    /* bitsize */
389
         TRUE,                  /* pc_relative */
390
         0,                      /* bitpos */
391
         complain_overflow_signed, /* complain_on_overflow */
392
         bfd_elf_generic_reloc, /* special_function */
393
         "R_PPC_REL14_BRNTAKEN",/* name */
394
         FALSE,                 /* partial_inplace */
395
         0,                      /* src_mask */
396
         0xfffc,                /* dst_mask */
397
         TRUE),                 /* pcrel_offset */
398
 
399
  /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
400
     symbol.  */
401
  HOWTO (R_PPC_GOT16,           /* type */
402
         0,                      /* rightshift */
403
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
404
         16,                    /* bitsize */
405
         FALSE,                 /* pc_relative */
406
         0,                      /* bitpos */
407
         complain_overflow_signed, /* complain_on_overflow */
408
         bfd_elf_generic_reloc, /* special_function */
409
         "R_PPC_GOT16",         /* name */
410
         FALSE,                 /* partial_inplace */
411
         0,                      /* src_mask */
412
         0xffff,                /* dst_mask */
413
         FALSE),                /* pcrel_offset */
414
 
415
  /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
416
     the symbol.  */
417
  HOWTO (R_PPC_GOT16_LO,        /* type */
418
         0,                      /* rightshift */
419
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
420
         16,                    /* bitsize */
421
         FALSE,                 /* pc_relative */
422
         0,                      /* bitpos */
423
         complain_overflow_dont, /* complain_on_overflow */
424
         bfd_elf_generic_reloc, /* special_function */
425
         "R_PPC_GOT16_LO",      /* name */
426
         FALSE,                 /* partial_inplace */
427
         0,                      /* src_mask */
428
         0xffff,                /* dst_mask */
429
         FALSE),                /* pcrel_offset */
430
 
431
  /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
432
     the symbol.  */
433
  HOWTO (R_PPC_GOT16_HI,        /* type */
434
         16,                    /* rightshift */
435
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
436
         16,                    /* bitsize */
437
         FALSE,                 /* pc_relative */
438
         0,                      /* bitpos */
439
         complain_overflow_bitfield, /* complain_on_overflow */
440
         bfd_elf_generic_reloc, /* special_function */
441
         "R_PPC_GOT16_HI",      /* name */
442
         FALSE,                 /* partial_inplace */
443
         0,                      /* src_mask */
444
         0xffff,                /* dst_mask */
445
         FALSE),                 /* pcrel_offset */
446
 
447
  /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
448
     the symbol.  */
449
  HOWTO (R_PPC_GOT16_HA,        /* type */
450
         16,                    /* rightshift */
451
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
452
         16,                    /* bitsize */
453
         FALSE,                 /* pc_relative */
454
         0,                      /* bitpos */
455
         complain_overflow_bitfield, /* complain_on_overflow */
456
         ppc_elf_addr16_ha_reloc, /* special_function */
457
         "R_PPC_GOT16_HA",      /* name */
458
         FALSE,                 /* partial_inplace */
459
         0,                      /* src_mask */
460
         0xffff,                /* dst_mask */
461
         FALSE),                /* pcrel_offset */
462
 
463
  /* Like R_PPC_REL24, but referring to the procedure linkage table
464
     entry for the symbol.  */
465
  HOWTO (R_PPC_PLTREL24,        /* type */
466
         0,                      /* rightshift */
467
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
468
         26,                    /* bitsize */
469
         TRUE,                  /* pc_relative */
470
         0,                      /* bitpos */
471
         complain_overflow_signed,  /* complain_on_overflow */
472
         bfd_elf_generic_reloc, /* special_function */
473
         "R_PPC_PLTREL24",      /* name */
474
         FALSE,                 /* partial_inplace */
475
         0,                      /* src_mask */
476
         0x3fffffc,             /* dst_mask */
477
         TRUE),                 /* pcrel_offset */
478
 
479
  /* This is used only by the dynamic linker.  The symbol should exist
480
     both in the object being run and in some shared library.  The
481
     dynamic linker copies the data addressed by the symbol from the
482
     shared library into the object, because the object being
483
     run has to have the data at some particular address.  */
484
  HOWTO (R_PPC_COPY,            /* type */
485
         0,                      /* rightshift */
486
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
487
         32,                    /* bitsize */
488
         FALSE,                 /* pc_relative */
489
         0,                      /* bitpos */
490
         complain_overflow_bitfield, /* complain_on_overflow */
491
         bfd_elf_generic_reloc,  /* special_function */
492
         "R_PPC_COPY",          /* name */
493
         FALSE,                 /* partial_inplace */
494
         0,                      /* src_mask */
495
         0,                      /* dst_mask */
496
         FALSE),                /* pcrel_offset */
497
 
498
  /* Like R_PPC_ADDR32, but used when setting global offset table
499
     entries.  */
500
  HOWTO (R_PPC_GLOB_DAT,        /* type */
501
         0,                      /* rightshift */
502
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
503
         32,                    /* bitsize */
504
         FALSE,                 /* pc_relative */
505
         0,                      /* bitpos */
506
         complain_overflow_bitfield, /* complain_on_overflow */
507
         bfd_elf_generic_reloc,  /* special_function */
508
         "R_PPC_GLOB_DAT",      /* name */
509
         FALSE,                 /* partial_inplace */
510
         0,                      /* src_mask */
511
         0xffffffff,            /* dst_mask */
512
         FALSE),                /* pcrel_offset */
513
 
514
  /* Marks a procedure linkage table entry for a symbol.  */
515
  HOWTO (R_PPC_JMP_SLOT,        /* type */
516
         0,                      /* rightshift */
517
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
518
         32,                    /* bitsize */
519
         FALSE,                 /* pc_relative */
520
         0,                      /* bitpos */
521
         complain_overflow_bitfield, /* complain_on_overflow */
522
         bfd_elf_generic_reloc,  /* special_function */
523
         "R_PPC_JMP_SLOT",      /* name */
524
         FALSE,                 /* partial_inplace */
525
         0,                      /* src_mask */
526
         0,                      /* dst_mask */
527
         FALSE),                /* pcrel_offset */
528
 
529
  /* Used only by the dynamic linker.  When the object is run, this
530
     longword is set to the load address of the object, plus the
531
     addend.  */
532
  HOWTO (R_PPC_RELATIVE,        /* type */
533
         0,                      /* rightshift */
534
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
535
         32,                    /* bitsize */
536
         FALSE,                 /* pc_relative */
537
         0,                      /* bitpos */
538
         complain_overflow_bitfield, /* complain_on_overflow */
539
         bfd_elf_generic_reloc,  /* special_function */
540
         "R_PPC_RELATIVE",      /* name */
541
         FALSE,                 /* partial_inplace */
542
         0,                      /* src_mask */
543
         0xffffffff,            /* dst_mask */
544
         FALSE),                /* pcrel_offset */
545
 
546
  /* Like R_PPC_REL24, but uses the value of the symbol within the
547
     object rather than the final value.  Normally used for
548
     _GLOBAL_OFFSET_TABLE_.  */
549
  HOWTO (R_PPC_LOCAL24PC,       /* type */
550
         0,                      /* rightshift */
551
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
552
         26,                    /* bitsize */
553
         TRUE,                  /* pc_relative */
554
         0,                      /* bitpos */
555
         complain_overflow_signed, /* complain_on_overflow */
556
         bfd_elf_generic_reloc, /* special_function */
557
         "R_PPC_LOCAL24PC",     /* name */
558
         FALSE,                 /* partial_inplace */
559
         0,                      /* src_mask */
560
         0x3fffffc,             /* dst_mask */
561
         TRUE),                 /* pcrel_offset */
562
 
563
  /* Like R_PPC_ADDR32, but may be unaligned.  */
564
  HOWTO (R_PPC_UADDR32,         /* type */
565
         0,                      /* rightshift */
566
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
567
         32,                    /* bitsize */
568
         FALSE,                 /* pc_relative */
569
         0,                      /* bitpos */
570
         complain_overflow_bitfield, /* complain_on_overflow */
571
         bfd_elf_generic_reloc, /* special_function */
572
         "R_PPC_UADDR32",       /* name */
573
         FALSE,                 /* partial_inplace */
574
         0,                      /* src_mask */
575
         0xffffffff,            /* dst_mask */
576
         FALSE),                /* pcrel_offset */
577
 
578
  /* Like R_PPC_ADDR16, but may be unaligned.  */
579
  HOWTO (R_PPC_UADDR16,         /* type */
580
         0,                      /* rightshift */
581
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
582
         16,                    /* bitsize */
583
         FALSE,                 /* pc_relative */
584
         0,                      /* bitpos */
585
         complain_overflow_bitfield, /* complain_on_overflow */
586
         bfd_elf_generic_reloc, /* special_function */
587
         "R_PPC_UADDR16",       /* name */
588
         FALSE,                 /* partial_inplace */
589
         0,                      /* src_mask */
590
         0xffff,                /* dst_mask */
591
         FALSE),                /* pcrel_offset */
592
 
593
  /* 32-bit PC relative */
594
  HOWTO (R_PPC_REL32,           /* type */
595
         0,                      /* rightshift */
596
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
597
         32,                    /* bitsize */
598
         TRUE,                  /* pc_relative */
599
         0,                      /* bitpos */
600
         complain_overflow_bitfield, /* complain_on_overflow */
601
         bfd_elf_generic_reloc, /* special_function */
602
         "R_PPC_REL32",         /* name */
603
         FALSE,                 /* partial_inplace */
604
         0,                      /* src_mask */
605
         0xffffffff,            /* dst_mask */
606
         TRUE),                 /* pcrel_offset */
607
 
608
  /* 32-bit relocation to the symbol's procedure linkage table.
609
     FIXME: not supported.  */
610
  HOWTO (R_PPC_PLT32,           /* type */
611
         0,                      /* rightshift */
612
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
613
         32,                    /* bitsize */
614
         FALSE,                 /* pc_relative */
615
         0,                      /* bitpos */
616
         complain_overflow_bitfield, /* complain_on_overflow */
617
         bfd_elf_generic_reloc, /* special_function */
618
         "R_PPC_PLT32",         /* name */
619
         FALSE,                 /* partial_inplace */
620
         0,                      /* src_mask */
621
         0,                      /* dst_mask */
622
         FALSE),                /* pcrel_offset */
623
 
624
  /* 32-bit PC relative relocation to the symbol's procedure linkage table.
625
     FIXME: not supported.  */
626
  HOWTO (R_PPC_PLTREL32,        /* type */
627
         0,                      /* rightshift */
628
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
629
         32,                    /* bitsize */
630
         TRUE,                  /* pc_relative */
631
         0,                      /* bitpos */
632
         complain_overflow_bitfield, /* complain_on_overflow */
633
         bfd_elf_generic_reloc, /* special_function */
634
         "R_PPC_PLTREL32",      /* name */
635
         FALSE,                 /* partial_inplace */
636
         0,                      /* src_mask */
637
         0,                      /* dst_mask */
638
         TRUE),                 /* pcrel_offset */
639
 
640
  /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
641
     the symbol.  */
642
  HOWTO (R_PPC_PLT16_LO,        /* type */
643
         0,                      /* rightshift */
644
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
645
         16,                    /* bitsize */
646
         FALSE,                 /* pc_relative */
647
         0,                      /* bitpos */
648
         complain_overflow_dont, /* complain_on_overflow */
649
         bfd_elf_generic_reloc, /* special_function */
650
         "R_PPC_PLT16_LO",      /* name */
651
         FALSE,                 /* partial_inplace */
652
         0,                      /* src_mask */
653
         0xffff,                /* dst_mask */
654
         FALSE),                /* pcrel_offset */
655
 
656
  /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
657
     the symbol.  */
658
  HOWTO (R_PPC_PLT16_HI,        /* type */
659
         16,                    /* rightshift */
660
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
661
         16,                    /* bitsize */
662
         FALSE,                 /* pc_relative */
663
         0,                      /* bitpos */
664
         complain_overflow_bitfield, /* complain_on_overflow */
665
         bfd_elf_generic_reloc, /* special_function */
666
         "R_PPC_PLT16_HI",      /* name */
667
         FALSE,                 /* partial_inplace */
668
         0,                      /* src_mask */
669
         0xffff,                /* dst_mask */
670
         FALSE),                 /* pcrel_offset */
671
 
672
  /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
673
     the symbol.  */
674
  HOWTO (R_PPC_PLT16_HA,        /* type */
675
         16,                    /* rightshift */
676
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
677
         16,                    /* bitsize */
678
         FALSE,                 /* pc_relative */
679
         0,                      /* bitpos */
680
         complain_overflow_bitfield, /* complain_on_overflow */
681
         ppc_elf_addr16_ha_reloc, /* special_function */
682
         "R_PPC_PLT16_HA",      /* name */
683
         FALSE,                 /* partial_inplace */
684
         0,                      /* src_mask */
685
         0xffff,                /* dst_mask */
686
         FALSE),                /* pcrel_offset */
687
 
688
  /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
689
     small data items.  */
690
  HOWTO (R_PPC_SDAREL16,        /* type */
691
         0,                      /* rightshift */
692
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
693
         16,                    /* bitsize */
694
         FALSE,                 /* pc_relative */
695
         0,                      /* bitpos */
696
         complain_overflow_signed, /* complain_on_overflow */
697
         bfd_elf_generic_reloc, /* special_function */
698
         "R_PPC_SDAREL16",      /* name */
699
         FALSE,                 /* partial_inplace */
700
         0,                      /* src_mask */
701
         0xffff,                /* dst_mask */
702
         FALSE),                /* pcrel_offset */
703
 
704
  /* 16-bit section relative relocation.  */
705
  HOWTO (R_PPC_SECTOFF,         /* type */
706
         0,                      /* rightshift */
707
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
708
         16,                    /* bitsize */
709
         FALSE,                 /* pc_relative */
710
         0,                      /* bitpos */
711
         complain_overflow_bitfield, /* complain_on_overflow */
712
         bfd_elf_generic_reloc, /* special_function */
713
         "R_PPC_SECTOFF",       /* name */
714
         FALSE,                 /* partial_inplace */
715
         0,                      /* src_mask */
716
         0xffff,                /* dst_mask */
717
         FALSE),                /* pcrel_offset */
718
 
719
  /* 16-bit lower half section relative relocation.  */
720
  HOWTO (R_PPC_SECTOFF_LO,        /* type */
721
         0,                      /* rightshift */
722
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
723
         16,                    /* bitsize */
724
         FALSE,                 /* pc_relative */
725
         0,                      /* bitpos */
726
         complain_overflow_dont, /* complain_on_overflow */
727
         bfd_elf_generic_reloc, /* special_function */
728
         "R_PPC_SECTOFF_LO",    /* name */
729
         FALSE,                 /* partial_inplace */
730
         0,                      /* src_mask */
731
         0xffff,                /* dst_mask */
732
         FALSE),                /* pcrel_offset */
733
 
734
  /* 16-bit upper half section relative relocation.  */
735
  HOWTO (R_PPC_SECTOFF_HI,      /* type */
736
         16,                    /* rightshift */
737
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
738
         16,                    /* bitsize */
739
         FALSE,                 /* pc_relative */
740
         0,                      /* bitpos */
741
         complain_overflow_bitfield, /* complain_on_overflow */
742
         bfd_elf_generic_reloc, /* special_function */
743
         "R_PPC_SECTOFF_HI",    /* name */
744
         FALSE,                 /* partial_inplace */
745
         0,                      /* src_mask */
746
         0xffff,                /* dst_mask */
747
         FALSE),                 /* pcrel_offset */
748
 
749
  /* 16-bit upper half adjusted section relative relocation.  */
750
  HOWTO (R_PPC_SECTOFF_HA,      /* type */
751
         16,                    /* rightshift */
752
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
753
         16,                    /* bitsize */
754
         FALSE,                 /* pc_relative */
755
         0,                      /* bitpos */
756
         complain_overflow_bitfield, /* complain_on_overflow */
757
         ppc_elf_addr16_ha_reloc, /* special_function */
758
         "R_PPC_SECTOFF_HA",    /* name */
759
         FALSE,                 /* partial_inplace */
760
         0,                      /* src_mask */
761
         0xffff,                /* dst_mask */
762
         FALSE),                /* pcrel_offset */
763
 
764
  /* Marker relocs for TLS.  */
765
  HOWTO (R_PPC_TLS,
766
         0,                      /* rightshift */
767
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
768
         32,                    /* bitsize */
769
         FALSE,                 /* pc_relative */
770
         0,                      /* bitpos */
771
         complain_overflow_dont, /* complain_on_overflow */
772
         bfd_elf_generic_reloc, /* special_function */
773
         "R_PPC_TLS",           /* name */
774
         FALSE,                 /* partial_inplace */
775
         0,                      /* src_mask */
776
         0,                      /* dst_mask */
777
         FALSE),                /* pcrel_offset */
778
 
779
  HOWTO (R_PPC_TLSGD,
780
         0,                      /* rightshift */
781
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
782
         32,                    /* bitsize */
783
         FALSE,                 /* pc_relative */
784
         0,                      /* bitpos */
785
         complain_overflow_dont, /* complain_on_overflow */
786
         bfd_elf_generic_reloc, /* special_function */
787
         "R_PPC_TLSGD",         /* name */
788
         FALSE,                 /* partial_inplace */
789
         0,                      /* src_mask */
790
         0,                      /* dst_mask */
791
         FALSE),                /* pcrel_offset */
792
 
793
  HOWTO (R_PPC_TLSLD,
794
         0,                      /* rightshift */
795
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
796
         32,                    /* bitsize */
797
         FALSE,                 /* pc_relative */
798
         0,                      /* bitpos */
799
         complain_overflow_dont, /* complain_on_overflow */
800
         bfd_elf_generic_reloc, /* special_function */
801
         "R_PPC_TLSLD",         /* name */
802
         FALSE,                 /* partial_inplace */
803
         0,                      /* src_mask */
804
         0,                      /* dst_mask */
805
         FALSE),                /* pcrel_offset */
806
 
807
  /* Computes the load module index of the load module that contains the
808
     definition of its TLS sym.  */
809
  HOWTO (R_PPC_DTPMOD32,
810
         0,                      /* rightshift */
811
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
812
         32,                    /* bitsize */
813
         FALSE,                 /* pc_relative */
814
         0,                      /* bitpos */
815
         complain_overflow_dont, /* complain_on_overflow */
816
         ppc_elf_unhandled_reloc, /* special_function */
817
         "R_PPC_DTPMOD32",      /* name */
818
         FALSE,                 /* partial_inplace */
819
         0,                      /* src_mask */
820
         0xffffffff,            /* dst_mask */
821
         FALSE),                /* pcrel_offset */
822
 
823
  /* Computes a dtv-relative displacement, the difference between the value
824
     of sym+add and the base address of the thread-local storage block that
825
     contains the definition of sym, minus 0x8000.  */
826
  HOWTO (R_PPC_DTPREL32,
827
         0,                      /* rightshift */
828
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
829
         32,                    /* bitsize */
830
         FALSE,                 /* pc_relative */
831
         0,                      /* bitpos */
832
         complain_overflow_dont, /* complain_on_overflow */
833
         ppc_elf_unhandled_reloc, /* special_function */
834
         "R_PPC_DTPREL32",      /* name */
835
         FALSE,                 /* partial_inplace */
836
         0,                      /* src_mask */
837
         0xffffffff,            /* dst_mask */
838
         FALSE),                /* pcrel_offset */
839
 
840
  /* A 16 bit dtprel reloc.  */
841
  HOWTO (R_PPC_DTPREL16,
842
         0,                      /* rightshift */
843
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
844
         16,                    /* bitsize */
845
         FALSE,                 /* pc_relative */
846
         0,                      /* bitpos */
847
         complain_overflow_signed, /* complain_on_overflow */
848
         ppc_elf_unhandled_reloc, /* special_function */
849
         "R_PPC_DTPREL16",      /* name */
850
         FALSE,                 /* partial_inplace */
851
         0,                      /* src_mask */
852
         0xffff,                /* dst_mask */
853
         FALSE),                /* pcrel_offset */
854
 
855
  /* Like DTPREL16, but no overflow.  */
856
  HOWTO (R_PPC_DTPREL16_LO,
857
         0,                      /* rightshift */
858
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
859
         16,                    /* bitsize */
860
         FALSE,                 /* pc_relative */
861
         0,                      /* bitpos */
862
         complain_overflow_dont, /* complain_on_overflow */
863
         ppc_elf_unhandled_reloc, /* special_function */
864
         "R_PPC_DTPREL16_LO",   /* name */
865
         FALSE,                 /* partial_inplace */
866
         0,                      /* src_mask */
867
         0xffff,                /* dst_mask */
868
         FALSE),                /* pcrel_offset */
869
 
870
  /* Like DTPREL16_LO, but next higher group of 16 bits.  */
871
  HOWTO (R_PPC_DTPREL16_HI,
872
         16,                    /* rightshift */
873
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
874
         16,                    /* bitsize */
875
         FALSE,                 /* pc_relative */
876
         0,                      /* bitpos */
877
         complain_overflow_dont, /* complain_on_overflow */
878
         ppc_elf_unhandled_reloc, /* special_function */
879
         "R_PPC_DTPREL16_HI",   /* name */
880
         FALSE,                 /* partial_inplace */
881
         0,                      /* src_mask */
882
         0xffff,                /* dst_mask */
883
         FALSE),                /* pcrel_offset */
884
 
885
  /* Like DTPREL16_HI, but adjust for low 16 bits.  */
886
  HOWTO (R_PPC_DTPREL16_HA,
887
         16,                    /* rightshift */
888
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
889
         16,                    /* bitsize */
890
         FALSE,                 /* pc_relative */
891
         0,                      /* bitpos */
892
         complain_overflow_dont, /* complain_on_overflow */
893
         ppc_elf_unhandled_reloc, /* special_function */
894
         "R_PPC_DTPREL16_HA",   /* name */
895
         FALSE,                 /* partial_inplace */
896
         0,                      /* src_mask */
897
         0xffff,                /* dst_mask */
898
         FALSE),                /* pcrel_offset */
899
 
900
  /* Computes a tp-relative displacement, the difference between the value of
901
     sym+add and the value of the thread pointer (r13).  */
902
  HOWTO (R_PPC_TPREL32,
903
         0,                      /* rightshift */
904
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
905
         32,                    /* bitsize */
906
         FALSE,                 /* pc_relative */
907
         0,                      /* bitpos */
908
         complain_overflow_dont, /* complain_on_overflow */
909
         ppc_elf_unhandled_reloc, /* special_function */
910
         "R_PPC_TPREL32",       /* name */
911
         FALSE,                 /* partial_inplace */
912
         0,                      /* src_mask */
913
         0xffffffff,            /* dst_mask */
914
         FALSE),                /* pcrel_offset */
915
 
916
  /* A 16 bit tprel reloc.  */
917
  HOWTO (R_PPC_TPREL16,
918
         0,                      /* rightshift */
919
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
920
         16,                    /* bitsize */
921
         FALSE,                 /* pc_relative */
922
         0,                      /* bitpos */
923
         complain_overflow_signed, /* complain_on_overflow */
924
         ppc_elf_unhandled_reloc, /* special_function */
925
         "R_PPC_TPREL16",       /* name */
926
         FALSE,                 /* partial_inplace */
927
         0,                      /* src_mask */
928
         0xffff,                /* dst_mask */
929
         FALSE),                /* pcrel_offset */
930
 
931
  /* Like TPREL16, but no overflow.  */
932
  HOWTO (R_PPC_TPREL16_LO,
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
         ppc_elf_unhandled_reloc, /* special_function */
940
         "R_PPC_TPREL16_LO",    /* name */
941
         FALSE,                 /* partial_inplace */
942
         0,                      /* src_mask */
943
         0xffff,                /* dst_mask */
944
         FALSE),                /* pcrel_offset */
945
 
946
  /* Like TPREL16_LO, but next higher group of 16 bits.  */
947
  HOWTO (R_PPC_TPREL16_HI,
948
         16,                    /* rightshift */
949
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
950
         16,                    /* bitsize */
951
         FALSE,                 /* pc_relative */
952
         0,                      /* bitpos */
953
         complain_overflow_dont, /* complain_on_overflow */
954
         ppc_elf_unhandled_reloc, /* special_function */
955
         "R_PPC_TPREL16_HI",    /* name */
956
         FALSE,                 /* partial_inplace */
957
         0,                      /* src_mask */
958
         0xffff,                /* dst_mask */
959
         FALSE),                /* pcrel_offset */
960
 
961
  /* Like TPREL16_HI, but adjust for low 16 bits.  */
962
  HOWTO (R_PPC_TPREL16_HA,
963
         16,                    /* rightshift */
964
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
965
         16,                    /* bitsize */
966
         FALSE,                 /* pc_relative */
967
         0,                      /* bitpos */
968
         complain_overflow_dont, /* complain_on_overflow */
969
         ppc_elf_unhandled_reloc, /* special_function */
970
         "R_PPC_TPREL16_HA",    /* name */
971
         FALSE,                 /* partial_inplace */
972
         0,                      /* src_mask */
973
         0xffff,                /* dst_mask */
974
         FALSE),                /* pcrel_offset */
975
 
976
  /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
977
     with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
978
     to the first entry.  */
979
  HOWTO (R_PPC_GOT_TLSGD16,
980
         0,                      /* rightshift */
981
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
982
         16,                    /* bitsize */
983
         FALSE,                 /* pc_relative */
984
         0,                      /* bitpos */
985
         complain_overflow_signed, /* complain_on_overflow */
986
         ppc_elf_unhandled_reloc, /* special_function */
987
         "R_PPC_GOT_TLSGD16",   /* name */
988
         FALSE,                 /* partial_inplace */
989
         0,                      /* src_mask */
990
         0xffff,                /* dst_mask */
991
         FALSE),                /* pcrel_offset */
992
 
993
  /* Like GOT_TLSGD16, but no overflow.  */
994
  HOWTO (R_PPC_GOT_TLSGD16_LO,
995
         0,                      /* rightshift */
996
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
997
         16,                    /* bitsize */
998
         FALSE,                 /* pc_relative */
999
         0,                      /* bitpos */
1000
         complain_overflow_dont, /* complain_on_overflow */
1001
         ppc_elf_unhandled_reloc, /* special_function */
1002
         "R_PPC_GOT_TLSGD16_LO", /* name */
1003
         FALSE,                 /* partial_inplace */
1004
         0,                      /* src_mask */
1005
         0xffff,                /* dst_mask */
1006
         FALSE),                /* pcrel_offset */
1007
 
1008
  /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1009
  HOWTO (R_PPC_GOT_TLSGD16_HI,
1010
         16,                    /* rightshift */
1011
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1012
         16,                    /* bitsize */
1013
         FALSE,                 /* pc_relative */
1014
         0,                      /* bitpos */
1015
         complain_overflow_dont, /* complain_on_overflow */
1016
         ppc_elf_unhandled_reloc, /* special_function */
1017
         "R_PPC_GOT_TLSGD16_HI", /* name */
1018
         FALSE,                 /* partial_inplace */
1019
         0,                      /* src_mask */
1020
         0xffff,                /* dst_mask */
1021
         FALSE),                /* pcrel_offset */
1022
 
1023
  /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1024
  HOWTO (R_PPC_GOT_TLSGD16_HA,
1025
         16,                    /* 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
         ppc_elf_unhandled_reloc, /* special_function */
1032
         "R_PPC_GOT_TLSGD16_HA", /* name */
1033
         FALSE,                 /* partial_inplace */
1034
         0,                      /* src_mask */
1035
         0xffff,                /* dst_mask */
1036
         FALSE),                /* pcrel_offset */
1037
 
1038
  /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1039
     with values (sym+add)@dtpmod and zero, and computes the offset to the
1040
     first entry.  */
1041
  HOWTO (R_PPC_GOT_TLSLD16,
1042
         0,                      /* rightshift */
1043
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1044
         16,                    /* bitsize */
1045
         FALSE,                 /* pc_relative */
1046
         0,                      /* bitpos */
1047
         complain_overflow_signed, /* complain_on_overflow */
1048
         ppc_elf_unhandled_reloc, /* special_function */
1049
         "R_PPC_GOT_TLSLD16",   /* name */
1050
         FALSE,                 /* partial_inplace */
1051
         0,                      /* src_mask */
1052
         0xffff,                /* dst_mask */
1053
         FALSE),                /* pcrel_offset */
1054
 
1055
  /* Like GOT_TLSLD16, but no overflow.  */
1056
  HOWTO (R_PPC_GOT_TLSLD16_LO,
1057
         0,                      /* rightshift */
1058
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1059
         16,                    /* bitsize */
1060
         FALSE,                 /* pc_relative */
1061
         0,                      /* bitpos */
1062
         complain_overflow_dont, /* complain_on_overflow */
1063
         ppc_elf_unhandled_reloc, /* special_function */
1064
         "R_PPC_GOT_TLSLD16_LO", /* name */
1065
         FALSE,                 /* partial_inplace */
1066
         0,                      /* src_mask */
1067
         0xffff,                /* dst_mask */
1068
         FALSE),                /* pcrel_offset */
1069
 
1070
  /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1071
  HOWTO (R_PPC_GOT_TLSLD16_HI,
1072
         16,                    /* rightshift */
1073
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1074
         16,                    /* bitsize */
1075
         FALSE,                 /* pc_relative */
1076
         0,                      /* bitpos */
1077
         complain_overflow_dont, /* complain_on_overflow */
1078
         ppc_elf_unhandled_reloc, /* special_function */
1079
         "R_PPC_GOT_TLSLD16_HI", /* name */
1080
         FALSE,                 /* partial_inplace */
1081
         0,                      /* src_mask */
1082
         0xffff,                /* dst_mask */
1083
         FALSE),                /* pcrel_offset */
1084
 
1085
  /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1086
  HOWTO (R_PPC_GOT_TLSLD16_HA,
1087
         16,                    /* rightshift */
1088
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1089
         16,                    /* bitsize */
1090
         FALSE,                 /* pc_relative */
1091
         0,                      /* bitpos */
1092
         complain_overflow_dont, /* complain_on_overflow */
1093
         ppc_elf_unhandled_reloc, /* special_function */
1094
         "R_PPC_GOT_TLSLD16_HA", /* name */
1095
         FALSE,                 /* partial_inplace */
1096
         0,                      /* src_mask */
1097
         0xffff,                /* dst_mask */
1098
         FALSE),                /* pcrel_offset */
1099
 
1100
  /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1101
     the offset to the entry.  */
1102
  HOWTO (R_PPC_GOT_DTPREL16,
1103
         0,                      /* rightshift */
1104
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1105
         16,                    /* bitsize */
1106
         FALSE,                 /* pc_relative */
1107
         0,                      /* bitpos */
1108
         complain_overflow_signed, /* complain_on_overflow */
1109
         ppc_elf_unhandled_reloc, /* special_function */
1110
         "R_PPC_GOT_DTPREL16",  /* name */
1111
         FALSE,                 /* partial_inplace */
1112
         0,                      /* src_mask */
1113
         0xffff,                /* dst_mask */
1114
         FALSE),                /* pcrel_offset */
1115
 
1116
  /* Like GOT_DTPREL16, but no overflow.  */
1117
  HOWTO (R_PPC_GOT_DTPREL16_LO,
1118
         0,                      /* rightshift */
1119
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1120
         16,                    /* bitsize */
1121
         FALSE,                 /* pc_relative */
1122
         0,                      /* bitpos */
1123
         complain_overflow_dont, /* complain_on_overflow */
1124
         ppc_elf_unhandled_reloc, /* special_function */
1125
         "R_PPC_GOT_DTPREL16_LO", /* name */
1126
         FALSE,                 /* partial_inplace */
1127
         0,                      /* src_mask */
1128
         0xffff,                /* dst_mask */
1129
         FALSE),                /* pcrel_offset */
1130
 
1131
  /* Like GOT_DTPREL16_LO, but next higher group of 16 bits.  */
1132
  HOWTO (R_PPC_GOT_DTPREL16_HI,
1133
         16,                    /* rightshift */
1134
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1135
         16,                    /* bitsize */
1136
         FALSE,                 /* pc_relative */
1137
         0,                      /* bitpos */
1138
         complain_overflow_dont, /* complain_on_overflow */
1139
         ppc_elf_unhandled_reloc, /* special_function */
1140
         "R_PPC_GOT_DTPREL16_HI", /* name */
1141
         FALSE,                 /* partial_inplace */
1142
         0,                      /* src_mask */
1143
         0xffff,                /* dst_mask */
1144
         FALSE),                /* pcrel_offset */
1145
 
1146
  /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1147
  HOWTO (R_PPC_GOT_DTPREL16_HA,
1148
         16,                    /* rightshift */
1149
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1150
         16,                    /* bitsize */
1151
         FALSE,                 /* pc_relative */
1152
         0,                      /* bitpos */
1153
         complain_overflow_dont, /* complain_on_overflow */
1154
         ppc_elf_unhandled_reloc, /* special_function */
1155
         "R_PPC_GOT_DTPREL16_HA", /* name */
1156
         FALSE,                 /* partial_inplace */
1157
         0,                      /* src_mask */
1158
         0xffff,                /* dst_mask */
1159
         FALSE),                /* pcrel_offset */
1160
 
1161
  /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1162
     offset to the entry.  */
1163
  HOWTO (R_PPC_GOT_TPREL16,
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_signed, /* complain_on_overflow */
1170
         ppc_elf_unhandled_reloc, /* special_function */
1171
         "R_PPC_GOT_TPREL16",   /* name */
1172
         FALSE,                 /* partial_inplace */
1173
         0,                      /* src_mask */
1174
         0xffff,                /* dst_mask */
1175
         FALSE),                /* pcrel_offset */
1176
 
1177
  /* Like GOT_TPREL16, but no overflow.  */
1178
  HOWTO (R_PPC_GOT_TPREL16_LO,
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_dont, /* complain_on_overflow */
1185
         ppc_elf_unhandled_reloc, /* special_function */
1186
         "R_PPC_GOT_TPREL16_LO", /* name */
1187
         FALSE,                 /* partial_inplace */
1188
         0,                      /* src_mask */
1189
         0xffff,                /* dst_mask */
1190
         FALSE),                /* pcrel_offset */
1191
 
1192
  /* Like GOT_TPREL16_LO, but next higher group of 16 bits.  */
1193
  HOWTO (R_PPC_GOT_TPREL16_HI,
1194
         16,                    /* 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
         ppc_elf_unhandled_reloc, /* special_function */
1201
         "R_PPC_GOT_TPREL16_HI", /* name */
1202
         FALSE,                 /* partial_inplace */
1203
         0,                      /* src_mask */
1204
         0xffff,                /* dst_mask */
1205
         FALSE),                /* pcrel_offset */
1206
 
1207
  /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1208
  HOWTO (R_PPC_GOT_TPREL16_HA,
1209
         16,                    /* rightshift */
1210
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1211
         16,                    /* bitsize */
1212
         FALSE,                 /* pc_relative */
1213
         0,                      /* bitpos */
1214
         complain_overflow_dont, /* complain_on_overflow */
1215
         ppc_elf_unhandled_reloc, /* special_function */
1216
         "R_PPC_GOT_TPREL16_HA", /* name */
1217
         FALSE,                 /* partial_inplace */
1218
         0,                      /* src_mask */
1219
         0xffff,                /* dst_mask */
1220
         FALSE),                /* pcrel_offset */
1221
 
1222
  /* The remaining relocs are from the Embedded ELF ABI, and are not
1223
     in the SVR4 ELF ABI.  */
1224
 
1225
  /* 32 bit value resulting from the addend minus the symbol.  */
1226
  HOWTO (R_PPC_EMB_NADDR32,     /* type */
1227
         0,                      /* rightshift */
1228
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1229
         32,                    /* bitsize */
1230
         FALSE,                 /* pc_relative */
1231
         0,                      /* bitpos */
1232
         complain_overflow_bitfield, /* complain_on_overflow */
1233
         bfd_elf_generic_reloc, /* special_function */
1234
         "R_PPC_EMB_NADDR32",   /* name */
1235
         FALSE,                 /* partial_inplace */
1236
         0,                      /* src_mask */
1237
         0xffffffff,            /* dst_mask */
1238
         FALSE),                /* pcrel_offset */
1239
 
1240
  /* 16 bit value resulting from the addend minus the symbol.  */
1241
  HOWTO (R_PPC_EMB_NADDR16,     /* type */
1242
         0,                      /* rightshift */
1243
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1244
         16,                    /* bitsize */
1245
         FALSE,                 /* pc_relative */
1246
         0,                      /* bitpos */
1247
         complain_overflow_bitfield, /* complain_on_overflow */
1248
         bfd_elf_generic_reloc, /* special_function */
1249
         "R_PPC_EMB_NADDR16",   /* name */
1250
         FALSE,                 /* partial_inplace */
1251
         0,                      /* src_mask */
1252
         0xffff,                /* dst_mask */
1253
         FALSE),                /* pcrel_offset */
1254
 
1255
  /* 16 bit value resulting from the addend minus the symbol.  */
1256
  HOWTO (R_PPC_EMB_NADDR16_LO,  /* type */
1257
         0,                      /* rightshift */
1258
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1259
         16,                    /* bitsize */
1260
         FALSE,                 /* pc_relative */
1261
         0,                      /* bitpos */
1262
         complain_overflow_dont,/* complain_on_overflow */
1263
         bfd_elf_generic_reloc, /* special_function */
1264
         "R_PPC_EMB_ADDR16_LO", /* name */
1265
         FALSE,                 /* partial_inplace */
1266
         0,                      /* src_mask */
1267
         0xffff,                /* dst_mask */
1268
         FALSE),                /* pcrel_offset */
1269
 
1270
  /* The high order 16 bits of the addend minus the symbol.  */
1271
  HOWTO (R_PPC_EMB_NADDR16_HI,  /* type */
1272
         16,                    /* rightshift */
1273
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1274
         16,                    /* bitsize */
1275
         FALSE,                 /* pc_relative */
1276
         0,                      /* bitpos */
1277
         complain_overflow_dont, /* complain_on_overflow */
1278
         bfd_elf_generic_reloc, /* special_function */
1279
         "R_PPC_EMB_NADDR16_HI", /* name */
1280
         FALSE,                 /* partial_inplace */
1281
         0,                      /* src_mask */
1282
         0xffff,                /* dst_mask */
1283
         FALSE),                /* pcrel_offset */
1284
 
1285
  /* The high order 16 bits of the result of the addend minus the address,
1286
     plus 1 if the contents of the low 16 bits, treated as a signed number,
1287
     is negative.  */
1288
  HOWTO (R_PPC_EMB_NADDR16_HA,  /* type */
1289
         16,                    /* rightshift */
1290
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1291
         16,                    /* bitsize */
1292
         FALSE,                 /* pc_relative */
1293
         0,                      /* bitpos */
1294
         complain_overflow_dont, /* complain_on_overflow */
1295
         ppc_elf_addr16_ha_reloc, /* special_function */
1296
         "R_PPC_EMB_NADDR16_HA", /* name */
1297
         FALSE,                 /* partial_inplace */
1298
         0,                      /* src_mask */
1299
         0xffff,                /* dst_mask */
1300
         FALSE),                /* pcrel_offset */
1301
 
1302
  /* 16 bit value resulting from allocating a 4 byte word to hold an
1303
     address in the .sdata section, and returning the offset from
1304
     _SDA_BASE_ for that relocation.  */
1305
  HOWTO (R_PPC_EMB_SDAI16,      /* type */
1306
         0,                      /* rightshift */
1307
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1308
         16,                    /* bitsize */
1309
         FALSE,                 /* pc_relative */
1310
         0,                      /* bitpos */
1311
         complain_overflow_signed, /* complain_on_overflow */
1312
         bfd_elf_generic_reloc, /* special_function */
1313
         "R_PPC_EMB_SDAI16",    /* name */
1314
         FALSE,                 /* partial_inplace */
1315
         0,                      /* src_mask */
1316
         0xffff,                /* dst_mask */
1317
         FALSE),                /* pcrel_offset */
1318
 
1319
  /* 16 bit value resulting from allocating a 4 byte word to hold an
1320
     address in the .sdata2 section, and returning the offset from
1321
     _SDA2_BASE_ for that relocation.  */
1322
  HOWTO (R_PPC_EMB_SDA2I16,     /* type */
1323
         0,                      /* rightshift */
1324
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1325
         16,                    /* bitsize */
1326
         FALSE,                 /* pc_relative */
1327
         0,                      /* bitpos */
1328
         complain_overflow_signed, /* complain_on_overflow */
1329
         bfd_elf_generic_reloc, /* special_function */
1330
         "R_PPC_EMB_SDA2I16",   /* name */
1331
         FALSE,                 /* partial_inplace */
1332
         0,                      /* src_mask */
1333
         0xffff,                /* dst_mask */
1334
         FALSE),                /* pcrel_offset */
1335
 
1336
  /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
1337
     small data items.   */
1338
  HOWTO (R_PPC_EMB_SDA2REL,     /* type */
1339
         0,                      /* rightshift */
1340
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1341
         16,                    /* bitsize */
1342
         FALSE,                 /* pc_relative */
1343
         0,                      /* bitpos */
1344
         complain_overflow_signed, /* complain_on_overflow */
1345
         bfd_elf_generic_reloc, /* special_function */
1346
         "R_PPC_EMB_SDA2REL",   /* name */
1347
         FALSE,                 /* partial_inplace */
1348
         0,                      /* src_mask */
1349
         0xffff,                /* dst_mask */
1350
         FALSE),                /* pcrel_offset */
1351
 
1352
  /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
1353
     signed offset from the appropriate base, and filling in the register
1354
     field with the appropriate register (0, 2, or 13).  */
1355
  HOWTO (R_PPC_EMB_SDA21,       /* type */
1356
         0,                      /* rightshift */
1357
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1358
         16,                    /* bitsize */
1359
         FALSE,                 /* pc_relative */
1360
         0,                      /* bitpos */
1361
         complain_overflow_signed, /* complain_on_overflow */
1362
         bfd_elf_generic_reloc, /* special_function */
1363
         "R_PPC_EMB_SDA21",     /* name */
1364
         FALSE,                 /* partial_inplace */
1365
         0,                      /* src_mask */
1366
         0xffff,                /* dst_mask */
1367
         FALSE),                /* pcrel_offset */
1368
 
1369
  /* Relocation not handled: R_PPC_EMB_MRKREF */
1370
  /* Relocation not handled: R_PPC_EMB_RELSEC16 */
1371
  /* Relocation not handled: R_PPC_EMB_RELST_LO */
1372
  /* Relocation not handled: R_PPC_EMB_RELST_HI */
1373
  /* Relocation not handled: R_PPC_EMB_RELST_HA */
1374
  /* Relocation not handled: R_PPC_EMB_BIT_FLD */
1375
 
1376
  /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
1377
     in the 16 bit signed offset from the appropriate base, and filling in the
1378
     register field with the appropriate register (0, 2, or 13).  */
1379
  HOWTO (R_PPC_EMB_RELSDA,      /* type */
1380
         0,                      /* rightshift */
1381
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382
         16,                    /* bitsize */
1383
         FALSE,                 /* pc_relative */
1384
         0,                      /* bitpos */
1385
         complain_overflow_signed, /* complain_on_overflow */
1386
         bfd_elf_generic_reloc, /* special_function */
1387
         "R_PPC_EMB_RELSDA",    /* name */
1388
         FALSE,                 /* partial_inplace */
1389
         0,                      /* src_mask */
1390
         0xffff,                /* dst_mask */
1391
         FALSE),                /* pcrel_offset */
1392
 
1393
  HOWTO (R_PPC_IRELATIVE,       /* type */
1394
         0,                      /* rightshift */
1395
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1396
         32,                    /* bitsize */
1397
         FALSE,                 /* pc_relative */
1398
         0,                      /* bitpos */
1399
         complain_overflow_bitfield, /* complain_on_overflow */
1400
         bfd_elf_generic_reloc,  /* special_function */
1401
         "R_PPC_IRELATIVE",     /* name */
1402
         FALSE,                 /* partial_inplace */
1403
         0,                      /* src_mask */
1404
         0xffffffff,            /* dst_mask */
1405
         FALSE),                /* pcrel_offset */
1406
 
1407
  /* A 16 bit relative relocation.  */
1408
  HOWTO (R_PPC_REL16,           /* type */
1409
         0,                      /* rightshift */
1410
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1411
         16,                    /* bitsize */
1412
         TRUE,                  /* pc_relative */
1413
         0,                      /* bitpos */
1414
         complain_overflow_bitfield, /* complain_on_overflow */
1415
         bfd_elf_generic_reloc, /* special_function */
1416
         "R_PPC_REL16",         /* name */
1417
         FALSE,                 /* partial_inplace */
1418
         0,                      /* src_mask */
1419
         0xffff,                /* dst_mask */
1420
         TRUE),                 /* pcrel_offset */
1421
 
1422
  /* A 16 bit relative relocation without overflow.  */
1423
  HOWTO (R_PPC_REL16_LO,        /* type */
1424
         0,                      /* rightshift */
1425
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1426
         16,                    /* bitsize */
1427
         TRUE,                  /* pc_relative */
1428
         0,                      /* bitpos */
1429
         complain_overflow_dont,/* complain_on_overflow */
1430
         bfd_elf_generic_reloc, /* special_function */
1431
         "R_PPC_REL16_LO",      /* name */
1432
         FALSE,                 /* partial_inplace */
1433
         0,                      /* src_mask */
1434
         0xffff,                /* dst_mask */
1435
         TRUE),                 /* pcrel_offset */
1436
 
1437
  /* The high order 16 bits of a relative address.  */
1438
  HOWTO (R_PPC_REL16_HI,        /* type */
1439
         16,                    /* rightshift */
1440
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1441
         16,                    /* bitsize */
1442
         TRUE,                  /* pc_relative */
1443
         0,                      /* bitpos */
1444
         complain_overflow_dont, /* complain_on_overflow */
1445
         bfd_elf_generic_reloc, /* special_function */
1446
         "R_PPC_REL16_HI",      /* name */
1447
         FALSE,                 /* partial_inplace */
1448
         0,                      /* src_mask */
1449
         0xffff,                /* dst_mask */
1450
         TRUE),                 /* pcrel_offset */
1451
 
1452
  /* The high order 16 bits of a relative address, plus 1 if the contents of
1453
     the low 16 bits, treated as a signed number, is negative.  */
1454
  HOWTO (R_PPC_REL16_HA,        /* type */
1455
         16,                    /* rightshift */
1456
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457
         16,                    /* bitsize */
1458
         TRUE,                  /* pc_relative */
1459
         0,                      /* bitpos */
1460
         complain_overflow_dont, /* complain_on_overflow */
1461
         ppc_elf_addr16_ha_reloc, /* special_function */
1462
         "R_PPC_REL16_HA",      /* name */
1463
         FALSE,                 /* partial_inplace */
1464
         0,                      /* src_mask */
1465
         0xffff,                /* dst_mask */
1466
         TRUE),                 /* pcrel_offset */
1467
 
1468
  /* GNU extension to record C++ vtable hierarchy.  */
1469
  HOWTO (R_PPC_GNU_VTINHERIT,   /* type */
1470
         0,                      /* rightshift */
1471
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
1472
         0,                      /* bitsize */
1473
         FALSE,                 /* pc_relative */
1474
         0,                      /* bitpos */
1475
         complain_overflow_dont, /* complain_on_overflow */
1476
         NULL,                  /* special_function */
1477
         "R_PPC_GNU_VTINHERIT", /* name */
1478
         FALSE,                 /* partial_inplace */
1479
         0,                      /* src_mask */
1480
         0,                      /* dst_mask */
1481
         FALSE),                /* pcrel_offset */
1482
 
1483
  /* GNU extension to record C++ vtable member usage.  */
1484
  HOWTO (R_PPC_GNU_VTENTRY,     /* type */
1485
         0,                      /* rightshift */
1486
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
1487
         0,                      /* bitsize */
1488
         FALSE,                 /* pc_relative */
1489
         0,                      /* bitpos */
1490
         complain_overflow_dont, /* complain_on_overflow */
1491
         NULL,                  /* special_function */
1492
         "R_PPC_GNU_VTENTRY",   /* name */
1493
         FALSE,                 /* partial_inplace */
1494
         0,                      /* src_mask */
1495
         0,                      /* dst_mask */
1496
         FALSE),                /* pcrel_offset */
1497
 
1498
  /* Phony reloc to handle AIX style TOC entries.  */
1499
  HOWTO (R_PPC_TOC16,           /* type */
1500
         0,                      /* rightshift */
1501
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502
         16,                    /* bitsize */
1503
         FALSE,                 /* pc_relative */
1504
         0,                      /* bitpos */
1505
         complain_overflow_signed, /* complain_on_overflow */
1506
         bfd_elf_generic_reloc, /* special_function */
1507
         "R_PPC_TOC16",         /* name */
1508
         FALSE,                 /* partial_inplace */
1509
         0,                      /* src_mask */
1510
         0xffff,                /* dst_mask */
1511
         FALSE),                /* pcrel_offset */
1512
};
1513
 
1514
/* Initialize the ppc_elf_howto_table, so that linear accesses can be done.  */
1515
 
1516
static void
1517
ppc_elf_howto_init (void)
1518
{
1519
  unsigned int i, type;
1520
 
1521
  for (i = 0;
1522
       i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]);
1523
       i++)
1524
    {
1525
      type = ppc_elf_howto_raw[i].type;
1526
      if (type >= (sizeof (ppc_elf_howto_table)
1527
                   / sizeof (ppc_elf_howto_table[0])))
1528
        abort ();
1529
      ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
1530
    }
1531
}
1532
 
1533
static reloc_howto_type *
1534
ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1535
                           bfd_reloc_code_real_type code)
1536
{
1537
  enum elf_ppc_reloc_type r;
1538
 
1539
  /* Initialize howto table if not already done.  */
1540
  if (!ppc_elf_howto_table[R_PPC_ADDR32])
1541
    ppc_elf_howto_init ();
1542
 
1543
  switch (code)
1544
    {
1545
    default:
1546
      return NULL;
1547
 
1548
    case BFD_RELOC_NONE:                r = R_PPC_NONE;                 break;
1549
    case BFD_RELOC_32:                  r = R_PPC_ADDR32;               break;
1550
    case BFD_RELOC_PPC_BA26:            r = R_PPC_ADDR24;               break;
1551
    case BFD_RELOC_16:                  r = R_PPC_ADDR16;               break;
1552
    case BFD_RELOC_LO16:                r = R_PPC_ADDR16_LO;            break;
1553
    case BFD_RELOC_HI16:                r = R_PPC_ADDR16_HI;            break;
1554
    case BFD_RELOC_HI16_S:              r = R_PPC_ADDR16_HA;            break;
1555
    case BFD_RELOC_PPC_BA16:            r = R_PPC_ADDR14;               break;
1556
    case BFD_RELOC_PPC_BA16_BRTAKEN:    r = R_PPC_ADDR14_BRTAKEN;       break;
1557
    case BFD_RELOC_PPC_BA16_BRNTAKEN:   r = R_PPC_ADDR14_BRNTAKEN;      break;
1558
    case BFD_RELOC_PPC_B26:             r = R_PPC_REL24;                break;
1559
    case BFD_RELOC_PPC_B16:             r = R_PPC_REL14;                break;
1560
    case BFD_RELOC_PPC_B16_BRTAKEN:     r = R_PPC_REL14_BRTAKEN;        break;
1561
    case BFD_RELOC_PPC_B16_BRNTAKEN:    r = R_PPC_REL14_BRNTAKEN;       break;
1562
    case BFD_RELOC_16_GOTOFF:           r = R_PPC_GOT16;                break;
1563
    case BFD_RELOC_LO16_GOTOFF:         r = R_PPC_GOT16_LO;             break;
1564
    case BFD_RELOC_HI16_GOTOFF:         r = R_PPC_GOT16_HI;             break;
1565
    case BFD_RELOC_HI16_S_GOTOFF:       r = R_PPC_GOT16_HA;             break;
1566
    case BFD_RELOC_24_PLT_PCREL:        r = R_PPC_PLTREL24;             break;
1567
    case BFD_RELOC_PPC_COPY:            r = R_PPC_COPY;                 break;
1568
    case BFD_RELOC_PPC_GLOB_DAT:        r = R_PPC_GLOB_DAT;             break;
1569
    case BFD_RELOC_PPC_LOCAL24PC:       r = R_PPC_LOCAL24PC;            break;
1570
    case BFD_RELOC_32_PCREL:            r = R_PPC_REL32;                break;
1571
    case BFD_RELOC_32_PLTOFF:           r = R_PPC_PLT32;                break;
1572
    case BFD_RELOC_32_PLT_PCREL:        r = R_PPC_PLTREL32;             break;
1573
    case BFD_RELOC_LO16_PLTOFF:         r = R_PPC_PLT16_LO;             break;
1574
    case BFD_RELOC_HI16_PLTOFF:         r = R_PPC_PLT16_HI;             break;
1575
    case BFD_RELOC_HI16_S_PLTOFF:       r = R_PPC_PLT16_HA;             break;
1576
    case BFD_RELOC_GPREL16:             r = R_PPC_SDAREL16;             break;
1577
    case BFD_RELOC_16_BASEREL:          r = R_PPC_SECTOFF;              break;
1578
    case BFD_RELOC_LO16_BASEREL:        r = R_PPC_SECTOFF_LO;           break;
1579
    case BFD_RELOC_HI16_BASEREL:        r = R_PPC_SECTOFF_HI;           break;
1580
    case BFD_RELOC_HI16_S_BASEREL:      r = R_PPC_SECTOFF_HA;           break;
1581
    case BFD_RELOC_CTOR:                r = R_PPC_ADDR32;               break;
1582
    case BFD_RELOC_PPC_TOC16:           r = R_PPC_TOC16;                break;
1583
    case BFD_RELOC_PPC_TLS:             r = R_PPC_TLS;                  break;
1584
    case BFD_RELOC_PPC_TLSGD:           r = R_PPC_TLSGD;                break;
1585
    case BFD_RELOC_PPC_TLSLD:           r = R_PPC_TLSLD;                break;
1586
    case BFD_RELOC_PPC_DTPMOD:          r = R_PPC_DTPMOD32;             break;
1587
    case BFD_RELOC_PPC_TPREL16:         r = R_PPC_TPREL16;              break;
1588
    case BFD_RELOC_PPC_TPREL16_LO:      r = R_PPC_TPREL16_LO;           break;
1589
    case BFD_RELOC_PPC_TPREL16_HI:      r = R_PPC_TPREL16_HI;           break;
1590
    case BFD_RELOC_PPC_TPREL16_HA:      r = R_PPC_TPREL16_HA;           break;
1591
    case BFD_RELOC_PPC_TPREL:           r = R_PPC_TPREL32;              break;
1592
    case BFD_RELOC_PPC_DTPREL16:        r = R_PPC_DTPREL16;             break;
1593
    case BFD_RELOC_PPC_DTPREL16_LO:     r = R_PPC_DTPREL16_LO;          break;
1594
    case BFD_RELOC_PPC_DTPREL16_HI:     r = R_PPC_DTPREL16_HI;          break;
1595
    case BFD_RELOC_PPC_DTPREL16_HA:     r = R_PPC_DTPREL16_HA;          break;
1596
    case BFD_RELOC_PPC_DTPREL:          r = R_PPC_DTPREL32;             break;
1597
    case BFD_RELOC_PPC_GOT_TLSGD16:     r = R_PPC_GOT_TLSGD16;          break;
1598
    case BFD_RELOC_PPC_GOT_TLSGD16_LO:  r = R_PPC_GOT_TLSGD16_LO;       break;
1599
    case BFD_RELOC_PPC_GOT_TLSGD16_HI:  r = R_PPC_GOT_TLSGD16_HI;       break;
1600
    case BFD_RELOC_PPC_GOT_TLSGD16_HA:  r = R_PPC_GOT_TLSGD16_HA;       break;
1601
    case BFD_RELOC_PPC_GOT_TLSLD16:     r = R_PPC_GOT_TLSLD16;          break;
1602
    case BFD_RELOC_PPC_GOT_TLSLD16_LO:  r = R_PPC_GOT_TLSLD16_LO;       break;
1603
    case BFD_RELOC_PPC_GOT_TLSLD16_HI:  r = R_PPC_GOT_TLSLD16_HI;       break;
1604
    case BFD_RELOC_PPC_GOT_TLSLD16_HA:  r = R_PPC_GOT_TLSLD16_HA;       break;
1605
    case BFD_RELOC_PPC_GOT_TPREL16:     r = R_PPC_GOT_TPREL16;          break;
1606
    case BFD_RELOC_PPC_GOT_TPREL16_LO:  r = R_PPC_GOT_TPREL16_LO;       break;
1607
    case BFD_RELOC_PPC_GOT_TPREL16_HI:  r = R_PPC_GOT_TPREL16_HI;       break;
1608
    case BFD_RELOC_PPC_GOT_TPREL16_HA:  r = R_PPC_GOT_TPREL16_HA;       break;
1609
    case BFD_RELOC_PPC_GOT_DTPREL16:    r = R_PPC_GOT_DTPREL16;         break;
1610
    case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC_GOT_DTPREL16_LO;      break;
1611
    case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC_GOT_DTPREL16_HI;      break;
1612
    case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC_GOT_DTPREL16_HA;      break;
1613
    case BFD_RELOC_PPC_EMB_NADDR32:     r = R_PPC_EMB_NADDR32;          break;
1614
    case BFD_RELOC_PPC_EMB_NADDR16:     r = R_PPC_EMB_NADDR16;          break;
1615
    case BFD_RELOC_PPC_EMB_NADDR16_LO:  r = R_PPC_EMB_NADDR16_LO;       break;
1616
    case BFD_RELOC_PPC_EMB_NADDR16_HI:  r = R_PPC_EMB_NADDR16_HI;       break;
1617
    case BFD_RELOC_PPC_EMB_NADDR16_HA:  r = R_PPC_EMB_NADDR16_HA;       break;
1618
    case BFD_RELOC_PPC_EMB_SDAI16:      r = R_PPC_EMB_SDAI16;           break;
1619
    case BFD_RELOC_PPC_EMB_SDA2I16:     r = R_PPC_EMB_SDA2I16;          break;
1620
    case BFD_RELOC_PPC_EMB_SDA2REL:     r = R_PPC_EMB_SDA2REL;          break;
1621
    case BFD_RELOC_PPC_EMB_SDA21:       r = R_PPC_EMB_SDA21;            break;
1622
    case BFD_RELOC_PPC_EMB_MRKREF:      r = R_PPC_EMB_MRKREF;           break;
1623
    case BFD_RELOC_PPC_EMB_RELSEC16:    r = R_PPC_EMB_RELSEC16;         break;
1624
    case BFD_RELOC_PPC_EMB_RELST_LO:    r = R_PPC_EMB_RELST_LO;         break;
1625
    case BFD_RELOC_PPC_EMB_RELST_HI:    r = R_PPC_EMB_RELST_HI;         break;
1626
    case BFD_RELOC_PPC_EMB_RELST_HA:    r = R_PPC_EMB_RELST_HA;         break;
1627
    case BFD_RELOC_PPC_EMB_BIT_FLD:     r = R_PPC_EMB_BIT_FLD;          break;
1628
    case BFD_RELOC_PPC_EMB_RELSDA:      r = R_PPC_EMB_RELSDA;           break;
1629
    case BFD_RELOC_16_PCREL:            r = R_PPC_REL16;                break;
1630
    case BFD_RELOC_LO16_PCREL:          r = R_PPC_REL16_LO;             break;
1631
    case BFD_RELOC_HI16_PCREL:          r = R_PPC_REL16_HI;             break;
1632
    case BFD_RELOC_HI16_S_PCREL:        r = R_PPC_REL16_HA;             break;
1633
    case BFD_RELOC_VTABLE_INHERIT:      r = R_PPC_GNU_VTINHERIT;        break;
1634
    case BFD_RELOC_VTABLE_ENTRY:        r = R_PPC_GNU_VTENTRY;          break;
1635
    }
1636
 
1637
  return ppc_elf_howto_table[r];
1638
};
1639
 
1640
static reloc_howto_type *
1641
ppc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1642
                           const char *r_name)
1643
{
1644
  unsigned int i;
1645
 
1646
  for (i = 0;
1647
       i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]);
1648
       i++)
1649
    if (ppc_elf_howto_raw[i].name != NULL
1650
        && strcasecmp (ppc_elf_howto_raw[i].name, r_name) == 0)
1651
      return &ppc_elf_howto_raw[i];
1652
 
1653
  return NULL;
1654
}
1655
 
1656
/* Set the howto pointer for a PowerPC ELF reloc.  */
1657
 
1658
static void
1659
ppc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1660
                       arelent *cache_ptr,
1661
                       Elf_Internal_Rela *dst)
1662
{
1663
  /* Initialize howto table if not already done.  */
1664
  if (!ppc_elf_howto_table[R_PPC_ADDR32])
1665
    ppc_elf_howto_init ();
1666
 
1667
  BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
1668
  cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
1669
 
1670
  /* Just because the above assert didn't trigger doesn't mean that
1671
     ELF32_R_TYPE (dst->r_info) is necessarily a valid relocation.  */
1672
  if (!cache_ptr->howto)
1673
    {
1674
      (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
1675
                             abfd, ELF32_R_TYPE (dst->r_info));
1676
      bfd_set_error (bfd_error_bad_value);
1677
 
1678
      cache_ptr->howto = ppc_elf_howto_table[R_PPC_NONE];
1679
    }
1680
}
1681
 
1682
/* Handle the R_PPC_ADDR16_HA and R_PPC_REL16_HA relocs.  */
1683
 
1684
static bfd_reloc_status_type
1685
ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1686
                         arelent *reloc_entry,
1687
                         asymbol *symbol,
1688
                         void *data ATTRIBUTE_UNUSED,
1689
                         asection *input_section,
1690
                         bfd *output_bfd,
1691
                         char **error_message ATTRIBUTE_UNUSED)
1692
{
1693
  bfd_vma relocation;
1694
 
1695
  if (output_bfd != NULL)
1696
    {
1697
      reloc_entry->address += input_section->output_offset;
1698
      return bfd_reloc_ok;
1699
    }
1700
 
1701
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1702
    return bfd_reloc_outofrange;
1703
 
1704
  if (bfd_is_com_section (symbol->section))
1705
    relocation = 0;
1706
  else
1707
    relocation = symbol->value;
1708
 
1709
  relocation += symbol->section->output_section->vma;
1710
  relocation += symbol->section->output_offset;
1711
  relocation += reloc_entry->addend;
1712
  if (reloc_entry->howto->pc_relative)
1713
    relocation -= reloc_entry->address;
1714
 
1715
  reloc_entry->addend += (relocation & 0x8000) << 1;
1716
 
1717
  return bfd_reloc_continue;
1718
}
1719
 
1720
static bfd_reloc_status_type
1721
ppc_elf_unhandled_reloc (bfd *abfd,
1722
                         arelent *reloc_entry,
1723
                         asymbol *symbol,
1724
                         void *data,
1725
                         asection *input_section,
1726
                         bfd *output_bfd,
1727
                         char **error_message)
1728
{
1729
  /* If this is a relocatable link (output_bfd test tells us), just
1730
     call the generic function.  Any adjustment will be done at final
1731
     link time.  */
1732
  if (output_bfd != NULL)
1733
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1734
                                  input_section, output_bfd, error_message);
1735
 
1736
  if (error_message != NULL)
1737
    {
1738
      static char buf[60];
1739
      sprintf (buf, _("generic linker can't handle %s"),
1740
               reloc_entry->howto->name);
1741
      *error_message = buf;
1742
    }
1743
  return bfd_reloc_dangerous;
1744
}
1745
 
1746
/* Sections created by the linker.  */
1747
 
1748
typedef struct elf_linker_section
1749
{
1750
  /* Pointer to the bfd section.  */
1751
  asection *section;
1752
  /* Section name.  */
1753
  const char *name;
1754
  /* Associated bss section name.  */
1755
  const char *bss_name;
1756
  /* Associated symbol name.  */
1757
  const char *sym_name;
1758
  /* Associated symbol.  */
1759
  struct elf_link_hash_entry *sym;
1760
} elf_linker_section_t;
1761
 
1762
/* Linked list of allocated pointer entries.  This hangs off of the
1763
   symbol lists, and provides allows us to return different pointers,
1764
   based on different addend's.  */
1765
 
1766
typedef struct elf_linker_section_pointers
1767
{
1768
  /* next allocated pointer for this symbol */
1769
  struct elf_linker_section_pointers *next;
1770
  /* offset of pointer from beginning of section */
1771
  bfd_vma offset;
1772
  /* addend used */
1773
  bfd_vma addend;
1774
  /* which linker section this is */
1775
  elf_linker_section_t *lsect;
1776
} elf_linker_section_pointers_t;
1777
 
1778
struct ppc_elf_obj_tdata
1779
{
1780
  struct elf_obj_tdata elf;
1781
 
1782
  /* A mapping from local symbols to offsets into the various linker
1783
     sections added.  This is index by the symbol index.  */
1784
  elf_linker_section_pointers_t **linker_section_pointers;
1785
 
1786
  /* Flags used to auto-detect plt type.  */
1787
  unsigned int makes_plt_call : 1;
1788
  unsigned int has_rel16 : 1;
1789
};
1790
 
1791
#define ppc_elf_tdata(bfd) \
1792
  ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any)
1793
 
1794
#define elf_local_ptr_offsets(bfd) \
1795
  (ppc_elf_tdata (bfd)->linker_section_pointers)
1796
 
1797
#define is_ppc_elf(bfd) \
1798
  (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1799
   && elf_object_id (bfd) == PPC32_ELF_DATA)
1800
 
1801
/* Override the generic function because we store some extras.  */
1802
 
1803
static bfd_boolean
1804
ppc_elf_mkobject (bfd *abfd)
1805
{
1806
  return bfd_elf_allocate_object (abfd, sizeof (struct ppc_elf_obj_tdata),
1807
                                  PPC32_ELF_DATA);
1808
}
1809
 
1810
/* Fix bad default arch selected for a 32 bit input bfd when the
1811
   default is 64 bit.  */
1812
 
1813
static bfd_boolean
1814
ppc_elf_object_p (bfd *abfd)
1815
{
1816
  if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 64)
1817
    {
1818
      Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
1819
 
1820
      if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS32)
1821
        {
1822
          /* Relies on arch after 64 bit default being 32 bit default.  */
1823
          abfd->arch_info = abfd->arch_info->next;
1824
          BFD_ASSERT (abfd->arch_info->bits_per_word == 32);
1825
        }
1826
    }
1827
  return TRUE;
1828
}
1829
 
1830
/* Function to set whether a module needs the -mrelocatable bit set.  */
1831
 
1832
static bfd_boolean
1833
ppc_elf_set_private_flags (bfd *abfd, flagword flags)
1834
{
1835
  BFD_ASSERT (!elf_flags_init (abfd)
1836
              || elf_elfheader (abfd)->e_flags == flags);
1837
 
1838
  elf_elfheader (abfd)->e_flags = flags;
1839
  elf_flags_init (abfd) = TRUE;
1840
  return TRUE;
1841
}
1842
 
1843
/* Support for core dump NOTE sections.  */
1844
 
1845
static bfd_boolean
1846
ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1847
{
1848
  int offset;
1849
  unsigned int size;
1850
 
1851
  switch (note->descsz)
1852
    {
1853
    default:
1854
      return FALSE;
1855
 
1856
    case 268:           /* Linux/PPC.  */
1857
      /* pr_cursig */
1858
      elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1859
 
1860
      /* pr_pid */
1861
      elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1862
 
1863
      /* pr_reg */
1864
      offset = 72;
1865
      size = 192;
1866
 
1867
      break;
1868
    }
1869
 
1870
  /* Make a ".reg/999" section.  */
1871
  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1872
                                          size, note->descpos + offset);
1873
}
1874
 
1875
static bfd_boolean
1876
ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1877
{
1878
  switch (note->descsz)
1879
    {
1880
    default:
1881
      return FALSE;
1882
 
1883
    case 128:           /* Linux/PPC elf_prpsinfo.  */
1884
      elf_tdata (abfd)->core_program
1885
        = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
1886
      elf_tdata (abfd)->core_command
1887
        = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
1888
    }
1889
 
1890
  /* Note that for some reason, a spurious space is tacked
1891
     onto the end of the args in some (at least one anyway)
1892
     implementations, so strip it off if it exists.  */
1893
 
1894
  {
1895
    char *command = elf_tdata (abfd)->core_command;
1896
    int n = strlen (command);
1897
 
1898
    if (0 < n && command[n - 1] == ' ')
1899
      command[n - 1] = '\0';
1900
  }
1901
 
1902
  return TRUE;
1903
}
1904
 
1905
static char *
1906
ppc_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...)
1907
{
1908
  switch (note_type)
1909
    {
1910
    default:
1911
      return NULL;
1912
 
1913
    case NT_PRPSINFO:
1914
      {
1915
        char data[128];
1916
        va_list ap;
1917
 
1918
        va_start (ap, note_type);
1919
        memset (data, 0, 32);
1920
        strncpy (data + 32, va_arg (ap, const char *), 16);
1921
        strncpy (data + 48, va_arg (ap, const char *), 80);
1922
        va_end (ap);
1923
        return elfcore_write_note (abfd, buf, bufsiz,
1924
                                   "CORE", note_type, data, sizeof (data));
1925
      }
1926
 
1927
    case NT_PRSTATUS:
1928
      {
1929
        char data[268];
1930
        va_list ap;
1931
        long pid;
1932
        int cursig;
1933
        const void *greg;
1934
 
1935
        va_start (ap, note_type);
1936
        memset (data, 0, 72);
1937
        pid = va_arg (ap, long);
1938
        bfd_put_32 (abfd, pid, data + 24);
1939
        cursig = va_arg (ap, int);
1940
        bfd_put_16 (abfd, cursig, data + 12);
1941
        greg = va_arg (ap, const void *);
1942
        memcpy (data + 72, greg, 192);
1943
        memset (data + 264, 0, 4);
1944
        va_end (ap);
1945
        return elfcore_write_note (abfd, buf, bufsiz,
1946
                                   "CORE", note_type, data, sizeof (data));
1947
      }
1948
    }
1949
}
1950
 
1951
/* Return address for Ith PLT stub in section PLT, for relocation REL
1952
   or (bfd_vma) -1 if it should not be included.  */
1953
 
1954
static bfd_vma
1955
ppc_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
1956
                     const asection *plt ATTRIBUTE_UNUSED,
1957
                     const arelent *rel)
1958
{
1959
  return rel->address;
1960
}
1961
 
1962
/* Handle a PowerPC specific section when reading an object file.  This
1963
   is called when bfd_section_from_shdr finds a section with an unknown
1964
   type.  */
1965
 
1966
static bfd_boolean
1967
ppc_elf_section_from_shdr (bfd *abfd,
1968
                           Elf_Internal_Shdr *hdr,
1969
                           const char *name,
1970
                           int shindex)
1971
{
1972
  asection *newsect;
1973
  flagword flags;
1974
 
1975
  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1976
    return FALSE;
1977
 
1978
  newsect = hdr->bfd_section;
1979
  flags = bfd_get_section_flags (abfd, newsect);
1980
  if (hdr->sh_flags & SHF_EXCLUDE)
1981
    flags |= SEC_EXCLUDE;
1982
 
1983
  if (hdr->sh_type == SHT_ORDERED)
1984
    flags |= SEC_SORT_ENTRIES;
1985
 
1986
  bfd_set_section_flags (abfd, newsect, flags);
1987
  return TRUE;
1988
}
1989
 
1990
/* Set up any other section flags and such that may be necessary.  */
1991
 
1992
static bfd_boolean
1993
ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
1994
                       Elf_Internal_Shdr *shdr,
1995
                       asection *asect)
1996
{
1997
  if ((asect->flags & SEC_SORT_ENTRIES) != 0)
1998
    shdr->sh_type = SHT_ORDERED;
1999
 
2000
  return TRUE;
2001
}
2002
 
2003
/* If we have .sbss2 or .PPC.EMB.sbss0 output sections, we
2004
   need to bump up the number of section headers.  */
2005
 
2006
static int
2007
ppc_elf_additional_program_headers (bfd *abfd,
2008
                                    struct bfd_link_info *info ATTRIBUTE_UNUSED)
2009
{
2010
  asection *s;
2011
  int ret = 0;
2012
 
2013
  s = bfd_get_section_by_name (abfd, ".sbss2");
2014
  if (s != NULL && (s->flags & SEC_ALLOC) != 0)
2015
    ++ret;
2016
 
2017
  s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
2018
  if (s != NULL && (s->flags & SEC_ALLOC) != 0)
2019
    ++ret;
2020
 
2021
  return ret;
2022
}
2023
 
2024
/* Add extra PPC sections -- Note, for now, make .sbss2 and
2025
   .PPC.EMB.sbss0 a normal section, and not a bss section so
2026
   that the linker doesn't crater when trying to make more than
2027
   2 sections.  */
2028
 
2029
static const struct bfd_elf_special_section ppc_elf_special_sections[] =
2030
{
2031
  { STRING_COMMA_LEN (".plt"),             0, SHT_NOBITS,   SHF_ALLOC + SHF_EXECINSTR },
2032
  { STRING_COMMA_LEN (".sbss"),           -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2033
  { STRING_COMMA_LEN (".sbss2"),          -2, SHT_PROGBITS, SHF_ALLOC },
2034
  { STRING_COMMA_LEN (".sdata"),          -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2035
  { STRING_COMMA_LEN (".sdata2"),         -2, SHT_PROGBITS, SHF_ALLOC },
2036
  { STRING_COMMA_LEN (".tags"),            0, SHT_ORDERED,  SHF_ALLOC },
2037
  { STRING_COMMA_LEN (".PPC.EMB.apuinfo"), 0, SHT_NOTE,     0 },
2038
  { STRING_COMMA_LEN (".PPC.EMB.sbss0"),   0, SHT_PROGBITS, SHF_ALLOC },
2039
  { STRING_COMMA_LEN (".PPC.EMB.sdata0"),  0, SHT_PROGBITS, SHF_ALLOC },
2040
  { NULL,                              0,  0, 0,            0 }
2041
};
2042
 
2043
/* This is what we want for new plt/got.  */
2044
static struct bfd_elf_special_section ppc_alt_plt =
2045
  { STRING_COMMA_LEN (".plt"),             0, SHT_PROGBITS, SHF_ALLOC };
2046
 
2047
static const struct bfd_elf_special_section *
2048
ppc_elf_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
2049
{
2050
  const struct bfd_elf_special_section *ssect;
2051
 
2052
  /* See if this is one of the special sections.  */
2053
  if (sec->name == NULL)
2054
    return NULL;
2055
 
2056
  ssect = _bfd_elf_get_special_section (sec->name, ppc_elf_special_sections,
2057
                                        sec->use_rela_p);
2058
  if (ssect != NULL)
2059
    {
2060
      if (ssect == ppc_elf_special_sections && (sec->flags & SEC_LOAD) != 0)
2061
        ssect = &ppc_alt_plt;
2062
      return ssect;
2063
    }
2064
 
2065
  return _bfd_elf_get_sec_type_attr (abfd, sec);
2066
}
2067
 
2068
/* Very simple linked list structure for recording apuinfo values.  */
2069
typedef struct apuinfo_list
2070
{
2071
  struct apuinfo_list *next;
2072
  unsigned long value;
2073
}
2074
apuinfo_list;
2075
 
2076
static apuinfo_list *head;
2077
static bfd_boolean apuinfo_set;
2078
 
2079
static void
2080
apuinfo_list_init (void)
2081
{
2082
  head = NULL;
2083
  apuinfo_set = FALSE;
2084
}
2085
 
2086
static void
2087
apuinfo_list_add (unsigned long value)
2088
{
2089
  apuinfo_list *entry = head;
2090
 
2091
  while (entry != NULL)
2092
    {
2093
      if (entry->value == value)
2094
        return;
2095
      entry = entry->next;
2096
    }
2097
 
2098
  entry = bfd_malloc (sizeof (* entry));
2099
  if (entry == NULL)
2100
    return;
2101
 
2102
  entry->value = value;
2103
  entry->next  = head;
2104
  head = entry;
2105
}
2106
 
2107
static unsigned
2108
apuinfo_list_length (void)
2109
{
2110
  apuinfo_list *entry;
2111
  unsigned long count;
2112
 
2113
  for (entry = head, count = 0;
2114
       entry;
2115
       entry = entry->next)
2116
    ++ count;
2117
 
2118
  return count;
2119
}
2120
 
2121
static inline unsigned long
2122
apuinfo_list_element (unsigned long number)
2123
{
2124
  apuinfo_list * entry;
2125
 
2126
  for (entry = head;
2127
       entry && number --;
2128
       entry = entry->next)
2129
    ;
2130
 
2131
  return entry ? entry->value : 0;
2132
}
2133
 
2134
static void
2135
apuinfo_list_finish (void)
2136
{
2137
  apuinfo_list *entry;
2138
 
2139
  for (entry = head; entry;)
2140
    {
2141
      apuinfo_list *next = entry->next;
2142
      free (entry);
2143
      entry = next;
2144
    }
2145
 
2146
  head = NULL;
2147
}
2148
 
2149
#define APUINFO_SECTION_NAME    ".PPC.EMB.apuinfo"
2150
#define APUINFO_LABEL           "APUinfo"
2151
 
2152
/* Scan the input BFDs and create a linked list of
2153
   the APUinfo values that will need to be emitted.  */
2154
 
2155
static void
2156
ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info)
2157
{
2158
  bfd *ibfd;
2159
  asection *asec;
2160
  char *buffer = NULL;
2161
  bfd_size_type largest_input_size = 0;
2162
  unsigned i;
2163
  unsigned long length;
2164
  const char *error_message = NULL;
2165
 
2166
  if (link_info == NULL)
2167
    return;
2168
 
2169
  apuinfo_list_init ();
2170
 
2171
  /* Read in the input sections contents.  */
2172
  for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next)
2173
    {
2174
      unsigned long datum;
2175
 
2176
      asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
2177
      if (asec == NULL)
2178
        continue;
2179
 
2180
      error_message = _("corrupt %s section in %B");
2181
      length = asec->size;
2182
      if (length < 20)
2183
        goto fail;
2184
 
2185
      apuinfo_set = TRUE;
2186
      if (largest_input_size < asec->size)
2187
        {
2188
          if (buffer)
2189
            free (buffer);
2190
          largest_input_size = asec->size;
2191
          buffer = bfd_malloc (largest_input_size);
2192
          if (!buffer)
2193
            return;
2194
        }
2195
 
2196
      if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0
2197
          || (bfd_bread (buffer, length, ibfd) != length))
2198
        {
2199
          error_message = _("unable to read in %s section from %B");
2200
          goto fail;
2201
        }
2202
 
2203
      /* Verify the contents of the header.  Note - we have to
2204
         extract the values this way in order to allow for a
2205
         host whose endian-ness is different from the target.  */
2206
      datum = bfd_get_32 (ibfd, buffer);
2207
      if (datum != sizeof APUINFO_LABEL)
2208
        goto fail;
2209
 
2210
      datum = bfd_get_32 (ibfd, buffer + 8);
2211
      if (datum != 0x2)
2212
        goto fail;
2213
 
2214
      if (strcmp (buffer + 12, APUINFO_LABEL) != 0)
2215
        goto fail;
2216
 
2217
      /* Get the number of bytes used for apuinfo entries.  */
2218
      datum = bfd_get_32 (ibfd, buffer + 4);
2219
      if (datum + 20 != length)
2220
        goto fail;
2221
 
2222
      /* Scan the apuinfo section, building a list of apuinfo numbers.  */
2223
      for (i = 0; i < datum; i += 4)
2224
        apuinfo_list_add (bfd_get_32 (ibfd, buffer + 20 + i));
2225
    }
2226
 
2227
  error_message = NULL;
2228
 
2229
  if (apuinfo_set)
2230
    {
2231
      /* Compute the size of the output section.  */
2232
      unsigned num_entries = apuinfo_list_length ();
2233
 
2234
      /* Set the output section size, if it exists.  */
2235
      asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
2236
 
2237
      if (asec && ! bfd_set_section_size (abfd, asec, 20 + num_entries * 4))
2238
        {
2239
          ibfd = abfd;
2240
          error_message = _("warning: unable to set size of %s section in %B");
2241
        }
2242
    }
2243
 
2244
 fail:
2245
  if (buffer)
2246
    free (buffer);
2247
 
2248
  if (error_message)
2249
    (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME);
2250
}
2251
 
2252
/* Prevent the output section from accumulating the input sections'
2253
   contents.  We have already stored this in our linked list structure.  */
2254
 
2255
static bfd_boolean
2256
ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED,
2257
                       struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2258
                       asection *asec,
2259
                       bfd_byte *contents ATTRIBUTE_UNUSED)
2260
{
2261
  return apuinfo_set && strcmp (asec->name, APUINFO_SECTION_NAME) == 0;
2262
}
2263
 
2264
/* Finally we can generate the output section.  */
2265
 
2266
static void
2267
ppc_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
2268
{
2269
  bfd_byte *buffer;
2270
  asection *asec;
2271
  unsigned i;
2272
  unsigned num_entries;
2273
  bfd_size_type length;
2274
 
2275
  asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
2276
  if (asec == NULL)
2277
    return;
2278
 
2279
  if (!apuinfo_set)
2280
    return;
2281
 
2282
  length = asec->size;
2283
  if (length < 20)
2284
    return;
2285
 
2286
  buffer = bfd_malloc (length);
2287
  if (buffer == NULL)
2288
    {
2289
      (*_bfd_error_handler)
2290
        (_("failed to allocate space for new APUinfo section."));
2291
      return;
2292
    }
2293
 
2294
  /* Create the apuinfo header.  */
2295
  num_entries = apuinfo_list_length ();
2296
  bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer);
2297
  bfd_put_32 (abfd, num_entries * 4, buffer + 4);
2298
  bfd_put_32 (abfd, 0x2, buffer + 8);
2299
  strcpy ((char *) buffer + 12, APUINFO_LABEL);
2300
 
2301
  length = 20;
2302
  for (i = 0; i < num_entries; i++)
2303
    {
2304
      bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
2305
      length += 4;
2306
    }
2307
 
2308
  if (length != asec->size)
2309
    (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
2310
 
2311
  if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
2312
    (*_bfd_error_handler) (_("failed to install new APUinfo section."));
2313
 
2314
  free (buffer);
2315
 
2316
  apuinfo_list_finish ();
2317
}
2318
 
2319
static bfd_boolean
2320
is_nonpic_glink_stub (bfd *abfd, asection *glink, bfd_vma off)
2321
{
2322
  bfd_byte buf[GLINK_ENTRY_SIZE];
2323
 
2324
  if (!bfd_get_section_contents (abfd, glink, buf, off, GLINK_ENTRY_SIZE))
2325
    return FALSE;
2326
 
2327
  return ((bfd_get_32 (abfd, buf + 0) & 0xffff0000) == LIS_11
2328
          && (bfd_get_32 (abfd, buf + 4) & 0xffff0000) == LWZ_11_11
2329
          && bfd_get_32 (abfd, buf + 8) == MTCTR_11
2330
          && bfd_get_32 (abfd, buf + 12) == BCTR);
2331
}
2332
 
2333
static bfd_boolean
2334
section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2335
{
2336
  bfd_vma vma = *(bfd_vma *) ptr;
2337
  return ((section->flags & SEC_ALLOC) != 0
2338
          && section->vma <= vma
2339
          && vma < section->vma + section->size);
2340
}
2341
 
2342
static long
2343
ppc_elf_get_synthetic_symtab (bfd *abfd, long symcount, asymbol **syms,
2344
                              long dynsymcount, asymbol **dynsyms,
2345
                              asymbol **ret)
2346
{
2347
  bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2348
  asection *plt, *relplt, *dynamic, *glink;
2349
  bfd_vma glink_vma = 0;
2350
  bfd_vma resolv_vma = 0;
2351
  bfd_vma stub_vma;
2352
  asymbol *s;
2353
  arelent *p;
2354
  long count, i;
2355
  size_t size;
2356
  char *names;
2357
  bfd_byte buf[4];
2358
 
2359
  *ret = NULL;
2360
 
2361
  if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
2362
    return 0;
2363
 
2364
  if (dynsymcount <= 0)
2365
    return 0;
2366
 
2367
  relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2368
  if (relplt == NULL)
2369
    return 0;
2370
 
2371
  plt = bfd_get_section_by_name (abfd, ".plt");
2372
  if (plt == NULL)
2373
    return 0;
2374
 
2375
  /* Call common code to handle old-style executable PLTs.  */
2376
  if (elf_section_flags (plt) & SHF_EXECINSTR)
2377
    return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms,
2378
                                          dynsymcount, dynsyms, ret);
2379
 
2380
  /* If this object was prelinked, the prelinker stored the address
2381
     of .glink at got[1].  If it wasn't prelinked, got[1] will be zero.  */
2382
  dynamic = bfd_get_section_by_name (abfd, ".dynamic");
2383
  if (dynamic != NULL)
2384
    {
2385
      bfd_byte *dynbuf, *extdyn, *extdynend;
2386
      size_t extdynsize;
2387
      void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
2388
 
2389
      if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
2390
        return -1;
2391
 
2392
      extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
2393
      swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
2394
 
2395
      extdyn = dynbuf;
2396
      extdynend = extdyn + dynamic->size;
2397
      for (; extdyn < extdynend; extdyn += extdynsize)
2398
        {
2399
          Elf_Internal_Dyn dyn;
2400
          (*swap_dyn_in) (abfd, extdyn, &dyn);
2401
 
2402
          if (dyn.d_tag == DT_NULL)
2403
            break;
2404
 
2405
          if (dyn.d_tag == DT_PPC_GOT)
2406
            {
2407
              unsigned int g_o_t = dyn.d_un.d_val;
2408
              asection *got = bfd_get_section_by_name (abfd, ".got");
2409
              if (got != NULL
2410
                  && bfd_get_section_contents (abfd, got, buf,
2411
                                               g_o_t - got->vma + 4, 4))
2412
                glink_vma = bfd_get_32 (abfd, buf);
2413
              break;
2414
            }
2415
        }
2416
      free (dynbuf);
2417
    }
2418
 
2419
  /* Otherwise we read the first plt entry.  */
2420
  if (glink_vma == 0)
2421
    {
2422
      if (bfd_get_section_contents (abfd, plt, buf, 0, 4))
2423
        glink_vma = bfd_get_32 (abfd, buf);
2424
    }
2425
 
2426
  if (glink_vma == 0)
2427
    return 0;
2428
 
2429
  /* The .glink section usually does not survive the final
2430
     link; search for the section (usually .text) where the
2431
     glink stubs now reside.  */
2432
  glink = bfd_sections_find_if (abfd, section_covers_vma, &glink_vma);
2433
  if (glink == NULL)
2434
    return 0;
2435
 
2436
  /* Determine glink PLT resolver by reading the relative branch
2437
     from the first glink stub.  */
2438
  if (bfd_get_section_contents (abfd, glink, buf,
2439
                                glink_vma - glink->vma, 4))
2440
    {
2441
      unsigned int insn = bfd_get_32 (abfd, buf);
2442
 
2443
      /* The first glink stub may either branch to the resolver ...  */
2444
      insn ^= B;
2445
      if ((insn & ~0x3fffffc) == 0)
2446
        resolv_vma = glink_vma + (insn ^ 0x2000000) - 0x2000000;
2447
 
2448
      /* ... or fall through a bunch of NOPs.  */
2449
      else if ((insn ^ B ^ NOP) == 0)
2450
        for (i = 4;
2451
             bfd_get_section_contents (abfd, glink, buf,
2452
                                       glink_vma - glink->vma + i, 4);
2453
             i += 4)
2454
          if (bfd_get_32 (abfd, buf) != NOP)
2455
            {
2456
              resolv_vma = glink_vma + i;
2457
              break;
2458
            }
2459
    }
2460
 
2461
  count = relplt->size / sizeof (Elf32_External_Rela);
2462
  stub_vma = glink_vma - (bfd_vma) count * 16;
2463
  /* If the stubs are those for -shared/-pie then we might have
2464
     multiple stubs for each plt entry.  If that is the case then
2465
     there is no way to associate stubs with their plt entries short
2466
     of figuring out the GOT pointer value used in the stub.  */
2467
  if (!is_nonpic_glink_stub (abfd, glink,
2468
                             glink_vma - GLINK_ENTRY_SIZE - glink->vma))
2469
    return 0;
2470
 
2471
  slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2472
  if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
2473
    return -1;
2474
 
2475
  size = count * sizeof (asymbol);
2476
  p = relplt->relocation;
2477
  for (i = 0; i < count; i++, p++)
2478
    {
2479
      size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2480
      if (p->addend != 0)
2481
        size += sizeof ("+0x") - 1 + 8;
2482
    }
2483
 
2484
  size += sizeof (asymbol) + sizeof ("__glink");
2485
 
2486
  if (resolv_vma)
2487
    size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
2488
 
2489
  s = *ret = bfd_malloc (size);
2490
  if (s == NULL)
2491
    return -1;
2492
 
2493
  names = (char *) (s + count + 1 + (resolv_vma != 0));
2494
  p = relplt->relocation;
2495
  for (i = 0; i < count; i++, p++)
2496
    {
2497
      size_t len;
2498
 
2499
      *s = **p->sym_ptr_ptr;
2500
      /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
2501
         we are defining a symbol, ensure one of them is set.  */
2502
      if ((s->flags & BSF_LOCAL) == 0)
2503
        s->flags |= BSF_GLOBAL;
2504
      s->flags |= BSF_SYNTHETIC;
2505
      s->section = glink;
2506
      s->value = stub_vma - glink->vma;
2507
      s->name = names;
2508
      s->udata.p = NULL;
2509
      len = strlen ((*p->sym_ptr_ptr)->name);
2510
      memcpy (names, (*p->sym_ptr_ptr)->name, len);
2511
      names += len;
2512
      if (p->addend != 0)
2513
        {
2514
          memcpy (names, "+0x", sizeof ("+0x") - 1);
2515
          names += sizeof ("+0x") - 1;
2516
          bfd_sprintf_vma (abfd, names, p->addend);
2517
          names += strlen (names);
2518
        }
2519
      memcpy (names, "@plt", sizeof ("@plt"));
2520
      names += sizeof ("@plt");
2521
      ++s;
2522
      stub_vma += 16;
2523
    }
2524
 
2525
  /* Add a symbol at the start of the glink branch table.  */
2526
  memset (s, 0, sizeof *s);
2527
  s->the_bfd = abfd;
2528
  s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
2529
  s->section = glink;
2530
  s->value = glink_vma - glink->vma;
2531
  s->name = names;
2532
  memcpy (names, "__glink", sizeof ("__glink"));
2533
  names += sizeof ("__glink");
2534
  s++;
2535
  count++;
2536
 
2537
  if (resolv_vma)
2538
    {
2539
      /* Add a symbol for the glink PLT resolver.  */
2540
      memset (s, 0, sizeof *s);
2541
      s->the_bfd = abfd;
2542
      s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
2543
      s->section = glink;
2544
      s->value = resolv_vma - glink->vma;
2545
      s->name = names;
2546
      memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
2547
      names += sizeof ("__glink_PLTresolve");
2548
      s++;
2549
      count++;
2550
    }
2551
 
2552
  return count;
2553
}
2554
 
2555
/* The following functions are specific to the ELF linker, while
2556
   functions above are used generally.  They appear in this file more
2557
   or less in the order in which they are called.  eg.
2558
   ppc_elf_check_relocs is called early in the link process,
2559
   ppc_elf_finish_dynamic_sections is one of the last functions
2560
   called.  */
2561
 
2562
/* The PPC linker needs to keep track of the number of relocs that it
2563
   decides to copy as dynamic relocs in check_relocs for each symbol.
2564
   This is so that it can later discard them if they are found to be
2565
   unnecessary.  We store the information in a field extending the
2566
   regular ELF linker hash table.  */
2567
 
2568
struct ppc_elf_dyn_relocs
2569
{
2570
  struct ppc_elf_dyn_relocs *next;
2571
 
2572
  /* The input section of the reloc.  */
2573
  asection *sec;
2574
 
2575
  /* Total number of relocs copied for the input section.  */
2576
  bfd_size_type count;
2577
 
2578
  /* Number of pc-relative relocs copied for the input section.  */
2579
  bfd_size_type pc_count;
2580
};
2581
 
2582
/* Track PLT entries needed for a given symbol.  We might need more
2583
   than one glink entry per symbol when generating a pic binary.  */
2584
struct plt_entry
2585
{
2586
  struct plt_entry *next;
2587
 
2588
  /* -fPIC uses multiple GOT sections, one per file, called ".got2".
2589
     This field stores the offset into .got2 used to initialise the
2590
     GOT pointer reg.  It will always be at least 32768.  (Current
2591
     gcc always uses an offset of 32768, but ld -r will pack .got2
2592
     sections together resulting in larger offsets).  */
2593
  bfd_vma addend;
2594
 
2595
  /* The .got2 section.  */
2596
  asection *sec;
2597
 
2598
  /* PLT refcount or offset.  */
2599
  union
2600
    {
2601
      bfd_signed_vma refcount;
2602
      bfd_vma offset;
2603
    } plt;
2604
 
2605
  /* .glink stub offset.  */
2606
  bfd_vma glink_offset;
2607
};
2608
 
2609
/* Of those relocs that might be copied as dynamic relocs, this function
2610
   selects those that must be copied when linking a shared library,
2611
   even when the symbol is local.  */
2612
 
2613
static int
2614
must_be_dyn_reloc (struct bfd_link_info *info,
2615
                   enum elf_ppc_reloc_type r_type)
2616
{
2617
  switch (r_type)
2618
    {
2619
    default:
2620
      return 1;
2621
 
2622
    case R_PPC_REL24:
2623
    case R_PPC_REL14:
2624
    case R_PPC_REL14_BRTAKEN:
2625
    case R_PPC_REL14_BRNTAKEN:
2626
    case R_PPC_REL32:
2627
      return 0;
2628
 
2629
    case R_PPC_TPREL32:
2630
    case R_PPC_TPREL16:
2631
    case R_PPC_TPREL16_LO:
2632
    case R_PPC_TPREL16_HI:
2633
    case R_PPC_TPREL16_HA:
2634
      return !info->executable;
2635
    }
2636
}
2637
 
2638
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2639
   copying dynamic variables from a shared lib into an app's dynbss
2640
   section, and instead use a dynamic relocation to point into the
2641
   shared lib.  */
2642
#define ELIMINATE_COPY_RELOCS 1
2643
 
2644
/* PPC ELF linker hash entry.  */
2645
 
2646
struct ppc_elf_link_hash_entry
2647
{
2648
  struct elf_link_hash_entry elf;
2649
 
2650
  /* If this symbol is used in the linker created sections, the processor
2651
     specific backend uses this field to map the field into the offset
2652
     from the beginning of the section.  */
2653
  elf_linker_section_pointers_t *linker_section_pointer;
2654
 
2655
  /* Track dynamic relocs copied for this symbol.  */
2656
  struct ppc_elf_dyn_relocs *dyn_relocs;
2657
 
2658
  /* Contexts in which symbol is used in the GOT (or TOC).
2659
     TLS_GD .. TLS_TLS bits are or'd into the mask as the
2660
     corresponding relocs are encountered during check_relocs.
2661
     tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
2662
     indicate the corresponding GOT entry type is not needed.  */
2663
#define TLS_GD           1      /* GD reloc. */
2664
#define TLS_LD           2      /* LD reloc. */
2665
#define TLS_TPREL        4      /* TPREL reloc, => IE. */
2666
#define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
2667
#define TLS_TLS         16      /* Any TLS reloc.  */
2668
#define TLS_TPRELGD     32      /* TPREL reloc resulting from GD->IE. */
2669
#define PLT_IFUNC       64      /* STT_GNU_IFUNC.  */
2670
  char tls_mask;
2671
 
2672
  /* Nonzero if we have seen a small data relocation referring to this
2673
     symbol.  */
2674
  unsigned char has_sda_refs;
2675
};
2676
 
2677
#define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent))
2678
 
2679
/* PPC ELF linker hash table.  */
2680
 
2681
struct ppc_elf_link_hash_table
2682
{
2683
  struct elf_link_hash_table elf;
2684
 
2685
  /* Short-cuts to get to dynamic linker sections.  */
2686
  asection *got;
2687
  asection *relgot;
2688
  asection *glink;
2689
  asection *plt;
2690
  asection *relplt;
2691
  asection *iplt;
2692
  asection *reliplt;
2693
  asection *dynbss;
2694
  asection *relbss;
2695
  asection *dynsbss;
2696
  asection *relsbss;
2697
  elf_linker_section_t sdata[2];
2698
  asection *sbss;
2699
 
2700
  /* The (unloaded but important) .rela.plt.unloaded on VxWorks.  */
2701
  asection *srelplt2;
2702
 
2703
  /* The .got.plt section (VxWorks only)*/
2704
  asection *sgotplt;
2705
 
2706
  /* Shortcut to __tls_get_addr.  */
2707
  struct elf_link_hash_entry *tls_get_addr;
2708
 
2709
  /* The bfd that forced an old-style PLT.  */
2710
  bfd *old_bfd;
2711
 
2712
  /* TLS local dynamic got entry handling.  */
2713
  union {
2714
    bfd_signed_vma refcount;
2715
    bfd_vma offset;
2716
  } tlsld_got;
2717
 
2718
  /* Offset of branch table to PltResolve function in glink.  */
2719
  bfd_vma glink_pltresolve;
2720
 
2721
  /* Size of reserved GOT entries.  */
2722
  unsigned int got_header_size;
2723
  /* Non-zero if allocating the header left a gap.  */
2724
  unsigned int got_gap;
2725
 
2726
  /* The type of PLT we have chosen to use.  */
2727
  enum ppc_elf_plt_type plt_type;
2728
 
2729
  /* Set if we should emit symbols for stubs.  */
2730
  unsigned int emit_stub_syms:1;
2731
 
2732
  /* Set if __tls_get_addr optimization should not be done.  */
2733
  unsigned int no_tls_get_addr_opt:1;
2734
 
2735
  /* True if the target system is VxWorks.  */
2736
  unsigned int is_vxworks:1;
2737
 
2738
  /* The size of PLT entries.  */
2739
  int plt_entry_size;
2740
  /* The distance between adjacent PLT slots.  */
2741
  int plt_slot_size;
2742
  /* The size of the first PLT entry.  */
2743
  int plt_initial_entry_size;
2744
 
2745
  /* Small local sym cache.  */
2746
  struct sym_cache sym_cache;
2747
};
2748
 
2749
/* Rename some of the generic section flags to better document how they
2750
   are used here.  */
2751
 
2752
/* Nonzero if this section has TLS related relocations.  */
2753
#define has_tls_reloc sec_flg0
2754
 
2755
/* Nonzero if this section has a call to __tls_get_addr.  */
2756
#define has_tls_get_addr_call sec_flg1
2757
 
2758
/* Get the PPC ELF linker hash table from a link_info structure.  */
2759
 
2760
#define ppc_elf_hash_table(p) \
2761
  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2762
  == PPC32_ELF_DATA ? ((struct ppc_elf_link_hash_table *) ((p)->hash)) : NULL)
2763
 
2764
/* Create an entry in a PPC ELF linker hash table.  */
2765
 
2766
static struct bfd_hash_entry *
2767
ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
2768
                           struct bfd_hash_table *table,
2769
                           const char *string)
2770
{
2771
  /* Allocate the structure if it has not already been allocated by a
2772
     subclass.  */
2773
  if (entry == NULL)
2774
    {
2775
      entry = bfd_hash_allocate (table,
2776
                                 sizeof (struct ppc_elf_link_hash_entry));
2777
      if (entry == NULL)
2778
        return entry;
2779
    }
2780
 
2781
  /* Call the allocation method of the superclass.  */
2782
  entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2783
  if (entry != NULL)
2784
    {
2785
      ppc_elf_hash_entry (entry)->linker_section_pointer = NULL;
2786
      ppc_elf_hash_entry (entry)->dyn_relocs = NULL;
2787
      ppc_elf_hash_entry (entry)->tls_mask = 0;
2788
    }
2789
 
2790
  return entry;
2791
}
2792
 
2793
/* Create a PPC ELF linker hash table.  */
2794
 
2795
static struct bfd_link_hash_table *
2796
ppc_elf_link_hash_table_create (bfd *abfd)
2797
{
2798
  struct ppc_elf_link_hash_table *ret;
2799
 
2800
  ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table));
2801
  if (ret == NULL)
2802
    return NULL;
2803
 
2804
  if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
2805
                                      ppc_elf_link_hash_newfunc,
2806
                                      sizeof (struct ppc_elf_link_hash_entry),
2807
                                      PPC32_ELF_DATA))
2808
    {
2809
      free (ret);
2810
      return NULL;
2811
    }
2812
 
2813
  ret->elf.init_plt_refcount.refcount = 0;
2814
  ret->elf.init_plt_refcount.glist = NULL;
2815
  ret->elf.init_plt_offset.offset = 0;
2816
  ret->elf.init_plt_offset.glist = NULL;
2817
 
2818
  ret->sdata[0].name = ".sdata";
2819
  ret->sdata[0].sym_name = "_SDA_BASE_";
2820
  ret->sdata[0].bss_name = ".sbss";
2821
 
2822
  ret->sdata[1].name = ".sdata2";
2823
  ret->sdata[1].sym_name = "_SDA2_BASE_";
2824
  ret->sdata[1].bss_name = ".sbss2";
2825
 
2826
  ret->plt_entry_size = 12;
2827
  ret->plt_slot_size = 8;
2828
  ret->plt_initial_entry_size = 72;
2829
 
2830
  return &ret->elf.root;
2831
}
2832
 
2833
/* Create .got and the related sections.  */
2834
 
2835
static bfd_boolean
2836
ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info)
2837
{
2838
  struct ppc_elf_link_hash_table *htab;
2839
  asection *s;
2840
  flagword flags;
2841
 
2842
  if (!_bfd_elf_create_got_section (abfd, info))
2843
    return FALSE;
2844
 
2845
  htab = ppc_elf_hash_table (info);
2846
  htab->got = s = bfd_get_section_by_name (abfd, ".got");
2847
  if (s == NULL)
2848
    abort ();
2849
 
2850
  if (htab->is_vxworks)
2851
    {
2852
      htab->sgotplt = bfd_get_section_by_name (abfd, ".got.plt");
2853
      if (!htab->sgotplt)
2854
        abort ();
2855
    }
2856
  else
2857
    {
2858
      /* The powerpc .got has a blrl instruction in it.  Mark it
2859
         executable.  */
2860
      flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS
2861
               | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2862
      if (!bfd_set_section_flags (abfd, s, flags))
2863
        return FALSE;
2864
    }
2865
 
2866
  htab->relgot = bfd_get_section_by_name (abfd, ".rela.got");
2867
  if (!htab->relgot)
2868
    abort ();
2869
 
2870
  return TRUE;
2871
}
2872
 
2873
static bfd_boolean
2874
ppc_elf_create_glink (bfd *abfd, struct bfd_link_info *info)
2875
{
2876
  struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
2877
  asection *s;
2878
  flagword flags;
2879
 
2880
  flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS
2881
           | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2882
  s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags);
2883
  htab->glink = s;
2884
  if (s == NULL
2885
      || !bfd_set_section_alignment (abfd, s, 4))
2886
    return FALSE;
2887
 
2888
  flags = SEC_ALLOC | SEC_LINKER_CREATED;
2889
  s = bfd_make_section_anyway_with_flags (abfd, ".iplt", flags);
2890
  htab->iplt = s;
2891
  if (s == NULL
2892
      || !bfd_set_section_alignment (abfd, s, 4))
2893
    return FALSE;
2894
 
2895
  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
2896
           | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2897
  s = bfd_make_section_with_flags (abfd, ".rela.iplt", flags);
2898
  htab->reliplt = s;
2899
  if (s == NULL
2900
      || ! bfd_set_section_alignment (abfd, s, 2))
2901
    return FALSE;
2902
  return TRUE;
2903
}
2904
 
2905
/* We have to create .dynsbss and .rela.sbss here so that they get mapped
2906
   to output sections (just like _bfd_elf_create_dynamic_sections has
2907
   to create .dynbss and .rela.bss).  */
2908
 
2909
static bfd_boolean
2910
ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2911
{
2912
  struct ppc_elf_link_hash_table *htab;
2913
  asection *s;
2914
  flagword flags;
2915
 
2916
  htab = ppc_elf_hash_table (info);
2917
 
2918
  if (htab->got == NULL
2919
      && !ppc_elf_create_got (abfd, info))
2920
    return FALSE;
2921
 
2922
  if (!_bfd_elf_create_dynamic_sections (abfd, info))
2923
    return FALSE;
2924
 
2925
  if (htab->glink == NULL
2926
      && !ppc_elf_create_glink (abfd, info))
2927
    return FALSE;
2928
 
2929
  htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss");
2930
  s = bfd_make_section_with_flags (abfd, ".dynsbss",
2931
                                   SEC_ALLOC | SEC_LINKER_CREATED);
2932
  htab->dynsbss = s;
2933
  if (s == NULL)
2934
    return FALSE;
2935
 
2936
  if (! info->shared)
2937
    {
2938
      htab->relbss = bfd_get_section_by_name (abfd, ".rela.bss");
2939
      flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
2940
               | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2941
      s = bfd_make_section_with_flags (abfd, ".rela.sbss", flags);
2942
      htab->relsbss = s;
2943
      if (s == NULL
2944
          || ! bfd_set_section_alignment (abfd, s, 2))
2945
        return FALSE;
2946
    }
2947
 
2948
  if (htab->is_vxworks
2949
      && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
2950
    return FALSE;
2951
 
2952
  htab->relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2953
  htab->plt = s = bfd_get_section_by_name (abfd, ".plt");
2954
  if (s == NULL)
2955
    abort ();
2956
 
2957
  flags = SEC_ALLOC | SEC_CODE | SEC_LINKER_CREATED;
2958
  if (htab->plt_type == PLT_VXWORKS)
2959
    /* The VxWorks PLT is a loaded section with contents.  */
2960
    flags |= SEC_HAS_CONTENTS | SEC_LOAD | SEC_READONLY;
2961
  return bfd_set_section_flags (abfd, s, flags);
2962
}
2963
 
2964
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
2965
 
2966
static void
2967
ppc_elf_copy_indirect_symbol (struct bfd_link_info *info,
2968
                              struct elf_link_hash_entry *dir,
2969
                              struct elf_link_hash_entry *ind)
2970
{
2971
  struct ppc_elf_link_hash_entry *edir, *eind;
2972
 
2973
  edir = (struct ppc_elf_link_hash_entry *) dir;
2974
  eind = (struct ppc_elf_link_hash_entry *) ind;
2975
 
2976
  if (eind->dyn_relocs != NULL)
2977
    {
2978
      if (edir->dyn_relocs != NULL)
2979
        {
2980
          struct ppc_elf_dyn_relocs **pp;
2981
          struct ppc_elf_dyn_relocs *p;
2982
 
2983
          /* Add reloc counts against the indirect sym to the direct sym
2984
             list.  Merge any entries against the same section.  */
2985
          for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2986
            {
2987
              struct ppc_elf_dyn_relocs *q;
2988
 
2989
              for (q = edir->dyn_relocs; q != NULL; q = q->next)
2990
                if (q->sec == p->sec)
2991
                  {
2992
                    q->pc_count += p->pc_count;
2993
                    q->count += p->count;
2994
                    *pp = p->next;
2995
                    break;
2996
                  }
2997
              if (q == NULL)
2998
                pp = &p->next;
2999
            }
3000
          *pp = edir->dyn_relocs;
3001
        }
3002
 
3003
      edir->dyn_relocs = eind->dyn_relocs;
3004
      eind->dyn_relocs = NULL;
3005
    }
3006
 
3007
  edir->tls_mask |= eind->tls_mask;
3008
  edir->has_sda_refs |= eind->has_sda_refs;
3009
 
3010
  /* If called to transfer flags for a weakdef during processing
3011
     of elf_adjust_dynamic_symbol, don't copy non_got_ref.
3012
     We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
3013
  if (!(ELIMINATE_COPY_RELOCS
3014
        && eind->elf.root.type != bfd_link_hash_indirect
3015
        && edir->elf.dynamic_adjusted))
3016
    edir->elf.non_got_ref |= eind->elf.non_got_ref;
3017
 
3018
  edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3019
  edir->elf.ref_regular |= eind->elf.ref_regular;
3020
  edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3021
  edir->elf.needs_plt |= eind->elf.needs_plt;
3022
  edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
3023
 
3024
  /* If we were called to copy over info for a weak sym, that's all.  */
3025
  if (eind->elf.root.type != bfd_link_hash_indirect)
3026
    return;
3027
 
3028
  /* Copy over the GOT refcount entries that we may have already seen to
3029
     the symbol which just became indirect.  */
3030
  edir->elf.got.refcount += eind->elf.got.refcount;
3031
  eind->elf.got.refcount = 0;
3032
 
3033
  /* And plt entries.  */
3034
  if (eind->elf.plt.plist != NULL)
3035
    {
3036
      if (edir->elf.plt.plist != NULL)
3037
        {
3038
          struct plt_entry **entp;
3039
          struct plt_entry *ent;
3040
 
3041
          for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; )
3042
            {
3043
              struct plt_entry *dent;
3044
 
3045
              for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next)
3046
                if (dent->sec == ent->sec && dent->addend == ent->addend)
3047
                  {
3048
                    dent->plt.refcount += ent->plt.refcount;
3049
                    *entp = ent->next;
3050
                    break;
3051
                  }
3052
              if (dent == NULL)
3053
                entp = &ent->next;
3054
            }
3055
          *entp = edir->elf.plt.plist;
3056
        }
3057
 
3058
      edir->elf.plt.plist = eind->elf.plt.plist;
3059
      eind->elf.plt.plist = NULL;
3060
    }
3061
 
3062
  if (eind->elf.dynindx != -1)
3063
    {
3064
      if (edir->elf.dynindx != -1)
3065
        _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3066
                                edir->elf.dynstr_index);
3067
      edir->elf.dynindx = eind->elf.dynindx;
3068
      edir->elf.dynstr_index = eind->elf.dynstr_index;
3069
      eind->elf.dynindx = -1;
3070
      eind->elf.dynstr_index = 0;
3071
    }
3072
}
3073
 
3074
/* Hook called by the linker routine which adds symbols from an object
3075
   file.  We use it to put .comm items in .sbss, and not .bss.  */
3076
 
3077
static bfd_boolean
3078
ppc_elf_add_symbol_hook (bfd *abfd,
3079
                         struct bfd_link_info *info,
3080
                         Elf_Internal_Sym *sym,
3081
                         const char **namep ATTRIBUTE_UNUSED,
3082
                         flagword *flagsp ATTRIBUTE_UNUSED,
3083
                         asection **secp,
3084
                         bfd_vma *valp)
3085
{
3086
  if (sym->st_shndx == SHN_COMMON
3087
      && !info->relocatable
3088
      && is_ppc_elf (info->output_bfd)
3089
      && sym->st_size <= elf_gp_size (abfd))
3090
    {
3091
      /* Common symbols less than or equal to -G nn bytes are automatically
3092
         put into .sbss.  */
3093
      struct ppc_elf_link_hash_table *htab;
3094
 
3095
      htab = ppc_elf_hash_table (info);
3096
      if (htab->sbss == NULL)
3097
        {
3098
          flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
3099
 
3100
          if (!htab->elf.dynobj)
3101
            htab->elf.dynobj = abfd;
3102
 
3103
          htab->sbss = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
3104
                                                           ".sbss",
3105
                                                           flags);
3106
          if (htab->sbss == NULL)
3107
            return FALSE;
3108
        }
3109
 
3110
      *secp = htab->sbss;
3111
      *valp = sym->st_size;
3112
    }
3113
 
3114
  if ((abfd->flags & DYNAMIC) == 0
3115
      && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3116
    elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
3117
 
3118
  return TRUE;
3119
}
3120
 
3121
static bfd_boolean
3122
create_sdata_sym (struct bfd_link_info *info, elf_linker_section_t *lsect)
3123
{
3124
  struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
3125
 
3126
  lsect->sym = elf_link_hash_lookup (&htab->elf, lsect->sym_name,
3127
                                     TRUE, FALSE, TRUE);
3128
  if (lsect->sym == NULL)
3129
    return FALSE;
3130
  if (lsect->sym->root.type == bfd_link_hash_new)
3131
    lsect->sym->non_elf = 0;
3132
  lsect->sym->ref_regular = 1;
3133
  _bfd_elf_link_hash_hide_symbol (info, lsect->sym, TRUE);
3134
  return TRUE;
3135
}
3136
 
3137
/* Create a special linker section.  */
3138
 
3139
static bfd_boolean
3140
ppc_elf_create_linker_section (bfd *abfd,
3141
                               struct bfd_link_info *info,
3142
                               flagword flags,
3143
                               elf_linker_section_t *lsect)
3144
{
3145
  struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
3146
  asection *s;
3147
 
3148
  flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3149
            | SEC_LINKER_CREATED);
3150
 
3151
  /* Record the first bfd that needs the special sections.  */
3152
  if (!htab->elf.dynobj)
3153
    htab->elf.dynobj = abfd;
3154
 
3155
  s = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
3156
                                          lsect->name,
3157
                                          flags);
3158
  if (s == NULL
3159
      || !bfd_set_section_alignment (htab->elf.dynobj, s, 2))
3160
    return FALSE;
3161
  lsect->section = s;
3162
 
3163
  return create_sdata_sym (info, lsect);
3164
}
3165
 
3166
/* Find a linker generated pointer with a given addend and type.  */
3167
 
3168
static elf_linker_section_pointers_t *
3169
elf_find_pointer_linker_section
3170
  (elf_linker_section_pointers_t *linker_pointers,
3171
   bfd_vma addend,
3172
   elf_linker_section_t *lsect)
3173
{
3174
  for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
3175
    if (lsect == linker_pointers->lsect && addend == linker_pointers->addend)
3176
      return linker_pointers;
3177
 
3178
  return NULL;
3179
}
3180
 
3181
/* Allocate a pointer to live in a linker created section.  */
3182
 
3183
static bfd_boolean
3184
elf_create_pointer_linker_section (bfd *abfd,
3185
                                   elf_linker_section_t *lsect,
3186
                                   struct elf_link_hash_entry *h,
3187
                                   const Elf_Internal_Rela *rel)
3188
{
3189
  elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
3190
  elf_linker_section_pointers_t *linker_section_ptr;
3191
  unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
3192
  bfd_size_type amt;
3193
 
3194
  BFD_ASSERT (lsect != NULL);
3195
 
3196
  /* Is this a global symbol?  */
3197
  if (h != NULL)
3198
    {
3199
      struct ppc_elf_link_hash_entry *eh;
3200
 
3201
      /* Has this symbol already been allocated?  If so, our work is done.  */
3202
      eh = (struct ppc_elf_link_hash_entry *) h;
3203
      if (elf_find_pointer_linker_section (eh->linker_section_pointer,
3204
                                           rel->r_addend,
3205
                                           lsect))
3206
        return TRUE;
3207
 
3208
      ptr_linker_section_ptr = &eh->linker_section_pointer;
3209
    }
3210
  else
3211
    {
3212
      BFD_ASSERT (is_ppc_elf (abfd));
3213
 
3214
      /* Allocation of a pointer to a local symbol.  */
3215
      elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
3216
 
3217
      /* Allocate a table to hold the local symbols if first time.  */
3218
      if (!ptr)
3219
        {
3220
          unsigned int num_symbols = elf_symtab_hdr (abfd).sh_info;
3221
 
3222
          amt = num_symbols;
3223
          amt *= sizeof (elf_linker_section_pointers_t *);
3224
          ptr = bfd_zalloc (abfd, amt);
3225
 
3226
          if (!ptr)
3227
            return FALSE;
3228
 
3229
          elf_local_ptr_offsets (abfd) = ptr;
3230
        }
3231
 
3232
      /* Has this symbol already been allocated?  If so, our work is done.  */
3233
      if (elf_find_pointer_linker_section (ptr[r_symndx],
3234
                                           rel->r_addend,
3235
                                           lsect))
3236
        return TRUE;
3237
 
3238
      ptr_linker_section_ptr = &ptr[r_symndx];
3239
    }
3240
 
3241
  /* Allocate space for a pointer in the linker section, and allocate
3242
     a new pointer record from internal memory.  */
3243
  BFD_ASSERT (ptr_linker_section_ptr != NULL);
3244
  amt = sizeof (elf_linker_section_pointers_t);
3245
  linker_section_ptr = bfd_alloc (abfd, amt);
3246
 
3247
  if (!linker_section_ptr)
3248
    return FALSE;
3249
 
3250
  linker_section_ptr->next = *ptr_linker_section_ptr;
3251
  linker_section_ptr->addend = rel->r_addend;
3252
  linker_section_ptr->lsect = lsect;
3253
  *ptr_linker_section_ptr = linker_section_ptr;
3254
 
3255
  linker_section_ptr->offset = lsect->section->size;
3256
  lsect->section->size += 4;
3257
 
3258
#ifdef DEBUG
3259
  fprintf (stderr,
3260
           "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3261
           lsect->name, (long) linker_section_ptr->offset,
3262
           (long) lsect->section->size);
3263
#endif
3264
 
3265
  return TRUE;
3266
}
3267
 
3268
static struct plt_entry **
3269
update_local_sym_info (bfd *abfd,
3270
                       Elf_Internal_Shdr *symtab_hdr,
3271
                       unsigned long r_symndx,
3272
                       int tls_type)
3273
{
3274
  bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
3275
  struct plt_entry **local_plt;
3276
  char *local_got_tls_masks;
3277
 
3278
  if (local_got_refcounts == NULL)
3279
    {
3280
      bfd_size_type size = symtab_hdr->sh_info;
3281
 
3282
      size *= (sizeof (*local_got_refcounts)
3283
               + sizeof (*local_plt)
3284
               + sizeof (*local_got_tls_masks));
3285
      local_got_refcounts = bfd_zalloc (abfd, size);
3286
      if (local_got_refcounts == NULL)
3287
        return NULL;
3288
      elf_local_got_refcounts (abfd) = local_got_refcounts;
3289
    }
3290
 
3291
  local_plt = (struct plt_entry **) (local_got_refcounts + symtab_hdr->sh_info);
3292
  local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
3293
  local_got_tls_masks[r_symndx] |= tls_type;
3294
  if (tls_type != PLT_IFUNC)
3295
    local_got_refcounts[r_symndx] += 1;
3296
  return local_plt + r_symndx;
3297
}
3298
 
3299
static bfd_boolean
3300
update_plt_info (bfd *abfd, struct plt_entry **plist,
3301
                 asection *sec, bfd_vma addend)
3302
{
3303
  struct plt_entry *ent;
3304
 
3305
  if (addend < 32768)
3306
    sec = NULL;
3307
  for (ent = *plist; ent != NULL; ent = ent->next)
3308
    if (ent->sec == sec && ent->addend == addend)
3309
      break;
3310
  if (ent == NULL)
3311
    {
3312
      bfd_size_type amt = sizeof (*ent);
3313
      ent = bfd_alloc (abfd, amt);
3314
      if (ent == NULL)
3315
        return FALSE;
3316
      ent->next = *plist;
3317
      ent->sec = sec;
3318
      ent->addend = addend;
3319
      ent->plt.refcount = 0;
3320
      *plist = ent;
3321
    }
3322
  ent->plt.refcount += 1;
3323
  return TRUE;
3324
}
3325
 
3326
static struct plt_entry *
3327
find_plt_ent (struct plt_entry **plist, asection *sec, bfd_vma addend)
3328
{
3329
  struct plt_entry *ent;
3330
 
3331
  if (addend < 32768)
3332
    sec = NULL;
3333
  for (ent = *plist; ent != NULL; ent = ent->next)
3334
    if (ent->sec == sec && ent->addend == addend)
3335
      break;
3336
  return ent;
3337
}
3338
 
3339
static bfd_boolean
3340
is_branch_reloc (enum elf_ppc_reloc_type r_type)
3341
{
3342
  return (r_type == R_PPC_PLTREL24
3343
          || r_type == R_PPC_LOCAL24PC
3344
          || r_type == R_PPC_REL24
3345
          || r_type == R_PPC_REL14
3346
          || r_type == R_PPC_REL14_BRTAKEN
3347
          || r_type == R_PPC_REL14_BRNTAKEN
3348
          || r_type == R_PPC_ADDR24
3349
          || r_type == R_PPC_ADDR14
3350
          || r_type == R_PPC_ADDR14_BRTAKEN
3351
          || r_type == R_PPC_ADDR14_BRNTAKEN);
3352
}
3353
 
3354
static void
3355
bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
3356
{
3357
  (*_bfd_error_handler)
3358
    (_("%B: relocation %s cannot be used when making a shared object"),
3359
     abfd,
3360
     ppc_elf_howto_table[r_type]->name);
3361
  bfd_set_error (bfd_error_bad_value);
3362
}
3363
 
3364
/* Look through the relocs for a section during the first phase, and
3365
   allocate space in the global offset table or procedure linkage
3366
   table.  */
3367
 
3368
static bfd_boolean
3369
ppc_elf_check_relocs (bfd *abfd,
3370
                      struct bfd_link_info *info,
3371
                      asection *sec,
3372
                      const Elf_Internal_Rela *relocs)
3373
{
3374
  struct ppc_elf_link_hash_table *htab;
3375
  Elf_Internal_Shdr *symtab_hdr;
3376
  struct elf_link_hash_entry **sym_hashes;
3377
  const Elf_Internal_Rela *rel;
3378
  const Elf_Internal_Rela *rel_end;
3379
  asection *got2, *sreloc;
3380
  struct elf_link_hash_entry *tga;
3381
 
3382
  if (info->relocatable)
3383
    return TRUE;
3384
 
3385
  /* Don't do anything special with non-loaded, non-alloced sections.
3386
     In particular, any relocs in such sections should not affect GOT
3387
     and PLT reference counting (ie. we don't allow them to create GOT
3388
     or PLT entries), there's no possibility or desire to optimize TLS
3389
     relocs, and there's not much point in propagating relocs to shared
3390
     libs that the dynamic linker won't relocate.  */
3391
  if ((sec->flags & SEC_ALLOC) == 0)
3392
    return TRUE;
3393
 
3394
#ifdef DEBUG
3395
  _bfd_error_handler ("ppc_elf_check_relocs called for section %A in %B",
3396
                      sec, abfd);
3397
#endif
3398
 
3399
  BFD_ASSERT (is_ppc_elf (abfd));
3400
 
3401
  /* Initialize howto table if not already done.  */
3402
  if (!ppc_elf_howto_table[R_PPC_ADDR32])
3403
    ppc_elf_howto_init ();
3404
 
3405
  htab = ppc_elf_hash_table (info);
3406
  if (htab->glink == NULL)
3407
    {
3408
      if (htab->elf.dynobj == NULL)
3409
        htab->elf.dynobj = abfd;
3410
      if (!ppc_elf_create_glink (htab->elf.dynobj, info))
3411
        return FALSE;
3412
    }
3413
  tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
3414
                              FALSE, FALSE, TRUE);
3415
  symtab_hdr = &elf_symtab_hdr (abfd);
3416
  sym_hashes = elf_sym_hashes (abfd);
3417
  got2 = bfd_get_section_by_name (abfd, ".got2");
3418
  sreloc = NULL;
3419
 
3420
  rel_end = relocs + sec->reloc_count;
3421
  for (rel = relocs; rel < rel_end; rel++)
3422
    {
3423
      unsigned long r_symndx;
3424
      enum elf_ppc_reloc_type r_type;
3425
      struct elf_link_hash_entry *h;
3426
      int tls_type;
3427
 
3428
      r_symndx = ELF32_R_SYM (rel->r_info);
3429
      if (r_symndx < symtab_hdr->sh_info)
3430
        h = NULL;
3431
      else
3432
        {
3433
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3434
          while (h->root.type == bfd_link_hash_indirect
3435
                 || h->root.type == bfd_link_hash_warning)
3436
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
3437
        }
3438
 
3439
      /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
3440
         This shows up in particular in an R_PPC_ADDR32 in the eabi
3441
         startup code.  */
3442
      if (h != NULL
3443
          && htab->got == NULL
3444
          && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3445
        {
3446
          if (htab->elf.dynobj == NULL)
3447
            htab->elf.dynobj = abfd;
3448
          if (!ppc_elf_create_got (htab->elf.dynobj, info))
3449
            return FALSE;
3450
          BFD_ASSERT (h == htab->elf.hgot);
3451
        }
3452
 
3453
      tls_type = 0;
3454
      r_type = ELF32_R_TYPE (rel->r_info);
3455
      if (h == NULL && !htab->is_vxworks)
3456
        {
3457
          Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3458
                                                          abfd, r_symndx);
3459
          if (isym == NULL)
3460
            return FALSE;
3461
 
3462
          if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
3463
              && (!info->shared
3464
                  || is_branch_reloc (r_type)))
3465
            {
3466
              struct plt_entry **ifunc;
3467
              bfd_vma addend;
3468
 
3469
              ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
3470
                                             PLT_IFUNC);
3471
              if (ifunc == NULL)
3472
                return FALSE;
3473
 
3474
              /* STT_GNU_IFUNC symbols must have a PLT entry;
3475
                 In a non-pie executable even when there are
3476
                 no plt calls.  */
3477
              addend = 0;
3478
              if (r_type == R_PPC_PLTREL24)
3479
                {
3480
                  ppc_elf_tdata (abfd)->makes_plt_call = 1;
3481
                  if (info->shared)
3482
                    addend = rel->r_addend;
3483
                }
3484
              if (!update_plt_info (abfd, ifunc, got2, addend))
3485
                return FALSE;
3486
            }
3487
        }
3488
 
3489
      if (!htab->is_vxworks
3490
          && is_branch_reloc (r_type)
3491
          && h != NULL
3492
          && h == tga)
3493
        {
3494
          if (rel != relocs
3495
              && (ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSGD
3496
                  || ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSLD))
3497
            /* We have a new-style __tls_get_addr call with a marker
3498
               reloc.  */
3499
            ;
3500
          else
3501
            /* Mark this section as having an old-style call.  */
3502
            sec->has_tls_get_addr_call = 1;
3503
        }
3504
 
3505
      switch (r_type)
3506
        {
3507
        case R_PPC_TLSGD:
3508
        case R_PPC_TLSLD:
3509
          /* These special tls relocs tie a call to __tls_get_addr with
3510
             its parameter symbol.  */
3511
          break;
3512
 
3513
        case R_PPC_GOT_TLSLD16:
3514
        case R_PPC_GOT_TLSLD16_LO:
3515
        case R_PPC_GOT_TLSLD16_HI:
3516
        case R_PPC_GOT_TLSLD16_HA:
3517
          tls_type = TLS_TLS | TLS_LD;
3518
          goto dogottls;
3519
 
3520
        case R_PPC_GOT_TLSGD16:
3521
        case R_PPC_GOT_TLSGD16_LO:
3522
        case R_PPC_GOT_TLSGD16_HI:
3523
        case R_PPC_GOT_TLSGD16_HA:
3524
          tls_type = TLS_TLS | TLS_GD;
3525
          goto dogottls;
3526
 
3527
        case R_PPC_GOT_TPREL16:
3528
        case R_PPC_GOT_TPREL16_LO:
3529
        case R_PPC_GOT_TPREL16_HI:
3530
        case R_PPC_GOT_TPREL16_HA:
3531
          if (!info->executable)
3532
            info->flags |= DF_STATIC_TLS;
3533
          tls_type = TLS_TLS | TLS_TPREL;
3534
          goto dogottls;
3535
 
3536
        case R_PPC_GOT_DTPREL16:
3537
        case R_PPC_GOT_DTPREL16_LO:
3538
        case R_PPC_GOT_DTPREL16_HI:
3539
        case R_PPC_GOT_DTPREL16_HA:
3540
          tls_type = TLS_TLS | TLS_DTPREL;
3541
        dogottls:
3542
          sec->has_tls_reloc = 1;
3543
          /* Fall thru */
3544
 
3545
          /* GOT16 relocations */
3546
        case R_PPC_GOT16:
3547
        case R_PPC_GOT16_LO:
3548
        case R_PPC_GOT16_HI:
3549
        case R_PPC_GOT16_HA:
3550
          /* This symbol requires a global offset table entry.  */
3551
          if (htab->got == NULL)
3552
            {
3553
              if (htab->elf.dynobj == NULL)
3554
                htab->elf.dynobj = abfd;
3555
              if (!ppc_elf_create_got (htab->elf.dynobj, info))
3556
                return FALSE;
3557
            }
3558
          if (h != NULL)
3559
            {
3560
              h->got.refcount += 1;
3561
              ppc_elf_hash_entry (h)->tls_mask |= tls_type;
3562
            }
3563
          else
3564
            /* This is a global offset table entry for a local symbol.  */
3565
            if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
3566
              return FALSE;
3567
 
3568
          /* We may also need a plt entry if the symbol turns out to be
3569
             an ifunc.  */
3570
          if (h != NULL && !info->shared)
3571
            {
3572
              if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
3573
                return FALSE;
3574
            }
3575
          break;
3576
 
3577
          /* Indirect .sdata relocation.  */
3578
        case R_PPC_EMB_SDAI16:
3579
          if (info->shared)
3580
            {
3581
              bad_shared_reloc (abfd, r_type);
3582
              return FALSE;
3583
            }
3584
          if (htab->sdata[0].section == NULL
3585
              && !ppc_elf_create_linker_section (abfd, info, 0,
3586
                                                 &htab->sdata[0]))
3587
            return FALSE;
3588
          if (!elf_create_pointer_linker_section (abfd, &htab->sdata[0],
3589
                                                  h, rel))
3590
            return FALSE;
3591
          if (h != NULL)
3592
            {
3593
              ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3594
              h->non_got_ref = TRUE;
3595
            }
3596
          break;
3597
 
3598
          /* Indirect .sdata2 relocation.  */
3599
        case R_PPC_EMB_SDA2I16:
3600
          if (info->shared)
3601
            {
3602
              bad_shared_reloc (abfd, r_type);
3603
              return FALSE;
3604
            }
3605
          if (htab->sdata[1].section == NULL
3606
              && !ppc_elf_create_linker_section (abfd, info, SEC_READONLY,
3607
                                                 &htab->sdata[1]))
3608
            return FALSE;
3609
          if (!elf_create_pointer_linker_section (abfd, &htab->sdata[1],
3610
                                                  h, rel))
3611
            return FALSE;
3612
          if (h != NULL)
3613
            {
3614
              ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3615
              h->non_got_ref = TRUE;
3616
            }
3617
          break;
3618
 
3619
        case R_PPC_SDAREL16:
3620
          if (htab->sdata[0].sym == NULL
3621
              && !create_sdata_sym (info, &htab->sdata[0]))
3622
            return FALSE;
3623
          if (h != NULL)
3624
            {
3625
              ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3626
              h->non_got_ref = TRUE;
3627
            }
3628
          break;
3629
 
3630
        case R_PPC_EMB_SDA2REL:
3631
          if (info->shared)
3632
            {
3633
              bad_shared_reloc (abfd, r_type);
3634
              return FALSE;
3635
            }
3636
          if (htab->sdata[1].sym == NULL
3637
              && !create_sdata_sym (info, &htab->sdata[1]))
3638
            return FALSE;
3639
          if (h != NULL)
3640
            {
3641
              ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3642
              h->non_got_ref = TRUE;
3643
            }
3644
          break;
3645
 
3646
        case R_PPC_EMB_SDA21:
3647
        case R_PPC_EMB_RELSDA:
3648
          if (info->shared)
3649
            {
3650
              bad_shared_reloc (abfd, r_type);
3651
              return FALSE;
3652
            }
3653
          if (htab->sdata[0].sym == NULL
3654
              && !create_sdata_sym (info, &htab->sdata[0]))
3655
            return FALSE;
3656
          if (htab->sdata[1].sym == NULL
3657
              && !create_sdata_sym (info, &htab->sdata[1]))
3658
            return FALSE;
3659
          if (h != NULL)
3660
            {
3661
              ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
3662
              h->non_got_ref = TRUE;
3663
            }
3664
          break;
3665
 
3666
        case R_PPC_EMB_NADDR32:
3667
        case R_PPC_EMB_NADDR16:
3668
        case R_PPC_EMB_NADDR16_LO:
3669
        case R_PPC_EMB_NADDR16_HI:
3670
        case R_PPC_EMB_NADDR16_HA:
3671
          if (info->shared)
3672
            {
3673
              bad_shared_reloc (abfd, r_type);
3674
              return FALSE;
3675
            }
3676
          if (h != NULL)
3677
            h->non_got_ref = TRUE;
3678
          break;
3679
 
3680
        case R_PPC_PLTREL24:
3681
          if (h == NULL)
3682
            break;
3683
          /* Fall through */
3684
        case R_PPC_PLT32:
3685
        case R_PPC_PLTREL32:
3686
        case R_PPC_PLT16_LO:
3687
        case R_PPC_PLT16_HI:
3688
        case R_PPC_PLT16_HA:
3689
#ifdef DEBUG
3690
          fprintf (stderr, "Reloc requires a PLT entry\n");
3691
#endif
3692
          /* This symbol requires a procedure linkage table entry.  We
3693
             actually build the entry in finish_dynamic_symbol,
3694
             because this might be a case of linking PIC code without
3695
             linking in any dynamic objects, in which case we don't
3696
             need to generate a procedure linkage table after all.  */
3697
 
3698
          if (h == NULL)
3699
            {
3700
              /* It does not make sense to have a procedure linkage
3701
                 table entry for a local symbol.  */
3702
              (*_bfd_error_handler) (_("%B(%A+0x%lx): %s reloc against "
3703
                                       "local symbol"),
3704
                                     abfd,
3705
                                     sec,
3706
                                     (long) rel->r_offset,
3707
                                     ppc_elf_howto_table[r_type]->name);
3708
              bfd_set_error (bfd_error_bad_value);
3709
              return FALSE;
3710
            }
3711
          else
3712
            {
3713
              bfd_vma addend = 0;
3714
 
3715
              if (r_type == R_PPC_PLTREL24)
3716
                {
3717
                  ppc_elf_tdata (abfd)->makes_plt_call = 1;
3718
                  if (info->shared)
3719
                    addend = rel->r_addend;
3720
                }
3721
              h->needs_plt = 1;
3722
              if (!update_plt_info (abfd, &h->plt.plist, got2, addend))
3723
                return FALSE;
3724
            }
3725
          break;
3726
 
3727
          /* The following relocations don't need to propagate the
3728
             relocation if linking a shared object since they are
3729
             section relative.  */
3730
        case R_PPC_SECTOFF:
3731
        case R_PPC_SECTOFF_LO:
3732
        case R_PPC_SECTOFF_HI:
3733
        case R_PPC_SECTOFF_HA:
3734
        case R_PPC_DTPREL16:
3735
        case R_PPC_DTPREL16_LO:
3736
        case R_PPC_DTPREL16_HI:
3737
        case R_PPC_DTPREL16_HA:
3738
        case R_PPC_TOC16:
3739
          break;
3740
 
3741
        case R_PPC_REL16:
3742
        case R_PPC_REL16_LO:
3743
        case R_PPC_REL16_HI:
3744
        case R_PPC_REL16_HA:
3745
          ppc_elf_tdata (abfd)->has_rel16 = 1;
3746
          break;
3747
 
3748
          /* These are just markers.  */
3749
        case R_PPC_TLS:
3750
        case R_PPC_EMB_MRKREF:
3751
        case R_PPC_NONE:
3752
        case R_PPC_max:
3753
        case R_PPC_RELAX:
3754
        case R_PPC_RELAX_PLT:
3755
        case R_PPC_RELAX_PLTREL24:
3756
          break;
3757
 
3758
          /* These should only appear in dynamic objects.  */
3759
        case R_PPC_COPY:
3760
        case R_PPC_GLOB_DAT:
3761
        case R_PPC_JMP_SLOT:
3762
        case R_PPC_RELATIVE:
3763
        case R_PPC_IRELATIVE:
3764
          break;
3765
 
3766
          /* These aren't handled yet.  We'll report an error later.  */
3767
        case R_PPC_ADDR30:
3768
        case R_PPC_EMB_RELSEC16:
3769
        case R_PPC_EMB_RELST_LO:
3770
        case R_PPC_EMB_RELST_HI:
3771
        case R_PPC_EMB_RELST_HA:
3772
        case R_PPC_EMB_BIT_FLD:
3773
          break;
3774
 
3775
          /* This refers only to functions defined in the shared library.  */
3776
        case R_PPC_LOCAL24PC:
3777
          if (h != NULL && h == htab->elf.hgot && htab->plt_type == PLT_UNSET)
3778
            {
3779
              htab->plt_type = PLT_OLD;
3780
              htab->old_bfd = abfd;
3781
            }
3782
          break;
3783
 
3784
          /* This relocation describes the C++ object vtable hierarchy.
3785
             Reconstruct it for later use during GC.  */
3786
        case R_PPC_GNU_VTINHERIT:
3787
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3788
            return FALSE;
3789
          break;
3790
 
3791
          /* This relocation describes which C++ vtable entries are actually
3792
             used.  Record for later use during GC.  */
3793
        case R_PPC_GNU_VTENTRY:
3794
          BFD_ASSERT (h != NULL);
3795
          if (h != NULL
3796
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3797
            return FALSE;
3798
          break;
3799
 
3800
          /* We shouldn't really be seeing these.  */
3801
        case R_PPC_TPREL32:
3802
        case R_PPC_TPREL16:
3803
        case R_PPC_TPREL16_LO:
3804
        case R_PPC_TPREL16_HI:
3805
        case R_PPC_TPREL16_HA:
3806
          if (!info->executable)
3807
            info->flags |= DF_STATIC_TLS;
3808
          goto dodyn;
3809
 
3810
          /* Nor these.  */
3811
        case R_PPC_DTPMOD32:
3812
        case R_PPC_DTPREL32:
3813
          goto dodyn;
3814
 
3815
        case R_PPC_REL32:
3816
          if (h == NULL
3817
              && got2 != NULL
3818
              && (sec->flags & SEC_CODE) != 0
3819
              && info->shared
3820
              && htab->plt_type == PLT_UNSET)
3821
            {
3822
              /* Old -fPIC gcc code has .long LCTOC1-LCFx just before
3823
                 the start of a function, which assembles to a REL32
3824
                 reference to .got2.  If we detect one of these, then
3825
                 force the old PLT layout because the linker cannot
3826
                 reliably deduce the GOT pointer value needed for
3827
                 PLT call stubs.  */
3828
              asection *s;
3829
              Elf_Internal_Sym *isym;
3830
 
3831
              isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3832
                                            abfd, r_symndx);
3833
              if (isym == NULL)
3834
                return FALSE;
3835
 
3836
              s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3837
              if (s == got2)
3838
                {
3839
                  htab->plt_type = PLT_OLD;
3840
                  htab->old_bfd = abfd;
3841
                }
3842
            }
3843
          if (h == NULL || h == htab->elf.hgot)
3844
            break;
3845
          /* fall through */
3846
 
3847
        case R_PPC_ADDR32:
3848
        case R_PPC_ADDR16:
3849
        case R_PPC_ADDR16_LO:
3850
        case R_PPC_ADDR16_HI:
3851
        case R_PPC_ADDR16_HA:
3852
        case R_PPC_UADDR32:
3853
        case R_PPC_UADDR16:
3854
          if (h != NULL && !info->shared)
3855
            {
3856
              /* We may need a plt entry if the symbol turns out to be
3857
                 a function defined in a dynamic object.  */
3858
              if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
3859
                return FALSE;
3860
 
3861
              /* We may need a copy reloc too.  */
3862
              h->non_got_ref = 1;
3863
              h->pointer_equality_needed = 1;
3864
            }
3865
          goto dodyn;
3866
 
3867
        case R_PPC_REL24:
3868
        case R_PPC_REL14:
3869
        case R_PPC_REL14_BRTAKEN:
3870
        case R_PPC_REL14_BRNTAKEN:
3871
          if (h == NULL)
3872
            break;
3873
          if (h == htab->elf.hgot)
3874
            {
3875
              if (htab->plt_type == PLT_UNSET)
3876
                {
3877
                  htab->plt_type = PLT_OLD;
3878
                  htab->old_bfd = abfd;
3879
                }
3880
              break;
3881
            }
3882
          /* fall through */
3883
 
3884
        case R_PPC_ADDR24:
3885
        case R_PPC_ADDR14:
3886
        case R_PPC_ADDR14_BRTAKEN:
3887
        case R_PPC_ADDR14_BRNTAKEN:
3888
          if (h != NULL && !info->shared)
3889
            {
3890
              /* We may need a plt entry if the symbol turns out to be
3891
                 a function defined in a dynamic object.  */
3892
              h->needs_plt = 1;
3893
              if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
3894
                return FALSE;
3895
              break;
3896
            }
3897
 
3898
        dodyn:
3899
          /* If we are creating a shared library, and this is a reloc
3900
             against a global symbol, or a non PC relative reloc
3901
             against a local symbol, then we need to copy the reloc
3902
             into the shared library.  However, if we are linking with
3903
             -Bsymbolic, we do not need to copy a reloc against a
3904
             global symbol which is defined in an object we are
3905
             including in the link (i.e., DEF_REGULAR is set).  At
3906
             this point we have not seen all the input files, so it is
3907
             possible that DEF_REGULAR is not set now but will be set
3908
             later (it is never cleared).  In case of a weak definition,
3909
             DEF_REGULAR may be cleared later by a strong definition in
3910
             a shared library.  We account for that possibility below by
3911
             storing information in the dyn_relocs field of the hash
3912
             table entry.  A similar situation occurs when creating
3913
             shared libraries and symbol visibility changes render the
3914
             symbol local.
3915
 
3916
             If on the other hand, we are creating an executable, we
3917
             may need to keep relocations for symbols satisfied by a
3918
             dynamic library if we manage to avoid copy relocs for the
3919
             symbol.  */
3920
          if ((info->shared
3921
               && (must_be_dyn_reloc (info, r_type)
3922
                   || (h != NULL
3923
                       && (! info->symbolic
3924
                           || h->root.type == bfd_link_hash_defweak
3925
                           || !h->def_regular))))
3926
              || (ELIMINATE_COPY_RELOCS
3927
                  && !info->shared
3928
                  && h != NULL
3929
                  && (h->root.type == bfd_link_hash_defweak
3930
                      || !h->def_regular)))
3931
            {
3932
              struct ppc_elf_dyn_relocs *p;
3933
              struct ppc_elf_dyn_relocs **rel_head;
3934
 
3935
#ifdef DEBUG
3936
              fprintf (stderr,
3937
                       "ppc_elf_check_relocs needs to "
3938
                       "create relocation for %s\n",
3939
                       (h && h->root.root.string
3940
                        ? h->root.root.string : "<unknown>"));
3941
#endif
3942
              if (sreloc == NULL)
3943
                {
3944
                  if (htab->elf.dynobj == NULL)
3945
                    htab->elf.dynobj = abfd;
3946
 
3947
                  sreloc = _bfd_elf_make_dynamic_reloc_section
3948
                    (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
3949
 
3950
                  if (sreloc == NULL)
3951
                    return FALSE;
3952
                }
3953
 
3954
              /* If this is a global symbol, we count the number of
3955
                 relocations we need for this symbol.  */
3956
              if (h != NULL)
3957
                {
3958
                  rel_head = &ppc_elf_hash_entry (h)->dyn_relocs;
3959
                }
3960
              else
3961
                {
3962
                  /* Track dynamic relocs needed for local syms too.
3963
                     We really need local syms available to do this
3964
                     easily.  Oh well.  */
3965
                  asection *s;
3966
                  void *vpp;
3967
                  Elf_Internal_Sym *isym;
3968
 
3969
                  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3970
                                                abfd, r_symndx);
3971
                  if (isym == NULL)
3972
                    return FALSE;
3973
 
3974
                  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3975
                  if (s == NULL)
3976
                    s = sec;
3977
 
3978
                  vpp = &elf_section_data (s)->local_dynrel;
3979
                  rel_head = (struct ppc_elf_dyn_relocs **) vpp;
3980
                }
3981
 
3982
              p = *rel_head;
3983
              if (p == NULL || p->sec != sec)
3984
                {
3985
                  p = bfd_alloc (htab->elf.dynobj, sizeof *p);
3986
                  if (p == NULL)
3987
                    return FALSE;
3988
                  p->next = *rel_head;
3989
                  *rel_head = p;
3990
                  p->sec = sec;
3991
                  p->count = 0;
3992
                  p->pc_count = 0;
3993
                }
3994
 
3995
              p->count += 1;
3996
              if (!must_be_dyn_reloc (info, r_type))
3997
                p->pc_count += 1;
3998
            }
3999
 
4000
          break;
4001
        }
4002
    }
4003
 
4004
  return TRUE;
4005
}
4006
 
4007
 
4008
/* Merge object attributes from IBFD into OBFD.  Raise an error if
4009
   there are conflicting attributes.  */
4010
static bfd_boolean
4011
ppc_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
4012
{
4013
  obj_attribute *in_attr, *in_attrs;
4014
  obj_attribute *out_attr, *out_attrs;
4015
 
4016
  if (!elf_known_obj_attributes_proc (obfd)[0].i)
4017
    {
4018
      /* This is the first object.  Copy the attributes.  */
4019
      _bfd_elf_copy_obj_attributes (ibfd, obfd);
4020
 
4021
      /* Use the Tag_null value to indicate the attributes have been
4022
         initialized.  */
4023
      elf_known_obj_attributes_proc (obfd)[0].i = 1;
4024
 
4025
      return TRUE;
4026
    }
4027
 
4028
  in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4029
  out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4030
 
4031
  /* Check for conflicting Tag_GNU_Power_ABI_FP attributes and merge
4032
     non-conflicting ones.  */
4033
  in_attr = &in_attrs[Tag_GNU_Power_ABI_FP];
4034
  out_attr = &out_attrs[Tag_GNU_Power_ABI_FP];
4035
  if (in_attr->i != out_attr->i)
4036
    {
4037
      out_attr->type = 1;
4038
      if (out_attr->i == 0)
4039
        out_attr->i = in_attr->i;
4040
      else if (in_attr->i == 0)
4041
        ;
4042
      else if (out_attr->i == 1 && in_attr->i == 2)
4043
        _bfd_error_handler
4044
          (_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd);
4045
      else if (out_attr->i == 1 && in_attr->i == 3)
4046
        _bfd_error_handler
4047
          (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
4048
          obfd, ibfd);
4049
      else if (out_attr->i == 3 && in_attr->i == 1)
4050
        _bfd_error_handler
4051
          (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
4052
          ibfd, obfd);
4053
      else if (out_attr->i == 3 && in_attr->i == 2)
4054
        _bfd_error_handler
4055
          (_("Warning: %B uses soft float, %B uses single-precision hard float"),
4056
          ibfd, obfd);
4057
      else if (out_attr->i == 2 && (in_attr->i == 1 || in_attr->i == 3))
4058
        _bfd_error_handler
4059
          (_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd);
4060
      else if (in_attr->i > 3)
4061
        _bfd_error_handler
4062
          (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
4063
           in_attr->i);
4064
      else
4065
        _bfd_error_handler
4066
          (_("Warning: %B uses unknown floating point ABI %d"), obfd,
4067
           out_attr->i);
4068
    }
4069
 
4070
  /* Check for conflicting Tag_GNU_Power_ABI_Vector attributes and
4071
     merge non-conflicting ones.  */
4072
  in_attr = &in_attrs[Tag_GNU_Power_ABI_Vector];
4073
  out_attr = &out_attrs[Tag_GNU_Power_ABI_Vector];
4074
  if (in_attr->i != out_attr->i)
4075
    {
4076
      const char *in_abi = NULL, *out_abi = NULL;
4077
 
4078
      switch (in_attr->i)
4079
        {
4080
        case 1: in_abi = "generic"; break;
4081
        case 2: in_abi = "AltiVec"; break;
4082
        case 3: in_abi = "SPE"; break;
4083
        }
4084
 
4085
      switch (out_attr->i)
4086
        {
4087
        case 1: out_abi = "generic"; break;
4088
        case 2: out_abi = "AltiVec"; break;
4089
        case 3: out_abi = "SPE"; break;
4090
        }
4091
 
4092
      out_attr->type = 1;
4093
      if (out_attr->i == 0)
4094
        out_attr->i = in_attr->i;
4095
      else if (in_attr->i == 0)
4096
        ;
4097
      /* For now, allow generic to transition to AltiVec or SPE
4098
         without a warning.  If GCC marked files with their stack
4099
         alignment and used don't-care markings for files which are
4100
         not affected by the vector ABI, we could warn about this
4101
         case too.  */
4102
      else if (out_attr->i == 1)
4103
        out_attr->i = in_attr->i;
4104
      else if (in_attr->i == 1)
4105
        ;
4106
      else if (in_abi == NULL)
4107
        _bfd_error_handler
4108
          (_("Warning: %B uses unknown vector ABI %d"), ibfd,
4109
           in_attr->i);
4110
      else if (out_abi == NULL)
4111
        _bfd_error_handler
4112
          (_("Warning: %B uses unknown vector ABI %d"), obfd,
4113
           in_attr->i);
4114
      else
4115
        _bfd_error_handler
4116
          (_("Warning: %B uses vector ABI \"%s\", %B uses \"%s\""),
4117
           ibfd, obfd, in_abi, out_abi);
4118
    }
4119
 
4120
  /* Check for conflicting Tag_GNU_Power_ABI_Struct_Return attributes
4121
     and merge non-conflicting ones.  */
4122
  in_attr = &in_attrs[Tag_GNU_Power_ABI_Struct_Return];
4123
  out_attr = &out_attrs[Tag_GNU_Power_ABI_Struct_Return];
4124
  if (in_attr->i != out_attr->i)
4125
    {
4126
      out_attr->type = 1;
4127
      if (out_attr->i == 0)
4128
       out_attr->i = in_attr->i;
4129
      else if (in_attr->i == 0)
4130
       ;
4131
      else if (out_attr->i == 1 && in_attr->i == 2)
4132
       _bfd_error_handler
4133
         (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), obfd, ibfd);
4134
      else if (out_attr->i == 2 && in_attr->i == 1)
4135
       _bfd_error_handler
4136
         (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), ibfd, obfd);
4137
      else if (in_attr->i > 2)
4138
       _bfd_error_handler
4139
         (_("Warning: %B uses unknown small structure return convention %d"), ibfd,
4140
          in_attr->i);
4141
      else
4142
       _bfd_error_handler
4143
         (_("Warning: %B uses unknown small structure return convention %d"), obfd,
4144
          out_attr->i);
4145
    }
4146
 
4147
  /* Merge Tag_compatibility attributes and any common GNU ones.  */
4148
  _bfd_elf_merge_object_attributes (ibfd, obfd);
4149
 
4150
  return TRUE;
4151
}
4152
 
4153
/* Merge backend specific data from an object file to the output
4154
   object file when linking.  */
4155
 
4156
static bfd_boolean
4157
ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4158
{
4159
  flagword old_flags;
4160
  flagword new_flags;
4161
  bfd_boolean error;
4162
 
4163
  if (!is_ppc_elf (ibfd) || !is_ppc_elf (obfd))
4164
    return TRUE;
4165
 
4166
  /* Check if we have the same endianess.  */
4167
  if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4168
    return FALSE;
4169
 
4170
  if (!ppc_elf_merge_obj_attributes (ibfd, obfd))
4171
    return FALSE;
4172
 
4173
  new_flags = elf_elfheader (ibfd)->e_flags;
4174
  old_flags = elf_elfheader (obfd)->e_flags;
4175
  if (!elf_flags_init (obfd))
4176
    {
4177
      /* First call, no flags set.  */
4178
      elf_flags_init (obfd) = TRUE;
4179
      elf_elfheader (obfd)->e_flags = new_flags;
4180
    }
4181
 
4182
  /* Compatible flags are ok.  */
4183
  else if (new_flags == old_flags)
4184
    ;
4185
 
4186
  /* Incompatible flags.  */
4187
  else
4188
    {
4189
      /* Warn about -mrelocatable mismatch.  Allow -mrelocatable-lib
4190
         to be linked with either.  */
4191
      error = FALSE;
4192
      if ((new_flags & EF_PPC_RELOCATABLE) != 0
4193
          && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
4194
        {
4195
          error = TRUE;
4196
          (*_bfd_error_handler)
4197
            (_("%B: compiled with -mrelocatable and linked with "
4198
               "modules compiled normally"), ibfd);
4199
        }
4200
      else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
4201
               && (old_flags & EF_PPC_RELOCATABLE) != 0)
4202
        {
4203
          error = TRUE;
4204
          (*_bfd_error_handler)
4205
            (_("%B: compiled normally and linked with "
4206
               "modules compiled with -mrelocatable"), ibfd);
4207
        }
4208
 
4209
      /* The output is -mrelocatable-lib iff both the input files are.  */
4210
      if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
4211
        elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
4212
 
4213
      /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
4214
         but each input file is either -mrelocatable or -mrelocatable-lib.  */
4215
      if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
4216
          && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
4217
          && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
4218
        elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
4219
 
4220
      /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if
4221
         any module uses it.  */
4222
      elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
4223
 
4224
      new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
4225
      old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
4226
 
4227
      /* Warn about any other mismatches.  */
4228
      if (new_flags != old_flags)
4229
        {
4230
          error = TRUE;
4231
          (*_bfd_error_handler)
4232
            (_("%B: uses different e_flags (0x%lx) fields "
4233
               "than previous modules (0x%lx)"),
4234
             ibfd, (long) new_flags, (long) old_flags);
4235
        }
4236
 
4237
      if (error)
4238
        {
4239
          bfd_set_error (bfd_error_bad_value);
4240
          return FALSE;
4241
        }
4242
    }
4243
 
4244
  return TRUE;
4245
}
4246
 
4247
/* Choose which PLT scheme to use, and set .plt flags appropriately.
4248
   Returns -1 on error, 0 for old PLT, 1 for new PLT.  */
4249
int
4250
ppc_elf_select_plt_layout (bfd *output_bfd ATTRIBUTE_UNUSED,
4251
                           struct bfd_link_info *info,
4252
                           enum ppc_elf_plt_type plt_style,
4253
                           int emit_stub_syms)
4254
{
4255
  struct ppc_elf_link_hash_table *htab;
4256
  flagword flags;
4257
 
4258
  htab = ppc_elf_hash_table (info);
4259
 
4260
  htab->emit_stub_syms = emit_stub_syms;
4261
 
4262
  if (htab->plt_type == PLT_UNSET)
4263
    {
4264
      if (plt_style == PLT_OLD)
4265
        htab->plt_type = PLT_OLD;
4266
      else
4267
        {
4268
          bfd *ibfd;
4269
          enum ppc_elf_plt_type plt_type = plt_style;
4270
 
4271
          /* Look through the reloc flags left by ppc_elf_check_relocs.
4272
             Use the old style bss plt if a file makes plt calls
4273
             without using the new relocs, and if ld isn't given
4274
             --secure-plt and we never see REL16 relocs.  */
4275
          if (plt_type == PLT_UNSET)
4276
            plt_type = PLT_OLD;
4277
          for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
4278
            if (is_ppc_elf (ibfd))
4279
              {
4280
                if (ppc_elf_tdata (ibfd)->has_rel16)
4281
                  plt_type = PLT_NEW;
4282
                else if (ppc_elf_tdata (ibfd)->makes_plt_call)
4283
                  {
4284
                    plt_type = PLT_OLD;
4285
                    htab->old_bfd = ibfd;
4286
                    break;
4287
                  }
4288
              }
4289
          htab->plt_type = plt_type;
4290
        }
4291
    }
4292
  if (htab->plt_type == PLT_OLD && plt_style == PLT_NEW)
4293
    info->callbacks->info (_("Using bss-plt due to %B"), htab->old_bfd);
4294
 
4295
  BFD_ASSERT (htab->plt_type != PLT_VXWORKS);
4296
 
4297
  if (htab->plt_type == PLT_NEW)
4298
    {
4299
      flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4300
               | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4301
 
4302
      /* The new PLT is a loaded section.  */
4303
      if (htab->plt != NULL
4304
          && !bfd_set_section_flags (htab->elf.dynobj, htab->plt, flags))
4305
        return -1;
4306
 
4307
      /* The new GOT is not executable.  */
4308
      if (htab->got != NULL
4309
          && !bfd_set_section_flags (htab->elf.dynobj, htab->got, flags))
4310
        return -1;
4311
    }
4312
  else
4313
    {
4314
      /* Stop an unused .glink section from affecting .text alignment.  */
4315
      if (htab->glink != NULL
4316
          && !bfd_set_section_alignment (htab->elf.dynobj, htab->glink, 0))
4317
        return -1;
4318
    }
4319
  return htab->plt_type == PLT_NEW;
4320
}
4321
 
4322
/* Return the section that should be marked against GC for a given
4323
   relocation.  */
4324
 
4325
static asection *
4326
ppc_elf_gc_mark_hook (asection *sec,
4327
                      struct bfd_link_info *info,
4328
                      Elf_Internal_Rela *rel,
4329
                      struct elf_link_hash_entry *h,
4330
                      Elf_Internal_Sym *sym)
4331
{
4332
  if (h != NULL)
4333
    switch (ELF32_R_TYPE (rel->r_info))
4334
      {
4335
      case R_PPC_GNU_VTINHERIT:
4336
      case R_PPC_GNU_VTENTRY:
4337
        return NULL;
4338
      }
4339
 
4340
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4341
}
4342
 
4343
/* Update the got, plt and dynamic reloc reference counts for the
4344
   section being removed.  */
4345
 
4346
static bfd_boolean
4347
ppc_elf_gc_sweep_hook (bfd *abfd,
4348
                       struct bfd_link_info *info,
4349
                       asection *sec,
4350
                       const Elf_Internal_Rela *relocs)
4351
{
4352
  struct ppc_elf_link_hash_table *htab;
4353
  Elf_Internal_Shdr *symtab_hdr;
4354
  struct elf_link_hash_entry **sym_hashes;
4355
  bfd_signed_vma *local_got_refcounts;
4356
  const Elf_Internal_Rela *rel, *relend;
4357
  asection *got2;
4358
 
4359
  if (info->relocatable)
4360
    return TRUE;
4361
 
4362
  if ((sec->flags & SEC_ALLOC) == 0)
4363
    return TRUE;
4364
 
4365
  elf_section_data (sec)->local_dynrel = NULL;
4366
 
4367
  htab = ppc_elf_hash_table (info);
4368
  symtab_hdr = &elf_symtab_hdr (abfd);
4369
  sym_hashes = elf_sym_hashes (abfd);
4370
  local_got_refcounts = elf_local_got_refcounts (abfd);
4371
  got2 = bfd_get_section_by_name (abfd, ".got2");
4372
 
4373
  relend = relocs + sec->reloc_count;
4374
  for (rel = relocs; rel < relend; rel++)
4375
    {
4376
      unsigned long r_symndx;
4377
      enum elf_ppc_reloc_type r_type;
4378
      struct elf_link_hash_entry *h = NULL;
4379
 
4380
      r_symndx = ELF32_R_SYM (rel->r_info);
4381
      if (r_symndx >= symtab_hdr->sh_info)
4382
        {
4383
          struct ppc_elf_dyn_relocs **pp, *p;
4384
          struct ppc_elf_link_hash_entry *eh;
4385
 
4386
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4387
          while (h->root.type == bfd_link_hash_indirect
4388
                 || h->root.type == bfd_link_hash_warning)
4389
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
4390
          eh = (struct ppc_elf_link_hash_entry *) h;
4391
 
4392
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
4393
            if (p->sec == sec)
4394
              {
4395
                /* Everything must go for SEC.  */
4396
                *pp = p->next;
4397
                break;
4398
              }
4399
        }
4400
 
4401
      r_type = ELF32_R_TYPE (rel->r_info);
4402
      if (!htab->is_vxworks
4403
          && h == NULL
4404
          && local_got_refcounts != NULL
4405
          && (!info->shared
4406
              || is_branch_reloc (r_type)))
4407
        {
4408
          struct plt_entry **local_plt = (struct plt_entry **)
4409
            (local_got_refcounts + symtab_hdr->sh_info);
4410
          char *local_got_tls_masks = (char *)
4411
            (local_plt + symtab_hdr->sh_info);
4412
          if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
4413
            {
4414
              struct plt_entry **ifunc = local_plt + r_symndx;
4415
              bfd_vma addend = 0;
4416
              struct plt_entry *ent;
4417
 
4418
              if (r_type == R_PPC_PLTREL24 && info->shared)
4419
                addend = rel->r_addend;
4420
              ent = find_plt_ent (ifunc, got2, addend);
4421
              if (ent->plt.refcount > 0)
4422
                ent->plt.refcount -= 1;
4423
              continue;
4424
            }
4425
        }
4426
 
4427
      switch (r_type)
4428
        {
4429
        case R_PPC_GOT_TLSLD16:
4430
        case R_PPC_GOT_TLSLD16_LO:
4431
        case R_PPC_GOT_TLSLD16_HI:
4432
        case R_PPC_GOT_TLSLD16_HA:
4433
        case R_PPC_GOT_TLSGD16:
4434
        case R_PPC_GOT_TLSGD16_LO:
4435
        case R_PPC_GOT_TLSGD16_HI:
4436
        case R_PPC_GOT_TLSGD16_HA:
4437
        case R_PPC_GOT_TPREL16:
4438
        case R_PPC_GOT_TPREL16_LO:
4439
        case R_PPC_GOT_TPREL16_HI:
4440
        case R_PPC_GOT_TPREL16_HA:
4441
        case R_PPC_GOT_DTPREL16:
4442
        case R_PPC_GOT_DTPREL16_LO:
4443
        case R_PPC_GOT_DTPREL16_HI:
4444
        case R_PPC_GOT_DTPREL16_HA:
4445
        case R_PPC_GOT16:
4446
        case R_PPC_GOT16_LO:
4447
        case R_PPC_GOT16_HI:
4448
        case R_PPC_GOT16_HA:
4449
          if (h != NULL)
4450
            {
4451
              if (h->got.refcount > 0)
4452
                h->got.refcount--;
4453
              if (!info->shared)
4454
                {
4455
                  struct plt_entry *ent;
4456
 
4457
                  ent = find_plt_ent (&h->plt.plist, NULL, 0);
4458
                  if (ent != NULL && ent->plt.refcount > 0)
4459
                    ent->plt.refcount -= 1;
4460
                }
4461
            }
4462
          else if (local_got_refcounts != NULL)
4463
            {
4464
              if (local_got_refcounts[r_symndx] > 0)
4465
                local_got_refcounts[r_symndx]--;
4466
            }
4467
          break;
4468
 
4469
        case R_PPC_REL24:
4470
        case R_PPC_REL14:
4471
        case R_PPC_REL14_BRTAKEN:
4472
        case R_PPC_REL14_BRNTAKEN:
4473
        case R_PPC_REL32:
4474
          if (h == NULL || h == htab->elf.hgot)
4475
            break;
4476
          /* Fall thru */
4477
 
4478
        case R_PPC_ADDR32:
4479
        case R_PPC_ADDR24:
4480
        case R_PPC_ADDR16:
4481
        case R_PPC_ADDR16_LO:
4482
        case R_PPC_ADDR16_HI:
4483
        case R_PPC_ADDR16_HA:
4484
        case R_PPC_ADDR14:
4485
        case R_PPC_ADDR14_BRTAKEN:
4486
        case R_PPC_ADDR14_BRNTAKEN:
4487
        case R_PPC_UADDR32:
4488
        case R_PPC_UADDR16:
4489
          if (info->shared)
4490
            break;
4491
 
4492
        case R_PPC_PLT32:
4493
        case R_PPC_PLTREL24:
4494
        case R_PPC_PLTREL32:
4495
        case R_PPC_PLT16_LO:
4496
        case R_PPC_PLT16_HI:
4497
        case R_PPC_PLT16_HA:
4498
          if (h != NULL)
4499
            {
4500
              bfd_vma addend = 0;
4501
              struct plt_entry *ent;
4502
 
4503
              if (r_type == R_PPC_PLTREL24 && info->shared)
4504
                addend = rel->r_addend;
4505
              ent = find_plt_ent (&h->plt.plist, got2, addend);
4506
              if (ent != NULL && ent->plt.refcount > 0)
4507
                ent->plt.refcount -= 1;
4508
            }
4509
          break;
4510
 
4511
        default:
4512
          break;
4513
        }
4514
    }
4515
  return TRUE;
4516
}
4517
 
4518
/* Set plt output section type, htab->tls_get_addr, and call the
4519
   generic ELF tls_setup function.  */
4520
 
4521
asection *
4522
ppc_elf_tls_setup (bfd *obfd,
4523
                   struct bfd_link_info *info,
4524
                   int no_tls_get_addr_opt)
4525
{
4526
  struct ppc_elf_link_hash_table *htab;
4527
 
4528
  htab = ppc_elf_hash_table (info);
4529
  htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4530
                                             FALSE, FALSE, TRUE);
4531
  if (!no_tls_get_addr_opt)
4532
    {
4533
      struct elf_link_hash_entry *opt, *tga;
4534
      opt = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
4535
                                  FALSE, FALSE, TRUE);
4536
      if (opt != NULL
4537
          && (opt->root.type == bfd_link_hash_defined
4538
              || opt->root.type == bfd_link_hash_defweak))
4539
        {
4540
          /* If glibc supports an optimized __tls_get_addr call stub,
4541
             signalled by the presence of __tls_get_addr_opt, and we'll
4542
             be calling __tls_get_addr via a plt call stub, then
4543
             make __tls_get_addr point to __tls_get_addr_opt.  */
4544
          tga = htab->tls_get_addr;
4545
          if (htab->elf.dynamic_sections_created
4546
              && tga != NULL
4547
              && (tga->type == STT_FUNC
4548
                  || tga->needs_plt)
4549
              && !(SYMBOL_CALLS_LOCAL (info, tga)
4550
                   || (ELF_ST_VISIBILITY (tga->other) != STV_DEFAULT
4551
                       && tga->root.type == bfd_link_hash_undefweak)))
4552
            {
4553
              struct plt_entry *ent;
4554
              for (ent = tga->plt.plist; ent != NULL; ent = ent->next)
4555
                if (ent->plt.refcount > 0)
4556
                  break;
4557
              if (ent != NULL)
4558
                {
4559
                  tga->root.type = bfd_link_hash_indirect;
4560
                  tga->root.u.i.link = &opt->root;
4561
                  ppc_elf_copy_indirect_symbol (info, opt, tga);
4562
                  if (opt->dynindx != -1)
4563
                    {
4564
                      /* Use __tls_get_addr_opt in dynamic relocations.  */
4565
                      opt->dynindx = -1;
4566
                      _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4567
                                              opt->dynstr_index);
4568
                      if (!bfd_elf_link_record_dynamic_symbol (info, opt))
4569
                        return FALSE;
4570
                    }
4571
                  htab->tls_get_addr = opt;
4572
                }
4573
            }
4574
        }
4575
      else
4576
        no_tls_get_addr_opt = TRUE;
4577
    }
4578
  htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
4579
  if (htab->plt_type == PLT_NEW
4580
      && htab->plt != NULL
4581
      && htab->plt->output_section != NULL)
4582
    {
4583
      elf_section_type (htab->plt->output_section) = SHT_PROGBITS;
4584
      elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE;
4585
    }
4586
 
4587
  return _bfd_elf_tls_setup (obfd, info);
4588
}
4589
 
4590
/* Return TRUE iff REL is a branch reloc with a global symbol matching
4591
   HASH.  */
4592
 
4593
static bfd_boolean
4594
branch_reloc_hash_match (const bfd *ibfd,
4595
                         const Elf_Internal_Rela *rel,
4596
                         const struct elf_link_hash_entry *hash)
4597
{
4598
  Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
4599
  enum elf_ppc_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
4600
  unsigned int r_symndx = ELF32_R_SYM (rel->r_info);
4601
 
4602
  if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
4603
    {
4604
      struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
4605
      struct elf_link_hash_entry *h;
4606
 
4607
      h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4608
      while (h->root.type == bfd_link_hash_indirect
4609
             || h->root.type == bfd_link_hash_warning)
4610
        h = (struct elf_link_hash_entry *) h->root.u.i.link;
4611
      if (h == hash)
4612
        return TRUE;
4613
    }
4614
  return FALSE;
4615
}
4616
 
4617
/* Run through all the TLS relocs looking for optimization
4618
   opportunities.  */
4619
 
4620
bfd_boolean
4621
ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED,
4622
                      struct bfd_link_info *info)
4623
{
4624
  bfd *ibfd;
4625
  asection *sec;
4626
  struct ppc_elf_link_hash_table *htab;
4627
  int pass;
4628
 
4629
  if (info->relocatable || !info->executable)
4630
    return TRUE;
4631
 
4632
  htab = ppc_elf_hash_table (info);
4633
  /* Make two passes through the relocs.  First time check that tls
4634
     relocs involved in setting up a tls_get_addr call are indeed
4635
     followed by such a call.  If they are not, exclude them from
4636
     the optimizations done on the second pass.  */
4637
  for (pass = 0; pass < 2; ++pass)
4638
    for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4639
      {
4640
        Elf_Internal_Sym *locsyms = NULL;
4641
        Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
4642
        asection *got2 = bfd_get_section_by_name (ibfd, ".got2");
4643
 
4644
        for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4645
          if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
4646
            {
4647
              Elf_Internal_Rela *relstart, *rel, *relend;
4648
 
4649
              /* Read the relocations.  */
4650
              relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
4651
                                                    info->keep_memory);
4652
              if (relstart == NULL)
4653
                return FALSE;
4654
 
4655
              relend = relstart + sec->reloc_count;
4656
              for (rel = relstart; rel < relend; rel++)
4657
                {
4658
                  enum elf_ppc_reloc_type r_type;
4659
                  unsigned long r_symndx;
4660
                  struct elf_link_hash_entry *h = NULL;
4661
                  char *tls_mask;
4662
                  char tls_set, tls_clear;
4663
                  bfd_boolean is_local;
4664
                  int expecting_tls_get_addr;
4665
                  bfd_signed_vma *got_count;
4666
 
4667
                  r_symndx = ELF32_R_SYM (rel->r_info);
4668
                  if (r_symndx >= symtab_hdr->sh_info)
4669
                    {
4670
                      struct elf_link_hash_entry **sym_hashes;
4671
 
4672
                      sym_hashes = elf_sym_hashes (ibfd);
4673
                      h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4674
                      while (h->root.type == bfd_link_hash_indirect
4675
                             || h->root.type == bfd_link_hash_warning)
4676
                        h = (struct elf_link_hash_entry *) h->root.u.i.link;
4677
                    }
4678
 
4679
                  expecting_tls_get_addr = 0;
4680
                  is_local = FALSE;
4681
                  if (h == NULL
4682
                      || !h->def_dynamic)
4683
                    is_local = TRUE;
4684
 
4685
                  r_type = ELF32_R_TYPE (rel->r_info);
4686
                  switch (r_type)
4687
                    {
4688
                    case R_PPC_GOT_TLSLD16:
4689
                    case R_PPC_GOT_TLSLD16_LO:
4690
                      expecting_tls_get_addr = 1;
4691
                      /* Fall thru */
4692
 
4693
                    case R_PPC_GOT_TLSLD16_HI:
4694
                    case R_PPC_GOT_TLSLD16_HA:
4695
                      /* These relocs should never be against a symbol
4696
                         defined in a shared lib.  Leave them alone if
4697
                         that turns out to be the case.  */
4698
                      if (!is_local)
4699
                        continue;
4700
 
4701
                      /* LD -> LE */
4702
                      tls_set = 0;
4703
                      tls_clear = TLS_LD;
4704
                      break;
4705
 
4706
                    case R_PPC_GOT_TLSGD16:
4707
                    case R_PPC_GOT_TLSGD16_LO:
4708
                      expecting_tls_get_addr = 1;
4709
                      /* Fall thru */
4710
 
4711
                    case R_PPC_GOT_TLSGD16_HI:
4712
                    case R_PPC_GOT_TLSGD16_HA:
4713
                      if (is_local)
4714
                        /* GD -> LE */
4715
                        tls_set = 0;
4716
                      else
4717
                        /* GD -> IE */
4718
                        tls_set = TLS_TLS | TLS_TPRELGD;
4719
                      tls_clear = TLS_GD;
4720
                      break;
4721
 
4722
                    case R_PPC_GOT_TPREL16:
4723
                    case R_PPC_GOT_TPREL16_LO:
4724
                    case R_PPC_GOT_TPREL16_HI:
4725
                    case R_PPC_GOT_TPREL16_HA:
4726
                      if (is_local)
4727
                        {
4728
                          /* IE -> LE */
4729
                          tls_set = 0;
4730
                          tls_clear = TLS_TPREL;
4731
                          break;
4732
                        }
4733
                      else
4734
                        continue;
4735
 
4736
                    case R_PPC_TLSGD:
4737
                    case R_PPC_TLSLD:
4738
                      expecting_tls_get_addr = 2;
4739
                      tls_set = 0;
4740
                      tls_clear = 0;
4741
                      break;
4742
 
4743
                    default:
4744
                      continue;
4745
                    }
4746
 
4747
                  if (pass == 0)
4748
                    {
4749
                      if (!expecting_tls_get_addr
4750
                          || (expecting_tls_get_addr == 1
4751
                              && !sec->has_tls_get_addr_call))
4752
                        continue;
4753
 
4754
                      if (rel + 1 < relend
4755
                          && branch_reloc_hash_match (ibfd, rel + 1,
4756
                                                      htab->tls_get_addr))
4757
                        continue;
4758
 
4759
                      /* Uh oh, we didn't find the expected call.  We
4760
                         could just mark this symbol to exclude it
4761
                         from tls optimization but it's safer to skip
4762
                         the entire section.  */
4763
                      sec->has_tls_reloc = 0;
4764
                      break;
4765
                    }
4766
 
4767
                  if (expecting_tls_get_addr)
4768
                    {
4769
                      struct plt_entry *ent;
4770
                      bfd_vma addend = 0;
4771
 
4772
                      if (info->shared
4773
                          && ELF32_R_TYPE (rel[1].r_info) == R_PPC_PLTREL24)
4774
                        addend = rel[1].r_addend;
4775
                      ent = find_plt_ent (&htab->tls_get_addr->plt.plist,
4776
                                          got2, addend);
4777
                      if (ent != NULL && ent->plt.refcount > 0)
4778
                        ent->plt.refcount -= 1;
4779
 
4780
                      if (expecting_tls_get_addr == 2)
4781
                        continue;
4782
                    }
4783
 
4784
                  if (h != NULL)
4785
                    {
4786
                      tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
4787
                      got_count = &h->got.refcount;
4788
                    }
4789
                  else
4790
                    {
4791
                      bfd_signed_vma *lgot_refs;
4792
                      struct plt_entry **local_plt;
4793
                      char *lgot_masks;
4794
 
4795
                      if (locsyms == NULL)
4796
                        {
4797
                          locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
4798
                          if (locsyms == NULL)
4799
                            locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
4800
                                                            symtab_hdr->sh_info,
4801
                                                            0, NULL, NULL, NULL);
4802
                          if (locsyms == NULL)
4803
                            {
4804
                              if (elf_section_data (sec)->relocs != relstart)
4805
                                free (relstart);
4806
                              return FALSE;
4807
                            }
4808
                        }
4809
                      lgot_refs = elf_local_got_refcounts (ibfd);
4810
                      if (lgot_refs == NULL)
4811
                        abort ();
4812
                      local_plt = (struct plt_entry **)
4813
                        (lgot_refs + symtab_hdr->sh_info);
4814
                      lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
4815
                      tls_mask = &lgot_masks[r_symndx];
4816
                      got_count = &lgot_refs[r_symndx];
4817
                    }
4818
 
4819
                  if (tls_set == 0)
4820
                    {
4821
                      /* We managed to get rid of a got entry.  */
4822
                      if (*got_count > 0)
4823
                        *got_count -= 1;
4824
                    }
4825
 
4826
                  *tls_mask |= tls_set;
4827
                  *tls_mask &= ~tls_clear;
4828
                }
4829
 
4830
              if (elf_section_data (sec)->relocs != relstart)
4831
                free (relstart);
4832
            }
4833
 
4834
        if (locsyms != NULL
4835
            && (symtab_hdr->contents != (unsigned char *) locsyms))
4836
          {
4837
            if (!info->keep_memory)
4838
              free (locsyms);
4839
            else
4840
              symtab_hdr->contents = (unsigned char *) locsyms;
4841
          }
4842
      }
4843
  return TRUE;
4844
}
4845
 
4846
/* Return true if we have dynamic relocs that apply to read-only sections.  */
4847
 
4848
static bfd_boolean
4849
readonly_dynrelocs (struct elf_link_hash_entry *h)
4850
{
4851
  struct ppc_elf_dyn_relocs *p;
4852
 
4853
  for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
4854
    {
4855
      asection *s = p->sec->output_section;
4856
 
4857
      if (s != NULL
4858
          && ((s->flags & (SEC_READONLY | SEC_ALLOC))
4859
              == (SEC_READONLY | SEC_ALLOC)))
4860
        return TRUE;
4861
    }
4862
  return FALSE;
4863
}
4864
 
4865
/* Adjust a symbol defined by a dynamic object and referenced by a
4866
   regular object.  The current definition is in some section of the
4867
   dynamic object, but we're not including those sections.  We have to
4868
   change the definition to something the rest of the link can
4869
   understand.  */
4870
 
4871
static bfd_boolean
4872
ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
4873
                               struct elf_link_hash_entry *h)
4874
{
4875
  struct ppc_elf_link_hash_table *htab;
4876
  asection *s;
4877
 
4878
#ifdef DEBUG
4879
  fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n",
4880
           h->root.root.string);
4881
#endif
4882
 
4883
  /* Make sure we know what is going on here.  */
4884
  htab = ppc_elf_hash_table (info);
4885
  BFD_ASSERT (htab->elf.dynobj != NULL
4886
              && (h->needs_plt
4887
                  || h->type == STT_GNU_IFUNC
4888
                  || h->u.weakdef != NULL
4889
                  || (h->def_dynamic
4890
                      && h->ref_regular
4891
                      && !h->def_regular)));
4892
 
4893
  /* Deal with function syms.  */
4894
  if (h->type == STT_FUNC
4895
      || h->type == STT_GNU_IFUNC
4896
      || h->needs_plt)
4897
    {
4898
      /* Clear procedure linkage table information for any symbol that
4899
         won't need a .plt entry.  */
4900
      struct plt_entry *ent;
4901
      for (ent = h->plt.plist; ent != NULL; ent = ent->next)
4902
        if (ent->plt.refcount > 0)
4903
          break;
4904
      if (ent == NULL
4905
          || (h->type != STT_GNU_IFUNC
4906
              && (SYMBOL_CALLS_LOCAL (info, h)
4907
                  || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4908
                      && h->root.type == bfd_link_hash_undefweak))))
4909
        {
4910
          /* A PLT entry is not required/allowed when:
4911
 
4912
             1. We are not using ld.so; because then the PLT entry
4913
             can't be set up, so we can't use one.  In this case,
4914
             ppc_elf_adjust_dynamic_symbol won't even be called.
4915
 
4916
             2. GC has rendered the entry unused.
4917
 
4918
             3. We know for certain that a call to this symbol
4919
             will go to this object, or will remain undefined.  */
4920
          h->plt.plist = NULL;
4921
          h->needs_plt = 0;
4922
        }
4923
      else
4924
        {
4925
          /* After adjust_dynamic_symbol, non_got_ref set in the
4926
             non-shared case means that we have allocated space in
4927
             .dynbss for the symbol and thus dyn_relocs for this
4928
             symbol should be discarded.
4929
             If we get here we know we are making a PLT entry for this
4930
             symbol, and in an executable we'd normally resolve
4931
             relocations against this symbol to the PLT entry.  Allow
4932
             dynamic relocs if the reference is weak, and the dynamic
4933
             relocs will not cause text relocation.  */
4934
          if (!h->ref_regular_nonweak
4935
              && h->non_got_ref
4936
              && h->type != STT_GNU_IFUNC
4937
              && !htab->is_vxworks
4938
              && !ppc_elf_hash_entry (h)->has_sda_refs
4939
              && !readonly_dynrelocs (h))
4940
            h->non_got_ref = 0;
4941
        }
4942
      return TRUE;
4943
    }
4944
  else
4945
    h->plt.plist = NULL;
4946
 
4947
  /* If this is a weak symbol, and there is a real definition, the
4948
     processor independent code will have arranged for us to see the
4949
     real definition first, and we can just use the same value.  */
4950
  if (h->u.weakdef != NULL)
4951
    {
4952
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4953
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
4954
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
4955
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
4956
      if (ELIMINATE_COPY_RELOCS)
4957
        h->non_got_ref = h->u.weakdef->non_got_ref;
4958
      return TRUE;
4959
    }
4960
 
4961
  /* This is a reference to a symbol defined by a dynamic object which
4962
     is not a function.  */
4963
 
4964
  /* If we are creating a shared library, we must presume that the
4965
     only references to the symbol are via the global offset table.
4966
     For such cases we need not do anything here; the relocations will
4967
     be handled correctly by relocate_section.  */
4968
  if (info->shared)
4969
    return TRUE;
4970
 
4971
  /* If there are no references to this symbol that do not use the
4972
     GOT, we don't need to generate a copy reloc.  */
4973
  if (!h->non_got_ref)
4974
    return TRUE;
4975
 
4976
   /* If we didn't find any dynamic relocs in read-only sections, then
4977
      we'll be keeping the dynamic relocs and avoiding the copy reloc.
4978
      We can't do this if there are any small data relocations.  This
4979
      doesn't work on VxWorks, where we can not have dynamic
4980
      relocations (other than copy and jump slot relocations) in an
4981
      executable.  */
4982
  if (ELIMINATE_COPY_RELOCS
4983
      && !ppc_elf_hash_entry (h)->has_sda_refs
4984
      && !htab->is_vxworks
4985
      && !h->def_regular
4986
      && !readonly_dynrelocs (h))
4987
    {
4988
      h->non_got_ref = 0;
4989
      return TRUE;
4990
    }
4991
 
4992
  if (h->size == 0)
4993
    {
4994
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4995
                             h->root.root.string);
4996
      return TRUE;
4997
    }
4998
 
4999
  /* We must allocate the symbol in our .dynbss section, which will
5000
     become part of the .bss section of the executable.  There will be
5001
     an entry for this symbol in the .dynsym section.  The dynamic
5002
     object will contain position independent code, so all references
5003
     from the dynamic object to this symbol will go through the global
5004
     offset table.  The dynamic linker will use the .dynsym entry to
5005
     determine the address it must put in the global offset table, so
5006
     both the dynamic object and the regular object will refer to the
5007
     same memory location for the variable.
5008
 
5009
     Of course, if the symbol is referenced using SDAREL relocs, we
5010
     must instead allocate it in .sbss.  */
5011
 
5012
  if (ppc_elf_hash_entry (h)->has_sda_refs)
5013
    s = htab->dynsbss;
5014
  else
5015
    s = htab->dynbss;
5016
  BFD_ASSERT (s != NULL);
5017
 
5018
  /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
5019
     copy the initial value out of the dynamic object and into the
5020
     runtime process image.  We need to remember the offset into the
5021
     .rela.bss section we are going to use.  */
5022
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5023
    {
5024
      asection *srel;
5025
 
5026
      if (ppc_elf_hash_entry (h)->has_sda_refs)
5027
        srel = htab->relsbss;
5028
      else
5029
        srel = htab->relbss;
5030
      BFD_ASSERT (srel != NULL);
5031
      srel->size += sizeof (Elf32_External_Rela);
5032
      h->needs_copy = 1;
5033
    }
5034
 
5035
  return _bfd_elf_adjust_dynamic_copy (h, s);
5036
}
5037
 
5038
/* Generate a symbol to mark plt call stubs.  For non-PIC code the sym is
5039
   xxxxxxxx.plt_call32.<callee> where xxxxxxxx is a hex number, usually 0,
5040
   specifying the addend on the plt relocation.  For -fpic code, the sym
5041
   is xxxxxxxx.plt_pic32.<callee>, and for -fPIC
5042
   xxxxxxxx.got2.plt_pic32.<callee>.  */
5043
 
5044
static bfd_boolean
5045
add_stub_sym (struct plt_entry *ent,
5046
              struct elf_link_hash_entry *h,
5047
              struct bfd_link_info *info)
5048
{
5049
  struct elf_link_hash_entry *sh;
5050
  size_t len1, len2, len3;
5051
  char *name;
5052
  const char *stub;
5053
  struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
5054
 
5055
  if (info->shared)
5056
    stub = ".plt_pic32.";
5057
  else
5058
    stub = ".plt_call32.";
5059
 
5060
  len1 = strlen (h->root.root.string);
5061
  len2 = strlen (stub);
5062
  len3 = 0;
5063
  if (ent->sec)
5064
    len3 = strlen (ent->sec->name);
5065
  name = bfd_malloc (len1 + len2 + len3 + 9);
5066
  if (name == NULL)
5067
    return FALSE;
5068
  sprintf (name, "%08x", (unsigned) ent->addend & 0xffffffff);
5069
  if (ent->sec)
5070
    memcpy (name + 8, ent->sec->name, len3);
5071
  memcpy (name + 8 + len3, stub, len2);
5072
  memcpy (name + 8 + len3 + len2, h->root.root.string, len1 + 1);
5073
  sh = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
5074
  if (sh == NULL)
5075
    return FALSE;
5076
  if (sh->root.type == bfd_link_hash_new)
5077
    {
5078
      sh->root.type = bfd_link_hash_defined;
5079
      sh->root.u.def.section = htab->glink;
5080
      sh->root.u.def.value = ent->glink_offset;
5081
      sh->ref_regular = 1;
5082
      sh->def_regular = 1;
5083
      sh->ref_regular_nonweak = 1;
5084
      sh->forced_local = 1;
5085
      sh->non_elf = 0;
5086
    }
5087
  return TRUE;
5088
}
5089
 
5090
/* Allocate NEED contiguous space in .got, and return the offset.
5091
   Handles allocation of the got header when crossing 32k.  */
5092
 
5093
static bfd_vma
5094
allocate_got (struct ppc_elf_link_hash_table *htab, unsigned int need)
5095
{
5096
  bfd_vma where;
5097
  unsigned int max_before_header;
5098
 
5099
  if (htab->plt_type == PLT_VXWORKS)
5100
    {
5101
      where = htab->got->size;
5102
      htab->got->size += need;
5103
    }
5104
  else
5105
    {
5106
      max_before_header = htab->plt_type == PLT_NEW ? 32768 : 32764;
5107
      if (need <= htab->got_gap)
5108
        {
5109
          where = max_before_header - htab->got_gap;
5110
          htab->got_gap -= need;
5111
        }
5112
      else
5113
        {
5114
          if (htab->got->size + need > max_before_header
5115
              && htab->got->size <= max_before_header)
5116
            {
5117
              htab->got_gap = max_before_header - htab->got->size;
5118
              htab->got->size = max_before_header + htab->got_header_size;
5119
            }
5120
          where = htab->got->size;
5121
          htab->got->size += need;
5122
        }
5123
    }
5124
  return where;
5125
}
5126
 
5127
/* Allocate space in associated reloc sections for dynamic relocs.  */
5128
 
5129
static bfd_boolean
5130
allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5131
{
5132
  struct bfd_link_info *info = inf;
5133
  struct ppc_elf_link_hash_entry *eh;
5134
  struct ppc_elf_link_hash_table *htab;
5135
  struct ppc_elf_dyn_relocs *p;
5136
 
5137
  if (h->root.type == bfd_link_hash_indirect)
5138
    return TRUE;
5139
 
5140
  if (h->root.type == bfd_link_hash_warning)
5141
    /* When warning symbols are created, they **replace** the "real"
5142
       entry in the hash table, thus we never get to see the real
5143
       symbol in a hash traversal.  So look at it now.  */
5144
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
5145
 
5146
  htab = ppc_elf_hash_table (info);
5147
  if (htab->elf.dynamic_sections_created
5148
      || h->type == STT_GNU_IFUNC)
5149
    {
5150
      struct plt_entry *ent;
5151
      bfd_boolean doneone = FALSE;
5152
      bfd_vma plt_offset = 0, glink_offset = 0;
5153
      bfd_boolean dyn;
5154
 
5155
      for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5156
        if (ent->plt.refcount > 0)
5157
          {
5158
            /* Make sure this symbol is output as a dynamic symbol.  */
5159
            if (h->dynindx == -1
5160
                && !h->forced_local
5161
                && !h->def_regular
5162
                && htab->elf.dynamic_sections_created)
5163
              {
5164
                if (! bfd_elf_link_record_dynamic_symbol (info, h))
5165
                  return FALSE;
5166
              }
5167
 
5168
            dyn = htab->elf.dynamic_sections_created;
5169
            if (info->shared
5170
                || h->type == STT_GNU_IFUNC
5171
                || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
5172
              {
5173
                asection *s = htab->plt;
5174
                if (!dyn || h->dynindx == -1)
5175
                  s = htab->iplt;
5176
 
5177
                if (htab->plt_type == PLT_NEW || !dyn || h->dynindx == -1)
5178
                  {
5179
                    if (!doneone)
5180
                      {
5181
                        plt_offset = s->size;
5182
                        s->size += 4;
5183
                      }
5184
                    ent->plt.offset = plt_offset;
5185
 
5186
                    s = htab->glink;
5187
                    if (!doneone || info->shared)
5188
                      {
5189
                        glink_offset = s->size;
5190
                        s->size += GLINK_ENTRY_SIZE;
5191
                        if (h == htab->tls_get_addr
5192
                            && !htab->no_tls_get_addr_opt)
5193
                          s->size += TLS_GET_ADDR_GLINK_SIZE - GLINK_ENTRY_SIZE;
5194
                      }
5195
                    if (!doneone
5196
                        && !info->shared
5197
                        && h->def_dynamic
5198
                        && !h->def_regular)
5199
                      {
5200
                        h->root.u.def.section = s;
5201
                        h->root.u.def.value = glink_offset;
5202
                      }
5203
                    ent->glink_offset = glink_offset;
5204
 
5205
                    if (htab->emit_stub_syms
5206
                        && !add_stub_sym (ent, h, info))
5207
                      return FALSE;
5208
                  }
5209
                else
5210
                  {
5211
                    if (!doneone)
5212
                      {
5213
                        /* If this is the first .plt entry, make room
5214
                           for the special first entry.  */
5215
                        if (s->size == 0)
5216
                          s->size += htab->plt_initial_entry_size;
5217
 
5218
                        /* The PowerPC PLT is actually composed of two
5219
                           parts, the first part is 2 words (for a load
5220
                           and a jump), and then there is a remaining
5221
                           word available at the end.  */
5222
                        plt_offset = (htab->plt_initial_entry_size
5223
                                      + (htab->plt_slot_size
5224
                                         * ((s->size
5225
                                             - htab->plt_initial_entry_size)
5226
                                            / htab->plt_entry_size)));
5227
 
5228
                        /* If this symbol is not defined in a regular
5229
                           file, and we are not generating a shared
5230
                           library, then set the symbol to this location
5231
                           in the .plt.  This is to avoid text
5232
                           relocations, and is required to make
5233
                           function pointers compare as equal between
5234
                           the normal executable and the shared library.  */
5235
                        if (! info->shared
5236
                            && h->def_dynamic
5237
                            && !h->def_regular)
5238
                          {
5239
                            h->root.u.def.section = s;
5240
                            h->root.u.def.value = plt_offset;
5241
                          }
5242
 
5243
                        /* Make room for this entry.  */
5244
                        s->size += htab->plt_entry_size;
5245
                        /* After the 8192nd entry, room for two entries
5246
                           is allocated.  */
5247
                        if (htab->plt_type == PLT_OLD
5248
                            && (s->size - htab->plt_initial_entry_size)
5249
                                / htab->plt_entry_size
5250
                               > PLT_NUM_SINGLE_ENTRIES)
5251
                          s->size += htab->plt_entry_size;
5252
                      }
5253
                    ent->plt.offset = plt_offset;
5254
                  }
5255
 
5256
                /* We also need to make an entry in the .rela.plt section.  */
5257
                if (!doneone)
5258
                  {
5259
                    if (!htab->elf.dynamic_sections_created
5260
                        || h->dynindx == -1)
5261
                      htab->reliplt->size += sizeof (Elf32_External_Rela);
5262
                    else
5263
                      {
5264
                        htab->relplt->size += sizeof (Elf32_External_Rela);
5265
 
5266
                        if (htab->plt_type == PLT_VXWORKS)
5267
                          {
5268
                            /* Allocate space for the unloaded relocations.  */
5269
                            if (!info->shared
5270
                                && htab->elf.dynamic_sections_created)
5271
                              {
5272
                                if (ent->plt.offset
5273
                                    == (bfd_vma) htab->plt_initial_entry_size)
5274
                                  {
5275
                                    htab->srelplt2->size
5276
                                      += (sizeof (Elf32_External_Rela)
5277
                                          * VXWORKS_PLTRESOLVE_RELOCS);
5278
                                  }
5279
 
5280
                                htab->srelplt2->size
5281
                                  += (sizeof (Elf32_External_Rela)
5282
                                      * VXWORKS_PLT_NON_JMP_SLOT_RELOCS);
5283
                              }
5284
 
5285
                            /* Every PLT entry has an associated GOT entry in
5286
                               .got.plt.  */
5287
                            htab->sgotplt->size += 4;
5288
                          }
5289
                      }
5290
                    doneone = TRUE;
5291
                  }
5292
              }
5293
            else
5294
              ent->plt.offset = (bfd_vma) -1;
5295
          }
5296
        else
5297
          ent->plt.offset = (bfd_vma) -1;
5298
 
5299
      if (!doneone)
5300
        {
5301
          h->plt.plist = NULL;
5302
          h->needs_plt = 0;
5303
        }
5304
    }
5305
  else
5306
    {
5307
      h->plt.plist = NULL;
5308
      h->needs_plt = 0;
5309
    }
5310
 
5311
  eh = (struct ppc_elf_link_hash_entry *) h;
5312
  if (eh->elf.got.refcount > 0)
5313
    {
5314
      bfd_boolean dyn;
5315
      unsigned int need;
5316
 
5317
      /* Make sure this symbol is output as a dynamic symbol.  */
5318
      if (eh->elf.dynindx == -1
5319
          && !eh->elf.forced_local
5320
          && eh->elf.type != STT_GNU_IFUNC
5321
          && htab->elf.dynamic_sections_created)
5322
        {
5323
          if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf))
5324
            return FALSE;
5325
        }
5326
 
5327
      need = 0;
5328
      if ((eh->tls_mask & TLS_TLS) != 0)
5329
        {
5330
          if ((eh->tls_mask & TLS_LD) != 0)
5331
            {
5332
              if (!eh->elf.def_dynamic)
5333
                /* We'll just use htab->tlsld_got.offset.  This should
5334
                   always be the case.  It's a little odd if we have
5335
                   a local dynamic reloc against a non-local symbol.  */
5336
                htab->tlsld_got.refcount += 1;
5337
              else
5338
                need += 8;
5339
            }
5340
          if ((eh->tls_mask & TLS_GD) != 0)
5341
            need += 8;
5342
          if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
5343
            need += 4;
5344
          if ((eh->tls_mask & TLS_DTPREL) != 0)
5345
            need += 4;
5346
        }
5347
      else
5348
        need += 4;
5349
      if (need == 0)
5350
        eh->elf.got.offset = (bfd_vma) -1;
5351
      else
5352
        {
5353
          eh->elf.got.offset = allocate_got (htab, need);
5354
          dyn = htab->elf.dynamic_sections_created;
5355
          if ((info->shared
5356
               || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf))
5357
              && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT
5358
                  || eh->elf.root.type != bfd_link_hash_undefweak))
5359
            {
5360
              asection *rsec = htab->relgot;
5361
              /* All the entries we allocated need relocs.
5362
                 Except LD only needs one.  */
5363
              if ((eh->tls_mask & TLS_LD) != 0
5364
                  && eh->elf.def_dynamic)
5365
                need -= 4;
5366
              rsec->size += need * (sizeof (Elf32_External_Rela) / 4);
5367
            }
5368
        }
5369
    }
5370
  else
5371
    eh->elf.got.offset = (bfd_vma) -1;
5372
 
5373
  if (eh->dyn_relocs == NULL
5374
      || !htab->elf.dynamic_sections_created)
5375
    return TRUE;
5376
 
5377
  /* In the shared -Bsymbolic case, discard space allocated for
5378
     dynamic pc-relative relocs against symbols which turn out to be
5379
     defined in regular objects.  For the normal shared case, discard
5380
     space for relocs that have become local due to symbol visibility
5381
     changes.  */
5382
 
5383
  if (info->shared)
5384
    {
5385
      /* Relocs that use pc_count are those that appear on a call insn,
5386
         or certain REL relocs (see must_be_dyn_reloc) that can be
5387
         generated via assembly.  We want calls to protected symbols to
5388
         resolve directly to the function rather than going via the plt.
5389
         If people want function pointer comparisons to work as expected
5390
         then they should avoid writing weird assembly.  */
5391
      if (SYMBOL_CALLS_LOCAL (info, h))
5392
        {
5393
          struct ppc_elf_dyn_relocs **pp;
5394
 
5395
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5396
            {
5397
              p->count -= p->pc_count;
5398
              p->pc_count = 0;
5399
              if (p->count == 0)
5400
                *pp = p->next;
5401
              else
5402
                pp = &p->next;
5403
            }
5404
        }
5405
 
5406
      if (htab->is_vxworks)
5407
        {
5408
          struct ppc_elf_dyn_relocs **pp;
5409
 
5410
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5411
            {
5412
              if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
5413
                *pp = p->next;
5414
              else
5415
                pp = &p->next;
5416
            }
5417
        }
5418
 
5419
      /* Discard relocs on undefined symbols that must be local.  */
5420
      if (eh->dyn_relocs != NULL
5421
          && h->root.type == bfd_link_hash_undefined
5422
          && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
5423
              || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
5424
        eh->dyn_relocs = NULL;
5425
 
5426
      /* Also discard relocs on undefined weak syms with non-default
5427
         visibility.  */
5428
      if (eh->dyn_relocs != NULL
5429
          && h->root.type == bfd_link_hash_undefweak)
5430
        {
5431
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5432
            eh->dyn_relocs = NULL;
5433
 
5434
          /* Make sure undefined weak symbols are output as a dynamic
5435
             symbol in PIEs.  */
5436
          else if (h->dynindx == -1
5437
                   && !h->forced_local
5438
                   && !h->def_regular)
5439
            {
5440
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
5441
                return FALSE;
5442
            }
5443
        }
5444
    }
5445
  else if (ELIMINATE_COPY_RELOCS)
5446
    {
5447
      /* For the non-shared case, discard space for relocs against
5448
         symbols which turn out to need copy relocs or are not
5449
         dynamic.  */
5450
 
5451
      if (!h->non_got_ref
5452
          && !h->def_regular)
5453
        {
5454
          /* Make sure this symbol is output as a dynamic symbol.
5455
             Undefined weak syms won't yet be marked as dynamic.  */
5456
          if (h->dynindx == -1
5457
              && !h->forced_local)
5458
            {
5459
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
5460
                return FALSE;
5461
            }
5462
 
5463
          /* If that succeeded, we know we'll be keeping all the
5464
             relocs.  */
5465
          if (h->dynindx != -1)
5466
            goto keep;
5467
        }
5468
 
5469
      eh->dyn_relocs = NULL;
5470
 
5471
    keep: ;
5472
    }
5473
 
5474
  /* Finally, allocate space.  */
5475
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
5476
    {
5477
      asection *sreloc = elf_section_data (p->sec)->sreloc;
5478
      if (!htab->elf.dynamic_sections_created)
5479
        sreloc = htab->reliplt;
5480
      sreloc->size += p->count * sizeof (Elf32_External_Rela);
5481
    }
5482
 
5483
  return TRUE;
5484
}
5485
 
5486
/* Set DF_TEXTREL if we find any dynamic relocs that apply to
5487
   read-only sections.  */
5488
 
5489
static bfd_boolean
5490
maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
5491
{
5492
  if (h->root.type == bfd_link_hash_indirect)
5493
    return TRUE;
5494
 
5495
  if (h->root.type == bfd_link_hash_warning)
5496
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
5497
 
5498
  if (readonly_dynrelocs (h))
5499
    {
5500
      ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
5501
 
5502
      /* Not an error, just cut short the traversal.  */
5503
      return FALSE;
5504
    }
5505
  return TRUE;
5506
}
5507
 
5508
/* Set the sizes of the dynamic sections.  */
5509
 
5510
static bfd_boolean
5511
ppc_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5512
                               struct bfd_link_info *info)
5513
{
5514
  struct ppc_elf_link_hash_table *htab;
5515
  asection *s;
5516
  bfd_boolean relocs;
5517
  bfd *ibfd;
5518
 
5519
#ifdef DEBUG
5520
  fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
5521
#endif
5522
 
5523
  htab = ppc_elf_hash_table (info);
5524
  BFD_ASSERT (htab->elf.dynobj != NULL);
5525
 
5526
  if (elf_hash_table (info)->dynamic_sections_created)
5527
    {
5528
      /* Set the contents of the .interp section to the interpreter.  */
5529
      if (info->executable)
5530
        {
5531
          s = bfd_get_section_by_name (htab->elf.dynobj, ".interp");
5532
          BFD_ASSERT (s != NULL);
5533
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5534
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5535
        }
5536
    }
5537
 
5538
  if (htab->plt_type == PLT_OLD)
5539
    htab->got_header_size = 16;
5540
  else if (htab->plt_type == PLT_NEW)
5541
    htab->got_header_size = 12;
5542
 
5543
  /* Set up .got offsets for local syms, and space for local dynamic
5544
     relocs.  */
5545
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5546
    {
5547
      bfd_signed_vma *local_got;
5548
      bfd_signed_vma *end_local_got;
5549
      struct plt_entry **local_plt;
5550
      struct plt_entry **end_local_plt;
5551
      char *lgot_masks;
5552
      bfd_size_type locsymcount;
5553
      Elf_Internal_Shdr *symtab_hdr;
5554
 
5555
      if (!is_ppc_elf (ibfd))
5556
        continue;
5557
 
5558
      for (s = ibfd->sections; s != NULL; s = s->next)
5559
        {
5560
          struct ppc_elf_dyn_relocs *p;
5561
 
5562
          for (p = ((struct ppc_elf_dyn_relocs *)
5563
                    elf_section_data (s)->local_dynrel);
5564
               p != NULL;
5565
               p = p->next)
5566
            {
5567
              if (!bfd_is_abs_section (p->sec)
5568
                  && bfd_is_abs_section (p->sec->output_section))
5569
                {
5570
                  /* Input section has been discarded, either because
5571
                     it is a copy of a linkonce section or due to
5572
                     linker script /DISCARD/, so we'll be discarding
5573
                     the relocs too.  */
5574
                }
5575
              else if (htab->is_vxworks
5576
                       && strcmp (p->sec->output_section->name,
5577
                                  ".tls_vars") == 0)
5578
                {
5579
                  /* Relocations in vxworks .tls_vars sections are
5580
                     handled specially by the loader.  */
5581
                }
5582
              else if (p->count != 0)
5583
                {
5584
                  asection *sreloc = elf_section_data (p->sec)->sreloc;
5585
                  if (!htab->elf.dynamic_sections_created)
5586
                    sreloc = htab->reliplt;
5587
                  sreloc->size += p->count * sizeof (Elf32_External_Rela);
5588
                  if ((p->sec->output_section->flags
5589
                       & (SEC_READONLY | SEC_ALLOC))
5590
                      == (SEC_READONLY | SEC_ALLOC))
5591
                    info->flags |= DF_TEXTREL;
5592
                }
5593
            }
5594
        }
5595
 
5596
      local_got = elf_local_got_refcounts (ibfd);
5597
      if (!local_got)
5598
        continue;
5599
 
5600
      symtab_hdr = &elf_symtab_hdr (ibfd);
5601
      locsymcount = symtab_hdr->sh_info;
5602
      end_local_got = local_got + locsymcount;
5603
      local_plt = (struct plt_entry **) end_local_got;
5604
      end_local_plt = local_plt + locsymcount;
5605
      lgot_masks = (char *) end_local_plt;
5606
 
5607
      for (; local_got < end_local_got; ++local_got, ++lgot_masks)
5608
        if (*local_got > 0)
5609
          {
5610
            unsigned int need = 0;
5611
            if ((*lgot_masks & TLS_TLS) != 0)
5612
              {
5613
                if ((*lgot_masks & TLS_GD) != 0)
5614
                  need += 8;
5615
                if ((*lgot_masks & TLS_LD) != 0)
5616
                  htab->tlsld_got.refcount += 1;
5617
                if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
5618
                  need += 4;
5619
                if ((*lgot_masks & TLS_DTPREL) != 0)
5620
                  need += 4;
5621
              }
5622
            else
5623
              need += 4;
5624
            if (need == 0)
5625
              *local_got = (bfd_vma) -1;
5626
            else
5627
              {
5628
                *local_got = allocate_got (htab, need);
5629
                if (info->shared)
5630
                  htab->relgot->size += (need
5631
                                         * (sizeof (Elf32_External_Rela) / 4));
5632
              }
5633
          }
5634
        else
5635
          *local_got = (bfd_vma) -1;
5636
 
5637
      if (htab->is_vxworks)
5638
        continue;
5639
 
5640
      /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
5641
      for (; local_plt < end_local_plt; ++local_plt)
5642
        {
5643
          struct plt_entry *ent;
5644
          bfd_boolean doneone = FALSE;
5645
          bfd_vma plt_offset = 0, glink_offset = 0;
5646
 
5647
          for (ent = *local_plt; ent != NULL; ent = ent->next)
5648
            if (ent->plt.refcount > 0)
5649
              {
5650
                s = htab->iplt;
5651
 
5652
                if (!doneone)
5653
                  {
5654
                    plt_offset = s->size;
5655
                    s->size += 4;
5656
                  }
5657
                ent->plt.offset = plt_offset;
5658
 
5659
                s = htab->glink;
5660
                if (!doneone || info->shared)
5661
                  {
5662
                    glink_offset = s->size;
5663
                    s->size += GLINK_ENTRY_SIZE;
5664
                  }
5665
                ent->glink_offset = glink_offset;
5666
 
5667
                if (!doneone)
5668
                  {
5669
                    htab->reliplt->size += sizeof (Elf32_External_Rela);
5670
                    doneone = TRUE;
5671
                  }
5672
              }
5673
            else
5674
              ent->plt.offset = (bfd_vma) -1;
5675
        }
5676
    }
5677
 
5678
  /* Allocate space for global sym dynamic relocs.  */
5679
  elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
5680
 
5681
  if (htab->tlsld_got.refcount > 0)
5682
    {
5683
      htab->tlsld_got.offset = allocate_got (htab, 8);
5684
      if (info->shared)
5685
        htab->relgot->size += sizeof (Elf32_External_Rela);
5686
    }
5687
  else
5688
    htab->tlsld_got.offset = (bfd_vma) -1;
5689
 
5690
  if (htab->got != NULL && htab->plt_type != PLT_VXWORKS)
5691
    {
5692
      unsigned int g_o_t = 32768;
5693
 
5694
      /* If we haven't allocated the header, do so now.  When we get here,
5695
         for old plt/got the got size will be 0 to 32764 (not allocated),
5696
         or 32780 to 65536 (header allocated).  For new plt/got, the
5697
         corresponding ranges are 0 to 32768 and 32780 to 65536.  */
5698
      if (htab->got->size <= 32768)
5699
        {
5700
          g_o_t = htab->got->size;
5701
          if (htab->plt_type == PLT_OLD)
5702
            g_o_t += 4;
5703
          htab->got->size += htab->got_header_size;
5704
        }
5705
 
5706
      htab->elf.hgot->root.u.def.value = g_o_t;
5707
    }
5708
  if (info->shared)
5709
    {
5710
      struct elf_link_hash_entry *sda = htab->sdata[0].sym;
5711
      if (sda != NULL
5712
          && !(sda->root.type == bfd_link_hash_defined
5713
               || sda->root.type == bfd_link_hash_defweak))
5714
        {
5715
          sda->root.type = bfd_link_hash_defined;
5716
          sda->root.u.def.section = htab->elf.hgot->root.u.def.section;
5717
          sda->root.u.def.value = htab->elf.hgot->root.u.def.value;
5718
        }
5719
    }
5720
 
5721
  if (htab->glink != NULL
5722
      && htab->glink->size != 0
5723
      && htab->elf.dynamic_sections_created)
5724
    {
5725
      htab->glink_pltresolve = htab->glink->size;
5726
      /* Space for the branch table.  */
5727
      htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4;
5728
      /* Pad out to align the start of PLTresolve.  */
5729
      htab->glink->size += -htab->glink->size & 15;
5730
      htab->glink->size += GLINK_PLTRESOLVE;
5731
 
5732
      if (htab->emit_stub_syms)
5733
        {
5734
          struct elf_link_hash_entry *sh;
5735
          sh = elf_link_hash_lookup (&htab->elf, "__glink",
5736
                                     TRUE, FALSE, FALSE);
5737
          if (sh == NULL)
5738
            return FALSE;
5739
          if (sh->root.type == bfd_link_hash_new)
5740
            {
5741
              sh->root.type = bfd_link_hash_defined;
5742
              sh->root.u.def.section = htab->glink;
5743
              sh->root.u.def.value = htab->glink_pltresolve;
5744
              sh->ref_regular = 1;
5745
              sh->def_regular = 1;
5746
              sh->ref_regular_nonweak = 1;
5747
              sh->forced_local = 1;
5748
              sh->non_elf = 0;
5749
            }
5750
          sh = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
5751
                                     TRUE, FALSE, FALSE);
5752
          if (sh == NULL)
5753
            return FALSE;
5754
          if (sh->root.type == bfd_link_hash_new)
5755
            {
5756
              sh->root.type = bfd_link_hash_defined;
5757
              sh->root.u.def.section = htab->glink;
5758
              sh->root.u.def.value = htab->glink->size - GLINK_PLTRESOLVE;
5759
              sh->ref_regular = 1;
5760
              sh->def_regular = 1;
5761
              sh->ref_regular_nonweak = 1;
5762
              sh->forced_local = 1;
5763
              sh->non_elf = 0;
5764
            }
5765
        }
5766
    }
5767
 
5768
  /* We've now determined the sizes of the various dynamic sections.
5769
     Allocate memory for them.  */
5770
  relocs = FALSE;
5771
  for (s = htab->elf.dynobj->sections; s != NULL; s = s->next)
5772
    {
5773
      bfd_boolean strip_section = TRUE;
5774
 
5775
      if ((s->flags & SEC_LINKER_CREATED) == 0)
5776
        continue;
5777
 
5778
      if (s == htab->plt
5779
          || s == htab->got)
5780
        {
5781
          /* We'd like to strip these sections if they aren't needed, but if
5782
             we've exported dynamic symbols from them we must leave them.
5783
             It's too late to tell BFD to get rid of the symbols.  */
5784
          if (htab->elf.hplt != NULL)
5785
            strip_section = FALSE;
5786
          /* Strip this section if we don't need it; see the
5787
             comment below.  */
5788
        }
5789
      else if (s == htab->iplt
5790
               || s == htab->glink
5791
               || s == htab->sgotplt
5792
               || s == htab->sbss
5793
               || s == htab->dynbss
5794
               || s == htab->dynsbss
5795
               || s == htab->sdata[0].section
5796
               || s == htab->sdata[1].section)
5797
        {
5798
          /* Strip these too.  */
5799
        }
5800
      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
5801
        {
5802
          if (s->size != 0)
5803
            {
5804
              /* Remember whether there are any relocation sections.  */
5805
              relocs = TRUE;
5806
 
5807
              /* We use the reloc_count field as a counter if we need
5808
                 to copy relocs into the output file.  */
5809
              s->reloc_count = 0;
5810
            }
5811
        }
5812
      else
5813
        {
5814
          /* It's not one of our sections, so don't allocate space.  */
5815
          continue;
5816
        }
5817
 
5818
      if (s->size == 0 && strip_section)
5819
        {
5820
          /* If we don't need this section, strip it from the
5821
             output file.  This is mostly to handle .rela.bss and
5822
             .rela.plt.  We must create both sections in
5823
             create_dynamic_sections, because they must be created
5824
             before the linker maps input sections to output
5825
             sections.  The linker does that before
5826
             adjust_dynamic_symbol is called, and it is that
5827
             function which decides whether anything needs to go
5828
             into these sections.  */
5829
          s->flags |= SEC_EXCLUDE;
5830
          continue;
5831
        }
5832
 
5833
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
5834
        continue;
5835
 
5836
      /* Allocate memory for the section contents.  */
5837
      s->contents = bfd_zalloc (htab->elf.dynobj, s->size);
5838
      if (s->contents == NULL)
5839
        return FALSE;
5840
    }
5841
 
5842
  if (htab->elf.dynamic_sections_created)
5843
    {
5844
      /* Add some entries to the .dynamic section.  We fill in the
5845
         values later, in ppc_elf_finish_dynamic_sections, but we
5846
         must add the entries now so that we get the correct size for
5847
         the .dynamic section.  The DT_DEBUG entry is filled in by the
5848
         dynamic linker and used by the debugger.  */
5849
#define add_dynamic_entry(TAG, VAL) \
5850
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5851
 
5852
      if (info->executable)
5853
        {
5854
          if (!add_dynamic_entry (DT_DEBUG, 0))
5855
            return FALSE;
5856
        }
5857
 
5858
      if (htab->plt != NULL && htab->plt->size != 0)
5859
        {
5860
          if (!add_dynamic_entry (DT_PLTGOT, 0)
5861
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
5862
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5863
              || !add_dynamic_entry (DT_JMPREL, 0))
5864
            return FALSE;
5865
        }
5866
 
5867
      if (htab->glink != NULL && htab->glink->size != 0)
5868
        {
5869
          if (!add_dynamic_entry (DT_PPC_GOT, 0))
5870
            return FALSE;
5871
          if (!htab->no_tls_get_addr_opt
5872
              && htab->tls_get_addr != NULL
5873
              && htab->tls_get_addr->plt.plist != NULL
5874
              && !add_dynamic_entry (DT_PPC_TLSOPT, 0))
5875
            return FALSE;
5876
        }
5877
 
5878
      if (relocs)
5879
        {
5880
          if (!add_dynamic_entry (DT_RELA, 0)
5881
              || !add_dynamic_entry (DT_RELASZ, 0)
5882
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
5883
            return FALSE;
5884
        }
5885
 
5886
      /* If any dynamic relocs apply to a read-only section, then we
5887
         need a DT_TEXTREL entry.  */
5888
      if ((info->flags & DF_TEXTREL) == 0)
5889
        elf_link_hash_traverse (elf_hash_table (info), maybe_set_textrel,
5890
                                info);
5891
 
5892
      if ((info->flags & DF_TEXTREL) != 0)
5893
        {
5894
          if (!add_dynamic_entry (DT_TEXTREL, 0))
5895
            return FALSE;
5896
        }
5897
      if (htab->is_vxworks
5898
          && !elf_vxworks_add_dynamic_entries (output_bfd, info))
5899
        return FALSE;
5900
   }
5901
#undef add_dynamic_entry
5902
 
5903
  return TRUE;
5904
}
5905
 
5906
/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5907
 
5908
static bfd_boolean
5909
ppc_elf_hash_symbol (struct elf_link_hash_entry *h)
5910
{
5911
  if (h->plt.plist != NULL
5912
      && !h->def_regular
5913
      && (!h->pointer_equality_needed
5914
          || !h->ref_regular_nonweak))
5915
    return FALSE;
5916
 
5917
  return _bfd_elf_hash_symbol (h);
5918
}
5919
 
5920
#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
5921
 
5922
/* Relaxation trampolines.  r12 is available for clobbering (r11, is
5923
   used for some functions that are allowed to break the ABI).  */
5924
static const int shared_stub_entry[] =
5925
  {
5926
    0x7c0802a6, /* mflr 0 */
5927
    0x429f0005, /* bcl 20, 31, .Lxxx */
5928
    0x7d8802a6, /* mflr 12 */
5929
    0x3d8c0000, /* addis 12, 12, (xxx-.Lxxx)@ha */
5930
    0x398c0008, /* addi 12, 12, (xxx-.Lxxx)@l */
5931
    0x7c0803a6, /* mtlr 0 */
5932
    0x7d8903a6, /* mtctr 12 */
5933
    0x4e800420, /* bctr */
5934
  };
5935
 
5936
static const int stub_entry[] =
5937
  {
5938
    0x3d800000, /* lis 12,xxx@ha */
5939
    0x398c0000, /* addi 12,12,xxx@l */
5940
    0x7d8903a6, /* mtctr 12 */
5941
    0x4e800420, /* bctr */
5942
  };
5943
 
5944
static bfd_boolean
5945
ppc_elf_relax_section (bfd *abfd,
5946
                       asection *isec,
5947
                       struct bfd_link_info *link_info,
5948
                       bfd_boolean *again)
5949
{
5950
  struct one_fixup
5951
  {
5952
    struct one_fixup *next;
5953
    asection *tsec;
5954
    /* Final link, can use the symbol offset.  For a
5955
       relocatable link we use the symbol's index.  */
5956
    bfd_vma toff;
5957
    bfd_vma trampoff;
5958
  };
5959
 
5960
  Elf_Internal_Shdr *symtab_hdr;
5961
  bfd_byte *contents = NULL;
5962
  Elf_Internal_Sym *isymbuf = NULL;
5963
  Elf_Internal_Rela *internal_relocs = NULL;
5964
  Elf_Internal_Rela *irel, *irelend;
5965
  struct one_fixup *fixups = NULL;
5966
  unsigned changes = 0;
5967
  struct ppc_elf_link_hash_table *htab;
5968
  bfd_size_type trampoff;
5969
  asection *got2;
5970
  bfd_boolean maybe_pasted;
5971
 
5972
  *again = FALSE;
5973
 
5974
  /* Nothing to do if there are no relocations, and no need to do
5975
     anything with non-alloc or non-code sections.  */
5976
  if ((isec->flags & SEC_ALLOC) == 0
5977
      || (isec->flags & SEC_CODE) == 0
5978
      || (isec->flags & SEC_RELOC) == 0
5979
      || isec->reloc_count == 0)
5980
    return TRUE;
5981
 
5982
  /* We cannot represent the required PIC relocs in the output, so don't
5983
     do anything.  The linker doesn't support mixing -shared and -r
5984
     anyway.  */
5985
  if (link_info->relocatable && link_info->shared)
5986
     return TRUE;
5987
 
5988
  trampoff = (isec->size + 3) & (bfd_vma) -4;
5989
  maybe_pasted = (strcmp (isec->output_section->name, ".init") == 0
5990
                  || strcmp (isec->output_section->name, ".fini") == 0);
5991
  /* Space for a branch around any trampolines.  */
5992
  if (maybe_pasted)
5993
    trampoff += 4;
5994
 
5995
  symtab_hdr = &elf_symtab_hdr (abfd);
5996
 
5997
  /* Get a copy of the native relocations.  */
5998
  internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL,
5999
                                               link_info->keep_memory);
6000
  if (internal_relocs == NULL)
6001
    goto error_return;
6002
 
6003
  htab = ppc_elf_hash_table (link_info);
6004
  got2 = bfd_get_section_by_name (abfd, ".got2");
6005
 
6006
  irelend = internal_relocs + isec->reloc_count;
6007
  for (irel = internal_relocs; irel < irelend; irel++)
6008
    {
6009
      unsigned long r_type = ELF32_R_TYPE (irel->r_info);
6010
      bfd_vma toff, roff;
6011
      asection *tsec;
6012
      struct one_fixup *f;
6013
      size_t insn_offset = 0;
6014
      bfd_vma max_branch_offset, val;
6015
      bfd_byte *hit_addr;
6016
      unsigned long t0;
6017
      struct elf_link_hash_entry *h;
6018
      struct plt_entry **plist;
6019
      unsigned char sym_type;
6020
 
6021
      switch (r_type)
6022
        {
6023
        case R_PPC_REL24:
6024
        case R_PPC_LOCAL24PC:
6025
        case R_PPC_PLTREL24:
6026
          max_branch_offset = 1 << 25;
6027
          break;
6028
 
6029
        case R_PPC_REL14:
6030
        case R_PPC_REL14_BRTAKEN:
6031
        case R_PPC_REL14_BRNTAKEN:
6032
          max_branch_offset = 1 << 15;
6033
          break;
6034
 
6035
        default:
6036
          continue;
6037
        }
6038
 
6039
      /* Get the value of the symbol referred to by the reloc.  */
6040
      h = NULL;
6041
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6042
        {
6043
          /* A local symbol.  */
6044
          Elf_Internal_Sym *isym;
6045
 
6046
          /* Read this BFD's local symbols.  */
6047
          if (isymbuf == NULL)
6048
            {
6049
              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6050
              if (isymbuf == NULL)
6051
                isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
6052
                                                symtab_hdr->sh_info, 0,
6053
                                                NULL, NULL, NULL);
6054
              if (isymbuf == 0)
6055
                goto error_return;
6056
            }
6057
          isym = isymbuf + ELF32_R_SYM (irel->r_info);
6058
          if (isym->st_shndx == SHN_UNDEF)
6059
            tsec = bfd_und_section_ptr;
6060
          else if (isym->st_shndx == SHN_ABS)
6061
            tsec = bfd_abs_section_ptr;
6062
          else if (isym->st_shndx == SHN_COMMON)
6063
            tsec = bfd_com_section_ptr;
6064
          else
6065
            tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6066
 
6067
          toff = isym->st_value;
6068
          sym_type = ELF_ST_TYPE (isym->st_info);
6069
        }
6070
      else
6071
        {
6072
          /* Global symbol handling.  */
6073
          unsigned long indx;
6074
 
6075
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6076
          h = elf_sym_hashes (abfd)[indx];
6077
 
6078
          while (h->root.type == bfd_link_hash_indirect
6079
                 || h->root.type == bfd_link_hash_warning)
6080
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
6081
 
6082
          if (h->root.type == bfd_link_hash_defined
6083
              || h->root.type == bfd_link_hash_defweak)
6084
            {
6085
              tsec = h->root.u.def.section;
6086
              toff = h->root.u.def.value;
6087
            }
6088
          else if (h->root.type == bfd_link_hash_undefined
6089
                   || h->root.type == bfd_link_hash_undefweak)
6090
            {
6091
              tsec = bfd_und_section_ptr;
6092
              toff = link_info->relocatable ? indx : 0;
6093
            }
6094
          else
6095
            continue;
6096
 
6097
          sym_type = h->type;
6098
        }
6099
 
6100
      /* The condition here under which we call find_plt_ent must
6101
         match that in relocate_section.  If we call find_plt_ent here
6102
         but not in relocate_section, or vice versa, then the branch
6103
         destination used here may be incorrect.  */
6104
      plist = NULL;
6105
      if (h != NULL)
6106
        {
6107
          /* We know is_branch_reloc (r_type) is true.  */
6108
          if (h->type == STT_GNU_IFUNC
6109
              || r_type == R_PPC_PLTREL24)
6110
            plist = &h->plt.plist;
6111
        }
6112
      else if (sym_type == STT_GNU_IFUNC
6113
               && elf_local_got_offsets (abfd) != NULL)
6114
        {
6115
          bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
6116
          struct plt_entry **local_plt = (struct plt_entry **)
6117
            (local_got_offsets + symtab_hdr->sh_info);
6118
          plist = local_plt + ELF32_R_SYM (irel->r_info);
6119
        }
6120
      if (plist != NULL)
6121
        {
6122
          bfd_vma addend = 0;
6123
          struct plt_entry *ent;
6124
 
6125
          if (r_type == R_PPC_PLTREL24 && link_info->shared)
6126
            addend = irel->r_addend;
6127
          ent = find_plt_ent (plist, got2, addend);
6128
          if (ent != NULL)
6129
            {
6130
              if (htab->plt_type == PLT_NEW
6131
                  || h == NULL
6132
                  || !htab->elf.dynamic_sections_created
6133
                  || h->dynindx == -1)
6134
                {
6135
                  tsec = htab->glink;
6136
                  toff = ent->glink_offset;
6137
                }
6138
              else
6139
                {
6140
                  tsec = htab->plt;
6141
                  toff = ent->plt.offset;
6142
                }
6143
            }
6144
        }
6145
 
6146
      /* If the branch and target are in the same section, you have
6147
         no hope of adding stubs.  We'll error out later should the
6148
         branch overflow.  */
6149
      if (tsec == isec)
6150
        continue;
6151
 
6152
      /* There probably isn't any reason to handle symbols in
6153
         SEC_MERGE sections;  SEC_MERGE doesn't seem a likely
6154
         attribute for a code section, and we are only looking at
6155
         branches.  However, implement it correctly here as a
6156
         reference for other target relax_section functions.  */
6157
      if (0 && tsec->sec_info_type == ELF_INFO_TYPE_MERGE)
6158
        {
6159
          /* At this stage in linking, no SEC_MERGE symbol has been
6160
             adjusted, so all references to such symbols need to be
6161
             passed through _bfd_merged_section_offset.  (Later, in
6162
             relocate_section, all SEC_MERGE symbols *except* for
6163
             section symbols have been adjusted.)
6164
 
6165
             gas may reduce relocations against symbols in SEC_MERGE
6166
             sections to a relocation against the section symbol when
6167
             the original addend was zero.  When the reloc is against
6168
             a section symbol we should include the addend in the
6169
             offset passed to _bfd_merged_section_offset, since the
6170
             location of interest is the original symbol.  On the
6171
             other hand, an access to "sym+addend" where "sym" is not
6172
             a section symbol should not include the addend;  Such an
6173
             access is presumed to be an offset from "sym";  The
6174
             location of interest is just "sym".  */
6175
          if (sym_type == STT_SECTION)
6176
            toff += irel->r_addend;
6177
 
6178
          toff = _bfd_merged_section_offset (abfd, &tsec,
6179
                                             elf_section_data (tsec)->sec_info,
6180
                                             toff);
6181
 
6182
          if (sym_type != STT_SECTION)
6183
            toff += irel->r_addend;
6184
        }
6185
      /* PLTREL24 addends are special.  */
6186
      else if (r_type != R_PPC_PLTREL24)
6187
        toff += irel->r_addend;
6188
 
6189
      /* Attempted -shared link of non-pic code loses.  */
6190
      if (tsec->output_section == NULL)
6191
        continue;
6192
 
6193
      roff = irel->r_offset;
6194
 
6195
      /* If the branch is in range, no need to do anything.  */
6196
      if (tsec != bfd_und_section_ptr
6197
          && (!link_info->relocatable
6198
              /* A relocatable link may have sections moved during
6199
                 final link, so do not presume they remain in range.  */
6200
              || tsec->output_section == isec->output_section))
6201
        {
6202
          bfd_vma symaddr, reladdr;
6203
 
6204
          symaddr = tsec->output_section->vma + tsec->output_offset + toff;
6205
          reladdr = isec->output_section->vma + isec->output_offset + roff;
6206
          if (symaddr - reladdr + max_branch_offset < 2 * max_branch_offset)
6207
            continue;
6208
        }
6209
 
6210
      /* Look for an existing fixup to this address.  */
6211
      for (f = fixups; f ; f = f->next)
6212
        if (f->tsec == tsec && f->toff == toff)
6213
          break;
6214
 
6215
      if (f == NULL)
6216
        {
6217
          size_t size;
6218
          unsigned long stub_rtype;
6219
 
6220
          val = trampoff - roff;
6221
          if (val >= max_branch_offset)
6222
            /* Oh dear, we can't reach a trampoline.  Don't try to add
6223
               one.  We'll report an error later.  */
6224
            continue;
6225
 
6226
          if (link_info->shared)
6227
            {
6228
              size = 4 * ARRAY_SIZE (shared_stub_entry);
6229
              insn_offset = 12;
6230
            }
6231
          else
6232
            {
6233
              size = 4 * ARRAY_SIZE (stub_entry);
6234
              insn_offset = 0;
6235
            }
6236
          stub_rtype = R_PPC_RELAX;
6237
          if (tsec == htab->plt
6238
              || tsec == htab->glink)
6239
            {
6240
              stub_rtype = R_PPC_RELAX_PLT;
6241
              if (r_type == R_PPC_PLTREL24)
6242
                stub_rtype = R_PPC_RELAX_PLTREL24;
6243
            }
6244
 
6245
          /* Hijack the old relocation.  Since we need two
6246
             relocations for this use a "composite" reloc.  */
6247
          irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
6248
                                       stub_rtype);
6249
          irel->r_offset = trampoff + insn_offset;
6250
          if (r_type == R_PPC_PLTREL24
6251
              && stub_rtype != R_PPC_RELAX_PLTREL24)
6252
            irel->r_addend = 0;
6253
 
6254
          /* Record the fixup so we don't do it again this section.  */
6255
          f = bfd_malloc (sizeof (*f));
6256
          f->next = fixups;
6257
          f->tsec = tsec;
6258
          f->toff = toff;
6259
          f->trampoff = trampoff;
6260
          fixups = f;
6261
 
6262
          trampoff += size;
6263
          changes++;
6264
        }
6265
      else
6266
        {
6267
          val = f->trampoff - roff;
6268
          if (val >= max_branch_offset)
6269
            continue;
6270
 
6271
          /* Nop out the reloc, since we're finalizing things here.  */
6272
          irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
6273
        }
6274
 
6275
      /* Get the section contents.  */
6276
      if (contents == NULL)
6277
        {
6278
          /* Get cached copy if it exists.  */
6279
          if (elf_section_data (isec)->this_hdr.contents != NULL)
6280
            contents = elf_section_data (isec)->this_hdr.contents;
6281
          else
6282
            {
6283
              /* Go get them off disk.  */
6284
              if (!bfd_malloc_and_get_section (abfd, isec, &contents))
6285
                goto error_return;
6286
            }
6287
        }
6288
 
6289
      /* Fix up the existing branch to hit the trampoline.  */
6290
      hit_addr = contents + roff;
6291
      switch (r_type)
6292
        {
6293
        case R_PPC_REL24:
6294
        case R_PPC_LOCAL24PC:
6295
        case R_PPC_PLTREL24:
6296
          t0 = bfd_get_32 (abfd, hit_addr);
6297
          t0 &= ~0x3fffffc;
6298
          t0 |= val & 0x3fffffc;
6299
          bfd_put_32 (abfd, t0, hit_addr);
6300
          break;
6301
 
6302
        case R_PPC_REL14:
6303
        case R_PPC_REL14_BRTAKEN:
6304
        case R_PPC_REL14_BRNTAKEN:
6305
          t0 = bfd_get_32 (abfd, hit_addr);
6306
          t0 &= ~0xfffc;
6307
          t0 |= val & 0xfffc;
6308
          bfd_put_32 (abfd, t0, hit_addr);
6309
          break;
6310
        }
6311
    }
6312
 
6313
  /* Write out the trampolines.  */
6314
  if (fixups != NULL)
6315
    {
6316
      const int *stub;
6317
      bfd_byte *dest;
6318
      int i, size;
6319
 
6320
      do
6321
        {
6322
          struct one_fixup *f = fixups;
6323
          fixups = fixups->next;
6324
          free (f);
6325
        }
6326
      while (fixups);
6327
 
6328
      contents = bfd_realloc_or_free (contents, trampoff);
6329
      if (contents == NULL)
6330
        goto error_return;
6331
 
6332
      isec->size = (isec->size + 3) & (bfd_vma) -4;
6333
      dest = contents + isec->size;
6334
      /* Branch around the trampolines.  */
6335
      if (maybe_pasted)
6336
        {
6337
          bfd_vma val = B + trampoff - isec->size;
6338
          bfd_put_32 (abfd, val, dest);
6339
          dest += 4;
6340
        }
6341
      isec->size = trampoff;
6342
 
6343
      if (link_info->shared)
6344
        {
6345
          stub = shared_stub_entry;
6346
          size = ARRAY_SIZE (shared_stub_entry);
6347
        }
6348
      else
6349
        {
6350
          stub = stub_entry;
6351
          size = ARRAY_SIZE (stub_entry);
6352
        }
6353
 
6354
      i = 0;
6355
      while (dest < contents + trampoff)
6356
        {
6357
          bfd_put_32 (abfd, stub[i], dest);
6358
          i++;
6359
          if (i == size)
6360
            i = 0;
6361
          dest += 4;
6362
        }
6363
      BFD_ASSERT (i == 0);
6364
    }
6365
 
6366
  if (isymbuf != NULL
6367
      && symtab_hdr->contents != (unsigned char *) isymbuf)
6368
    {
6369
      if (! link_info->keep_memory)
6370
        free (isymbuf);
6371
      else
6372
        {
6373
          /* Cache the symbols for elf_link_input_bfd.  */
6374
          symtab_hdr->contents = (unsigned char *) isymbuf;
6375
        }
6376
    }
6377
 
6378
  if (contents != NULL
6379
      && elf_section_data (isec)->this_hdr.contents != contents)
6380
    {
6381
      if (!changes && !link_info->keep_memory)
6382
        free (contents);
6383
      else
6384
        {
6385
          /* Cache the section contents for elf_link_input_bfd.  */
6386
          elf_section_data (isec)->this_hdr.contents = contents;
6387
        }
6388
    }
6389
 
6390
  if (changes != 0)
6391
    {
6392
      /* Append sufficient NOP relocs so we can write out relocation
6393
         information for the trampolines.  */
6394
      Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count)
6395
                                                  * sizeof (*new_relocs));
6396
      unsigned ix;
6397
 
6398
      if (!new_relocs)
6399
        goto error_return;
6400
      memcpy (new_relocs, internal_relocs,
6401
              isec->reloc_count * sizeof (*new_relocs));
6402
      for (ix = changes; ix--;)
6403
        {
6404
          irel = new_relocs + ix + isec->reloc_count;
6405
 
6406
          irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
6407
        }
6408
      if (internal_relocs != elf_section_data (isec)->relocs)
6409
        free (internal_relocs);
6410
      elf_section_data (isec)->relocs = new_relocs;
6411
      isec->reloc_count += changes;
6412
      elf_section_data (isec)->rel_hdr.sh_size
6413
        += changes * elf_section_data (isec)->rel_hdr.sh_entsize;
6414
    }
6415
  else if (elf_section_data (isec)->relocs != internal_relocs)
6416
    free (internal_relocs);
6417
 
6418
  *again = changes != 0;
6419
  if (!*again && link_info->relocatable)
6420
    {
6421
      /* Convert the internal relax relocs to external form.  */
6422
      for (irel = internal_relocs; irel < irelend; irel++)
6423
        if (ELF32_R_TYPE (irel->r_info) == R_PPC_RELAX)
6424
          {
6425
            unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
6426
 
6427
            /* Rewrite the reloc and convert one of the trailing nop
6428
               relocs to describe this relocation.  */
6429
            BFD_ASSERT (ELF32_R_TYPE (irelend[-1].r_info) == R_PPC_NONE);
6430
            /* The relocs are at the bottom 2 bytes */
6431
            irel[0].r_offset += 2;
6432
            memmove (irel + 1, irel, (irelend - irel - 1) * sizeof (*irel));
6433
            irel[0].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
6434
            irel[1].r_offset += 4;
6435
            irel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
6436
            irel++;
6437
          }
6438
    }
6439
 
6440
  return TRUE;
6441
 
6442
 error_return:
6443
  if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
6444
    free (isymbuf);
6445
  if (contents != NULL
6446
      && elf_section_data (isec)->this_hdr.contents != contents)
6447
    free (contents);
6448
  if (internal_relocs != NULL
6449
      && elf_section_data (isec)->relocs != internal_relocs)
6450
    free (internal_relocs);
6451
  return FALSE;
6452
}
6453
 
6454
/* What to do when ld finds relocations against symbols defined in
6455
   discarded sections.  */
6456
 
6457
static unsigned int
6458
ppc_elf_action_discarded (asection *sec)
6459
{
6460
  if (strcmp (".fixup", sec->name) == 0)
6461
    return 0;
6462
 
6463
  if (strcmp (".got2", sec->name) == 0)
6464
    return 0;
6465
 
6466
  return _bfd_elf_default_action_discarded (sec);
6467
}
6468
 
6469
/* Fill in the address for a pointer generated in a linker section.  */
6470
 
6471
static bfd_vma
6472
elf_finish_pointer_linker_section (bfd *input_bfd,
6473
                                   elf_linker_section_t *lsect,
6474
                                   struct elf_link_hash_entry *h,
6475
                                   bfd_vma relocation,
6476
                                   const Elf_Internal_Rela *rel)
6477
{
6478
  elf_linker_section_pointers_t *linker_section_ptr;
6479
 
6480
  BFD_ASSERT (lsect != NULL);
6481
 
6482
  if (h != NULL)
6483
    {
6484
      /* Handle global symbol.  */
6485
      struct ppc_elf_link_hash_entry *eh;
6486
 
6487
      eh = (struct ppc_elf_link_hash_entry *) h;
6488
      BFD_ASSERT (eh->elf.def_regular);
6489
      linker_section_ptr = eh->linker_section_pointer;
6490
    }
6491
  else
6492
    {
6493
      /* Handle local symbol.  */
6494
      unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
6495
 
6496
      BFD_ASSERT (is_ppc_elf (input_bfd));
6497
      BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
6498
      linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx];
6499
    }
6500
 
6501
  linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr,
6502
                                                        rel->r_addend,
6503
                                                        lsect);
6504
  BFD_ASSERT (linker_section_ptr != NULL);
6505
 
6506
  /* Offset will always be a multiple of four, so use the bottom bit
6507
     as a "written" flag.  */
6508
  if ((linker_section_ptr->offset & 1) == 0)
6509
    {
6510
      bfd_put_32 (lsect->section->owner,
6511
                  relocation + linker_section_ptr->addend,
6512
                  lsect->section->contents + linker_section_ptr->offset);
6513
      linker_section_ptr->offset += 1;
6514
    }
6515
 
6516
  relocation = (lsect->section->output_section->vma
6517
                + lsect->section->output_offset
6518
                + linker_section_ptr->offset - 1
6519
                - SYM_VAL (lsect->sym));
6520
 
6521
#ifdef DEBUG
6522
  fprintf (stderr,
6523
           "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
6524
           lsect->name, (long) relocation, (long) relocation);
6525
#endif
6526
 
6527
  return relocation;
6528
}
6529
 
6530
#define PPC_LO(v) ((v) & 0xffff)
6531
#define PPC_HI(v) (((v) >> 16) & 0xffff)
6532
#define PPC_HA(v) PPC_HI ((v) + 0x8000)
6533
 
6534
static void
6535
write_glink_stub (struct plt_entry *ent, asection *plt_sec, unsigned char *p,
6536
                  struct bfd_link_info *info)
6537
{
6538
  struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
6539
  bfd *output_bfd = info->output_bfd;
6540
  bfd_vma plt;
6541
 
6542
  plt = ((ent->plt.offset & ~1)
6543
         + plt_sec->output_section->vma
6544
         + plt_sec->output_offset);
6545
 
6546
  if (info->shared)
6547
    {
6548
      bfd_vma got = 0;
6549
 
6550
      if (ent->addend >= 32768)
6551
        got = (ent->addend
6552
               + ent->sec->output_section->vma
6553
               + ent->sec->output_offset);
6554
      else if (htab->elf.hgot != NULL)
6555
        got = SYM_VAL (htab->elf.hgot);
6556
 
6557
      plt -= got;
6558
 
6559
      if (plt + 0x8000 < 0x10000)
6560
        {
6561
          bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p);
6562
          p += 4;
6563
          bfd_put_32 (output_bfd, MTCTR_11, p);
6564
          p += 4;
6565
          bfd_put_32 (output_bfd, BCTR, p);
6566
          p += 4;
6567
          bfd_put_32 (output_bfd, NOP, p);
6568
          p += 4;
6569
        }
6570
      else
6571
        {
6572
          bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p);
6573
          p += 4;
6574
          bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
6575
          p += 4;
6576
          bfd_put_32 (output_bfd, MTCTR_11, p);
6577
          p += 4;
6578
          bfd_put_32 (output_bfd, BCTR, p);
6579
          p += 4;
6580
        }
6581
    }
6582
  else
6583
    {
6584
      bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p);
6585
      p += 4;
6586
      bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
6587
      p += 4;
6588
      bfd_put_32 (output_bfd, MTCTR_11, p);
6589
      p += 4;
6590
      bfd_put_32 (output_bfd, BCTR, p);
6591
      p += 4;
6592
    }
6593
}
6594
 
6595
/* Return true if symbol is defined statically.  */
6596
 
6597
static bfd_boolean
6598
is_static_defined (struct elf_link_hash_entry *h)
6599
{
6600
  return ((h->root.type == bfd_link_hash_defined
6601
           || h->root.type == bfd_link_hash_defweak)
6602
          && h->root.u.def.section != NULL
6603
          && h->root.u.def.section->output_section != NULL);
6604
}
6605
 
6606
/* If INSN is an opcode that may be used with an @tls operand, return
6607
   the transformed insn for TLS optimisation, otherwise return 0.  If
6608
   REG is non-zero only match an insn with RB or RA equal to REG.  */
6609
 
6610
unsigned int
6611
_bfd_elf_ppc_at_tls_transform (unsigned int insn, unsigned int reg)
6612
{
6613
  unsigned int rtra;
6614
 
6615
  if ((insn & (0x3f << 26)) != 31 << 26)
6616
    return 0;
6617
 
6618
  if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
6619
    rtra = insn & ((1 << 26) - (1 << 16));
6620
  else if (((insn >> 16) & 0x1f) == reg)
6621
    rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
6622
  else
6623
    return 0;
6624
 
6625
  if ((insn & (0x3ff << 1)) == 266 << 1)
6626
    /* add -> addi.  */
6627
    insn = 14 << 26;
6628
  else if ((insn & (0x1f << 1)) == 23 << 1
6629
           && ((insn & (0x1f << 6)) < 14 << 6
6630
               || ((insn & (0x1f << 6)) >= 16 << 6
6631
                   && (insn & (0x1f << 6)) < 24 << 6)))
6632
    /* load and store indexed -> dform.  */
6633
    insn = (32 | ((insn >> 6) & 0x1f)) << 26;
6634
  else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
6635
    /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
6636
    insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
6637
  else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
6638
    /* lwax -> lwa.  */
6639
    insn = (58 << 26) | 2;
6640
  else
6641
    return 0;
6642
  insn |= rtra;
6643
  return insn;
6644
}
6645
 
6646
/* If INSN is an opcode that may be used with an @tprel operand, return
6647
   the transformed insn for an undefined weak symbol, ie. with the
6648
   thread pointer REG operand removed.  Otherwise return 0.  */
6649
 
6650
unsigned int
6651
_bfd_elf_ppc_at_tprel_transform (unsigned int insn, unsigned int reg)
6652
{
6653
  if ((insn & (0x1f << 16)) == reg << 16
6654
      && ((insn & (0x3f << 26)) == 14u << 26 /* addi */
6655
          || (insn & (0x3f << 26)) == 15u << 26 /* addis */
6656
          || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
6657
          || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
6658
          || (insn & (0x3f << 26)) == 36u << 26 /* stw */
6659
          || (insn & (0x3f << 26)) == 38u << 26 /* stb */
6660
          || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
6661
          || (insn & (0x3f << 26)) == 42u << 26 /* lha */
6662
          || (insn & (0x3f << 26)) == 44u << 26 /* sth */
6663
          || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
6664
          || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
6665
          || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
6666
          || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
6667
          || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
6668
          || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
6669
          || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
6670
              && (insn & 3) != 1)
6671
          || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
6672
              && ((insn & 3) == 0 || (insn & 3) == 3))))
6673
    {
6674
      insn &= ~(0x1f << 16);
6675
    }
6676
  else if ((insn & (0x1f << 21)) == reg << 21
6677
           && ((insn & (0x3e << 26)) == 24u << 26 /* ori, oris */
6678
               || (insn & (0x3e << 26)) == 26u << 26 /* xori,xoris */
6679
               || (insn & (0x3e << 26)) == 28u << 26 /* andi,andis */))
6680
    {
6681
      insn &= ~(0x1f << 21);
6682
      insn |= (insn & (0x1f << 16)) << 5;
6683
      if ((insn & (0x3e << 26)) == 26 << 26 /* xori,xoris */)
6684
        insn -= 2 >> 26;  /* convert to ori,oris */
6685
    }
6686
  else
6687
    insn = 0;
6688
  return insn;
6689
}
6690
 
6691
/* The RELOCATE_SECTION function is called by the ELF backend linker
6692
   to handle the relocations for a section.
6693
 
6694
   The relocs are always passed as Rela structures; if the section
6695
   actually uses Rel structures, the r_addend field will always be
6696
   zero.
6697
 
6698
   This function is responsible for adjust the section contents as
6699
   necessary, and (if using Rela relocs and generating a
6700
   relocatable output file) adjusting the reloc addend as
6701
   necessary.
6702
 
6703
   This function does not have to worry about setting the reloc
6704
   address or the reloc symbol index.
6705
 
6706
   LOCAL_SYMS is a pointer to the swapped in local symbols.
6707
 
6708
   LOCAL_SECTIONS is an array giving the section in the input file
6709
   corresponding to the st_shndx field of each local symbol.
6710
 
6711
   The global hash table entry for the global symbols can be found
6712
   via elf_sym_hashes (input_bfd).
6713
 
6714
   When generating relocatable output, this function must handle
6715
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
6716
   going to be the section symbol corresponding to the output
6717
   section, which means that the addend must be adjusted
6718
   accordingly.  */
6719
 
6720
static bfd_boolean
6721
ppc_elf_relocate_section (bfd *output_bfd,
6722
                          struct bfd_link_info *info,
6723
                          bfd *input_bfd,
6724
                          asection *input_section,
6725
                          bfd_byte *contents,
6726
                          Elf_Internal_Rela *relocs,
6727
                          Elf_Internal_Sym *local_syms,
6728
                          asection **local_sections)
6729
{
6730
  Elf_Internal_Shdr *symtab_hdr;
6731
  struct elf_link_hash_entry **sym_hashes;
6732
  struct ppc_elf_link_hash_table *htab;
6733
  Elf_Internal_Rela *rel;
6734
  Elf_Internal_Rela *relend;
6735
  Elf_Internal_Rela outrel;
6736
  asection *got2, *sreloc = NULL;
6737
  bfd_vma *local_got_offsets;
6738
  bfd_boolean ret = TRUE;
6739
  bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
6740
  bfd_boolean is_vxworks_tls;
6741
 
6742
#ifdef DEBUG
6743
  _bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, "
6744
                      "%ld relocations%s",
6745
                      input_bfd, input_section,
6746
                      (long) input_section->reloc_count,
6747
                      (info->relocatable) ? " (relocatable)" : "");
6748
#endif
6749
 
6750
  got2 = bfd_get_section_by_name (input_bfd, ".got2");
6751
 
6752
  /* Initialize howto table if not already done.  */
6753
  if (!ppc_elf_howto_table[R_PPC_ADDR32])
6754
    ppc_elf_howto_init ();
6755
 
6756
  htab = ppc_elf_hash_table (info);
6757
  local_got_offsets = elf_local_got_offsets (input_bfd);
6758
  symtab_hdr = &elf_symtab_hdr (input_bfd);
6759
  sym_hashes = elf_sym_hashes (input_bfd);
6760
  /* We have to handle relocations in vxworks .tls_vars sections
6761
     specially, because the dynamic loader is 'weird'.  */
6762
  is_vxworks_tls = (htab->is_vxworks && info->shared
6763
                    && !strcmp (input_section->output_section->name,
6764
                                ".tls_vars"));
6765
  rel = relocs;
6766
  relend = relocs + input_section->reloc_count;
6767
  for (; rel < relend; rel++)
6768
    {
6769
      enum elf_ppc_reloc_type r_type;
6770
      bfd_vma addend;
6771
      bfd_reloc_status_type r;
6772
      Elf_Internal_Sym *sym;
6773
      asection *sec;
6774
      struct elf_link_hash_entry *h;
6775
      const char *sym_name;
6776
      reloc_howto_type *howto;
6777
      unsigned long r_symndx;
6778
      bfd_vma relocation;
6779
      bfd_vma branch_bit, from;
6780
      bfd_boolean unresolved_reloc;
6781
      bfd_boolean warned;
6782
      unsigned int tls_type, tls_mask, tls_gd;
6783
      struct plt_entry **ifunc;
6784
 
6785
      r_type = ELF32_R_TYPE (rel->r_info);
6786
      sym = NULL;
6787
      sec = NULL;
6788
      h = NULL;
6789
      unresolved_reloc = FALSE;
6790
      warned = FALSE;
6791
      r_symndx = ELF32_R_SYM (rel->r_info);
6792
 
6793
      if (r_symndx < symtab_hdr->sh_info)
6794
        {
6795
          sym = local_syms + r_symndx;
6796
          sec = local_sections[r_symndx];
6797
          sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
6798
 
6799
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
6800
        }
6801
      else
6802
        {
6803
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
6804
                                   r_symndx, symtab_hdr, sym_hashes,
6805
                                   h, sec, relocation,
6806
                                   unresolved_reloc, warned);
6807
 
6808
          sym_name = h->root.root.string;
6809
        }
6810
 
6811
      if (sec != NULL && elf_discarded_section (sec))
6812
        {
6813
          /* For relocs against symbols from removed linkonce sections,
6814
             or sections discarded by a linker script, we just want the
6815
             section contents zeroed.  Avoid any special processing.  */
6816
          howto = NULL;
6817
          if (r_type < R_PPC_max)
6818
            howto = ppc_elf_howto_table[r_type];
6819
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
6820
          rel->r_info = 0;
6821
          rel->r_addend = 0;
6822
          continue;
6823
        }
6824
 
6825
      if (info->relocatable)
6826
        {
6827
          if (got2 != NULL
6828
              && r_type == R_PPC_PLTREL24
6829
              && rel->r_addend >= 32768)
6830
            {
6831
              /* R_PPC_PLTREL24 is rather special.  If non-zero, the
6832
                 addend specifies the GOT pointer offset within .got2.  */
6833
              rel->r_addend += got2->output_offset;
6834
            }
6835
          continue;
6836
        }
6837
 
6838
      /* TLS optimizations.  Replace instruction sequences and relocs
6839
         based on information we collected in tls_optimize.  We edit
6840
         RELOCS so that --emit-relocs will output something sensible
6841
         for the final instruction stream.  */
6842
      tls_mask = 0;
6843
      tls_gd = 0;
6844
      if (h != NULL)
6845
        tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
6846
      else if (local_got_offsets != NULL)
6847
        {
6848
          struct plt_entry **local_plt;
6849
          char *lgot_masks;
6850
          local_plt
6851
            = (struct plt_entry **) (local_got_offsets + symtab_hdr->sh_info);
6852
          lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
6853
          tls_mask = lgot_masks[r_symndx];
6854
        }
6855
 
6856
      /* Ensure reloc mapping code below stays sane.  */
6857
      if ((R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TLSGD16 & 3)
6858
          || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
6859
          || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
6860
          || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3)
6861
          || (R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TPREL16 & 3)
6862
          || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3)
6863
          || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3)
6864
          || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3))
6865
        abort ();
6866
      switch (r_type)
6867
        {
6868
        default:
6869
          break;
6870
 
6871
        case R_PPC_GOT_TPREL16:
6872
        case R_PPC_GOT_TPREL16_LO:
6873
          if ((tls_mask & TLS_TLS) != 0
6874
              && (tls_mask & TLS_TPREL) == 0)
6875
            {
6876
              bfd_vma insn;
6877
 
6878
              insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
6879
              insn &= 31 << 21;
6880
              insn |= 0x3c020000;       /* addis 0,2,0 */
6881
              bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
6882
              r_type = R_PPC_TPREL16_HA;
6883
              rel->r_info = ELF32_R_INFO (r_symndx, r_type);
6884
            }
6885
          break;
6886
 
6887
        case R_PPC_TLS:
6888
          if ((tls_mask & TLS_TLS) != 0
6889
              && (tls_mask & TLS_TPREL) == 0)
6890
            {
6891
              bfd_vma insn;
6892
 
6893
              insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
6894
              insn = _bfd_elf_ppc_at_tls_transform (insn, 2);
6895
              if (insn == 0)
6896
                abort ();
6897
              bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
6898
              r_type = R_PPC_TPREL16_LO;
6899
              rel->r_info = ELF32_R_INFO (r_symndx, r_type);
6900
 
6901
              /* Was PPC_TLS which sits on insn boundary, now
6902
                 PPC_TPREL16_LO which is at low-order half-word.  */
6903
              rel->r_offset += d_offset;
6904
            }
6905
          break;
6906
 
6907
        case R_PPC_GOT_TLSGD16_HI:
6908
        case R_PPC_GOT_TLSGD16_HA:
6909
          tls_gd = TLS_TPRELGD;
6910
          if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
6911
            goto tls_gdld_hi;
6912
          break;
6913
 
6914
        case R_PPC_GOT_TLSLD16_HI:
6915
        case R_PPC_GOT_TLSLD16_HA:
6916
          if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
6917
            {
6918
            tls_gdld_hi:
6919
              if ((tls_mask & tls_gd) != 0)
6920
                r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
6921
                          + R_PPC_GOT_TPREL16);
6922
              else
6923
                {
6924
                  bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
6925
                  rel->r_offset -= d_offset;
6926
                  r_type = R_PPC_NONE;
6927
                }
6928
              rel->r_info = ELF32_R_INFO (r_symndx, r_type);
6929
            }
6930
          break;
6931
 
6932
        case R_PPC_GOT_TLSGD16:
6933
        case R_PPC_GOT_TLSGD16_LO:
6934
          tls_gd = TLS_TPRELGD;
6935
          if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
6936
            goto tls_ldgd_opt;
6937
          break;
6938
 
6939
        case R_PPC_GOT_TLSLD16:
6940
        case R_PPC_GOT_TLSLD16_LO:
6941
          if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
6942
            {
6943
              unsigned int insn1, insn2;
6944
              bfd_vma offset;
6945
 
6946
            tls_ldgd_opt:
6947
              offset = (bfd_vma) -1;
6948
              /* If not using the newer R_PPC_TLSGD/LD to mark
6949
                 __tls_get_addr calls, we must trust that the call
6950
                 stays with its arg setup insns, ie. that the next
6951
                 reloc is the __tls_get_addr call associated with
6952
                 the current reloc.  Edit both insns.  */
6953
              if (input_section->has_tls_get_addr_call
6954
                  && rel + 1 < relend
6955
                  && branch_reloc_hash_match (input_bfd, rel + 1,
6956
                                              htab->tls_get_addr))
6957
                offset = rel[1].r_offset;
6958
              if ((tls_mask & tls_gd) != 0)
6959
                {
6960
                  /* IE */
6961
                  insn1 = bfd_get_32 (output_bfd,
6962
                                      contents + rel->r_offset - d_offset);
6963
                  insn1 &= (1 << 26) - 1;
6964
                  insn1 |= 32 << 26;    /* lwz */
6965
                  if (offset != (bfd_vma) -1)
6966
                    {
6967
                      rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
6968
                      insn2 = 0x7c631214;       /* add 3,3,2 */
6969
                      bfd_put_32 (output_bfd, insn2, contents + offset);
6970
                    }
6971
                  r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
6972
                            + R_PPC_GOT_TPREL16);
6973
                  rel->r_info = ELF32_R_INFO (r_symndx, r_type);
6974
                }
6975
              else
6976
                {
6977
                  /* LE */
6978
                  insn1 = 0x3c620000;   /* addis 3,2,0 */
6979
                  if (tls_gd == 0)
6980
                    {
6981
                      /* Was an LD reloc.  */
6982
                      for (r_symndx = 0;
6983
                           r_symndx < symtab_hdr->sh_info;
6984
                           r_symndx++)
6985
                        if (local_sections[r_symndx] == sec)
6986
                          break;
6987
                      if (r_symndx >= symtab_hdr->sh_info)
6988
                        r_symndx = 0;
6989
                      rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
6990
                      if (r_symndx != 0)
6991
                        rel->r_addend -= (local_syms[r_symndx].st_value
6992
                                          + sec->output_offset
6993
                                          + sec->output_section->vma);
6994
                    }
6995
                  r_type = R_PPC_TPREL16_HA;
6996
                  rel->r_info = ELF32_R_INFO (r_symndx, r_type);
6997
                  if (offset != (bfd_vma) -1)
6998
                    {
6999
                      rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7000
                      rel[1].r_offset = offset + d_offset;
7001
                      rel[1].r_addend = rel->r_addend;
7002
                      insn2 = 0x38630000;       /* addi 3,3,0 */
7003
                      bfd_put_32 (output_bfd, insn2, contents + offset);
7004
                    }
7005
                }
7006
              bfd_put_32 (output_bfd, insn1,
7007
                          contents + rel->r_offset - d_offset);
7008
              if (tls_gd == 0)
7009
                {
7010
                  /* We changed the symbol on an LD reloc.  Start over
7011
                     in order to get h, sym, sec etc. right.  */
7012
                  rel--;
7013
                  continue;
7014
                }
7015
            }
7016
          break;
7017
 
7018
        case R_PPC_TLSGD:
7019
          if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
7020
            {
7021
              unsigned int insn2;
7022
              bfd_vma offset = rel->r_offset;
7023
 
7024
              if ((tls_mask & TLS_TPRELGD) != 0)
7025
                {
7026
                  /* IE */
7027
                  r_type = R_PPC_NONE;
7028
                  insn2 = 0x7c631214;   /* add 3,3,2 */
7029
                }
7030
              else
7031
                {
7032
                  /* LE */
7033
                  r_type = R_PPC_TPREL16_LO;
7034
                  rel->r_offset += d_offset;
7035
                  insn2 = 0x38630000;   /* addi 3,3,0 */
7036
                }
7037
              rel->r_info = ELF32_R_INFO (r_symndx, r_type);
7038
              bfd_put_32 (output_bfd, insn2, contents + offset);
7039
              /* Zap the reloc on the _tls_get_addr call too.  */
7040
              BFD_ASSERT (offset == rel[1].r_offset);
7041
              rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7042
            }
7043
          break;
7044
 
7045
        case R_PPC_TLSLD:
7046
          if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
7047
            {
7048
              unsigned int insn2;
7049
 
7050
              for (r_symndx = 0;
7051
                   r_symndx < symtab_hdr->sh_info;
7052
                   r_symndx++)
7053
                if (local_sections[r_symndx] == sec)
7054
                  break;
7055
              if (r_symndx >= symtab_hdr->sh_info)
7056
                r_symndx = 0;
7057
              rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
7058
              if (r_symndx != 0)
7059
                rel->r_addend -= (local_syms[r_symndx].st_value
7060
                                  + sec->output_offset
7061
                                  + sec->output_section->vma);
7062
 
7063
              rel->r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
7064
              rel->r_offset += d_offset;
7065
              insn2 = 0x38630000;       /* addi 3,3,0 */
7066
              bfd_put_32 (output_bfd, insn2,
7067
                          contents + rel->r_offset - d_offset);
7068
              /* Zap the reloc on the _tls_get_addr call too.  */
7069
              BFD_ASSERT (rel->r_offset - d_offset == rel[1].r_offset);
7070
              rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
7071
              rel--;
7072
              continue;
7073
            }
7074
          break;
7075
        }
7076
 
7077
      /* Handle other relocations that tweak non-addend part of insn.  */
7078
      branch_bit = 0;
7079
      switch (r_type)
7080
        {
7081
        default:
7082
          break;
7083
 
7084
          /* Branch taken prediction relocations.  */
7085
        case R_PPC_ADDR14_BRTAKEN:
7086
        case R_PPC_REL14_BRTAKEN:
7087
          branch_bit = BRANCH_PREDICT_BIT;
7088
          /* Fall thru */
7089
 
7090
          /* Branch not taken prediction relocations.  */
7091
        case R_PPC_ADDR14_BRNTAKEN:
7092
        case R_PPC_REL14_BRNTAKEN:
7093
          {
7094
            bfd_vma insn;
7095
 
7096
            insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
7097
            insn &= ~BRANCH_PREDICT_BIT;
7098
            insn |= branch_bit;
7099
 
7100
            from = (rel->r_offset
7101
                    + input_section->output_offset
7102
                    + input_section->output_section->vma);
7103
 
7104
            /* Invert 'y' bit if not the default.  */
7105
            if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
7106
              insn ^= BRANCH_PREDICT_BIT;
7107
 
7108
            bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
7109
            break;
7110
          }
7111
        }
7112
 
7113
      ifunc = NULL;
7114
      if (!htab->is_vxworks)
7115
        {
7116
          struct plt_entry *ent;
7117
 
7118
          if (h != NULL)
7119
            {
7120
              if (h->type == STT_GNU_IFUNC)
7121
                ifunc = &h->plt.plist;
7122
            }
7123
          else if (local_got_offsets != NULL
7124
                   && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
7125
            {
7126
              struct plt_entry **local_plt;
7127
 
7128
              local_plt = (struct plt_entry **) (local_got_offsets
7129
                                                 + symtab_hdr->sh_info);
7130
              ifunc = local_plt + r_symndx;
7131
            }
7132
 
7133
          ent = NULL;
7134
          if (ifunc != NULL
7135
              && (!info->shared
7136
                  || is_branch_reloc (r_type)))
7137
            {
7138
              addend = 0;
7139
              if (r_type == R_PPC_PLTREL24 && info->shared)
7140
                addend = rel->r_addend;
7141
              ent = find_plt_ent (ifunc, got2, addend);
7142
            }
7143
          if (ent != NULL)
7144
            {
7145
              if (h == NULL && (ent->plt.offset & 1) == 0)
7146
                {
7147
                  Elf_Internal_Rela rela;
7148
                  bfd_byte *loc;
7149
 
7150
                  rela.r_offset = (htab->iplt->output_section->vma
7151
                                   + htab->iplt->output_offset
7152
                                   + ent->plt.offset);
7153
                  rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
7154
                  rela.r_addend = relocation;
7155
                  loc = htab->reliplt->contents;
7156
                  loc += (htab->reliplt->reloc_count++
7157
                          * sizeof (Elf32_External_Rela));
7158
                  bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
7159
 
7160
                  ent->plt.offset |= 1;
7161
                }
7162
              if (h == NULL && (ent->glink_offset & 1) == 0)
7163
                {
7164
                  unsigned char *p = ((unsigned char *) htab->glink->contents
7165
                                      + ent->glink_offset);
7166
                  write_glink_stub (ent, htab->iplt, p, info);
7167
                  ent->glink_offset |= 1;
7168
                }
7169
 
7170
              unresolved_reloc = FALSE;
7171
              if (htab->plt_type == PLT_NEW
7172
                  || !htab->elf.dynamic_sections_created
7173
                  || h == NULL)
7174
                relocation = (htab->glink->output_section->vma
7175
                              + htab->glink->output_offset
7176
                              + (ent->glink_offset & ~1));
7177
              else
7178
                relocation = (htab->plt->output_section->vma
7179
                              + htab->plt->output_offset
7180
                              + ent->plt.offset);
7181
            }
7182
        }
7183
 
7184
      addend = rel->r_addend;
7185
      tls_type = 0;
7186
      howto = NULL;
7187
      if (r_type < R_PPC_max)
7188
        howto = ppc_elf_howto_table[r_type];
7189
      switch (r_type)
7190
        {
7191
        default:
7192
          (*_bfd_error_handler)
7193
            (_("%B: unknown relocation type %d for symbol %s"),
7194
             input_bfd, (int) r_type, sym_name);
7195
 
7196
          bfd_set_error (bfd_error_bad_value);
7197
          ret = FALSE;
7198
          continue;
7199
 
7200
        case R_PPC_NONE:
7201
        case R_PPC_TLS:
7202
        case R_PPC_TLSGD:
7203
        case R_PPC_TLSLD:
7204
        case R_PPC_EMB_MRKREF:
7205
        case R_PPC_GNU_VTINHERIT:
7206
        case R_PPC_GNU_VTENTRY:
7207
          continue;
7208
 
7209
          /* GOT16 relocations.  Like an ADDR16 using the symbol's
7210
             address in the GOT as relocation value instead of the
7211
             symbol's value itself.  Also, create a GOT entry for the
7212
             symbol and put the symbol value there.  */
7213
        case R_PPC_GOT_TLSGD16:
7214
        case R_PPC_GOT_TLSGD16_LO:
7215
        case R_PPC_GOT_TLSGD16_HI:
7216
        case R_PPC_GOT_TLSGD16_HA:
7217
          tls_type = TLS_TLS | TLS_GD;
7218
          goto dogot;
7219
 
7220
        case R_PPC_GOT_TLSLD16:
7221
        case R_PPC_GOT_TLSLD16_LO:
7222
        case R_PPC_GOT_TLSLD16_HI:
7223
        case R_PPC_GOT_TLSLD16_HA:
7224
          tls_type = TLS_TLS | TLS_LD;
7225
          goto dogot;
7226
 
7227
        case R_PPC_GOT_TPREL16:
7228
        case R_PPC_GOT_TPREL16_LO:
7229
        case R_PPC_GOT_TPREL16_HI:
7230
        case R_PPC_GOT_TPREL16_HA:
7231
          tls_type = TLS_TLS | TLS_TPREL;
7232
          goto dogot;
7233
 
7234
        case R_PPC_GOT_DTPREL16:
7235
        case R_PPC_GOT_DTPREL16_LO:
7236
        case R_PPC_GOT_DTPREL16_HI:
7237
        case R_PPC_GOT_DTPREL16_HA:
7238
          tls_type = TLS_TLS | TLS_DTPREL;
7239
          goto dogot;
7240
 
7241
        case R_PPC_GOT16:
7242
        case R_PPC_GOT16_LO:
7243
        case R_PPC_GOT16_HI:
7244
        case R_PPC_GOT16_HA:
7245
          tls_mask = 0;
7246
        dogot:
7247
          {
7248
            /* Relocation is to the entry for this symbol in the global
7249
               offset table.  */
7250
            bfd_vma off;
7251
            bfd_vma *offp;
7252
            unsigned long indx;
7253
 
7254
            if (htab->got == NULL)
7255
              abort ();
7256
 
7257
            indx = 0;
7258
            if (tls_type == (TLS_TLS | TLS_LD)
7259
                && (h == NULL
7260
                    || !h->def_dynamic))
7261
              offp = &htab->tlsld_got.offset;
7262
            else if (h != NULL)
7263
              {
7264
                bfd_boolean dyn;
7265
                dyn = htab->elf.dynamic_sections_created;
7266
                if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7267
                    || (info->shared
7268
                        && SYMBOL_REFERENCES_LOCAL (info, h)))
7269
                  /* This is actually a static link, or it is a
7270
                     -Bsymbolic link and the symbol is defined
7271
                     locally, or the symbol was forced to be local
7272
                     because of a version file.  */
7273
                  ;
7274
                else
7275
                  {
7276
                    indx = h->dynindx;
7277
                    unresolved_reloc = FALSE;
7278
                  }
7279
                offp = &h->got.offset;
7280
              }
7281
            else
7282
              {
7283
                if (local_got_offsets == NULL)
7284
                  abort ();
7285
                offp = &local_got_offsets[r_symndx];
7286
              }
7287
 
7288
            /* The offset must always be a multiple of 4.  We use the
7289
               least significant bit to record whether we have already
7290
               processed this entry.  */
7291
            off = *offp;
7292
            if ((off & 1) != 0)
7293
              off &= ~1;
7294
            else
7295
              {
7296
                unsigned int tls_m = (tls_mask
7297
                                      & (TLS_LD | TLS_GD | TLS_DTPREL
7298
                                         | TLS_TPREL | TLS_TPRELGD));
7299
 
7300
                if (offp == &htab->tlsld_got.offset)
7301
                  tls_m = TLS_LD;
7302
                else if (h == NULL
7303
                         || !h->def_dynamic)
7304
                  tls_m &= ~TLS_LD;
7305
 
7306
                /* We might have multiple got entries for this sym.
7307
                   Initialize them all.  */
7308
                do
7309
                  {
7310
                    int tls_ty = 0;
7311
 
7312
                    if ((tls_m & TLS_LD) != 0)
7313
                      {
7314
                        tls_ty = TLS_TLS | TLS_LD;
7315
                        tls_m &= ~TLS_LD;
7316
                      }
7317
                    else if ((tls_m & TLS_GD) != 0)
7318
                      {
7319
                        tls_ty = TLS_TLS | TLS_GD;
7320
                        tls_m &= ~TLS_GD;
7321
                      }
7322
                    else if ((tls_m & TLS_DTPREL) != 0)
7323
                      {
7324
                        tls_ty = TLS_TLS | TLS_DTPREL;
7325
                        tls_m &= ~TLS_DTPREL;
7326
                      }
7327
                    else if ((tls_m & (TLS_TPREL | TLS_TPRELGD)) != 0)
7328
                      {
7329
                        tls_ty = TLS_TLS | TLS_TPREL;
7330
                        tls_m = 0;
7331
                      }
7332
 
7333
                    /* Generate relocs for the dynamic linker.  */
7334
                    if ((info->shared || indx != 0)
7335
                        && (offp == &htab->tlsld_got.offset
7336
                            || h == NULL
7337
                            || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7338
                            || h->root.type != bfd_link_hash_undefweak))
7339
                      {
7340
                        asection *rsec = htab->relgot;
7341
                        bfd_byte * loc;
7342
 
7343
                        outrel.r_offset = (htab->got->output_section->vma
7344
                                           + htab->got->output_offset
7345
                                           + off);
7346
                        outrel.r_addend = 0;
7347
                        if (tls_ty & (TLS_LD | TLS_GD))
7348
                          {
7349
                            outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
7350
                            if (tls_ty == (TLS_TLS | TLS_GD))
7351
                              {
7352
                                loc = rsec->contents;
7353
                                loc += (rsec->reloc_count++
7354
                                        * sizeof (Elf32_External_Rela));
7355
                                bfd_elf32_swap_reloca_out (output_bfd,
7356
                                                           &outrel, loc);
7357
                                outrel.r_offset += 4;
7358
                                outrel.r_info
7359
                                  = ELF32_R_INFO (indx, R_PPC_DTPREL32);
7360
                              }
7361
                          }
7362
                        else if (tls_ty == (TLS_TLS | TLS_DTPREL))
7363
                          outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
7364
                        else if (tls_ty == (TLS_TLS | TLS_TPREL))
7365
                          outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
7366
                        else if (indx != 0)
7367
                          outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
7368
                        else if (ifunc != NULL)
7369
                          outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
7370
                        else
7371
                          outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
7372
                        if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD))
7373
                          {
7374
                            outrel.r_addend += relocation;
7375
                            if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
7376
                              outrel.r_addend -= htab->elf.tls_sec->vma;
7377
                          }
7378
                        loc = rsec->contents;
7379
                        loc += (rsec->reloc_count++
7380
                                * sizeof (Elf32_External_Rela));
7381
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
7382
                      }
7383
 
7384
                    /* Init the .got section contents if we're not
7385
                       emitting a reloc.  */
7386
                    else
7387
                      {
7388
                        bfd_vma value = relocation;
7389
 
7390
                        if (tls_ty == (TLS_TLS | TLS_LD))
7391
                          value = 1;
7392
                        else if (tls_ty != 0)
7393
                          {
7394
                            value -= htab->elf.tls_sec->vma + DTP_OFFSET;
7395
                            if (tls_ty == (TLS_TLS | TLS_TPREL))
7396
                              value += DTP_OFFSET - TP_OFFSET;
7397
 
7398
                            if (tls_ty == (TLS_TLS | TLS_GD))
7399
                              {
7400
                                bfd_put_32 (output_bfd, value,
7401
                                            htab->got->contents + off + 4);
7402
                                value = 1;
7403
                              }
7404
                          }
7405
                        bfd_put_32 (output_bfd, value,
7406
                                    htab->got->contents + off);
7407
                      }
7408
 
7409
                    off += 4;
7410
                    if (tls_ty & (TLS_LD | TLS_GD))
7411
                      off += 4;
7412
                  }
7413
                while (tls_m != 0);
7414
 
7415
                off = *offp;
7416
                *offp = off | 1;
7417
              }
7418
 
7419
            if (off >= (bfd_vma) -2)
7420
              abort ();
7421
 
7422
            if ((tls_type & TLS_TLS) != 0)
7423
              {
7424
                if (tls_type != (TLS_TLS | TLS_LD))
7425
                  {
7426
                    if ((tls_mask & TLS_LD) != 0
7427
                        && !(h == NULL
7428
                             || !h->def_dynamic))
7429
                      off += 8;
7430
                    if (tls_type != (TLS_TLS | TLS_GD))
7431
                      {
7432
                        if ((tls_mask & TLS_GD) != 0)
7433
                          off += 8;
7434
                        if (tls_type != (TLS_TLS | TLS_DTPREL))
7435
                          {
7436
                            if ((tls_mask & TLS_DTPREL) != 0)
7437
                              off += 4;
7438
                          }
7439
                      }
7440
                  }
7441
              }
7442
 
7443
            relocation = (htab->got->output_section->vma
7444
                          + htab->got->output_offset
7445
                          + off
7446
                          - SYM_VAL (htab->elf.hgot));
7447
 
7448
            /* Addends on got relocations don't make much sense.
7449
               x+off@got is actually x@got+off, and since the got is
7450
               generated by a hash table traversal, the value in the
7451
               got at entry m+n bears little relation to the entry m.  */
7452
            if (addend != 0)
7453
              (*_bfd_error_handler)
7454
                (_("%B(%A+0x%lx): non-zero addend on %s reloc against `%s'"),
7455
                 input_bfd,
7456
                 input_section,
7457
                 (long) rel->r_offset,
7458
                 howto->name,
7459
                 sym_name);
7460
          }
7461
        break;
7462
 
7463
        /* Relocations that need no special processing.  */
7464
        case R_PPC_LOCAL24PC:
7465
          /* It makes no sense to point a local relocation
7466
             at a symbol not in this object.  */
7467
          if (unresolved_reloc)
7468
            {
7469
              if (! (*info->callbacks->undefined_symbol) (info,
7470
                                                          h->root.root.string,
7471
                                                          input_bfd,
7472
                                                          input_section,
7473
                                                          rel->r_offset,
7474
                                                          TRUE))
7475
                return FALSE;
7476
              continue;
7477
            }
7478
          break;
7479
 
7480
        case R_PPC_DTPREL16:
7481
        case R_PPC_DTPREL16_LO:
7482
        case R_PPC_DTPREL16_HI:
7483
        case R_PPC_DTPREL16_HA:
7484
          addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
7485
          break;
7486
 
7487
          /* Relocations that may need to be propagated if this is a shared
7488
             object.  */
7489
        case R_PPC_TPREL16:
7490
        case R_PPC_TPREL16_LO:
7491
        case R_PPC_TPREL16_HI:
7492
        case R_PPC_TPREL16_HA:
7493
          if (h != NULL
7494
              && h->root.type == bfd_link_hash_undefweak
7495
              && h->dynindx == -1)
7496
            {
7497
              /* Make this relocation against an undefined weak symbol
7498
                 resolve to zero.  This is really just a tweak, since
7499
                 code using weak externs ought to check that they are
7500
                 defined before using them.  */
7501
              bfd_byte *p = contents + rel->r_offset - d_offset;
7502
              unsigned int insn = bfd_get_32 (output_bfd, p);
7503
              insn = _bfd_elf_ppc_at_tprel_transform (insn, 2);
7504
              if (insn != 0)
7505
                bfd_put_32 (output_bfd, insn, p);
7506
              break;
7507
            }
7508
          addend -= htab->elf.tls_sec->vma + TP_OFFSET;
7509
          /* The TPREL16 relocs shouldn't really be used in shared
7510
             libs as they will result in DT_TEXTREL being set, but
7511
             support them anyway.  */
7512
          goto dodyn;
7513
 
7514
        case R_PPC_TPREL32:
7515
          addend -= htab->elf.tls_sec->vma + TP_OFFSET;
7516
          goto dodyn;
7517
 
7518
        case R_PPC_DTPREL32:
7519
          addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
7520
          goto dodyn;
7521
 
7522
        case R_PPC_DTPMOD32:
7523
          relocation = 1;
7524
          addend = 0;
7525
          goto dodyn;
7526
 
7527
        case R_PPC_REL16:
7528
        case R_PPC_REL16_LO:
7529
        case R_PPC_REL16_HI:
7530
        case R_PPC_REL16_HA:
7531
          break;
7532
 
7533
        case R_PPC_REL32:
7534
          if (h == NULL || h == htab->elf.hgot)
7535
            break;
7536
          /* fall through */
7537
 
7538
        case R_PPC_ADDR32:
7539
        case R_PPC_ADDR16:
7540
        case R_PPC_ADDR16_LO:
7541
        case R_PPC_ADDR16_HI:
7542
        case R_PPC_ADDR16_HA:
7543
        case R_PPC_UADDR32:
7544
        case R_PPC_UADDR16:
7545
          goto dodyn;
7546
 
7547
        case R_PPC_REL24:
7548
        case R_PPC_REL14:
7549
        case R_PPC_REL14_BRTAKEN:
7550
        case R_PPC_REL14_BRNTAKEN:
7551
          /* If these relocations are not to a named symbol, they can be
7552
             handled right here, no need to bother the dynamic linker.  */
7553
          if (SYMBOL_CALLS_LOCAL (info, h)
7554
              || h == htab->elf.hgot)
7555
            break;
7556
          /* fall through */
7557
 
7558
        case R_PPC_ADDR24:
7559
        case R_PPC_ADDR14:
7560
        case R_PPC_ADDR14_BRTAKEN:
7561
        case R_PPC_ADDR14_BRNTAKEN:
7562
          if (h != NULL && !info->shared)
7563
            break;
7564
          /* fall through */
7565
 
7566
        dodyn:
7567
          if ((input_section->flags & SEC_ALLOC) == 0
7568
              || is_vxworks_tls)
7569
            break;
7570
 
7571
          if ((info->shared
7572
               && !(h != NULL
7573
                    && ((h->root.type == bfd_link_hash_undefined
7574
                         && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
7575
                             || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
7576
                        || (h->root.type == bfd_link_hash_undefweak
7577
                            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)))
7578
               && (must_be_dyn_reloc (info, r_type)
7579
                   || !SYMBOL_CALLS_LOCAL (info, h)))
7580
              || (ELIMINATE_COPY_RELOCS
7581
                  && !info->shared
7582
                  && h != NULL
7583
                  && h->dynindx != -1
7584
                  && !h->non_got_ref
7585
                  && !h->def_regular))
7586
            {
7587
              int skip;
7588
              bfd_byte * loc;
7589
#ifdef DEBUG
7590
              fprintf (stderr, "ppc_elf_relocate_section needs to "
7591
                       "create relocation for %s\n",
7592
                       (h && h->root.root.string
7593
                        ? h->root.root.string : "<unknown>"));
7594
#endif
7595
 
7596
              /* When generating a shared object, these relocations
7597
                 are copied into the output file to be resolved at run
7598
                 time.  */
7599
              if (sreloc == NULL)
7600
                {
7601
                  sreloc = elf_section_data (input_section)->sreloc;
7602
                  if (!htab->elf.dynamic_sections_created)
7603
                    sreloc = htab->reliplt;
7604
                  if (sreloc == NULL)
7605
                    return FALSE;
7606
                }
7607
 
7608
              skip = 0;
7609
              outrel.r_offset = _bfd_elf_section_offset (output_bfd, info,
7610
                                                         input_section,
7611
                                                         rel->r_offset);
7612
              if (outrel.r_offset == (bfd_vma) -1
7613
                  || outrel.r_offset == (bfd_vma) -2)
7614
                skip = (int) outrel.r_offset;
7615
              outrel.r_offset += (input_section->output_section->vma
7616
                                  + input_section->output_offset);
7617
 
7618
              if (skip)
7619
                memset (&outrel, 0, sizeof outrel);
7620
              else if ((h != NULL
7621
                        && (h->root.type == bfd_link_hash_undefined
7622
                            || h->root.type == bfd_link_hash_undefweak))
7623
                       || !SYMBOL_REFERENCES_LOCAL (info, h))
7624
                {
7625
                  unresolved_reloc = FALSE;
7626
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
7627
                  outrel.r_addend = rel->r_addend;
7628
                }
7629
              else
7630
                {
7631
                  outrel.r_addend = relocation + rel->r_addend;
7632
 
7633
                  if (r_type != R_PPC_ADDR32)
7634
                    {
7635
                      long indx = 0;
7636
 
7637
                      if (ifunc != NULL)
7638
                        {
7639
                          /* If we get here when building a static
7640
                             executable, then the libc startup function
7641
                             responsible for applying indirect function
7642
                             relocations is going to complain about
7643
                             the reloc type.
7644
                             If we get here when building a dynamic
7645
                             executable, it will be because we have
7646
                             a text relocation.  The dynamic loader
7647
                             will set the text segment writable and
7648
                             non-executable to apply text relocations.
7649
                             So we'll segfault when trying to run the
7650
                             indirection function to resolve the reloc.  */
7651
                          (*_bfd_error_handler)
7652
                            (_("%B(%A+0x%lx): relocation %s for indirect "
7653
                               "function %s unsupported"),
7654
                             input_bfd,
7655
                             input_section,
7656
                             (long) rel->r_offset,
7657
                             howto->name,
7658
                             sym_name);
7659
                          ret = FALSE;
7660
                        }
7661
                      else if (r_symndx == 0 || bfd_is_abs_section (sec))
7662
                        ;
7663
                      else if (sec == NULL || sec->owner == NULL)
7664
                        {
7665
                          bfd_set_error (bfd_error_bad_value);
7666
                          ret = FALSE;
7667
                        }
7668
                      else
7669
                        {
7670
                          asection *osec;
7671
 
7672
                          /* We are turning this relocation into one
7673
                             against a section symbol.  It would be
7674
                             proper to subtract the symbol's value,
7675
                             osec->vma, from the emitted reloc addend,
7676
                             but ld.so expects buggy relocs.
7677
                             FIXME: Why not always use a zero index?  */
7678
                          osec = sec->output_section;
7679
                          indx = elf_section_data (osec)->dynindx;
7680
                          if (indx == 0)
7681
                            {
7682
                              osec = htab->elf.text_index_section;
7683
                              indx = elf_section_data (osec)->dynindx;
7684
                            }
7685
                          BFD_ASSERT (indx != 0);
7686
#ifdef DEBUG
7687
                          if (indx == 0)
7688
                            printf ("indx=%ld section=%s flags=%08x name=%s\n",
7689
                                    indx, osec->name, osec->flags,
7690
                                    h->root.root.string);
7691
#endif
7692
                        }
7693
 
7694
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
7695
                    }
7696
                  else if (ifunc != NULL)
7697
                    outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
7698
                  else
7699
                    outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
7700
                }
7701
 
7702
              loc = sreloc->contents;
7703
              loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
7704
              bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
7705
 
7706
              if (skip == -1)
7707
                continue;
7708
 
7709
              /* This reloc will be computed at runtime.  We clear the memory
7710
                 so that it contains predictable value.  */
7711
              if (! skip
7712
                  && ((input_section->flags & SEC_ALLOC) != 0
7713
                      || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE))
7714
                {
7715
                  relocation = howto->pc_relative ? outrel.r_offset : 0;
7716
                  addend = 0;
7717
                  break;
7718
                }
7719
            }
7720
          break;
7721
 
7722
        case R_PPC_RELAX_PLT:
7723
        case R_PPC_RELAX_PLTREL24:
7724
          if (h != NULL)
7725
            {
7726
              struct plt_entry *ent;
7727
              bfd_vma got2_addend = 0;
7728
 
7729
              if (r_type == R_PPC_RELAX_PLTREL24)
7730
                {
7731
                  if (info->shared)
7732
                    got2_addend = addend;
7733
                  addend = 0;
7734
                }
7735
              ent = find_plt_ent (&h->plt.plist, got2, got2_addend);
7736
              if (htab->plt_type == PLT_NEW)
7737
                relocation = (htab->glink->output_section->vma
7738
                              + htab->glink->output_offset
7739
                              + ent->glink_offset);
7740
              else
7741
                relocation = (htab->plt->output_section->vma
7742
                              + htab->plt->output_offset
7743
                              + ent->plt.offset);
7744
            }
7745
          /* Fall thru */
7746
 
7747
        case R_PPC_RELAX:
7748
          if (info->shared)
7749
            relocation -= (input_section->output_section->vma
7750
                           + input_section->output_offset
7751
                           + rel->r_offset - 4);
7752
 
7753
          {
7754
            unsigned long t0;
7755
            unsigned long t1;
7756
 
7757
            t0 = bfd_get_32 (output_bfd, contents + rel->r_offset);
7758
            t1 = bfd_get_32 (output_bfd, contents + rel->r_offset + 4);
7759
 
7760
            /* We're clearing the bits for R_PPC_ADDR16_HA
7761
               and R_PPC_ADDR16_LO here.  */
7762
            t0 &= ~0xffff;
7763
            t1 &= ~0xffff;
7764
 
7765
            /* t0 is HA, t1 is LO */
7766
            relocation += addend;
7767
            t0 |= ((relocation + 0x8000) >> 16) & 0xffff;
7768
            t1 |= relocation & 0xffff;
7769
 
7770
            bfd_put_32 (output_bfd, t0, contents + rel->r_offset);
7771
            bfd_put_32 (output_bfd, t1, contents + rel->r_offset + 4);
7772
 
7773
            /* Rewrite the reloc and convert one of the trailing nop
7774
               relocs to describe this relocation.  */
7775
            BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE);
7776
            /* The relocs are at the bottom 2 bytes */
7777
            rel[0].r_offset += 2;
7778
            memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel));
7779
            rel[0].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
7780
            rel[1].r_offset += 4;
7781
            rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
7782
            rel++;
7783
          }
7784
          continue;
7785
 
7786
          /* Indirect .sdata relocation.  */
7787
        case R_PPC_EMB_SDAI16:
7788
          BFD_ASSERT (htab->sdata[0].section != NULL);
7789
          if (!is_static_defined (htab->sdata[0].sym))
7790
            {
7791
              unresolved_reloc = TRUE;
7792
              break;
7793
            }
7794
          relocation
7795
            = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0],
7796
                                                 h, relocation, rel);
7797
          addend = 0;
7798
          break;
7799
 
7800
          /* Indirect .sdata2 relocation.  */
7801
        case R_PPC_EMB_SDA2I16:
7802
          BFD_ASSERT (htab->sdata[1].section != NULL);
7803
          if (!is_static_defined (htab->sdata[1].sym))
7804
            {
7805
              unresolved_reloc = TRUE;
7806
              break;
7807
            }
7808
          relocation
7809
            = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1],
7810
                                                 h, relocation, rel);
7811
          addend = 0;
7812
          break;
7813
 
7814
          /* Handle the TOC16 reloc.  We want to use the offset within the .got
7815
             section, not the actual VMA.  This is appropriate when generating
7816
             an embedded ELF object, for which the .got section acts like the
7817
             AIX .toc section.  */
7818
        case R_PPC_TOC16:                       /* phony GOT16 relocations */
7819
          if (sec == NULL || sec->output_section == NULL)
7820
            {
7821
              unresolved_reloc = TRUE;
7822
              break;
7823
            }
7824
          BFD_ASSERT (strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
7825
                      || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0);
7826
 
7827
          addend -= sec->output_section->vma + sec->output_offset + 0x8000;
7828
          break;
7829
 
7830
        case R_PPC_PLTREL24:
7831
          if (h == NULL || ifunc != NULL)
7832
            break;
7833
          /* Relocation is to the entry for this symbol in the
7834
             procedure linkage table.  */
7835
          {
7836
            struct plt_entry *ent = find_plt_ent (&h->plt.plist, got2,
7837
                                                  info->shared ? addend : 0);
7838
            addend = 0;
7839
            if (ent == NULL
7840
                || htab->plt == NULL)
7841
              {
7842
                /* We didn't make a PLT entry for this symbol.  This
7843
                   happens when statically linking PIC code, or when
7844
                   using -Bsymbolic.  */
7845
                break;
7846
              }
7847
 
7848
            unresolved_reloc = FALSE;
7849
            if (htab->plt_type == PLT_NEW)
7850
              relocation = (htab->glink->output_section->vma
7851
                            + htab->glink->output_offset
7852
                            + ent->glink_offset);
7853
            else
7854
              relocation = (htab->plt->output_section->vma
7855
                            + htab->plt->output_offset
7856
                            + ent->plt.offset);
7857
          }
7858
          break;
7859
 
7860
          /* Relocate against _SDA_BASE_.  */
7861
        case R_PPC_SDAREL16:
7862
          {
7863
            const char *name;
7864
            struct elf_link_hash_entry *sda = htab->sdata[0].sym;
7865
 
7866
            if (sec == NULL
7867
                || sec->output_section == NULL
7868
                || !is_static_defined (sda))
7869
              {
7870
                unresolved_reloc = TRUE;
7871
                break;
7872
              }
7873
            addend -= SYM_VAL (sda);
7874
 
7875
            name = bfd_get_section_name (abfd, sec->output_section);
7876
            if (! ((CONST_STRNEQ (name, ".sdata")
7877
                    && (name[6] == 0 || name[6] == '.'))
7878
                   || (CONST_STRNEQ (name, ".sbss")
7879
                       && (name[5] == 0 || name[5] == '.'))))
7880
              {
7881
                (*_bfd_error_handler)
7882
                  (_("%B: the target (%s) of a %s relocation is "
7883
                     "in the wrong output section (%s)"),
7884
                   input_bfd,
7885
                   sym_name,
7886
                   howto->name,
7887
                   name);
7888
              }
7889
          }
7890
          break;
7891
 
7892
          /* Relocate against _SDA2_BASE_.  */
7893
        case R_PPC_EMB_SDA2REL:
7894
          {
7895
            const char *name;
7896
            struct elf_link_hash_entry *sda = htab->sdata[1].sym;
7897
 
7898
            if (sec == NULL
7899
                || sec->output_section == NULL
7900
                || !is_static_defined (sda))
7901
              {
7902
                unresolved_reloc = TRUE;
7903
                break;
7904
              }
7905
            addend -= SYM_VAL (sda);
7906
 
7907
            name = bfd_get_section_name (abfd, sec->output_section);
7908
            if (! (CONST_STRNEQ (name, ".sdata2")
7909
                   || CONST_STRNEQ (name, ".sbss2")))
7910
              {
7911
                (*_bfd_error_handler)
7912
                  (_("%B: the target (%s) of a %s relocation is "
7913
                     "in the wrong output section (%s)"),
7914
                   input_bfd,
7915
                   sym_name,
7916
                   howto->name,
7917
                   name);
7918
              }
7919
          }
7920
          break;
7921
 
7922
          /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0.  */
7923
        case R_PPC_EMB_SDA21:
7924
        case R_PPC_EMB_RELSDA:
7925
          {
7926
            const char *name;
7927
            int reg;
7928
            struct elf_link_hash_entry *sda = NULL;
7929
 
7930
            if (sec == NULL || sec->output_section == NULL)
7931
              {
7932
                unresolved_reloc = TRUE;
7933
                break;
7934
              }
7935
 
7936
            name = bfd_get_section_name (abfd, sec->output_section);
7937
            if (((CONST_STRNEQ (name, ".sdata")
7938
                  && (name[6] == 0 || name[6] == '.'))
7939
                 || (CONST_STRNEQ (name, ".sbss")
7940
                     && (name[5] == 0 || name[5] == '.'))))
7941
              {
7942
                reg = 13;
7943
                sda = htab->sdata[0].sym;
7944
              }
7945
            else if (CONST_STRNEQ (name, ".sdata2")
7946
                     || CONST_STRNEQ (name, ".sbss2"))
7947
              {
7948
                reg = 2;
7949
                sda = htab->sdata[1].sym;
7950
              }
7951
            else if (strcmp (name, ".PPC.EMB.sdata0") == 0
7952
                     || strcmp (name, ".PPC.EMB.sbss0") == 0)
7953
              {
7954
                reg = 0;
7955
              }
7956
            else
7957
              {
7958
                (*_bfd_error_handler)
7959
                  (_("%B: the target (%s) of a %s relocation is "
7960
                     "in the wrong output section (%s)"),
7961
                   input_bfd,
7962
                   sym_name,
7963
                   howto->name,
7964
                   name);
7965
 
7966
                bfd_set_error (bfd_error_bad_value);
7967
                ret = FALSE;
7968
                continue;
7969
              }
7970
 
7971
            if (sda != NULL)
7972
              {
7973
                if (!is_static_defined (sda))
7974
                  {
7975
                    unresolved_reloc = TRUE;
7976
                    break;
7977
                  }
7978
                addend -= SYM_VAL (sda);
7979
              }
7980
 
7981
            if (r_type == R_PPC_EMB_SDA21)
7982
              {
7983
                bfd_vma insn;  /* Fill in register field.  */
7984
 
7985
                insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
7986
                insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
7987
                bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
7988
              }
7989
          }
7990
          break;
7991
 
7992
          /* Relocate against the beginning of the section.  */
7993
        case R_PPC_SECTOFF:
7994
        case R_PPC_SECTOFF_LO:
7995
        case R_PPC_SECTOFF_HI:
7996
        case R_PPC_SECTOFF_HA:
7997
          if (sec == NULL || sec->output_section == NULL)
7998
            {
7999
              unresolved_reloc = TRUE;
8000
              break;
8001
            }
8002
          addend -= sec->output_section->vma;
8003
          break;
8004
 
8005
          /* Negative relocations.  */
8006
        case R_PPC_EMB_NADDR32:
8007
        case R_PPC_EMB_NADDR16:
8008
        case R_PPC_EMB_NADDR16_LO:
8009
        case R_PPC_EMB_NADDR16_HI:
8010
        case R_PPC_EMB_NADDR16_HA:
8011
          addend -= 2 * relocation;
8012
          break;
8013
 
8014
        case R_PPC_COPY:
8015
        case R_PPC_GLOB_DAT:
8016
        case R_PPC_JMP_SLOT:
8017
        case R_PPC_RELATIVE:
8018
        case R_PPC_IRELATIVE:
8019
        case R_PPC_PLT32:
8020
        case R_PPC_PLTREL32:
8021
        case R_PPC_PLT16_LO:
8022
        case R_PPC_PLT16_HI:
8023
        case R_PPC_PLT16_HA:
8024
        case R_PPC_ADDR30:
8025
        case R_PPC_EMB_RELSEC16:
8026
        case R_PPC_EMB_RELST_LO:
8027
        case R_PPC_EMB_RELST_HI:
8028
        case R_PPC_EMB_RELST_HA:
8029
        case R_PPC_EMB_BIT_FLD:
8030
          (*_bfd_error_handler)
8031
            (_("%B: relocation %s is not yet supported for symbol %s."),
8032
             input_bfd,
8033
             howto->name,
8034
             sym_name);
8035
 
8036
          bfd_set_error (bfd_error_invalid_operation);
8037
          ret = FALSE;
8038
          continue;
8039
        }
8040
 
8041
      /* Do any further special processing.  */
8042
      switch (r_type)
8043
        {
8044
        default:
8045
          break;
8046
 
8047
        case R_PPC_ADDR16_HA:
8048
        case R_PPC_REL16_HA:
8049
        case R_PPC_SECTOFF_HA:
8050
        case R_PPC_TPREL16_HA:
8051
        case R_PPC_DTPREL16_HA:
8052
        case R_PPC_EMB_NADDR16_HA:
8053
        case R_PPC_EMB_RELST_HA:
8054
          /* It's just possible that this symbol is a weak symbol
8055
             that's not actually defined anywhere.  In that case,
8056
             'sec' would be NULL, and we should leave the symbol
8057
             alone (it will be set to zero elsewhere in the link).  */
8058
          if (sec == NULL)
8059
            break;
8060
          /* Fall thru */
8061
 
8062
        case R_PPC_PLT16_HA:
8063
        case R_PPC_GOT16_HA:
8064
        case R_PPC_GOT_TLSGD16_HA:
8065
        case R_PPC_GOT_TLSLD16_HA:
8066
        case R_PPC_GOT_TPREL16_HA:
8067
        case R_PPC_GOT_DTPREL16_HA:
8068
          /* Add 0x10000 if sign bit in 0:15 is set.
8069
             Bits 0:15 are not used.  */
8070
          addend += 0x8000;
8071
          break;
8072
        }
8073
 
8074
#ifdef DEBUG
8075
      fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, "
8076
               "offset = %ld, addend = %ld\n",
8077
               howto->name,
8078
               (int) r_type,
8079
               sym_name,
8080
               r_symndx,
8081
               (long) rel->r_offset,
8082
               (long) addend);
8083
#endif
8084
 
8085
      if (unresolved_reloc
8086
          && !((input_section->flags & SEC_DEBUGGING) != 0
8087
               && h->def_dynamic))
8088
        {
8089
          (*_bfd_error_handler)
8090
            (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
8091
             input_bfd,
8092
             input_section,
8093
             (long) rel->r_offset,
8094
             howto->name,
8095
             sym_name);
8096
          ret = FALSE;
8097
        }
8098
 
8099
      r = _bfd_final_link_relocate (howto,
8100
                                    input_bfd,
8101
                                    input_section,
8102
                                    contents,
8103
                                    rel->r_offset,
8104
                                    relocation,
8105
                                    addend);
8106
 
8107
      if (r != bfd_reloc_ok)
8108
        {
8109
          if (r == bfd_reloc_overflow)
8110
            {
8111
              if (warned)
8112
                continue;
8113
              if (h != NULL
8114
                  && h->root.type == bfd_link_hash_undefweak
8115
                  && howto->pc_relative)
8116
                {
8117
                  /* Assume this is a call protected by other code that
8118
                     detect the symbol is undefined.  If this is the case,
8119
                     we can safely ignore the overflow.  If not, the
8120
                     program is hosed anyway, and a little warning isn't
8121
                     going to help.  */
8122
 
8123
                  continue;
8124
                }
8125
 
8126
              if (! (*info->callbacks->reloc_overflow) (info,
8127
                                                        (h ? &h->root : NULL),
8128
                                                        sym_name,
8129
                                                        howto->name,
8130
                                                        rel->r_addend,
8131
                                                        input_bfd,
8132
                                                        input_section,
8133
                                                        rel->r_offset))
8134
                return FALSE;
8135
            }
8136
          else
8137
            {
8138
              (*_bfd_error_handler)
8139
                (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
8140
                 input_bfd, input_section,
8141
                 (long) rel->r_offset, howto->name, sym_name, (int) r);
8142
              ret = FALSE;
8143
            }
8144
        }
8145
    }
8146
 
8147
#ifdef DEBUG
8148
  fprintf (stderr, "\n");
8149
#endif
8150
 
8151
  return ret;
8152
}
8153
 
8154
/* Finish up dynamic symbol handling.  We set the contents of various
8155
   dynamic sections here.  */
8156
 
8157
static bfd_boolean
8158
ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
8159
                               struct bfd_link_info *info,
8160
                               struct elf_link_hash_entry *h,
8161
                               Elf_Internal_Sym *sym)
8162
{
8163
  struct ppc_elf_link_hash_table *htab;
8164
  struct plt_entry *ent;
8165
  bfd_boolean doneone;
8166
 
8167
#ifdef DEBUG
8168
  fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
8169
           h->root.root.string);
8170
#endif
8171
 
8172
  htab = ppc_elf_hash_table (info);
8173
  BFD_ASSERT (htab->elf.dynobj != NULL);
8174
 
8175
  doneone = FALSE;
8176
  for (ent = h->plt.plist; ent != NULL; ent = ent->next)
8177
    if (ent->plt.offset != (bfd_vma) -1)
8178
      {
8179
        if (!doneone)
8180
          {
8181
            Elf_Internal_Rela rela;
8182
            bfd_byte *loc;
8183
            bfd_vma reloc_index;
8184
 
8185
            if (htab->plt_type == PLT_NEW
8186
                || !htab->elf.dynamic_sections_created
8187
                || h->dynindx == -1)
8188
              reloc_index = ent->plt.offset / 4;
8189
            else
8190
              {
8191
                reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size)
8192
                               / htab->plt_slot_size);
8193
                if (reloc_index > PLT_NUM_SINGLE_ENTRIES
8194
                    && htab->plt_type == PLT_OLD)
8195
                  reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
8196
              }
8197
 
8198
            /* This symbol has an entry in the procedure linkage table.
8199
               Set it up.  */
8200
            if (htab->plt_type == PLT_VXWORKS
8201
                && htab->elf.dynamic_sections_created
8202
                && h->dynindx != -1)
8203
              {
8204
                bfd_vma got_offset;
8205
                const bfd_vma *plt_entry;
8206
 
8207
                /* The first three entries in .got.plt are reserved.  */
8208
                got_offset = (reloc_index + 3) * 4;
8209
 
8210
                /* Use the right PLT. */
8211
                plt_entry = info->shared ? ppc_elf_vxworks_pic_plt_entry
8212
                            : ppc_elf_vxworks_plt_entry;
8213
 
8214
                /* Fill in the .plt on VxWorks.  */
8215
                if (info->shared)
8216
                  {
8217
                    bfd_put_32 (output_bfd,
8218
                                plt_entry[0] | PPC_HA (got_offset),
8219
                                htab->plt->contents + ent->plt.offset + 0);
8220
                    bfd_put_32 (output_bfd,
8221
                                plt_entry[1] | PPC_LO (got_offset),
8222
                                htab->plt->contents + ent->plt.offset + 4);
8223
                  }
8224
                else
8225
                  {
8226
                    bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot);
8227
 
8228
                    bfd_put_32 (output_bfd,
8229
                                plt_entry[0] | PPC_HA (got_loc),
8230
                                htab->plt->contents + ent->plt.offset + 0);
8231
                    bfd_put_32 (output_bfd,
8232
                                plt_entry[1] | PPC_LO (got_loc),
8233
                                htab->plt->contents + ent->plt.offset + 4);
8234
                  }
8235
 
8236
                bfd_put_32 (output_bfd, plt_entry[2],
8237
                            htab->plt->contents + ent->plt.offset + 8);
8238
                bfd_put_32 (output_bfd, plt_entry[3],
8239
                            htab->plt->contents + ent->plt.offset + 12);
8240
 
8241
                /* This instruction is an immediate load.  The value loaded is
8242
                   the byte offset of the R_PPC_JMP_SLOT relocation from the
8243
                   start of the .rela.plt section.  The value is stored in the
8244
                   low-order 16 bits of the load instruction.  */
8245
                /* NOTE: It appears that this is now an index rather than a
8246
                   prescaled offset.  */
8247
                bfd_put_32 (output_bfd,
8248
                            plt_entry[4] | reloc_index,
8249
                            htab->plt->contents + ent->plt.offset + 16);
8250
                /* This instruction is a PC-relative branch whose target is
8251
                   the start of the PLT section.  The address of this branch
8252
                   instruction is 20 bytes beyond the start of this PLT entry.
8253
                   The address is encoded in bits 6-29, inclusive.  The value
8254
                   stored is right-shifted by two bits, permitting a 26-bit
8255
                   offset.  */
8256
                bfd_put_32 (output_bfd,
8257
                            (plt_entry[5]
8258
                             | (-(ent->plt.offset + 20) & 0x03fffffc)),
8259
                            htab->plt->contents + ent->plt.offset + 20);
8260
                bfd_put_32 (output_bfd, plt_entry[6],
8261
                            htab->plt->contents + ent->plt.offset + 24);
8262
                bfd_put_32 (output_bfd, plt_entry[7],
8263
                            htab->plt->contents + ent->plt.offset + 28);
8264
 
8265
                /* Fill in the GOT entry corresponding to this PLT slot with
8266
                   the address immediately after the the "bctr" instruction
8267
                   in this PLT entry.  */
8268
                bfd_put_32 (output_bfd, (htab->plt->output_section->vma
8269
                                         + htab->plt->output_offset
8270
                                         + ent->plt.offset + 16),
8271
                            htab->sgotplt->contents + got_offset);
8272
 
8273
                if (!info->shared)
8274
                  {
8275
                    /* Fill in a couple of entries in .rela.plt.unloaded.  */
8276
                    loc = htab->srelplt2->contents
8277
                      + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index
8278
                          * VXWORKS_PLT_NON_JMP_SLOT_RELOCS)
8279
                         * sizeof (Elf32_External_Rela));
8280
 
8281
                    /* Provide the @ha relocation for the first instruction.  */
8282
                    rela.r_offset = (htab->plt->output_section->vma
8283
                                     + htab->plt->output_offset
8284
                                     + ent->plt.offset + 2);
8285
                    rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
8286
                                                R_PPC_ADDR16_HA);
8287
                    rela.r_addend = got_offset;
8288
                    bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8289
                    loc += sizeof (Elf32_External_Rela);
8290
 
8291
                    /* Provide the @l relocation for the second instruction.  */
8292
                    rela.r_offset = (htab->plt->output_section->vma
8293
                                     + htab->plt->output_offset
8294
                                     + ent->plt.offset + 6);
8295
                    rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
8296
                                                R_PPC_ADDR16_LO);
8297
                    rela.r_addend = got_offset;
8298
                    bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8299
                    loc += sizeof (Elf32_External_Rela);
8300
 
8301
                    /* Provide a relocation for the GOT entry corresponding to this
8302
                       PLT slot.  Point it at the middle of the .plt entry.  */
8303
                    rela.r_offset = (htab->sgotplt->output_section->vma
8304
                                     + htab->sgotplt->output_offset
8305
                                     + got_offset);
8306
                    rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
8307
                                                R_PPC_ADDR32);
8308
                    rela.r_addend = ent->plt.offset + 16;
8309
                    bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8310
                  }
8311
 
8312
                /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT.
8313
                   In particular, the offset for the relocation is not the
8314
                   address of the PLT entry for this function, as specified
8315
                   by the ABI.  Instead, the offset is set to the address of
8316
                   the GOT slot for this function.  See EABI 4.4.4.1.  */
8317
                rela.r_offset = (htab->sgotplt->output_section->vma
8318
                                 + htab->sgotplt->output_offset
8319
                                 + got_offset);
8320
 
8321
              }
8322
            else
8323
              {
8324
                asection *splt = htab->plt;
8325
                if (!htab->elf.dynamic_sections_created
8326
                    || h->dynindx == -1)
8327
                  splt = htab->iplt;
8328
 
8329
                rela.r_offset = (splt->output_section->vma
8330
                                 + splt->output_offset
8331
                                 + ent->plt.offset);
8332
                if (htab->plt_type == PLT_OLD
8333
                    || !htab->elf.dynamic_sections_created
8334
                    || h->dynindx == -1)
8335
                  {
8336
                    /* We don't need to fill in the .plt.  The ppc dynamic
8337
                       linker will fill it in.  */
8338
                  }
8339
                else
8340
                  {
8341
                    bfd_vma val = (htab->glink_pltresolve + ent->plt.offset
8342
                                   + htab->glink->output_section->vma
8343
                                   + htab->glink->output_offset);
8344
                    bfd_put_32 (output_bfd, val,
8345
                                splt->contents + ent->plt.offset);
8346
                  }
8347
              }
8348
 
8349
            /* Fill in the entry in the .rela.plt section.  */
8350
            rela.r_addend = 0;
8351
            if (!htab->elf.dynamic_sections_created
8352
                || h->dynindx == -1)
8353
              {
8354
                BFD_ASSERT (h->type == STT_GNU_IFUNC
8355
                            && h->def_regular
8356
                            && (h->root.type == bfd_link_hash_defined
8357
                                || h->root.type == bfd_link_hash_defweak));
8358
                rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
8359
                rela.r_addend = SYM_VAL (h);
8360
              }
8361
            else
8362
              rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
8363
 
8364
            if (!htab->elf.dynamic_sections_created
8365
                || h->dynindx == -1)
8366
              loc = (htab->reliplt->contents
8367
                     + (htab->reliplt->reloc_count++
8368
                        * sizeof (Elf32_External_Rela)));
8369
            else
8370
              loc = (htab->relplt->contents
8371
                     + reloc_index * sizeof (Elf32_External_Rela));
8372
            bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8373
 
8374
            if (!h->def_regular)
8375
              {
8376
                /* Mark the symbol as undefined, rather than as
8377
                   defined in the .plt section.  Leave the value if
8378
                   there were any relocations where pointer equality
8379
                   matters (this is a clue for the dynamic linker, to
8380
                   make function pointer comparisons work between an
8381
                   application and shared library), otherwise set it
8382
                   to zero.  */
8383
                sym->st_shndx = SHN_UNDEF;
8384
                if (!h->pointer_equality_needed)
8385
                  sym->st_value = 0;
8386
                else if (!h->ref_regular_nonweak)
8387
                  {
8388
                    /* This breaks function pointer comparisons, but
8389
                       that is better than breaking tests for a NULL
8390
                       function pointer.  */
8391
                    sym->st_value = 0;
8392
                  }
8393
              }
8394
            else if (h->type == STT_GNU_IFUNC
8395
                     && !info->shared)
8396
              {
8397
                /* Set the value of ifunc symbols in a non-pie
8398
                   executable to the glink entry.  This is to avoid
8399
                   text relocations.  We can't do this for ifunc in
8400
                   allocate_dynrelocs, as we do for normal dynamic
8401
                   function symbols with plt entries, because we need
8402
                   to keep the original value around for the ifunc
8403
                   relocation.  */
8404
                sym->st_shndx = (_bfd_elf_section_from_bfd_section
8405
                                 (output_bfd, htab->glink->output_section));
8406
                sym->st_value = (ent->glink_offset
8407
                                 + htab->glink->output_offset
8408
                                 + htab->glink->output_section->vma);
8409
              }
8410
            doneone = TRUE;
8411
          }
8412
 
8413
        if (htab->plt_type == PLT_NEW
8414
            || !htab->elf.dynamic_sections_created
8415
            || h->dynindx == -1)
8416
          {
8417
            unsigned char *p;
8418
            asection *splt = htab->plt;
8419
            if (!htab->elf.dynamic_sections_created
8420
                || h->dynindx == -1)
8421
              splt = htab->iplt;
8422
 
8423
            p = (unsigned char *) htab->glink->contents + ent->glink_offset;
8424
 
8425
            if (h == htab->tls_get_addr && !htab->no_tls_get_addr_opt)
8426
              {
8427
                bfd_put_32 (output_bfd, LWZ_11_3, p);
8428
                p += 4;
8429
                bfd_put_32 (output_bfd, LWZ_12_3 + 4, p);
8430
                p += 4;
8431
                bfd_put_32 (output_bfd, MR_0_3, p);
8432
                p += 4;
8433
                bfd_put_32 (output_bfd, CMPWI_11_0, p);
8434
                p += 4;
8435
                bfd_put_32 (output_bfd, ADD_3_12_2, p);
8436
                p += 4;
8437
                bfd_put_32 (output_bfd, BEQLR, p);
8438
                p += 4;
8439
                bfd_put_32 (output_bfd, MR_3_0, p);
8440
                p += 4;
8441
                bfd_put_32 (output_bfd, NOP, p);
8442
                p += 4;
8443
              }
8444
 
8445
            write_glink_stub (ent, splt, p, info);
8446
 
8447
            if (!info->shared)
8448
              /* We only need one non-PIC glink stub.  */
8449
              break;
8450
          }
8451
        else
8452
          break;
8453
      }
8454
 
8455
  if (h->needs_copy)
8456
    {
8457
      asection *s;
8458
      Elf_Internal_Rela rela;
8459
      bfd_byte *loc;
8460
 
8461
      /* This symbols needs a copy reloc.  Set it up.  */
8462
 
8463
#ifdef DEBUG
8464
      fprintf (stderr, ", copy");
8465
#endif
8466
 
8467
      BFD_ASSERT (h->dynindx != -1);
8468
 
8469
      if (ppc_elf_hash_entry (h)->has_sda_refs)
8470
        s = htab->relsbss;
8471
      else
8472
        s = htab->relbss;
8473
      BFD_ASSERT (s != NULL);
8474
 
8475
      rela.r_offset = SYM_VAL (h);
8476
      rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
8477
      rela.r_addend = 0;
8478
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
8479
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8480
    }
8481
 
8482
#ifdef DEBUG
8483
  fprintf (stderr, "\n");
8484
#endif
8485
 
8486
  /* Mark some specially defined symbols as absolute.  */
8487
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
8488
      || (!htab->is_vxworks
8489
          && (h == htab->elf.hgot
8490
              || strcmp (h->root.root.string,
8491
                         "_PROCEDURE_LINKAGE_TABLE_") == 0)))
8492
    sym->st_shndx = SHN_ABS;
8493
 
8494
  return TRUE;
8495
}
8496
 
8497
static enum elf_reloc_type_class
8498
ppc_elf_reloc_type_class (const Elf_Internal_Rela *rela)
8499
{
8500
  switch (ELF32_R_TYPE (rela->r_info))
8501
    {
8502
    case R_PPC_RELATIVE:
8503
      return reloc_class_relative;
8504
    case R_PPC_REL24:
8505
    case R_PPC_ADDR24:
8506
    case R_PPC_JMP_SLOT:
8507
      return reloc_class_plt;
8508
    case R_PPC_COPY:
8509
      return reloc_class_copy;
8510
    default:
8511
      return reloc_class_normal;
8512
    }
8513
}
8514
 
8515
/* Finish up the dynamic sections.  */
8516
 
8517
static bfd_boolean
8518
ppc_elf_finish_dynamic_sections (bfd *output_bfd,
8519
                                 struct bfd_link_info *info)
8520
{
8521
  asection *sdyn;
8522
  asection *splt;
8523
  struct ppc_elf_link_hash_table *htab;
8524
  bfd_vma got;
8525
  bfd *dynobj;
8526
  bfd_boolean ret = TRUE;
8527
 
8528
#ifdef DEBUG
8529
  fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
8530
#endif
8531
 
8532
  htab = ppc_elf_hash_table (info);
8533
  dynobj = elf_hash_table (info)->dynobj;
8534
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8535
  if (htab->is_vxworks)
8536
    splt = bfd_get_section_by_name (dynobj, ".plt");
8537
  else
8538
    splt = NULL;
8539
 
8540
  got = 0;
8541
  if (htab->elf.hgot != NULL)
8542
    got = SYM_VAL (htab->elf.hgot);
8543
 
8544
  if (htab->elf.dynamic_sections_created)
8545
    {
8546
      Elf32_External_Dyn *dyncon, *dynconend;
8547
 
8548
      BFD_ASSERT (htab->plt != NULL && sdyn != NULL);
8549
 
8550
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
8551
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
8552
      for (; dyncon < dynconend; dyncon++)
8553
        {
8554
          Elf_Internal_Dyn dyn;
8555
          asection *s;
8556
 
8557
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
8558
 
8559
          switch (dyn.d_tag)
8560
            {
8561
            case DT_PLTGOT:
8562
              if (htab->is_vxworks)
8563
                s = htab->sgotplt;
8564
              else
8565
                s = htab->plt;
8566
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
8567
              break;
8568
 
8569
            case DT_PLTRELSZ:
8570
              dyn.d_un.d_val = htab->relplt->size;
8571
              break;
8572
 
8573
            case DT_JMPREL:
8574
              s = htab->relplt;
8575
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
8576
              break;
8577
 
8578
            case DT_PPC_GOT:
8579
              dyn.d_un.d_ptr = got;
8580
              break;
8581
 
8582
            case DT_RELASZ:
8583
              if (htab->is_vxworks)
8584
                {
8585
                  if (htab->relplt)
8586
                    dyn.d_un.d_ptr -= htab->relplt->size;
8587
                  break;
8588
                }
8589
              continue;
8590
 
8591
            default:
8592
              if (htab->is_vxworks
8593
                  && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
8594
                break;
8595
              continue;
8596
            }
8597
 
8598
          bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
8599
        }
8600
    }
8601
 
8602
  if (htab->got != NULL)
8603
    {
8604
      if (htab->elf.hgot->root.u.def.section == htab->got
8605
          || htab->elf.hgot->root.u.def.section == htab->sgotplt)
8606
        {
8607
          unsigned char *p = htab->elf.hgot->root.u.def.section->contents;
8608
 
8609
          p += htab->elf.hgot->root.u.def.value;
8610
          if (htab->plt_type == PLT_OLD)
8611
            {
8612
              /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4
8613
                 so that a function can easily find the address of
8614
                 _GLOBAL_OFFSET_TABLE_.  */
8615
              BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4
8616
                          < htab->elf.hgot->root.u.def.section->size);
8617
              bfd_put_32 (output_bfd, 0x4e800021, p - 4);
8618
            }
8619
 
8620
          if (sdyn != NULL)
8621
            {
8622
              bfd_vma val = sdyn->output_section->vma + sdyn->output_offset;
8623
              BFD_ASSERT (htab->elf.hgot->root.u.def.value
8624
                          < htab->elf.hgot->root.u.def.section->size);
8625
              bfd_put_32 (output_bfd, val, p);
8626
            }
8627
        }
8628
      else
8629
        {
8630
          (*_bfd_error_handler) (_("%s not defined in linker created %s"),
8631
                                 htab->elf.hgot->root.root.string,
8632
                                 (htab->sgotplt != NULL
8633
                                  ? htab->sgotplt->name : htab->got->name));
8634
          bfd_set_error (bfd_error_bad_value);
8635
          ret = FALSE;
8636
        }
8637
 
8638
      elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
8639
    }
8640
 
8641
  /* Fill in the first entry in the VxWorks procedure linkage table.  */
8642
  if (splt && splt->size > 0)
8643
    {
8644
      /* Use the right PLT. */
8645
      const bfd_vma *plt_entry = (info->shared
8646
                                  ? ppc_elf_vxworks_pic_plt0_entry
8647
                                  : ppc_elf_vxworks_plt0_entry);
8648
 
8649
      if (!info->shared)
8650
        {
8651
          bfd_vma got_value = SYM_VAL (htab->elf.hgot);
8652
 
8653
          bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value),
8654
                      splt->contents +  0);
8655
          bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value),
8656
                      splt->contents +  4);
8657
        }
8658
      else
8659
        {
8660
          bfd_put_32 (output_bfd, plt_entry[0], splt->contents +  0);
8661
          bfd_put_32 (output_bfd, plt_entry[1], splt->contents +  4);
8662
        }
8663
      bfd_put_32 (output_bfd, plt_entry[2], splt->contents +  8);
8664
      bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12);
8665
      bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16);
8666
      bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20);
8667
      bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24);
8668
      bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28);
8669
 
8670
      if (! info->shared)
8671
        {
8672
          Elf_Internal_Rela rela;
8673
          bfd_byte *loc;
8674
 
8675
          loc = htab->srelplt2->contents;
8676
 
8677
          /* Output the @ha relocation for the first instruction.  */
8678
          rela.r_offset = (htab->plt->output_section->vma
8679
                           + htab->plt->output_offset
8680
                           + 2);
8681
          rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
8682
          rela.r_addend = 0;
8683
          bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8684
          loc += sizeof (Elf32_External_Rela);
8685
 
8686
          /* Output the @l relocation for the second instruction.  */
8687
          rela.r_offset = (htab->plt->output_section->vma
8688
                           + htab->plt->output_offset
8689
                           + 6);
8690
          rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
8691
          rela.r_addend = 0;
8692
          bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8693
          loc += sizeof (Elf32_External_Rela);
8694
 
8695
          /* Fix up the remaining relocations.  They may have the wrong
8696
             symbol index for _G_O_T_ or _P_L_T_ depending on the order
8697
             in which symbols were output.  */
8698
          while (loc < htab->srelplt2->contents + htab->srelplt2->size)
8699
            {
8700
              Elf_Internal_Rela rel;
8701
 
8702
              bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
8703
              rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA);
8704
              bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
8705
              loc += sizeof (Elf32_External_Rela);
8706
 
8707
              bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
8708
              rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO);
8709
              bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
8710
              loc += sizeof (Elf32_External_Rela);
8711
 
8712
              bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
8713
              rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32);
8714
              bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
8715
              loc += sizeof (Elf32_External_Rela);
8716
            }
8717
        }
8718
    }
8719
 
8720
  if (htab->glink != NULL
8721
      && htab->glink->contents != NULL
8722
      && htab->elf.dynamic_sections_created)
8723
    {
8724
      unsigned char *p;
8725
      unsigned char *endp;
8726
      bfd_vma res0;
8727
      unsigned int i;
8728
 
8729
      /*
8730
       * PIC glink code is the following:
8731
       *
8732
       * # ith PLT code stub.
8733
       *   addis 11,30,(plt+(i-1)*4-got)@ha
8734
       *   lwz 11,(plt+(i-1)*4-got)@l(11)
8735
       *   mtctr 11
8736
       *   bctr
8737
       *
8738
       * # A table of branches, one for each plt entry.
8739
       * # The idea is that the plt call stub loads ctr and r11 with these
8740
       * # addresses, so (r11 - res_0) gives the plt index * 4.
8741
       * res_0: b PLTresolve
8742
       * res_1: b PLTresolve
8743
       * .
8744
       * # Some number of entries towards the end can be nops
8745
       * res_n_m3: nop
8746
       * res_n_m2: nop
8747
       * res_n_m1:
8748
       *
8749
       * PLTresolve:
8750
       *    addis 11,11,(1f-res_0)@ha
8751
       *    mflr 0
8752
       *    bcl 20,31,1f
8753
       * 1: addi 11,11,(1b-res_0)@l
8754
       *    mflr 12
8755
       *    mtlr 0
8756
       *    sub 11,11,12                # r11 = index * 4
8757
       *    addis 12,12,(got+4-1b)@ha
8758
       *    lwz 0,(got+4-1b)@l(12)      # got[1] address of dl_runtime_resolve
8759
       *    lwz 12,(got+8-1b)@l(12)     # got[2] contains the map address
8760
       *    mtctr 0
8761
       *    add 0,11,11
8762
       *    add 11,0,11                 # r11 = index * 12 = reloc offset.
8763
       *    bctr
8764
       */
8765
      static const unsigned int pic_plt_resolve[] =
8766
        {
8767
          ADDIS_11_11,
8768
          MFLR_0,
8769
          BCL_20_31,
8770
          ADDI_11_11,
8771
          MFLR_12,
8772
          MTLR_0,
8773
          SUB_11_11_12,
8774
          ADDIS_12_12,
8775
          LWZ_0_12,
8776
          LWZ_12_12,
8777
          MTCTR_0,
8778
          ADD_0_11_11,
8779
          ADD_11_0_11,
8780
          BCTR,
8781
          NOP,
8782
          NOP
8783
        };
8784
 
8785
      /*
8786
       * Non-PIC glink code is a little simpler.
8787
       *
8788
       * # ith PLT code stub.
8789
       *   lis 11,(plt+(i-1)*4)@ha
8790
       *   lwz 11,(plt+(i-1)*4)@l(11)
8791
       *   mtctr 11
8792
       *   bctr
8793
       *
8794
       * The branch table is the same, then comes
8795
       *
8796
       * PLTresolve:
8797
       *    lis 12,(got+4)@ha
8798
       *    addis 11,11,(-res_0)@ha
8799
       *    lwz 0,(got+4)@l(12)         # got[1] address of dl_runtime_resolve
8800
       *    addi 11,11,(-res_0)@l       # r11 = index * 4
8801
       *    mtctr 0
8802
       *    add 0,11,11
8803
       *    lwz 12,(got+8)@l(12)        # got[2] contains the map address
8804
       *    add 11,0,11                 # r11 = index * 12 = reloc offset.
8805
       *    bctr
8806
       */
8807
      static const unsigned int plt_resolve[] =
8808
        {
8809
          LIS_12,
8810
          ADDIS_11_11,
8811
          LWZ_0_12,
8812
          ADDI_11_11,
8813
          MTCTR_0,
8814
          ADD_0_11_11,
8815
          LWZ_12_12,
8816
          ADD_11_0_11,
8817
          BCTR,
8818
          NOP,
8819
          NOP,
8820
          NOP,
8821
          NOP,
8822
          NOP,
8823
          NOP,
8824
          NOP
8825
        };
8826
 
8827
      if (ARRAY_SIZE (pic_plt_resolve) != GLINK_PLTRESOLVE / 4)
8828
        abort ();
8829
      if (ARRAY_SIZE (plt_resolve) != GLINK_PLTRESOLVE / 4)
8830
        abort ();
8831
 
8832
      /* Build the branch table, one for each plt entry (less one),
8833
         and perhaps some padding.  */
8834
      p = htab->glink->contents;
8835
      p += htab->glink_pltresolve;
8836
      endp = htab->glink->contents;
8837
      endp += htab->glink->size - GLINK_PLTRESOLVE;
8838
      while (p < endp - 8 * 4)
8839
        {
8840
          bfd_put_32 (output_bfd, B + endp - p, p);
8841
          p += 4;
8842
        }
8843
      while (p < endp)
8844
        {
8845
          bfd_put_32 (output_bfd, NOP, p);
8846
          p += 4;
8847
        }
8848
 
8849
      res0 = (htab->glink_pltresolve
8850
              + htab->glink->output_section->vma
8851
              + htab->glink->output_offset);
8852
 
8853
      /* Last comes the PLTresolve stub.  */
8854
      if (info->shared)
8855
        {
8856
          bfd_vma bcl;
8857
 
8858
          for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++)
8859
            {
8860
              bfd_put_32 (output_bfd, pic_plt_resolve[i], p);
8861
              p += 4;
8862
            }
8863
          p -= 4 * ARRAY_SIZE (pic_plt_resolve);
8864
 
8865
          bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4
8866
                 + htab->glink->output_section->vma
8867
                 + htab->glink->output_offset);
8868
 
8869
          bfd_put_32 (output_bfd,
8870
                      ADDIS_11_11 + PPC_HA (bcl - res0), p + 0*4);
8871
          bfd_put_32 (output_bfd,
8872
                      ADDI_11_11 + PPC_LO (bcl - res0), p + 3*4);
8873
          bfd_put_32 (output_bfd,
8874
                      ADDIS_12_12 + PPC_HA (got + 4 - bcl), p + 7*4);
8875
          if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl))
8876
            {
8877
              bfd_put_32 (output_bfd,
8878
                          LWZ_0_12 + PPC_LO (got + 4 - bcl), p + 8*4);
8879
              bfd_put_32 (output_bfd,
8880
                          LWZ_12_12 + PPC_LO (got + 8 - bcl), p + 9*4);
8881
            }
8882
          else
8883
            {
8884
              bfd_put_32 (output_bfd,
8885
                          LWZU_0_12 + PPC_LO (got + 4 - bcl), p + 8*4);
8886
              bfd_put_32 (output_bfd,
8887
                          LWZ_12_12 + 4, p + 9*4);
8888
            }
8889
        }
8890
      else
8891
        {
8892
          for (i = 0; i < ARRAY_SIZE (plt_resolve); i++)
8893
            {
8894
              bfd_put_32 (output_bfd, plt_resolve[i], p);
8895
              p += 4;
8896
            }
8897
          p -= 4 * ARRAY_SIZE (plt_resolve);
8898
 
8899
          bfd_put_32 (output_bfd,
8900
                      LIS_12 + PPC_HA (got + 4), p + 0*4);
8901
          bfd_put_32 (output_bfd,
8902
                      ADDIS_11_11 + PPC_HA (-res0), p + 1*4);
8903
          bfd_put_32 (output_bfd,
8904
                      ADDI_11_11 + PPC_LO (-res0), p + 3*4);
8905
          if (PPC_HA (got + 4) == PPC_HA (got + 8))
8906
            {
8907
              bfd_put_32 (output_bfd,
8908
                          LWZ_0_12 + PPC_LO (got + 4), p + 2*4);
8909
              bfd_put_32 (output_bfd,
8910
                          LWZ_12_12 + PPC_LO (got + 8), p + 6*4);
8911
            }
8912
          else
8913
            {
8914
              bfd_put_32 (output_bfd,
8915
                          LWZU_0_12 + PPC_LO (got + 4), p + 2*4);
8916
              bfd_put_32 (output_bfd,
8917
                          LWZ_12_12 + 4, p + 6*4);
8918
            }
8919
        }
8920
    }
8921
 
8922
  return ret;
8923
}
8924
 
8925
#define TARGET_LITTLE_SYM       bfd_elf32_powerpcle_vec
8926
#define TARGET_LITTLE_NAME      "elf32-powerpcle"
8927
#define TARGET_BIG_SYM          bfd_elf32_powerpc_vec
8928
#define TARGET_BIG_NAME         "elf32-powerpc"
8929
#define ELF_ARCH                bfd_arch_powerpc
8930
#define ELF_MACHINE_CODE        EM_PPC
8931
#ifdef __QNXTARGET__
8932
#define ELF_MAXPAGESIZE         0x1000
8933
#else
8934
#define ELF_MAXPAGESIZE         0x10000
8935
#endif
8936
#define ELF_MINPAGESIZE         0x1000
8937
#define ELF_COMMONPAGESIZE      0x1000
8938
#define elf_info_to_howto       ppc_elf_info_to_howto
8939
 
8940
#ifdef  EM_CYGNUS_POWERPC
8941
#define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
8942
#endif
8943
 
8944
#ifdef EM_PPC_OLD
8945
#define ELF_MACHINE_ALT2        EM_PPC_OLD
8946
#endif
8947
 
8948
#define elf_backend_plt_not_loaded      1
8949
#define elf_backend_can_gc_sections     1
8950
#define elf_backend_can_refcount        1
8951
#define elf_backend_rela_normal         1
8952
 
8953
#define bfd_elf32_mkobject                      ppc_elf_mkobject
8954
#define bfd_elf32_bfd_merge_private_bfd_data    ppc_elf_merge_private_bfd_data
8955
#define bfd_elf32_bfd_relax_section             ppc_elf_relax_section
8956
#define bfd_elf32_bfd_reloc_type_lookup         ppc_elf_reloc_type_lookup
8957
#define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup
8958
#define bfd_elf32_bfd_set_private_flags         ppc_elf_set_private_flags
8959
#define bfd_elf32_bfd_link_hash_table_create    ppc_elf_link_hash_table_create
8960
#define bfd_elf32_get_synthetic_symtab          ppc_elf_get_synthetic_symtab
8961
 
8962
#define elf_backend_object_p                    ppc_elf_object_p
8963
#define elf_backend_gc_mark_hook                ppc_elf_gc_mark_hook
8964
#define elf_backend_gc_sweep_hook               ppc_elf_gc_sweep_hook
8965
#define elf_backend_section_from_shdr           ppc_elf_section_from_shdr
8966
#define elf_backend_relocate_section            ppc_elf_relocate_section
8967
#define elf_backend_create_dynamic_sections     ppc_elf_create_dynamic_sections
8968
#define elf_backend_check_relocs                ppc_elf_check_relocs
8969
#define elf_backend_copy_indirect_symbol        ppc_elf_copy_indirect_symbol
8970
#define elf_backend_adjust_dynamic_symbol       ppc_elf_adjust_dynamic_symbol
8971
#define elf_backend_add_symbol_hook             ppc_elf_add_symbol_hook
8972
#define elf_backend_size_dynamic_sections       ppc_elf_size_dynamic_sections
8973
#define elf_backend_hash_symbol                 ppc_elf_hash_symbol
8974
#define elf_backend_finish_dynamic_symbol       ppc_elf_finish_dynamic_symbol
8975
#define elf_backend_finish_dynamic_sections     ppc_elf_finish_dynamic_sections
8976
#define elf_backend_fake_sections               ppc_elf_fake_sections
8977
#define elf_backend_additional_program_headers  ppc_elf_additional_program_headers
8978
#define elf_backend_grok_prstatus               ppc_elf_grok_prstatus
8979
#define elf_backend_grok_psinfo                 ppc_elf_grok_psinfo
8980
#define elf_backend_write_core_note             ppc_elf_write_core_note
8981
#define elf_backend_reloc_type_class            ppc_elf_reloc_type_class
8982
#define elf_backend_begin_write_processing      ppc_elf_begin_write_processing
8983
#define elf_backend_final_write_processing      ppc_elf_final_write_processing
8984
#define elf_backend_write_section               ppc_elf_write_section
8985
#define elf_backend_get_sec_type_attr           ppc_elf_get_sec_type_attr
8986
#define elf_backend_plt_sym_val                 ppc_elf_plt_sym_val
8987
#define elf_backend_action_discarded            ppc_elf_action_discarded
8988
#define elf_backend_init_index_section          _bfd_elf_init_1_index_section
8989
#define elf_backend_post_process_headers        _bfd_elf_set_osabi
8990
 
8991
#include "elf32-target.h"
8992
 
8993
/* VxWorks Target */
8994
 
8995
#undef TARGET_LITTLE_SYM
8996
#undef TARGET_LITTLE_NAME
8997
 
8998
#undef TARGET_BIG_SYM
8999
#define TARGET_BIG_SYM          bfd_elf32_powerpc_vxworks_vec
9000
#undef TARGET_BIG_NAME
9001
#define TARGET_BIG_NAME         "elf32-powerpc-vxworks"
9002
 
9003
/* VxWorks uses the elf default section flags for .plt.  */
9004
static const struct bfd_elf_special_section *
9005
ppc_elf_vxworks_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
9006
{
9007
  if (sec->name == NULL)
9008
    return NULL;
9009
 
9010
  if (strcmp (sec->name, ".plt") == 0)
9011
    return _bfd_elf_get_sec_type_attr (abfd, sec);
9012
 
9013
  return ppc_elf_get_sec_type_attr (abfd, sec);
9014
}
9015
 
9016
/* Like ppc_elf_link_hash_table_create, but overrides
9017
   appropriately for VxWorks.  */
9018
static struct bfd_link_hash_table *
9019
ppc_elf_vxworks_link_hash_table_create (bfd *abfd)
9020
{
9021
  struct bfd_link_hash_table *ret;
9022
 
9023
  ret = ppc_elf_link_hash_table_create (abfd);
9024
  if (ret)
9025
    {
9026
      struct ppc_elf_link_hash_table *htab
9027
        = (struct ppc_elf_link_hash_table *)ret;
9028
      htab->is_vxworks = 1;
9029
      htab->plt_type = PLT_VXWORKS;
9030
      htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE;
9031
      htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE;
9032
      htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE;
9033
    }
9034
  return ret;
9035
}
9036
 
9037
/* Tweak magic VxWorks symbols as they are loaded.  */
9038
static bfd_boolean
9039
ppc_elf_vxworks_add_symbol_hook (bfd *abfd,
9040
                                 struct bfd_link_info *info,
9041
                                 Elf_Internal_Sym *sym,
9042
                                 const char **namep ATTRIBUTE_UNUSED,
9043
                                 flagword *flagsp ATTRIBUTE_UNUSED,
9044
                                 asection **secp,
9045
                                 bfd_vma *valp)
9046
{
9047
  if (!elf_vxworks_add_symbol_hook(abfd, info, sym,namep, flagsp, secp,
9048
                                   valp))
9049
    return FALSE;
9050
 
9051
  return ppc_elf_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, valp);
9052
}
9053
 
9054
static void
9055
ppc_elf_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
9056
{
9057
  ppc_elf_final_write_processing(abfd, linker);
9058
  elf_vxworks_final_write_processing(abfd, linker);
9059
}
9060
 
9061
/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
9062
   define it.  */
9063
#undef elf_backend_want_plt_sym
9064
#define elf_backend_want_plt_sym                1
9065
#undef elf_backend_want_got_plt
9066
#define elf_backend_want_got_plt                1
9067
#undef elf_backend_got_symbol_offset
9068
#define elf_backend_got_symbol_offset           0
9069
#undef elf_backend_plt_not_loaded
9070
#define elf_backend_plt_not_loaded              0
9071
#undef elf_backend_plt_readonly
9072
#define elf_backend_plt_readonly                1
9073
#undef elf_backend_got_header_size
9074
#define elf_backend_got_header_size             12
9075
 
9076
#undef bfd_elf32_get_synthetic_symtab
9077
 
9078
#undef bfd_elf32_bfd_link_hash_table_create
9079
#define bfd_elf32_bfd_link_hash_table_create \
9080
  ppc_elf_vxworks_link_hash_table_create
9081
#undef elf_backend_add_symbol_hook
9082
#define elf_backend_add_symbol_hook \
9083
  ppc_elf_vxworks_add_symbol_hook
9084
#undef elf_backend_link_output_symbol_hook
9085
#define elf_backend_link_output_symbol_hook \
9086
  elf_vxworks_link_output_symbol_hook
9087
#undef elf_backend_final_write_processing
9088
#define elf_backend_final_write_processing \
9089
  ppc_elf_vxworks_final_write_processing
9090
#undef elf_backend_get_sec_type_attr
9091
#define elf_backend_get_sec_type_attr \
9092
  ppc_elf_vxworks_get_sec_type_attr
9093
#undef elf_backend_emit_relocs
9094
#define elf_backend_emit_relocs \
9095
  elf_vxworks_emit_relocs
9096
 
9097
#undef elf32_bed
9098
#define elf32_bed                               ppc_elf_vxworks_bed
9099
#undef elf_backend_post_process_headers
9100
 
9101
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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