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