projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[deliverable/binutils-gdb.git] / gold / powerpc.cc
CommitLineData
42cacb20
DE		 1// powerpc.cc -- powerpc target support for gold.
2
0e70b911 3// Copyright 2008, 2009, 2010 Free Software Foundation, Inc.
42cacb20
DE		 4// Written by David S. Miller <davem@davemloft.net>
5// and David Edelsohn <edelsohn@gnu.org>
6
7// This file is part of gold.
8
9// This program is free software; you can redistribute it and/or modify
10// it under the terms of the GNU General Public License as published by
11// the Free Software Foundation; either version 3 of the License, or
12// (at your option) any later version.
13
14// This program is distributed in the hope that it will be useful,
15// but WITHOUT ANY WARRANTY; without even the implied warranty of
16// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17// GNU General Public License for more details.
18
19// You should have received a copy of the GNU General Public License
20// along with this program; if not, write to the Free Software
21// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22// MA 02110-1301, USA.
23
24#include "gold.h"
25
26#include "elfcpp.h"
27#include "parameters.h"
28#include "reloc.h"
29#include "powerpc.h"
30#include "object.h"
31#include "symtab.h"
32#include "layout.h"
33#include "output.h"
34#include "copy-relocs.h"
35#include "target.h"
36#include "target-reloc.h"
37#include "target-select.h"
38#include "tls.h"
39#include "errors.h"
f345227a 40#include "gc.h"
42cacb20
DE		 41
42namespace
43{
44
45using namespace gold;
46
47template<int size, bool big_endian>
48class Output_data_plt_powerpc;
49
50template<int size, bool big_endian>
51class Target_powerpc : public Sized_target<size, big_endian>
52{
53 public:
54 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section;
55
56 Target_powerpc()
57 : Sized_target<size, big_endian>(&powerpc_info),
58 got_(NULL), got2_(NULL), toc_(NULL),
59 plt_(NULL), rela_dyn_(NULL),
60 copy_relocs_(elfcpp::R_POWERPC_COPY),
61 dynbss_(NULL), got_mod_index_offset_(-1U)
62 {
63 }
64
6d03d481
ST		 65 // Process the relocations to determine unreferenced sections for
66 // garbage collection.
67 void
ad0f2072 68 gc_process_relocs(Symbol_table* symtab,
6d03d481 69 Layout* layout,
6fa2a40b 70 Sized_relobj_file<size, big_endian>* object,
6d03d481
ST		 71 unsigned int data_shndx,
72 unsigned int sh_type,
73 const unsigned char* prelocs,
74 size_t reloc_count,
75 Output_section* output_section,
76 bool needs_special_offset_handling,
77 size_t local_symbol_count,
78 const unsigned char* plocal_symbols);
79
42cacb20
DE		 80 // Scan the relocations to look for symbol adjustments.
81 void
ad0f2072 82 scan_relocs(Symbol_table* symtab,
42cacb20 83 Layout* layout,
6fa2a40b 84 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 85 unsigned int data_shndx,
86 unsigned int sh_type,
87 const unsigned char* prelocs,
88 size_t reloc_count,
89 Output_section* output_section,
90 bool needs_special_offset_handling,
91 size_t local_symbol_count,
92 const unsigned char* plocal_symbols);
93 // Finalize the sections.
94 void
f59f41f3 95 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
42cacb20
DE		 96
97 // Return the value to use for a dynamic which requires special
98 // treatment.
99 uint64_t
100 do_dynsym_value(const Symbol*) const;
101
102 // Relocate a section.
103 void
104 relocate_section(const Relocate_info<size, big_endian>*,
105 unsigned int sh_type,
106 const unsigned char* prelocs,
107 size_t reloc_count,
108 Output_section* output_section,
109 bool needs_special_offset_handling,
110 unsigned char* view,
111 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
364c7fa5
ILT		 112 section_size_type view_size,
113 const Reloc_symbol_changes*);
42cacb20
DE		 114
115 // Scan the relocs during a relocatable link.
116 void
ad0f2072 117 scan_relocatable_relocs(Symbol_table* symtab,
42cacb20 118 Layout* layout,
6fa2a40b 119 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 120 unsigned int data_shndx,
121 unsigned int sh_type,
122 const unsigned char* prelocs,
123 size_t reloc_count,
124 Output_section* output_section,
125 bool needs_special_offset_handling,
126 size_t local_symbol_count,
127 const unsigned char* plocal_symbols,
128 Relocatable_relocs*);
129
130 // Relocate a section during a relocatable link.
131 void
132 relocate_for_relocatable(const Relocate_info<size, big_endian>*,
133 unsigned int sh_type,
134 const unsigned char* prelocs,
135 size_t reloc_count,
136 Output_section* output_section,
137 off_t offset_in_output_section,
138 const Relocatable_relocs*,
139 unsigned char* view,
140 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
141 section_size_type view_size,
142 unsigned char* reloc_view,
143 section_size_type reloc_view_size);
144
145 // Return whether SYM is defined by the ABI.
146 bool
9c2d0ef9 147 do_is_defined_by_abi(const Symbol* sym) const
42cacb20
DE		 148 {
149 return strcmp(sym->name(), "___tls_get_addr") == 0;
150 }
151
152 // Return the size of the GOT section.
153 section_size_type
0e70b911 154 got_size() const
42cacb20
DE		 155 {
156 gold_assert(this->got_ != NULL);
157 return this->got_->data_size();
158 }
159
0e70b911
CC		 160 // Return the number of entries in the GOT.
161 unsigned int
162 got_entry_count() const
163 {
164 if (this->got_ == NULL)
165 return 0;
166 return this->got_size() / (size / 8);
167 }
168
169 // Return the number of entries in the PLT.
170 unsigned int
171 plt_entry_count() const;
172
173 // Return the offset of the first non-reserved PLT entry.
174 unsigned int
175 first_plt_entry_offset() const;
176
177 // Return the size of each PLT entry.
178 unsigned int
179 plt_entry_size() const;
180
42cacb20
DE		 181 private:
182
183 // The class which scans relocations.
184 class Scan
185 {
186 public:
187 Scan()
188 : issued_non_pic_error_(false)
189 { }
190
95a2c8d6
RS		 191 static inline int
192 get_reference_flags(unsigned int r_type);
193
42cacb20 194 inline void
ad0f2072 195 local(Symbol_table* symtab, Layout* layout, Target_powerpc* target,
6fa2a40b 196 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 197 unsigned int data_shndx,
198 Output_section* output_section,
199 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
200 const elfcpp::Sym<size, big_endian>& lsym);
201
202 inline void
ad0f2072 203 global(Symbol_table* symtab, Layout* layout, Target_powerpc* target,
6fa2a40b 204 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 205 unsigned int data_shndx,
206 Output_section* output_section,
207 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
208 Symbol* gsym);
209
21bb3914
ST		 210 inline bool
211 local_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
212 Target_powerpc* ,
6fa2a40b 213 Sized_relobj_file<size, big_endian>* ,
21bb3914
ST		 214 unsigned int ,
215 Output_section* ,
216 const elfcpp::Rela<size, big_endian>& ,
217 unsigned int ,
218 const elfcpp::Sym<size, big_endian>&)
219 { return false; }
220
221 inline bool
222 global_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
223 Target_powerpc* ,
6fa2a40b 224 Sized_relobj_file<size, big_endian>* ,
21bb3914
ST		 225 unsigned int ,
226 Output_section* ,
227 const elfcpp::Rela<size,
228 big_endian>& ,
229 unsigned int , Symbol*)
230 { return false; }
231
42cacb20
DE		 232 private:
233 static void
6fa2a40b 234 unsupported_reloc_local(Sized_relobj_file<size, big_endian>*,
42cacb20
DE		 235 unsigned int r_type);
236
237 static void
6fa2a40b 238 unsupported_reloc_global(Sized_relobj_file<size, big_endian>*,
42cacb20
DE		 239 unsigned int r_type, Symbol*);
240
241 static void
242 generate_tls_call(Symbol_table* symtab, Layout* layout,
243 Target_powerpc* target);
244
245 void
246 check_non_pic(Relobj*, unsigned int r_type);
247
248 // Whether we have issued an error about a non-PIC compilation.
249 bool issued_non_pic_error_;
250 };
251
252 // The class which implements relocation.
253 class Relocate
254 {
255 public:
256 // Do a relocation. Return false if the caller should not issue
257 // any warnings about this relocation.
258 inline bool
259 relocate(const Relocate_info<size, big_endian>*, Target_powerpc*,
031cdbed
ILT		 260 Output_section*, size_t relnum,
261 const elfcpp::Rela<size, big_endian>&,
42cacb20
DE		 262 unsigned int r_type, const Sized_symbol<size>*,
263 const Symbol_value<size>*,
264 unsigned char*,
265 typename elfcpp::Elf_types<size>::Elf_Addr,
266 section_size_type);
267
268 private:
269 // Do a TLS relocation.
270 inline void
271 relocate_tls(const Relocate_info<size, big_endian>*,
272 Target_powerpc* target,
273 size_t relnum, const elfcpp::Rela<size, big_endian>&,
274 unsigned int r_type, const Sized_symbol<size>*,
275 const Symbol_value<size>*,
276 unsigned char*,
277 typename elfcpp::Elf_types<size>::Elf_Addr,
278 section_size_type);
279 };
280
281 // A class which returns the size required for a relocation type,
282 // used while scanning relocs during a relocatable link.
283 class Relocatable_size_for_reloc
284 {
285 public:
286 unsigned int
287 get_size_for_reloc(unsigned int, Relobj*);
288 };
289
290 // Get the GOT section, creating it if necessary.
291 Output_data_got<size, big_endian>*
292 got_section(Symbol_table*, Layout*);
293
294 Output_data_space*
295 got2_section() const
296 {
ca09d69a 297 gold_assert(this->got2_ != NULL);
42cacb20
DE		 298 return this->got2_;
299 }
300
301 // Get the TOC section.
302 Output_data_space*
303 toc_section() const
304 {
ca09d69a 305 gold_assert(this->toc_ != NULL);
42cacb20
DE		 306 return this->toc_;
307 }
308
309 // Create a PLT entry for a global symbol.
310 void
311 make_plt_entry(Symbol_table*, Layout*, Symbol*);
312
313 // Create a GOT entry for the TLS module index.
314 unsigned int
315 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
6fa2a40b 316 Sized_relobj_file<size, big_endian>* object);
42cacb20
DE		 317
318 // Get the PLT section.
319 const Output_data_plt_powerpc<size, big_endian>*
320 plt_section() const
321 {
322 gold_assert(this->plt_ != NULL);
323 return this->plt_;
324 }
325
326 // Get the dynamic reloc section, creating it if necessary.
327 Reloc_section*
328 rela_dyn_section(Layout*);
329
42cacb20
DE		 330 // Copy a relocation against a global symbol.
331 void
ef9beddf 332 copy_reloc(Symbol_table* symtab, Layout* layout,
6fa2a40b 333 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 334 unsigned int shndx, Output_section* output_section,
335 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
336 {
337 this->copy_relocs_.copy_reloc(symtab, layout,
338 symtab->get_sized_symbol<size>(sym),
339 object, shndx, output_section,
340 reloc, this->rela_dyn_section(layout));
341 }
342
343 // Information about this specific target which we pass to the
344 // general Target structure.
345 static Target::Target_info powerpc_info;
346
347 // The types of GOT entries needed for this platform.
0e70b911
CC		 348 // These values are exposed to the ABI in an incremental link.
349 // Do not renumber existing values without changing the version
350 // number of the .gnu_incremental_inputs section.
42cacb20
DE		 351 enum Got_type
352 {
353 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
354 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset
355 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair
356 };
357
358 // The GOT section.
359 Output_data_got<size, big_endian>* got_;
360 // The GOT2 section.
361 Output_data_space* got2_;
362 // The TOC section.
363 Output_data_space* toc_;
364 // The PLT section.
365 Output_data_plt_powerpc<size, big_endian>* plt_;
366 // The dynamic reloc section.
367 Reloc_section* rela_dyn_;
368 // Relocs saved to avoid a COPY reloc.
369 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
370 // Space for variables copied with a COPY reloc.
371 Output_data_space* dynbss_;
372 // Offset of the GOT entry for the TLS module index;
373 unsigned int got_mod_index_offset_;
374};
375
376template<>
377Target::Target_info Target_powerpc<32, true>::powerpc_info =
378{
379 32, // size
380 true, // is_big_endian
381 elfcpp::EM_PPC, // machine_code
382 false, // has_make_symbol
383 false, // has_resolve
384 false, // has_code_fill
385 true, // is_default_stack_executable
386 '\0', // wrap_char
387 "/usr/lib/ld.so.1", // dynamic_linker
388 0x10000000, // default_text_segment_address
389 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08
ILT		 390 4 * 1024, // common_pagesize (overridable by -z common-page-size)
391 elfcpp::SHN_UNDEF, // small_common_shndx
392 elfcpp::SHN_UNDEF, // large_common_shndx
393 0, // small_common_section_flags
05a352e6
DK		 394 0, // large_common_section_flags
395 NULL, // attributes_section
396 NULL // attributes_vendor
42cacb20
DE		 397};
398
399template<>
400Target::Target_info Target_powerpc<32, false>::powerpc_info =
401{
402 32, // size
403 false, // is_big_endian
404 elfcpp::EM_PPC, // machine_code
405 false, // has_make_symbol
406 false, // has_resolve
407 false, // has_code_fill
408 true, // is_default_stack_executable
409 '\0', // wrap_char
410 "/usr/lib/ld.so.1", // dynamic_linker
411 0x10000000, // default_text_segment_address
412 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08
ILT		 413 4 * 1024, // common_pagesize (overridable by -z common-page-size)
414 elfcpp::SHN_UNDEF, // small_common_shndx
415 elfcpp::SHN_UNDEF, // large_common_shndx
416 0, // small_common_section_flags
05a352e6
DK		 417 0, // large_common_section_flags
418 NULL, // attributes_section
419 NULL // attributes_vendor
42cacb20
DE		 420};
421
422template<>
423Target::Target_info Target_powerpc<64, true>::powerpc_info =
424{
425 64, // size
426 true, // is_big_endian
427 elfcpp::EM_PPC64, // machine_code
428 false, // has_make_symbol
429 false, // has_resolve
430 false, // has_code_fill
431 true, // is_default_stack_executable
432 '\0', // wrap_char
433 "/usr/lib/ld.so.1", // dynamic_linker
434 0x10000000, // default_text_segment_address
435 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08
ILT		 436 8 * 1024, // common_pagesize (overridable by -z common-page-size)
437 elfcpp::SHN_UNDEF, // small_common_shndx
438 elfcpp::SHN_UNDEF, // large_common_shndx
439 0, // small_common_section_flags
05a352e6
DK		 440 0, // large_common_section_flags
441 NULL, // attributes_section
442 NULL // attributes_vendor
42cacb20
DE		 443};
444
445template<>
446Target::Target_info Target_powerpc<64, false>::powerpc_info =
447{
448 64, // size
449 false, // is_big_endian
450 elfcpp::EM_PPC64, // machine_code
451 false, // has_make_symbol
452 false, // has_resolve
453 false, // has_code_fill
454 true, // is_default_stack_executable
455 '\0', // wrap_char
456 "/usr/lib/ld.so.1", // dynamic_linker
457 0x10000000, // default_text_segment_address
458 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08
ILT		 459 8 * 1024, // common_pagesize (overridable by -z common-page-size)
460 elfcpp::SHN_UNDEF, // small_common_shndx
461 elfcpp::SHN_UNDEF, // large_common_shndx
462 0, // small_common_section_flags
05a352e6
DK		 463 0, // large_common_section_flags
464 NULL, // attributes_section
465 NULL // attributes_vendor
42cacb20
DE		 466};
467
468template<int size, bool big_endian>
469class Powerpc_relocate_functions
470{
471private:
472 // Do a simple relocation with the addend in the relocation.
473 template<int valsize>
474 static inline void
475 rela(unsigned char* view,
476 unsigned int right_shift,
477 elfcpp::Elf_Xword dst_mask,
478 typename elfcpp::Swap<size, big_endian>::Valtype value,
479 typename elfcpp::Swap<size, big_endian>::Valtype addend)
480 {
481 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
482 Valtype* wv = reinterpret_cast<Valtype*>(view);
483 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
484 Valtype reloc = ((value + addend) >> right_shift);
485
486 val &= ~dst_mask;
487 reloc &= dst_mask;
488
489 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
490 }
491
492 // Do a simple relocation using a symbol value with the addend in
493 // the relocation.
494 template<int valsize>
495 static inline void
496 rela(unsigned char* view,
497 unsigned int right_shift,
498 elfcpp::Elf_Xword dst_mask,
6fa2a40b 499 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 500 const Symbol_value<size>* psymval,
501 typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
502 {
503 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
504 Valtype* wv = reinterpret_cast<Valtype*>(view);
505 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
506 Valtype reloc = (psymval->value(object, addend) >> right_shift);
507
508 val &= ~dst_mask;
509 reloc &= dst_mask;
510
511 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
512 }
513
514 // Do a simple relocation using a symbol value with the addend in
515 // the relocation, unaligned.
516 template<int valsize>
517 static inline void
518 rela_ua(unsigned char* view, unsigned int right_shift,
519 elfcpp::Elf_Xword dst_mask,
6fa2a40b 520 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 521 const Symbol_value<size>* psymval,
522 typename elfcpp::Swap<size, big_endian>::Valtype addend)
523 {
524 typedef typename elfcpp::Swap_unaligned<valsize,
525 big_endian>::Valtype Valtype;
526 unsigned char* wv = view;
527 Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv);
528 Valtype reloc = (psymval->value(object, addend) >> right_shift);
529
530 val &= ~dst_mask;
531 reloc &= dst_mask;
532
533 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, val | reloc);
534 }
535
536 // Do a simple PC relative relocation with a Symbol_value with the
537 // addend in the relocation.
538 template<int valsize>
539 static inline void
540 pcrela(unsigned char* view, unsigned int right_shift,
541 elfcpp::Elf_Xword dst_mask,
6fa2a40b 542 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 543 const Symbol_value<size>* psymval,
544 typename elfcpp::Swap<size, big_endian>::Valtype addend,
545 typename elfcpp::Elf_types<size>::Elf_Addr address)
546 {
547 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
548 Valtype* wv = reinterpret_cast<Valtype*>(view);
549 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
550 Valtype reloc = ((psymval->value(object, addend) - address)
551 >> right_shift);
552
553 val &= ~dst_mask;
554 reloc &= dst_mask;
555
556 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
557 }
558
559 template<int valsize>
560 static inline void
561 pcrela_unaligned(unsigned char* view,
6fa2a40b 562 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 563 const Symbol_value<size>* psymval,
564 typename elfcpp::Swap<size, big_endian>::Valtype addend,
565 typename elfcpp::Elf_types<size>::Elf_Addr address)
566 {
567 typedef typename elfcpp::Swap_unaligned<valsize,
568 big_endian>::Valtype Valtype;
569 unsigned char* wv = view;
570 Valtype reloc = (psymval->value(object, addend) - address);
571
572 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, reloc);
573 }
574
575 typedef Powerpc_relocate_functions<size, big_endian> This;
576 typedef Relocate_functions<size, big_endian> This_reloc;
577public:
578 // R_POWERPC_REL32: (Symbol + Addend - Address)
579 static inline void
580 rel32(unsigned char* view,
6fa2a40b 581 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 582 const Symbol_value<size>* psymval,
583 typename elfcpp::Elf_types<size>::Elf_Addr addend,
584 typename elfcpp::Elf_types<size>::Elf_Addr address)
585 { This_reloc::pcrela32(view, object, psymval, addend, address); }
586
587 // R_POWERPC_REL24: (Symbol + Addend - Address) & 0x3fffffc
588 static inline void
589 rel24(unsigned char* view,
6fa2a40b 590 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 591 const Symbol_value<size>* psymval,
592 typename elfcpp::Elf_types<size>::Elf_Addr addend,
593 typename elfcpp::Elf_types<size>::Elf_Addr address)
594 {
595 This::template pcrela<32>(view, 0, 0x03fffffc, object,
596 psymval, addend, address);
597 }
598
599 // R_POWERPC_REL14: (Symbol + Addend - Address) & 0xfffc
600 static inline void
601 rel14(unsigned char* view,
6fa2a40b 602 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 603 const Symbol_value<size>* psymval,
604 typename elfcpp::Elf_types<size>::Elf_Addr addend,
605 typename elfcpp::Elf_types<size>::Elf_Addr address)
606 {
607 This::template pcrela<32>(view, 0, 0x0000fffc, object,
608 psymval, addend, address);
609 }
610
611 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff
612 static inline void
613 addr16(unsigned char* view,
614 typename elfcpp::Elf_types<size>::Elf_Addr value,
615 typename elfcpp::Elf_types<size>::Elf_Addr addend)
616 { This_reloc::rela16(view, value, addend); }
617
618 static inline void
619 addr16(unsigned char* view,
6fa2a40b 620 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 621 const Symbol_value<size>* psymval,
622 typename elfcpp::Elf_types<size>::Elf_Addr addend)
623 { This_reloc::rela16(view, object, psymval, addend); }
624
625 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc
626 static inline void
627 addr16_ds(unsigned char* view,
628 typename elfcpp::Elf_types<size>::Elf_Addr value,
629 typename elfcpp::Elf_types<size>::Elf_Addr addend)
630 {
631 This::template rela<16>(view, 0, 0xfffc, value, addend);
632 }
633
634 // R_POWERPC_ADDR16_LO: (Symbol + Addend) & 0xffff
635 static inline void
636 addr16_lo(unsigned char* view,
637 typename elfcpp::Elf_types<size>::Elf_Addr value,
638 typename elfcpp::Elf_types<size>::Elf_Addr addend)
639 { This_reloc::rela16(view, value, addend); }
640
641 static inline void
642 addr16_lo(unsigned char* view,
6fa2a40b 643 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 644 const Symbol_value<size>* psymval,
645 typename elfcpp::Elf_types<size>::Elf_Addr addend)
646 { This_reloc::rela16(view, object, psymval, addend); }
647
648 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff
649 static inline void
650 addr16_hi(unsigned char* view,
651 typename elfcpp::Elf_types<size>::Elf_Addr value,
652 typename elfcpp::Elf_types<size>::Elf_Addr addend)
653 {
654 This::template rela<16>(view, 16, 0xffff, value, addend);
655 }
656
657 static inline void
658 addr16_hi(unsigned char* view,
6fa2a40b 659 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 660 const Symbol_value<size>* psymval,
661 typename elfcpp::Elf_types<size>::Elf_Addr addend)
662 {
663 This::template rela<16>(view, 16, 0xffff, object, psymval, addend);
664 }
665
666 // R_POWERPC_ADDR16_HA: Same as R_POWERPC_ADDR16_HI except that if the
667 // final value of the low 16 bits of the
668 // relocation is negative, add one.
669 static inline void
670 addr16_ha(unsigned char* view,
671 typename elfcpp::Elf_types<size>::Elf_Addr value,
672 typename elfcpp::Elf_types<size>::Elf_Addr addend)
673 {
42cacb20
DE		 674 typename elfcpp::Elf_types<size>::Elf_Addr reloc;
675
676 reloc = value + addend;
677
678 if (reloc & 0x8000)
679 reloc += 0x10000;
680 reloc >>= 16;
681
e6fde208 682 elfcpp::Swap<16, big_endian>::writeval(view, reloc);
42cacb20
DE		 683 }
684
685 static inline void
686 addr16_ha(unsigned char* view,
6fa2a40b 687 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 688 const Symbol_value<size>* psymval,
689 typename elfcpp::Elf_types<size>::Elf_Addr addend)
690 {
42cacb20
DE		 691 typename elfcpp::Elf_types<size>::Elf_Addr reloc;
692
693 reloc = psymval->value(object, addend);
694
695 if (reloc & 0x8000)
696 reloc += 0x10000;
697 reloc >>= 16;
698
e6fde208 699 elfcpp::Swap<16, big_endian>::writeval(view, reloc);
42cacb20
DE		 700 }
701
702 // R_PPC_REL16: (Symbol + Addend - Address) & 0xffff
703 static inline void
704 rel16(unsigned char* view,
6fa2a40b 705 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 706 const Symbol_value<size>* psymval,
707 typename elfcpp::Elf_types<size>::Elf_Addr addend,
708 typename elfcpp::Elf_types<size>::Elf_Addr address)
709 { This_reloc::pcrela16(view, object, psymval, addend, address); }
710
711 // R_PPC_REL16_LO: (Symbol + Addend - Address) & 0xffff
712 static inline void
713 rel16_lo(unsigned char* view,
6fa2a40b 714 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 715 const Symbol_value<size>* psymval,
716 typename elfcpp::Elf_types<size>::Elf_Addr addend,
717 typename elfcpp::Elf_types<size>::Elf_Addr address)
718 { This_reloc::pcrela16(view, object, psymval, addend, address); }
719
720 // R_PPC_REL16_HI: ((Symbol + Addend - Address) >> 16) & 0xffff
721 static inline void
722 rel16_hi(unsigned char* view,
6fa2a40b 723 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 724 const Symbol_value<size>* psymval,
725 typename elfcpp::Elf_types<size>::Elf_Addr addend,
726 typename elfcpp::Elf_types<size>::Elf_Addr address)
727 {
728 This::template pcrela<16>(view, 16, 0xffff, object,
729 psymval, addend, address);
730 }
731
732 // R_PPC_REL16_HA: Same as R_PPC_REL16_HI except that if the
733 // final value of the low 16 bits of the
734 // relocation is negative, add one.
735 static inline void
736 rel16_ha(unsigned char* view,
6fa2a40b 737 const Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 738 const Symbol_value<size>* psymval,
739 typename elfcpp::Elf_types<size>::Elf_Addr addend,
740 typename elfcpp::Elf_types<size>::Elf_Addr address)
741 {
42cacb20
DE		 742 typename elfcpp::Elf_types<size>::Elf_Addr reloc;
743
744 reloc = (psymval->value(object, addend) - address);
745 if (reloc & 0x8000)
746 reloc += 0x10000;
747 reloc >>= 16;
748
83d22aa8 749 elfcpp::Swap<16, big_endian>::writeval(view, reloc);
42cacb20
DE		 750 }
751};
752
753// Get the GOT section, creating it if necessary.
754
755template<int size, bool big_endian>
756Output_data_got<size, big_endian>*
757Target_powerpc<size, big_endian>::got_section(Symbol_table* symtab,
758 Layout* layout)
759{
760 if (this->got_ == NULL)
761 {
762 gold_assert(symtab != NULL && layout != NULL);
763
764 this->got_ = new Output_data_got<size, big_endian>();
765
766 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
767 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
22f0da72 768 this->got_, ORDER_DATA, false);
42cacb20
DE		 769
770 // Create the GOT2 or TOC in the .got section.
771 if (size == 32)
772 {
773 this->got2_ = new Output_data_space(4, "** GOT2");
774 layout->add_output_section_data(".got2", elfcpp::SHT_PROGBITS,
775 elfcpp::SHF_ALLOC
776 | elfcpp::SHF_WRITE,
22f0da72 777 this->got2_, ORDER_DATA, false);
42cacb20
DE		 778 }
779 else
780 {
781 this->toc_ = new Output_data_space(8, "** TOC");
782 layout->add_output_section_data(".toc", elfcpp::SHT_PROGBITS,
783 elfcpp::SHF_ALLOC
784 | elfcpp::SHF_WRITE,
22f0da72 785 this->toc_, ORDER_DATA, false);
42cacb20
DE		 786 }
787
788 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
789 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
99fff23b 790 Symbol_table::PREDEFINED,
42cacb20
DE		 791 this->got_,
792 0, 0, elfcpp::STT_OBJECT,
793 elfcpp::STB_LOCAL,
794 elfcpp::STV_HIDDEN, 0,
795 false, false);
796 }
797
798 return this->got_;
799}
800
801// Get the dynamic reloc section, creating it if necessary.
802
803template<int size, bool big_endian>
804typename Target_powerpc<size, big_endian>::Reloc_section*
805Target_powerpc<size, big_endian>::rela_dyn_section(Layout* layout)
806{
807 if (this->rela_dyn_ == NULL)
808 {
809 gold_assert(layout != NULL);
810 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
811 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
22f0da72
ILT		 812 elfcpp::SHF_ALLOC, this->rela_dyn_,
813 ORDER_DYNAMIC_RELOCS, false);
42cacb20
DE		 814 }
815 return this->rela_dyn_;
816}
817
818// A class to handle the PLT data.
819
820template<int size, bool big_endian>
821class Output_data_plt_powerpc : public Output_section_data
822{
823 public:
824 typedef Output_data_reloc<elfcpp::SHT_RELA, true,
825 size, big_endian> Reloc_section;
826
827 Output_data_plt_powerpc(Layout*);
828
829 // Add an entry to the PLT.
830 void add_entry(Symbol* gsym);
831
832 // Return the .rela.plt section data.
833 const Reloc_section* rel_plt() const
834 {
835 return this->rel_;
836 }
837
0e70b911
CC		 838 // Return the number of PLT entries.
839 unsigned int
840 entry_count() const
841 { return this->count_; }
842
843 // Return the offset of the first non-reserved PLT entry.
844 static unsigned int
845 first_plt_entry_offset()
846 { return 4 * base_plt_entry_size; }
847
848 // Return the size of a PLT entry.
849 static unsigned int
850 get_plt_entry_size()
851 { return base_plt_entry_size; }
852
42cacb20
DE		 853 protected:
854 void do_adjust_output_section(Output_section* os);
855
856 private:
857 // The size of an entry in the PLT.
858 static const int base_plt_entry_size = (size == 32 ? 16 : 24);
859
860 // Set the final size.
861 void
862 set_final_data_size()
863 {
864 unsigned int full_count = this->count_ + 4;
865
866 this->set_data_size(full_count * base_plt_entry_size);
867 }
868
869 // Write out the PLT data.
870 void
871 do_write(Output_file*);
872
873 // The reloc section.
874 Reloc_section* rel_;
875 // The number of PLT entries.
876 unsigned int count_;
877};
878
879// Create the PLT section. The ordinary .got section is an argument,
880// since we need to refer to the start.
881
882template<int size, bool big_endian>
883Output_data_plt_powerpc<size, big_endian>::Output_data_plt_powerpc(Layout* layout)
884 : Output_section_data(size == 32 ? 4 : 8), count_(0)
885{
886 this->rel_ = new Reloc_section(false);
887 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
22f0da72
ILT		 888 elfcpp::SHF_ALLOC, this->rel_,
889 ORDER_DYNAMIC_PLT_RELOCS, false);
42cacb20
DE		 890}
891
892template<int size, bool big_endian>
893void
894Output_data_plt_powerpc<size, big_endian>::do_adjust_output_section(Output_section* os)
895{
896 os->set_entsize(0);
897}
898
899// Add an entry to the PLT.
900
901template<int size, bool big_endian>
902void
903Output_data_plt_powerpc<size, big_endian>::add_entry(Symbol* gsym)
904{
905 gold_assert(!gsym->has_plt_offset());
906 unsigned int index = this->count_+ + 4;
907 section_offset_type plt_offset;
908
909 if (index < 8192)
910 plt_offset = index * base_plt_entry_size;
911 else
912 gold_unreachable();
913
914 gsym->set_plt_offset(plt_offset);
915
916 ++this->count_;
917
918 gsym->set_needs_dynsym_entry();
919 this->rel_->add_global(gsym, elfcpp::R_POWERPC_JMP_SLOT, this,
920 plt_offset, 0);
921}
922
923static const unsigned int addis_11_11 = 0x3d6b0000;
924static const unsigned int addis_11_30 = 0x3d7e0000;
925static const unsigned int addis_12_12 = 0x3d8c0000;
926static const unsigned int addi_11_11 = 0x396b0000;
927static const unsigned int add_0_11_11 = 0x7c0b5a14;
928static const unsigned int add_11_0_11 = 0x7d605a14;
929static const unsigned int b = 0x48000000;
930static const unsigned int bcl_20_31 = 0x429f0005;
931static const unsigned int bctr = 0x4e800420;
932static const unsigned int lis_11 = 0x3d600000;
933static const unsigned int lis_12 = 0x3d800000;
934static const unsigned int lwzu_0_12 = 0x840c0000;
935static const unsigned int lwz_0_12 = 0x800c0000;
936static const unsigned int lwz_11_11 = 0x816b0000;
937static const unsigned int lwz_11_30 = 0x817e0000;
938static const unsigned int lwz_12_12 = 0x818c0000;
939static const unsigned int mflr_0 = 0x7c0802a6;
940static const unsigned int mflr_12 = 0x7d8802a6;
941static const unsigned int mtctr_0 = 0x7c0903a6;
942static const unsigned int mtctr_11 = 0x7d6903a6;
943static const unsigned int mtlr_0 = 0x7c0803a6;
944static const unsigned int nop = 0x60000000;
945static const unsigned int sub_11_11_12 = 0x7d6c5850;
946
947static const unsigned int addis_r12_r2 = 0x3d820000; /* addis %r12,%r2,xxx@ha */
948static const unsigned int std_r2_40r1 = 0xf8410028; /* std %r2,40(%r1) */
949static const unsigned int ld_r11_0r12 = 0xe96c0000; /* ld %r11,xxx+0@l(%r12) */
950static const unsigned int ld_r2_0r12 = 0xe84c0000; /* ld %r2,xxx+8@l(%r12) */
951 /* ld %r11,xxx+16@l(%r12) */
952
953
954// Write out the PLT.
955
956template<int size, bool big_endian>
957void
958Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of)
959{
2ea97941 960 const off_t offset = this->offset();
42cacb20
DE		 961 const section_size_type oview_size =
962 convert_to_section_size_type(this->data_size());
2ea97941 963 unsigned char* const oview = of->get_output_view(offset, oview_size);
42cacb20
DE		 964 unsigned char* pov = oview;
965
966 memset(pov, 0, base_plt_entry_size * 4);
967 pov += base_plt_entry_size * 4;
968
969 unsigned int plt_offset = base_plt_entry_size * 4;
970 const unsigned int count = this->count_;
971
972 if (size == 64)
973 {
974 for (unsigned int i = 0; i < count; i++)
975 {
976 }
977 }
978 else
979 {
980 for (unsigned int i = 0; i < count; i++)
981 {
982 elfcpp::Swap<32, true>::writeval(pov + 0x00,
983 lwz_11_30 + plt_offset);
984 elfcpp::Swap<32, true>::writeval(pov + 0x04, mtctr_11);
985 elfcpp::Swap<32, true>::writeval(pov + 0x08, bctr);
ce3ac18a 986 elfcpp::Swap<32, true>::writeval(pov + 0x0c, nop);
42cacb20
DE		 987 pov += base_plt_entry_size;
988 plt_offset += base_plt_entry_size;
989 }
990 }
991
992 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
993
2ea97941 994 of->write_output_view(offset, oview_size, oview);
42cacb20
DE		 995}
996
997// Create a PLT entry for a global symbol.
998
999template<int size, bool big_endian>
1000void
1001Target_powerpc<size, big_endian>::make_plt_entry(Symbol_table* symtab,
1002 Layout* layout,
1003 Symbol* gsym)
1004{
1005 if (gsym->has_plt_offset())
1006 return;
1007
1008 if (this->plt_ == NULL)
1009 {
1010 // Create the GOT section first.
1011 this->got_section(symtab, layout);
1012
612a8d3d
DM		 1013 // Ensure that .rela.dyn always appears before .rela.plt This is
1014 // necessary due to how, on PowerPC and some other targets, .rela.dyn
1015 // needs to include .rela.plt in it's range.
1016 this->rela_dyn_section(layout);
1017
42cacb20
DE		 1018 this->plt_ = new Output_data_plt_powerpc<size, big_endian>(layout);
1019 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1020 (elfcpp::SHF_ALLOC
1021 | elfcpp::SHF_EXECINSTR
1022 | elfcpp::SHF_WRITE),
22f0da72 1023 this->plt_, ORDER_PLT, false);
42cacb20
DE		 1024
1025 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
1026 symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
99fff23b 1027 Symbol_table::PREDEFINED,
42cacb20
DE		 1028 this->plt_,
1029 0, 0, elfcpp::STT_OBJECT,
1030 elfcpp::STB_LOCAL,
1031 elfcpp::STV_HIDDEN, 0,
1032 false, false);
1033 }
1034
1035 this->plt_->add_entry(gsym);
1036}
1037
0e70b911
CC		 1038// Return the number of entries in the PLT.
1039
1040template<int size, bool big_endian>
1041unsigned int
1042Target_powerpc<size, big_endian>::plt_entry_count() const
1043{
1044 if (this->plt_ == NULL)
1045 return 0;
1046 return this->plt_->entry_count();
1047}
1048
1049// Return the offset of the first non-reserved PLT entry.
1050
1051template<int size, bool big_endian>
1052unsigned int
1053Target_powerpc<size, big_endian>::first_plt_entry_offset() const
1054{
1055 return Output_data_plt_powerpc<size, big_endian>::first_plt_entry_offset();
1056}
1057
1058// Return the size of each PLT entry.
1059
1060template<int size, bool big_endian>
1061unsigned int
1062Target_powerpc<size, big_endian>::plt_entry_size() const
1063{
1064 return Output_data_plt_powerpc<size, big_endian>::get_plt_entry_size();
1065}
1066
42cacb20
DE		 1067// Create a GOT entry for the TLS module index.
1068
1069template<int size, bool big_endian>
1070unsigned int
6fa2a40b
CC		 1071Target_powerpc<size, big_endian>::got_mod_index_entry(
1072 Symbol_table* symtab,
1073 Layout* layout,
1074 Sized_relobj_file<size, big_endian>* object)
42cacb20
DE		 1075{
1076 if (this->got_mod_index_offset_ == -1U)
1077 {
1078 gold_assert(symtab != NULL && layout != NULL && object != NULL);
1079 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
1080 Output_data_got<size, big_endian>* got;
1081 unsigned int got_offset;
1082
1083 got = this->got_section(symtab, layout);
1084 got_offset = got->add_constant(0);
1085 rela_dyn->add_local(object, 0, elfcpp::R_POWERPC_DTPMOD, got,
1086 got_offset, 0);
1087 got->add_constant(0);
1088 this->got_mod_index_offset_ = got_offset;
1089 }
1090 return this->got_mod_index_offset_;
1091}
1092
1093// Optimize the TLS relocation type based on what we know about the
1094// symbol. IS_FINAL is true if the final address of this symbol is
1095// known at link time.
1096
1097static tls::Tls_optimization
1098optimize_tls_reloc(bool /* is_final */, int r_type)
1099{
1100 // If we are generating a shared library, then we can't do anything
1101 // in the linker.
1102 if (parameters->options().shared())
1103 return tls::TLSOPT_NONE;
1104 switch (r_type)
1105 {
1106 // XXX
1107 default:
1108 gold_unreachable();
1109 }
1110}
1111
95a2c8d6
RS		 1112// Get the Reference_flags for a particular relocation.
1113
1114template<int size, bool big_endian>
1115int
1116Target_powerpc<size, big_endian>::Scan::get_reference_flags(
1117 unsigned int r_type)
1118{
1119 switch (r_type)
1120 {
1121 case elfcpp::R_POWERPC_NONE:
1122 case elfcpp::R_POWERPC_GNU_VTINHERIT:
1123 case elfcpp::R_POWERPC_GNU_VTENTRY:
1124 case elfcpp::R_PPC64_TOC:
1125 // No symbol reference.
1126 return 0;
1127
1128 case elfcpp::R_POWERPC_ADDR16:
1129 case elfcpp::R_POWERPC_ADDR16_LO:
1130 case elfcpp::R_POWERPC_ADDR16_HI:
1131 case elfcpp::R_POWERPC_ADDR16_HA:
1132 case elfcpp::R_POWERPC_ADDR32:
1133 case elfcpp::R_PPC64_ADDR64:
1134 return Symbol::ABSOLUTE_REF;
1135
1136 case elfcpp::R_POWERPC_REL24:
1137 case elfcpp::R_PPC_LOCAL24PC:
1138 case elfcpp::R_PPC_REL16:
1139 case elfcpp::R_PPC_REL16_LO:
1140 case elfcpp::R_PPC_REL16_HI:
1141 case elfcpp::R_PPC_REL16_HA:
1142 return Symbol::RELATIVE_REF;
1143
1144 case elfcpp::R_PPC_PLTREL24:
1145 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
1146
1147 case elfcpp::R_POWERPC_GOT16:
1148 case elfcpp::R_POWERPC_GOT16_LO:
1149 case elfcpp::R_POWERPC_GOT16_HI:
1150 case elfcpp::R_POWERPC_GOT16_HA:
1151 case elfcpp::R_PPC64_TOC16:
1152 case elfcpp::R_PPC64_TOC16_LO:
1153 case elfcpp::R_PPC64_TOC16_HI:
1154 case elfcpp::R_PPC64_TOC16_HA:
1155 case elfcpp::R_PPC64_TOC16_DS:
1156 case elfcpp::R_PPC64_TOC16_LO_DS:
1157 // Absolute in GOT.
1158 return Symbol::ABSOLUTE_REF;
1159
1160 case elfcpp::R_POWERPC_GOT_TPREL16:
1161 case elfcpp::R_POWERPC_TLS:
1162 return Symbol::TLS_REF;
1163
1164 case elfcpp::R_POWERPC_COPY:
1165 case elfcpp::R_POWERPC_GLOB_DAT:
1166 case elfcpp::R_POWERPC_JMP_SLOT:
1167 case elfcpp::R_POWERPC_RELATIVE:
1168 case elfcpp::R_POWERPC_DTPMOD:
1169 default:
1170 // Not expected. We will give an error later.
1171 return 0;
1172 }
1173}
1174
42cacb20
DE		 1175// Report an unsupported relocation against a local symbol.
1176
1177template<int size, bool big_endian>
1178void
1179Target_powerpc<size, big_endian>::Scan::unsupported_reloc_local(
6fa2a40b 1180 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 1181 unsigned int r_type)
1182{
1183 gold_error(_("%s: unsupported reloc %u against local symbol"),
1184 object->name().c_str(), r_type);
1185}
1186
1187// We are about to emit a dynamic relocation of type R_TYPE. If the
1188// dynamic linker does not support it, issue an error.
1189
1190template<int size, bool big_endian>
1191void
1192Target_powerpc<size, big_endian>::Scan::check_non_pic(Relobj* object,
1193 unsigned int r_type)
1194{
1195 gold_assert(r_type != elfcpp::R_POWERPC_NONE);
1196
1197 // These are the relocation types supported by glibc for both 32-bit
1198 // and 64-bit powerpc.
1199 switch (r_type)
1200 {
1201 case elfcpp::R_POWERPC_RELATIVE:
1202 case elfcpp::R_POWERPC_GLOB_DAT:
1203 case elfcpp::R_POWERPC_DTPMOD:
1204 case elfcpp::R_POWERPC_DTPREL:
1205 case elfcpp::R_POWERPC_TPREL:
1206 case elfcpp::R_POWERPC_JMP_SLOT:
1207 case elfcpp::R_POWERPC_COPY:
1208 case elfcpp::R_POWERPC_ADDR32:
1209 case elfcpp::R_POWERPC_ADDR24:
1210 case elfcpp::R_POWERPC_REL24:
1211 return;
1212
1213 default:
1214 break;
1215 }
1216
1217 if (size == 64)
1218 {
1219 switch (r_type)
1220 {
1221 // These are the relocation types supported only on 64-bit.
1222 case elfcpp::R_PPC64_ADDR64:
1223 case elfcpp::R_PPC64_TPREL16_LO_DS:
1224 case elfcpp::R_PPC64_TPREL16_DS:
1225 case elfcpp::R_POWERPC_TPREL16:
1226 case elfcpp::R_POWERPC_TPREL16_LO:
1227 case elfcpp::R_POWERPC_TPREL16_HI:
1228 case elfcpp::R_POWERPC_TPREL16_HA:
1229 case elfcpp::R_PPC64_TPREL16_HIGHER:
1230 case elfcpp::R_PPC64_TPREL16_HIGHEST:
1231 case elfcpp::R_PPC64_TPREL16_HIGHERA:
1232 case elfcpp::R_PPC64_TPREL16_HIGHESTA:
1233 case elfcpp::R_PPC64_ADDR16_LO_DS:
1234 case elfcpp::R_POWERPC_ADDR16_LO:
1235 case elfcpp::R_POWERPC_ADDR16_HI:
1236 case elfcpp::R_POWERPC_ADDR16_HA:
1237 case elfcpp::R_POWERPC_ADDR30:
1238 case elfcpp::R_PPC64_UADDR64:
1239 case elfcpp::R_POWERPC_UADDR32:
1240 case elfcpp::R_POWERPC_ADDR16:
1241 case elfcpp::R_POWERPC_UADDR16:
1242 case elfcpp::R_PPC64_ADDR16_DS:
1243 case elfcpp::R_PPC64_ADDR16_HIGHER:
1244 case elfcpp::R_PPC64_ADDR16_HIGHEST:
1245 case elfcpp::R_PPC64_ADDR16_HIGHERA:
1246 case elfcpp::R_PPC64_ADDR16_HIGHESTA:
1247 case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
1248 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
1249 case elfcpp::R_POWERPC_REL32:
1250 case elfcpp::R_PPC64_REL64:
1251 return;
1252
1253 default:
1254 break;
1255 }
1256 }
1257 else
1258 {
1259 switch (r_type)
1260 {
1261 // These are the relocation types supported only on 32-bit.
1262
1263 default:
1264 break;
1265 }
1266 }
1267
1268 // This prevents us from issuing more than one error per reloc
1269 // section. But we can still wind up issuing more than one
1270 // error per object file.
1271 if (this->issued_non_pic_error_)
1272 return;
33aea2fd 1273 gold_assert(parameters->options().output_is_position_independent());
42cacb20
DE		 1274 object->error(_("requires unsupported dynamic reloc; "
1275 "recompile with -fPIC"));
1276 this->issued_non_pic_error_ = true;
1277 return;
1278}
1279
1280// Scan a relocation for a local symbol.
1281
1282template<int size, bool big_endian>
1283inline void
1284Target_powerpc<size, big_endian>::Scan::local(
42cacb20
DE		 1285 Symbol_table* symtab,
1286 Layout* layout,
1287 Target_powerpc<size, big_endian>* target,
6fa2a40b 1288 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 1289 unsigned int data_shndx,
1290 Output_section* output_section,
1291 const elfcpp::Rela<size, big_endian>& reloc,
1292 unsigned int r_type,
1293 const elfcpp::Sym<size, big_endian>& lsym)
1294{
1295 switch (r_type)
1296 {
1297 case elfcpp::R_POWERPC_NONE:
1298 case elfcpp::R_POWERPC_GNU_VTINHERIT:
1299 case elfcpp::R_POWERPC_GNU_VTENTRY:
1300 break;
1301
1302 case elfcpp::R_PPC64_ADDR64:
1303 case elfcpp::R_POWERPC_ADDR32:
1304 case elfcpp::R_POWERPC_ADDR16_HA:
1305 case elfcpp::R_POWERPC_ADDR16_LO:
1306 // If building a shared library (or a position-independent
1307 // executable), we need to create a dynamic relocation for
1308 // this location.
1309 if (parameters->options().output_is_position_independent())
1310 {
1311 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1312
1313 check_non_pic(object, r_type);
1314 if (lsym.get_st_type() != elfcpp::STT_SECTION)
1315 {
1316 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1317 rela_dyn->add_local(object, r_sym, r_type, output_section,
1318 data_shndx, reloc.get_r_offset(),
1319 reloc.get_r_addend());
1320 }
1321 else
1322 {
1323 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1324 gold_assert(lsym.get_st_value() == 0);
1325 rela_dyn->add_local_relative(object, r_sym, r_type,
1326 output_section, data_shndx,
1327 reloc.get_r_offset(),
1328 reloc.get_r_addend());
1329 }
1330 }
1331 break;
1332
1333 case elfcpp::R_POWERPC_REL24:
1334 case elfcpp::R_PPC_LOCAL24PC:
1335 case elfcpp::R_POWERPC_REL32:
1336 case elfcpp::R_PPC_REL16_LO:
1337 case elfcpp::R_PPC_REL16_HA:
1338 break;
1339
1340 case elfcpp::R_POWERPC_GOT16:
1341 case elfcpp::R_POWERPC_GOT16_LO:
1342 case elfcpp::R_POWERPC_GOT16_HI:
1343 case elfcpp::R_POWERPC_GOT16_HA:
1344 case elfcpp::R_PPC64_TOC16:
1345 case elfcpp::R_PPC64_TOC16_LO:
1346 case elfcpp::R_PPC64_TOC16_HI:
1347 case elfcpp::R_PPC64_TOC16_HA:
1348 case elfcpp::R_PPC64_TOC16_DS:
1349 case elfcpp::R_PPC64_TOC16_LO_DS:
1350 {
1351 // The symbol requires a GOT entry.
1352 Output_data_got<size, big_endian>* got;
1353 unsigned int r_sym;
1354
1355 got = target->got_section(symtab, layout);
1356 r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1357
1358 // If we are generating a shared object, we need to add a
1359 // dynamic relocation for this symbol's GOT entry.
1360 if (parameters->options().output_is_position_independent())
1361 {
1362 if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD))
1363 {
1364 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1365 unsigned int off;
1366
1367 off = got->add_constant(0);
1368 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off);
1369 rela_dyn->add_local_relative(object, r_sym,
1370 elfcpp::R_POWERPC_RELATIVE,
1371 got, off, 0);
1372 }
1373 }
1374 else
1375 got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1376 }
1377 break;
1378
1379 case elfcpp::R_PPC64_TOC:
1380 // We need a GOT section.
1381 target->got_section(symtab, layout);
1382 break;
1383
1384 // These are relocations which should only be seen by the
1385 // dynamic linker, and should never be seen here.
1386 case elfcpp::R_POWERPC_COPY:
1387 case elfcpp::R_POWERPC_GLOB_DAT:
1388 case elfcpp::R_POWERPC_JMP_SLOT:
1389 case elfcpp::R_POWERPC_RELATIVE:
1390 case elfcpp::R_POWERPC_DTPMOD:
1391 gold_error(_("%s: unexpected reloc %u in object file"),
1392 object->name().c_str(), r_type);
1393 break;
1394
1395 default:
1396 unsupported_reloc_local(object, r_type);
1397 break;
1398 }
1399}
1400
1401// Report an unsupported relocation against a global symbol.
1402
1403template<int size, bool big_endian>
1404void
1405Target_powerpc<size, big_endian>::Scan::unsupported_reloc_global(
6fa2a40b 1406 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 1407 unsigned int r_type,
1408 Symbol* gsym)
1409{
1410 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1411 object->name().c_str(), r_type, gsym->demangled_name().c_str());
1412}
1413
1414// Scan a relocation for a global symbol.
1415
1416template<int size, bool big_endian>
1417inline void
1418Target_powerpc<size, big_endian>::Scan::global(
42cacb20
DE		 1419 Symbol_table* symtab,
1420 Layout* layout,
1421 Target_powerpc<size, big_endian>* target,
6fa2a40b 1422 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 1423 unsigned int data_shndx,
1424 Output_section* output_section,
1425 const elfcpp::Rela<size, big_endian>& reloc,
1426 unsigned int r_type,
1427 Symbol* gsym)
1428{
1429 switch (r_type)
1430 {
1431 case elfcpp::R_POWERPC_NONE:
1432 case elfcpp::R_POWERPC_GNU_VTINHERIT:
1433 case elfcpp::R_POWERPC_GNU_VTENTRY:
1434 break;
1435
1436 case elfcpp::R_PPC_PLTREL24:
1437 // If the symbol is fully resolved, this is just a PC32 reloc.
1438 // Otherwise we need a PLT entry.
1439 if (gsym->final_value_is_known())
1440 break;
1441 // If building a shared library, we can also skip the PLT entry
1442 // if the symbol is defined in the output file and is protected
1443 // or hidden.
1444 if (gsym->is_defined()
1445 && !gsym->is_from_dynobj()
1446 && !gsym->is_preemptible())
1447 break;
1448 target->make_plt_entry(symtab, layout, gsym);
1449 break;
1450
1451 case elfcpp::R_POWERPC_ADDR16:
1452 case elfcpp::R_POWERPC_ADDR16_LO:
1453 case elfcpp::R_POWERPC_ADDR16_HI:
1454 case elfcpp::R_POWERPC_ADDR16_HA:
1455 case elfcpp::R_POWERPC_ADDR32:
1456 case elfcpp::R_PPC64_ADDR64:
1457 {
1458 // Make a PLT entry if necessary.
1459 if (gsym->needs_plt_entry())
1460 {
1461 target->make_plt_entry(symtab, layout, gsym);
1462 // Since this is not a PC-relative relocation, we may be
1463 // taking the address of a function. In that case we need to
1464 // set the entry in the dynamic symbol table to the address of
1465 // the PLT entry.
1466 if (gsym->is_from_dynobj() && !parameters->options().shared())
1467 gsym->set_needs_dynsym_value();
1468 }
1469 // Make a dynamic relocation if necessary.
95a2c8d6 1470 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
42cacb20 1471 {
966d4097 1472 if (gsym->may_need_copy_reloc())
42cacb20
DE		 1473 {
1474 target->copy_reloc(symtab, layout, object,
1475 data_shndx, output_section, gsym, reloc);
1476 }
1477 else if ((r_type == elfcpp::R_POWERPC_ADDR32
1478 || r_type == elfcpp::R_PPC64_ADDR64)
1479 && gsym->can_use_relative_reloc(false))
1480 {
1481 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1482 rela_dyn->add_global_relative(gsym, elfcpp::R_POWERPC_RELATIVE,
1483 output_section, object,
1484 data_shndx, reloc.get_r_offset(),
1485 reloc.get_r_addend());
1486 }
1487 else
1488 {
1489 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1490
1491 check_non_pic(object, r_type);
1492 if (gsym->is_from_dynobj()
1493 || gsym->is_undefined()
1494 || gsym->is_preemptible())
1495 rela_dyn->add_global(gsym, r_type, output_section,
1496 object, data_shndx,
1497 reloc.get_r_offset(),
1498 reloc.get_r_addend());
1499 else
1500 rela_dyn->add_global_relative(gsym, r_type,
1501 output_section, object,
1502 data_shndx,
1503 reloc.get_r_offset(),
1504 reloc.get_r_addend());
1505 }
1506 }
1507 }
1508 break;
1509
1510 case elfcpp::R_POWERPC_REL24:
1511 case elfcpp::R_PPC_LOCAL24PC:
1512 case elfcpp::R_PPC_REL16:
1513 case elfcpp::R_PPC_REL16_LO:
1514 case elfcpp::R_PPC_REL16_HI:
1515 case elfcpp::R_PPC_REL16_HA:
1516 {
1517 if (gsym->needs_plt_entry())
1518 target->make_plt_entry(symtab, layout, gsym);
1519 // Make a dynamic relocation if necessary.
95a2c8d6 1520 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
42cacb20 1521 {
966d4097 1522 if (gsym->may_need_copy_reloc())
42cacb20
DE		 1523 {
1524 target->copy_reloc(symtab, layout, object,
1525 data_shndx, output_section, gsym,
1526 reloc);
1527 }
1528 else
1529 {
1530 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1531 check_non_pic(object, r_type);
1532 rela_dyn->add_global(gsym, r_type, output_section, object,
1533 data_shndx, reloc.get_r_offset(),
1534 reloc.get_r_addend());
1535 }
1536 }
1537 }
1538 break;
1539
1540 case elfcpp::R_POWERPC_GOT16:
1541 case elfcpp::R_POWERPC_GOT16_LO:
1542 case elfcpp::R_POWERPC_GOT16_HI:
1543 case elfcpp::R_POWERPC_GOT16_HA:
1544 case elfcpp::R_PPC64_TOC16:
1545 case elfcpp::R_PPC64_TOC16_LO:
1546 case elfcpp::R_PPC64_TOC16_HI:
1547 case elfcpp::R_PPC64_TOC16_HA:
1548 case elfcpp::R_PPC64_TOC16_DS:
1549 case elfcpp::R_PPC64_TOC16_LO_DS:
1550 {
1551 // The symbol requires a GOT entry.
1552 Output_data_got<size, big_endian>* got;
1553
1554 got = target->got_section(symtab, layout);
1555 if (gsym->final_value_is_known())
1556 got->add_global(gsym, GOT_TYPE_STANDARD);
1557 else
1558 {
1559 // If this symbol is not fully resolved, we need to add a
1560 // dynamic relocation for it.
1561 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1562 if (gsym->is_from_dynobj()
1563 || gsym->is_undefined()
1564 || gsym->is_preemptible())
1565 got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
1566 elfcpp::R_POWERPC_GLOB_DAT);
1567 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD))
1568 {
1569 unsigned int off = got->add_constant(0);
1570
1571 gsym->set_got_offset(GOT_TYPE_STANDARD, off);
1572 rela_dyn->add_global_relative(gsym, elfcpp::R_POWERPC_RELATIVE,
1573 got, off, 0);
1574 }
1575 }
1576 }
1577 break;
1578
1579 case elfcpp::R_PPC64_TOC:
1580 // We need a GOT section.
1581 target->got_section(symtab, layout);
1582 break;
1583
1584 case elfcpp::R_POWERPC_GOT_TPREL16:
1585 case elfcpp::R_POWERPC_TLS:
1586 // XXX TLS
1587 break;
1588
1589 // These are relocations which should only be seen by the
1590 // dynamic linker, and should never be seen here.
1591 case elfcpp::R_POWERPC_COPY:
1592 case elfcpp::R_POWERPC_GLOB_DAT:
1593 case elfcpp::R_POWERPC_JMP_SLOT:
1594 case elfcpp::R_POWERPC_RELATIVE:
1595 case elfcpp::R_POWERPC_DTPMOD:
1596 gold_error(_("%s: unexpected reloc %u in object file"),
1597 object->name().c_str(), r_type);
1598 break;
1599
1600 default:
1601 unsupported_reloc_global(object, r_type, gsym);
1602 break;
1603 }
1604}
1605
6d03d481
ST		 1606// Process relocations for gc.
1607
1608template<int size, bool big_endian>
1609void
1610Target_powerpc<size, big_endian>::gc_process_relocs(
6d03d481
ST		 1611 Symbol_table* symtab,
1612 Layout* layout,
6fa2a40b 1613 Sized_relobj_file<size, big_endian>* object,
6d03d481
ST		 1614 unsigned int data_shndx,
1615 unsigned int,
1616 const unsigned char* prelocs,
1617 size_t reloc_count,
1618 Output_section* output_section,
1619 bool needs_special_offset_handling,
1620 size_t local_symbol_count,
1621 const unsigned char* plocal_symbols)
1622{
1623 typedef Target_powerpc<size, big_endian> Powerpc;
2ea97941 1624 typedef typename Target_powerpc<size, big_endian>::Scan Scan;
6d03d481 1625
41cbeecc 1626 gold::gc_process_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan,
3ff2ccb0 1627 typename Target_powerpc::Relocatable_size_for_reloc>(
6d03d481
ST		 1628 symtab,
1629 layout,
1630 this,
1631 object,
1632 data_shndx,
1633 prelocs,
1634 reloc_count,
1635 output_section,
1636 needs_special_offset_handling,
1637 local_symbol_count,
1638 plocal_symbols);
1639}
1640
42cacb20
DE		 1641// Scan relocations for a section.
1642
1643template<int size, bool big_endian>
1644void
1645Target_powerpc<size, big_endian>::scan_relocs(
42cacb20
DE		 1646 Symbol_table* symtab,
1647 Layout* layout,
6fa2a40b 1648 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 1649 unsigned int data_shndx,
1650 unsigned int sh_type,
1651 const unsigned char* prelocs,
1652 size_t reloc_count,
1653 Output_section* output_section,
1654 bool needs_special_offset_handling,
1655 size_t local_symbol_count,
1656 const unsigned char* plocal_symbols)
1657{
1658 typedef Target_powerpc<size, big_endian> Powerpc;
2ea97941 1659 typedef typename Target_powerpc<size, big_endian>::Scan Scan;
42cacb20
DE		 1660 static Output_data_space* sdata;
1661
1662 if (sh_type == elfcpp::SHT_REL)
1663 {
1664 gold_error(_("%s: unsupported REL reloc section"),
1665 object->name().c_str());
1666 return;
1667 }
1668
1669 // Define _SDA_BASE_ at the start of the .sdata section.
1670 if (sdata == NULL)
1671 {
1672 // layout->find_output_section(".sdata") == NULL
1673 sdata = new Output_data_space(4, "** sdata");
1674 Output_section* os = layout->add_output_section_data(".sdata", 0,
1675 elfcpp::SHF_ALLOC
1676 | elfcpp::SHF_WRITE,
22f0da72
ILT		 1677 sdata,
1678 ORDER_SMALL_DATA,
1679 false);
42cacb20 1680 symtab->define_in_output_data("_SDA_BASE_", NULL,
99fff23b 1681 Symbol_table::PREDEFINED,
42cacb20
DE		 1682 os,
1683 32768, 0,
1684 elfcpp::STT_OBJECT,
1685 elfcpp::STB_LOCAL,
1686 elfcpp::STV_HIDDEN, 0,
1687 false, false);
1688 }
1689
2ea97941 1690 gold::scan_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan>(
42cacb20
DE		 1691 symtab,
1692 layout,
1693 this,
1694 object,
1695 data_shndx,
1696 prelocs,
1697 reloc_count,
1698 output_section,
1699 needs_special_offset_handling,
1700 local_symbol_count,
1701 plocal_symbols);
1702}
1703
1704// Finalize the sections.
1705
1706template<int size, bool big_endian>
1707void
d5b40221
DK		 1708Target_powerpc<size, big_endian>::do_finalize_sections(
1709 Layout* layout,
f59f41f3
DK		 1710 const Input_objects*,
1711 Symbol_table*)
42cacb20
DE		 1712{
1713 // Fill in some more dynamic tags.
ea715a34
ILT		 1714 const Reloc_section* rel_plt = (this->plt_ == NULL
1715 ? NULL
1716 : this->plt_->rel_plt());
1717 layout->add_target_dynamic_tags(false, this->plt_, rel_plt,
612a8d3d 1718 this->rela_dyn_, true, size == 32);
42cacb20
DE		 1719
1720 // Emit any relocs we saved in an attempt to avoid generating COPY
1721 // relocs.
1722 if (this->copy_relocs_.any_saved_relocs())
1723 this->copy_relocs_.emit(this->rela_dyn_section(layout));
1724}
1725
1726// Perform a relocation.
1727
1728template<int size, bool big_endian>
1729inline bool
1730Target_powerpc<size, big_endian>::Relocate::relocate(
1731 const Relocate_info<size, big_endian>* relinfo,
1732 Target_powerpc* target,
031cdbed 1733 Output_section*,
42cacb20
DE		 1734 size_t relnum,
1735 const elfcpp::Rela<size, big_endian>& rela,
1736 unsigned int r_type,
1737 const Sized_symbol<size>* gsym,
1738 const Symbol_value<size>* psymval,
1739 unsigned char* view,
1740 typename elfcpp::Elf_types<size>::Elf_Addr address,
1741 section_size_type /* view_size */)
1742{
1743 const unsigned int toc_base_offset = 0x8000;
1744 typedef Powerpc_relocate_functions<size, big_endian> Reloc;
1745
1746 // Pick the value to use for symbols defined in shared objects.
1747 Symbol_value<size> symval;
1748 if (gsym != NULL
95a2c8d6 1749 && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
42cacb20
DE		 1750 {
1751 elfcpp::Elf_Xword value;
1752
1753 value = target->plt_section()->address() + gsym->plt_offset();
1754
1755 symval.set_output_value(value);
1756
1757 psymval = &symval;
1758 }
1759
6fa2a40b 1760 const Sized_relobj_file<size, big_endian>* object = relinfo->object;
42cacb20
DE		 1761 elfcpp::Elf_Xword addend = rela.get_r_addend();
1762
1763 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT
1764 // pointer points to the beginning, not the end, of the table.
1765 // So we just use the plain offset.
42cacb20
DE		 1766 unsigned int got_offset = 0;
1767 unsigned int got2_offset = 0;
1768 switch (r_type)
1769 {
1770 case elfcpp::R_PPC64_TOC16:
1771 case elfcpp::R_PPC64_TOC16_LO:
1772 case elfcpp::R_PPC64_TOC16_HI:
1773 case elfcpp::R_PPC64_TOC16_HA:
1774 case elfcpp::R_PPC64_TOC16_DS:
1775 case elfcpp::R_PPC64_TOC16_LO_DS:
1776 // Subtract the TOC base address.
1777 addend -= target->toc_section()->address() + toc_base_offset;
1778 /* FALLTHRU */
1779
1780 case elfcpp::R_POWERPC_GOT16:
1781 case elfcpp::R_POWERPC_GOT16_LO:
1782 case elfcpp::R_POWERPC_GOT16_HI:
1783 case elfcpp::R_POWERPC_GOT16_HA:
1784 case elfcpp::R_PPC64_GOT16_DS:
1785 case elfcpp::R_PPC64_GOT16_LO_DS:
1786 if (gsym != NULL)
1787 {
1788 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
1789 got_offset = gsym->got_offset(GOT_TYPE_STANDARD);
1790 }
1791 else
1792 {
1793 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
1794 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
1795 got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
1796 }
42cacb20
DE		 1797 break;
1798
1799 // R_PPC_PLTREL24 is rather special. If non-zero,
1800 // the addend specifies the GOT pointer offset within .got2.
1801 case elfcpp::R_PPC_PLTREL24:
1802 if (addend >= 32768)
1803 {
1804 Output_data_space* got2;
1805 got2 = target->got2_section();
1806 got2_offset = got2->offset();
1807 addend += got2_offset;
1808 }
42cacb20
DE		 1809 break;
1810
1811 default:
1812 break;
1813 }
1814
1815 switch (r_type)
1816 {
1817 case elfcpp::R_POWERPC_NONE:
1818 case elfcpp::R_POWERPC_GNU_VTINHERIT:
1819 case elfcpp::R_POWERPC_GNU_VTENTRY:
1820 break;
1821
1822 case elfcpp::R_POWERPC_REL32:
1823 Reloc::rel32(view, object, psymval, addend, address);
1824 break;
1825
1826 case elfcpp::R_POWERPC_REL24:
1827 Reloc::rel24(view, object, psymval, addend, address);
1828 break;
1829
1830 case elfcpp::R_POWERPC_REL14:
1831 Reloc::rel14(view, object, psymval, addend, address);
1832 break;
1833
1834 case elfcpp::R_PPC_PLTREL24:
1835 Reloc::rel24(view, object, psymval, addend, address);
1836 break;
1837
1838 case elfcpp::R_PPC_LOCAL24PC:
1839 Reloc::rel24(view, object, psymval, addend, address);
1840 break;
1841
1842 case elfcpp::R_PPC64_ADDR64:
1843 if (!parameters->options().output_is_position_independent())
1844 Relocate_functions<size, big_endian>::rela64(view, object,
1845 psymval, addend);
1846 break;
1847
1848 case elfcpp::R_POWERPC_ADDR32:
1849 if (!parameters->options().output_is_position_independent())
1850 Relocate_functions<size, big_endian>::rela32(view, object,
1851 psymval, addend);
1852 break;
1853
1854 case elfcpp::R_POWERPC_ADDR16_LO:
1855 Reloc::addr16_lo(view, object, psymval, addend);
1856 break;
1857
1858 case elfcpp::R_POWERPC_ADDR16_HI:
1859 Reloc::addr16_hi(view, object, psymval, addend);
1860 break;
1861
1862 case elfcpp::R_POWERPC_ADDR16_HA:
1863 Reloc::addr16_ha(view, object, psymval, addend);
1864 break;
1865
1866 case elfcpp::R_PPC_REL16_LO:
1867 Reloc::rel16_lo(view, object, psymval, addend, address);
1868 break;
1869
1870 case elfcpp::R_PPC_REL16_HI:
1871 Reloc::rel16_lo(view, object, psymval, addend, address);
1872 break;
1873
1874 case elfcpp::R_PPC_REL16_HA:
83d22aa8 1875 Reloc::rel16_ha(view, object, psymval, addend, address);
42cacb20
DE		 1876 break;
1877
1878 case elfcpp::R_POWERPC_GOT16:
1879 Reloc::addr16(view, got_offset, addend);
1880 break;
1881
1882 case elfcpp::R_POWERPC_GOT16_LO:
1883 Reloc::addr16_lo(view, got_offset, addend);
1884 break;
1885
1886 case elfcpp::R_POWERPC_GOT16_HI:
1887 Reloc::addr16_hi(view, got_offset, addend);
1888 break;
1889
1890 case elfcpp::R_POWERPC_GOT16_HA:
1891 Reloc::addr16_ha(view, got_offset, addend);
1892 break;
1893
1894 case elfcpp::R_PPC64_TOC16:
1895 Reloc::addr16(view, got_offset, addend);
1896 break;
1897
1898 case elfcpp::R_PPC64_TOC16_LO:
1899 Reloc::addr16_lo(view, got_offset, addend);
1900 break;
1901
1902 case elfcpp::R_PPC64_TOC16_HI:
1903 Reloc::addr16_hi(view, got_offset, addend);
1904 break;
1905
1906 case elfcpp::R_PPC64_TOC16_HA:
1907 Reloc::addr16_ha(view, got_offset, addend);
1908 break;
1909
1910 case elfcpp::R_PPC64_TOC16_DS:
1911 case elfcpp::R_PPC64_TOC16_LO_DS:
1912 Reloc::addr16_ds(view, got_offset, addend);
1913 break;
1914
1915 case elfcpp::R_PPC64_TOC:
1916 {
1917 elfcpp::Elf_types<64>::Elf_Addr value;
1918 value = target->toc_section()->address() + toc_base_offset;
1919 Relocate_functions<64, false>::rela64(view, value, addend);
1920 }
1921 break;
1922
1923 case elfcpp::R_POWERPC_COPY:
1924 case elfcpp::R_POWERPC_GLOB_DAT:
1925 case elfcpp::R_POWERPC_JMP_SLOT:
1926 case elfcpp::R_POWERPC_RELATIVE:
1927 // This is an outstanding tls reloc, which is unexpected when
1928 // linking.
1929 case elfcpp::R_POWERPC_DTPMOD:
1930 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
1931 _("unexpected reloc %u in object file"),
1932 r_type);
1933 break;
1934
1935 default:
1936 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
1937 _("unsupported reloc %u"),
1938 r_type);
1939 break;
1940 }
1941
1942 return true;
1943}
1944
1945// Perform a TLS relocation.
1946
1947template<int size, bool big_endian>
1948inline void
1949Target_powerpc<size, big_endian>::Relocate::relocate_tls(
1950 const Relocate_info<size, big_endian>* relinfo,
1951 Target_powerpc<size, big_endian>* target,
1952 size_t relnum,
1953 const elfcpp::Rela<size, big_endian>& rela,
1954 unsigned int r_type,
1955 const Sized_symbol<size>* gsym,
1956 const Symbol_value<size>* psymval,
1957 unsigned char* view,
1958 typename elfcpp::Elf_types<size>::Elf_Addr address,
1959 section_size_type)
1960{
1961 Output_segment* tls_segment = relinfo->layout->tls_segment();
1962 typedef Powerpc_relocate_functions<size, big_endian> Reloc;
6fa2a40b 1963 const Sized_relobj_file<size, big_endian>* object = relinfo->object;
42cacb20
DE		 1964
1965 const elfcpp::Elf_Xword addend = rela.get_r_addend();
1966 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0);
1967
1968 const bool is_final =
1969 (gsym == NULL
1970 ? !parameters->options().output_is_position_independent()
1971 : gsym->final_value_is_known());
1972 const tls::Tls_optimization optimized_type
1973 = optimize_tls_reloc(is_final, r_type);
1974
1975 switch (r_type)
1976 {
1977 // XXX
1978 }
1979}
1980
1981// Relocate section data.
1982
1983template<int size, bool big_endian>
1984void
1985Target_powerpc<size, big_endian>::relocate_section(
1986 const Relocate_info<size, big_endian>* relinfo,
1987 unsigned int sh_type,
1988 const unsigned char* prelocs,
1989 size_t reloc_count,
1990 Output_section* output_section,
1991 bool needs_special_offset_handling,
1992 unsigned char* view,
1993 typename elfcpp::Elf_types<size>::Elf_Addr address,
364c7fa5
ILT		 1994 section_size_type view_size,
1995 const Reloc_symbol_changes* reloc_symbol_changes)
42cacb20
DE		 1996{
1997 typedef Target_powerpc<size, big_endian> Powerpc;
1998 typedef typename Target_powerpc<size, big_endian>::Relocate Powerpc_relocate;
1999
2000 gold_assert(sh_type == elfcpp::SHT_RELA);
2001
2002 gold::relocate_section<size, big_endian, Powerpc, elfcpp::SHT_RELA,
2003 Powerpc_relocate>(
2004 relinfo,
2005 this,
2006 prelocs,
2007 reloc_count,
2008 output_section,
2009 needs_special_offset_handling,
2010 view,
2011 address,
364c7fa5
ILT		 2012 view_size,
2013 reloc_symbol_changes);
42cacb20
DE		 2014}
2015
2016// Return the size of a relocation while scanning during a relocatable
2017// link.
2018
2019template<int size, bool big_endian>
2020unsigned int
2021Target_powerpc<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
2022 unsigned int,
2023 Relobj*)
2024{
2025 // We are always SHT_RELA, so we should never get here.
2026 gold_unreachable();
2027 return 0;
2028}
2029
2030// Scan the relocs during a relocatable link.
2031
2032template<int size, bool big_endian>
2033void
2034Target_powerpc<size, big_endian>::scan_relocatable_relocs(
42cacb20
DE		 2035 Symbol_table* symtab,
2036 Layout* layout,
6fa2a40b 2037 Sized_relobj_file<size, big_endian>* object,
42cacb20
DE		 2038 unsigned int data_shndx,
2039 unsigned int sh_type,
2040 const unsigned char* prelocs,
2041 size_t reloc_count,
2042 Output_section* output_section,
2043 bool needs_special_offset_handling,
2044 size_t local_symbol_count,
2045 const unsigned char* plocal_symbols,
2046 Relocatable_relocs* rr)
2047{
2048 gold_assert(sh_type == elfcpp::SHT_RELA);
2049
2050 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
2051 Relocatable_size_for_reloc> Scan_relocatable_relocs;
2052
2053 gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
2054 Scan_relocatable_relocs>(
42cacb20
DE		 2055 symtab,
2056 layout,
2057 object,
2058 data_shndx,
2059 prelocs,
2060 reloc_count,
2061 output_section,
2062 needs_special_offset_handling,
2063 local_symbol_count,
2064 plocal_symbols,
2065 rr);
2066}
2067
2068// Relocate a section during a relocatable link.
2069
2070template<int size, bool big_endian>
2071void
2072Target_powerpc<size, big_endian>::relocate_for_relocatable(
2073 const Relocate_info<size, big_endian>* relinfo,
2074 unsigned int sh_type,
2075 const unsigned char* prelocs,
2076 size_t reloc_count,
2077 Output_section* output_section,
2078 off_t offset_in_output_section,
2079 const Relocatable_relocs* rr,
2080 unsigned char* view,
2081 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
2082 section_size_type view_size,
2083 unsigned char* reloc_view,
2084 section_size_type reloc_view_size)
2085{
2086 gold_assert(sh_type == elfcpp::SHT_RELA);
2087
2088 gold::relocate_for_relocatable<size, big_endian, elfcpp::SHT_RELA>(
2089 relinfo,
2090 prelocs,
2091 reloc_count,
2092 output_section,
2093 offset_in_output_section,
2094 rr,
2095 view,
2096 view_address,
2097 view_size,
2098 reloc_view,
2099 reloc_view_size);
2100}
2101
2102// Return the value to use for a dynamic which requires special
2103// treatment. This is how we support equality comparisons of function
2104// pointers across shared library boundaries, as described in the
2105// processor specific ABI supplement.
2106
2107template<int size, bool big_endian>
2108uint64_t
2109Target_powerpc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
2110{
2111 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
2112 return this->plt_section()->address() + gsym->plt_offset();
2113}
2114
2115// The selector for powerpc object files.
2116
2117template<int size, bool big_endian>
2118class Target_selector_powerpc : public Target_selector
2119{
2120public:
2121 Target_selector_powerpc()
2122 : Target_selector(elfcpp::EM_NONE, size, big_endian,
2123 (size == 64 ?
2124 (big_endian ? "elf64-powerpc" : "elf64-powerpcle") :
2125 (big_endian ? "elf32-powerpc" : "elf32-powerpcle")))
2126 { }
2127
2ea97941 2128 Target* do_recognize(int machine, int, int)
42cacb20
DE		 2129 {
2130 switch (size)
2131 {
2132 case 64:
2ea97941 2133 if (machine != elfcpp::EM_PPC64)
42cacb20
DE		 2134 return NULL;
2135 break;
2136
2137 case 32:
2ea97941 2138 if (machine != elfcpp::EM_PPC)
42cacb20
DE		 2139 return NULL;
2140 break;
2141
2142 default:
2143 return NULL;
2144 }
2145
7f055c20 2146 return this->instantiate_target();
42cacb20
DE		 2147 }
2148
2149 Target* do_instantiate_target()
7f055c20 2150 { return new Target_powerpc<size, big_endian>(); }
42cacb20
DE		 2151};
2152
2153Target_selector_powerpc<32, true> target_selector_ppc32;
2154Target_selector_powerpc<32, false> target_selector_ppc32le;
2155Target_selector_powerpc<64, true> target_selector_ppc64;
2156Target_selector_powerpc<64, false> target_selector_ppc64le;
2157
2158} // End anonymous namespace.
GDB Binutils - Deliverables
This page took 0.30136 seconds and 4 git commands to generate.