OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [powerpc.cc] - Blame information for rev 41

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.