projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add support -mrelocatable-lib
[binutils-gdb.git] / bfd / elf32-ppc.c
1 /* PowerPC-specific support for 32-bit ELF
2 Copyright 1994, 1995 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 /* This file is based on a preliminary PowerPC ELF ABI. The
22 information may not match the final PowerPC ELF ABI. It includes
23 suggestions from the in-progress Embedded PowerPC ABI, and that
24 information may also not match. */
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "bfdlink.h"
29 #include "libbfd.h"
30 #include "libelf.h"
31 #include "elf/ppc.h"
32
33 static bfd_reloc_status_type ppc_elf_unsupported_reloc
34 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
35 static bfd_reloc_status_type ppc_elf_std_reloc
36 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
37
38 static bfd_vma ppc_elf_addr16_ha_inner PARAMS ((bfd_vma));
39 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
40 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
41 static bfd_vma ppc_elf_got16_inner PARAMS ((asection *sec));
42 static bfd_reloc_status_type ppc_elf_got16_reloc
43 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
44 static reloc_howto_type *ppc_elf_reloc_type_lookup
45 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
46 static void ppc_elf_info_to_howto
47 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf32_Internal_Rela *dst));
48 static void ppc_elf_howto_init PARAMS ((void));
49 static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword));
50 static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
51 static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
52
53 static boolean ppc_elf_relocate_section PARAMS ((bfd *,
54 struct bfd_link_info *info,
55 bfd *,
56 asection *,
57 bfd_byte *,
58 Elf_Internal_Rela *relocs,
59 Elf_Internal_Sym *local_syms,
60 asection **));
61
62 #define USE_RELA
63
64 enum reloc_type
65 {
66 R_PPC_NONE = 0, /* 0 */
67 R_PPC_ADDR32, /* 1 */
68 R_PPC_ADDR24, /* 2 */
69 R_PPC_ADDR16, /* 3 */
70 R_PPC_ADDR16_LO, /* 4 */
71 R_PPC_ADDR16_HI, /* 5 */
72 R_PPC_ADDR16_HA, /* 6 */
73 R_PPC_ADDR14, /* 7 */
74 R_PPC_ADDR14_BRTAKEN, /* 8 */
75 R_PPC_ADDR14_BRNTAKEN, /* 9 */
76 R_PPC_REL24, /* 10 */
77 R_PPC_REL14, /* 11 */
78 R_PPC_REL14_BRTAKEN, /* 12 */
79 R_PPC_REL14_BRNTAKEN, /* 13 */
80 R_PPC_GOT16, /* 14 */
81 R_PPC_GOT16_LO, /* 15 */
82 R_PPC_GOT16_HI, /* 16 */
83 R_PPC_GOT16_HA, /* 17 */
84 R_PPC_PLT24, /* 18 */
85 R_PPC_COPY, /* 19 */
86 R_PPC_GLOB_DAT, /* 20 -- not in final System V spec */
87 R_PPC_JMP_SLOT, /* 21 */
88 R_PPC_RELATIVE, /* 22 */
89 R_PPC_LOCAL24PC, /* 23 */
90 R_PPC_UADDR32, /* 24 */
91 R_PPC_UADDR16, /* 25 */
92 R_PPC_REL32, /* 26 */
93 R_PPC_PLT32, /* 27 */
94 R_PPC_PLTREL32, /* 28 */
95 R_PPC_PLT16_LO, /* 29 */
96 R_PPC_PLT16_HI, /* 30 */
97 R_PPC_PLT16_HA, /* 31 */
98 R_PPC_SDAREL, /* 32 */
99
100 /* Relocations added by Sun. */
101 R_PPC_SECTOFF, /* 33 */
102 R_PPC_SECTOFF_LO, /* 34 */
103 R_PPC_SECTOFF_HI, /* 35 */
104 R_PPC_SECTOFF_HA, /* 36 */
105
106 /* The remaining relocs are from the Embedded ELF ABI, and are not
107 in the SVR4 ELF ABI. */
108 R_PPC_EMB_NADDR32 = 101, /* 101 */
109 R_PPC_EMB_NADDR16, /* 102 */
110 R_PPC_EMB_NADDR16_LO, /* 103 */
111 R_PPC_EMB_NADDR16_HI, /* 104 */
112 R_PPC_EMB_NADDR16_HA, /* 105 */
113 R_PPC_EMB_SDAI16, /* 106 */
114 R_PPC_EMB_SDA2I16, /* 107 */
115 R_PPC_EMB_SDA2REL, /* 108 */
116 R_PPC_EMB_SDA21, /* 109 */
117 R_PPC_EMB_MRKREF, /* 110 */
118 R_PPC_EMB_RELSEC16, /* 111 */
119 R_PPC_EMB_RELST_LO, /* 112 */
120 R_PPC_EMB_RELST_HI, /* 113 */
121 R_PPC_EMB_RELST_HA, /* 114 */
122 R_PPC_EMB_BIT_FLD, /* 115 */
123 R_PPC_EMB_RELSDA, /* 116 */
124 R_PPC_max
125 };
126
127 \f
128 static reloc_howto_type *ppc_elf_howto_table[ (int)R_PPC_max ];
129
130 static reloc_howto_type ppc_elf_howto_raw[] =
131 {
132 /* This reloc does nothing. */
133 HOWTO (R_PPC_NONE, /* type */
134 0, /* rightshift */
135 2, /* size (0 = byte, 1 = short, 2 = long) */
136 32, /* bitsize */
137 false, /* pc_relative */
138 0, /* bitpos */
139 complain_overflow_bitfield, /* complain_on_overflow */
140 ppc_elf_std_reloc, /* special_function */
141 "R_PPC_NONE", /* name */
142 false, /* partial_inplace */
143 0, /* src_mask */
144 0, /* dst_mask */
145 false), /* pcrel_offset */
146
147 /* A standard 32 bit relocation. */
148 HOWTO (R_PPC_ADDR32, /* type */
149 0, /* rightshift */
150 2, /* size (0 = byte, 1 = short, 2 = long) */
151 32, /* bitsize */
152 false, /* pc_relative */
153 0, /* bitpos */
154 complain_overflow_bitfield, /* complain_on_overflow */
155 ppc_elf_std_reloc, /* special_function */
156 "R_PPC_ADDR32", /* name */
157 false, /* partial_inplace */
158 0, /* src_mask */
159 0xffffffff, /* dst_mask */
160 false), /* pcrel_offset */
161
162 /* An absolute 26 bit branch; the lower two bits must be zero.
163 FIXME: we don't check that, we just clear them. */
164 HOWTO (R_PPC_ADDR24, /* type */
165 0, /* rightshift */
166 2, /* size (0 = byte, 1 = short, 2 = long) */
167 26, /* bitsize */
168 false, /* pc_relative */
169 0, /* bitpos */
170 complain_overflow_bitfield, /* complain_on_overflow */
171 ppc_elf_std_reloc, /* special_function */
172 "R_PPC_ADDR24", /* name */
173 false, /* partial_inplace */
174 0, /* src_mask */
175 0x3fffffc, /* dst_mask */
176 false), /* pcrel_offset */
177
178 /* A standard 16 bit relocation. */
179 HOWTO (R_PPC_ADDR16, /* type */
180 0, /* rightshift */
181 1, /* size (0 = byte, 1 = short, 2 = long) */
182 16, /* bitsize */
183 false, /* pc_relative */
184 0, /* bitpos */
185 complain_overflow_bitfield, /* complain_on_overflow */
186 ppc_elf_std_reloc, /* special_function */
187 "R_PPC_ADDR16", /* name */
188 false, /* partial_inplace */
189 0, /* src_mask */
190 0xffff, /* dst_mask */
191 false), /* pcrel_offset */
192
193 /* A 16 bit relocation without overflow. */
194 HOWTO (R_PPC_ADDR16_LO, /* type */
195 0, /* rightshift */
196 1, /* size (0 = byte, 1 = short, 2 = long) */
197 16, /* bitsize */
198 false, /* pc_relative */
199 0, /* bitpos */
200 complain_overflow_dont,/* complain_on_overflow */
201 ppc_elf_std_reloc, /* special_function */
202 "R_PPC_ADDR16_LO", /* name */
203 false, /* partial_inplace */
204 0, /* src_mask */
205 0xffff, /* dst_mask */
206 false), /* pcrel_offset */
207
208 /* The high order 16 bits of an address. */
209 HOWTO (R_PPC_ADDR16_HI, /* type */
210 16, /* rightshift */
211 1, /* size (0 = byte, 1 = short, 2 = long) */
212 16, /* bitsize */
213 false, /* pc_relative */
214 0, /* bitpos */
215 complain_overflow_dont, /* complain_on_overflow */
216 ppc_elf_std_reloc, /* special_function */
217 "R_PPC_ADDR16_HI", /* name */
218 false, /* partial_inplace */
219 0, /* src_mask */
220 0xffff, /* dst_mask */
221 false), /* pcrel_offset */
222
223 /* The high order 16 bits of an address, plus 1 if the contents of
224 the low 16 bits, treated as a signed number, is negative. */
225 HOWTO (R_PPC_ADDR16_HA, /* type */
226 16, /* rightshift */
227 1, /* size (0 = byte, 1 = short, 2 = long) */
228 16, /* bitsize */
229 false, /* pc_relative */
230 0, /* bitpos */
231 complain_overflow_dont, /* complain_on_overflow */
232 ppc_elf_addr16_ha_reloc, /* special_function */
233 "R_PPC_ADDR16_HA", /* name */
234 false, /* partial_inplace */
235 0, /* src_mask */
236 0xffff, /* dst_mask */
237 false), /* pcrel_offset */
238
239 /* An absolute 16 bit branch; the lower two bits must be zero.
240 FIXME: we don't check that, we just clear them. */
241 HOWTO (R_PPC_ADDR14, /* type */
242 0, /* rightshift */
243 2, /* size (0 = byte, 1 = short, 2 = long) */
244 16, /* bitsize */
245 false, /* pc_relative */
246 0, /* bitpos */
247 complain_overflow_bitfield, /* complain_on_overflow */
248 ppc_elf_std_reloc, /* special_function */
249 "R_PPC_ADDR14", /* name */
250 false, /* partial_inplace */
251 0, /* src_mask */
252 0xfffc, /* dst_mask */
253 false), /* pcrel_offset */
254
255 /* An absolute 16 bit branch, for which bit 10 should be set to
256 indicate that the branch is expected to be taken. The lower two
257 bits must be zero. */
258 HOWTO (R_PPC_ADDR14_BRTAKEN, /* type */
259 0, /* rightshift */
260 2, /* size (0 = byte, 1 = short, 2 = long) */
261 16, /* bitsize */
262 false, /* pc_relative */
263 0, /* bitpos */
264 complain_overflow_bitfield, /* complain_on_overflow */
265 ppc_elf_unsupported_reloc, /* special_function */
266 "R_PPC_ADDR14_BRTAKEN",/* name */
267 false, /* partial_inplace */
268 0, /* src_mask */
269 0xfffc, /* dst_mask */
270 false), /* pcrel_offset */
271
272 /* An absolute 16 bit branch, for which bit 10 should be set to
273 indicate that the branch is not expected to be taken. The lower
274 two bits must be zero. */
275 HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
276 0, /* rightshift */
277 2, /* size (0 = byte, 1 = short, 2 = long) */
278 16, /* bitsize */
279 false, /* pc_relative */
280 0, /* bitpos */
281 complain_overflow_bitfield, /* complain_on_overflow */
282 ppc_elf_unsupported_reloc, /* special_function */
283 "R_PPC_ADDR14_BRNTAKEN",/* name */
284 false, /* partial_inplace */
285 0, /* src_mask */
286 0xfffc, /* dst_mask */
287 false), /* pcrel_offset */
288
289 /* A relative 26 bit branch; the lower two bits must be zero. */
290 HOWTO (R_PPC_REL24, /* type */
291 0, /* rightshift */
292 2, /* size (0 = byte, 1 = short, 2 = long) */
293 26, /* bitsize */
294 true, /* pc_relative */
295 0, /* bitpos */
296 complain_overflow_signed, /* complain_on_overflow */
297 ppc_elf_std_reloc, /* special_function */
298 "R_PPC_REL24", /* name */
299 false, /* partial_inplace */
300 0, /* src_mask */
301 0x3fffffc, /* dst_mask */
302 true), /* pcrel_offset */
303
304 /* A relative 16 bit branch; the lower two bits must be zero. */
305 HOWTO (R_PPC_REL14, /* type */
306 0, /* rightshift */
307 2, /* size (0 = byte, 1 = short, 2 = long) */
308 16, /* bitsize */
309 true, /* pc_relative */
310 0, /* bitpos */
311 complain_overflow_signed, /* complain_on_overflow */
312 ppc_elf_std_reloc, /* special_function */
313 "R_PPC_REL14", /* name */
314 false, /* partial_inplace */
315 0, /* src_mask */
316 0xfffc, /* dst_mask */
317 true), /* pcrel_offset */
318
319 /* A relative 16 bit branch. Bit 10 should be set to indicate that
320 the branch is expected to be taken. The lower two bits must be
321 zero. */
322 HOWTO (R_PPC_REL14_BRTAKEN, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 16, /* bitsize */
326 false, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_signed, /* complain_on_overflow */
329 ppc_elf_unsupported_reloc, /* special_function */
330 "R_PPC_REL14_BRTAKEN", /* name */
331 false, /* partial_inplace */
332 0, /* src_mask */
333 0xfffc, /* dst_mask */
334 true), /* pcrel_offset */
335
336 /* A relative 16 bit branch. Bit 10 should be set to indicate that
337 the branch is not expected to be taken. The lower two bits must
338 be zero. */
339 HOWTO (R_PPC_REL14_BRNTAKEN, /* type */
340 0, /* rightshift */
341 2, /* size (0 = byte, 1 = short, 2 = long) */
342 16, /* bitsize */
343 false, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_signed, /* complain_on_overflow */
346 ppc_elf_unsupported_reloc, /* special_function */
347 "R_PPC_REL14_BRNTAKEN",/* name */
348 false, /* partial_inplace */
349 0, /* src_mask */
350 0xfffc, /* dst_mask */
351 true), /* pcrel_offset */
352
353 /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
354 symbol. */
355 HOWTO (R_PPC_GOT16, /* type */
356 0, /* rightshift */
357 1, /* size (0 = byte, 1 = short, 2 = long) */
358 16, /* bitsize */
359 false, /* pc_relative */
360 0, /* bitpos */
361 complain_overflow_signed, /* complain_on_overflow */
362 ppc_elf_got16_reloc, /* special_function */
363 "R_PPC_GOT16", /* name */
364 false, /* partial_inplace */
365 0, /* src_mask */
366 0xffff, /* dst_mask */
367 false), /* pcrel_offset */
368
369 /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
370 the symbol. */
371 HOWTO (R_PPC_GOT16_LO, /* type */
372 0, /* rightshift */
373 1, /* size (0 = byte, 1 = short, 2 = long) */
374 16, /* bitsize */
375 false, /* pc_relative */
376 0, /* bitpos */
377 complain_overflow_bitfield, /* complain_on_overflow */
378 ppc_elf_got16_reloc, /* special_function */
379 "R_PPC_GOT16_LO", /* name */
380 false, /* partial_inplace */
381 0, /* src_mask */
382 0xffff, /* dst_mask */
383 false), /* pcrel_offset */
384
385 /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
386 the symbol. */
387 HOWTO (R_PPC_GOT16_HI, /* type */
388 16, /* rightshift */
389 1, /* size (0 = byte, 1 = short, 2 = long) */
390 16, /* bitsize */
391 false, /* pc_relative */
392 0, /* bitpos */
393 complain_overflow_bitfield, /* complain_on_overflow */
394 ppc_elf_got16_reloc, /* special_function */
395 "R_PPC_GOT16_HI", /* name */
396 false, /* partial_inplace */
397 0, /* src_mask */
398 0xffff, /* dst_mask */
399 false), /* pcrel_offset */
400
401 /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
402 the symbol. FIXME: Not supported. */
403 HOWTO (R_PPC_GOT16_HA, /* type */
404 0, /* rightshift */
405 1, /* size (0 = byte, 1 = short, 2 = long) */
406 16, /* bitsize */
407 false, /* pc_relative */
408 0, /* bitpos */
409 complain_overflow_bitfield, /* complain_on_overflow */
410 ppc_elf_unsupported_reloc, /* special_function */
411 "R_PPC_GOT16_HA", /* name */
412 false, /* partial_inplace */
413 0, /* src_mask */
414 0xffff, /* dst_mask */
415 false), /* pcrel_offset */
416
417 /* Like R_PPC_REL24, but referring to the procedure linkage table
418 entry for the symbol. FIXME: Not supported. */
419 HOWTO (R_PPC_PLT24, /* type */
420 0, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 26, /* bitsize */
423 true, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_signed, /* complain_on_overflow */
426 ppc_elf_std_reloc, /* special_function */
427 "R_PPC_PLT24", /* name */
428 false, /* partial_inplace */
429 0, /* src_mask */
430 0x3fffffc, /* dst_mask */
431 true), /* pcrel_offset */
432
433 /* This is used only by the dynamic linker. The symbol should exist
434 both in the object being run and in some shared library. The
435 dynamic linker copies the data addressed by the symbol from the
436 shared library into the object. I have no idea what the purpose
437 of this is. */
438 HOWTO (R_PPC_COPY, /* type */
439 0, /* rightshift */
440 2, /* size (0 = byte, 1 = short, 2 = long) */
441 32, /* bitsize */
442 false, /* pc_relative */
443 0, /* bitpos */
444 complain_overflow_bitfield, /* complain_on_overflow */
445 ppc_elf_std_reloc, /* special_function */
446 "R_PPC_COPY", /* name */
447 false, /* partial_inplace */
448 0, /* src_mask */
449 0, /* dst_mask */
450 false), /* pcrel_offset */
451
452 /* Like R_PPC_ADDR32, but used when setting global offset table
453 entries. */
454 HOWTO (R_PPC_GLOB_DAT, /* type */
455 0, /* rightshift */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
457 32, /* bitsize */
458 false, /* pc_relative */
459 0, /* bitpos */
460 complain_overflow_bitfield, /* complain_on_overflow */
461 ppc_elf_std_reloc, /* special_function */
462 "R_PPC_GLOB_DAT", /* name */
463 false, /* partial_inplace */
464 0, /* src_mask */
465 0xffffffff, /* dst_mask */
466 false), /* pcrel_offset */
467
468 /* Marks a procedure linkage table entry for a symbol. */
469 HOWTO (R_PPC_JMP_SLOT, /* type */
470 0, /* rightshift */
471 2, /* size (0 = byte, 1 = short, 2 = long) */
472 32, /* bitsize */
473 false, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_bitfield, /* complain_on_overflow */
476 ppc_elf_std_reloc, /* special_function */
477 "R_PPC_JMP_SLOT", /* name */
478 false, /* partial_inplace */
479 0, /* src_mask */
480 0, /* dst_mask */
481 false), /* pcrel_offset */
482
483 /* Used only by the dynamic linker. When the object is run, this
484 longword is set to the load address of the object, plus the
485 addend. */
486 HOWTO (R_PPC_RELATIVE, /* type */
487 0, /* rightshift */
488 2, /* size (0 = byte, 1 = short, 2 = long) */
489 32, /* bitsize */
490 false, /* pc_relative */
491 0, /* bitpos */
492 complain_overflow_bitfield, /* complain_on_overflow */
493 ppc_elf_std_reloc, /* special_function */
494 "R_PPC_RELATIVE", /* name */
495 false, /* partial_inplace */
496 0, /* src_mask */
497 0xffffffff, /* dst_mask */
498 false), /* pcrel_offset */
499
500 /* Like R_PPC_REL24, but uses the value of the symbol within the
501 object rather than the final value. Normally used for
502 _GLOBAL_OFFSET_TABLE_. FIXME: Not supported. */
503 HOWTO (R_PPC_LOCAL24PC, /* type */
504 0, /* rightshift */
505 2, /* size (0 = byte, 1 = short, 2 = long) */
506 26, /* bitsize */
507 true, /* pc_relative */
508 0, /* bitpos */
509 complain_overflow_signed, /* complain_on_overflow */
510 ppc_elf_unsupported_reloc, /* special_function */
511 "R_PPC_LOCAL24PC", /* name */
512 false, /* partial_inplace */
513 0, /* src_mask */
514 0x3fffffc, /* dst_mask */
515 true), /* pcrel_offset */
516
517 /* Like R_PPC_ADDR32, but may be unaligned. */
518 HOWTO (R_PPC_UADDR32, /* type */
519 0, /* rightshift */
520 2, /* size (0 = byte, 1 = short, 2 = long) */
521 32, /* bitsize */
522 false, /* pc_relative */
523 0, /* bitpos */
524 complain_overflow_bitfield, /* complain_on_overflow */
525 ppc_elf_std_reloc, /* special_function */
526 "R_PPC_UADDR32", /* name */
527 false, /* partial_inplace */
528 0, /* src_mask */
529 0xffffffff, /* dst_mask */
530 false), /* pcrel_offset */
531
532 /* Like R_PPC_ADDR16, but may be unaligned. */
533 HOWTO (R_PPC_UADDR16, /* type */
534 0, /* rightshift */
535 1, /* size (0 = byte, 1 = short, 2 = long) */
536 16, /* bitsize */
537 false, /* pc_relative */
538 0, /* bitpos */
539 complain_overflow_bitfield, /* complain_on_overflow */
540 ppc_elf_std_reloc, /* special_function */
541 "R_PPC_UADDR16", /* name */
542 false, /* partial_inplace */
543 0, /* src_mask */
544 0xffff, /* dst_mask */
545 false), /* pcrel_offset */
546
547 /* 32-bit PC relative */
548 HOWTO (R_PPC_REL32, /* type */
549 0, /* rightshift */
550 2, /* size (0 = byte, 1 = short, 2 = long) */
551 32, /* bitsize */
552 true, /* pc_relative */
553 0, /* bitpos */
554 complain_overflow_bitfield, /* complain_on_overflow */
555 ppc_elf_std_reloc, /* special_function */
556 "R_PPC_REL32", /* name */
557 false, /* partial_inplace */
558 0, /* src_mask */
559 0xffffffff, /* dst_mask */
560 true), /* pcrel_offset */
561
562 /* 32-bit relocation to the symbol's procedure linkage table.
563 FIXEME: not supported. */
564 HOWTO (R_PPC_PLT32, /* type */
565 0, /* rightshift */
566 2, /* size (0 = byte, 1 = short, 2 = long) */
567 32, /* bitsize */
568 false, /* pc_relative */
569 0, /* bitpos */
570 complain_overflow_bitfield, /* complain_on_overflow */
571 ppc_elf_unsupported_reloc, /* special_function */
572 "R_PPC_PLT32", /* name */
573 false, /* partial_inplace */
574 0, /* src_mask */
575 0, /* dst_mask */
576 false), /* pcrel_offset */
577
578 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
579 FIXEME: not supported. */
580 HOWTO (R_PPC_PLTREL32, /* type */
581 0, /* rightshift */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
583 32, /* bitsize */
584 true, /* pc_relative */
585 0, /* bitpos */
586 complain_overflow_bitfield, /* complain_on_overflow */
587 ppc_elf_unsupported_reloc, /* special_function */
588 "R_PPC_PLTREL32", /* name */
589 false, /* partial_inplace */
590 0, /* src_mask */
591 0, /* dst_mask */
592 true), /* pcrel_offset */
593
594 /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
595 the symbol. */
596 HOWTO (R_PPC_PLT16_LO, /* type */
597 0, /* rightshift */
598 1, /* size (0 = byte, 1 = short, 2 = long) */
599 16, /* bitsize */
600 false, /* pc_relative */
601 0, /* bitpos */
602 complain_overflow_bitfield, /* complain_on_overflow */
603 ppc_elf_unsupported_reloc, /* special_function */
604 "R_PPC_PLT16_LO", /* name */
605 false, /* partial_inplace */
606 0, /* src_mask */
607 0xffff, /* dst_mask */
608 false), /* pcrel_offset */
609
610 /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
611 the symbol. */
612 HOWTO (R_PPC_PLT16_HI, /* type */
613 16, /* rightshift */
614 1, /* size (0 = byte, 1 = short, 2 = long) */
615 16, /* bitsize */
616 false, /* pc_relative */
617 0, /* bitpos */
618 complain_overflow_bitfield, /* complain_on_overflow */
619 ppc_elf_unsupported_reloc, /* special_function */
620 "R_PPC_PLT16_HI", /* name */
621 false, /* partial_inplace */
622 0, /* src_mask */
623 0xffff, /* dst_mask */
624 false), /* pcrel_offset */
625
626 /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
627 the symbol. FIXME: Not supported. */
628 HOWTO (R_PPC_PLT16_HA, /* type */
629 0, /* rightshift */
630 1, /* size (0 = byte, 1 = short, 2 = long) */
631 16, /* bitsize */
632 false, /* pc_relative */
633 0, /* bitpos */
634 complain_overflow_bitfield, /* complain_on_overflow */
635 ppc_elf_unsupported_reloc, /* special_function */
636 "R_PPC_PLT16_HA", /* name */
637 false, /* partial_inplace */
638 0, /* src_mask */
639 0xffff, /* dst_mask */
640 false), /* pcrel_offset */
641
642 /* A sign-extended 16 bit value relative to _SDA_BASE, for use with
643 small data items. */
644 HOWTO (R_PPC_SDAREL, /* type */
645 0, /* rightshift */
646 1, /* size (0 = byte, 1 = short, 2 = long) */
647 16, /* bitsize */
648 false, /* pc_relative */
649 0, /* bitpos */
650 complain_overflow_signed, /* complain_on_overflow */
651 ppc_elf_got16_reloc, /* special_function */
652 "R_PPC_SDAREL", /* name */
653 false, /* partial_inplace */
654 0, /* src_mask */
655 0xffff, /* dst_mask */
656 false), /* pcrel_offset */
657
658 /* These next 4 relocations were added by Sun. */
659 /* 32-bit section relative relocation. FIXME: not supported. */
660 HOWTO (R_PPC_SECTOFF, /* type */
661 0, /* rightshift */
662 2, /* size (0 = byte, 1 = short, 2 = long) */
663 32, /* bitsize */
664 true, /* pc_relative */
665 0, /* bitpos */
666 complain_overflow_bitfield, /* complain_on_overflow */
667 ppc_elf_unsupported_reloc, /* special_function */
668 "R_PPC_SECTOFF", /* name */
669 false, /* partial_inplace */
670 0, /* src_mask */
671 0, /* dst_mask */
672 true), /* pcrel_offset */
673
674 /* 16-bit lower half section relative relocation. FIXME: not supported. */
675 HOWTO (R_PPC_SECTOFF_LO, /* type */
676 0, /* rightshift */
677 1, /* size (0 = byte, 1 = short, 2 = long) */
678 16, /* bitsize */
679 false, /* pc_relative */
680 0, /* bitpos */
681 complain_overflow_bitfield, /* complain_on_overflow */
682 ppc_elf_unsupported_reloc, /* special_function */
683 "R_PPC_SECTOFF_LO", /* name */
684 false, /* partial_inplace */
685 0, /* src_mask */
686 0xffff, /* dst_mask */
687 false), /* pcrel_offset */
688
689 /* 16-bit upper half section relative relocation. FIXME: not supported. */
690 HOWTO (R_PPC_SECTOFF_HI, /* type */
691 16, /* rightshift */
692 1, /* size (0 = byte, 1 = short, 2 = long) */
693 16, /* bitsize */
694 false, /* pc_relative */
695 0, /* bitpos */
696 complain_overflow_bitfield, /* complain_on_overflow */
697 ppc_elf_unsupported_reloc, /* special_function */
698 "R_PPC_SECTOFF_HI", /* name */
699 false, /* partial_inplace */
700 0, /* src_mask */
701 0xffff, /* dst_mask */
702 false), /* pcrel_offset */
703
704 /* 16-bit upper half adjusted section relative relocation. FIXME: not supported. */
705 HOWTO (R_PPC_SECTOFF_HA, /* type */
706 0, /* rightshift */
707 1, /* size (0 = byte, 1 = short, 2 = long) */
708 16, /* bitsize */
709 false, /* pc_relative */
710 0, /* bitpos */
711 complain_overflow_bitfield, /* complain_on_overflow */
712 ppc_elf_unsupported_reloc, /* special_function */
713 "R_PPC_SECTOFF_HA", /* name */
714 false, /* partial_inplace */
715 0, /* src_mask */
716 0xffff, /* dst_mask */
717 false), /* pcrel_offset */
718
719 /* The remaining relocs are from the Embedded ELF ABI, and are not
720 in the SVR4 ELF ABI. */
721
722 /* 32 bit value resulting from the addend minus the symbol */
723 HOWTO (R_PPC_EMB_NADDR32, /* type */
724 0, /* rightshift */
725 2, /* size (0 = byte, 1 = short, 2 = long) */
726 32, /* bitsize */
727 false, /* pc_relative */
728 0, /* bitpos */
729 complain_overflow_bitfield, /* complain_on_overflow */
730 ppc_elf_unsupported_reloc, /* special_function */
731 "R_PPC_EMB_NADDR32", /* name */
732 false, /* partial_inplace */
733 0, /* src_mask */
734 0xffffffff, /* dst_mask */
735 false), /* pcrel_offset */
736
737 /* 16 bit value resulting from the addend minus the symbol */
738 HOWTO (R_PPC_EMB_NADDR16, /* type */
739 0, /* rightshift */
740 1, /* size (0 = byte, 1 = short, 2 = long) */
741 16, /* bitsize */
742 false, /* pc_relative */
743 0, /* bitpos */
744 complain_overflow_bitfield, /* complain_on_overflow */
745 ppc_elf_unsupported_reloc, /* special_function */
746 "R_PPC_EMB_NADDR16", /* name */
747 false, /* partial_inplace */
748 0, /* src_mask */
749 0xffff, /* dst_mask */
750 false), /* pcrel_offset */
751
752 /* 16 bit value resulting from the addend minus the symbol */
753 HOWTO (R_PPC_EMB_NADDR16_LO, /* type */
754 0, /* rightshift */
755 1, /* size (0 = byte, 1 = short, 2 = long) */
756 16, /* bitsize */
757 false, /* pc_relative */
758 0, /* bitpos */
759 complain_overflow_dont,/* complain_on_overflow */
760 ppc_elf_unsupported_reloc, /* special_function */
761 "R_PPC_EMB_ADDR16_LO", /* name */
762 false, /* partial_inplace */
763 0, /* src_mask */
764 0xffff, /* dst_mask */
765 false), /* pcrel_offset */
766
767 /* The high order 16 bits of the addend minus the symbol */
768 HOWTO (R_PPC_EMB_NADDR16_HI, /* type */
769 16, /* rightshift */
770 1, /* size (0 = byte, 1 = short, 2 = long) */
771 16, /* bitsize */
772 false, /* pc_relative */
773 0, /* bitpos */
774 complain_overflow_dont, /* complain_on_overflow */
775 ppc_elf_unsupported_reloc, /* special_function */
776 "R_PPC_EMB_NADDR16_HI", /* name */
777 false, /* partial_inplace */
778 0, /* src_mask */
779 0xffff, /* dst_mask */
780 false), /* pcrel_offset */
781
782 /* The high order 16 bits of the result of the addend minus the address,
783 plus 1 if the contents of the low 16 bits, treated as a signed number,
784 is negative. */
785 HOWTO (R_PPC_EMB_NADDR16_HA, /* type */
786 16, /* rightshift */
787 1, /* size (0 = byte, 1 = short, 2 = long) */
788 16, /* bitsize */
789 false, /* pc_relative */
790 0, /* bitpos */
791 complain_overflow_dont, /* complain_on_overflow */
792 ppc_elf_unsupported_reloc, /* special_function */
793 "R_PPC_EMB_NADDR16_HA", /* name */
794 false, /* partial_inplace */
795 0, /* src_mask */
796 0xffff, /* dst_mask */
797 false), /* pcrel_offset */
798 };
799
800 \f
801 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */
802
803 static void
804 ppc_elf_howto_init ()
805 {
806 unsigned int i, type;
807
808 for (i = 0; i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); i++)
809 {
810 type = ppc_elf_howto_raw[i].type;
811 BFD_ASSERT (type < sizeof(ppc_elf_howto_table) / sizeof(ppc_elf_howto_table[0]));
812 ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
813 }
814 }
815
816 \f
817 static reloc_howto_type *
818 ppc_elf_reloc_type_lookup (abfd, code)
819 bfd *abfd;
820 bfd_reloc_code_real_type code;
821 {
822 if (!ppc_elf_howto_table[ R_PPC_ADDR32 ]) /* Initialize howto table if needed */
823 ppc_elf_howto_init ();
824
825 switch ((int)code)
826 {
827 case BFD_RELOC_NONE: return ppc_elf_howto_table[ (int) R_PPC_NONE ];
828 case BFD_RELOC_32: return ppc_elf_howto_table[ (int) R_PPC_ADDR32 ];
829 case BFD_RELOC_32_PCREL: return ppc_elf_howto_table[ (int) R_PPC_REL32 ];
830 case BFD_RELOC_CTOR: return ppc_elf_howto_table[ (int) R_PPC_ADDR32 ];
831 case BFD_RELOC_PPC_B26: return ppc_elf_howto_table[ (int) R_PPC_REL24 ];
832 case BFD_RELOC_PPC_BA26: return ppc_elf_howto_table[ (int) R_PPC_ADDR24 ];
833 case BFD_RELOC_PPC_TOC16: return ppc_elf_howto_table[ (int) R_PPC_GOT16 ];
834 case BFD_RELOC_LO16: return ppc_elf_howto_table[ (int) R_PPC_ADDR16_LO ];
835 case BFD_RELOC_HI16: return ppc_elf_howto_table[ (int) R_PPC_ADDR16_HI ];
836 case BFD_RELOC_HI16_S: return ppc_elf_howto_table[ (int) R_PPC_ADDR16_HA ];
837 case BFD_RELOC_GPREL16: return ppc_elf_howto_table[ (int) R_PPC_SDAREL ];
838 }
839
840 return (reloc_howto_type *)NULL;
841 };
842
843 /* Set the howto pointer for a PowerPC ELF reloc. */
844
845 static void
846 ppc_elf_info_to_howto (abfd, cache_ptr, dst)
847 bfd *abfd;
848 arelent *cache_ptr;
849 Elf32_Internal_Rela *dst;
850 {
851 if (!ppc_elf_howto_table[ R_PPC_ADDR32 ]) /* Initialize howto table if needed */
852 ppc_elf_howto_init ();
853
854 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
855 cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
856 }
857
858 /* Function to set whether a module needs the -mrelocatable bit set. */
859
860 static boolean
861 ppc_elf_set_private_flags (abfd, flags)
862 bfd *abfd;
863 flagword flags;
864 {
865 BFD_ASSERT (!elf_ppc_flags_init (abfd)
866 || elf_elfheader (abfd)->e_flags == flags);
867
868 elf_elfheader (abfd)->e_flags = flags;
869 elf_ppc_flags_init (abfd) = true;
870 return true;
871 }
872
873 /* Copy backend specific data from one object module to another */
874 static boolean
875 ppc_elf_copy_private_bfd_data (ibfd, obfd)
876 bfd *ibfd;
877 bfd *obfd;
878 {
879 /* This function is selected based on the input vector. We only
880 want to copy information over if the output BFD also uses Elf
881 format. */
882 if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
883 return true;
884
885 BFD_ASSERT (!elf_ppc_flags_init (obfd)
886 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
887
888 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
889 elf_ppc_flags_init (obfd) = true;
890 return true;
891 }
892
893 /* Merge backend specific data from an object file to the output
894 object file when linking */
895 static boolean
896 ppc_elf_merge_private_bfd_data (ibfd, obfd)
897 bfd *ibfd;
898 bfd *obfd;
899 {
900 flagword old_flags;
901 flagword new_flags;
902
903 /* Check if we have the same endianess */
904 if (ibfd->xvec->byteorder_big_p != obfd->xvec->byteorder_big_p)
905 {
906 fprintf (stderr,
907 "%s: compiled for a %s endian system and target is %s endian.\n",
908 bfd_get_filename (ibfd),
909 (ibfd->xvec->byteorder_big_p) ? "big" : "little",
910 (obfd->xvec->byteorder_big_p) ? "big" : "little");
911
912 bfd_set_error (bfd_error_wrong_format);
913 return false;
914 }
915
916 /* This function is selected based on the input vector. We only
917 want to copy information over if the output BFD also uses Elf
918 format. */
919 if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
920 return true;
921
922 new_flags = elf_elfheader (ibfd)->e_flags;
923 old_flags = elf_elfheader (obfd)->e_flags;
924 if (!elf_ppc_flags_init (obfd)) /* First call, no flags set */
925 {
926 elf_ppc_flags_init (obfd) = true;
927 elf_elfheader (obfd)->e_flags = new_flags;
928 }
929
930 else if (new_flags == old_flags) /* Compatible flags are ok */
931 ;
932
933 else /* Incompatible flags */
934 {
935 /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib to be linked
936 with either. */
937 if ((new_flags & EF_PPC_RELOCATABLE) != 0
938 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
939 {
940 new_flags &= ~EF_PPC_RELOCATABLE;
941 fprintf (stderr,
942 "%s: compiled with -mrelocatable and linked with modules compiled normally\n",
943 bfd_get_filename (ibfd));
944 }
945 else if ((new_flags & EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB) == 0
946 && (old_flags & EF_PPC_RELOCATABLE) != 0)
947 {
948 old_flags &= ~EF_PPC_RELOCATABLE;
949 fprintf (stderr,
950 "%s: compiled normally and linked with modules compiled with -mrelocatable\n",
951 bfd_get_filename (ibfd));
952 }
953 else if ((new_flags & EF_PPC_RELOCATABLE_LIB) != 0)
954 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE_LIB;
955
956 new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB);
957 old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB);
958
959 /* Warn about eabi vs. V.4 mismatch */
960 if ((new_flags & EF_PPC_EMB) != 0 && (old_flags & EF_PPC_EMB) == 0)
961 {
962 new_flags &= ~EF_PPC_EMB;
963 fprintf (stderr,
964 "%s: compiled for the eabi and linked with modules compiled for System V\n",
965 bfd_get_filename (ibfd));
966 }
967 else if ((new_flags & EF_PPC_EMB) == 0 && (old_flags & EF_PPC_EMB) != 0)
968 {
969 old_flags &= ~EF_PPC_EMB;
970 fprintf (stderr,
971 "%s: compiled for System V and linked with modules compiled for eabi\n",
972 bfd_get_filename (ibfd));
973 }
974
975 /* Warn about any other mismatches */
976 if (new_flags != old_flags)
977 fprintf (stderr,
978 "%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)\n",
979 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
980
981 bfd_set_error (bfd_error_bad_value);
982 return false;
983 }
984
985 return true;
986 }
987
988 \f
989 /* ELF relocs are against symbols. If we are producing relocateable
990 output, and the reloc is against an external symbol, and nothing
991 has given us any additional addend, the resulting reloc will also
992 be against the same symbol. In such a case, we don't want to
993 change anything about the way the reloc is handled, since it will
994 all be done at final link time. Rather than put special case code
995 into bfd_perform_relocation, all the reloc types use this howto
996 function. It just short circuits the reloc if producing
997 relocateable output against an external symbol. */
998
999 /*ARGSUSED*/
1000 static bfd_reloc_status_type
1001 ppc_elf_std_reloc (abfd,
1002 reloc_entry,
1003 symbol,
1004 data,
1005 input_section,
1006 output_bfd,
1007 error_message)
1008 bfd *abfd;
1009 arelent *reloc_entry;
1010 asymbol *symbol;
1011 PTR data;
1012 asection *input_section;
1013 bfd *output_bfd;
1014 char **error_message;
1015 {
1016 if (output_bfd != (bfd *) NULL
1017 && (symbol->flags & BSF_SECTION_SYM) == 0
1018 && (! reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1019 {
1020 reloc_entry->address += input_section->output_offset;
1021 return bfd_reloc_ok;
1022 }
1023
1024 return bfd_reloc_continue;
1025 }
1026
1027 /* Don't pretend we can deal with unsupported relocs. */
1028
1029 /*ARGSUSED*/
1030 static bfd_reloc_status_type
1031 ppc_elf_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
1032 output_bfd, error_message)
1033 bfd *abfd;
1034 arelent *reloc_entry;
1035 asymbol *symbol;
1036 PTR data;
1037 asection *input_section;
1038 bfd *output_bfd;
1039 char **error_message;
1040 {
1041 BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
1042 fprintf (stderr,
1043 "%s: Relocation %s (%d) is not currently supported.\n",
1044 bfd_get_filename (abfd),
1045 reloc_entry->howto->name,
1046 reloc_entry->howto->type);
1047
1048 return bfd_reloc_notsupported;
1049 }
1050
1051 /* Internal function to return the adjustment to the addend for relocations
1052 that return the upper 16 bits after sign extending the lower 16 bits, ie
1053 for use with a ADDIS instruction followed by a memory reference using the
1054 bottom 16 bits. */
1055
1056 INLINE
1057 static bfd_vma
1058 ppc_elf_addr16_ha_inner (relocation)
1059 bfd_vma relocation;
1060 {
1061 return (relocation & 0x8000) << 1;
1062 }
1063
1064 /* Handle the ADDR16_HA reloc by adjusting the reloc addend. */
1065
1066 /*ARGSUSED*/
1067 static bfd_reloc_status_type
1068 ppc_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
1069 output_bfd, error_message)
1070 bfd *abfd;
1071 arelent *reloc_entry;
1072 asymbol *symbol;
1073 PTR data;
1074 asection *input_section;
1075 bfd *output_bfd;
1076 char **error_message;
1077 {
1078 bfd_vma relocation;
1079 asection *sec;
1080
1081 if (output_bfd != (bfd *) NULL)
1082 return ppc_elf_std_reloc (abfd, reloc_entry, symbol, data,
1083 input_section, output_bfd, error_message);
1084
1085 sec = symbol->section;
1086 relocation = (((bfd_is_com_section (sec)) ? 0 : symbol->value)
1087 + sec->output_section->vma
1088 + sec->output_offset
1089 + reloc_entry->addend);
1090
1091 reloc_entry->addend += ppc_elf_addr16_ha_inner (relocation);
1092 return bfd_reloc_continue;
1093 }
1094
1095 /* Internal function to return the addjustment to the addend for GOT16
1096 entries */
1097
1098 INLINE
1099 static bfd_vma
1100 ppc_elf_got16_inner (sec)
1101 asection *sec;
1102 {
1103 BFD_ASSERT (bfd_is_und_section (sec)
1104 || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
1105 || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0
1106 || strcmp (bfd_get_section_name (abfd, sec), ".sdata") == 0
1107 || strcmp (bfd_get_section_name (abfd, sec), ".sbss") == 0)
1108
1109 return -(sec->output_section->vma + 0x8000);
1110 }
1111
1112 /* Handle the GOT16 reloc. We want to use the offset within the .got
1113 section, not the actual VMA. This is appropriate when generating
1114 an embedded ELF object, for which the .got section acts like the
1115 AIX .toc section. When and if we support PIC code, we will have to
1116 change this, perhaps by switching off on the e_type field. */
1117
1118 /*ARGSUSED*/
1119 static bfd_reloc_status_type
1120 ppc_elf_got16_reloc (abfd, reloc_entry, symbol, data, input_section,
1121 output_bfd, error_message)
1122 bfd *abfd;
1123 arelent *reloc_entry;
1124 asymbol *symbol;
1125 PTR data;
1126 asection *input_section;
1127 bfd *output_bfd;
1128 char **error_message;
1129 {
1130 if (output_bfd != (bfd *) NULL)
1131 return ppc_elf_std_reloc (abfd, reloc_entry, symbol, data,
1132 input_section, output_bfd, error_message);
1133
1134 reloc_entry->addend += ppc_elf_got16_inner (bfd_get_section (*reloc_entry->sym_ptr_ptr));
1135 return bfd_reloc_continue;
1136 }
1137
1138 \f
1139 /* The RELOCATE_SECTION function is called by the ELF backend linker
1140 to handle the relocations for a section.
1141
1142 The relocs are always passed as Rela structures; if the section
1143 actually uses Rel structures, the r_addend field will always be
1144 zero.
1145
1146 This function is responsible for adjust the section contents as
1147 necessary, and (if using Rela relocs and generating a
1148 relocateable output file) adjusting the reloc addend as
1149 necessary.
1150
1151 This function does not have to worry about setting the reloc
1152 address or the reloc symbol index.
1153
1154 LOCAL_SYMS is a pointer to the swapped in local symbols.
1155
1156 LOCAL_SECTIONS is an array giving the section in the input file
1157 corresponding to the st_shndx field of each local symbol.
1158
1159 The global hash table entry for the global symbols can be found
1160 via elf_sym_hashes (input_bfd).
1161
1162 When generating relocateable output, this function must handle
1163 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1164 going to be the section symbol corresponding to the output
1165 section, which means that the addend must be adjusted
1166 accordingly. */
1167
1168 static boolean
1169 ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1170 contents, relocs, local_syms, local_sections)
1171 bfd *output_bfd;
1172 struct bfd_link_info *info;
1173 bfd *input_bfd;
1174 asection *input_section;
1175 bfd_byte *contents;
1176 Elf_Internal_Rela *relocs;
1177 Elf_Internal_Sym *local_syms;
1178 asection **local_sections;
1179 {
1180 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1181 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1182 Elf_Internal_Rela *rel = relocs;
1183 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1184 boolean ret = true;
1185
1186 #ifdef DEBUG
1187 fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, %ld relocations%s\n",
1188 bfd_get_filename (input_bfd),
1189 bfd_section_name(input_bfd, input_section),
1190 (long)input_section->reloc_count,
1191 (info->relocateable) ? " (relocatable)" : "");
1192 #endif
1193
1194 if (!ppc_elf_howto_table[ R_PPC_ADDR32 ]) /* Initialize howto table if needed */
1195 ppc_elf_howto_init ();
1196
1197 for (; rel < relend; rel++)
1198 {
1199 enum reloc_type r_type = (enum reloc_type)ELF32_R_TYPE (rel->r_info);
1200 bfd_vma offset = rel->r_offset;
1201 bfd_vma addend = rel->r_addend;
1202 bfd_reloc_status_type r = bfd_reloc_other;
1203 Elf_Internal_Sym *sym = (Elf_Internal_Sym *)0;
1204 asection *sec = (asection *)0;
1205 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *)0;
1206 reloc_howto_type *howto;
1207 unsigned long r_symndx;
1208 bfd_vma relocation;
1209
1210 /* Unknown relocation handling */
1211 if ((unsigned)r_type >= (unsigned)R_PPC_max || !ppc_elf_howto_table[(int)r_type])
1212 {
1213 fprintf (stderr,
1214 "%s: Unknown relocation type %d\n",
1215 bfd_get_filename (input_bfd),
1216 (int)r_type);
1217
1218 bfd_set_error (bfd_error_bad_value);
1219 ret = false;
1220 continue;
1221 }
1222
1223 howto = ppc_elf_howto_table[(int)r_type];
1224 r_symndx = ELF32_R_SYM (rel->r_info);
1225
1226 if (info->relocateable)
1227 {
1228 /* This is a relocateable link. We don't have to change
1229 anything, unless the reloc is against a section symbol,
1230 in which case we have to adjust according to where the
1231 section symbol winds up in the output section. */
1232 if (r_symndx < symtab_hdr->sh_info)
1233 {
1234 sym = local_syms + r_symndx;
1235 if ((unsigned)ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1236 {
1237 sec = local_sections[r_symndx];
1238 addend = rel->r_addend += sec->output_offset + sym->st_value;
1239 }
1240 }
1241
1242 #ifdef DEBUG
1243 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1244 howto->name,
1245 (int)r_type,
1246 r_symndx,
1247 (long)offset,
1248 (long)addend);
1249 #endif
1250 continue;
1251 }
1252
1253 /* This is a final link. */
1254
1255 /* Complain about known relocation that are not yet supported */
1256 if (howto->special_function == ppc_elf_unsupported_reloc)
1257 {
1258 fprintf (stderr,
1259 "%s: Relocation %s (%d) is not currently supported.\n",
1260 bfd_get_filename (input_bfd),
1261 howto->name,
1262 (int)r_type);
1263
1264 bfd_set_error (bfd_error_bad_value);
1265 ret = false;
1266 continue;
1267 }
1268
1269 if (r_symndx < symtab_hdr->sh_info)
1270 {
1271 sym = local_syms + r_symndx;
1272 sec = local_sections[r_symndx];
1273 relocation = (sec->output_section->vma
1274 + sec->output_offset
1275 + sym->st_value);
1276 }
1277 else
1278 {
1279 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1280 if (h->root.type == bfd_link_hash_defined
1281 || h->root.type == bfd_link_hash_defweak)
1282 {
1283 sec = h->root.u.def.section;
1284 relocation = (h->root.u.def.value
1285 + sec->output_section->vma
1286 + sec->output_offset);
1287 }
1288 else if (h->root.type == bfd_link_hash_undefweak)
1289 relocation = 0;
1290 else if (info->shared)
1291 relocation = 0;
1292 else
1293 {
1294 (*info->callbacks->undefined_symbol)(info,
1295 h->root.root.string,
1296 input_bfd,
1297 input_section,
1298 rel->r_offset);
1299 ret = false;
1300 continue;
1301 }
1302 }
1303
1304 switch ((int)r_type)
1305 {
1306 default:
1307 break;
1308
1309 case (int)R_PPC_GOT16: /* GOT16 relocations */
1310 case (int)R_PPC_GOT16_LO:
1311 case (int)R_PPC_GOT16_HI:
1312 case (int)R_PPC_SDAREL:
1313 BFD_ASSERT (sec != (asection *)0);
1314 addend += ppc_elf_got16_inner (sec);
1315 break;
1316
1317 case (int)R_PPC_ADDR16_HA: /* arithmetic adjust relocations */
1318 BFD_ASSERT (sec != (asection *)0);
1319 addend += ppc_elf_addr16_ha_inner (relocation + addend);
1320 break;
1321 }
1322
1323
1324 #ifdef DEBUG
1325 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1326 howto->name,
1327 (int)r_type,
1328 r_symndx,
1329 (long)offset,
1330 (long)addend);
1331 #endif
1332
1333 r = _bfd_final_link_relocate (howto,
1334 input_bfd,
1335 input_section,
1336 contents,
1337 offset,
1338 relocation,
1339 addend);
1340
1341 if (r != bfd_reloc_ok)
1342 {
1343 ret = false;
1344 switch (r)
1345 {
1346 default:
1347 break;
1348
1349 case bfd_reloc_overflow:
1350 {
1351 const char *name;
1352
1353 if (h != NULL)
1354 name = h->root.root.string;
1355 else
1356 {
1357 name = bfd_elf_string_from_elf_section (input_bfd,
1358 symtab_hdr->sh_link,
1359 sym->st_name);
1360 if (name == NULL)
1361 break;
1362
1363 if (*name == '\0')
1364 name = bfd_section_name (input_bfd, sec);
1365 }
1366
1367 (*info->callbacks->reloc_overflow)(info,
1368 name,
1369 howto->name,
1370 (bfd_vma) 0,
1371 input_bfd,
1372 input_section,
1373 offset);
1374 }
1375 break;
1376
1377 }
1378 }
1379 }
1380
1381
1382 #ifdef DEBUG
1383 fprintf (stderr, "\n");
1384 #endif
1385
1386 return ret;
1387 }
1388
1389 #define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec
1390 #define TARGET_LITTLE_NAME "elf32-powerpcle"
1391 #define TARGET_BIG_SYM bfd_elf32_powerpc_vec
1392 #define TARGET_BIG_NAME "elf32-powerpc"
1393 #define ELF_ARCH bfd_arch_powerpc
1394 #define ELF_MACHINE_CODE EM_PPC
1395 #define ELF_MAXPAGESIZE 0x10000
1396 #define elf_info_to_howto ppc_elf_info_to_howto
1397
1398 #ifdef EM_CYGNUS_POWERPC
1399 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
1400 #endif
1401
1402 #ifdef EM_PPC_OLD
1403 #define ELF_MACHINE_ALT2 EM_PPC_OLD
1404 #endif
1405
1406 #define bfd_elf32_bfd_copy_private_bfd_data ppc_elf_copy_private_bfd_data
1407 #define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data
1408 #define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
1409 #define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup
1410 #define elf_backend_relocate_section ppc_elf_relocate_section
1411
1412 #include "elf32-target.h"