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