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